From a1cb9cc999451a810f2a2f4d853794becff32e58 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Sat, 12 Oct 2024 16:13:50 +0200 Subject: [PATCH 01/82] Simplify all return statements in the equal() methods of the Modification classes. Also simplify some conditions in validateAssertions() and modify() methods. --- .../de/rub/nds/modifiablevariable/VariableModification.java | 2 +- .../biginteger/BigIntegerAddModification.java | 5 +---- .../biginteger/BigIntegerExplicitValueModification.java | 5 +---- .../biginteger/BigIntegerMultiplyModification.java | 5 +---- .../biginteger/BigIntegerShiftLeftModification.java | 5 +---- .../biginteger/BigIntegerShiftRightModification.java | 5 +---- .../biginteger/BigIntegerSubtractModification.java | 5 +---- .../biginteger/BigIntegerXorModification.java | 5 +---- .../modifiablevariable/biginteger/ModifiableBigInteger.java | 4 +--- .../bool/BooleanExplicitValueModification.java | 5 +---- .../modifiablevariable/bool/BooleanToggleModification.java | 5 +---- .../rub/nds/modifiablevariable/bool/ModifiableBoolean.java | 4 +--- .../bytearray/ByteArrayDeleteModification.java | 5 +---- .../bytearray/ByteArrayDuplicateModification.java | 5 +---- .../bytearray/ByteArrayExplicitValueModification.java | 5 +---- .../bytearray/ByteArrayInsertModification.java | 5 +---- .../bytearray/ByteArrayShuffleModification.java | 5 +---- .../bytearray/ByteArrayXorModification.java | 5 +---- .../modifiablevariable/integer/IntegerAddModification.java | 5 +---- .../integer/IntegerExplicitValueModification.java | 5 +---- .../integer/IntegerShiftLeftModification.java | 5 +---- .../integer/IntegerShiftRightModification.java | 5 +---- .../integer/IntegerSubtractModification.java | 5 +---- .../modifiablevariable/integer/IntegerXorModification.java | 5 +---- .../nds/modifiablevariable/longint/LongAddModification.java | 5 +---- .../longint/LongExplicitValueModification.java | 5 +---- .../modifiablevariable/longint/LongSubtractModification.java | 5 +---- .../nds/modifiablevariable/longint/LongXorModification.java | 5 +---- .../modifiablevariable/singlebyte/ByteAddModification.java | 5 +---- .../singlebyte/ByteExplicitValueModification.java | 5 +---- .../singlebyte/ByteSubtractModification.java | 5 +---- .../modifiablevariable/singlebyte/ByteXorModification.java | 5 +---- .../string/StringExplicitValueModification.java | 5 +---- .../rub/nds/modifiablevariable/util/ComparableByteArray.java | 5 +---- 34 files changed, 34 insertions(+), 131 deletions(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java b/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java index 04e81ef2..56ceadf3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java @@ -41,7 +41,7 @@ public abstract class VariableModification { public E modify(E input) { E modifiedValue = modifyImplementationHook(input); - if ((modificationFilter == null) || (modificationFilter.filterModification() == false)) { + if ((modificationFilter == null) || (!modificationFilter.filterModification())) { debug(modifiedValue); return modifiedValue; } else { 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..d5467901 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java @@ -69,9 +69,6 @@ public boolean equals(Object obj) { return false; } final BigIntegerAddModification other = (BigIntegerAddModification) obj; - if (!Objects.equals(this.summand, other.summand)) { - return false; - } - return true; + return Objects.equals(this.summand, other.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..6593141a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java @@ -75,9 +75,6 @@ public boolean equals(Object obj) { return false; } final BigIntegerExplicitValueModification other = (BigIntegerExplicitValueModification) obj; - if (!Objects.equals(this.explicitValue, other.explicitValue)) { - return false; - } - return true; + return Objects.equals(this.explicitValue, other.explicitValue); } } 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..4ffe0ca7 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java @@ -72,9 +72,6 @@ public boolean equals(Object obj) { return false; } final BigIntegerMultiplyModification other = (BigIntegerMultiplyModification) obj; - if (!Objects.equals(this.factor, other.factor)) { - return false; - } - return true; + return Objects.equals(this.factor, other.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..0c058b33 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java @@ -70,9 +70,6 @@ public boolean equals(Object obj) { return false; } final BigIntegerShiftLeftModification other = (BigIntegerShiftLeftModification) obj; - if (this.shift != other.shift) { - return false; - } - return true; + return this.shift == other.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..9d30b4bf 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java @@ -70,9 +70,6 @@ public boolean equals(Object obj) { return false; } final BigIntegerShiftRightModification other = (BigIntegerShiftRightModification) obj; - if (this.shift != other.shift) { - return false; - } - return true; + return this.shift == other.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..96e7819b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java @@ -72,9 +72,6 @@ public boolean equals(Object obj) { return false; } final BigIntegerSubtractModification other = (BigIntegerSubtractModification) obj; - if (!Objects.equals(this.subtrahend, other.subtrahend)) { - return false; - } - return true; + return Objects.equals(this.subtrahend, other.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..035c0f70 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java @@ -71,9 +71,6 @@ public boolean equals(Object obj) { return false; } final BigIntegerXorModification other = (BigIntegerXorModification) obj; - if (!Objects.equals(this.xor, other.xor)) { - return false; - } - return true; + return Objects.equals(this.xor, other.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..03b4697e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigInteger.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigInteger.java @@ -52,9 +52,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; } 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..407e0456 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanExplicitValueModification.java @@ -60,10 +60,7 @@ public boolean equals(Object obj) { return false; } final BooleanExplicitValueModification other = (BooleanExplicitValueModification) obj; - if (this.explicitValue != other.explicitValue) { - return false; - } - return true; + return this.explicitValue == other.explicitValue; } @Override 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..3f9da992 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanToggleModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanToggleModification.java @@ -44,10 +44,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..058e8f5d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/ModifiableBoolean.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/ModifiableBoolean.java @@ -49,9 +49,7 @@ public boolean isOriginalValueModified() { @Override public boolean validateAssertions() { if (assertEquals != null) { - if (assertEquals.compareTo(getValue()) != 0) { - return false; - } + return assertEquals.compareTo(getValue()) == 0; } return true; } 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..95503255 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java @@ -132,10 +132,7 @@ public boolean equals(Object obj) { if (this.count != other.count) { return false; } - if (this.startPosition != other.startPosition) { - return false; - } - return true; + return this.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..32f1ebb7 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDuplicateModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDuplicateModification.java @@ -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..c7c29ae3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java @@ -86,9 +86,6 @@ public boolean equals(Object obj) { return false; } final ByteArrayExplicitValueModification other = (ByteArrayExplicitValueModification) obj; - if (!Arrays.equals(this.explicitValue, other.explicitValue)) { - return false; - } - return true; + return Arrays.equals(this.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 index 660d6e0c..2bbd2812 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertModification.java @@ -133,10 +133,7 @@ public boolean equals(Object obj) { if (this.startPosition != other.startPosition) { return false; } - if (!Arrays.equals(this.bytesToInsert, other.bytesToInsert)) { - return false; - } - return true; + return Arrays.equals(this.bytesToInsert, other.bytesToInsert); } @Override 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..56680a0e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayShuffleModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayShuffleModification.java @@ -93,10 +93,7 @@ public boolean equals(Object obj) { return false; } final ByteArrayShuffleModification other = (ByteArrayShuffleModification) obj; - if (!Arrays.equals(this.shuffle, other.shuffle)) { - return false; - } - return true; + return Arrays.equals(this.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..ac47705c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java @@ -129,10 +129,7 @@ public boolean equals(Object obj) { if (this.startPosition != other.startPosition) { return false; } - if (!Arrays.equals(this.xor, other.xor)) { - return false; - } - return true; + return Arrays.equals(this.xor, other.xor); } @Override 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..8ad6d9a4 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAddModification.java @@ -64,9 +64,6 @@ public boolean equals(Object obj) { return false; } final IntegerAddModification other = (IntegerAddModification) obj; - if (!Objects.equals(this.summand, other.summand)) { - return false; - } - return true; + return Objects.equals(this.summand, other.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..792f05a5 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueModification.java @@ -71,9 +71,6 @@ public boolean equals(Object obj) { return false; } final IntegerExplicitValueModification other = (IntegerExplicitValueModification) obj; - if (!Objects.equals(this.explicitValue, other.explicitValue)) { - return false; - } - return true; + return Objects.equals(this.explicitValue, other.explicitValue); } } 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..dcb56cc9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftLeftModification.java @@ -75,9 +75,6 @@ public boolean equals(Object obj) { return false; } final IntegerShiftLeftModification other = (IntegerShiftLeftModification) obj; - if (this.shift != other.shift) { - return false; - } - return true; + return this.shift == other.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..2969a134 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftRightModification.java @@ -75,9 +75,6 @@ public boolean equals(Object obj) { return false; } final IntegerShiftRightModification other = (IntegerShiftRightModification) obj; - if (this.shift != other.shift) { - return false; - } - return true; + return this.shift == other.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..c527713e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSubtractModification.java @@ -65,9 +65,6 @@ public boolean equals(Object obj) { return false; } final IntegerSubtractModification other = (IntegerSubtractModification) obj; - if (!Objects.equals(this.subtrahend, other.subtrahend)) { - return false; - } - return true; + return Objects.equals(this.subtrahend, other.subtrahend); } } 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..dda4a30c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerXorModification.java @@ -69,9 +69,6 @@ public boolean equals(Object obj) { return false; } final IntegerXorModification other = (IntegerXorModification) obj; - if (!Objects.equals(this.xor, other.xor)) { - return false; - } - return true; + return Objects.equals(this.xor, other.xor); } } 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..637297f2 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java @@ -64,9 +64,6 @@ public boolean equals(Object obj) { return false; } final LongAddModification other = (LongAddModification) obj; - if (!Objects.equals(this.summand, other.summand)) { - return false; - } - return true; + return Objects.equals(this.summand, other.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..8b4ae295 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java @@ -71,9 +71,6 @@ public boolean equals(Object obj) { return false; } final LongExplicitValueModification other = (LongExplicitValueModification) obj; - if (!Objects.equals(this.explicitValue, other.explicitValue)) { - return false; - } - return true; + return Objects.equals(this.explicitValue, other.explicitValue); } } 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..e1cde296 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java @@ -65,9 +65,6 @@ public boolean equals(Object obj) { return false; } final LongSubtractModification other = (LongSubtractModification) obj; - if (!Objects.equals(this.subtrahend, other.subtrahend)) { - return false; - } - return true; + return Objects.equals(this.subtrahend, other.subtrahend); } } 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..50afc213 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java @@ -69,9 +69,6 @@ public boolean equals(Object obj) { return false; } final LongXorModification other = (LongXorModification) obj; - if (!Objects.equals(this.xor, other.xor)) { - return false; - } - return true; + return Objects.equals(this.xor, other.xor); } } 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..6cfcc7e8 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteAddModification.java @@ -67,9 +67,6 @@ public boolean equals(Object obj) { return false; } final ByteAddModification other = (ByteAddModification) obj; - if (!Objects.equals(this.summand, other.summand)) { - return false; - } - return true; + return Objects.equals(this.summand, other.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..0297cf81 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueModification.java @@ -71,9 +71,6 @@ public boolean equals(Object obj) { return false; } final ByteExplicitValueModification other = (ByteExplicitValueModification) obj; - if (!Objects.equals(this.explicitValue, other.explicitValue)) { - return false; - } - return true; + return Objects.equals(this.explicitValue, other.explicitValue); } } 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..85c22ba3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteSubtractModification.java @@ -68,9 +68,6 @@ public boolean equals(Object obj) { return false; } final ByteSubtractModification other = (ByteSubtractModification) obj; - if (!Objects.equals(this.subtrahend, other.subtrahend)) { - return false; - } - return true; + return Objects.equals(this.subtrahend, other.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..21cad46d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteXorModification.java @@ -73,9 +73,6 @@ public boolean equals(Object obj) { return false; } final ByteXorModification other = (ByteXorModification) obj; - if (!Objects.equals(this.xor, other.xor)) { - return false; - } - return true; + return Objects.equals(this.xor, other.xor); } } 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..dd2b8ee4 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java @@ -65,9 +65,6 @@ public boolean equals(Object obj) { return false; } final StringExplicitValueModification other = (StringExplicitValueModification) obj; - if (!Objects.equals(this.explicitValue, other.explicitValue)) { - return false; - } - return true; + return Objects.equals(this.explicitValue, other.explicitValue); } } 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..9382c05b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/ComparableByteArray.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/ComparableByteArray.java @@ -44,9 +44,6 @@ public boolean equals(Object obj) { return false; } final ComparableByteArray other = (ComparableByteArray) obj; - if (!Arrays.equals(this.array, other.array)) { - return false; - } - return true; + return Arrays.equals(this.array, other.array); } } From 7f3fb2f0741426b1a7cc97aeec2d95f22ef996a2 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Sat, 12 Oct 2024 16:19:58 +0200 Subject: [PATCH 02/82] Replace constant string concatenations that are used as arguments to logging methods with parameterized log messages --- .../bytearray/ByteArrayDeleteModification.java | 11 +++-------- .../bytearray/ByteArrayInsertModification.java | 10 ++-------- 2 files changed, 5 insertions(+), 16 deletions(-) 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 95503255..ed3152dc 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java @@ -45,22 +45,17 @@ protected byte[] modifyImplementationHook(byte[] input) { if (start < 0) { start += input.length; if (start < 0) { - LOGGER.debug( - "Trying to delete from too negative Startposition. start = " - + (start - input.length)); + 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)); + LOGGER.debug("Bytes {}..{} cannot be deleted from {{}} of length {}", start, endPosition, bytesToHexString(input), input.length); return input; } if (count <= 0) { - LOGGER.debug("You must delete at least one byte. count = " + count); + LOGGER.debug("You must delete at least one byte. count = {}", count); return input; } byte[] ret1 = Arrays.copyOf(input, start); diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertModification.java index 2bbd2812..64c4ab5e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertModification.java @@ -49,18 +49,12 @@ protected byte[] modifyImplementationHook(byte[] input) { if (start < 0) { start += input.length; if (start < 0) { - LOGGER.debug( - "Trying to insert from too negative Startposition. start = " - + startPosition); + 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); + LOGGER.debug("Trying to insert behind the Array. ArraySize:{} Insert Position:{}", input.length, startPosition); return input; } byte[] ret1 = Arrays.copyOf(input, start); From 4ee5dd0dec1c7444d79df8781f07213d268b6b2b Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Mon, 14 Oct 2024 11:37:41 +0200 Subject: [PATCH 03/82] Fix getModifiedCopy() of ByteArrayShuffleModification. Before the Modification was not modified, just copied. --- .../bytearray/ByteArrayShuffleModification.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 56680a0e..7b899154 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayShuffleModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayShuffleModification.java @@ -71,7 +71,7 @@ public VariableModification getModifiedCopy() { 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); + return new ByteArrayShuffleModification(newValue); } @Override From 24750a56e410fc8379910dea3efff86ce344c815 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Mon, 14 Oct 2024 13:12:53 +0200 Subject: [PATCH 04/82] Fix getModifiedCopy() of StringModifications, so that the methods actually return modified copies and not only the same modification. --- .../string/StringAppendValueModification.java | 10 +++++++++- .../string/StringExplicitValueModification.java | 13 ++++++++++++- .../string/StringPrependValueModification.java | 10 +++++++++- 3 files changed, 30 insertions(+), 3 deletions(-) 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..a81d708c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java @@ -13,12 +13,15 @@ import jakarta.xml.bind.annotation.XmlType; import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.util.Objects; +import java.util.Random; /** Modification that appends a string to the original value. */ @XmlRootElement @XmlType(propOrder = {"appendValue", "modificationFilter"}) public class StringAppendValueModification extends VariableModification { + private static final int MAX_EXPLICIT_VALUE = 256; + @XmlJavaTypeAdapter(IllegalStringAdapter.class) private String appendValue; @@ -43,7 +46,12 @@ public void setAppendValue(final String appendValue) { @Override public VariableModification getModifiedCopy() { - return new StringAppendValueModification(appendValue); + Random r = new Random(); + int index = r.nextInt(appendValue.length()); + char randomChar = (char) r.nextInt(MAX_EXPLICIT_VALUE);; + StringBuilder modifiedString = new StringBuilder(appendValue); + modifiedString.setCharAt(index, randomChar); + return new StringAppendValueModification(modifiedString.toString()); } @Override 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 dd2b8ee4..26c7fa6a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java @@ -13,12 +13,15 @@ import jakarta.xml.bind.annotation.XmlType; import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.util.Objects; +import java.util.Random; /** */ @XmlRootElement @XmlType(propOrder = {"explicitValue", "modificationFilter"}) public class StringExplicitValueModification extends VariableModification { + private static final int MAX_EXPLICIT_VALUE = 256; + @XmlJavaTypeAdapter(IllegalStringAdapter.class) private String explicitValue; @@ -43,7 +46,15 @@ public void setExplicitValue(String explicitValue) { @Override public VariableModification getModifiedCopy() { - return new StringExplicitValueModification(explicitValue); + if (explicitValue.isEmpty()) { + return this; + } + Random r = new Random(); + int index = r.nextInt(explicitValue.length()); + char randomChar = (char) r.nextInt(MAX_EXPLICIT_VALUE);; + StringBuilder modifiedString = new StringBuilder(explicitValue); + modifiedString.setCharAt(index, randomChar); + return new StringExplicitValueModification(modifiedString.toString()); } @Override 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..2fdaeee7 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java @@ -13,12 +13,15 @@ import jakarta.xml.bind.annotation.XmlType; import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.util.Objects; +import java.util.Random; /** Modification that prepends a string to the original value. */ @XmlRootElement @XmlType(propOrder = {"prependValue", "modificationFilter"}) public class StringPrependValueModification extends VariableModification { + private static final int MAX_EXPLICIT_VALUE = 256; + @XmlJavaTypeAdapter(IllegalStringAdapter.class) private String prependValue; @@ -43,7 +46,12 @@ public void setPrependValue(final String prependValue) { @Override public VariableModification getModifiedCopy() { - return new StringPrependValueModification(prependValue); + Random r = new Random(); + int index = r.nextInt(prependValue.length()); + char randomChar = (char) r.nextInt(MAX_EXPLICIT_VALUE);; + StringBuilder modifiedString = new StringBuilder(prependValue); + modifiedString.setCharAt(index, randomChar); + return new StringPrependValueModification(modifiedString.toString()); } @Override From 31bfb2f6061d9203502589400eebc5e40a150738 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Mon, 14 Oct 2024 13:15:34 +0200 Subject: [PATCH 05/82] Make createRandomModification() more readable by using Enums for the modification types instead of constant integers. This also unifies the method in all factories. Also remove unnecessary semicolons from previous commit. --- .../BigIntegerModificationFactory.java | 53 +++++++------- .../bool/BooleanModificationFactory.java | 16 +++-- .../ByteArrayModificationFactory.java | 69 +++++++------------ .../integer/IntegerModificationFactory.java | 47 ++++++------- .../longint/LongModificationFactory.java | 37 +++++----- .../singlebyte/ByteModificationFactory.java | 45 +++++------- .../string/StringAppendValueModification.java | 2 +- .../StringExplicitValueModification.java | 2 +- .../string/StringModificationFactory.java | 44 ++++++++++-- .../StringPrependValueModification.java | 2 +- 10 files changed, 157 insertions(+), 160 deletions(-) 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 3d316c97..0470bbdd 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationFactory.java @@ -24,7 +24,11 @@ public class BigIntegerModificationFactory { - private static final int MODIFICATION_COUNT = 7; + private enum ModificationType { + ADD, SUBTRACT, XOR, EXPLICIT, SHIFT_LEFT, SHIFT_RIGHT, EXPLICIT_FROM_FILE + } + + private static final int MODIFICATION_COUNT = ModificationType.values().length; private static final int MAX_MODIFICATION_VALUE = 320000; @@ -133,7 +137,7 @@ public static synchronized List> modificationsF String line; while ((line = br.readLine()) != null) { String value = line.trim().split(" ")[0]; - if (!value.equals("")) { + if (!value.isEmpty()) { modificationsFromFile.add(explicitValue(value)); } } @@ -147,35 +151,26 @@ public static synchronized List> modificationsF public static VariableModification createRandomModification() { Random random = RandomHelper.getRandom(); - int r = random.nextInt(MODIFICATION_COUNT); + ModificationType randomType = ModificationType.values()[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; + switch (randomType) { + case ADD: + return new BigIntegerAddModification(modification); + case SUBTRACT: + return new BigIntegerSubtractModification(modification); + case XOR: + return new BigIntegerXorModification(modification); + case EXPLICIT: + return new BigIntegerExplicitValueModification(modification); + case SHIFT_LEFT: + return new BigIntegerShiftLeftModification(shiftModification); + case SHIFT_RIGHT: + return new BigIntegerShiftRightModification(shiftModification); + case EXPLICIT_FROM_FILE: + return explicitValueFromFile(MAX_MODIFICATION_VALUE); + default: + throw new IllegalStateException("Unexpected modification type: " + randomType); } } 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..66c009ac 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanModificationFactory.java @@ -13,19 +13,23 @@ public class BooleanModificationFactory { - private static final int MODIFICATION_COUNT = 3; + private enum ModificationType { + EXPLICIT_TRUE, EXPLICIT_FALSE, TOGGLE + } + private static final int MODIFICATION_COUNT = ModificationType.values().length; public static VariableModification createRandomModification() { Random random = RandomHelper.getRandom(); - switch (random.nextInt(MODIFICATION_COUNT)) { - case 0: + ModificationType randomType = ModificationType.values()[random.nextInt(MODIFICATION_COUNT)]; + switch (randomType) { + case EXPLICIT_TRUE: return new BooleanExplicitValueModification(true); - case 1: + case EXPLICIT_FALSE: return new BooleanExplicitValueModification(false); - case 2: + case TOGGLE: return new BooleanToggleModification(); default: - return null; + throw new IllegalStateException("Unexpected modification type: " + randomType); } } 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..c87c5e55 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayModificationFactory.java @@ -21,21 +21,10 @@ 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 enum ModificationType { + XOR, INSERT, DELETE, EXPLICIT, DUPLICATE, EXPLICIT_FROM_FILE, SHUFFLE + } + private static final int MODIFICATION_COUNT = ModificationType.values().length; private static final int MAX_CONFIG_PARAMETER = 200; @@ -131,29 +120,29 @@ public static synchronized List> modificationsFromF public static VariableModification createRandomModification(byte[] originalValue) { Random random = RandomHelper.getRandom(); - int r = random.nextInt(MODIFICATION_COUNT); - VariableModification vm = null; + ModificationType randomType = ModificationType.values()[random.nextInt(MODIFICATION_COUNT)]; int modifiedArrayLength; + int modificationArrayLength; + int startPosition; 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; + randomType = ModificationType.EXPLICIT; } } - switch (r) { - case BYTE_ARRAY_XOR_MODIFICATION: - int modificationArrayLength = random.nextInt(modifiedArrayLength); + switch (randomType) { + case XOR: + 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: + startPosition = random.nextInt(modifiedArrayLength - modificationArrayLength); + return new ByteArrayXorModification(xor, startPosition); + case INSERT: modificationArrayLength = random.nextInt(MAX_CONFIG_PARAMETER); if (modificationArrayLength == 0) { modificationArrayLength++; @@ -161,37 +150,31 @@ public static VariableModification createRandomModification(byte[] origi 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: + return new ByteArrayInsertModification(bytesToInsert, insertPosition); + case DELETE: 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: + return new ByteArrayDeleteModification(startPosition, count); + case EXPLICIT: 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: + return new ByteArrayExplicitValueModification(explicitValue); + case DUPLICATE: + return new ByteArrayDuplicateModification(); + case EXPLICIT_FROM_FILE: + return explicitValueFromFile(random.nextInt(EXPLICIT_VALUE_RANDOM)); + case SHUFFLE: int shuffleSize = random.nextInt(MAX_CONFIG_PARAMETER); byte[] shuffle = new byte[shuffleSize]; random.nextBytes(shuffle); - vm = shuffle(shuffle); - return vm; + return new ByteArrayShuffleModification(shuffle); default: - return vm; + throw new IllegalStateException("Unexpected modification type: " + randomType); } } 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..7b65d624 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerModificationFactory.java @@ -20,7 +20,10 @@ public class IntegerModificationFactory { - private static final int MODIFICATION_COUNT = 7; + private enum ModificationType { + ADD, SUBTRACT, XOR, EXPLICIT, SHIFT_LEFT, SHIFT_RIGHT, EXPLICIT_FROM_FILE + } + private static final int MODIFICATION_COUNT = ModificationType.values().length; private static final int MAX_MODIFICATION_VALUE = 32000; @@ -106,34 +109,26 @@ public static synchronized List> modificationsFrom public static VariableModification createRandomModification() { Random random = RandomHelper.getRandom(); - int r = random.nextInt(MODIFICATION_COUNT); + ModificationType randomType = ModificationType.values()[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; + switch (randomType) { + case ADD: + return new IntegerAddModification(modification); + case SUBTRACT: + return new IntegerSubtractModification(modification); + case XOR: + return new IntegerXorModification(modification); + case EXPLICIT: + return new IntegerExplicitValueModification(modification); + case SHIFT_LEFT: + return new IntegerShiftLeftModification(shiftModification); + case SHIFT_RIGHT: + return new IntegerShiftRightModification(shiftModification); + case EXPLICIT_FROM_FILE: + return explicitValueFromFile(random.nextInt(MAX_MODIFICATION_VALUE)); default: - return vm; + throw new IllegalStateException("Unexpected modification type: " + randomType); } } 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..ca97a66a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongModificationFactory.java @@ -21,7 +21,10 @@ public class LongModificationFactory { - private static final int MODIFICATION_COUNT = 5; + private enum ModificationType { + ADD, SUBTRACT, XOR, EXPLICIT, EXPLICIT_FROM_FILE + } + private static final int MODIFICATION_COUNT = ModificationType.values().length; private static final int MAX_MODIFICATION_VALUE = 32000; @@ -88,27 +91,21 @@ public static synchronized List> modificationsFromFil public static VariableModification createRandomModification() { Random random = RandomHelper.getRandom(); - int r = random.nextInt(MODIFICATION_COUNT); + ModificationType randomType = ModificationType.values()[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; + switch (randomType) { + case ADD: + return new LongAddModification(modification); + case SUBTRACT: + return new LongSubtractModification(modification); + case XOR: + return new LongXorModification(modification); + case EXPLICIT: + return new LongExplicitValueModification(modification); + case EXPLICIT_FROM_FILE: + return explicitValueFromFile(random.nextInt(MAX_MODIFICATION_VALUE)); default: - return vm; + throw new IllegalStateException("Unexpected modification type: " + randomType); } } 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..20e4d84e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteModificationFactory.java @@ -20,15 +20,10 @@ public 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 enum ModificationType { + ADD, SUBTRACT, XOR, EXPLICIT, EXPLICIT_FROM_FILE + } + private static final int MODIFICATION_COUNT = ModificationType.values().length; private static List> modificationsFromFile; @@ -94,27 +89,21 @@ public static synchronized List> modificationsFromFil public static VariableModification createRandomModification() { Random random = RandomHelper.getRandom(); - int r = random.nextInt(MODIFICATION_COUNT); + ModificationType randomType = ModificationType.values()[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; + switch (randomType) { + case ADD: + return new ByteAddModification(modification); + case SUBTRACT: + return new ByteSubtractModification(modification); + case XOR: + return new ByteXorModification(modification); + case EXPLICIT: + return new ByteExplicitValueModification(modification); + case EXPLICIT_FROM_FILE: + return explicitValueFromFile(random.nextInt(Byte.MAX_VALUE)); default: - return vm; + throw new IllegalStateException("Unexpected modification type: " + randomType); } } 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 a81d708c..0c352c3a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java @@ -48,7 +48,7 @@ public void setAppendValue(final String appendValue) { public VariableModification getModifiedCopy() { Random r = new Random(); int index = r.nextInt(appendValue.length()); - char randomChar = (char) r.nextInt(MAX_EXPLICIT_VALUE);; + char randomChar = (char) r.nextInt(MAX_EXPLICIT_VALUE); StringBuilder modifiedString = new StringBuilder(appendValue); modifiedString.setCharAt(index, randomChar); return new StringAppendValueModification(modifiedString.toString()); 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 26c7fa6a..0e48fb08 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java @@ -51,7 +51,7 @@ public VariableModification getModifiedCopy() { } Random r = new Random(); int index = r.nextInt(explicitValue.length()); - char randomChar = (char) r.nextInt(MAX_EXPLICIT_VALUE);; + char randomChar = (char) r.nextInt(MAX_EXPLICIT_VALUE); StringBuilder modifiedString = new StringBuilder(explicitValue); modifiedString.setCharAt(index, randomChar); return new StringExplicitValueModification(modifiedString.toString()); 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..77455d22 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringModificationFactory.java @@ -10,10 +10,20 @@ import de.rub.nds.modifiablevariable.VariableModification; import de.rub.nds.modifiablevariable.util.RandomHelper; +import java.util.Random; + /** */ public class StringModificationFactory { - private static final int MAX_BYTE_LENGTH = 1000; + private enum ModificationType { + APPEND, PREPEND, EXPLICIT + } + private static final int MODIFICATION_COUNT = ModificationType.values().length; + + private static final int MAX_BYTE_LENGTH_INSERT = 200; + + private static final int MAX_BYTE_LENGTH_EXPLICIT = 1000; + public static VariableModification prependValue(final String value) { return new StringPrependValueModification(value); @@ -28,9 +38,33 @@ public static VariableModification explicitValue(final String 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)); + Random random = RandomHelper.getRandom(); + ModificationType randomType = ModificationType.values()[random.nextInt(MODIFICATION_COUNT)]; + int modificationArrayLength; + switch (randomType) { + case APPEND: + modificationArrayLength = random.nextInt(MAX_BYTE_LENGTH_INSERT); + if (modificationArrayLength == 0) { + modificationArrayLength++; + } + byte[] bytesToAppend = new byte[modificationArrayLength]; + random.nextBytes(bytesToAppend); + return new StringAppendValueModification(new String(bytesToAppend)); + case PREPEND: + modificationArrayLength = random.nextInt(MAX_BYTE_LENGTH_INSERT); + if (modificationArrayLength == 0) { + modificationArrayLength++; + } + byte[] bytesToPrepend = new byte[modificationArrayLength]; + random.nextBytes(bytesToPrepend); + return new StringPrependValueModification(new String(bytesToPrepend)); + case EXPLICIT: + modificationArrayLength = random.nextInt(MAX_BYTE_LENGTH_EXPLICIT); + byte[] explicitValue = new byte[modificationArrayLength]; + random.nextBytes(explicitValue); + return new StringExplicitValueModification(new String(explicitValue)); + default: + throw new IllegalStateException("Unexpected modification type: " + randomType); + } } } 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 2fdaeee7..09cfb16b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java @@ -48,7 +48,7 @@ public void setPrependValue(final String prependValue) { public VariableModification getModifiedCopy() { Random r = new Random(); int index = r.nextInt(prependValue.length()); - char randomChar = (char) r.nextInt(MAX_EXPLICIT_VALUE);; + char randomChar = (char) r.nextInt(MAX_EXPLICIT_VALUE); StringBuilder modifiedString = new StringBuilder(prependValue); modifiedString.setCharAt(index, randomChar); return new StringPrependValueModification(modifiedString.toString()); From 753cf1be014b0db8cca7470f2ea8a86e21e6e67d Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Mon, 14 Oct 2024 14:48:58 +0200 Subject: [PATCH 06/82] Create StingInsertValueModification class. Very similar to the ByteArrayInsertModification class. To make the String modifiable variable more complete. Naming it InsertValue to keep it consistent with append and prepend, though the other Modification classes put "value" only behind Explicit Modifications. --- .../ModifiableVariable.java | 6 +- .../ByteArrayInsertModification.java | 4 +- .../string/StringInsertValueModification.java | 122 ++++++++++++++++++ .../string/StringModificationFactory.java | 28 +++- .../modifiablevariable/util/Modifiable.java | 4 + 5 files changed, 159 insertions(+), 5 deletions(-) create mode 100644 src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java index fe196ed1..1e7349bc 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -39,6 +39,7 @@ 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.StringInsertValueModification; import de.rub.nds.modifiablevariable.string.StringPrependValueModification; import jakarta.xml.bind.annotation.XmlAccessType; import jakarta.xml.bind.annotation.XmlAccessorType; @@ -149,7 +150,10 @@ public abstract class ModifiableVariable implements Serializable { name = "StringAppendValueModification"), @XmlElement( type = StringExplicitValueModification.class, - name = "StringExplicitValueModification") + name = "StringExplicitValueModification"), + @XmlElement( + type = StringInsertValueModification.class, + name = "StringInsertValueModification") }) private VariableModification modification = null; diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertModification.java index 64c4ab5e..53f43bb9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertModification.java @@ -53,13 +53,13 @@ protected byte[] modifyImplementationHook(byte[] input) { return input; } } - if (startPosition > input.length) { + if (start > input.length) { LOGGER.debug("Trying to insert behind the Array. ArraySize:{} Insert Position:{}", input.length, startPosition); return input; } byte[] ret1 = Arrays.copyOf(input, start); byte[] ret3 = null; - if ((start) < input.length) { + if (start < input.length) { ret3 = Arrays.copyOfRange(input, start, input.length); } return ArrayConverter.concatenate(ret1, bytesToInsert, ret3); 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..f18e84ff --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java @@ -0,0 +1,122 @@ +/* + * 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 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; +import java.util.Random; + +/** Modification that appends a string to the original value. */ +@XmlRootElement +@XmlType(propOrder = {"insertValue", "modificationFilter"}) +public class StringInsertValueModification extends VariableModification { + + private static final int MAX_EXPLICIT_VALUE = 256; + + private static final int MAX_INSERT_MODIFIER = 32; + + @XmlJavaTypeAdapter(IllegalStringAdapter.class) + private String insertValue; + + private int startPosition; + + public StringInsertValueModification() {} + + public StringInsertValueModification(final String insertValue, int startPosition) { + this.insertValue = insertValue; + this.startPosition = startPosition; + } + + @Override + protected String modifyImplementationHook(final String input) { + int start = startPosition; + if (start < 0) { + start += input.length(); + if (start < 0) { + LOGGER.debug("Trying to insert from too negative start position. start = {}", startPosition); + return input; + } + } + if (start > input.length()) { + LOGGER.debug("Trying to insert behind the string. String Length:{} Insert Position:{}", input.length(), startPosition); + return input; + } + + return new StringBuilder(input).insert(start, insertValue).toString(); + } + + public String getinsertValue() { + return this.insertValue; + } + + public void setinsertValue(final String insertValue) { + this.insertValue = insertValue; + } + + 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(insertValue.length()); + char randomChar = (char) r.nextInt(MAX_EXPLICIT_VALUE); + StringBuilder modifiedString = new StringBuilder(insertValue); + modifiedString.setCharAt(index, randomChar); + return new StringInsertValueModification(modifiedString.toString(), startPosition); + } else { + int modifier = r.nextInt(MAX_INSERT_MODIFIER); + if (r.nextBoolean()) { + modifier *= -1; + } + modifier = startPosition + modifier; + if (modifier <= 0) { + modifier = 1; + } + return new StringInsertValueModification(insertValue, modifier); + } + } + + @Override + public int hashCode() { + int hash = 4; + hash = 83 * hash + Objects.hashCode(this.insertValue); + hash = 83 * 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 StringInsertValueModification other = (StringInsertValueModification) obj; + if (this.startPosition != other.startPosition) { + return false; + } + return Objects.equals(this.insertValue, other.getinsertValue()); + } +} 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 77455d22..f7fdea6f 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringModificationFactory.java @@ -16,7 +16,7 @@ public class StringModificationFactory { private enum ModificationType { - APPEND, PREPEND, EXPLICIT + APPEND, PREPEND, EXPLICIT, INSERT } private static final int MODIFICATION_COUNT = ModificationType.values().length; @@ -24,6 +24,8 @@ private enum ModificationType { private static final int MAX_BYTE_LENGTH_EXPLICIT = 1000; + private static final int MODIFIED_STRING_LENGTH_ESTIMATION = 50; + public static VariableModification prependValue(final String value) { return new StringPrependValueModification(value); @@ -37,10 +39,23 @@ public static VariableModification explicitValue(final String value) { return new StringExplicitValueModification(value); } - public static VariableModification createRandomModification() { + public static VariableModification insertValue(final String value, final int position) { + return new StringInsertValueModification(value, position); + } + + public static VariableModification createRandomModification(String originalValue) { Random random = RandomHelper.getRandom(); ModificationType randomType = ModificationType.values()[random.nextInt(MODIFICATION_COUNT)]; int modificationArrayLength; + int modifiedArrayLength; + if (originalValue == null) { + modifiedArrayLength = MODIFIED_STRING_LENGTH_ESTIMATION; + } else { + modifiedArrayLength = originalValue.length(); + if (modifiedArrayLength == 0 || modifiedArrayLength == 1) { + randomType = ModificationType.EXPLICIT; + } + } switch (randomType) { case APPEND: modificationArrayLength = random.nextInt(MAX_BYTE_LENGTH_INSERT); @@ -63,6 +78,15 @@ public static VariableModification createRandomModification() { byte[] explicitValue = new byte[modificationArrayLength]; random.nextBytes(explicitValue); return new StringExplicitValueModification(new String(explicitValue)); + case INSERT: + modificationArrayLength = random.nextInt(MAX_BYTE_LENGTH_INSERT); + if (modificationArrayLength == 0) { + modificationArrayLength++; + } + byte[] bytesToInsert = new byte[modificationArrayLength]; + random.nextBytes(bytesToInsert); + int insertPosition = random.nextInt(modifiedArrayLength); + return new StringInsertValueModification(new String(bytesToInsert), insertPosition); default: throw new IllegalStateException("Unexpected modification type: " + randomType); } 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..d87dd421 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/Modifiable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/Modifiable.java @@ -114,6 +114,10 @@ public static ModifiableBoolean explicit(Boolean b) { public static ModifiableString explicit(String s) { return getModifiableStringWithModification(StringModificationFactory.explicitValue(s)); } + public static ModifiableString insert(String s, int position) { + return getModifiableStringWithModification(StringModificationFactory.insertValue(s, position)); + } + public static ModifiableByteArray xor(byte[] b, int position) { return getModifiableByteArrayWithModification( From 457a67b4b2244489282c313a608efce3b08b3d04 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Mon, 14 Oct 2024 14:55:12 +0200 Subject: [PATCH 07/82] Fix Typo getinsertValue to getInsertValue --- .../string/StringInsertValueModification.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java index f18e84ff..2cd29a19 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java @@ -55,11 +55,11 @@ protected String modifyImplementationHook(final String input) { return new StringBuilder(input).insert(start, insertValue).toString(); } - public String getinsertValue() { + public String getInsertValue() { return this.insertValue; } - public void setinsertValue(final String insertValue) { + public void setInsertValue(final String insertValue) { this.insertValue = insertValue; } @@ -117,6 +117,6 @@ public boolean equals(Object obj) { if (this.startPosition != other.startPosition) { return false; } - return Objects.equals(this.insertValue, other.getinsertValue()); + return Objects.equals(this.insertValue, other.getInsertValue()); } } From fc9d71b4c567e37f512fdcf9a7ac4b519ba5b8a1 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Tue, 12 Nov 2024 11:31:17 +0100 Subject: [PATCH 08/82] fix bytesToLong --- .../de/rub/nds/modifiablevariable/util/ArrayConverter.java | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) 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..5449b1ea 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/ArrayConverter.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/ArrayConverter.java @@ -119,10 +119,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; @@ -188,8 +188,7 @@ 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(); From 8599859f89d3bfe4c057e6500ed55af125880b6e Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Wed, 20 Nov 2024 14:48:14 +0100 Subject: [PATCH 09/82] Change the hashCode() function of all Modifications, so they have a bit more semantic. There is no real reason for this change. Now the magic numbers, are a little bit less magic (just counting up the different modifications) --- .../biginteger/BigIntegerAddModification.java | 2 +- .../biginteger/BigIntegerExplicitValueModification.java | 4 ++-- .../biginteger/BigIntegerMultiplyModification.java | 4 ++-- .../biginteger/BigIntegerShiftLeftModification.java | 2 +- .../biginteger/BigIntegerShiftRightModification.java | 2 +- .../biginteger/BigIntegerSubtractModification.java | 4 ++-- .../biginteger/BigIntegerXorModification.java | 2 +- .../bool/BooleanExplicitValueModification.java | 2 +- .../bytearray/ByteArrayDeleteModification.java | 4 ++-- .../bytearray/ByteArrayExplicitValueModification.java | 4 ++-- .../bytearray/ByteArrayInsertModification.java | 4 ++-- .../bytearray/ByteArrayShuffleModification.java | 4 ++-- .../bytearray/ByteArrayXorModification.java | 4 ++-- .../modifiablevariable/integer/IntegerAddModification.java | 4 ++-- .../integer/IntegerExplicitValueModification.java | 2 +- .../integer/IntegerShiftLeftModification.java | 2 +- .../integer/IntegerShiftRightModification.java | 4 ++-- .../integer/IntegerSubtractModification.java | 2 +- .../modifiablevariable/integer/IntegerXorModification.java | 4 ++-- .../nds/modifiablevariable/longint/LongAddModification.java | 2 +- .../longint/LongExplicitValueModification.java | 4 ++-- .../longint/LongSubtractModification.java | 2 +- .../nds/modifiablevariable/longint/LongXorModification.java | 4 ++-- .../modifiablevariable/singlebyte/ByteAddModification.java | 4 ++-- .../singlebyte/ByteExplicitValueModification.java | 2 +- .../singlebyte/ByteSubtractModification.java | 4 ++-- .../modifiablevariable/singlebyte/ByteXorModification.java | 2 +- .../string/StringAppendValueModification.java | 4 ++-- .../string/StringExplicitValueModification.java | 4 ++-- .../string/StringInsertValueModification.java | 6 +++--- .../string/StringPrependValueModification.java | 4 ++-- 31 files changed, 51 insertions(+), 51 deletions(-) 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 d5467901..06f69e73 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java @@ -53,7 +53,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 41 * hash + Objects.hashCode(this.summand); + hash = 51 * hash + Objects.hashCode(this.summand); return hash; } 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 6593141a..780d0b3c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java @@ -58,8 +58,8 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { - int hash = 3; - hash = 41 * hash + Objects.hashCode(this.explicitValue); + int hash = 7; + hash = 52 * hash + Objects.hashCode(this.explicitValue); return hash; } 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 4ffe0ca7..97376ea8 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java @@ -55,8 +55,8 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { - int hash = 5; - hash = 61 * hash + Objects.hashCode(this.factor); + int hash = 7; + hash = 53 * hash + Objects.hashCode(this.factor); return hash; } 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 0c058b33..b40fef8e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java @@ -54,7 +54,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 97 * hash + this.shift; + hash = 54 * hash + this.shift; return hash; } 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 9d30b4bf..623c7ae8 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java @@ -54,7 +54,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 97 * hash + this.shift; + hash = 55 * hash + this.shift; return hash; } 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 96e7819b..9e57ec18 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java @@ -55,8 +55,8 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { - int hash = 5; - hash = 61 * hash + Objects.hashCode(this.subtrahend); + int hash = 7; + hash = 56 * hash + Objects.hashCode(this.subtrahend); return hash; } 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 035c0f70..d820ddf4 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java @@ -55,7 +55,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 97 * hash + Objects.hashCode(this.xor); + hash = 57 * hash + Objects.hashCode(this.xor); return hash; } 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 407e0456..19dc3dca 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanExplicitValueModification.java @@ -44,7 +44,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 29 * hash + (this.explicitValue ? 1 : 0); + hash = 21 * hash + (this.explicitValue ? 1 : 0); return hash; } 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 ed3152dc..0c4964bf 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java @@ -107,8 +107,8 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 89 * hash + this.count; - hash = 89 * hash + this.startPosition; + hash = 81 * hash + this.count; + hash = 81 * hash + this.startPosition; return hash; } 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 c7c29ae3..4bb31238 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java @@ -69,8 +69,8 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { - int hash = 5; - hash = 53 * hash + Arrays.hashCode(this.explicitValue); + int hash = 7; + hash = 82 * hash + Arrays.hashCode(this.explicitValue); return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertModification.java index 53f43bb9..c98b92ea 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertModification.java @@ -107,8 +107,8 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 59 * hash + Arrays.hashCode(this.bytesToInsert); - hash = 59 * hash + this.startPosition; + hash = 83 * hash + Arrays.hashCode(this.bytesToInsert); + hash = 83 * hash + this.startPosition; return hash; } 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 7b899154..d270ba2d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayShuffleModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayShuffleModification.java @@ -76,8 +76,8 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { - int hash = 5; - hash = 71 * hash + Arrays.hashCode(this.shuffle); + int hash = 7; + hash = 84 * hash + Arrays.hashCode(this.shuffle); return hash; } 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 ac47705c..1bc070bf 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java @@ -109,8 +109,8 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 97 * hash + Arrays.hashCode(this.xor); - hash = 97 * hash + this.startPosition; + hash = 85 * hash + Arrays.hashCode(this.xor); + hash = 85 * hash + this.startPosition; return hash; } 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 8ad6d9a4..1b4a9c44 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAddModification.java @@ -47,8 +47,8 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { - int hash = 3; - hash = 23 * hash + Objects.hashCode(this.summand); + int hash = 7; + hash = 31 * hash + Objects.hashCode(this.summand); return hash; } 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 792f05a5..32affcac 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueModification.java @@ -55,7 +55,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 53 * hash + Objects.hashCode(this.explicitValue); + hash = 32 * hash + Objects.hashCode(this.explicitValue); return hash; } 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 dcb56cc9..31332f5b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftLeftModification.java @@ -59,7 +59,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 73 * hash + this.shift; + hash = 33 * hash + this.shift; return hash; } 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 2969a134..4d0467fa 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftRightModification.java @@ -58,8 +58,8 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { - int hash = 5; - hash = 59 * hash + this.shift; + int hash = 7; + hash = 34 * hash + this.shift; return hash; } 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 c527713e..0d23a33b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSubtractModification.java @@ -49,7 +49,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 23 * hash + Objects.hashCode(this.subtrahend); + hash = 35 * hash + Objects.hashCode(this.subtrahend); return hash; } 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 dda4a30c..07338a89 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerXorModification.java @@ -52,8 +52,8 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { - int hash = 3; - hash = 97 * hash + Objects.hashCode(this.xor); + int hash = 7; + hash = 36 * hash + Objects.hashCode(this.xor); return hash; } 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 637297f2..afde2330 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java @@ -48,7 +48,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 43 * hash + Objects.hashCode(this.summand); + hash = 41 * hash + Objects.hashCode(this.summand); return hash; } 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 8b4ae295..b7422adf 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java @@ -54,8 +54,8 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { - int hash = 3; - hash = 43 * hash + Objects.hashCode(this.explicitValue); + int hash = 7; + hash = 42 * hash + Objects.hashCode(this.explicitValue); return hash; } 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 e1cde296..7b554e0d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java @@ -49,7 +49,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 97 * hash + Objects.hashCode(this.subtrahend); + hash = 43 * hash + Objects.hashCode(this.subtrahend); return hash; } 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 50afc213..fd73e4d2 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java @@ -52,8 +52,8 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { - int hash = 3; - hash = 59 * hash + Objects.hashCode(this.xor); + int hash = 7; + hash = 44 * hash + Objects.hashCode(this.xor); return hash; } 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 6cfcc7e8..7850d344 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteAddModification.java @@ -50,8 +50,8 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { - int hash = 5; - hash = 17 * hash + Objects.hashCode(this.summand); + int hash = 7; + hash = 11 * hash + Objects.hashCode(this.summand); return hash; } 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 0297cf81..d1f32c02 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueModification.java @@ -55,7 +55,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 79 * hash + Objects.hashCode(this.explicitValue); + hash = 12 * hash + Objects.hashCode(this.explicitValue); return hash; } 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 85c22ba3..ebe1ca83 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteSubtractModification.java @@ -51,8 +51,8 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { - int hash = 3; - hash = 71 * hash + Objects.hashCode(this.subtrahend); + int hash = 7; + hash = 13 * hash + Objects.hashCode(this.subtrahend); return hash; } 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 21cad46d..1b968a08 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteXorModification.java @@ -57,7 +57,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 89 * hash + Objects.hashCode(this.xor); + hash = 14 * hash + Objects.hashCode(this.xor); return hash; } 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 0c352c3a..3d060022 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java @@ -56,8 +56,8 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { - int hash = 4; - hash = 83 * hash + Objects.hashCode(this.appendValue); + int hash = 7; + hash = 61 * hash + Objects.hashCode(this.appendValue); return hash; } 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 0e48fb08..243c87cd 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java @@ -59,8 +59,8 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { - int hash = 3; - hash = 83 * hash + Objects.hashCode(this.explicitValue); + int hash = 7; + hash = 62 * hash + Objects.hashCode(this.explicitValue); return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java index 2cd29a19..8fae6a1b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java @@ -96,9 +96,9 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { - int hash = 4; - hash = 83 * hash + Objects.hashCode(this.insertValue); - hash = 83 * hash + this.startPosition; + int hash = 7; + hash = 63 * hash + Objects.hashCode(this.insertValue); + hash = 63 * hash + this.startPosition; return hash; } 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 09cfb16b..99164c32 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java @@ -56,8 +56,8 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { - int hash = 5; - hash = 83 * hash + Objects.hashCode(this.prependValue); + int hash = 7; + hash = 64 * hash + Objects.hashCode(this.prependValue); return hash; } From 9789ee73f48139338f58d9f5ec85af7d5fce3337 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Thu, 21 Nov 2024 09:26:37 +0100 Subject: [PATCH 10/82] Move the Moodifications from SSH-Fuzzer to ModifiableVaraible. SSH-Fuzzer hat defined some modificiations using the explicitValueModificationGenerator() method. It makes not much sense for me to define them not well structured in the SSH-Fuzzer (and abusing explicit modifications for this). The Mutations that got moved over are: - Append - Insert - Prepend for Integer, BigInteger, ByteArray and Long These Modifications do currently produce no usefull values for negative parameters, but if someone needs this, he should revise this. For our work, we mostly need only positiv values. I also added the missing modifications for long, since SFTP uses longs. And also added multiply modifiaction to integer. --- .../ModifiableVariable.java | 77 +++++++---- .../BigIntegerAppendValueModification.java | 76 +++++++++++ .../BigIntegerInsertValueModification.java | 120 ++++++++++++++++++ .../BigIntegerModificationFactory.java | 51 +++++++- .../BigIntegerMultiplyModification.java | 5 +- .../BigIntegerPrependValueModification.java | 76 +++++++++++ .../ByteArrayAppendValueModification.java | 91 +++++++++++++ ... => ByteArrayInsertValueModification.java} | 22 ++-- .../ByteArrayModificationFactory.java | 50 ++++---- .../ByteArrayPrependValueModification.java | 91 +++++++++++++ .../integer/IntegerAddModification.java | 4 +- .../IntegerAppendValueModification.java | 73 +++++++++++ .../IntegerExplicitValueModification.java | 4 +- .../IntegerInsertValueModification.java | 117 +++++++++++++++++ .../integer/IntegerModificationFactory.java | 52 +++++++- .../integer/IntegerMultiplyModification.java | 72 +++++++++++ .../IntegerPrependValueModification.java | 74 +++++++++++ .../integer/IntegerShiftLeftModification.java | 2 +- .../IntegerShiftRightModification.java | 2 +- .../integer/IntegerSubtractModification.java | 4 +- .../integer/IntegerXorModification.java | 4 +- .../longint/LongAddModification.java | 4 +- .../longint/LongAppendValueModification.java | 72 +++++++++++ .../LongExplicitValueModification.java | 4 +- .../longint/LongInsertValueModification.java | 113 +++++++++++++++++ .../longint/LongModificationFactory.java | 62 ++++++++- .../longint/LongMultiplyModification.java | 69 ++++++++++ .../longint/LongPrependValueModification.java | 72 +++++++++++ .../longint/LongShiftLeftModification.java | 82 ++++++++++++ .../longint/LongShiftRightModification.java | 82 ++++++++++++ .../longint/LongSubtractModification.java | 4 +- .../longint/LongXorModification.java | 8 +- .../string/ModifiableString.java | 2 +- .../modifiablevariable/util/Modifiable.java | 78 +++++++++++- .../nds/modifiablevariable/explicit/long.vec | 31 +++++ .../bytearray/ModifiableByteArrayTest.java | 10 +- .../ByteArraySerializationTest.java | 4 +- 37 files changed, 1660 insertions(+), 104 deletions(-) create mode 100644 src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java create mode 100644 src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java create mode 100644 src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java create mode 100644 src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java rename src/main/java/de/rub/nds/modifiablevariable/bytearray/{ByteArrayInsertModification.java => ByteArrayInsertValueModification.java} (81%) create mode 100644 src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java create mode 100644 src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java create mode 100644 src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java create mode 100644 src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java create mode 100644 src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java create mode 100644 src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java create mode 100644 src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java create mode 100644 src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java create mode 100644 src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java create mode 100644 src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java create mode 100644 src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java create mode 100644 src/main/resources/de/rub/nds/modifiablevariable/explicit/long.vec diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java index 1e7349bc..d9334ecb 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -7,32 +7,12 @@ */ 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.biginteger.*; 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.bytearray.*; +import de.rub.nds.modifiablevariable.integer.*; +import de.rub.nds.modifiablevariable.longint.*; import de.rub.nds.modifiablevariable.singlebyte.ByteAddModification; import de.rub.nds.modifiablevariable.singlebyte.ByteExplicitValueModification; import de.rub.nds.modifiablevariable.singlebyte.ByteSubtractModification; @@ -88,6 +68,15 @@ public abstract class ModifiableVariable implements Serializable { @XmlElement( type = BigIntegerMultiplyModification.class, name = "BigIntegerMultiplyModification"), + @XmlElement( + type = BigIntegerAppendValueModification.class, + name = "BigIntegerAppendValueModification"), + @XmlElement( + type = BigIntegerInsertValueModification.class, + name = "BigIntegerInsertValueModification"), + @XmlElement( + type = BigIntegerPrependValueModification.class, + name = "BigIntegerPrependValueModification"), @XmlElement( type = BooleanToggleModification.class, name = "BooleanToggleModification"), @@ -101,8 +90,14 @@ public abstract class ModifiableVariable implements Serializable { type = ByteArrayShuffleModification.class, name = "ByteArrayShuffleModification"), @XmlElement( - type = ByteArrayInsertModification.class, - name = "ByteArrayInsertModification"), + type = ByteArrayAppendValueModification.class, + name = "ByteArrayAppendValueModification"), + @XmlElement( + type = ByteArrayInsertValueModification.class, + name = "ByteArrayInsertValueModification"), + @XmlElement( + type = ByteArrayPrependValueModification.class, + name = "ByteArrayPrependValueModification"), @XmlElement( type = ByteArrayExplicitValueModification.class, name = "ByteArrayExplicitValueModification"), @@ -116,6 +111,9 @@ public abstract class ModifiableVariable implements Serializable { @XmlElement( type = IntegerSubtractModification.class, name = "IntegerSubtractModification"), + @XmlElement( + type = IntegerMultiplyModification.class, + name = "IntegerMultiplyModification"), @XmlElement( type = IntegerShiftRightModification.class, name = "IntegerShiftRightModification"), @@ -126,6 +124,15 @@ public abstract class ModifiableVariable implements Serializable { type = IntegerExplicitValueModification.class, name = "IntegerExplicitValueModification"), @XmlElement(type = IntegerAddModification.class, name = "IntegerAddModification"), + @XmlElement( + type = IntegerAppendValueModification.class, + name = "IntegerAppendValueModification"), + @XmlElement( + type = IntegerInsertValueModification.class, + name = "IntegerInsertValueModification"), + @XmlElement( + type = IntegerPrependValueModification.class, + name = "IntegerPrependValueModification"), @XmlElement(type = LongXorModification.class, name = "LongXorModification"), @XmlElement( type = LongSubtractModification.class, @@ -133,6 +140,24 @@ public abstract class ModifiableVariable implements Serializable { @XmlElement( type = LongExplicitValueModification.class, name = "LongExplicitValueModification"), + @XmlElement( + type = LongAppendValueModification.class, + name = "LongAppendValueModification"), + @XmlElement( + type = LongInsertValueModification.class, + name = "LongInsertValueModification"), + @XmlElement( + type = LongPrependValueModification.class, + name = "LongPrependValueModification"), + @XmlElement( + type = LongMultiplyModification.class, + name = "LongMultiplyModification"), + @XmlElement( + type = LongShiftLeftModification.class, + name = "LongShiftLeftModification"), + @XmlElement( + type = LongShiftRightModification.class, + name = "LongShiftRightModification"), @XmlElement(type = LongAddModification.class, name = "LongAddModification"), @XmlElement(type = ByteXorModification.class, name = "ByteXorModification"), @XmlElement( diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java new file mode 100644 index 00000000..5b1c385c --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java @@ -0,0 +1,76 @@ +/* + * 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.XmlType; +import java.math.BigInteger; +import java.util.Objects; +import java.util.Random; + +@XmlRootElement +@XmlType(propOrder = {"appendValue", "modificationFilter"}) +@XmlAccessorType(XmlAccessType.FIELD) +public class BigIntegerAppendValueModification extends VariableModification { + + private static final int MAX_APPEND_LENGTH = 8; + + private BigInteger appendValue; + + public BigIntegerAppendValueModification() {} + + public BigIntegerAppendValueModification(BigInteger bi) { + this.appendValue = bi; + } + + @Override + protected BigInteger modifyImplementationHook(BigInteger input) { + if (input == null) { + input = BigInteger.ZERO; + } + return input.shiftLeft(appendValue.bitLength()).add(appendValue); + } + + public BigInteger getAppendValue() { + return appendValue; + } + + public void setAppendValue(BigInteger appendValue) { + this.appendValue = appendValue; + } + + @Override + public VariableModification getModifiedCopy() { + return new BigIntegerAppendValueModification(appendValue.add(new BigInteger(MAX_APPEND_LENGTH, new Random()))); + } + + @Override + public int hashCode() { + int hash = 7; + hash = 59 * hash + Objects.hashCode(this.appendValue); + 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 BigIntegerAppendValueModification other = (BigIntegerAppendValueModification) obj; + return Objects.equals(this.appendValue, other.appendValue); + } +} diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java new file mode 100644 index 00000000..9fa713b7 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java @@ -0,0 +1,120 @@ +/* + * 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.XmlType; +import java.math.BigInteger; +import java.util.Objects; +import java.util.Random; + +@XmlRootElement +@XmlType(propOrder = {"insertValue", "startPosition", "modificationFilter"}) +@XmlAccessorType(XmlAccessType.FIELD) +public class BigIntegerInsertValueModification extends VariableModification { + + private static final int MAX_INSERT_LENGTH = 8; + private static final int MAX_POSITION_MODIFIER = 32; + + private BigInteger insertValue; + private int startPosition; + + public BigIntegerInsertValueModification() {} + + public BigIntegerInsertValueModification(BigInteger bi, int startPosition) { + this.insertValue = bi; + this.startPosition = startPosition; + } + + @Override + protected BigInteger modifyImplementationHook(BigInteger input) { + if (input == null) { + input = BigInteger.ZERO; + } + int originalValueLength = input.bitLength(); + int insertValueLength = insertValue.bitLength(); + int insertPosition = startPosition; + if (startPosition > originalValueLength) { + insertPosition = originalValueLength; + } else if (startPosition < 0) { + insertPosition = 0; + } + BigInteger mask = BigInteger.valueOf((1L << insertPosition) - 1); + + return input.shiftRight(insertPosition) + .shiftLeft(insertValueLength) + .and(insertValue) + .shiftLeft(insertPosition) + .add(mask.and(input)); + } + + public BigInteger getInsertValue() { + return insertValue; + } + + public void setInsertValue(BigInteger insertValue) { + this.insertValue = insertValue; + } + + public int getStartPosition() { + return startPosition; + } + + public void setStartPosition(int startPosition) { + this.startPosition = startPosition; + } + + @Override + public VariableModification getModifiedCopy() { + Random r = new Random(); + + if (r.nextBoolean()) { + return new BigIntegerInsertValueModification( + insertValue.add(new BigInteger(MAX_INSERT_LENGTH, r)), startPosition); + } else { + int modifier = r.nextInt(MAX_POSITION_MODIFIER); + if (r.nextBoolean()) { + modifier *= -1; + } + modifier = startPosition + modifier; + if (modifier <= 0) { + modifier = 1; + } + return new BigIntegerInsertValueModification(insertValue, modifier); + } + } + + @Override + public int hashCode() { + int hash = 7; + hash = 58 * hash + Objects.hashCode(this.insertValue); + hash = 58 * hash + Objects.hashCode(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 BigIntegerInsertValueModification other = (BigIntegerInsertValueModification) obj; + if (this.startPosition != other.startPosition) { + return false; + } + return Objects.equals(this.insertValue, other.insertValue); + } +} 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 75158ce8..ebb2c1e3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationFactory.java @@ -11,6 +11,7 @@ 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.longint.LongModificationFactory; import de.rub.nds.modifiablevariable.util.RandomHelper; import java.io.BufferedReader; import java.io.IOException; @@ -25,15 +26,33 @@ public class BigIntegerModificationFactory { private enum ModificationType { - ADD, SUBTRACT, XOR, EXPLICIT, SHIFT_LEFT, SHIFT_RIGHT, EXPLICIT_FROM_FILE + ADD, + SUBTRACT, + MULTIPLY, + XOR, + EXPLICIT, + SHIFT_LEFT, + SHIFT_RIGHT, + EXPLICIT_FROM_FILE, + APPEND, + INSERT, + PREPEND } private static final int MODIFICATION_COUNT = ModificationType.values().length; private static final int MAX_MODIFICATION_VALUE = 320000; + private static final int MAX_FILE_ENTRIES = 200; + private static final int MAX_MODIFICATION_SHIFT_VALUE = 50; + private static final int MAX_MODIFICATION_MULTIPLY_VALUE = 256; + + private static final int MAX_MODIFICATION_INSERT_VALUE = 256; + + private static final int MAX_MODIFICATION_INSERT_POSITION_VALUE = 50; + private static List> modificationsFromFile; public static BigIntegerAddModification add(final String summand) { @@ -94,6 +113,19 @@ public static VariableModification explicitValueFromFile(int value) return modifications.get(pos); } + public static VariableModification appendValue(final BigInteger value) { + return new BigIntegerAppendValueModification(value); + } + + public static VariableModification insertValue( + final BigInteger value, final int startPosition) { + return new BigIntegerInsertValueModification(value, startPosition); + } + + public static VariableModification prependValue(final BigInteger value) { + return new BigIntegerPrependValueModification(value); + } + /* * Interactive modification */ @@ -137,7 +169,7 @@ public static synchronized List> modificationsF modificationsFromFile = new LinkedList<>(); ClassLoader classLoader = ByteArrayModificationFactory.class.getClassLoader(); InputStream is = - classLoader.getResourceAsStream(IntegerModificationFactory.FILE_NAME); + classLoader.getResourceAsStream(LongModificationFactory.FILE_NAME); BufferedReader br = new BufferedReader(new InputStreamReader(is)); String line; while ((line = br.readLine()) != null) { @@ -158,12 +190,17 @@ public static VariableModification createRandomModification() { Random random = RandomHelper.getRandom(); ModificationType randomType = ModificationType.values()[random.nextInt(MODIFICATION_COUNT)]; BigInteger modification = BigInteger.valueOf(random.nextInt(MAX_MODIFICATION_VALUE)); + BigInteger insert_modification = + BigInteger.valueOf(random.nextInt(MAX_MODIFICATION_INSERT_VALUE)); int shiftModification = random.nextInt(MAX_MODIFICATION_SHIFT_VALUE); switch (randomType) { case ADD: return new BigIntegerAddModification(modification); case SUBTRACT: return new BigIntegerSubtractModification(modification); + case MULTIPLY: + return new BigIntegerMultiplyModification( + BigInteger.valueOf(random.nextInt(MAX_MODIFICATION_MULTIPLY_VALUE))); case XOR: return new BigIntegerXorModification(modification); case EXPLICIT: @@ -173,7 +210,15 @@ public static VariableModification createRandomModification() { case SHIFT_RIGHT: return new BigIntegerShiftRightModification(shiftModification); case EXPLICIT_FROM_FILE: - return explicitValueFromFile(MAX_MODIFICATION_VALUE); + return explicitValueFromFile(MAX_FILE_ENTRIES); + case APPEND: + return new BigIntegerAppendValueModification(insert_modification); + case INSERT: + return new BigIntegerInsertValueModification( + insert_modification, + random.nextInt(MAX_MODIFICATION_INSERT_POSITION_VALUE)); + case PREPEND: + return new BigIntegerPrependValueModification(insert_modification); default: throw new IllegalStateException("Unexpected modification type: " + randomType); } 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 97376ea8..2f68fcb4 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java @@ -33,10 +33,7 @@ public BigIntegerMultiplyModification(BigInteger bi) { @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() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java new file mode 100644 index 00000000..92f7f772 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java @@ -0,0 +1,76 @@ +/* + * 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.XmlType; +import java.math.BigInteger; +import java.util.Objects; +import java.util.Random; + +@XmlRootElement +@XmlType(propOrder = {"prependValue", "modificationFilter"}) +@XmlAccessorType(XmlAccessType.FIELD) +public class BigIntegerPrependValueModification extends VariableModification { + + private static final int MAX_PREPEND_LENGTH = 8; + + private BigInteger prependValue; + + public BigIntegerPrependValueModification() {} + + public BigIntegerPrependValueModification(BigInteger bi) { + this.prependValue = bi; + } + + @Override + protected BigInteger modifyImplementationHook(BigInteger input) { + if (input == null) { + input = BigInteger.ZERO; + } + return prependValue.shiftLeft(input.bitLength()).add(input); + } + + public BigInteger getPrependValue() { + return prependValue; + } + + public void setPrependValue(BigInteger prependValue) { + this.prependValue = prependValue; + } + + @Override + public VariableModification getModifiedCopy() { + return new BigIntegerPrependValueModification(prependValue.add(new BigInteger(MAX_PREPEND_LENGTH, new Random()))); + } + + @Override + public int hashCode() { + int hash = 7; + hash = 60 * hash + Objects.hashCode(this.prependValue); + 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 BigIntegerPrependValueModification other = (BigIntegerPrependValueModification) obj; + return Objects.equals(this.prependValue, other.prependValue); + } +} 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..e80a5bb4 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java @@ -0,0 +1,91 @@ +/* + * 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 = {"bytesToAppend", "modificationFilter"}) +@XmlAccessorType(XmlAccessType.FIELD) +public class ByteArrayAppendValueModification extends VariableModification { + + private static final int MAX_EXPLICIT_VALUE = 256; + + @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) + private byte[] bytesToAppend; + + public ByteArrayAppendValueModification() {} + + public ByteArrayAppendValueModification(byte[] bytesToAppend) { + this.bytesToAppend = bytesToAppend; + } + + @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 VariableModification getModifiedCopy() { + Random r = new Random(); + + int index = r.nextInt(bytesToAppend.length); + byte[] newValue = Arrays.copyOf(bytesToAppend, bytesToAppend.length); + newValue[index] = (byte) r.nextInt(MAX_EXPLICIT_VALUE); + return new ByteArrayAppendValueModification(newValue); + } + + @Override + public int hashCode() { + int hash = 7; + hash = 86 * hash + Arrays.hashCode(this.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; + } + final ByteArrayAppendValueModification other = (ByteArrayAppendValueModification) obj; + return Arrays.equals(this.bytesToAppend, other.bytesToAppend); + } + + @Override + public String toString() { + return String.format("ByteArrayInsertModification{bytesToAppend=%s}", + ArrayConverter.bytesToHexString(bytesToAppend)); + } +} diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java similarity index 81% rename from src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertModification.java rename to src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java index c98b92ea..2a871621 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java @@ -21,20 +21,20 @@ @XmlRootElement @XmlType(propOrder = {"bytesToInsert", "startPosition", "modificationFilter"}) @XmlAccessorType(XmlAccessType.FIELD) -public class ByteArrayInsertModification extends VariableModification { +public class ByteArrayInsertValueModification extends VariableModification { private static final int MAX_EXPLICIT_VALUE = 256; - private static final int MAX_INSERT_MODIFIER = 32; + private static final int MAX_POSITION_MODIFIER = 32; @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) private byte[] bytesToInsert; private int startPosition; - public ByteArrayInsertModification() {} + public ByteArrayInsertValueModification() {} - public ByteArrayInsertModification(byte[] bytesToInsert, int startPosition) { + public ByteArrayInsertValueModification(byte[] bytesToInsert, int startPosition) { this.bytesToInsert = bytesToInsert; this.startPosition = startPosition; } @@ -49,13 +49,11 @@ protected byte[] modifyImplementationHook(byte[] input) { if (start < 0) { start += input.length; if (start < 0) { - LOGGER.debug("Trying to insert from too negative Startposition. start = {}", startPosition); - return input; + start = 0; } } if (start > input.length) { - LOGGER.debug("Trying to insert behind the Array. ArraySize:{} Insert Position:{}", input.length, startPosition); - return input; + start = input.length; } byte[] ret1 = Arrays.copyOf(input, start); byte[] ret3 = null; @@ -89,10 +87,10 @@ public VariableModification getModifiedCopy() { 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); + return new ByteArrayInsertValueModification(newValue, startPosition); } else { byte[] newValue = Arrays.copyOf(bytesToInsert, bytesToInsert.length); - int modifier = r.nextInt(MAX_INSERT_MODIFIER); + int modifier = r.nextInt(MAX_POSITION_MODIFIER); if (r.nextBoolean()) { modifier *= -1; } @@ -100,7 +98,7 @@ public VariableModification getModifiedCopy() { if (modifier <= 0) { modifier = 1; } - return new ByteArrayInsertModification(newValue, modifier); + return new ByteArrayInsertValueModification(newValue, modifier); } } @@ -123,7 +121,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final ByteArrayInsertModification other = (ByteArrayInsertModification) obj; + final ByteArrayInsertValueModification other = (ByteArrayInsertValueModification) obj; if (this.startPosition != other.startPosition) { return false; } 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 c87c5e55..f32e4153 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayModificationFactory.java @@ -22,13 +22,13 @@ public class ByteArrayModificationFactory { private enum ModificationType { - XOR, INSERT, DELETE, EXPLICIT, DUPLICATE, EXPLICIT_FROM_FILE, SHUFFLE + XOR, APPEND, INSERT, PREPEND, DELETE, EXPLICIT, DUPLICATE, EXPLICIT_FROM_FILE, SHUFFLE } private static final int MODIFICATION_COUNT = ModificationType.values().length; - private static final int MAX_CONFIG_PARAMETER = 200; + private static final int MAX_BYTE_ARRAY_LENGTH = 200; - private static final int EXPLICIT_VALUE_RANDOM = 1000; + private static final int MAX_FILE_ENTRIES = 1000; private static final int MODIFIED_ARRAY_LENGTH_ESTIMATION = 50; @@ -48,13 +48,23 @@ public static VariableModification xor(final byte[] xor, final int start /** * * * - * @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( + public static VariableModification insertValue( final byte[] bytesToInsert, final int startPosition) { - return new ByteArrayInsertModification(bytesToInsert, startPosition); + return new ByteArrayInsertValueModification(bytesToInsert, startPosition); + } + + public static VariableModification appendValue( + final byte[] bytesToAppend) { + return new ByteArrayAppendValueModification(bytesToAppend); + } + + public static VariableModification prependValue( + final byte[] bytesToPrepend) { + return new ByteArrayPrependValueModification(bytesToPrepend); } /** @@ -132,44 +142,40 @@ public static VariableModification createRandomModification(byte[] origi randomType = ModificationType.EXPLICIT; } } + modificationArrayLength = random.nextInt(MAX_BYTE_ARRAY_LENGTH - 1) + 1; switch (randomType) { case XOR: - modificationArrayLength = random.nextInt(modifiedArrayLength); - if (modificationArrayLength == 0) { - modificationArrayLength++; - } byte[] xor = new byte[modificationArrayLength]; random.nextBytes(xor); startPosition = random.nextInt(modifiedArrayLength - modificationArrayLength); return new ByteArrayXorModification(xor, startPosition); + case APPEND: + byte[] bytesToAppend = new byte[modificationArrayLength]; + random.nextBytes(bytesToAppend); + return new ByteArrayAppendValueModification(bytesToAppend); case INSERT: - modificationArrayLength = random.nextInt(MAX_CONFIG_PARAMETER); - if (modificationArrayLength == 0) { - modificationArrayLength++; - } byte[] bytesToInsert = new byte[modificationArrayLength]; random.nextBytes(bytesToInsert); - int insertPosition = random.nextInt(modifiedArrayLength); - return new ByteArrayInsertModification(bytesToInsert, insertPosition); + return new ByteArrayInsertValueModification(bytesToInsert, random.nextInt(modifiedArrayLength)); + case PREPEND: + byte[] bytesToPrepend = new byte[modificationArrayLength]; + random.nextBytes(bytesToPrepend); + return new ByteArrayPrependValueModification(bytesToPrepend); case DELETE: startPosition = random.nextInt(modifiedArrayLength - 1); int count = random.nextInt(modifiedArrayLength - startPosition); count++; return new ByteArrayDeleteModification(startPosition, count); case EXPLICIT: - modificationArrayLength = random.nextInt(MAX_CONFIG_PARAMETER); - if (modificationArrayLength == 0) { - modificationArrayLength++; - } byte[] explicitValue = new byte[modificationArrayLength]; random.nextBytes(explicitValue); return new ByteArrayExplicitValueModification(explicitValue); case DUPLICATE: return new ByteArrayDuplicateModification(); case EXPLICIT_FROM_FILE: - return explicitValueFromFile(random.nextInt(EXPLICIT_VALUE_RANDOM)); + return explicitValueFromFile(random.nextInt(MAX_FILE_ENTRIES)); case SHUFFLE: - int shuffleSize = random.nextInt(MAX_CONFIG_PARAMETER); + int shuffleSize = random.nextInt(MAX_BYTE_ARRAY_LENGTH); byte[] shuffle = new byte[shuffleSize]; random.nextBytes(shuffle); return new ByteArrayShuffleModification(shuffle); 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..f1bfc264 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java @@ -0,0 +1,91 @@ +/* + * 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 = {"bytesToPrepend", "modificationFilter"}) +@XmlAccessorType(XmlAccessType.FIELD) +public class ByteArrayPrependValueModification extends VariableModification { + + private static final int MAX_EXPLICIT_VALUE = 256; + + @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) + private byte[] bytesToPrepend; + + public ByteArrayPrependValueModification() {} + + public ByteArrayPrependValueModification(byte[] bytesToPrepend) { + this.bytesToPrepend = bytesToPrepend; + } + + @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 VariableModification getModifiedCopy() { + Random r = new Random(); + + int index = r.nextInt(bytesToPrepend.length); + byte[] newValue = Arrays.copyOf(bytesToPrepend, bytesToPrepend.length); + newValue[index] = (byte) r.nextInt(MAX_EXPLICIT_VALUE); + return new ByteArrayPrependValueModification(newValue); + } + + @Override + public int hashCode() { + int hash = 7; + hash = 87 * hash + Arrays.hashCode(this.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; + } + final ByteArrayPrependValueModification other = (ByteArrayPrependValueModification) obj; + return Arrays.equals(this.bytesToPrepend, other.bytesToPrepend); + } + + @Override + public String toString() { + return String.format("ByteArrayInsertModification{bytesToPrepend=%s}", + ArrayConverter.bytesToHexString(bytesToPrepend)); + } +} 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 1b4a9c44..a44ed33a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAddModification.java @@ -23,8 +23,8 @@ public class IntegerAddModification extends VariableModification { public IntegerAddModification() {} - public IntegerAddModification(Integer bi) { - this.summand = bi; + public IntegerAddModification(Integer summand) { + this.summand = summand; } @Override diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java new file mode 100644 index 00000000..067410f6 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java @@ -0,0 +1,73 @@ +/* + * 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 jakarta.xml.bind.annotation.XmlType; +import java.util.Objects; +import java.util.Random; + +@XmlRootElement +@XmlType(propOrder = {"appendValue", "modificationFilter"}) +public class IntegerAppendValueModification extends VariableModification { + + private static final int MAX_VALUE_MODIFIER = 256; + + private Integer appendValue; + + public IntegerAppendValueModification() {} + + public IntegerAppendValueModification(Integer appendValue) { + this.appendValue = appendValue; + } + + @Override + protected Integer modifyImplementationHook(Integer input) { + if (input == null) { + input = 0; + } + return (input << (Integer.SIZE - Integer.numberOfLeadingZeros((appendValue)))) + appendValue; + } + + public Integer getAppendValue() { + return appendValue; + } + + public void setAppendValue(Integer appendValue) { + this.appendValue = appendValue; + } + + @Override + public VariableModification getModifiedCopy() { + return new IntegerAppendValueModification( + appendValue + new Random().nextInt(MAX_VALUE_MODIFIER)); + } + + @Override + public int hashCode() { + int hash = 7; + hash = 38 * hash + Objects.hashCode(this.appendValue); + 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 IntegerAppendValueModification other = (IntegerAppendValueModification) obj; + return Objects.equals(this.appendValue, other.appendValue); + } +} 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 32affcac..0ad99c1a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueModification.java @@ -23,8 +23,8 @@ public class IntegerExplicitValueModification extends VariableModification { + + private static final int MAX_VALUE_MODIFIER = 256; + + private static final int MAX_POSITION_MODIFIER = 32; + + private Integer insertValue; + + private int startPosition; + + public IntegerInsertValueModification() {} + + public IntegerInsertValueModification(Integer insertValue, int startPosition) { + this.insertValue = insertValue; + this.startPosition = startPosition; + } + + @Override + protected Integer modifyImplementationHook(Integer input) { + if (input == null) { + input = 0; + } + int originalValueLength = Integer.SIZE - Integer.numberOfLeadingZeros((input)); + int insertValueLength = Integer.SIZE - Integer.numberOfLeadingZeros((insertValue)); + int insertPosition = startPosition; + if (startPosition > originalValueLength) { + insertPosition = originalValueLength; + } else if (startPosition < 0) { + insertPosition = 0; + } + int mask = ((1 << insertPosition) - 1); + + return (((input >> insertPosition) << insertValueLength) + insertValue) << insertPosition + (mask & input); + } + + public Integer getInsertValue() { + return insertValue; + } + + public void setInsertValue(Integer insertValue) { + this.insertValue = insertValue; + } + + public int getStartPosition() { + return startPosition; + } + + public void setStartPosition(int startPosition) { + this.startPosition = startPosition; + } + + @Override + public VariableModification getModifiedCopy() { + Random r = new Random(); + + if (r.nextBoolean()) { + return new IntegerInsertValueModification( + insertValue + r.nextInt(MAX_VALUE_MODIFIER), startPosition); + } else { + int modifier = r.nextInt(MAX_POSITION_MODIFIER); + if (r.nextBoolean()) { + modifier *= -1; + } + modifier = startPosition + modifier; + if (modifier <= 0) { + modifier = 1; + } + return new IntegerInsertValueModification(insertValue, modifier); + } + } + + @Override + public int hashCode() { + int hash = 7; + hash = 37 * hash + Objects.hashCode(this.insertValue); + hash = 37 * 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 IntegerInsertValueModification other = (IntegerInsertValueModification) obj; + if (this.startPosition != other.startPosition) { + return false; + } + return Objects.equals(this.insertValue, other.insertValue); + } +} 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 7b65d624..dd596e93 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerModificationFactory.java @@ -21,14 +21,33 @@ public class IntegerModificationFactory { private enum ModificationType { - ADD, SUBTRACT, XOR, EXPLICIT, SHIFT_LEFT, SHIFT_RIGHT, EXPLICIT_FROM_FILE + ADD, + SUBTRACT, + MULTIPLY, + XOR, + EXPLICIT, + SHIFT_LEFT, + SHIFT_RIGHT, + EXPLICIT_FROM_FILE, + APPEND, + INSERT, + PREPEND } + private static final int MODIFICATION_COUNT = ModificationType.values().length; private static final int MAX_MODIFICATION_VALUE = 32000; + private static final int MAX_FILE_ENTRIES = 200; + private static final int MAX_MODIFICATION_SHIFT_VALUE = 20; + private static final int MAX_MODIFICATION_MULTIPLY_VALUE = 256; + + private static final int MAX_MODIFICATION_INSERT_VALUE = 256; + + private static final int MAX_MODIFICATION_INSERT_POSITION_VALUE = 32; + private static List> modificationsFromFile; public static final String FILE_NAME = "de/rub/nds/modifiablevariable/explicit/integer.vec"; @@ -87,6 +106,23 @@ public static VariableModification explicitValueFromFile(int value) { return modifications.get(pos); } + public static VariableModification appendValue(final Integer value) { + return new IntegerAppendValueModification(value); + } + + public static VariableModification insertValue( + final Integer value, final int position) { + return new IntegerInsertValueModification(value, position); + } + + public static VariableModification prependValue(final Integer value) { + return new IntegerPrependValueModification(value); + } + + public static VariableModification multiply(final Integer value) { + return new IntegerMultiplyModification(value); + } + public static synchronized List> modificationsFromFile() { try { if (modificationsFromFile == null) { @@ -111,12 +147,16 @@ public static VariableModification createRandomModification() { Random random = RandomHelper.getRandom(); ModificationType randomType = ModificationType.values()[random.nextInt(MODIFICATION_COUNT)]; int modification = random.nextInt(MAX_MODIFICATION_VALUE); + int insert_modification = random.nextInt(MAX_MODIFICATION_INSERT_VALUE); int shiftModification = random.nextInt(MAX_MODIFICATION_SHIFT_VALUE); switch (randomType) { case ADD: return new IntegerAddModification(modification); case SUBTRACT: return new IntegerSubtractModification(modification); + case MULTIPLY: + return new IntegerSubtractModification( + random.nextInt(MAX_MODIFICATION_MULTIPLY_VALUE)); case XOR: return new IntegerXorModification(modification); case EXPLICIT: @@ -126,7 +166,15 @@ public static VariableModification createRandomModification() { case SHIFT_RIGHT: return new IntegerShiftRightModification(shiftModification); case EXPLICIT_FROM_FILE: - return explicitValueFromFile(random.nextInt(MAX_MODIFICATION_VALUE)); + return explicitValueFromFile(random.nextInt(MAX_FILE_ENTRIES)); + case APPEND: + return new IntegerAppendValueModification(insert_modification); + case INSERT: + return new IntegerInsertValueModification( + insert_modification, + random.nextInt(MAX_MODIFICATION_INSERT_POSITION_VALUE)); + case PREPEND: + return new IntegerPrependValueModification(insert_modification); default: throw new IllegalStateException("Unexpected modification type: " + randomType); } 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..431b97af --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java @@ -0,0 +1,72 @@ +/* + * 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 jakarta.xml.bind.annotation.XmlType; +import java.util.Objects; +import java.util.Random; + +@XmlRootElement +@XmlType(propOrder = {"factor", "modificationFilter"}) +public class IntegerMultiplyModification extends VariableModification { + + private static final int MAX_FACTOR_MODIFIER = 256; + + private Integer factor; + + public IntegerMultiplyModification() {} + + public IntegerMultiplyModification(Integer factor) { + this.factor = factor; + } + + @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 VariableModification getModifiedCopy() { + Random r = new Random(); + + return new IntegerMultiplyModification( + factor + r.nextInt(MAX_FACTOR_MODIFIER)); + } + + @Override + public int hashCode() { + int hash = 7; + hash = 40 * hash + Objects.hashCode(this.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; + } + final IntegerMultiplyModification other = (IntegerMultiplyModification) obj; + return Objects.equals(this.factor, other.factor); + } +} diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java new file mode 100644 index 00000000..10612063 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java @@ -0,0 +1,74 @@ +/* + * 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 jakarta.xml.bind.annotation.XmlType; +import java.util.Objects; +import java.util.Random; + +@XmlRootElement +@XmlType(propOrder = {"prependValue", "modificationFilter"}) +public class IntegerPrependValueModification extends VariableModification { + + private static final int MAX_VALUE_MODIFIER = 256; + + private Integer prependValue; + + public IntegerPrependValueModification() {} + + public IntegerPrependValueModification(Integer prependValue) { + this.prependValue = prependValue; + } + + @Override + protected Integer modifyImplementationHook(Integer input) { + if (input == null) { + input = 0; + } + + return (prependValue << (Integer.SIZE - Integer.numberOfLeadingZeros((input)))) + input; + } + + public Integer getPrependValue() { + return prependValue; + } + + public void setPrependValue(Integer prependValue) { + this.prependValue = prependValue; + } + + @Override + public VariableModification getModifiedCopy() { + return new IntegerPrependValueModification( + prependValue + new Random().nextInt(MAX_VALUE_MODIFIER)); + } + + @Override + public int hashCode() { + int hash = 7; + hash = 39 * hash + Objects.hashCode(this.prependValue); + 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 IntegerPrependValueModification other = (IntegerPrependValueModification) obj; + return Objects.equals(this.prependValue, other.prependValue); + } +} 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 31332f5b..b422e87e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftLeftModification.java @@ -28,7 +28,7 @@ public IntegerShiftLeftModification(int shift) { @Override protected Integer modifyImplementationHook(Integer input) { - return (input == null) ? 0 : input << shift; + return (input == null) ? 0 : input << shift % MAX_SHIFT_MODIFIER; } public int getShift() { 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 4d0467fa..fb503ec5 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftRightModification.java @@ -28,7 +28,7 @@ public IntegerShiftRightModification(int shift) { @Override protected Integer modifyImplementationHook(final Integer input) { - return (input == null) ? 0 : input >> shift; + return (input == null) ? 0 : input >> shift % MAX_SHIFT_MODIFIER; } public int getShift() { 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 0d23a33b..b71c9cea 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSubtractModification.java @@ -23,8 +23,8 @@ public class IntegerSubtractModification extends VariableModification { public IntegerSubtractModification() {} - public IntegerSubtractModification(Integer bi) { - this.subtrahend = bi; + public IntegerSubtractModification(Integer subtrahend) { + this.subtrahend = subtrahend; } @Override 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 07338a89..7931f109 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerXorModification.java @@ -23,8 +23,8 @@ public class IntegerXorModification extends VariableModification { public IntegerXorModification() {} - public IntegerXorModification(Integer bi) { - this.xor = bi; + public IntegerXorModification(Integer xor) { + this.xor = xor; } @Override 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 afde2330..781d17c3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java @@ -23,8 +23,8 @@ public class LongAddModification extends VariableModification { public LongAddModification() {} - public LongAddModification(Long bi) { - this.summand = bi; + public LongAddModification(Long summand) { + this.summand = summand; } @Override diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java new file mode 100644 index 00000000..cf163e93 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java @@ -0,0 +1,72 @@ +/* + * 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 jakarta.xml.bind.annotation.XmlType; +import java.util.Objects; +import java.util.Random; + +@XmlRootElement +@XmlType(propOrder = {"appendValue", "modificationFilter"}) +public class LongAppendValueModification extends VariableModification { + + private static final int MAX_VALUE_MODIFIER = 256; + + private Long appendValue; + + public LongAppendValueModification() {} + + public LongAppendValueModification(Long appendValue) { + this.appendValue = appendValue; + } + + @Override + protected Long modifyImplementationHook(Long input) { + if (input == null) { + input = 0L; + } + return (input << (Long.SIZE - Long.numberOfLeadingZeros((appendValue)))) + appendValue; + } + + public Long getAppendValue() { + return appendValue; + } + + public void setAppendValue(Long appendValue) { + this.appendValue = appendValue; + } + + @Override + public VariableModification getModifiedCopy() { + return new LongAppendValueModification(appendValue + new Random().nextInt(MAX_VALUE_MODIFIER)); + } + + @Override + public int hashCode() { + int hash = 7; + hash = 45 * hash + Objects.hashCode(this.appendValue); + 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 LongAppendValueModification other = (LongAppendValueModification) obj; + return Objects.equals(this.appendValue, other.appendValue); + } +} 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 b7422adf..765476b8 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java @@ -23,8 +23,8 @@ public class LongExplicitValueModification extends VariableModification { public LongExplicitValueModification() {} - public LongExplicitValueModification(Long bi) { - this.explicitValue = bi; + public LongExplicitValueModification(Long explicitValue) { + this.explicitValue = explicitValue; } @Override diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java new file mode 100644 index 00000000..524f6613 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java @@ -0,0 +1,113 @@ +/* + * 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 de.rub.nds.modifiablevariable.integer.IntegerInsertValueModification; +import jakarta.xml.bind.annotation.XmlRootElement; +import jakarta.xml.bind.annotation.XmlType; +import java.util.Objects; +import java.util.Random; + +@XmlRootElement +@XmlType(propOrder = {"insertValue", "startPosition", "modificationFilter"}) +public class LongInsertValueModification extends VariableModification { + + private static final int MAX_VALUE_MODIFIER = 256; + private static final int MAX_POSITION_MODIFIER = 32; + + private Long insertValue; + private int startPosition; + + public LongInsertValueModification() {} + + public LongInsertValueModification(Long insertValue, int startPosition) { + this.insertValue = insertValue; + this.startPosition = startPosition; + } + + @Override + protected Long modifyImplementationHook(Long input) { + if (input == null) { + input = 0L; + } + int originalValueLength = Long.SIZE - Long.numberOfLeadingZeros((input)); + int insertValueLength = Long.SIZE - Long.numberOfLeadingZeros((insertValue)); + int insertPosition = startPosition; + if (startPosition > originalValueLength) { + insertPosition = originalValueLength; + } else if (startPosition < 0) { + insertPosition = 0; + } + long mask = ((1L << insertPosition) - 1); + + return (((input >> insertPosition) << insertValueLength) + insertValue) << insertPosition + (mask & input); + } + + public Long getInsertValue() { + return insertValue; + } + + public void setInsertValue(Long insertValue) { + this.insertValue = insertValue; + } + + public int getStartPosition() { + return startPosition; + } + + public void setStartPosition(int startPosition) { + this.startPosition = startPosition; + } + + @Override + public VariableModification getModifiedCopy() { + Random r = new Random(); + + if (r.nextBoolean()) { + return new LongInsertValueModification( + insertValue + r.nextInt(MAX_VALUE_MODIFIER), startPosition); + } else { + int modifier = r.nextInt(MAX_POSITION_MODIFIER); + if (r.nextBoolean()) { + modifier *= -1; + } + modifier = startPosition + modifier; + if (modifier <= 0) { + modifier = 1; + } + return new LongInsertValueModification(insertValue, modifier); + } + } + + @Override + public int hashCode() { + int hash = 7; + hash = 47 * hash + Objects.hashCode(this.insertValue); + hash = 47 * hash + Objects.hashCode(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 LongInsertValueModification other = (LongInsertValueModification) obj; + if (this.startPosition != other.startPosition) { + return false; + } + return Objects.equals(this.insertValue, other.insertValue); + } +} 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 ca97a66a..afc6322c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongModificationFactory.java @@ -22,14 +22,31 @@ public class LongModificationFactory { private enum ModificationType { - ADD, SUBTRACT, XOR, EXPLICIT, EXPLICIT_FROM_FILE + ADD, SUBTRACT, MULTIPLY, XOR, EXPLICIT, + SHIFT_LEFT, + SHIFT_RIGHT, EXPLICIT_FROM_FILE, + APPEND, + INSERT, + PREPEND } private static final int MODIFICATION_COUNT = ModificationType.values().length; private static final int MAX_MODIFICATION_VALUE = 32000; + private static final int MAX_FILE_ENTRIES = 200; + + private static final int MAX_MODIFICATION_SHIFT_VALUE = 40; + + private static final int MAX_MODIFICATION_MULTIPLY_VALUE = 256; + + private static final int MAX_MODIFICATION_INSERT_VALUE = 256; + + private static final int MAX_MODIFICATION_INSERT_POSITION_VALUE = 64; + private static List> modificationsFromFile; + public static final String FILE_NAME = "de/rub/nds/modifiablevariable/explicit/long.vec"; + public static LongAddModification add(final String summand) { return add(Long.parseLong(summand)); } @@ -68,13 +85,38 @@ public static VariableModification explicitValueFromFile(int value) { return modifications.get(pos); } + public static VariableModification appendValue(final Long value) { + return new LongAppendValueModification(value); + } + + public static VariableModification insertValue(final Long value, final int position) { + return new LongInsertValueModification(value, position); + } + + public static VariableModification prependValue(final Long value) { + return new LongPrependValueModification(value); + } + + public static VariableModification multiply(final Long factor) { + return new LongMultiplyModification(factor); + } + + public static VariableModification shiftLeft(final int shift) { + return new LongShiftLeftModification(shift); + } + + public static VariableModification shiftRight(final int shift) { + return new LongShiftRightModification(shift); + } + + public static synchronized List> modificationsFromFile() { try { if (modificationsFromFile == null) { modificationsFromFile = new LinkedList<>(); ClassLoader classLoader = IntegerModificationFactory.class.getClassLoader(); InputStream is = - classLoader.getResourceAsStream(IntegerModificationFactory.FILE_NAME); + classLoader.getResourceAsStream(FILE_NAME); BufferedReader br = new BufferedReader(new InputStreamReader(is)); String line; while ((line = br.readLine()) != null) { @@ -93,17 +135,31 @@ public static VariableModification createRandomModification() { Random random = RandomHelper.getRandom(); ModificationType randomType = ModificationType.values()[random.nextInt(MODIFICATION_COUNT)]; long modification = random.nextInt(MAX_MODIFICATION_VALUE); + long insert_modification = random.nextInt( MAX_MODIFICATION_INSERT_VALUE); + int shiftModification = random.nextInt(MAX_MODIFICATION_SHIFT_VALUE); switch (randomType) { case ADD: return new LongAddModification(modification); case SUBTRACT: return new LongSubtractModification(modification); + case MULTIPLY: + return new LongMultiplyModification((long)random.nextInt(MAX_MODIFICATION_MULTIPLY_VALUE)); case XOR: return new LongXorModification(modification); case EXPLICIT: return new LongExplicitValueModification(modification); + case SHIFT_LEFT: + return new LongShiftLeftModification(shiftModification); + case SHIFT_RIGHT: + return new LongShiftRightModification(shiftModification); case EXPLICIT_FROM_FILE: - return explicitValueFromFile(random.nextInt(MAX_MODIFICATION_VALUE)); + return explicitValueFromFile(random.nextInt(MAX_FILE_ENTRIES)); + case APPEND: + return new LongAppendValueModification(insert_modification); + case INSERT: + return new LongInsertValueModification(insert_modification, random.nextInt(MAX_MODIFICATION_INSERT_POSITION_VALUE)); + case PREPEND: + return new LongPrependValueModification(insert_modification); default: throw new IllegalStateException("Unexpected modification type: " + randomType); } 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..1c9388ed --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java @@ -0,0 +1,69 @@ +/* + * 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 jakarta.xml.bind.annotation.XmlType; +import java.util.Objects; +import java.util.Random; + +@XmlRootElement +@XmlType(propOrder = {"factor", "modificationFilter"}) +public class LongMultiplyModification extends VariableModification { + + private static final int MAX_FACTOR_MODIFIER = 256; + + private Long factor; + + public LongMultiplyModification() {} + + public LongMultiplyModification(Long factor) { + this.factor = factor; + } + + @Override + protected Long modifyImplementationHook(final Long input) { + return (input == null) ? 0L : input * factor; + } + + public Long getFactor() { + return factor; + } + + public void setFactor(Long factor) { + this.factor = factor; + } + + @Override + public VariableModification getModifiedCopy() { + return new LongMultiplyModification(factor + new Random().nextInt(MAX_FACTOR_MODIFIER)); + } + + @Override + public int hashCode() { + int hash = 7; + hash = 48 * hash + Objects.hashCode(this.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; + } + final LongMultiplyModification other = (LongMultiplyModification) obj; + return Objects.equals(this.factor, other.factor); + } +} diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java new file mode 100644 index 00000000..1d035dc9 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java @@ -0,0 +1,72 @@ +/* + * 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 jakarta.xml.bind.annotation.XmlType; +import java.util.Objects; +import java.util.Random; + +@XmlRootElement +@XmlType(propOrder = {"prependValue", "modificationFilter"}) +public class LongPrependValueModification extends VariableModification { + + private static final int MAX_VALUE_MODIFIER = 256; + + private Long prependValue; + + public LongPrependValueModification() {} + + public LongPrependValueModification(Long prependValue) { + this.prependValue = prependValue; + } + + @Override + protected Long modifyImplementationHook(Long input) { + if (input == null) { + input = 0L; + } + return (prependValue << (Long.SIZE - Long.numberOfLeadingZeros((input)))) + input; + } + + public Long getPrependValue() { + return prependValue; + } + + public void setPrependValue(Long prependValue) { + this.prependValue = prependValue; + } + + @Override + public VariableModification getModifiedCopy() { + return new LongPrependValueModification(prependValue + new Random().nextInt(MAX_VALUE_MODIFIER)); + } + + @Override + public int hashCode() { + int hash = 7; + hash = 46 * hash + Objects.hashCode(this.prependValue); + 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 LongPrependValueModification other = (LongPrependValueModification) obj; + return Objects.equals(this.prependValue, other.prependValue); + } +} 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..2cb69884 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java @@ -0,0 +1,82 @@ +/* + * 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 jakarta.xml.bind.annotation.XmlType; +import java.util.Objects; +import java.util.Random; + +@XmlRootElement +@XmlType(propOrder = {"shift", "modificationFilter"}) +public class LongShiftLeftModification extends VariableModification { + + private static final int MAX_SHIFT_MODIFIER = 64; + + private int shift; + + public LongShiftLeftModification() {} + + public LongShiftLeftModification(int shift) { + this.shift = shift; + } + + @Override + protected Long modifyImplementationHook(final 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 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 LongShiftLeftModification(newShift); + } + + @Override + public int hashCode() { + int hash = 7; + hash = 49 * hash + Objects.hashCode(this.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; + } + final LongShiftLeftModification other = (LongShiftLeftModification) obj; + return Objects.equals(this.shift, other.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..1b2b9a08 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java @@ -0,0 +1,82 @@ +/* + * 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 jakarta.xml.bind.annotation.XmlType; +import java.util.Objects; +import java.util.Random; + +@XmlRootElement +@XmlType(propOrder = {"shift", "modificationFilter"}) +public class LongShiftRightModification extends VariableModification { + + private static final int MAX_SHIFT_MODIFIER = 64; + + private int shift; + + public LongShiftRightModification() {} + + public LongShiftRightModification(int shift) { + this.shift = shift; + } + + @Override + protected Long modifyImplementationHook(final 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 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 LongShiftRightModification(newShift); + } + + @Override + public int hashCode() { + int hash = 7; + hash = 50 * hash + Objects.hashCode(this.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; + } + final LongShiftRightModification other = (LongShiftRightModification) obj; + return Objects.equals(this.shift, other.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 7b554e0d..6c617018 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java @@ -23,8 +23,8 @@ public class LongSubtractModification extends VariableModification { public LongSubtractModification() {} - public LongSubtractModification(Long bi) { - this.subtrahend = bi; + public LongSubtractModification(Long subtrahend) { + this.subtrahend = subtrahend; } @Override 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 fd73e4d2..0cc8b3ba 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java @@ -23,8 +23,8 @@ public class LongXorModification extends VariableModification { public LongXorModification() {} - public LongXorModification(Long bi) { - this.xor = bi; + public LongXorModification(Long xor) { + this.xor = xor; } @Override @@ -44,9 +44,9 @@ public void setXor(Long xor) { public VariableModification getModifiedCopy() { Random r = new Random(); if (r.nextBoolean()) { - return new LongXorModification(xor + new Random().nextInt(MAX_XOR_MODIFIER)); + return new LongXorModification(xor + r.nextInt(MAX_XOR_MODIFIER)); } else { - return new LongXorModification(xor - new Random().nextInt(MAX_XOR_MODIFIER)); + return new LongXorModification(xor - r.nextInt(MAX_XOR_MODIFIER)); } } 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..05dd42a9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java @@ -30,7 +30,7 @@ public ModifiableString() {} @Override protected void createRandomModification() { - VariableModification vm = StringModificationFactory.createRandomModification(); + VariableModification vm = StringModificationFactory.createRandomModification(null); setModification(vm); } 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 d87dd421..e261f2c8 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/Modifiable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/Modifiable.java @@ -77,10 +77,47 @@ private static ModifiableString getModifiableStringWithModification( return modifiableString; } + public static ModifiableBigInteger prepend(BigInteger i) { + return getModifiableBigIntegerWithModification( + BigIntegerModificationFactory.prependValue(i)); + } + + public static ModifiableByteArray prepend(byte[] b) { + return getModifiableByteArrayWithModification( + ByteArrayModificationFactory.prependValue(b)); + } + + public static ModifiableInteger prepend(Integer i) { + return getModifiableIntegerWithModification(IntegerModificationFactory.prependValue(i)); + } + + public static ModifiableLong prepend(Long l) { + return getModifiableLongWithModification(LongModificationFactory.prependValue(l)); + } + public static ModifiableString prepend(final String s) { return getModifiableStringWithModification(StringModificationFactory.prependValue(s)); } + + public static ModifiableBigInteger append(BigInteger i) { + return getModifiableBigIntegerWithModification( + BigIntegerModificationFactory.appendValue(i)); + } + + public static ModifiableByteArray append(byte[] b) { + return getModifiableByteArrayWithModification( + ByteArrayModificationFactory.appendValue(b)); + } + + public static ModifiableInteger append(Integer i) { + return getModifiableIntegerWithModification(IntegerModificationFactory.appendValue(i)); + } + + public static ModifiableLong append(Long l) { + return getModifiableLongWithModification(LongModificationFactory.appendValue(l)); + } + public static ModifiableString append(final String s) { return getModifiableStringWithModification(StringModificationFactory.appendValue(s)); } @@ -114,6 +151,26 @@ public static ModifiableBoolean explicit(Boolean b) { public static ModifiableString explicit(String s) { return getModifiableStringWithModification(StringModificationFactory.explicitValue(s)); } + + + public static ModifiableBigInteger insert(BigInteger i, int position) { + return getModifiableBigIntegerWithModification( + BigIntegerModificationFactory.insertValue(i, position)); + } + + public static ModifiableByteArray insert(byte[] b, int position) { + return getModifiableByteArrayWithModification( + ByteArrayModificationFactory.insertValue(b, position)); + } + + public static ModifiableInteger insert(Integer i, int position) { + return getModifiableIntegerWithModification(IntegerModificationFactory.insertValue(i, position)); + } + + public static ModifiableLong insert(Long l, int position) { + return getModifiableLongWithModification(LongModificationFactory.insertValue(l, position)); + } + public static ModifiableString insert(String s, int position) { return getModifiableStringWithModification(StringModificationFactory.insertValue(s, position)); } @@ -172,10 +229,6 @@ public static ModifiableLong sub(Long l) { return getModifiableLongWithModification(LongModificationFactory.sub(l)); } - public static ModifiableByteArray insert(byte[] b, int position) { - return getModifiableByteArrayWithModification( - ByteArrayModificationFactory.insert(b, position)); - } public static ModifiableByteArray delete(int startPosition, int count) { return getModifiableByteArrayWithModification( @@ -203,6 +256,10 @@ public static ModifiableInteger shiftLeft(Integer i) { return getModifiableIntegerWithModification(IntegerModificationFactory.shiftLeft(i)); } + public static ModifiableLong shiftLeftLong(Integer i) { + return getModifiableLongWithModification(LongModificationFactory.shiftLeft(i)); + } + public static ModifiableBigInteger shiftRightBigInteger(Integer i) { return getModifiableBigIntegerWithModification(BigIntegerModificationFactory.shiftRight(i)); } @@ -211,7 +268,20 @@ public static ModifiableBigInteger multiplyBigInteger(BigInteger i) { return getModifiableBigIntegerWithModification(BigIntegerModificationFactory.multiply(i)); } + + public static ModifiableInteger multiply(Integer i) { + return getModifiableIntegerWithModification(IntegerModificationFactory.multiply(i)); + } + + public static ModifiableLong multiply(Long l) { + return getModifiableLongWithModification(LongModificationFactory.multiply(l)); + } + public static ModifiableInteger shiftRight(Integer i) { return getModifiableIntegerWithModification(IntegerModificationFactory.shiftRight(i)); } + + public static ModifiableLong shiftRightLong(Integer i) { + return getModifiableLongWithModification(LongModificationFactory.shiftRight(i)); + } } diff --git a/src/main/resources/de/rub/nds/modifiablevariable/explicit/long.vec b/src/main/resources/de/rub/nds/modifiablevariable/explicit/long.vec new file mode 100644 index 00000000..da14a614 --- /dev/null +++ b/src/main/resources/de/rub/nds/modifiablevariable/explicit/long.vec @@ -0,0 +1,31 @@ +-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 */ +-9223372036854775808 /* Overflow signed 64-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 */ +9223372036854775807 /* Overflow signed 64-bit when incremented */ +4294967295 /* Overflow unsig 32-bit when incremented */ +4294967296 /* Overflow unsig 32-bit */ \ No newline at end of file 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..00961cf7 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArrayTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArrayTest.java @@ -123,7 +123,7 @@ public void testPrependBytes() { } VariableModification modifier = - ByteArrayModificationFactory.insert(modification1, 0); + ByteArrayModificationFactory.insertValue(modification1, 0); start.setModification(modifier); LOGGER.debug("Expected: {}", expResult); @@ -146,7 +146,7 @@ public void testAppendBytes() { } VariableModification modifier = - ByteArrayModificationFactory.insert(modification1, originalValue.length); + ByteArrayModificationFactory.insertValue(modification1, originalValue.length); start.setModification(modifier); LOGGER.debug("Expected: {}", expResult); @@ -246,21 +246,21 @@ public void testInsertBytes() { assumeTrue(modification1.length < originalValue.length); LOGGER.debug("Inserting negative Position"); VariableModification modifier = - ByteArrayModificationFactory.insert(modification1, -2 * originalValue.length); + ByteArrayModificationFactory.insertValue(modification1, -2 * originalValue.length); start.setModification(modifier); assertArrayEquals(start.getValue(), originalValue); start = new ModifiableByteArray(); start.setOriginalValue(originalValue); LOGGER.debug("Inserting empty Array"); byte[] emptyArray = new byte[0]; - modifier = ByteArrayModificationFactory.insert(emptyArray, 0); + modifier = ByteArrayModificationFactory.insertValue(emptyArray, 0); start.setModification(modifier); assertArrayEquals(originalValue, start.getValue()); start = new ModifiableByteArray(); start.setOriginalValue(originalValue); LOGGER.debug("Inserting to big Start position"); - modifier = ByteArrayModificationFactory.insert(modification1, originalValue.length * 2); + modifier = ByteArrayModificationFactory.insertValue(modification1, originalValue.length * 2); start.setModification(modifier); assertArrayEquals(originalValue, start.getValue()); } 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..9aeba5c7 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/serialization/ByteArraySerializationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/serialization/ByteArraySerializationTest.java @@ -54,7 +54,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); @@ -81,7 +81,7 @@ public void testSerializeDeserializeSimple() throws Exception { @Test public void testSerializeDeserializeWithModification() throws Exception { VariableModification modifier = - ByteArrayModificationFactory.insert(new byte[] {1, 2}, 0); + ByteArrayModificationFactory.insertValue(new byte[] {1, 2}, 0); start.setModification(modifier); m.marshal(start, writer); From 413d6d4185d63cde4847131b80e52b043a5a8fc6 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Thu, 21 Nov 2024 10:04:59 +0100 Subject: [PATCH 11/82] fix tests --- .../bytearray/ByteArrayInsertValueModification.java | 5 +---- .../string/StringInsertValueModification.java | 2 +- .../biginteger/BigIntegerModificationTest.java | 2 +- .../bytearray/ModifiableByteArrayTest.java | 9 ++++++--- .../modifiablevariable/mlong/LongModificationTest.java | 2 +- 5 files changed, 10 insertions(+), 10 deletions(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java index 2a871621..77b8ece8 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java @@ -47,10 +47,7 @@ protected byte[] modifyImplementationHook(byte[] input) { int start = startPosition; if (start < 0) { - start += input.length; - if (start < 0) { - start = 0; - } + start = 0; } if (start > input.length) { start = input.length; diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java index 8fae6a1b..aae65f18 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java @@ -18,7 +18,7 @@ /** Modification that appends a string to the original value. */ @XmlRootElement -@XmlType(propOrder = {"insertValue", "modificationFilter"}) +@XmlType(propOrder = {"insertValue", "startPosition", "modificationFilter"}) public class StringInsertValueModification extends VariableModification { private static final int MAX_EXPLICIT_VALUE = 256; 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..d712e84b 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationTest.java @@ -131,7 +131,7 @@ public void testExplicitValueFromFile() { result = start.getValue(); assertEquals(expectedResult, result); - modifier = BigIntegerModificationFactory.explicitValueFromFile(26); + modifier = BigIntegerModificationFactory.explicitValueFromFile(27); start.setModification(modifier); expectedResult = BigInteger.valueOf(2147483647); result = start.getValue(); 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 00961cf7..738ca473 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArrayTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArrayTest.java @@ -242,13 +242,14 @@ public void testDeleteBytes() { @Test public void testInsertBytes() { LOGGER.info("testInsertBytes"); - // Insert negative position, insert 0 bytes, insert too far + // Insert at too negative position, prepend bytes assumeTrue(modification1.length < originalValue.length); LOGGER.debug("Inserting negative Position"); VariableModification modifier = ByteArrayModificationFactory.insertValue(modification1, -2 * originalValue.length); start.setModification(modifier); - assertArrayEquals(start.getValue(), originalValue); + byte[] expResult = ArrayConverter.concatenate(modification1, originalValue); + assertArrayEquals(start.getValue(), expResult); start = new ModifiableByteArray(); start.setOriginalValue(originalValue); LOGGER.debug("Inserting empty Array"); @@ -257,12 +258,14 @@ public void testInsertBytes() { start.setModification(modifier); assertArrayEquals(originalValue, start.getValue()); + // Insert at too positive position, append bytes start = new ModifiableByteArray(); start.setOriginalValue(originalValue); LOGGER.debug("Inserting to big Start position"); modifier = ByteArrayModificationFactory.insertValue(modification1, originalValue.length * 2); start.setModification(modifier); - assertArrayEquals(originalValue, start.getValue()); + expResult = ArrayConverter.concatenate(originalValue, modification1); + assertArrayEquals(expResult, start.getValue()); } /** Test of add method, of class BigIntegerModificationFactory. */ 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..1a9fe96c 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/mlong/LongModificationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/mlong/LongModificationTest.java @@ -86,7 +86,7 @@ public void testExplicitValueFromFile() { result = start.getValue(); assertEquals(expectedResult, result); - modifier = LongModificationFactory.explicitValueFromFile(26); + modifier = LongModificationFactory.explicitValueFromFile(27); start.setModification(modifier); expectedResult = 2147483647L; result = start.getValue(); From ca69bbf15841061ba7a1225d67118a33d6c2bd85 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Thu, 21 Nov 2024 11:11:58 +0100 Subject: [PATCH 12/82] Change the Insert Prepend and Append Modifications of Integer, BigInteger and Long, so that they actually make sense. Before the calculations where copied form SSH-Fuzzer, but they do not really produce values that makes any sense. Because the values were shifted and then a new value were added, but adding a value to a binary integer, does not produce the expected insertion. Now we insert the values bitwise, I see a use-case for this. e.g. in mask fields. Also let the insert position wrap around in all insert modifications. For int and long it wraps around the bit size. --- .../BigIntegerAppendValueModification.java | 2 +- .../BigIntegerInsertValueModification.java | 16 +++++++------- .../BigIntegerPrependValueModification.java | 2 +- .../ByteArrayInsertValueModification.java | 17 +++++++-------- .../IntegerAppendValueModification.java | 2 +- .../IntegerInsertValueModification.java | 21 +++++++++---------- .../IntegerPrependValueModification.java | 2 +- .../longint/LongAppendValueModification.java | 2 +- .../longint/LongInsertValueModification.java | 15 ++++++------- .../longint/LongPrependValueModification.java | 2 +- .../string/StringInsertValueModification.java | 17 +++++---------- .../bytearray/ModifiableByteArrayTest.java | 13 ++++++------ .../integer/IntegerModificationTest.java | 12 +++++++++++ 13 files changed, 65 insertions(+), 58 deletions(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java index 5b1c385c..36886acc 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java @@ -36,7 +36,7 @@ protected BigInteger modifyImplementationHook(BigInteger input) { if (input == null) { input = BigInteger.ZERO; } - return input.shiftLeft(appendValue.bitLength()).add(appendValue); + return input.shiftLeft(appendValue.bitLength()).or(appendValue); } public BigInteger getAppendValue() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java index 9fa713b7..9065dda5 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java @@ -39,21 +39,23 @@ protected BigInteger modifyImplementationHook(BigInteger input) { if (input == null) { input = BigInteger.ZERO; } + int originalValueLength = input.bitLength(); int insertValueLength = insertValue.bitLength(); - int insertPosition = startPosition; - if (startPosition > originalValueLength) { - insertPosition = originalValueLength; - } else if (startPosition < 0) { - insertPosition = 0; + + // Wrap around and also allow to insert at the end of the original value + int insertPosition = startPosition % (originalValueLength + 1); + if (startPosition < 0) { + insertPosition += originalValueLength; } + BigInteger mask = BigInteger.valueOf((1L << insertPosition) - 1); return input.shiftRight(insertPosition) .shiftLeft(insertValueLength) - .and(insertValue) + .or(insertValue) .shiftLeft(insertPosition) - .add(mask.and(input)); + .or(mask.and(input)); } public BigInteger getInsertValue() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java index 92f7f772..24d75d32 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java @@ -36,7 +36,7 @@ protected BigInteger modifyImplementationHook(BigInteger input) { if (input == null) { input = BigInteger.ZERO; } - return prependValue.shiftLeft(input.bitLength()).add(input); + return prependValue.shiftLeft(input.bitLength()).or(input); } public BigInteger getPrependValue() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java index 77b8ece8..7117b16b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java @@ -45,17 +45,16 @@ protected byte[] modifyImplementationHook(byte[] input) { input = new byte[0]; } - int start = startPosition; - if (start < 0) { - start = 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; } - if (start > input.length) { - start = input.length; - } - byte[] ret1 = Arrays.copyOf(input, start); + + byte[] ret1 = Arrays.copyOf(input, insertPosition); byte[] ret3 = null; - if (start < input.length) { - ret3 = Arrays.copyOfRange(input, start, input.length); + if (insertPosition < input.length) { + ret3 = Arrays.copyOfRange(input, insertPosition, input.length); } return ArrayConverter.concatenate(ret1, bytesToInsert, ret3); } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java index 067410f6..9448b597 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java @@ -32,7 +32,7 @@ protected Integer modifyImplementationHook(Integer input) { if (input == null) { input = 0; } - return (input << (Integer.SIZE - Integer.numberOfLeadingZeros((appendValue)))) + appendValue; + return (input << (Integer.SIZE - Integer.numberOfLeadingZeros((appendValue)))) | appendValue; } public Integer getAppendValue() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java index ca513613..7c6ab01b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java @@ -8,11 +8,8 @@ package de.rub.nds.modifiablevariable.integer; import de.rub.nds.modifiablevariable.VariableModification; -import de.rub.nds.modifiablevariable.bytearray.ByteArrayInsertValueModification; import jakarta.xml.bind.annotation.XmlRootElement; import jakarta.xml.bind.annotation.XmlType; -import java.math.BigInteger; -import java.util.Arrays; import java.util.Objects; import java.util.Random; @@ -40,17 +37,19 @@ protected Integer modifyImplementationHook(Integer input) { if (input == null) { input = 0; } - int originalValueLength = Integer.SIZE - Integer.numberOfLeadingZeros((input)); + int insertValueLength = Integer.SIZE - Integer.numberOfLeadingZeros((insertValue)); - int insertPosition = startPosition; - if (startPosition > originalValueLength) { - insertPosition = originalValueLength; - } else if (startPosition < 0) { - insertPosition = 0; + + // Wrap around integer size + int insertPosition = startPosition % Integer.SIZE; + if (startPosition < 0) { + insertPosition += Integer.SIZE - 1; } + int mask = ((1 << insertPosition) - 1); - return (((input >> insertPosition) << insertValueLength) + insertValue) << insertPosition + (mask & input); + return (((input >> insertPosition) << insertValueLength) | insertValue) + << insertPosition | (mask & input); } public Integer getInsertValue() { @@ -75,7 +74,7 @@ public VariableModification getModifiedCopy() { if (r.nextBoolean()) { return new IntegerInsertValueModification( - insertValue + r.nextInt(MAX_VALUE_MODIFIER), startPosition); + insertValue + r.nextInt(MAX_VALUE_MODIFIER), startPosition); } else { int modifier = r.nextInt(MAX_POSITION_MODIFIER); if (r.nextBoolean()) { diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java index 10612063..975949e6 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java @@ -33,7 +33,7 @@ protected Integer modifyImplementationHook(Integer input) { input = 0; } - return (prependValue << (Integer.SIZE - Integer.numberOfLeadingZeros((input)))) + input; + return (prependValue << (Integer.SIZE - Integer.numberOfLeadingZeros((input)))) | input; } public Integer getPrependValue() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java index cf163e93..05eb5ec0 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java @@ -32,7 +32,7 @@ protected Long modifyImplementationHook(Long input) { if (input == null) { input = 0L; } - return (input << (Long.SIZE - Long.numberOfLeadingZeros((appendValue)))) + appendValue; + return (input << (Long.SIZE - Long.numberOfLeadingZeros((appendValue)))) | appendValue; } public Long getAppendValue() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java index 524f6613..9ffa3550 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java @@ -36,17 +36,18 @@ protected Long modifyImplementationHook(Long input) { if (input == null) { input = 0L; } - int originalValueLength = Long.SIZE - Long.numberOfLeadingZeros((input)); + int insertValueLength = Long.SIZE - Long.numberOfLeadingZeros((insertValue)); - int insertPosition = startPosition; - if (startPosition > originalValueLength) { - insertPosition = originalValueLength; - } else if (startPosition < 0) { - insertPosition = 0; + + // Wrap around long size + int insertPosition = startPosition % Long.SIZE; + if (startPosition < 0) { + insertPosition += Long.SIZE - 1; } + long mask = ((1L << insertPosition) - 1); - return (((input >> insertPosition) << insertValueLength) + insertValue) << insertPosition + (mask & input); + return (((input >> insertPosition) << insertValueLength) | insertValue) << insertPosition | (mask & input); } public Long getInsertValue() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java index 1d035dc9..5dd6baf8 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java @@ -32,7 +32,7 @@ protected Long modifyImplementationHook(Long input) { if (input == null) { input = 0L; } - return (prependValue << (Long.SIZE - Long.numberOfLeadingZeros((input)))) + input; + return (prependValue << (Long.SIZE - Long.numberOfLeadingZeros((input)))) | input; } public Long getPrependValue() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java index aae65f18..5a85f476 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java @@ -39,20 +39,13 @@ public StringInsertValueModification(final String insertValue, int startPosition @Override protected String modifyImplementationHook(final String input) { - int start = startPosition; - if (start < 0) { - start += input.length(); - if (start < 0) { - LOGGER.debug("Trying to insert from too negative start position. start = {}", startPosition); - return input; - } - } - if (start > input.length()) { - LOGGER.debug("Trying to insert behind the string. String Length:{} Insert Position:{}", input.length(), startPosition); - return input; + // 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(start, insertValue).toString(); + return new StringBuilder(input).insert(insertPosition, insertValue).toString(); } public String getInsertValue() { 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 738ca473..95781690 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArrayTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArrayTest.java @@ -17,6 +17,7 @@ import org.apache.logging.log4j.Logger; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import java.util.Arrays; public class ModifiableByteArrayTest { @@ -242,13 +243,13 @@ public void testDeleteBytes() { @Test public void testInsertBytes() { LOGGER.info("testInsertBytes"); - // Insert at too negative position, prepend bytes + // 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.insertValue(modification1, -2 * originalValue.length); start.setModification(modifier); - byte[] expResult = ArrayConverter.concatenate(modification1, originalValue); + 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); @@ -258,13 +259,13 @@ public void testInsertBytes() { start.setModification(modifier); assertArrayEquals(originalValue, start.getValue()); - // Insert at too positive position, append bytes + // Insert at too positive position -> wrap around start = new ModifiableByteArray(); start.setOriginalValue(originalValue); - LOGGER.debug("Inserting to big Start position"); + LOGGER.debug("Inserting at too large position"); modifier = ByteArrayModificationFactory.insertValue(modification1, originalValue.length * 2); start.setModification(modifier); - expResult = ArrayConverter.concatenate(originalValue, modification1); + expResult = ArrayConverter.concatenate(Arrays.copyOf(originalValue, originalValue.length - 1), modification1, Arrays.copyOfRange(originalValue, originalValue.length -1, originalValue.length)); assertArrayEquals(expResult, start.getValue()); } 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..127c4228 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/integer/IntegerModificationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/integer/IntegerModificationTest.java @@ -71,6 +71,18 @@ public void testExplicitValue() { assertEquals(Integer.valueOf(10), start.getOriginalValue()); } + @Test + public void testInsertValue() { + // expect: ...xx111xxxxxxxxxx + VariableModification modifier = IntegerModificationFactory.insertValue(7, 10); + start.setModification(modifier); + int mask = ((1 << 3) - 1) << 10; + expectedResult = 7; + result = (start.getValue() & mask) >> 10; + assertEquals(expectedResult, result); + assertEquals(Integer.valueOf(10), start.getOriginalValue()); + } + @Test public void testShiftLeft() { VariableModification modifier = IntegerModificationFactory.shiftLeft(2); From 3337cba12a4cdc42f4a92ed3b4971b2b0df80adb Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Thu, 21 Nov 2024 11:12:42 +0100 Subject: [PATCH 13/82] run formatter --- .../BigIntegerAppendValueModification.java | 3 ++- .../BigIntegerModificationFactory.java | 4 +-- .../BigIntegerMultiplyModification.java | 2 +- .../BigIntegerPrependValueModification.java | 3 ++- .../bool/BooleanModificationFactory.java | 5 +++- .../ByteArrayAppendValueModification.java | 5 ++-- .../ByteArrayDeleteModification.java | 11 ++++++-- .../ByteArrayModificationFactory.java | 20 ++++++++++----- .../ByteArrayPrependValueModification.java | 5 ++-- .../IntegerAppendValueModification.java | 5 ++-- .../IntegerInsertValueModification.java | 4 +-- .../integer/IntegerMultiplyModification.java | 3 +-- .../IntegerPrependValueModification.java | 2 +- .../longint/LongAppendValueModification.java | 3 ++- .../longint/LongInsertValueModification.java | 6 ++--- .../longint/LongModificationFactory.java | 23 +++++++++++------ .../longint/LongPrependValueModification.java | 3 ++- .../singlebyte/ByteModificationFactory.java | 7 +++++- .../string/StringInsertValueModification.java | 3 +-- .../string/StringModificationFactory.java | 8 +++--- .../modifiablevariable/util/Modifiable.java | 25 ++++++++----------- .../bytearray/ModifiableByteArrayTest.java | 18 ++++++++++--- 22 files changed, 104 insertions(+), 64 deletions(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java index 36886acc..6e47b20f 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java @@ -49,7 +49,8 @@ public void setAppendValue(BigInteger appendValue) { @Override public VariableModification getModifiedCopy() { - return new BigIntegerAppendValueModification(appendValue.add(new BigInteger(MAX_APPEND_LENGTH, new Random()))); + return new BigIntegerAppendValueModification( + appendValue.add(new BigInteger(MAX_APPEND_LENGTH, new Random()))); } @Override 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 ebb2c1e3..0b04f0dc 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationFactory.java @@ -10,7 +10,6 @@ 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.longint.LongModificationFactory; import de.rub.nds.modifiablevariable.util.RandomHelper; import java.io.BufferedReader; @@ -168,8 +167,7 @@ public static synchronized List> modificationsF if (modificationsFromFile == null) { modificationsFromFile = new LinkedList<>(); ClassLoader classLoader = ByteArrayModificationFactory.class.getClassLoader(); - InputStream is = - classLoader.getResourceAsStream(LongModificationFactory.FILE_NAME); + InputStream is = classLoader.getResourceAsStream(LongModificationFactory.FILE_NAME); BufferedReader br = new BufferedReader(new InputStreamReader(is)); String line; while ((line = br.readLine()) != null) { 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 2f68fcb4..ffe89754 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java @@ -33,7 +33,7 @@ public BigIntegerMultiplyModification(BigInteger bi) { @Override protected BigInteger modifyImplementationHook(BigInteger input) { - return (input == null) ? BigInteger.ZERO: input.multiply(factor); + return (input == null) ? BigInteger.ZERO : input.multiply(factor); } public BigInteger getFactor() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java index 24d75d32..4e765eb3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java @@ -49,7 +49,8 @@ public void setPrependValue(BigInteger prependValue) { @Override public VariableModification getModifiedCopy() { - return new BigIntegerPrependValueModification(prependValue.add(new BigInteger(MAX_PREPEND_LENGTH, new Random()))); + return new BigIntegerPrependValueModification( + prependValue.add(new BigInteger(MAX_PREPEND_LENGTH, new Random()))); } @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 66c009ac..6ef65e1d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanModificationFactory.java @@ -14,8 +14,11 @@ public class BooleanModificationFactory { private enum ModificationType { - EXPLICIT_TRUE, EXPLICIT_FALSE, TOGGLE + EXPLICIT_TRUE, + EXPLICIT_FALSE, + TOGGLE } + private static final int MODIFICATION_COUNT = ModificationType.values().length; public static VariableModification createRandomModification() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java index e80a5bb4..bcbb93f1 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java @@ -85,7 +85,8 @@ public boolean equals(Object obj) { @Override public String toString() { - return String.format("ByteArrayInsertModification{bytesToAppend=%s}", - ArrayConverter.bytesToHexString(bytesToAppend)); + return String.format( + "ByteArrayInsertModification{bytesToAppend=%s}", + 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 0c4964bf..f3408d83 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java @@ -45,13 +45,20 @@ protected byte[] modifyImplementationHook(byte[] input) { if (start < 0) { start += input.length; if (start < 0) { - LOGGER.debug("Trying to delete from too negative Startposition. start = {}", start - input.length); + 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("Bytes {}..{} cannot be deleted from {{}} of length {}", start, endPosition, bytesToHexString(input), input.length); + LOGGER.debug( + "Bytes {}..{} cannot be deleted from {{}} of length {}", + start, + endPosition, + bytesToHexString(input), + input.length); return input; } if (count <= 0) { 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 f32e4153..0b2579a9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayModificationFactory.java @@ -22,8 +22,17 @@ public class ByteArrayModificationFactory { private enum ModificationType { - XOR, APPEND, INSERT, PREPEND, DELETE, EXPLICIT, DUPLICATE, EXPLICIT_FROM_FILE, SHUFFLE + XOR, + APPEND, + INSERT, + PREPEND, + DELETE, + EXPLICIT, + DUPLICATE, + EXPLICIT_FROM_FILE, + SHUFFLE } + private static final int MODIFICATION_COUNT = ModificationType.values().length; private static final int MAX_BYTE_ARRAY_LENGTH = 200; @@ -57,13 +66,11 @@ public static VariableModification insertValue( return new ByteArrayInsertValueModification(bytesToInsert, startPosition); } - public static VariableModification appendValue( - final byte[] bytesToAppend) { + public static VariableModification appendValue(final byte[] bytesToAppend) { return new ByteArrayAppendValueModification(bytesToAppend); } - public static VariableModification prependValue( - final byte[] bytesToPrepend) { + public static VariableModification prependValue(final byte[] bytesToPrepend) { return new ByteArrayPrependValueModification(bytesToPrepend); } @@ -156,7 +163,8 @@ public static VariableModification createRandomModification(byte[] origi case INSERT: byte[] bytesToInsert = new byte[modificationArrayLength]; random.nextBytes(bytesToInsert); - return new ByteArrayInsertValueModification(bytesToInsert, random.nextInt(modifiedArrayLength)); + return new ByteArrayInsertValueModification( + bytesToInsert, random.nextInt(modifiedArrayLength)); case PREPEND: byte[] bytesToPrepend = new byte[modificationArrayLength]; random.nextBytes(bytesToPrepend); diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java index f1bfc264..26b87eb9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java @@ -85,7 +85,8 @@ public boolean equals(Object obj) { @Override public String toString() { - return String.format("ByteArrayInsertModification{bytesToPrepend=%s}", - ArrayConverter.bytesToHexString(bytesToPrepend)); + return String.format( + "ByteArrayInsertModification{bytesToPrepend=%s}", + ArrayConverter.bytesToHexString(bytesToPrepend)); } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java index 9448b597..10fadef2 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java @@ -32,7 +32,8 @@ protected Integer modifyImplementationHook(Integer input) { if (input == null) { input = 0; } - return (input << (Integer.SIZE - Integer.numberOfLeadingZeros((appendValue)))) | appendValue; + return (input << (Integer.SIZE - Integer.numberOfLeadingZeros((appendValue)))) + | appendValue; } public Integer getAppendValue() { @@ -46,7 +47,7 @@ public void setAppendValue(Integer appendValue) { @Override public VariableModification getModifiedCopy() { return new IntegerAppendValueModification( - appendValue + new Random().nextInt(MAX_VALUE_MODIFIER)); + appendValue + new Random().nextInt(MAX_VALUE_MODIFIER)); } @Override diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java index 7c6ab01b..4c273abf 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java @@ -48,8 +48,8 @@ protected Integer modifyImplementationHook(Integer input) { int mask = ((1 << insertPosition) - 1); - return (((input >> insertPosition) << insertValueLength) | insertValue) - << insertPosition | (mask & input); + return (((input >> insertPosition) << insertValueLength) | insertValue) << insertPosition + | (mask & input); } public Integer getInsertValue() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java index 431b97af..e3c6c822 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java @@ -44,8 +44,7 @@ public void setFactor(Integer factor) { public VariableModification getModifiedCopy() { Random r = new Random(); - return new IntegerMultiplyModification( - factor + r.nextInt(MAX_FACTOR_MODIFIER)); + return new IntegerMultiplyModification(factor + r.nextInt(MAX_FACTOR_MODIFIER)); } @Override diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java index 975949e6..f03775cd 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java @@ -47,7 +47,7 @@ public void setPrependValue(Integer prependValue) { @Override public VariableModification getModifiedCopy() { return new IntegerPrependValueModification( - prependValue + new Random().nextInt(MAX_VALUE_MODIFIER)); + prependValue + new Random().nextInt(MAX_VALUE_MODIFIER)); } @Override diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java index 05eb5ec0..25c205fa 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java @@ -45,7 +45,8 @@ public void setAppendValue(Long appendValue) { @Override public VariableModification getModifiedCopy() { - return new LongAppendValueModification(appendValue + new Random().nextInt(MAX_VALUE_MODIFIER)); + return new LongAppendValueModification( + appendValue + new Random().nextInt(MAX_VALUE_MODIFIER)); } @Override diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java index 9ffa3550..cc793dac 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java @@ -8,7 +8,6 @@ package de.rub.nds.modifiablevariable.longint; import de.rub.nds.modifiablevariable.VariableModification; -import de.rub.nds.modifiablevariable.integer.IntegerInsertValueModification; import jakarta.xml.bind.annotation.XmlRootElement; import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @@ -47,7 +46,8 @@ protected Long modifyImplementationHook(Long input) { long mask = ((1L << insertPosition) - 1); - return (((input >> insertPosition) << insertValueLength) | insertValue) << insertPosition | (mask & input); + return (((input >> insertPosition) << insertValueLength) | insertValue) << insertPosition + | (mask & input); } public Long getInsertValue() { @@ -72,7 +72,7 @@ public VariableModification getModifiedCopy() { if (r.nextBoolean()) { return new LongInsertValueModification( - insertValue + r.nextInt(MAX_VALUE_MODIFIER), startPosition); + insertValue + r.nextInt(MAX_VALUE_MODIFIER), startPosition); } else { int modifier = r.nextInt(MAX_POSITION_MODIFIER); if (r.nextBoolean()) { 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 afc6322c..549b1357 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongModificationFactory.java @@ -22,13 +22,19 @@ public class LongModificationFactory { private enum ModificationType { - ADD, SUBTRACT, MULTIPLY, XOR, EXPLICIT, + ADD, + SUBTRACT, + MULTIPLY, + XOR, + EXPLICIT, SHIFT_LEFT, - SHIFT_RIGHT, EXPLICIT_FROM_FILE, + SHIFT_RIGHT, + EXPLICIT_FROM_FILE, APPEND, INSERT, PREPEND } + private static final int MODIFICATION_COUNT = ModificationType.values().length; private static final int MAX_MODIFICATION_VALUE = 32000; @@ -109,14 +115,12 @@ public static VariableModification shiftRight(final int shift) { return new LongShiftRightModification(shift); } - public static synchronized List> modificationsFromFile() { try { if (modificationsFromFile == null) { modificationsFromFile = new LinkedList<>(); ClassLoader classLoader = IntegerModificationFactory.class.getClassLoader(); - InputStream is = - classLoader.getResourceAsStream(FILE_NAME); + InputStream is = classLoader.getResourceAsStream(FILE_NAME); BufferedReader br = new BufferedReader(new InputStreamReader(is)); String line; while ((line = br.readLine()) != null) { @@ -135,7 +139,7 @@ public static VariableModification createRandomModification() { Random random = RandomHelper.getRandom(); ModificationType randomType = ModificationType.values()[random.nextInt(MODIFICATION_COUNT)]; long modification = random.nextInt(MAX_MODIFICATION_VALUE); - long insert_modification = random.nextInt( MAX_MODIFICATION_INSERT_VALUE); + long insert_modification = random.nextInt(MAX_MODIFICATION_INSERT_VALUE); int shiftModification = random.nextInt(MAX_MODIFICATION_SHIFT_VALUE); switch (randomType) { case ADD: @@ -143,7 +147,8 @@ public static VariableModification createRandomModification() { case SUBTRACT: return new LongSubtractModification(modification); case MULTIPLY: - return new LongMultiplyModification((long)random.nextInt(MAX_MODIFICATION_MULTIPLY_VALUE)); + return new LongMultiplyModification( + (long) random.nextInt(MAX_MODIFICATION_MULTIPLY_VALUE)); case XOR: return new LongXorModification(modification); case EXPLICIT: @@ -157,7 +162,9 @@ public static VariableModification createRandomModification() { case APPEND: return new LongAppendValueModification(insert_modification); case INSERT: - return new LongInsertValueModification(insert_modification, random.nextInt(MAX_MODIFICATION_INSERT_POSITION_VALUE)); + return new LongInsertValueModification( + insert_modification, + random.nextInt(MAX_MODIFICATION_INSERT_POSITION_VALUE)); case PREPEND: return new LongPrependValueModification(insert_modification); default: diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java index 5dd6baf8..61d7431a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java @@ -45,7 +45,8 @@ public void setPrependValue(Long prependValue) { @Override public VariableModification getModifiedCopy() { - return new LongPrependValueModification(prependValue + new Random().nextInt(MAX_VALUE_MODIFIER)); + return new LongPrependValueModification( + prependValue + new Random().nextInt(MAX_VALUE_MODIFIER)); } @Override 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 20e4d84e..200925eb 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteModificationFactory.java @@ -21,8 +21,13 @@ public class ByteModificationFactory { private enum ModificationType { - ADD, SUBTRACT, XOR, EXPLICIT, EXPLICIT_FROM_FILE + ADD, + SUBTRACT, + XOR, + EXPLICIT, + EXPLICIT_FROM_FILE } + private static final int MODIFICATION_COUNT = ModificationType.values().length; private static List> modificationsFromFile; diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java index 5a85f476..eb4e1ddc 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java @@ -12,7 +12,6 @@ import jakarta.xml.bind.annotation.XmlRootElement; import jakarta.xml.bind.annotation.XmlType; import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; - import java.util.Objects; import java.util.Random; @@ -40,7 +39,7 @@ public StringInsertValueModification(final String insertValue, int startPosition @Override protected String modifyImplementationHook(final String input) { // Wrap around and also allow to insert at the end of the original value - int insertPosition = startPosition % (input.length() + 1); + int insertPosition = startPosition % (input.length() + 1); if (startPosition < 0) { insertPosition += input.length(); } 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 f7fdea6f..56f4c65c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringModificationFactory.java @@ -9,15 +9,18 @@ import de.rub.nds.modifiablevariable.VariableModification; import de.rub.nds.modifiablevariable.util.RandomHelper; - import java.util.Random; /** */ public class StringModificationFactory { private enum ModificationType { - APPEND, PREPEND, EXPLICIT, INSERT + APPEND, + PREPEND, + EXPLICIT, + INSERT } + private static final int MODIFICATION_COUNT = ModificationType.values().length; private static final int MAX_BYTE_LENGTH_INSERT = 200; @@ -26,7 +29,6 @@ private enum ModificationType { private static final int MODIFIED_STRING_LENGTH_ESTIMATION = 50; - public static VariableModification prependValue(final String value) { return new StringPrependValueModification(value); } 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 e261f2c8..769b1ab3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/Modifiable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/Modifiable.java @@ -79,12 +79,11 @@ private static ModifiableString getModifiableStringWithModification( public static ModifiableBigInteger prepend(BigInteger i) { return getModifiableBigIntegerWithModification( - BigIntegerModificationFactory.prependValue(i)); + BigIntegerModificationFactory.prependValue(i)); } public static ModifiableByteArray prepend(byte[] b) { - return getModifiableByteArrayWithModification( - ByteArrayModificationFactory.prependValue(b)); + return getModifiableByteArrayWithModification(ByteArrayModificationFactory.prependValue(b)); } public static ModifiableInteger prepend(Integer i) { @@ -99,15 +98,13 @@ public static ModifiableString prepend(final String s) { return getModifiableStringWithModification(StringModificationFactory.prependValue(s)); } - public static ModifiableBigInteger append(BigInteger i) { return getModifiableBigIntegerWithModification( - BigIntegerModificationFactory.appendValue(i)); + BigIntegerModificationFactory.appendValue(i)); } public static ModifiableByteArray append(byte[] b) { - return getModifiableByteArrayWithModification( - ByteArrayModificationFactory.appendValue(b)); + return getModifiableByteArrayWithModification(ByteArrayModificationFactory.appendValue(b)); } public static ModifiableInteger append(Integer i) { @@ -152,19 +149,19 @@ public static ModifiableString explicit(String s) { return getModifiableStringWithModification(StringModificationFactory.explicitValue(s)); } - public static ModifiableBigInteger insert(BigInteger i, int position) { return getModifiableBigIntegerWithModification( - BigIntegerModificationFactory.insertValue(i, position)); + BigIntegerModificationFactory.insertValue(i, position)); } public static ModifiableByteArray insert(byte[] b, int position) { return getModifiableByteArrayWithModification( - ByteArrayModificationFactory.insertValue(b, position)); + ByteArrayModificationFactory.insertValue(b, position)); } public static ModifiableInteger insert(Integer i, int position) { - return getModifiableIntegerWithModification(IntegerModificationFactory.insertValue(i, position)); + return getModifiableIntegerWithModification( + IntegerModificationFactory.insertValue(i, position)); } public static ModifiableLong insert(Long l, int position) { @@ -172,10 +169,10 @@ public static ModifiableLong insert(Long l, int position) { } public static ModifiableString insert(String s, int position) { - return getModifiableStringWithModification(StringModificationFactory.insertValue(s, position)); + return getModifiableStringWithModification( + StringModificationFactory.insertValue(s, position)); } - public static ModifiableByteArray xor(byte[] b, int position) { return getModifiableByteArrayWithModification( ByteArrayModificationFactory.xor(b, position)); @@ -229,7 +226,6 @@ public static ModifiableLong sub(Long l) { return getModifiableLongWithModification(LongModificationFactory.sub(l)); } - public static ModifiableByteArray delete(int startPosition, int count) { return getModifiableByteArrayWithModification( ByteArrayModificationFactory.delete(startPosition, count)); @@ -268,7 +264,6 @@ public static ModifiableBigInteger multiplyBigInteger(BigInteger i) { return getModifiableBigIntegerWithModification(BigIntegerModificationFactory.multiply(i)); } - public static ModifiableInteger multiply(Integer i) { return getModifiableIntegerWithModification(IntegerModificationFactory.multiply(i)); } 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 95781690..26b643f8 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArrayTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArrayTest.java @@ -13,11 +13,11 @@ 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; import org.junit.jupiter.api.Test; -import java.util.Arrays; public class ModifiableByteArrayTest { @@ -249,7 +249,11 @@ public void testInsertBytes() { VariableModification modifier = ByteArrayModificationFactory.insertValue(modification1, -2 * originalValue.length); start.setModification(modifier); - byte[] expResult = ArrayConverter.concatenate(Arrays.copyOf(originalValue, 1), modification1, Arrays.copyOfRange(originalValue, 1, originalValue.length)); + 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); @@ -263,9 +267,15 @@ public void testInsertBytes() { start = new ModifiableByteArray(); start.setOriginalValue(originalValue); LOGGER.debug("Inserting at too large position"); - modifier = ByteArrayModificationFactory.insertValue(modification1, originalValue.length * 2); + modifier = + ByteArrayModificationFactory.insertValue(modification1, originalValue.length * 2); start.setModification(modifier); - expResult = ArrayConverter.concatenate(Arrays.copyOf(originalValue, originalValue.length - 1), modification1, Arrays.copyOfRange(originalValue, originalValue.length -1, originalValue.length)); + expResult = + ArrayConverter.concatenate( + Arrays.copyOf(originalValue, originalValue.length - 1), + modification1, + Arrays.copyOfRange( + originalValue, originalValue.length - 1, originalValue.length)); assertArrayEquals(expResult, start.getValue()); } From 0e71c4c4632aa19cd9821e89d44e7f8e25c9b74d Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Thu, 21 Nov 2024 11:34:44 +0100 Subject: [PATCH 14/82] Add simple insertion test for long and BigInteger --- .../BigIntegerModificationTest.java | 21 +++++++++++++++++++ .../mlong/LongModificationTest.java | 12 +++++++++++ 2 files changed, 33 insertions(+) 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 d712e84b..4076156e 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationTest.java @@ -80,6 +80,27 @@ public void testExplicitValue() { assertEquals(BigInteger.TEN, start.getOriginalValue()); } + @Test + public void testInsertValue() { + // expect: 111xxxx + VariableModification modifier = + BigIntegerModificationFactory.insertValue(BigInteger.valueOf(7), 4); + start.setModification(modifier); + BigInteger mask = BigInteger.valueOf((1L << 3) - 1).shiftLeft(4); + expectedResult = BigInteger.valueOf(7); + result = start.getValue().and(mask).shiftRight(4); + assertEquals(expectedResult, result); + assertEquals(BigInteger.valueOf(10), start.getOriginalValue()); + + // expect: x111xxx + modifier = BigIntegerModificationFactory.insertValue(BigInteger.valueOf(7), 3); + start.setModification(modifier); + mask = BigInteger.valueOf((1L << 3) - 1).shiftLeft(3); + expectedResult = BigInteger.valueOf(7); + result = start.getValue().and(mask).shiftRight(3); + assertEquals(expectedResult, result); + } + /** Test of add method, of class BigIntegerModificationFactory. */ @Test public void testIsOriginalValueModified() { 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 1a9fe96c..4b29ce19 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/mlong/LongModificationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/mlong/LongModificationTest.java @@ -71,6 +71,18 @@ public void testExplicitValue() { assertEquals(Long.valueOf(10L), start.getOriginalValue()); } + @Test + public void testInsertValue() { + // expect: ...xx111xxxxxxxxxxxx + VariableModification modifier = LongModificationFactory.insertValue(7L, 12); + start.setModification(modifier); + int mask = ((1 << 3) - 1) << 12; + expectedResult = 7L; + result = (start.getValue() & mask) >> 12; + assertEquals(expectedResult, result); + assertEquals(Long.valueOf(10), start.getOriginalValue()); + } + /** Test of explicitValue from file method */ @Test public void testExplicitValueFromFile() { From 8c67bff2ae685e15dbbdfbff730b49cc6b8ab468 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Thu, 21 Nov 2024 13:11:02 +0100 Subject: [PATCH 15/82] Actually remove magic values from hashCode() method of all modifications and use standard prime number instead. --- .../rub/nds/modifiablevariable/ModifiableVariableHolder.java | 2 +- .../nds/modifiablevariable/ModifiableVariableProperty.java | 4 ++-- .../biginteger/BigIntegerAddModification.java | 2 +- .../biginteger/BigIntegerAppendValueModification.java | 2 +- .../biginteger/BigIntegerExplicitValueModification.java | 2 +- .../biginteger/BigIntegerInsertValueModification.java | 4 ++-- .../biginteger/BigIntegerMultiplyModification.java | 2 +- .../biginteger/BigIntegerPrependValueModification.java | 2 +- .../biginteger/BigIntegerShiftLeftModification.java | 2 +- .../biginteger/BigIntegerShiftRightModification.java | 2 +- .../biginteger/BigIntegerSubtractModification.java | 2 +- .../biginteger/BigIntegerXorModification.java | 2 +- .../bool/BooleanExplicitValueModification.java | 2 +- .../bytearray/ByteArrayAppendValueModification.java | 2 +- .../bytearray/ByteArrayDeleteModification.java | 4 ++-- .../bytearray/ByteArrayExplicitValueModification.java | 2 +- .../bytearray/ByteArrayInsertValueModification.java | 4 ++-- .../bytearray/ByteArrayPrependValueModification.java | 2 +- .../bytearray/ByteArrayShuffleModification.java | 2 +- .../bytearray/ByteArrayXorModification.java | 4 ++-- .../modifiablevariable/integer/IntegerAddModification.java | 2 +- .../integer/IntegerAppendValueModification.java | 2 +- .../integer/IntegerExplicitValueModification.java | 2 +- .../integer/IntegerInsertValueModification.java | 4 ++-- .../integer/IntegerMultiplyModification.java | 2 +- .../integer/IntegerPrependValueModification.java | 2 +- .../integer/IntegerShiftLeftModification.java | 2 +- .../integer/IntegerShiftRightModification.java | 2 +- .../integer/IntegerSubtractModification.java | 2 +- .../modifiablevariable/integer/IntegerXorModification.java | 2 +- .../nds/modifiablevariable/longint/LongAddModification.java | 2 +- .../longint/LongAppendValueModification.java | 2 +- .../longint/LongExplicitValueModification.java | 2 +- .../longint/LongInsertValueModification.java | 4 ++-- .../modifiablevariable/longint/LongMultiplyModification.java | 2 +- .../longint/LongPrependValueModification.java | 2 +- .../modifiablevariable/longint/LongShiftLeftModification.java | 2 +- .../longint/LongShiftRightModification.java | 2 +- .../modifiablevariable/longint/LongSubtractModification.java | 2 +- .../nds/modifiablevariable/longint/LongXorModification.java | 2 +- .../modifiablevariable/singlebyte/ByteAddModification.java | 2 +- .../singlebyte/ByteExplicitValueModification.java | 2 +- .../singlebyte/ByteSubtractModification.java | 2 +- .../modifiablevariable/singlebyte/ByteXorModification.java | 2 +- .../string/StringAppendValueModification.java | 2 +- .../string/StringExplicitValueModification.java | 2 +- .../string/StringInsertValueModification.java | 4 ++-- .../string/StringPrependValueModification.java | 2 +- 48 files changed, 56 insertions(+), 56 deletions(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableHolder.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableHolder.java index 137fc7b8..01286f03 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableHolder.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableHolder.java @@ -150,7 +150,7 @@ protected String getExtendedString(int depth) { } stringBuilder.append(field.getName()); stringBuilder.append(": "); - stringBuilder.append(tempObject.toString()); + stringBuilder.append(tempObject); stringBuilder.append("\n"); } } else { 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/biginteger/BigIntegerAddModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java index 06f69e73..905c8e56 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java @@ -53,7 +53,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 51 * hash + Objects.hashCode(this.summand); + hash = 31 * hash + summand.hashCode(); return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java index 6e47b20f..97f3f88e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java @@ -56,7 +56,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 59 * hash + Objects.hashCode(this.appendValue); + hash = 31 * hash + appendValue.hashCode(); return hash; } 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 780d0b3c..e4ea8dd1 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java @@ -59,7 +59,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 52 * hash + Objects.hashCode(this.explicitValue); + hash = 31 * hash + explicitValue.hashCode(); return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java index 9065dda5..cf7d7efe 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java @@ -97,8 +97,8 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 58 * hash + Objects.hashCode(this.insertValue); - hash = 58 * hash + Objects.hashCode(this.startPosition); + hash = 31 * hash + insertValue.hashCode(); + hash = 31 * hash + startPosition; return hash; } 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 ffe89754..52975ae2 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java @@ -53,7 +53,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 53 * hash + Objects.hashCode(this.factor); + hash = 31 * hash + factor.hashCode(); return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java index 4e765eb3..5a813b73 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java @@ -56,7 +56,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 60 * hash + Objects.hashCode(this.prependValue); + hash = 31 * hash + prependValue.hashCode(); return hash; } 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 b40fef8e..6e42525a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java @@ -54,7 +54,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 54 * hash + this.shift; + hash = 31 * hash + shift; return hash; } 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 623c7ae8..27470f73 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java @@ -54,7 +54,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 55 * hash + this.shift; + hash = 31 * hash + shift; return hash; } 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 9e57ec18..d77d0f38 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java @@ -56,7 +56,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 56 * hash + Objects.hashCode(this.subtrahend); + hash = 31 * hash + subtrahend.hashCode(); return hash; } 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 d820ddf4..b416ff0a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java @@ -55,7 +55,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 57 * hash + Objects.hashCode(this.xor); + hash = 31 * hash + xor.hashCode(); return hash; } 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 19dc3dca..5ca6a23c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanExplicitValueModification.java @@ -44,7 +44,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 21 * hash + (this.explicitValue ? 1 : 0); + hash = 31 * hash + (explicitValue ? 1231 : 1237); return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java index bcbb93f1..95e2f2e7 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java @@ -64,7 +64,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 86 * hash + Arrays.hashCode(this.bytesToAppend); + hash = 31 * hash + Arrays.hashCode(bytesToAppend); return hash; } 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 f3408d83..6000870a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java @@ -114,8 +114,8 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 81 * hash + this.count; - hash = 81 * hash + this.startPosition; + hash = 31 * hash + count; + hash = 31 * hash + startPosition; return hash; } 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 4bb31238..173a97ed 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java @@ -70,7 +70,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 82 * hash + Arrays.hashCode(this.explicitValue); + hash = 31 * hash + Arrays.hashCode(explicitValue); return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java index 7117b16b..d1523e7a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java @@ -101,8 +101,8 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 83 * hash + Arrays.hashCode(this.bytesToInsert); - hash = 83 * hash + this.startPosition; + hash = 31 * hash + Arrays.hashCode(bytesToInsert); + hash = 31 * hash + startPosition; return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java index 26b87eb9..73585436 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java @@ -64,7 +64,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 87 * hash + Arrays.hashCode(this.bytesToPrepend); + hash = 31 * hash + Arrays.hashCode(bytesToPrepend); return hash; } 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 d270ba2d..862bcb7e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayShuffleModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayShuffleModification.java @@ -77,7 +77,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 84 * hash + Arrays.hashCode(this.shuffle); + hash = 31 * hash + Arrays.hashCode(shuffle); return hash; } 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 1bc070bf..d8b19a43 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java @@ -109,8 +109,8 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 85 * hash + Arrays.hashCode(this.xor); - hash = 85 * hash + this.startPosition; + hash = 31 * hash + Arrays.hashCode(xor); + hash = 31 * hash + startPosition; return hash; } 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 a44ed33a..fb1e15e5 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAddModification.java @@ -48,7 +48,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + Objects.hashCode(this.summand); + hash = 31 * hash + summand; return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java index 10fadef2..b2a1f4d7 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java @@ -53,7 +53,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 38 * hash + Objects.hashCode(this.appendValue); + hash = 31 * hash + appendValue; return hash; } 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 0ad99c1a..1f207cf8 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueModification.java @@ -55,7 +55,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 32 * hash + Objects.hashCode(this.explicitValue); + hash = 31 * hash + explicitValue; return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java index 4c273abf..c5cf0701 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java @@ -91,8 +91,8 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 37 * hash + Objects.hashCode(this.insertValue); - hash = 37 * hash + this.startPosition; + hash = 31 * hash + insertValue; + hash = 31 * hash + startPosition; return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java index e3c6c822..5c2fced9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java @@ -50,7 +50,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 40 * hash + Objects.hashCode(this.factor); + hash = 31 * hash + factor; return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java index f03775cd..67ff5ff1 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java @@ -53,7 +53,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 39 * hash + Objects.hashCode(this.prependValue); + hash = 31 * hash + prependValue; return hash; } 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 b422e87e..f99cdfa8 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftLeftModification.java @@ -59,7 +59,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 33 * hash + this.shift; + hash = 31 * hash + shift; return hash; } 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 fb503ec5..367e16d0 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftRightModification.java @@ -59,7 +59,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 34 * hash + this.shift; + hash = 31 * hash + shift; return hash; } 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 b71c9cea..06916072 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSubtractModification.java @@ -49,7 +49,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 35 * hash + Objects.hashCode(this.subtrahend); + hash = 31 * hash + subtrahend; return hash; } 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 7931f109..a91e8fb7 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerXorModification.java @@ -53,7 +53,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 36 * hash + Objects.hashCode(this.xor); + hash = 31 * hash + xor; return hash; } 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 781d17c3..f37fbc26 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java @@ -48,7 +48,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 41 * hash + Objects.hashCode(this.summand); + hash = 31 * hash + summand.hashCode(); return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java index 25c205fa..b7177fda 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java @@ -52,7 +52,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 45 * hash + Objects.hashCode(this.appendValue); + hash = 31 * hash + appendValue.hashCode(); return hash; } 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 765476b8..bfdc1b8c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java @@ -55,7 +55,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 42 * hash + Objects.hashCode(this.explicitValue); + hash = 31 * hash + explicitValue.hashCode(); return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java index cc793dac..88a24f17 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java @@ -89,8 +89,8 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 47 * hash + Objects.hashCode(this.insertValue); - hash = 47 * hash + Objects.hashCode(this.startPosition); + hash = 31 * hash + insertValue.hashCode(); + hash = 31 * hash + startPosition; return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java index 1c9388ed..0c1a9f16 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java @@ -48,7 +48,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 48 * hash + Objects.hashCode(this.factor); + hash = 31 * hash + factor.hashCode(); return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java index 61d7431a..b803d6cc 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java @@ -52,7 +52,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 46 * hash + Objects.hashCode(this.prependValue); + hash = 31 * hash + prependValue.hashCode(); return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java index 2cb69884..02cfbc36 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java @@ -61,7 +61,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 49 * hash + Objects.hashCode(this.shift); + hash = 31 * hash + shift; return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java index 1b2b9a08..511eaf79 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java @@ -61,7 +61,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 50 * hash + Objects.hashCode(this.shift); + hash = 31 * hash + shift; return hash; } 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 6c617018..b43b0a8d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java @@ -49,7 +49,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 43 * hash + Objects.hashCode(this.subtrahend); + hash = 31 * hash + subtrahend.hashCode(); return hash; } 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 0cc8b3ba..07bd6141 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java @@ -53,7 +53,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 44 * hash + Objects.hashCode(this.xor); + hash = 31 * hash + xor.hashCode(); return hash; } 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 7850d344..4e4e598f 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteAddModification.java @@ -51,7 +51,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 11 * hash + Objects.hashCode(this.summand); + hash = 31 * hash + summand; return hash; } 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 d1f32c02..7a428b7c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueModification.java @@ -55,7 +55,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 12 * hash + Objects.hashCode(this.explicitValue); + hash = 31 * hash + explicitValue; return hash; } 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 ebe1ca83..1df8179e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteSubtractModification.java @@ -52,7 +52,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 13 * hash + Objects.hashCode(this.subtrahend); + hash = 31 * hash + subtrahend; return hash; } 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 1b968a08..cb10612a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteXorModification.java @@ -57,7 +57,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 14 * hash + Objects.hashCode(this.xor); + hash = 31 * hash + xor; return hash; } 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 3d060022..5cef0f1d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java @@ -57,7 +57,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 61 * hash + Objects.hashCode(this.appendValue); + hash = 31 * hash + appendValue.hashCode(); return hash; } 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 243c87cd..e370f2b7 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java @@ -60,7 +60,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 62 * hash + Objects.hashCode(this.explicitValue); + hash = 31 * hash + explicitValue.hashCode(); return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java index eb4e1ddc..b1acfc44 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java @@ -89,8 +89,8 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 63 * hash + Objects.hashCode(this.insertValue); - hash = 63 * hash + this.startPosition; + hash = 31 * hash + insertValue.hashCode(); + hash = 31 * hash + startPosition; return hash; } 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 99164c32..d5a9fe54 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java @@ -57,7 +57,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 64 * hash + Objects.hashCode(this.prependValue); + hash = 31 * hash + prependValue.hashCode(); return hash; } From 5f31e085db68fdd1b372490239be516de8d8c687 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Fri, 29 Nov 2024 15:24:31 +0100 Subject: [PATCH 16/82] Add copy constructors to all modifiable variables Also some refactoring --- .../FileConfigurationException.java | 4 +- .../ModifiableVariable.java | 274 ++++++++---------- .../ModifiableVariableFactory.java | 6 +- .../ModifiableVariableHolder.java | 39 +-- .../ModificationFilter.java | 2 +- .../VariableModification.java | 16 +- .../biginteger/BigIntegerAddModification.java | 20 +- .../BigIntegerAppendValueModification.java | 18 +- .../BigIntegerExplicitValueModification.java | 20 +- .../BigIntegerInsertValueModification.java | 20 +- .../BigIntegerInteractiveModification.java | 18 +- .../BigIntegerModificationFactory.java | 43 ++- .../BigIntegerMultiplyModification.java | 20 +- .../BigIntegerPrependValueModification.java | 18 +- .../BigIntegerShiftLeftModification.java | 14 +- .../BigIntegerShiftRightModification.java | 14 +- .../BigIntegerSubtractModification.java | 18 +- .../biginteger/BigIntegerXorModification.java | 18 +- .../biginteger/ModifiableBigInteger.java | 26 +- .../BooleanExplicitValueModification.java | 16 +- .../bool/BooleanModificationFactory.java | 8 +- .../bool/BooleanToggleModification.java | 14 +- .../bool/ModifiableBoolean.java | 27 +- .../ByteArrayAppendValueModification.java | 15 +- .../ByteArrayDeleteModification.java | 22 +- .../ByteArrayDuplicateModification.java | 14 +- .../ByteArrayExplicitValueModification.java | 17 +- .../ByteArrayInsertValueModification.java | 17 +- .../ByteArrayModificationFactory.java | 20 +- .../ByteArrayPrependValueModification.java | 15 +- .../ByteArrayShuffleModification.java | 16 +- .../bytearray/ByteArrayXorModification.java | 18 +- .../bytearray/ModifiableByteArray.java | 34 ++- .../filter/AccessModificationFilter.java | 6 +- .../filter/ModificationFilterFactory.java | 8 +- .../integer/IntegerAddModification.java | 16 +- .../IntegerAppendValueModification.java | 17 +- .../IntegerExplicitValueModification.java | 16 +- .../IntegerInsertValueModification.java | 24 +- .../integer/IntegerModificationFactory.java | 39 +-- .../integer/IntegerMultiplyModification.java | 16 +- .../IntegerPrependValueModification.java | 16 +- .../integer/IntegerShiftLeftModification.java | 16 +- .../IntegerShiftRightModification.java | 18 +- .../integer/IntegerSubtractModification.java | 18 +- .../integer/IntegerXorModification.java | 22 +- .../integer/ModifiableInteger.java | 24 +- .../length/ModifiableLengthField.java | 21 +- .../logging/ExtendedPatternLayout.java | 177 ++++++----- .../longint/LongAddModification.java | 18 +- .../longint/LongAppendValueModification.java | 16 +- .../LongExplicitValueModification.java | 16 +- .../longint/LongInsertValueModification.java | 24 +- .../longint/LongModificationFactory.java | 34 ++- .../longint/LongMultiplyModification.java | 18 +- .../longint/LongPrependValueModification.java | 16 +- .../longint/LongShiftLeftModification.java | 18 +- .../longint/LongShiftRightModification.java | 18 +- .../longint/LongSubtractModification.java | 18 +- .../longint/LongXorModification.java | 18 +- .../longint/ModifiableLong.java | 24 +- .../singlebyte/ByteAddModification.java | 18 +- .../ByteExplicitValueModification.java | 20 +- .../singlebyte/ByteModificationFactory.java | 22 +- .../singlebyte/ByteSubtractModification.java | 20 +- .../singlebyte/ByteXorModification.java | 18 +- .../singlebyte/ModifiableByte.java | 24 +- .../string/ModifiableString.java | 24 +- .../string/StringAppendValueModification.java | 24 +- .../StringExplicitValueModification.java | 14 +- .../string/StringInsertValueModification.java | 24 +- .../string/StringModificationFactory.java | 14 +- .../StringPrependValueModification.java | 24 +- .../util/ArrayConverter.java | 41 +-- .../util/BadFixedRandom.java | 1 + .../modifiablevariable/util/BadRandom.java | 7 +- .../util/ComparableByteArray.java | 7 +- .../modifiablevariable/util/Modifiable.java | 10 +- .../util/ModifiableVariableAnalyzer.java | 24 +- .../util/ModifiableVariableField.java | 11 +- .../util/ModifiableVariableListHolder.java | 11 +- .../modifiablevariable/util/RandomHelper.java | 6 +- .../util/ReflectionHelper.java | 24 +- .../modifiablevariable/util/StringUtil.java | 12 +- .../BigIntegerOperationConcatenationTest.java | 16 +- 85 files changed, 1245 insertions(+), 724 deletions(-) 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 d9334ecb..8488ab69 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -32,8 +32,8 @@ /** * 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 + * to be defined transient to allow propOrder definition in subclasses, see: ... * * @param */ @@ -42,151 +42,134 @@ @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 = BigIntegerAppendValueModification.class, - name = "BigIntegerAppendValueModification"), - @XmlElement( - type = BigIntegerInsertValueModification.class, - name = "BigIntegerInsertValueModification"), - @XmlElement( - type = BigIntegerPrependValueModification.class, - name = "BigIntegerPrependValueModification"), - @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 = ByteArrayAppendValueModification.class, - name = "ByteArrayAppendValueModification"), - @XmlElement( - type = ByteArrayInsertValueModification.class, - name = "ByteArrayInsertValueModification"), - @XmlElement( - type = ByteArrayPrependValueModification.class, - name = "ByteArrayPrependValueModification"), - @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 = IntegerMultiplyModification.class, - name = "IntegerMultiplyModification"), - @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 = IntegerAppendValueModification.class, - name = "IntegerAppendValueModification"), - @XmlElement( - type = IntegerInsertValueModification.class, - name = "IntegerInsertValueModification"), - @XmlElement( - type = IntegerPrependValueModification.class, - name = "IntegerPrependValueModification"), - @XmlElement(type = LongXorModification.class, name = "LongXorModification"), - @XmlElement( - type = LongSubtractModification.class, - name = "LongSubtractModification"), - @XmlElement( - type = LongExplicitValueModification.class, - name = "LongExplicitValueModification"), - @XmlElement( - type = LongAppendValueModification.class, - name = "LongAppendValueModification"), - @XmlElement( - type = LongInsertValueModification.class, - name = "LongInsertValueModification"), - @XmlElement( - type = LongPrependValueModification.class, - name = "LongPrependValueModification"), - @XmlElement( - type = LongMultiplyModification.class, - name = "LongMultiplyModification"), - @XmlElement( - type = LongShiftLeftModification.class, - name = "LongShiftLeftModification"), - @XmlElement( - type = LongShiftRightModification.class, - name = "LongShiftRightModification"), - @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"), - @XmlElement( - type = StringInsertValueModification.class, - name = "StringInsertValueModification") - }) + @XmlElements({ + @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 = BigIntegerAppendValueModification.class, + name = "BigIntegerAppendValueModification"), + @XmlElement( + type = BigIntegerInsertValueModification.class, + name = "BigIntegerInsertValueModification"), + @XmlElement( + type = BigIntegerPrependValueModification.class, + name = "BigIntegerPrependValueModification"), + @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 = ByteArrayAppendValueModification.class, + name = "ByteArrayAppendValueModification"), + @XmlElement( + type = ByteArrayInsertValueModification.class, + name = "ByteArrayInsertValueModification"), + @XmlElement( + type = ByteArrayPrependValueModification.class, + name = "ByteArrayPrependValueModification"), + @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 = IntegerMultiplyModification.class, name = "IntegerMultiplyModification"), + @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 = IntegerAppendValueModification.class, + name = "IntegerAppendValueModification"), + @XmlElement( + type = IntegerInsertValueModification.class, + name = "IntegerInsertValueModification"), + @XmlElement( + type = IntegerPrependValueModification.class, + name = "IntegerPrependValueModification"), + @XmlElement(type = LongXorModification.class, name = "LongXorModification"), + @XmlElement(type = LongSubtractModification.class, name = "LongSubtractModification"), + @XmlElement( + type = LongExplicitValueModification.class, + name = "LongExplicitValueModification"), + @XmlElement(type = LongAppendValueModification.class, name = "LongAppendValueModification"), + @XmlElement(type = LongInsertValueModification.class, name = "LongInsertValueModification"), + @XmlElement( + type = LongPrependValueModification.class, + name = "LongPrependValueModification"), + @XmlElement(type = LongMultiplyModification.class, name = "LongMultiplyModification"), + @XmlElement(type = LongShiftLeftModification.class, name = "LongShiftLeftModification"), + @XmlElement(type = LongShiftRightModification.class, name = "LongShiftRightModification"), + @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"), + @XmlElement( + type = StringInsertValueModification.class, + name = "StringInsertValueModification") + }) private VariableModification modification = null; private Boolean createRandomModification; protected E assertEquals; - public ModifiableVariable() {} + protected ModifiableVariable() { + super(); + } + + protected ModifiableVariable(ModifiableVariable other) { + super(); + if (other != null) { + createRandomModification = other.createRandomModification; + modification = other.modification != null ? other.modification.createCopy() : null; + // Warning: Make sure to copy assertEquals in subclass correctly + assertEquals = other.assertEquals; + } + } public void setModification(VariableModification modification) { this.modification = modification; @@ -215,6 +198,8 @@ public E getValue() { protected abstract void createRandomModification(); + protected abstract ModifiableVariable createCopy(); + public void createRandomModificationAtRuntime() { createRandomModification = true; } @@ -224,13 +209,10 @@ public void createRandomModificationAtRuntime() { public abstract boolean validateAssertions(); public boolean containsAssertion() { - return (assertEquals != null); + return assertEquals != null; } public Boolean isCreateRandomModification() { - if (createRandomModification == null) { - return false; - } - return createRandomModification; + return Objects.requireNonNullElse(createRandomModification, false); } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableFactory.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableFactory.java index 19b9a22d..4e3e3e91 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(); @@ -94,5 +94,7 @@ public static ModifiableBoolean safelySetValue(ModifiableBoolean mv, Boolean val 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 01286f03..073365f0 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,12 +70,12 @@ 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); @@ -85,7 +85,7 @@ public void reset() { 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 String.format("%s{\n%s}\n", getClass().getSimpleName(), getExtendedString(1)); } 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 @@ -122,41 +117,31 @@ protected String getExtendedString(int depth) { if (tempObject != null) { if (tempObject instanceof byte[]) { byte[] temp = (byte[]) tempObject; - 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(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); 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/ModificationFilter.java b/src/main/java/de/rub/nds/modifiablevariable/ModificationFilter.java index f7967f1b..94f19f0b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModificationFilter.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModificationFilter.java @@ -15,7 +15,7 @@ * data. For example, only the first data access returns a modified value. This can be achieved * using a ModificationFilter object. */ -@XmlSeeAlso({AccessModificationFilter.class}) +@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 56ceadf3..6558dcd8 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java @@ -32,16 +32,12 @@ public abstract class VariableModification { * ModificationFilter is responsible for validating if the modification can be executed. */ @XmlElements( - value = { - @XmlElement( - type = AccessModificationFilter.class, - name = "AccessModificationFilter") - }) - private ModificationFilter modificationFilter = null; + @XmlElement(type = AccessModificationFilter.class, name = "AccessModificationFilter")) + private ModificationFilter modificationFilter; public E modify(E input) { E modifiedValue = modifyImplementationHook(input); - if ((modificationFilter == null) || (!modificationFilter.filterModification())) { + if (modificationFilter == null || !modificationFilter.filterModification()) { debug(modifiedValue); return modifiedValue; } else { @@ -53,8 +49,10 @@ public E modify(E input) { public abstract VariableModification getModifiedCopy(); + public abstract VariableModification createCopy(); + /** - * 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 @@ -78,7 +76,7 @@ protected void debug(E value) { } LOGGER.debug( "Using {} in function:\n {}\n New value: {}", - this.getClass().getSimpleName(), + getClass().getSimpleName(), stack[index], valueString); } 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 905c8e56..cd555622 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java @@ -25,15 +25,18 @@ public class BigIntegerAddModification extends VariableModification private BigInteger summand; - public BigIntegerAddModification() {} + public BigIntegerAddModification() { + super(); + } - public BigIntegerAddModification(BigInteger bi) { - this.summand = bi; + public BigIntegerAddModification(BigInteger summand) { + super(); + this.summand = summand; } @Override protected BigInteger modifyImplementationHook(BigInteger input) { - return (input == null) ? summand : input.add(summand); + return input == null ? summand : input.add(summand); } public BigInteger getSummand() { @@ -50,6 +53,11 @@ public VariableModification getModifiedCopy() { summand.add(new BigInteger(MAX_ADD_LENGTH, new Random()))); } + @Override + public VariableModification createCopy() { + return new BigIntegerAddModification(summand); + } + @Override public int hashCode() { int hash = 7; @@ -68,7 +76,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final BigIntegerAddModification other = (BigIntegerAddModification) obj; - return Objects.equals(this.summand, other.summand); + BigIntegerAddModification other = (BigIntegerAddModification) obj; + return Objects.equals(summand, other.summand); } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java index 97f3f88e..c894edf1 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java @@ -25,10 +25,13 @@ public class BigIntegerAppendValueModification extends VariableModification getModifiedCopy() { appendValue.add(new BigInteger(MAX_APPEND_LENGTH, new Random()))); } + @Override + public VariableModification createCopy() { + return new BigIntegerAppendValueModification(appendValue); + } + @Override public int hashCode() { int hash = 7; @@ -71,7 +79,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final BigIntegerAppendValueModification other = (BigIntegerAppendValueModification) obj; - return Objects.equals(this.appendValue, other.appendValue); + BigIntegerAppendValueModification other = (BigIntegerAppendValueModification) obj; + return Objects.equals(appendValue, other.appendValue); } } 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 e4ea8dd1..9dae5aa7 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java @@ -25,14 +25,17 @@ public class BigIntegerExplicitValueModification extends VariableModification getModifiedCopy() { } } + @Override + public VariableModification createCopy() { + return new BigIntegerExplicitValueModification(explicitValue); + } + @Override public int hashCode() { int hash = 7; @@ -74,7 +82,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final BigIntegerExplicitValueModification other = (BigIntegerExplicitValueModification) obj; - return Objects.equals(this.explicitValue, other.explicitValue); + BigIntegerExplicitValueModification other = (BigIntegerExplicitValueModification) obj; + return Objects.equals(explicitValue, other.explicitValue); } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java index cf7d7efe..407b8bb2 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java @@ -27,10 +27,13 @@ public class BigIntegerInsertValueModification extends VariableModification getModifiedCopy() { } } + @Override + public VariableModification createCopy() { + return new BigIntegerInsertValueModification(insertValue, startPosition); + } + @Override public int hashCode() { int hash = 7; @@ -113,10 +121,10 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final BigIntegerInsertValueModification other = (BigIntegerInsertValueModification) obj; - if (this.startPosition != other.startPosition) { + BigIntegerInsertValueModification other = (BigIntegerInsertValueModification) obj; + if (startPosition != other.startPosition) { return false; } - return Objects.equals(this.insertValue, other.insertValue); + return Objects.equals(insertValue, other.insertValue); } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInteractiveModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInteractiveModification.java index 0ec3fa18..61162991 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInteractiveModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInteractiveModification.java @@ -16,23 +16,25 @@ import java.math.BigInteger; @XmlRootElement -@XmlType(propOrder = {"modificationFilter"}) +@XmlType(propOrder = "modificationFilter") @XmlAccessorType(XmlAccessType.FIELD) public class BigIntegerInteractiveModification extends VariableModification { - @XmlTransient private InteractiveBigIntegerModification modification; + @XmlTransient private final InteractiveBigIntegerModification modification; protected BigIntegerInteractiveModification() { - this.modification = BigIntegerModificationFactory.getStandardInteractiveModification(); + super(); + modification = BigIntegerModificationFactory.getStandardInteractiveModification(); } protected BigIntegerInteractiveModification(InteractiveBigIntegerModification modification) { + super(); this.modification = modification; } @Override - protected BigInteger modifyImplementationHook(final BigInteger input) { - return this.modification.modify(input); + protected BigInteger modifyImplementationHook(BigInteger input) { + return modification.modify(input); } public interface InteractiveBigIntegerModification { @@ -45,4 +47,10 @@ public VariableModification getModifiedCopy() { throw new UnsupportedOperationException( "This method is not supported for interactive modifications"); } + + @Override + public VariableModification createCopy() { + 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 0b04f0dc..66ab8f48 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationFactory.java @@ -22,7 +22,7 @@ import java.util.Random; import java.util.Scanner; -public class BigIntegerModificationFactory { +public final class BigIntegerModificationFactory { private enum ModificationType { ADD, @@ -54,55 +54,55 @@ private enum ModificationType { 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); } @@ -112,16 +112,16 @@ public static VariableModification explicitValueFromFile(int value) return modifications.get(pos); } - public static VariableModification appendValue(final BigInteger value) { + public static VariableModification appendValue(BigInteger value) { return new BigIntegerAppendValueModification(value); } public static VariableModification insertValue( - final BigInteger value, final int startPosition) { + BigInteger value, int startPosition) { return new BigIntegerInsertValueModification(value, startPosition); } - public static VariableModification prependValue(final BigInteger value) { + public static VariableModification prependValue(BigInteger value) { return new BigIntegerPrependValueModification(value); } @@ -137,11 +137,8 @@ public static VariableModification prependValue(final BigInteger val public BigInteger modify(BigInteger oldVal) { if (value == null) { System.out.println("Enter new value for BigInt: "); - Scanner scanner = new Scanner(System.in); - try { + try (Scanner scanner = new Scanner(System.in)) { value = scanner.nextBigInteger(); - } finally { - scanner.close(); } } return value; @@ -222,5 +219,7 @@ public static VariableModification createRandomModification() { } } - private BigIntegerModificationFactory() {} + private BigIntegerModificationFactory() { + super(); + } } 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 52975ae2..e5141c16 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java @@ -25,15 +25,18 @@ public class BigIntegerMultiplyModification extends VariableModification getModifiedCopy() { factor.add(new BigInteger(MAX_FACTOR_LENGTH, new Random()))); } + @Override + public VariableModification createCopy() { + return new BigIntegerMultiplyModification(factor); + } + @Override public int hashCode() { int hash = 7; @@ -68,7 +76,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final BigIntegerMultiplyModification other = (BigIntegerMultiplyModification) obj; - return Objects.equals(this.factor, other.factor); + BigIntegerMultiplyModification other = (BigIntegerMultiplyModification) obj; + return Objects.equals(factor, other.factor); } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java index 5a813b73..282bf2d6 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java @@ -25,10 +25,13 @@ public class BigIntegerPrependValueModification extends VariableModification getModifiedCopy() { prependValue.add(new BigInteger(MAX_PREPEND_LENGTH, new Random()))); } + @Override + public VariableModification createCopy() { + return new BigIntegerPrependValueModification(prependValue); + } + @Override public int hashCode() { int hash = 7; @@ -71,7 +79,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final BigIntegerPrependValueModification other = (BigIntegerPrependValueModification) obj; - return Objects.equals(this.prependValue, other.prependValue); + BigIntegerPrependValueModification other = (BigIntegerPrependValueModification) obj; + return Objects.equals(prependValue, other.prependValue); } } 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 6e42525a..569280c3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java @@ -24,9 +24,12 @@ public class BigIntegerShiftLeftModification extends VariableModification getModifiedCopy() { return new BigIntegerShiftLeftModification(shift + new Random().nextInt(MAX_SHIFT_LENGTH)); } + @Override + public VariableModification createCopy() { + return new BigIntegerShiftLeftModification(shift); + } + @Override public int hashCode() { int hash = 7; @@ -69,7 +77,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final BigIntegerShiftLeftModification other = (BigIntegerShiftLeftModification) obj; - return this.shift == other.shift; + BigIntegerShiftLeftModification other = (BigIntegerShiftLeftModification) obj; + return shift == other.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 27470f73..f103d976 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java @@ -24,9 +24,12 @@ public class BigIntegerShiftRightModification extends VariableModification getModifiedCopy() { return new BigIntegerShiftRightModification(shift + new Random().nextInt(MAX_SHIFT_LENGTH)); } + @Override + public VariableModification createCopy() { + return new BigIntegerShiftRightModification(shift); + } + @Override public int hashCode() { int hash = 7; @@ -69,7 +77,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final BigIntegerShiftRightModification other = (BigIntegerShiftRightModification) obj; - return this.shift == other.shift; + BigIntegerShiftRightModification other = (BigIntegerShiftRightModification) obj; + return shift == other.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 d77d0f38..a818dc8c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java @@ -25,10 +25,13 @@ public class BigIntegerSubtractModification extends VariableModification getModifiedCopy() { subtrahend.add(new BigInteger(MAX_SUBTRACT_LENGTH, new Random()))); } + @Override + public VariableModification createCopy() { + return new BigIntegerSubtractModification(subtrahend); + } + @Override public int hashCode() { int hash = 7; @@ -71,7 +79,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final BigIntegerSubtractModification other = (BigIntegerSubtractModification) obj; - return Objects.equals(this.subtrahend, other.subtrahend); + BigIntegerSubtractModification other = (BigIntegerSubtractModification) obj; + return Objects.equals(subtrahend, other.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 b416ff0a..2c3529a7 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java @@ -25,10 +25,13 @@ public class BigIntegerXorModification extends VariableModification private BigInteger xor; - public BigIntegerXorModification() {} + public BigIntegerXorModification() { + super(); + } - public BigIntegerXorModification(BigInteger bi) { - this.xor = bi; + public BigIntegerXorModification(BigInteger xor) { + super(); + this.xor = xor; } @Override @@ -52,6 +55,11 @@ public VariableModification getModifiedCopy() { return new BigIntegerXorModification(xor.add(new BigInteger(MAX_XOR_LENGTH, new Random()))); } + @Override + public VariableModification createCopy() { + return new BigIntegerXorModification(xor); + } + @Override public int hashCode() { int hash = 7; @@ -70,7 +78,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final BigIntegerXorModification other = (BigIntegerXorModification) obj; - return Objects.equals(this.xor, other.xor); + BigIntegerXorModification other = (BigIntegerXorModification) obj; + return Objects.equals(xor, other.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 03b4697e..d2af64c8 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigInteger.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigInteger.java @@ -21,6 +21,17 @@ public class ModifiableBigInteger extends ModifiableVariable { private BigInteger originalValue; + public ModifiableBigInteger() { + super(); + } + + public ModifiableBigInteger(ModifiableBigInteger other) { + super(other); + if (other != null) { + originalValue = other.originalValue; + } + } + @Override protected void createRandomModification() { VariableModification vm = @@ -28,6 +39,11 @@ protected void createRandomModification() { setModification(vm); } + @Override + public ModifiableBigInteger createCopy() { + return new ModifiableBigInteger(this); + } + public BigInteger getAssertEquals() { return assertEquals; } @@ -38,7 +54,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() { @@ -73,15 +89,15 @@ public String toString() { } @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)) { return false; } - ModifiableBigInteger that = (ModifiableBigInteger) o; + ModifiableBigInteger that = (ModifiableBigInteger) obj; 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 5ca6a23c..744ba2f9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanExplicitValueModification.java @@ -17,14 +17,17 @@ public class BooleanExplicitValueModification extends VariableModification getModifiedCopy() { return new BooleanExplicitValueModification(!explicitValue); } + @Override + public VariableModification createCopy() { + return new BooleanExplicitValueModification(explicitValue); + } + @Override public int hashCode() { int hash = 7; @@ -59,8 +67,8 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final BooleanExplicitValueModification other = (BooleanExplicitValueModification) obj; - return this.explicitValue == other.explicitValue; + 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 6ef65e1d..653d6ddb 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanModificationFactory.java @@ -11,7 +11,11 @@ import de.rub.nds.modifiablevariable.util.RandomHelper; import java.util.Random; -public class BooleanModificationFactory { +public final class BooleanModificationFactory { + + private BooleanModificationFactory() { + super(); + } private enum ModificationType { EXPLICIT_TRUE, @@ -40,7 +44,7 @@ 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 3f9da992..5d12e6ae 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanToggleModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanToggleModification.java @@ -12,10 +12,12 @@ import jakarta.xml.bind.annotation.XmlType; @XmlRootElement -@XmlType(propOrder = {"modificationFilter"}) +@XmlType(propOrder = "modificationFilter") public class BooleanToggleModification extends VariableModification { - public BooleanToggleModification() {} + public BooleanToggleModification() { + super(); + } @Override protected Boolean modifyImplementationHook(Boolean input) { @@ -30,10 +32,14 @@ public VariableModification getModifiedCopy() { return new BooleanToggleModification(); } + @Override + public VariableModification createCopy() { + return new BooleanToggleModification(); + } + @Override public int hashCode() { - int hash = 7; - return hash; + return 7; } @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 058e8f5d..3cf082d8 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/ModifiableBoolean.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/ModifiableBoolean.java @@ -19,12 +19,22 @@ 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); + if (other != null) { + originalValue = other.originalValue; + } + } + @Override public Boolean getOriginalValue() { return originalValue; @@ -41,9 +51,14 @@ protected void createRandomModification() { setModification(vm); } + @Override + public ModifiableBoolean createCopy() { + return new ModifiableBoolean(this); + } + @Override public boolean isOriginalValueModified() { - return getOriginalValue() != null && (getOriginalValue().compareTo(getValue()) != 0); + return originalValue != null && originalValue.compareTo(getValue()) != 0; } @Override @@ -60,15 +75,15 @@ public String toString() { } @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)) { return false; } - ModifiableBoolean that = (ModifiableBoolean) o; + ModifiableBoolean that = (ModifiableBoolean) obj; 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 index 95e2f2e7..9048b3d6 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java @@ -28,9 +28,12 @@ public class ByteArrayAppendValueModification extends VariableModification getModifiedCopy() { return new ByteArrayAppendValueModification(newValue); } + @Override + public VariableModification createCopy() { + return new ByteArrayAppendValueModification( + bytesToAppend != null ? bytesToAppend.clone() : null); + } + @Override public int hashCode() { int hash = 7; @@ -79,8 +88,8 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final ByteArrayAppendValueModification other = (ByteArrayAppendValueModification) obj; - return Arrays.equals(this.bytesToAppend, other.bytesToAppend); + ByteArrayAppendValueModification other = (ByteArrayAppendValueModification) obj; + return Arrays.equals(bytesToAppend, other.bytesToAppend); } @Override 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 6000870a..4838c43d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java @@ -29,9 +29,12 @@ public class ByteArrayDeleteModification extends VariableModification { private int startPosition; - public ByteArrayDeleteModification() {} + public ByteArrayDeleteModification() { + super(); + } public ByteArrayDeleteModification(int startPosition, int count) { + super(); this.startPosition = startPosition; this.count = count; } @@ -51,8 +54,8 @@ protected byte[] modifyImplementationHook(byte[] input) { return input; } } - final int endPosition = start + count; - if ((endPosition) > input.length) { + int endPosition = start + count; + if (endPosition > input.length) { LOGGER.debug( "Bytes {}..{} cannot be deleted from {{}} of length {}", start, @@ -67,7 +70,7 @@ protected byte[] modifyImplementationHook(byte[] input) { } byte[] ret1 = Arrays.copyOf(input, start); byte[] ret2 = null; - if ((endPosition) < input.length) { + if (endPosition < input.length) { ret2 = Arrays.copyOfRange(input, endPosition, input.length); } return ArrayConverter.concatenate(ret1, ret2); @@ -111,6 +114,11 @@ public VariableModification getModifiedCopy() { } } + @Override + public VariableModification createCopy() { + return new ByteArrayDeleteModification(startPosition, count); + } + @Override public int hashCode() { int hash = 7; @@ -130,11 +138,11 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final ByteArrayDeleteModification other = (ByteArrayDeleteModification) obj; - if (this.count != other.count) { + ByteArrayDeleteModification other = (ByteArrayDeleteModification) obj; + if (count != other.count) { return false; } - return this.startPosition == other.startPosition; + 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 32f1ebb7..55d5f3c0 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDuplicateModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDuplicateModification.java @@ -15,11 +15,13 @@ import jakarta.xml.bind.annotation.XmlType; @XmlRootElement -@XmlType(propOrder = {"modificationFilter"}) +@XmlType(propOrder = "modificationFilter") @XmlAccessorType(XmlAccessType.FIELD) public class ByteArrayDuplicateModification extends VariableModification { - public ByteArrayDuplicateModification() {} + public ByteArrayDuplicateModification() { + super(); + } @Override protected byte[] modifyImplementationHook(byte[] input) { @@ -34,10 +36,14 @@ public VariableModification getModifiedCopy() { return new ByteArrayDuplicateModification(); } + @Override + public VariableModification createCopy() { + return new ByteArrayDuplicateModification(); + } + @Override public int hashCode() { - int hash = 7; - return hash; + return 7; } @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 173a97ed..f62d2030 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java @@ -28,14 +28,17 @@ public class ByteArrayExplicitValueModification extends VariableModification getModifiedCopy() { return new ByteArrayExplicitValueModification(newValue); } + @Override + public VariableModification createCopy() { + return new ByteArrayExplicitValueModification( + explicitValue != null ? explicitValue.clone() : null); + } + @Override public int hashCode() { int hash = 7; @@ -85,7 +94,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final ByteArrayExplicitValueModification other = (ByteArrayExplicitValueModification) obj; - return Arrays.equals(this.explicitValue, other.explicitValue); + ByteArrayExplicitValueModification other = (ByteArrayExplicitValueModification) obj; + return Arrays.equals(explicitValue, other.explicitValue); } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java index d1523e7a..180f16b4 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java @@ -32,9 +32,12 @@ public class ByteArrayInsertValueModification extends VariableModification getModifiedCopy() { } } + @Override + public VariableModification createCopy() { + return new ByteArrayInsertValueModification( + bytesToInsert != null ? bytesToInsert.clone() : null, startPosition); + } + @Override public int hashCode() { int hash = 7; @@ -117,11 +126,11 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final ByteArrayInsertValueModification other = (ByteArrayInsertValueModification) obj; - if (this.startPosition != other.startPosition) { + ByteArrayInsertValueModification other = (ByteArrayInsertValueModification) obj; + if (startPosition != other.startPosition) { return false; } - return Arrays.equals(this.bytesToInsert, other.bytesToInsert); + return Arrays.equals(bytesToInsert, other.bytesToInsert); } @Override 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 0b2579a9..2dbca908 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayModificationFactory.java @@ -19,7 +19,7 @@ import java.util.List; import java.util.Random; -public class ByteArrayModificationFactory { +public final class ByteArrayModificationFactory { private enum ModificationType { XOR, @@ -50,7 +50,7 @@ private enum ModificationType { * @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); } @@ -62,15 +62,15 @@ public static VariableModification xor(final byte[] xor, final int start * @return variable modification */ public static VariableModification insertValue( - final byte[] bytesToInsert, final int startPosition) { + byte[] bytesToInsert, int startPosition) { return new ByteArrayInsertValueModification(bytesToInsert, startPosition); } - public static VariableModification appendValue(final byte[] bytesToAppend) { + public static VariableModification appendValue(byte[] bytesToAppend) { return new ByteArrayAppendValueModification(bytesToAppend); } - public static VariableModification prependValue(final byte[] bytesToPrepend) { + public static VariableModification prependValue(byte[] bytesToPrepend) { return new ByteArrayPrependValueModification(bytesToPrepend); } @@ -81,7 +81,7 @@ public static VariableModification prependValue(final byte[] bytesToPrep * @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); } @@ -94,7 +94,7 @@ public static VariableModification duplicate() { return new ByteArrayDuplicateModification(); } - public static VariableModification explicitValue(final byte[] explicitValue) { + public static VariableModification explicitValue(byte[] explicitValue) { return new ByteArrayExplicitValueModification(explicitValue); } @@ -110,7 +110,7 @@ public static VariableModification explicitValueFromFile(int value) { * @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); } @@ -192,5 +192,7 @@ public static VariableModification createRandomModification(byte[] origi } } - private ByteArrayModificationFactory() {} + private ByteArrayModificationFactory() { + super(); + } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java index 73585436..792c8872 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java @@ -28,9 +28,12 @@ public class ByteArrayPrependValueModification extends VariableModification getModifiedCopy() { return new ByteArrayPrependValueModification(newValue); } + @Override + public VariableModification createCopy() { + return new ByteArrayPrependValueModification( + bytesToPrepend != null ? bytesToPrepend.clone() : null); + } + @Override public int hashCode() { int hash = 7; @@ -79,8 +88,8 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final ByteArrayPrependValueModification other = (ByteArrayPrependValueModification) obj; - return Arrays.equals(this.bytesToPrepend, other.bytesToPrepend); + ByteArrayPrependValueModification other = (ByteArrayPrependValueModification) obj; + return Arrays.equals(bytesToPrepend, other.bytesToPrepend); } @Override 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 862bcb7e..0ce87fd3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayShuffleModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayShuffleModification.java @@ -32,14 +32,17 @@ public class ByteArrayShuffleModification extends VariableModification { @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) private byte[] shuffle; - public ByteArrayShuffleModification() {} + public ByteArrayShuffleModification() { + super(); + } public ByteArrayShuffleModification(byte[] shuffle) { + super(); this.shuffle = shuffle; } @Override - protected byte[] modifyImplementationHook(final byte[] input) { + protected byte[] modifyImplementationHook(byte[] input) { if (input == null) { return input; } @@ -74,6 +77,11 @@ public VariableModification getModifiedCopy() { return new ByteArrayShuffleModification(newValue); } + @Override + public VariableModification createCopy() { + return new ByteArrayShuffleModification(shuffle != null ? shuffle.clone() : null); + } + @Override public int hashCode() { int hash = 7; @@ -92,8 +100,8 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final ByteArrayShuffleModification other = (ByteArrayShuffleModification) obj; - return Arrays.equals(this.shuffle, other.shuffle); + 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 d8b19a43..9dfbb39b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java @@ -32,9 +32,12 @@ public class ByteArrayXorModification extends VariableModification { private int startPosition; - public ByteArrayXorModification() {} + public ByteArrayXorModification() { + super(); + } public ByteArrayXorModification(byte[] xor, int startPosition) { + super(); this.xor = xor; this.startPosition = startPosition; } @@ -49,7 +52,7 @@ protected byte[] modifyImplementationHook(byte[] input) { if (start < 0) { start += input.length; } - final int end = start + xor.length; + int end = start + xor.length; if (end > result.length) { // result = new byte[end]; // System.arraycopy(input, 0, result, 0, input.length); @@ -106,6 +109,11 @@ public VariableModification getModifiedCopy() { } } + @Override + public VariableModification createCopy() { + return new ByteArrayXorModification(xor != null ? xor.clone() : null, startPosition); + } + @Override public int hashCode() { int hash = 7; @@ -125,11 +133,11 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final ByteArrayXorModification other = (ByteArrayXorModification) obj; - if (this.startPosition != other.startPosition) { + ByteArrayXorModification other = (ByteArrayXorModification) obj; + if (startPosition != other.startPosition) { return false; } - return Arrays.equals(this.xor, other.xor); + 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..f989cf46 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArray.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArray.java @@ -21,10 +21,21 @@ @XmlAccessorType(XmlAccessType.PROPERTY) public class ModifiableByteArray extends ModifiableVariable { - public ModifiableByteArray() {} - private byte[] originalValue; + public ModifiableByteArray() { + super(); + } + + @SuppressWarnings("IncompleteCopyConstructor") + public ModifiableByteArray(ModifiableByteArray other) { + super(other); + if (other != null) { + originalValue = other.originalValue != null ? other.originalValue.clone() : null; + assertEquals = other.assertEquals != null ? other.assertEquals.clone() : null; + } + } + @Override protected void createRandomModification() { VariableModification vm = @@ -32,6 +43,11 @@ protected void createRandomModification() { setModification(vm); } + @Override + public ModifiableByteArray createCopy() { + return new ModifiableByteArray(this); + } + @Override @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) public byte[] getOriginalValue() { @@ -71,28 +87,28 @@ public boolean validateAssertions() { @Override public String toString() { StringBuilder result = new StringBuilder(); - if (this.isOriginalValueModified()) { + if (isOriginalValueModified()) { result.append("Actual byte value is: "); result.append(ArrayConverter.bytesToHexString(this)); result.append("\nOriginal value was: "); - result.append(ArrayConverter.bytesToHexString(this.getOriginalValue())); + result.append(ArrayConverter.bytesToHexString(getOriginalValue())); } else { result.append("Original byte value is: "); - result.append(ArrayConverter.bytesToHexString(this.getOriginalValue())); + result.append(ArrayConverter.bytesToHexString(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)) { return false; } - ModifiableByteArray that = (ModifiableByteArray) o; + ModifiableByteArray that = (ModifiableByteArray) obj; return Arrays.equals(getValue(), that.getValue()); } diff --git a/src/main/java/de/rub/nds/modifiablevariable/filter/AccessModificationFilter.java b/src/main/java/de/rub/nds/modifiablevariable/filter/AccessModificationFilter.java index 02daf06f..54ca94cf 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/filter/AccessModificationFilter.java +++ b/src/main/java/de/rub/nds/modifiablevariable/filter/AccessModificationFilter.java @@ -29,10 +29,12 @@ public class AccessModificationFilter extends ModificationFilter { private int[] accessNumbers; public AccessModificationFilter() { + super(); accessCounter = 1; } - public AccessModificationFilter(final int[] accessNumbers) { + public AccessModificationFilter(int[] accessNumbers) { + super(); accessCounter = 1; this.accessNumbers = accessNumbers; } @@ -44,7 +46,7 @@ public boolean filterModification() { return filter; } - private boolean contains(int[] numbers, int number) { + private static boolean contains(int[] numbers, int number) { for (int i : numbers) { if (i == number) { return true; diff --git a/src/main/java/de/rub/nds/modifiablevariable/filter/ModificationFilterFactory.java b/src/main/java/de/rub/nds/modifiablevariable/filter/ModificationFilterFactory.java index db70b67f..66a46b03 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/filter/ModificationFilterFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/filter/ModificationFilterFactory.java @@ -7,11 +7,13 @@ */ package de.rub.nds.modifiablevariable.filter; -public class ModificationFilterFactory { +public final class ModificationFilterFactory { - public static AccessModificationFilter access(final int[] accessNumbers) { + public static AccessModificationFilter access(int[] accessNumbers) { return new AccessModificationFilter(accessNumbers); } - private ModificationFilterFactory() {} + private ModificationFilterFactory() { + super(); + } } 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 fb1e15e5..129906ac 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAddModification.java @@ -21,15 +21,18 @@ public class IntegerAddModification extends VariableModification { private Integer summand; - public IntegerAddModification() {} + public IntegerAddModification() { + super(); + } public IntegerAddModification(Integer summand) { + super(); this.summand = summand; } @Override protected Integer modifyImplementationHook(Integer input) { - return (input == null) ? summand : input + summand; + return input == null ? summand : input + summand; } public Integer getSummand() { @@ -45,6 +48,11 @@ public VariableModification getModifiedCopy() { return new IntegerAddModification(summand + new Random().nextInt(MAX_ADD_MODIFIER)); } + @Override + public VariableModification createCopy() { + return new IntegerAddModification(summand); + } + @Override public int hashCode() { int hash = 7; @@ -63,7 +71,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final IntegerAddModification other = (IntegerAddModification) obj; - return Objects.equals(this.summand, other.summand); + IntegerAddModification other = (IntegerAddModification) obj; + return Objects.equals(summand, other.summand); } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java index b2a1f4d7..572f6590 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java @@ -21,9 +21,12 @@ public class IntegerAppendValueModification extends VariableModification getModifiedCopy() { appendValue + new Random().nextInt(MAX_VALUE_MODIFIER)); } + @Override + public VariableModification createCopy() { + return new IntegerAppendValueModification(appendValue); + } + @Override public int hashCode() { int hash = 7; @@ -68,7 +75,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final IntegerAppendValueModification other = (IntegerAppendValueModification) obj; - return Objects.equals(this.appendValue, other.appendValue); + IntegerAppendValueModification other = (IntegerAppendValueModification) obj; + return Objects.equals(appendValue, other.appendValue); } } 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 1f207cf8..408d704c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueModification.java @@ -21,14 +21,17 @@ public class IntegerExplicitValueModification extends VariableModification getModifiedCopy() { } } + @Override + public VariableModification createCopy() { + return new IntegerExplicitValueModification(explicitValue); + } + @Override public int hashCode() { int hash = 7; @@ -70,7 +78,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final IntegerExplicitValueModification other = (IntegerExplicitValueModification) obj; - return Objects.equals(this.explicitValue, other.explicitValue); + IntegerExplicitValueModification other = (IntegerExplicitValueModification) obj; + return Objects.equals(explicitValue, other.explicitValue); } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java index c5cf0701..36b0c277 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java @@ -25,9 +25,12 @@ public class IntegerInsertValueModification extends VariableModification> insertPosition) << insertValueLength) | insertValue) << insertPosition - | (mask & input); + return (input >> insertPosition << insertValueLength | insertValue) << insertPosition + | mask & input; } public Integer getInsertValue() { @@ -88,6 +91,11 @@ public VariableModification getModifiedCopy() { } } + @Override + public VariableModification createCopy() { + return new IntegerInsertValueModification(insertValue, startPosition); + } + @Override public int hashCode() { int hash = 7; @@ -107,10 +115,10 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final IntegerInsertValueModification other = (IntegerInsertValueModification) obj; - if (this.startPosition != other.startPosition) { + IntegerInsertValueModification other = (IntegerInsertValueModification) obj; + if (startPosition != other.startPosition) { return false; } - return Objects.equals(this.insertValue, other.insertValue); + return Objects.equals(insertValue, other.insertValue); } } 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 dd596e93..f1646c61 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerModificationFactory.java @@ -18,7 +18,7 @@ import java.util.List; import java.util.Random; -public class IntegerModificationFactory { +public final class IntegerModificationFactory { private enum ModificationType { ADD, @@ -52,51 +52,51 @@ private enum ModificationType { 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) { + public static VariableModification explicitValue(String value) { return explicitValue(Integer.parseInt(value)); } - public static VariableModification explicitValue(final Integer value) { + public static VariableModification explicitValue(Integer value) { return new IntegerExplicitValueModification(value); } @@ -106,20 +106,19 @@ public static VariableModification explicitValueFromFile(int value) { return modifications.get(pos); } - public static VariableModification appendValue(final Integer value) { + public static VariableModification appendValue(Integer value) { return new IntegerAppendValueModification(value); } - public static VariableModification insertValue( - final Integer value, final int position) { + public static VariableModification insertValue(Integer value, int position) { return new IntegerInsertValueModification(value, position); } - public static VariableModification prependValue(final Integer value) { + public static VariableModification prependValue(Integer value) { return new IntegerPrependValueModification(value); } - public static VariableModification multiply(final Integer value) { + public static VariableModification multiply(Integer value) { return new IntegerMultiplyModification(value); } @@ -180,5 +179,7 @@ public static VariableModification createRandomModification() { } } - private IntegerModificationFactory() {} + private IntegerModificationFactory() { + super(); + } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java index 5c2fced9..a978315c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java @@ -21,15 +21,18 @@ public class IntegerMultiplyModification extends VariableModification { private Integer factor; - public IntegerMultiplyModification() {} + public IntegerMultiplyModification() { + super(); + } public IntegerMultiplyModification(Integer factor) { + super(); this.factor = factor; } @Override protected Integer modifyImplementationHook(Integer input) { - return (input == null) ? 0 : input * factor; + return input == null ? 0 : input * factor; } public Integer getFactor() { @@ -47,6 +50,11 @@ public VariableModification getModifiedCopy() { return new IntegerMultiplyModification(factor + r.nextInt(MAX_FACTOR_MODIFIER)); } + @Override + public VariableModification createCopy() { + return new IntegerMultiplyModification(factor); + } + @Override public int hashCode() { int hash = 7; @@ -65,7 +73,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final IntegerMultiplyModification other = (IntegerMultiplyModification) obj; - return Objects.equals(this.factor, other.factor); + IntegerMultiplyModification other = (IntegerMultiplyModification) obj; + return Objects.equals(factor, other.factor); } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java index 67ff5ff1..67c970a3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java @@ -21,9 +21,12 @@ public class IntegerPrependValueModification extends VariableModification getModifiedCopy() { prependValue + new Random().nextInt(MAX_VALUE_MODIFIER)); } + @Override + public VariableModification createCopy() { + return new IntegerPrependValueModification(prependValue); + } + @Override public int hashCode() { int hash = 7; @@ -68,7 +76,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final IntegerPrependValueModification other = (IntegerPrependValueModification) obj; - return Objects.equals(this.prependValue, other.prependValue); + IntegerPrependValueModification other = (IntegerPrependValueModification) obj; + return Objects.equals(prependValue, other.prependValue); } } 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 f99cdfa8..f619d774 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftLeftModification.java @@ -20,15 +20,18 @@ public class IntegerShiftLeftModification extends VariableModification private int shift; - public IntegerShiftLeftModification() {} + public IntegerShiftLeftModification() { + super(); + } public IntegerShiftLeftModification(int shift) { + super(); this.shift = shift; } @Override protected Integer modifyImplementationHook(Integer input) { - return (input == null) ? 0 : input << shift % MAX_SHIFT_MODIFIER; + return input == null ? 0 : input << shift % MAX_SHIFT_MODIFIER; } public int getShift() { @@ -56,6 +59,11 @@ public VariableModification getModifiedCopy() { return new IntegerShiftLeftModification(newShift); } + @Override + public VariableModification createCopy() { + return new IntegerShiftLeftModification(shift); + } + @Override public int hashCode() { int hash = 7; @@ -74,7 +82,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final IntegerShiftLeftModification other = (IntegerShiftLeftModification) obj; - return this.shift == other.shift; + IntegerShiftLeftModification other = (IntegerShiftLeftModification) obj; + return shift == other.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 367e16d0..7fe13833 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftRightModification.java @@ -20,15 +20,18 @@ public class IntegerShiftRightModification extends VariableModification private int shift; - public IntegerShiftRightModification() {} + public IntegerShiftRightModification() { + super(); + } public IntegerShiftRightModification(int shift) { + super(); this.shift = shift; } @Override - protected Integer modifyImplementationHook(final Integer input) { - return (input == null) ? 0 : input >> shift % MAX_SHIFT_MODIFIER; + protected Integer modifyImplementationHook(Integer input) { + return input == null ? 0 : input >> shift % MAX_SHIFT_MODIFIER; } public int getShift() { @@ -56,6 +59,11 @@ public VariableModification getModifiedCopy() { return new IntegerShiftRightModification(newShift); } + @Override + public VariableModification createCopy() { + return new IntegerShiftRightModification(shift); + } + @Override public int hashCode() { int hash = 7; @@ -74,7 +82,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final IntegerShiftRightModification other = (IntegerShiftRightModification) obj; - return this.shift == other.shift; + IntegerShiftRightModification other = (IntegerShiftRightModification) obj; + return shift == other.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 06916072..aa070ac2 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSubtractModification.java @@ -21,15 +21,18 @@ public class IntegerSubtractModification extends VariableModification { private Integer subtrahend; - public IntegerSubtractModification() {} + public IntegerSubtractModification() { + super(); + } public IntegerSubtractModification(Integer subtrahend) { + super(); this.subtrahend = subtrahend; } @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() { @@ -46,6 +49,11 @@ public VariableModification getModifiedCopy() { subtrahend + new Random().nextInt(MAX_SUBTRACT_MODIFIER)); } + @Override + public VariableModification createCopy() { + return new IntegerSubtractModification(subtrahend); + } + @Override public int hashCode() { int hash = 7; @@ -64,7 +72,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final IntegerSubtractModification other = (IntegerSubtractModification) obj; - return Objects.equals(this.subtrahend, other.subtrahend); + IntegerSubtractModification other = (IntegerSubtractModification) obj; + return Objects.equals(subtrahend, other.subtrahend); } } 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 a91e8fb7..09c6e09a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerXorModification.java @@ -21,15 +21,18 @@ public class IntegerXorModification extends VariableModification { private Integer xor; - public IntegerXorModification() {} + public IntegerXorModification() { + super(); + } public IntegerXorModification(Integer xor) { + super(); this.xor = xor; } @Override - protected Integer modifyImplementationHook(final Integer input) { - return (input == null) ? xor : input ^ xor; + protected Integer modifyImplementationHook(Integer input) { + return input == null ? xor : input ^ xor; } public Integer getXor() { @@ -44,12 +47,17 @@ public void setXor(Integer xor) { public VariableModification getModifiedCopy() { Random r = new Random(); if (r.nextBoolean()) { - return new IntegerSubtractModification(xor + new Random().nextInt(MAX_VALUE_MODIFIER)); + return new IntegerXorModification(xor + new Random().nextInt(MAX_VALUE_MODIFIER)); } else { - return new IntegerSubtractModification(xor - new Random().nextInt(MAX_VALUE_MODIFIER)); + return new IntegerXorModification(xor - new Random().nextInt(MAX_VALUE_MODIFIER)); } } + @Override + public VariableModification createCopy() { + return new IntegerXorModification(xor); + } + @Override public int hashCode() { int hash = 7; @@ -68,7 +76,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final IntegerXorModification other = (IntegerXorModification) obj; - return Objects.equals(this.xor, other.xor); + IntegerXorModification other = (IntegerXorModification) obj; + return Objects.equals(xor, other.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..2f401a2b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/ModifiableInteger.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/ModifiableInteger.java @@ -20,12 +20,28 @@ public class ModifiableInteger extends ModifiableVariable { private Integer originalValue; + public ModifiableInteger() { + super(); + } + + public ModifiableInteger(ModifiableInteger other) { + super(other); + if (other != null) { + originalValue = other.originalValue; + } + } + @Override protected void createRandomModification() { VariableModification vm = IntegerModificationFactory.createRandomModification(); setModification(vm); } + @Override + public ModifiableInteger createCopy() { + return new ModifiableInteger(this); + } + public Integer getAssertEquals() { return assertEquals; } @@ -70,15 +86,15 @@ public String toString() { } @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)) { return false; } - ModifiableInteger that = (ModifiableInteger) o; + ModifiableInteger that = (ModifiableInteger) obj; 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..175cefc0 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; @@ -40,17 +51,17 @@ public String 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)) { return false; } - ModifiableLengthField that = (ModifiableLengthField) o; + ModifiableLengthField that = (ModifiableLengthField) obj; - return ref != null ? getValue().equals(that.getValue()) : that.getValue() == null; + return ref != null ? getValue().equals(getValue()) : that.getValue() == null; } @Override 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..fa8009b1 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) { @@ -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,76 @@ 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("]"); + return String.format( + "%s[patternSelector=%s, replace=%s]", + super.toString(), patternSelector.toString(), replace.toString()); } } @@ -421,28 +418,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 +486,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 +535,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 +546,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 f37fbc26..2a2bc5a8 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java @@ -21,15 +21,18 @@ public class LongAddModification extends VariableModification { private Long summand; - public LongAddModification() {} + public LongAddModification() { + super(); + } public LongAddModification(Long summand) { + super(); this.summand = summand; } @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() { @@ -45,6 +48,11 @@ public VariableModification getModifiedCopy() { return new LongAddModification(summand + new Random().nextInt(MAX_ADD_MODIFIER)); } + @Override + public VariableModification createCopy() { + return new LongAddModification(summand); + } + @Override public int hashCode() { int hash = 7; @@ -63,7 +71,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final LongAddModification other = (LongAddModification) obj; - return Objects.equals(this.summand, other.summand); + LongAddModification other = (LongAddModification) obj; + return Objects.equals(summand, other.summand); } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java index b7177fda..04bfa005 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java @@ -21,9 +21,12 @@ public class LongAppendValueModification extends VariableModification { private Long appendValue; - public LongAppendValueModification() {} + public LongAppendValueModification() { + super(); + } public LongAppendValueModification(Long appendValue) { + super(); this.appendValue = appendValue; } @@ -32,7 +35,7 @@ protected Long modifyImplementationHook(Long input) { if (input == null) { input = 0L; } - return (input << (Long.SIZE - Long.numberOfLeadingZeros((appendValue)))) | appendValue; + return input << Long.SIZE - Long.numberOfLeadingZeros(appendValue) | appendValue; } public Long getAppendValue() { @@ -49,6 +52,11 @@ public VariableModification getModifiedCopy() { appendValue + new Random().nextInt(MAX_VALUE_MODIFIER)); } + @Override + public VariableModification createCopy() { + return new LongAppendValueModification(appendValue); + } + @Override public int hashCode() { int hash = 7; @@ -67,7 +75,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final LongAppendValueModification other = (LongAppendValueModification) obj; - return Objects.equals(this.appendValue, other.appendValue); + LongAppendValueModification other = (LongAppendValueModification) obj; + return Objects.equals(appendValue, other.appendValue); } } 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 bfdc1b8c..44145053 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java @@ -21,14 +21,17 @@ public class LongExplicitValueModification extends VariableModification { private Long explicitValue; - public LongExplicitValueModification() {} + public LongExplicitValueModification() { + super(); + } public LongExplicitValueModification(Long explicitValue) { + super(); this.explicitValue = explicitValue; } @Override - protected Long modifyImplementationHook(final Long input) { + protected Long modifyImplementationHook(Long input) { return explicitValue; } @@ -52,6 +55,11 @@ public VariableModification getModifiedCopy() { } } + @Override + public VariableModification createCopy() { + return new LongExplicitValueModification(explicitValue); + } + @Override public int hashCode() { int hash = 7; @@ -70,7 +78,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final LongExplicitValueModification other = (LongExplicitValueModification) obj; - return Objects.equals(this.explicitValue, other.explicitValue); + LongExplicitValueModification other = (LongExplicitValueModification) obj; + return Objects.equals(explicitValue, other.explicitValue); } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java index 88a24f17..a16e9e02 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java @@ -23,9 +23,12 @@ public class LongInsertValueModification extends VariableModification { private Long insertValue; private int startPosition; - public LongInsertValueModification() {} + public LongInsertValueModification() { + super(); + } public LongInsertValueModification(Long insertValue, int startPosition) { + super(); this.insertValue = insertValue; this.startPosition = startPosition; } @@ -36,7 +39,7 @@ protected Long modifyImplementationHook(Long input) { input = 0L; } - int insertValueLength = Long.SIZE - Long.numberOfLeadingZeros((insertValue)); + int insertValueLength = Long.SIZE - Long.numberOfLeadingZeros(insertValue); // Wrap around long size int insertPosition = startPosition % Long.SIZE; @@ -44,10 +47,10 @@ protected Long modifyImplementationHook(Long input) { insertPosition += Long.SIZE - 1; } - long mask = ((1L << insertPosition) - 1); + long mask = (1L << insertPosition) - 1; - return (((input >> insertPosition) << insertValueLength) | insertValue) << insertPosition - | (mask & input); + return (input >> insertPosition << insertValueLength | insertValue) << insertPosition + | mask & input; } public Long getInsertValue() { @@ -86,6 +89,11 @@ public VariableModification getModifiedCopy() { } } + @Override + public VariableModification createCopy() { + return new LongInsertValueModification(insertValue, startPosition); + } + @Override public int hashCode() { int hash = 7; @@ -105,10 +113,10 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final LongInsertValueModification other = (LongInsertValueModification) obj; - if (this.startPosition != other.startPosition) { + LongInsertValueModification other = (LongInsertValueModification) obj; + if (startPosition != other.startPosition) { return false; } - return Objects.equals(this.insertValue, other.insertValue); + return Objects.equals(insertValue, other.insertValue); } } 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 549b1357..c0c66a7b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongModificationFactory.java @@ -19,7 +19,7 @@ import java.util.List; import java.util.Random; -public class LongModificationFactory { +public final class LongModificationFactory { private enum ModificationType { ADD, @@ -53,35 +53,35 @@ private enum ModificationType { public static final String FILE_NAME = "de/rub/nds/modifiablevariable/explicit/long.vec"; - 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 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); } @@ -91,27 +91,27 @@ public static VariableModification explicitValueFromFile(int value) { return modifications.get(pos); } - public static VariableModification appendValue(final Long value) { + public static VariableModification appendValue(Long value) { return new LongAppendValueModification(value); } - public static VariableModification insertValue(final Long value, final int position) { + public static VariableModification insertValue(Long value, int position) { return new LongInsertValueModification(value, position); } - public static VariableModification prependValue(final Long value) { + public static VariableModification prependValue(Long value) { return new LongPrependValueModification(value); } - public static VariableModification multiply(final Long factor) { + public static VariableModification multiply(Long factor) { return new LongMultiplyModification(factor); } - public static VariableModification shiftLeft(final int shift) { + public static VariableModification shiftLeft(int shift) { return new LongShiftLeftModification(shift); } - public static VariableModification shiftRight(final int shift) { + public static VariableModification shiftRight(int shift) { return new LongShiftRightModification(shift); } @@ -172,5 +172,7 @@ public static VariableModification createRandomModification() { } } - 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 index 0c1a9f16..463d82f3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java @@ -21,15 +21,18 @@ public class LongMultiplyModification extends VariableModification { private Long factor; - public LongMultiplyModification() {} + public LongMultiplyModification() { + super(); + } public LongMultiplyModification(Long factor) { + super(); this.factor = factor; } @Override - protected Long modifyImplementationHook(final Long input) { - return (input == null) ? 0L : input * factor; + protected Long modifyImplementationHook(Long input) { + return input == null ? 0L : input * factor; } public Long getFactor() { @@ -45,6 +48,11 @@ public VariableModification getModifiedCopy() { return new LongMultiplyModification(factor + new Random().nextInt(MAX_FACTOR_MODIFIER)); } + @Override + public VariableModification createCopy() { + return new LongMultiplyModification(factor); + } + @Override public int hashCode() { int hash = 7; @@ -63,7 +71,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final LongMultiplyModification other = (LongMultiplyModification) obj; - return Objects.equals(this.factor, other.factor); + LongMultiplyModification other = (LongMultiplyModification) obj; + return Objects.equals(factor, other.factor); } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java index b803d6cc..e0ec7815 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java @@ -21,9 +21,12 @@ public class LongPrependValueModification extends VariableModification { private Long prependValue; - public LongPrependValueModification() {} + public LongPrependValueModification() { + super(); + } public LongPrependValueModification(Long prependValue) { + super(); this.prependValue = prependValue; } @@ -32,7 +35,7 @@ protected Long modifyImplementationHook(Long input) { if (input == null) { input = 0L; } - return (prependValue << (Long.SIZE - Long.numberOfLeadingZeros((input)))) | input; + return prependValue << Long.SIZE - Long.numberOfLeadingZeros(input) | input; } public Long getPrependValue() { @@ -49,6 +52,11 @@ public VariableModification getModifiedCopy() { prependValue + new Random().nextInt(MAX_VALUE_MODIFIER)); } + @Override + public VariableModification createCopy() { + return new LongPrependValueModification(prependValue); + } + @Override public int hashCode() { int hash = 7; @@ -67,7 +75,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final LongPrependValueModification other = (LongPrependValueModification) obj; - return Objects.equals(this.prependValue, other.prependValue); + LongPrependValueModification other = (LongPrependValueModification) obj; + return Objects.equals(prependValue, other.prependValue); } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java index 02cfbc36..bf508fef 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java @@ -21,15 +21,18 @@ public class LongShiftLeftModification extends VariableModification { private int shift; - public LongShiftLeftModification() {} + public LongShiftLeftModification() { + super(); + } public LongShiftLeftModification(int shift) { + super(); this.shift = shift; } @Override - protected Long modifyImplementationHook(final Long input) { - return (input == null) ? 0L : input << shift % MAX_SHIFT_MODIFIER; + protected Long modifyImplementationHook(Long input) { + return input == null ? 0L : input << shift % MAX_SHIFT_MODIFIER; } public int getShift() { @@ -58,6 +61,11 @@ public VariableModification getModifiedCopy() { return new LongShiftLeftModification(newShift); } + @Override + public VariableModification createCopy() { + return new LongShiftLeftModification(shift); + } + @Override public int hashCode() { int hash = 7; @@ -76,7 +84,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final LongShiftLeftModification other = (LongShiftLeftModification) obj; - return Objects.equals(this.shift, other.shift); + LongShiftLeftModification other = (LongShiftLeftModification) obj; + return Objects.equals(shift, other.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 index 511eaf79..c901d719 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java @@ -21,15 +21,18 @@ public class LongShiftRightModification extends VariableModification { private int shift; - public LongShiftRightModification() {} + public LongShiftRightModification() { + super(); + } public LongShiftRightModification(int shift) { + super(); this.shift = shift; } @Override - protected Long modifyImplementationHook(final Long input) { - return (input == null) ? 0L : input >> shift % MAX_SHIFT_MODIFIER; + protected Long modifyImplementationHook(Long input) { + return input == null ? 0L : input >> shift % MAX_SHIFT_MODIFIER; } public int getShift() { @@ -58,6 +61,11 @@ public VariableModification getModifiedCopy() { return new LongShiftRightModification(newShift); } + @Override + public VariableModification createCopy() { + return new LongShiftRightModification(shift); + } + @Override public int hashCode() { int hash = 7; @@ -76,7 +84,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final LongShiftRightModification other = (LongShiftRightModification) obj; - return Objects.equals(this.shift, other.shift); + LongShiftRightModification other = (LongShiftRightModification) obj; + return Objects.equals(shift, other.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 b43b0a8d..f303ca8e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java @@ -21,15 +21,18 @@ public class LongSubtractModification extends VariableModification { private Long subtrahend; - public LongSubtractModification() {} + public LongSubtractModification() { + super(); + } public LongSubtractModification(Long subtrahend) { + super(); this.subtrahend = subtrahend; } @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() { @@ -46,6 +49,11 @@ public VariableModification getModifiedCopy() { subtrahend + new Random().nextInt(MAX_SUBTRACT_MODIFIER)); } + @Override + public VariableModification createCopy() { + return new LongSubtractModification(subtrahend); + } + @Override public int hashCode() { int hash = 7; @@ -64,7 +72,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final LongSubtractModification other = (LongSubtractModification) obj; - return Objects.equals(this.subtrahend, other.subtrahend); + LongSubtractModification other = (LongSubtractModification) obj; + return Objects.equals(subtrahend, other.subtrahend); } } 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 07bd6141..650704f7 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java @@ -21,15 +21,18 @@ public class LongXorModification extends VariableModification { private Long xor; - public LongXorModification() {} + public LongXorModification() { + super(); + } public LongXorModification(Long xor) { + super(); this.xor = xor; } @Override - protected Long modifyImplementationHook(final Long input) { - return (input == null) ? xor : input ^ xor; + protected Long modifyImplementationHook(Long input) { + return input == null ? xor : input ^ xor; } public Long getXor() { @@ -50,6 +53,11 @@ public VariableModification getModifiedCopy() { } } + @Override + public VariableModification createCopy() { + return new LongXorModification(xor); + } + @Override public int hashCode() { int hash = 7; @@ -68,7 +76,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final LongXorModification other = (LongXorModification) obj; - return Objects.equals(this.xor, other.xor); + LongXorModification other = (LongXorModification) obj; + return Objects.equals(xor, other.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..b9204760 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/ModifiableLong.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/ModifiableLong.java @@ -20,12 +20,28 @@ public class ModifiableLong extends ModifiableVariable { private Long originalValue; + public ModifiableLong() { + super(); + } + + public ModifiableLong(ModifiableLong other) { + super(other); + if (other != null) { + originalValue = other.originalValue; + } + } + @Override protected void createRandomModification() { VariableModification vm = LongModificationFactory.createRandomModification(); setModification(vm); } + @Override + public ModifiableLong createCopy() { + return new ModifiableLong(this); + } + public Long getAssertEquals() { return assertEquals; } @@ -70,15 +86,15 @@ public String toString() { } @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)) { return false; } - ModifiableLong that = (ModifiableLong) o; + ModifiableLong that = (ModifiableLong) obj; 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 4e4e598f..54482223 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteAddModification.java @@ -21,10 +21,13 @@ public class ByteAddModification extends VariableModification { private Byte summand; - public ByteAddModification() {} + public ByteAddModification() { + super(); + } - public ByteAddModification(Byte bi) { - this.summand = bi; + public ByteAddModification(Byte summand) { + super(); + this.summand = summand; } @Override @@ -48,6 +51,11 @@ public VariableModification getModifiedCopy() { return new ByteAddModification((byte) (summand + new Random().nextInt(MAX_ADD_MODIFIER))); } + @Override + public VariableModification createCopy() { + return new ByteAddModification(summand); + } + @Override public int hashCode() { int hash = 7; @@ -66,7 +74,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final ByteAddModification other = (ByteAddModification) obj; - return Objects.equals(this.summand, other.summand); + ByteAddModification other = (ByteAddModification) obj; + return Objects.equals(summand, other.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 7a428b7c..b2439ae5 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueModification.java @@ -21,14 +21,17 @@ public class ByteExplicitValueModification extends VariableModification { private Byte explicitValue; - public ByteExplicitValueModification() {} + public ByteExplicitValueModification() { + super(); + } - public ByteExplicitValueModification(Byte bi) { - this.explicitValue = bi; + public ByteExplicitValueModification(Byte explicitValue) { + super(); + this.explicitValue = explicitValue; } @Override - protected Byte modifyImplementationHook(final Byte input) { + protected Byte modifyImplementationHook(Byte input) { return explicitValue; } @@ -52,6 +55,11 @@ public VariableModification getModifiedCopy() { } } + @Override + public VariableModification createCopy() { + return new ByteAddModification(explicitValue); + } + @Override public int hashCode() { int hash = 7; @@ -70,7 +78,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final ByteExplicitValueModification other = (ByteExplicitValueModification) obj; - return Objects.equals(this.explicitValue, other.explicitValue); + ByteExplicitValueModification other = (ByteExplicitValueModification) obj; + return Objects.equals(explicitValue, other.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 200925eb..b9179be3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteModificationFactory.java @@ -18,7 +18,7 @@ import java.util.List; import java.util.Random; -public class ByteModificationFactory { +public final class ByteModificationFactory { private enum ModificationType { ADD, @@ -34,35 +34,35 @@ private enum ModificationType { 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); } @@ -112,5 +112,7 @@ public static VariableModification createRandomModification() { } } - private ByteModificationFactory() {} + private ByteModificationFactory() { + super(); + } } 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 1df8179e..fb6627bc 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteSubtractModification.java @@ -21,10 +21,13 @@ public class ByteSubtractModification extends VariableModification { private Byte subtrahend; - public ByteSubtractModification() {} + public ByteSubtractModification() { + super(); + } - public ByteSubtractModification(Byte bi) { - this.subtrahend = bi; + public ByteSubtractModification(Byte subtrahend) { + super(); + this.subtrahend = subtrahend; } @Override @@ -45,10 +48,15 @@ public void setSubtrahend(Byte subtrahend) { @Override public VariableModification getModifiedCopy() { - return new ByteAddModification( + return new ByteSubtractModification( (byte) (subtrahend + new Random().nextInt(MAX_SUBTRACT_MODIFIER))); } + @Override + public VariableModification createCopy() { + return new ByteSubtractModification(subtrahend); + } + @Override public int hashCode() { int hash = 7; @@ -67,7 +75,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final ByteSubtractModification other = (ByteSubtractModification) obj; - return Objects.equals(this.subtrahend, other.subtrahend); + ByteSubtractModification other = (ByteSubtractModification) obj; + return Objects.equals(subtrahend, other.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 cb10612a..eb471709 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteXorModification.java @@ -22,10 +22,13 @@ public class ByteXorModification extends VariableModification { private Byte xor; - public ByteXorModification() {} + public ByteXorModification() { + super(); + } - public ByteXorModification(Byte bi) { - this.xor = bi; + public ByteXorModification(Byte xor) { + super(); + this.xor = xor; } @Override @@ -54,6 +57,11 @@ public VariableModification getModifiedCopy() { } } + @Override + public VariableModification createCopy() { + return new ByteXorModification(xor); + } + @Override public int hashCode() { int hash = 7; @@ -72,7 +80,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final ByteXorModification other = (ByteXorModification) obj; - return Objects.equals(this.xor, other.xor); + ByteXorModification other = (ByteXorModification) obj; + return Objects.equals(xor, other.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..af338da8 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByte.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByte.java @@ -19,12 +19,28 @@ public class ModifiableByte extends ModifiableVariable { private Byte originalValue; + public ModifiableByte() { + super(); + } + + public ModifiableByte(ModifiableByte other) { + super(other); + if (other != null) { + originalValue = other.originalValue; + } + } + @Override protected void createRandomModification() { VariableModification vm = ByteModificationFactory.createRandomModification(); setModification(vm); } + @Override + public ModifiableByte createCopy() { + return new ModifiableByte(this); + } + public Byte getAssertEquals() { return assertEquals; } @@ -65,15 +81,15 @@ public String toString() { } @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)) { return false; } - ModifiableByte that = (ModifiableByte) o; + ModifiableByte that = (ModifiableByte) obj; 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 05dd42a9..237833aa 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java @@ -26,7 +26,16 @@ public class ModifiableString extends ModifiableVariable { @XmlJavaTypeAdapter(IllegalStringAdapter.class) private String originalValue; - public ModifiableString() {} + public ModifiableString() { + super(); + } + + public ModifiableString(ModifiableString other) { + super(other); + if (other != null) { + originalValue = other.originalValue; + } + } @Override protected void createRandomModification() { @@ -34,6 +43,11 @@ protected void createRandomModification() { setModification(vm); } + @Override + public ModifiableString createCopy() { + return new ModifiableString(this); + } + public String getAssertEquals() { return assertEquals; } @@ -79,15 +93,15 @@ public String toString() { } @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)) { return false; } - ModifiableString that = (ModifiableString) o; + ModifiableString that = (ModifiableString) obj; 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 5cef0f1d..b4858829 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java @@ -25,22 +25,25 @@ 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; } @Override - protected String modifyImplementationHook(final String input) { - return input + this.appendValue; + protected String modifyImplementationHook(String input) { + return input + appendValue; } public String getAppendValue() { - return this.appendValue; + return appendValue; } - public void setAppendValue(final String appendValue) { + public void setAppendValue(String appendValue) { this.appendValue = appendValue; } @@ -54,6 +57,11 @@ public VariableModification getModifiedCopy() { return new StringAppendValueModification(modifiedString.toString()); } + @Override + public VariableModification createCopy() { + return new StringAppendValueModification(appendValue); + } + @Override public int hashCode() { int hash = 7; @@ -72,7 +80,7 @@ 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); } } 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 e370f2b7..7b564a22 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java @@ -25,9 +25,12 @@ public class StringExplicitValueModification extends VariableModification getModifiedCopy() { return new StringExplicitValueModification(modifiedString.toString()); } + @Override + public VariableModification createCopy() { + return new StringExplicitValueModification(explicitValue); + } + @Override public int hashCode() { int hash = 7; @@ -75,7 +83,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final StringExplicitValueModification other = (StringExplicitValueModification) obj; - return Objects.equals(this.explicitValue, other.explicitValue); + StringExplicitValueModification other = (StringExplicitValueModification) obj; + return Objects.equals(explicitValue, other.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 index b1acfc44..367ed4a8 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java @@ -29,15 +29,18 @@ public class StringInsertValueModification extends VariableModification private int startPosition; - public StringInsertValueModification() {} + public StringInsertValueModification() { + super(); + } - public StringInsertValueModification(final String insertValue, int startPosition) { + public StringInsertValueModification(String insertValue, int startPosition) { + super(); this.insertValue = insertValue; this.startPosition = startPosition; } @Override - protected String modifyImplementationHook(final String input) { + protected String modifyImplementationHook(String input) { // Wrap around and also allow to insert at the end of the original value int insertPosition = startPosition % (input.length() + 1); if (startPosition < 0) { @@ -48,10 +51,10 @@ protected String modifyImplementationHook(final String input) { } public String getInsertValue() { - return this.insertValue; + return insertValue; } - public void setInsertValue(final String insertValue) { + public void setInsertValue(String insertValue) { this.insertValue = insertValue; } @@ -86,6 +89,11 @@ public VariableModification getModifiedCopy() { } } + @Override + public VariableModification createCopy() { + return new StringInsertValueModification(insertValue, startPosition); + } + @Override public int hashCode() { int hash = 7; @@ -105,10 +113,10 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final StringInsertValueModification other = (StringInsertValueModification) obj; - if (this.startPosition != other.startPosition) { + StringInsertValueModification other = (StringInsertValueModification) obj; + if (startPosition != other.startPosition) { return false; } - return Objects.equals(this.insertValue, other.getInsertValue()); + return Objects.equals(insertValue, other.insertValue); } } 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 56f4c65c..1f81a342 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringModificationFactory.java @@ -12,7 +12,11 @@ import java.util.Random; /** */ -public class StringModificationFactory { +public final class StringModificationFactory { + + private StringModificationFactory() { + super(); + } private enum ModificationType { APPEND, @@ -29,19 +33,19 @@ private enum ModificationType { private static final int MODIFIED_STRING_LENGTH_ESTIMATION = 50; - 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 insertValue(final String value, final int position) { + public static VariableModification insertValue(String value, int position) { return new StringInsertValueModification(value, position); } 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 d5a9fe54..1b5dcf5b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java @@ -25,22 +25,25 @@ 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; } @Override - protected String modifyImplementationHook(final String input) { - return this.prependValue + input; + protected String modifyImplementationHook(String input) { + return prependValue + input; } public String getPrependValue() { - return this.prependValue; + return prependValue; } - public void setPrependValue(final String prependValue) { + public void setPrependValue(String prependValue) { this.prependValue = prependValue; } @@ -54,6 +57,11 @@ public VariableModification getModifiedCopy() { return new StringPrependValueModification(modifiedString.toString()); } + @Override + public VariableModification createCopy() { + return new StringPrependValueModification(prependValue); + } + @Override public int hashCode() { int hash = 7; @@ -72,7 +80,7 @@ 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); } } 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 5449b1ea..799c7414 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/ArrayConverter.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/ArrayConverter.java @@ -13,7 +13,11 @@ 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 @@ -31,7 +35,7 @@ public static byte[] longToUint64Bytes(long l) { result[4] = (byte) (l >>> 24); result[5] = (byte) (l >>> 16); result[6] = (byte) (l >>> 8); - result[7] = (byte) (l); + result[7] = (byte) l; return result; } @@ -46,7 +50,7 @@ public static byte[] longToUint32Bytes(long l) { result[0] = (byte) (l >>> 24); result[1] = (byte) (l >>> 16); result[2] = (byte) (l >>> 8); - result[3] = (byte) (l); + result[3] = (byte) l; return result; } @@ -64,7 +68,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 +91,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; @@ -122,7 +126,7 @@ public static long bytesToLong(byte[] value) { long result = 0; int shift = 0; for (int i = value.length - 1; i >= 0; i--) { - result += ((long) (value[i] & 0xFF)) << shift; + result += (long) (value[i] & 0xFF) << shift; shift += 8; } return result; @@ -132,7 +136,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 +155,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(" "); @@ -195,39 +199,39 @@ public static String bytesToRawHexString(byte[] array) { } @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) { + for (T[] a : arrays) { length += a.length; } @SuppressWarnings("unchecked") T[] result = (T[]) Array.newInstance(arrays[0].getClass().getComponentType(), length); int currentOffset = 0; - for (final T[] a : arrays) { + for (T[] a : arrays) { 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; @@ -236,8 +240,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); @@ -245,7 +248,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; @@ -331,7 +334,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: " 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..ccc3df97 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/BadFixedRandom.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/BadFixedRandom.java @@ -18,6 +18,7 @@ public class BadFixedRandom extends Random { 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..c61b16c4 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/BadRandom.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/BadRandom.java @@ -18,14 +18,17 @@ 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 +65,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 9382c05b..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,7 +44,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final ComparableByteArray other = (ComparableByteArray) obj; - return Arrays.equals(this.array, other.array); + ComparableByteArray other = (ComparableByteArray) obj; + return Arrays.equals(array, other.array); } } 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 769b1ab3..d883b468 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/Modifiable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/Modifiable.java @@ -26,7 +26,11 @@ import java.math.BigInteger; @SuppressWarnings("unused") -public class Modifiable { +public final class Modifiable { + + private Modifiable() { + super(); + } private static ModifiableByteArray getModifiableByteArrayWithModification( VariableModification modification) { @@ -94,7 +98,7 @@ public static ModifiableLong prepend(Long l) { return getModifiableLongWithModification(LongModificationFactory.prependValue(l)); } - public static ModifiableString prepend(final String s) { + public static ModifiableString prepend(String s) { return getModifiableStringWithModification(StringModificationFactory.prependValue(s)); } @@ -115,7 +119,7 @@ public static ModifiableLong append(Long l) { return getModifiableLongWithModification(LongModificationFactory.appendValue(l)); } - public static ModifiableString append(final String s) { + public static ModifiableString append(String s) { return getModifiableStringWithModification(StringModificationFactory.appendValue(s)); } 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..e09c6927 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/ModifiableVariableAnalyzer.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/ModifiableVariableAnalyzer.java @@ -16,10 +16,14 @@ 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 +71,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 +93,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 +115,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..96bdb56b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/RandomHelper.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/RandomHelper.java @@ -10,7 +10,7 @@ import java.util.Random; /** */ -public class RandomHelper { +public final class RandomHelper { private static Random random; @@ -29,5 +29,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..ec2c8ec1 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,9 +69,9 @@ 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; 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..f94755df 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/StringUtil.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/StringUtil.java @@ -7,10 +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() {} + private StringUtil() { + super(); + } static final int HI_SURROGATE_START = 0xD800; @@ -21,10 +23,10 @@ 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); + public static String backslashEscapeString(String value) { + StringBuffer buffer = new StringBuffer(value); for (int i = 0; i < buffer.length(); i++) { - final int codePoint = buffer.codePointAt(i); + int codePoint = buffer.codePointAt(i); String replacement; int numCodePoints = 1; switch (codePoint) { 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..a17cfba0 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerOperationConcatenationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerOperationConcatenationTest.java @@ -39,16 +39,12 @@ protected BigInteger modifyImplementationHook(BigInteger input) { @Override public VariableModification getModifiedCopy() { - throw new UnsupportedOperationException("Not supported yet."); // To - // change - // body - // of - // generated - // methods, - // choose - // Tools - // | - // Templates. + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public VariableModification createCopy() { + throw new UnsupportedOperationException("Not supported yet."); } }); expectedResult = new BigInteger("13"); From 9598313ec40224128ba48a01e9ab5f1a764085b5 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Fri, 29 Nov 2024 15:35:56 +0100 Subject: [PATCH 17/82] Fix equals() of ModifiableLengthField (I broke it in last commit) --- .../nds/modifiablevariable/length/ModifiableLengthField.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 175cefc0..2fd2fc5a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/length/ModifiableLengthField.java +++ b/src/main/java/de/rub/nds/modifiablevariable/length/ModifiableLengthField.java @@ -61,7 +61,7 @@ public boolean equals(Object obj) { ModifiableLengthField that = (ModifiableLengthField) obj; - return ref != null ? getValue().equals(getValue()) : that.getValue() == null; + return ref != null ? getValue().equals(that.getValue()) : that.getValue() == null; } @Override From 580b5282657db4e45db4a0a82d163193b3032941 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Fri, 29 Nov 2024 15:50:15 +0100 Subject: [PATCH 18/82] Undo changes to use String.format() instead of string concatenation --- .../nds/modifiablevariable/ModifiableVariableHolder.java | 2 +- .../bytearray/ByteArrayAppendValueModification.java | 6 +++--- .../bytearray/ByteArrayPrependValueModification.java | 6 +++--- .../logging/ExtendedPatternLayout.java | 9 ++++++--- .../nds/modifiablevariable/string/ModifiableString.java | 3 +-- 5 files changed, 14 insertions(+), 12 deletions(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableHolder.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableHolder.java index 073365f0..73bc4928 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableHolder.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableHolder.java @@ -95,7 +95,7 @@ public void reset() { } public String getExtendedString() { - return String.format("%s{\n%s}\n", getClass().getSimpleName(), getExtendedString(1)); + return getClass().getSimpleName() + "{\n" + getExtendedString(1) + "}\n"; } protected String getExtendedString(int depth) { diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java index 9048b3d6..b9641e5d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java @@ -94,8 +94,8 @@ public boolean equals(Object obj) { @Override public String toString() { - return String.format( - "ByteArrayInsertModification{bytesToAppend=%s}", - ArrayConverter.bytesToHexString(bytesToAppend)); + return "ByteArrayInsertModification{bytesToAppend=" + + ArrayConverter.bytesToHexString(bytesToAppend) + + "}"; } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java index 792c8872..4f0f434c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java @@ -94,8 +94,8 @@ public boolean equals(Object obj) { @Override public String toString() { - return String.format( - "ByteArrayInsertModification{bytesToPrepend=%s}", - ArrayConverter.bytesToHexString(bytesToPrepend)); + return "ByteArrayInsertModification{bytesToPrepend=" + + ArrayConverter.bytesToHexString(bytesToPrepend) + + "}"; } } 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 fa8009b1..b293cc81 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/logging/ExtendedPatternLayout.java +++ b/src/main/java/de/rub/nds/modifiablevariable/logging/ExtendedPatternLayout.java @@ -399,9 +399,12 @@ public boolean requiresLocation() { @Override public String toString() { - return String.format( - "%s[patternSelector=%s, replace=%s]", - super.toString(), patternSelector.toString(), replace.toString()); + return super.toString() + + "[patternSelector=" + + patternSelector.toString() + + ", replace=" + + replace.toString() + + "]"; } } 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 237833aa..f3a63c1a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java @@ -88,8 +88,7 @@ public void setOriginalValue(String originalValue) { @Override public String toString() { - return String.format( - "ModifiableString{originalValue=%s}", backslashEscapeString(originalValue)); + return "ModifiableString{originalValue=" + backslashEscapeString(originalValue) + "}"; } @Override From b153a9ec5f722be3ee228e6890af790198b061ec Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Sun, 1 Dec 2024 17:31:45 +0100 Subject: [PATCH 19/82] Change CopyConstructors. Throw NullPointerException instead of allowing null as object. I think it makes no sense to allow null as copy object. --- .gitignore | 8 ++++++-- .../rub/nds/modifiablevariable/ModifiableVariable.java | 10 ++++------ .../biginteger/ModifiableBigInteger.java | 4 +--- .../nds/modifiablevariable/bool/ModifiableBoolean.java | 4 +--- .../bytearray/ModifiableByteArray.java | 6 ++---- .../modifiablevariable/integer/ModifiableInteger.java | 4 +--- .../nds/modifiablevariable/longint/ModifiableLong.java | 4 +--- .../modifiablevariable/singlebyte/ModifiableByte.java | 4 +--- .../modifiablevariable/string/ModifiableString.java | 4 +--- 9 files changed, 18 insertions(+), 30 deletions(-) diff --git a/.gitignore b/.gitignore index e0f94da2..69fb61ad 100644 --- a/.gitignore +++ b/.gitignore @@ -9,9 +9,13 @@ nbproject/ nbactions.xml.project nbactions.xml -# IntelliJ -.idea/ +### IntelliJ IDEA ### +.idea/* +!.idea/inspectionProfiles +!.idea/runConfigurations +*.iws *.iml +*.ipr # VS Code .vscode/ diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java index 8488ab69..b3832cf6 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -163,12 +163,10 @@ protected ModifiableVariable() { protected ModifiableVariable(ModifiableVariable other) { super(); - if (other != null) { - createRandomModification = other.createRandomModification; - modification = other.modification != null ? other.modification.createCopy() : null; - // Warning: Make sure to copy assertEquals in subclass correctly - assertEquals = other.assertEquals; - } + createRandomModification = other.createRandomModification; + modification = other.modification != null ? other.modification.createCopy() : null; + // Warning: Make sure to copy assertEquals in subclass correctly + assertEquals = other.assertEquals; } public void setModification(VariableModification modification) { 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 d2af64c8..ef32a2ba 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigInteger.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigInteger.java @@ -27,9 +27,7 @@ public ModifiableBigInteger() { public ModifiableBigInteger(ModifiableBigInteger other) { super(other); - if (other != null) { - originalValue = other.originalValue; - } + originalValue = other.originalValue; } @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 3cf082d8..64d7f4a3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/ModifiableBoolean.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/ModifiableBoolean.java @@ -30,9 +30,7 @@ public ModifiableBoolean(Boolean originalValue) { public ModifiableBoolean(ModifiableBoolean other) { super(other); - if (other != null) { - originalValue = other.originalValue; - } + originalValue = other.originalValue; } @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 f989cf46..22fb143a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArray.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArray.java @@ -30,10 +30,8 @@ public ModifiableByteArray() { @SuppressWarnings("IncompleteCopyConstructor") public ModifiableByteArray(ModifiableByteArray other) { super(other); - if (other != null) { - originalValue = other.originalValue != null ? other.originalValue.clone() : null; - assertEquals = other.assertEquals != null ? other.assertEquals.clone() : null; - } + originalValue = other.originalValue != null ? other.originalValue.clone() : null; + assertEquals = other.assertEquals != null ? other.assertEquals.clone() : null; } @Override 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 2f401a2b..1280d2b0 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/ModifiableInteger.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/ModifiableInteger.java @@ -26,9 +26,7 @@ public ModifiableInteger() { public ModifiableInteger(ModifiableInteger other) { super(other); - if (other != null) { - originalValue = other.originalValue; - } + originalValue = other.originalValue; } @Override 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 b9204760..dbe1622b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/ModifiableLong.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/ModifiableLong.java @@ -26,9 +26,7 @@ public ModifiableLong() { public ModifiableLong(ModifiableLong other) { super(other); - if (other != null) { - originalValue = other.originalValue; - } + originalValue = other.originalValue; } @Override 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 af338da8..706fc68d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByte.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByte.java @@ -25,9 +25,7 @@ public ModifiableByte() { public ModifiableByte(ModifiableByte other) { super(other); - if (other != null) { - originalValue = other.originalValue; - } + originalValue = other.originalValue; } @Override 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 f3a63c1a..7fbc8d7b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java @@ -32,9 +32,7 @@ public ModifiableString() { public ModifiableString(ModifiableString other) { super(other); - if (other != null) { - originalValue = other.originalValue; - } + originalValue = other.originalValue; } @Override From 4b606ee9c5a748f9d5538d25e90985dc4e435943 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Sun, 1 Dec 2024 17:47:51 +0100 Subject: [PATCH 20/82] Add Project_Defaults.xml to repo. So everyone developing on this repo wil see the same Warnings, in IntelliJ. --- .idea/inspectionProfiles/Project_Default.xml | 323 +++++++++++++++++++ 1 file changed, 323 insertions(+) create mode 100644 .idea/inspectionProfiles/Project_Default.xml diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml new file mode 100644 index 00000000..0ad4972f --- /dev/null +++ b/.idea/inspectionProfiles/Project_Default.xml @@ -0,0 +1,323 @@ + + + + \ No newline at end of file From 509333d92d362f2677a6e4ac7b3660bd6638a0a3 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Mon, 2 Dec 2024 16:30:28 +0100 Subject: [PATCH 21/82] Add FromFileModifications, so one can distinguish it from normal explicit value modifications. --- ...egerExplicitValueFromFileModification.java | 75 +++++++++++++++++++ .../BigIntegerExplicitValueModification.java | 2 +- .../BigIntegerModificationFactory.java | 13 ++-- ...rrayExplicitValueFromFileModification.java | 74 ++++++++++++++++++ .../ByteArrayExplicitValueModification.java | 2 +- .../ByteArrayModificationFactory.java | 9 ++- ...egerExplicitValueFromFileModification.java | 73 ++++++++++++++++++ .../IntegerExplicitValueModification.java | 2 +- .../integer/IntegerModificationFactory.java | 10 ++- ...LongExplicitValueFromFileModification.java | 72 ++++++++++++++++++ .../LongExplicitValueModification.java | 2 +- .../longint/LongModificationFactory.java | 10 ++- ...ByteExplicitValueFromFileModification.java | 72 ++++++++++++++++++ .../ByteExplicitValueModification.java | 2 +- .../singlebyte/ByteModificationFactory.java | 10 ++- 15 files changed, 405 insertions(+), 23 deletions(-) create mode 100644 src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java create mode 100644 src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueFromFileModification.java create mode 100644 src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java create mode 100644 src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java create mode 100644 src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java new file mode 100644 index 00000000..84abbb14 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java @@ -0,0 +1,75 @@ +/* + * 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.XmlType; +import java.math.BigInteger; +import java.util.Objects; + +@XmlRootElement +@XmlType(propOrder = {"index", "explicitValue", "modificationFilter"}) +@XmlAccessorType(XmlAccessType.FIELD) +public class BigIntegerExplicitValueFromFileModification + extends BigIntegerExplicitValueModification { + private int index; + + public BigIntegerExplicitValueFromFileModification() { + super(); + } + + public BigIntegerExplicitValueFromFileModification(int index, BigInteger explicitValue) { + super(explicitValue); + this.index = index; + } + + public int getIndex() { + return index; + } + + @Override + public VariableModification getModifiedCopy() { + throw new UnsupportedOperationException( + "Cannot set modify Value of BigIntegerExplicitValueFromFileModification"); + } + + @Override + public VariableModification createCopy() { + return new BigIntegerExplicitValueFromFileModification(index, explicitValue); + } + + @Override + public int hashCode() { + int hash = 7; + hash = 31 * hash + index; + hash = 31 * hash + explicitValue.hashCode(); + return hash; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + BigIntegerExplicitValueFromFileModification other = + (BigIntegerExplicitValueFromFileModification) obj; + if (index != other.index) { + return false; + } + return Objects.equals(explicitValue, other.explicitValue); + } +} 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 9dae5aa7..aee27363 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java @@ -23,7 +23,7 @@ public class BigIntegerExplicitValueModification extends VariableModification interactive() { public static synchronized List> modificationsFromFile() { try { if (modificationsFromFile == null) { - modificationsFromFile = new LinkedList<>(); + modificationsFromFile = new ArrayList<>(); ClassLoader classLoader = ByteArrayModificationFactory.class.getClassLoader(); InputStream is = classLoader.getResourceAsStream(LongModificationFactory.FILE_NAME); BufferedReader br = new BufferedReader(new InputStreamReader(is)); String line; + int index = 0; while ((line = br.readLine()) != null) { String value = line.trim().split(" ")[0]; if (!value.isEmpty()) { - modificationsFromFile.add(explicitValue(value)); + modificationsFromFile.add( + new BigIntegerExplicitValueFromFileModification( + index, new BigInteger(value))); + index++; } } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueFromFileModification.java new file mode 100644 index 00000000..92ea7905 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueFromFileModification.java @@ -0,0 +1,74 @@ +/* + * 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 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; + +@XmlRootElement +@XmlType(propOrder = {"index", "explicitValue", "modificationFilter"}) +@XmlAccessorType(XmlAccessType.FIELD) +public class ByteArrayExplicitValueFromFileModification extends ByteArrayExplicitValueModification { + private int index; + + public ByteArrayExplicitValueFromFileModification() { + super(); + } + + public ByteArrayExplicitValueFromFileModification(int index, byte[] explicitValue) { + super(explicitValue); + this.index = index; + } + + public int getIndex() { + return index; + } + + @Override + public VariableModification getModifiedCopy() { + throw new UnsupportedOperationException( + "Cannot set modify Value of ByteArrayExplicitValueFromFileModification"); + } + + @Override + public VariableModification createCopy() { + return new ByteArrayExplicitValueFromFileModification( + index, explicitValue != null ? explicitValue.clone() : null); + } + + @Override + public int hashCode() { + int hash = 7; + hash = 31 * hash + index; + hash = 31 * hash + Arrays.hashCode(explicitValue); + return hash; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + ByteArrayExplicitValueFromFileModification other = + (ByteArrayExplicitValueFromFileModification) obj; + if (index != other.index) { + return false; + } + return Arrays.equals(explicitValue, other.explicitValue); + } +} 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 f62d2030..3f89b0ac 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java @@ -26,7 +26,7 @@ public class ByteArrayExplicitValueModification extends VariableModification shuffle(byte[] shuffle) { public static synchronized List> modificationsFromFile() { try { if (modificationsFromFile == null) { - modificationsFromFile = new LinkedList<>(); + modificationsFromFile = new ArrayList<>(); ClassLoader classLoader = ByteArrayModificationFactory.class.getClassLoader(); InputStream is = classLoader.getResourceAsStream(FILE_NAME); BufferedReader br = new BufferedReader(new InputStreamReader(is)); String line; + int index = 0; while ((line = br.readLine()) != null) { line = line.replaceAll("\\s+", ""); byte[] value = ArrayConverter.hexStringToByteArray(line); - modificationsFromFile.add(explicitValue(value)); + modificationsFromFile.add( + new ByteArrayExplicitValueFromFileModification(index, value)); + index++; } } return modificationsFromFile; diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java new file mode 100644 index 00000000..07295fd8 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java @@ -0,0 +1,73 @@ +/* + * 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.XmlAccessType; +import jakarta.xml.bind.annotation.XmlAccessorType; +import jakarta.xml.bind.annotation.XmlRootElement; +import jakarta.xml.bind.annotation.XmlType; +import java.util.Objects; + +@XmlRootElement +@XmlType(propOrder = {"index", "explicitValue", "modificationFilter"}) +@XmlAccessorType(XmlAccessType.FIELD) +public class IntegerExplicitValueFromFileModification extends IntegerExplicitValueModification { + private int index; + + public IntegerExplicitValueFromFileModification() { + super(); + } + + public IntegerExplicitValueFromFileModification(int index, Integer explicitValue) { + super(explicitValue); + this.index = index; + } + + public int getIndex() { + return index; + } + + @Override + public VariableModification getModifiedCopy() { + throw new UnsupportedOperationException( + "Cannot set modify Value of IntegerExplicitValueFromFileModification"); + } + + @Override + public VariableModification createCopy() { + return new IntegerExplicitValueFromFileModification(index, explicitValue); + } + + @Override + public int hashCode() { + int hash = 7; + hash = 31 * hash + index; + hash = 31 * hash + explicitValue.hashCode(); + return hash; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + IntegerExplicitValueFromFileModification other = + (IntegerExplicitValueFromFileModification) obj; + if (index != other.index) { + return false; + } + return Objects.equals(explicitValue, other.explicitValue); + } +} 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 408d704c..9e26ef01 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueModification.java @@ -19,7 +19,7 @@ public class IntegerExplicitValueModification extends VariableModification multiply(Integer value) { public static synchronized List> modificationsFromFile() { try { if (modificationsFromFile == null) { - modificationsFromFile = new LinkedList<>(); + modificationsFromFile = new ArrayList<>(); ClassLoader classLoader = IntegerModificationFactory.class.getClassLoader(); InputStream is = classLoader.getResourceAsStream(FILE_NAME); BufferedReader br = new BufferedReader(new InputStreamReader(is)); String line; + int index = 0; while ((line = br.readLine()) != null) { String value = line.trim().split(" ")[0]; - modificationsFromFile.add(explicitValue(value)); + modificationsFromFile.add( + new IntegerExplicitValueFromFileModification( + index, Integer.parseInt(value))); + index++; } } return modificationsFromFile; diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java new file mode 100644 index 00000000..791bcb64 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java @@ -0,0 +1,72 @@ +/* + * 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.XmlAccessType; +import jakarta.xml.bind.annotation.XmlAccessorType; +import jakarta.xml.bind.annotation.XmlRootElement; +import jakarta.xml.bind.annotation.XmlType; +import java.util.Objects; + +@XmlRootElement +@XmlType(propOrder = {"index", "explicitValue", "modificationFilter"}) +@XmlAccessorType(XmlAccessType.FIELD) +public class LongExplicitValueFromFileModification extends LongExplicitValueModification { + private int index; + + public LongExplicitValueFromFileModification() { + super(); + } + + public LongExplicitValueFromFileModification(int index, Long explicitValue) { + super(explicitValue); + this.index = index; + } + + public int getIndex() { + return index; + } + + @Override + public VariableModification getModifiedCopy() { + throw new UnsupportedOperationException( + "Cannot set modify Value of LongExplicitValueFromFileModification"); + } + + @Override + public VariableModification createCopy() { + return new LongExplicitValueFromFileModification(index, explicitValue); + } + + @Override + public int hashCode() { + int hash = 7; + hash = 31 * hash + index; + hash = 31 * hash + explicitValue.hashCode(); + return hash; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + LongExplicitValueFromFileModification other = (LongExplicitValueFromFileModification) obj; + if (index != other.index) { + return false; + } + return Objects.equals(explicitValue, other.explicitValue); + } +} 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 44145053..88e46b0f 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java @@ -19,7 +19,7 @@ public class LongExplicitValueModification extends VariableModification { private static final int MAX_EXPLICIT_MODIFIER = 256; - private Long explicitValue; + protected Long explicitValue; public LongExplicitValueModification() { super(); 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 c0c66a7b..0b22db18 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongModificationFactory.java @@ -15,7 +15,7 @@ import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; -import java.util.LinkedList; +import java.util.ArrayList; import java.util.List; import java.util.Random; @@ -118,14 +118,18 @@ public static VariableModification shiftRight(int shift) { public static synchronized List> modificationsFromFile() { try { if (modificationsFromFile == null) { - modificationsFromFile = new LinkedList<>(); + modificationsFromFile = new ArrayList<>(); ClassLoader classLoader = IntegerModificationFactory.class.getClassLoader(); InputStream is = classLoader.getResourceAsStream(FILE_NAME); BufferedReader br = new BufferedReader(new InputStreamReader(is)); String line; + int index = 0; while ((line = br.readLine()) != null) { String value = line.trim().split(" ")[0]; - modificationsFromFile.add(explicitValue(value)); + modificationsFromFile.add( + new LongExplicitValueFromFileModification( + index, Long.parseLong(value))); + index++; } } return modificationsFromFile; diff --git a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java new file mode 100644 index 00000000..16b208d7 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java @@ -0,0 +1,72 @@ +/* + * 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.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 jakarta.xml.bind.annotation.XmlType; +import java.util.Objects; + +@XmlRootElement +@XmlType(propOrder = {"index", "explicitValue", "modificationFilter"}) +@XmlAccessorType(XmlAccessType.FIELD) +public class ByteExplicitValueFromFileModification extends ByteExplicitValueModification { + private int index; + + public ByteExplicitValueFromFileModification() { + super(); + } + + public ByteExplicitValueFromFileModification(int index, Byte explicitValue) { + super(explicitValue); + this.index = index; + } + + public int getIndex() { + return index; + } + + @Override + public VariableModification getModifiedCopy() { + throw new UnsupportedOperationException( + "Cannot set modify Value of ByteExplicitValueFromFileModification"); + } + + @Override + public VariableModification createCopy() { + return new ByteExplicitValueFromFileModification(index, explicitValue); + } + + @Override + public int hashCode() { + int hash = 7; + hash = 31 * hash + index; + hash = 31 * hash + explicitValue.hashCode(); + return hash; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + ByteExplicitValueFromFileModification other = (ByteExplicitValueFromFileModification) obj; + if (index != other.index) { + return false; + } + return Objects.equals(explicitValue, other.explicitValue); + } +} 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 b2439ae5..bcaf6fd6 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueModification.java @@ -19,7 +19,7 @@ public class ByteExplicitValueModification extends VariableModification { private static final int MAX_EXPLICIT_MODIFIER = 16; - private Byte explicitValue; + protected Byte explicitValue; public ByteExplicitValueModification() { super(); 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 b9179be3..91627a4b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteModificationFactory.java @@ -14,7 +14,7 @@ import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; -import java.util.LinkedList; +import java.util.ArrayList; import java.util.List; import java.util.Random; @@ -75,14 +75,18 @@ public static VariableModification explicitValueFromFile(int value) { public static synchronized List> modificationsFromFile() { try { if (modificationsFromFile == null) { - modificationsFromFile = new LinkedList<>(); + modificationsFromFile = new ArrayList<>(); ClassLoader classLoader = ByteModificationFactory.class.getClassLoader(); InputStream is = classLoader.getResourceAsStream(FILE_NAME); BufferedReader br = new BufferedReader(new InputStreamReader(is)); String line; + int index = 0; while ((line = br.readLine()) != null) { String value = line.trim().split(" ")[0]; - modificationsFromFile.add(explicitValue(value)); + modificationsFromFile.add( + new ByteExplicitValueFromFileModification( + index, Byte.parseByte(value))); + index++; } } return modificationsFromFile; From da88f9be231b7adef2f7f17a51a673ae5b1c06c0 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Mon, 2 Dec 2024 22:28:33 +0100 Subject: [PATCH 22/82] Fix CreateCopy() of ByteExplicitValue --- .../singlebyte/ByteExplicitValueModification.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 bcaf6fd6..05df3e8b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueModification.java @@ -57,7 +57,7 @@ public VariableModification getModifiedCopy() { @Override public VariableModification createCopy() { - return new ByteAddModification(explicitValue); + return new ByteExplicitValueModification(explicitValue); } @Override From be36e780515742dc717da7de8b12fac514cdddf3 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Tue, 3 Dec 2024 07:48:38 +0100 Subject: [PATCH 23/82] Add missing XmlElement for explicit from file modifications --- .../ModifiableVariable.java | 20 +++++++++++++++---- 1 file changed, 16 insertions(+), 4 deletions(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java index b3832cf6..f7fbe2d5 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -13,10 +13,7 @@ import de.rub.nds.modifiablevariable.bytearray.*; import de.rub.nds.modifiablevariable.integer.*; import de.rub.nds.modifiablevariable.longint.*; -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.singlebyte.*; import de.rub.nds.modifiablevariable.string.StringAppendValueModification; import de.rub.nds.modifiablevariable.string.StringExplicitValueModification; import de.rub.nds.modifiablevariable.string.StringInsertValueModification; @@ -53,6 +50,9 @@ public abstract class ModifiableVariable implements Serializable { @XmlElement( type = BigIntegerShiftLeftModification.class, name = "BigIntegerShiftLeftModification"), + @XmlElement( + type = BigIntegerExplicitValueFromFileModification.class, + name = "BigIntegerExplicitValueFromFileModification"), @XmlElement( type = BigIntegerExplicitValueModification.class, name = "BigIntegerExplicitValueModification"), @@ -89,6 +89,9 @@ public abstract class ModifiableVariable implements Serializable { @XmlElement( type = ByteArrayPrependValueModification.class, name = "ByteArrayPrependValueModification"), + @XmlElement( + type = ByteArrayExplicitValueFromFileModification.class, + name = "ByteArrayExplicitValueFromFileModification"), @XmlElement( type = ByteArrayExplicitValueModification.class, name = "ByteArrayExplicitValueModification"), @@ -105,6 +108,9 @@ public abstract class ModifiableVariable implements Serializable { @XmlElement( type = IntegerShiftLeftModification.class, name = "IntegerShiftLeftModification"), + @XmlElement( + type = IntegerExplicitValueFromFileModification.class, + name = "IntegerExplicitValueFromFileModification"), @XmlElement( type = IntegerExplicitValueModification.class, name = "IntegerExplicitValueModification"), @@ -120,6 +126,9 @@ public abstract class ModifiableVariable implements Serializable { name = "IntegerPrependValueModification"), @XmlElement(type = LongXorModification.class, name = "LongXorModification"), @XmlElement(type = LongSubtractModification.class, name = "LongSubtractModification"), + @XmlElement( + type = LongExplicitValueFromFileModification.class, + name = "LongExplicitValueFromFileModification"), @XmlElement( type = LongExplicitValueModification.class, name = "LongExplicitValueModification"), @@ -135,6 +144,9 @@ public abstract class ModifiableVariable implements Serializable { @XmlElement(type = ByteXorModification.class, name = "ByteXorModification"), @XmlElement(type = ByteSubtractModification.class, name = "ByteSubtractModification"), @XmlElement(type = ByteAddModification.class, name = "ByteAddModification"), + @XmlElement( + type = ByteExplicitValueFromFileModification.class, + name = "ByteExplicitValueFromFileModification"), @XmlElement( type = ByteExplicitValueModification.class, name = "ByteExplicitValueModification"), From c073a2b7cb46f1b344ac3bfab6d5713283793df5 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Wed, 4 Dec 2024 18:43:14 +0100 Subject: [PATCH 24/82] Add PathModification. Fix copy methods --- .../ModifiableVariable.java | 6 + .../ModificationFilter.java | 10 + .../VariableModification.java | 14 +- .../biginteger/BigIntegerAddModification.java | 15 +- .../BigIntegerAppendValueModification.java | 15 +- ...egerExplicitValueFromFileModification.java | 18 +- .../BigIntegerExplicitValueModification.java | 15 +- .../BigIntegerInsertValueModification.java | 16 +- .../BigIntegerMultiplyModification.java | 15 +- .../BigIntegerPrependValueModification.java | 15 +- .../BigIntegerShiftLeftModification.java | 15 +- .../BigIntegerShiftRightModification.java | 15 +- .../BigIntegerSubtractModification.java | 15 +- .../biginteger/BigIntegerXorModification.java | 15 +- .../biginteger/ModifiableBigInteger.java | 10 +- .../BooleanExplicitValueModification.java | 15 +- .../bool/BooleanToggleModification.java | 14 +- .../bool/ModifiableBoolean.java | 10 +- .../ByteArrayAppendValueModification.java | 16 +- .../ByteArrayDeleteModification.java | 16 +- .../ByteArrayDuplicateModification.java | 14 +- ...rrayExplicitValueFromFileModification.java | 19 +- .../ByteArrayExplicitValueModification.java | 16 +- .../ByteArrayInsertValueModification.java | 17 +- .../ByteArrayPrependValueModification.java | 16 +- .../ByteArrayShuffleModification.java | 15 +- .../bytearray/ByteArrayXorModification.java | 16 +- .../bytearray/ModifiableByteArray.java | 11 +- .../filter/AccessModificationFilter.java | 11 ++ .../integer/IntegerAddModification.java | 15 +- .../IntegerAppendValueModification.java | 15 +- ...egerExplicitValueFromFileModification.java | 18 +- .../IntegerExplicitValueModification.java | 15 +- .../IntegerInsertValueModification.java | 16 +- .../integer/IntegerMultiplyModification.java | 15 +- .../IntegerPrependValueModification.java | 15 +- .../integer/IntegerShiftLeftModification.java | 15 +- .../IntegerShiftRightModification.java | 15 +- .../integer/IntegerSubtractModification.java | 15 +- .../integer/IntegerXorModification.java | 15 +- .../integer/ModifiableInteger.java | 10 +- .../longint/LongAddModification.java | 15 +- .../longint/LongAppendValueModification.java | 15 +- ...LongExplicitValueFromFileModification.java | 17 +- .../LongExplicitValueModification.java | 15 +- .../longint/LongInsertValueModification.java | 16 +- .../longint/LongMultiplyModification.java | 15 +- .../longint/LongPrependValueModification.java | 15 +- .../longint/LongShiftLeftModification.java | 15 +- .../longint/LongShiftRightModification.java | 15 +- .../longint/LongSubtractModification.java | 15 +- .../longint/LongXorModification.java | 15 +- .../longint/ModifiableLong.java | 10 +- .../path/ModifiablePath.java | 60 ++++++ .../path/PathAppendValueModification.java | 97 ++++++++++ ...rtDirectoryTraversalValueModification.java | 177 ++++++++++++++++++ .../path/PathInsertValueModification.java | 158 ++++++++++++++++ .../path/PathModificationFactory.java | 88 +++++++++ .../path/PathPrependValueModification.java | 97 ++++++++++ .../path/PathToggleRootValueModification.java | 63 +++++++ .../singlebyte/ByteAddModification.java | 15 +- ...ByteExplicitValueFromFileModification.java | 17 +- .../ByteExplicitValueModification.java | 15 +- .../singlebyte/ByteSubtractModification.java | 15 +- .../singlebyte/ByteXorModification.java | 15 +- .../singlebyte/ModifiableByte.java | 10 +- .../string/ModifiableString.java | 12 +- .../string/StringAppendValueModification.java | 17 +- ...ringExplicitValueFromFileModification.java | 78 ++++++++ .../StringExplicitValueModification.java | 17 +- .../string/StringInsertValueModification.java | 19 +- .../StringPrependValueModification.java | 17 +- .../ByteArraySerializationTest.java | 1 - 73 files changed, 1442 insertions(+), 318 deletions(-) create mode 100644 src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java create mode 100644 src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java create mode 100644 src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalValueModification.java create mode 100644 src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java create mode 100644 src/main/java/de/rub/nds/modifiablevariable/path/PathModificationFactory.java create mode 100644 src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java create mode 100644 src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootValueModification.java create mode 100644 src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java index f7fbe2d5..29a45a46 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -202,6 +202,12 @@ public E getValue() { return getOriginalValue(); } + public void reduceToOriginalValue(boolean evenWithNullOriginalValue) { + if (evenWithNullOriginalValue || getOriginalValue() != null) { + setOriginalValue(getValue()); + } + } + public abstract E getOriginalValue(); public abstract void setOriginalValue(E originalValue); diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModificationFilter.java b/src/main/java/de/rub/nds/modifiablevariable/ModificationFilter.java index 94f19f0b..24816427 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModificationFilter.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModificationFilter.java @@ -18,5 +18,15 @@ @XmlSeeAlso(AccessModificationFilter.class) public abstract class ModificationFilter { + protected ModificationFilter() { + super(); + } + + protected ModificationFilter(ModificationFilter other) { + super(); + } + + public abstract ModificationFilter createCopy(); + 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 6558dcd8..be4396b4 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java @@ -35,6 +35,18 @@ public abstract class VariableModification { @XmlElement(type = AccessModificationFilter.class, name = "AccessModificationFilter")) private ModificationFilter modificationFilter; + protected VariableModification() { + super(); + } + + protected VariableModification(VariableModification other) { + super(); + modificationFilter = + other.modificationFilter != null ? other.modificationFilter.createCopy() : null; + } + + public abstract VariableModification createCopy(); + public E modify(E input) { E modifiedValue = modifyImplementationHook(input); if (modificationFilter == null || !modificationFilter.filterModification()) { @@ -49,8 +61,6 @@ public E modify(E input) { public abstract VariableModification getModifiedCopy(); - public abstract VariableModification createCopy(); - /** * Debugging modified variables. Getting stack trace can be time-consuming, thus we use * isDebugEnabled() function 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 cd555622..7fbbddef 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java @@ -34,6 +34,16 @@ public BigIntegerAddModification(BigInteger summand) { this.summand = summand; } + public BigIntegerAddModification(BigIntegerAddModification other) { + super(other); + summand = other.summand; + } + + @Override + public BigIntegerAddModification createCopy() { + return new BigIntegerAddModification(this); + } + @Override protected BigInteger modifyImplementationHook(BigInteger input) { return input == null ? summand : input.add(summand); @@ -53,11 +63,6 @@ public VariableModification getModifiedCopy() { summand.add(new BigInteger(MAX_ADD_LENGTH, new Random()))); } - @Override - public VariableModification createCopy() { - return new BigIntegerAddModification(summand); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java index c894edf1..15068f53 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java @@ -34,6 +34,16 @@ public BigIntegerAppendValueModification(BigInteger appendValue) { this.appendValue = appendValue; } + public BigIntegerAppendValueModification(BigIntegerAppendValueModification other) { + super(other); + appendValue = other.appendValue; + } + + @Override + public BigIntegerAppendValueModification createCopy() { + return new BigIntegerAppendValueModification(this); + } + @Override protected BigInteger modifyImplementationHook(BigInteger input) { if (input == null) { @@ -56,11 +66,6 @@ public VariableModification getModifiedCopy() { appendValue.add(new BigInteger(MAX_APPEND_LENGTH, new Random()))); } - @Override - public VariableModification createCopy() { - return new BigIntegerAppendValueModification(appendValue); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java index 84abbb14..ae7eba28 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java @@ -16,7 +16,7 @@ import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"index", "explicitValue", "modificationFilter"}) +@XmlType(propOrder = "index") @XmlAccessorType(XmlAccessType.FIELD) public class BigIntegerExplicitValueFromFileModification extends BigIntegerExplicitValueModification { @@ -31,6 +31,17 @@ public BigIntegerExplicitValueFromFileModification(int index, BigInteger explici this.index = index; } + public BigIntegerExplicitValueFromFileModification( + BigIntegerExplicitValueFromFileModification other) { + super(other); + index = other.index; + } + + @Override + public BigIntegerExplicitValueFromFileModification createCopy() { + return new BigIntegerExplicitValueFromFileModification(this); + } + public int getIndex() { return index; } @@ -41,11 +52,6 @@ public VariableModification getModifiedCopy() { "Cannot set modify Value of BigIntegerExplicitValueFromFileModification"); } - @Override - public VariableModification createCopy() { - return new BigIntegerExplicitValueFromFileModification(index, explicitValue); - } - @Override public int hashCode() { int hash = 7; 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 aee27363..d3694aea 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java @@ -34,6 +34,16 @@ public BigIntegerExplicitValueModification(BigInteger explicitValue) { this.explicitValue = explicitValue; } + public BigIntegerExplicitValueModification(BigIntegerExplicitValueModification other) { + super(other); + explicitValue = other.explicitValue; + } + + @Override + public BigIntegerExplicitValueModification createCopy() { + return new BigIntegerExplicitValueModification(this); + } + @Override protected BigInteger modifyImplementationHook(BigInteger input) { return explicitValue; @@ -59,11 +69,6 @@ public VariableModification getModifiedCopy() { } } - @Override - public VariableModification createCopy() { - return new BigIntegerExplicitValueModification(explicitValue); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java index 407b8bb2..d0886851 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java @@ -37,6 +37,17 @@ public BigIntegerInsertValueModification(BigInteger insertValue, int startPositi this.startPosition = startPosition; } + public BigIntegerInsertValueModification(BigIntegerInsertValueModification other) { + super(other); + insertValue = other.insertValue; + startPosition = other.startPosition; + } + + @Override + public BigIntegerInsertValueModification createCopy() { + return new BigIntegerInsertValueModification(this); + } + @Override protected BigInteger modifyImplementationHook(BigInteger input) { if (input == null) { @@ -97,11 +108,6 @@ public VariableModification getModifiedCopy() { } } - @Override - public VariableModification createCopy() { - return new BigIntegerInsertValueModification(insertValue, startPosition); - } - @Override public int hashCode() { int hash = 7; 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 e5141c16..9569280d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java @@ -34,6 +34,16 @@ public BigIntegerMultiplyModification(BigInteger factor) { this.factor = factor; } + public BigIntegerMultiplyModification(BigIntegerMultiplyModification other) { + super(other); + factor = other.factor; + } + + @Override + public BigIntegerMultiplyModification createCopy() { + return new BigIntegerMultiplyModification(this); + } + @Override protected BigInteger modifyImplementationHook(BigInteger input) { return input == null ? BigInteger.ZERO : input.multiply(factor); @@ -53,11 +63,6 @@ public VariableModification getModifiedCopy() { factor.add(new BigInteger(MAX_FACTOR_LENGTH, new Random()))); } - @Override - public VariableModification createCopy() { - return new BigIntegerMultiplyModification(factor); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java index 282bf2d6..7bc86e7e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java @@ -34,6 +34,16 @@ public BigIntegerPrependValueModification(BigInteger prependValue) { this.prependValue = prependValue; } + public BigIntegerPrependValueModification(BigIntegerPrependValueModification other) { + super(other); + prependValue = other.prependValue; + } + + @Override + public BigIntegerPrependValueModification createCopy() { + return new BigIntegerPrependValueModification(this); + } + @Override protected BigInteger modifyImplementationHook(BigInteger input) { if (input == null) { @@ -56,11 +66,6 @@ public VariableModification getModifiedCopy() { prependValue.add(new BigInteger(MAX_PREPEND_LENGTH, new Random()))); } - @Override - public VariableModification createCopy() { - return new BigIntegerPrependValueModification(prependValue); - } - @Override public int hashCode() { int hash = 7; 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 569280c3..1509533f 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java @@ -33,6 +33,16 @@ public BigIntegerShiftLeftModification(int shift) { 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) { @@ -54,11 +64,6 @@ public VariableModification getModifiedCopy() { return new BigIntegerShiftLeftModification(shift + new Random().nextInt(MAX_SHIFT_LENGTH)); } - @Override - public VariableModification createCopy() { - return new BigIntegerShiftLeftModification(shift); - } - @Override public int hashCode() { int hash = 7; 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 f103d976..0e598888 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java @@ -33,6 +33,16 @@ public BigIntegerShiftRightModification(int shift) { 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) { @@ -54,11 +64,6 @@ public VariableModification getModifiedCopy() { return new BigIntegerShiftRightModification(shift + new Random().nextInt(MAX_SHIFT_LENGTH)); } - @Override - public VariableModification createCopy() { - return new BigIntegerShiftRightModification(shift); - } - @Override public int hashCode() { int hash = 7; 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 a818dc8c..f8fce93f 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java @@ -34,6 +34,16 @@ public BigIntegerSubtractModification(BigInteger subtrahend) { this.subtrahend = subtrahend; } + public BigIntegerSubtractModification(BigIntegerSubtractModification other) { + super(other); + subtrahend = other.subtrahend; + } + + @Override + public BigIntegerSubtractModification createCopy() { + return new BigIntegerSubtractModification(this); + } + @Override protected BigInteger modifyImplementationHook(BigInteger input) { if (input == null) { @@ -56,11 +66,6 @@ public VariableModification getModifiedCopy() { subtrahend.add(new BigInteger(MAX_SUBTRACT_LENGTH, new Random()))); } - @Override - public VariableModification createCopy() { - return new BigIntegerSubtractModification(subtrahend); - } - @Override public int hashCode() { int hash = 7; 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 2c3529a7..5cbc9bb2 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java @@ -34,6 +34,16 @@ public BigIntegerXorModification(BigInteger xor) { this.xor = xor; } + public BigIntegerXorModification(BigIntegerXorModification other) { + super(other); + xor = other.xor; + } + + @Override + public BigIntegerXorModification createCopy() { + return new BigIntegerXorModification(this); + } + @Override protected BigInteger modifyImplementationHook(BigInteger input) { if (input == null) { @@ -55,11 +65,6 @@ public VariableModification getModifiedCopy() { return new BigIntegerXorModification(xor.add(new BigInteger(MAX_XOR_LENGTH, new Random()))); } - @Override - public VariableModification createCopy() { - return new BigIntegerXorModification(xor); - } - @Override public int hashCode() { int hash = 7; 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 ef32a2ba..07eb6459 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigInteger.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigInteger.java @@ -30,6 +30,11 @@ public ModifiableBigInteger(ModifiableBigInteger other) { originalValue = other.originalValue; } + @Override + public ModifiableBigInteger createCopy() { + return new ModifiableBigInteger(this); + } + @Override protected void createRandomModification() { VariableModification vm = @@ -37,11 +42,6 @@ protected void createRandomModification() { setModification(vm); } - @Override - public ModifiableBigInteger createCopy() { - return new ModifiableBigInteger(this); - } - public BigInteger getAssertEquals() { return assertEquals; } 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 744ba2f9..123d95f4 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanExplicitValueModification.java @@ -26,6 +26,16 @@ public BooleanExplicitValueModification(boolean explicitValue) { this.explicitValue = explicitValue; } + public BooleanExplicitValueModification(BooleanExplicitValueModification other) { + super(other); + explicitValue = other.explicitValue; + } + + @Override + public BooleanExplicitValueModification createCopy() { + return new BooleanExplicitValueModification(this); + } + @Override protected Boolean modifyImplementationHook(Boolean input) { return explicitValue; @@ -44,11 +54,6 @@ public VariableModification getModifiedCopy() { return new BooleanExplicitValueModification(!explicitValue); } - @Override - public VariableModification createCopy() { - return new BooleanExplicitValueModification(explicitValue); - } - @Override public int hashCode() { int hash = 7; 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 5d12e6ae..34ad7608 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanToggleModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanToggleModification.java @@ -19,6 +19,15 @@ public BooleanToggleModification() { super(); } + public BooleanToggleModification(BooleanToggleModification other) { + super(other); + } + + @Override + public BooleanToggleModification createCopy() { + return new BooleanToggleModification(this); + } + @Override protected Boolean modifyImplementationHook(Boolean input) { if (input == null) { @@ -32,11 +41,6 @@ public VariableModification getModifiedCopy() { return new BooleanToggleModification(); } - @Override - public VariableModification createCopy() { - return new BooleanToggleModification(); - } - @Override public int hashCode() { return 7; 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 64d7f4a3..fc03f2d3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/ModifiableBoolean.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/ModifiableBoolean.java @@ -33,6 +33,11 @@ public ModifiableBoolean(ModifiableBoolean other) { originalValue = other.originalValue; } + @Override + public ModifiableBoolean createCopy() { + return new ModifiableBoolean(this); + } + @Override public Boolean getOriginalValue() { return originalValue; @@ -49,11 +54,6 @@ protected void createRandomModification() { setModification(vm); } - @Override - public ModifiableBoolean createCopy() { - return new ModifiableBoolean(this); - } - @Override public boolean isOriginalValueModified() { return originalValue != null && originalValue.compareTo(getValue()) != 0; diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java index b9641e5d..78eb3d2e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java @@ -37,6 +37,16 @@ public ByteArrayAppendValueModification(byte[] bytesToAppend) { 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) { @@ -64,12 +74,6 @@ public VariableModification getModifiedCopy() { return new ByteArrayAppendValueModification(newValue); } - @Override - public VariableModification createCopy() { - return new ByteArrayAppendValueModification( - bytesToAppend != null ? bytesToAppend.clone() : null); - } - @Override public int hashCode() { int hash = 7; 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 4838c43d..f44e2a11 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java @@ -39,6 +39,17 @@ public ByteArrayDeleteModification(int startPosition, int count) { 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) { @@ -114,11 +125,6 @@ public VariableModification getModifiedCopy() { } } - @Override - public VariableModification createCopy() { - return new ByteArrayDeleteModification(startPosition, count); - } - @Override public int hashCode() { int hash = 7; 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 55d5f3c0..b919fccf 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDuplicateModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDuplicateModification.java @@ -23,6 +23,15 @@ public ByteArrayDuplicateModification() { super(); } + public ByteArrayDuplicateModification(ByteArrayDuplicateModification other) { + super(other); + } + + @Override + public ByteArrayDuplicateModification createCopy() { + return new ByteArrayDuplicateModification(this); + } + @Override protected byte[] modifyImplementationHook(byte[] input) { if (input == null) { @@ -36,11 +45,6 @@ public VariableModification getModifiedCopy() { return new ByteArrayDuplicateModification(); } - @Override - public VariableModification createCopy() { - return new ByteArrayDuplicateModification(); - } - @Override public int hashCode() { return 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueFromFileModification.java index 92ea7905..e95a9e31 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueFromFileModification.java @@ -15,7 +15,7 @@ import java.util.Arrays; @XmlRootElement -@XmlType(propOrder = {"index", "explicitValue", "modificationFilter"}) +@XmlType(propOrder = "index") @XmlAccessorType(XmlAccessType.FIELD) public class ByteArrayExplicitValueFromFileModification extends ByteArrayExplicitValueModification { private int index; @@ -29,6 +29,17 @@ public ByteArrayExplicitValueFromFileModification(int index, byte[] explicitValu this.index = index; } + public ByteArrayExplicitValueFromFileModification( + ByteArrayExplicitValueFromFileModification other) { + super(other); + index = other.index; + } + + @Override + public ByteArrayExplicitValueFromFileModification createCopy() { + return new ByteArrayExplicitValueFromFileModification(this); + } + public int getIndex() { return index; } @@ -39,12 +50,6 @@ public VariableModification getModifiedCopy() { "Cannot set modify Value of ByteArrayExplicitValueFromFileModification"); } - @Override - public VariableModification createCopy() { - return new ByteArrayExplicitValueFromFileModification( - index, explicitValue != null ? explicitValue.clone() : null); - } - @Override public int hashCode() { int hash = 7; 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 3f89b0ac..83fca1b1 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java @@ -37,6 +37,16 @@ public ByteArrayExplicitValueModification(byte[] explicitValue) { 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(byte[] input) { return explicitValue.clone(); @@ -70,12 +80,6 @@ public VariableModification getModifiedCopy() { return new ByteArrayExplicitValueModification(newValue); } - @Override - public VariableModification createCopy() { - return new ByteArrayExplicitValueModification( - explicitValue != null ? explicitValue.clone() : null); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java index 180f16b4..59579e1d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java @@ -42,6 +42,17 @@ public ByteArrayInsertValueModification(byte[] bytesToInsert, int startPosition) 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) { @@ -101,12 +112,6 @@ public VariableModification getModifiedCopy() { } } - @Override - public VariableModification createCopy() { - return new ByteArrayInsertValueModification( - bytesToInsert != null ? bytesToInsert.clone() : null, startPosition); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java index 4f0f434c..17e8135c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java @@ -37,6 +37,16 @@ public ByteArrayPrependValueModification(byte[] bytesToPrepend) { 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) { @@ -64,12 +74,6 @@ public VariableModification getModifiedCopy() { return new ByteArrayPrependValueModification(newValue); } - @Override - public VariableModification createCopy() { - return new ByteArrayPrependValueModification( - bytesToPrepend != null ? bytesToPrepend.clone() : null); - } - @Override public int hashCode() { int hash = 7; 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 0ce87fd3..cddfd270 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayShuffleModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayShuffleModification.java @@ -41,6 +41,16 @@ public ByteArrayShuffleModification(byte[] shuffle) { this.shuffle = shuffle; } + public ByteArrayShuffleModification(ByteArrayShuffleModification other) { + super(other); + shuffle = other.shuffle != null ? other.shuffle.clone() : null; + } + + @Override + public ByteArrayShuffleModification createCopy() { + return new ByteArrayShuffleModification(this); + } + @Override protected byte[] modifyImplementationHook(byte[] input) { if (input == null) { @@ -77,11 +87,6 @@ public VariableModification getModifiedCopy() { return new ByteArrayShuffleModification(newValue); } - @Override - public VariableModification createCopy() { - return new ByteArrayShuffleModification(shuffle != null ? shuffle.clone() : null); - } - @Override public int hashCode() { int hash = 7; 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 9dfbb39b..b26a5c86 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java @@ -42,6 +42,17 @@ public ByteArrayXorModification(byte[] xor, int startPosition) { 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) { @@ -109,11 +120,6 @@ public VariableModification getModifiedCopy() { } } - @Override - public VariableModification createCopy() { - return new ByteArrayXorModification(xor != null ? xor.clone() : null, startPosition); - } - @Override public int hashCode() { int hash = 7; 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 22fb143a..3bd16daa 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArray.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArray.java @@ -27,13 +27,17 @@ public ModifiableByteArray() { super(); } - @SuppressWarnings("IncompleteCopyConstructor") public ModifiableByteArray(ModifiableByteArray other) { super(other); originalValue = other.originalValue != null ? other.originalValue.clone() : null; assertEquals = other.assertEquals != null ? other.assertEquals.clone() : null; } + @Override + public ModifiableByteArray createCopy() { + return new ModifiableByteArray(this); + } + @Override protected void createRandomModification() { VariableModification vm = @@ -41,11 +45,6 @@ protected void createRandomModification() { setModification(vm); } - @Override - public ModifiableByteArray createCopy() { - return new ModifiableByteArray(this); - } - @Override @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) public byte[] getOriginalValue() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/filter/AccessModificationFilter.java b/src/main/java/de/rub/nds/modifiablevariable/filter/AccessModificationFilter.java index 54ca94cf..cbf940ac 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/filter/AccessModificationFilter.java +++ b/src/main/java/de/rub/nds/modifiablevariable/filter/AccessModificationFilter.java @@ -39,6 +39,17 @@ public AccessModificationFilter(int[] accessNumbers) { this.accessNumbers = accessNumbers; } + public AccessModificationFilter(AccessModificationFilter other) { + super(other); + accessCounter = other.accessCounter; + accessNumbers = other.accessNumbers != null ? other.accessNumbers.clone() : null; + } + + @Override + public AccessModificationFilter createCopy() { + return new AccessModificationFilter(this); + } + @Override public boolean filterModification() { boolean filter = contains(accessNumbers, accessCounter); 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 129906ac..f7f698f8 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAddModification.java @@ -30,6 +30,16 @@ public IntegerAddModification(Integer summand) { this.summand = summand; } + public IntegerAddModification(IntegerAddModification other) { + super(other); + summand = other.summand; + } + + @Override + public IntegerAddModification createCopy() { + return new IntegerAddModification(this); + } + @Override protected Integer modifyImplementationHook(Integer input) { return input == null ? summand : input + summand; @@ -48,11 +58,6 @@ public VariableModification getModifiedCopy() { return new IntegerAddModification(summand + new Random().nextInt(MAX_ADD_MODIFIER)); } - @Override - public VariableModification createCopy() { - return new IntegerAddModification(summand); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java index 572f6590..3cbafa1b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java @@ -30,6 +30,16 @@ public IntegerAppendValueModification(Integer appendValue) { this.appendValue = appendValue; } + public IntegerAppendValueModification(IntegerAppendValueModification other) { + super(other); + appendValue = other.appendValue; + } + + @Override + public IntegerAppendValueModification createCopy() { + return new IntegerAppendValueModification(this); + } + @Override protected Integer modifyImplementationHook(Integer input) { if (input == null) { @@ -52,11 +62,6 @@ public VariableModification getModifiedCopy() { appendValue + new Random().nextInt(MAX_VALUE_MODIFIER)); } - @Override - public VariableModification createCopy() { - return new IntegerAppendValueModification(appendValue); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java index 07295fd8..488875a7 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java @@ -15,7 +15,7 @@ import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"index", "explicitValue", "modificationFilter"}) +@XmlType(propOrder = "index") @XmlAccessorType(XmlAccessType.FIELD) public class IntegerExplicitValueFromFileModification extends IntegerExplicitValueModification { private int index; @@ -29,6 +29,17 @@ public IntegerExplicitValueFromFileModification(int index, Integer explicitValue this.index = index; } + public IntegerExplicitValueFromFileModification( + IntegerExplicitValueFromFileModification other) { + super(other); + index = other.index; + } + + @Override + public IntegerExplicitValueFromFileModification createCopy() { + return new IntegerExplicitValueFromFileModification(this); + } + public int getIndex() { return index; } @@ -39,11 +50,6 @@ public VariableModification getModifiedCopy() { "Cannot set modify Value of IntegerExplicitValueFromFileModification"); } - @Override - public VariableModification createCopy() { - return new IntegerExplicitValueFromFileModification(index, explicitValue); - } - @Override public int hashCode() { int hash = 7; 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 9e26ef01..26ec5ea4 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueModification.java @@ -30,6 +30,16 @@ public IntegerExplicitValueModification(Integer explicitValue) { this.explicitValue = explicitValue; } + public IntegerExplicitValueModification(IntegerExplicitValueModification other) { + super(other); + explicitValue = other.explicitValue; + } + + @Override + public IntegerExplicitValueModification createCopy() { + return new IntegerExplicitValueModification(this); + } + @Override protected Integer modifyImplementationHook(Integer input) { return explicitValue; @@ -55,11 +65,6 @@ public VariableModification getModifiedCopy() { } } - @Override - public VariableModification createCopy() { - return new IntegerExplicitValueModification(explicitValue); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java index 36b0c277..f56056c3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java @@ -35,6 +35,17 @@ public IntegerInsertValueModification(Integer insertValue, int startPosition) { this.startPosition = startPosition; } + public IntegerInsertValueModification(IntegerInsertValueModification other) { + super(other); + insertValue = other.insertValue; + startPosition = other.startPosition; + } + + @Override + public IntegerInsertValueModification createCopy() { + return new IntegerInsertValueModification(this); + } + @Override protected Integer modifyImplementationHook(Integer input) { if (input == null) { @@ -91,11 +102,6 @@ public VariableModification getModifiedCopy() { } } - @Override - public VariableModification createCopy() { - return new IntegerInsertValueModification(insertValue, startPosition); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java index a978315c..aae8071d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java @@ -30,6 +30,16 @@ public IntegerMultiplyModification(Integer factor) { 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; @@ -50,11 +60,6 @@ public VariableModification getModifiedCopy() { return new IntegerMultiplyModification(factor + r.nextInt(MAX_FACTOR_MODIFIER)); } - @Override - public VariableModification createCopy() { - return new IntegerMultiplyModification(factor); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java index 67c970a3..a8043aa3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java @@ -30,6 +30,16 @@ public IntegerPrependValueModification(Integer prependValue) { this.prependValue = prependValue; } + public IntegerPrependValueModification(IntegerPrependValueModification other) { + super(other); + prependValue = other.prependValue; + } + + @Override + public IntegerPrependValueModification createCopy() { + return new IntegerPrependValueModification(this); + } + @Override protected Integer modifyImplementationHook(Integer input) { if (input == null) { @@ -53,11 +63,6 @@ public VariableModification getModifiedCopy() { prependValue + new Random().nextInt(MAX_VALUE_MODIFIER)); } - @Override - public VariableModification createCopy() { - return new IntegerPrependValueModification(prependValue); - } - @Override public int hashCode() { int hash = 7; 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 f619d774..712e7c8e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftLeftModification.java @@ -29,6 +29,16 @@ public IntegerShiftLeftModification(int shift) { 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 % MAX_SHIFT_MODIFIER; @@ -59,11 +69,6 @@ public VariableModification getModifiedCopy() { return new IntegerShiftLeftModification(newShift); } - @Override - public VariableModification createCopy() { - return new IntegerShiftLeftModification(shift); - } - @Override public int hashCode() { int hash = 7; 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 7fe13833..0abfd06a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftRightModification.java @@ -29,6 +29,16 @@ public IntegerShiftRightModification(int shift) { this.shift = shift; } + public IntegerShiftRightModification(IntegerShiftRightModification other) { + super(other); + shift = other.shift; + } + + @Override + public IntegerShiftRightModification createCopy() { + return new IntegerShiftRightModification(this); + } + @Override protected Integer modifyImplementationHook(Integer input) { return input == null ? 0 : input >> shift % MAX_SHIFT_MODIFIER; @@ -59,11 +69,6 @@ public VariableModification getModifiedCopy() { return new IntegerShiftRightModification(newShift); } - @Override - public VariableModification createCopy() { - return new IntegerShiftRightModification(shift); - } - @Override public int hashCode() { int hash = 7; 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 aa070ac2..e052658e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSubtractModification.java @@ -30,6 +30,16 @@ public IntegerSubtractModification(Integer subtrahend) { this.subtrahend = subtrahend; } + public IntegerSubtractModification(IntegerSubtractModification other) { + super(other); + subtrahend = other.subtrahend; + } + + @Override + public IntegerSubtractModification createCopy() { + return new IntegerSubtractModification(this); + } + @Override protected Integer modifyImplementationHook(Integer input) { return input == null ? -subtrahend : input - subtrahend; @@ -49,11 +59,6 @@ public VariableModification getModifiedCopy() { subtrahend + new Random().nextInt(MAX_SUBTRACT_MODIFIER)); } - @Override - public VariableModification createCopy() { - return new IntegerSubtractModification(subtrahend); - } - @Override public int hashCode() { int hash = 7; 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 09c6e09a..729392e0 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerXorModification.java @@ -30,6 +30,16 @@ public IntegerXorModification(Integer xor) { this.xor = xor; } + public IntegerXorModification(IntegerXorModification other) { + super(other); + xor = other.xor; + } + + @Override + public IntegerXorModification createCopy() { + return new IntegerXorModification(this); + } + @Override protected Integer modifyImplementationHook(Integer input) { return input == null ? xor : input ^ xor; @@ -53,11 +63,6 @@ public VariableModification getModifiedCopy() { } } - @Override - public VariableModification createCopy() { - return new IntegerXorModification(xor); - } - @Override public int hashCode() { int hash = 7; 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 1280d2b0..0977990b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/ModifiableInteger.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/ModifiableInteger.java @@ -30,14 +30,14 @@ public ModifiableInteger(ModifiableInteger other) { } @Override - protected void createRandomModification() { - VariableModification vm = IntegerModificationFactory.createRandomModification(); - setModification(vm); + public ModifiableInteger createCopy() { + return new ModifiableInteger(this); } @Override - public ModifiableInteger createCopy() { - return new ModifiableInteger(this); + protected void createRandomModification() { + VariableModification vm = IntegerModificationFactory.createRandomModification(); + setModification(vm); } public Integer getAssertEquals() { 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 2a2bc5a8..d5339a5b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java @@ -30,6 +30,16 @@ public LongAddModification(Long summand) { this.summand = summand; } + public LongAddModification(LongAddModification other) { + super(other); + summand = other.summand; + } + + @Override + public LongAddModification createCopy() { + return new LongAddModification(this); + } + @Override protected Long modifyImplementationHook(Long input) { return input == null ? summand : input + summand; @@ -48,11 +58,6 @@ public VariableModification getModifiedCopy() { return new LongAddModification(summand + new Random().nextInt(MAX_ADD_MODIFIER)); } - @Override - public VariableModification createCopy() { - return new LongAddModification(summand); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java index 04bfa005..2b1c6339 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java @@ -30,6 +30,16 @@ public LongAppendValueModification(Long appendValue) { this.appendValue = appendValue; } + public LongAppendValueModification(LongAppendValueModification other) { + super(other); + appendValue = other.appendValue; + } + + @Override + public LongAppendValueModification createCopy() { + return new LongAppendValueModification(this); + } + @Override protected Long modifyImplementationHook(Long input) { if (input == null) { @@ -52,11 +62,6 @@ public VariableModification getModifiedCopy() { appendValue + new Random().nextInt(MAX_VALUE_MODIFIER)); } - @Override - public VariableModification createCopy() { - return new LongAppendValueModification(appendValue); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java index 791bcb64..f2422286 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java @@ -15,7 +15,7 @@ import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"index", "explicitValue", "modificationFilter"}) +@XmlType(propOrder = "index") @XmlAccessorType(XmlAccessType.FIELD) public class LongExplicitValueFromFileModification extends LongExplicitValueModification { private int index; @@ -29,6 +29,16 @@ public LongExplicitValueFromFileModification(int index, Long explicitValue) { this.index = index; } + public LongExplicitValueFromFileModification(LongExplicitValueFromFileModification other) { + super(other); + index = other.index; + } + + @Override + public LongExplicitValueFromFileModification createCopy() { + return new LongExplicitValueFromFileModification(this); + } + public int getIndex() { return index; } @@ -39,11 +49,6 @@ public VariableModification getModifiedCopy() { "Cannot set modify Value of LongExplicitValueFromFileModification"); } - @Override - public VariableModification createCopy() { - return new LongExplicitValueFromFileModification(index, explicitValue); - } - @Override public int hashCode() { int hash = 7; 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 88e46b0f..e2bd2afc 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java @@ -30,6 +30,16 @@ public LongExplicitValueModification(Long explicitValue) { this.explicitValue = explicitValue; } + public LongExplicitValueModification(LongExplicitValueModification other) { + super(other); + explicitValue = other.explicitValue; + } + + @Override + public LongExplicitValueModification createCopy() { + return new LongExplicitValueModification(this); + } + @Override protected Long modifyImplementationHook(Long input) { return explicitValue; @@ -55,11 +65,6 @@ public VariableModification getModifiedCopy() { } } - @Override - public VariableModification createCopy() { - return new LongExplicitValueModification(explicitValue); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java index a16e9e02..9f77686f 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java @@ -33,6 +33,17 @@ public LongInsertValueModification(Long insertValue, int startPosition) { this.startPosition = startPosition; } + public LongInsertValueModification(LongInsertValueModification other) { + super(other); + insertValue = other.insertValue; + startPosition = other.startPosition; + } + + @Override + public LongInsertValueModification createCopy() { + return new LongInsertValueModification(this); + } + @Override protected Long modifyImplementationHook(Long input) { if (input == null) { @@ -89,11 +100,6 @@ public VariableModification getModifiedCopy() { } } - @Override - public VariableModification createCopy() { - return new LongInsertValueModification(insertValue, startPosition); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java index 463d82f3..76f735f8 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java @@ -30,6 +30,16 @@ public LongMultiplyModification(Long factor) { 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; @@ -48,11 +58,6 @@ public VariableModification getModifiedCopy() { return new LongMultiplyModification(factor + new Random().nextInt(MAX_FACTOR_MODIFIER)); } - @Override - public VariableModification createCopy() { - return new LongMultiplyModification(factor); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java index e0ec7815..a2ddbd6d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java @@ -30,6 +30,16 @@ public LongPrependValueModification(Long prependValue) { this.prependValue = prependValue; } + public LongPrependValueModification(LongPrependValueModification other) { + super(other); + prependValue = other.prependValue; + } + + @Override + public LongPrependValueModification createCopy() { + return new LongPrependValueModification(this); + } + @Override protected Long modifyImplementationHook(Long input) { if (input == null) { @@ -52,11 +62,6 @@ public VariableModification getModifiedCopy() { prependValue + new Random().nextInt(MAX_VALUE_MODIFIER)); } - @Override - public VariableModification createCopy() { - return new LongPrependValueModification(prependValue); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java index bf508fef..2a65b5cf 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java @@ -30,6 +30,16 @@ public LongShiftLeftModification(int shift) { 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; @@ -61,11 +71,6 @@ public VariableModification getModifiedCopy() { return new LongShiftLeftModification(newShift); } - @Override - public VariableModification createCopy() { - return new LongShiftLeftModification(shift); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java index c901d719..bb0d5a74 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java @@ -30,6 +30,16 @@ public LongShiftRightModification(int shift) { 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; @@ -61,11 +71,6 @@ public VariableModification getModifiedCopy() { return new LongShiftRightModification(newShift); } - @Override - public VariableModification createCopy() { - return new LongShiftRightModification(shift); - } - @Override public int hashCode() { int hash = 7; 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 f303ca8e..2af22632 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java @@ -30,6 +30,16 @@ public LongSubtractModification(Long subtrahend) { this.subtrahend = subtrahend; } + public LongSubtractModification(LongSubtractModification other) { + super(other); + subtrahend = other.subtrahend; + } + + @Override + public LongSubtractModification createCopy() { + return new LongSubtractModification(this); + } + @Override protected Long modifyImplementationHook(Long input) { return input == null ? -subtrahend : input - subtrahend; @@ -49,11 +59,6 @@ public VariableModification getModifiedCopy() { subtrahend + new Random().nextInt(MAX_SUBTRACT_MODIFIER)); } - @Override - public VariableModification createCopy() { - return new LongSubtractModification(subtrahend); - } - @Override public int hashCode() { int hash = 7; 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 650704f7..a8fff829 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java @@ -30,6 +30,16 @@ public LongXorModification(Long xor) { this.xor = xor; } + public LongXorModification(LongXorModification other) { + super(other); + xor = other.xor; + } + + @Override + public LongXorModification createCopy() { + return new LongXorModification(this); + } + @Override protected Long modifyImplementationHook(Long input) { return input == null ? xor : input ^ xor; @@ -53,11 +63,6 @@ public VariableModification getModifiedCopy() { } } - @Override - public VariableModification createCopy() { - return new LongXorModification(xor); - } - @Override public int hashCode() { int hash = 7; 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 dbe1622b..9a377bad 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/ModifiableLong.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/ModifiableLong.java @@ -30,14 +30,14 @@ public ModifiableLong(ModifiableLong other) { } @Override - protected void createRandomModification() { - VariableModification vm = LongModificationFactory.createRandomModification(); - setModification(vm); + public ModifiableLong createCopy() { + return new ModifiableLong(this); } @Override - public ModifiableLong createCopy() { - return new ModifiableLong(this); + protected void createRandomModification() { + VariableModification vm = LongModificationFactory.createRandomModification(); + setModification(vm); } public Long getAssertEquals() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java b/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java new file mode 100644 index 00000000..5fcbf317 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java @@ -0,0 +1,60 @@ +/* + * 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.path; + +import static de.rub.nds.modifiablevariable.util.StringUtil.backslashEscapeString; + +import de.rub.nds.modifiablevariable.VariableModification; +import de.rub.nds.modifiablevariable.string.ModifiableString; +import jakarta.xml.bind.annotation.XmlAccessType; +import jakarta.xml.bind.annotation.XmlAccessorType; +import jakarta.xml.bind.annotation.XmlRootElement; + +/** */ +@XmlRootElement +@XmlAccessorType(XmlAccessType.FIELD) +public class ModifiablePath extends ModifiableString { + + public ModifiablePath() { + super(); + } + + public ModifiablePath(ModifiablePath other) { + super(other); + } + + @Override + public ModifiablePath createCopy() { + return new ModifiablePath(this); + } + + @Override + protected void createRandomModification() { + VariableModification vm = PathModificationFactory.createRandomModification(null); + setModification(vm); + } + + @Override + public String toString() { + return "ModifiablePath{originalValue=" + backslashEscapeString(originalValue) + "}"; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (!(obj instanceof ModifiablePath)) { + return false; + } + + ModifiablePath that = (ModifiablePath) obj; + + return getValue() != null ? getValue().equals(that.getValue()) : that.getValue() == null; + } +} diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java new file mode 100644 index 00000000..9a106a73 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java @@ -0,0 +1,97 @@ +/* + * 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.path; + +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; +import java.util.Random; + +/** Modification that appends a string to the original value. */ +@XmlRootElement +@XmlType(propOrder = {"appendValue", "modificationFilter"}) +public class PathAppendValueModification extends VariableModification { + + private static final int MAX_EXPLICIT_VALUE = 256; + + @XmlJavaTypeAdapter(IllegalStringAdapter.class) + private String appendValue; + + public PathAppendValueModification() { + super(); + } + + public PathAppendValueModification(String appendValue) { + super(); + this.appendValue = appendValue; + } + + public PathAppendValueModification(PathAppendValueModification other) { + super(other); + appendValue = other.appendValue; + } + + @Override + public PathAppendValueModification createCopy() { + return new PathAppendValueModification(this); + } + + @Override + protected String modifyImplementationHook(String input) { + if (input == null) { + return null; + } + if (input.endsWith("/")) { + return input + appendValue + "/"; + } + return input + "/" + appendValue; + } + + public String getAppendValue() { + return appendValue; + } + + public void setAppendValue(String appendValue) { + this.appendValue = appendValue; + } + + @Override + public VariableModification getModifiedCopy() { + Random r = new Random(); + int index = r.nextInt(appendValue.length()); + char randomChar = (char) r.nextInt(MAX_EXPLICIT_VALUE); + StringBuilder modifiedString = new StringBuilder(appendValue); + modifiedString.setCharAt(index, randomChar); + return new PathAppendValueModification(modifiedString.toString()); + } + + @Override + public int hashCode() { + int hash = 7; + hash = 31 * hash + appendValue.hashCode(); + return hash; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + PathAppendValueModification other = (PathAppendValueModification) obj; + return Objects.equals(appendValue, other.appendValue); + } +} diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalValueModification.java new file mode 100644 index 00000000..94f222c2 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalValueModification.java @@ -0,0 +1,177 @@ +/* + * 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.path; + +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; +import java.util.Random; + +/** Modification that appends a string to the original value. */ +@XmlRootElement +@XmlType(propOrder = {"insertValue", "count", "startPosition", "modificationFilter"}) +public class PathInsertDirectoryTraversalValueModification extends VariableModification { + + private static final int MAX_INSERT_MODIFIER = 32; + + @XmlJavaTypeAdapter(IllegalStringAdapter.class) + private String insertValue; + + private int count; + private int startPosition; + + public PathInsertDirectoryTraversalValueModification() { + super(); + } + + public PathInsertDirectoryTraversalValueModification(int count, int startPosition) { + super(); + this.count = count; + this.startPosition = startPosition; + updateInsertValue(); + } + + public PathInsertDirectoryTraversalValueModification( + PathInsertDirectoryTraversalValueModification other) { + super(other); + insertValue = other.insertValue; + count = other.count; + startPosition = other.startPosition; + } + + @Override + public PathInsertDirectoryTraversalValueModification createCopy() { + return new PathInsertDirectoryTraversalValueModification(this); + } + + private void updateInsertValue() { + StringBuilder builder = new StringBuilder(count * 3 - 1); + for (int i = 0; i < count; i++) { + builder.append(".."); + if (i < count - 1) { + builder.append("/"); + } + } + insertValue = builder.toString(); + } + + @Override + protected String modifyImplementationHook(String input) { + if (input == null) { + return null; + } + + if (input.isEmpty()) { + return insertValue; + } + String[] pathParts = input.split("/"); + boolean leadingSlash = pathParts[0].isEmpty(); + + // Wrap around and also allow to insert at the end of the original value + int insertPosition; + if (leadingSlash) { + // If the path starts with a slash, skip the first empty path part. + insertPosition = startPosition % pathParts.length; + if (startPosition < 0) { + insertPosition += pathParts.length - 1; + } + insertPosition++; + } else { + insertPosition = startPosition % (pathParts.length + 1); + if (startPosition < 0) { + insertPosition += pathParts.length; + } + } + + if (insertPosition == 0 && leadingSlash) { + pathParts[insertPosition] = "/" + insertValue; + } else if (insertPosition == pathParts.length) { + pathParts[insertPosition - 1] = pathParts[insertPosition - 1] + "/" + insertValue; + } else { + pathParts[insertPosition] = insertValue + "/" + pathParts[insertPosition]; + } + if (input.endsWith("/")) { + pathParts[pathParts.length - 1] += "/"; + } + return String.join("/", pathParts); + } + + public int getCount() { + return count; + } + + public void setCount(int count) { + this.count = count; + updateInsertValue(); + } + + 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 modifier = r.nextInt(MAX_INSERT_MODIFIER); + if (r.nextBoolean()) { + modifier *= -1; + } + modifier = count + modifier; + if (modifier <= 0) { + modifier = 1; + } + return new PathInsertDirectoryTraversalValueModification(modifier, startPosition); + } else { + int modifier = r.nextInt(MAX_INSERT_MODIFIER); + if (r.nextBoolean()) { + modifier *= -1; + } + modifier = startPosition + modifier; + if (modifier <= 0) { + modifier = 1; + } + return new PathInsertDirectoryTraversalValueModification(count, modifier); + } + } + + @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; + } + PathInsertDirectoryTraversalValueModification other = + (PathInsertDirectoryTraversalValueModification) obj; + if (startPosition != other.startPosition) { + return false; + } + return Objects.equals(count, other.count); + } +} diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java new file mode 100644 index 00000000..12a694a6 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java @@ -0,0 +1,158 @@ +/* + * 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.path; + +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; +import java.util.Random; + +/** Modification that appends a string to the original value. */ +@XmlRootElement +@XmlType(propOrder = {"insertValue", "startPosition", "modificationFilter"}) +public class PathInsertValueModification extends VariableModification { + + private static final int MAX_EXPLICIT_VALUE = 256; + + private static final int MAX_INSERT_MODIFIER = 32; + + @XmlJavaTypeAdapter(IllegalStringAdapter.class) + private String insertValue; + + private int startPosition; + + public PathInsertValueModification() { + super(); + } + + public PathInsertValueModification(String insertValue, int startPosition) { + super(); + this.insertValue = insertValue; + this.startPosition = startPosition; + } + + public PathInsertValueModification(PathInsertValueModification other) { + super(other); + insertValue = other.insertValue; + startPosition = other.startPosition; + } + + @Override + public PathInsertValueModification createCopy() { + return new PathInsertValueModification(this); + } + + @Override + protected String modifyImplementationHook(String input) { + if (input == null) { + return null; + } + + if (input.isEmpty()) { + return insertValue; + } + String[] pathParts = input.split("/"); + boolean leadingSlash = pathParts[0].isEmpty(); + + // Wrap around and also allow to insert at the end of the original value + int insertPosition; + if (leadingSlash) { + // If the path starts with a slash, skip the first empty path part. + insertPosition = startPosition % pathParts.length; + if (startPosition < 0) { + insertPosition += pathParts.length - 1; + } + insertPosition++; + } else { + insertPosition = startPosition % (pathParts.length + 1); + if (startPosition < 0) { + insertPosition += pathParts.length; + } + } + + if (insertPosition == 0 && leadingSlash) { + pathParts[insertPosition] = "/" + insertValue; + } else if (insertPosition == pathParts.length) { + pathParts[insertPosition - 1] = pathParts[insertPosition - 1] + "/" + insertValue; + } else { + pathParts[insertPosition] = insertValue + "/" + pathParts[insertPosition]; + } + if (input.endsWith("/")) { + pathParts[pathParts.length - 1] += "/"; + } + return String.join("/", pathParts); + } + + 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 VariableModification getModifiedCopy() { + Random r = new Random(); + + if (r.nextBoolean()) { + int index = r.nextInt(insertValue.length()); + char randomChar = (char) r.nextInt(MAX_EXPLICIT_VALUE); + StringBuilder modifiedString = new StringBuilder(insertValue); + modifiedString.setCharAt(index, randomChar); + return new PathInsertValueModification(modifiedString.toString(), startPosition); + } else { + int modifier = r.nextInt(MAX_INSERT_MODIFIER); + if (r.nextBoolean()) { + modifier *= -1; + } + modifier = startPosition + modifier; + if (modifier <= 0) { + modifier = 1; + } + return new PathInsertValueModification(insertValue, modifier); + } + } + + @Override + public int hashCode() { + int hash = 7; + hash = 31 * hash + insertValue.hashCode(); + 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; + } + PathInsertValueModification other = (PathInsertValueModification) obj; + if (startPosition != other.startPosition) { + return false; + } + return Objects.equals(insertValue, other.insertValue); + } +} diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathModificationFactory.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathModificationFactory.java new file mode 100644 index 00000000..46f2eade --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathModificationFactory.java @@ -0,0 +1,88 @@ +/* + * 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.path; + +import de.rub.nds.modifiablevariable.VariableModification; +import de.rub.nds.modifiablevariable.util.RandomHelper; +import java.util.Random; + +/** */ +public final class PathModificationFactory { + + private PathModificationFactory() { + super(); + } + + private enum ModificationType { + APPEND, + PREPEND, + INSERT + } + + private static final int MODIFICATION_COUNT = ModificationType.values().length; + + private static final int MAX_BYTE_LENGTH_INSERT = 200; + + private static final int MODIFIED_STRING_LENGTH_ESTIMATION = 50; + + public static VariableModification prependValue(String value) { + return new PathPrependValueModification(value); + } + + public static VariableModification appendValue(String value) { + return new PathAppendValueModification(value); + } + + public static VariableModification insertValue(String value, int position) { + return new PathInsertValueModification(value, position); + } + + public static VariableModification createRandomModification(String originalValue) { + Random random = RandomHelper.getRandom(); + ModificationType randomType = ModificationType.values()[random.nextInt(MODIFICATION_COUNT)]; + int modificationArrayLength; + int modifiedArrayLength; + if (originalValue == null) { + modifiedArrayLength = MODIFIED_STRING_LENGTH_ESTIMATION; + } else { + modifiedArrayLength = originalValue.length(); + if (modifiedArrayLength == 0 || modifiedArrayLength == 1) { + randomType = ModificationType.APPEND; + } + } + switch (randomType) { + case APPEND: + modificationArrayLength = random.nextInt(MAX_BYTE_LENGTH_INSERT); + if (modificationArrayLength == 0) { + modificationArrayLength++; + } + byte[] bytesToAppend = new byte[modificationArrayLength]; + random.nextBytes(bytesToAppend); + return new PathAppendValueModification(new String(bytesToAppend)); + case PREPEND: + modificationArrayLength = random.nextInt(MAX_BYTE_LENGTH_INSERT); + if (modificationArrayLength == 0) { + modificationArrayLength++; + } + byte[] bytesToPrepend = new byte[modificationArrayLength]; + random.nextBytes(bytesToPrepend); + return new PathPrependValueModification(new String(bytesToPrepend)); + case INSERT: + modificationArrayLength = random.nextInt(MAX_BYTE_LENGTH_INSERT); + if (modificationArrayLength == 0) { + modificationArrayLength++; + } + byte[] bytesToInsert = new byte[modificationArrayLength]; + random.nextBytes(bytesToInsert); + int insertPosition = random.nextInt(modifiedArrayLength); + return new PathInsertValueModification(new String(bytesToInsert), insertPosition); + default: + throw new IllegalStateException("Unexpected modification type: " + randomType); + } + } +} diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java new file mode 100644 index 00000000..fb4efc39 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java @@ -0,0 +1,97 @@ +/* + * 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.path; + +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; +import java.util.Random; + +/** Modification that prepends a string to the original value. */ +@XmlRootElement +@XmlType(propOrder = {"prependValue", "modificationFilter"}) +public class PathPrependValueModification extends VariableModification { + + private static final int MAX_EXPLICIT_VALUE = 256; + + @XmlJavaTypeAdapter(IllegalStringAdapter.class) + private String prependValue; + + public PathPrependValueModification() { + super(); + } + + public PathPrependValueModification(String prependValue) { + super(); + this.prependValue = prependValue; + } + + public PathPrependValueModification(PathPrependValueModification other) { + super(other); + prependValue = other.prependValue; + } + + @Override + public PathPrependValueModification createCopy() { + return new PathPrependValueModification(this); + } + + @Override + protected String modifyImplementationHook(String input) { + if (input == null) { + return null; + } + if (input.startsWith("/")) { + return "/" + prependValue + input; + } + return prependValue + "/" + input; + } + + public String getPrependValue() { + return prependValue; + } + + public void setPrependValue(String prependValue) { + this.prependValue = prependValue; + } + + @Override + public VariableModification getModifiedCopy() { + Random r = new Random(); + int index = r.nextInt(prependValue.length()); + char randomChar = (char) r.nextInt(MAX_EXPLICIT_VALUE); + StringBuilder modifiedString = new StringBuilder(prependValue); + modifiedString.setCharAt(index, randomChar); + return new PathPrependValueModification(modifiedString.toString()); + } + + @Override + public int hashCode() { + int hash = 7; + hash = 31 * hash + prependValue.hashCode(); + return hash; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + PathPrependValueModification other = (PathPrependValueModification) obj; + return Objects.equals(prependValue, other.prependValue); + } +} diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootValueModification.java new file mode 100644 index 00000000..ac84f829 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootValueModification.java @@ -0,0 +1,63 @@ +/* + * 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.path; + +import de.rub.nds.modifiablevariable.VariableModification; +import jakarta.xml.bind.annotation.XmlRootElement; +import jakarta.xml.bind.annotation.XmlType; + +/** Modification that appends a string to the original value. */ +@XmlRootElement +@XmlType(propOrder = {"modificationFilter"}) +public class PathToggleRootValueModification extends VariableModification { + + public PathToggleRootValueModification() { + super(); + } + + public PathToggleRootValueModification(PathToggleRootValueModification other) { + super(other); + } + + @Override + public PathToggleRootValueModification createCopy() { + return new PathToggleRootValueModification(this); + } + + @Override + protected String modifyImplementationHook(String input) { + if (input == null) { + return null; + } + if (!input.isEmpty() && input.charAt(0) == '/') { + return input.substring(1); + } + return "/" + input; + } + + @Override + public VariableModification getModifiedCopy() { + return new PathToggleRootValueModification(); + } + + @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(); + } +} 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 54482223..b5ce1bc2 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteAddModification.java @@ -30,6 +30,16 @@ public ByteAddModification(Byte summand) { this.summand = summand; } + public ByteAddModification(ByteAddModification other) { + super(other); + summand = other.summand; + } + + @Override + public ByteAddModification createCopy() { + return new ByteAddModification(this); + } + @Override protected Byte modifyImplementationHook(Byte input) { if (input == null) { @@ -51,11 +61,6 @@ public VariableModification getModifiedCopy() { return new ByteAddModification((byte) (summand + new Random().nextInt(MAX_ADD_MODIFIER))); } - @Override - public VariableModification createCopy() { - return new ByteAddModification(summand); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java index 16b208d7..b8948fbc 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java @@ -15,7 +15,7 @@ import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"index", "explicitValue", "modificationFilter"}) +@XmlType(propOrder = "index") @XmlAccessorType(XmlAccessType.FIELD) public class ByteExplicitValueFromFileModification extends ByteExplicitValueModification { private int index; @@ -29,6 +29,16 @@ public ByteExplicitValueFromFileModification(int index, Byte explicitValue) { this.index = index; } + public ByteExplicitValueFromFileModification(ByteExplicitValueFromFileModification other) { + super(other); + index = other.index; + } + + @Override + public ByteExplicitValueFromFileModification createCopy() { + return new ByteExplicitValueFromFileModification(this); + } + public int getIndex() { return index; } @@ -39,11 +49,6 @@ public VariableModification getModifiedCopy() { "Cannot set modify Value of ByteExplicitValueFromFileModification"); } - @Override - public VariableModification createCopy() { - return new ByteExplicitValueFromFileModification(index, explicitValue); - } - @Override public int hashCode() { int hash = 7; 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 05df3e8b..47d2db54 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueModification.java @@ -30,6 +30,16 @@ public ByteExplicitValueModification(Byte explicitValue) { this.explicitValue = explicitValue; } + public ByteExplicitValueModification(ByteExplicitValueModification other) { + super(other); + explicitValue = other.explicitValue; + } + + @Override + public ByteExplicitValueModification createCopy() { + return new ByteExplicitValueModification(this); + } + @Override protected Byte modifyImplementationHook(Byte input) { return explicitValue; @@ -55,11 +65,6 @@ public VariableModification getModifiedCopy() { } } - @Override - public VariableModification createCopy() { - return new ByteExplicitValueModification(explicitValue); - } - @Override public int hashCode() { int hash = 7; 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 fb6627bc..834bcc37 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteSubtractModification.java @@ -30,6 +30,16 @@ public ByteSubtractModification(Byte subtrahend) { this.subtrahend = subtrahend; } + public ByteSubtractModification(ByteSubtractModification other) { + super(other); + subtrahend = other.subtrahend; + } + + @Override + public ByteSubtractModification createCopy() { + return new ByteSubtractModification(this); + } + @Override protected Byte modifyImplementationHook(Byte input) { if (input == null) { @@ -52,11 +62,6 @@ public VariableModification getModifiedCopy() { (byte) (subtrahend + new Random().nextInt(MAX_SUBTRACT_MODIFIER))); } - @Override - public VariableModification createCopy() { - return new ByteSubtractModification(subtrahend); - } - @Override public int hashCode() { int hash = 7; 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 eb471709..19b8aef5 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteXorModification.java @@ -31,6 +31,16 @@ public ByteXorModification(Byte xor) { this.xor = xor; } + public ByteXorModification(ByteXorModification other) { + super(other); + xor = other.xor; + } + + @Override + public ByteXorModification createCopy() { + return new ByteXorModification(this); + } + @Override protected Byte modifyImplementationHook(Byte input) { if (input == null) { @@ -57,11 +67,6 @@ public VariableModification getModifiedCopy() { } } - @Override - public VariableModification createCopy() { - return new ByteXorModification(xor); - } - @Override public int hashCode() { int hash = 7; 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 706fc68d..3a76bd78 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByte.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByte.java @@ -29,14 +29,14 @@ public ModifiableByte(ModifiableByte other) { } @Override - protected void createRandomModification() { - VariableModification vm = ByteModificationFactory.createRandomModification(); - setModification(vm); + public ModifiableByte createCopy() { + return new ModifiableByte(this); } @Override - public ModifiableByte createCopy() { - return new ModifiableByte(this); + protected void createRandomModification() { + VariableModification vm = ByteModificationFactory.createRandomModification(); + setModification(vm); } public Byte getAssertEquals() { 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 7fbc8d7b..c207b180 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java @@ -24,7 +24,7 @@ public class ModifiableString extends ModifiableVariable { @XmlJavaTypeAdapter(IllegalStringAdapter.class) - private String originalValue; + protected String originalValue; public ModifiableString() { super(); @@ -36,14 +36,14 @@ public ModifiableString(ModifiableString other) { } @Override - protected void createRandomModification() { - VariableModification vm = StringModificationFactory.createRandomModification(null); - setModification(vm); + public ModifiableString createCopy() { + return new ModifiableString(this); } @Override - public ModifiableString createCopy() { - return new ModifiableString(this); + protected void createRandomModification() { + VariableModification vm = StringModificationFactory.createRandomModification(null); + setModification(vm); } public String getAssertEquals() { 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 b4858829..3de565ff 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java @@ -34,9 +34,19 @@ public StringAppendValueModification(String appendValue) { this.appendValue = appendValue; } + public StringAppendValueModification(StringAppendValueModification other) { + super(other); + appendValue = other.appendValue; + } + + @Override + public StringAppendValueModification createCopy() { + return new StringAppendValueModification(this); + } + @Override protected String modifyImplementationHook(String input) { - return input + appendValue; + return input != null ? input + appendValue : appendValue; } public String getAppendValue() { @@ -57,11 +67,6 @@ public VariableModification getModifiedCopy() { return new StringAppendValueModification(modifiedString.toString()); } - @Override - public VariableModification createCopy() { - return new StringAppendValueModification(appendValue); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java new file mode 100644 index 00000000..5d7acd11 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java @@ -0,0 +1,78 @@ +/* + * 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.XmlAccessType; +import jakarta.xml.bind.annotation.XmlAccessorType; +import jakarta.xml.bind.annotation.XmlRootElement; +import jakarta.xml.bind.annotation.XmlType; +import java.util.Objects; + +@XmlRootElement +@XmlType(propOrder = "index") +@XmlAccessorType(XmlAccessType.FIELD) +public class StringExplicitValueFromFileModification extends StringExplicitValueModification { + private int index; + + public StringExplicitValueFromFileModification() { + super(); + } + + public StringExplicitValueFromFileModification(int index, String explicitValue) { + super(explicitValue); + this.index = index; + } + + public StringExplicitValueFromFileModification(StringExplicitValueFromFileModification other) { + super(other); + index = other.index; + } + + @Override + public StringExplicitValueFromFileModification createCopy() { + return new StringExplicitValueFromFileModification(this); + } + + public int getIndex() { + return index; + } + + @Override + public VariableModification getModifiedCopy() { + throw new UnsupportedOperationException( + "Cannot set modify Value of StringExplicitValueFromFileModification"); + } + + @Override + public int hashCode() { + int hash = 7; + hash = 31 * hash + index; + hash = 31 * hash + explicitValue.hashCode(); + return hash; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + StringExplicitValueFromFileModification other = + (StringExplicitValueFromFileModification) obj; + if (index != other.index) { + return false; + } + return Objects.equals(explicitValue, other.explicitValue); + } +} 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 7b564a22..d901fc51 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java @@ -23,7 +23,7 @@ public class StringExplicitValueModification extends VariableModification getModifiedCopy() { return new StringExplicitValueModification(modifiedString.toString()); } - @Override - public VariableModification createCopy() { - return new StringExplicitValueModification(explicitValue); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java index 367ed4a8..ea99f581 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java @@ -39,8 +39,22 @@ public StringInsertValueModification(String insertValue, int startPosition) { 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) { @@ -89,11 +103,6 @@ public VariableModification getModifiedCopy() { } } - @Override - public VariableModification createCopy() { - return new StringInsertValueModification(insertValue, startPosition); - } - @Override public int hashCode() { int hash = 7; 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 1b5dcf5b..93452fe1 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java @@ -34,9 +34,19 @@ public StringPrependValueModification(String prependValue) { this.prependValue = prependValue; } + public StringPrependValueModification(StringPrependValueModification other) { + super(other); + prependValue = other.prependValue; + } + + @Override + public StringPrependValueModification createCopy() { + return new StringPrependValueModification(this); + } + @Override protected String modifyImplementationHook(String input) { - return prependValue + input; + return input != null ? prependValue + input : prependValue; } public String getPrependValue() { @@ -57,11 +67,6 @@ public VariableModification getModifiedCopy() { return new StringPrependValueModification(modifiedString.toString()); } - @Override - public VariableModification createCopy() { - return new StringPrependValueModification(prependValue); - } - @Override public int hashCode() { int hash = 7; 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 9aeba5c7..ec87a841 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/serialization/ByteArraySerializationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/serialization/ByteArraySerializationTest.java @@ -82,7 +82,6 @@ public void testSerializeDeserializeSimple() throws Exception { public void testSerializeDeserializeWithModification() throws Exception { VariableModification modifier = ByteArrayModificationFactory.insertValue(new byte[] {1, 2}, 0); - start.setModification(modifier); m.marshal(start, writer); From 3bb9d9f1f9db990abfb3c7f7194532d1bb66be79 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Wed, 4 Dec 2024 19:32:16 +0100 Subject: [PATCH 25/82] Add ModifiablePath utilities and missing XmlElement Annotations --- .../ModifiableVariable.java | 24 +++++-- .../ModifiableVariableFactory.java | 21 ++++++ .../path/ModifiablePath.java | 1 - ...InsertDirectoryTraversalModification.java} | 22 +++--- .../path/PathModificationFactory.java | 72 +++++++++++++------ ...n.java => PathToggleRootModification.java} | 12 ++-- .../modifiablevariable/util/Modifiable.java | 37 ++++++++-- 7 files changed, 140 insertions(+), 49 deletions(-) rename src/main/java/de/rub/nds/modifiablevariable/path/{PathInsertDirectoryTraversalValueModification.java => PathInsertDirectoryTraversalModification.java} (85%) rename src/main/java/de/rub/nds/modifiablevariable/path/{PathToggleRootValueModification.java => PathToggleRootModification.java} (77%) diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java index 29a45a46..0080189c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -13,11 +13,9 @@ import de.rub.nds.modifiablevariable.bytearray.*; import de.rub.nds.modifiablevariable.integer.*; import de.rub.nds.modifiablevariable.longint.*; +import de.rub.nds.modifiablevariable.path.*; import de.rub.nds.modifiablevariable.singlebyte.*; -import de.rub.nds.modifiablevariable.string.StringAppendValueModification; -import de.rub.nds.modifiablevariable.string.StringExplicitValueModification; -import de.rub.nds.modifiablevariable.string.StringInsertValueModification; -import de.rub.nds.modifiablevariable.string.StringPrependValueModification; +import de.rub.nds.modifiablevariable.string.*; import jakarta.xml.bind.annotation.XmlAccessType; import jakarta.xml.bind.annotation.XmlAccessorType; import jakarta.xml.bind.annotation.XmlElement; @@ -156,14 +154,28 @@ public abstract class ModifiableVariable implements Serializable { @XmlElement( type = StringAppendValueModification.class, name = "StringAppendValueModification"), + @XmlElement( + type = StringExplicitValueFromFileModification.class, + name = "StringExplicitValueFromFileModification"), @XmlElement( type = StringExplicitValueModification.class, name = "StringExplicitValueModification"), @XmlElement( type = StringInsertValueModification.class, - name = "StringInsertValueModification") + name = "StringInsertValueModification"), + @XmlElement(type = PathAppendValueModification.class, name = "PathAppendValueModification"), + @XmlElement( + type = PathInsertDirectoryTraversalModification.class, + name = "PathInsertDirectoryTraversalValueModification"), + @XmlElement(type = PathInsertValueModification.class, name = "PathInsertValueModification"), + @XmlElement( + type = PathPrependValueModification.class, + name = "PathPrependValueModification"), + @XmlElement( + type = PathToggleRootModification.class, + name = "PathToggleRootValueModification"), }) - private VariableModification modification = null; + private VariableModification modification; private Boolean createRandomModification; diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableFactory.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableFactory.java index 4e3e3e91..08fe41b6 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableFactory.java @@ -12,6 +12,7 @@ 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.path.ModifiablePath; import de.rub.nds.modifiablevariable.singlebyte.ModifiableByte; import de.rub.nds.modifiablevariable.string.ModifiableString; import java.math.BigInteger; @@ -38,6 +39,18 @@ public static ModifiableLong createLongModifiableVariable() { return new ModifiableLong(); } + public static ModifiableBoolean createBooleanModifiableVariable() { + return new ModifiableBoolean(); + } + + public static ModifiableString createStringModifiableVariable() { + return new ModifiableString(); + } + + public static ModifiablePath createPathModifiableVariable() { + return new ModifiablePath(); + } + public static ModifiableBigInteger safelySetValue(ModifiableBigInteger mv, BigInteger value) { if (mv == null) { mv = new ModifiableBigInteger(); @@ -94,6 +107,14 @@ public static ModifiableBoolean safelySetValue(ModifiableBoolean mv, Boolean val return mv; } + public static ModifiablePath safelySetValue(ModifiablePath mv, String value) { + if (mv == null) { + mv = new ModifiablePath(); + } + mv.setOriginalValue(value); + return mv; + } + private ModifiableVariableFactory() { super(); } diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java b/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java index 5fcbf317..47e4489a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java @@ -15,7 +15,6 @@ import jakarta.xml.bind.annotation.XmlAccessorType; import jakarta.xml.bind.annotation.XmlRootElement; -/** */ @XmlRootElement @XmlAccessorType(XmlAccessType.FIELD) public class ModifiablePath extends ModifiableString { diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java similarity index 85% rename from src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalValueModification.java rename to src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java index 94f222c2..253cd67d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java @@ -18,7 +18,7 @@ /** Modification that appends a string to the original value. */ @XmlRootElement @XmlType(propOrder = {"insertValue", "count", "startPosition", "modificationFilter"}) -public class PathInsertDirectoryTraversalValueModification extends VariableModification { +public class PathInsertDirectoryTraversalModification extends VariableModification { private static final int MAX_INSERT_MODIFIER = 32; @@ -28,19 +28,19 @@ public class PathInsertDirectoryTraversalValueModification extends VariableModif private int count; private int startPosition; - public PathInsertDirectoryTraversalValueModification() { + public PathInsertDirectoryTraversalModification() { super(); } - public PathInsertDirectoryTraversalValueModification(int count, int startPosition) { + public PathInsertDirectoryTraversalModification(int count, int startPosition) { super(); this.count = count; this.startPosition = startPosition; updateInsertValue(); } - public PathInsertDirectoryTraversalValueModification( - PathInsertDirectoryTraversalValueModification other) { + public PathInsertDirectoryTraversalModification( + PathInsertDirectoryTraversalModification other) { super(other); insertValue = other.insertValue; count = other.count; @@ -48,8 +48,8 @@ public PathInsertDirectoryTraversalValueModification( } @Override - public PathInsertDirectoryTraversalValueModification createCopy() { - return new PathInsertDirectoryTraversalValueModification(this); + public PathInsertDirectoryTraversalModification createCopy() { + return new PathInsertDirectoryTraversalModification(this); } private void updateInsertValue() { @@ -134,7 +134,7 @@ public VariableModification getModifiedCopy() { if (modifier <= 0) { modifier = 1; } - return new PathInsertDirectoryTraversalValueModification(modifier, startPosition); + return new PathInsertDirectoryTraversalModification(modifier, startPosition); } else { int modifier = r.nextInt(MAX_INSERT_MODIFIER); if (r.nextBoolean()) { @@ -144,7 +144,7 @@ public VariableModification getModifiedCopy() { if (modifier <= 0) { modifier = 1; } - return new PathInsertDirectoryTraversalValueModification(count, modifier); + return new PathInsertDirectoryTraversalModification(count, modifier); } } @@ -167,8 +167,8 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - PathInsertDirectoryTraversalValueModification other = - (PathInsertDirectoryTraversalValueModification) obj; + PathInsertDirectoryTraversalModification other = + (PathInsertDirectoryTraversalModification) obj; if (startPosition != other.startPosition) { return false; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathModificationFactory.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathModificationFactory.java index 46f2eade..267cacdc 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathModificationFactory.java @@ -21,14 +21,18 @@ private PathModificationFactory() { private enum ModificationType { APPEND, PREPEND, - INSERT + INSERT, + INSERT_DIRECTORY_TRAVERSAL, + TOGGLE_ROOT, } private static final int MODIFICATION_COUNT = ModificationType.values().length; private static final int MAX_BYTE_LENGTH_INSERT = 200; - private static final int MODIFIED_STRING_LENGTH_ESTIMATION = 50; + private static final int NUMBER_OF_PATH_PARTS_ESTIMATION = 50; + + private static final int MAX_NUMBER_OF_DIRECTORY_TRAVERSAL_INSERT = 10; public static VariableModification prependValue(String value) { return new PathPrependValueModification(value); @@ -42,45 +46,71 @@ public static VariableModification insertValue(String value, int positio return new PathInsertValueModification(value, position); } + public static VariableModification insertDirectoryTraversal(int count, int position) { + return new PathInsertDirectoryTraversalModification(count, position); + } + + public static VariableModification toggleRoot() { + return new PathToggleRootModification(); + } + public static VariableModification createRandomModification(String originalValue) { Random random = RandomHelper.getRandom(); ModificationType randomType = ModificationType.values()[random.nextInt(MODIFICATION_COUNT)]; - int modificationArrayLength; - int modifiedArrayLength; + int modificationStringLength; + int numberOfPathParts; if (originalValue == null) { - modifiedArrayLength = MODIFIED_STRING_LENGTH_ESTIMATION; + numberOfPathParts = NUMBER_OF_PATH_PARTS_ESTIMATION; } else { - modifiedArrayLength = originalValue.length(); - if (modifiedArrayLength == 0 || modifiedArrayLength == 1) { - randomType = ModificationType.APPEND; + String[] pathParts = originalValue.split("/"); + if (pathParts.length == 0) { + if (randomType == ModificationType.INSERT) { + randomType = ModificationType.APPEND; + } + numberOfPathParts = 0; + } else { + if (pathParts[0].isEmpty()) { + numberOfPathParts = originalValue.split("/").length - 1; + } else { + numberOfPathParts = originalValue.split("/").length; + } } } + int insertPosition; switch (randomType) { case APPEND: - modificationArrayLength = random.nextInt(MAX_BYTE_LENGTH_INSERT); - if (modificationArrayLength == 0) { - modificationArrayLength++; + modificationStringLength = random.nextInt(MAX_BYTE_LENGTH_INSERT); + if (modificationStringLength == 0) { + modificationStringLength++; } - byte[] bytesToAppend = new byte[modificationArrayLength]; + byte[] bytesToAppend = new byte[modificationStringLength]; random.nextBytes(bytesToAppend); return new PathAppendValueModification(new String(bytesToAppend)); case PREPEND: - modificationArrayLength = random.nextInt(MAX_BYTE_LENGTH_INSERT); - if (modificationArrayLength == 0) { - modificationArrayLength++; + modificationStringLength = random.nextInt(MAX_BYTE_LENGTH_INSERT); + if (modificationStringLength == 0) { + modificationStringLength++; } - byte[] bytesToPrepend = new byte[modificationArrayLength]; + byte[] bytesToPrepend = new byte[modificationStringLength]; random.nextBytes(bytesToPrepend); return new PathPrependValueModification(new String(bytesToPrepend)); case INSERT: - modificationArrayLength = random.nextInt(MAX_BYTE_LENGTH_INSERT); - if (modificationArrayLength == 0) { - modificationArrayLength++; + modificationStringLength = random.nextInt(MAX_BYTE_LENGTH_INSERT); + if (modificationStringLength == 0) { + modificationStringLength++; } - byte[] bytesToInsert = new byte[modificationArrayLength]; + byte[] bytesToInsert = new byte[modificationStringLength]; random.nextBytes(bytesToInsert); - int insertPosition = random.nextInt(modifiedArrayLength); + insertPosition = random.nextInt(numberOfPathParts); return new PathInsertValueModification(new String(bytesToInsert), insertPosition); + case INSERT_DIRECTORY_TRAVERSAL: + int numberOfDirectoryTraversal = + random.nextInt(MAX_NUMBER_OF_DIRECTORY_TRAVERSAL_INSERT); + insertPosition = random.nextInt(numberOfPathParts); + return new PathInsertDirectoryTraversalModification( + numberOfDirectoryTraversal, insertPosition); + case TOGGLE_ROOT: + return new PathToggleRootModification(); default: throw new IllegalStateException("Unexpected modification type: " + randomType); } diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootModification.java similarity index 77% rename from src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootValueModification.java rename to src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootModification.java index ac84f829..ea06e1d1 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootModification.java @@ -14,19 +14,19 @@ /** Modification that appends a string to the original value. */ @XmlRootElement @XmlType(propOrder = {"modificationFilter"}) -public class PathToggleRootValueModification extends VariableModification { +public class PathToggleRootModification extends VariableModification { - public PathToggleRootValueModification() { + public PathToggleRootModification() { super(); } - public PathToggleRootValueModification(PathToggleRootValueModification other) { + public PathToggleRootModification(PathToggleRootModification other) { super(other); } @Override - public PathToggleRootValueModification createCopy() { - return new PathToggleRootValueModification(this); + public PathToggleRootModification createCopy() { + return new PathToggleRootModification(this); } @Override @@ -42,7 +42,7 @@ protected String modifyImplementationHook(String input) { @Override public VariableModification getModifiedCopy() { - return new PathToggleRootValueModification(); + return new PathToggleRootModification(); } @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 d883b468..6db03640 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; @@ -19,6 +18,8 @@ import de.rub.nds.modifiablevariable.integer.ModifiableInteger; import de.rub.nds.modifiablevariable.longint.LongModificationFactory; import de.rub.nds.modifiablevariable.longint.ModifiableLong; +import de.rub.nds.modifiablevariable.path.ModifiablePath; +import de.rub.nds.modifiablevariable.path.PathModificationFactory; import de.rub.nds.modifiablevariable.singlebyte.ByteModificationFactory; import de.rub.nds.modifiablevariable.singlebyte.ModifiableByte; import de.rub.nds.modifiablevariable.string.ModifiableString; @@ -81,6 +82,13 @@ private static ModifiableString getModifiableStringWithModification( return modifiableString; } + private static ModifiablePath getModifiablePathWithModification( + VariableModification modification) { + ModifiablePath modifiablePath = new ModifiablePath(); + modifiablePath.setModification(modification); + return modifiablePath; + } + public static ModifiableBigInteger prepend(BigInteger i) { return getModifiableBigIntegerWithModification( BigIntegerModificationFactory.prependValue(i)); @@ -102,6 +110,10 @@ public static ModifiableString prepend(String s) { return getModifiableStringWithModification(StringModificationFactory.prependValue(s)); } + public static ModifiablePath prependPath(String s) { + return getModifiablePathWithModification(PathModificationFactory.prependValue(s)); + } + public static ModifiableBigInteger append(BigInteger i) { return getModifiableBigIntegerWithModification( BigIntegerModificationFactory.appendValue(i)); @@ -123,6 +135,10 @@ public static ModifiableString append(String s) { return getModifiableStringWithModification(StringModificationFactory.appendValue(s)); } + public static ModifiablePath appendPath(String s) { + return getModifiablePathWithModification(PathModificationFactory.appendValue(s)); + } + public static ModifiableByteArray explicit(byte[] b) { return getModifiableByteArrayWithModification( ByteArrayModificationFactory.explicitValue(b)); @@ -146,7 +162,7 @@ public static ModifiableLong explicit(Long l) { } public static ModifiableBoolean explicit(Boolean b) { - return getModifiableBooleanWithModification(new BooleanExplicitValueModification(b)); + return getModifiableBooleanWithModification(BooleanModificationFactory.explicitValue(b)); } public static ModifiableString explicit(String s) { @@ -177,6 +193,15 @@ public static ModifiableString insert(String s, int position) { StringModificationFactory.insertValue(s, position)); } + public static ModifiablePath insertPath(String s, int position) { + return getModifiablePathWithModification(PathModificationFactory.insertValue(s, position)); + } + + public static ModifiablePath insertDirectoryTraversal(int count, int position) { + return getModifiablePathWithModification( + PathModificationFactory.insertDirectoryTraversal(count, position)); + } + public static ModifiableByteArray xor(byte[] b, int position) { return getModifiableByteArrayWithModification( ByteArrayModificationFactory.xor(b, position)); @@ -245,7 +270,11 @@ public static ModifiableByteArray duplicate() { } public static ModifiableBoolean toggle() { - return getModifiableBooleanWithModification(new BooleanToggleModification()); + return getModifiableBooleanWithModification(BooleanModificationFactory.toggle()); + } + + public static ModifiablePath toggleRoot() { + return getModifiablePathWithModification(PathModificationFactory.toggleRoot()); } public static ModifiableBigInteger shiftLeftBigInteger(Integer i) { From 753aa9dc1344514f405e4226651de3c6ed7d8657 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Wed, 4 Dec 2024 19:40:11 +0100 Subject: [PATCH 26/82] run formatter --- .../de/rub/nds/modifiablevariable/ModifiableVariable.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java index 0080189c..a88741ec 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -155,8 +155,8 @@ public abstract class ModifiableVariable implements Serializable { type = StringAppendValueModification.class, name = "StringAppendValueModification"), @XmlElement( - type = StringExplicitValueFromFileModification.class, - name = "StringExplicitValueFromFileModification"), + type = StringExplicitValueFromFileModification.class, + name = "StringExplicitValueFromFileModification"), @XmlElement( type = StringExplicitValueModification.class, name = "StringExplicitValueModification"), From 6566fb94292ae0ef9f702e4fc72698474203eb14 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Thu, 5 Dec 2024 15:25:05 +0100 Subject: [PATCH 27/82] Add PathInsertDirectorySeparatorModification --- .../ModifiableVariable.java | 3 + ...hInsertDirectorySeparatorModification.java | 134 ++++++++++++++++++ ...hInsertDirectoryTraversalModification.java | 38 +---- .../path/PathInsertValueModification.java | 38 +---- .../path/PathModificationFactory.java | 12 ++ .../nds/modifiablevariable/path/PathUtil.java | 62 ++++++++ .../modifiablevariable/util/Modifiable.java | 5 + 7 files changed, 218 insertions(+), 74 deletions(-) create mode 100644 src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectorySeparatorModification.java create mode 100644 src/main/java/de/rub/nds/modifiablevariable/path/PathUtil.java diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java index a88741ec..77d59ac9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -164,6 +164,9 @@ public abstract class ModifiableVariable implements Serializable { type = StringInsertValueModification.class, name = "StringInsertValueModification"), @XmlElement(type = PathAppendValueModification.class, name = "PathAppendValueModification"), + @XmlElement( + type = PathInsertDirectorySeparatorModification.class, + name = "PathInsertDirectorySeparatorModification"), @XmlElement( type = PathInsertDirectoryTraversalModification.class, name = "PathInsertDirectoryTraversalValueModification"), diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectorySeparatorModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectorySeparatorModification.java new file mode 100644 index 00000000..77741bfa --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectorySeparatorModification.java @@ -0,0 +1,134 @@ +/* + * 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.path; + +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; +import java.util.Random; + +/** Modification that appends a string to the original value. */ +@XmlRootElement +@XmlType(propOrder = {"insertValue", "count", "startPosition", "modificationFilter"}) +public class PathInsertDirectorySeparatorModification extends VariableModification { + + private static final int MAX_INSERT_MODIFIER = 32; + + @XmlJavaTypeAdapter(IllegalStringAdapter.class) + private String insertValue; + + private int count; + private int startPosition; + + public PathInsertDirectorySeparatorModification() { + super(); + } + + public PathInsertDirectorySeparatorModification(int count, int startPosition) { + super(); + this.count = count; + this.startPosition = startPosition; + updateInsertValue(); + } + + public PathInsertDirectorySeparatorModification( + PathInsertDirectorySeparatorModification other) { + super(other); + insertValue = other.insertValue; + count = other.count; + startPosition = other.startPosition; + } + + @Override + public PathInsertDirectorySeparatorModification createCopy() { + return new PathInsertDirectorySeparatorModification(this); + } + + private void updateInsertValue() { + insertValue = "/".repeat(Math.max(0, count)); + } + + @Override + protected String modifyImplementationHook(String input) { + return PathUtil.insertValueAsPathPart(input, insertValue, startPosition); + } + + public int getCount() { + return count; + } + + public void setCount(int count) { + this.count = count; + updateInsertValue(); + } + + 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 modifier = r.nextInt(MAX_INSERT_MODIFIER); + if (r.nextBoolean()) { + modifier *= -1; + } + modifier = count + modifier; + if (modifier <= 0) { + modifier = 1; + } + return new PathInsertDirectorySeparatorModification(modifier, startPosition); + } else { + int modifier = r.nextInt(MAX_INSERT_MODIFIER); + if (r.nextBoolean()) { + modifier *= -1; + } + modifier = startPosition + modifier; + if (modifier <= 0) { + modifier = 1; + } + return new PathInsertDirectorySeparatorModification(count, modifier); + } + } + + @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; + } + PathInsertDirectorySeparatorModification other = + (PathInsertDirectorySeparatorModification) obj; + if (startPosition != other.startPosition) { + return false; + } + return Objects.equals(count, other.count); + } +} diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java index 253cd67d..4506bc38 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java @@ -65,43 +65,7 @@ private void updateInsertValue() { @Override protected String modifyImplementationHook(String input) { - if (input == null) { - return null; - } - - if (input.isEmpty()) { - return insertValue; - } - String[] pathParts = input.split("/"); - boolean leadingSlash = pathParts[0].isEmpty(); - - // Wrap around and also allow to insert at the end of the original value - int insertPosition; - if (leadingSlash) { - // If the path starts with a slash, skip the first empty path part. - insertPosition = startPosition % pathParts.length; - if (startPosition < 0) { - insertPosition += pathParts.length - 1; - } - insertPosition++; - } else { - insertPosition = startPosition % (pathParts.length + 1); - if (startPosition < 0) { - insertPosition += pathParts.length; - } - } - - if (insertPosition == 0 && leadingSlash) { - pathParts[insertPosition] = "/" + insertValue; - } else if (insertPosition == pathParts.length) { - pathParts[insertPosition - 1] = pathParts[insertPosition - 1] + "/" + insertValue; - } else { - pathParts[insertPosition] = insertValue + "/" + pathParts[insertPosition]; - } - if (input.endsWith("/")) { - pathParts[pathParts.length - 1] += "/"; - } - return String.join("/", pathParts); + return PathUtil.insertValueAsPathPart(input, insertValue, startPosition); } public int getCount() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java index 12a694a6..b391b40f 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java @@ -52,43 +52,7 @@ public PathInsertValueModification createCopy() { @Override protected String modifyImplementationHook(String input) { - if (input == null) { - return null; - } - - if (input.isEmpty()) { - return insertValue; - } - String[] pathParts = input.split("/"); - boolean leadingSlash = pathParts[0].isEmpty(); - - // Wrap around and also allow to insert at the end of the original value - int insertPosition; - if (leadingSlash) { - // If the path starts with a slash, skip the first empty path part. - insertPosition = startPosition % pathParts.length; - if (startPosition < 0) { - insertPosition += pathParts.length - 1; - } - insertPosition++; - } else { - insertPosition = startPosition % (pathParts.length + 1); - if (startPosition < 0) { - insertPosition += pathParts.length; - } - } - - if (insertPosition == 0 && leadingSlash) { - pathParts[insertPosition] = "/" + insertValue; - } else if (insertPosition == pathParts.length) { - pathParts[insertPosition - 1] = pathParts[insertPosition - 1] + "/" + insertValue; - } else { - pathParts[insertPosition] = insertValue + "/" + pathParts[insertPosition]; - } - if (input.endsWith("/")) { - pathParts[pathParts.length - 1] += "/"; - } - return String.join("/", pathParts); + return PathUtil.insertValueAsPathPart(input, insertValue, startPosition); } public String getInsertValue() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathModificationFactory.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathModificationFactory.java index 267cacdc..b1e6d374 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathModificationFactory.java @@ -23,6 +23,7 @@ private enum ModificationType { PREPEND, INSERT, INSERT_DIRECTORY_TRAVERSAL, + INSERT_DIRECTORY_SEPERATOR, TOGGLE_ROOT, } @@ -33,6 +34,7 @@ private enum ModificationType { private static final int NUMBER_OF_PATH_PARTS_ESTIMATION = 50; private static final int MAX_NUMBER_OF_DIRECTORY_TRAVERSAL_INSERT = 10; + private static final int MAX_NUMBER_OF_DIRECTORY_SEPERATOR_INSERT = 10; public static VariableModification prependValue(String value) { return new PathPrependValueModification(value); @@ -50,6 +52,10 @@ public static VariableModification insertDirectoryTraversal(int count, i return new PathInsertDirectoryTraversalModification(count, position); } + public static VariableModification insertDirectorySeperator(int count, int position) { + return new PathInsertDirectorySeparatorModification(count, position); + } + public static VariableModification toggleRoot() { return new PathToggleRootModification(); } @@ -109,6 +115,12 @@ public static VariableModification createRandomModification(String origi insertPosition = random.nextInt(numberOfPathParts); return new PathInsertDirectoryTraversalModification( numberOfDirectoryTraversal, insertPosition); + case INSERT_DIRECTORY_SEPERATOR: + int numberOfDirectorySeperator = + random.nextInt(MAX_NUMBER_OF_DIRECTORY_SEPERATOR_INSERT); + insertPosition = random.nextInt(numberOfPathParts); + return new PathInsertDirectorySeparatorModification( + numberOfDirectorySeperator, insertPosition); case TOGGLE_ROOT: return new PathToggleRootModification(); default: diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathUtil.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathUtil.java new file mode 100644 index 00000000..b4154de3 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathUtil.java @@ -0,0 +1,62 @@ +/* + * 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.path; + +public final class PathUtil { + + private PathUtil() { + super(); + } + + public static String insertValueAsPathPart( + String input, String insertValue, int startPosition) { + if (input == null) { + return null; + } + + if (input.isEmpty()) { + return insertValue; + } + String[] pathParts = input.split("/"); + boolean leadingSlash = pathParts[0].isEmpty(); + + // Wrap around and also allow to insert at the end of the original value + int insertPosition = getInsertPosition(startPosition, leadingSlash, pathParts); + + if (insertPosition == 0 && leadingSlash) { + pathParts[insertPosition] = "/" + insertValue; + } else if (insertPosition == pathParts.length) { + pathParts[insertPosition - 1] = pathParts[insertPosition - 1] + "/" + insertValue; + } else { + pathParts[insertPosition] = insertValue + "/" + pathParts[insertPosition]; + } + if (input.endsWith("/")) { + pathParts[pathParts.length - 1] += "/"; + } + return String.join("/", pathParts); + } + + private static int getInsertPosition( + int startPosition, boolean leadingSlash, String[] pathParts) { + int insertPosition; + if (leadingSlash) { + // If the path starts with a slash, skip the first empty path part. + insertPosition = startPosition % pathParts.length; + if (startPosition < 0) { + insertPosition += pathParts.length - 1; + } + insertPosition++; + } else { + insertPosition = startPosition % (pathParts.length + 1); + if (startPosition < 0) { + insertPosition += pathParts.length; + } + } + return insertPosition; + } +} 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 6db03640..a9507321 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/Modifiable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/Modifiable.java @@ -202,6 +202,11 @@ public static ModifiablePath insertDirectoryTraversal(int count, int position) { PathModificationFactory.insertDirectoryTraversal(count, position)); } + public static ModifiablePath insertDirectorySeperator(int count, int position) { + return getModifiablePathWithModification( + PathModificationFactory.insertDirectorySeperator(count, position)); + } + public static ModifiableByteArray xor(byte[] b, int position) { return getModifiableByteArrayWithModification( ByteArrayModificationFactory.xor(b, position)); From 95bb1ec4bd14ae2cfbc9ed7116464ecbec03fd4a Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Thu, 5 Dec 2024 15:27:55 +0100 Subject: [PATCH 28/82] Fix some comments --- .../modifiablevariable/path/PathAppendValueModification.java | 2 +- .../path/PathInsertDirectorySeparatorModification.java | 2 +- .../path/PathInsertDirectoryTraversalModification.java | 2 +- .../modifiablevariable/path/PathInsertValueModification.java | 2 +- .../nds/modifiablevariable/path/PathToggleRootModification.java | 2 +- .../string/StringInsertValueModification.java | 2 +- 6 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java index 9a106a73..67cf917a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java @@ -15,7 +15,7 @@ import java.util.Objects; import java.util.Random; -/** Modification that appends a string to the original value. */ +/** Modification that appends a path parts to the original value. */ @XmlRootElement @XmlType(propOrder = {"appendValue", "modificationFilter"}) public class PathAppendValueModification extends VariableModification { diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectorySeparatorModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectorySeparatorModification.java index 77741bfa..2235ff5c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectorySeparatorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectorySeparatorModification.java @@ -15,7 +15,7 @@ import java.util.Objects; import java.util.Random; -/** Modification that appends a string to the original value. */ +/** Modification that inserts directory separators as path parts to the original value. */ @XmlRootElement @XmlType(propOrder = {"insertValue", "count", "startPosition", "modificationFilter"}) public class PathInsertDirectorySeparatorModification extends VariableModification { diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java index 4506bc38..1ee351e9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java @@ -15,7 +15,7 @@ import java.util.Objects; import java.util.Random; -/** Modification that appends a string to the original value. */ +/** Modification that directory traversal path parts the original value. */ @XmlRootElement @XmlType(propOrder = {"insertValue", "count", "startPosition", "modificationFilter"}) public class PathInsertDirectoryTraversalModification extends VariableModification { diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java index b391b40f..620c7479 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java @@ -15,7 +15,7 @@ import java.util.Objects; import java.util.Random; -/** Modification that appends a string to the original value. */ +/** Modification that inserts path parts to the original value. */ @XmlRootElement @XmlType(propOrder = {"insertValue", "startPosition", "modificationFilter"}) public class PathInsertValueModification extends VariableModification { diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootModification.java index ea06e1d1..68479346 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootModification.java @@ -11,7 +11,7 @@ import jakarta.xml.bind.annotation.XmlRootElement; import jakarta.xml.bind.annotation.XmlType; -/** Modification that appends a string to the original value. */ +/** Modification that toggle the root slash of the original value. */ @XmlRootElement @XmlType(propOrder = {"modificationFilter"}) public class PathToggleRootModification extends VariableModification { diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java index ea99f581..8009d557 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java @@ -15,7 +15,7 @@ import java.util.Objects; import java.util.Random; -/** Modification that appends a string to the original value. */ +/** Modification that inserts a string to the original value. */ @XmlRootElement @XmlType(propOrder = {"insertValue", "startPosition", "modificationFilter"}) public class StringInsertValueModification extends VariableModification { From 4ded76cdbd6d62740cdd722189654624644503c0 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Thu, 5 Dec 2024 16:23:06 +0100 Subject: [PATCH 29/82] Add PathExplicitValueModification and PathExplicitValueFromFileModification --- .../ModifiableVariable.java | 6 ++ ...PathExplicitValueFromFileModification.java | 77 +++++++++++++++ .../path/PathExplicitValueModification.java | 93 +++++++++++++++++++ .../path/PathModificationFactory.java | 4 + 4 files changed, 180 insertions(+) create mode 100644 src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java create mode 100644 src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java index 77d59ac9..bc2afa0c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -163,6 +163,12 @@ public abstract class ModifiableVariable implements Serializable { @XmlElement( type = StringInsertValueModification.class, name = "StringInsertValueModification"), + @XmlElement( + type = PathExplicitValueFromFileModification.class, + name = "PathExplicitValueFromFileModification"), + @XmlElement( + type = PathExplicitValueModification.class, + name = "PathExplicitValueModification"), @XmlElement(type = PathAppendValueModification.class, name = "PathAppendValueModification"), @XmlElement( type = PathInsertDirectorySeparatorModification.class, diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java new file mode 100644 index 00000000..34f445d1 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.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.path; + +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.util.Objects; + +@XmlRootElement +@XmlType(propOrder = "index") +@XmlAccessorType(XmlAccessType.FIELD) +public class PathExplicitValueFromFileModification extends PathExplicitValueModification { + private int index; + + public PathExplicitValueFromFileModification() { + super(); + } + + public PathExplicitValueFromFileModification(int index, String explicitValue) { + super(explicitValue); + this.index = index; + } + + public PathExplicitValueFromFileModification(PathExplicitValueFromFileModification other) { + super(other); + index = other.index; + } + + @Override + public PathExplicitValueFromFileModification createCopy() { + return new PathExplicitValueFromFileModification(this); + } + + public int getIndex() { + return index; + } + + @Override + public VariableModification getModifiedCopy() { + throw new UnsupportedOperationException( + "Cannot set modify Value of PathExplicitValueFromFileModification"); + } + + @Override + public int hashCode() { + int hash = 7; + hash = 31 * hash + index; + hash = 31 * hash + explicitValue.hashCode(); + return hash; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + PathExplicitValueFromFileModification other = (PathExplicitValueFromFileModification) obj; + if (index != other.index) { + return false; + } + return Objects.equals(explicitValue, other.explicitValue); + } +} diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java new file mode 100644 index 00000000..01d4f048 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.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.path; + +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; +import java.util.Random; + +@XmlRootElement +@XmlType(propOrder = {"explicitValue", "modificationFilter"}) +public class PathExplicitValueModification extends VariableModification { + + private static final int MAX_EXPLICIT_VALUE = 256; + + @XmlJavaTypeAdapter(IllegalStringAdapter.class) + protected String explicitValue; + + public PathExplicitValueModification() { + super(); + } + + public PathExplicitValueModification(String explicitValue) { + super(); + this.explicitValue = explicitValue; + } + + public PathExplicitValueModification(PathExplicitValueModification other) { + super(other); + explicitValue = other.explicitValue; + } + + @Override + public PathExplicitValueModification createCopy() { + return new PathExplicitValueModification(this); + } + + @Override + protected String modifyImplementationHook(String input) { + return explicitValue; + } + + public String getExplicitValue() { + return explicitValue; + } + + public void setExplicitValue(String explicitValue) { + this.explicitValue = explicitValue; + } + + @Override + public VariableModification getModifiedCopy() { + if (explicitValue.isEmpty()) { + return this; + } + Random r = new Random(); + int index = r.nextInt(explicitValue.length()); + char randomChar = (char) r.nextInt(MAX_EXPLICIT_VALUE); + StringBuilder modifiedString = new StringBuilder(explicitValue); + modifiedString.setCharAt(index, randomChar); + return new PathExplicitValueModification(modifiedString.toString()); + } + + @Override + public int hashCode() { + int hash = 7; + hash = 31 * hash + explicitValue.hashCode(); + return hash; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + PathExplicitValueModification other = (PathExplicitValueModification) obj; + return Objects.equals(explicitValue, other.explicitValue); + } +} diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathModificationFactory.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathModificationFactory.java index b1e6d374..bd86f8bc 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathModificationFactory.java @@ -40,6 +40,10 @@ public static VariableModification prependValue(String value) { return new PathPrependValueModification(value); } + public static VariableModification explicitValue(String value) { + return new PathExplicitValueModification(value); + } + public static VariableModification appendValue(String value) { return new PathAppendValueModification(value); } From f9b1a010597f33c770b28553e220d3b124cf3d32 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Thu, 5 Dec 2024 17:11:17 +0100 Subject: [PATCH 30/82] Be kind to negative and null count in PathInsertDirectoryTraversalModification --- .../path/PathInsertDirectoryTraversalModification.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java index 1ee351e9..8df1104a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java @@ -53,6 +53,10 @@ public PathInsertDirectoryTraversalModification createCopy() { } private void updateInsertValue() { + if (count <= 0) { + insertValue = ""; + return; + } StringBuilder builder = new StringBuilder(count * 3 - 1); for (int i = 0; i < count; i++) { builder.append(".."); From 73094349815e2fd64dbad5a939e9ac1726ec64b9 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Fri, 6 Dec 2024 11:59:11 +0100 Subject: [PATCH 31/82] Add some toString() methods. Change backslashEscapeString() to return null if the value is null. --- .../biginteger/BigIntegerAddModification.java | 5 ++++ .../BigIntegerAppendValueModification.java | 5 ++++ ...egerExplicitValueFromFileModification.java | 10 ++++++++ .../BigIntegerExplicitValueModification.java | 5 ++++ .../BigIntegerInsertValueModification.java | 10 ++++++++ .../BigIntegerMultiplyModification.java | 5 ++++ .../BigIntegerPrependValueModification.java | 5 ++++ .../BigIntegerShiftLeftModification.java | 5 ++++ .../BigIntegerShiftRightModification.java | 5 ++++ .../BigIntegerSubtractModification.java | 5 ++++ .../biginteger/BigIntegerXorModification.java | 5 ++++ ...rrayExplicitValueFromFileModification.java | 11 +++++++++ .../ByteArrayPrependValueModification.java | 2 +- .../bytearray/ModifiableByteArray.java | 23 +++++++------------ .../integer/IntegerAddModification.java | 5 ++++ .../IntegerAppendValueModification.java | 5 ++++ ...egerExplicitValueFromFileModification.java | 10 ++++++++ .../IntegerExplicitValueModification.java | 5 ++++ .../IntegerInsertValueModification.java | 10 ++++++++ .../integer/IntegerMultiplyModification.java | 5 ++++ .../IntegerPrependValueModification.java | 5 ++++ .../integer/IntegerShiftLeftModification.java | 5 ++++ .../IntegerShiftRightModification.java | 5 ++++ .../integer/IntegerSubtractModification.java | 5 ++++ .../integer/IntegerXorModification.java | 5 ++++ .../longint/LongAddModification.java | 5 ++++ .../longint/LongAppendValueModification.java | 5 ++++ ...LongExplicitValueFromFileModification.java | 10 ++++++++ .../LongExplicitValueModification.java | 5 ++++ .../longint/LongInsertValueModification.java | 10 ++++++++ .../longint/LongMultiplyModification.java | 5 ++++ .../longint/LongPrependValueModification.java | 5 ++++ .../longint/LongShiftLeftModification.java | 5 ++++ .../longint/LongShiftRightModification.java | 5 ++++ .../longint/LongSubtractModification.java | 5 ++++ .../longint/LongXorModification.java | 5 ++++ .../path/ModifiablePath.java | 6 ++++- .../path/PathAppendValueModification.java | 11 +++++++++ ...PathExplicitValueFromFileModification.java | 12 ++++++++++ .../path/PathExplicitValueModification.java | 11 +++++++++ ...hInsertDirectorySeparatorModification.java | 13 +++++++++++ ...hInsertDirectoryTraversalModification.java | 13 +++++++++++ .../path/PathInsertValueModification.java | 13 +++++++++++ .../path/PathPrependValueModification.java | 11 +++++++++ .../path/PathToggleRootModification.java | 5 ++++ .../singlebyte/ByteAddModification.java | 5 ++++ ...ByteExplicitValueFromFileModification.java | 10 ++++++++ .../ByteExplicitValueModification.java | 5 ++++ .../singlebyte/ByteSubtractModification.java | 5 ++++ .../singlebyte/ByteXorModification.java | 5 ++++ .../string/ModifiableString.java | 6 ++++- .../string/StringAppendValueModification.java | 11 +++++++++ ...ringExplicitValueFromFileModification.java | 13 +++++++++++ .../StringExplicitValueModification.java | 11 +++++++++ .../string/StringInsertValueModification.java | 13 +++++++++++ .../StringPrependValueModification.java | 11 +++++++++ .../modifiablevariable/util/StringUtil.java | 3 +++ 57 files changed, 406 insertions(+), 18 deletions(-) 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 7fbbddef..8e5e44d2 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java @@ -84,4 +84,9 @@ public boolean equals(Object obj) { 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/BigIntegerAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java index 15068f53..0e7b70eb 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java @@ -87,4 +87,9 @@ public boolean equals(Object obj) { BigIntegerAppendValueModification other = (BigIntegerAppendValueModification) obj; return Objects.equals(appendValue, other.appendValue); } + + @Override + public String toString() { + return "BigIntegerAppendValueModification{" + "appendValue=" + appendValue + '}'; + } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java index ae7eba28..3cfe18b1 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java @@ -78,4 +78,14 @@ public boolean equals(Object obj) { } return Objects.equals(explicitValue, other.explicitValue); } + + @Override + public String toString() { + return "BigIntegerExplicitValueFromFileModification{" + + "index=" + + index + + ", explicitValue=" + + explicitValue + + '}'; + } } 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 d3694aea..3150a89b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java @@ -90,4 +90,9 @@ public boolean equals(Object obj) { 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/BigIntegerInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java index d0886851..007f9f12 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java @@ -133,4 +133,14 @@ public boolean equals(Object obj) { } return Objects.equals(insertValue, other.insertValue); } + + @Override + public String toString() { + return "BigIntegerInsertValueModification{" + + "insertValue=" + + insertValue + + ", startPosition=" + + startPosition + + '}'; + } } 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 9569280d..93a732e5 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java @@ -84,4 +84,9 @@ public boolean equals(Object obj) { 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/BigIntegerPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java index 7bc86e7e..d9e2fe1a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java @@ -87,4 +87,9 @@ public boolean equals(Object obj) { BigIntegerPrependValueModification other = (BigIntegerPrependValueModification) obj; return Objects.equals(prependValue, other.prependValue); } + + @Override + public String toString() { + return "BigIntegerPrependValueModification{" + "prependValue=" + prependValue + '}'; + } } 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 1509533f..77a9295f 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java @@ -85,4 +85,9 @@ public boolean equals(Object obj) { 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 0e598888..0d142373 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java @@ -85,4 +85,9 @@ public boolean equals(Object obj) { 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 f8fce93f..f07e4fb0 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java @@ -87,4 +87,9 @@ public boolean equals(Object obj) { 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 5cbc9bb2..c3d67759 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java @@ -86,4 +86,9 @@ public boolean equals(Object obj) { 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/bytearray/ByteArrayExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueFromFileModification.java index e95a9e31..f303e922 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueFromFileModification.java @@ -8,6 +8,7 @@ package de.rub.nds.modifiablevariable.bytearray; 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; @@ -76,4 +77,14 @@ public boolean equals(Object obj) { } return Arrays.equals(explicitValue, other.explicitValue); } + + @Override + public String toString() { + return "ByteArrayExplicitValueFromFileModification{" + + "index=" + + index + + ", explicitValue=" + + ArrayConverter.bytesToHexString(explicitValue) + + '}'; + } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java index 17e8135c..7399d6ec 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java @@ -98,7 +98,7 @@ public boolean equals(Object obj) { @Override public String toString() { - return "ByteArrayInsertModification{bytesToPrepend=" + return "ByteArrayPrependValueModification{bytesToPrepend=" + ArrayConverter.bytesToHexString(bytesToPrepend) + "}"; } 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 3bd16daa..2973f82d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArray.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArray.java @@ -81,21 +81,6 @@ public boolean validateAssertions() { return valid; } - @Override - public String toString() { - StringBuilder result = new StringBuilder(); - if (isOriginalValueModified()) { - result.append("Actual byte value is: "); - result.append(ArrayConverter.bytesToHexString(this)); - result.append("\nOriginal value was: "); - result.append(ArrayConverter.bytesToHexString(getOriginalValue())); - } else { - result.append("Original byte value is: "); - result.append(ArrayConverter.bytesToHexString(getOriginalValue())); - } - return result.toString(); - } - @Override public boolean equals(Object obj) { if (this == obj) { @@ -116,4 +101,12 @@ public int hashCode() { result = 31 * result + Arrays.hashCode(getValue()); return result; } + + @Override + public String toString() { + return "ModifiableByteArray{" + + "originalValue=" + + ArrayConverter.bytesToHexString(originalValue) + + '}'; + } } 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 f7f698f8..d0e24a60 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAddModification.java @@ -79,4 +79,9 @@ public boolean equals(Object obj) { 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/IntegerAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java index 3cbafa1b..1f4729ab 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java @@ -83,4 +83,9 @@ public boolean equals(Object obj) { IntegerAppendValueModification other = (IntegerAppendValueModification) obj; return Objects.equals(appendValue, other.appendValue); } + + @Override + public String toString() { + return "IntegerAppendValueModification{" + "appendValue=" + appendValue + '}'; + } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java index 488875a7..f8affaed 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java @@ -76,4 +76,14 @@ public boolean equals(Object obj) { } return Objects.equals(explicitValue, other.explicitValue); } + + @Override + public String toString() { + return "IntegerExplicitValueFromFileModification{" + + "index=" + + index + + ", explicitValue=" + + explicitValue + + '}'; + } } 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 26ec5ea4..10d5e6f1 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueModification.java @@ -86,4 +86,9 @@ public boolean equals(Object obj) { 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/IntegerInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java index f56056c3..2473144b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java @@ -127,4 +127,14 @@ public boolean equals(Object obj) { } return Objects.equals(insertValue, other.insertValue); } + + @Override + public String toString() { + return "IntegerInsertValueModification{" + + "insertValue=" + + insertValue + + ", startPosition=" + + startPosition + + '}'; + } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java index aae8071d..0f441bba 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java @@ -81,4 +81,9 @@ public boolean equals(Object obj) { 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/IntegerPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java index a8043aa3..ddbf3676 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java @@ -84,4 +84,9 @@ public boolean equals(Object obj) { IntegerPrependValueModification other = (IntegerPrependValueModification) obj; return Objects.equals(prependValue, other.prependValue); } + + @Override + public String toString() { + return "IntegerPrependValueModification{" + "prependValue=" + prependValue + '}'; + } } 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 712e7c8e..7c6aced5 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftLeftModification.java @@ -90,4 +90,9 @@ public boolean equals(Object obj) { 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 0abfd06a..bb25bd2b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftRightModification.java @@ -90,4 +90,9 @@ public boolean equals(Object obj) { 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 e052658e..3586d55c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSubtractModification.java @@ -80,4 +80,9 @@ public boolean equals(Object obj) { 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/IntegerXorModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerXorModification.java index 729392e0..d33f6fc3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerXorModification.java @@ -84,4 +84,9 @@ public boolean equals(Object obj) { 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/longint/LongAddModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java index d5339a5b..a42604f4 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java @@ -79,4 +79,9 @@ public boolean equals(Object obj) { 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/LongAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java index 2b1c6339..b6f05442 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java @@ -83,4 +83,9 @@ public boolean equals(Object obj) { LongAppendValueModification other = (LongAppendValueModification) obj; return Objects.equals(appendValue, other.appendValue); } + + @Override + public String toString() { + return "LongAppendValueModification{" + "appendValue=" + appendValue + '}'; + } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java index f2422286..9635702d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java @@ -74,4 +74,14 @@ public boolean equals(Object obj) { } return Objects.equals(explicitValue, other.explicitValue); } + + @Override + public String toString() { + return "LongExplicitValueFromFileModification{" + + "index=" + + index + + ", explicitValue=" + + explicitValue + + '}'; + } } 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 e2bd2afc..a52d08ed 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java @@ -86,4 +86,9 @@ public boolean equals(Object obj) { 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/LongInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java index 9f77686f..3eb30715 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java @@ -125,4 +125,14 @@ public boolean equals(Object obj) { } return Objects.equals(insertValue, other.insertValue); } + + @Override + public String toString() { + return "LongInsertValueModification{" + + "insertValue=" + + insertValue + + ", startPosition=" + + startPosition + + '}'; + } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java index 76f735f8..180f96b3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java @@ -79,4 +79,9 @@ public boolean equals(Object obj) { 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/LongPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java index a2ddbd6d..484d710c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java @@ -83,4 +83,9 @@ public boolean equals(Object obj) { LongPrependValueModification other = (LongPrependValueModification) obj; return Objects.equals(prependValue, other.prependValue); } + + @Override + public String toString() { + return "LongPrependValueModification{" + "prependValue=" + prependValue + '}'; + } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java index 2a65b5cf..2d479360 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java @@ -92,4 +92,9 @@ public boolean equals(Object obj) { 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 index bb0d5a74..0f8b2cfe 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java @@ -92,4 +92,9 @@ public boolean equals(Object obj) { 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 2af22632..2f04ac48 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java @@ -80,4 +80,9 @@ public boolean equals(Object obj) { 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/LongXorModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java index a8fff829..9407bed8 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java @@ -84,4 +84,9 @@ public boolean equals(Object obj) { 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/path/ModifiablePath.java b/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java index 47e4489a..44252cb0 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java @@ -40,7 +40,11 @@ protected void createRandomModification() { @Override public String toString() { - return "ModifiablePath{originalValue=" + backslashEscapeString(originalValue) + "}"; + return "ModifiablePath{" + + "originalValue='" + + backslashEscapeString(originalValue) + + '\'' + + '}'; } @Override diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java index 67cf917a..1a806de9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java @@ -7,6 +7,8 @@ */ package de.rub.nds.modifiablevariable.path; +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; @@ -94,4 +96,13 @@ public boolean equals(Object obj) { PathAppendValueModification other = (PathAppendValueModification) obj; return Objects.equals(appendValue, other.appendValue); } + + @Override + public String toString() { + return "PathAppendValueModification{" + + "appendValue='" + + backslashEscapeString(appendValue) + + '\'' + + '}'; + } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java index 34f445d1..7d78424e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java @@ -7,6 +7,8 @@ */ package de.rub.nds.modifiablevariable.path; +import static de.rub.nds.modifiablevariable.util.StringUtil.backslashEscapeString; + import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlAccessType; import jakarta.xml.bind.annotation.XmlAccessorType; @@ -74,4 +76,14 @@ public boolean equals(Object obj) { } return Objects.equals(explicitValue, other.explicitValue); } + + @Override + public String toString() { + return "PathExplicitValueFromFileModification{" + + "index=" + + index + + ", explicitValue=" + + backslashEscapeString(explicitValue) + + '}'; + } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java index 01d4f048..d5ea0b6c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java @@ -7,6 +7,8 @@ */ package de.rub.nds.modifiablevariable.path; +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; @@ -90,4 +92,13 @@ public boolean equals(Object obj) { PathExplicitValueModification other = (PathExplicitValueModification) obj; return Objects.equals(explicitValue, other.explicitValue); } + + @Override + public String toString() { + return "PathExplicitValueModification{" + + "explicitValue='" + + backslashEscapeString(explicitValue) + + '\'' + + '}'; + } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectorySeparatorModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectorySeparatorModification.java index 2235ff5c..0dfa225d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectorySeparatorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectorySeparatorModification.java @@ -131,4 +131,17 @@ public boolean equals(Object obj) { } return Objects.equals(count, other.count); } + + @Override + public String toString() { + return "PathInsertDirectorySeparatorModification{" + + "insertValue='" + + insertValue + + '\'' + + ", count=" + + count + + ", startPosition=" + + startPosition + + '}'; + } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java index 8df1104a..1e22284c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java @@ -142,4 +142,17 @@ public boolean equals(Object obj) { } return Objects.equals(count, other.count); } + + @Override + public String toString() { + return "PathInsertDirectoryTraversalModification{" + + "insertValue='" + + insertValue + + '\'' + + ", count=" + + count + + ", startPosition=" + + startPosition + + '}'; + } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java index 620c7479..60ab6dc5 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java @@ -7,6 +7,8 @@ */ package de.rub.nds.modifiablevariable.path; +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; @@ -119,4 +121,15 @@ public boolean equals(Object obj) { } return Objects.equals(insertValue, other.insertValue); } + + @Override + public String toString() { + return "PathInsertValueModification{" + + "insertValue='" + + backslashEscapeString(insertValue) + + '\'' + + ", startPosition=" + + startPosition + + '}'; + } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java index fb4efc39..e56f147f 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java @@ -7,6 +7,8 @@ */ package de.rub.nds.modifiablevariable.path; +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; @@ -94,4 +96,13 @@ public boolean equals(Object obj) { PathPrependValueModification other = (PathPrependValueModification) obj; return Objects.equals(prependValue, other.prependValue); } + + @Override + public String toString() { + return "PathPrependValueModification{" + + "prependValue='" + + backslashEscapeString(prependValue) + + '\'' + + '}'; + } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootModification.java index 68479346..671e4139 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootModification.java @@ -60,4 +60,9 @@ public boolean equals(Object obj) { } return getClass() == obj.getClass(); } + + @Override + public String toString() { + return "PathToggleRootModification{}"; + } } 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 b5ce1bc2..2fd73b29 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteAddModification.java @@ -82,4 +82,9 @@ public boolean equals(Object obj) { 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/ByteExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java index b8948fbc..6460f962 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java @@ -74,4 +74,14 @@ public boolean equals(Object obj) { } return Objects.equals(explicitValue, other.explicitValue); } + + @Override + public String toString() { + return "ByteExplicitValueFromFileModification{" + + "index=" + + index + + ", explicitValue=" + + explicitValue + + '}'; + } } 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 47d2db54..f0e6bffe 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueModification.java @@ -86,4 +86,9 @@ public boolean equals(Object obj) { 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/ByteSubtractModification.java b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteSubtractModification.java index 834bcc37..9093969c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteSubtractModification.java @@ -83,4 +83,9 @@ public boolean equals(Object obj) { 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 19b8aef5..da6ed4db 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteXorModification.java @@ -88,4 +88,9 @@ public boolean equals(Object obj) { 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/string/ModifiableString.java b/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java index c207b180..742fb799 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java @@ -86,7 +86,11 @@ public void setOriginalValue(String originalValue) { @Override public String toString() { - return "ModifiableString{originalValue=" + backslashEscapeString(originalValue) + "}"; + return "ModifiableString{" + + "originalValue='" + + backslashEscapeString(originalValue) + + '\'' + + '}'; } @Override 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 3de565ff..d5cd99be 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java @@ -7,6 +7,8 @@ */ 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; @@ -88,4 +90,13 @@ public boolean equals(Object obj) { 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/StringExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java index 5d7acd11..4c429947 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java @@ -7,6 +7,8 @@ */ package de.rub.nds.modifiablevariable.string; +import static de.rub.nds.modifiablevariable.util.StringUtil.backslashEscapeString; + import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlAccessType; import jakarta.xml.bind.annotation.XmlAccessorType; @@ -75,4 +77,15 @@ public boolean equals(Object obj) { } return Objects.equals(explicitValue, other.explicitValue); } + + @Override + public String toString() { + return "StringExplicitValueFromFileModification{" + + "index=" + + index + + ", explicitValue='" + + backslashEscapeString(explicitValue) + + '\'' + + '}'; + } } 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 d901fc51..f2f9bdd2 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java @@ -7,6 +7,8 @@ */ 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; @@ -91,4 +93,13 @@ public boolean equals(Object obj) { 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 index 8009d557..595d92db 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java @@ -7,6 +7,8 @@ */ 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; @@ -128,4 +130,15 @@ public boolean equals(Object obj) { } 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/StringPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java index 93452fe1..ef96848c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java @@ -7,6 +7,8 @@ */ 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; @@ -88,4 +90,13 @@ public boolean equals(Object obj) { 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/StringUtil.java b/src/main/java/de/rub/nds/modifiablevariable/util/StringUtil.java index f94755df..628a0c27 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/StringUtil.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/StringUtil.java @@ -24,6 +24,9 @@ private StringUtil() { * @return string with non-printable or non-ascii characters replaced */ public static String backslashEscapeString(String value) { + if (value == null) { + return null; + } StringBuffer buffer = new StringBuffer(value); for (int i = 0; i < buffer.length(); i++) { int codePoint = buffer.codePointAt(i); From 149ceb26d92715e089e66f2a04812b2b565b4984 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Fri, 6 Dec 2024 12:08:36 +0100 Subject: [PATCH 32/82] Replace StringBuffer with StringBuilder in backslashEscapeString. To make it a little bit faster, since we do not need the synchronisation of StringBuffer. fix test, since I changed toString of ModifiableByteArray --- .../path/PathToggleRootModification.java | 2 +- .../de/rub/nds/modifiablevariable/util/StringUtil.java | 10 +++++----- .../bytearray/ModifiableByteArrayTest.java | 10 +--------- 3 files changed, 7 insertions(+), 15 deletions(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootModification.java index 671e4139..8d6ee3e8 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootModification.java @@ -13,7 +13,7 @@ /** Modification that toggle the root slash of the original value. */ @XmlRootElement -@XmlType(propOrder = {"modificationFilter"}) +@XmlType(propOrder = "modificationFilter") public class PathToggleRootModification extends VariableModification { public PathToggleRootModification() { 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 628a0c27..947926b5 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/StringUtil.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/StringUtil.java @@ -27,9 +27,9 @@ public static String backslashEscapeString(String value) { if (value == null) { return null; } - StringBuffer buffer = new StringBuffer(value); - for (int i = 0; i < buffer.length(); i++) { - int codePoint = buffer.codePointAt(i); + 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) { @@ -73,10 +73,10 @@ public static String backslashEscapeString(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/test/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArrayTest.java b/src/test/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArrayTest.java index 26b643f8..2f7ae9b5 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArrayTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArrayTest.java @@ -357,15 +357,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 From 882c926d3bc36abc40b392afa5296dc81b3e5f46 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Fri, 6 Dec 2024 12:10:57 +0100 Subject: [PATCH 33/82] fix logger of ModifiableByteArrayTest --- .../modifiablevariable/bytearray/ModifiableByteArrayTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 2f7ae9b5..384d3762 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArrayTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArrayTest.java @@ -21,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; From 09a055a631fff4d74903b1dc2aeb996bcef460ed Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Fri, 6 Dec 2024 20:44:28 +0100 Subject: [PATCH 34/82] Make ByteArrayDeleteModification more useful by allowing more random inputs, that still results in modifications. Add Delete modification for Path and Strings. --- .../ModifiableVariable.java | 2 + .../ByteArrayDeleteModification.java | 41 ++--- .../path/PathDeleteModification.java | 161 ++++++++++++++++++ .../path/PathModificationFactory.java | 16 +- .../nds/modifiablevariable/path/PathUtil.java | 19 +++ .../string/StringDeleteModification.java | 147 ++++++++++++++++ .../string/StringModificationFactory.java | 12 +- 7 files changed, 368 insertions(+), 30 deletions(-) create mode 100644 src/main/java/de/rub/nds/modifiablevariable/path/PathDeleteModification.java create mode 100644 src/main/java/de/rub/nds/modifiablevariable/string/StringDeleteModification.java diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java index bc2afa0c..e5849435 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -163,6 +163,7 @@ public abstract class ModifiableVariable implements Serializable { @XmlElement( type = StringInsertValueModification.class, name = "StringInsertValueModification"), + @XmlElement(type = StringDeleteModification.class, name = "StringDeleteModification"), @XmlElement( type = PathExplicitValueFromFileModification.class, name = "PathExplicitValueFromFileModification"), @@ -173,6 +174,7 @@ public abstract class ModifiableVariable implements Serializable { @XmlElement( type = PathInsertDirectorySeparatorModification.class, name = "PathInsertDirectorySeparatorModification"), + @XmlElement(type = PathDeleteModification.class, name = "PathDeleteModification"), @XmlElement( type = PathInsertDirectoryTraversalModification.class, name = "PathInsertDirectoryTraversalValueModification"), 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 f44e2a11..a8413556 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java @@ -7,8 +7,6 @@ */ 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; @@ -55,34 +53,23 @@ 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; - } - } - int endPosition = start + count; - if (endPosition > input.length) { - LOGGER.debug( - "Bytes {}..{} cannot be deleted from {{}} of length {}", - start, - endPosition, - bytesToHexString(input), - input.length); - 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 (count <= 0) { - LOGGER.debug("You must delete at least one byte. count = {}", count); - return input; + + // 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, start); + + byte[] ret1 = Arrays.copyOf(input, deleteStartPosition); byte[] ret2 = null; - if (endPosition < input.length) { - ret2 = Arrays.copyOfRange(input, endPosition, input.length); + if (deleteEndPosition < input.length) { + ret2 = Arrays.copyOfRange(input, deleteEndPosition, input.length); } return ArrayConverter.concatenate(ret1, ret2); } diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathDeleteModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathDeleteModification.java new file mode 100644 index 00000000..3de7c144 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathDeleteModification.java @@ -0,0 +1,161 @@ +/* + * 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.path; + +import de.rub.nds.modifiablevariable.VariableModification; +import de.rub.nds.modifiablevariable.util.ArrayConverter; +import jakarta.xml.bind.annotation.XmlRootElement; +import jakarta.xml.bind.annotation.XmlType; +import java.util.Arrays; +import java.util.Objects; +import java.util.Random; + +/** Modification that deletes path parts from the original value. */ +@XmlRootElement +@XmlType(propOrder = {"count", "startPosition", "modificationFilter"}) +public class PathDeleteModification extends VariableModification { + + private static final int MAX_MODIFIER_LENGTH = 32; + + private int count; + + private int startPosition; + + public PathDeleteModification() { + super(); + } + + public PathDeleteModification(int startPosition, int count) { + super(); + this.count = count; + this.startPosition = startPosition; + } + + public PathDeleteModification(PathDeleteModification other) { + super(other); + count = other.count; + startPosition = other.startPosition; + } + + @Override + public PathDeleteModification createCopy() { + return new PathDeleteModification(this); + } + + @Override + protected String modifyImplementationHook(String input) { + if (input == null) { + return null; + } + if (input.isEmpty()) { + return input; + } + String[] pathParts = input.split("/"); + boolean leadingSlash = pathParts[0].isEmpty(); + + // Wrap around and also allow to delete at the end of the original value + int deleteStartPosition = + PathUtil.getPathPartPosition(startPosition, leadingSlash, pathParts); + // If the end position overflows, it is fixed at the end of the path + int deleteEndPosition = deleteStartPosition + count; + if (deleteEndPosition > pathParts.length) { + deleteEndPosition = pathParts.length; + } + + String[] partsBefore = Arrays.copyOf(pathParts, deleteStartPosition); + String[] partsAfter = null; + if (deleteEndPosition < pathParts.length) { + partsAfter = Arrays.copyOfRange(pathParts, deleteEndPosition, pathParts.length); + } + String[] resultParts = ArrayConverter.concatenate(partsBefore, partsAfter); + + if (input.endsWith("/") && resultParts.length > 0) { + resultParts[resultParts.length - 1] += "/"; + } + return String.join("/", resultParts); + } + + 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 VariableModification getModifiedCopy() { + Random r = new Random(); + + if (r.nextBoolean()) { + int modifier = r.nextInt(MAX_MODIFIER_LENGTH); + if (r.nextBoolean()) { + modifier *= -1; + } + modifier = count + modifier; + if (modifier <= 0) { + modifier = 1; + } + return new PathDeleteModification(modifier, startPosition); + } else { + int modifier = r.nextInt(MAX_MODIFIER_LENGTH); + if (r.nextBoolean()) { + modifier *= -1; + } + modifier = startPosition + modifier; + if (modifier <= 0) { + modifier = 1; + } + return new PathDeleteModification(count, modifier); + } + } + + @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; + } + PathDeleteModification other = (PathDeleteModification) obj; + if (startPosition != other.startPosition) { + return false; + } + return Objects.equals(count, other.count); + } + + @Override + public String toString() { + return "PathDeleteModification{" + + "count=" + + count + + ", startPosition=" + + startPosition + + '}'; + } +} diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathModificationFactory.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathModificationFactory.java index bd86f8bc..f143360d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathModificationFactory.java @@ -8,6 +8,7 @@ package de.rub.nds.modifiablevariable.path; import de.rub.nds.modifiablevariable.VariableModification; +import de.rub.nds.modifiablevariable.string.StringDeleteModification; import de.rub.nds.modifiablevariable.util.RandomHelper; import java.util.Random; @@ -22,9 +23,10 @@ private enum ModificationType { APPEND, PREPEND, INSERT, + DELETE, INSERT_DIRECTORY_TRAVERSAL, INSERT_DIRECTORY_SEPERATOR, - TOGGLE_ROOT, + TOGGLE_ROOT } private static final int MODIFICATION_COUNT = ModificationType.values().length; @@ -52,6 +54,10 @@ public static VariableModification insertValue(String value, int positio return new PathInsertValueModification(value, position); } + public static VariableModification delete(int position, int count) { + return new PathDeleteModification(position, count); + } + public static VariableModification insertDirectoryTraversal(int count, int position) { return new PathInsertDirectoryTraversalModification(count, position); } @@ -74,7 +80,8 @@ public static VariableModification createRandomModification(String origi } else { String[] pathParts = originalValue.split("/"); if (pathParts.length == 0) { - if (randomType == ModificationType.INSERT) { + if (randomType == ModificationType.INSERT + || randomType == ModificationType.DELETE) { randomType = ModificationType.APPEND; } numberOfPathParts = 0; @@ -127,6 +134,11 @@ public static VariableModification createRandomModification(String origi numberOfDirectorySeperator, insertPosition); case TOGGLE_ROOT: return new PathToggleRootModification(); + case DELETE: + int startPosition = random.nextInt(numberOfPathParts - 1); + int count = random.nextInt(numberOfPathParts - startPosition); + count++; + return new StringDeleteModification(startPosition, count); default: throw new IllegalStateException("Unexpected modification type: " + randomType); } diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathUtil.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathUtil.java index b4154de3..549f98ca 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathUtil.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathUtil.java @@ -59,4 +59,23 @@ private static int getInsertPosition( } return insertPosition; } + + public static int getPathPartPosition( + int startPosition, boolean leadingSlash, String[] pathParts) { + int pathPartPosition; + if (leadingSlash) { + // If the path starts with a slash, skip the first empty path part. + pathPartPosition = startPosition % (pathParts.length - 1); + if (startPosition < 0) { + pathPartPosition += pathParts.length - 2; + } + pathPartPosition++; + } else { + pathPartPosition = startPosition % pathParts.length; + if (startPosition < 0) { + pathPartPosition += pathParts.length - 1; + } + } + return pathPartPosition; + } } 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..85dee061 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringDeleteModification.java @@ -0,0 +1,147 @@ +/* + * 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 jakarta.xml.bind.annotation.XmlType; +import java.util.Objects; +import java.util.Random; + +/** Modification that deletes part of a string from the original value. */ +@XmlRootElement +@XmlType(propOrder = {"count", "startPosition", "modificationFilter"}) +public class StringDeleteModification extends VariableModification { + + private static final int MAX_MODIFIER_LENGTH = 32; + + 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; + } + + // 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 VariableModification getModifiedCopy() { + Random r = new Random(); + + if (r.nextBoolean()) { + int modifier = r.nextInt(MAX_MODIFIER_LENGTH); + if (r.nextBoolean()) { + modifier *= -1; + } + modifier = count + modifier; + if (modifier <= 0) { + modifier = 1; + } + return new StringDeleteModification(modifier, startPosition); + } else { + int modifier = r.nextInt(MAX_MODIFIER_LENGTH); + if (r.nextBoolean()) { + modifier *= -1; + } + modifier = startPosition + modifier; + if (modifier <= 0) { + modifier = 1; + } + return new StringDeleteModification(count, modifier); + } + } + + @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/StringModificationFactory.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringModificationFactory.java index 1f81a342..b7d5709e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringModificationFactory.java @@ -22,7 +22,8 @@ private enum ModificationType { APPEND, PREPEND, EXPLICIT, - INSERT + INSERT, + DELETE } private static final int MODIFICATION_COUNT = ModificationType.values().length; @@ -49,6 +50,10 @@ public static VariableModification insertValue(String value, int positio return new StringInsertValueModification(value, position); } + public static VariableModification delete(int startPosition, int count) { + return new StringDeleteModification(startPosition, count); + } + public static VariableModification createRandomModification(String originalValue) { Random random = RandomHelper.getRandom(); ModificationType randomType = ModificationType.values()[random.nextInt(MODIFICATION_COUNT)]; @@ -93,6 +98,11 @@ public static VariableModification createRandomModification(String origi random.nextBytes(bytesToInsert); int insertPosition = random.nextInt(modifiedArrayLength); return new StringInsertValueModification(new String(bytesToInsert), insertPosition); + case DELETE: + int startPosition = random.nextInt(modifiedArrayLength - 1); + int count = random.nextInt(modifiedArrayLength - startPosition); + count++; + return new StringDeleteModification(startPosition, count); default: throw new IllegalStateException("Unexpected modification type: " + randomType); } From e688cae34b9216334ae5c4633bb06aecab4b0e81 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Fri, 6 Dec 2024 20:54:24 +0100 Subject: [PATCH 35/82] Fix tests because I changed the behavior of ByteArrayDeleteModification --- .../bytearray/ModifiableByteArrayTest.java | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) 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 384d3762..b1d5e544 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArrayTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArrayTest.java @@ -201,6 +201,8 @@ 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); @@ -212,7 +214,7 @@ public void testDeleteBytes() { modifier = ByteArrayModificationFactory.delete(0, len + 1); start.setModification(modifier); - assertArrayEquals(start.getValue(), originalValue); + assertArrayEquals(start.getValue(), expResult); start = new ModifiableByteArray(); start.setOriginalValue(originalValue); LOGGER.debug("Testing Delete negative amount"); @@ -228,15 +230,15 @@ public void testDeleteBytes() { start = new ModifiableByteArray(); start.setOriginalValue(originalValue); LOGGER.debug("Testing Delete from negative Start position"); - modifier = ByteArrayModificationFactory.delete(len * -2, modification1.length); + modifier = ByteArrayModificationFactory.delete(len * -2, 1); start.setModification(modifier); - assertArrayEquals(start.getValue(), originalValue); + 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); + modifier = ByteArrayModificationFactory.delete(len * 2, 2); start.setModification(modifier); - assertArrayEquals(start.getValue(), originalValue); + assertArrayEquals(start.getValue(), expResult3); } /** Test of setInsertBytes method, of class ModifiableByteArray. */ From 0ba036f10ba0b4244d81a89722fce05ebddcde1b Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Fri, 6 Dec 2024 22:08:40 +0100 Subject: [PATCH 36/82] Fix ByteArrayShuffleModification to also shuffle byte arrays with length > 255 correctly up to length of 65535 --- .../bytearray/ByteArrayShuffleModification.java | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) 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 cddfd270..852456a6 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayShuffleModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayShuffleModification.java @@ -58,7 +58,16 @@ protected byte[] modifyImplementationHook(byte[] input) { } 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; From 2adcc6936063a96b318d6348c43a24adb999b2b3 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Mon, 9 Dec 2024 12:12:48 +0100 Subject: [PATCH 37/82] Also print modifications in toString() methods. Not very nicely implemented using innerToString() but good enough for now. --- .../nds/modifiablevariable/ModifiableVariable.java | 14 ++++++++++++++ .../biginteger/ModifiableBigInteger.java | 2 +- .../modifiablevariable/bool/ModifiableBoolean.java | 2 +- .../bytearray/ModifiableByteArray.java | 1 + .../integer/ModifiableInteger.java | 2 +- .../length/ModifiableLengthField.java | 2 +- .../modifiablevariable/longint/ModifiableLong.java | 2 +- .../modifiablevariable/path/ModifiablePath.java | 1 + .../singlebyte/ModifiableByte.java | 2 +- .../string/ModifiableString.java | 1 + 10 files changed, 23 insertions(+), 6 deletions(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java index e5849435..d64be333 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -254,4 +254,18 @@ public boolean containsAssertion() { public Boolean isCreateRandomModification() { return Objects.requireNonNullElse(createRandomModification, false); } + + public String innerToString() { + StringBuilder result = new StringBuilder(); + result.append(", modification=").append(modification); + + if (createRandomModification != null) { + result.append(", createRandomModification=").append(createRandomModification); + } + if (assertEquals != null) { + result.append(", assertEquals=").append(assertEquals); + } + + return result.toString(); + } } 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 07eb6459..5967ca6f 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigInteger.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigInteger.java @@ -83,7 +83,7 @@ public void setOriginalValue(BigInteger originalValue) { @Override public String toString() { - return "ModifiableBigInteger{" + "originalValue=" + originalValue + '}'; + return "ModifiableBigInteger{" + "originalValue=" + originalValue + innerToString() + '}'; } @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 fc03f2d3..0db7a529 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/ModifiableBoolean.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/ModifiableBoolean.java @@ -69,7 +69,7 @@ public boolean validateAssertions() { @Override public String toString() { - return "ModifiableBoolean{" + "originalValue=" + originalValue + '}'; + return "ModifiableBoolean{" + "originalValue=" + originalValue + innerToString() + '}'; } @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 2973f82d..44ee354c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArray.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArray.java @@ -107,6 +107,7 @@ public String toString() { return "ModifiableByteArray{" + "originalValue=" + ArrayConverter.bytesToHexString(originalValue) + + innerToString() + '}'; } } 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 0977990b..e983e33f 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/ModifiableInteger.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/ModifiableInteger.java @@ -80,7 +80,7 @@ public void setOriginalValue(Integer originalValue) { @Override public String toString() { - return "ModifiableInteger{" + "originalValue=" + originalValue + '}'; + return "ModifiableInteger{" + "originalValue=" + originalValue + innerToString() + '}'; } @Override 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 2fd2fc5a..0afcfe2d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/length/ModifiableLengthField.java +++ b/src/main/java/de/rub/nds/modifiablevariable/length/ModifiableLengthField.java @@ -47,7 +47,7 @@ public void setOriginalValue(Integer originalValue) { @Override public String toString() { - return "ModifiableLengthField{" + "ref=" + ref + "} " + super.toString(); + return "ModifiableLengthField{" + "ref=" + ref + super.toString() + "} "; } @Override 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 9a377bad..4111534a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/ModifiableLong.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/ModifiableLong.java @@ -80,7 +80,7 @@ public void setOriginalValue(Long originalValue) { @Override public String toString() { - return "ModifiableLong{" + "originalValue=" + originalValue + '}'; + return "ModifiableLong{" + "originalValue=" + originalValue + innerToString() + '}'; } @Override diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java b/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java index 44252cb0..aff45546 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java @@ -44,6 +44,7 @@ public String toString() { + "originalValue='" + backslashEscapeString(originalValue) + '\'' + + innerToString() + '}'; } 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 3a76bd78..f4920538 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByte.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByte.java @@ -75,7 +75,7 @@ public void setOriginalValue(Byte originalValue) { @Override public String toString() { - return "ModifiableByte{" + "originalValue=" + originalValue + '}'; + return "ModifiableByte{" + "originalValue=" + originalValue + innerToString() + '}'; } @Override 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 742fb799..6b9c33cf 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java @@ -90,6 +90,7 @@ public String toString() { + "originalValue='" + backslashEscapeString(originalValue) + '\'' + + innerToString() + '}'; } From 272f6b60f765e82556335aa21877427cf8c4e66d Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Mon, 9 Dec 2024 15:31:05 +0100 Subject: [PATCH 38/82] Just some renaming of parameters --- .../modifiablevariable/util/Modifiable.java | 207 ++++++++++-------- 1 file changed, 113 insertions(+), 94 deletions(-) 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 a9507321..43c2812a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/Modifiable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/Modifiable.java @@ -89,112 +89,127 @@ private static ModifiablePath getModifiablePathWithModification( return modifiablePath; } - public static ModifiableBigInteger prepend(BigInteger i) { + public static ModifiableBigInteger prepend(BigInteger perpendValue) { return getModifiableBigIntegerWithModification( - BigIntegerModificationFactory.prependValue(i)); + BigIntegerModificationFactory.prependValue(perpendValue)); } - public static ModifiableByteArray prepend(byte[] b) { - return getModifiableByteArrayWithModification(ByteArrayModificationFactory.prependValue(b)); + public static ModifiableByteArray prepend(byte[] perpendValue) { + return getModifiableByteArrayWithModification( + ByteArrayModificationFactory.prependValue(perpendValue)); } - public static ModifiableInteger prepend(Integer i) { - return getModifiableIntegerWithModification(IntegerModificationFactory.prependValue(i)); + public static ModifiableInteger prepend(Integer perpendValue) { + return getModifiableIntegerWithModification( + IntegerModificationFactory.prependValue(perpendValue)); } - public static ModifiableLong prepend(Long l) { - return getModifiableLongWithModification(LongModificationFactory.prependValue(l)); + public static ModifiableLong prepend(Long perpendValue) { + return getModifiableLongWithModification( + LongModificationFactory.prependValue(perpendValue)); } - public static ModifiableString prepend(String s) { - return getModifiableStringWithModification(StringModificationFactory.prependValue(s)); + public static ModifiableString prepend(String perpendValue) { + return getModifiableStringWithModification( + StringModificationFactory.prependValue(perpendValue)); } - public static ModifiablePath prependPath(String s) { - return getModifiablePathWithModification(PathModificationFactory.prependValue(s)); + public static ModifiablePath prependPath(String perpendValue) { + return getModifiablePathWithModification( + PathModificationFactory.prependValue(perpendValue)); } - public static ModifiableBigInteger append(BigInteger i) { + public static ModifiableBigInteger append(BigInteger appendValue) { return getModifiableBigIntegerWithModification( - BigIntegerModificationFactory.appendValue(i)); + BigIntegerModificationFactory.appendValue(appendValue)); } - public static ModifiableByteArray append(byte[] b) { - return getModifiableByteArrayWithModification(ByteArrayModificationFactory.appendValue(b)); + public static ModifiableByteArray append(byte[] appendValue) { + return getModifiableByteArrayWithModification( + ByteArrayModificationFactory.appendValue(appendValue)); } - public static ModifiableInteger append(Integer i) { - return getModifiableIntegerWithModification(IntegerModificationFactory.appendValue(i)); + public static ModifiableInteger append(Integer appendValue) { + return getModifiableIntegerWithModification( + IntegerModificationFactory.appendValue(appendValue)); } - public static ModifiableLong append(Long l) { - return getModifiableLongWithModification(LongModificationFactory.appendValue(l)); + public static ModifiableLong append(Long appendValue) { + return getModifiableLongWithModification(LongModificationFactory.appendValue(appendValue)); } - public static ModifiableString append(String s) { - return getModifiableStringWithModification(StringModificationFactory.appendValue(s)); + public static ModifiableString append(String appendValue) { + return getModifiableStringWithModification( + StringModificationFactory.appendValue(appendValue)); } - public static ModifiablePath appendPath(String s) { - return getModifiablePathWithModification(PathModificationFactory.appendValue(s)); + public static ModifiablePath appendPath(String appendValue) { + return getModifiablePathWithModification(PathModificationFactory.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(BooleanModificationFactory.explicitValue(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 ModifiableBigInteger insert(BigInteger i, int position) { + public static ModifiableBigInteger insert(BigInteger insertValue, int position) { return getModifiableBigIntegerWithModification( - BigIntegerModificationFactory.insertValue(i, position)); + BigIntegerModificationFactory.insertValue(insertValue, position)); } - public static ModifiableByteArray insert(byte[] b, int position) { + public static ModifiableByteArray insert(byte[] insertValue, int position) { return getModifiableByteArrayWithModification( - ByteArrayModificationFactory.insertValue(b, position)); + ByteArrayModificationFactory.insertValue(insertValue, position)); } - public static ModifiableInteger insert(Integer i, int position) { + public static ModifiableInteger insert(Integer insertValue, int position) { return getModifiableIntegerWithModification( - IntegerModificationFactory.insertValue(i, position)); + IntegerModificationFactory.insertValue(insertValue, position)); } - public static ModifiableLong insert(Long l, int position) { - return getModifiableLongWithModification(LongModificationFactory.insertValue(l, position)); + public static ModifiableLong insert(Long insertValue, int position) { + return getModifiableLongWithModification( + LongModificationFactory.insertValue(insertValue, position)); } - public static ModifiableString insert(String s, int position) { + public static ModifiableString insert(String insertValue, int position) { return getModifiableStringWithModification( - StringModificationFactory.insertValue(s, position)); + StringModificationFactory.insertValue(insertValue, position)); } - public static ModifiablePath insertPath(String s, int position) { - return getModifiablePathWithModification(PathModificationFactory.insertValue(s, position)); + public static ModifiablePath insertPath(String insertValue, int position) { + return getModifiablePathWithModification( + PathModificationFactory.insertValue(insertValue, position)); } public static ModifiablePath insertDirectoryTraversal(int count, int position) { @@ -207,57 +222,58 @@ public static ModifiablePath insertDirectorySeperator(int count, int position) { PathModificationFactory.insertDirectorySeperator(count, position)); } - public static ModifiableByteArray xor(byte[] b, int position) { + public static ModifiableByteArray xor(byte[] xor, int position) { return getModifiableByteArrayWithModification( - ByteArrayModificationFactory.xor(b, position)); + ByteArrayModificationFactory.xor(xor, position)); } - public static ModifiableByte xor(Byte b) { - return getModifiableByteWithModification(ByteModificationFactory.xor(b)); + public static ModifiableByte xor(Byte xor) { + return getModifiableByteWithModification(ByteModificationFactory.xor(xor)); } - public static ModifiableInteger xor(Integer i) { - return getModifiableIntegerWithModification(IntegerModificationFactory.xor(i)); + public static ModifiableInteger xor(Integer xor) { + return getModifiableIntegerWithModification(IntegerModificationFactory.xor(xor)); } - public static ModifiableBigInteger xor(BigInteger i) { - return getModifiableBigIntegerWithModification(BigIntegerModificationFactory.xor(i)); + public static ModifiableBigInteger xor(BigInteger xor) { + return getModifiableBigIntegerWithModification(BigIntegerModificationFactory.xor(xor)); } - public static ModifiableLong xor(Long l) { - return getModifiableLongWithModification(LongModificationFactory.xor(l)); + public static ModifiableLong xor(Long xor) { + return getModifiableLongWithModification(LongModificationFactory.xor(xor)); } - public static ModifiableByte add(Byte b) { - return getModifiableByteWithModification(ByteModificationFactory.add(b)); + public static ModifiableByte add(Byte summand) { + return getModifiableByteWithModification(ByteModificationFactory.add(summand)); } - public static ModifiableInteger add(Integer i) { - return getModifiableIntegerWithModification(IntegerModificationFactory.add(i)); + public static ModifiableInteger add(Integer summand) { + return getModifiableIntegerWithModification(IntegerModificationFactory.add(summand)); } - public static ModifiableBigInteger add(BigInteger i) { - return getModifiableBigIntegerWithModification(BigIntegerModificationFactory.add(i)); + public static ModifiableBigInteger add(BigInteger summand) { + return getModifiableBigIntegerWithModification(BigIntegerModificationFactory.add(summand)); } - public static ModifiableLong add(Long l) { - return getModifiableLongWithModification(LongModificationFactory.add(l)); + public static ModifiableLong add(Long summand) { + return getModifiableLongWithModification(LongModificationFactory.add(summand)); } - public static ModifiableByte sub(Byte b) { - return getModifiableByteWithModification(ByteModificationFactory.sub(b)); + public static ModifiableByte sub(Byte subtrahend) { + return getModifiableByteWithModification(ByteModificationFactory.sub(subtrahend)); } - public static ModifiableInteger sub(Integer i) { - return getModifiableIntegerWithModification(IntegerModificationFactory.sub(i)); + public static ModifiableInteger sub(Integer subtrahend) { + return getModifiableIntegerWithModification(IntegerModificationFactory.sub(subtrahend)); } - public static ModifiableBigInteger sub(BigInteger i) { - return getModifiableBigIntegerWithModification(BigIntegerModificationFactory.sub(i)); + public static ModifiableBigInteger sub(BigInteger subtrahend) { + return getModifiableBigIntegerWithModification( + BigIntegerModificationFactory.sub(subtrahend)); } - public static ModifiableLong sub(Long l) { - return getModifiableLongWithModification(LongModificationFactory.sub(l)); + public static ModifiableLong sub(Long subtrahend) { + return getModifiableLongWithModification(LongModificationFactory.sub(subtrahend)); } public static ModifiableByteArray delete(int startPosition, int count) { @@ -282,39 +298,42 @@ public static ModifiablePath toggleRoot() { return getModifiablePathWithModification(PathModificationFactory.toggleRoot()); } - public static ModifiableBigInteger shiftLeftBigInteger(Integer i) { - return getModifiableBigIntegerWithModification(BigIntegerModificationFactory.shiftLeft(i)); + public static ModifiableBigInteger shiftLeftBigInteger(Integer shift) { + return getModifiableBigIntegerWithModification( + BigIntegerModificationFactory.shiftLeft(shift)); } - public static ModifiableInteger shiftLeft(Integer i) { - return getModifiableIntegerWithModification(IntegerModificationFactory.shiftLeft(i)); + public static ModifiableInteger shiftLeft(Integer shift) { + return getModifiableIntegerWithModification(IntegerModificationFactory.shiftLeft(shift)); } - public static ModifiableLong shiftLeftLong(Integer i) { - return getModifiableLongWithModification(LongModificationFactory.shiftLeft(i)); + public static ModifiableLong shiftLeftLong(Integer shift) { + return getModifiableLongWithModification(LongModificationFactory.shiftLeft(shift)); } - public static ModifiableBigInteger shiftRightBigInteger(Integer i) { - return getModifiableBigIntegerWithModification(BigIntegerModificationFactory.shiftRight(i)); + public static ModifiableBigInteger shiftRightBigInteger(Integer shift) { + return getModifiableBigIntegerWithModification( + BigIntegerModificationFactory.shiftRight(shift)); } - public static ModifiableBigInteger multiplyBigInteger(BigInteger i) { - return getModifiableBigIntegerWithModification(BigIntegerModificationFactory.multiply(i)); + public static ModifiableInteger shiftRight(Integer shift) { + return getModifiableIntegerWithModification(IntegerModificationFactory.shiftRight(shift)); } - public static ModifiableInteger multiply(Integer i) { - return getModifiableIntegerWithModification(IntegerModificationFactory.multiply(i)); + public static ModifiableLong shiftRightLong(Integer shift) { + return getModifiableLongWithModification(LongModificationFactory.shiftRight(shift)); } - public static ModifiableLong multiply(Long l) { - return getModifiableLongWithModification(LongModificationFactory.multiply(l)); + public static ModifiableBigInteger multiplyBigInteger(BigInteger factor) { + return getModifiableBigIntegerWithModification( + BigIntegerModificationFactory.multiply(factor)); } - public static ModifiableInteger shiftRight(Integer i) { - return getModifiableIntegerWithModification(IntegerModificationFactory.shiftRight(i)); + public static ModifiableInteger multiply(Integer factor) { + return getModifiableIntegerWithModification(IntegerModificationFactory.multiply(factor)); } - public static ModifiableLong shiftRightLong(Integer i) { - return getModifiableLongWithModification(LongModificationFactory.shiftRight(i)); + public static ModifiableLong multiply(Long factor) { + return getModifiableLongWithModification(LongModificationFactory.multiply(factor)); } } From d613cdd1ba1489c156821cec399a91810da703bc Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Mon, 9 Dec 2024 16:04:01 +0100 Subject: [PATCH 39/82] Change behavior of ByteArrayXorModification. Allow arbitrary start position, that wraps around. And always apply xor, even if xor is to long for original value -> cut of to long part. This probably does not match the expected behavior of all users, so further improvements can be made in the future. --- .../BigIntegerModificationFactory.java | 2 +- .../ByteArrayShuffleModification.java | 2 +- .../bytearray/ByteArrayXorModification.java | 32 +++++++++--------- .../logging/ExtendedPatternLayout.java | 2 +- .../util/BadFixedRandom.java | 2 +- .../util/ReflectionHelper.java | 33 ------------------- .../util/SuppressingBooleanAdapter.java | 4 +-- .../bytearray/ModifiableByteArrayTest.java | 17 ++++++++-- 8 files changed, 35 insertions(+), 59 deletions(-) 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 53573fe5..120067cb 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationFactory.java @@ -147,7 +147,7 @@ public static void setStandardInteractiveModification( standardInteractiveModification = modification; } - protected static BigIntegerInteractiveModification.InteractiveBigIntegerModification + static BigIntegerInteractiveModification.InteractiveBigIntegerModification getStandardInteractiveModification() { return standardInteractiveModification; } 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 852456a6..47990150 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayShuffleModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayShuffleModification.java @@ -54,7 +54,7 @@ public ByteArrayShuffleModification createCopy() { @Override protected byte[] modifyImplementationHook(byte[] input) { if (input == null) { - return input; + return null; } byte[] result = input.clone(); int size = input.length; 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 b26a5c86..f989c665 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java @@ -59,25 +59,23 @@ protected byte[] modifyImplementationHook(byte[] input) { input = new byte[0]; } 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; } - 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 + // Todo: Add an option that expands the byte array instead + 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; } 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 b293cc81..e35a58e9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/logging/ExtendedPatternLayout.java +++ b/src/main/java/de/rub/nds/modifiablevariable/logging/ExtendedPatternLayout.java @@ -171,7 +171,7 @@ private static 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) { 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 ccc3df97..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,7 +15,7 @@ */ public class BadFixedRandom extends Random { - byte retVal; + private final byte retVal; public BadFixedRandom(byte retVal) { 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 ec2c8ec1..699fc39d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/ReflectionHelper.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/ReflectionHelper.java @@ -77,39 +77,6 @@ public static List getValuesFromFieldList(Object object, List fie 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/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 modifier2 = ByteArrayModificationFactory.xor(modification2, 0); start.setModification(modifier2); - assertArrayEquals(originalValue, start.getValue()); + assertArrayEquals(expResult2, start.getValue()); } /** Test of setXorLastBytes method, of class ModifiableByteArray. */ @@ -103,10 +107,15 @@ public void testXorLastBytes() { 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()); + assertArrayEquals(expResult2, start.getValue()); } /** Test of setPrependBytes method, of class ModifiableByteArray. */ @@ -359,7 +368,9 @@ public void toStringTest() { toTest = ModifiableVariableFactory.safelySetValue( toTest, new byte[] {0x00, 0x11, 0x22, 0x33, 0x44}); - assertEquals("ModifiableByteArray{originalValue=00 11 22 33 44}", toTest.toString()); + assertEquals( + "ModifiableByteArray{originalValue=00 11 22 33 44, modification=null}", + toTest.toString()); } @Test From ad139d1d019028753daf9d171369cc97eeb219d2 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Thu, 12 Dec 2024 19:46:20 +0100 Subject: [PATCH 40/82] Change behaviour of reduceToOriginalValue() --- .../nds/modifiablevariable/ModifiableVariable.java | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java index d64be333..67fcf6f4 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -225,9 +225,18 @@ public E getValue() { return getOriginalValue(); } + /** + * Sets the original value to the value changed by the modification. The modification is then + * set to null, to reduce the modifiable variable to the original value. + * + *

createRandomModification is ignored + */ public void reduceToOriginalValue(boolean evenWithNullOriginalValue) { if (evenWithNullOriginalValue || getOriginalValue() != null) { - setOriginalValue(getValue()); + if (modification != null) { + setOriginalValue(modification.modify(getOriginalValue())); + modification = null; + } } } From 564be8061d55cc7d53730189fc910a5dbb5e8b62 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Fri, 13 Dec 2024 15:11:47 +0100 Subject: [PATCH 41/82] Add Swap Endian Modifications for long and integer --- .../ModifiableVariable.java | 4 ++ .../integer/IntegerModificationFactory.java | 7 ++ .../IntegerSwapEndianModification.java | 64 +++++++++++++++++++ .../longint/LongModificationFactory.java | 7 ++ .../longint/LongSwapEndianModification.java | 64 +++++++++++++++++++ .../modifiablevariable/util/Modifiable.java | 8 +++ 6 files changed, 154 insertions(+) create mode 100644 src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSwapEndianModification.java create mode 100644 src/main/java/de/rub/nds/modifiablevariable/longint/LongSwapEndianModification.java diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java index 67fcf6f4..2914dd47 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -97,6 +97,9 @@ public abstract class ModifiableVariable implements Serializable { type = ByteArrayDuplicateModification.class, name = "ByteArrayDuplicateModification"), @XmlElement(type = ByteArrayDeleteModification.class, name = "ByteArrayDeleteModification"), + @XmlElement( + type = IntegerSwapEndianModification.class, + name = "IntegerSwapEndianModification"), @XmlElement(type = IntegerXorModification.class, name = "IntegerXorModification"), @XmlElement(type = IntegerSubtractModification.class, name = "IntegerSubtractModification"), @XmlElement(type = IntegerMultiplyModification.class, name = "IntegerMultiplyModification"), @@ -123,6 +126,7 @@ public abstract class ModifiableVariable implements Serializable { type = IntegerPrependValueModification.class, name = "IntegerPrependValueModification"), @XmlElement(type = LongXorModification.class, name = "LongXorModification"), + @XmlElement(type = LongSwapEndianModification.class, name = "LongSwapEndianModification"), @XmlElement(type = LongSubtractModification.class, name = "LongSubtractModification"), @XmlElement( type = LongExplicitValueFromFileModification.class, 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 8215f233..78b9d04d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerModificationFactory.java @@ -25,6 +25,7 @@ private enum ModificationType { SUBTRACT, MULTIPLY, XOR, + SWAP_ENDIAN, EXPLICIT, SHIFT_LEFT, SHIFT_RIGHT, @@ -92,6 +93,10 @@ public static VariableModification xor(Integer xor) { return new IntegerXorModification(xor); } + public static VariableModification swapEndian() { + return new IntegerSwapEndianModification(); + } + public static VariableModification explicitValue(String value) { return explicitValue(Integer.parseInt(value)); } @@ -162,6 +167,8 @@ public static VariableModification createRandomModification() { random.nextInt(MAX_MODIFICATION_MULTIPLY_VALUE)); case XOR: return new IntegerXorModification(modification); + case SWAP_ENDIAN: + return new IntegerSwapEndianModification(); case EXPLICIT: return new IntegerExplicitValueModification(modification); case SHIFT_LEFT: 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..601b9abd --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSwapEndianModification.java @@ -0,0 +1,64 @@ +/* + * 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 jakarta.xml.bind.annotation.XmlType; + +@XmlRootElement +@XmlType(propOrder = "modificationFilter") +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 VariableModification getModifiedCopy() { + return new IntegerSwapEndianModification(); + } + + @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/longint/LongModificationFactory.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongModificationFactory.java index 0b22db18..11050ebb 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongModificationFactory.java @@ -26,6 +26,7 @@ private enum ModificationType { SUBTRACT, MULTIPLY, XOR, + SWAP_ENDIAN, EXPLICIT, SHIFT_LEFT, SHIFT_RIGHT, @@ -77,6 +78,10 @@ public static VariableModification xor(Long xor) { return new LongXorModification(xor); } + public static VariableModification swapEndian() { + return new LongSwapEndianModification(); + } + public static VariableModification explicitValue(String value) { return explicitValue(Long.parseLong(value)); } @@ -155,6 +160,8 @@ public static VariableModification createRandomModification() { (long) random.nextInt(MAX_MODIFICATION_MULTIPLY_VALUE)); case XOR: return new LongXorModification(modification); + case SWAP_ENDIAN: + return new LongSwapEndianModification(); case EXPLICIT: return new LongExplicitValueModification(modification); case SHIFT_LEFT: 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..980b4b8e --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongSwapEndianModification.java @@ -0,0 +1,64 @@ +/* + * 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 jakarta.xml.bind.annotation.XmlType; + +@XmlRootElement +@XmlType(propOrder = "modificationFilter") +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 VariableModification getModifiedCopy() { + return new LongSwapEndianModification(); + } + + @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/util/Modifiable.java b/src/main/java/de/rub/nds/modifiablevariable/util/Modifiable.java index 43c2812a..cf1e2371 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/Modifiable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/Modifiable.java @@ -243,6 +243,14 @@ public static ModifiableLong xor(Long xor) { return getModifiableLongWithModification(LongModificationFactory.xor(xor)); } + public static ModifiableInteger swapEndianIntger() { + return getModifiableIntegerWithModification(IntegerModificationFactory.swapEndian()); + } + + public static ModifiableLong swapEndianLong() { + return getModifiableLongWithModification(LongModificationFactory.swapEndian()); + } + public static ModifiableByte add(Byte summand) { return getModifiableByteWithModification(ByteModificationFactory.add(summand)); } From 6a0d506a8f810d95dfcc40bbb0b874a3708cb2ef Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Fri, 13 Dec 2024 16:52:51 +0100 Subject: [PATCH 42/82] Allow multiple modifications on one modifiable variable --- .../ModifiableVariable.java | 81 ++++++++++++++----- .../bytearray/ModifiableByteArrayTest.java | 4 +- 2 files changed, 64 insertions(+), 21 deletions(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java index 2914dd47..1cdafd38 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -16,14 +16,11 @@ import de.rub.nds.modifiablevariable.path.*; import de.rub.nds.modifiablevariable.singlebyte.*; import de.rub.nds.modifiablevariable.string.*; -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.LinkedList; import java.util.Objects; +import java.util.stream.Collectors; /** * The base abstract class for modifiable variables, including the getValue function.The class needs @@ -37,6 +34,7 @@ @XmlAccessorType(XmlAccessType.FIELD) public abstract class ModifiableVariable implements Serializable { + @XmlElementWrapper @XmlElements({ @XmlElement(type = BigIntegerXorModification.class, name = "BigIntegerXorModification"), @XmlElement( @@ -190,7 +188,7 @@ public abstract class ModifiableVariable implements Serializable { type = PathToggleRootModification.class, name = "PathToggleRootValueModification"), }) - private VariableModification modification; + private LinkedList> modifications; private Boolean createRandomModification; @@ -202,19 +200,52 @@ protected ModifiableVariable() { protected ModifiableVariable(ModifiableVariable other) { super(); + if (other.modifications != null) { + modifications = new LinkedList<>(); + for (VariableModification item : other.modifications) { + modifications.add(item != null ? item.createCopy() : null); + } + } createRandomModification = other.createRandomModification; - modification = other.modification != null ? other.modification.createCopy() : null; // Warning: Make sure to copy assertEquals in subclass correctly assertEquals = other.assertEquals; } + /** Set a single modification, all previously set modifications are removed */ public void setModification(VariableModification modification) { - this.modification = modification; + if (modification != null) { + modifications = new LinkedList<>(); + modifications.add(modification); + } else { + modifications = null; + } + } + + /** Adds a modification to this modifiable variable */ + public void addModification(VariableModification modification) { + if (modification != null) { + if (modifications == null) { + modifications = new LinkedList<>(); + } + modifications.add(modification); + } } - @XmlTransient + /** + * Returns the first modification that was set for this modifiable variable, if one exists. + * + *

Use {@code getModifications()} to get all modifications + */ public VariableModification getModification() { - return modification; + if (modifications == null || modifications.isEmpty()) { + return null; + } + return modifications.getFirst(); + } + + /** Returns all modifications that are set for this modifiable variable */ + public LinkedList> getModifications() { + return modifications; } public E getValue() { @@ -223,10 +254,17 @@ public E getValue() { createRandomModification = false; } - if (modification != null) { - return modification.modify(getOriginalValue()); + return getModifiedValue(); + } + + private E getModifiedValue() { + E resultValue = getOriginalValue(); + if (modifications != null) { + for (VariableModification modification : modifications) { + resultValue = modification.modify(resultValue); + } } - return getOriginalValue(); + return resultValue; } /** @@ -237,9 +275,9 @@ public E getValue() { */ public void reduceToOriginalValue(boolean evenWithNullOriginalValue) { if (evenWithNullOriginalValue || getOriginalValue() != null) { - if (modification != null) { - setOriginalValue(modification.modify(getOriginalValue())); - modification = null; + if (modifications != null) { + setOriginalValue(getModifiedValue()); + modifications = null; } } } @@ -270,7 +308,14 @@ public Boolean isCreateRandomModification() { public String innerToString() { StringBuilder result = new StringBuilder(); - result.append(", modification=").append(modification); + if (modifications != null) { + result.append(", modifications=[") + .append( + modifications.stream() + .map(Object::toString) + .collect(Collectors.joining(", "))) + .append("]"); + } if (createRandomModification != null) { result.append(", createRandomModification=").append(createRandomModification); 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 62287d94..37563bf2 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArrayTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArrayTest.java @@ -368,9 +368,7 @@ public void toStringTest() { toTest = ModifiableVariableFactory.safelySetValue( toTest, new byte[] {0x00, 0x11, 0x22, 0x33, 0x44}); - assertEquals( - "ModifiableByteArray{originalValue=00 11 22 33 44, modification=null}", - toTest.toString()); + assertEquals("ModifiableByteArray{originalValue=00 11 22 33 44}", toTest.toString()); } @Test From 3a3a2adf975f3a3927583277da60187535f02ff5 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Mon, 16 Dec 2024 09:58:18 +0100 Subject: [PATCH 43/82] Fi some overflows --- .../biginteger/BigIntegerModificationFactory.java | 5 ++--- .../bytearray/ByteArrayDeleteModification.java | 3 +++ .../bytearray/ByteArrayModificationFactory.java | 3 +-- .../bytearray/ByteArrayXorModification.java | 3 +++ .../integer/IntegerModificationFactory.java | 5 ++--- .../modifiablevariable/longint/LongModificationFactory.java | 5 ++--- .../singlebyte/ByteModificationFactory.java | 5 ++--- .../modifiablevariable/string/StringDeleteModification.java | 3 +++ 8 files changed, 18 insertions(+), 14 deletions(-) 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 120067cb..57e3ba7a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationFactory.java @@ -103,10 +103,9 @@ public static VariableModification explicitValue(BigInteger value) { return new BigIntegerExplicitValueModification(value); } - public static VariableModification explicitValueFromFile(int value) { + public static VariableModification explicitValueFromFile(int pos) { List> modifications = modificationsFromFile(); - int pos = value % modifications.size(); - return modifications.get(pos); + return modifications.get(pos % modifications.size()); } public static VariableModification appendValue(BigInteger value) { 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 a8413556..88b25d5f 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java @@ -53,6 +53,9 @@ protected byte[] modifyImplementationHook(byte[] input) { if (input == null) { input = new byte[0]; } + if (input.length == 0) { + return input; + } // Wrap around and also allow to delete at the end of the original value int deleteStartPosition = startPosition % input.length; 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 c458ad42..ee603cff 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayModificationFactory.java @@ -100,8 +100,7 @@ public static VariableModification explicitValue(byte[] explicitValue) { public static VariableModification explicitValueFromFile(int value) { List> modifications = modificationsFromFile(); - int pos = value % modifications.size(); - return modifications.get(pos); + return modifications.get(value % modifications.size()); } /** 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 f989c665..3471b3ea 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java @@ -58,6 +58,9 @@ protected byte[] modifyImplementationHook(byte[] input) { if (input == null) { input = new byte[0]; } + if (input.length == 0) { + return input; + } byte[] result = input.clone(); // Wrap around and also allow to xor at the end of the original value 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 78b9d04d..9acd71eb 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerModificationFactory.java @@ -105,10 +105,9 @@ public static VariableModification explicitValue(Integer value) { return new IntegerExplicitValueModification(value); } - public static VariableModification explicitValueFromFile(int value) { + public static VariableModification explicitValueFromFile(int pos) { List> modifications = modificationsFromFile(); - int pos = value % modifications.size(); - return modifications.get(pos); + return modifications.get(pos % modifications.size()); } public static VariableModification appendValue(Integer value) { 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 11050ebb..546db557 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongModificationFactory.java @@ -90,10 +90,9 @@ public static VariableModification explicitValue(Long value) { return new LongExplicitValueModification(value); } - public static VariableModification explicitValueFromFile(int value) { + public static VariableModification explicitValueFromFile(int pos) { List> modifications = modificationsFromFile(); - int pos = value % modifications.size(); - return modifications.get(pos); + return modifications.get(pos % modifications.size()); } public static VariableModification appendValue(Long value) { 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 91627a4b..51593775 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteModificationFactory.java @@ -66,10 +66,9 @@ public static VariableModification explicitValue(Byte value) { return new ByteExplicitValueModification(value); } - public static VariableModification explicitValueFromFile(int value) { + public static VariableModification explicitValueFromFile(int pos) { List> modifications = modificationsFromFile(); - int pos = value % modifications.size(); - return modifications.get(pos); + return modifications.get(pos % modifications.size()); } public static synchronized List> modificationsFromFile() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringDeleteModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringDeleteModification.java index 85dee061..aea4e26f 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringDeleteModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringDeleteModification.java @@ -50,6 +50,9 @@ 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(); From dc19dd427b2d24789d4f2a6c3c83ac006ac3cb33 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Wed, 18 Dec 2024 16:54:54 +0100 Subject: [PATCH 44/82] Add softlySetValue methods for all modifiable variables. --- .../ModifiableVariableFactory.java | 104 ++++++++++++++++++ .../biginteger/ModifiableBigInteger.java | 5 + .../bytearray/ModifiableByteArray.java | 5 + .../integer/ModifiableInteger.java | 5 + .../longint/ModifiableLong.java | 5 + .../path/ModifiablePath.java | 4 + .../singlebyte/ModifiableByte.java | 5 + .../string/ModifiableString.java | 5 + 8 files changed, 138 insertions(+) diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableFactory.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableFactory.java index 08fe41b6..9e80039d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableFactory.java @@ -59,6 +59,19 @@ public static ModifiableBigInteger safelySetValue(ModifiableBigInteger mv, BigIn return mv; } + /** + * Returns only a ModifiableBigInteger with the value, if the given mv is null or the original + * value of the mv is null + */ + public static ModifiableBigInteger softlySetValue(ModifiableBigInteger mv, BigInteger value) { + if (mv == null) { + return new ModifiableBigInteger(value); + } else if (mv.getOriginalValue() == null) { + mv.setOriginalValue(value); + } + return mv; + } + public static ModifiableString safelySetValue(ModifiableString mv, String value) { if (mv == null) { mv = new ModifiableString(); @@ -67,6 +80,19 @@ public static ModifiableString safelySetValue(ModifiableString mv, String value) return mv; } + /** + * Returns only a ModifiableString with the value, if the given mv is null or the original value + * of the mv is null + */ + public static ModifiableString softlySetValue(ModifiableString mv, String value) { + if (mv == null) { + return new ModifiableString(value); + } else if (mv.getOriginalValue() == null) { + mv.setOriginalValue(value); + } + return mv; + } + public static ModifiableInteger safelySetValue(ModifiableInteger mv, Integer value) { if (mv == null) { mv = new ModifiableInteger(); @@ -75,6 +101,19 @@ public static ModifiableInteger safelySetValue(ModifiableInteger mv, Integer val return mv; } + /** + * Returns only a ModifiableInteger with the value, if the given mv is null or the original + * value of the mv is null + */ + public static ModifiableInteger softlySetValue(ModifiableInteger mv, Integer value) { + if (mv == null) { + return new ModifiableInteger(value); + } else if (mv.getOriginalValue() == null) { + mv.setOriginalValue(value); + } + return mv; + } + public static ModifiableByte safelySetValue(ModifiableByte mv, Byte value) { if (mv == null) { mv = new ModifiableByte(); @@ -83,6 +122,19 @@ public static ModifiableByte safelySetValue(ModifiableByte mv, Byte value) { return mv; } + /** + * Returns only a ModifiableByte with the value, if the given mv is null or the original value + * of the mv is null + */ + public static ModifiableByte softlySetValue(ModifiableByte mv, Byte value) { + if (mv == null) { + return new ModifiableByte(value); + } else if (mv.getOriginalValue() == null) { + mv.setOriginalValue(value); + } + return mv; + } + public static ModifiableByteArray safelySetValue(ModifiableByteArray mv, byte[] value) { if (mv == null) { mv = new ModifiableByteArray(); @@ -91,6 +143,19 @@ public static ModifiableByteArray safelySetValue(ModifiableByteArray mv, byte[] return mv; } + /** + * Returns only a ModifiableByteArray with the value, if the given mv is null or the original + * value of the mv is null + */ + public static ModifiableByteArray softlySetValue(ModifiableByteArray mv, byte[] value) { + if (mv == null) { + return new ModifiableByteArray(value); + } else if (mv.getOriginalValue() == null) { + mv.setOriginalValue(value); + } + return mv; + } + public static ModifiableLong safelySetValue(ModifiableLong mv, Long value) { if (mv == null) { mv = new ModifiableLong(); @@ -99,6 +164,19 @@ public static ModifiableLong safelySetValue(ModifiableLong mv, Long value) { return mv; } + /** + * Returns only a ModifiableLong with the value, if the given mv is null or the original value + * of the mv is null + */ + public static ModifiableLong softlySetValue(ModifiableLong mv, Long value) { + if (mv == null) { + return new ModifiableLong(value); + } else if (mv.getOriginalValue() == null) { + mv.setOriginalValue(value); + } + return mv; + } + public static ModifiableBoolean safelySetValue(ModifiableBoolean mv, Boolean value) { if (mv == null) { mv = new ModifiableBoolean(); @@ -107,6 +185,19 @@ public static ModifiableBoolean safelySetValue(ModifiableBoolean mv, Boolean val return mv; } + /** + * Returns only a ModifiableBoolean with the value, if the given mv is null or the original + * value of the mv is null + */ + public static ModifiableBoolean softlySetValue(ModifiableBoolean mv, Boolean value) { + if (mv == null) { + return new ModifiableBoolean(value); + } else if (mv.getOriginalValue() == null) { + mv.setOriginalValue(value); + } + return mv; + } + public static ModifiablePath safelySetValue(ModifiablePath mv, String value) { if (mv == null) { mv = new ModifiablePath(); @@ -115,6 +206,19 @@ public static ModifiablePath safelySetValue(ModifiablePath mv, String value) { return mv; } + /** + * Returns only a ModifiablePath with the value, if the given mv is null or the original value + * of the mv is null + */ + public static ModifiablePath softlySetValue(ModifiablePath mv, String value) { + if (mv == null) { + return new ModifiablePath(value); + } else if (mv.getOriginalValue() == null) { + mv.setOriginalValue(value); + } + return mv; + } + private ModifiableVariableFactory() { super(); } 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 5967ca6f..b801daa9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigInteger.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigInteger.java @@ -25,6 +25,11 @@ public ModifiableBigInteger() { super(); } + public ModifiableBigInteger(BigInteger originalValue) { + super(); + this.originalValue = originalValue; + } + public ModifiableBigInteger(ModifiableBigInteger other) { super(other); originalValue = other.originalValue; 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 44ee354c..cdcfbcc1 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArray.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArray.java @@ -27,6 +27,11 @@ 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; 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 e983e33f..11189a91 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/ModifiableInteger.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/ModifiableInteger.java @@ -24,6 +24,11 @@ public ModifiableInteger() { super(); } + public ModifiableInteger(Integer originalValue) { + super(); + this.originalValue = originalValue; + } + public ModifiableInteger(ModifiableInteger other) { super(other); originalValue = other.originalValue; 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 4111534a..b5cc778a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/ModifiableLong.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/ModifiableLong.java @@ -24,6 +24,11 @@ public ModifiableLong() { super(); } + public ModifiableLong(Long originalValue) { + super(); + this.originalValue = originalValue; + } + public ModifiableLong(ModifiableLong other) { super(other); originalValue = other.originalValue; diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java b/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java index aff45546..f618ce74 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java @@ -23,6 +23,10 @@ public ModifiablePath() { super(); } + public ModifiablePath(String originalValue) { + super(originalValue); + } + public ModifiablePath(ModifiablePath other) { super(other); } 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 f4920538..2676c998 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByte.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByte.java @@ -23,6 +23,11 @@ public ModifiableByte() { super(); } + public ModifiableByte(Byte originalValue) { + super(); + this.originalValue = originalValue; + } + public ModifiableByte(ModifiableByte other) { super(other); originalValue = other.originalValue; 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 6b9c33cf..848b70af 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java @@ -30,6 +30,11 @@ public ModifiableString() { super(); } + public ModifiableString(String originalValue) { + super(); + this.originalValue = originalValue; + } + public ModifiableString(ModifiableString other) { super(other); originalValue = other.originalValue; From e4237b528437b43838092022624e4e400f74bc03 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Wed, 18 Dec 2024 17:03:05 +0100 Subject: [PATCH 45/82] Add softlySetValue with alwaysSet option --- .../ModifiableVariableFactory.java | 126 ++++++++++++++++-- 1 file changed, 118 insertions(+), 8 deletions(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableFactory.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableFactory.java index 9e80039d..3c0d2f1a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableFactory.java @@ -53,7 +53,7 @@ public static ModifiablePath createPathModifiableVariable() { public static ModifiableBigInteger safelySetValue(ModifiableBigInteger mv, BigInteger value) { if (mv == null) { - mv = new ModifiableBigInteger(); + return new ModifiableBigInteger(value); } mv.setOriginalValue(value); return mv; @@ -72,9 +72,23 @@ public static ModifiableBigInteger softlySetValue(ModifiableBigInteger mv, BigIn return mv; } + /** + * Returns only a ModifiableBigInteger with the value, if the given mv is null or the original + * value of the mv is null or alwaysSet is true + */ + public static ModifiableBigInteger softlySetValue( + ModifiableBigInteger mv, BigInteger value, boolean alwaysSet) { + if (mv == null) { + return new ModifiableBigInteger(value); + } else if (alwaysSet || mv.getOriginalValue() == null) { + mv.setOriginalValue(value); + } + return mv; + } + public static ModifiableString safelySetValue(ModifiableString mv, String value) { if (mv == null) { - mv = new ModifiableString(); + return new ModifiableString(value); } mv.setOriginalValue(value); return mv; @@ -93,9 +107,23 @@ public static ModifiableString softlySetValue(ModifiableString mv, String value) return mv; } + /** + * Returns only a ModifiableString with the value, if the given mv is null or the original value + * of the mv is null or alwaysSet is true + */ + public static ModifiableString softlySetValue( + ModifiableString mv, String value, boolean alwaysSet) { + if (mv == null) { + return new ModifiableString(value); + } else if (alwaysSet || mv.getOriginalValue() == null) { + mv.setOriginalValue(value); + } + return mv; + } + public static ModifiableInteger safelySetValue(ModifiableInteger mv, Integer value) { if (mv == null) { - mv = new ModifiableInteger(); + return new ModifiableInteger(value); } mv.setOriginalValue(value); return mv; @@ -114,9 +142,23 @@ public static ModifiableInteger softlySetValue(ModifiableInteger mv, Integer val return mv; } + /** + * Returns only a ModifiableInteger with the value, if the given mv is null or the original + * value of the mv is null or alwaysSet is true + */ + public static ModifiableInteger softlySetValue( + ModifiableInteger mv, Integer value, boolean alwaysSet) { + if (mv == null) { + return new ModifiableInteger(value); + } else if (alwaysSet || mv.getOriginalValue() == null) { + mv.setOriginalValue(value); + } + return mv; + } + public static ModifiableByte safelySetValue(ModifiableByte mv, Byte value) { if (mv == null) { - mv = new ModifiableByte(); + return new ModifiableByte(value); } mv.setOriginalValue(value); return mv; @@ -135,9 +177,22 @@ public static ModifiableByte softlySetValue(ModifiableByte mv, Byte value) { return mv; } + /** + * Returns only a ModifiableByte with the value, if the given mv is null or the original value + * of the mv is null or alwaysSet is true + */ + public static ModifiableByte softlySetValue(ModifiableByte mv, Byte value, boolean alwaysSet) { + if (mv == null) { + return new ModifiableByte(value); + } else if (alwaysSet || mv.getOriginalValue() == null) { + mv.setOriginalValue(value); + } + return mv; + } + public static ModifiableByteArray safelySetValue(ModifiableByteArray mv, byte[] value) { if (mv == null) { - mv = new ModifiableByteArray(); + return new ModifiableByteArray(value); } mv.setOriginalValue(value); return mv; @@ -156,9 +211,23 @@ public static ModifiableByteArray softlySetValue(ModifiableByteArray mv, byte[] return mv; } + /** + * Returns only a ModifiableByteArray with the value, if the given mv is null or the original + * value of the mv is null or alwaysSet is true + */ + public static ModifiableByteArray softlySetValue( + ModifiableByteArray mv, byte[] value, boolean alwaysSet) { + if (mv == null) { + return new ModifiableByteArray(value); + } else if (alwaysSet || mv.getOriginalValue() == null) { + mv.setOriginalValue(value); + } + return mv; + } + public static ModifiableLong safelySetValue(ModifiableLong mv, Long value) { if (mv == null) { - mv = new ModifiableLong(); + return new ModifiableLong(value); } mv.setOriginalValue(value); return mv; @@ -177,9 +246,22 @@ public static ModifiableLong softlySetValue(ModifiableLong mv, Long value) { return mv; } + /** + * Returns only a ModifiableLong with the value, if the given mv is null or the original value + * of the mv is null or alwaysSet is true + */ + public static ModifiableLong softlySetValue(ModifiableLong mv, Long value, boolean alwaysSet) { + if (mv == null) { + return new ModifiableLong(value); + } else if (alwaysSet || mv.getOriginalValue() == null) { + mv.setOriginalValue(value); + } + return mv; + } + public static ModifiableBoolean safelySetValue(ModifiableBoolean mv, Boolean value) { if (mv == null) { - mv = new ModifiableBoolean(); + return new ModifiableBoolean(value); } mv.setOriginalValue(value); return mv; @@ -198,9 +280,23 @@ public static ModifiableBoolean softlySetValue(ModifiableBoolean mv, Boolean val return mv; } + /** + * Returns only a ModifiableBoolean with the value, if the given mv is null or the original + * value of the mv is null or alwaysSet is true + */ + public static ModifiableBoolean softlySetValue( + ModifiableBoolean mv, Boolean value, boolean alwaysSet) { + if (mv == null) { + return new ModifiableBoolean(value); + } else if (alwaysSet || mv.getOriginalValue() == null) { + mv.setOriginalValue(value); + } + return mv; + } + public static ModifiablePath safelySetValue(ModifiablePath mv, String value) { if (mv == null) { - mv = new ModifiablePath(); + return new ModifiablePath(value); } mv.setOriginalValue(value); return mv; @@ -219,6 +315,20 @@ public static ModifiablePath softlySetValue(ModifiablePath mv, String value) { return mv; } + /** + * Returns only a ModifiablePath with the value, if the given mv is null or the original value + * of the mv is null or alwaysSet is true + */ + public static ModifiablePath softlySetValue( + ModifiablePath mv, String value, boolean alwaysSet) { + if (mv == null) { + return new ModifiablePath(value); + } else if (alwaysSet || mv.getOriginalValue() == null) { + mv.setOriginalValue(value); + } + return mv; + } + private ModifiableVariableFactory() { super(); } From 8684f65b4b29493d2536d18c91d66bdabfd650f6 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Fri, 20 Dec 2024 14:43:17 +0100 Subject: [PATCH 46/82] Rename createRandomModification to setRandomModification, and make it public. --- .../de/rub/nds/modifiablevariable/ModifiableVariable.java | 7 ++++--- .../biginteger/ModifiableBigInteger.java | 2 +- .../rub/nds/modifiablevariable/bool/ModifiableBoolean.java | 2 +- .../modifiablevariable/bytearray/ModifiableByteArray.java | 2 +- .../nds/modifiablevariable/integer/ModifiableInteger.java | 2 +- .../rub/nds/modifiablevariable/longint/ModifiableLong.java | 2 +- .../de/rub/nds/modifiablevariable/path/ModifiablePath.java | 2 +- .../nds/modifiablevariable/singlebyte/ModifiableByte.java | 2 +- .../nds/modifiablevariable/string/ModifiableString.java | 2 +- .../biginteger/ModifiableBigIntegerTest.java | 2 +- .../nds/modifiablevariable/bool/ModifiableBooleanTest.java | 2 +- .../modifiablevariable/integer/ModifiableIntegerTest.java | 6 +++--- .../nds/modifiablevariable/mlong/ModifiableLongTest.java | 2 +- .../modifiablevariable/singlebyte/ModifiableByteTest.java | 2 +- 14 files changed, 19 insertions(+), 18 deletions(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java index 1cdafd38..d9ad5aea 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -250,7 +250,7 @@ public LinkedList> getModifications() { public E getValue() { if (Objects.equals(createRandomModification, Boolean.TRUE)) { - createRandomModification(); + setRandomModification(); createRandomModification = false; } @@ -286,9 +286,10 @@ public void reduceToOriginalValue(boolean evenWithNullOriginalValue) { public abstract void setOriginalValue(E originalValue); - protected abstract void createRandomModification(); + /** Set a single random modification, all previously set modifications are removed */ + public abstract void setRandomModification(); - protected abstract ModifiableVariable createCopy(); + public abstract ModifiableVariable createCopy(); public void createRandomModificationAtRuntime() { createRandomModification = true; 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 b801daa9..0788cdcf 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigInteger.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigInteger.java @@ -41,7 +41,7 @@ public ModifiableBigInteger createCopy() { } @Override - protected void createRandomModification() { + public void setRandomModification() { VariableModification vm = BigIntegerModificationFactory.createRandomModification(); setModification(vm); 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 0db7a529..b6c2e97c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/ModifiableBoolean.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/ModifiableBoolean.java @@ -49,7 +49,7 @@ public void setOriginalValue(Boolean originalValue) { } @Override - protected void createRandomModification() { + public void setRandomModification() { VariableModification vm = BooleanModificationFactory.createRandomModification(); setModification(vm); } 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 cdcfbcc1..9601e69e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArray.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArray.java @@ -44,7 +44,7 @@ public ModifiableByteArray createCopy() { } @Override - protected void createRandomModification() { + public void setRandomModification() { VariableModification vm = ByteArrayModificationFactory.createRandomModification(originalValue); setModification(vm); 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 11189a91..d9612ec3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/ModifiableInteger.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/ModifiableInteger.java @@ -40,7 +40,7 @@ public ModifiableInteger createCopy() { } @Override - protected void createRandomModification() { + public void setRandomModification() { VariableModification vm = IntegerModificationFactory.createRandomModification(); setModification(vm); } 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 b5cc778a..44c233a4 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/ModifiableLong.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/ModifiableLong.java @@ -40,7 +40,7 @@ public ModifiableLong createCopy() { } @Override - protected void createRandomModification() { + public void setRandomModification() { VariableModification vm = LongModificationFactory.createRandomModification(); setModification(vm); } diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java b/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java index f618ce74..b3566ea1 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java @@ -37,7 +37,7 @@ public ModifiablePath createCopy() { } @Override - protected void createRandomModification() { + public void setRandomModification() { VariableModification vm = PathModificationFactory.createRandomModification(null); setModification(vm); } 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 2676c998..ee543274 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByte.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByte.java @@ -39,7 +39,7 @@ public ModifiableByte createCopy() { } @Override - protected void createRandomModification() { + public void setRandomModification() { VariableModification vm = ByteModificationFactory.createRandomModification(); setModification(vm); } 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 848b70af..fd18bbb9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java @@ -46,7 +46,7 @@ public ModifiableString createCopy() { } @Override - protected void createRandomModification() { + public void setRandomModification() { VariableModification vm = StringModificationFactory.createRandomModification(null); setModification(vm); } 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..620d291f 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigIntegerTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigIntegerTest.java @@ -32,7 +32,7 @@ public void setUp() { /** Test of createRandomModification method, of class ModifiableBigInteger. */ @Disabled("Not yet implemented") @Test - public void testCreateRandomModification() {} + public void testSetRandomModification() {} /** Test of getAssertEquals method, of class ModifiableBigInteger. */ @Disabled("Not yet implemented") 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..994b489c 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/bool/ModifiableBooleanTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/bool/ModifiableBooleanTest.java @@ -41,7 +41,7 @@ public void testSetOriginalValue() {} /** Test of createRandomModification method, of class ModifiableBoolean. */ @Disabled("Not yet implemented") @Test - public void testCreateRandomModification() {} + public void testSetRandomModification() {} /** Test of isOriginalValueModified method, of class ModifiableBoolean. */ @Disabled("Not yet implemented") 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..adc5360a 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/integer/ModifiableIntegerTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/integer/ModifiableIntegerTest.java @@ -28,9 +28,9 @@ public void setUp() { /** Test of createRandomModification method, of class ModifiableInteger. */ @Test - public void testCreateRandomModification() { + public void testSetRandomModification() { assertNull(integer1.getModification()); - integer1.createRandomModification(); + integer1.setRandomModification(); assertNotNull(integer1.getModification()); } @@ -53,7 +53,7 @@ public void testSetAssertEquals() { @Test public void testIsOriginalValueModified() { assertFalse(integer1.isOriginalValueModified()); - integer1.createRandomModification(); + integer1.setRandomModification(); assertTrue(integer1.isOriginalValueModified()); } 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..7c53baac 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/mlong/ModifiableLongTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/mlong/ModifiableLongTest.java @@ -32,7 +32,7 @@ public void setUp() { /** Test of createRandomModification method, of class ModifiableLong. */ @Disabled("Not yet implemented") @Test - public void testCreateRandomModification() {} + public void testSetRandomModification() {} /** Test of getAssertEquals method, of class ModifiableLong. */ @Disabled("Not yet implemented") 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..0bf0fffb 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByteTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByteTest.java @@ -30,7 +30,7 @@ public void setUp() { /** Test of createRandomModification method, of class ModifiableByte. */ @Disabled("Not yet implemented") @Test - public void testCreateRandomModification() {} + public void testSetRandomModification() {} /** Test of getAssertEquals method, of class ModifiableByte. */ @Disabled("Not yet implemented") From ff01b27c22d1f40255240364797d795541ae2a6d Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Mon, 30 Dec 2024 19:06:28 +0100 Subject: [PATCH 47/82] Rename longToUint64Bytes to longToEightBytes since it can also be used to convert long to int64, this sounds more general. Also renamed longToUint48Bytes to longToSixBytes and longToUint32Bytes to intToFourBytes. Added helper methods: eigthBytesToLong and fourBytesToInt --- .../util/ArrayConverter.java | 79 +++++++++++-------- .../util/ArrayConverterTest.java | 10 +-- 2 files changed, 51 insertions(+), 38 deletions(-) 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 799c7414..731c9515 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/ArrayConverter.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/ArrayConverter.java @@ -23,37 +23,67 @@ private ArrayConverter() { * 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[] longToEightBytes(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[] longToSixBytes(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[] intToFourBytes(int 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 eigthBytesToLong(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 fourBytesToInt(byte[] bytes) { + return (long) (bytes[4] & 0xFF) << 24 + | (long) (bytes[5] & 0xFF) << 16 + | (long) (bytes[6] & 0xFF) << 8 + | (long) (bytes[7] & 0xFF); + } + /** * Takes an integer value and stores its last bytes into a byte array * @@ -386,19 +416,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/test/java/de/rub/nds/modifiablevariable/util/ArrayConverterTest.java b/src/test/java/de/rub/nds/modifiablevariable/util/ArrayConverterTest.java index 429e68db..7cf5d205 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/util/ArrayConverterTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/util/ArrayConverterTest.java @@ -228,22 +228,18 @@ public void testBigIntegerToNullPaddedByteArray() { } @Test - public void testLongToUint48Bytes() { + public void testLongToSixBytes() { long testValue = 0x0000123456789ABCL; byte[] expectedResult = ArrayConverter.hexStringToByteArray("123456789ABC"); assertArrayEquals( - expectedResult, - ArrayConverter.longToUint48Bytes(testValue), - "Assert correct output"); + expectedResult, ArrayConverter.longToSixBytes(testValue), "Assert correct output"); testValue = 0x0000000000000001L; expectedResult = ArrayConverter.hexStringToByteArray("000000000001"); assertArrayEquals( - expectedResult, - ArrayConverter.longToUint48Bytes(testValue), - "Assert correct output"); + expectedResult, ArrayConverter.longToSixBytes(testValue), "Assert correct output"); } /** From c0fb8253e1782c66237bc4c13caaff29e0aeff60 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Mon, 30 Dec 2024 19:07:58 +0100 Subject: [PATCH 48/82] run linter --- .../util/ArrayConverterTest.java | 33 +++++++++---------- 1 file changed, 15 insertions(+), 18 deletions(-) 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 7cf5d205..b9568e10 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)); @@ -294,7 +291,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}, @@ -333,7 +330,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)); } } From 2ca2f90f2eda910367dd8458d2ef244975616626 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Mon, 30 Dec 2024 19:11:03 +0100 Subject: [PATCH 49/82] Fix fourBytesToInt --- .../nds/modifiablevariable/util/ArrayConverter.java | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) 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 731c9515..ded589af 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/ArrayConverter.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/ArrayConverter.java @@ -77,11 +77,11 @@ public static long eigthBytesToLong(byte[] bytes) { | (long) (bytes[7] & 0xFF); } - public static long fourBytesToInt(byte[] bytes) { - return (long) (bytes[4] & 0xFF) << 24 - | (long) (bytes[5] & 0xFF) << 16 - | (long) (bytes[6] & 0xFF) << 8 - | (long) (bytes[7] & 0xFF); + public static int fourBytesToInt(byte[] bytes) { + return (bytes[4] & 0xFF) << 24 + | (bytes[5] & 0xFF) << 16 + | (bytes[6] & 0xFF) << 8 + | bytes[7] & 0xFF; } /** From 01f2f20e6cba66c4c83c6c9b41eb14a154097295 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Mon, 30 Dec 2024 19:46:32 +0100 Subject: [PATCH 50/82] Fix fourBytesToInt but for real -.- --- .../rub/nds/modifiablevariable/util/ArrayConverter.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) 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 ded589af..7077f9b7 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/ArrayConverter.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/ArrayConverter.java @@ -78,10 +78,10 @@ public static long eigthBytesToLong(byte[] bytes) { } public static int fourBytesToInt(byte[] bytes) { - return (bytes[4] & 0xFF) << 24 - | (bytes[5] & 0xFF) << 16 - | (bytes[6] & 0xFF) << 8 - | bytes[7] & 0xFF; + return (bytes[0] & 0xFF) << 24 + | (bytes[1] & 0xFF) << 16 + | (bytes[2] & 0xFF) << 8 + | bytes[3] & 0xFF; } /** From c472f2392369b0122eb79909f6b25cbfdd000a74 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Thu, 9 Jan 2025 10:47:44 +0100 Subject: [PATCH 51/82] Update Readme --- README.md | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index f2b78555..46aef26c 100644 --- a/README.md +++ b/README.md @@ -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 + + ``` From b515c13a8c5d1262da410d49c87a3d3e01583e37 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Thu, 30 Jan 2025 15:35:38 +0100 Subject: [PATCH 52/82] Fix ArrayConverter.concatenate() if one of the arrays is null. Also only use it in the modifications if it is not null :D --- .../bytearray/ByteArrayDeleteModification.java | 6 +++--- .../bytearray/ByteArrayInsertValueModification.java | 6 +++--- .../path/PathDeleteModification.java | 9 ++++++--- .../nds/modifiablevariable/util/ArrayConverter.java | 10 +++++++--- 4 files changed, 19 insertions(+), 12 deletions(-) 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 88b25d5f..fe326291 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java @@ -70,11 +70,11 @@ protected byte[] modifyImplementationHook(byte[] input) { } byte[] ret1 = Arrays.copyOf(input, deleteStartPosition); - byte[] ret2 = null; if (deleteEndPosition < input.length) { - ret2 = Arrays.copyOfRange(input, 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() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java index 59579e1d..d6d8b90a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java @@ -66,11 +66,11 @@ protected byte[] modifyImplementationHook(byte[] input) { } byte[] ret1 = Arrays.copyOf(input, insertPosition); - byte[] ret3 = null; if (insertPosition < input.length) { - ret3 = Arrays.copyOfRange(input, insertPosition, input.length); + byte[] ret2 = Arrays.copyOfRange(input, insertPosition, input.length); + return ArrayConverter.concatenate(ret1, bytesToInsert, ret2); } - return ArrayConverter.concatenate(ret1, bytesToInsert, ret3); + return ret1; } public byte[] getBytesToInsert() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathDeleteModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathDeleteModification.java index 3de7c144..7a547326 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathDeleteModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathDeleteModification.java @@ -68,11 +68,14 @@ protected String modifyImplementationHook(String input) { } String[] partsBefore = Arrays.copyOf(pathParts, deleteStartPosition); - String[] partsAfter = null; + String[] resultParts; if (deleteEndPosition < pathParts.length) { - partsAfter = Arrays.copyOfRange(pathParts, deleteEndPosition, pathParts.length); + String[] partsAfter = + Arrays.copyOfRange(pathParts, deleteEndPosition, pathParts.length); + resultParts = ArrayConverter.concatenate(partsBefore, partsAfter); + } else { + resultParts = partsBefore; } - String[] resultParts = ArrayConverter.concatenate(partsBefore, partsAfter); if (input.endsWith("/") && resultParts.length > 0) { resultParts[resultParts.length - 1] += "/"; 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 7077f9b7..14aea1b7 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/ArrayConverter.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/ArrayConverter.java @@ -236,14 +236,18 @@ public static T[] concatenate(T[]... arrays) { } int length = 0; for (T[] a : arrays) { - length += a.length; + if (a != null) { + length += a.length; + } } @SuppressWarnings("unchecked") T[] result = (T[]) Array.newInstance(arrays[0].getClass().getComponentType(), length); int currentOffset = 0; for (T[] a : arrays) { - System.arraycopy(a, 0, result, currentOffset, a.length); - currentOffset += a.length; + if (a != null) { + System.arraycopy(a, 0, result, currentOffset, a.length); + currentOffset += a.length; + } } return result; } From 38d4607a3f672a403d1857d9e7e82d64c7debfbb Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Thu, 30 Jan 2025 15:39:35 +0100 Subject: [PATCH 53/82] Fix ByteArrayInsertValueModification, that I messed up last commit --- .../bytearray/ByteArrayInsertValueModification.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java index d6d8b90a..b96569d4 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java @@ -70,7 +70,7 @@ protected byte[] modifyImplementationHook(byte[] input) { byte[] ret2 = Arrays.copyOfRange(input, insertPosition, input.length); return ArrayConverter.concatenate(ret1, bytesToInsert, ret2); } - return ret1; + return ArrayConverter.concatenate(ret1, bytesToInsert); } public byte[] getBytesToInsert() { From 5bc90d5116ba35feec2140c9f18470050df2205a Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Thu, 30 Jan 2025 17:25:47 +0100 Subject: [PATCH 54/82] Fix Path Insertion and Deletion. Also add tests for these two modifications. --- .../path/PathDeleteModification.java | 7 + .../nds/modifiablevariable/path/PathUtil.java | 4 + .../path/PathModificationTest.java | 167 ++++++++++++++++++ 3 files changed, 178 insertions(+) create mode 100644 src/test/java/de/rub/nds/modifiablevariable/path/PathModificationTest.java diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathDeleteModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathDeleteModification.java index 7a547326..71639a37 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathDeleteModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathDeleteModification.java @@ -56,6 +56,13 @@ protected String modifyImplementationHook(String input) { return input; } String[] pathParts = input.split("/"); + if (pathParts.length == 0) { + // It is just a single slash + if (count == 0) { + return input; + } + return ""; + } boolean leadingSlash = pathParts[0].isEmpty(); // Wrap around and also allow to delete at the end of the original value diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathUtil.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathUtil.java index 549f98ca..db3d46d3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathUtil.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathUtil.java @@ -23,6 +23,10 @@ public static String insertValueAsPathPart( return insertValue; } String[] pathParts = input.split("/"); + if (pathParts.length == 0) { + // It is just a single slash + pathParts = new String[] {""}; + } boolean leadingSlash = pathParts[0].isEmpty(); // Wrap around and also allow to insert at the end of the original value diff --git a/src/test/java/de/rub/nds/modifiablevariable/path/PathModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/path/PathModificationTest.java new file mode 100644 index 00000000..f44f4d26 --- /dev/null +++ b/src/test/java/de/rub/nds/modifiablevariable/path/PathModificationTest.java @@ -0,0 +1,167 @@ +/* + * 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.path; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; + +import org.junit.jupiter.api.Test; + +public class PathModificationTest { + + @Test + public void testInsert() { + ModifiablePath nullPath = new ModifiablePath(); + nullPath.setModification(new PathInsertValueModification("test", 2)); + assertNull(nullPath.getValue()); + + ModifiablePath emptyPath = new ModifiablePath(""); + emptyPath.setModification(new PathInsertValueModification("test", 0)); + assertEquals("test", emptyPath.getValue()); + emptyPath.setModification(new PathInsertValueModification("test", 10)); + assertEquals("test", emptyPath.getValue()); + + ModifiablePath simplePathLeadingSlash = new ModifiablePath("/this/is/a/path"); + simplePathLeadingSlash.setModification(new PathInsertValueModification("test", 0)); + assertEquals("/test/this/is/a/path", simplePathLeadingSlash.getValue()); + simplePathLeadingSlash.setModification(new PathInsertValueModification("test", 4)); + assertEquals("/this/is/a/path/test", simplePathLeadingSlash.getValue()); + simplePathLeadingSlash.setModification(new PathInsertValueModification("test", 5)); + assertEquals("/test/this/is/a/path", simplePathLeadingSlash.getValue()); + simplePathLeadingSlash.setModification(new PathInsertValueModification("test", 6)); + assertEquals("/this/test/is/a/path", simplePathLeadingSlash.getValue()); + simplePathLeadingSlash.setModification(new PathInsertValueModification("test", 11)); + assertEquals("/this/test/is/a/path", simplePathLeadingSlash.getValue()); + + ModifiablePath simplePathLeadingAndTrailingSlash = new ModifiablePath("/this/is/a/path/"); + simplePathLeadingAndTrailingSlash.setModification( + new PathInsertValueModification("test", 0)); + assertEquals("/test/this/is/a/path/", simplePathLeadingAndTrailingSlash.getValue()); + simplePathLeadingAndTrailingSlash.setModification( + new PathInsertValueModification("test", 4)); + assertEquals("/this/is/a/path/test/", simplePathLeadingAndTrailingSlash.getValue()); + simplePathLeadingAndTrailingSlash.setModification( + new PathInsertValueModification("test", 5)); + assertEquals("/test/this/is/a/path/", simplePathLeadingAndTrailingSlash.getValue()); + simplePathLeadingAndTrailingSlash.setModification( + new PathInsertValueModification("test", 6)); + assertEquals("/this/test/is/a/path/", simplePathLeadingAndTrailingSlash.getValue()); + simplePathLeadingAndTrailingSlash.setModification( + new PathInsertValueModification("test", 11)); + assertEquals("/this/test/is/a/path/", simplePathLeadingAndTrailingSlash.getValue()); + + ModifiablePath simplePath = new ModifiablePath("this/is/a/path"); + simplePath.setModification(new PathInsertValueModification("test", 0)); + assertEquals("test/this/is/a/path", simplePath.getValue()); + simplePath.setModification(new PathInsertValueModification("test", 4)); + assertEquals("this/is/a/path/test", simplePath.getValue()); + simplePath.setModification(new PathInsertValueModification("test", 5)); + assertEquals("test/this/is/a/path", simplePath.getValue()); + simplePath.setModification(new PathInsertValueModification("test", 6)); + assertEquals("this/test/is/a/path", simplePath.getValue()); + simplePath.setModification(new PathInsertValueModification("test", 11)); + assertEquals("this/test/is/a/path", simplePath.getValue()); + + ModifiablePath simplePathTrailingSlash = new ModifiablePath("this/is/a/path/"); + simplePathTrailingSlash.setModification(new PathInsertValueModification("test", 0)); + assertEquals("test/this/is/a/path/", simplePathTrailingSlash.getValue()); + simplePathTrailingSlash.setModification(new PathInsertValueModification("test", 4)); + assertEquals("this/is/a/path/test/", simplePathTrailingSlash.getValue()); + simplePathTrailingSlash.setModification(new PathInsertValueModification("test", 5)); + assertEquals("test/this/is/a/path/", simplePathTrailingSlash.getValue()); + simplePathTrailingSlash.setModification(new PathInsertValueModification("test", 6)); + assertEquals("this/test/is/a/path/", simplePathTrailingSlash.getValue()); + simplePathTrailingSlash.setModification(new PathInsertValueModification("test", 11)); + assertEquals("this/test/is/a/path/", simplePathTrailingSlash.getValue()); + + ModifiablePath rootPath = new ModifiablePath("/"); + rootPath.setModification(new PathInsertValueModification("test", 0)); + assertEquals("/test/", rootPath.getValue()); + rootPath.setModification(new PathInsertValueModification("test", 2)); + assertEquals("/test/", rootPath.getValue()); + rootPath.setModification(new PathInsertValueModification("test", 5)); + assertEquals("/test/", rootPath.getValue()); + } + + @Test + public void testDelete() { + ModifiablePath nullPath = new ModifiablePath(); + nullPath.setModification(new PathDeleteModification(0, 1)); + assertNull(nullPath.getValue()); + + ModifiablePath emptyPath = new ModifiablePath(""); + emptyPath.setModification(new PathDeleteModification(0, 1)); + assertEquals("", emptyPath.getValue()); + emptyPath.setModification(new PathDeleteModification(1, 10)); + assertEquals("", emptyPath.getValue()); + + ModifiablePath simplePathLeadingSlash = new ModifiablePath("/this/is/a/path"); + simplePathLeadingSlash.setModification(new PathDeleteModification(0, 0)); + assertEquals("/this/is/a/path", simplePathLeadingSlash.getValue()); + simplePathLeadingSlash.setModification(new PathDeleteModification(4, 4)); + assertEquals("", simplePathLeadingSlash.getValue()); + simplePathLeadingSlash.setModification(new PathDeleteModification(4, 1)); + assertEquals("/is/a/path", simplePathLeadingSlash.getValue()); + simplePathLeadingSlash.setModification(new PathDeleteModification(5, 1)); + assertEquals("/this/a/path", simplePathLeadingSlash.getValue()); + simplePathLeadingSlash.setModification(new PathDeleteModification(6, 1)); + assertEquals("/this/is/path", simplePathLeadingSlash.getValue()); + simplePathLeadingSlash.setModification(new PathDeleteModification(11, 11)); + assertEquals("/this/is/a", simplePathLeadingSlash.getValue()); + + ModifiablePath simplePathLeadingAndTrailingSlash = new ModifiablePath("/this/is/a/path/"); + simplePathLeadingAndTrailingSlash.setModification(new PathDeleteModification(0, 0)); + assertEquals("/this/is/a/path/", simplePathLeadingAndTrailingSlash.getValue()); + simplePathLeadingAndTrailingSlash.setModification(new PathDeleteModification(4, 4)); + assertEquals("/", simplePathLeadingAndTrailingSlash.getValue()); + simplePathLeadingAndTrailingSlash.setModification(new PathDeleteModification(4, 1)); + assertEquals("/is/a/path/", simplePathLeadingAndTrailingSlash.getValue()); + simplePathLeadingAndTrailingSlash.setModification(new PathDeleteModification(5, 1)); + assertEquals("/this/a/path/", simplePathLeadingAndTrailingSlash.getValue()); + simplePathLeadingAndTrailingSlash.setModification(new PathDeleteModification(6, 1)); + assertEquals("/this/is/path/", simplePathLeadingAndTrailingSlash.getValue()); + simplePathLeadingAndTrailingSlash.setModification(new PathDeleteModification(11, 11)); + assertEquals("/this/is/a/", simplePathLeadingAndTrailingSlash.getValue()); + + ModifiablePath simplePath = new ModifiablePath("this/is/a/path"); + simplePath.setModification(new PathDeleteModification(0, 0)); + assertEquals("this/is/a/path", simplePath.getValue()); + simplePath.setModification(new PathDeleteModification(4, 4)); + assertEquals("", simplePath.getValue()); + simplePath.setModification(new PathDeleteModification(4, 1)); + assertEquals("is/a/path", simplePath.getValue()); + simplePath.setModification(new PathDeleteModification(5, 1)); + assertEquals("this/a/path", simplePath.getValue()); + simplePath.setModification(new PathDeleteModification(6, 1)); + assertEquals("this/is/path", simplePath.getValue()); + simplePath.setModification(new PathDeleteModification(11, 11)); + assertEquals("this/is/a", simplePath.getValue()); + + ModifiablePath simplePathTrailingSlash = new ModifiablePath("this/is/a/path/"); + simplePathTrailingSlash.setModification(new PathDeleteModification(0, 0)); + assertEquals("this/is/a/path/", simplePathTrailingSlash.getValue()); + simplePathTrailingSlash.setModification(new PathDeleteModification(4, 4)); + assertEquals("", simplePathTrailingSlash.getValue()); + simplePathTrailingSlash.setModification(new PathDeleteModification(4, 1)); + assertEquals("is/a/path/", simplePathTrailingSlash.getValue()); + simplePathTrailingSlash.setModification(new PathDeleteModification(5, 1)); + assertEquals("this/a/path/", simplePathTrailingSlash.getValue()); + simplePathTrailingSlash.setModification(new PathDeleteModification(6, 1)); + assertEquals("this/is/path/", simplePathTrailingSlash.getValue()); + simplePathTrailingSlash.setModification(new PathDeleteModification(11, 11)); + assertEquals("this/is/a/", simplePathTrailingSlash.getValue()); + + ModifiablePath rootPath = new ModifiablePath("/"); + rootPath.setModification(new PathDeleteModification(0, 0)); + assertEquals("/", rootPath.getValue()); + rootPath.setModification(new PathDeleteModification(2, 2)); + assertEquals("", rootPath.getValue()); + rootPath.setModification(new PathDeleteModification(5, 5)); + assertEquals("", rootPath.getValue()); + } +} From 18a605bd508cfbec5af6cd9a4781d317da01f467 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Fri, 7 Feb 2025 13:37:39 +0100 Subject: [PATCH 55/82] Fix ModifiableByteArray serialization --- .../nds/modifiablevariable/bytearray/ModifiableByteArray.java | 1 - 1 file changed, 1 deletion(-) 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 9601e69e..3fa85afc 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArray.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArray.java @@ -18,7 +18,6 @@ import java.util.Arrays; @XmlRootElement -@XmlAccessorType(XmlAccessType.PROPERTY) public class ModifiableByteArray extends ModifiableVariable { private byte[] originalValue; From 51887db09a6ea9cb178e0b798c6aa47a8159ccf3 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Fri, 7 Feb 2025 13:40:13 +0100 Subject: [PATCH 56/82] run formatter --- .../nds/modifiablevariable/bytearray/ModifiableByteArray.java | 2 -- 1 file changed, 2 deletions(-) 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 3fa85afc..bb46316b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArray.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArray.java @@ -11,8 +11,6 @@ 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.adapters.XmlJavaTypeAdapter; import java.util.Arrays; From 7ad8434938d070e6aff0ca78e5b170abdb24b358 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Fri, 7 Feb 2025 16:17:44 +0100 Subject: [PATCH 57/82] Fixing serialization of ByteArrays, Strings and Path for real by making "getModification" transient. Removing unnecessary @XmlAccessorType(XmlAccessType.FIELD) annotations. For the record, using package-info.java did not work, because we can not specify adapters for assertEquals, but we could use it to get rid of the XmlJavaTypeAdapter annotations in the modifications. --- .../ModifiableVariable.java | 17 ++- .../VariableModification.java | 2 - .../biginteger/BigIntegerAddModification.java | 3 - .../BigIntegerAppendValueModification.java | 3 - ...egerExplicitValueFromFileModification.java | 3 - .../BigIntegerExplicitValueModification.java | 3 - .../BigIntegerInsertValueModification.java | 3 - .../BigIntegerInteractiveModification.java | 3 - .../BigIntegerMultiplyModification.java | 3 - .../BigIntegerPrependValueModification.java | 3 - .../BigIntegerShiftLeftModification.java | 3 - .../BigIntegerShiftRightModification.java | 3 - .../BigIntegerSubtractModification.java | 3 - .../biginteger/BigIntegerXorModification.java | 3 - .../biginteger/ModifiableBigInteger.java | 3 - .../bool/ModifiableBoolean.java | 3 - .../ByteArrayAppendValueModification.java | 3 - .../ByteArrayDeleteModification.java | 3 - .../ByteArrayDuplicateModification.java | 3 - ...rrayExplicitValueFromFileModification.java | 3 - .../ByteArrayExplicitValueModification.java | 3 - .../ByteArrayInsertValueModification.java | 3 - .../ByteArrayPrependValueModification.java | 3 - .../ByteArrayShuffleModification.java | 3 - .../bytearray/ByteArrayXorModification.java | 3 - .../bytearray/ModifiableByteArray.java | 3 + ...egerExplicitValueFromFileModification.java | 3 - .../integer/ModifiableInteger.java | 3 - ...LongExplicitValueFromFileModification.java | 3 - .../longint/ModifiableLong.java | 3 - .../path/ModifiablePath.java | 2 +- ...PathExplicitValueFromFileModification.java | 3 - ...ByteExplicitValueFromFileModification.java | 3 - .../singlebyte/ByteXorModification.java | 3 - .../singlebyte/ModifiableByte.java | 3 - .../string/ModifiableString.java | 5 +- ...ringExplicitValueFromFileModification.java | 3 - .../ByteArraySerializationTest.java | 1 + .../serialization/PathSerializationTest.java | 111 +++++++++++++++++ .../StringSerializationTest.java | 115 ++++++++++++++++++ 40 files changed, 247 insertions(+), 105 deletions(-) create mode 100644 src/test/java/de/rub/nds/modifiablevariable/serialization/PathSerializationTest.java create mode 100644 src/test/java/de/rub/nds/modifiablevariable/serialization/StringSerializationTest.java diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java index d9ad5aea..357079a4 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -23,13 +23,12 @@ 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: ... + * 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 { @@ -192,6 +191,15 @@ public abstract class ModifiableVariable implements Serializable { private Boolean createRandomModification; + // @XmlElements({ + // @XmlElement(type = byte[].class), + // @XmlElement(type = String.class), + // @XmlElement(type = Boolean.class), + // @XmlElement(type = Byte.class), + // @XmlElement(type = Integer.class), + // @XmlElement(type = Long.class), + // @XmlElement(type = BigInteger.class) + // }) protected E assertEquals; protected ModifiableVariable() { @@ -236,6 +244,7 @@ public void addModification(VariableModification modification) { * *

Use {@code getModifications()} to get all modifications */ + @XmlTransient public VariableModification getModification() { if (modifications == null || modifications.isEmpty()) { return null; diff --git a/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java b/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java index be4396b4..b7d6d14d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java @@ -15,12 +15,10 @@ 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 { 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 8e5e44d2..810f9036 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java @@ -8,8 +8,6 @@ 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; @@ -18,7 +16,6 @@ @XmlRootElement @XmlType(propOrder = {"summand", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class BigIntegerAddModification extends VariableModification { private static final int MAX_ADD_LENGTH = 8; diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java index 0e7b70eb..61fcfbe0 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java @@ -8,8 +8,6 @@ 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; @@ -18,7 +16,6 @@ @XmlRootElement @XmlType(propOrder = {"appendValue", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class BigIntegerAppendValueModification extends VariableModification { private static final int MAX_APPEND_LENGTH = 8; diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java index 3cfe18b1..710afd62 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java @@ -8,8 +8,6 @@ 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; @@ -17,7 +15,6 @@ @XmlRootElement @XmlType(propOrder = "index") -@XmlAccessorType(XmlAccessType.FIELD) public class BigIntegerExplicitValueFromFileModification extends BigIntegerExplicitValueModification { private int index; 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 3150a89b..05b05889 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java @@ -8,8 +8,6 @@ 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; @@ -18,7 +16,6 @@ @XmlRootElement @XmlType(propOrder = {"explicitValue", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class BigIntegerExplicitValueModification extends VariableModification { private static final int MAX_EXPLICIT_LENGTH = 8; diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java index 007f9f12..1cc2c5ed 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java @@ -8,8 +8,6 @@ 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; @@ -18,7 +16,6 @@ @XmlRootElement @XmlType(propOrder = {"insertValue", "startPosition", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class BigIntegerInsertValueModification extends VariableModification { private static final int MAX_INSERT_LENGTH = 8; diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInteractiveModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInteractiveModification.java index 61162991..83fe29ff 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInteractiveModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInteractiveModification.java @@ -8,8 +8,6 @@ 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; @@ -17,7 +15,6 @@ @XmlRootElement @XmlType(propOrder = "modificationFilter") -@XmlAccessorType(XmlAccessType.FIELD) public class BigIntegerInteractiveModification extends VariableModification { @XmlTransient private final InteractiveBigIntegerModification modification; 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 93a732e5..b34ce279 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java @@ -8,8 +8,6 @@ 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; @@ -18,7 +16,6 @@ @XmlRootElement @XmlType(propOrder = {"factor", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class BigIntegerMultiplyModification extends VariableModification { private static final int MAX_FACTOR_LENGTH = 8; diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java index d9e2fe1a..a3b9f937 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java @@ -8,8 +8,6 @@ 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; @@ -18,7 +16,6 @@ @XmlRootElement @XmlType(propOrder = {"prependValue", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class BigIntegerPrependValueModification extends VariableModification { private static final int MAX_PREPEND_LENGTH = 8; 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 77a9295f..733d831d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java @@ -8,8 +8,6 @@ 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; @@ -17,7 +15,6 @@ @XmlRootElement @XmlType(propOrder = {"shift", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class BigIntegerShiftLeftModification extends VariableModification { private static final int MAX_SHIFT_LENGTH = 32; 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 0d142373..bdb9bb6a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java @@ -8,8 +8,6 @@ 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; @@ -17,7 +15,6 @@ @XmlRootElement @XmlType(propOrder = {"shift", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class BigIntegerShiftRightModification extends VariableModification { private static final int MAX_SHIFT_LENGTH = 32; 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 f07e4fb0..2fa5d942 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java @@ -8,8 +8,6 @@ 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; @@ -18,7 +16,6 @@ @XmlRootElement @XmlType(propOrder = {"subtrahend", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class BigIntegerSubtractModification extends VariableModification { private static final int MAX_SUBTRACT_LENGTH = 8; 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 c3d67759..1653ea50 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java @@ -8,8 +8,6 @@ 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; @@ -18,7 +16,6 @@ @XmlRootElement @XmlType(propOrder = {"xor", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class BigIntegerXorModification extends VariableModification { private static final int MAX_XOR_LENGTH = 8; 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 0788cdcf..be6c11c7 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigInteger.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigInteger.java @@ -10,13 +10,10 @@ 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; 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 b6c2e97c..e0440aee 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/ModifiableBoolean.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/ModifiableBoolean.java @@ -9,12 +9,9 @@ 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; diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java index 78eb3d2e..941a83a3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java @@ -10,8 +10,6 @@ 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; @@ -20,7 +18,6 @@ @XmlRootElement @XmlType(propOrder = {"bytesToAppend", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class ByteArrayAppendValueModification extends VariableModification { private static final int MAX_EXPLICIT_VALUE = 256; 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 fe326291..7659a294 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java @@ -9,8 +9,6 @@ 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; @@ -18,7 +16,6 @@ @XmlRootElement @XmlType(propOrder = {"count", "startPosition", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class ByteArrayDeleteModification extends VariableModification { private static final int MAX_MODIFIER_LENGTH = 32; 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 b919fccf..e9f74b34 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDuplicateModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDuplicateModification.java @@ -9,14 +9,11 @@ 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() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueFromFileModification.java index f303e922..c4d07509 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueFromFileModification.java @@ -9,15 +9,12 @@ 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; @XmlRootElement @XmlType(propOrder = "index") -@XmlAccessorType(XmlAccessType.FIELD) public class ByteArrayExplicitValueFromFileModification extends ByteArrayExplicitValueModification { private int index; 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 83fca1b1..90465721 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java @@ -10,8 +10,6 @@ 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; @@ -20,7 +18,6 @@ @XmlRootElement @XmlType(propOrder = {"explicitValue", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class ByteArrayExplicitValueModification extends VariableModification { private static final int MAX_EXPLICIT_VALUE = 256; diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java index b96569d4..be7be1b9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java @@ -10,8 +10,6 @@ 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; @@ -20,7 +18,6 @@ @XmlRootElement @XmlType(propOrder = {"bytesToInsert", "startPosition", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class ByteArrayInsertValueModification extends VariableModification { private static final int MAX_EXPLICIT_VALUE = 256; diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java index 7399d6ec..3bf46387 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java @@ -10,8 +10,6 @@ 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; @@ -20,7 +18,6 @@ @XmlRootElement @XmlType(propOrder = {"bytesToPrepend", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class ByteArrayPrependValueModification extends VariableModification { private static final int MAX_EXPLICIT_VALUE = 256; 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 47990150..18521520 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayShuffleModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayShuffleModification.java @@ -10,8 +10,6 @@ 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; @@ -24,7 +22,6 @@ */ @XmlRootElement @XmlType(propOrder = {"shuffle", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class ByteArrayShuffleModification extends VariableModification { private static final int MAX_MODIFIER_VALUE = 256; 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 3471b3ea..60b2df2b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java @@ -10,8 +10,6 @@ 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; @@ -20,7 +18,6 @@ @XmlRootElement @XmlType(propOrder = {"xor", "startPosition", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class ByteArrayXorModification extends VariableModification { private static final int MAX_MODIFIER_VALUE = 256; 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 bb46316b..9601e69e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArray.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArray.java @@ -11,11 +11,14 @@ 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.adapters.XmlJavaTypeAdapter; import java.util.Arrays; @XmlRootElement +@XmlAccessorType(XmlAccessType.PROPERTY) public class ModifiableByteArray extends ModifiableVariable { private byte[] originalValue; diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java index f8affaed..839c6b48 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java @@ -8,15 +8,12 @@ package de.rub.nds.modifiablevariable.integer; 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.util.Objects; @XmlRootElement @XmlType(propOrder = "index") -@XmlAccessorType(XmlAccessType.FIELD) public class IntegerExplicitValueFromFileModification extends IntegerExplicitValueModification { private int index; 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 d9612ec3..8aa26aff 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/ModifiableInteger.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/ModifiableInteger.java @@ -10,12 +10,9 @@ 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; diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java index 9635702d..fcc1fa16 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java @@ -8,15 +8,12 @@ package de.rub.nds.modifiablevariable.longint; 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.util.Objects; @XmlRootElement @XmlType(propOrder = "index") -@XmlAccessorType(XmlAccessType.FIELD) public class LongExplicitValueFromFileModification extends LongExplicitValueModification { private int index; 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 44c233a4..f763257b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/ModifiableLong.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/ModifiableLong.java @@ -10,12 +10,9 @@ 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; diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java b/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java index b3566ea1..6745f895 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java @@ -16,7 +16,7 @@ import jakarta.xml.bind.annotation.XmlRootElement; @XmlRootElement -@XmlAccessorType(XmlAccessType.FIELD) +@XmlAccessorType(XmlAccessType.PROPERTY) public class ModifiablePath extends ModifiableString { public ModifiablePath() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java index 7d78424e..4955b06d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java @@ -10,15 +10,12 @@ import static de.rub.nds.modifiablevariable.util.StringUtil.backslashEscapeString; 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.util.Objects; @XmlRootElement @XmlType(propOrder = "index") -@XmlAccessorType(XmlAccessType.FIELD) public class PathExplicitValueFromFileModification extends PathExplicitValueModification { private int index; diff --git a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java index 6460f962..fc531181 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java @@ -8,15 +8,12 @@ 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 jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @XmlRootElement @XmlType(propOrder = "index") -@XmlAccessorType(XmlAccessType.FIELD) public class ByteExplicitValueFromFileModification extends ByteExplicitValueModification { private int index; 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 da6ed4db..18f614b2 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteXorModification.java @@ -8,14 +8,11 @@ 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; 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 ee543274..d86500e9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByte.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByte.java @@ -9,12 +9,9 @@ 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; 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 fd18bbb9..3f55926f 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java @@ -20,10 +20,9 @@ /** */ @XmlRootElement -@XmlAccessorType(XmlAccessType.FIELD) +@XmlAccessorType(XmlAccessType.PROPERTY) public class ModifiableString extends ModifiableVariable { - @XmlJavaTypeAdapter(IllegalStringAdapter.class) protected String originalValue; public ModifiableString() { @@ -51,6 +50,7 @@ public void setRandomModification() { setModification(vm); } + @XmlJavaTypeAdapter(IllegalStringAdapter.class) public String getAssertEquals() { return assertEquals; } @@ -80,6 +80,7 @@ public boolean validateAssertions() { } @Override + @XmlJavaTypeAdapter(IllegalStringAdapter.class) public String getOriginalValue() { return originalValue; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java index 4c429947..6d65c583 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java @@ -10,15 +10,12 @@ import static de.rub.nds.modifiablevariable.util.StringUtil.backslashEscapeString; 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.util.Objects; @XmlRootElement @XmlType(propOrder = "index") -@XmlAccessorType(XmlAccessType.FIELD) public class StringExplicitValueFromFileModification extends StringExplicitValueModification { private int index; 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 ec87a841..39b9abb9 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/serialization/ByteArraySerializationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/serialization/ByteArraySerializationTest.java @@ -64,6 +64,7 @@ public void setUp() throws JAXBException { @Test public void testSerializeDeserializeSimple() throws Exception { start.setModification(null); + start.setAssertEquals(new byte[] {(byte) 0xff, 5, 44, 3}); m.marshal(start, writer); String xmlString = writer.toString(); diff --git a/src/test/java/de/rub/nds/modifiablevariable/serialization/PathSerializationTest.java b/src/test/java/de/rub/nds/modifiablevariable/serialization/PathSerializationTest.java new file mode 100644 index 00000000..2f427559 --- /dev/null +++ b/src/test/java/de/rub/nds/modifiablevariable/serialization/PathSerializationTest.java @@ -0,0 +1,111 @@ +/* + * 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.assertEquals; + +import de.rub.nds.modifiablevariable.VariableModification; +import de.rub.nds.modifiablevariable.filter.AccessModificationFilter; +import de.rub.nds.modifiablevariable.filter.ModificationFilterFactory; +import de.rub.nds.modifiablevariable.path.ModifiablePath; +import de.rub.nds.modifiablevariable.path.PathModificationFactory; +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 PathSerializationTest { + + private static final Logger LOGGER = LogManager.getLogger(); + + private ModifiablePath 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 ModifiablePath("Hello from Test ❤️\\ \u0000 \u0001 \u0006"); + expectedResult = null; + result = null; + + writer = new StringWriter(); + context = JAXBContext.newInstance(ModifiablePath.class); + m = context.createMarshaller(); + m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true); + um = context.createUnmarshaller(); + } + + @Test + public void testSerializeDeserializeSimple() throws Exception { + start.setModification(null); + start.setAssertEquals("Hello from Test 2 \\ \u0000 \u0001 \u0006"); + m.marshal(start, writer); + + String xmlString = writer.toString(); + LOGGER.debug(xmlString); + + um = context.createUnmarshaller(); + ModifiablePath unmarshalled = (ModifiablePath) 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 = PathModificationFactory.insertValue("Uff! ", 0); + start.setModification(modifier); + m.marshal(start, writer); + + String xmlString = writer.toString(); + LOGGER.debug(xmlString); + + um = context.createUnmarshaller(); + ModifiablePath unmarshalled = (ModifiablePath) um.unmarshal(new StringReader(xmlString)); + + expectedResult = "Uff! /Hello from Test ❤️\\ \u0000 \u0001 \u0006"; + result = unmarshalled.getValue(); + assertEquals(expectedResult, result); + } + + @Test + public void testSerializeDeserializeWithModificationFilter() throws Exception { + VariableModification modifier = PathModificationFactory.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(); + ModifiablePath unmarshalled = (ModifiablePath) um.unmarshal(new StringReader(xmlString)); + + // it happens nothing, because the modification is filtered + expectedResult = "Hello from Test ❤️\\ \u0000 \u0001 \u0006"; + result = unmarshalled.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..d4b72ede --- /dev/null +++ b/src/test/java/de/rub/nds/modifiablevariable/serialization/StringSerializationTest.java @@ -0,0 +1,115 @@ +/* + * 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.bytearray.*; +import de.rub.nds.modifiablevariable.filter.AccessModificationFilter; +import de.rub.nds.modifiablevariable.filter.ModificationFilterFactory; +import de.rub.nds.modifiablevariable.string.ModifiableString; +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); + m = context.createMarshaller(); + m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true); + um = context.createUnmarshaller(); + } + + @Test + public void testSerializeDeserializeSimple() throws Exception { + start.setModification(null); + 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.setModification(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); + } + + @Test + public void testSerializeDeserializeWithModificationFilter() throws Exception { + VariableModification modifier = StringModificationFactory.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(); + ModifiableString unmarshalled = + (ModifiableString) um.unmarshal(new StringReader(xmlString)); + + // it happens nothing, because the modification is filtered + expectedResult = "Hello from Test ❤️\\ \u0000 \u0001 \u0006"; + result = unmarshalled.getValue(); + assertEquals(expectedResult, result); + } +} From cfd221ed02efa5429d7f54d515ee307132d5bc36 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Fri, 7 Feb 2025 17:14:52 +0100 Subject: [PATCH 58/82] Remove commented out code that I forgot to delete last commit --- .../rub/nds/modifiablevariable/ModifiableVariable.java | 9 --------- 1 file changed, 9 deletions(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java index 357079a4..6a4ed200 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -191,15 +191,6 @@ public abstract class ModifiableVariable implements Serializable { private Boolean createRandomModification; - // @XmlElements({ - // @XmlElement(type = byte[].class), - // @XmlElement(type = String.class), - // @XmlElement(type = Boolean.class), - // @XmlElement(type = Byte.class), - // @XmlElement(type = Integer.class), - // @XmlElement(type = Long.class), - // @XmlElement(type = BigInteger.class) - // }) protected E assertEquals; protected ModifiableVariable() { From 7b3e5440783557bcfe7e06a41f67feffe262d2c8 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Fri, 21 Feb 2025 12:42:15 +0100 Subject: [PATCH 59/82] Add removed functions to ArrayConverter, so that projects that relay on them can still use the old names. --- .../nds/modifiablevariable/util/ArrayConverter.java | 12 ++++++++++++ 1 file changed, 12 insertions(+) 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 14aea1b7..b3e98861 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/ArrayConverter.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/ArrayConverter.java @@ -51,6 +51,18 @@ public static byte[] longToSixBytes(long value) { return output; } + public static byte[] longToUint64Bytes(long value) { + return longToEightBytes(value); + } + + public static byte[] longToUint48Bytes(long value) { + return longToSixBytes(value); + } + + public static byte[] longToUint32Bytes(long value) { + return intToFourBytes((int) value); + } + /** * Takes an int value and converts it to 4 bytes * From febc53d5d30ab511a6cd84530c2a194cdad39b34 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Mon, 24 Feb 2025 14:05:46 +0100 Subject: [PATCH 60/82] Remove setRandomModification() and createRandomModification from all modifiable Variables. Because of https://github.com/tls-attacker/ModifiableVariable/pull/182#discussion_r1967365709 --- .../ModifiableVariable.java | 22 ------ .../ModifiableVariableHolder.java | 2 +- .../biginteger/ModifiableBigInteger.java | 7 -- .../bool/ModifiableBoolean.java | 6 -- .../bytearray/ModifiableByteArray.java | 7 -- .../integer/ModifiableInteger.java | 6 -- .../longint/ModifiableLong.java | 6 -- .../path/ModifiablePath.java | 6 -- .../singlebyte/ModifiableByte.java | 6 -- .../string/ModifiableString.java | 6 -- .../ModifiableVariableTest.java | 76 ------------------- .../biginteger/ModifiableBigIntegerTest.java | 5 -- .../bool/ModifiableBooleanTest.java | 5 -- .../integer/ModifiableIntegerTest.java | 16 ---- .../mlong/ModifiableLongTest.java | 5 -- .../singlebyte/ModifiableByteTest.java | 5 -- 16 files changed, 1 insertion(+), 185 deletions(-) delete mode 100644 src/test/java/de/rub/nds/modifiablevariable/ModifiableVariableTest.java diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java index 6a4ed200..00f4f077 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -189,8 +189,6 @@ public abstract class ModifiableVariable implements Serializable { }) private LinkedList> modifications; - private Boolean createRandomModification; - protected E assertEquals; protected ModifiableVariable() { @@ -205,7 +203,6 @@ protected ModifiableVariable(ModifiableVariable other) { modifications.add(item != null ? item.createCopy() : null); } } - createRandomModification = other.createRandomModification; // Warning: Make sure to copy assertEquals in subclass correctly assertEquals = other.assertEquals; } @@ -249,11 +246,6 @@ public LinkedList> getModifications() { } public E getValue() { - if (Objects.equals(createRandomModification, Boolean.TRUE)) { - setRandomModification(); - createRandomModification = false; - } - return getModifiedValue(); } @@ -286,15 +278,8 @@ public void reduceToOriginalValue(boolean evenWithNullOriginalValue) { public abstract void setOriginalValue(E originalValue); - /** Set a single random modification, all previously set modifications are removed */ - public abstract void setRandomModification(); - public abstract ModifiableVariable createCopy(); - public void createRandomModificationAtRuntime() { - createRandomModification = true; - } - public abstract boolean isOriginalValueModified(); public abstract boolean validateAssertions(); @@ -303,10 +288,6 @@ public boolean containsAssertion() { return assertEquals != null; } - public Boolean isCreateRandomModification() { - return Objects.requireNonNullElse(createRandomModification, false); - } - public String innerToString() { StringBuilder result = new StringBuilder(); if (modifications != null) { @@ -318,9 +299,6 @@ public String innerToString() { .append("]"); } - if (createRandomModification != null) { - result.append(", createRandomModification=").append(createRandomModification); - } if (assertEquals != null) { result.append(", assertEquals=").append(assertEquals); } diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableHolder.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableHolder.java index 73bc4928..d61c5c5f 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableHolder.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableHolder.java @@ -81,7 +81,7 @@ public void reset() { LOGGER.debug(ex); } if (mv != null) { - if (mv.getModification() != null || mv.isCreateRandomModification()) { + if (mv.getModification() != null) { mv.setOriginalValue(null); } else { try { 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 be6c11c7..eba8591e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigInteger.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigInteger.java @@ -37,13 +37,6 @@ public ModifiableBigInteger createCopy() { return new ModifiableBigInteger(this); } - @Override - public void setRandomModification() { - VariableModification vm = - BigIntegerModificationFactory.createRandomModification(); - setModification(vm); - } - public BigInteger getAssertEquals() { return assertEquals; } 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 e0440aee..681bf675 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/ModifiableBoolean.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/ModifiableBoolean.java @@ -45,12 +45,6 @@ public void setOriginalValue(Boolean originalValue) { this.originalValue = originalValue; } - @Override - public void setRandomModification() { - VariableModification vm = BooleanModificationFactory.createRandomModification(); - setModification(vm); - } - @Override public boolean isOriginalValueModified() { return originalValue != null && originalValue.compareTo(getValue()) != 0; 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 9601e69e..e8bec9f0 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArray.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArray.java @@ -43,13 +43,6 @@ public ModifiableByteArray createCopy() { return new ModifiableByteArray(this); } - @Override - public void setRandomModification() { - VariableModification vm = - ByteArrayModificationFactory.createRandomModification(originalValue); - setModification(vm); - } - @Override @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) public byte[] getOriginalValue() { 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 8aa26aff..c6047352 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/ModifiableInteger.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/ModifiableInteger.java @@ -36,12 +36,6 @@ public ModifiableInteger createCopy() { return new ModifiableInteger(this); } - @Override - public void setRandomModification() { - VariableModification vm = IntegerModificationFactory.createRandomModification(); - setModification(vm); - } - public Integer getAssertEquals() { return assertEquals; } 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 f763257b..556d10d0 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/ModifiableLong.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/ModifiableLong.java @@ -36,12 +36,6 @@ public ModifiableLong createCopy() { return new ModifiableLong(this); } - @Override - public void setRandomModification() { - VariableModification vm = LongModificationFactory.createRandomModification(); - setModification(vm); - } - public Long getAssertEquals() { return assertEquals; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java b/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java index 6745f895..7833234f 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java @@ -36,12 +36,6 @@ public ModifiablePath createCopy() { return new ModifiablePath(this); } - @Override - public void setRandomModification() { - VariableModification vm = PathModificationFactory.createRandomModification(null); - setModification(vm); - } - @Override public String toString() { return "ModifiablePath{" 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 d86500e9..cbad24ab 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByte.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByte.java @@ -35,12 +35,6 @@ public ModifiableByte createCopy() { return new ModifiableByte(this); } - @Override - public void setRandomModification() { - VariableModification vm = ByteModificationFactory.createRandomModification(); - setModification(vm); - } - public Byte getAssertEquals() { return assertEquals; } 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 3f55926f..9539e56e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java @@ -44,12 +44,6 @@ public ModifiableString createCopy() { return new ModifiableString(this); } - @Override - public void setRandomModification() { - VariableModification vm = StringModificationFactory.createRandomModification(null); - setModification(vm); - } - @XmlJavaTypeAdapter(IllegalStringAdapter.class) public String getAssertEquals() { return assertEquals; 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/biginteger/ModifiableBigIntegerTest.java b/src/test/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigIntegerTest.java index 620d291f..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 testSetRandomModification() {} - /** Test of getAssertEquals method, of class ModifiableBigInteger. */ @Disabled("Not yet implemented") @Test 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 994b489c..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 testSetRandomModification() {} - /** Test of isOriginalValueModified method, of class ModifiableBoolean. */ @Disabled("Not yet implemented") @Test 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 adc5360a..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 testSetRandomModification() { - assertNull(integer1.getModification()); - integer1.setRandomModification(); - 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.setRandomModification(); - 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/ModifiableLongTest.java b/src/test/java/de/rub/nds/modifiablevariable/mlong/ModifiableLongTest.java index 7c53baac..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 testSetRandomModification() {} - /** Test of getAssertEquals method, of class ModifiableLong. */ @Disabled("Not yet implemented") @Test 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 0bf0fffb..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 testSetRandomModification() {} - /** Test of getAssertEquals method, of class ModifiableByte. */ @Disabled("Not yet implemented") @Test From 2ff6a93eaaebfff9b7426a5675192abb5306e2c0 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Mon, 24 Feb 2025 14:07:19 +0100 Subject: [PATCH 61/82] change visibility of innerToString to protected --- .../java/de/rub/nds/modifiablevariable/ModifiableVariable.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java index 00f4f077..5df4adc1 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -288,7 +288,7 @@ public boolean containsAssertion() { return assertEquals != null; } - public String innerToString() { + protected String innerToString() { StringBuilder result = new StringBuilder(); if (modifications != null) { result.append(", modifications=[") From 7da0fbab3b14d1a7e2ddc070e27ee2ec60ea91b5 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Mon, 24 Feb 2025 14:34:14 +0100 Subject: [PATCH 62/82] Add setModifications() methods. As suggested by @ic0ns --- .../ModifiableVariable.java | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java index 5df4adc1..f7a1d965 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -19,6 +19,7 @@ import jakarta.xml.bind.annotation.*; import java.io.Serializable; import java.util.LinkedList; +import java.util.List; import java.util.Objects; import java.util.stream.Collectors; @@ -217,6 +218,26 @@ public void setModification(VariableModification modification) { } } + /** Sets multiple modifications, all previously set modifications are removed */ + public void setModifications(List> modifications) { + if (modifications != null) { + this.modifications = new LinkedList<>(modifications); + } else { + this.modifications = null; + } + } + + /** Sets multiple modifications, all previously set modifications are removed */ + @SafeVarargs + public final void setModifications(VariableModification... modifications) { + if (modifications != null) { + this.modifications = new LinkedList<>(List.of(modifications)); + } else { + this.modifications = null; + } + } + + /** Adds a modification to this modifiable variable */ public void addModification(VariableModification modification) { if (modification != null) { From a1b45fba9c3be395034624ab65317bfefb9ef412 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Mon, 24 Feb 2025 14:34:44 +0100 Subject: [PATCH 63/82] run formatter --- .../java/de/rub/nds/modifiablevariable/ModifiableVariable.java | 2 -- .../nds/modifiablevariable/biginteger/ModifiableBigInteger.java | 1 - .../de/rub/nds/modifiablevariable/bool/ModifiableBoolean.java | 1 - .../nds/modifiablevariable/bytearray/ModifiableByteArray.java | 1 - .../rub/nds/modifiablevariable/integer/ModifiableInteger.java | 1 - .../de/rub/nds/modifiablevariable/longint/ModifiableLong.java | 1 - .../java/de/rub/nds/modifiablevariable/path/ModifiablePath.java | 1 - .../rub/nds/modifiablevariable/singlebyte/ModifiableByte.java | 1 - .../de/rub/nds/modifiablevariable/string/ModifiableString.java | 1 - 9 files changed, 10 deletions(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java index f7a1d965..b24cd058 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -20,7 +20,6 @@ import java.io.Serializable; import java.util.LinkedList; import java.util.List; -import java.util.Objects; import java.util.stream.Collectors; /** @@ -237,7 +236,6 @@ public final void setModifications(VariableModification... modifications) { } } - /** Adds a modification to this modifiable variable */ public void addModification(VariableModification modification) { if (modification != null) { 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 eba8591e..85e1d071 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigInteger.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigInteger.java @@ -8,7 +8,6 @@ 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.XmlRootElement; import java.math.BigInteger; 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 681bf675..60bab446 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/ModifiableBoolean.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/ModifiableBoolean.java @@ -8,7 +8,6 @@ package de.rub.nds.modifiablevariable.bool; import de.rub.nds.modifiablevariable.ModifiableVariable; -import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; @XmlRootElement 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 e8bec9f0..f69d18e9 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; 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 c6047352..c2932275 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/ModifiableInteger.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/ModifiableInteger.java @@ -8,7 +8,6 @@ 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.XmlRootElement; 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 556d10d0..8da4f62e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/ModifiableLong.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/ModifiableLong.java @@ -8,7 +8,6 @@ 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.XmlRootElement; diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java b/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java index 7833234f..843076ac 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java @@ -9,7 +9,6 @@ import static de.rub.nds.modifiablevariable.util.StringUtil.backslashEscapeString; -import de.rub.nds.modifiablevariable.VariableModification; import de.rub.nds.modifiablevariable.string.ModifiableString; import jakarta.xml.bind.annotation.XmlAccessType; import jakarta.xml.bind.annotation.XmlAccessorType; 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 cbad24ab..7658df56 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByte.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByte.java @@ -8,7 +8,6 @@ package de.rub.nds.modifiablevariable.singlebyte; import de.rub.nds.modifiablevariable.ModifiableVariable; -import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; @XmlRootElement 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 9539e56e..548f9ef7 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; From f0374cd9ed0df0712fcb2d1d113466ca9ca2a5e9 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Mon, 24 Feb 2025 14:40:34 +0100 Subject: [PATCH 64/82] Rename getModification to getFirstModification. See https://github.com/tls-attacker/ModifiableVariable/pull/182#discussion_r1967363753 --- .../java/de/rub/nds/modifiablevariable/ModifiableVariable.java | 2 +- .../de/rub/nds/modifiablevariable/ModifiableVariableHolder.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java index b24cd058..258cb54e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -252,7 +252,7 @@ public void addModification(VariableModification modification) { *

Use {@code getModifications()} to get all modifications */ @XmlTransient - public VariableModification getModification() { + public VariableModification getFirstModification() { if (modifications == null || modifications.isEmpty()) { return null; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableHolder.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableHolder.java index d61c5c5f..3cb93dd1 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableHolder.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableHolder.java @@ -81,7 +81,7 @@ public void reset() { LOGGER.debug(ex); } if (mv != null) { - if (mv.getModification() != null) { + if (mv.getModifications() != null) { mv.setOriginalValue(null); } else { try { From 1ac420895cadf5c9b3bdd3aa01ff2c4c7deb890a Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Mon, 24 Feb 2025 14:55:56 +0100 Subject: [PATCH 65/82] revert to use Objects.hashCode(...) in hashCode methods instead. --- .../biginteger/BigIntegerAddModification.java | 2 +- .../biginteger/BigIntegerAppendValueModification.java | 2 +- .../biginteger/BigIntegerExplicitValueFromFileModification.java | 2 +- .../biginteger/BigIntegerExplicitValueModification.java | 2 +- .../biginteger/BigIntegerInsertValueModification.java | 2 +- .../biginteger/BigIntegerMultiplyModification.java | 2 +- .../biginteger/BigIntegerPrependValueModification.java | 2 +- .../biginteger/BigIntegerSubtractModification.java | 2 +- .../biginteger/BigIntegerXorModification.java | 2 +- .../integer/IntegerExplicitValueFromFileModification.java | 2 +- .../rub/nds/modifiablevariable/longint/LongAddModification.java | 2 +- .../modifiablevariable/longint/LongAppendValueModification.java | 2 +- .../longint/LongExplicitValueFromFileModification.java | 2 +- .../longint/LongExplicitValueModification.java | 2 +- .../modifiablevariable/longint/LongInsertValueModification.java | 2 +- .../modifiablevariable/longint/LongMultiplyModification.java | 2 +- .../longint/LongPrependValueModification.java | 2 +- .../modifiablevariable/longint/LongSubtractModification.java | 2 +- .../rub/nds/modifiablevariable/longint/LongXorModification.java | 2 +- .../modifiablevariable/path/PathAppendValueModification.java | 2 +- .../path/PathExplicitValueFromFileModification.java | 2 +- .../modifiablevariable/path/PathExplicitValueModification.java | 2 +- .../modifiablevariable/path/PathInsertValueModification.java | 2 +- .../modifiablevariable/path/PathPrependValueModification.java | 2 +- .../singlebyte/ByteExplicitValueFromFileModification.java | 2 +- .../string/StringAppendValueModification.java | 2 +- .../string/StringExplicitValueFromFileModification.java | 2 +- .../string/StringExplicitValueModification.java | 2 +- .../string/StringInsertValueModification.java | 2 +- .../string/StringPrependValueModification.java | 2 +- 30 files changed, 30 insertions(+), 30 deletions(-) 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 810f9036..959e8bd0 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java @@ -63,7 +63,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + summand.hashCode(); + hash = 31 * hash + Objects.hashCode(summand);; return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java index 61fcfbe0..29c533b2 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java @@ -66,7 +66,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + appendValue.hashCode(); + hash = 31 * hash + Objects.hashCode(appendValue);; return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java index 710afd62..69d81b5a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java @@ -53,7 +53,7 @@ public VariableModification getModifiedCopy() { public int hashCode() { int hash = 7; hash = 31 * hash + index; - hash = 31 * hash + explicitValue.hashCode(); + hash = 31 * hash + Objects.hashCode(explicitValue);; return hash; } 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 05b05889..0914aea0 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java @@ -69,7 +69,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + explicitValue.hashCode(); + hash = 31 * hash + Objects.hashCode(explicitValue);; return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java index 1cc2c5ed..b01e16ac 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java @@ -108,7 +108,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + insertValue.hashCode(); + hash = 31 * hash + Objects.hashCode(insertValue);; hash = 31 * hash + startPosition; return hash; } 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 b34ce279..8f93da18 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java @@ -63,7 +63,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + factor.hashCode(); + hash = 31 * hash + Objects.hashCode(factor);; return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java index a3b9f937..71a63fdf 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java @@ -66,7 +66,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + prependValue.hashCode(); + hash = 31 * hash + Objects.hashCode(prependValue);; return hash; } 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 2fa5d942..332c52ca 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java @@ -66,7 +66,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + subtrahend.hashCode(); + hash = 31 * hash + Objects.hashCode(subtrahend);; return hash; } 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 1653ea50..2b6371ca 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java @@ -65,7 +65,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + xor.hashCode(); + hash = 31 * hash + Objects.hashCode(xor);; return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java index 839c6b48..ac6904da 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java @@ -51,7 +51,7 @@ public VariableModification getModifiedCopy() { public int hashCode() { int hash = 7; hash = 31 * hash + index; - hash = 31 * hash + explicitValue.hashCode(); + hash = 31 * hash + Objects.hashCode(explicitValue);; return hash; } 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 a42604f4..62e510a7 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java @@ -61,7 +61,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + summand.hashCode(); + hash = 31 * hash + Objects.hashCode(summand);; return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java index b6f05442..5f8a2578 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java @@ -65,7 +65,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + appendValue.hashCode(); + hash = 31 * hash + Objects.hashCode(appendValue);; return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java index fcc1fa16..df4109a0 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java @@ -50,7 +50,7 @@ public VariableModification getModifiedCopy() { public int hashCode() { int hash = 7; hash = 31 * hash + index; - hash = 31 * hash + explicitValue.hashCode(); + hash = 31 * hash + Objects.hashCode(explicitValue);; return hash; } 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 a52d08ed..de05bdd5 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java @@ -68,7 +68,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + explicitValue.hashCode(); + hash = 31 * hash + Objects.hashCode(explicitValue);; return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java index 3eb30715..cbe98623 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java @@ -103,7 +103,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + insertValue.hashCode(); + hash = 31 * hash + Objects.hashCode(insertValue);; hash = 31 * hash + startPosition; return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java index 180f96b3..6ef6dd76 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java @@ -61,7 +61,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + factor.hashCode(); + hash = 31 * hash + Objects.hashCode(factor);; return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java index 484d710c..1d150325 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java @@ -65,7 +65,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + prependValue.hashCode(); + hash = 31 * hash + Objects.hashCode(prependValue);; return hash; } 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 2f04ac48..f546ba82 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java @@ -62,7 +62,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + subtrahend.hashCode(); + hash = 31 * hash + Objects.hashCode(subtrahend);; return hash; } 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 9407bed8..5dc6e127 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java @@ -66,7 +66,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + xor.hashCode(); + hash = 31 * hash + Objects.hashCode(xor);; return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java index 1a806de9..bcad2191 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java @@ -78,7 +78,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + appendValue.hashCode(); + hash = 31 * hash + Objects.hashCode(appendValue);; return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java index 4955b06d..c9455693 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java @@ -52,7 +52,7 @@ public VariableModification getModifiedCopy() { public int hashCode() { int hash = 7; hash = 31 * hash + index; - hash = 31 * hash + explicitValue.hashCode(); + hash = 31 * hash + Objects.hashCode(explicitValue);; return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java index d5ea0b6c..57a50518 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java @@ -74,7 +74,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + explicitValue.hashCode(); + hash = 31 * hash + Objects.hashCode(explicitValue);; return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java index 60ab6dc5..2a84a84b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java @@ -99,7 +99,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + insertValue.hashCode(); + hash = 31 * hash + Objects.hashCode(insertValue);; hash = 31 * hash + startPosition; return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java index e56f147f..40e2f83b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java @@ -78,7 +78,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + prependValue.hashCode(); + hash = 31 * hash + Objects.hashCode(prependValue);; return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java index fc531181..a3121c19 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java @@ -50,7 +50,7 @@ public VariableModification getModifiedCopy() { public int hashCode() { int hash = 7; hash = 31 * hash + index; - hash = 31 * hash + explicitValue.hashCode(); + hash = 31 * hash + Objects.hashCode(explicitValue);; return hash; } 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 d5cd99be..3dc72937 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java @@ -72,7 +72,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + appendValue.hashCode(); + hash = 31 * hash + Objects.hashCode(appendValue);; return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java index 6d65c583..7b6f97e3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java @@ -52,7 +52,7 @@ public VariableModification getModifiedCopy() { public int hashCode() { int hash = 7; hash = 31 * hash + index; - hash = 31 * hash + explicitValue.hashCode(); + hash = 31 * hash + Objects.hashCode(explicitValue);; return hash; } 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 f2f9bdd2..96e7f2be 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java @@ -75,7 +75,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + explicitValue.hashCode(); + hash = 31 * hash + Objects.hashCode(explicitValue);; return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java index 595d92db..0c41ec09 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java @@ -108,7 +108,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + insertValue.hashCode(); + hash = 31 * hash + Objects.hashCode(insertValue);; hash = 31 * hash + startPosition; return hash; } 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 ef96848c..d6888111 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java @@ -72,7 +72,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + prependValue.hashCode(); + hash = 31 * hash + Objects.hashCode(prependValue);; return hash; } From b52a6e15ad646b03baa5f8a667350dd057fc37fb Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Mon, 24 Feb 2025 14:57:37 +0100 Subject: [PATCH 66/82] run formatter --- .../biginteger/BigIntegerAddModification.java | 2 +- .../biginteger/BigIntegerAppendValueModification.java | 2 +- .../biginteger/BigIntegerExplicitValueFromFileModification.java | 2 +- .../biginteger/BigIntegerExplicitValueModification.java | 2 +- .../biginteger/BigIntegerInsertValueModification.java | 2 +- .../biginteger/BigIntegerMultiplyModification.java | 2 +- .../biginteger/BigIntegerPrependValueModification.java | 2 +- .../biginteger/BigIntegerSubtractModification.java | 2 +- .../biginteger/BigIntegerXorModification.java | 2 +- .../integer/IntegerExplicitValueFromFileModification.java | 2 +- .../rub/nds/modifiablevariable/longint/LongAddModification.java | 2 +- .../modifiablevariable/longint/LongAppendValueModification.java | 2 +- .../longint/LongExplicitValueFromFileModification.java | 2 +- .../longint/LongExplicitValueModification.java | 2 +- .../modifiablevariable/longint/LongInsertValueModification.java | 2 +- .../modifiablevariable/longint/LongMultiplyModification.java | 2 +- .../longint/LongPrependValueModification.java | 2 +- .../modifiablevariable/longint/LongSubtractModification.java | 2 +- .../rub/nds/modifiablevariable/longint/LongXorModification.java | 2 +- .../modifiablevariable/path/PathAppendValueModification.java | 2 +- .../path/PathExplicitValueFromFileModification.java | 2 +- .../modifiablevariable/path/PathExplicitValueModification.java | 2 +- .../modifiablevariable/path/PathInsertValueModification.java | 2 +- .../modifiablevariable/path/PathPrependValueModification.java | 2 +- .../singlebyte/ByteExplicitValueFromFileModification.java | 2 +- .../string/StringAppendValueModification.java | 2 +- .../string/StringExplicitValueFromFileModification.java | 2 +- .../string/StringExplicitValueModification.java | 2 +- .../string/StringInsertValueModification.java | 2 +- .../string/StringPrependValueModification.java | 2 +- 30 files changed, 30 insertions(+), 30 deletions(-) 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 959e8bd0..3e998207 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java @@ -63,7 +63,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + Objects.hashCode(summand);; + hash = 31 * hash + Objects.hashCode(summand); return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java index 29c533b2..2b8297b1 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java @@ -66,7 +66,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + Objects.hashCode(appendValue);; + hash = 31 * hash + Objects.hashCode(appendValue); return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java index 69d81b5a..9cc6008f 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java @@ -53,7 +53,7 @@ public VariableModification getModifiedCopy() { public int hashCode() { int hash = 7; hash = 31 * hash + index; - hash = 31 * hash + Objects.hashCode(explicitValue);; + hash = 31 * hash + Objects.hashCode(explicitValue); return hash; } 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 0914aea0..a716def0 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java @@ -69,7 +69,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + Objects.hashCode(explicitValue);; + hash = 31 * hash + Objects.hashCode(explicitValue); return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java index b01e16ac..d354d25e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java @@ -108,7 +108,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + Objects.hashCode(insertValue);; + hash = 31 * hash + Objects.hashCode(insertValue); hash = 31 * hash + startPosition; return hash; } 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 8f93da18..e481e2ec 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java @@ -63,7 +63,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + Objects.hashCode(factor);; + hash = 31 * hash + Objects.hashCode(factor); return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java index 71a63fdf..89078708 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java @@ -66,7 +66,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + Objects.hashCode(prependValue);; + hash = 31 * hash + Objects.hashCode(prependValue); return hash; } 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 332c52ca..ac8d26b0 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java @@ -66,7 +66,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + Objects.hashCode(subtrahend);; + hash = 31 * hash + Objects.hashCode(subtrahend); return hash; } 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 2b6371ca..be07db5c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java @@ -65,7 +65,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + Objects.hashCode(xor);; + hash = 31 * hash + Objects.hashCode(xor); return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java index ac6904da..4486bf0f 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java @@ -51,7 +51,7 @@ public VariableModification getModifiedCopy() { public int hashCode() { int hash = 7; hash = 31 * hash + index; - hash = 31 * hash + Objects.hashCode(explicitValue);; + hash = 31 * hash + Objects.hashCode(explicitValue); return hash; } 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 62e510a7..6096a81a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java @@ -61,7 +61,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + Objects.hashCode(summand);; + hash = 31 * hash + Objects.hashCode(summand); return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java index 5f8a2578..6bb5b682 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java @@ -65,7 +65,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + Objects.hashCode(appendValue);; + hash = 31 * hash + Objects.hashCode(appendValue); return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java index df4109a0..14cf58b9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java @@ -50,7 +50,7 @@ public VariableModification getModifiedCopy() { public int hashCode() { int hash = 7; hash = 31 * hash + index; - hash = 31 * hash + Objects.hashCode(explicitValue);; + hash = 31 * hash + Objects.hashCode(explicitValue); return hash; } 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 de05bdd5..4a10a5df 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java @@ -68,7 +68,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + Objects.hashCode(explicitValue);; + hash = 31 * hash + Objects.hashCode(explicitValue); return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java index cbe98623..bc0caf0c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java @@ -103,7 +103,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + Objects.hashCode(insertValue);; + hash = 31 * hash + Objects.hashCode(insertValue); hash = 31 * hash + startPosition; return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java index 6ef6dd76..79434b91 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java @@ -61,7 +61,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + Objects.hashCode(factor);; + hash = 31 * hash + Objects.hashCode(factor); return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java index 1d150325..366cb6e6 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java @@ -65,7 +65,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + Objects.hashCode(prependValue);; + hash = 31 * hash + Objects.hashCode(prependValue); return hash; } 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 f546ba82..b161b12c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java @@ -62,7 +62,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + Objects.hashCode(subtrahend);; + hash = 31 * hash + Objects.hashCode(subtrahend); return hash; } 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 5dc6e127..8b82adc4 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java @@ -66,7 +66,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + Objects.hashCode(xor);; + hash = 31 * hash + Objects.hashCode(xor); return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java index bcad2191..ec3fc569 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java @@ -78,7 +78,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + Objects.hashCode(appendValue);; + hash = 31 * hash + Objects.hashCode(appendValue); return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java index c9455693..6627f5d6 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java @@ -52,7 +52,7 @@ public VariableModification getModifiedCopy() { public int hashCode() { int hash = 7; hash = 31 * hash + index; - hash = 31 * hash + Objects.hashCode(explicitValue);; + hash = 31 * hash + Objects.hashCode(explicitValue); return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java index 57a50518..6bce03b2 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java @@ -74,7 +74,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + Objects.hashCode(explicitValue);; + hash = 31 * hash + Objects.hashCode(explicitValue); return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java index 2a84a84b..7b85cedf 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java @@ -99,7 +99,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + Objects.hashCode(insertValue);; + hash = 31 * hash + Objects.hashCode(insertValue); hash = 31 * hash + startPosition; return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java index 40e2f83b..e3505bc6 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java @@ -78,7 +78,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + Objects.hashCode(prependValue);; + hash = 31 * hash + Objects.hashCode(prependValue); return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java index a3121c19..739405a4 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java @@ -50,7 +50,7 @@ public VariableModification getModifiedCopy() { public int hashCode() { int hash = 7; hash = 31 * hash + index; - hash = 31 * hash + Objects.hashCode(explicitValue);; + hash = 31 * hash + Objects.hashCode(explicitValue); return hash; } 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 3dc72937..424ebeb5 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java @@ -72,7 +72,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + Objects.hashCode(appendValue);; + hash = 31 * hash + Objects.hashCode(appendValue); return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java index 7b6f97e3..a2ecebfc 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java @@ -52,7 +52,7 @@ public VariableModification getModifiedCopy() { public int hashCode() { int hash = 7; hash = 31 * hash + index; - hash = 31 * hash + Objects.hashCode(explicitValue);; + hash = 31 * hash + Objects.hashCode(explicitValue); return hash; } 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 96e7f2be..f4d927d2 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java @@ -75,7 +75,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + Objects.hashCode(explicitValue);; + hash = 31 * hash + Objects.hashCode(explicitValue); return hash; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java index 0c41ec09..628ae55a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java @@ -108,7 +108,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + Objects.hashCode(insertValue);; + hash = 31 * hash + Objects.hashCode(insertValue); hash = 31 * hash + startPosition; return hash; } 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 d6888111..e144dfc6 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java @@ -72,7 +72,7 @@ public VariableModification getModifiedCopy() { @Override public int hashCode() { int hash = 7; - hash = 31 * hash + Objects.hashCode(prependValue);; + hash = 31 * hash + Objects.hashCode(prependValue); return hash; } From 3f8d6c333ea03b43b2c2b1028964e1c1b58f0b13 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Mon, 24 Feb 2025 15:04:07 +0100 Subject: [PATCH 67/82] Remove getModifiedCopy() See https://github.com/tls-attacker/ModifiableVariable/pull/182#discussion_r1967394825 --- .../VariableModification.java | 2 -- .../biginteger/BigIntegerAddModification.java | 7 ----- .../BigIntegerAppendValueModification.java | 7 ----- ...egerExplicitValueFromFileModification.java | 7 ----- .../BigIntegerExplicitValueModification.java | 13 --------- .../BigIntegerInsertValueModification.java | 21 -------------- .../BigIntegerInteractiveModification.java | 6 ---- .../BigIntegerMultiplyModification.java | 7 ----- .../BigIntegerPrependValueModification.java | 7 ----- .../BigIntegerShiftLeftModification.java | 6 ---- .../BigIntegerShiftRightModification.java | 6 ---- .../BigIntegerSubtractModification.java | 7 ----- .../biginteger/BigIntegerXorModification.java | 6 ---- .../BooleanExplicitValueModification.java | 5 ---- .../bool/BooleanToggleModification.java | 5 ---- .../ByteArrayAppendValueModification.java | 11 -------- .../ByteArrayDeleteModification.java | 23 --------------- .../ByteArrayDuplicateModification.java | 5 ---- ...rrayExplicitValueFromFileModification.java | 7 ----- .../ByteArrayExplicitValueModification.java | 13 --------- .../ByteArrayInsertValueModification.java | 24 ---------------- .../ByteArrayPrependValueModification.java | 11 -------- .../ByteArrayShuffleModification.java | 10 ------- .../bytearray/ByteArrayXorModification.java | 23 --------------- .../integer/IntegerAddModification.java | 6 ---- .../IntegerAppendValueModification.java | 7 ----- ...egerExplicitValueFromFileModification.java | 7 ----- .../IntegerExplicitValueModification.java | 13 --------- .../IntegerInsertValueModification.java | 21 -------------- .../integer/IntegerMultiplyModification.java | 8 ------ .../IntegerPrependValueModification.java | 7 ----- .../integer/IntegerShiftLeftModification.java | 18 ------------ .../IntegerShiftRightModification.java | 18 ------------ .../integer/IntegerSubtractModification.java | 7 ----- .../IntegerSwapEndianModification.java | 5 ---- .../integer/IntegerXorModification.java | 11 -------- .../longint/LongAddModification.java | 6 ---- .../longint/LongAppendValueModification.java | 7 ----- ...LongExplicitValueFromFileModification.java | 7 ----- .../LongExplicitValueModification.java | 13 --------- .../longint/LongInsertValueModification.java | 21 -------------- .../longint/LongMultiplyModification.java | 6 ---- .../longint/LongPrependValueModification.java | 7 ----- .../longint/LongShiftLeftModification.java | 19 ------------- .../longint/LongShiftRightModification.java | 19 ------------- .../longint/LongSubtractModification.java | 7 ----- .../longint/LongSwapEndianModification.java | 5 ---- .../longint/LongXorModification.java | 11 -------- .../path/PathAppendValueModification.java | 11 -------- .../path/PathDeleteModification.java | 28 ------------------- ...PathExplicitValueFromFileModification.java | 7 ----- .../path/PathExplicitValueModification.java | 14 ---------- ...hInsertDirectorySeparatorModification.java | 28 ------------------- ...hInsertDirectoryTraversalModification.java | 28 ------------------- .../path/PathInsertValueModification.java | 24 ---------------- .../path/PathPrependValueModification.java | 11 -------- .../path/PathToggleRootModification.java | 5 ---- .../singlebyte/ByteAddModification.java | 6 ---- ...ByteExplicitValueFromFileModification.java | 7 ----- .../ByteExplicitValueModification.java | 13 --------- .../singlebyte/ByteSubtractModification.java | 7 ----- .../singlebyte/ByteXorModification.java | 11 -------- .../string/StringAppendValueModification.java | 11 -------- .../string/StringDeleteModification.java | 28 ------------------- ...ringExplicitValueFromFileModification.java | 7 ----- .../StringExplicitValueModification.java | 14 ---------- .../string/StringInsertValueModification.java | 24 ---------------- .../StringPrependValueModification.java | 11 -------- .../BigIntegerAddModificationTest.java | 6 ---- ...gIntegerExplicitValueModificationTest.java | 5 ---- .../BigIntegerOperationConcatenationTest.java | 5 ---- .../BigIntegerSubtractModificationTest.java | 5 ---- .../BigIntegerXorModificationTest.java | 5 ---- .../BooleanExplicitValueModificationTest.java | 6 ---- .../ByteArrayDeleteModificationTest.java | 6 ---- 75 files changed, 828 deletions(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java b/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java index b7d6d14d..fc290d17 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java @@ -57,8 +57,6 @@ public E modify(E input) { protected abstract E modifyImplementationHook(E input); - public abstract VariableModification getModifiedCopy(); - /** * Debugging modified variables. Getting stack trace can be time-consuming, thus we use * isDebugEnabled() function 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 3e998207..f6c264a5 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java @@ -12,7 +12,6 @@ import jakarta.xml.bind.annotation.XmlType; import java.math.BigInteger; import java.util.Objects; -import java.util.Random; @XmlRootElement @XmlType(propOrder = {"summand", "modificationFilter"}) @@ -54,12 +53,6 @@ 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; diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java index 2b8297b1..398e4e8c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java @@ -12,7 +12,6 @@ import jakarta.xml.bind.annotation.XmlType; import java.math.BigInteger; import java.util.Objects; -import java.util.Random; @XmlRootElement @XmlType(propOrder = {"appendValue", "modificationFilter"}) @@ -57,12 +56,6 @@ public void setAppendValue(BigInteger appendValue) { this.appendValue = appendValue; } - @Override - public VariableModification getModifiedCopy() { - return new BigIntegerAppendValueModification( - appendValue.add(new BigInteger(MAX_APPEND_LENGTH, new Random()))); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java index 9cc6008f..452e7cee 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java @@ -7,7 +7,6 @@ */ package de.rub.nds.modifiablevariable.biginteger; -import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; import jakarta.xml.bind.annotation.XmlType; import java.math.BigInteger; @@ -43,12 +42,6 @@ public int getIndex() { return index; } - @Override - public VariableModification getModifiedCopy() { - throw new UnsupportedOperationException( - "Cannot set modify Value of BigIntegerExplicitValueFromFileModification"); - } - @Override public int hashCode() { int hash = 7; 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 a716def0..1d6fbca8 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java @@ -12,7 +12,6 @@ import jakarta.xml.bind.annotation.XmlType; import java.math.BigInteger; import java.util.Objects; -import java.util.Random; @XmlRootElement @XmlType(propOrder = {"explicitValue", "modificationFilter"}) @@ -54,18 +53,6 @@ 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 = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java index d354d25e..18ff784b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java @@ -12,7 +12,6 @@ import jakarta.xml.bind.annotation.XmlType; import java.math.BigInteger; import java.util.Objects; -import java.util.Random; @XmlRootElement @XmlType(propOrder = {"insertValue", "startPosition", "modificationFilter"}) @@ -85,26 +84,6 @@ public void setStartPosition(int startPosition) { this.startPosition = startPosition; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - - if (r.nextBoolean()) { - return new BigIntegerInsertValueModification( - insertValue.add(new BigInteger(MAX_INSERT_LENGTH, r)), startPosition); - } else { - int modifier = r.nextInt(MAX_POSITION_MODIFIER); - if (r.nextBoolean()) { - modifier *= -1; - } - modifier = startPosition + modifier; - if (modifier <= 0) { - modifier = 1; - } - return new BigIntegerInsertValueModification(insertValue, modifier); - } - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInteractiveModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInteractiveModification.java index 83fe29ff..c38e18ac 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInteractiveModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInteractiveModification.java @@ -39,12 +39,6 @@ public interface InteractiveBigIntegerModification { BigInteger modify(BigInteger oldVal); } - @Override - public VariableModification getModifiedCopy() { - throw new UnsupportedOperationException( - "This method is not supported for interactive modifications"); - } - @Override public VariableModification createCopy() { throw new UnsupportedOperationException( 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 e481e2ec..2685b081 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java @@ -12,7 +12,6 @@ import jakarta.xml.bind.annotation.XmlType; import java.math.BigInteger; import java.util.Objects; -import java.util.Random; @XmlRootElement @XmlType(propOrder = {"factor", "modificationFilter"}) @@ -54,12 +53,6 @@ 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 = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java index 89078708..4be9f595 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java @@ -12,7 +12,6 @@ import jakarta.xml.bind.annotation.XmlType; import java.math.BigInteger; import java.util.Objects; -import java.util.Random; @XmlRootElement @XmlType(propOrder = {"prependValue", "modificationFilter"}) @@ -57,12 +56,6 @@ public void setPrependValue(BigInteger prependValue) { this.prependValue = prependValue; } - @Override - public VariableModification getModifiedCopy() { - return new BigIntegerPrependValueModification( - prependValue.add(new BigInteger(MAX_PREPEND_LENGTH, new Random()))); - } - @Override public int hashCode() { int hash = 7; 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 733d831d..847943b7 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java @@ -11,7 +11,6 @@ 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"}) @@ -56,11 +55,6 @@ 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; 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 bdb9bb6a..f1a434cc 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java @@ -11,7 +11,6 @@ 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"}) @@ -56,11 +55,6 @@ 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; 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 ac8d26b0..29369078 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java @@ -12,7 +12,6 @@ import jakarta.xml.bind.annotation.XmlType; import java.math.BigInteger; import java.util.Objects; -import java.util.Random; @XmlRootElement @XmlType(propOrder = {"subtrahend", "modificationFilter"}) @@ -57,12 +56,6 @@ 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 = 7; 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 be07db5c..fe00b598 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java @@ -12,7 +12,6 @@ import jakarta.xml.bind.annotation.XmlType; import java.math.BigInteger; import java.util.Objects; -import java.util.Random; @XmlRootElement @XmlType(propOrder = {"xor", "modificationFilter"}) @@ -57,11 +56,6 @@ 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; 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 123d95f4..f24c5f67 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanExplicitValueModification.java @@ -49,11 +49,6 @@ public void setExplicitValue(boolean explicitValue) { this.explicitValue = explicitValue; } - @Override - public VariableModification getModifiedCopy() { - return new BooleanExplicitValueModification(!explicitValue); - } - @Override public int hashCode() { int hash = 7; 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 34ad7608..b53b8036 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanToggleModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanToggleModification.java @@ -36,11 +36,6 @@ protected Boolean modifyImplementationHook(Boolean input) { return !input; } - @Override - public VariableModification getModifiedCopy() { - return new BooleanToggleModification(); - } - @Override public int hashCode() { return 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java index 941a83a3..7142652d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java @@ -14,7 +14,6 @@ import jakarta.xml.bind.annotation.XmlType; import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.util.Arrays; -import java.util.Random; @XmlRootElement @XmlType(propOrder = {"bytesToAppend", "modificationFilter"}) @@ -61,16 +60,6 @@ public void setBytesToAppend(byte[] bytesToAppend) { this.bytesToAppend = bytesToAppend; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - - int index = r.nextInt(bytesToAppend.length); - byte[] newValue = Arrays.copyOf(bytesToAppend, bytesToAppend.length); - newValue[index] = (byte) r.nextInt(MAX_EXPLICIT_VALUE); - return new ByteArrayAppendValueModification(newValue); - } - @Override public int hashCode() { int hash = 7; 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 7659a294..3762618e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java @@ -12,7 +12,6 @@ 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"}) @@ -90,28 +89,6 @@ 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; 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 e9f74b34..6fc82563 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDuplicateModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDuplicateModification.java @@ -37,11 +37,6 @@ protected byte[] modifyImplementationHook(byte[] input) { return ArrayConverter.concatenate(input, input); } - @Override - public VariableModification getModifiedCopy() { - return new ByteArrayDuplicateModification(); - } - @Override public int hashCode() { return 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueFromFileModification.java index c4d07509..083705b8 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueFromFileModification.java @@ -7,7 +7,6 @@ */ package de.rub.nds.modifiablevariable.bytearray; -import de.rub.nds.modifiablevariable.VariableModification; import de.rub.nds.modifiablevariable.util.ArrayConverter; import jakarta.xml.bind.annotation.XmlRootElement; import jakarta.xml.bind.annotation.XmlType; @@ -42,12 +41,6 @@ public int getIndex() { return index; } - @Override - public VariableModification getModifiedCopy() { - throw new UnsupportedOperationException( - "Cannot set modify Value of ByteArrayExplicitValueFromFileModification"); - } - @Override public int hashCode() { int hash = 7; 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 90465721..9f79ff34 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java @@ -14,7 +14,6 @@ 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"}) @@ -65,18 +64,6 @@ 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 = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java index be7be1b9..46a3e910 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java @@ -14,7 +14,6 @@ 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"}) @@ -86,29 +85,6 @@ 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 ByteArrayInsertValueModification(newValue, startPosition); - } else { - byte[] newValue = Arrays.copyOf(bytesToInsert, bytesToInsert.length); - int modifier = r.nextInt(MAX_POSITION_MODIFIER); - if (r.nextBoolean()) { - modifier *= -1; - } - modifier = startPosition + modifier; - if (modifier <= 0) { - modifier = 1; - } - return new ByteArrayInsertValueModification(newValue, modifier); - } - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java index 3bf46387..00f6f77e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java @@ -14,7 +14,6 @@ import jakarta.xml.bind.annotation.XmlType; import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.util.Arrays; -import java.util.Random; @XmlRootElement @XmlType(propOrder = {"bytesToPrepend", "modificationFilter"}) @@ -61,16 +60,6 @@ public void setBytesToPrepend(byte[] bytesToPrepend) { this.bytesToPrepend = bytesToPrepend; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - - int index = r.nextInt(bytesToPrepend.length); - byte[] newValue = Arrays.copyOf(bytesToPrepend, bytesToPrepend.length); - newValue[index] = (byte) r.nextInt(MAX_EXPLICIT_VALUE); - return new ByteArrayPrependValueModification(newValue); - } - @Override public int hashCode() { int hash = 7; 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 18521520..ae1a9fda 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayShuffleModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayShuffleModification.java @@ -14,7 +14,6 @@ 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 @@ -84,15 +83,6 @@ 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(newValue); - } - @Override public int hashCode() { int hash = 7; 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 60b2df2b..75ea45eb 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java @@ -14,7 +14,6 @@ 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"}) @@ -96,28 +95,6 @@ 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; 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 d0e24a60..089f64e9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAddModification.java @@ -11,7 +11,6 @@ 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"}) @@ -53,11 +52,6 @@ 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 = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java index 1f4729ab..e16c7126 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java @@ -11,7 +11,6 @@ import jakarta.xml.bind.annotation.XmlRootElement; import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; -import java.util.Random; @XmlRootElement @XmlType(propOrder = {"appendValue", "modificationFilter"}) @@ -56,12 +55,6 @@ public void setAppendValue(Integer appendValue) { this.appendValue = appendValue; } - @Override - public VariableModification getModifiedCopy() { - return new IntegerAppendValueModification( - appendValue + new Random().nextInt(MAX_VALUE_MODIFIER)); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java index 4486bf0f..b253e898 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java @@ -7,7 +7,6 @@ */ package de.rub.nds.modifiablevariable.integer; -import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @@ -41,12 +40,6 @@ public int getIndex() { return index; } - @Override - public VariableModification getModifiedCopy() { - throw new UnsupportedOperationException( - "Cannot set modify Value of IntegerExplicitValueFromFileModification"); - } - @Override public int hashCode() { int hash = 7; 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 10d5e6f1..8bd0d7f3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueModification.java @@ -11,7 +11,6 @@ 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"}) @@ -53,18 +52,6 @@ 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; diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java index 2473144b..a609e5db 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java @@ -11,7 +11,6 @@ import jakarta.xml.bind.annotation.XmlRootElement; import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; -import java.util.Random; @XmlRootElement @XmlType(propOrder = {"insertValue", "startPosition", "modificationFilter"}) @@ -82,26 +81,6 @@ public void setStartPosition(int startPosition) { this.startPosition = startPosition; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - - if (r.nextBoolean()) { - return new IntegerInsertValueModification( - insertValue + r.nextInt(MAX_VALUE_MODIFIER), startPosition); - } else { - int modifier = r.nextInt(MAX_POSITION_MODIFIER); - if (r.nextBoolean()) { - modifier *= -1; - } - modifier = startPosition + modifier; - if (modifier <= 0) { - modifier = 1; - } - return new IntegerInsertValueModification(insertValue, modifier); - } - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java index 0f441bba..cada7c93 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java @@ -11,7 +11,6 @@ import jakarta.xml.bind.annotation.XmlRootElement; import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; -import java.util.Random; @XmlRootElement @XmlType(propOrder = {"factor", "modificationFilter"}) @@ -53,13 +52,6 @@ public void setFactor(Integer factor) { this.factor = factor; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - - return new IntegerMultiplyModification(factor + r.nextInt(MAX_FACTOR_MODIFIER)); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java index ddbf3676..9f2bd7d2 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java @@ -11,7 +11,6 @@ import jakarta.xml.bind.annotation.XmlRootElement; import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; -import java.util.Random; @XmlRootElement @XmlType(propOrder = {"prependValue", "modificationFilter"}) @@ -57,12 +56,6 @@ public void setPrependValue(Integer prependValue) { this.prependValue = prependValue; } - @Override - public VariableModification getModifiedCopy() { - return new IntegerPrependValueModification( - prependValue + new Random().nextInt(MAX_VALUE_MODIFIER)); - } - @Override public int hashCode() { int hash = 7; 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 7c6aced5..9525ed2f 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftLeftModification.java @@ -10,7 +10,6 @@ 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"}) @@ -52,23 +51,6 @@ 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; 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 bb25bd2b..bbe167a6 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftRightModification.java @@ -10,7 +10,6 @@ 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"}) @@ -52,23 +51,6 @@ 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 = 7; 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 3586d55c..42a49aac 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSubtractModification.java @@ -11,7 +11,6 @@ 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"}) @@ -53,12 +52,6 @@ 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; diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSwapEndianModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSwapEndianModification.java index 601b9abd..6ec89c1b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSwapEndianModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSwapEndianModification.java @@ -36,11 +36,6 @@ protected Integer modifyImplementationHook(Integer input) { return Integer.reverseBytes(input); } - @Override - public VariableModification getModifiedCopy() { - return new IntegerSwapEndianModification(); - } - @Override public int hashCode() { return 7; 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 d33f6fc3..1efa2150 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerXorModification.java @@ -11,7 +11,6 @@ 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"}) @@ -53,16 +52,6 @@ public void setXor(Integer xor) { this.xor = xor; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - if (r.nextBoolean()) { - return new IntegerXorModification(xor + new Random().nextInt(MAX_VALUE_MODIFIER)); - } else { - return new IntegerXorModification(xor - new Random().nextInt(MAX_VALUE_MODIFIER)); - } - } - @Override public int hashCode() { int hash = 7; 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 6096a81a..bf305588 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java @@ -11,7 +11,6 @@ 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"}) @@ -53,11 +52,6 @@ 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; diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java index 6bb5b682..54b0cae7 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java @@ -11,7 +11,6 @@ import jakarta.xml.bind.annotation.XmlRootElement; import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; -import java.util.Random; @XmlRootElement @XmlType(propOrder = {"appendValue", "modificationFilter"}) @@ -56,12 +55,6 @@ public void setAppendValue(Long appendValue) { this.appendValue = appendValue; } - @Override - public VariableModification getModifiedCopy() { - return new LongAppendValueModification( - appendValue + new Random().nextInt(MAX_VALUE_MODIFIER)); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java index 14cf58b9..2a744153 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java @@ -7,7 +7,6 @@ */ package de.rub.nds.modifiablevariable.longint; -import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @@ -40,12 +39,6 @@ public int getIndex() { return index; } - @Override - public VariableModification getModifiedCopy() { - throw new UnsupportedOperationException( - "Cannot set modify Value of LongExplicitValueFromFileModification"); - } - @Override public int hashCode() { int hash = 7; 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 4a10a5df..4919b544 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java @@ -11,7 +11,6 @@ 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"}) @@ -53,18 +52,6 @@ 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 = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java index bc0caf0c..1da0838d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java @@ -11,7 +11,6 @@ import jakarta.xml.bind.annotation.XmlRootElement; import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; -import java.util.Random; @XmlRootElement @XmlType(propOrder = {"insertValue", "startPosition", "modificationFilter"}) @@ -80,26 +79,6 @@ public void setStartPosition(int startPosition) { this.startPosition = startPosition; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - - if (r.nextBoolean()) { - return new LongInsertValueModification( - insertValue + r.nextInt(MAX_VALUE_MODIFIER), startPosition); - } else { - int modifier = r.nextInt(MAX_POSITION_MODIFIER); - if (r.nextBoolean()) { - modifier *= -1; - } - modifier = startPosition + modifier; - if (modifier <= 0) { - modifier = 1; - } - return new LongInsertValueModification(insertValue, modifier); - } - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java index 79434b91..d1b8c345 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java @@ -11,7 +11,6 @@ import jakarta.xml.bind.annotation.XmlRootElement; import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; -import java.util.Random; @XmlRootElement @XmlType(propOrder = {"factor", "modificationFilter"}) @@ -53,11 +52,6 @@ public void setFactor(Long factor) { this.factor = factor; } - @Override - public VariableModification getModifiedCopy() { - return new LongMultiplyModification(factor + new Random().nextInt(MAX_FACTOR_MODIFIER)); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java index 366cb6e6..23b59b05 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java @@ -11,7 +11,6 @@ import jakarta.xml.bind.annotation.XmlRootElement; import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; -import java.util.Random; @XmlRootElement @XmlType(propOrder = {"prependValue", "modificationFilter"}) @@ -56,12 +55,6 @@ public void setPrependValue(Long prependValue) { this.prependValue = prependValue; } - @Override - public VariableModification getModifiedCopy() { - return new LongPrependValueModification( - prependValue + new Random().nextInt(MAX_VALUE_MODIFIER)); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java index 2d479360..d935404b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java @@ -11,7 +11,6 @@ import jakarta.xml.bind.annotation.XmlRootElement; import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; -import java.util.Random; @XmlRootElement @XmlType(propOrder = {"shift", "modificationFilter"}) @@ -53,24 +52,6 @@ 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 LongShiftLeftModification(newShift); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java index 0f8b2cfe..87890095 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java @@ -11,7 +11,6 @@ import jakarta.xml.bind.annotation.XmlRootElement; import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; -import java.util.Random; @XmlRootElement @XmlType(propOrder = {"shift", "modificationFilter"}) @@ -53,24 +52,6 @@ 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 LongShiftRightModification(newShift); - } - @Override public int hashCode() { int hash = 7; 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 b161b12c..35b480f0 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java @@ -11,7 +11,6 @@ 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"}) @@ -53,12 +52,6 @@ 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; diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongSwapEndianModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongSwapEndianModification.java index 980b4b8e..ae4c394d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongSwapEndianModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongSwapEndianModification.java @@ -36,11 +36,6 @@ protected Long modifyImplementationHook(Long input) { return Long.reverseBytes(input); } - @Override - public VariableModification getModifiedCopy() { - return new LongSwapEndianModification(); - } - @Override public int hashCode() { return 7; 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 8b82adc4..8f009a5f 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java @@ -11,7 +11,6 @@ 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"}) @@ -53,16 +52,6 @@ public void setXor(Long xor) { this.xor = xor; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - if (r.nextBoolean()) { - return new LongXorModification(xor + r.nextInt(MAX_XOR_MODIFIER)); - } else { - return new LongXorModification(xor - r.nextInt(MAX_XOR_MODIFIER)); - } - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java index ec3fc569..be7333bc 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java @@ -15,7 +15,6 @@ import jakarta.xml.bind.annotation.XmlType; import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.util.Objects; -import java.util.Random; /** Modification that appends a path parts to the original value. */ @XmlRootElement @@ -65,16 +64,6 @@ public void setAppendValue(String appendValue) { this.appendValue = appendValue; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - int index = r.nextInt(appendValue.length()); - char randomChar = (char) r.nextInt(MAX_EXPLICIT_VALUE); - StringBuilder modifiedString = new StringBuilder(appendValue); - modifiedString.setCharAt(index, randomChar); - return new PathAppendValueModification(modifiedString.toString()); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathDeleteModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathDeleteModification.java index 71639a37..fcc28a7b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathDeleteModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathDeleteModification.java @@ -13,7 +13,6 @@ import jakarta.xml.bind.annotation.XmlType; import java.util.Arrays; import java.util.Objects; -import java.util.Random; /** Modification that deletes path parts from the original value. */ @XmlRootElement @@ -106,33 +105,6 @@ public void setStartPosition(int startPosition) { this.startPosition = startPosition; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - - if (r.nextBoolean()) { - int modifier = r.nextInt(MAX_MODIFIER_LENGTH); - if (r.nextBoolean()) { - modifier *= -1; - } - modifier = count + modifier; - if (modifier <= 0) { - modifier = 1; - } - return new PathDeleteModification(modifier, startPosition); - } else { - int modifier = r.nextInt(MAX_MODIFIER_LENGTH); - if (r.nextBoolean()) { - modifier *= -1; - } - modifier = startPosition + modifier; - if (modifier <= 0) { - modifier = 1; - } - return new PathDeleteModification(count, modifier); - } - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java index 6627f5d6..bd07f9e2 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java @@ -9,7 +9,6 @@ import static de.rub.nds.modifiablevariable.util.StringUtil.backslashEscapeString; -import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @@ -42,12 +41,6 @@ public int getIndex() { return index; } - @Override - public VariableModification getModifiedCopy() { - throw new UnsupportedOperationException( - "Cannot set modify Value of PathExplicitValueFromFileModification"); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java index 6bce03b2..b18f52ea 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java @@ -15,7 +15,6 @@ import jakarta.xml.bind.annotation.XmlType; import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.util.Objects; -import java.util.Random; @XmlRootElement @XmlType(propOrder = {"explicitValue", "modificationFilter"}) @@ -58,19 +57,6 @@ public void setExplicitValue(String explicitValue) { this.explicitValue = explicitValue; } - @Override - public VariableModification getModifiedCopy() { - if (explicitValue.isEmpty()) { - return this; - } - Random r = new Random(); - int index = r.nextInt(explicitValue.length()); - char randomChar = (char) r.nextInt(MAX_EXPLICIT_VALUE); - StringBuilder modifiedString = new StringBuilder(explicitValue); - modifiedString.setCharAt(index, randomChar); - return new PathExplicitValueModification(modifiedString.toString()); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectorySeparatorModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectorySeparatorModification.java index 0dfa225d..af014b0b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectorySeparatorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectorySeparatorModification.java @@ -13,7 +13,6 @@ import jakarta.xml.bind.annotation.XmlType; import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.util.Objects; -import java.util.Random; /** Modification that inserts directory separators as path parts to the original value. */ @XmlRootElement @@ -78,33 +77,6 @@ public void setStartPosition(int startPosition) { this.startPosition = startPosition; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - - if (r.nextBoolean()) { - int modifier = r.nextInt(MAX_INSERT_MODIFIER); - if (r.nextBoolean()) { - modifier *= -1; - } - modifier = count + modifier; - if (modifier <= 0) { - modifier = 1; - } - return new PathInsertDirectorySeparatorModification(modifier, startPosition); - } else { - int modifier = r.nextInt(MAX_INSERT_MODIFIER); - if (r.nextBoolean()) { - modifier *= -1; - } - modifier = startPosition + modifier; - if (modifier <= 0) { - modifier = 1; - } - return new PathInsertDirectorySeparatorModification(count, modifier); - } - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java index 1e22284c..0f612c25 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java @@ -13,7 +13,6 @@ import jakarta.xml.bind.annotation.XmlType; import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.util.Objects; -import java.util.Random; /** Modification that directory traversal path parts the original value. */ @XmlRootElement @@ -89,33 +88,6 @@ public void setStartPosition(int startPosition) { this.startPosition = startPosition; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - - if (r.nextBoolean()) { - int modifier = r.nextInt(MAX_INSERT_MODIFIER); - if (r.nextBoolean()) { - modifier *= -1; - } - modifier = count + modifier; - if (modifier <= 0) { - modifier = 1; - } - return new PathInsertDirectoryTraversalModification(modifier, startPosition); - } else { - int modifier = r.nextInt(MAX_INSERT_MODIFIER); - if (r.nextBoolean()) { - modifier *= -1; - } - modifier = startPosition + modifier; - if (modifier <= 0) { - modifier = 1; - } - return new PathInsertDirectoryTraversalModification(count, modifier); - } - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java index 7b85cedf..5f712807 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java @@ -15,7 +15,6 @@ import jakarta.xml.bind.annotation.XmlType; import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.util.Objects; -import java.util.Random; /** Modification that inserts path parts to the original value. */ @XmlRootElement @@ -73,29 +72,6 @@ public void setStartPosition(int startPosition) { this.startPosition = startPosition; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - - if (r.nextBoolean()) { - int index = r.nextInt(insertValue.length()); - char randomChar = (char) r.nextInt(MAX_EXPLICIT_VALUE); - StringBuilder modifiedString = new StringBuilder(insertValue); - modifiedString.setCharAt(index, randomChar); - return new PathInsertValueModification(modifiedString.toString(), startPosition); - } else { - int modifier = r.nextInt(MAX_INSERT_MODIFIER); - if (r.nextBoolean()) { - modifier *= -1; - } - modifier = startPosition + modifier; - if (modifier <= 0) { - modifier = 1; - } - return new PathInsertValueModification(insertValue, modifier); - } - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java index e3505bc6..5b43c1e8 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java @@ -15,7 +15,6 @@ import jakarta.xml.bind.annotation.XmlType; import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.util.Objects; -import java.util.Random; /** Modification that prepends a string to the original value. */ @XmlRootElement @@ -65,16 +64,6 @@ public void setPrependValue(String prependValue) { this.prependValue = prependValue; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - int index = r.nextInt(prependValue.length()); - char randomChar = (char) r.nextInt(MAX_EXPLICIT_VALUE); - StringBuilder modifiedString = new StringBuilder(prependValue); - modifiedString.setCharAt(index, randomChar); - return new PathPrependValueModification(modifiedString.toString()); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootModification.java index 8d6ee3e8..efcec4e0 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootModification.java @@ -40,11 +40,6 @@ protected String modifyImplementationHook(String input) { return "/" + input; } - @Override - public VariableModification getModifiedCopy() { - return new PathToggleRootModification(); - } - @Override public int hashCode() { return 7; 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 2fd73b29..482041a9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteAddModification.java @@ -11,7 +11,6 @@ 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"}) @@ -56,11 +55,6 @@ 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 = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java index 739405a4..114078a0 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java @@ -7,7 +7,6 @@ */ package de.rub.nds.modifiablevariable.singlebyte; -import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @@ -40,12 +39,6 @@ public int getIndex() { return index; } - @Override - public VariableModification getModifiedCopy() { - throw new UnsupportedOperationException( - "Cannot set modify Value of ByteExplicitValueFromFileModification"); - } - @Override public int hashCode() { int hash = 7; 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 f0e6bffe..3a99bb97 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueModification.java @@ -11,7 +11,6 @@ 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"}) @@ -53,18 +52,6 @@ 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; 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 9093969c..d1ecf774 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteSubtractModification.java @@ -11,7 +11,6 @@ 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"}) @@ -56,12 +55,6 @@ public void setSubtrahend(Byte subtrahend) { this.subtrahend = subtrahend; } - @Override - public VariableModification getModifiedCopy() { - return new ByteSubtractModification( - (byte) (subtrahend + new Random().nextInt(MAX_SUBTRACT_MODIFIER))); - } - @Override public int hashCode() { int hash = 7; 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 18f614b2..428616e1 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteXorModification.java @@ -10,7 +10,6 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; import java.util.Objects; -import java.util.Random; @XmlRootElement public class ByteXorModification extends VariableModification { @@ -54,16 +53,6 @@ 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; 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 424ebeb5..b2cc7bdc 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java @@ -15,7 +15,6 @@ import jakarta.xml.bind.annotation.XmlType; import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.util.Objects; -import java.util.Random; /** Modification that appends a string to the original value. */ @XmlRootElement @@ -59,16 +58,6 @@ public void setAppendValue(String appendValue) { this.appendValue = appendValue; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - int index = r.nextInt(appendValue.length()); - char randomChar = (char) r.nextInt(MAX_EXPLICIT_VALUE); - StringBuilder modifiedString = new StringBuilder(appendValue); - modifiedString.setCharAt(index, randomChar); - return new StringAppendValueModification(modifiedString.toString()); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringDeleteModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringDeleteModification.java index aea4e26f..55751381 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringDeleteModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringDeleteModification.java @@ -11,7 +11,6 @@ import jakarta.xml.bind.annotation.XmlRootElement; import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; -import java.util.Random; /** Modification that deletes part of a string from the original value. */ @XmlRootElement @@ -85,33 +84,6 @@ public void setStartPosition(int startPosition) { this.startPosition = startPosition; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - - if (r.nextBoolean()) { - int modifier = r.nextInt(MAX_MODIFIER_LENGTH); - if (r.nextBoolean()) { - modifier *= -1; - } - modifier = count + modifier; - if (modifier <= 0) { - modifier = 1; - } - return new StringDeleteModification(modifier, startPosition); - } else { - int modifier = r.nextInt(MAX_MODIFIER_LENGTH); - if (r.nextBoolean()) { - modifier *= -1; - } - modifier = startPosition + modifier; - if (modifier <= 0) { - modifier = 1; - } - return new StringDeleteModification(count, modifier); - } - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java index a2ecebfc..80ac4c2e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java @@ -9,7 +9,6 @@ import static de.rub.nds.modifiablevariable.util.StringUtil.backslashEscapeString; -import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @@ -42,12 +41,6 @@ public int getIndex() { return index; } - @Override - public VariableModification getModifiedCopy() { - throw new UnsupportedOperationException( - "Cannot set modify Value of StringExplicitValueFromFileModification"); - } - @Override public int hashCode() { int hash = 7; 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 f4d927d2..b490370a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java @@ -15,7 +15,6 @@ import jakarta.xml.bind.annotation.XmlType; import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.util.Objects; -import java.util.Random; /** */ @XmlRootElement @@ -59,19 +58,6 @@ public void setExplicitValue(String explicitValue) { this.explicitValue = explicitValue; } - @Override - public VariableModification getModifiedCopy() { - if (explicitValue.isEmpty()) { - return this; - } - Random r = new Random(); - int index = r.nextInt(explicitValue.length()); - char randomChar = (char) r.nextInt(MAX_EXPLICIT_VALUE); - StringBuilder modifiedString = new StringBuilder(explicitValue); - modifiedString.setCharAt(index, randomChar); - return new StringExplicitValueModification(modifiedString.toString()); - } - @Override public int hashCode() { int hash = 7; diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java index 628ae55a..223377cc 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java @@ -15,7 +15,6 @@ import jakarta.xml.bind.annotation.XmlType; import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.util.Objects; -import java.util.Random; /** Modification that inserts a string to the original value. */ @XmlRootElement @@ -82,29 +81,6 @@ public void setStartPosition(int startPosition) { this.startPosition = startPosition; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - - if (r.nextBoolean()) { - int index = r.nextInt(insertValue.length()); - char randomChar = (char) r.nextInt(MAX_EXPLICIT_VALUE); - StringBuilder modifiedString = new StringBuilder(insertValue); - modifiedString.setCharAt(index, randomChar); - return new StringInsertValueModification(modifiedString.toString(), startPosition); - } else { - int modifier = r.nextInt(MAX_INSERT_MODIFIER); - if (r.nextBoolean()) { - modifier *= -1; - } - modifier = startPosition + modifier; - if (modifier <= 0) { - modifier = 1; - } - return new StringInsertValueModification(insertValue, modifier); - } - } - @Override public int hashCode() { int hash = 7; 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 e144dfc6..228d63fe 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java @@ -15,7 +15,6 @@ import jakarta.xml.bind.annotation.XmlType; import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.util.Objects; -import java.util.Random; /** Modification that prepends a string to the original value. */ @XmlRootElement @@ -59,16 +58,6 @@ public void setPrependValue(String prependValue) { this.prependValue = prependValue; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - int index = r.nextInt(prependValue.length()); - char randomChar = (char) r.nextInt(MAX_EXPLICIT_VALUE); - StringBuilder modifiedString = new StringBuilder(prependValue); - modifiedString.setCharAt(index, randomChar); - return new StringPrependValueModification(modifiedString.toString()); - } - @Override public int hashCode() { int hash = 7; 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/BigIntegerOperationConcatenationTest.java b/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerOperationConcatenationTest.java index a17cfba0..cb0ef515 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerOperationConcatenationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerOperationConcatenationTest.java @@ -37,11 +37,6 @@ protected BigInteger modifyImplementationHook(BigInteger input) { return input.add(new BigInteger("4")).xor(new BigInteger("3")); } - @Override - public VariableModification getModifiedCopy() { - throw new UnsupportedOperationException("Not supported yet."); - } - @Override public VariableModification createCopy() { throw new UnsupportedOperationException("Not supported yet."); 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/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/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() { From 01ecd03d36aefa3ddcd2019395e960ac7bb2c2f5 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Mon, 24 Feb 2025 15:11:42 +0100 Subject: [PATCH 68/82] Remove now unused limit constants, because I removed getModifiedCopy --- .../biginteger/BigIntegerAddModification.java | 2 -- .../biginteger/BigIntegerAppendValueModification.java | 2 -- .../biginteger/BigIntegerExplicitValueModification.java | 2 -- .../biginteger/BigIntegerInsertValueModification.java | 3 --- .../biginteger/BigIntegerMultiplyModification.java | 2 -- .../biginteger/BigIntegerPrependValueModification.java | 2 -- .../biginteger/BigIntegerShiftLeftModification.java | 2 -- .../biginteger/BigIntegerShiftRightModification.java | 2 -- .../biginteger/BigIntegerSubtractModification.java | 2 -- .../biginteger/BigIntegerXorModification.java | 2 -- .../bytearray/ByteArrayAppendValueModification.java | 2 -- .../bytearray/ByteArrayDeleteModification.java | 2 -- .../bytearray/ByteArrayExplicitValueModification.java | 2 -- .../bytearray/ByteArrayInsertValueModification.java | 4 ---- .../bytearray/ByteArrayPrependValueModification.java | 2 -- .../bytearray/ByteArrayShuffleModification.java | 2 -- .../bytearray/ByteArrayXorModification.java | 4 ---- .../modifiablevariable/integer/IntegerAddModification.java | 2 -- .../integer/IntegerAppendValueModification.java | 2 -- .../integer/IntegerExplicitValueModification.java | 2 -- .../integer/IntegerInsertValueModification.java | 4 ---- .../integer/IntegerMultiplyModification.java | 2 -- .../integer/IntegerPrependValueModification.java | 2 -- .../integer/IntegerSubtractModification.java | 2 -- .../modifiablevariable/integer/IntegerXorModification.java | 2 -- .../nds/modifiablevariable/longint/LongAddModification.java | 2 -- .../longint/LongAppendValueModification.java | 2 -- .../longint/LongExplicitValueModification.java | 2 -- .../longint/LongInsertValueModification.java | 3 --- .../modifiablevariable/longint/LongModificationFactory.java | 1 + .../modifiablevariable/longint/LongMultiplyModification.java | 2 -- .../longint/LongPrependValueModification.java | 2 -- .../modifiablevariable/longint/LongSubtractModification.java | 2 -- .../nds/modifiablevariable/longint/LongXorModification.java | 2 -- .../modifiablevariable/path/PathAppendValueModification.java | 2 -- .../nds/modifiablevariable/path/PathDeleteModification.java | 2 -- .../path/PathExplicitValueModification.java | 2 -- .../path/PathInsertDirectorySeparatorModification.java | 2 -- .../path/PathInsertDirectoryTraversalModification.java | 2 -- .../modifiablevariable/path/PathInsertValueModification.java | 4 ---- .../modifiablevariable/path/PathPrependValueModification.java | 2 -- .../modifiablevariable/singlebyte/ByteAddModification.java | 2 -- .../singlebyte/ByteExplicitValueModification.java | 2 -- .../singlebyte/ByteSubtractModification.java | 2 -- .../modifiablevariable/singlebyte/ByteXorModification.java | 2 -- .../string/StringAppendValueModification.java | 2 -- .../modifiablevariable/string/StringDeleteModification.java | 2 -- .../string/StringExplicitValueModification.java | 2 -- .../string/StringInsertValueModification.java | 4 ---- .../string/StringPrependValueModification.java | 2 -- .../java/de/rub/nds/modifiablevariable/util/StringUtil.java | 2 -- 51 files changed, 1 insertion(+), 112 deletions(-) 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 f6c264a5..dc8925d1 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java @@ -17,8 +17,6 @@ @XmlType(propOrder = {"summand", "modificationFilter"}) public class BigIntegerAddModification extends VariableModification { - private static final int MAX_ADD_LENGTH = 8; - private BigInteger summand; public BigIntegerAddModification() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java index 398e4e8c..74978df3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java @@ -17,8 +17,6 @@ @XmlType(propOrder = {"appendValue", "modificationFilter"}) public class BigIntegerAppendValueModification extends VariableModification { - private static final int MAX_APPEND_LENGTH = 8; - private BigInteger appendValue; public BigIntegerAppendValueModification() { 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 1d6fbca8..62b6a34b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java @@ -17,8 +17,6 @@ @XmlType(propOrder = {"explicitValue", "modificationFilter"}) public class BigIntegerExplicitValueModification extends VariableModification { - private static final int MAX_EXPLICIT_LENGTH = 8; - protected BigInteger explicitValue; public BigIntegerExplicitValueModification() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java index 18ff784b..ada942b1 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java @@ -17,9 +17,6 @@ @XmlType(propOrder = {"insertValue", "startPosition", "modificationFilter"}) public class BigIntegerInsertValueModification extends VariableModification { - private static final int MAX_INSERT_LENGTH = 8; - private static final int MAX_POSITION_MODIFIER = 32; - private BigInteger insertValue; private int startPosition; 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 2685b081..421cfac1 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java @@ -17,8 +17,6 @@ @XmlType(propOrder = {"factor", "modificationFilter"}) public class BigIntegerMultiplyModification extends VariableModification { - private static final int MAX_FACTOR_LENGTH = 8; - private BigInteger factor; public BigIntegerMultiplyModification() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java index 4be9f595..2e359563 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java @@ -17,8 +17,6 @@ @XmlType(propOrder = {"prependValue", "modificationFilter"}) public class BigIntegerPrependValueModification extends VariableModification { - private static final int MAX_PREPEND_LENGTH = 8; - private BigInteger prependValue; public BigIntegerPrependValueModification() { 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 847943b7..83f0ec6b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java @@ -16,8 +16,6 @@ @XmlType(propOrder = {"shift", "modificationFilter"}) public class BigIntegerShiftLeftModification extends VariableModification { - private static final int MAX_SHIFT_LENGTH = 32; - private int shift; public BigIntegerShiftLeftModification() { 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 f1a434cc..4fa5218f 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java @@ -16,8 +16,6 @@ @XmlType(propOrder = {"shift", "modificationFilter"}) public class BigIntegerShiftRightModification extends VariableModification { - private static final int MAX_SHIFT_LENGTH = 32; - private int shift; public BigIntegerShiftRightModification() { 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 29369078..94f49c90 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java @@ -17,8 +17,6 @@ @XmlType(propOrder = {"subtrahend", "modificationFilter"}) public class BigIntegerSubtractModification extends VariableModification { - private static final int MAX_SUBTRACT_LENGTH = 8; - private BigInteger subtrahend; public BigIntegerSubtractModification() { 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 fe00b598..e7dd2396 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java @@ -17,8 +17,6 @@ @XmlType(propOrder = {"xor", "modificationFilter"}) public class BigIntegerXorModification extends VariableModification { - private static final int MAX_XOR_LENGTH = 8; - private BigInteger xor; public BigIntegerXorModification() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java index 7142652d..12a41637 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java @@ -19,8 +19,6 @@ @XmlType(propOrder = {"bytesToAppend", "modificationFilter"}) public class ByteArrayAppendValueModification extends VariableModification { - private static final int MAX_EXPLICIT_VALUE = 256; - @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) private byte[] 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 3762618e..7970759d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java @@ -17,8 +17,6 @@ @XmlType(propOrder = {"count", "startPosition", "modificationFilter"}) public class ByteArrayDeleteModification extends VariableModification { - private static final int MAX_MODIFIER_LENGTH = 32; - private int count; private int startPosition; 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 9f79ff34..184996d9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java @@ -19,8 +19,6 @@ @XmlType(propOrder = {"explicitValue", "modificationFilter"}) public class ByteArrayExplicitValueModification extends VariableModification { - private static final int MAX_EXPLICIT_VALUE = 256; - @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) protected byte[] explicitValue; diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java index 46a3e910..1b17d4ee 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java @@ -19,10 +19,6 @@ @XmlType(propOrder = {"bytesToInsert", "startPosition", "modificationFilter"}) public class ByteArrayInsertValueModification extends VariableModification { - private static final int MAX_EXPLICIT_VALUE = 256; - - private static final int MAX_POSITION_MODIFIER = 32; - @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) private byte[] bytesToInsert; diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java index 00f6f77e..3949d8d1 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java @@ -19,8 +19,6 @@ @XmlType(propOrder = {"bytesToPrepend", "modificationFilter"}) public class ByteArrayPrependValueModification extends VariableModification { - private static final int MAX_EXPLICIT_VALUE = 256; - @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) private byte[] 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 ae1a9fda..1c8a7546 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayShuffleModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayShuffleModification.java @@ -23,8 +23,6 @@ @XmlType(propOrder = {"shuffle", "modificationFilter"}) public class ByteArrayShuffleModification extends VariableModification { - private static final int MAX_MODIFIER_VALUE = 256; - @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) private byte[] shuffle; 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 75ea45eb..2885dad6 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java @@ -19,10 +19,6 @@ @XmlType(propOrder = {"xor", "startPosition", "modificationFilter"}) 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; 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 089f64e9..df3179bd 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAddModification.java @@ -16,8 +16,6 @@ @XmlType(propOrder = {"summand", "modificationFilter"}) public class IntegerAddModification extends VariableModification { - private static final int MAX_ADD_MODIFIER = 256; - private Integer summand; public IntegerAddModification() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java index e16c7126..f3f0941e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java @@ -16,8 +16,6 @@ @XmlType(propOrder = {"appendValue", "modificationFilter"}) public class IntegerAppendValueModification extends VariableModification { - private static final int MAX_VALUE_MODIFIER = 256; - private Integer appendValue; public IntegerAppendValueModification() { 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 8bd0d7f3..380125c5 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueModification.java @@ -16,8 +16,6 @@ @XmlType(propOrder = {"explicitValue", "modificationFilter"}) public class IntegerExplicitValueModification extends VariableModification { - private static final int MAX_VALUE_MODIFIER = 256; - protected Integer explicitValue; public IntegerExplicitValueModification() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java index a609e5db..62393bda 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java @@ -16,10 +16,6 @@ @XmlType(propOrder = {"insertValue", "startPosition", "modificationFilter"}) public class IntegerInsertValueModification extends VariableModification { - private static final int MAX_VALUE_MODIFIER = 256; - - private static final int MAX_POSITION_MODIFIER = 32; - private Integer insertValue; private int startPosition; diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java index cada7c93..acf219ca 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java @@ -16,8 +16,6 @@ @XmlType(propOrder = {"factor", "modificationFilter"}) public class IntegerMultiplyModification extends VariableModification { - private static final int MAX_FACTOR_MODIFIER = 256; - private Integer factor; public IntegerMultiplyModification() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java index 9f2bd7d2..0c8ebd34 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java @@ -16,8 +16,6 @@ @XmlType(propOrder = {"prependValue", "modificationFilter"}) public class IntegerPrependValueModification extends VariableModification { - private static final int MAX_VALUE_MODIFIER = 256; - private Integer prependValue; public IntegerPrependValueModification() { 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 42a49aac..6dc45563 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSubtractModification.java @@ -16,8 +16,6 @@ @XmlType(propOrder = {"subtrahend", "modificationFilter"}) public class IntegerSubtractModification extends VariableModification { - private static final int MAX_SUBTRACT_MODIFIER = 256; - private Integer subtrahend; public IntegerSubtractModification() { 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 1efa2150..df3e5ec6 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerXorModification.java @@ -16,8 +16,6 @@ @XmlType(propOrder = {"xor", "modificationFilter"}) public class IntegerXorModification extends VariableModification { - private static final int MAX_VALUE_MODIFIER = 256; - private Integer xor; public IntegerXorModification() { 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 bf305588..1fd4135c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java @@ -16,8 +16,6 @@ @XmlType(propOrder = {"summand", "modificationFilter"}) public class LongAddModification extends VariableModification { - private static final int MAX_ADD_MODIFIER = 32; - private Long summand; public LongAddModification() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java index 54b0cae7..23c42895 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java @@ -16,8 +16,6 @@ @XmlType(propOrder = {"appendValue", "modificationFilter"}) public class LongAppendValueModification extends VariableModification { - private static final int MAX_VALUE_MODIFIER = 256; - private Long appendValue; public LongAppendValueModification() { 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 4919b544..f0fce781 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java @@ -16,8 +16,6 @@ @XmlType(propOrder = {"explicitValue", "modificationFilter"}) public class LongExplicitValueModification extends VariableModification { - private static final int MAX_EXPLICIT_MODIFIER = 256; - protected Long explicitValue; public LongExplicitValueModification() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java index 1da0838d..373e0456 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java @@ -16,9 +16,6 @@ @XmlType(propOrder = {"insertValue", "startPosition", "modificationFilter"}) public class LongInsertValueModification extends VariableModification { - private static final int MAX_VALUE_MODIFIER = 256; - private static final int MAX_POSITION_MODIFIER = 32; - private Long insertValue; private int startPosition; 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 546db557..94aeff30 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongModificationFactory.java @@ -21,6 +21,7 @@ public final class LongModificationFactory { + @SuppressWarnings("unused") private enum ModificationType { ADD, SUBTRACT, diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java index d1b8c345..5bf91160 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java @@ -16,8 +16,6 @@ @XmlType(propOrder = {"factor", "modificationFilter"}) public class LongMultiplyModification extends VariableModification { - private static final int MAX_FACTOR_MODIFIER = 256; - private Long factor; public LongMultiplyModification() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java index 23b59b05..50d68116 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java @@ -16,8 +16,6 @@ @XmlType(propOrder = {"prependValue", "modificationFilter"}) public class LongPrependValueModification extends VariableModification { - private static final int MAX_VALUE_MODIFIER = 256; - private Long prependValue; public LongPrependValueModification() { 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 35b480f0..5a9a21e4 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java @@ -16,8 +16,6 @@ @XmlType(propOrder = {"subtrahend", "modificationFilter"}) public class LongSubtractModification extends VariableModification { - private static final int MAX_SUBTRACT_MODIFIER = 256; - private Long subtrahend; public LongSubtractModification() { 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 8f009a5f..94d69395 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java @@ -16,8 +16,6 @@ @XmlType(propOrder = {"xor", "modificationFilter"}) public class LongXorModification extends VariableModification { - private static final int MAX_XOR_MODIFIER = 256; - private Long xor; public LongXorModification() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java index be7333bc..9dbc622c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java @@ -21,8 +21,6 @@ @XmlType(propOrder = {"appendValue", "modificationFilter"}) public class PathAppendValueModification extends VariableModification { - private static final int MAX_EXPLICIT_VALUE = 256; - @XmlJavaTypeAdapter(IllegalStringAdapter.class) private String appendValue; diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathDeleteModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathDeleteModification.java index fcc28a7b..bb50f031 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathDeleteModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathDeleteModification.java @@ -19,8 +19,6 @@ @XmlType(propOrder = {"count", "startPosition", "modificationFilter"}) public class PathDeleteModification extends VariableModification { - private static final int MAX_MODIFIER_LENGTH = 32; - private int count; private int startPosition; diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java index b18f52ea..84fa43d9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java @@ -20,8 +20,6 @@ @XmlType(propOrder = {"explicitValue", "modificationFilter"}) public class PathExplicitValueModification extends VariableModification { - private static final int MAX_EXPLICIT_VALUE = 256; - @XmlJavaTypeAdapter(IllegalStringAdapter.class) protected String explicitValue; diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectorySeparatorModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectorySeparatorModification.java index af014b0b..eca8ad8a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectorySeparatorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectorySeparatorModification.java @@ -19,8 +19,6 @@ @XmlType(propOrder = {"insertValue", "count", "startPosition", "modificationFilter"}) public class PathInsertDirectorySeparatorModification extends VariableModification { - private static final int MAX_INSERT_MODIFIER = 32; - @XmlJavaTypeAdapter(IllegalStringAdapter.class) private String insertValue; diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java index 0f612c25..a91db51a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java @@ -19,8 +19,6 @@ @XmlType(propOrder = {"insertValue", "count", "startPosition", "modificationFilter"}) public class PathInsertDirectoryTraversalModification extends VariableModification { - private static final int MAX_INSERT_MODIFIER = 32; - @XmlJavaTypeAdapter(IllegalStringAdapter.class) private String insertValue; diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java index 5f712807..e09576cb 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java @@ -21,10 +21,6 @@ @XmlType(propOrder = {"insertValue", "startPosition", "modificationFilter"}) public class PathInsertValueModification extends VariableModification { - private static final int MAX_EXPLICIT_VALUE = 256; - - private static final int MAX_INSERT_MODIFIER = 32; - @XmlJavaTypeAdapter(IllegalStringAdapter.class) private String insertValue; diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java index 5b43c1e8..c621ca00 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java @@ -21,8 +21,6 @@ @XmlType(propOrder = {"prependValue", "modificationFilter"}) public class PathPrependValueModification extends VariableModification { - private static final int MAX_EXPLICIT_VALUE = 256; - @XmlJavaTypeAdapter(IllegalStringAdapter.class) private String prependValue; 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 482041a9..017dee27 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteAddModification.java @@ -16,8 +16,6 @@ @XmlType(propOrder = {"summand", "modificationFilter"}) public class ByteAddModification extends VariableModification { - private static final int MAX_ADD_MODIFIER = 16; - private Byte summand; public ByteAddModification() { 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 3a99bb97..e0d0a4c1 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueModification.java @@ -16,8 +16,6 @@ @XmlType(propOrder = {"explicitValue", "modificationFilter"}) public class ByteExplicitValueModification extends VariableModification { - private static final int MAX_EXPLICIT_MODIFIER = 16; - protected Byte explicitValue; public ByteExplicitValueModification() { 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 d1ecf774..800d3ff3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteSubtractModification.java @@ -16,8 +16,6 @@ @XmlType(propOrder = {"subtrahend", "modificationFilter"}) public class ByteSubtractModification extends VariableModification { - private static final int MAX_SUBTRACT_MODIFIER = 16; - private Byte subtrahend; public ByteSubtractModification() { 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 428616e1..2954e0bf 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteXorModification.java @@ -14,8 +14,6 @@ @XmlRootElement public class ByteXorModification extends VariableModification { - private static final int MAX_XOR_MODIFIER = 16; - private Byte xor; public ByteXorModification() { 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 b2cc7bdc..e3c98ba4 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java @@ -21,8 +21,6 @@ @XmlType(propOrder = {"appendValue", "modificationFilter"}) public class StringAppendValueModification extends VariableModification { - private static final int MAX_EXPLICIT_VALUE = 256; - @XmlJavaTypeAdapter(IllegalStringAdapter.class) private String 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 index 55751381..4383720b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringDeleteModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringDeleteModification.java @@ -17,8 +17,6 @@ @XmlType(propOrder = {"count", "startPosition", "modificationFilter"}) public class StringDeleteModification extends VariableModification { - private static final int MAX_MODIFIER_LENGTH = 32; - private int count; private int 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 b490370a..d88fd48f 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java @@ -21,8 +21,6 @@ @XmlType(propOrder = {"explicitValue", "modificationFilter"}) public class StringExplicitValueModification extends VariableModification { - private static final int MAX_EXPLICIT_VALUE = 256; - @XmlJavaTypeAdapter(IllegalStringAdapter.class) protected String 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 index 223377cc..13e19b48 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java @@ -21,10 +21,6 @@ @XmlType(propOrder = {"insertValue", "startPosition", "modificationFilter"}) public class StringInsertValueModification extends VariableModification { - private static final int MAX_EXPLICIT_VALUE = 256; - - private static final int MAX_INSERT_MODIFIER = 32; - @XmlJavaTypeAdapter(IllegalStringAdapter.class) private String insertValue; 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 228d63fe..caaec3ea 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java @@ -21,8 +21,6 @@ @XmlType(propOrder = {"prependValue", "modificationFilter"}) public class StringPrependValueModification extends VariableModification { - private static final int MAX_EXPLICIT_VALUE = 256; - @XmlJavaTypeAdapter(IllegalStringAdapter.class) private String prependValue; 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 947926b5..a2e0102a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/StringUtil.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/StringUtil.java @@ -14,8 +14,6 @@ private StringUtil() { super(); } - static final int HI_SURROGATE_START = 0xD800; - /** * Replace any non-printable (or non-ascii) characters other than space with their * backslash-escaped equivalents. From 840f6983b56273f298b11cc1f2d46c6aeae782ee Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Mon, 24 Feb 2025 15:21:26 +0100 Subject: [PATCH 69/82] Remove BigIntegerInteractiveModification See https://github.com/tls-attacker/ModifiableVariable/pull/182#discussion_r1967409237 --- .../ModifiableVariable.java | 3 -- .../BigIntegerInteractiveModification.java | 47 ------------------- .../BigIntegerModificationFactory.java | 34 -------------- .../BigIntegerSerializationTest.java | 25 +--------- 4 files changed, 1 insertion(+), 108 deletions(-) delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInteractiveModification.java diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java index 258cb54e..c5277a91 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -52,9 +52,6 @@ public abstract class ModifiableVariable implements Serializable { type = BigIntegerExplicitValueModification.class, name = "BigIntegerExplicitValueModification"), @XmlElement(type = BigIntegerAddModification.class, name = "BigIntegerAddModification"), - @XmlElement( - type = BigIntegerInteractiveModification.class, - name = "BigIntegerInteractiveModification"), @XmlElement( type = BigIntegerMultiplyModification.class, name = "BigIntegerMultiplyModification"), 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 c38e18ac..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInteractiveModification.java +++ /dev/null @@ -1,47 +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.XmlRootElement; -import jakarta.xml.bind.annotation.XmlTransient; -import jakarta.xml.bind.annotation.XmlType; -import java.math.BigInteger; - -@XmlRootElement -@XmlType(propOrder = "modificationFilter") -public class BigIntegerInteractiveModification extends VariableModification { - - @XmlTransient private final InteractiveBigIntegerModification modification; - - protected BigIntegerInteractiveModification() { - super(); - modification = BigIntegerModificationFactory.getStandardInteractiveModification(); - } - - protected BigIntegerInteractiveModification(InteractiveBigIntegerModification modification) { - super(); - this.modification = modification; - } - - @Override - protected BigInteger modifyImplementationHook(BigInteger input) { - return modification.modify(input); - } - - public interface InteractiveBigIntegerModification { - - BigInteger modify(BigInteger oldVal); - } - - @Override - public VariableModification createCopy() { - 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 57e3ba7a..f9566f80 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationFactory.java @@ -121,40 +121,6 @@ public static VariableModification prependValue(BigInteger value) { return new BigIntegerPrependValueModification(value); } - /* - * 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: "); - try (Scanner scanner = new Scanner(System.in)) { - value = scanner.nextBigInteger(); - } - } - return value; - } - }; - - public static void setStandardInteractiveModification( - BigIntegerInteractiveModification.InteractiveBigIntegerModification modification) { - standardInteractiveModification = modification; - } - - static BigIntegerInteractiveModification.InteractiveBigIntegerModification - getStandardInteractiveModification() { - return standardInteractiveModification; - } - - public static VariableModification interactive() { - return new BigIntegerInteractiveModification(); - } - public static synchronized List> modificationsFromFile() { try { if (modificationsFromFile == null) { 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..784ea5a4 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/serialization/BigIntegerSerializationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/serialization/BigIntegerSerializationTest.java @@ -12,7 +12,6 @@ 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; @@ -58,14 +57,10 @@ 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 @@ -104,24 +99,6 @@ public void testSerializeDeserializeWithModification() throws Exception { 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 = From 922914a97870d6e3e29a7f612ad7a1326eb879a5 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Mon, 24 Feb 2025 16:12:29 +0100 Subject: [PATCH 70/82] Revert names of ArrayConverter methods back to the old one. And adapt the name pattern for the new eigthBytesToLong and fourBytesToInt methods. --- .../bytearray/ByteArrayXorModification.java | 1 - .../util/ArrayConverter.java | 24 +++++-------------- .../util/ArrayConverterTest.java | 10 +++++--- 3 files changed, 13 insertions(+), 22 deletions(-) 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 2885dad6..3ede43d7 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java @@ -65,7 +65,6 @@ protected byte[] modifyImplementationHook(byte[] input) { // 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 - // Todo: Add an option that expands the byte array instead endPosition = result.length; } 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 b3e98861..99b9c038 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/ArrayConverter.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/ArrayConverter.java @@ -26,7 +26,7 @@ private ArrayConverter() { * @param value long value * @return long represented by 8 bytes */ - public static byte[] longToEightBytes(long value) { + public static byte[] longToUint64Bytes(long value) { byte[] result = new byte[8]; result[0] = (byte) (value >>> 56); result[1] = (byte) (value >>> 48); @@ -40,7 +40,7 @@ public static byte[] longToEightBytes(long value) { } /** Note: This will truncate the long */ - public static byte[] longToSixBytes(long value) { + public static byte[] longToUint48Bytes(long value) { byte[] output = new byte[6]; output[0] = (byte) (value >>> 40); output[1] = (byte) (value >>> 32); @@ -51,25 +51,13 @@ public static byte[] longToSixBytes(long value) { return output; } - public static byte[] longToUint64Bytes(long value) { - return longToEightBytes(value); - } - - public static byte[] longToUint48Bytes(long value) { - return longToSixBytes(value); - } - - public static byte[] longToUint32Bytes(long value) { - return intToFourBytes((int) value); - } - /** * Takes an int value and converts it to 4 bytes * * @param value int value * @return int represented by 4 bytes */ - public static byte[] intToFourBytes(int value) { + public static byte[] longToUint32Bytes(long value) { byte[] result = new byte[4]; result[0] = (byte) (value >>> 24); result[1] = (byte) (value >>> 16); @@ -78,7 +66,7 @@ public static byte[] intToFourBytes(int value) { return result; } - public static long eigthBytesToLong(byte[] bytes) { + public static long uInt64BytesToLong(byte[] bytes) { return (long) (bytes[0] & 0xFF) << 56 | (long) (bytes[1] & 0xFF) << 48 | (long) (bytes[2] & 0xFF) << 40 @@ -89,8 +77,8 @@ public static long eigthBytesToLong(byte[] bytes) { | (long) (bytes[7] & 0xFF); } - public static int fourBytesToInt(byte[] bytes) { - return (bytes[0] & 0xFF) << 24 + public static long uInt32BytesToLong(byte[] bytes) { + return (long) (bytes[0] & 0xFF) << 24 | (bytes[1] & 0xFF) << 16 | (bytes[2] & 0xFF) << 8 | bytes[3] & 0xFF; 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 b9568e10..3e9b8a55 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/util/ArrayConverterTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/util/ArrayConverterTest.java @@ -225,18 +225,22 @@ public void testBigIntegerToNullPaddedByteArray() { } @Test - public void testLongToSixBytes() { + public void testLongToUint48Bytes() { long testValue = 0x0000123456789ABCL; byte[] expectedResult = ArrayConverter.hexStringToByteArray("123456789ABC"); assertArrayEquals( - expectedResult, ArrayConverter.longToSixBytes(testValue), "Assert correct output"); + expectedResult, + ArrayConverter.longToUint48Bytes(testValue), + "Assert correct output"); testValue = 0x0000000000000001L; expectedResult = ArrayConverter.hexStringToByteArray("000000000001"); assertArrayEquals( - expectedResult, ArrayConverter.longToSixBytes(testValue), "Assert correct output"); + expectedResult, + ArrayConverter.longToUint48Bytes(testValue), + "Assert correct output"); } /** From 51401fd02c39944ff732c0efba6523d5cf07e460 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Wed, 26 Feb 2025 08:54:28 +0100 Subject: [PATCH 71/82] Remove inspection profile, because of https://github.com/tls-attacker/ModifiableVariable/pull/182#discussion_r1967160153 --- .gitignore | 2 - .idea/inspectionProfiles/Project_Default.xml | 323 ------------------- 2 files changed, 325 deletions(-) delete mode 100644 .idea/inspectionProfiles/Project_Default.xml diff --git a/.gitignore b/.gitignore index 69fb61ad..d10feb99 100644 --- a/.gitignore +++ b/.gitignore @@ -11,8 +11,6 @@ nbactions.xml ### IntelliJ IDEA ### .idea/* -!.idea/inspectionProfiles -!.idea/runConfigurations *.iws *.iml *.ipr diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml deleted file mode 100644 index 0ad4972f..00000000 --- a/.idea/inspectionProfiles/Project_Default.xml +++ /dev/null @@ -1,323 +0,0 @@ - - - - \ No newline at end of file From d75be137892548a3c5a1b85a54a0c1b1afca9d06 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Wed, 26 Feb 2025 09:15:22 +0100 Subject: [PATCH 72/82] remove reduceToOriginalValue, see https://github.com/tls-attacker/ModifiableVariable/pull/182#discussion_r1969046894 --- .../modifiablevariable/ModifiableVariable.java | 15 --------------- 1 file changed, 15 deletions(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java index c5277a91..2f310f9f 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -275,21 +275,6 @@ private E getModifiedValue() { return resultValue; } - /** - * Sets the original value to the value changed by the modification. The modification is then - * set to null, to reduce the modifiable variable to the original value. - * - *

createRandomModification is ignored - */ - public void reduceToOriginalValue(boolean evenWithNullOriginalValue) { - if (evenWithNullOriginalValue || getOriginalValue() != null) { - if (modifications != null) { - setOriginalValue(getModifiedValue()); - modifications = null; - } - } - } - public abstract E getOriginalValue(); public abstract void setOriginalValue(E originalValue); From deb69e25906e2d71e8760d808c491f2a395e37ae Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Wed, 26 Feb 2025 09:32:03 +0100 Subject: [PATCH 73/82] Remove modification filter feature see: https://github.com/tls-attacker/ModifiableVariable/pull/182#discussion_r1969077913 Also removing all propOrder annotations, because without modificationFilter the order is the same as specified. --- .../ModificationFilter.java | 32 -------- .../VariableModification.java | 29 +------ .../biginteger/BigIntegerAddModification.java | 2 - .../BigIntegerAppendValueModification.java | 2 - ...egerExplicitValueFromFileModification.java | 2 - .../BigIntegerExplicitValueModification.java | 2 - .../BigIntegerInsertValueModification.java | 2 - .../BigIntegerMultiplyModification.java | 2 - .../BigIntegerPrependValueModification.java | 2 - .../BigIntegerShiftLeftModification.java | 2 - .../BigIntegerShiftRightModification.java | 2 - .../BigIntegerSubtractModification.java | 2 - .../biginteger/BigIntegerXorModification.java | 2 - .../BooleanExplicitValueModification.java | 2 - .../bool/BooleanToggleModification.java | 2 - .../ByteArrayAppendValueModification.java | 2 - .../ByteArrayDeleteModification.java | 2 - .../ByteArrayDuplicateModification.java | 2 - ...rrayExplicitValueFromFileModification.java | 2 - .../ByteArrayExplicitValueModification.java | 2 - .../ByteArrayInsertValueModification.java | 2 - .../ByteArrayPrependValueModification.java | 2 - .../ByteArrayShuffleModification.java | 2 - .../bytearray/ByteArrayXorModification.java | 2 - .../filter/AccessModificationFilter.java | 76 ------------------- .../filter/ModificationFilterFactory.java | 19 ----- .../integer/IntegerAddModification.java | 2 - .../IntegerAppendValueModification.java | 2 - ...egerExplicitValueFromFileModification.java | 2 - .../IntegerExplicitValueModification.java | 2 - .../IntegerInsertValueModification.java | 2 - .../integer/IntegerMultiplyModification.java | 2 - .../IntegerPrependValueModification.java | 2 - .../integer/IntegerShiftLeftModification.java | 2 - .../IntegerShiftRightModification.java | 2 - .../integer/IntegerSubtractModification.java | 2 - .../IntegerSwapEndianModification.java | 2 - .../integer/IntegerXorModification.java | 2 - .../longint/LongAddModification.java | 2 - .../longint/LongAppendValueModification.java | 2 - ...LongExplicitValueFromFileModification.java | 2 - .../LongExplicitValueModification.java | 2 - .../longint/LongInsertValueModification.java | 2 - .../longint/LongMultiplyModification.java | 2 - .../longint/LongPrependValueModification.java | 2 - .../longint/LongShiftLeftModification.java | 2 - .../longint/LongShiftRightModification.java | 2 - .../longint/LongSubtractModification.java | 2 - .../longint/LongSwapEndianModification.java | 2 - .../longint/LongXorModification.java | 2 - .../path/PathAppendValueModification.java | 2 - .../path/PathDeleteModification.java | 2 - ...PathExplicitValueFromFileModification.java | 2 - .../path/PathExplicitValueModification.java | 2 - ...hInsertDirectorySeparatorModification.java | 2 - ...hInsertDirectoryTraversalModification.java | 2 - .../path/PathInsertValueModification.java | 2 - .../path/PathPrependValueModification.java | 2 - .../path/PathToggleRootModification.java | 2 - .../singlebyte/ByteAddModification.java | 2 - ...ByteExplicitValueFromFileModification.java | 2 - .../ByteExplicitValueModification.java | 2 - .../singlebyte/ByteSubtractModification.java | 2 - .../string/StringAppendValueModification.java | 2 - .../string/StringDeleteModification.java | 2 - ...ringExplicitValueFromFileModification.java | 2 - .../StringExplicitValueModification.java | 2 - .../string/StringInsertValueModification.java | 2 - .../StringPrependValueModification.java | 2 - .../filter/ModificationApprovalTest.java | 63 --------------- .../BigIntegerSerializationTest.java | 24 ------ .../ByteArraySerializationTest.java | 24 ------ .../serialization/LongSerializationTest.java | 22 ------ .../serialization/PathSerializationTest.java | 23 ------ .../StringSerializationTest.java | 24 ------ 75 files changed, 2 insertions(+), 464 deletions(-) delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/ModificationFilter.java delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/filter/AccessModificationFilter.java delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/filter/ModificationFilterFactory.java delete mode 100644 src/test/java/de/rub/nds/modifiablevariable/filter/ModificationApprovalTest.java 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 24816427..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/ModificationFilter.java +++ /dev/null @@ -1,32 +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 { - - protected ModificationFilter() { - super(); - } - - protected ModificationFilter(ModificationFilter other) { - super(); - } - - public abstract ModificationFilter createCopy(); - - 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 fc290d17..01c4d723 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java @@ -9,12 +9,9 @@ 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.XmlTransient; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; @@ -25,34 +22,20 @@ 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( - @XmlElement(type = AccessModificationFilter.class, name = "AccessModificationFilter")) - private ModificationFilter modificationFilter; - protected VariableModification() { super(); } protected VariableModification(VariableModification other) { super(); - modificationFilter = - other.modificationFilter != null ? other.modificationFilter.createCopy() : null; } public abstract VariableModification createCopy(); public E modify(E input) { E modifiedValue = modifyImplementationHook(input); - if (modificationFilter == null || !modificationFilter.filterModification()) { - debug(modifiedValue); - return modifiedValue; - } else { - return input; - } + debug(modifiedValue); + return modifiedValue; } protected abstract E modifyImplementationHook(E input); @@ -87,12 +70,4 @@ protected void debug(E value) { 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 dc8925d1..3db45077 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java @@ -9,12 +9,10 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.math.BigInteger; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"summand", "modificationFilter"}) public class BigIntegerAddModification extends VariableModification { private BigInteger summand; diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java index 74978df3..6e4fefd0 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java @@ -9,12 +9,10 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.math.BigInteger; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"appendValue", "modificationFilter"}) public class BigIntegerAppendValueModification extends VariableModification { private BigInteger appendValue; diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java index 452e7cee..b9ae55f6 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java @@ -8,12 +8,10 @@ package de.rub.nds.modifiablevariable.biginteger; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.math.BigInteger; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = "index") public class BigIntegerExplicitValueFromFileModification extends BigIntegerExplicitValueModification { private int index; 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 62b6a34b..ac739e83 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java @@ -9,12 +9,10 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.math.BigInteger; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"explicitValue", "modificationFilter"}) public class BigIntegerExplicitValueModification extends VariableModification { protected BigInteger explicitValue; diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java index ada942b1..e50e1206 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java @@ -9,12 +9,10 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.math.BigInteger; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"insertValue", "startPosition", "modificationFilter"}) public class BigIntegerInsertValueModification extends VariableModification { private BigInteger insertValue; 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 421cfac1..f7918b32 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java @@ -9,12 +9,10 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.math.BigInteger; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"factor", "modificationFilter"}) public class BigIntegerMultiplyModification extends VariableModification { private BigInteger factor; diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java index 2e359563..c60c9829 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java @@ -9,12 +9,10 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.math.BigInteger; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"prependValue", "modificationFilter"}) public class BigIntegerPrependValueModification extends VariableModification { private BigInteger prependValue; 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 83f0ec6b..21695d78 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java @@ -9,11 +9,9 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.math.BigInteger; @XmlRootElement -@XmlType(propOrder = {"shift", "modificationFilter"}) public class BigIntegerShiftLeftModification extends VariableModification { private int 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 4fa5218f..3845d3f8 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java @@ -9,11 +9,9 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.math.BigInteger; @XmlRootElement -@XmlType(propOrder = {"shift", "modificationFilter"}) public class BigIntegerShiftRightModification extends VariableModification { private int 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 94f49c90..356463b8 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java @@ -9,12 +9,10 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.math.BigInteger; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"subtrahend", "modificationFilter"}) public class BigIntegerSubtractModification extends VariableModification { private BigInteger 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 e7dd2396..10d79b3a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java @@ -9,12 +9,10 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.math.BigInteger; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"xor", "modificationFilter"}) public class BigIntegerXorModification extends VariableModification { private BigInteger xor; 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 f24c5f67..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,10 +9,8 @@ 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; 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 b53b8036..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,10 +9,8 @@ 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() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java index 12a41637..627d8e35 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java @@ -11,12 +11,10 @@ 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.XmlType; import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.util.Arrays; @XmlRootElement -@XmlType(propOrder = {"bytesToAppend", "modificationFilter"}) public class ByteArrayAppendValueModification extends VariableModification { @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) 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 7970759d..592ef978 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java @@ -10,11 +10,9 @@ import de.rub.nds.modifiablevariable.VariableModification; import de.rub.nds.modifiablevariable.util.ArrayConverter; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Arrays; @XmlRootElement -@XmlType(propOrder = {"count", "startPosition", "modificationFilter"}) public class ByteArrayDeleteModification extends VariableModification { private int count; 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 6fc82563..c8f13fda 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDuplicateModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDuplicateModification.java @@ -10,10 +10,8 @@ import de.rub.nds.modifiablevariable.VariableModification; import de.rub.nds.modifiablevariable.util.ArrayConverter; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; @XmlRootElement -@XmlType(propOrder = "modificationFilter") public class ByteArrayDuplicateModification extends VariableModification { public ByteArrayDuplicateModification() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueFromFileModification.java index 083705b8..8abfa7c5 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueFromFileModification.java @@ -9,11 +9,9 @@ import de.rub.nds.modifiablevariable.util.ArrayConverter; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Arrays; @XmlRootElement -@XmlType(propOrder = "index") public class ByteArrayExplicitValueFromFileModification extends ByteArrayExplicitValueModification { private int index; 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 184996d9..e1a43b44 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java @@ -11,12 +11,10 @@ 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.XmlType; import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.util.Arrays; @XmlRootElement -@XmlType(propOrder = {"explicitValue", "modificationFilter"}) public class ByteArrayExplicitValueModification extends VariableModification { @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java index 1b17d4ee..d07e76cf 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java @@ -11,12 +11,10 @@ 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.XmlType; import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.util.Arrays; @XmlRootElement -@XmlType(propOrder = {"bytesToInsert", "startPosition", "modificationFilter"}) public class ByteArrayInsertValueModification extends VariableModification { @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java index 3949d8d1..f76d25d3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java @@ -11,12 +11,10 @@ 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.XmlType; import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.util.Arrays; @XmlRootElement -@XmlType(propOrder = {"bytesToPrepend", "modificationFilter"}) public class ByteArrayPrependValueModification extends VariableModification { @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) 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 1c8a7546..150e6311 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayShuffleModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayShuffleModification.java @@ -11,7 +11,6 @@ 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.XmlType; import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.util.Arrays; @@ -20,7 +19,6 @@ * are currently defined as bytes, since we are modifying rather smaller arrays. */ @XmlRootElement -@XmlType(propOrder = {"shuffle", "modificationFilter"}) public class ByteArrayShuffleModification extends VariableModification { @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) 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 3ede43d7..ff63f644 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java @@ -11,12 +11,10 @@ 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.XmlType; import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.util.Arrays; @XmlRootElement -@XmlType(propOrder = {"xor", "startPosition", "modificationFilter"}) public class ByteArrayXorModification extends VariableModification { @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) 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 cbf940ac..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/filter/AccessModificationFilter.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.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() { - super(); - accessCounter = 1; - } - - public AccessModificationFilter(int[] accessNumbers) { - super(); - accessCounter = 1; - this.accessNumbers = accessNumbers; - } - - public AccessModificationFilter(AccessModificationFilter other) { - super(other); - accessCounter = other.accessCounter; - accessNumbers = other.accessNumbers != null ? other.accessNumbers.clone() : null; - } - - @Override - public AccessModificationFilter createCopy() { - return new AccessModificationFilter(this); - } - - @Override - public boolean filterModification() { - boolean filter = contains(accessNumbers, accessCounter); - accessCounter++; - return filter; - } - - private static 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 66a46b03..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/filter/ModificationFilterFactory.java +++ /dev/null @@ -1,19 +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 final class ModificationFilterFactory { - - public static AccessModificationFilter access(int[] accessNumbers) { - return new AccessModificationFilter(accessNumbers); - } - - private ModificationFilterFactory() { - super(); - } -} 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 df3179bd..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,11 +9,9 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"summand", "modificationFilter"}) public class IntegerAddModification extends VariableModification { private Integer summand; diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java index f3f0941e..880ad316 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java @@ -9,11 +9,9 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"appendValue", "modificationFilter"}) public class IntegerAppendValueModification extends VariableModification { private Integer appendValue; diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java index b253e898..5ff68e6b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java @@ -8,11 +8,9 @@ package de.rub.nds.modifiablevariable.integer; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = "index") public class IntegerExplicitValueFromFileModification extends IntegerExplicitValueModification { private int index; 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 380125c5..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,11 +9,9 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"explicitValue", "modificationFilter"}) public class IntegerExplicitValueModification extends VariableModification { protected Integer explicitValue; diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java index 62393bda..1ef0c28e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java @@ -9,11 +9,9 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"insertValue", "startPosition", "modificationFilter"}) public class IntegerInsertValueModification extends VariableModification { private Integer insertValue; diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java index acf219ca..9a853051 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java @@ -9,11 +9,9 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"factor", "modificationFilter"}) public class IntegerMultiplyModification extends VariableModification { private Integer factor; diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java index 0c8ebd34..455b544d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java @@ -9,11 +9,9 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"prependValue", "modificationFilter"}) public class IntegerPrependValueModification extends VariableModification { private Integer prependValue; 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 9525ed2f..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,10 +9,8 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; @XmlRootElement -@XmlType(propOrder = {"shift", "modificationFilter"}) public class IntegerShiftLeftModification extends VariableModification { private static final int MAX_SHIFT_MODIFIER = 32; 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 bbe167a6..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,10 +9,8 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; @XmlRootElement -@XmlType(propOrder = {"shift", "modificationFilter"}) public class IntegerShiftRightModification extends VariableModification { private static final int MAX_SHIFT_MODIFIER = 32; 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 6dc45563..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,11 +9,9 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"subtrahend", "modificationFilter"}) public class IntegerSubtractModification extends VariableModification { private Integer 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 index 6ec89c1b..4a7fcdf7 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSwapEndianModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSwapEndianModification.java @@ -9,10 +9,8 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; @XmlRootElement -@XmlType(propOrder = "modificationFilter") public class IntegerSwapEndianModification extends VariableModification { public 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 df3e5ec6..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,11 +9,9 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"xor", "modificationFilter"}) public class IntegerXorModification extends VariableModification { private Integer xor; 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 1fd4135c..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,11 +9,9 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"summand", "modificationFilter"}) public class LongAddModification extends VariableModification { private Long summand; diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java index 23c42895..0c69c6a2 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java @@ -9,11 +9,9 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"appendValue", "modificationFilter"}) public class LongAppendValueModification extends VariableModification { private Long appendValue; diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java index 2a744153..0062ca9e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java @@ -8,11 +8,9 @@ package de.rub.nds.modifiablevariable.longint; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = "index") public class LongExplicitValueFromFileModification extends LongExplicitValueModification { private int index; 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 f0fce781..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,11 +9,9 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"explicitValue", "modificationFilter"}) public class LongExplicitValueModification extends VariableModification { protected Long explicitValue; diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java index 373e0456..00b6279e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java @@ -9,11 +9,9 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"insertValue", "startPosition", "modificationFilter"}) public class LongInsertValueModification extends VariableModification { private Long insertValue; diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java index 5bf91160..33a890c1 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java @@ -9,11 +9,9 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"factor", "modificationFilter"}) public class LongMultiplyModification extends VariableModification { private Long factor; diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java index 50d68116..4fef4aee 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java @@ -9,11 +9,9 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"prependValue", "modificationFilter"}) public class LongPrependValueModification extends VariableModification { private Long prependValue; diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java index d935404b..359ccf16 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java @@ -9,11 +9,9 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"shift", "modificationFilter"}) public class LongShiftLeftModification extends VariableModification { private static final int MAX_SHIFT_MODIFIER = 64; diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java index 87890095..145d3fb2 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java @@ -9,11 +9,9 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"shift", "modificationFilter"}) public class LongShiftRightModification extends VariableModification { private static final int MAX_SHIFT_MODIFIER = 64; 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 5a9a21e4..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,11 +9,9 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"subtrahend", "modificationFilter"}) public class LongSubtractModification extends VariableModification { private Long 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 index ae4c394d..ae0050da 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongSwapEndianModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongSwapEndianModification.java @@ -9,10 +9,8 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; @XmlRootElement -@XmlType(propOrder = "modificationFilter") public class LongSwapEndianModification extends VariableModification { public 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 94d69395..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,11 +9,9 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"xor", "modificationFilter"}) public class LongXorModification extends VariableModification { private Long xor; diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java index 9dbc622c..822b177a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java @@ -12,13 +12,11 @@ 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 path parts to the original value. */ @XmlRootElement -@XmlType(propOrder = {"appendValue", "modificationFilter"}) public class PathAppendValueModification extends VariableModification { @XmlJavaTypeAdapter(IllegalStringAdapter.class) diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathDeleteModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathDeleteModification.java index bb50f031..7413c1e5 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathDeleteModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathDeleteModification.java @@ -10,13 +10,11 @@ import de.rub.nds.modifiablevariable.VariableModification; import de.rub.nds.modifiablevariable.util.ArrayConverter; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Arrays; import java.util.Objects; /** Modification that deletes path parts from the original value. */ @XmlRootElement -@XmlType(propOrder = {"count", "startPosition", "modificationFilter"}) public class PathDeleteModification extends VariableModification { private int count; diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java index bd07f9e2..c7c32d89 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java @@ -10,11 +10,9 @@ import static de.rub.nds.modifiablevariable.util.StringUtil.backslashEscapeString; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = "index") public class PathExplicitValueFromFileModification extends PathExplicitValueModification { private int index; diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java index 84fa43d9..ecaf6de9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java @@ -12,12 +12,10 @@ 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 PathExplicitValueModification extends VariableModification { @XmlJavaTypeAdapter(IllegalStringAdapter.class) diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectorySeparatorModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectorySeparatorModification.java index eca8ad8a..5babf468 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectorySeparatorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectorySeparatorModification.java @@ -10,13 +10,11 @@ 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 inserts directory separators as path parts to the original value. */ @XmlRootElement -@XmlType(propOrder = {"insertValue", "count", "startPosition", "modificationFilter"}) public class PathInsertDirectorySeparatorModification extends VariableModification { @XmlJavaTypeAdapter(IllegalStringAdapter.class) diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java index a91db51a..45f27303 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java @@ -10,13 +10,11 @@ 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 directory traversal path parts the original value. */ @XmlRootElement -@XmlType(propOrder = {"insertValue", "count", "startPosition", "modificationFilter"}) public class PathInsertDirectoryTraversalModification extends VariableModification { @XmlJavaTypeAdapter(IllegalStringAdapter.class) diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java index e09576cb..47f8c49a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java @@ -12,13 +12,11 @@ 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 inserts path parts to the original value. */ @XmlRootElement -@XmlType(propOrder = {"insertValue", "startPosition", "modificationFilter"}) public class PathInsertValueModification extends VariableModification { @XmlJavaTypeAdapter(IllegalStringAdapter.class) diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java index c621ca00..2b73cb18 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java @@ -12,13 +12,11 @@ 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 PathPrependValueModification extends VariableModification { @XmlJavaTypeAdapter(IllegalStringAdapter.class) diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootModification.java index efcec4e0..90c2a439 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootModification.java @@ -9,11 +9,9 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; /** Modification that toggle the root slash of the original value. */ @XmlRootElement -@XmlType(propOrder = "modificationFilter") public class PathToggleRootModification extends VariableModification { public PathToggleRootModification() { 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 017dee27..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,11 +9,9 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"summand", "modificationFilter"}) public class ByteAddModification extends VariableModification { private Byte summand; diff --git a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java index 114078a0..607d2a63 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java @@ -8,11 +8,9 @@ package de.rub.nds.modifiablevariable.singlebyte; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = "index") public class ByteExplicitValueFromFileModification extends ByteExplicitValueModification { private int index; 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 e0d0a4c1..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,11 +9,9 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"explicitValue", "modificationFilter"}) public class ByteExplicitValueModification extends VariableModification { protected Byte explicitValue; 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 800d3ff3..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,11 +9,9 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = {"subtrahend", "modificationFilter"}) public class ByteSubtractModification extends VariableModification { private Byte subtrahend; 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 e3c98ba4..22f6ebee 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java @@ -12,13 +12,11 @@ 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) diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringDeleteModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringDeleteModification.java index 4383720b..9ba8ff91 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringDeleteModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringDeleteModification.java @@ -9,12 +9,10 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; /** Modification that deletes part of a string from the original value. */ @XmlRootElement -@XmlType(propOrder = {"count", "startPosition", "modificationFilter"}) public class StringDeleteModification extends VariableModification { private int count; diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java index 80ac4c2e..e7b88765 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java @@ -10,11 +10,9 @@ import static de.rub.nds.modifiablevariable.util.StringUtil.backslashEscapeString; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; @XmlRootElement -@XmlType(propOrder = "index") public class StringExplicitValueFromFileModification extends StringExplicitValueModification { private int index; 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 d88fd48f..e81851e9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java @@ -12,13 +12,11 @@ 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) diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java index 13e19b48..d58ca3fd 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java @@ -12,13 +12,11 @@ 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 inserts a string to the original value. */ @XmlRootElement -@XmlType(propOrder = {"insertValue", "startPosition", "modificationFilter"}) public class StringInsertValueModification extends VariableModification { @XmlJavaTypeAdapter(IllegalStringAdapter.class) 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 caaec3ea..47441905 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java @@ -12,13 +12,11 @@ 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) 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/serialization/BigIntegerSerializationTest.java b/src/test/java/de/rub/nds/modifiablevariable/serialization/BigIntegerSerializationTest.java index 784ea5a4..3cc1044f 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/serialization/BigIntegerSerializationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/serialization/BigIntegerSerializationTest.java @@ -15,8 +15,6 @@ 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; @@ -98,26 +96,4 @@ public void testSerializeDeserializeWithModification() throws Exception { 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 39b9abb9..d7275e51 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; @@ -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/LongSerializationTest.java b/src/test/java/de/rub/nds/modifiablevariable/serialization/LongSerializationTest.java index 815c05d8..73622722 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; @@ -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/PathSerializationTest.java b/src/test/java/de/rub/nds/modifiablevariable/serialization/PathSerializationTest.java index 2f427559..179c07d2 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/serialization/PathSerializationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/serialization/PathSerializationTest.java @@ -10,8 +10,6 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import de.rub.nds.modifiablevariable.VariableModification; -import de.rub.nds.modifiablevariable.filter.AccessModificationFilter; -import de.rub.nds.modifiablevariable.filter.ModificationFilterFactory; import de.rub.nds.modifiablevariable.path.ModifiablePath; import de.rub.nds.modifiablevariable.path.PathModificationFactory; import jakarta.xml.bind.JAXBContext; @@ -87,25 +85,4 @@ public void testSerializeDeserializeWithModification() throws Exception { result = unmarshalled.getValue(); assertEquals(expectedResult, result); } - - @Test - public void testSerializeDeserializeWithModificationFilter() throws Exception { - VariableModification modifier = PathModificationFactory.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(); - ModifiablePath unmarshalled = (ModifiablePath) um.unmarshal(new StringReader(xmlString)); - - // it happens nothing, because the modification is filtered - expectedResult = "Hello from Test ❤️\\ \u0000 \u0001 \u0006"; - result = unmarshalled.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 index d4b72ede..84990a04 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/serialization/StringSerializationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/serialization/StringSerializationTest.java @@ -11,8 +11,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 de.rub.nds.modifiablevariable.string.ModifiableString; import de.rub.nds.modifiablevariable.string.StringModificationFactory; import jakarta.xml.bind.JAXBContext; @@ -90,26 +88,4 @@ public void testSerializeDeserializeWithModification() throws Exception { result = unmarshalled.getValue(); assertEquals(expectedResult, result); } - - @Test - public void testSerializeDeserializeWithModificationFilter() throws Exception { - VariableModification modifier = StringModificationFactory.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(); - ModifiableString unmarshalled = - (ModifiableString) um.unmarshal(new StringReader(xmlString)); - - // it happens nothing, because the modification is filtered - expectedResult = "Hello from Test ❤️\\ \u0000 \u0001 \u0006"; - result = unmarshalled.getValue(); - assertEquals(expectedResult, result); - } } From 3c3b6a0ced99d77e85af4e50bca8dd06e624b6b2 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Wed, 26 Feb 2025 09:43:21 +0100 Subject: [PATCH 74/82] Use Pattern Variables where possible --- .../rub/nds/modifiablevariable/ModifiableVariableHolder.java | 3 +-- .../modifiablevariable/biginteger/ModifiableBigInteger.java | 4 +--- .../de/rub/nds/modifiablevariable/bool/ModifiableBoolean.java | 4 +--- .../nds/modifiablevariable/bytearray/ModifiableByteArray.java | 4 +--- .../rub/nds/modifiablevariable/integer/ModifiableInteger.java | 4 +--- .../nds/modifiablevariable/length/ModifiableLengthField.java | 4 +--- .../de/rub/nds/modifiablevariable/longint/ModifiableLong.java | 4 +--- .../de/rub/nds/modifiablevariable/path/ModifiablePath.java | 4 +--- .../rub/nds/modifiablevariable/singlebyte/ModifiableByte.java | 4 +--- .../rub/nds/modifiablevariable/string/ModifiableString.java | 4 +--- .../serialization/StringSerializationTest.java | 1 - 11 files changed, 10 insertions(+), 30 deletions(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableHolder.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableHolder.java index 3cb93dd1..73f6a3c3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableHolder.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableHolder.java @@ -115,8 +115,7 @@ protected String getExtendedString(int depth) { LOGGER.debug(ex); } if (tempObject != null) { - if (tempObject instanceof byte[]) { - byte[] temp = (byte[]) tempObject; + if (tempObject instanceof byte[] temp) { stringBuilder.append("\t".repeat(Math.max(0, depth))); stringBuilder.append(field.getName()); stringBuilder.append(": "); 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 85e1d071..1414963b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigInteger.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigInteger.java @@ -85,12 +85,10 @@ public boolean equals(Object obj) { if (this == obj) { return true; } - if (!(obj instanceof ModifiableBigInteger)) { + if (!(obj instanceof ModifiableBigInteger that)) { return false; } - ModifiableBigInteger that = (ModifiableBigInteger) obj; - return getValue() != null ? getValue().equals(that.getValue()) : that.getValue() == null; } 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 60bab446..b695ca89 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/ModifiableBoolean.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/ModifiableBoolean.java @@ -67,12 +67,10 @@ public boolean equals(Object obj) { if (this == obj) { return true; } - if (!(obj instanceof ModifiableBoolean)) { + if (!(obj instanceof ModifiableBoolean that)) { return false; } - ModifiableBoolean that = (ModifiableBoolean) obj; - return getValue() != null ? getValue().equals(that.getValue()) : that.getValue() == null; } 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 f69d18e9..4f98986a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArray.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArray.java @@ -83,12 +83,10 @@ public boolean equals(Object obj) { if (this == obj) { return true; } - if (!(obj instanceof ModifiableByteArray)) { + if (!(obj instanceof ModifiableByteArray that)) { return false; } - ModifiableByteArray that = (ModifiableByteArray) obj; - return Arrays.equals(getValue(), that.getValue()); } 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 c2932275..0d5e0984 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/ModifiableInteger.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/ModifiableInteger.java @@ -83,12 +83,10 @@ public boolean equals(Object obj) { if (this == obj) { return true; } - if (!(obj instanceof ModifiableInteger)) { + if (!(obj instanceof ModifiableInteger that)) { return false; } - ModifiableInteger that = (ModifiableInteger) obj; - 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 0afcfe2d..e77f0796 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/length/ModifiableLengthField.java +++ b/src/main/java/de/rub/nds/modifiablevariable/length/ModifiableLengthField.java @@ -55,12 +55,10 @@ public boolean equals(Object obj) { if (this == obj) { return true; } - if (!(obj instanceof ModifiableLengthField)) { + if (!(obj instanceof ModifiableLengthField that)) { return false; } - ModifiableLengthField that = (ModifiableLengthField) obj; - return ref != null ? getValue().equals(that.getValue()) : that.getValue() == null; } 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 8da4f62e..70c0bd8d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/ModifiableLong.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/ModifiableLong.java @@ -83,12 +83,10 @@ public boolean equals(Object obj) { if (this == obj) { return true; } - if (!(obj instanceof ModifiableLong)) { + if (!(obj instanceof ModifiableLong that)) { return false; } - ModifiableLong that = (ModifiableLong) obj; - return getValue() != null ? getValue().equals(that.getValue()) : that.getValue() == null; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java b/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java index 843076ac..6b73b5ee 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java +++ b/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java @@ -50,12 +50,10 @@ public boolean equals(Object obj) { if (this == obj) { return true; } - if (!(obj instanceof ModifiablePath)) { + if (!(obj instanceof ModifiablePath that)) { return false; } - ModifiablePath that = (ModifiablePath) obj; - return getValue() != null ? getValue().equals(that.getValue()) : that.getValue() == null; } } 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 7658df56..bc8adc22 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByte.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByte.java @@ -78,12 +78,10 @@ public boolean equals(Object obj) { if (this == obj) { return true; } - if (!(obj instanceof ModifiableByte)) { + if (!(obj instanceof ModifiableByte that)) { return false; } - ModifiableByte that = (ModifiableByte) obj; - 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 548f9ef7..0ba8cdfd 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java @@ -98,12 +98,10 @@ public boolean equals(Object obj) { if (this == obj) { return true; } - if (!(obj instanceof ModifiableString)) { + if (!(obj instanceof ModifiableString that)) { return false; } - ModifiableString that = (ModifiableString) obj; - return getValue() != null ? getValue().equals(that.getValue()) : that.getValue() == null; } diff --git a/src/test/java/de/rub/nds/modifiablevariable/serialization/StringSerializationTest.java b/src/test/java/de/rub/nds/modifiablevariable/serialization/StringSerializationTest.java index 84990a04..26bb1e6a 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/serialization/StringSerializationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/serialization/StringSerializationTest.java @@ -10,7 +10,6 @@ import static org.junit.jupiter.api.Assertions.*; import de.rub.nds.modifiablevariable.VariableModification; -import de.rub.nds.modifiablevariable.bytearray.*; import de.rub.nds.modifiablevariable.string.ModifiableString; import de.rub.nds.modifiablevariable.string.StringModificationFactory; import jakarta.xml.bind.JAXBContext; From 7fa74487ee0900b55e920888a34aabb0b1a480d1 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Wed, 26 Feb 2025 09:58:13 +0100 Subject: [PATCH 75/82] Remove softlySet Methods. See https://github.com/tls-attacker/ModifiableVariable/pull/182#discussion_r1969049661 --- .../ModifiableVariableFactory.java | 214 ------------------ 1 file changed, 214 deletions(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableFactory.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableFactory.java index 3c0d2f1a..feb687f0 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableFactory.java @@ -59,33 +59,6 @@ public static ModifiableBigInteger safelySetValue(ModifiableBigInteger mv, BigIn return mv; } - /** - * Returns only a ModifiableBigInteger with the value, if the given mv is null or the original - * value of the mv is null - */ - public static ModifiableBigInteger softlySetValue(ModifiableBigInteger mv, BigInteger value) { - if (mv == null) { - return new ModifiableBigInteger(value); - } else if (mv.getOriginalValue() == null) { - mv.setOriginalValue(value); - } - return mv; - } - - /** - * Returns only a ModifiableBigInteger with the value, if the given mv is null or the original - * value of the mv is null or alwaysSet is true - */ - public static ModifiableBigInteger softlySetValue( - ModifiableBigInteger mv, BigInteger value, boolean alwaysSet) { - if (mv == null) { - return new ModifiableBigInteger(value); - } else if (alwaysSet || mv.getOriginalValue() == null) { - mv.setOriginalValue(value); - } - return mv; - } - public static ModifiableString safelySetValue(ModifiableString mv, String value) { if (mv == null) { return new ModifiableString(value); @@ -94,33 +67,6 @@ public static ModifiableString safelySetValue(ModifiableString mv, String value) return mv; } - /** - * Returns only a ModifiableString with the value, if the given mv is null or the original value - * of the mv is null - */ - public static ModifiableString softlySetValue(ModifiableString mv, String value) { - if (mv == null) { - return new ModifiableString(value); - } else if (mv.getOriginalValue() == null) { - mv.setOriginalValue(value); - } - return mv; - } - - /** - * Returns only a ModifiableString with the value, if the given mv is null or the original value - * of the mv is null or alwaysSet is true - */ - public static ModifiableString softlySetValue( - ModifiableString mv, String value, boolean alwaysSet) { - if (mv == null) { - return new ModifiableString(value); - } else if (alwaysSet || mv.getOriginalValue() == null) { - mv.setOriginalValue(value); - } - return mv; - } - public static ModifiableInteger safelySetValue(ModifiableInteger mv, Integer value) { if (mv == null) { return new ModifiableInteger(value); @@ -129,33 +75,6 @@ public static ModifiableInteger safelySetValue(ModifiableInteger mv, Integer val return mv; } - /** - * Returns only a ModifiableInteger with the value, if the given mv is null or the original - * value of the mv is null - */ - public static ModifiableInteger softlySetValue(ModifiableInteger mv, Integer value) { - if (mv == null) { - return new ModifiableInteger(value); - } else if (mv.getOriginalValue() == null) { - mv.setOriginalValue(value); - } - return mv; - } - - /** - * Returns only a ModifiableInteger with the value, if the given mv is null or the original - * value of the mv is null or alwaysSet is true - */ - public static ModifiableInteger softlySetValue( - ModifiableInteger mv, Integer value, boolean alwaysSet) { - if (mv == null) { - return new ModifiableInteger(value); - } else if (alwaysSet || mv.getOriginalValue() == null) { - mv.setOriginalValue(value); - } - return mv; - } - public static ModifiableByte safelySetValue(ModifiableByte mv, Byte value) { if (mv == null) { return new ModifiableByte(value); @@ -164,32 +83,6 @@ public static ModifiableByte safelySetValue(ModifiableByte mv, Byte value) { return mv; } - /** - * Returns only a ModifiableByte with the value, if the given mv is null or the original value - * of the mv is null - */ - public static ModifiableByte softlySetValue(ModifiableByte mv, Byte value) { - if (mv == null) { - return new ModifiableByte(value); - } else if (mv.getOriginalValue() == null) { - mv.setOriginalValue(value); - } - return mv; - } - - /** - * Returns only a ModifiableByte with the value, if the given mv is null or the original value - * of the mv is null or alwaysSet is true - */ - public static ModifiableByte softlySetValue(ModifiableByte mv, Byte value, boolean alwaysSet) { - if (mv == null) { - return new ModifiableByte(value); - } else if (alwaysSet || mv.getOriginalValue() == null) { - mv.setOriginalValue(value); - } - return mv; - } - public static ModifiableByteArray safelySetValue(ModifiableByteArray mv, byte[] value) { if (mv == null) { return new ModifiableByteArray(value); @@ -198,33 +91,6 @@ public static ModifiableByteArray safelySetValue(ModifiableByteArray mv, byte[] return mv; } - /** - * Returns only a ModifiableByteArray with the value, if the given mv is null or the original - * value of the mv is null - */ - public static ModifiableByteArray softlySetValue(ModifiableByteArray mv, byte[] value) { - if (mv == null) { - return new ModifiableByteArray(value); - } else if (mv.getOriginalValue() == null) { - mv.setOriginalValue(value); - } - return mv; - } - - /** - * Returns only a ModifiableByteArray with the value, if the given mv is null or the original - * value of the mv is null or alwaysSet is true - */ - public static ModifiableByteArray softlySetValue( - ModifiableByteArray mv, byte[] value, boolean alwaysSet) { - if (mv == null) { - return new ModifiableByteArray(value); - } else if (alwaysSet || mv.getOriginalValue() == null) { - mv.setOriginalValue(value); - } - return mv; - } - public static ModifiableLong safelySetValue(ModifiableLong mv, Long value) { if (mv == null) { return new ModifiableLong(value); @@ -233,32 +99,6 @@ public static ModifiableLong safelySetValue(ModifiableLong mv, Long value) { return mv; } - /** - * Returns only a ModifiableLong with the value, if the given mv is null or the original value - * of the mv is null - */ - public static ModifiableLong softlySetValue(ModifiableLong mv, Long value) { - if (mv == null) { - return new ModifiableLong(value); - } else if (mv.getOriginalValue() == null) { - mv.setOriginalValue(value); - } - return mv; - } - - /** - * Returns only a ModifiableLong with the value, if the given mv is null or the original value - * of the mv is null or alwaysSet is true - */ - public static ModifiableLong softlySetValue(ModifiableLong mv, Long value, boolean alwaysSet) { - if (mv == null) { - return new ModifiableLong(value); - } else if (alwaysSet || mv.getOriginalValue() == null) { - mv.setOriginalValue(value); - } - return mv; - } - public static ModifiableBoolean safelySetValue(ModifiableBoolean mv, Boolean value) { if (mv == null) { return new ModifiableBoolean(value); @@ -267,33 +107,6 @@ public static ModifiableBoolean safelySetValue(ModifiableBoolean mv, Boolean val return mv; } - /** - * Returns only a ModifiableBoolean with the value, if the given mv is null or the original - * value of the mv is null - */ - public static ModifiableBoolean softlySetValue(ModifiableBoolean mv, Boolean value) { - if (mv == null) { - return new ModifiableBoolean(value); - } else if (mv.getOriginalValue() == null) { - mv.setOriginalValue(value); - } - return mv; - } - - /** - * Returns only a ModifiableBoolean with the value, if the given mv is null or the original - * value of the mv is null or alwaysSet is true - */ - public static ModifiableBoolean softlySetValue( - ModifiableBoolean mv, Boolean value, boolean alwaysSet) { - if (mv == null) { - return new ModifiableBoolean(value); - } else if (alwaysSet || mv.getOriginalValue() == null) { - mv.setOriginalValue(value); - } - return mv; - } - public static ModifiablePath safelySetValue(ModifiablePath mv, String value) { if (mv == null) { return new ModifiablePath(value); @@ -302,33 +115,6 @@ public static ModifiablePath safelySetValue(ModifiablePath mv, String value) { return mv; } - /** - * Returns only a ModifiablePath with the value, if the given mv is null or the original value - * of the mv is null - */ - public static ModifiablePath softlySetValue(ModifiablePath mv, String value) { - if (mv == null) { - return new ModifiablePath(value); - } else if (mv.getOriginalValue() == null) { - mv.setOriginalValue(value); - } - return mv; - } - - /** - * Returns only a ModifiablePath with the value, if the given mv is null or the original value - * of the mv is null or alwaysSet is true - */ - public static ModifiablePath softlySetValue( - ModifiablePath mv, String value, boolean alwaysSet) { - if (mv == null) { - return new ModifiablePath(value); - } else if (alwaysSet || mv.getOriginalValue() == null) { - mv.setOriginalValue(value); - } - return mv; - } - private ModifiableVariableFactory() { super(); } From 02b7eaa57a051c4045ab422241dbe71f3011596f Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Wed, 26 Feb 2025 14:51:56 +0100 Subject: [PATCH 76/82] Use @XmlAnyElement(lax = true) instead of strong typing. See https://github.com/tls-attacker/ModifiableVariable/pull/182#discussion_r1967337723 Projects that relayed on strong typing need now to add all Modifications and Mod Vars to the JAXB Context. --- .../ModifiableVariable.java | 160 +----------------- .../serialization/PathSerializationTest.java | 3 +- .../StringSerializationTest.java | 5 +- 3 files changed, 7 insertions(+), 161 deletions(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java index 2f310f9f..c920eca2 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -7,15 +7,6 @@ */ package de.rub.nds.modifiablevariable; -import de.rub.nds.modifiablevariable.biginteger.*; -import de.rub.nds.modifiablevariable.bool.BooleanExplicitValueModification; -import de.rub.nds.modifiablevariable.bool.BooleanToggleModification; -import de.rub.nds.modifiablevariable.bytearray.*; -import de.rub.nds.modifiablevariable.integer.*; -import de.rub.nds.modifiablevariable.longint.*; -import de.rub.nds.modifiablevariable.path.*; -import de.rub.nds.modifiablevariable.singlebyte.*; -import de.rub.nds.modifiablevariable.string.*; import jakarta.xml.bind.annotation.*; import java.io.Serializable; import java.util.LinkedList; @@ -34,156 +25,7 @@ public abstract class ModifiableVariable implements Serializable { @XmlElementWrapper - @XmlElements({ - @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 = BigIntegerExplicitValueFromFileModification.class, - name = "BigIntegerExplicitValueFromFileModification"), - @XmlElement( - type = BigIntegerExplicitValueModification.class, - name = "BigIntegerExplicitValueModification"), - @XmlElement(type = BigIntegerAddModification.class, name = "BigIntegerAddModification"), - @XmlElement( - type = BigIntegerMultiplyModification.class, - name = "BigIntegerMultiplyModification"), - @XmlElement( - type = BigIntegerAppendValueModification.class, - name = "BigIntegerAppendValueModification"), - @XmlElement( - type = BigIntegerInsertValueModification.class, - name = "BigIntegerInsertValueModification"), - @XmlElement( - type = BigIntegerPrependValueModification.class, - name = "BigIntegerPrependValueModification"), - @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 = ByteArrayAppendValueModification.class, - name = "ByteArrayAppendValueModification"), - @XmlElement( - type = ByteArrayInsertValueModification.class, - name = "ByteArrayInsertValueModification"), - @XmlElement( - type = ByteArrayPrependValueModification.class, - name = "ByteArrayPrependValueModification"), - @XmlElement( - type = ByteArrayExplicitValueFromFileModification.class, - name = "ByteArrayExplicitValueFromFileModification"), - @XmlElement( - type = ByteArrayExplicitValueModification.class, - name = "ByteArrayExplicitValueModification"), - @XmlElement( - type = ByteArrayDuplicateModification.class, - name = "ByteArrayDuplicateModification"), - @XmlElement(type = ByteArrayDeleteModification.class, name = "ByteArrayDeleteModification"), - @XmlElement( - type = IntegerSwapEndianModification.class, - name = "IntegerSwapEndianModification"), - @XmlElement(type = IntegerXorModification.class, name = "IntegerXorModification"), - @XmlElement(type = IntegerSubtractModification.class, name = "IntegerSubtractModification"), - @XmlElement(type = IntegerMultiplyModification.class, name = "IntegerMultiplyModification"), - @XmlElement( - type = IntegerShiftRightModification.class, - name = "IntegerShiftRightModification"), - @XmlElement( - type = IntegerShiftLeftModification.class, - name = "IntegerShiftLeftModification"), - @XmlElement( - type = IntegerExplicitValueFromFileModification.class, - name = "IntegerExplicitValueFromFileModification"), - @XmlElement( - type = IntegerExplicitValueModification.class, - name = "IntegerExplicitValueModification"), - @XmlElement(type = IntegerAddModification.class, name = "IntegerAddModification"), - @XmlElement( - type = IntegerAppendValueModification.class, - name = "IntegerAppendValueModification"), - @XmlElement( - type = IntegerInsertValueModification.class, - name = "IntegerInsertValueModification"), - @XmlElement( - type = IntegerPrependValueModification.class, - name = "IntegerPrependValueModification"), - @XmlElement(type = LongXorModification.class, name = "LongXorModification"), - @XmlElement(type = LongSwapEndianModification.class, name = "LongSwapEndianModification"), - @XmlElement(type = LongSubtractModification.class, name = "LongSubtractModification"), - @XmlElement( - type = LongExplicitValueFromFileModification.class, - name = "LongExplicitValueFromFileModification"), - @XmlElement( - type = LongExplicitValueModification.class, - name = "LongExplicitValueModification"), - @XmlElement(type = LongAppendValueModification.class, name = "LongAppendValueModification"), - @XmlElement(type = LongInsertValueModification.class, name = "LongInsertValueModification"), - @XmlElement( - type = LongPrependValueModification.class, - name = "LongPrependValueModification"), - @XmlElement(type = LongMultiplyModification.class, name = "LongMultiplyModification"), - @XmlElement(type = LongShiftLeftModification.class, name = "LongShiftLeftModification"), - @XmlElement(type = LongShiftRightModification.class, name = "LongShiftRightModification"), - @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 = ByteExplicitValueFromFileModification.class, - name = "ByteExplicitValueFromFileModification"), - @XmlElement( - type = ByteExplicitValueModification.class, - name = "ByteExplicitValueModification"), - @XmlElement( - type = StringPrependValueModification.class, - name = "StringPrependValueModification"), - @XmlElement( - type = StringAppendValueModification.class, - name = "StringAppendValueModification"), - @XmlElement( - type = StringExplicitValueFromFileModification.class, - name = "StringExplicitValueFromFileModification"), - @XmlElement( - type = StringExplicitValueModification.class, - name = "StringExplicitValueModification"), - @XmlElement( - type = StringInsertValueModification.class, - name = "StringInsertValueModification"), - @XmlElement(type = StringDeleteModification.class, name = "StringDeleteModification"), - @XmlElement( - type = PathExplicitValueFromFileModification.class, - name = "PathExplicitValueFromFileModification"), - @XmlElement( - type = PathExplicitValueModification.class, - name = "PathExplicitValueModification"), - @XmlElement(type = PathAppendValueModification.class, name = "PathAppendValueModification"), - @XmlElement( - type = PathInsertDirectorySeparatorModification.class, - name = "PathInsertDirectorySeparatorModification"), - @XmlElement(type = PathDeleteModification.class, name = "PathDeleteModification"), - @XmlElement( - type = PathInsertDirectoryTraversalModification.class, - name = "PathInsertDirectoryTraversalValueModification"), - @XmlElement(type = PathInsertValueModification.class, name = "PathInsertValueModification"), - @XmlElement( - type = PathPrependValueModification.class, - name = "PathPrependValueModification"), - @XmlElement( - type = PathToggleRootModification.class, - name = "PathToggleRootValueModification"), - }) + @XmlAnyElement(lax = true) private LinkedList> modifications; protected E assertEquals; diff --git a/src/test/java/de/rub/nds/modifiablevariable/serialization/PathSerializationTest.java b/src/test/java/de/rub/nds/modifiablevariable/serialization/PathSerializationTest.java index 179c07d2..f1e1bdce 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/serialization/PathSerializationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/serialization/PathSerializationTest.java @@ -11,6 +11,7 @@ import de.rub.nds.modifiablevariable.VariableModification; import de.rub.nds.modifiablevariable.path.ModifiablePath; +import de.rub.nds.modifiablevariable.path.PathInsertValueModification; import de.rub.nds.modifiablevariable.path.PathModificationFactory; import jakarta.xml.bind.JAXBContext; import jakarta.xml.bind.JAXBException; @@ -46,7 +47,7 @@ public void setUp() throws JAXBException { result = null; writer = new StringWriter(); - context = JAXBContext.newInstance(ModifiablePath.class); + context = JAXBContext.newInstance(ModifiablePath.class, PathInsertValueModification.class); m = context.createMarshaller(); m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true); um = context.createUnmarshaller(); diff --git a/src/test/java/de/rub/nds/modifiablevariable/serialization/StringSerializationTest.java b/src/test/java/de/rub/nds/modifiablevariable/serialization/StringSerializationTest.java index 26bb1e6a..be2e0318 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/serialization/StringSerializationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/serialization/StringSerializationTest.java @@ -11,6 +11,7 @@ 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; @@ -46,7 +47,9 @@ public void setUp() throws JAXBException { result = null; writer = new StringWriter(); - context = JAXBContext.newInstance(ModifiableString.class); + context = + JAXBContext.newInstance( + ModifiableString.class, StringInsertValueModification.class); m = context.createMarshaller(); m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true); um = context.createUnmarshaller(); From 897eabe697907ed06a9f9498621a39cbe5baeef5 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Wed, 26 Feb 2025 15:58:04 +0100 Subject: [PATCH 77/82] Remove all createRandomModification() methods from all factories. Move all Append, Insert, Prepend Modifications for Integer, Long and BigInteger to Fuzzer code, because it does not fit into the vision of ModifiableVariables Framework (and are not self explained because they work at binary level). Remove all Explicit Value from file modifications. --- .../ModifiableVariableFactory.java | 13 -- .../BigIntegerAppendValueModification.java | 81 --------- ...egerExplicitValueFromFileModification.java | 79 --------- .../BigIntegerInsertValueModification.java | 117 ------------ .../BigIntegerModificationFactory.java | 121 ------------- .../BigIntegerPrependValueModification.java | 81 --------- .../bool/BooleanModificationFactory.java | 25 --- ...rrayExplicitValueFromFileModification.java | 78 -------- .../ByteArrayModificationFactory.java | 120 ------------- .../IntegerAppendValueModification.java | 80 --------- ...egerExplicitValueFromFileModification.java | 77 -------- .../IntegerInsertValueModification.java | 113 ------------ .../integer/IntegerModificationFactory.java | 122 ------------- .../IntegerPrependValueModification.java | 81 --------- .../longint/LongAppendValueModification.java | 80 --------- ...LongExplicitValueFromFileModification.java | 75 -------- .../longint/LongInsertValueModification.java | 112 ------------ .../longint/LongModificationFactory.java | 124 ------------- .../longint/LongPrependValueModification.java | 80 --------- .../path/ModifiablePath.java | 59 ------- .../path/PathAppendValueModification.java | 93 ---------- .../path/PathDeleteModification.java | 139 --------------- ...PathExplicitValueFromFileModification.java | 77 -------- .../path/PathExplicitValueModification.java | 86 --------- ...hInsertDirectorySeparatorModification.java | 115 ------------ ...hInsertDirectoryTraversalModification.java | 126 ------------- .../path/PathInsertValueModification.java | 105 ----------- .../path/PathModificationFactory.java | 146 --------------- .../path/PathPrependValueModification.java | 93 ---------- .../path/PathToggleRootModification.java | 61 ------- .../nds/modifiablevariable/path/PathUtil.java | 85 --------- ...ByteExplicitValueFromFileModification.java | 75 -------- .../singlebyte/ByteModificationFactory.java | 72 -------- .../string/ModifiableString.java | 1 - ...ringExplicitValueFromFileModification.java | 79 --------- .../StringExplicitValueModification.java | 1 - .../string/StringModificationFactory.java | 73 -------- .../modifiablevariable/util/BadRandom.java | 1 - .../util/IllegalStringAdapter.java | 1 - .../modifiablevariable/util/Modifiable.java | 81 --------- .../util/ModifiableVariableAnalyzer.java | 1 - .../modifiablevariable/util/RandomHelper.java | 1 - .../util/UnformattedByteArrayAdapter.java | 1 - .../nds/modifiablevariable/explicit/array.vec | 49 ----- .../nds/modifiablevariable/explicit/byte.vec | 9 - .../modifiablevariable/explicit/integer.vec | 27 --- .../nds/modifiablevariable/explicit/long.vec | 31 ---- .../BigIntegerModificationTest.java | 44 ----- .../integer/IntegerModificationTest.java | 35 ---- .../mlong/LongModificationTest.java | 34 ---- .../path/PathModificationTest.java | 167 ------------------ .../serialization/PathSerializationTest.java | 89 ---------- 52 files changed, 3716 deletions(-) delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueFromFileModification.java delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/path/PathDeleteModification.java delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectorySeparatorModification.java delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/path/PathModificationFactory.java delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootModification.java delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/path/PathUtil.java delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java delete mode 100644 src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java delete mode 100644 src/main/resources/de/rub/nds/modifiablevariable/explicit/array.vec delete mode 100644 src/main/resources/de/rub/nds/modifiablevariable/explicit/byte.vec delete mode 100644 src/main/resources/de/rub/nds/modifiablevariable/explicit/integer.vec delete mode 100644 src/main/resources/de/rub/nds/modifiablevariable/explicit/long.vec delete mode 100644 src/test/java/de/rub/nds/modifiablevariable/path/PathModificationTest.java delete mode 100644 src/test/java/de/rub/nds/modifiablevariable/serialization/PathSerializationTest.java diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableFactory.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableFactory.java index feb687f0..7f163b09 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableFactory.java @@ -12,7 +12,6 @@ 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.path.ModifiablePath; import de.rub.nds.modifiablevariable.singlebyte.ModifiableByte; import de.rub.nds.modifiablevariable.string.ModifiableString; import java.math.BigInteger; @@ -47,10 +46,6 @@ public static ModifiableString createStringModifiableVariable() { return new ModifiableString(); } - public static ModifiablePath createPathModifiableVariable() { - return new ModifiablePath(); - } - public static ModifiableBigInteger safelySetValue(ModifiableBigInteger mv, BigInteger value) { if (mv == null) { return new ModifiableBigInteger(value); @@ -107,14 +102,6 @@ public static ModifiableBoolean safelySetValue(ModifiableBoolean mv, Boolean val return mv; } - public static ModifiablePath safelySetValue(ModifiablePath mv, String value) { - if (mv == null) { - return new ModifiablePath(value); - } - mv.setOriginalValue(value); - return mv; - } - private ModifiableVariableFactory() { super(); } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java deleted file mode 100644 index 6e4fefd0..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAppendValueModification.java +++ /dev/null @@ -1,81 +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.XmlRootElement; -import java.math.BigInteger; -import java.util.Objects; - -@XmlRootElement -public class BigIntegerAppendValueModification extends VariableModification { - - private BigInteger appendValue; - - public BigIntegerAppendValueModification() { - super(); - } - - public BigIntegerAppendValueModification(BigInteger appendValue) { - super(); - this.appendValue = appendValue; - } - - public BigIntegerAppendValueModification(BigIntegerAppendValueModification other) { - super(other); - appendValue = other.appendValue; - } - - @Override - public BigIntegerAppendValueModification createCopy() { - return new BigIntegerAppendValueModification(this); - } - - @Override - protected BigInteger modifyImplementationHook(BigInteger input) { - if (input == null) { - input = BigInteger.ZERO; - } - return input.shiftLeft(appendValue.bitLength()).or(appendValue); - } - - public BigInteger getAppendValue() { - return appendValue; - } - - public void setAppendValue(BigInteger appendValue) { - this.appendValue = appendValue; - } - - @Override - public int hashCode() { - int hash = 7; - hash = 31 * hash + Objects.hashCode(appendValue); - return hash; - } - - @Override - public boolean equals(Object obj) { - if (this == obj) { - return true; - } - if (obj == null) { - return false; - } - if (getClass() != obj.getClass()) { - return false; - } - BigIntegerAppendValueModification other = (BigIntegerAppendValueModification) obj; - return Objects.equals(appendValue, other.appendValue); - } - - @Override - public String toString() { - return "BigIntegerAppendValueModification{" + "appendValue=" + appendValue + '}'; - } -} diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java deleted file mode 100644 index b9ae55f6..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueFromFileModification.java +++ /dev/null @@ -1,79 +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 jakarta.xml.bind.annotation.XmlRootElement; -import java.math.BigInteger; -import java.util.Objects; - -@XmlRootElement -public class BigIntegerExplicitValueFromFileModification - extends BigIntegerExplicitValueModification { - private int index; - - public BigIntegerExplicitValueFromFileModification() { - super(); - } - - public BigIntegerExplicitValueFromFileModification(int index, BigInteger explicitValue) { - super(explicitValue); - this.index = index; - } - - public BigIntegerExplicitValueFromFileModification( - BigIntegerExplicitValueFromFileModification other) { - super(other); - index = other.index; - } - - @Override - public BigIntegerExplicitValueFromFileModification createCopy() { - return new BigIntegerExplicitValueFromFileModification(this); - } - - public int getIndex() { - return index; - } - - @Override - public int hashCode() { - int hash = 7; - hash = 31 * hash + index; - hash = 31 * hash + Objects.hashCode(explicitValue); - return hash; - } - - @Override - public boolean equals(Object obj) { - if (this == obj) { - return true; - } - if (obj == null) { - return false; - } - if (getClass() != obj.getClass()) { - return false; - } - BigIntegerExplicitValueFromFileModification other = - (BigIntegerExplicitValueFromFileModification) obj; - if (index != other.index) { - return false; - } - return Objects.equals(explicitValue, other.explicitValue); - } - - @Override - public String toString() { - return "BigIntegerExplicitValueFromFileModification{" - + "index=" - + index - + ", explicitValue=" - + explicitValue - + '}'; - } -} diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java deleted file mode 100644 index e50e1206..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInsertValueModification.java +++ /dev/null @@ -1,117 +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.XmlRootElement; -import java.math.BigInteger; -import java.util.Objects; - -@XmlRootElement -public class BigIntegerInsertValueModification extends VariableModification { - - private BigInteger insertValue; - private int startPosition; - - public BigIntegerInsertValueModification() { - super(); - } - - public BigIntegerInsertValueModification(BigInteger insertValue, int startPosition) { - super(); - this.insertValue = insertValue; - this.startPosition = startPosition; - } - - public BigIntegerInsertValueModification(BigIntegerInsertValueModification other) { - super(other); - insertValue = other.insertValue; - startPosition = other.startPosition; - } - - @Override - public BigIntegerInsertValueModification createCopy() { - return new BigIntegerInsertValueModification(this); - } - - @Override - protected BigInteger modifyImplementationHook(BigInteger input) { - if (input == null) { - input = BigInteger.ZERO; - } - - int originalValueLength = input.bitLength(); - int insertValueLength = insertValue.bitLength(); - - // Wrap around and also allow to insert at the end of the original value - int insertPosition = startPosition % (originalValueLength + 1); - if (startPosition < 0) { - insertPosition += originalValueLength; - } - - BigInteger mask = BigInteger.valueOf((1L << insertPosition) - 1); - - return input.shiftRight(insertPosition) - .shiftLeft(insertValueLength) - .or(insertValue) - .shiftLeft(insertPosition) - .or(mask.and(input)); - } - - public BigInteger getInsertValue() { - return insertValue; - } - - public void setInsertValue(BigInteger 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; - } - BigIntegerInsertValueModification other = (BigIntegerInsertValueModification) obj; - if (startPosition != other.startPosition) { - return false; - } - return Objects.equals(insertValue, other.insertValue); - } - - @Override - public String toString() { - return "BigIntegerInsertValueModification{" - + "insertValue=" - + insertValue - + ", startPosition=" - + startPosition - + '}'; - } -} 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 f9566f80..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,50 +7,11 @@ */ 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.longint.LongModificationFactory; -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.*; public final class BigIntegerModificationFactory { - private enum ModificationType { - ADD, - SUBTRACT, - MULTIPLY, - XOR, - EXPLICIT, - SHIFT_LEFT, - SHIFT_RIGHT, - EXPLICIT_FROM_FILE, - APPEND, - INSERT, - PREPEND - } - - private static final int MODIFICATION_COUNT = ModificationType.values().length; - - private static final int MAX_MODIFICATION_VALUE = 320000; - - private static final int MAX_FILE_ENTRIES = 200; - - private static final int MAX_MODIFICATION_SHIFT_VALUE = 50; - - private static final int MAX_MODIFICATION_MULTIPLY_VALUE = 256; - - private static final int MAX_MODIFICATION_INSERT_VALUE = 256; - - private static final int MAX_MODIFICATION_INSERT_POSITION_VALUE = 50; - - private static List> modificationsFromFile; - public static BigIntegerAddModification add(String summand) { return add(new BigInteger(summand)); } @@ -103,88 +64,6 @@ public static VariableModification explicitValue(BigInteger value) { return new BigIntegerExplicitValueModification(value); } - public static VariableModification explicitValueFromFile(int pos) { - List> modifications = modificationsFromFile(); - return modifications.get(pos % modifications.size()); - } - - public static VariableModification appendValue(BigInteger value) { - return new BigIntegerAppendValueModification(value); - } - - public static VariableModification insertValue( - BigInteger value, int startPosition) { - return new BigIntegerInsertValueModification(value, startPosition); - } - - public static VariableModification prependValue(BigInteger value) { - return new BigIntegerPrependValueModification(value); - } - - public static synchronized List> modificationsFromFile() { - try { - if (modificationsFromFile == null) { - modificationsFromFile = new ArrayList<>(); - ClassLoader classLoader = ByteArrayModificationFactory.class.getClassLoader(); - InputStream is = classLoader.getResourceAsStream(LongModificationFactory.FILE_NAME); - BufferedReader br = new BufferedReader(new InputStreamReader(is)); - String line; - int index = 0; - while ((line = br.readLine()) != null) { - String value = line.trim().split(" ")[0]; - if (!value.isEmpty()) { - modificationsFromFile.add( - new BigIntegerExplicitValueFromFileModification( - index, new BigInteger(value))); - index++; - } - } - } - 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(); - ModificationType randomType = ModificationType.values()[random.nextInt(MODIFICATION_COUNT)]; - BigInteger modification = BigInteger.valueOf(random.nextInt(MAX_MODIFICATION_VALUE)); - BigInteger insert_modification = - BigInteger.valueOf(random.nextInt(MAX_MODIFICATION_INSERT_VALUE)); - int shiftModification = random.nextInt(MAX_MODIFICATION_SHIFT_VALUE); - switch (randomType) { - case ADD: - return new BigIntegerAddModification(modification); - case SUBTRACT: - return new BigIntegerSubtractModification(modification); - case MULTIPLY: - return new BigIntegerMultiplyModification( - BigInteger.valueOf(random.nextInt(MAX_MODIFICATION_MULTIPLY_VALUE))); - case XOR: - return new BigIntegerXorModification(modification); - case EXPLICIT: - return new BigIntegerExplicitValueModification(modification); - case SHIFT_LEFT: - return new BigIntegerShiftLeftModification(shiftModification); - case SHIFT_RIGHT: - return new BigIntegerShiftRightModification(shiftModification); - case EXPLICIT_FROM_FILE: - return explicitValueFromFile(MAX_FILE_ENTRIES); - case APPEND: - return new BigIntegerAppendValueModification(insert_modification); - case INSERT: - return new BigIntegerInsertValueModification( - insert_modification, - random.nextInt(MAX_MODIFICATION_INSERT_POSITION_VALUE)); - case PREPEND: - return new BigIntegerPrependValueModification(insert_modification); - default: - throw new IllegalStateException("Unexpected modification type: " + randomType); - } - } - private BigIntegerModificationFactory() { super(); } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java deleted file mode 100644 index c60c9829..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerPrependValueModification.java +++ /dev/null @@ -1,81 +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.XmlRootElement; -import java.math.BigInteger; -import java.util.Objects; - -@XmlRootElement -public class BigIntegerPrependValueModification extends VariableModification { - - private BigInteger prependValue; - - public BigIntegerPrependValueModification() { - super(); - } - - public BigIntegerPrependValueModification(BigInteger prependValue) { - super(); - this.prependValue = prependValue; - } - - public BigIntegerPrependValueModification(BigIntegerPrependValueModification other) { - super(other); - prependValue = other.prependValue; - } - - @Override - public BigIntegerPrependValueModification createCopy() { - return new BigIntegerPrependValueModification(this); - } - - @Override - protected BigInteger modifyImplementationHook(BigInteger input) { - if (input == null) { - input = BigInteger.ZERO; - } - return prependValue.shiftLeft(input.bitLength()).or(input); - } - - public BigInteger getPrependValue() { - return prependValue; - } - - public void setPrependValue(BigInteger prependValue) { - this.prependValue = prependValue; - } - - @Override - public int hashCode() { - int hash = 7; - hash = 31 * hash + Objects.hashCode(prependValue); - return hash; - } - - @Override - public boolean equals(Object obj) { - if (this == obj) { - return true; - } - if (obj == null) { - return false; - } - if (getClass() != obj.getClass()) { - return false; - } - BigIntegerPrependValueModification other = (BigIntegerPrependValueModification) obj; - return Objects.equals(prependValue, other.prependValue); - } - - @Override - public String toString() { - return "BigIntegerPrependValueModification{" + "prependValue=" + prependValue + '}'; - } -} 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 653d6ddb..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,8 +8,6 @@ package de.rub.nds.modifiablevariable.bool; import de.rub.nds.modifiablevariable.VariableModification; -import de.rub.nds.modifiablevariable.util.RandomHelper; -import java.util.Random; public final class BooleanModificationFactory { @@ -17,29 +15,6 @@ private BooleanModificationFactory() { super(); } - private enum ModificationType { - EXPLICIT_TRUE, - EXPLICIT_FALSE, - TOGGLE - } - - private static final int MODIFICATION_COUNT = ModificationType.values().length; - - public static VariableModification createRandomModification() { - Random random = RandomHelper.getRandom(); - ModificationType randomType = ModificationType.values()[random.nextInt(MODIFICATION_COUNT)]; - switch (randomType) { - case EXPLICIT_TRUE: - return new BooleanExplicitValueModification(true); - case EXPLICIT_FALSE: - return new BooleanExplicitValueModification(false); - case TOGGLE: - return new BooleanToggleModification(); - default: - throw new IllegalStateException("Unexpected modification type: " + randomType); - } - } - public static VariableModification toggle() { return new BooleanToggleModification(); } diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueFromFileModification.java deleted file mode 100644 index 8abfa7c5..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueFromFileModification.java +++ /dev/null @@ -1,78 +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.util.ArrayConverter; -import jakarta.xml.bind.annotation.XmlRootElement; -import java.util.Arrays; - -@XmlRootElement -public class ByteArrayExplicitValueFromFileModification extends ByteArrayExplicitValueModification { - private int index; - - public ByteArrayExplicitValueFromFileModification() { - super(); - } - - public ByteArrayExplicitValueFromFileModification(int index, byte[] explicitValue) { - super(explicitValue); - this.index = index; - } - - public ByteArrayExplicitValueFromFileModification( - ByteArrayExplicitValueFromFileModification other) { - super(other); - index = other.index; - } - - @Override - public ByteArrayExplicitValueFromFileModification createCopy() { - return new ByteArrayExplicitValueFromFileModification(this); - } - - public int getIndex() { - return index; - } - - @Override - public int hashCode() { - int hash = 7; - hash = 31 * hash + index; - hash = 31 * hash + Arrays.hashCode(explicitValue); - return hash; - } - - @Override - public boolean equals(Object obj) { - if (this == obj) { - return true; - } - if (obj == null) { - return false; - } - if (getClass() != obj.getClass()) { - return false; - } - ByteArrayExplicitValueFromFileModification other = - (ByteArrayExplicitValueFromFileModification) obj; - if (index != other.index) { - return false; - } - return Arrays.equals(explicitValue, other.explicitValue); - } - - @Override - public String toString() { - return "ByteArrayExplicitValueFromFileModification{" - + "index=" - + index - + ", explicitValue=" - + ArrayConverter.bytesToHexString(explicitValue) - + '}'; - } -} 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 ee603cff..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,44 +7,10 @@ */ 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.ArrayList; -import java.util.List; -import java.util.Random; public final class ByteArrayModificationFactory { - private enum ModificationType { - XOR, - APPEND, - INSERT, - PREPEND, - DELETE, - EXPLICIT, - DUPLICATE, - EXPLICIT_FROM_FILE, - SHUFFLE - } - - private static final int MODIFICATION_COUNT = ModificationType.values().length; - - private static final int MAX_BYTE_ARRAY_LENGTH = 200; - - private static final int MAX_FILE_ENTRIES = 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"; - /** * @param xor bytes to xor * @param startPosition negative numbers mean that the position is taken from the end @@ -98,11 +64,6 @@ public static VariableModification explicitValue(byte[] explicitValue) { return new ByteArrayExplicitValueModification(explicitValue); } - public static VariableModification explicitValueFromFile(int value) { - List> modifications = modificationsFromFile(); - return modifications.get(value % modifications.size()); - } - /** * Shuffles the bytes in the array, given a specified array of positions. * @@ -113,87 +74,6 @@ public static VariableModification shuffle(byte[] shuffle) { return new ByteArrayShuffleModification(shuffle); } - public static synchronized List> modificationsFromFile() { - try { - if (modificationsFromFile == null) { - modificationsFromFile = new ArrayList<>(); - ClassLoader classLoader = ByteArrayModificationFactory.class.getClassLoader(); - InputStream is = classLoader.getResourceAsStream(FILE_NAME); - BufferedReader br = new BufferedReader(new InputStreamReader(is)); - String line; - int index = 0; - while ((line = br.readLine()) != null) { - line = line.replaceAll("\\s+", ""); - byte[] value = ArrayConverter.hexStringToByteArray(line); - modificationsFromFile.add( - new ByteArrayExplicitValueFromFileModification(index, value)); - index++; - } - } - return modificationsFromFile; - } catch (IOException ex) { - throw new FileConfigurationException( - "Modifiable variable file name could not have been found.", ex); - } - } - - public static VariableModification createRandomModification(byte[] originalValue) { - Random random = RandomHelper.getRandom(); - ModificationType randomType = ModificationType.values()[random.nextInt(MODIFICATION_COUNT)]; - int modifiedArrayLength; - int modificationArrayLength; - int startPosition; - if (originalValue == null) { - modifiedArrayLength = MODIFIED_ARRAY_LENGTH_ESTIMATION; - } else { - modifiedArrayLength = originalValue.length; - if (originalValue.length == 0 || originalValue.length == 1) { - randomType = ModificationType.EXPLICIT; - } - } - modificationArrayLength = random.nextInt(MAX_BYTE_ARRAY_LENGTH - 1) + 1; - switch (randomType) { - case XOR: - byte[] xor = new byte[modificationArrayLength]; - random.nextBytes(xor); - startPosition = random.nextInt(modifiedArrayLength - modificationArrayLength); - return new ByteArrayXorModification(xor, startPosition); - case APPEND: - byte[] bytesToAppend = new byte[modificationArrayLength]; - random.nextBytes(bytesToAppend); - return new ByteArrayAppendValueModification(bytesToAppend); - case INSERT: - byte[] bytesToInsert = new byte[modificationArrayLength]; - random.nextBytes(bytesToInsert); - return new ByteArrayInsertValueModification( - bytesToInsert, random.nextInt(modifiedArrayLength)); - case PREPEND: - byte[] bytesToPrepend = new byte[modificationArrayLength]; - random.nextBytes(bytesToPrepend); - return new ByteArrayPrependValueModification(bytesToPrepend); - case DELETE: - startPosition = random.nextInt(modifiedArrayLength - 1); - int count = random.nextInt(modifiedArrayLength - startPosition); - count++; - return new ByteArrayDeleteModification(startPosition, count); - case EXPLICIT: - byte[] explicitValue = new byte[modificationArrayLength]; - random.nextBytes(explicitValue); - return new ByteArrayExplicitValueModification(explicitValue); - case DUPLICATE: - return new ByteArrayDuplicateModification(); - case EXPLICIT_FROM_FILE: - return explicitValueFromFile(random.nextInt(MAX_FILE_ENTRIES)); - case SHUFFLE: - int shuffleSize = random.nextInt(MAX_BYTE_ARRAY_LENGTH); - byte[] shuffle = new byte[shuffleSize]; - random.nextBytes(shuffle); - return new ByteArrayShuffleModification(shuffle); - default: - throw new IllegalStateException("Unexpected modification type: " + randomType); - } - } - private ByteArrayModificationFactory() { super(); } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java deleted file mode 100644 index 880ad316..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAppendValueModification.java +++ /dev/null @@ -1,80 +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.integer; - -import de.rub.nds.modifiablevariable.VariableModification; -import jakarta.xml.bind.annotation.XmlRootElement; -import java.util.Objects; - -@XmlRootElement -public class IntegerAppendValueModification extends VariableModification { - - private Integer appendValue; - - public IntegerAppendValueModification() { - super(); - } - - public IntegerAppendValueModification(Integer appendValue) { - super(); - this.appendValue = appendValue; - } - - public IntegerAppendValueModification(IntegerAppendValueModification other) { - super(other); - appendValue = other.appendValue; - } - - @Override - public IntegerAppendValueModification createCopy() { - return new IntegerAppendValueModification(this); - } - - @Override - protected Integer modifyImplementationHook(Integer input) { - if (input == null) { - input = 0; - } - return input << Integer.SIZE - Integer.numberOfLeadingZeros(appendValue) | appendValue; - } - - public Integer getAppendValue() { - return appendValue; - } - - public void setAppendValue(Integer appendValue) { - this.appendValue = appendValue; - } - - @Override - public int hashCode() { - int hash = 7; - hash = 31 * hash + appendValue; - return hash; - } - - @Override - public boolean equals(Object obj) { - if (this == obj) { - return true; - } - if (obj == null) { - return false; - } - if (getClass() != obj.getClass()) { - return false; - } - IntegerAppendValueModification other = (IntegerAppendValueModification) obj; - return Objects.equals(appendValue, other.appendValue); - } - - @Override - public String toString() { - return "IntegerAppendValueModification{" + "appendValue=" + appendValue + '}'; - } -} diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java deleted file mode 100644 index 5ff68e6b..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueFromFileModification.java +++ /dev/null @@ -1,77 +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.integer; - -import jakarta.xml.bind.annotation.XmlRootElement; -import java.util.Objects; - -@XmlRootElement -public class IntegerExplicitValueFromFileModification extends IntegerExplicitValueModification { - private int index; - - public IntegerExplicitValueFromFileModification() { - super(); - } - - public IntegerExplicitValueFromFileModification(int index, Integer explicitValue) { - super(explicitValue); - this.index = index; - } - - public IntegerExplicitValueFromFileModification( - IntegerExplicitValueFromFileModification other) { - super(other); - index = other.index; - } - - @Override - public IntegerExplicitValueFromFileModification createCopy() { - return new IntegerExplicitValueFromFileModification(this); - } - - public int getIndex() { - return index; - } - - @Override - public int hashCode() { - int hash = 7; - hash = 31 * hash + index; - hash = 31 * hash + Objects.hashCode(explicitValue); - return hash; - } - - @Override - public boolean equals(Object obj) { - if (this == obj) { - return true; - } - if (obj == null) { - return false; - } - if (getClass() != obj.getClass()) { - return false; - } - IntegerExplicitValueFromFileModification other = - (IntegerExplicitValueFromFileModification) obj; - if (index != other.index) { - return false; - } - return Objects.equals(explicitValue, other.explicitValue); - } - - @Override - public String toString() { - return "IntegerExplicitValueFromFileModification{" - + "index=" - + index - + ", explicitValue=" - + explicitValue - + '}'; - } -} diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java deleted file mode 100644 index 1ef0c28e..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerInsertValueModification.java +++ /dev/null @@ -1,113 +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.integer; - -import de.rub.nds.modifiablevariable.VariableModification; -import jakarta.xml.bind.annotation.XmlRootElement; -import java.util.Objects; - -@XmlRootElement -public class IntegerInsertValueModification extends VariableModification { - - private Integer insertValue; - - private int startPosition; - - public IntegerInsertValueModification() { - super(); - } - - public IntegerInsertValueModification(Integer insertValue, int startPosition) { - super(); - this.insertValue = insertValue; - this.startPosition = startPosition; - } - - public IntegerInsertValueModification(IntegerInsertValueModification other) { - super(other); - insertValue = other.insertValue; - startPosition = other.startPosition; - } - - @Override - public IntegerInsertValueModification createCopy() { - return new IntegerInsertValueModification(this); - } - - @Override - protected Integer modifyImplementationHook(Integer input) { - if (input == null) { - input = 0; - } - - int insertValueLength = Integer.SIZE - Integer.numberOfLeadingZeros(insertValue); - - // Wrap around integer size - int insertPosition = startPosition % Integer.SIZE; - if (startPosition < 0) { - insertPosition += Integer.SIZE - 1; - } - - int mask = (1 << insertPosition) - 1; - - return (input >> insertPosition << insertValueLength | insertValue) << insertPosition - | mask & input; - } - - public Integer getInsertValue() { - return insertValue; - } - - public void setInsertValue(Integer 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 + 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; - } - IntegerInsertValueModification other = (IntegerInsertValueModification) obj; - if (startPosition != other.startPosition) { - return false; - } - return Objects.equals(insertValue, other.insertValue); - } - - @Override - public String toString() { - return "IntegerInsertValueModification{" - + "insertValue=" - + insertValue - + ", startPosition=" - + startPosition - + '}'; - } -} 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 9acd71eb..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,52 +7,10 @@ */ 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.ArrayList; -import java.util.List; -import java.util.Random; public final class IntegerModificationFactory { - private enum ModificationType { - ADD, - SUBTRACT, - MULTIPLY, - XOR, - SWAP_ENDIAN, - EXPLICIT, - SHIFT_LEFT, - SHIFT_RIGHT, - EXPLICIT_FROM_FILE, - APPEND, - INSERT, - PREPEND - } - - private static final int MODIFICATION_COUNT = ModificationType.values().length; - - private static final int MAX_MODIFICATION_VALUE = 32000; - - private static final int MAX_FILE_ENTRIES = 200; - - private static final int MAX_MODIFICATION_SHIFT_VALUE = 20; - - private static final int MAX_MODIFICATION_MULTIPLY_VALUE = 256; - - private static final int MAX_MODIFICATION_INSERT_VALUE = 256; - - private static final int MAX_MODIFICATION_INSERT_POSITION_VALUE = 32; - - private static List> modificationsFromFile; - - public static final String FILE_NAME = "de/rub/nds/modifiablevariable/explicit/integer.vec"; - public static IntegerAddModification add(String summand) { return add(Integer.parseInt(summand)); } @@ -105,90 +63,10 @@ public static VariableModification explicitValue(Integer value) { return new IntegerExplicitValueModification(value); } - public static VariableModification explicitValueFromFile(int pos) { - List> modifications = modificationsFromFile(); - return modifications.get(pos % modifications.size()); - } - - public static VariableModification appendValue(Integer value) { - return new IntegerAppendValueModification(value); - } - - public static VariableModification insertValue(Integer value, int position) { - return new IntegerInsertValueModification(value, position); - } - - public static VariableModification prependValue(Integer value) { - return new IntegerPrependValueModification(value); - } - public static VariableModification multiply(Integer value) { return new IntegerMultiplyModification(value); } - public static synchronized List> modificationsFromFile() { - try { - if (modificationsFromFile == null) { - modificationsFromFile = new ArrayList<>(); - ClassLoader classLoader = IntegerModificationFactory.class.getClassLoader(); - InputStream is = classLoader.getResourceAsStream(FILE_NAME); - BufferedReader br = new BufferedReader(new InputStreamReader(is)); - String line; - int index = 0; - while ((line = br.readLine()) != null) { - String value = line.trim().split(" ")[0]; - modificationsFromFile.add( - new IntegerExplicitValueFromFileModification( - index, Integer.parseInt(value))); - index++; - } - } - 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(); - ModificationType randomType = ModificationType.values()[random.nextInt(MODIFICATION_COUNT)]; - int modification = random.nextInt(MAX_MODIFICATION_VALUE); - int insert_modification = random.nextInt(MAX_MODIFICATION_INSERT_VALUE); - int shiftModification = random.nextInt(MAX_MODIFICATION_SHIFT_VALUE); - switch (randomType) { - case ADD: - return new IntegerAddModification(modification); - case SUBTRACT: - return new IntegerSubtractModification(modification); - case MULTIPLY: - return new IntegerSubtractModification( - random.nextInt(MAX_MODIFICATION_MULTIPLY_VALUE)); - case XOR: - return new IntegerXorModification(modification); - case SWAP_ENDIAN: - return new IntegerSwapEndianModification(); - case EXPLICIT: - return new IntegerExplicitValueModification(modification); - case SHIFT_LEFT: - return new IntegerShiftLeftModification(shiftModification); - case SHIFT_RIGHT: - return new IntegerShiftRightModification(shiftModification); - case EXPLICIT_FROM_FILE: - return explicitValueFromFile(random.nextInt(MAX_FILE_ENTRIES)); - case APPEND: - return new IntegerAppendValueModification(insert_modification); - case INSERT: - return new IntegerInsertValueModification( - insert_modification, - random.nextInt(MAX_MODIFICATION_INSERT_POSITION_VALUE)); - case PREPEND: - return new IntegerPrependValueModification(insert_modification); - default: - throw new IllegalStateException("Unexpected modification type: " + randomType); - } - } - private IntegerModificationFactory() { super(); } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java deleted file mode 100644 index 455b544d..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerPrependValueModification.java +++ /dev/null @@ -1,81 +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.integer; - -import de.rub.nds.modifiablevariable.VariableModification; -import jakarta.xml.bind.annotation.XmlRootElement; -import java.util.Objects; - -@XmlRootElement -public class IntegerPrependValueModification extends VariableModification { - - private Integer prependValue; - - public IntegerPrependValueModification() { - super(); - } - - public IntegerPrependValueModification(Integer prependValue) { - super(); - this.prependValue = prependValue; - } - - public IntegerPrependValueModification(IntegerPrependValueModification other) { - super(other); - prependValue = other.prependValue; - } - - @Override - public IntegerPrependValueModification createCopy() { - return new IntegerPrependValueModification(this); - } - - @Override - protected Integer modifyImplementationHook(Integer input) { - if (input == null) { - input = 0; - } - - return prependValue << Integer.SIZE - Integer.numberOfLeadingZeros(input) | input; - } - - public Integer getPrependValue() { - return prependValue; - } - - public void setPrependValue(Integer prependValue) { - this.prependValue = prependValue; - } - - @Override - public int hashCode() { - int hash = 7; - hash = 31 * hash + prependValue; - return hash; - } - - @Override - public boolean equals(Object obj) { - if (this == obj) { - return true; - } - if (obj == null) { - return false; - } - if (getClass() != obj.getClass()) { - return false; - } - IntegerPrependValueModification other = (IntegerPrependValueModification) obj; - return Objects.equals(prependValue, other.prependValue); - } - - @Override - public String toString() { - return "IntegerPrependValueModification{" + "prependValue=" + prependValue + '}'; - } -} diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java deleted file mode 100644 index 0c69c6a2..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAppendValueModification.java +++ /dev/null @@ -1,80 +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.longint; - -import de.rub.nds.modifiablevariable.VariableModification; -import jakarta.xml.bind.annotation.XmlRootElement; -import java.util.Objects; - -@XmlRootElement -public class LongAppendValueModification extends VariableModification { - - private Long appendValue; - - public LongAppendValueModification() { - super(); - } - - public LongAppendValueModification(Long appendValue) { - super(); - this.appendValue = appendValue; - } - - public LongAppendValueModification(LongAppendValueModification other) { - super(other); - appendValue = other.appendValue; - } - - @Override - public LongAppendValueModification createCopy() { - return new LongAppendValueModification(this); - } - - @Override - protected Long modifyImplementationHook(Long input) { - if (input == null) { - input = 0L; - } - return input << Long.SIZE - Long.numberOfLeadingZeros(appendValue) | appendValue; - } - - public Long getAppendValue() { - return appendValue; - } - - public void setAppendValue(Long appendValue) { - this.appendValue = appendValue; - } - - @Override - public int hashCode() { - int hash = 7; - hash = 31 * hash + Objects.hashCode(appendValue); - return hash; - } - - @Override - public boolean equals(Object obj) { - if (this == obj) { - return true; - } - if (obj == null) { - return false; - } - if (getClass() != obj.getClass()) { - return false; - } - LongAppendValueModification other = (LongAppendValueModification) obj; - return Objects.equals(appendValue, other.appendValue); - } - - @Override - public String toString() { - return "LongAppendValueModification{" + "appendValue=" + appendValue + '}'; - } -} diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java deleted file mode 100644 index 0062ca9e..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueFromFileModification.java +++ /dev/null @@ -1,75 +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.longint; - -import jakarta.xml.bind.annotation.XmlRootElement; -import java.util.Objects; - -@XmlRootElement -public class LongExplicitValueFromFileModification extends LongExplicitValueModification { - private int index; - - public LongExplicitValueFromFileModification() { - super(); - } - - public LongExplicitValueFromFileModification(int index, Long explicitValue) { - super(explicitValue); - this.index = index; - } - - public LongExplicitValueFromFileModification(LongExplicitValueFromFileModification other) { - super(other); - index = other.index; - } - - @Override - public LongExplicitValueFromFileModification createCopy() { - return new LongExplicitValueFromFileModification(this); - } - - public int getIndex() { - return index; - } - - @Override - public int hashCode() { - int hash = 7; - hash = 31 * hash + index; - hash = 31 * hash + Objects.hashCode(explicitValue); - return hash; - } - - @Override - public boolean equals(Object obj) { - if (this == obj) { - return true; - } - if (obj == null) { - return false; - } - if (getClass() != obj.getClass()) { - return false; - } - LongExplicitValueFromFileModification other = (LongExplicitValueFromFileModification) obj; - if (index != other.index) { - return false; - } - return Objects.equals(explicitValue, other.explicitValue); - } - - @Override - public String toString() { - return "LongExplicitValueFromFileModification{" - + "index=" - + index - + ", explicitValue=" - + explicitValue - + '}'; - } -} diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java deleted file mode 100644 index 00b6279e..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongInsertValueModification.java +++ /dev/null @@ -1,112 +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.longint; - -import de.rub.nds.modifiablevariable.VariableModification; -import jakarta.xml.bind.annotation.XmlRootElement; -import java.util.Objects; - -@XmlRootElement -public class LongInsertValueModification extends VariableModification { - - private Long insertValue; - private int startPosition; - - public LongInsertValueModification() { - super(); - } - - public LongInsertValueModification(Long insertValue, int startPosition) { - super(); - this.insertValue = insertValue; - this.startPosition = startPosition; - } - - public LongInsertValueModification(LongInsertValueModification other) { - super(other); - insertValue = other.insertValue; - startPosition = other.startPosition; - } - - @Override - public LongInsertValueModification createCopy() { - return new LongInsertValueModification(this); - } - - @Override - protected Long modifyImplementationHook(Long input) { - if (input == null) { - input = 0L; - } - - int insertValueLength = Long.SIZE - Long.numberOfLeadingZeros(insertValue); - - // Wrap around long size - int insertPosition = startPosition % Long.SIZE; - if (startPosition < 0) { - insertPosition += Long.SIZE - 1; - } - - long mask = (1L << insertPosition) - 1; - - return (input >> insertPosition << insertValueLength | insertValue) << insertPosition - | mask & input; - } - - public Long getInsertValue() { - return insertValue; - } - - public void setInsertValue(Long 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; - } - LongInsertValueModification other = (LongInsertValueModification) obj; - if (startPosition != other.startPosition) { - return false; - } - return Objects.equals(insertValue, other.insertValue); - } - - @Override - public String toString() { - return "LongInsertValueModification{" - + "insertValue=" - + insertValue - + ", startPosition=" - + startPosition - + '}'; - } -} 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 94aeff30..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,54 +7,10 @@ */ 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.ArrayList; -import java.util.List; -import java.util.Random; public final class LongModificationFactory { - @SuppressWarnings("unused") - private enum ModificationType { - ADD, - SUBTRACT, - MULTIPLY, - XOR, - SWAP_ENDIAN, - EXPLICIT, - SHIFT_LEFT, - SHIFT_RIGHT, - EXPLICIT_FROM_FILE, - APPEND, - INSERT, - PREPEND - } - - private static final int MODIFICATION_COUNT = ModificationType.values().length; - - private static final int MAX_MODIFICATION_VALUE = 32000; - - private static final int MAX_FILE_ENTRIES = 200; - - private static final int MAX_MODIFICATION_SHIFT_VALUE = 40; - - private static final int MAX_MODIFICATION_MULTIPLY_VALUE = 256; - - private static final int MAX_MODIFICATION_INSERT_VALUE = 256; - - private static final int MAX_MODIFICATION_INSERT_POSITION_VALUE = 64; - - private static List> modificationsFromFile; - - public static final String FILE_NAME = "de/rub/nds/modifiablevariable/explicit/long.vec"; - public static LongAddModification add(String summand) { return add(Long.parseLong(summand)); } @@ -91,23 +47,6 @@ public static VariableModification explicitValue(Long value) { return new LongExplicitValueModification(value); } - public static VariableModification explicitValueFromFile(int pos) { - List> modifications = modificationsFromFile(); - return modifications.get(pos % modifications.size()); - } - - public static VariableModification appendValue(Long value) { - return new LongAppendValueModification(value); - } - - public static VariableModification insertValue(Long value, int position) { - return new LongInsertValueModification(value, position); - } - - public static VariableModification prependValue(Long value) { - return new LongPrependValueModification(value); - } - public static VariableModification multiply(Long factor) { return new LongMultiplyModification(factor); } @@ -120,69 +59,6 @@ public static VariableModification shiftRight(int shift) { return new LongShiftRightModification(shift); } - public static synchronized List> modificationsFromFile() { - try { - if (modificationsFromFile == null) { - modificationsFromFile = new ArrayList<>(); - ClassLoader classLoader = IntegerModificationFactory.class.getClassLoader(); - InputStream is = classLoader.getResourceAsStream(FILE_NAME); - BufferedReader br = new BufferedReader(new InputStreamReader(is)); - String line; - int index = 0; - while ((line = br.readLine()) != null) { - String value = line.trim().split(" ")[0]; - modificationsFromFile.add( - new LongExplicitValueFromFileModification( - index, Long.parseLong(value))); - index++; - } - } - 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(); - ModificationType randomType = ModificationType.values()[random.nextInt(MODIFICATION_COUNT)]; - long modification = random.nextInt(MAX_MODIFICATION_VALUE); - long insert_modification = random.nextInt(MAX_MODIFICATION_INSERT_VALUE); - int shiftModification = random.nextInt(MAX_MODIFICATION_SHIFT_VALUE); - switch (randomType) { - case ADD: - return new LongAddModification(modification); - case SUBTRACT: - return new LongSubtractModification(modification); - case MULTIPLY: - return new LongMultiplyModification( - (long) random.nextInt(MAX_MODIFICATION_MULTIPLY_VALUE)); - case XOR: - return new LongXorModification(modification); - case SWAP_ENDIAN: - return new LongSwapEndianModification(); - case EXPLICIT: - return new LongExplicitValueModification(modification); - case SHIFT_LEFT: - return new LongShiftLeftModification(shiftModification); - case SHIFT_RIGHT: - return new LongShiftRightModification(shiftModification); - case EXPLICIT_FROM_FILE: - return explicitValueFromFile(random.nextInt(MAX_FILE_ENTRIES)); - case APPEND: - return new LongAppendValueModification(insert_modification); - case INSERT: - return new LongInsertValueModification( - insert_modification, - random.nextInt(MAX_MODIFICATION_INSERT_POSITION_VALUE)); - case PREPEND: - return new LongPrependValueModification(insert_modification); - default: - throw new IllegalStateException("Unexpected modification type: " + randomType); - } - } - private LongModificationFactory() { super(); } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java deleted file mode 100644 index 4fef4aee..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongPrependValueModification.java +++ /dev/null @@ -1,80 +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.longint; - -import de.rub.nds.modifiablevariable.VariableModification; -import jakarta.xml.bind.annotation.XmlRootElement; -import java.util.Objects; - -@XmlRootElement -public class LongPrependValueModification extends VariableModification { - - private Long prependValue; - - public LongPrependValueModification() { - super(); - } - - public LongPrependValueModification(Long prependValue) { - super(); - this.prependValue = prependValue; - } - - public LongPrependValueModification(LongPrependValueModification other) { - super(other); - prependValue = other.prependValue; - } - - @Override - public LongPrependValueModification createCopy() { - return new LongPrependValueModification(this); - } - - @Override - protected Long modifyImplementationHook(Long input) { - if (input == null) { - input = 0L; - } - return prependValue << Long.SIZE - Long.numberOfLeadingZeros(input) | input; - } - - public Long getPrependValue() { - return prependValue; - } - - public void setPrependValue(Long prependValue) { - this.prependValue = prependValue; - } - - @Override - public int hashCode() { - int hash = 7; - hash = 31 * hash + Objects.hashCode(prependValue); - return hash; - } - - @Override - public boolean equals(Object obj) { - if (this == obj) { - return true; - } - if (obj == null) { - return false; - } - if (getClass() != obj.getClass()) { - return false; - } - LongPrependValueModification other = (LongPrependValueModification) obj; - return Objects.equals(prependValue, other.prependValue); - } - - @Override - public String toString() { - return "LongPrependValueModification{" + "prependValue=" + prependValue + '}'; - } -} diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java b/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java deleted file mode 100644 index 6b73b5ee..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/path/ModifiablePath.java +++ /dev/null @@ -1,59 +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.path; - -import static de.rub.nds.modifiablevariable.util.StringUtil.backslashEscapeString; - -import de.rub.nds.modifiablevariable.string.ModifiableString; -import jakarta.xml.bind.annotation.XmlAccessType; -import jakarta.xml.bind.annotation.XmlAccessorType; -import jakarta.xml.bind.annotation.XmlRootElement; - -@XmlRootElement -@XmlAccessorType(XmlAccessType.PROPERTY) -public class ModifiablePath extends ModifiableString { - - public ModifiablePath() { - super(); - } - - public ModifiablePath(String originalValue) { - super(originalValue); - } - - public ModifiablePath(ModifiablePath other) { - super(other); - } - - @Override - public ModifiablePath createCopy() { - return new ModifiablePath(this); - } - - @Override - public String toString() { - return "ModifiablePath{" - + "originalValue='" - + backslashEscapeString(originalValue) - + '\'' - + innerToString() - + '}'; - } - - @Override - public boolean equals(Object obj) { - if (this == obj) { - return true; - } - if (!(obj instanceof ModifiablePath that)) { - return false; - } - - return getValue() != null ? getValue().equals(that.getValue()) : that.getValue() == null; - } -} diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java deleted file mode 100644 index 822b177a..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathAppendValueModification.java +++ /dev/null @@ -1,93 +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.path; - -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 appends a path parts to the original value. */ -@XmlRootElement -public class PathAppendValueModification extends VariableModification { - - @XmlJavaTypeAdapter(IllegalStringAdapter.class) - private String appendValue; - - public PathAppendValueModification() { - super(); - } - - public PathAppendValueModification(String appendValue) { - super(); - this.appendValue = appendValue; - } - - public PathAppendValueModification(PathAppendValueModification other) { - super(other); - appendValue = other.appendValue; - } - - @Override - public PathAppendValueModification createCopy() { - return new PathAppendValueModification(this); - } - - @Override - protected String modifyImplementationHook(String input) { - if (input == null) { - return null; - } - if (input.endsWith("/")) { - return input + appendValue + "/"; - } - return input + "/" + appendValue; - } - - public String getAppendValue() { - return appendValue; - } - - public void setAppendValue(String appendValue) { - this.appendValue = appendValue; - } - - @Override - public int hashCode() { - int hash = 7; - hash = 31 * hash + Objects.hashCode(appendValue); - return hash; - } - - @Override - public boolean equals(Object obj) { - if (this == obj) { - return true; - } - if (obj == null) { - return false; - } - if (getClass() != obj.getClass()) { - return false; - } - PathAppendValueModification other = (PathAppendValueModification) obj; - return Objects.equals(appendValue, other.appendValue); - } - - @Override - public String toString() { - return "PathAppendValueModification{" - + "appendValue='" - + backslashEscapeString(appendValue) - + '\'' - + '}'; - } -} diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathDeleteModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathDeleteModification.java deleted file mode 100644 index 7413c1e5..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathDeleteModification.java +++ /dev/null @@ -1,139 +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.path; - -import de.rub.nds.modifiablevariable.VariableModification; -import de.rub.nds.modifiablevariable.util.ArrayConverter; -import jakarta.xml.bind.annotation.XmlRootElement; -import java.util.Arrays; -import java.util.Objects; - -/** Modification that deletes path parts from the original value. */ -@XmlRootElement -public class PathDeleteModification extends VariableModification { - - private int count; - - private int startPosition; - - public PathDeleteModification() { - super(); - } - - public PathDeleteModification(int startPosition, int count) { - super(); - this.count = count; - this.startPosition = startPosition; - } - - public PathDeleteModification(PathDeleteModification other) { - super(other); - count = other.count; - startPosition = other.startPosition; - } - - @Override - public PathDeleteModification createCopy() { - return new PathDeleteModification(this); - } - - @Override - protected String modifyImplementationHook(String input) { - if (input == null) { - return null; - } - if (input.isEmpty()) { - return input; - } - String[] pathParts = input.split("/"); - if (pathParts.length == 0) { - // It is just a single slash - if (count == 0) { - return input; - } - return ""; - } - boolean leadingSlash = pathParts[0].isEmpty(); - - // Wrap around and also allow to delete at the end of the original value - int deleteStartPosition = - PathUtil.getPathPartPosition(startPosition, leadingSlash, pathParts); - // If the end position overflows, it is fixed at the end of the path - int deleteEndPosition = deleteStartPosition + count; - if (deleteEndPosition > pathParts.length) { - deleteEndPosition = pathParts.length; - } - - String[] partsBefore = Arrays.copyOf(pathParts, deleteStartPosition); - String[] resultParts; - if (deleteEndPosition < pathParts.length) { - String[] partsAfter = - Arrays.copyOfRange(pathParts, deleteEndPosition, pathParts.length); - resultParts = ArrayConverter.concatenate(partsBefore, partsAfter); - } else { - resultParts = partsBefore; - } - - if (input.endsWith("/") && resultParts.length > 0) { - resultParts[resultParts.length - 1] += "/"; - } - return String.join("/", resultParts); - } - - 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; - } - PathDeleteModification other = (PathDeleteModification) obj; - if (startPosition != other.startPosition) { - return false; - } - return Objects.equals(count, other.count); - } - - @Override - public String toString() { - return "PathDeleteModification{" - + "count=" - + count - + ", startPosition=" - + startPosition - + '}'; - } -} diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java deleted file mode 100644 index c7c32d89..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueFromFileModification.java +++ /dev/null @@ -1,77 +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.path; - -import static de.rub.nds.modifiablevariable.util.StringUtil.backslashEscapeString; - -import jakarta.xml.bind.annotation.XmlRootElement; -import java.util.Objects; - -@XmlRootElement -public class PathExplicitValueFromFileModification extends PathExplicitValueModification { - private int index; - - public PathExplicitValueFromFileModification() { - super(); - } - - public PathExplicitValueFromFileModification(int index, String explicitValue) { - super(explicitValue); - this.index = index; - } - - public PathExplicitValueFromFileModification(PathExplicitValueFromFileModification other) { - super(other); - index = other.index; - } - - @Override - public PathExplicitValueFromFileModification createCopy() { - return new PathExplicitValueFromFileModification(this); - } - - public int getIndex() { - return index; - } - - @Override - public int hashCode() { - int hash = 7; - hash = 31 * hash + index; - hash = 31 * hash + Objects.hashCode(explicitValue); - return hash; - } - - @Override - public boolean equals(Object obj) { - if (this == obj) { - return true; - } - if (obj == null) { - return false; - } - if (getClass() != obj.getClass()) { - return false; - } - PathExplicitValueFromFileModification other = (PathExplicitValueFromFileModification) obj; - if (index != other.index) { - return false; - } - return Objects.equals(explicitValue, other.explicitValue); - } - - @Override - public String toString() { - return "PathExplicitValueFromFileModification{" - + "index=" - + index - + ", explicitValue=" - + backslashEscapeString(explicitValue) - + '}'; - } -} diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java deleted file mode 100644 index ecaf6de9..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathExplicitValueModification.java +++ /dev/null @@ -1,86 +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.path; - -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; - -@XmlRootElement -public class PathExplicitValueModification extends VariableModification { - - @XmlJavaTypeAdapter(IllegalStringAdapter.class) - protected String explicitValue; - - public PathExplicitValueModification() { - super(); - } - - public PathExplicitValueModification(String explicitValue) { - super(); - this.explicitValue = explicitValue; - } - - public PathExplicitValueModification(PathExplicitValueModification other) { - super(other); - explicitValue = other.explicitValue; - } - - @Override - public PathExplicitValueModification createCopy() { - return new PathExplicitValueModification(this); - } - - @Override - protected String modifyImplementationHook(String input) { - return explicitValue; - } - - public String getExplicitValue() { - return explicitValue; - } - - public void setExplicitValue(String explicitValue) { - this.explicitValue = explicitValue; - } - - @Override - public int hashCode() { - int hash = 7; - hash = 31 * hash + Objects.hashCode(explicitValue); - return hash; - } - - @Override - public boolean equals(Object obj) { - if (this == obj) { - return true; - } - if (obj == null) { - return false; - } - if (getClass() != obj.getClass()) { - return false; - } - PathExplicitValueModification other = (PathExplicitValueModification) obj; - return Objects.equals(explicitValue, other.explicitValue); - } - - @Override - public String toString() { - return "PathExplicitValueModification{" - + "explicitValue='" - + backslashEscapeString(explicitValue) - + '\'' - + '}'; - } -} diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectorySeparatorModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectorySeparatorModification.java deleted file mode 100644 index 5babf468..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectorySeparatorModification.java +++ /dev/null @@ -1,115 +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.path; - -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 directory separators as path parts to the original value. */ -@XmlRootElement -public class PathInsertDirectorySeparatorModification extends VariableModification { - - @XmlJavaTypeAdapter(IllegalStringAdapter.class) - private String insertValue; - - private int count; - private int startPosition; - - public PathInsertDirectorySeparatorModification() { - super(); - } - - public PathInsertDirectorySeparatorModification(int count, int startPosition) { - super(); - this.count = count; - this.startPosition = startPosition; - updateInsertValue(); - } - - public PathInsertDirectorySeparatorModification( - PathInsertDirectorySeparatorModification other) { - super(other); - insertValue = other.insertValue; - count = other.count; - startPosition = other.startPosition; - } - - @Override - public PathInsertDirectorySeparatorModification createCopy() { - return new PathInsertDirectorySeparatorModification(this); - } - - private void updateInsertValue() { - insertValue = "/".repeat(Math.max(0, count)); - } - - @Override - protected String modifyImplementationHook(String input) { - return PathUtil.insertValueAsPathPart(input, insertValue, startPosition); - } - - public int getCount() { - return count; - } - - public void setCount(int count) { - this.count = count; - updateInsertValue(); - } - - 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; - } - PathInsertDirectorySeparatorModification other = - (PathInsertDirectorySeparatorModification) obj; - if (startPosition != other.startPosition) { - return false; - } - return Objects.equals(count, other.count); - } - - @Override - public String toString() { - return "PathInsertDirectorySeparatorModification{" - + "insertValue='" - + insertValue - + '\'' - + ", count=" - + count - + ", startPosition=" - + startPosition - + '}'; - } -} diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java deleted file mode 100644 index 45f27303..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertDirectoryTraversalModification.java +++ /dev/null @@ -1,126 +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.path; - -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 directory traversal path parts the original value. */ -@XmlRootElement -public class PathInsertDirectoryTraversalModification extends VariableModification { - - @XmlJavaTypeAdapter(IllegalStringAdapter.class) - private String insertValue; - - private int count; - private int startPosition; - - public PathInsertDirectoryTraversalModification() { - super(); - } - - public PathInsertDirectoryTraversalModification(int count, int startPosition) { - super(); - this.count = count; - this.startPosition = startPosition; - updateInsertValue(); - } - - public PathInsertDirectoryTraversalModification( - PathInsertDirectoryTraversalModification other) { - super(other); - insertValue = other.insertValue; - count = other.count; - startPosition = other.startPosition; - } - - @Override - public PathInsertDirectoryTraversalModification createCopy() { - return new PathInsertDirectoryTraversalModification(this); - } - - private void updateInsertValue() { - if (count <= 0) { - insertValue = ""; - return; - } - StringBuilder builder = new StringBuilder(count * 3 - 1); - for (int i = 0; i < count; i++) { - builder.append(".."); - if (i < count - 1) { - builder.append("/"); - } - } - insertValue = builder.toString(); - } - - @Override - protected String modifyImplementationHook(String input) { - return PathUtil.insertValueAsPathPart(input, insertValue, startPosition); - } - - public int getCount() { - return count; - } - - public void setCount(int count) { - this.count = count; - updateInsertValue(); - } - - 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; - } - PathInsertDirectoryTraversalModification other = - (PathInsertDirectoryTraversalModification) obj; - if (startPosition != other.startPosition) { - return false; - } - return Objects.equals(count, other.count); - } - - @Override - public String toString() { - return "PathInsertDirectoryTraversalModification{" - + "insertValue='" - + insertValue - + '\'' - + ", count=" - + count - + ", startPosition=" - + startPosition - + '}'; - } -} diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java deleted file mode 100644 index 47f8c49a..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathInsertValueModification.java +++ /dev/null @@ -1,105 +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.path; - -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 path parts to the original value. */ -@XmlRootElement -public class PathInsertValueModification extends VariableModification { - - @XmlJavaTypeAdapter(IllegalStringAdapter.class) - private String insertValue; - - private int startPosition; - - public PathInsertValueModification() { - super(); - } - - public PathInsertValueModification(String insertValue, int startPosition) { - super(); - this.insertValue = insertValue; - this.startPosition = startPosition; - } - - public PathInsertValueModification(PathInsertValueModification other) { - super(other); - insertValue = other.insertValue; - startPosition = other.startPosition; - } - - @Override - public PathInsertValueModification createCopy() { - return new PathInsertValueModification(this); - } - - @Override - protected String modifyImplementationHook(String input) { - return PathUtil.insertValueAsPathPart(input, insertValue, startPosition); - } - - 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; - } - PathInsertValueModification other = (PathInsertValueModification) obj; - if (startPosition != other.startPosition) { - return false; - } - return Objects.equals(insertValue, other.insertValue); - } - - @Override - public String toString() { - return "PathInsertValueModification{" - + "insertValue='" - + backslashEscapeString(insertValue) - + '\'' - + ", startPosition=" - + startPosition - + '}'; - } -} diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathModificationFactory.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathModificationFactory.java deleted file mode 100644 index f143360d..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathModificationFactory.java +++ /dev/null @@ -1,146 +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.path; - -import de.rub.nds.modifiablevariable.VariableModification; -import de.rub.nds.modifiablevariable.string.StringDeleteModification; -import de.rub.nds.modifiablevariable.util.RandomHelper; -import java.util.Random; - -/** */ -public final class PathModificationFactory { - - private PathModificationFactory() { - super(); - } - - private enum ModificationType { - APPEND, - PREPEND, - INSERT, - DELETE, - INSERT_DIRECTORY_TRAVERSAL, - INSERT_DIRECTORY_SEPERATOR, - TOGGLE_ROOT - } - - private static final int MODIFICATION_COUNT = ModificationType.values().length; - - private static final int MAX_BYTE_LENGTH_INSERT = 200; - - private static final int NUMBER_OF_PATH_PARTS_ESTIMATION = 50; - - private static final int MAX_NUMBER_OF_DIRECTORY_TRAVERSAL_INSERT = 10; - private static final int MAX_NUMBER_OF_DIRECTORY_SEPERATOR_INSERT = 10; - - public static VariableModification prependValue(String value) { - return new PathPrependValueModification(value); - } - - public static VariableModification explicitValue(String value) { - return new PathExplicitValueModification(value); - } - - public static VariableModification appendValue(String value) { - return new PathAppendValueModification(value); - } - - public static VariableModification insertValue(String value, int position) { - return new PathInsertValueModification(value, position); - } - - public static VariableModification delete(int position, int count) { - return new PathDeleteModification(position, count); - } - - public static VariableModification insertDirectoryTraversal(int count, int position) { - return new PathInsertDirectoryTraversalModification(count, position); - } - - public static VariableModification insertDirectorySeperator(int count, int position) { - return new PathInsertDirectorySeparatorModification(count, position); - } - - public static VariableModification toggleRoot() { - return new PathToggleRootModification(); - } - - public static VariableModification createRandomModification(String originalValue) { - Random random = RandomHelper.getRandom(); - ModificationType randomType = ModificationType.values()[random.nextInt(MODIFICATION_COUNT)]; - int modificationStringLength; - int numberOfPathParts; - if (originalValue == null) { - numberOfPathParts = NUMBER_OF_PATH_PARTS_ESTIMATION; - } else { - String[] pathParts = originalValue.split("/"); - if (pathParts.length == 0) { - if (randomType == ModificationType.INSERT - || randomType == ModificationType.DELETE) { - randomType = ModificationType.APPEND; - } - numberOfPathParts = 0; - } else { - if (pathParts[0].isEmpty()) { - numberOfPathParts = originalValue.split("/").length - 1; - } else { - numberOfPathParts = originalValue.split("/").length; - } - } - } - int insertPosition; - switch (randomType) { - case APPEND: - modificationStringLength = random.nextInt(MAX_BYTE_LENGTH_INSERT); - if (modificationStringLength == 0) { - modificationStringLength++; - } - byte[] bytesToAppend = new byte[modificationStringLength]; - random.nextBytes(bytesToAppend); - return new PathAppendValueModification(new String(bytesToAppend)); - case PREPEND: - modificationStringLength = random.nextInt(MAX_BYTE_LENGTH_INSERT); - if (modificationStringLength == 0) { - modificationStringLength++; - } - byte[] bytesToPrepend = new byte[modificationStringLength]; - random.nextBytes(bytesToPrepend); - return new PathPrependValueModification(new String(bytesToPrepend)); - case INSERT: - modificationStringLength = random.nextInt(MAX_BYTE_LENGTH_INSERT); - if (modificationStringLength == 0) { - modificationStringLength++; - } - byte[] bytesToInsert = new byte[modificationStringLength]; - random.nextBytes(bytesToInsert); - insertPosition = random.nextInt(numberOfPathParts); - return new PathInsertValueModification(new String(bytesToInsert), insertPosition); - case INSERT_DIRECTORY_TRAVERSAL: - int numberOfDirectoryTraversal = - random.nextInt(MAX_NUMBER_OF_DIRECTORY_TRAVERSAL_INSERT); - insertPosition = random.nextInt(numberOfPathParts); - return new PathInsertDirectoryTraversalModification( - numberOfDirectoryTraversal, insertPosition); - case INSERT_DIRECTORY_SEPERATOR: - int numberOfDirectorySeperator = - random.nextInt(MAX_NUMBER_OF_DIRECTORY_SEPERATOR_INSERT); - insertPosition = random.nextInt(numberOfPathParts); - return new PathInsertDirectorySeparatorModification( - numberOfDirectorySeperator, insertPosition); - case TOGGLE_ROOT: - return new PathToggleRootModification(); - case DELETE: - int startPosition = random.nextInt(numberOfPathParts - 1); - int count = random.nextInt(numberOfPathParts - startPosition); - count++; - return new StringDeleteModification(startPosition, count); - default: - throw new IllegalStateException("Unexpected modification type: " + randomType); - } - } -} diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java deleted file mode 100644 index 2b73cb18..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathPrependValueModification.java +++ /dev/null @@ -1,93 +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.path; - -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 prepends a string to the original value. */ -@XmlRootElement -public class PathPrependValueModification extends VariableModification { - - @XmlJavaTypeAdapter(IllegalStringAdapter.class) - private String prependValue; - - public PathPrependValueModification() { - super(); - } - - public PathPrependValueModification(String prependValue) { - super(); - this.prependValue = prependValue; - } - - public PathPrependValueModification(PathPrependValueModification other) { - super(other); - prependValue = other.prependValue; - } - - @Override - public PathPrependValueModification createCopy() { - return new PathPrependValueModification(this); - } - - @Override - protected String modifyImplementationHook(String input) { - if (input == null) { - return null; - } - if (input.startsWith("/")) { - return "/" + prependValue + input; - } - return prependValue + "/" + input; - } - - public String getPrependValue() { - return prependValue; - } - - public void setPrependValue(String prependValue) { - this.prependValue = prependValue; - } - - @Override - public int hashCode() { - int hash = 7; - hash = 31 * hash + Objects.hashCode(prependValue); - return hash; - } - - @Override - public boolean equals(Object obj) { - if (this == obj) { - return true; - } - if (obj == null) { - return false; - } - if (getClass() != obj.getClass()) { - return false; - } - PathPrependValueModification other = (PathPrependValueModification) obj; - return Objects.equals(prependValue, other.prependValue); - } - - @Override - public String toString() { - return "PathPrependValueModification{" - + "prependValue='" - + backslashEscapeString(prependValue) - + '\'' - + '}'; - } -} diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootModification.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootModification.java deleted file mode 100644 index 90c2a439..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathToggleRootModification.java +++ /dev/null @@ -1,61 +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.path; - -import de.rub.nds.modifiablevariable.VariableModification; -import jakarta.xml.bind.annotation.XmlRootElement; - -/** Modification that toggle the root slash of the original value. */ -@XmlRootElement -public class PathToggleRootModification extends VariableModification { - - public PathToggleRootModification() { - super(); - } - - public PathToggleRootModification(PathToggleRootModification other) { - super(other); - } - - @Override - public PathToggleRootModification createCopy() { - return new PathToggleRootModification(this); - } - - @Override - protected String modifyImplementationHook(String input) { - if (input == null) { - return null; - } - if (!input.isEmpty() && input.charAt(0) == '/') { - return input.substring(1); - } - return "/" + 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 "PathToggleRootModification{}"; - } -} diff --git a/src/main/java/de/rub/nds/modifiablevariable/path/PathUtil.java b/src/main/java/de/rub/nds/modifiablevariable/path/PathUtil.java deleted file mode 100644 index db3d46d3..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/path/PathUtil.java +++ /dev/null @@ -1,85 +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.path; - -public final class PathUtil { - - private PathUtil() { - super(); - } - - public static String insertValueAsPathPart( - String input, String insertValue, int startPosition) { - if (input == null) { - return null; - } - - if (input.isEmpty()) { - return insertValue; - } - String[] pathParts = input.split("/"); - if (pathParts.length == 0) { - // It is just a single slash - pathParts = new String[] {""}; - } - boolean leadingSlash = pathParts[0].isEmpty(); - - // Wrap around and also allow to insert at the end of the original value - int insertPosition = getInsertPosition(startPosition, leadingSlash, pathParts); - - if (insertPosition == 0 && leadingSlash) { - pathParts[insertPosition] = "/" + insertValue; - } else if (insertPosition == pathParts.length) { - pathParts[insertPosition - 1] = pathParts[insertPosition - 1] + "/" + insertValue; - } else { - pathParts[insertPosition] = insertValue + "/" + pathParts[insertPosition]; - } - if (input.endsWith("/")) { - pathParts[pathParts.length - 1] += "/"; - } - return String.join("/", pathParts); - } - - private static int getInsertPosition( - int startPosition, boolean leadingSlash, String[] pathParts) { - int insertPosition; - if (leadingSlash) { - // If the path starts with a slash, skip the first empty path part. - insertPosition = startPosition % pathParts.length; - if (startPosition < 0) { - insertPosition += pathParts.length - 1; - } - insertPosition++; - } else { - insertPosition = startPosition % (pathParts.length + 1); - if (startPosition < 0) { - insertPosition += pathParts.length; - } - } - return insertPosition; - } - - public static int getPathPartPosition( - int startPosition, boolean leadingSlash, String[] pathParts) { - int pathPartPosition; - if (leadingSlash) { - // If the path starts with a slash, skip the first empty path part. - pathPartPosition = startPosition % (pathParts.length - 1); - if (startPosition < 0) { - pathPartPosition += pathParts.length - 2; - } - pathPartPosition++; - } else { - pathPartPosition = startPosition % pathParts.length; - if (startPosition < 0) { - pathPartPosition += pathParts.length - 1; - } - } - return pathPartPosition; - } -} diff --git a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java deleted file mode 100644 index 607d2a63..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueFromFileModification.java +++ /dev/null @@ -1,75 +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.singlebyte; - -import jakarta.xml.bind.annotation.XmlRootElement; -import java.util.Objects; - -@XmlRootElement -public class ByteExplicitValueFromFileModification extends ByteExplicitValueModification { - private int index; - - public ByteExplicitValueFromFileModification() { - super(); - } - - public ByteExplicitValueFromFileModification(int index, Byte explicitValue) { - super(explicitValue); - this.index = index; - } - - public ByteExplicitValueFromFileModification(ByteExplicitValueFromFileModification other) { - super(other); - index = other.index; - } - - @Override - public ByteExplicitValueFromFileModification createCopy() { - return new ByteExplicitValueFromFileModification(this); - } - - public int getIndex() { - return index; - } - - @Override - public int hashCode() { - int hash = 7; - hash = 31 * hash + index; - hash = 31 * hash + Objects.hashCode(explicitValue); - return hash; - } - - @Override - public boolean equals(Object obj) { - if (this == obj) { - return true; - } - if (obj == null) { - return false; - } - if (getClass() != obj.getClass()) { - return false; - } - ByteExplicitValueFromFileModification other = (ByteExplicitValueFromFileModification) obj; - if (index != other.index) { - return false; - } - return Objects.equals(explicitValue, other.explicitValue); - } - - @Override - public String toString() { - return "ByteExplicitValueFromFileModification{" - + "index=" - + index - + ", 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 51593775..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,33 +7,10 @@ */ 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.ArrayList; -import java.util.List; -import java.util.Random; public final class ByteModificationFactory { - private enum ModificationType { - ADD, - SUBTRACT, - XOR, - EXPLICIT, - EXPLICIT_FROM_FILE - } - - private static final int MODIFICATION_COUNT = ModificationType.values().length; - - private static List> modificationsFromFile; - - public static final String FILE_NAME = "de/rub/nds/modifiablevariable/explicit/byte.vec"; - public static ByteAddModification add(String summand) { return add(Byte.parseByte(summand)); } @@ -66,55 +43,6 @@ public static VariableModification explicitValue(Byte value) { return new ByteExplicitValueModification(value); } - public static VariableModification explicitValueFromFile(int pos) { - List> modifications = modificationsFromFile(); - return modifications.get(pos % modifications.size()); - } - - public static synchronized List> modificationsFromFile() { - try { - if (modificationsFromFile == null) { - modificationsFromFile = new ArrayList<>(); - ClassLoader classLoader = ByteModificationFactory.class.getClassLoader(); - InputStream is = classLoader.getResourceAsStream(FILE_NAME); - BufferedReader br = new BufferedReader(new InputStreamReader(is)); - String line; - int index = 0; - while ((line = br.readLine()) != null) { - String value = line.trim().split(" ")[0]; - modificationsFromFile.add( - new ByteExplicitValueFromFileModification( - index, Byte.parseByte(value))); - index++; - } - } - 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(); - ModificationType randomType = ModificationType.values()[random.nextInt(MODIFICATION_COUNT)]; - byte modification = (byte) random.nextInt(Byte.MAX_VALUE); - switch (randomType) { - case ADD: - return new ByteAddModification(modification); - case SUBTRACT: - return new ByteSubtractModification(modification); - case XOR: - return new ByteXorModification(modification); - case EXPLICIT: - return new ByteExplicitValueModification(modification); - case EXPLICIT_FROM_FILE: - return explicitValueFromFile(random.nextInt(Byte.MAX_VALUE)); - default: - throw new IllegalStateException("Unexpected modification type: " + randomType); - } - } - private ByteModificationFactory() { super(); } 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 0ba8cdfd..a373b3c4 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java @@ -17,7 +17,6 @@ import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.nio.charset.StandardCharsets; -/** */ @XmlRootElement @XmlAccessorType(XmlAccessType.PROPERTY) public class ModifiableString extends ModifiableVariable { diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java deleted file mode 100644 index e7b88765..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueFromFileModification.java +++ /dev/null @@ -1,79 +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.string; - -import static de.rub.nds.modifiablevariable.util.StringUtil.backslashEscapeString; - -import jakarta.xml.bind.annotation.XmlRootElement; -import java.util.Objects; - -@XmlRootElement -public class StringExplicitValueFromFileModification extends StringExplicitValueModification { - private int index; - - public StringExplicitValueFromFileModification() { - super(); - } - - public StringExplicitValueFromFileModification(int index, String explicitValue) { - super(explicitValue); - this.index = index; - } - - public StringExplicitValueFromFileModification(StringExplicitValueFromFileModification other) { - super(other); - index = other.index; - } - - @Override - public StringExplicitValueFromFileModification createCopy() { - return new StringExplicitValueFromFileModification(this); - } - - public int getIndex() { - return index; - } - - @Override - public int hashCode() { - int hash = 7; - hash = 31 * hash + index; - hash = 31 * hash + Objects.hashCode(explicitValue); - return hash; - } - - @Override - public boolean equals(Object obj) { - if (this == obj) { - return true; - } - if (obj == null) { - return false; - } - if (getClass() != obj.getClass()) { - return false; - } - StringExplicitValueFromFileModification other = - (StringExplicitValueFromFileModification) obj; - if (index != other.index) { - return false; - } - return Objects.equals(explicitValue, other.explicitValue); - } - - @Override - public String toString() { - return "StringExplicitValueFromFileModification{" - + "index=" - + index - + ", explicitValue='" - + backslashEscapeString(explicitValue) - + '\'' - + '}'; - } -} 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 e81851e9..5c8d4ffb 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java @@ -15,7 +15,6 @@ import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.util.Objects; -/** */ @XmlRootElement public class StringExplicitValueModification extends VariableModification { 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 b7d5709e..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,32 +8,13 @@ package de.rub.nds.modifiablevariable.string; import de.rub.nds.modifiablevariable.VariableModification; -import de.rub.nds.modifiablevariable.util.RandomHelper; -import java.util.Random; -/** */ public final class StringModificationFactory { private StringModificationFactory() { super(); } - private enum ModificationType { - APPEND, - PREPEND, - EXPLICIT, - INSERT, - DELETE - } - - private static final int MODIFICATION_COUNT = ModificationType.values().length; - - private static final int MAX_BYTE_LENGTH_INSERT = 200; - - private static final int MAX_BYTE_LENGTH_EXPLICIT = 1000; - - private static final int MODIFIED_STRING_LENGTH_ESTIMATION = 50; - public static VariableModification prependValue(String value) { return new StringPrependValueModification(value); } @@ -53,58 +34,4 @@ public static VariableModification insertValue(String value, int positio public static VariableModification delete(int startPosition, int count) { return new StringDeleteModification(startPosition, count); } - - public static VariableModification createRandomModification(String originalValue) { - Random random = RandomHelper.getRandom(); - ModificationType randomType = ModificationType.values()[random.nextInt(MODIFICATION_COUNT)]; - int modificationArrayLength; - int modifiedArrayLength; - if (originalValue == null) { - modifiedArrayLength = MODIFIED_STRING_LENGTH_ESTIMATION; - } else { - modifiedArrayLength = originalValue.length(); - if (modifiedArrayLength == 0 || modifiedArrayLength == 1) { - randomType = ModificationType.EXPLICIT; - } - } - switch (randomType) { - case APPEND: - modificationArrayLength = random.nextInt(MAX_BYTE_LENGTH_INSERT); - if (modificationArrayLength == 0) { - modificationArrayLength++; - } - byte[] bytesToAppend = new byte[modificationArrayLength]; - random.nextBytes(bytesToAppend); - return new StringAppendValueModification(new String(bytesToAppend)); - case PREPEND: - modificationArrayLength = random.nextInt(MAX_BYTE_LENGTH_INSERT); - if (modificationArrayLength == 0) { - modificationArrayLength++; - } - byte[] bytesToPrepend = new byte[modificationArrayLength]; - random.nextBytes(bytesToPrepend); - return new StringPrependValueModification(new String(bytesToPrepend)); - case EXPLICIT: - modificationArrayLength = random.nextInt(MAX_BYTE_LENGTH_EXPLICIT); - byte[] explicitValue = new byte[modificationArrayLength]; - random.nextBytes(explicitValue); - return new StringExplicitValueModification(new String(explicitValue)); - case INSERT: - modificationArrayLength = random.nextInt(MAX_BYTE_LENGTH_INSERT); - if (modificationArrayLength == 0) { - modificationArrayLength++; - } - byte[] bytesToInsert = new byte[modificationArrayLength]; - random.nextBytes(bytesToInsert); - int insertPosition = random.nextInt(modifiedArrayLength); - return new StringInsertValueModification(new String(bytesToInsert), insertPosition); - case DELETE: - int startPosition = random.nextInt(modifiedArrayLength - 1); - int count = random.nextInt(modifiedArrayLength - startPosition); - count++; - return new StringDeleteModification(startPosition, count); - default: - throw new IllegalStateException("Unexpected modification type: " + randomType); - } - } } 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 c61b16c4..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,7 +12,6 @@ import java.security.SecureRandomSpi; import java.util.Random; -/** */ public class BadRandom extends SecureRandom { private Random random; 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 cf1e2371..c3efe327 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/Modifiable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/Modifiable.java @@ -18,8 +18,6 @@ import de.rub.nds.modifiablevariable.integer.ModifiableInteger; import de.rub.nds.modifiablevariable.longint.LongModificationFactory; import de.rub.nds.modifiablevariable.longint.ModifiableLong; -import de.rub.nds.modifiablevariable.path.ModifiablePath; -import de.rub.nds.modifiablevariable.path.PathModificationFactory; import de.rub.nds.modifiablevariable.singlebyte.ByteModificationFactory; import de.rub.nds.modifiablevariable.singlebyte.ModifiableByte; import de.rub.nds.modifiablevariable.string.ModifiableString; @@ -82,71 +80,26 @@ private static ModifiableString getModifiableStringWithModification( return modifiableString; } - private static ModifiablePath getModifiablePathWithModification( - VariableModification modification) { - ModifiablePath modifiablePath = new ModifiablePath(); - modifiablePath.setModification(modification); - return modifiablePath; - } - - public static ModifiableBigInteger prepend(BigInteger perpendValue) { - return getModifiableBigIntegerWithModification( - BigIntegerModificationFactory.prependValue(perpendValue)); - } - public static ModifiableByteArray prepend(byte[] perpendValue) { return getModifiableByteArrayWithModification( ByteArrayModificationFactory.prependValue(perpendValue)); } - public static ModifiableInteger prepend(Integer perpendValue) { - return getModifiableIntegerWithModification( - IntegerModificationFactory.prependValue(perpendValue)); - } - - public static ModifiableLong prepend(Long perpendValue) { - return getModifiableLongWithModification( - LongModificationFactory.prependValue(perpendValue)); - } - public static ModifiableString prepend(String perpendValue) { return getModifiableStringWithModification( StringModificationFactory.prependValue(perpendValue)); } - public static ModifiablePath prependPath(String perpendValue) { - return getModifiablePathWithModification( - PathModificationFactory.prependValue(perpendValue)); - } - - public static ModifiableBigInteger append(BigInteger appendValue) { - return getModifiableBigIntegerWithModification( - BigIntegerModificationFactory.appendValue(appendValue)); - } - public static ModifiableByteArray append(byte[] appendValue) { return getModifiableByteArrayWithModification( ByteArrayModificationFactory.appendValue(appendValue)); } - public static ModifiableInteger append(Integer appendValue) { - return getModifiableIntegerWithModification( - IntegerModificationFactory.appendValue(appendValue)); - } - - public static ModifiableLong append(Long appendValue) { - return getModifiableLongWithModification(LongModificationFactory.appendValue(appendValue)); - } - public static ModifiableString append(String appendValue) { return getModifiableStringWithModification( StringModificationFactory.appendValue(appendValue)); } - public static ModifiablePath appendPath(String appendValue) { - return getModifiablePathWithModification(PathModificationFactory.appendValue(appendValue)); - } - public static ModifiableByteArray explicit(byte[] explicitValue) { return getModifiableByteArrayWithModification( ByteArrayModificationFactory.explicitValue(explicitValue)); @@ -182,46 +135,16 @@ public static ModifiableString explicit(String explicitValue) { StringModificationFactory.explicitValue(explicitValue)); } - public static ModifiableBigInteger insert(BigInteger insertValue, int position) { - return getModifiableBigIntegerWithModification( - BigIntegerModificationFactory.insertValue(insertValue, position)); - } - public static ModifiableByteArray insert(byte[] insertValue, int position) { return getModifiableByteArrayWithModification( ByteArrayModificationFactory.insertValue(insertValue, position)); } - public static ModifiableInteger insert(Integer insertValue, int position) { - return getModifiableIntegerWithModification( - IntegerModificationFactory.insertValue(insertValue, position)); - } - - public static ModifiableLong insert(Long insertValue, int position) { - return getModifiableLongWithModification( - LongModificationFactory.insertValue(insertValue, position)); - } - public static ModifiableString insert(String insertValue, int position) { return getModifiableStringWithModification( StringModificationFactory.insertValue(insertValue, position)); } - public static ModifiablePath insertPath(String insertValue, int position) { - return getModifiablePathWithModification( - PathModificationFactory.insertValue(insertValue, position)); - } - - public static ModifiablePath insertDirectoryTraversal(int count, int position) { - return getModifiablePathWithModification( - PathModificationFactory.insertDirectoryTraversal(count, position)); - } - - public static ModifiablePath insertDirectorySeperator(int count, int position) { - return getModifiablePathWithModification( - PathModificationFactory.insertDirectorySeperator(count, position)); - } - public static ModifiableByteArray xor(byte[] xor, int position) { return getModifiableByteArrayWithModification( ByteArrayModificationFactory.xor(xor, position)); @@ -302,10 +225,6 @@ public static ModifiableBoolean toggle() { return getModifiableBooleanWithModification(BooleanModificationFactory.toggle()); } - public static ModifiablePath toggleRoot() { - return getModifiablePathWithModification(PathModificationFactory.toggleRoot()); - } - public static ModifiableBigInteger shiftLeftBigInteger(Integer shift) { return getModifiableBigIntegerWithModification( BigIntegerModificationFactory.shiftLeft(shift)); 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 e09c6927..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,7 +15,6 @@ import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; -/** */ public final class ModifiableVariableAnalyzer { private static final Logger LOGGER = LogManager.getLogger(ModifiableVariableAnalyzer.class); 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 96bdb56b..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,7 +9,6 @@ import java.util.Random; -/** */ public final class RandomHelper { private static Random random; diff --git a/src/main/java/de/rub/nds/modifiablevariable/util/UnformattedByteArrayAdapter.java b/src/main/java/de/rub/nds/modifiablevariable/util/UnformattedByteArrayAdapter.java index 19935c46..8cbcd9ae 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/UnformattedByteArrayAdapter.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/UnformattedByteArrayAdapter.java @@ -9,7 +9,6 @@ import jakarta.xml.bind.annotation.adapters.XmlAdapter; -/** */ public class UnformattedByteArrayAdapter 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/main/resources/de/rub/nds/modifiablevariable/explicit/long.vec b/src/main/resources/de/rub/nds/modifiablevariable/explicit/long.vec deleted file mode 100644 index da14a614..00000000 --- a/src/main/resources/de/rub/nds/modifiablevariable/explicit/long.vec +++ /dev/null @@ -1,31 +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 */ --9223372036854775808 /* Overflow signed 64-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 */ -9223372036854775807 /* Overflow signed 64-bit when incremented */ -4294967295 /* Overflow unsig 32-bit when incremented */ -4294967296 /* Overflow unsig 32-bit */ \ No newline at end of file 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 4076156e..0367f1c2 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationTest.java @@ -80,27 +80,6 @@ public void testExplicitValue() { assertEquals(BigInteger.TEN, start.getOriginalValue()); } - @Test - public void testInsertValue() { - // expect: 111xxxx - VariableModification modifier = - BigIntegerModificationFactory.insertValue(BigInteger.valueOf(7), 4); - start.setModification(modifier); - BigInteger mask = BigInteger.valueOf((1L << 3) - 1).shiftLeft(4); - expectedResult = BigInteger.valueOf(7); - result = start.getValue().and(mask).shiftRight(4); - assertEquals(expectedResult, result); - assertEquals(BigInteger.valueOf(10), start.getOriginalValue()); - - // expect: x111xxx - modifier = BigIntegerModificationFactory.insertValue(BigInteger.valueOf(7), 3); - start.setModification(modifier); - mask = BigInteger.valueOf((1L << 3) - 1).shiftLeft(3); - expectedResult = BigInteger.valueOf(7); - result = start.getValue().and(mask).shiftRight(3); - assertEquals(expectedResult, result); - } - /** Test of add method, of class BigIntegerModificationFactory. */ @Test public void testIsOriginalValueModified() { @@ -135,27 +114,4 @@ public void testShiftRight() { 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(27); - start.setModification(modifier); - expectedResult = BigInteger.valueOf(2147483647); - result = start.getValue(); - assertEquals(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 127c4228..4a23c35f 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/integer/IntegerModificationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/integer/IntegerModificationTest.java @@ -71,18 +71,6 @@ public void testExplicitValue() { assertEquals(Integer.valueOf(10), start.getOriginalValue()); } - @Test - public void testInsertValue() { - // expect: ...xx111xxxxxxxxxx - VariableModification modifier = IntegerModificationFactory.insertValue(7, 10); - start.setModification(modifier); - int mask = ((1 << 3) - 1) << 10; - expectedResult = 7; - result = (start.getValue() & mask) >> 10; - assertEquals(expectedResult, result); - assertEquals(Integer.valueOf(10), start.getOriginalValue()); - } - @Test public void testShiftLeft() { VariableModification modifier = IntegerModificationFactory.shiftLeft(2); @@ -102,27 +90,4 @@ public void testShiftRight() { 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/mlong/LongModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/mlong/LongModificationTest.java index 4b29ce19..bae1c936 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/mlong/LongModificationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/mlong/LongModificationTest.java @@ -70,38 +70,4 @@ public void testExplicitValue() { assertEquals(expectedResult, result); assertEquals(Long.valueOf(10L), start.getOriginalValue()); } - - @Test - public void testInsertValue() { - // expect: ...xx111xxxxxxxxxxxx - VariableModification modifier = LongModificationFactory.insertValue(7L, 12); - start.setModification(modifier); - int mask = ((1 << 3) - 1) << 12; - expectedResult = 7L; - result = (start.getValue() & mask) >> 12; - assertEquals(expectedResult, result); - assertEquals(Long.valueOf(10), 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(27); - start.setModification(modifier); - expectedResult = 2147483647L; - result = start.getValue(); - assertEquals(expectedResult, result); - } } diff --git a/src/test/java/de/rub/nds/modifiablevariable/path/PathModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/path/PathModificationTest.java deleted file mode 100644 index f44f4d26..00000000 --- a/src/test/java/de/rub/nds/modifiablevariable/path/PathModificationTest.java +++ /dev/null @@ -1,167 +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.path; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNull; - -import org.junit.jupiter.api.Test; - -public class PathModificationTest { - - @Test - public void testInsert() { - ModifiablePath nullPath = new ModifiablePath(); - nullPath.setModification(new PathInsertValueModification("test", 2)); - assertNull(nullPath.getValue()); - - ModifiablePath emptyPath = new ModifiablePath(""); - emptyPath.setModification(new PathInsertValueModification("test", 0)); - assertEquals("test", emptyPath.getValue()); - emptyPath.setModification(new PathInsertValueModification("test", 10)); - assertEquals("test", emptyPath.getValue()); - - ModifiablePath simplePathLeadingSlash = new ModifiablePath("/this/is/a/path"); - simplePathLeadingSlash.setModification(new PathInsertValueModification("test", 0)); - assertEquals("/test/this/is/a/path", simplePathLeadingSlash.getValue()); - simplePathLeadingSlash.setModification(new PathInsertValueModification("test", 4)); - assertEquals("/this/is/a/path/test", simplePathLeadingSlash.getValue()); - simplePathLeadingSlash.setModification(new PathInsertValueModification("test", 5)); - assertEquals("/test/this/is/a/path", simplePathLeadingSlash.getValue()); - simplePathLeadingSlash.setModification(new PathInsertValueModification("test", 6)); - assertEquals("/this/test/is/a/path", simplePathLeadingSlash.getValue()); - simplePathLeadingSlash.setModification(new PathInsertValueModification("test", 11)); - assertEquals("/this/test/is/a/path", simplePathLeadingSlash.getValue()); - - ModifiablePath simplePathLeadingAndTrailingSlash = new ModifiablePath("/this/is/a/path/"); - simplePathLeadingAndTrailingSlash.setModification( - new PathInsertValueModification("test", 0)); - assertEquals("/test/this/is/a/path/", simplePathLeadingAndTrailingSlash.getValue()); - simplePathLeadingAndTrailingSlash.setModification( - new PathInsertValueModification("test", 4)); - assertEquals("/this/is/a/path/test/", simplePathLeadingAndTrailingSlash.getValue()); - simplePathLeadingAndTrailingSlash.setModification( - new PathInsertValueModification("test", 5)); - assertEquals("/test/this/is/a/path/", simplePathLeadingAndTrailingSlash.getValue()); - simplePathLeadingAndTrailingSlash.setModification( - new PathInsertValueModification("test", 6)); - assertEquals("/this/test/is/a/path/", simplePathLeadingAndTrailingSlash.getValue()); - simplePathLeadingAndTrailingSlash.setModification( - new PathInsertValueModification("test", 11)); - assertEquals("/this/test/is/a/path/", simplePathLeadingAndTrailingSlash.getValue()); - - ModifiablePath simplePath = new ModifiablePath("this/is/a/path"); - simplePath.setModification(new PathInsertValueModification("test", 0)); - assertEquals("test/this/is/a/path", simplePath.getValue()); - simplePath.setModification(new PathInsertValueModification("test", 4)); - assertEquals("this/is/a/path/test", simplePath.getValue()); - simplePath.setModification(new PathInsertValueModification("test", 5)); - assertEquals("test/this/is/a/path", simplePath.getValue()); - simplePath.setModification(new PathInsertValueModification("test", 6)); - assertEquals("this/test/is/a/path", simplePath.getValue()); - simplePath.setModification(new PathInsertValueModification("test", 11)); - assertEquals("this/test/is/a/path", simplePath.getValue()); - - ModifiablePath simplePathTrailingSlash = new ModifiablePath("this/is/a/path/"); - simplePathTrailingSlash.setModification(new PathInsertValueModification("test", 0)); - assertEquals("test/this/is/a/path/", simplePathTrailingSlash.getValue()); - simplePathTrailingSlash.setModification(new PathInsertValueModification("test", 4)); - assertEquals("this/is/a/path/test/", simplePathTrailingSlash.getValue()); - simplePathTrailingSlash.setModification(new PathInsertValueModification("test", 5)); - assertEquals("test/this/is/a/path/", simplePathTrailingSlash.getValue()); - simplePathTrailingSlash.setModification(new PathInsertValueModification("test", 6)); - assertEquals("this/test/is/a/path/", simplePathTrailingSlash.getValue()); - simplePathTrailingSlash.setModification(new PathInsertValueModification("test", 11)); - assertEquals("this/test/is/a/path/", simplePathTrailingSlash.getValue()); - - ModifiablePath rootPath = new ModifiablePath("/"); - rootPath.setModification(new PathInsertValueModification("test", 0)); - assertEquals("/test/", rootPath.getValue()); - rootPath.setModification(new PathInsertValueModification("test", 2)); - assertEquals("/test/", rootPath.getValue()); - rootPath.setModification(new PathInsertValueModification("test", 5)); - assertEquals("/test/", rootPath.getValue()); - } - - @Test - public void testDelete() { - ModifiablePath nullPath = new ModifiablePath(); - nullPath.setModification(new PathDeleteModification(0, 1)); - assertNull(nullPath.getValue()); - - ModifiablePath emptyPath = new ModifiablePath(""); - emptyPath.setModification(new PathDeleteModification(0, 1)); - assertEquals("", emptyPath.getValue()); - emptyPath.setModification(new PathDeleteModification(1, 10)); - assertEquals("", emptyPath.getValue()); - - ModifiablePath simplePathLeadingSlash = new ModifiablePath("/this/is/a/path"); - simplePathLeadingSlash.setModification(new PathDeleteModification(0, 0)); - assertEquals("/this/is/a/path", simplePathLeadingSlash.getValue()); - simplePathLeadingSlash.setModification(new PathDeleteModification(4, 4)); - assertEquals("", simplePathLeadingSlash.getValue()); - simplePathLeadingSlash.setModification(new PathDeleteModification(4, 1)); - assertEquals("/is/a/path", simplePathLeadingSlash.getValue()); - simplePathLeadingSlash.setModification(new PathDeleteModification(5, 1)); - assertEquals("/this/a/path", simplePathLeadingSlash.getValue()); - simplePathLeadingSlash.setModification(new PathDeleteModification(6, 1)); - assertEquals("/this/is/path", simplePathLeadingSlash.getValue()); - simplePathLeadingSlash.setModification(new PathDeleteModification(11, 11)); - assertEquals("/this/is/a", simplePathLeadingSlash.getValue()); - - ModifiablePath simplePathLeadingAndTrailingSlash = new ModifiablePath("/this/is/a/path/"); - simplePathLeadingAndTrailingSlash.setModification(new PathDeleteModification(0, 0)); - assertEquals("/this/is/a/path/", simplePathLeadingAndTrailingSlash.getValue()); - simplePathLeadingAndTrailingSlash.setModification(new PathDeleteModification(4, 4)); - assertEquals("/", simplePathLeadingAndTrailingSlash.getValue()); - simplePathLeadingAndTrailingSlash.setModification(new PathDeleteModification(4, 1)); - assertEquals("/is/a/path/", simplePathLeadingAndTrailingSlash.getValue()); - simplePathLeadingAndTrailingSlash.setModification(new PathDeleteModification(5, 1)); - assertEquals("/this/a/path/", simplePathLeadingAndTrailingSlash.getValue()); - simplePathLeadingAndTrailingSlash.setModification(new PathDeleteModification(6, 1)); - assertEquals("/this/is/path/", simplePathLeadingAndTrailingSlash.getValue()); - simplePathLeadingAndTrailingSlash.setModification(new PathDeleteModification(11, 11)); - assertEquals("/this/is/a/", simplePathLeadingAndTrailingSlash.getValue()); - - ModifiablePath simplePath = new ModifiablePath("this/is/a/path"); - simplePath.setModification(new PathDeleteModification(0, 0)); - assertEquals("this/is/a/path", simplePath.getValue()); - simplePath.setModification(new PathDeleteModification(4, 4)); - assertEquals("", simplePath.getValue()); - simplePath.setModification(new PathDeleteModification(4, 1)); - assertEquals("is/a/path", simplePath.getValue()); - simplePath.setModification(new PathDeleteModification(5, 1)); - assertEquals("this/a/path", simplePath.getValue()); - simplePath.setModification(new PathDeleteModification(6, 1)); - assertEquals("this/is/path", simplePath.getValue()); - simplePath.setModification(new PathDeleteModification(11, 11)); - assertEquals("this/is/a", simplePath.getValue()); - - ModifiablePath simplePathTrailingSlash = new ModifiablePath("this/is/a/path/"); - simplePathTrailingSlash.setModification(new PathDeleteModification(0, 0)); - assertEquals("this/is/a/path/", simplePathTrailingSlash.getValue()); - simplePathTrailingSlash.setModification(new PathDeleteModification(4, 4)); - assertEquals("", simplePathTrailingSlash.getValue()); - simplePathTrailingSlash.setModification(new PathDeleteModification(4, 1)); - assertEquals("is/a/path/", simplePathTrailingSlash.getValue()); - simplePathTrailingSlash.setModification(new PathDeleteModification(5, 1)); - assertEquals("this/a/path/", simplePathTrailingSlash.getValue()); - simplePathTrailingSlash.setModification(new PathDeleteModification(6, 1)); - assertEquals("this/is/path/", simplePathTrailingSlash.getValue()); - simplePathTrailingSlash.setModification(new PathDeleteModification(11, 11)); - assertEquals("this/is/a/", simplePathTrailingSlash.getValue()); - - ModifiablePath rootPath = new ModifiablePath("/"); - rootPath.setModification(new PathDeleteModification(0, 0)); - assertEquals("/", rootPath.getValue()); - rootPath.setModification(new PathDeleteModification(2, 2)); - assertEquals("", rootPath.getValue()); - rootPath.setModification(new PathDeleteModification(5, 5)); - assertEquals("", rootPath.getValue()); - } -} diff --git a/src/test/java/de/rub/nds/modifiablevariable/serialization/PathSerializationTest.java b/src/test/java/de/rub/nds/modifiablevariable/serialization/PathSerializationTest.java deleted file mode 100644 index f1e1bdce..00000000 --- a/src/test/java/de/rub/nds/modifiablevariable/serialization/PathSerializationTest.java +++ /dev/null @@ -1,89 +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.serialization; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -import de.rub.nds.modifiablevariable.VariableModification; -import de.rub.nds.modifiablevariable.path.ModifiablePath; -import de.rub.nds.modifiablevariable.path.PathInsertValueModification; -import de.rub.nds.modifiablevariable.path.PathModificationFactory; -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 PathSerializationTest { - - private static final Logger LOGGER = LogManager.getLogger(); - - private ModifiablePath 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 ModifiablePath("Hello from Test ❤️\\ \u0000 \u0001 \u0006"); - expectedResult = null; - result = null; - - writer = new StringWriter(); - context = JAXBContext.newInstance(ModifiablePath.class, PathInsertValueModification.class); - m = context.createMarshaller(); - m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true); - um = context.createUnmarshaller(); - } - - @Test - public void testSerializeDeserializeSimple() throws Exception { - start.setModification(null); - start.setAssertEquals("Hello from Test 2 \\ \u0000 \u0001 \u0006"); - m.marshal(start, writer); - - String xmlString = writer.toString(); - LOGGER.debug(xmlString); - - um = context.createUnmarshaller(); - ModifiablePath unmarshalled = (ModifiablePath) 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 = PathModificationFactory.insertValue("Uff! ", 0); - start.setModification(modifier); - m.marshal(start, writer); - - String xmlString = writer.toString(); - LOGGER.debug(xmlString); - - um = context.createUnmarshaller(); - ModifiablePath unmarshalled = (ModifiablePath) um.unmarshal(new StringReader(xmlString)); - - expectedResult = "Uff! /Hello from Test ❤️\\ \u0000 \u0001 \u0006"; - result = unmarshalled.getValue(); - assertEquals(expectedResult, result); - } -} From f3957eac17c3b803a40e56aac59f321d409a527e Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Wed, 26 Feb 2025 15:59:02 +0100 Subject: [PATCH 78/82] Remove explicit value from file tests I forgot to delete --- .../bytearray/ModifiableByteArrayTest.java | 23 ------------------- .../singlebyte/ByteModificationTest.java | 16 ------------- 2 files changed, 39 deletions(-) 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 37563bf2..68bb9382 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArrayTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArrayTest.java @@ -318,29 +318,6 @@ public void testDuplicateModification() { 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() { 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..437c1d8e 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/singlebyte/ByteModificationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/singlebyte/ByteModificationTest.java @@ -71,20 +71,4 @@ public void testExplicitValue() { 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); - } } From 012c0cfdc64514cc1493d0837038549993fe2141 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Wed, 26 Feb 2025 16:50:22 +0100 Subject: [PATCH 79/82] Fix debug method in VariableModification for cases where resulting value is null. I used an extra message so one can distinguish it from "null" string. --- .../VariableModification.java | 26 ++++++++++++------- 1 file changed, 16 insertions(+), 10 deletions(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java b/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java index 01c4d723..5d7de761 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java @@ -56,18 +56,24 @@ protected void debug(E value) { } } 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(); + 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: {}", - getClass().getSimpleName(), - stack[index], - valueString); } } } From e9ba2b54d29ef9e6e02f2b7f6a57f95b0baaac3e Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Wed, 26 Feb 2025 16:52:06 +0100 Subject: [PATCH 80/82] Move String valueString definition into the case. --- .../de/rub/nds/modifiablevariable/VariableModification.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java b/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java index 5d7de761..e4e39170 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java @@ -55,14 +55,13 @@ protected void debug(E value) { index = i + 1; } } - String valueString; if (value == null) { LOGGER.debug( "Using {} in function:\n {}\n New value is unset", getClass().getSimpleName(), stack[index]); } else { - valueString = + String valueString = switch (value) { case byte[] bytes -> ArrayConverter.bytesToHexString(bytes); case String s -> backslashEscapeString(s); From 449ca21c075c593e9507770c3cf1cd7271d0baf0 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Fri, 28 Feb 2025 09:47:22 +0100 Subject: [PATCH 81/82] Remove setModification(), because you can use setModifications(...). This makes it slower, but at least it is more similar to the rest of the attacker ecosystem. Remove getFirstModification() because you can use getModifications() --- .../ModifiableVariable.java | 23 ------------------- 1 file changed, 23 deletions(-) diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java index c920eca2..a2563872 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -46,16 +46,6 @@ protected ModifiableVariable(ModifiableVariable other) { assertEquals = other.assertEquals; } - /** Set a single modification, all previously set modifications are removed */ - public void setModification(VariableModification modification) { - if (modification != null) { - modifications = new LinkedList<>(); - modifications.add(modification); - } else { - modifications = null; - } - } - /** Sets multiple modifications, all previously set modifications are removed */ public void setModifications(List> modifications) { if (modifications != null) { @@ -85,19 +75,6 @@ public void addModification(VariableModification modification) { } } - /** - * Returns the first modification that was set for this modifiable variable, if one exists. - * - *

Use {@code getModifications()} to get all modifications - */ - @XmlTransient - public VariableModification getFirstModification() { - if (modifications == null || modifications.isEmpty()) { - return null; - } - return modifications.getFirst(); - } - /** Returns all modifications that are set for this modifiable variable */ public LinkedList> getModifications() { return modifications; From 3567f7b2fd29292f9beb539f0b46b74c95409309 Mon Sep 17 00:00:00 2001 From: c0d3d3v Date: Fri, 28 Feb 2025 10:08:48 +0100 Subject: [PATCH 82/82] Replace all setModification() calls with setModifications() Add clearModifications() because a call with null on setModifications() is not possible. --- README.md | 4 +- .../ModifiableVariable.java | 17 +++---- .../modifiablevariable/util/Modifiable.java | 14 +++--- .../assertion/AssertionTest.java | 2 +- .../BigIntegerModificationTest.java | 16 +++--- .../BigIntegerOperationConcatenationTest.java | 2 +- .../bytearray/ModifiableByteArrayTest.java | 50 +++++++++---------- .../integer/IntegerModificationTest.java | 12 ++--- .../mlong/LongModificationTest.java | 8 +-- .../BigIntegerSerializationTest.java | 4 +- .../ByteArraySerializationTest.java | 4 +- .../serialization/ByteSerializationTest.java | 2 +- .../serialization/LongSerializationTest.java | 4 +- .../StringSerializationTest.java | 4 +- .../singlebyte/ByteModificationTest.java | 8 +-- 15 files changed, 74 insertions(+), 77 deletions(-) diff --git a/README.md b/README.md index 33f62920..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 ``` diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java index a2563872..7aca6a30 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -48,21 +48,18 @@ protected ModifiableVariable(ModifiableVariable other) { /** Sets multiple modifications, all previously set modifications are removed */ public void setModifications(List> modifications) { - if (modifications != null) { - this.modifications = new LinkedList<>(modifications); - } else { - this.modifications = null; - } + this.modifications = new LinkedList<>(modifications); } /** Sets multiple modifications, all previously set modifications are removed */ @SafeVarargs public final void setModifications(VariableModification... modifications) { - if (modifications != null) { - this.modifications = new LinkedList<>(List.of(modifications)); - } else { - this.modifications = null; - } + this.modifications = new LinkedList<>(List.of(modifications)); + } + + /** Removes all modifications */ + public void clearModifications() { + modifications = null; } /** Adds a modification to this modifiable variable */ 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 c3efe327..d5f1800a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/Modifiable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/Modifiable.java @@ -34,49 +34,49 @@ private Modifiable() { 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; } 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/BigIntegerModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationTest.java index 0367f1c2..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,7 +107,7 @@ 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); 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 cb0ef515..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 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 68bb9382..f93e2d3d 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArrayTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArrayTest.java @@ -61,7 +61,7 @@ public void testExplicitValue() { LOGGER.info("testExplicitValue"); VariableModification modifier = ByteArrayModificationFactory.explicitValue(modification1); - start.setModification(modifier); + start.setModifications(modifier); assertArrayEquals(modification1, start.getValue()); } @@ -70,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++) { @@ -84,7 +84,7 @@ public void testXorFirstBytes() { expResult2[i] = (byte) (originalValue[i] ^ modification2[i]); } VariableModification modifier2 = ByteArrayModificationFactory.xor(modification2, 0); - start.setModification(modifier2); + start.setModifications(modifier2); assertArrayEquals(expResult2, start.getValue()); } @@ -101,7 +101,7 @@ 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())); @@ -114,7 +114,7 @@ public void testXorLastBytes() { VariableModification modifier2 = ByteArrayModificationFactory.xor(modification2, first); - start.setModification(modifier2); + start.setModifications(modifier2); assertArrayEquals(expResult2, start.getValue()); } @@ -134,7 +134,7 @@ public void testPrependBytes() { VariableModification modifier = ByteArrayModificationFactory.insertValue(modification1, 0); - start.setModification(modifier); + start.setModifications(modifier); LOGGER.debug("Expected: {}", expResult); LOGGER.debug("Computed: {}", () -> ArrayConverter.bytesToHexString(start.getValue())); @@ -157,7 +157,7 @@ public void testAppendBytes() { VariableModification modifier = ByteArrayModificationFactory.insertValue(modification1, originalValue.length); - start.setModification(modifier); + start.setModifications(modifier); LOGGER.debug("Expected: {}", expResult); LOGGER.debug("Computed: {}", () -> ArrayConverter.bytesToHexString(start.getValue())); @@ -175,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())); @@ -195,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())); @@ -214,39 +214,39 @@ public void testDeleteBytes() { 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(), 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, 1); - start.setModification(modifier); + 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, 2); - start.setModification(modifier); + start.setModifications(modifier); assertArrayEquals(start.getValue(), expResult3); } @@ -259,7 +259,7 @@ public void testInsertBytes() { LOGGER.debug("Inserting negative at position"); VariableModification modifier = ByteArrayModificationFactory.insertValue(modification1, -2 * originalValue.length); - start.setModification(modifier); + start.setModifications(modifier); byte[] expResult = ArrayConverter.concatenate( Arrays.copyOf(originalValue, 1), @@ -271,7 +271,7 @@ public void testInsertBytes() { LOGGER.debug("Inserting empty Array"); byte[] emptyArray = new byte[0]; modifier = ByteArrayModificationFactory.insertValue(emptyArray, 0); - start.setModification(modifier); + start.setModifications(modifier); assertArrayEquals(originalValue, start.getValue()); // Insert at too positive position -> wrap around @@ -280,7 +280,7 @@ public void testInsertBytes() { LOGGER.debug("Inserting at too large position"); modifier = ByteArrayModificationFactory.insertValue(modification1, originalValue.length * 2); - start.setModification(modifier); + start.setModifications(modifier); expResult = ArrayConverter.concatenate( Arrays.copyOf(originalValue, originalValue.length - 1), @@ -295,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()); } @@ -311,7 +311,7 @@ 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())); @@ -324,17 +324,17 @@ 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()); } 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 4a23c35f..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,7 +84,7 @@ 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); 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 bae1c936..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,7 +64,7 @@ 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); 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 3cc1044f..f4031c6f 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/serialization/BigIntegerSerializationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/serialization/BigIntegerSerializationTest.java @@ -63,7 +63,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(); @@ -82,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(); 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 d7275e51..e6ee7e55 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/serialization/ByteArraySerializationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/serialization/ByteArraySerializationTest.java @@ -61,7 +61,7 @@ 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); @@ -81,7 +81,7 @@ public void testSerializeDeserializeSimple() throws Exception { public void testSerializeDeserializeWithModification() throws Exception { VariableModification modifier = ByteArrayModificationFactory.insertValue(new byte[] {1, 2}, 0); - start.setModification(modifier); + start.setModifications(modifier); m.marshal(start, writer); String xmlString = writer.toString(); 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 73622722..5faf289a 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/serialization/LongSerializationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/serialization/LongSerializationTest.java @@ -61,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(); @@ -78,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(); diff --git a/src/test/java/de/rub/nds/modifiablevariable/serialization/StringSerializationTest.java b/src/test/java/de/rub/nds/modifiablevariable/serialization/StringSerializationTest.java index be2e0318..c6cd3724 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/serialization/StringSerializationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/serialization/StringSerializationTest.java @@ -57,7 +57,7 @@ public void setUp() throws JAXBException { @Test public void testSerializeDeserializeSimple() throws Exception { - start.setModification(null); + start.clearModifications(); start.setAssertEquals("Hello from Test 2 \\ \u0000 \u0001 \u0006"); m.marshal(start, writer); @@ -76,7 +76,7 @@ public void testSerializeDeserializeSimple() throws Exception { @Test public void testSerializeDeserializeWithModification() throws Exception { VariableModification modifier = StringModificationFactory.insertValue("Uff! ", 0); - start.setModification(modifier); + start.setModifications(modifier); m.marshal(start, writer); String xmlString = writer.toString(); 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 437c1d8e..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,7 +65,7 @@ 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);