diff --git a/README.md b/README.md index c141ce0..c1849ba 100644 --- a/README.md +++ b/README.md @@ -157,6 +157,15 @@ to the directory of the .jar file that this tool will print in `stdout` (by defa --- +### Tests +You need to have [Krakatau](https://github.com/Storyyeller/Krakatau) installed to your PATH, because test suite is using `krak2` for some tests + +1. Run `gradlew build` to assemble and run full test suite + +This tool uses tests from [huzpsb/JavaObfuscatorTest](https://github.com/huzpsb/JavaObfuscatorTest) + +--- + In case of any problems, feel free to open an issue or contact me at [re146.dev](https://re146.dev) ### Stargazers over time diff --git a/obfuscator/src/test/java/by/radioegor146/ClassicTest.java b/obfuscator/src/test/java/by/radioegor146/ClassicTest.java index e4c8896..f85bb3a 100644 --- a/obfuscator/src/test/java/by/radioegor146/ClassicTest.java +++ b/obfuscator/src/test/java/by/radioegor146/ClassicTest.java @@ -74,7 +74,7 @@ public void execute() throws Throwable { Optional mainClassOptional = javaFiles.stream() .filter(uncheckedPredicate(p -> Files.lines(p).collect(Collectors.joining("\n")) .matches("(?s).*public(\\s+static)?\\s+void\\s+main.*"))) - .map(p -> p.getFileName().toString()) + .map(p -> testData.relativize(p).toString().replace('\\', '/')) .map(f -> f.substring(0, f.lastIndexOf('.'))) .findAny(); @@ -83,10 +83,13 @@ public void execute() throws Throwable { throw new RuntimeException("Main class not found"); } - javaFiles.forEach(uncheckedConsumer(p -> Files.copy(p, tempSource.resolve(p.getFileName())))); - krakatauFiles.forEach(uncheckedConsumer(p -> Files.copy(p, tempKrakatauSource.resolve(p.getFileName())))); - resourceFiles.forEach(uncheckedConsumer(p -> { - Path target = temp.resolve(testData.relativize(p)); + javaFiles.forEach(uncheckedConsumer(p -> { + Path target = tempSource.resolve(testData.relativize(p)); + Files.createDirectories(target.getParent()); + Files.copy(p, target); + })); + krakatauFiles.forEach(uncheckedConsumer(p -> { + Path target = tempKrakatauSource.resolve(testData.relativize(p)); Files.createDirectories(target.getParent()); Files.copy(p, target); })); @@ -110,10 +113,16 @@ public void execute() throws Throwable { })); } + System.out.println("Copying resources"); + resourceFiles.forEach(uncheckedConsumer(p -> { + Path target = tempClasses.resolve(testData.relativize(p)); + Files.createDirectories(target.getParent()); + Files.copy(p, target); + })); + List jarParameters = new ArrayList<>(Arrays.asList( "jar", "cvfe", idealJar.toString(), mainClassOptional.get(), "-C", tempClasses + File.separator, ".")); - resourceFiles.stream().map(Path::toString).forEach(jarParameters::add); ProcessHelper.run(temp, 10_000, jarParameters) .check("Jar command"); diff --git a/obfuscator/src/test/java/by/radioegor146/TestsGenerator.java b/obfuscator/src/test/java/by/radioegor146/TestsGenerator.java index d329787..b3b67a1 100644 --- a/obfuscator/src/test/java/by/radioegor146/TestsGenerator.java +++ b/obfuscator/src/test/java/by/radioegor146/TestsGenerator.java @@ -12,13 +12,14 @@ import java.nio.file.Path; import java.nio.file.Paths; import java.util.*; +import java.util.stream.Collectors; import java.util.stream.Stream; public class TestsGenerator { - private final static List ALLOWED_TESTS = null; /* + // private final static List ALLOWED_TESTS = null; /* private final static List ALLOWED_TESTS = Arrays.asList( - "StringTokenizer" + "JavaObfuscatorTest" ); // */ private static boolean testAllowed(Path testPath) { @@ -38,8 +39,21 @@ private static boolean testAllowed(Path testPath) { return false; } + public List generateTests(Path testDir, boolean useKrakatau) throws IOException { + List result = new ArrayList<>(); + for (Path path : Files.list(testDir).filter(Files::isDirectory).collect(Collectors.toList())) { + if (hasJavaFiles(path) && testAllowed(path)) { + result.add(DynamicTest.dynamicTest(testDir.relativize(path).toString(), + new ClassicTest(path, testDir.relativize(path).toString(), useKrakatau))); + continue; + } + result.addAll(generateTests(path, useKrakatau)); + } + return result; + } + @TestFactory - public Stream generateTests() throws URISyntaxException, IOException { + public Collection generateTests() throws URISyntaxException, IOException { URL tests = TestsGenerator.class.getClassLoader().getResource("tests"); Objects.requireNonNull(tests, "No tests dir in resources"); @@ -57,13 +71,9 @@ public Stream generateTests() throws URISyntaxException, IOExceptio useKrakatau = false; } - boolean finalUseKrakatau = useKrakatau; - Path testDir = Paths.get(tests.toURI()); - return Files.walk(testDir, FileVisitOption.FOLLOW_LINKS).filter(Files::isDirectory) - .filter(TestsGenerator::hasJavaFiles).filter(TestsGenerator::testAllowed) - .map(p -> DynamicTest.dynamicTest(testDir.relativize(p).toString(), - new ClassicTest(p, testDir.relativize(p).toString(), finalUseKrakatau))); + + return generateTests(testDir, useKrakatau); } private static boolean hasJavaFiles(Path path) { diff --git a/obfuscator/test_data/tests/indy/Test1/Test1.java b/obfuscator/test_data/tests/indy/IndyTest1/Test1.java similarity index 100% rename from obfuscator/test_data/tests/indy/Test1/Test1.java rename to obfuscator/test_data/tests/indy/IndyTest1/Test1.java diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/README.md b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/README.md new file mode 100644 index 0000000..900ed03 --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/README.md @@ -0,0 +1,3 @@ +# java-obfuscator-test + +Slightly modified tests from [huzpsb/JavaObfuscatorTest](https://github.com/huzpsb/JavaObfuscatorTest) \ No newline at end of file diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/Test.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/Test.java new file mode 100644 index 0000000..0b8bc08 --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/Test.java @@ -0,0 +1,2 @@ +public class Test { +} \ No newline at end of file diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/Clazz.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/Clazz.java new file mode 100644 index 0000000..a3aff8d --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/Clazz.java @@ -0,0 +1,4 @@ +package pack; + +public class Clazz { +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/Main.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/Main.java new file mode 100644 index 0000000..bd09c89 --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/Main.java @@ -0,0 +1,118 @@ +package pack; + +import pack.tests.basics.accu.Digi; +import pack.tests.basics.cross.Top; +import pack.tests.basics.ctrl.Ctrl; +import pack.tests.basics.inner.Test; +import pack.tests.basics.overwirte.Sub; +import pack.tests.basics.runable.Task; +import pack.tests.basics.sub.Solver; +import pack.tests.bench.Calc; +import pack.tests.reflects.annot.annot; +import pack.tests.reflects.counter.Count; +import pack.tests.reflects.field.FTest; +import pack.tests.reflects.loader.LRun; +import pack.tests.reflects.res.Accesor; +import pack.tests.reflects.retrace.Tracer; +import pack.tests.security.SecTest; + +import java.io.File; + +public class Main { + public static void main(String[] args) throws Exception { + System.out.println("Obfuscator Test Program"); + System.out.println("Author: huzpsb"); + System.out.println("Version: 1.0r"); + System.out.println("Link: https://github.com/huzpsb/JavaObfuscatorTest"); + System.out.println("-------------Test #1: Basics-------------"); + System.out.print("Test 1.1: Inheritance "); + try { + new Sub().run(); + } catch (Throwable t) { + System.out.println("ERROR"); + } + System.out.print("Test 1.2: Cross "); + try { + new Top().run(); + } catch (Throwable t) { + System.out.println("ERROR"); + } + System.out.print("Test 1.3: Throw "); + try { + new Ctrl().run(); + } catch (Throwable t) { + System.out.println("ERROR"); + } + System.out.print("Test 1.4: Accuracy "); + try { + new Digi().run(); + } catch (Throwable t) { + System.out.println("ERROR"); + } + System.out.print("Test 1.5: SubClass "); + try { + new Solver(); + } catch (Throwable t) { + System.out.println("ERROR"); + } + System.out.print("Test 1.6: Pool "); + try { + new Task().run(); + } catch (Throwable t) { + System.out.println("ERROR"); + } + System.out.print("Test 1.7: InnerClass "); + try { + new Test().run(); + } catch (Throwable t) { + System.out.println("ERROR"); + } + System.out.println("-------------Test #2: Reflects-------------"); + System.out.print("Test 2.1: Counter "); + try { + new Count().run(); + } catch (Throwable t) { + System.out.println("ERROR"); + } + System.out.print("Test 2.2: Chinese 通过LMAO\b\b\b\b \n"); + System.out.print("Test 2.3: Resource "); + try { + new Accesor().run(); + } catch (Throwable t) { + System.out.println("ERROR"); + } + System.out.print("Test 2.4: Field "); + try { + new FTest().run(); + } catch (Throwable t) { + System.out.println("ERROR"); + } + System.out.print("Test 2.5: Loader "); + try { + new LRun().run(); + } catch (Throwable t) { + System.out.println("ERROR"); + } + System.out.print("Test 2.6: ReTrace "); + try { + new Tracer().run(); + } catch (Throwable t) { + System.out.println("ERROR"); + } + System.out.print("Test 2.7: Annotation "); + try { + new annot().run(); + } catch (Throwable t) { + System.out.println("ERROR"); + } + System.out.print("Test 2.8: Sec "); + try { + new SecTest().run(); + } catch (Throwable t) { + System.out.println("ERROR"); + } + System.out.println("-------------Test #3: Efficiency-------------"); + Calc.runAll(); + System.out.println("-------------Tests r Finished-------------"); + } +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/accu/Digi.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/accu/Digi.java new file mode 100644 index 0000000..d71972c --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/accu/Digi.java @@ -0,0 +1,25 @@ +package pack.tests.basics.accu; + +public class Digi { + public void run() { + double fl = 0d; + int co = 0; + float fx = 1.1f; + while (true) { + fl += 0.000000000000000001d; + co++; + if (co > 100 || (float) fl == 0.00000000000000002f) + break; + } + if (co == 20) { + fx += 1.3f; + if (fx == 2.4f) { + System.out.println("PASS"); + return; + } + System.out.println("FAIL"); + } else { + System.out.println("FAIL"); + } + } +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/cross/Abst1.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/cross/Abst1.java new file mode 100644 index 0000000..e32a78f --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/cross/Abst1.java @@ -0,0 +1,9 @@ +package pack.tests.basics.cross; + +public abstract class Abst1 { + public abstract int add(int a, int b); + + public int mul(int a, int b) { + return a * b; + } +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/cross/Inte.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/cross/Inte.java new file mode 100644 index 0000000..f80869c --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/cross/Inte.java @@ -0,0 +1,5 @@ +package pack.tests.basics.cross; + +public interface Inte { + public int mul(int a, int b); +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/cross/Top.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/cross/Top.java new file mode 100644 index 0000000..ab1b78b --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/cross/Top.java @@ -0,0 +1,19 @@ +package pack.tests.basics.cross; + +public class Top extends Abst1 implements Inte { + + public void run() { + if (add(1, 2) == 3) { + if (mul(2, 3) == 6) { + System.out.println("PASS"); + return; + } + } + System.out.println("FAIL"); + } + + @Override + public int add(int a, int b) { + return a + b; + } +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/ctrl/Ctrl.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/ctrl/Ctrl.java new file mode 100644 index 0000000..efc1991 --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/ctrl/Ctrl.java @@ -0,0 +1,31 @@ +package pack.tests.basics.ctrl; + +public class Ctrl { + private String ret = "FAIL"; + + public void runt() { + if ("a".equals("b")) { + } else { + throw new UnsupportedOperationException(); + } + } + + public void runf() { + try { + runt(); + } catch (RuntimeException e) { + ret = "PASS"; + } + try { + runt(); + ret = "FAIL"; + } catch (Exception e) { + + } + } + + public void run() { + runf(); + System.out.println(ret); + } +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/inner/Exec.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/inner/Exec.java new file mode 100644 index 0000000..a4f4144 --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/inner/Exec.java @@ -0,0 +1,22 @@ +package pack.tests.basics.inner; + +public class Exec { + public int fuss = 1; + + public void addF() { + fuss += 2; + } + + public class Inner { + int i; + + public Inner(int p) { + i = p; + } + + public void doAdd() { + addF(); + fuss += i; + } + } +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/inner/Test.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/inner/Test.java new file mode 100644 index 0000000..88f4394 --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/inner/Test.java @@ -0,0 +1,15 @@ +package pack.tests.basics.inner; + +public class Test { + public void run() { + Exec exec = new Exec(); + Exec.Inner inner1 = exec.new Inner(3); + inner1.doAdd(); + Exec.Inner inner2 = exec.new Inner(100); + inner2.doAdd(); + if (exec.fuss == 108) + System.out.println("PASS"); + else + System.out.println("ERROR"); + } +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/overwirte/Face.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/overwirte/Face.java new file mode 100644 index 0000000..797c1de --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/overwirte/Face.java @@ -0,0 +1,5 @@ +package pack.tests.basics.overwirte; + +public interface Face { + String face(int i); +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/overwirte/Sub.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/overwirte/Sub.java new file mode 100644 index 0000000..cfe5def --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/overwirte/Sub.java @@ -0,0 +1,17 @@ +package pack.tests.basics.overwirte; + +public class Sub extends Super { + public void run() { + Object o = this; + System.out.println(((Face) o).face(1)); + } + + @Override + public String face(int i) { + if (i == 1) { + return "PASS"; + } else { + return "FAIL"; + } + } +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/overwirte/Super.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/overwirte/Super.java new file mode 100644 index 0000000..f621220 --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/overwirte/Super.java @@ -0,0 +1,7 @@ +package pack.tests.basics.overwirte; + +public abstract class Super implements Face { + public void run() { + System.out.println("FAIL"); + } +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/runable/Exec.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/runable/Exec.java new file mode 100644 index 0000000..b9282c3 --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/runable/Exec.java @@ -0,0 +1,19 @@ +package pack.tests.basics.runable; + +public class Exec { + public static int i = 1; + private int d; + + public Exec(int delta) { + d = delta; + } + + void doAdd() { + try { + Thread.sleep(200L); + } catch (Exception ignored) { + + } + i += d; + } +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/runable/Pool.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/runable/Pool.java new file mode 100644 index 0000000..e6d31eb --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/runable/Pool.java @@ -0,0 +1,9 @@ +package pack.tests.basics.runable; + +import java.util.concurrent.LinkedBlockingQueue; +import java.util.concurrent.ThreadPoolExecutor; +import java.util.concurrent.TimeUnit; + +public class Pool { + public static ThreadPoolExecutor tpe = new ThreadPoolExecutor(0, 1, 1, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1)); +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/runable/Task.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/runable/Task.java new file mode 100644 index 0000000..146ccda --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/runable/Task.java @@ -0,0 +1,37 @@ +package pack.tests.basics.runable; + +import java.util.concurrent.RejectedExecutionException; + +public class Task { + public void run() throws Exception { + Exec e1 = new Exec(2); + Exec e2 = new Exec(3); + Exec e3 = new Exec(100); + try { + Pool.tpe.submit(e2::doAdd); + try { + Thread.sleep(50L); + } catch (InterruptedException e) { + } + Pool.tpe.submit(() -> { + int ix = Exec.i; + e1.doAdd(); + Exec.i += ix; + }); + try { + Thread.sleep(50L); + } catch (InterruptedException e) { + } + Pool.tpe.submit(e3::doAdd); + } catch (RejectedExecutionException e) { + Exec.i += 10; + } + Thread.sleep(300L); + if (Exec.i == 30) { + // 1->4(+3,e2)->14(+10,catch)->16(+2,e1)->30(+14,ix) + System.out.println("PASS"); + } else { + System.out.println("FAIL"); + } + } +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/sub/SolAdd.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/sub/SolAdd.java new file mode 100644 index 0000000..8f4ce6b --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/sub/SolAdd.java @@ -0,0 +1,21 @@ +package pack.tests.basics.sub; + +public class SolAdd { + public static int get() { + return new med(1, 2).result; + } +} + +class med { + int result; + + med(int a, int b) { + result = new flo().solve(a, b); + } +} + +class flo { + int solve(int a, int b) { + return a + b; + } +} \ No newline at end of file diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/sub/Solver.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/sub/Solver.java new file mode 100644 index 0000000..220ba62 --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/basics/sub/Solver.java @@ -0,0 +1,11 @@ +package pack.tests.basics.sub; + +public class Solver { + public Solver() { + if (SolAdd.get() == 3) { + System.out.println("PASS"); + } else { + System.out.println("FAIL"); + } + } +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/bench/Calc.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/bench/Calc.java new file mode 100644 index 0000000..3e35a4b --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/bench/Calc.java @@ -0,0 +1,40 @@ +package pack.tests.bench; + +public class Calc { + public static int count = 0; + + public static void runAll() { + long start = System.currentTimeMillis(); + for (int i = 0; i < 10000; i++) { + call(100); + runAdd(); + runStr(); + } + System.err.println("Calc: " + (System.currentTimeMillis() - start) + "ms"); + if (count != 30000) + throw new RuntimeException("[ERROR]: Errors occurred in calc!"); + } + + private static void call(int i) { + if (i == 0) + count++; + else + call(i - 1); + } + + private static void runAdd() { + double i = 0d; + while (i < 100.1d) { + i += 0.99d; + } + count++; + } + + private static void runStr() { + String str = ""; + while (str.length() < 101) { + str += "ax"; + } + count++; + } +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/annot/anno.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/annot/anno.java new file mode 100644 index 0000000..4149def --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/annot/anno.java @@ -0,0 +1,11 @@ +package pack.tests.reflects.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +@Retention(RetentionPolicy.RUNTIME) +public @interface anno { + String val() default "yes"; + + String val2() default "yes"; +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/annot/annoe.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/annot/annoe.java new file mode 100644 index 0000000..e11fe36 --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/annot/annoe.java @@ -0,0 +1,26 @@ +package pack.tests.reflects.annot; + +import java.lang.reflect.Field; + +public class annoe { + @anno(val = "PASS") + private static final String fail = "WHAT"; + + @anno + public void dox() throws Exception { + String toGet = "FAIL"; + for (Field f : annoe.class.getDeclaredFields()) { + f.setAccessible(true); + anno obj = f.getAnnotation(anno.class); + if (obj != null) { + toGet = obj.val(); + } + } + System.out.println(toGet); + } + + @anno(val = "no") + public void dov() { + System.out.println("FAIL"); + } +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/annot/annot.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/annot/annot.java new file mode 100644 index 0000000..edecfee --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/annot/annot.java @@ -0,0 +1,18 @@ +package pack.tests.reflects.annot; + +import java.lang.reflect.Method; + +public class annot { + public void run() throws Exception { + annoe a = new annoe(); + for (Method m : annoe.class.getDeclaredMethods()) { + m.setAccessible(true); + anno an = m.getAnnotation(anno.class); + if (an != null) { + if (an.val().equals("yes")) { + m.invoke(a); + } + } + } + } +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/counter/Count.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/counter/Count.java new file mode 100644 index 0000000..a2753a3 --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/counter/Count.java @@ -0,0 +1,10 @@ +package pack.tests.reflects.counter; + +public class Count { + public void run() throws Throwable { + if (Countee.class.getFields().length == 1 && Countee.class.getDeclaredFields().length == 4 && Countee.class.getMethods().length > 4 && Countee.class.getDeclaredMethods().length == 4) + System.out.println("PASS"); + else + System.out.println("FAIL"); + } +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/counter/Countee.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/counter/Countee.java new file mode 100644 index 0000000..f8806a7 --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/counter/Countee.java @@ -0,0 +1,20 @@ +package pack.tests.reflects.counter; + +public class Countee { + public int cpuli = 0; + protected int cprot = 0; + int cpackp = 1; + private int cpriv = 0; + + public void mpuli() { + } + + public void mprot() { + } + + public void mpackp() { + } + + public void mpriv() { + } +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/field/FObject.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/field/FObject.java new file mode 100644 index 0000000..b0fc7f3 --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/field/FObject.java @@ -0,0 +1,13 @@ +package pack.tests.reflects.field; + +public class FObject { + private int i; + + private FObject(int i) { + this.i = i; + } + + private void add() { + i += 3; + } +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/field/FTest.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/field/FTest.java new file mode 100644 index 0000000..9237908 --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/field/FTest.java @@ -0,0 +1,35 @@ +package pack.tests.reflects.field; + +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.lang.reflect.Method; + +public class FTest { + public void run() throws Exception { + Constructor con = FObject.class.getDeclaredConstructor(int.class); + if (con.isAccessible()) { + System.out.println("FAIL"); + return; + } + con.setAccessible(true); + FObject obj = (FObject) con.newInstance(1); + Method m = FObject.class.getDeclaredMethod("add", null); + if (m.isAccessible()) { + System.out.println("FAIL"); + return; + } + m.setAccessible(true); + m.invoke(obj); + Field f = FObject.class.getDeclaredField("i"); + if (f.isAccessible()) { + System.out.println("FAIL"); + return; + } + f.setAccessible(true); + if (f.getInt(obj) != 4) { + System.out.println("FAIL"); + return; + } + System.out.println("PASS"); + } +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/loader/LRun.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/loader/LRun.java new file mode 100644 index 0000000..7652376 --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/loader/LRun.java @@ -0,0 +1,10 @@ +package pack.tests.reflects.loader; + +public class LRun { + public void run() throws Exception { + Loader l = new Loader(); + Class c = l.findClass("pack.tests.reflects.loader.LTest"); + Object o = c.newInstance(); + c.getMethod("run").invoke(o); + } +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/loader/LTest.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/loader/LTest.java new file mode 100644 index 0000000..632f6ec --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/loader/LTest.java @@ -0,0 +1,21 @@ +package pack.tests.reflects.loader; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.InputStream; + +public class LTest { + public static byte[] readAllBytes(InputStream is) throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + byte[] buffer = new byte[1024]; + int bytesRead; + while ((bytesRead = is.read(buffer)) != -1) { + baos.write(buffer, 0, bytesRead); + } + return baos.toByteArray(); + } + + public void run() throws Exception { + System.out.println(new String(readAllBytes(LTest.class.getResourceAsStream("TEST")))); + } +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/loader/Loader.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/loader/Loader.java new file mode 100644 index 0000000..d9e79f0 --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/loader/Loader.java @@ -0,0 +1,35 @@ +package pack.tests.reflects.loader; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.InputStream; + +public class Loader extends ClassLoader { + public static byte[] readAllBytes(InputStream is) { + try { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + byte[] buffer = new byte[1024]; + int bytesRead; + while ((bytesRead = is.read(buffer)) != -1) { + baos.write(buffer, 0, bytesRead); + } + return baos.toByteArray(); + } catch (Exception e) { + return null; + } + } + + @Override + public InputStream getResourceAsStream(String name) { + if (name.contains("TEST")) { + return new ByteArrayInputStream("PASS".getBytes()); + } + return super.getResourceAsStream(name); + } + + @Override + public Class findClass(String name) throws ClassNotFoundException { + byte[] data = readAllBytes(Loader.class.getClassLoader().getResourceAsStream("pack/tests/reflects/loader/LTest.class")); + return defineClass(name, data, 0, data.length); + } +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/loader/TEST b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/loader/TEST new file mode 100644 index 0000000..fc26162 --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/loader/TEST @@ -0,0 +1 @@ +FAIL \ No newline at end of file diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/res/Accesor.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/res/Accesor.java new file mode 100644 index 0000000..b34da45 --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/res/Accesor.java @@ -0,0 +1,20 @@ +package pack.tests.reflects.res; + +public class Accesor { + public void run() { + try { + if (Accesor.class.getResourceAsStream("/pack/tests/reflects/res/file").read() != 'a') { + throw new RuntimeException(); + } + if (Accesor.class.getResourceAsStream("file2").read() != 'r') { + throw new RuntimeException(); + } + if (Accesor.class.getClassLoader().getResourceAsStream("pack/tests/reflects/res/file3").read() != 'c') { + throw new RuntimeException(); + } + System.out.println("PASS"); + } catch (Exception e) { + System.out.println("FAIL"); + } + } +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/res/file b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/res/file new file mode 100644 index 0000000..2e65efe --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/res/file @@ -0,0 +1 @@ +a \ No newline at end of file diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/res/file2 b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/res/file2 new file mode 100644 index 0000000..1d2f014 --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/res/file2 @@ -0,0 +1 @@ +r \ No newline at end of file diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/res/file3 b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/res/file3 new file mode 100644 index 0000000..3410062 --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/res/file3 @@ -0,0 +1 @@ +c \ No newline at end of file diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/retrace/Tracee.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/retrace/Tracee.java new file mode 100644 index 0000000..c41b8b8 --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/retrace/Tracee.java @@ -0,0 +1,16 @@ +package pack.tests.reflects.retrace; + +public class Tracee { + public static int p = 0; + + private void doTrace(int i) throws Exception { + p++; + StackTraceElement ste = new Throwable().getStackTrace()[1]; + Tracee.class.getDeclaredMethod(ste.getMethodName(), int.class).invoke(this, i - 1); + } + + public void toTrace(int i) throws Exception { + if (i == 0) return; + doTrace(i); + } +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/retrace/Tracer.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/retrace/Tracer.java new file mode 100644 index 0000000..89c04f2 --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/reflects/retrace/Tracer.java @@ -0,0 +1,12 @@ +package pack.tests.reflects.retrace; + +public class Tracer { + public void run() throws Exception { + new Tracee().toTrace(5); + if (Tracee.p == 5) { + System.out.println("PASS"); + } else { + System.out.println("FAIL"); + } + } +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/security/SecExec.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/security/SecExec.java new file mode 100644 index 0000000..009cef2 --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/security/SecExec.java @@ -0,0 +1,7 @@ +package pack.tests.security; + +public class SecExec { + private static void doShutdown() { + System.exit(-1); + } +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/security/SecTest.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/security/SecTest.java new file mode 100644 index 0000000..7b782a7 --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/security/SecTest.java @@ -0,0 +1,32 @@ +package pack.tests.security; + +import java.lang.reflect.Method; + +public class SecTest { + public void run() { + System.setSecurityManager(new Sman()); + System.out.print("FAIL"); + try { + Method m = SecExec.class.getDeclaredMethod("doShutdown"); + m.setAccessible(true); + m.invoke(null); + } catch (Throwable t) { + Throwable r, f = t; + while (true) { + r = f.getCause(); + if (r != null) { + f = r; + continue; + } + break; + } + String str = f.getMessage(); + if (str == null) { + return; + } + if (str.contains("HOOK")) { + System.out.println("\b\b\b\bPASS"); + } + } + } +} diff --git a/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/security/Sman.java b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/security/Sman.java new file mode 100644 index 0000000..26a60c0 --- /dev/null +++ b/obfuscator/test_data/tests/java-obfuscator-test/JavaObfuscatorTest/pack/tests/security/Sman.java @@ -0,0 +1,10 @@ +package pack.tests.security; + +import java.security.Permission; + +public class Sman extends SecurityManager { + public void checkPermission(Permission perm) { + if (perm.getName().contains("exitVM")) + throw new SecurityException("HOOKED"); + } +}