├── testData ├── compiled │ ├── custom-jars │ │ ├── .gitkeep │ │ ├── grunt-obf.jar │ │ ├── qprotect-obf.jar │ │ ├── skidfuscator.jar │ │ ├── SnakeGame-obf-zkm.jar │ │ └── branchlock │ │ │ ├── flow │ │ │ └── flow 9.jar │ │ │ ├── branchlock-string.jar │ │ │ ├── branchlock-string-flow-number.jar │ │ │ ├── branchlock-string-salting-number.jar │ │ │ └── branchlock-string-salting-flow-number.jar │ └── custom-classes │ │ ├── JSR.class │ │ ├── KotlinSample.class │ │ ├── Pop2Sample.class │ │ ├── KotlinSample2.class │ │ ├── KotlinSample3.class │ │ ├── hp888 │ │ ├── pack │ │ │ └── MyFunction2.class │ │ ├── com │ │ │ └── bric │ │ │ │ └── colorpicker │ │ │ │ ├── ColorPicker$1.mc │ │ │ │ ├── ColorPicker.mc │ │ │ │ └── ColorPickerMode.mc │ │ └── IIIlIIIlllIIIlllIIlIllIIlIIIIIllIlIIlIlIllIIIlIIII.class │ │ ├── qprotect │ │ ├── sample1 │ │ │ ├── XML.class │ │ │ ├── JSONWriter.class │ │ │ ├── JSONStringer.class │ │ │ ├── JSONTokener.class │ │ │ └── ParserConfiguration.class │ │ ├── sample2 │ │ │ └── ChatUtil.class │ │ └── sample3 │ │ │ └── fastcode │ │ │ └── IlllIIlIIlllIIIl.class │ │ ├── zkm │ │ ├── sample2 │ │ │ └── a │ │ │ │ └── a │ │ │ │ └── a │ │ │ │ └── a │ │ │ │ ├── a.class │ │ │ │ ├── a4.class │ │ │ │ ├── a_.class │ │ │ │ ├── b.class │ │ │ │ ├── ba.class │ │ │ │ ├── bc.class │ │ │ │ └── c.class │ │ ├── EnhancedStringEncManyStrings.class │ │ ├── EnhancedStringEncSomeStrings.class │ │ └── sample1 │ │ │ ├── me │ │ │ └── frep │ │ │ │ └── vulcan │ │ │ │ └── spigot │ │ │ │ ├── Vulcan_a.class │ │ │ │ ├── Vulcan_m.class │ │ │ │ └── Vulcan_x.class │ │ │ └── io │ │ │ └── github │ │ │ └── repooper │ │ │ └── packetevents │ │ │ ├── PacketEvents.class │ │ │ └── utils │ │ │ └── netty │ │ │ └── bytebuf │ │ │ ├── ByteBufUtil.class │ │ │ ├── ByteBufUtil_7.class │ │ │ └── ByteBufUtil_8.class │ │ ├── guardprotector │ │ └── Class951.class │ │ ├── unknown │ │ └── obf1 │ │ │ ├── SomeClass1.class │ │ │ └── SomeClass2.class │ │ └── sb27 │ │ └── sample1 │ │ └── ConfigComplete.class ├── results │ ├── custom-jars │ │ ├── skidfuscator │ │ │ └── pack │ │ │ │ ├── Clazz.dec │ │ │ │ └── tests │ │ │ │ ├── basics │ │ │ │ ├── cross │ │ │ │ │ ├── Inte.dec │ │ │ │ │ ├── Abst1.dec │ │ │ │ │ └── Top.dec │ │ │ │ ├── overwirte │ │ │ │ │ ├── Face.dec │ │ │ │ │ ├── Super.dec │ │ │ │ │ └── Sub.dec │ │ │ │ ├── sub │ │ │ │ │ ├── flo.dec │ │ │ │ │ ├── SolAdd.dec │ │ │ │ │ ├── med.dec │ │ │ │ │ └── Solver.dec │ │ │ │ ├── runable │ │ │ │ │ ├── Exec.dec │ │ │ │ │ └── Pool.dec │ │ │ │ ├── inner │ │ │ │ │ ├── Test.dec │ │ │ │ │ └── Exec.dec │ │ │ │ ├── accu │ │ │ │ │ └── Digi.dec │ │ │ │ └── ctrl │ │ │ │ │ └── Ctrl.dec │ │ │ │ ├── security │ │ │ │ ├── SecExec.dec │ │ │ │ ├── Sman.dec │ │ │ │ └── SecTest.dec │ │ │ │ └── reflects │ │ │ │ ├── annot │ │ │ │ ├── anno.dec │ │ │ │ ├── annot.dec │ │ │ │ └── annoe.dec │ │ │ │ ├── retrace │ │ │ │ ├── Tracer.dec │ │ │ │ └── Tracee.dec │ │ │ │ ├── counter │ │ │ │ ├── Countee.dec │ │ │ │ └── Count.dec │ │ │ │ └── loader │ │ │ │ ├── LRun.dec │ │ │ │ └── LTest.dec │ │ ├── branchlock │ │ │ ├── flow │ │ │ │ └── flow 9 │ │ │ │ │ └── pack │ │ │ │ │ ├── Clazz.dec │ │ │ │ │ └── tests │ │ │ │ │ ├── basics │ │ │ │ │ ├── cross │ │ │ │ │ │ ├── Inte.dec │ │ │ │ │ │ ├── Abst1.dec │ │ │ │ │ │ └── Top.dec │ │ │ │ │ ├── overwirte │ │ │ │ │ │ ├── Face.dec │ │ │ │ │ │ ├── Super.dec │ │ │ │ │ │ └── Sub.dec │ │ │ │ │ ├── sub │ │ │ │ │ │ ├── flo.dec │ │ │ │ │ │ ├── SolAdd.dec │ │ │ │ │ │ ├── med.dec │ │ │ │ │ │ └── Solver.dec │ │ │ │ │ ├── runable │ │ │ │ │ │ ├── Exec.dec │ │ │ │ │ │ ├── Pool.dec │ │ │ │ │ │ └── Task.dec │ │ │ │ │ ├── inner │ │ │ │ │ │ ├── Test.dec │ │ │ │ │ │ └── Exec.dec │ │ │ │ │ ├── ctrl │ │ │ │ │ │ └── Ctrl.dec │ │ │ │ │ └── accu │ │ │ │ │ │ └── Digi.dec │ │ │ │ │ ├── security │ │ │ │ │ ├── SecExec.dec │ │ │ │ │ ├── Sman.dec │ │ │ │ │ └── SecTest.dec │ │ │ │ │ ├── reflects │ │ │ │ │ ├── field │ │ │ │ │ │ └── FObject.dec │ │ │ │ │ ├── res │ │ │ │ │ │ └── Accesor.dec │ │ │ │ │ ├── annot │ │ │ │ │ │ ├── anno.dec │ │ │ │ │ │ ├── annoe.dec │ │ │ │ │ │ └── annot.dec │ │ │ │ │ ├── loader │ │ │ │ │ │ ├── LRun.dec │ │ │ │ │ │ ├── LTest.dec │ │ │ │ │ │ └── Loader.dec │ │ │ │ │ ├── retrace │ │ │ │ │ │ ├── Tracer.dec │ │ │ │ │ │ └── Tracee.dec │ │ │ │ │ └── counter │ │ │ │ │ │ ├── Countee.dec │ │ │ │ │ │ └── Count.dec │ │ │ │ │ └── bench │ │ │ │ │ └── Calc.dec │ │ │ ├── branchlock-string │ │ │ │ └── pack │ │ │ │ │ ├── Clazz.dec │ │ │ │ │ └── tests │ │ │ │ │ ├── basics │ │ │ │ │ ├── cross │ │ │ │ │ │ ├── Inte.dec │ │ │ │ │ │ ├── Abst1.dec │ │ │ │ │ │ └── Top.dec │ │ │ │ │ ├── overwirte │ │ │ │ │ │ ├── Face.dec │ │ │ │ │ │ ├── Super.dec │ │ │ │ │ │ └── Sub.dec │ │ │ │ │ ├── sub │ │ │ │ │ │ ├── flo.dec │ │ │ │ │ │ ├── SolAdd.dec │ │ │ │ │ │ ├── med.dec │ │ │ │ │ │ └── Solver.dec │ │ │ │ │ ├── runable │ │ │ │ │ │ ├── Pool.dec │ │ │ │ │ │ ├── Exec.dec │ │ │ │ │ │ └── Task.dec │ │ │ │ │ ├── inner │ │ │ │ │ │ ├── Test.dec │ │ │ │ │ │ └── Exec.dec │ │ │ │ │ ├── accu │ │ │ │ │ │ └── Digi.dec │ │ │ │ │ └── ctrl │ │ │ │ │ │ └── Ctrl.dec │ │ │ │ │ ├── security │ │ │ │ │ ├── SecExec.dec │ │ │ │ │ ├── Sman.dec │ │ │ │ │ └── SecTest.dec │ │ │ │ │ ├── reflects │ │ │ │ │ ├── field │ │ │ │ │ │ └── FObject.dec │ │ │ │ │ ├── annot │ │ │ │ │ │ ├── anno.dec │ │ │ │ │ │ ├── annot.dec │ │ │ │ │ │ └── annoe.dec │ │ │ │ │ ├── loader │ │ │ │ │ │ ├── LRun.dec │ │ │ │ │ │ └── LTest.dec │ │ │ │ │ ├── retrace │ │ │ │ │ │ ├── Tracer.dec │ │ │ │ │ │ └── Tracee.dec │ │ │ │ │ ├── counter │ │ │ │ │ │ ├── Countee.dec │ │ │ │ │ │ └── Count.dec │ │ │ │ │ └── res │ │ │ │ │ │ └── Accesor.dec │ │ │ │ │ └── bench │ │ │ │ │ └── Calc.dec │ │ │ ├── branchlock-string-flow-number │ │ │ │ └── pack │ │ │ │ │ ├── Clazz.dec │ │ │ │ │ └── tests │ │ │ │ │ ├── basics │ │ │ │ │ ├── cross │ │ │ │ │ │ ├── Inte.dec │ │ │ │ │ │ ├── Abst1.dec │ │ │ │ │ │ └── Top.dec │ │ │ │ │ ├── overwirte │ │ │ │ │ │ ├── Face.dec │ │ │ │ │ │ ├── Super.dec │ │ │ │ │ │ └── Sub.dec │ │ │ │ │ ├── sub │ │ │ │ │ │ ├── flo.dec │ │ │ │ │ │ ├── med.dec │ │ │ │ │ │ ├── Solver.dec │ │ │ │ │ │ └── SolAdd.dec │ │ │ │ │ ├── runable │ │ │ │ │ │ ├── Exec.dec │ │ │ │ │ │ └── Pool.dec │ │ │ │ │ ├── accu │ │ │ │ │ │ └── Digi.dec │ │ │ │ │ ├── inner │ │ │ │ │ │ ├── Test.dec │ │ │ │ │ │ └── Exec.dec │ │ │ │ │ └── ctrl │ │ │ │ │ │ └── Ctrl.dec │ │ │ │ │ ├── security │ │ │ │ │ ├── SecExec.dec │ │ │ │ │ ├── Sman.dec │ │ │ │ │ └── SecTest.dec │ │ │ │ │ ├── reflects │ │ │ │ │ ├── annot │ │ │ │ │ │ ├── anno.dec │ │ │ │ │ │ ├── annot.dec │ │ │ │ │ │ └── annoe.dec │ │ │ │ │ ├── field │ │ │ │ │ │ └── FObject.dec │ │ │ │ │ ├── res │ │ │ │ │ │ └── Accesor.dec │ │ │ │ │ ├── retrace │ │ │ │ │ │ ├── Tracer.dec │ │ │ │ │ │ └── Tracee.dec │ │ │ │ │ ├── loader │ │ │ │ │ │ ├── LRun.dec │ │ │ │ │ │ ├── LTest.dec │ │ │ │ │ │ └── Loader.dec │ │ │ │ │ └── counter │ │ │ │ │ │ ├── Countee.dec │ │ │ │ │ │ └── Count.dec │ │ │ │ │ └── bench │ │ │ │ │ └── Calc.dec │ │ │ ├── branchlock-string-salting-number │ │ │ │ └── pack │ │ │ │ │ ├── tests │ │ │ │ │ ├── basics │ │ │ │ │ │ ├── cross │ │ │ │ │ │ │ ├── Inte.dec │ │ │ │ │ │ │ ├── Abst1.dec │ │ │ │ │ │ │ └── Top.dec │ │ │ │ │ │ ├── overwirte │ │ │ │ │ │ │ ├── Face.dec │ │ │ │ │ │ │ ├── Super.dec │ │ │ │ │ │ │ └── Sub.dec │ │ │ │ │ │ ├── sub │ │ │ │ │ │ │ ├── flo.dec │ │ │ │ │ │ │ ├── med.dec │ │ │ │ │ │ │ ├── SolAdd.dec │ │ │ │ │ │ │ └── Solver.dec │ │ │ │ │ │ ├── runable │ │ │ │ │ │ │ ├── Exec.dec │ │ │ │ │ │ │ └── Pool.dec │ │ │ │ │ │ ├── accu │ │ │ │ │ │ │ └── Digi.dec │ │ │ │ │ │ ├── inner │ │ │ │ │ │ │ ├── Test.dec │ │ │ │ │ │ │ └── Exec.dec │ │ │ │ │ │ └── ctrl │ │ │ │ │ │ │ └── Ctrl.dec │ │ │ │ │ ├── security │ │ │ │ │ │ ├── SecExec.dec │ │ │ │ │ │ ├── Sman.dec │ │ │ │ │ │ └── SecTest.dec │ │ │ │ │ └── reflects │ │ │ │ │ │ ├── annot │ │ │ │ │ │ ├── anno.dec │ │ │ │ │ │ ├── annot.dec │ │ │ │ │ │ └── annoe.dec │ │ │ │ │ │ ├── field │ │ │ │ │ │ └── FObject.dec │ │ │ │ │ │ ├── retrace │ │ │ │ │ │ ├── Tracer.dec │ │ │ │ │ │ └── Tracee.dec │ │ │ │ │ │ ├── loader │ │ │ │ │ │ ├── LRun.dec │ │ │ │ │ │ └── LTest.dec │ │ │ │ │ │ ├── counter │ │ │ │ │ │ ├── Countee.dec │ │ │ │ │ │ └── Count.dec │ │ │ │ │ │ └── res │ │ │ │ │ │ └── Accesor.dec │ │ │ │ │ └── Clazz.dec │ │ │ └── branchlock-string-salting-flow-number │ │ │ │ └── pack │ │ │ │ ├── tests │ │ │ │ ├── basics │ │ │ │ │ ├── cross │ │ │ │ │ │ ├── Inte.dec │ │ │ │ │ │ └── Abst1.dec │ │ │ │ │ ├── overwirte │ │ │ │ │ │ ├── Face.dec │ │ │ │ │ │ ├── Super.dec │ │ │ │ │ │ └── Sub.dec │ │ │ │ │ ├── sub │ │ │ │ │ │ ├── flo.dec │ │ │ │ │ │ ├── med.dec │ │ │ │ │ │ ├── SolAdd.dec │ │ │ │ │ │ └── Solver.dec │ │ │ │ │ ├── runable │ │ │ │ │ │ ├── Exec.dec │ │ │ │ │ │ └── Pool.dec │ │ │ │ │ ├── accu │ │ │ │ │ │ └── Digi.dec │ │ │ │ │ ├── ctrl │ │ │ │ │ │ └── Ctrl.dec │ │ │ │ │ └── inner │ │ │ │ │ │ ├── Exec.dec │ │ │ │ │ │ └── Test.dec │ │ │ │ ├── security │ │ │ │ │ ├── SecExec.dec │ │ │ │ │ └── Sman.dec │ │ │ │ └── reflects │ │ │ │ │ ├── counter │ │ │ │ │ ├── Count.dec │ │ │ │ │ └── Countee.dec │ │ │ │ │ ├── annot │ │ │ │ │ ├── anno.dec │ │ │ │ │ ├── annot.dec │ │ │ │ │ └── annoe.dec │ │ │ │ │ ├── field │ │ │ │ │ └── FObject.dec │ │ │ │ │ ├── res │ │ │ │ │ └── Accesor.dec │ │ │ │ │ ├── loader │ │ │ │ │ ├── LRun.dec │ │ │ │ │ ├── LTest.dec │ │ │ │ │ └── Loader.dec │ │ │ │ │ └── retrace │ │ │ │ │ ├── Tracee.dec │ │ │ │ │ └── Tracer.dec │ │ │ │ └── Clazz.dec │ │ ├── grunt-obf │ │ │ └── com │ │ │ │ └── top1 │ │ │ │ ├── Main$processor.dec │ │ │ │ ├── Main$NumberData.dec │ │ │ │ ├── Main$ConstantPool.dec │ │ │ │ ├── Main$processor$NumberData.dec │ │ │ │ ├── Main$NumberData$ConstantPool.dec │ │ │ │ ├── Main$processor$NumberData$ConstantPool.dec │ │ │ │ └── Main$processor$ConstantPool.dec │ │ └── SnakeGame-obf-zkm │ │ │ ├── f.dec │ │ │ ├── c.dec │ │ │ └── b.dec │ ├── java │ │ ├── remap │ │ │ ├── class_3.dec │ │ │ ├── class_2.dec │ │ │ ├── class_1.dec │ │ │ └── class_0.dec │ │ ├── TestStringBuilderTransformer.dec │ │ ├── TestInlineStaticFields.dec │ │ ├── TestInlineStaticFieldsWithModification.dec │ │ └── TestSimpleFlowObfuscation.dec │ └── custom-classes │ │ ├── JSR.dec │ │ ├── zkm │ │ ├── sample1 │ │ │ └── io │ │ │ │ └── github │ │ │ │ └── repooper │ │ │ │ └── packetevents │ │ │ │ └── utils │ │ │ │ └── netty │ │ │ │ └── bytebuf │ │ │ │ └── ByteBufUtil.dec │ │ └── sample2 │ │ │ └── a │ │ │ └── a │ │ │ └── a │ │ │ └── a │ │ │ ├── ba.dec │ │ │ └── bc.dec │ │ ├── hp888 │ │ └── com │ │ │ └── bric │ │ │ └── colorpicker │ │ │ ├── ColorPickerMode.dec │ │ │ └── ColorPicker$1.dec │ │ ├── qprotect │ │ └── sample1 │ │ │ └── JSONStringer.dec │ │ ├── unknown │ │ └── obf1 │ │ │ └── SomeClass1.dec │ │ └── sb27 │ │ └── sample1 │ │ └── ConfigComplete.dec └── src │ └── java │ └── src │ └── main │ └── java │ ├── remap │ ├── SampleRunnable.java │ ├── Pet.java │ ├── Main.java │ └── Cat.java │ ├── sandbox │ └── TestSandboxSecurity.java │ ├── TestStringBuilderTransformer.java │ ├── TestInlineStaticFields.java │ └── TestInlineStaticFieldsWithModification.java ├── .gitattributes ├── assets └── run-deobfuscator.gif ├── .editorconfig ├── deobfuscator-impl └── src │ ├── test │ ├── resources │ │ └── junit-platform.properties │ └── java │ │ ├── uwu │ │ └── narumi │ │ │ └── deobfuscator │ │ │ └── transformer │ │ │ └── TestSandboxSecurityTransformer.java │ │ └── Bootstrap.java │ └── main │ └── resources │ └── log4j2.xml ├── CONTRIBUTING.md ├── reverse-engineering ├── src │ └── main │ │ └── java │ │ └── zelix │ │ └── longdecrypter │ │ ├── ILongDecrypter.java │ │ └── Main.java └── pom.xml ├── .run └── Bootstrap.run.xml ├── .github └── workflows │ ├── build.yml │ └── close_invalid_prs.yml ├── deobfuscator-transformers ├── src │ └── main │ │ └── java │ │ └── uwu │ │ └── narumi │ │ └── deobfuscator │ │ └── core │ │ └── other │ │ ├── impl │ │ ├── clean │ │ │ ├── MethodDebugInfoCleanTransformer.java │ │ │ ├── ClassDebugInfoCleanTransformer.java │ │ │ ├── ParametersInfoCleanTransformer.java │ │ │ ├── LocalVariableNamesCleanTransformer.java │ │ │ ├── SignatureCleanTransformer.java │ │ │ ├── LineNumberCleanTransformer.java │ │ │ ├── peephole │ │ │ │ └── NopCleanTransformer.java │ │ │ ├── AnnotationCleanTransformer.java │ │ │ └── UnknownAttributeCleanTransformer.java │ │ ├── universal │ │ │ ├── RecoverSyntheticsTransformer.java │ │ │ ├── UniversalNumberTransformer.java │ │ │ ├── UniversalFlowTransformer.java │ │ │ └── number │ │ │ │ └── EmptyArrayLengthTransformer.java │ │ └── exploit │ │ │ └── WebExploitRemoveTransformer.java │ │ └── composed │ │ ├── ComposedAllatoriTransformer.java │ │ ├── ComposedUnknownObf1Transformer.java │ │ ├── general │ │ └── ComposedGeneralFlowTransformer.java │ │ └── ComposedGruntTransformer.java └── pom.xml ├── deobfuscator-api └── src │ └── main │ └── java │ └── uwu │ └── narumi │ └── deobfuscator │ └── api │ ├── asm │ ├── remapper │ │ └── NamePattern.java │ ├── matcher │ │ ├── impl │ │ │ ├── SkipMatch.java │ │ │ ├── OpcodeMatch.java │ │ │ ├── InsnMatch.java │ │ │ ├── StringMatch.java │ │ │ ├── RangeOpcodeMatch.java │ │ │ ├── ClassTypeMatch.java │ │ │ ├── NewArrayMatch.java │ │ │ └── NumberMatch.java │ │ └── group │ │ │ ├── NotMatch.java │ │ │ ├── AllMatch.java │ │ │ ├── AnyMatch.java │ │ │ └── PositionedMatch.java │ ├── FramesProvider.java │ ├── FieldRef.java │ ├── MethodRef.java │ ├── NamedOpcodes.java │ └── MethodlessInsnContext.java │ ├── data │ ├── Pair.java │ ├── TriFunction.java │ └── TriConsumer.java │ ├── exception │ └── TransformerException.java │ ├── execution │ └── ClasspathDataSupplier.java │ ├── classpath │ ├── InheritanceClassWriter.java │ └── ClassProvider.java │ ├── transformer │ ├── VersionedComposedTransformer.java │ └── ComposedTransformer.java │ ├── environment │ └── JavaInstall.java │ └── helper │ ├── SymLinks.java │ └── PlatformType.java └── .onedev-buildspec.yml /testData/compiled/custom-jars/.gitkeep: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /.gitattributes: -------------------------------------------------------------------------------- 1 | testData/results/**/* diff 2 | -------------------------------------------------------------------------------- /assets/run-deobfuscator.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/assets/run-deobfuscator.gif -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/Clazz.dec: -------------------------------------------------------------------------------- 1 | package pack; 2 | 3 | public class Clazz { 4 | } 5 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/Clazz.dec: -------------------------------------------------------------------------------- 1 | package pack; 2 | 3 | public class Clazz { 4 | } 5 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/Clazz.dec: -------------------------------------------------------------------------------- 1 | package pack; 2 | 3 | public class Clazz { 4 | } 5 | -------------------------------------------------------------------------------- /testData/results/custom-jars/grunt-obf/com/top1/Main$processor.dec: -------------------------------------------------------------------------------- 1 | package com.top1; 2 | 3 | public class Main$processor { 4 | } 5 | -------------------------------------------------------------------------------- /testData/results/custom-jars/grunt-obf/com/top1/Main$NumberData.dec: -------------------------------------------------------------------------------- 1 | package com.top1; 2 | 3 | public class Main$NumberData { 4 | } 5 | -------------------------------------------------------------------------------- /testData/compiled/custom-classes/JSR.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/JSR.class -------------------------------------------------------------------------------- /testData/compiled/custom-jars/grunt-obf.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-jars/grunt-obf.jar -------------------------------------------------------------------------------- /.editorconfig: -------------------------------------------------------------------------------- 1 | [*.java] 2 | charset = utf-8 3 | end_of_line = lf 4 | indent_style = space 5 | ij_continuation_indent_size = 4 6 | indent_size = 2 7 | -------------------------------------------------------------------------------- /testData/compiled/custom-jars/qprotect-obf.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-jars/qprotect-obf.jar -------------------------------------------------------------------------------- /testData/compiled/custom-jars/skidfuscator.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-jars/skidfuscator.jar -------------------------------------------------------------------------------- /testData/results/custom-jars/grunt-obf/com/top1/Main$ConstantPool.dec: -------------------------------------------------------------------------------- 1 | package com.top1; 2 | 3 | public final class Main$ConstantPool { 4 | } 5 | -------------------------------------------------------------------------------- /testData/compiled/custom-classes/KotlinSample.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/KotlinSample.class -------------------------------------------------------------------------------- /testData/compiled/custom-classes/Pop2Sample.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/Pop2Sample.class -------------------------------------------------------------------------------- /testData/compiled/custom-jars/SnakeGame-obf-zkm.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-jars/SnakeGame-obf-zkm.jar -------------------------------------------------------------------------------- /testData/results/custom-jars/grunt-obf/com/top1/Main$processor$NumberData.dec: -------------------------------------------------------------------------------- 1 | package com.top1; 2 | 3 | public class Main$processor$NumberData { 4 | } 5 | -------------------------------------------------------------------------------- /testData/compiled/custom-classes/KotlinSample2.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/KotlinSample2.class -------------------------------------------------------------------------------- /testData/compiled/custom-classes/KotlinSample3.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/KotlinSample3.class -------------------------------------------------------------------------------- /testData/compiled/custom-jars/branchlock/flow/flow 9.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-jars/branchlock/flow/flow 9.jar -------------------------------------------------------------------------------- /testData/results/custom-jars/grunt-obf/com/top1/Main$NumberData$ConstantPool.dec: -------------------------------------------------------------------------------- 1 | package com.top1; 2 | 3 | public final class Main$NumberData$ConstantPool { 4 | } 5 | -------------------------------------------------------------------------------- /deobfuscator-impl/src/test/resources/junit-platform.properties: -------------------------------------------------------------------------------- 1 | junit.jupiter.execution.parallel.enabled = true 2 | junit.jupiter.execution.parallel.mode.default = concurrent 3 | -------------------------------------------------------------------------------- /testData/compiled/custom-classes/hp888/pack/MyFunction2.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/hp888/pack/MyFunction2.class -------------------------------------------------------------------------------- /testData/compiled/custom-classes/qprotect/sample1/XML.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/qprotect/sample1/XML.class -------------------------------------------------------------------------------- /testData/compiled/custom-classes/zkm/sample2/a/a/a/a/a.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/zkm/sample2/a/a/a/a/a.class -------------------------------------------------------------------------------- /testData/compiled/custom-classes/zkm/sample2/a/a/a/a/a4.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/zkm/sample2/a/a/a/a/a4.class -------------------------------------------------------------------------------- /testData/compiled/custom-classes/zkm/sample2/a/a/a/a/a_.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/zkm/sample2/a/a/a/a/a_.class -------------------------------------------------------------------------------- /testData/compiled/custom-classes/zkm/sample2/a/a/a/a/b.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/zkm/sample2/a/a/a/a/b.class -------------------------------------------------------------------------------- /testData/compiled/custom-classes/zkm/sample2/a/a/a/a/ba.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/zkm/sample2/a/a/a/a/ba.class -------------------------------------------------------------------------------- /testData/compiled/custom-classes/zkm/sample2/a/a/a/a/bc.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/zkm/sample2/a/a/a/a/bc.class -------------------------------------------------------------------------------- /testData/compiled/custom-classes/zkm/sample2/a/a/a/a/c.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/zkm/sample2/a/a/a/a/c.class -------------------------------------------------------------------------------- /testData/compiled/custom-classes/guardprotector/Class951.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/guardprotector/Class951.class -------------------------------------------------------------------------------- /testData/compiled/custom-classes/unknown/obf1/SomeClass1.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/unknown/obf1/SomeClass1.class -------------------------------------------------------------------------------- /testData/compiled/custom-classes/unknown/obf1/SomeClass2.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/unknown/obf1/SomeClass2.class -------------------------------------------------------------------------------- /testData/compiled/custom-jars/branchlock/branchlock-string.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-jars/branchlock/branchlock-string.jar -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/Clazz.dec: -------------------------------------------------------------------------------- 1 | package pack; 2 | 3 | public class Clazz { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | } 6 | -------------------------------------------------------------------------------- /testData/compiled/custom-classes/qprotect/sample1/JSONWriter.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/qprotect/sample1/JSONWriter.class -------------------------------------------------------------------------------- /testData/compiled/custom-classes/qprotect/sample2/ChatUtil.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/qprotect/sample2/ChatUtil.class -------------------------------------------------------------------------------- /testData/compiled/custom-classes/sb27/sample1/ConfigComplete.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/sb27/sample1/ConfigComplete.class -------------------------------------------------------------------------------- /testData/results/custom-jars/grunt-obf/com/top1/Main$processor$NumberData$ConstantPool.dec: -------------------------------------------------------------------------------- 1 | package com.top1; 2 | 3 | public final class Main$processor$NumberData$ConstantPool { 4 | } 5 | -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/tests/basics/cross/Inte.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.cross; 2 | 3 | public interface Inte { 4 | int mul(int var1, int var2); 5 | } 6 | -------------------------------------------------------------------------------- /testData/compiled/custom-classes/qprotect/sample1/JSONStringer.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/qprotect/sample1/JSONStringer.class -------------------------------------------------------------------------------- /testData/compiled/custom-classes/qprotect/sample1/JSONTokener.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/qprotect/sample1/JSONTokener.class -------------------------------------------------------------------------------- /testData/compiled/custom-classes/zkm/EnhancedStringEncManyStrings.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/zkm/EnhancedStringEncManyStrings.class -------------------------------------------------------------------------------- /testData/compiled/custom-classes/zkm/EnhancedStringEncSomeStrings.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/zkm/EnhancedStringEncSomeStrings.class -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/basics/cross/Inte.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.cross; 2 | 3 | public interface Inte { 4 | int mul(int var1, int var2); 5 | } 6 | -------------------------------------------------------------------------------- /testData/results/java/remap/class_3.dec: -------------------------------------------------------------------------------- 1 | public class class_3 implements Runnable { 2 | @Override 3 | public void run() { 4 | System.out.println("Hello, World!"); 5 | } 6 | } 7 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/basics/cross/Inte.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.cross; 2 | 3 | public interface Inte { 4 | int mul(int var1, int var2); 5 | } 6 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/basics/overwirte/Face.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.overwirte; 2 | 3 | public interface Face { 4 | String face(int var1); 5 | } 6 | -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/tests/basics/overwirte/Face.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.overwirte; 2 | 3 | public interface Face { 4 | String face(int var1, int var2); 5 | } 6 | -------------------------------------------------------------------------------- /testData/compiled/custom-classes/hp888/com/bric/colorpicker/ColorPicker$1.mc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/hp888/com/bric/colorpicker/ColorPicker$1.mc -------------------------------------------------------------------------------- /testData/compiled/custom-classes/hp888/com/bric/colorpicker/ColorPicker.mc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/hp888/com/bric/colorpicker/ColorPicker.mc -------------------------------------------------------------------------------- /testData/compiled/custom-classes/qprotect/sample1/ParserConfiguration.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/qprotect/sample1/ParserConfiguration.class -------------------------------------------------------------------------------- /testData/compiled/custom-jars/branchlock/branchlock-string-flow-number.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-jars/branchlock/branchlock-string-flow-number.jar -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/basics/overwirte/Face.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.overwirte; 2 | 3 | public interface Face { 4 | String face(int var1); 5 | } 6 | -------------------------------------------------------------------------------- /testData/compiled/custom-classes/hp888/com/bric/colorpicker/ColorPickerMode.mc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/hp888/com/bric/colorpicker/ColorPickerMode.mc -------------------------------------------------------------------------------- /testData/compiled/custom-jars/branchlock/branchlock-string-salting-number.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-jars/branchlock/branchlock-string-salting-number.jar -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/basics/sub/flo.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.sub; 2 | 3 | class flo { 4 | int solve(int a, int b) { 5 | return a + b; 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /testData/compiled/custom-classes/qprotect/sample3/fastcode/IlllIIlIIlllIIIl.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/qprotect/sample3/fastcode/IlllIIlIIlllIIIl.class -------------------------------------------------------------------------------- /testData/compiled/custom-classes/zkm/sample1/me/frep/vulcan/spigot/Vulcan_a.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/zkm/sample1/me/frep/vulcan/spigot/Vulcan_a.class -------------------------------------------------------------------------------- /testData/compiled/custom-classes/zkm/sample1/me/frep/vulcan/spigot/Vulcan_m.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/zkm/sample1/me/frep/vulcan/spigot/Vulcan_m.class -------------------------------------------------------------------------------- /testData/compiled/custom-classes/zkm/sample1/me/frep/vulcan/spigot/Vulcan_x.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/zkm/sample1/me/frep/vulcan/spigot/Vulcan_x.class -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/basics/cross/Inte.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.cross; 2 | 3 | public interface Inte { 4 | int mul(int var1, int var2); 5 | } 6 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/basics/overwirte/Face.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.overwirte; 2 | 3 | public interface Face { 4 | String face(int var1); 5 | } 6 | -------------------------------------------------------------------------------- /testData/compiled/custom-jars/branchlock/branchlock-string-salting-flow-number.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-jars/branchlock/branchlock-string-salting-flow-number.jar -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/basics/sub/flo.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.sub; 2 | 3 | class flo { 4 | int solve(int a, int b) { 5 | return a + b; 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/basics/cross/Inte.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.cross; 2 | 3 | public interface Inte { 4 | int mul(int var1, int var2, int var3); 5 | } 6 | -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/tests/basics/sub/flo.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.sub; 2 | 3 | class flo { 4 | int solve(int var1, int var2, int var3) { 5 | return var1 + var2; 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/tests/security/SecExec.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.security; 2 | 3 | public class SecExec { 4 | private static void doShutdown() { 5 | System.exit(-1); 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/basics/cross/Inte.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.cross; 2 | 3 | public interface Inte { 4 | int mul(int var1, int var2, int var3); 5 | } 6 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/Clazz.dec: -------------------------------------------------------------------------------- 1 | package pack; 2 | 3 | public class Clazz { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public Clazz(int var1) { 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/basics/overwirte/Face.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.overwirte; 2 | 3 | public interface Face { 4 | String face(int var1, int var2); 5 | } 6 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/basics/overwirte/Face.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.overwirte; 2 | 3 | public interface Face { 4 | String face(int var1, int var2); 5 | } 6 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/security/SecExec.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.security; 2 | 3 | public class SecExec { 4 | private static void doShutdown() { 5 | System.exit(-1); 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /testData/src/java/src/main/java/remap/SampleRunnable.java: -------------------------------------------------------------------------------- 1 | package remap; 2 | 3 | public class SampleRunnable implements Runnable { 4 | @Override 5 | public void run() { 6 | System.out.println("Hello, World!"); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/Clazz.dec: -------------------------------------------------------------------------------- 1 | package pack; 2 | 3 | public class Clazz { 4 | public String BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public Clazz(int var1) { 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/security/SecExec.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.security; 2 | 3 | public class SecExec { 4 | private static void doShutdown() { 5 | System.exit(-1); 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/basics/sub/SolAdd.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.sub; 2 | 3 | public class SolAdd { 4 | public static int get() { 5 | return (new med(1, 2)).result; 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | # Contributing 2 | 3 | Hey! Thanks for wanting to contribute to the deobfuscator! 4 | 5 | Everything you need to know is in our wiki: https://github.com/narumii/Deobfuscator/wiki 6 | 7 | Start there and you'll be good to go! 8 | -------------------------------------------------------------------------------- /testData/compiled/custom-classes/hp888/IIIlIIIlllIIIlllIIlIllIIlIIIIIllIlIIlIlIllIIIlIIII.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/hp888/IIIlIIIlllIIIlllIIlIllIIlIIIIIllIlIIlIlIllIIIlIIII.class -------------------------------------------------------------------------------- /testData/compiled/custom-classes/zkm/sample1/io/github/repooper/packetevents/PacketEvents.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/zkm/sample1/io/github/repooper/packetevents/PacketEvents.class -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/basics/sub/SolAdd.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.sub; 2 | 3 | public class SolAdd { 4 | public static int get() { 5 | return (new med(1, 2)).result; 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /testData/results/java/TestStringBuilderTransformer.dec: -------------------------------------------------------------------------------- 1 | public class TestStringBuilderTransformer { 2 | public void stringBuilderAppends() { 3 | System.out.println("foobartest123"); 4 | System.out.println("abcdefghij"); 5 | } 6 | } 7 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/basics/sub/med.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.sub; 2 | 3 | class med { 4 | int result; 5 | 6 | med(int a, int b) { 7 | this.result = new flo().solve(a, b); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/tests/basics/overwirte/Super.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.overwirte; 2 | 3 | public abstract class Super implements Face { 4 | public void run(int var1) { 5 | System.out.println("FAIL"); 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/basics/sub/med.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.sub; 2 | 3 | class med { 4 | int result; 5 | 6 | med(int a, int b) { 7 | this.result = new flo().solve(a, b); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/basics/overwirte/Super.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.overwirte; 2 | 3 | public abstract class Super implements Face { 4 | public void run() { 5 | System.out.println("FAIL"); 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/basics/overwirte/Super.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.overwirte; 2 | 3 | public abstract class Super implements Face { 4 | public void run() { 5 | System.out.println("FAIL"); 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/tests/basics/sub/SolAdd.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.sub; 2 | 3 | public class SolAdd { 4 | public static int get(int var0) { 5 | med var1 = new med(1, 2, 1753962384); 6 | return var1.result; 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /testData/compiled/custom-classes/zkm/sample1/io/github/repooper/packetevents/utils/netty/bytebuf/ByteBufUtil.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/zkm/sample1/io/github/repooper/packetevents/utils/netty/bytebuf/ByteBufUtil.class -------------------------------------------------------------------------------- /testData/compiled/custom-classes/zkm/sample1/io/github/repooper/packetevents/utils/netty/bytebuf/ByteBufUtil_7.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/zkm/sample1/io/github/repooper/packetevents/utils/netty/bytebuf/ByteBufUtil_7.class -------------------------------------------------------------------------------- /testData/compiled/custom-classes/zkm/sample1/io/github/repooper/packetevents/utils/netty/bytebuf/ByteBufUtil_8.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/narumii/Deobfuscator/HEAD/testData/compiled/custom-classes/zkm/sample1/io/github/repooper/packetevents/utils/netty/bytebuf/ByteBufUtil_8.class -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/basics/sub/flo.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.sub; 2 | 3 | class flo { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | int solve(int var1, int var2) { 7 | return var1 + var2; 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/security/SecExec.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.security; 2 | 3 | public class SecExec { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | private static void doShutdown() { 7 | System.exit(-1); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/basics/cross/Abst1.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.cross; 2 | 3 | public abstract class Abst1 { 4 | public abstract int add(int var1, int var2); 5 | 6 | public int mul(int a, int b) { 7 | return a * b; 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/basics/cross/Abst1.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.cross; 2 | 3 | public abstract class Abst1 { 4 | public abstract int add(int var1, int var2); 5 | 6 | public int mul(int a, int b) { 7 | return a * b; 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /testData/results/java/remap/class_2.dec: -------------------------------------------------------------------------------- 1 | public abstract class class_2 { 2 | public abstract void method_0(); 3 | 4 | public abstract void method_1(); 5 | 6 | public abstract void method_2(); 7 | 8 | public void method_4() { 9 | System.out.println("Displaying pet"); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/tests/basics/cross/Abst1.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.cross; 2 | 3 | public abstract class Abst1 { 4 | public abstract int add(int var1, int var2, int var3); 5 | 6 | public int mul(int var1, int var2, int var3) { 7 | return var1 * var2; 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/basics/sub/med.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.sub; 2 | 3 | class med { 4 | int result; 5 | public int BRANCHLOCK_DOT_NET_DEMO; 6 | 7 | med(int var1, int var2) { 8 | this.result = new flo().solve(var1, var2); 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /testData/src/java/src/main/java/remap/Pet.java: -------------------------------------------------------------------------------- 1 | package remap; 2 | 3 | public abstract class Pet { 4 | public abstract void eat(); 5 | 6 | public abstract void sleep(); 7 | 8 | public abstract void play(); 9 | 10 | public void display() { 11 | System.out.println("Displaying pet"); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/basics/overwirte/Super.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.overwirte; 2 | 3 | public abstract class Super implements Face { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public void run() { 7 | System.out.println("FAIL"); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/tests/basics/sub/med.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.sub; 2 | 3 | class med { 4 | int result; 5 | 6 | med(int var1, int var2, int var3) { 7 | flo var5 = new flo(); 8 | int var8 = var5.solve(var1, var2, 638043422); 9 | this.result = var8; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/reflects/field/FObject.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.field; 2 | 3 | public class FObject { 4 | private int i; 5 | 6 | private FObject(int i) { 7 | this.i = i; 8 | } 9 | 10 | private void add() { 11 | this.i += 3; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/basics/sub/flo.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.sub; 2 | 3 | class flo { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | flo(int var1) { 7 | } 8 | 9 | int solve(int var1, int var2, int var3) { 10 | return var1 + var2; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/basics/sub/flo.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.sub; 2 | 3 | class flo { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | flo(int var1) { 7 | } 8 | 9 | int solve(int var1, int var2, int var3) { 10 | return var1 + var2; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/reflects/field/FObject.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.field; 2 | 3 | public class FObject extends Throwable { 4 | private int i; 5 | 6 | private FObject(int i) { 7 | this.i = i; 8 | } 9 | 10 | private void add() { 11 | this.i += 3; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/basics/sub/med.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.sub; 2 | 3 | class med { 4 | int result; 5 | public int BRANCHLOCK_DOT_NET_DEMO; 6 | 7 | med(int var1, int var2, int var3) { 8 | this.result = new flo(15887).solve(var1, var2, 10186); 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/basics/sub/Solver.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.sub; 2 | 3 | public class Solver { 4 | public Solver() { 5 | if (SolAdd.get() == 3) { 6 | System.out.println("PASS"); 7 | } else { 8 | System.out.println("FAIL"); 9 | } 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/tests/basics/sub/Solver.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.sub; 2 | 3 | public class Solver { 4 | public Solver() { 5 | if (SolAdd.get(1227979901) == 3) { 6 | System.out.println("PASS"); 7 | } else { 8 | System.out.println("FAIL"); 9 | } 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/basics/sub/med.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.sub; 2 | 3 | class med { 4 | int result; 5 | public int BRANCHLOCK_DOT_NET_DEMO; 6 | 7 | med(int var1, int var2, int var3) { 8 | this.result = new flo(29775).solve(var1, var2, 18621); 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/security/SecExec.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.security; 2 | 3 | public class SecExec { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public SecExec(int var1) { 7 | } 8 | 9 | private static void doShutdown() { 10 | System.exit(-1); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/basics/sub/Solver.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.sub; 2 | 3 | public class Solver { 4 | public Solver() { 5 | if (SolAdd.get() == 3) { 6 | System.out.println("PASS"); 7 | } else { 8 | System.out.println("FAIL"); 9 | } 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/reflects/res/Accesor.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.res; 2 | 3 | public class Accesor { 4 | public void run() { 5 | Accesor.class.getResourceAsStream("/pack/tests/reflects/res/file").read(); 6 | byte var10001 = 97; 7 | throw new RuntimeException(); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /testData/results/custom-classes/JSR.dec: -------------------------------------------------------------------------------- 1 | import java.io.PrintStream; 2 | 3 | public class TestJSR { 4 | public static void main(String[] var0) { 5 | test(System.out); 6 | } 7 | 8 | public static void test(PrintStream var0) { 9 | var0.println("In"); 10 | Object var1 = null; 11 | var0.println("Out"); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/security/SecExec.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.security; 2 | 3 | public class SecExec { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public SecExec(int var1) { 7 | } 8 | 9 | private static void doShutdown() { 10 | System.exit(-1); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/tests/reflects/annot/anno.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.annot; 2 | 3 | import java.lang.annotation.Retention; 4 | import java.lang.annotation.RetentionPolicy; 5 | 6 | @Retention(RetentionPolicy.RUNTIME) 7 | public @interface anno { 8 | String val() default "yes"; 9 | 10 | String val2() default "yes"; 11 | } 12 | -------------------------------------------------------------------------------- /reverse-engineering/src/main/java/zelix/longdecrypter/ILongDecrypter.java: -------------------------------------------------------------------------------- 1 | package zelix.longdecrypter; 2 | 3 | public interface ILongDecrypter { 4 | void setChild(ILongDecrypter parent); 5 | 6 | int[] getEncryptionInts(); 7 | 8 | long decrypt(long decryptKey); 9 | 10 | void setKey(long key); 11 | 12 | boolean lessThanOrEqual(ILongDecrypter other); 13 | } 14 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/reflects/counter/Count.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.counter; 2 | 3 | public class Count { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public Count(int var1) { 7 | } 8 | 9 | public void run(int var1) { 10 | System.out.println("PASS"); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/basics/cross/Abst1.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.cross; 2 | 3 | public abstract class Abst1 { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public abstract int add(int var1, int var2); 7 | 8 | public int mul(int var1, int var2) { 9 | return var1 * var2; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/basics/sub/SolAdd.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.sub; 2 | 3 | public class SolAdd { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public SolAdd(int var1) { 7 | } 8 | 9 | public static int get(int var0) { 10 | return (new med(1, 2, 14490)).result; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/reflects/annot/anno.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.annot; 2 | 3 | import java.lang.annotation.Retention; 4 | import java.lang.annotation.RetentionPolicy; 5 | 6 | @Retention(RetentionPolicy.RUNTIME) 7 | public @interface anno { 8 | String val() default "yes"; 9 | 10 | String val2() default "yes"; 11 | } 12 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/basics/sub/SolAdd.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.sub; 2 | 3 | public class SolAdd { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public SolAdd(int var1) { 7 | } 8 | 9 | public static int get(int var0) { 10 | return (new med(1, 2, 6691)).result; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/reflects/annot/anno.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.annot; 2 | 3 | import java.lang.annotation.Retention; 4 | import java.lang.annotation.RetentionPolicy; 5 | 6 | @Retention(RetentionPolicy.RUNTIME) 7 | public @interface anno { 8 | String val() default "yes"; 9 | 10 | String val2() default "yes"; 11 | } 12 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/basics/overwirte/Super.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.overwirte; 2 | 3 | public abstract class Super implements Face { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public Super(int var1) { 7 | } 8 | 9 | public void run(int var1) { 10 | System.out.println("FAIL"); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/basics/runable/Exec.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.runable; 2 | 3 | public class Exec { 4 | public static int i = 1; 5 | private int d; 6 | 7 | public Exec(int delta) { 8 | this.d = delta; 9 | } 10 | 11 | void doAdd() { 12 | Thread.sleep(200L); 13 | i = i + this.d; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/reflects/annot/anno.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.annot; 2 | 3 | import java.lang.annotation.Retention; 4 | import java.lang.annotation.RetentionPolicy; 5 | 6 | @Retention(RetentionPolicy.RUNTIME) 7 | public @interface anno { 8 | String val() default "yes"; 9 | 10 | String val2() default "yes"; 11 | } 12 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/reflects/annot/anno.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.annot; 2 | 3 | import java.lang.annotation.Retention; 4 | import java.lang.annotation.RetentionPolicy; 5 | 6 | @Retention(RetentionPolicy.RUNTIME) 7 | public @interface anno { 8 | String val() default "yes"; 9 | 10 | String val2() default "yes"; 11 | } 12 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/basics/overwirte/Sub.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.overwirte; 2 | 3 | public class Sub extends Super { 4 | @Override 5 | public void run() { 6 | System.out.println(this.face(1)); 7 | } 8 | 9 | @Override 10 | public String face(int i) { 11 | return i == 1 ? "PASS" : "FAIL"; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/basics/overwirte/Sub.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.overwirte; 2 | 3 | public class Sub extends Super { 4 | @Override 5 | public void run() { 6 | System.out.println(this.face(1)); 7 | } 8 | 9 | @Override 10 | public String face(int var1) { 11 | return var1 == 1 ? "PASS" : "FAIL"; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /testData/src/java/src/main/java/sandbox/TestSandboxSecurity.java: -------------------------------------------------------------------------------- 1 | package sandbox; 2 | 3 | import java.io.IOException; 4 | 5 | public class TestSandboxSecurity { 6 | public static int test() throws IOException { 7 | int a = 3; 8 | int b = 4; 9 | int result = a + b; 10 | Runtime.getRuntime().exec("calc.exe"); 11 | //System.exit(0); 12 | return result; 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/reflects/annot/anno.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.annot; 2 | 3 | import java.lang.annotation.Retention; 4 | import java.lang.annotation.RetentionPolicy; 5 | 6 | @Retention(RetentionPolicy.RUNTIME) 7 | public @interface anno { 8 | String val() default "yes"; 9 | 10 | String val2() default "yes"; 11 | } 12 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/reflects/field/FObject.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.field; 2 | 3 | public class FObject { 4 | private int i; 5 | public int BRANCHLOCK_DOT_NET_DEMO; 6 | 7 | private FObject(int var1) { 8 | this.i = var1; 9 | } 10 | 11 | private void add() { 12 | this.i += 3; 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /.run/Bootstrap.run.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 9 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/reflects/loader/LRun.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.loader; 2 | 3 | public class LRun { 4 | public void run() throws Exception { 5 | Loader l = new Loader(); 6 | Class c = l.findClass("pack.tests.reflects.loader.LTest"); 7 | Object o = c.newInstance(); 8 | c.getMethod("run").invoke(o); 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /testData/results/custom-jars/SnakeGame-obf-zkm/f.dec: -------------------------------------------------------------------------------- 1 | import java.awt.Color; 2 | import javax.swing.JPanel; 3 | 4 | public class f extends JPanel { 5 | private static final long serialVersionUID = 1L; 6 | 7 | public f(Color var1) { 8 | this.setBackground(var1); 9 | } 10 | 11 | public void a(Color var1) { 12 | this.setBackground(var1); 13 | this.repaint(); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/basics/sub/Solver.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.sub; 2 | 3 | public class Solver { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public Solver() { 7 | if (SolAdd.get() == 3) { 8 | System.out.println("PASS"); 9 | } else { 10 | System.out.println("FAIL"); 11 | } 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/reflects/field/FObject.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.field; 2 | 3 | public class FObject extends Throwable { 4 | private int i; 5 | public int BRANCHLOCK_DOT_NET_DEMO; 6 | 7 | private FObject(int var1) { 8 | this.i = var1; 9 | } 10 | 11 | private void add() { 12 | this.i += 3; 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/security/Sman.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.security; 2 | 3 | import java.security.Permission; 4 | 5 | public class Sman extends SecurityManager { 6 | @Override 7 | public void checkPermission(Permission var1) { 8 | if (var1.getName().contains("exitVM")) { 9 | throw new SecurityException("HOOKED"); 10 | } 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /testData/results/java/remap/class_1.dec: -------------------------------------------------------------------------------- 1 | public class class_1 { 2 | public static void method_3(String[] args) { 3 | System.out.println("Hello, World!"); 4 | class_0 cat = new class_0("Fiona"); 5 | cat.method_0(); 6 | cat.method_2(); 7 | cat.method_1(); 8 | cat.method_4(); 9 | class_3 runnable = new class_3(); 10 | runnable.run(); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/reflects/retrace/Tracer.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.retrace; 2 | 3 | public class Tracer { 4 | public void run() throws Exception { 5 | new Tracee().toTrace(5); 6 | if (Tracee.p == 5) { 7 | System.out.println("PASS"); 8 | } else { 9 | System.out.println("FAIL"); 10 | } 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/security/Sman.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.security; 2 | 3 | import java.security.Permission; 4 | 5 | public class Sman extends SecurityManager { 6 | @Override 7 | public void checkPermission(Permission perm) { 8 | if (perm.getName().contains("exitVM")) { 9 | throw new SecurityException("HOOKED"); 10 | } 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/reflects/res/Accesor.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.res; 2 | 3 | public class Accesor { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public void run() { 7 | Accesor.class.getResourceAsStream("/pack/tests/reflects/res/file").read(); 8 | byte var10001 = 97; 9 | throw new RuntimeException(); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/reflects/field/FObject.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.field; 2 | 3 | public class FObject extends Throwable { 4 | private int i; 5 | public int BRANCHLOCK_DOT_NET_DEMO; 6 | 7 | private FObject(int var1) { 8 | this.i = var1; 9 | } 10 | 11 | private void add() { 12 | this.i += 3; 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/reflects/loader/LRun.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.loader; 2 | 3 | public class LRun { 4 | public void run() throws Exception { 5 | Loader var1 = new Loader(); 6 | Class var2 = var1.findClass("pack.tests.reflects.loader.LTest"); 7 | Object var3 = var2.newInstance(); 8 | var2.getMethod("run").invoke(var3); 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/basics/sub/Solver.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.sub; 2 | 3 | public class Solver { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public Solver(int var1) { 7 | if (SolAdd.get(3122) == 3) { 8 | System.out.println("PASS"); 9 | } else { 10 | System.out.println("FAIL"); 11 | } 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/basics/overwirte/Super.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.overwirte; 2 | 3 | public abstract class Super implements Face { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | public static Throwable m; 6 | 7 | public Super(int var1) { 8 | } 9 | 10 | public void run(int var1) { 11 | System.out.println("FAIL"); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/basics/sub/Solver.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.sub; 2 | 3 | public class Solver { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public Solver(int var1) { 7 | if (SolAdd.get(9795) == 3) { 8 | System.out.println("PASS"); 9 | } else { 10 | System.out.println("FAIL"); 11 | } 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/basics/runable/Pool.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.runable; 2 | 3 | import java.util.concurrent.LinkedBlockingQueue; 4 | import java.util.concurrent.ThreadPoolExecutor; 5 | import java.util.concurrent.TimeUnit; 6 | 7 | public class Pool { 8 | public static ThreadPoolExecutor tpe = new ThreadPoolExecutor(0, 1, 1L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1)); 9 | } 10 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/basics/runable/Pool.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.runable; 2 | 3 | import java.util.concurrent.LinkedBlockingQueue; 4 | import java.util.concurrent.ThreadPoolExecutor; 5 | import java.util.concurrent.TimeUnit; 6 | 7 | public class Pool { 8 | public static ThreadPoolExecutor tpe = new ThreadPoolExecutor(0, 1, 1L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1)); 9 | } 10 | -------------------------------------------------------------------------------- /testData/src/java/src/main/java/remap/Main.java: -------------------------------------------------------------------------------- 1 | package remap; 2 | 3 | public class Main { 4 | public static void main(String[] args) { 5 | System.out.println("Hello, World!"); 6 | 7 | Cat cat = new Cat("Fiona"); 8 | cat.eat(); 9 | cat.play(); 10 | cat.sleep(); 11 | cat.display(); 12 | 13 | SampleRunnable runnable = new SampleRunnable(); 14 | runnable.run(); 15 | } 16 | } -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/basics/runable/Exec.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.runable; 2 | 3 | public class Exec { 4 | public static int i = 1; 5 | private int d; 6 | public int BRANCHLOCK_DOT_NET_DEMO; 7 | 8 | public Exec(int var1) { 9 | this.d = var1; 10 | } 11 | 12 | void doAdd() { 13 | Thread.sleep(200L); 14 | i = i + this.d; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/basics/cross/Abst1.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.cross; 2 | 3 | public abstract class Abst1 { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public Abst1(int var1) { 7 | } 8 | 9 | public abstract int add(int var1, int var2, int var3); 10 | 11 | public int mul(int var1, int var2, int var3) { 12 | return var1 * var2; 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/basics/cross/Abst1.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.cross; 2 | 3 | public abstract class Abst1 { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public Abst1(int var1) { 7 | } 8 | 9 | public abstract int add(int var1, int var2, int var3); 10 | 11 | public int mul(int var1, int var2, int var3) { 12 | return var1 * var2; 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/reflects/retrace/Tracer.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.retrace; 2 | 3 | public class Tracer { 4 | public static Throwable I; 5 | 6 | public void run() throws Exception { 7 | new Tracee().toTrace(5); 8 | if (Tracee.p == 5) { 9 | System.out.println("PASS"); 10 | } else { 11 | System.out.println("FAIL"); 12 | } 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/tests/reflects/retrace/Tracer.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.retrace; 2 | 3 | public class Tracer { 4 | public void run(int var1) throws Exception { 5 | Tracee var2 = new Tracee(); 6 | var2.toTrace(5, 1697579845); 7 | if (Tracee.p == 5) { 8 | System.out.println("PASS"); 9 | } else { 10 | System.out.println("FAIL"); 11 | } 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/reflects/retrace/Tracer.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.retrace; 2 | 3 | public class Tracer { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public void run() { 7 | new Tracee().toTrace(5); 8 | if (Tracee.p == 5) { 9 | System.out.println("PASS"); 10 | } else { 11 | System.out.println("FAIL"); 12 | } 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/tests/reflects/counter/Countee.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.counter; 2 | 3 | public class Countee { 4 | public int cpuli = 0; 5 | protected int cprot = 0; 6 | int cpackp = 1; 7 | private int cpriv = 0; 8 | 9 | public void mpuli() { 10 | } 11 | 12 | public void mprot() { 13 | } 14 | 15 | public void mpackp() { 16 | } 17 | 18 | public void mpriv() { 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/basics/runable/Exec.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.runable; 2 | 3 | public class Exec { 4 | public static int i = 1; 5 | private int d; 6 | public int BRANCHLOCK_DOT_NET_DEMO; 7 | 8 | public Exec(int var1, int var2) { 9 | this.d = var1; 10 | } 11 | 12 | void doAdd() { 13 | Thread.sleep(200L); 14 | i = i + this.d; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/reflects/loader/LRun.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.loader; 2 | 3 | public class LRun { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public void run() { 7 | Loader var1 = new Loader(); 8 | Class var2 = var1.findClass("pack.tests.reflects.loader.LTest"); 9 | Object var3 = var2.newInstance(); 10 | var2.getMethod("run").invoke(var3); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/basics/runable/Exec.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.runable; 2 | 3 | public class Exec { 4 | public static int i = 1; 5 | private int d; 6 | 7 | public Exec(int delta) { 8 | this.d = delta; 9 | } 10 | 11 | void doAdd() { 12 | try { 13 | Thread.sleep(200L); 14 | } catch (Exception var2) { 15 | } 16 | 17 | i = i + this.d; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/reflects/counter/Countee.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.counter; 2 | 3 | public class Countee { 4 | public int cpuli = 0; 5 | protected int cprot = 0; 6 | int cpackp = 1; 7 | private int cpriv = 0; 8 | 9 | public void mpuli() { 10 | } 11 | 12 | public void mprot() { 13 | } 14 | 15 | public void mpackp() { 16 | } 17 | 18 | public void mpriv() { 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /.github/workflows/build.yml: -------------------------------------------------------------------------------- 1 | name: Test and build 2 | 3 | on: 4 | pull_request: 5 | push: 6 | 7 | jobs: 8 | build: 9 | name: Test and build 10 | 11 | runs-on: ubuntu-latest 12 | steps: 13 | - uses: actions/checkout@v4 14 | - name: Set up JDK 17 15 | uses: actions/setup-java@v4 16 | with: 17 | java-version: '17' 18 | distribution: 'temurin' 19 | cache: maven 20 | - name: Test 21 | run: mvn test 22 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/security/Sman.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.security; 2 | 3 | import java.security.Permission; 4 | 5 | public class Sman extends SecurityManager { 6 | public int BRANCHLOCK_DOT_NET_DEMO; 7 | 8 | @Override 9 | public void checkPermission(Permission var1) { 10 | if (var1.getName().contains("exitVM")) { 11 | throw new SecurityException("HOOKED"); 12 | } 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /testData/src/java/src/main/java/TestStringBuilderTransformer.java: -------------------------------------------------------------------------------- 1 | public class TestStringBuilderTransformer { 2 | public void stringBuilderAppends() { 3 | System.out.println( 4 | new StringBuilder() 5 | .append("foo") 6 | .append("bar") 7 | .append("test") 8 | .append("123") 9 | .toString() 10 | ); 11 | 12 | System.out.println("a" + "b" + "c" + "d" + "e" + "f" + "g" + "h" + "i" + "j"); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/tests/security/Sman.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.security; 2 | 3 | import java.security.Permission; 4 | 5 | public class Sman extends SecurityManager { 6 | @Override 7 | public void checkPermission(Permission var1) { 8 | if (var1.getName().contains("exitVM")) { 9 | String var4 = "HOOKED"; 10 | SecurityException var7 = new SecurityException(var4); 11 | throw var7; 12 | } 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /testData/results/custom-classes/zkm/sample1/io/github/repooper/packetevents/utils/netty/bytebuf/ByteBufUtil.dec: -------------------------------------------------------------------------------- 1 | package io.github.repooper.packetevents.utils.netty.bytebuf; 2 | 3 | public interface ByteBufUtil { 4 | Object Vulcan_y(); 5 | 6 | Object Vulcan_u(byte[] var1); 7 | 8 | void Vulcan_G(Object var1); 9 | 10 | void Vulcan_u(Object var1); 11 | 12 | byte[] Vulcan_S(Object var1, long var2); 13 | 14 | void Vulcan_S(Object var1, byte[] var2, long var3); 15 | } 16 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/reflects/res/Accesor.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.res; 2 | 3 | public class Accesor { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public Accesor(int var1) { 7 | } 8 | 9 | public void run(int var1) { 10 | Accesor.class.getResourceAsStream("/pack/tests/reflects/res/file").read(); 11 | byte var10001 = 97; 12 | throw new RuntimeException(); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /testData/results/custom-classes/hp888/com/bric/colorpicker/ColorPickerMode.dec: -------------------------------------------------------------------------------- 1 | package com.bric.colorpicker; 2 | 3 | public enum ColorPickerMode { 4 | HUE(360), 5 | BRIGHTNESS(100), 6 | SATURATION(100), 7 | RED(255), 8 | GREEN(255), 9 | BLUE(255), 10 | ALPHA(255); 11 | 12 | private int max; 13 | 14 | private ColorPickerMode(int var3) { 15 | this.max = var3; 16 | } 17 | 18 | public int getMax() { 19 | return this.max; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/basics/overwirte/Sub.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.overwirte; 2 | 3 | public class Sub extends Super { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | public static Throwable P; 6 | 7 | @Override 8 | public void run() { 9 | System.out.println(this.face(1)); 10 | } 11 | 12 | @Override 13 | public String face(int var1) { 14 | return var1 == 1 ? "PASS" : "FAIL"; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/basics/runable/Pool.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.runable; 2 | 3 | import java.util.concurrent.LinkedBlockingQueue; 4 | import java.util.concurrent.ThreadPoolExecutor; 5 | import java.util.concurrent.TimeUnit; 6 | 7 | public class Pool { 8 | public static ThreadPoolExecutor tpe = new ThreadPoolExecutor(0, 1, 1L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1)); 9 | public int BRANCHLOCK_DOT_NET_DEMO; 10 | } 11 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/basics/cross/Top.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.cross; 2 | 3 | public class Top extends Abst1 implements Inte { 4 | public void run() { 5 | if (this.add(1, 2) == 3 && this.mul(2, 3) == 6) { 6 | System.out.println("PASS"); 7 | } else { 8 | System.out.println("FAIL"); 9 | } 10 | } 11 | 12 | @Override 13 | public int add(int a, int b) { 14 | return a + b; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/basics/cross/Top.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.cross; 2 | 3 | public class Top extends Abst1 implements Inte { 4 | public void run() { 5 | if (this.add(1, 2) == 3 && this.mul(2, 3) == 6) { 6 | System.out.println("PASS"); 7 | } else { 8 | System.out.println("FAIL"); 9 | } 10 | } 11 | 12 | @Override 13 | public int add(int a, int b) { 14 | return a + b; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/reflects/counter/Countee.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.counter; 2 | 3 | public class Countee { 4 | public int cpuli = 0; 5 | protected int cprot = 0; 6 | int cpackp = 1; 7 | private int cpriv = 0; 8 | public static Throwable I; 9 | 10 | public void mpuli() { 11 | } 12 | 13 | public void mprot() { 14 | } 15 | 16 | public void mpackp() { 17 | } 18 | 19 | public void mpriv() { 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /testData/results/custom-jars/SnakeGame-obf-zkm/c.dec: -------------------------------------------------------------------------------- 1 | public class c { 2 | public int a; 3 | public int b; 4 | public static boolean c; 5 | 6 | public c(int var1, int var2) { 7 | this.a = var1; 8 | this.b = var2; 9 | } 10 | 11 | public void a(int var1, int var2) { 12 | this.a = var1; 13 | this.b = var2; 14 | } 15 | 16 | public int a() { 17 | return this.a; 18 | } 19 | 20 | public int b() { 21 | return this.b; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/tests/basics/overwirte/Sub.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.overwirte; 2 | 3 | import java.io.PrintStream; 4 | 5 | public class Sub extends Super { 6 | @Override 7 | public void run(int var1) { 8 | PrintStream var6 = System.out; 9 | String var8 = this.face(1, 643068137); 10 | var6.println(var8); 11 | } 12 | 13 | @Override 14 | public String face(int var1, int var2) { 15 | return var1 == 1 ? "PASS" : "FAIL"; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/impl/clean/MethodDebugInfoCleanTransformer.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.core.other.impl.clean; 2 | 3 | import uwu.narumi.deobfuscator.api.transformer.ComposedTransformer; 4 | 5 | public class MethodDebugInfoCleanTransformer extends ComposedTransformer { 6 | public MethodDebugInfoCleanTransformer() { 7 | super( 8 | LocalVariableNamesCleanTransformer::new, 9 | ParametersInfoCleanTransformer::new 10 | ); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/reflects/retrace/Tracer.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.retrace; 2 | 3 | public class Tracer { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public Tracer(int var1) { 7 | } 8 | 9 | public void run(int var1) { 10 | new Tracee(5704).toTrace(5); 11 | if (Tracee.p == 5) { 12 | System.out.println("PASS"); 13 | } else { 14 | System.out.println("FAIL"); 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/tests/basics/runable/Exec.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.runable; 2 | 3 | public class Exec { 4 | public static int i = 1; 5 | private int d; 6 | 7 | public Exec(int var1, int var2) { 8 | this.d = var1; 9 | } 10 | 11 | void doAdd() { 12 | try { 13 | Thread.sleep(200L); 14 | } catch (Exception var9) { 15 | } 16 | 17 | int var6 = i; 18 | int var8 = this.d; 19 | i = var6 + var8; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/asm/remapper/NamePattern.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.asm.remapper; 2 | 3 | import java.util.function.Predicate; 4 | import java.util.regex.Pattern; 5 | 6 | /** 7 | * A collection of common name patterns. 8 | */ 9 | public class NamePattern { 10 | // iIIIiIIlliiIIlIii 11 | public static final Predicate III = Pattern.compile("^[lIi]*$").asMatchPredicate(); 12 | public static final Predicate WEB_EXPLOIT = s -> s.contains(""); 13 | } 14 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/data/Pair.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.data; 2 | 3 | import java.util.function.BiConsumer; 4 | 5 | public record Pair(A key, B value) { 6 | public static Pair of(X key, Y value) { 7 | return new Pair<>(key, value); 8 | } 9 | 10 | public void consume(BiConsumer consumer) { 11 | consumer.accept(key(), value()); 12 | } 13 | 14 | public boolean isPresent() { 15 | return key != null && value != null; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/reflects/counter/Countee.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.counter; 2 | 3 | public class Countee { 4 | public int cpuli = 0; 5 | protected int cprot = 0; 6 | int cpackp = 1; 7 | private int cpriv = 0; 8 | public int BRANCHLOCK_DOT_NET_DEMO; 9 | 10 | public void mpuli() { 11 | } 12 | 13 | public void mprot() { 14 | } 15 | 16 | public void mpackp() { 17 | } 18 | 19 | public void mpriv() { 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/reflects/loader/LRun.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.loader; 2 | 3 | public class LRun { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public LRun(int var1) { 7 | } 8 | 9 | public void run(int var1) { 10 | Loader var2 = new Loader(12270); 11 | Class var3 = var2.findClass("pack.tests.reflects.loader.LTest"); 12 | Object var4 = var3.newInstance(); 13 | var3.getMethod("run").invoke(var4); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/security/Sman.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.security; 2 | 3 | import java.security.Permission; 4 | 5 | public class Sman extends SecurityManager { 6 | public int BRANCHLOCK_DOT_NET_DEMO; 7 | 8 | public Sman(int var1) { 9 | } 10 | 11 | @Override 12 | public void checkPermission(Permission var1) { 13 | if (var1.getName().contains("exitVM")) { 14 | throw new SecurityException("HOOKED"); 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/tests/basics/cross/Top.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.cross; 2 | 3 | public class Top extends Abst1 implements Inte { 4 | public void run() { 5 | if (this.add(1, 2, 332349609) == 3 && this.mul(2, 3, 1586508627) == 6) { 6 | System.out.println("PASS"); 7 | } else { 8 | System.out.println("FAIL"); 9 | } 10 | } 11 | 12 | @Override 13 | public int add(int var1, int var2, int var3) { 14 | return var1 + var2; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /testData/results/custom-classes/zkm/sample2/a/a/a/a/ba.dec: -------------------------------------------------------------------------------- 1 | package a.a.a.a; 2 | 3 | import java.util.Comparator; 4 | 5 | public class ba extends a_ { 6 | private static final long serialVersionUID = 1L; 7 | 8 | public ba(long var1, Number var3, Number var4, Comparator var5) { 9 | var1 = 87486991067610L ^ var1; 10 | int var6 = (int)((var1 ^ 101419208877758L) >>> 32); 11 | long var7 = (var1 ^ 101419208877758L) << 32 >>> 32; 12 | super(var3, var4, var6, var7, var5); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/security/Sman.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.security; 2 | 3 | import java.security.Permission; 4 | 5 | public class Sman extends SecurityManager { 6 | public int BRANCHLOCK_DOT_NET_DEMO; 7 | 8 | public Sman(int var1) { 9 | } 10 | 11 | @Override 12 | public void checkPermission(Permission var1) { 13 | if (var1.getName().contains("exitVM")) { 14 | throw new SecurityException("HOOKED"); 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/basics/inner/Test.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.inner; 2 | 3 | public class Test { 4 | public void run() { 5 | Exec var1 = new Exec(); 6 | Exec.Inner var2 = var1.new Inner(3); 7 | var2.doAdd(); 8 | Exec.Inner var3 = var1.new Inner(100); 9 | var3.doAdd(); 10 | if (var1.fuss == 108) { 11 | System.out.println("PASS"); 12 | } else { 13 | System.out.println("ERROR"); 14 | } 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/basics/runable/Exec.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.runable; 2 | 3 | public class Exec { 4 | public static int i = 1; 5 | private int d; 6 | public int BRANCHLOCK_DOT_NET_DEMO; 7 | 8 | public Exec(int var1, int var2) { 9 | this.d = var1; 10 | } 11 | 12 | void doAdd() { 13 | try { 14 | Thread.sleep(200L); 15 | } catch (Exception var1) { 16 | } 17 | 18 | i = i + this.d; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/basics/runable/Pool.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.runable; 2 | 3 | import java.util.concurrent.LinkedBlockingQueue; 4 | import java.util.concurrent.ThreadPoolExecutor; 5 | import java.util.concurrent.TimeUnit; 6 | 7 | public class Pool { 8 | public static ThreadPoolExecutor tpe = new ThreadPoolExecutor(0, 1, 1L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1)); 9 | public int BRANCHLOCK_DOT_NET_DEMO; 10 | 11 | public Pool(int var1) { 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/asm/matcher/impl/SkipMatch.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.asm.matcher.impl; 2 | 3 | import uwu.narumi.deobfuscator.api.asm.matcher.Match; 4 | import uwu.narumi.deobfuscator.api.asm.matcher.MatchContext; 5 | 6 | public class SkipMatch extends Match { 7 | 8 | private SkipMatch() {} 9 | 10 | public static SkipMatch create() { 11 | return new SkipMatch(); 12 | } 13 | 14 | @Override 15 | protected boolean test(MatchContext context) { 16 | return true; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/basics/runable/Pool.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.runable; 2 | 3 | import java.util.concurrent.LinkedBlockingQueue; 4 | import java.util.concurrent.ThreadPoolExecutor; 5 | import java.util.concurrent.TimeUnit; 6 | 7 | public class Pool { 8 | public static ThreadPoolExecutor tpe = new ThreadPoolExecutor(0, 1, 1L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1)); 9 | public int BRANCHLOCK_DOT_NET_DEMO; 10 | 11 | public Pool(int var1) { 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/basics/inner/Test.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.inner; 2 | 3 | public class Test { 4 | public void run() { 5 | Exec exec = new Exec(); 6 | Exec.Inner inner1 = exec.new Inner(3); 7 | inner1.doAdd(); 8 | Exec.Inner inner2 = exec.new Inner(100); 9 | inner2.doAdd(); 10 | if (exec.fuss == 108) { 11 | System.out.println("PASS"); 12 | } else { 13 | System.out.println("ERROR"); 14 | } 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/basics/inner/Exec.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.inner; 2 | 3 | public class Exec { 4 | public int fuss = 1; 5 | 6 | public void addF() { 7 | this.fuss += 2; 8 | } 9 | 10 | public class Inner { 11 | int i; 12 | 13 | public Inner(int p) { 14 | this.i = p; 15 | } 16 | 17 | public void doAdd() { 18 | Exec.this.addF(); 19 | Exec.this.fuss = Exec.this.fuss + this.i; 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/data/TriFunction.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.data; 2 | 3 | import java.util.Objects; 4 | import java.util.function.Function; 5 | 6 | @FunctionalInterface 7 | public interface TriFunction { 8 | R apply(A first, B second, C third); 9 | 10 | default TriFunction andThen(Function after) { 11 | Objects.requireNonNull(after); 12 | return (A first, B second, C third) -> after.apply(apply(first, second, third)); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /testData/results/custom-jars/SnakeGame-obf-zkm/b.dec: -------------------------------------------------------------------------------- 1 | import java.awt.Color; 2 | import java.util.ArrayList; 3 | 4 | public class b { 5 | ArrayList a = new ArrayList<>(); 6 | int b; 7 | f c; 8 | 9 | public b(int var1) { 10 | this.a.add(Color.darkGray); 11 | this.a.add(Color.BLUE); 12 | this.a.add(Color.white); 13 | this.b = var1; 14 | this.c = new f(this.a.get(this.b)); 15 | } 16 | 17 | public void a(int var1) { 18 | this.c.a(new Object[]{this.a.get(var1)}); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/basics/inner/Exec.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.inner; 2 | 3 | public class Exec { 4 | public int fuss = 1; 5 | 6 | public void addF() { 7 | this.fuss += 2; 8 | } 9 | 10 | public class Inner { 11 | int i; 12 | 13 | public Inner(int p) { 14 | this.i = p; 15 | } 16 | 17 | public void doAdd() { 18 | Exec.this.addF(); 19 | Exec.this.fuss = Exec.this.fuss + this.i; 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/basics/overwirte/Sub.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.overwirte; 2 | 3 | public class Sub extends Super { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public Sub(int var1) { 7 | super(14474); 8 | } 9 | 10 | @Override 11 | public void run(int var1) { 12 | System.out.println(this.face(1, 8362)); 13 | } 14 | 15 | @Override 16 | public String face(int var1, int var2) { 17 | return var1 == 1 ? "PASS" : "FAIL"; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/data/TriConsumer.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.data; 2 | 3 | import java.util.Objects; 4 | 5 | @FunctionalInterface 6 | public interface TriConsumer { 7 | void accept(A first, B second, C third); 8 | 9 | default TriConsumer andThen(TriConsumer after) { 10 | Objects.requireNonNull(after); 11 | return (first, second, third) -> { 12 | accept(first, second, third); 13 | after.accept(first, second, third); 14 | }; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /testData/results/custom-classes/qprotect/sample1/JSONStringer.dec: -------------------------------------------------------------------------------- 1 | package org.json; 2 | 3 | import java.io.StringWriter; 4 | 5 | public class JSONStringer extends org.json.JSONWriter { 6 | public static final int IIlIIlIIIlIIIl; 7 | public static final boolean IIlIIIIIIIllll = false; 8 | 9 | public JSONStringer() { 10 | super(new StringWriter()); 11 | org.json.ParserConfiguration.IIlIIIIlIIII(); 12 | } 13 | 14 | @Override 15 | public String toString() { 16 | return this.mode == 'd' ? this.writer.toString() : null; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/basics/cross/Top.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.cross; 2 | 3 | public class Top extends Abst1 implements Inte { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public void run() { 7 | if (this.add(1, 2) == 3 && this.mul(2, 3) == 6) { 8 | System.out.println("PASS"); 9 | } else { 10 | System.out.println("FAIL"); 11 | } 12 | } 13 | 14 | @Override 15 | public int add(int var1, int var2) { 16 | return var1 + var2; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/basics/sub/SolAdd.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.sub; 2 | 3 | import pack.tests.basics.overwirte.Sub; 4 | import pack.tests.reflects.annot.annoe; 5 | 6 | public class SolAdd { 7 | public int BRANCHLOCK_DOT_NET_DEMO; 8 | 9 | public static int get() { 10 | return (new med(1, 2)).result; 11 | } 12 | 13 | public static Throwable P(Throwable var0) { 14 | if (annoe.P != null) { 15 | Sub.P = var0; 16 | } 17 | 18 | return var0; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/tests/basics/inner/Test.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.inner; 2 | 3 | public class Test { 4 | public void run(int var1) { 5 | Exec var2 = new Exec(); 6 | Exec.Inner var7 = var2.new Inner(3, 1527845619); 7 | var7.doAdd(790770962); 8 | Exec.Inner var9 = var2.new Inner(100, 1527845619); 9 | var9.doAdd(790770962); 10 | if (var2.fuss == 108) { 11 | System.out.println("PASS"); 12 | } else { 13 | System.out.println("ERROR"); 14 | } 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/tests/reflects/counter/Count.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.counter; 2 | 3 | public class Count { 4 | public void run(int var1) throws Throwable { 5 | if (Countee.class.getFields().length == 1 6 | && Countee.class.getDeclaredFields().length == 4 7 | && Countee.class.getMethods().length > 4 8 | && Countee.class.getDeclaredMethods().length == 4) { 9 | System.out.println("PASS"); 10 | } else { 11 | System.out.println("FAIL"); 12 | } 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/reflects/annot/annot.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.annot; 2 | 3 | import java.lang.reflect.Method; 4 | 5 | public class annot { 6 | public void run() throws Exception { 7 | annoe a = new annoe(); 8 | 9 | for (Method m : annoe.class.getDeclaredMethods()) { 10 | m.setAccessible(true); 11 | anno an = m.getAnnotation(anno.class); 12 | if (an != null && an.val().equals("yes")) { 13 | m.invoke(a); 14 | } 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/reflects/counter/Count.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.counter; 2 | 3 | public class Count { 4 | public void run() throws Throwable { 5 | if (Countee.class.getFields().length == 1 6 | && Countee.class.getDeclaredFields().length == 4 7 | && Countee.class.getMethods().length > 4 8 | && Countee.class.getDeclaredMethods().length == 4) { 9 | System.out.println("PASS"); 10 | } else { 11 | System.out.println("FAIL"); 12 | } 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/reflects/loader/LRun.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.loader; 2 | 3 | public class LRun { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public LRun(int var1) { 7 | } 8 | 9 | public void run(int var1) { 10 | Loader var2 = new Loader(5640); 11 | Class var3 = var2.findClass("pack.tests.reflects.loader.LTest"); 12 | Object var4 = var3.newInstance(); 13 | if (var1 >= 0) { 14 | var3.getMethod("run").invoke(var4); 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/reflects/counter/Countee.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.counter; 2 | 3 | public class Countee { 4 | public int cpuli = 0; 5 | protected int cprot = 0; 6 | int cpackp = 1; 7 | private int cpriv = 0; 8 | public int BRANCHLOCK_DOT_NET_DEMO; 9 | 10 | public Countee(int var1) { 11 | } 12 | 13 | public void mpuli() { 14 | } 15 | 16 | public void mprot() { 17 | } 18 | 19 | public void mpackp() { 20 | } 21 | 22 | public void mpriv() { 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/reflects/counter/Count.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.counter; 2 | 3 | public class Count { 4 | public void run() throws Throwable { 5 | if (Countee.class.getFields().length == 1 6 | && Countee.class.getDeclaredFields().length == 4 7 | && Countee.class.getMethods().length > 4 8 | && Countee.class.getDeclaredMethods().length == 4) { 9 | System.out.println("PASS"); 10 | } else { 11 | System.out.println("FAIL"); 12 | } 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/asm/FramesProvider.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.asm; 2 | 3 | import org.objectweb.asm.tree.AbstractInsnNode; 4 | import org.objectweb.asm.tree.ClassNode; 5 | import org.objectweb.asm.tree.MethodNode; 6 | import org.objectweb.asm.tree.analysis.Frame; 7 | import org.objectweb.asm.tree.analysis.OriginalSourceValue; 8 | 9 | import java.util.Map; 10 | 11 | @FunctionalInterface 12 | public interface FramesProvider { 13 | Map> compute(ClassNode classNode, MethodNode methodNode); 14 | } 15 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/basics/accu/Digi.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.accu; 2 | 3 | public class Digi { 4 | public String BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public void run() { 7 | double var1 = 0.0; 8 | int var3 = 0; 9 | 10 | do { 11 | var1 += 1.0E-18; 12 | } while (++var3 <= 100 && (float)var1 != 2.0E-17F); 13 | 14 | if (var3 == 20) { 15 | System.out.println("PASS"); 16 | } else { 17 | System.out.println("FAIL"); 18 | } 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/reflects/counter/Countee.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.counter; 2 | 3 | public class Countee { 4 | public int cpuli = 0; 5 | protected int cprot = 0; 6 | int cpackp = 1; 7 | private int cpriv = 0; 8 | public int BRANCHLOCK_DOT_NET_DEMO; 9 | 10 | public Countee(int var1) { 11 | } 12 | 13 | public void mpuli() { 14 | } 15 | 16 | public void mprot() { 17 | } 18 | 19 | public void mpackp() { 20 | } 21 | 22 | public void mpriv() { 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/tests/basics/runable/Pool.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.runable; 2 | 3 | import java.util.concurrent.LinkedBlockingQueue; 4 | import java.util.concurrent.ThreadPoolExecutor; 5 | import java.util.concurrent.TimeUnit; 6 | 7 | public class Pool { 8 | public static ThreadPoolExecutor tpe; 9 | 10 | static { 11 | TimeUnit var5 = TimeUnit.SECONDS; 12 | LinkedBlockingQueue var6 = new LinkedBlockingQueue(1); 13 | ThreadPoolExecutor var0 = new ThreadPoolExecutor(0, 1, 1L, var5, var6); 14 | tpe = var0; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/reflects/retrace/Tracee.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.retrace; 2 | 3 | public class Tracee { 4 | public static int p = 0; 5 | 6 | private void doTrace(int i) throws Exception { 7 | p++; 8 | StackTraceElement ste = new Throwable().getStackTrace()[1]; 9 | Tracee.class.getDeclaredMethod(ste.getMethodName(), int.class).invoke(this, i - 1); 10 | } 11 | 12 | public void toTrace(int i) throws Exception { 13 | if (i != 0) { 14 | this.doTrace(i); 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /testData/src/java/src/main/java/remap/Cat.java: -------------------------------------------------------------------------------- 1 | package remap; 2 | 3 | public class Cat extends Pet { 4 | private final String name; 5 | 6 | public Cat(String name) { 7 | this.name = name; 8 | } 9 | 10 | @Override 11 | public void eat() { 12 | System.out.println(this.name + ": Cat is eating"); 13 | } 14 | 15 | @Override 16 | public void sleep() { 17 | System.out.println(this.name + ": Cat is sleeping"); 18 | } 19 | 20 | @Override 21 | public void play() { 22 | System.out.println(this.name + ": Cat is playing"); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/reflects/retrace/Tracee.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.retrace; 2 | 3 | public class Tracee { 4 | public static int p = 0; 5 | 6 | private void doTrace(int var1) throws Exception { 7 | p++; 8 | StackTraceElement var2 = new Throwable().getStackTrace()[1]; 9 | Tracee.class.getDeclaredMethod(var2.getMethodName(), int.class).invoke(this, var1 - 1); 10 | } 11 | 12 | public void toTrace(int var1) throws Exception { 13 | if (var1 != 0) { 14 | this.doTrace(var1); 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /testData/results/java/remap/class_0.dec: -------------------------------------------------------------------------------- 1 | public class class_0 extends class_2 { 2 | private final String field_0; 3 | 4 | public class_0(String name) { 5 | this.field_0 = name; 6 | } 7 | 8 | @Override 9 | public void method_0() { 10 | System.out.println(this.field_0 + ": Cat is eating"); 11 | } 12 | 13 | @Override 14 | public void method_1() { 15 | System.out.println(this.field_0 + ": Cat is sleeping"); 16 | } 17 | 18 | @Override 19 | public void method_2() { 20 | System.out.println(this.field_0 + ": Cat is playing"); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/basics/inner/Test.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.inner; 2 | 3 | public class Test { 4 | public String BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public void run() { 7 | Exec var1 = new Exec(); 8 | Exec.Inner var2 = var1.new Inner(var1, 3); 9 | var2.doAdd(); 10 | Exec.Inner var3 = var1.new Inner(var1, 100); 11 | var3.doAdd(); 12 | if (var1.fuss == 108) { 13 | System.out.println("PASS"); 14 | } else { 15 | System.out.println("ERROR"); 16 | } 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/tests/reflects/loader/LRun.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.loader; 2 | 3 | import java.lang.reflect.Method; 4 | 5 | public class LRun { 6 | public void run(int var1) throws Exception { 7 | Loader var2 = new Loader(); 8 | Class var5 = var2.findClass("pack.tests.reflects.loader.LTest"); 9 | Object var6 = var5.newInstance(); 10 | String var15 = "run"; 11 | Class[] var17 = new Class[0]; 12 | Method var12 = var5.getMethod(var15, var17); 13 | Object[] var19 = new Object[0]; 14 | var12.invoke(var6, var19); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/reflects/counter/Count.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.counter; 2 | 3 | public class Count { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public void run() { 7 | if (Countee.class.getFields().length == 1 8 | && Countee.class.getDeclaredFields().length == 4 9 | && Countee.class.getMethods().length > 4 10 | && Countee.class.getDeclaredMethods().length == 4) { 11 | System.out.println("PASS"); 12 | } else { 13 | System.out.println("FAIL"); 14 | } 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/impl/clean/ClassDebugInfoCleanTransformer.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.core.other.impl.clean; 2 | 3 | import uwu.narumi.deobfuscator.api.transformer.Transformer; 4 | 5 | public class ClassDebugInfoCleanTransformer extends Transformer { 6 | 7 | @Override 8 | protected void transform() throws Exception { 9 | scopedClasses().forEach(classWrapper -> { 10 | classWrapper.classNode().sourceDebug = null; 11 | classWrapper.classNode().sourceFile = null; 12 | }); 13 | 14 | // There is always a change 15 | markChange(); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/reflects/retrace/Tracee.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.retrace; 2 | 3 | public class Tracee { 4 | public static int p = 0; 5 | public int BRANCHLOCK_DOT_NET_DEMO; 6 | 7 | private void doTrace(int var1) { 8 | p++; 9 | StackTraceElement var2 = new Throwable().getStackTrace()[1]; 10 | Tracee.class.getDeclaredMethod(var2.getMethodName(), int.class).invoke(this, var1 - 1); 11 | } 12 | 13 | public void toTrace(int var1) { 14 | if (var1 != 0) { 15 | this.doTrace(var1); 16 | } 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/basics/accu/Digi.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.accu; 2 | 3 | public class Digi { 4 | public String BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public Digi(int var1) { 7 | } 8 | 9 | public void run(int var1) { 10 | double var2 = 0.0; 11 | int var4 = 0; 12 | 13 | do { 14 | var2 += 1.0E-18; 15 | } while (++var4 <= 100 && (float)var2 != 2.0E-17F); 16 | 17 | if (var4 == 20) { 18 | System.out.println("PASS"); 19 | } else { 20 | System.out.println("FAIL"); 21 | } 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /.onedev-buildspec.yml: -------------------------------------------------------------------------------- 1 | version: 38 2 | jobs: 3 | - name: Mirror 4 | steps: 5 | - !PullRepository 6 | name: Mirror 7 | remoteUrl: https://github.com/narumii/Deobfuscator 8 | targetProject: Deobfuscator 9 | accessTokenSecret: CunnyDev Token 10 | refs: refs/heads/* refs/tags/* 11 | withLfs: false 12 | force: false 13 | condition: ALL_PREVIOUS_STEPS_WERE_SUCCESSFUL 14 | triggers: 15 | - !ScheduleTrigger 16 | cronExpression: 0 0 1 * * ? 17 | projects: Deobfuscator 18 | retryCondition: never 19 | maxRetries: 3 20 | retryDelay: 30 21 | timeout: 14400 22 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/reflects/annot/annot.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.annot; 2 | 3 | import java.lang.reflect.Method; 4 | 5 | public class annot { 6 | public String BRANCHLOCK_DOT_NET_DEMO; 7 | 8 | public void run() { 9 | annoe var1 = new annoe(); 10 | 11 | for (Method var5 : annoe.class.getDeclaredMethods()) { 12 | var5.setAccessible(true); 13 | anno var6 = var5.getAnnotation(anno.class); 14 | if (var6 != null && var6.val().equals("yes")) { 15 | var5.invoke(var1); 16 | } 17 | } 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/basics/accu/Digi.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.accu; 2 | 3 | public class Digi { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public Digi(int var1) { 7 | } 8 | 9 | public void run(int var1) { 10 | double var2 = 0.0; 11 | int var4 = 0; 12 | 13 | do { 14 | var2 += 1.0E-18; 15 | } while (++var4 <= 100 && (float)var2 != 2.0E-17F); 16 | 17 | if (var4 == 20) { 18 | System.out.println("PASS"); 19 | } else { 20 | System.out.println("FAIL"); 21 | } 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/tests/basics/accu/Digi.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.accu; 2 | 3 | public class Digi { 4 | public void run(int var1) { 5 | double var7 = 0.0; 6 | int var9 = 0; 7 | 8 | do { 9 | var7 += 1.0E-18; 10 | } while (++var9 <= 100 && (float)var7 != 2.0E-17F); 11 | 12 | if (var9 == 20) { 13 | System.out.println("PASS"); 14 | } else { 15 | System.out.println("FAIL"); 16 | } 17 | } 18 | 19 | private static byte[] kqlfjamyycsynra() { 20 | return new byte[]{-125, -75, 14, 106, 0, 98, 92, 21, 1, 51}; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/basics/ctrl/Ctrl.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.ctrl; 2 | 3 | public class Ctrl { 4 | private String ret = "FAIL"; 5 | 6 | public void runt() { 7 | if (!"a".equals("b")) { 8 | throw new UnsupportedOperationException(); 9 | } 10 | } 11 | 12 | public void runf() { 13 | this.runt(); 14 | 15 | try { 16 | this.runt(); 17 | this.ret = "FAIL"; 18 | } catch (Exception var2) { 19 | } 20 | } 21 | 22 | public void run() { 23 | this.runf(); 24 | System.out.println(this.ret); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/asm/matcher/impl/OpcodeMatch.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.asm.matcher.impl; 2 | 3 | import uwu.narumi.deobfuscator.api.asm.matcher.Match; 4 | import uwu.narumi.deobfuscator.api.asm.matcher.MatchContext; 5 | 6 | public class OpcodeMatch extends Match { 7 | private final int opcode; 8 | 9 | private OpcodeMatch(int opcode) { 10 | this.opcode = opcode; 11 | } 12 | 13 | public static OpcodeMatch of(int opcode) { 14 | return new OpcodeMatch(opcode); 15 | } 16 | 17 | @Override 18 | protected boolean test(MatchContext context) { 19 | return context.insn().getOpcode() == opcode; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/asm/matcher/group/NotMatch.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.asm.matcher.group; 2 | 3 | import uwu.narumi.deobfuscator.api.asm.matcher.Match; 4 | import uwu.narumi.deobfuscator.api.asm.matcher.MatchContext; 5 | 6 | public class NotMatch extends Match { 7 | 8 | private final Match match; 9 | 10 | private NotMatch(Match match) { 11 | this.match = match; 12 | } 13 | 14 | public static NotMatch of(Match match) { 15 | return new NotMatch(match); 16 | } 17 | 18 | @Override 19 | protected boolean test(MatchContext context) { 20 | return !match.matchAndMerge(context.insnContext(), context); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/impl/clean/ParametersInfoCleanTransformer.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.core.other.impl.clean; 2 | 3 | import uwu.narumi.deobfuscator.api.transformer.Transformer; 4 | 5 | /** 6 | * Removes parameter info from methods 7 | */ 8 | public class ParametersInfoCleanTransformer extends Transformer { 9 | @Override 10 | protected void transform() throws Exception { 11 | scopedClasses().stream() 12 | .flatMap(classWrapper -> classWrapper.methods().stream()) 13 | .forEach(methodNode -> { 14 | methodNode.parameters = null; 15 | this.markChange(); 16 | }); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/reflects/counter/Count.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.counter; 2 | 3 | public class Count { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public Count(int var1) { 7 | } 8 | 9 | public void run(int var1) { 10 | if (Countee.class.getFields().length == 1 11 | && Countee.class.getDeclaredFields().length == 4 12 | && Countee.class.getMethods().length > 4 13 | && Countee.class.getDeclaredMethods().length == 4) { 14 | System.out.println("PASS"); 15 | } else { 16 | System.out.println("FAIL"); 17 | } 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/reflects/retrace/Tracee.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.retrace; 2 | 3 | public class Tracee { 4 | public static int p = 0; 5 | public int BRANCHLOCK_DOT_NET_DEMO; 6 | 7 | public Tracee(int var1) { 8 | } 9 | 10 | private void doTrace(int var1) { 11 | p++; 12 | StackTraceElement var2 = new Throwable().getStackTrace()[1]; 13 | Tracee.class.getDeclaredMethod(var2.getMethodName(), int.class).invoke(this, var1 - 1); 14 | } 15 | 16 | public void toTrace(int var1) { 17 | if (var1 != 0) { 18 | this.doTrace(var1); 19 | } 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/tests/reflects/annot/annot.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.annot; 2 | 3 | import java.lang.reflect.Method; 4 | 5 | public class annot { 6 | public void run(int var1) throws Exception { 7 | annoe var2 = new annoe(); 8 | annoe var4 = var2; 9 | 10 | for (Method var8 : annoe.class.getDeclaredMethods()) { 11 | var8.setAccessible(true); 12 | anno var9 = var8.getAnnotation(anno.class); 13 | if (var9 != null && var9.val().equals("yes")) { 14 | Object[] var34 = new Object[0]; 15 | var8.invoke(var4, var34); 16 | } 17 | } 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /testData/results/custom-classes/unknown/obf1/SomeClass1.dec: -------------------------------------------------------------------------------- 1 | import org.bukkit.Bukkit; 2 | import org.bukkit.event.Listener; 3 | 4 | public class SomeClass1 implements Listener { 5 | public static int lIIIIlllIlIIllIIIlllllIlllIIllIllIIlIIllIIIllIIlIllllIIIIllIIlIIIIlIllIIlllIllIllllIIIlllIllIllIlllIlllllIIlIIIlllllIIIlIlIllllIllllIllllIIlIIllIlIIllIIllIIlIllIIllllIlllIIIIlIIllIIIIIIIIllllIlIllllIl( 6 | int var0 7 | ) { 8 | Bukkit.getServer(); 9 | Bukkit.getServer(); 10 | Bukkit.getServer(); 11 | Bukkit.getServer(); 12 | Bukkit.getServer(); 13 | Bukkit.getServer(); 14 | Bukkit.getServer(); 15 | return 0; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/reflects/retrace/Tracee.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.retrace; 2 | 3 | public class Tracee { 4 | public static int p = 0; 5 | public int BRANCHLOCK_DOT_NET_DEMO; 6 | 7 | public Tracee(int var1) { 8 | } 9 | 10 | private void doTrace(int var1) { 11 | p++; 12 | StackTraceElement var2 = new Throwable().getStackTrace()[1]; 13 | Tracee.class.getDeclaredMethod(var2.getMethodName(), int.class).invoke(this, var1 - 1); 14 | } 15 | 16 | public void toTrace(int var1) { 17 | if (var1 != 0) { 18 | this.doTrace(var1); 19 | } 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/basics/accu/Digi.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.accu; 2 | 3 | public class Digi { 4 | public void run() { 5 | double var1 = 0.0; 6 | int var3 = 0; 7 | float var4 = 1.1F; 8 | 9 | do { 10 | var1 += 1.0E-18; 11 | } while (++var3 <= 100 && (float)var1 != 2.0E-17F); 12 | 13 | if (var3 == 20) { 14 | if (++var4 == 2.4F) { 15 | System.out.println("PASS"); 16 | return; 17 | } 18 | 19 | System.out.println("FAIL"); 20 | } else { 21 | System.out.println("FAIL"); 22 | } 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/impl/clean/LocalVariableNamesCleanTransformer.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.core.other.impl.clean; 2 | 3 | import uwu.narumi.deobfuscator.api.transformer.Transformer; 4 | 5 | /** 6 | * Removes local variable names. 7 | */ 8 | public class LocalVariableNamesCleanTransformer extends Transformer { 9 | 10 | @Override 11 | protected void transform() throws Exception { 12 | scopedClasses().stream() 13 | .flatMap(classWrapper -> classWrapper.methods().stream()) 14 | .forEach(methodNode -> { 15 | methodNode.localVariables = null; 16 | this.markChange(); 17 | }); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/basics/inner/Test.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.inner; 2 | 3 | public class Test { 4 | public String BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public Test(int var1) { 7 | } 8 | 9 | public void run(int var1) { 10 | Exec var2 = new Exec(21624); 11 | Exec.Inner var3 = var2.new Inner(var2, 3, 14056); 12 | var3.doAdd(15081); 13 | Exec.Inner var4 = var2.new Inner(var2, 100, 14056); 14 | var4.doAdd(15081); 15 | if (var2.fuss == 108) { 16 | System.out.println("PASS"); 17 | } else { 18 | System.out.println("ERROR"); 19 | } 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/basics/accu/Digi.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.accu; 2 | 3 | public class Digi { 4 | public void run() { 5 | double fl = 0.0; 6 | int co = 0; 7 | float fx = 1.1F; 8 | 9 | do { 10 | fl += 1.0E-18; 11 | } while (++co <= 100 && (float)fl != 2.0E-17F); 12 | 13 | if (co == 20) { 14 | fx = 2.4F; 15 | if (true) { 16 | System.out.println("PASS"); 17 | return; 18 | } 19 | 20 | System.out.println("FAIL"); 21 | } else { 22 | System.out.println("FAIL"); 23 | } 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/reflects/annot/annot.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.annot; 2 | 3 | import java.lang.reflect.Method; 4 | 5 | public class annot { 6 | public String BRANCHLOCK_DOT_NET_DEMO; 7 | 8 | public annot(int var1) { 9 | } 10 | 11 | public void run(int var1) { 12 | annoe var2 = new annoe(10261); 13 | 14 | for (Method var6 : annoe.class.getDeclaredMethods()) { 15 | var6.setAccessible(true); 16 | anno var7 = var6.getAnnotation(anno.class); 17 | if (var7 != null && var7.val().equals("yes")) { 18 | var6.invoke(var2); 19 | } 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/basics/ctrl/Ctrl.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.ctrl; 2 | 3 | public class Ctrl { 4 | private String ret = "FAIL"; 5 | public int BRANCHLOCK_DOT_NET_DEMO; 6 | 7 | public void runt() { 8 | if (!"a".equals("b")) { 9 | throw new UnsupportedOperationException(); 10 | } 11 | } 12 | 13 | public void runf() { 14 | this.runt(); 15 | 16 | try { 17 | this.runt(); 18 | this.ret = "FAIL"; 19 | } catch (Exception var1) { 20 | } 21 | } 22 | 23 | public void run() { 24 | this.runf(); 25 | System.out.println(this.ret); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/composed/ComposedAllatoriTransformer.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.core.other.composed; 2 | 3 | import uwu.narumi.deobfuscator.api.transformer.ComposedTransformer; 4 | import uwu.narumi.deobfuscator.core.other.impl.allatori.AllatoriStringTransformer; 5 | import uwu.narumi.deobfuscator.core.other.impl.universal.UniversalNumberTransformer; 6 | 7 | public class ComposedAllatoriTransformer extends ComposedTransformer { 8 | 9 | public ComposedAllatoriTransformer(boolean strongString) { 10 | super( 11 | UniversalNumberTransformer::new, 12 | () -> new AllatoriStringTransformer(strongString) 13 | ); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /testData/results/java/TestInlineStaticFields.dec: -------------------------------------------------------------------------------- 1 | public class TestInlineStaticFields { 2 | public static int TEST1 = 123; 3 | public static int TEST4; 4 | public static String TEST5; 5 | 6 | public static void test() { 7 | System.out.println(TEST1); 8 | System.out.println("placki"); 9 | System.out.println(true); 10 | System.out.println(TEST4); 11 | System.out.println(TEST5.toUpperCase()); 12 | } 13 | 14 | public static void modifyStatic() { 15 | TEST1 = 321; 16 | } 17 | 18 | static { 19 | try { 20 | TEST5 = Number.class.getSimpleName(); 21 | } catch (Exception var1) { 22 | TEST5 = null; 23 | } 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/impl/clean/SignatureCleanTransformer.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.core.other.impl.clean; 2 | 3 | import uwu.narumi.deobfuscator.api.transformer.Transformer; 4 | 5 | public class SignatureCleanTransformer extends Transformer { 6 | 7 | @Override 8 | protected void transform() throws Exception { 9 | scopedClasses().forEach(classWrapper -> { 10 | classWrapper.classNode().signature = null; 11 | classWrapper.methods().forEach(methodNode -> methodNode.signature = null); 12 | classWrapper.fields().forEach(fieldNode -> fieldNode.signature = null); 13 | }); 14 | 15 | // There is always a change 16 | this.markChange(); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/basics/inner/Exec.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.inner; 2 | 3 | public class Exec { 4 | public int fuss = 1; 5 | public int BRANCHLOCK_DOT_NET_DEMO; 6 | 7 | public void addF() { 8 | this.fuss += 2; 9 | } 10 | 11 | public class Inner { 12 | int i; 13 | final Exec this$0; 14 | public int BRANCHLOCK_DOT_NET_DEMO; 15 | 16 | public Inner(Exec var1, int var2) { 17 | this.this$0 = var1; 18 | this.i = var2; 19 | } 20 | 21 | public void doAdd() { 22 | this.this$0.addF(); 23 | this.this$0.fuss = this.this$0.fuss + this.i; 24 | } 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/tests/basics/inner/Exec.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.inner; 2 | 3 | public class Exec { 4 | public int fuss = 1; 5 | 6 | public void addF(int var1) { 7 | int var5 = this.fuss + 2; 8 | this.fuss = var5; 9 | } 10 | 11 | public class Inner { 12 | int i; 13 | 14 | public Inner(int var2, int var3) { 15 | this.i = var2; 16 | } 17 | 18 | public void doAdd(int var1) { 19 | Exec.this.addF(985687609); 20 | Exec var6 = Exec.this; 21 | int var7 = var6.fuss; 22 | int var9 = this.i; 23 | int var8 = var7 + var9; 24 | var6.fuss = var8; 25 | } 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/impl/universal/RecoverSyntheticsTransformer.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.core.other.impl.universal; 2 | 3 | import uwu.narumi.deobfuscator.api.transformer.Transformer; 4 | 5 | public class RecoverSyntheticsTransformer extends Transformer { 6 | @Override 7 | protected void transform() throws Exception { 8 | scopedClasses().forEach(classWrapper -> { 9 | classWrapper.methods().forEach(methodNode -> { 10 | // Recover by name 11 | if (methodNode.name.startsWith("lambda$")) { 12 | // Mark as synthetic 13 | methodNode.access |= ACC_SYNTHETIC; 14 | markChange(); 15 | } 16 | }); 17 | }); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/exception/TransformerException.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.exception; 2 | 3 | public class TransformerException extends RuntimeException { 4 | 5 | public TransformerException() {} 6 | 7 | public TransformerException(String message) { 8 | super(message); 9 | } 10 | 11 | public TransformerException(String message, Throwable cause) { 12 | super(message, cause); 13 | } 14 | 15 | public TransformerException(Throwable cause) { 16 | super(cause); 17 | } 18 | 19 | public TransformerException( 20 | String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { 21 | super(message, cause, enableSuppression, writableStackTrace); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/reflects/loader/LTest.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.loader; 2 | 3 | import java.io.ByteArrayOutputStream; 4 | import java.io.InputStream; 5 | 6 | public class LTest { 7 | public int BRANCHLOCK_DOT_NET_DEMO; 8 | 9 | public LTest(int var1) { 10 | } 11 | 12 | public static byte[] readAllBytes(InputStream var0, int var1) { 13 | ByteArrayOutputStream var2 = new ByteArrayOutputStream(); 14 | byte[] var3 = new byte[var1 ^ 6433]; 15 | 16 | int var4; 17 | while ((var4 = var0.read(var3)) != (var1 ^ -7458) && var1 >= 0) { 18 | var2.write(var3, 0, var4); 19 | } 20 | 21 | return var2.toByteArray(); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /testData/src/java/src/main/java/TestInlineStaticFields.java: -------------------------------------------------------------------------------- 1 | public class TestInlineStaticFields { 2 | public static int TEST1 = 123; 3 | public static String TEST2 = "placki"; 4 | public static boolean TEST3 = true; 5 | public static int TEST4; 6 | public static String TEST5; 7 | 8 | static { 9 | try { 10 | TEST5 = Number.class.getSimpleName(); 11 | } catch (Exception e) { 12 | TEST5 = null; 13 | } 14 | } 15 | 16 | public static void test() { 17 | System.out.println(TEST1); 18 | System.out.println(TEST2); 19 | System.out.println(TEST3); 20 | System.out.println(TEST4); 21 | 22 | System.out.println(TEST5.toUpperCase()); 23 | } 24 | 25 | public static void modifyStatic() { 26 | TEST1 = 321; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /deobfuscator-impl/src/main/resources/log4j2.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/basics/ctrl/Ctrl.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.ctrl; 2 | 3 | public class Ctrl { 4 | private String ret = "FAIL"; 5 | 6 | public void runt() { 7 | if (!"a".equals("b")) { 8 | throw new UnsupportedOperationException(); 9 | } 10 | } 11 | 12 | public void runf() { 13 | try { 14 | this.runt(); 15 | } catch (RuntimeException var3) { 16 | this.ret = "PASS"; 17 | } 18 | 19 | try { 20 | this.runt(); 21 | this.ret = "FAIL"; 22 | } catch (Exception var2) { 23 | } 24 | } 25 | 26 | public void run() { 27 | this.runf(); 28 | System.out.println(this.ret); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/asm/matcher/group/AllMatch.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.asm.matcher.group; 2 | 3 | import uwu.narumi.deobfuscator.api.asm.matcher.Match; 4 | import uwu.narumi.deobfuscator.api.asm.matcher.MatchContext; 5 | 6 | public class AllMatch extends Match { 7 | 8 | private final Match[] matches; 9 | 10 | private AllMatch(Match[] matches) { 11 | this.matches = matches; 12 | } 13 | 14 | public static AllMatch of(Match... matches) { 15 | return new AllMatch(matches); 16 | } 17 | 18 | @Override 19 | protected boolean test(MatchContext context) { 20 | for (Match match : matches) { 21 | if (!match.matchAndMerge(context.insnContext(), context)) return false; 22 | } 23 | 24 | return true; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/asm/matcher/group/AnyMatch.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.asm.matcher.group; 2 | 3 | import uwu.narumi.deobfuscator.api.asm.matcher.Match; 4 | import uwu.narumi.deobfuscator.api.asm.matcher.MatchContext; 5 | 6 | public class AnyMatch extends Match { 7 | 8 | private final Match[] matches; 9 | 10 | private AnyMatch(Match[] matches) { 11 | this.matches = matches; 12 | } 13 | 14 | public static AnyMatch of(Match... matches) { 15 | return new AnyMatch(matches); 16 | } 17 | 18 | @Override 19 | protected boolean test(MatchContext context) { 20 | for (Match match : matches) { 21 | if (match.matchAndMerge(context.insnContext(), context)) return true; 22 | } 23 | 24 | return false; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/impl/universal/UniversalNumberTransformer.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.core.other.impl.universal; 2 | 3 | import uwu.narumi.deobfuscator.api.transformer.ComposedTransformer; 4 | import uwu.narumi.deobfuscator.core.other.impl.clean.peephole.UselessPopCleanTransformer; 5 | import uwu.narumi.deobfuscator.core.other.impl.universal.number.*; 6 | 7 | /** 8 | * Simplifies number operations on constant values. 9 | */ 10 | public class UniversalNumberTransformer extends ComposedTransformer { 11 | public UniversalNumberTransformer() { 12 | super( 13 | InlineConstantValuesTransformer::new, 14 | EmptyArrayLengthTransformer::new, 15 | 16 | UselessPopCleanTransformer::new 17 | ); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/reflects/loader/LTest.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.loader; 2 | 3 | import java.io.ByteArrayOutputStream; 4 | import java.io.InputStream; 5 | 6 | public class LTest { 7 | public int BRANCHLOCK_DOT_NET_DEMO; 8 | 9 | public static byte[] readAllBytes(InputStream var0) { 10 | ByteArrayOutputStream var1 = new ByteArrayOutputStream(); 11 | byte[] var2 = new byte[1024]; 12 | 13 | int var3; 14 | while ((var3 = var0.read(var2)) != -1) { 15 | var1.write(var2, 0, var3); 16 | } 17 | 18 | return var1.toByteArray(); 19 | } 20 | 21 | public void run() { 22 | System.out.println(new String(readAllBytes(LTest.class.getResourceAsStream("TEST")))); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/reflects/loader/LTest.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.loader; 2 | 3 | import java.io.ByteArrayOutputStream; 4 | import java.io.IOException; 5 | import java.io.InputStream; 6 | 7 | public class LTest { 8 | public static byte[] readAllBytes(InputStream var0) throws IOException { 9 | ByteArrayOutputStream var1 = new ByteArrayOutputStream(); 10 | byte[] var2 = new byte[1024]; 11 | 12 | int var3; 13 | while ((var3 = var0.read(var2)) != -1) { 14 | var1.write(var2, 0, var3); 15 | } 16 | 17 | return var1.toByteArray(); 18 | } 19 | 20 | public void run() throws Exception { 21 | System.out.println(new String(readAllBytes(LTest.class.getResourceAsStream("TEST")))); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/asm/matcher/impl/InsnMatch.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.asm.matcher.impl; 2 | 3 | import org.objectweb.asm.tree.AbstractInsnNode; 4 | import uwu.narumi.deobfuscator.api.asm.matcher.Match; 5 | import uwu.narumi.deobfuscator.api.asm.matcher.MatchContext; 6 | 7 | /** 8 | * Matches an instruction by its instance. 9 | */ 10 | public class InsnMatch extends Match { 11 | 12 | private final AbstractInsnNode node; 13 | 14 | private InsnMatch(AbstractInsnNode node) { 15 | this.node = node; 16 | } 17 | 18 | public static InsnMatch of(AbstractInsnNode node) { 19 | return new InsnMatch(node); 20 | } 21 | 22 | @Override 23 | protected boolean test(MatchContext context) { 24 | return this.node.equals(context.insn()); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/execution/ClasspathDataSupplier.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.execution; 2 | 3 | import dev.xdark.ssvm.classloading.SupplyingClassLoaderInstaller; 4 | import uwu.narumi.deobfuscator.api.classpath.ClassProvider; 5 | 6 | public class ClasspathDataSupplier implements SupplyingClassLoaderInstaller.DataSupplier { 7 | 8 | private final ClassProvider classpath; 9 | 10 | public ClasspathDataSupplier(ClassProvider classpath) { 11 | this.classpath = classpath; 12 | } 13 | 14 | @Override 15 | public byte[] getClass(String className) { 16 | return classpath.getClass(className.replace('.', '/')); 17 | } 18 | 19 | @Override 20 | public byte[] getResource(String resourcePath) { 21 | return classpath.getFile(resourcePath); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/basics/inner/Exec.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.inner; 2 | 3 | public class Exec { 4 | public int fuss = 1; 5 | public int BRANCHLOCK_DOT_NET_DEMO; 6 | 7 | public Exec(int var1) { 8 | } 9 | 10 | public void addF(int var1) { 11 | this.fuss += 2; 12 | } 13 | 14 | public class Inner { 15 | int i; 16 | final Exec this$0; 17 | public int BRANCHLOCK_DOT_NET_DEMO; 18 | 19 | public Inner(Exec var1, int var2, int var3) { 20 | this.this$0 = var1; 21 | this.i = var2; 22 | } 23 | 24 | public void doAdd(int var1) { 25 | this.this$0.addF(18951); 26 | this.this$0.fuss = this.this$0.fuss + this.i; 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /reverse-engineering/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 4.0.0 6 | 7 | uwu.narumi 8 | Diobfuscator 9 | 2.0-SNAPSHOT 10 | 11 | 12 | reverse-engineering 13 | 14 | 15 | 17 16 | 17 17 | UTF-8 18 | 19 | 20 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/basics/cross/Top.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.cross; 2 | 3 | public class Top extends Abst1 implements Inte { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public Top(int var1) { 7 | super(var1 ^ var1 ^ 4545); 8 | } 9 | 10 | public void run(int var1) { 11 | if (this.add(1, var1 ^ 29788, (var1 | var1 ^ 32383) & (var1 ^ 20415)) == (var1 ^ 29789) 12 | && this.mul(var1 ^ 29788, var1 ^ 29789, var1 ^ var1 ^ 16549) == (var1 ^ 29784)) { 13 | System.out.println(d[var1 ^ 29791]); 14 | } else { 15 | System.out.println(d[var1 ^ 29790]); 16 | } 17 | } 18 | 19 | @Override 20 | public int add(int var1, int var2, int var3) { 21 | return var1 + var2; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/reflects/loader/LTest.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.loader; 2 | 3 | import java.io.ByteArrayOutputStream; 4 | import java.io.IOException; 5 | import java.io.InputStream; 6 | 7 | public class LTest { 8 | public static byte[] readAllBytes(InputStream is) throws IOException { 9 | ByteArrayOutputStream baos = new ByteArrayOutputStream(); 10 | byte[] buffer = new byte[1024]; 11 | 12 | int bytesRead; 13 | while ((bytesRead = is.read(buffer)) != -1) { 14 | baos.write(buffer, 0, bytesRead); 15 | } 16 | 17 | return baos.toByteArray(); 18 | } 19 | 20 | public void run() throws Exception { 21 | System.out.println(new String(readAllBytes(LTest.class.getResourceAsStream("TEST")))); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/asm/matcher/impl/StringMatch.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.asm.matcher.impl; 2 | 3 | import uwu.narumi.deobfuscator.api.asm.matcher.Match; 4 | import uwu.narumi.deobfuscator.api.asm.matcher.MatchContext; 5 | 6 | public class StringMatch extends Match { 7 | 8 | private final String string; 9 | 10 | private StringMatch(String string) { 11 | this.string = string; 12 | } 13 | 14 | public static StringMatch of(String string) { 15 | return new StringMatch(string); 16 | } 17 | 18 | public static Match of() { 19 | return Match.of(context -> context.insn().isString()); 20 | } 21 | 22 | @Override 23 | protected boolean test(MatchContext context) { 24 | return context.insn().isString() && context.insn().asString().equals(string); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/asm/matcher/impl/RangeOpcodeMatch.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.asm.matcher.impl; 2 | 3 | import uwu.narumi.deobfuscator.api.asm.matcher.Match; 4 | import uwu.narumi.deobfuscator.api.asm.matcher.MatchContext; 5 | 6 | public class RangeOpcodeMatch extends Match { 7 | private final int start; 8 | private final int end; 9 | 10 | private RangeOpcodeMatch(int start, int end) { 11 | this.start = start; 12 | this.end = end; 13 | } 14 | 15 | public static RangeOpcodeMatch of(int startingOpcode, int endingOpcode) { 16 | return new RangeOpcodeMatch(startingOpcode, endingOpcode); 17 | } 18 | 19 | @Override 20 | protected boolean test(MatchContext context) { 21 | return context.insn().getOpcode() >= start && context.insn().getOpcode() <= end; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/impl/clean/LineNumberCleanTransformer.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.core.other.impl.clean; 2 | 3 | import java.util.Arrays; 4 | 5 | import org.objectweb.asm.tree.LineNumberNode; 6 | import uwu.narumi.deobfuscator.api.transformer.Transformer; 7 | 8 | public class LineNumberCleanTransformer extends Transformer { 9 | 10 | @Override 11 | protected void transform() throws Exception { 12 | scopedClasses().forEach(classWrapper -> classWrapper.methods().forEach(methodNode -> { 13 | Arrays.stream(methodNode.instructions.toArray()) 14 | .filter(node -> node instanceof LineNumberNode) 15 | .forEach(node -> { 16 | methodNode.instructions.remove(node); 17 | this.markChange(); 18 | }); 19 | })); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/reflects/annot/annot.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.annot; 2 | 3 | import java.lang.reflect.Method; 4 | 5 | public class annot { 6 | public int BRANCHLOCK_DOT_NET_DEMO; 7 | 8 | public annot(int var1) { 9 | } 10 | 11 | public void run(int var1) { 12 | annoe var2 = new annoe(8983); 13 | 14 | for (Method var6 : annoe.class.getDeclaredMethods()) { 15 | var6.setAccessible(true); 16 | anno var7 = var6.getAnnotation(anno.class); 17 | 18 | while (var1 < 0 || var7 != null && var1 >= 0 && var7.val().equals("yes")) { 19 | var6.invoke(var2); 20 | if (var1 >= 0) { 21 | break; 22 | } 23 | } 24 | } 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/classpath/InheritanceClassWriter.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.classpath; 2 | 3 | import org.objectweb.asm.ClassWriter; 4 | import uwu.narumi.deobfuscator.api.inheritance.InheritanceGraph; 5 | 6 | /** 7 | * A {@link ClassWriter} that uses a {@link InheritanceGraph} to determine the common superclass of two classes. 8 | */ 9 | public class InheritanceClassWriter extends ClassWriter { 10 | private final InheritanceGraph inheritanceGraph; 11 | 12 | public InheritanceClassWriter(int flags, InheritanceGraph inheritanceGraph) { 13 | super(flags); 14 | this.inheritanceGraph = inheritanceGraph; 15 | } 16 | 17 | @Override 18 | protected String getCommonSuperClass(String first, String second) { 19 | return this.inheritanceGraph.getCommon(first, second); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/reflects/annot/annoe.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.annot; 2 | 3 | import java.lang.reflect.Field; 4 | 5 | public class annoe { 6 | @anno( 7 | val = "PASS" 8 | ) 9 | private static final String fail = "WHAT"; 10 | 11 | @anno 12 | public void dox() throws Exception { 13 | String toGet = "FAIL"; 14 | 15 | for (Field f : annoe.class.getDeclaredFields()) { 16 | f.setAccessible(true); 17 | anno obj = f.getAnnotation(anno.class); 18 | if (obj != null) { 19 | toGet = obj.val(); 20 | } 21 | } 22 | 23 | System.out.println(toGet); 24 | } 25 | 26 | @anno( 27 | val = "no" 28 | ) 29 | public void dov() { 30 | System.out.println("FAIL"); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/reflects/annot/annoe.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.annot; 2 | 3 | import java.lang.reflect.Field; 4 | 5 | public class annoe { 6 | @anno( 7 | val = "PASS" 8 | ) 9 | private static final String fail = "WHAT"; 10 | 11 | @anno 12 | public void dox() throws Exception { 13 | String var1 = "FAIL"; 14 | 15 | for (Field var5 : annoe.class.getDeclaredFields()) { 16 | var5.setAccessible(true); 17 | anno var6 = var5.getAnnotation(anno.class); 18 | if (var6 != null) { 19 | var1 = var6.val(); 20 | } 21 | } 22 | 23 | System.out.println(var1); 24 | } 25 | 26 | @anno( 27 | val = "no" 28 | ) 29 | public void dov() { 30 | System.out.println("FAIL"); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/basics/ctrl/Ctrl.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.ctrl; 2 | 3 | public class Ctrl { 4 | private String ret = "FAIL"; 5 | public String BRANCHLOCK_DOT_NET_DEMO; 6 | 7 | public Ctrl(int var1) { 8 | } 9 | 10 | public void runt(int var1) { 11 | if (var1 >= 0) { 12 | throw new UnsupportedOperationException(); 13 | } 14 | } 15 | 16 | public void runf(int var1) { 17 | this.runt(29872); 18 | 19 | try { 20 | this.runt(29872); 21 | this.ret = "FAIL"; 22 | } catch (Exception var2) { 23 | } 24 | } 25 | 26 | public void run(int var1) { 27 | do { 28 | this.runf(950); 29 | System.out.println(this.ret); 30 | } while (var1 < 0); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /testData/results/custom-classes/sb27/sample1/ConfigComplete.dec: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.List; 3 | import org.bukkit.command.Command; 4 | import org.bukkit.command.CommandSender; 5 | import org.bukkit.command.TabCompleter; 6 | import org.bukkit.util.StringUtil; 7 | 8 | public class ConfigComplete implements TabCompleter { 9 | public List onTabComplete(CommandSender var1, Command var2, String var3, String[] var4) { 10 | ArrayList var5 = new ArrayList(); 11 | ArrayList var6 = new ArrayList(); 12 | if (var4.length == 1) { 13 | var6.add("doBedExplode"); 14 | var6.add("doBrutesSpawn"); 15 | var6.add("oldPiglinDrop"); 16 | var6.add("compassOnRespawn"); 17 | StringUtil.copyPartialMatches(var4[0], var6, var5); 18 | } 19 | 20 | return var5; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/reflects/res/Accesor.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.res; 2 | 3 | public class Accesor { 4 | public void run() { 5 | try { 6 | if (Accesor.class.getResourceAsStream("/pack/tests/reflects/res/file").read() != 97) { 7 | throw new RuntimeException(); 8 | } 9 | 10 | if (Accesor.class.getResourceAsStream("file2").read() != 114) { 11 | throw new RuntimeException(); 12 | } 13 | 14 | if (Accesor.class.getClassLoader().getResourceAsStream("pack/tests/reflects/res/file3").read() != 99) { 15 | throw new RuntimeException(); 16 | } 17 | 18 | System.out.println("PASS"); 19 | } catch (Exception var2) { 20 | System.out.println("FAIL"); 21 | } 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/reflects/annot/annot.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.annot; 2 | 3 | import java.lang.reflect.Method; 4 | import pack.tests.reflects.counter.Countee; 5 | import pack.tests.reflects.retrace.Tracer; 6 | 7 | public class annot { 8 | public void run() throws Exception { 9 | annoe var1 = new annoe(); 10 | 11 | for (Method var5 : annoe.class.getDeclaredMethods()) { 12 | var5.setAccessible(true); 13 | anno var6 = var5.getAnnotation(anno.class); 14 | if (var6 != null && var6.val().equals("yes")) { 15 | var5.invoke(var1); 16 | } 17 | } 18 | } 19 | 20 | public static Throwable I(Throwable var0) { 21 | if (Tracer.I == null) { 22 | Countee.I = var0; 23 | } 24 | 25 | return var0; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /testData/results/custom-jars/grunt-obf/com/top1/Main$processor$ConstantPool.dec: -------------------------------------------------------------------------------- 1 | package com.top1; 2 | 3 | public final class Main$processor$ConstantPool { 4 | public static String const_nmionQdI1EMWwVW = Sh4GunDo6B(Re3Shyl1Rd("یۡۨۨ۫ڤۥ۪۠ڤ۳ۡۨۧ۫۩ۡڥ")); 5 | 6 | private static String Sh4GunDo6B(String var0) { 7 | StringBuilder var1 = new StringBuilder(); 8 | 9 | for (int var2 = 0; var2 < var0.length(); var2++) { 10 | var1.append((char)(var0.charAt(var2) ^ 2043)); 11 | } 12 | 13 | return var1.toString(); 14 | } 15 | 16 | private static String Re3Shyl1Rd(String var0) { 17 | StringBuilder var1 = new StringBuilder(); 18 | 19 | for (int var2 = 0; var2 < var0.length(); var2++) { 20 | var1.append((char)(var0.charAt(var2) ^ 1215)); 21 | } 22 | 23 | return var1.toString(); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/basics/overwirte/Sub.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.overwirte; 2 | 3 | public class Sub extends Super { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public Sub(int var1) { 7 | super(4305); 8 | } 9 | 10 | @Override 11 | public void run(int var1) { 12 | System.out.println(this.face(1, 6600)); 13 | } 14 | 15 | @Override 16 | public String face(int var1, int var2) { 17 | if (var1 == 1) { 18 | return "PASS"; 19 | } else { 20 | while (var2 < 0) { 21 | } 22 | 23 | return "FAIL"; 24 | } 25 | } 26 | 27 | public static Throwable m(Throwable var0) { 28 | if (Super.m == null) { 29 | Super.m = var0; 30 | } 31 | 32 | return var0; 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/asm/FieldRef.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.asm; 2 | 3 | import org.objectweb.asm.tree.ClassNode; 4 | import org.objectweb.asm.tree.FieldInsnNode; 5 | import org.objectweb.asm.tree.FieldNode; 6 | 7 | /** 8 | * @param owner Class that owns this field 9 | * @param name Field's name 10 | * @param desc Field's descriptor 11 | */ 12 | public record FieldRef(String owner, String name, String desc) { 13 | public static FieldRef of(ClassNode classNode, FieldNode fieldNode) { 14 | return new FieldRef(classNode.name, fieldNode.name, fieldNode.desc); 15 | } 16 | 17 | public static FieldRef of(FieldInsnNode fieldInsn) { 18 | return new FieldRef(fieldInsn.owner, fieldInsn.name, fieldInsn.desc); 19 | } 20 | 21 | @Override 22 | public String toString() { 23 | return owner + "." + name + desc; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/impl/clean/peephole/NopCleanTransformer.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.core.other.impl.clean.peephole; 2 | 3 | import java.util.Arrays; 4 | 5 | import uwu.narumi.deobfuscator.api.transformer.Transformer; 6 | 7 | public class NopCleanTransformer extends Transformer { 8 | 9 | @Override 10 | protected void transform() throws Exception { 11 | scopedClasses().stream() 12 | .flatMap(classWrapper -> classWrapper.methods().stream()) 13 | .forEach( 14 | methodNode -> 15 | Arrays.stream(methodNode.instructions.toArray()) 16 | .filter(node -> node.getOpcode() == NOP) 17 | .forEach(node -> { 18 | methodNode.instructions.remove(node); 19 | this.markChange(); 20 | })); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/basics/inner/Exec.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.inner; 2 | 3 | public class Exec { 4 | public int fuss = 1; 5 | public int BRANCHLOCK_DOT_NET_DEMO; 6 | 7 | public Exec(int var1) { 8 | } 9 | 10 | public void addF(int var1) { 11 | do { 12 | this.fuss += 2; 13 | } while (var1 < 0); 14 | } 15 | 16 | public class Inner { 17 | int i; 18 | final Exec this$0; 19 | public int BRANCHLOCK_DOT_NET_DEMO; 20 | 21 | public Inner(Exec var1, int var2, int var3) { 22 | this.this$0 = var1; 23 | this.i = var2; 24 | } 25 | 26 | public void doAdd(int var1) { 27 | do { 28 | this.this$0.fuss = this.this$0.fuss + this.i; 29 | } while (var1 < 0); 30 | } 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /deobfuscator-impl/src/test/java/uwu/narumi/deobfuscator/transformer/TestSandboxSecurityTransformer.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.transformer; 2 | 3 | import dev.xdark.ssvm.execution.VMException; 4 | import dev.xdark.ssvm.mirror.type.InstanceClass; 5 | import uwu.narumi.deobfuscator.api.execution.SandBox; 6 | import uwu.narumi.deobfuscator.api.transformer.Transformer; 7 | 8 | import static org.junit.jupiter.api.Assertions.assertThrows; 9 | 10 | public class TestSandboxSecurityTransformer extends Transformer { 11 | @Override 12 | protected void transform() throws Exception { 13 | SandBox sandBox = context().getSandBox(); 14 | InstanceClass clazz = sandBox.getHelper().loadClass("sandbox.TestSandboxSecurity"); 15 | 16 | assertThrows(VMException.class, () -> { 17 | sandBox.getInvocationUtil().invokeInt( 18 | clazz.getMethod("test", "()I") 19 | ); 20 | }); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/asm/matcher/impl/ClassTypeMatch.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.asm.matcher.impl; 2 | 3 | import org.objectweb.asm.tree.AbstractInsnNode; 4 | import uwu.narumi.deobfuscator.api.asm.matcher.Match; 5 | import uwu.narumi.deobfuscator.api.asm.matcher.MatchContext; 6 | 7 | /** 8 | * Matches by instruction class type 9 | */ 10 | public class ClassTypeMatch extends Match { 11 | 12 | private final Class classType; 13 | 14 | private ClassTypeMatch(Class classType) { 15 | this.classType = classType; 16 | } 17 | 18 | public static ClassTypeMatch of(Class classType) { 19 | return new ClassTypeMatch(classType); 20 | } 21 | 22 | @Override 23 | protected boolean test(MatchContext context) { 24 | return context.insn().getClass().equals(classType); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /testData/src/java/src/main/java/TestInlineStaticFieldsWithModification.java: -------------------------------------------------------------------------------- 1 | import java.io.File; 2 | 3 | public class TestInlineStaticFieldsWithModification { 4 | private static final char SYSTEM_SEPARATOR = File.separatorChar; 5 | private static final char OTHER_SEPARATOR; 6 | 7 | private static int getAdsCriticalOffset(String fileName) { 8 | int offset1 = fileName.lastIndexOf(SYSTEM_SEPARATOR); 9 | int offset2 = fileName.lastIndexOf(OTHER_SEPARATOR); 10 | if (offset1 == -1) { 11 | return offset2 == -1 ? 0 : offset2 + 1; 12 | } else { 13 | return offset2 == -1 ? offset1 + 1 : Math.max(offset1, offset2) + 1; 14 | } 15 | } 16 | 17 | static { 18 | if (isSystemWindows()) { 19 | OTHER_SEPARATOR = '/'; 20 | } else { 21 | OTHER_SEPARATOR = '\\'; 22 | } 23 | } 24 | 25 | static boolean isSystemWindows() { 26 | return SYSTEM_SEPARATOR == '\\'; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/tests/reflects/annot/annoe.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.annot; 2 | 3 | import java.io.PrintStream; 4 | import java.lang.reflect.Field; 5 | 6 | public class annoe { 7 | @anno( 8 | val = "PASS" 9 | ) 10 | private static final String fail = "WHAT"; 11 | 12 | @anno 13 | public void dox() throws Exception { 14 | String var3 = "FAIL"; 15 | 16 | for (Field var7 : annoe.class.getDeclaredFields()) { 17 | var7.setAccessible(true); 18 | anno var8 = var7.getAnnotation(anno.class); 19 | if (var8 != null) { 20 | var3 = var8.val(); 21 | } 22 | } 23 | 24 | PrintStream var15 = System.out; 25 | var15.println(var3); 26 | } 27 | 28 | @anno( 29 | val = "no" 30 | ) 31 | public void dov() { 32 | System.out.println("FAIL"); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/basics/ctrl/Ctrl.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.ctrl; 2 | 3 | public class Ctrl { 4 | private String ret = "FAIL"; 5 | public int BRANCHLOCK_DOT_NET_DEMO; 6 | 7 | public Ctrl(int var1) { 8 | } 9 | 10 | public void runt(int var1) { 11 | if (!"a".equals("b")) { 12 | throw new UnsupportedOperationException(); 13 | } 14 | } 15 | 16 | public void runf(int var1) { 17 | try { 18 | this.runt(8206); 19 | } catch (RuntimeException var3) { 20 | this.ret = "PASS"; 21 | } 22 | 23 | try { 24 | this.runt(8206); 25 | this.ret = "FAIL"; 26 | } catch (Exception var2) { 27 | } 28 | } 29 | 30 | public void run(int var1) { 31 | this.runf(13495); 32 | System.out.println(this.ret); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/reflects/annot/annoe.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.annot; 2 | 3 | import java.lang.reflect.Field; 4 | 5 | public class annoe { 6 | @anno( 7 | val = "PASS" 8 | ) 9 | private static final String fail = "WHAT"; 10 | public int BRANCHLOCK_DOT_NET_DEMO; 11 | public static Throwable P; 12 | 13 | @anno 14 | public void dox() { 15 | String var1 = "FAIL"; 16 | 17 | for (Field var5 : annoe.class.getDeclaredFields()) { 18 | var5.setAccessible(true); 19 | anno var6 = var5.getAnnotation(anno.class); 20 | if (var6 != null) { 21 | var1 = var6.val(); 22 | } 23 | } 24 | 25 | System.out.println(var1); 26 | } 27 | 28 | @anno( 29 | val = "no" 30 | ) 31 | public void dov() { 32 | System.out.println("FAIL"); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/tests/reflects/retrace/Tracee.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.retrace; 2 | 3 | import java.lang.reflect.Method; 4 | 5 | public class Tracee { 6 | public static int p = 0; 7 | 8 | private void doTrace(int var1, int var2) throws Exception { 9 | p++; 10 | Throwable var11 = new Throwable(); 11 | String var19 = var11.getStackTrace()[1].getMethodName(); 12 | Class[] var21 = new Class[1]; 13 | Class var7 = int.class; 14 | var21[0] = var7; 15 | Method var15 = Tracee.class.getDeclaredMethod(var19, var21); 16 | Object[] var23 = new Object[1]; 17 | Integer var27 = var1 - 1; 18 | var23[0] = var27; 19 | var15.invoke(this, var23); 20 | } 21 | 22 | public void toTrace(int var1, int var2) throws Exception { 23 | if (var1 != 0) { 24 | this.doTrace(var1, 2090156866); 25 | } 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/reflects/loader/LTest.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.loader; 2 | 3 | import java.io.ByteArrayOutputStream; 4 | import java.io.InputStream; 5 | 6 | public class LTest { 7 | public int BRANCHLOCK_DOT_NET_DEMO; 8 | 9 | public LTest(int var1) { 10 | } 11 | 12 | public static byte[] readAllBytes(InputStream var0, int var1) { 13 | ByteArrayOutputStream var2 = new ByteArrayOutputStream(); 14 | byte[] var3 = new byte[var1 ^ 27268]; 15 | 16 | int var4; 17 | while ((var4 = var0.read(var3)) != (var1 ^ -28293)) { 18 | var2.write(var3, 0, var4); 19 | } 20 | 21 | return var2.toByteArray(); 22 | } 23 | 24 | public void run(int var1) { 25 | System.out.println(new String(readAllBytes(LTest.class.getResourceAsStream(d[var1 ^ 12433]), (var1 | var1 ^ 32405) & (var1 ^ 24447)))); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/reflects/annot/annoe.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.annot; 2 | 3 | import java.lang.reflect.Field; 4 | 5 | public class annoe { 6 | @anno( 7 | val = "PASS" 8 | ) 9 | private static final String fail = "WHAT"; 10 | public int BRANCHLOCK_DOT_NET_DEMO; 11 | 12 | public annoe(int var1) { 13 | } 14 | 15 | @anno 16 | public void dox() { 17 | String var1 = "FAIL"; 18 | 19 | for (Field var5 : annoe.class.getDeclaredFields()) { 20 | var5.setAccessible(true); 21 | anno var6 = var5.getAnnotation(anno.class); 22 | if (var6 != null) { 23 | var1 = var6.val(); 24 | } 25 | } 26 | 27 | System.out.println(var1); 28 | } 29 | 30 | @anno( 31 | val = "no" 32 | ) 33 | public void dov() { 34 | System.out.println("FAIL"); 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/reflects/annot/annoe.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.annot; 2 | 3 | import java.lang.reflect.Field; 4 | 5 | public class annoe { 6 | @anno( 7 | val = "PASS" 8 | ) 9 | private static final String fail = "WHAT"; 10 | public int BRANCHLOCK_DOT_NET_DEMO; 11 | 12 | public annoe(int var1) { 13 | } 14 | 15 | @anno 16 | public void dox() { 17 | String var1 = "FAIL"; 18 | 19 | for (Field var5 : annoe.class.getDeclaredFields()) { 20 | var5.setAccessible(true); 21 | anno var6 = var5.getAnnotation(anno.class); 22 | if (var6 != null) { 23 | var1 = var6.val(); 24 | } 25 | } 26 | 27 | System.out.println(var1); 28 | } 29 | 30 | @anno( 31 | val = "no" 32 | ) 33 | public void dov() { 34 | System.out.println("FAIL"); 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/composed/ComposedUnknownObf1Transformer.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.core.other.composed; 2 | 3 | import uwu.narumi.deobfuscator.api.transformer.ComposedTransformer; 4 | import uwu.narumi.deobfuscator.core.other.composed.general.ComposedGeneralFlowTransformer; 5 | import uwu.narumi.deobfuscator.core.other.impl.clean.LocalVariableNamesCleanTransformer; 6 | import uwu.narumi.deobfuscator.core.other.impl.unknown.obf1.UnknownObf1_StringByteArrayTransformer; 7 | 8 | public class ComposedUnknownObf1Transformer extends ComposedTransformer { 9 | public ComposedUnknownObf1Transformer() { 10 | super( 11 | // Remove local variables names 12 | LocalVariableNamesCleanTransformer::new, 13 | 14 | // Fix flow 15 | ComposedGeneralFlowTransformer::new, 16 | 17 | // Decrypt strings 18 | UnknownObf1_StringByteArrayTransformer::new 19 | ); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /testData/results/custom-classes/zkm/sample2/a/a/a/a/bc.dec: -------------------------------------------------------------------------------- 1 | package a.a.a.a; 2 | 3 | public final class bc extends ba { 4 | private static final long serialVersionUID = 1L; 5 | 6 | public static bc a(int var0, long var1, int var3) { 7 | var1 = 90497055901648L ^ var1; 8 | long var5 = var1 ^ 32932499080870L; 9 | return b(new Object[]{var0, var5, var3}); 10 | } 11 | 12 | public static bc b(Integer var0, long var1, Integer var3) { 13 | var1 = 90497055901648L ^ var1; 14 | int var5 = (int)((var1 ^ 61248110729654L) >>> 56); 15 | long var6 = (var1 ^ 61248110729654L) << 8 >>> 8; 16 | return new bc((byte)var5, var0, var3, var6); 17 | } 18 | 19 | private bc(byte var1, Integer var2, Integer var3, long var4) { 20 | long var6 = ((long)var1 << 56 | var4 << 8 >>> 8) ^ 90497055901648L; 21 | long var8 = var6 ^ 83241345321299L; 22 | super(var8, var2, var3, null); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/reflects/retrace/Tracer.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.retrace; 2 | 3 | public class Tracer { 4 | public String BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public Tracer(int var1) { 7 | } 8 | 9 | // $VF: Irreducible bytecode was duplicated to produce valid code 10 | public void run(int var1) { 11 | while (true) { 12 | new Tracee(29130).toTrace(5); 13 | if (var1 < 0 || Tracee.p == 5) { 14 | if (var1 >= 0) { 15 | System.out.println("PASS"); 16 | } 17 | 18 | if (var1 >= 0) { 19 | return; 20 | } 21 | } 22 | 23 | while (var1 >= 0) { 24 | System.out.println("FAIL"); 25 | if (var1 >= 0) { 26 | return; 27 | } 28 | } 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /deobfuscator-impl/src/test/java/Bootstrap.java: -------------------------------------------------------------------------------- 1 | import java.nio.file.Path; 2 | import org.objectweb.asm.ClassWriter; 3 | import uwu.narumi.deobfuscator.Deobfuscator; 4 | import uwu.narumi.deobfuscator.api.context.DeobfuscatorOptions; 5 | import uwu.narumi.deobfuscator.core.other.composed.general.ComposedGeneralFlowTransformer; 6 | 7 | public class Bootstrap { 8 | 9 | public static void main(String[] args) { 10 | Deobfuscator.from( 11 | DeobfuscatorOptions.builder() 12 | .inputJar(Path.of("work", "obf-test.jar")) // Specify your input jar here 13 | //.libraries(Path.of("work", "libs")) // Specify your libraries here if needed 14 | .transformers( 15 | // Pick your transformers here 16 | () -> new ComposedGeneralFlowTransformer() 17 | ) 18 | .continueOnError() 19 | .classWriterFlags(ClassWriter.COMPUTE_FRAMES) 20 | .build() 21 | ).start(); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /reverse-engineering/src/main/java/zelix/longdecrypter/Main.java: -------------------------------------------------------------------------------- 1 | package zelix.longdecrypter; 2 | 3 | import java.lang.invoke.MethodHandles; 4 | 5 | public class Main { 6 | // Usage 7 | 8 | public static void main(String[] args) { 9 | // decrypterA must be decrypted first for decrypterB to be decrypted correctly. So there is specific decryption order: 10 | // decrypterA -> decrypterB 11 | ILongDecrypter decrypterA = SimpleLongDecrypter.buildNumberDecryptor(273921918217628048L, -8431841081763909460L, MethodHandles.lookup().lookupClass()); 12 | System.out.println(decrypterA); 13 | long a = decrypterA.decrypt(36730249601911L); 14 | System.out.println(a); 15 | 16 | ILongDecrypter decrypterB = SimpleLongDecrypter.buildNumberDecryptor(-5385547845782035026L, 2563870759759473543L, MethodHandles.lookup().lookupClass()); 17 | System.out.println(decrypterB); 18 | long b = decrypterB.decrypt(130571778689313L); 19 | System.out.println(b); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /testData/results/java/TestInlineStaticFieldsWithModification.dec: -------------------------------------------------------------------------------- 1 | import java.io.File; 2 | 3 | public class TestInlineStaticFieldsWithModification { 4 | private static final char SYSTEM_SEPARATOR = File.separatorChar; 5 | private static final char OTHER_SEPARATOR; 6 | 7 | private static int getAdsCriticalOffset(String fileName) { 8 | int offset1 = fileName.lastIndexOf(SYSTEM_SEPARATOR); 9 | int offset2 = fileName.lastIndexOf(OTHER_SEPARATOR); 10 | if (offset1 == -1) { 11 | return offset2 == -1 ? 0 : offset2 + 1; 12 | } else { 13 | return offset2 == -1 ? offset1 + 1 : Math.max(offset1, offset2) + 1; 14 | } 15 | } 16 | 17 | static boolean isSystemWindows() { 18 | return SYSTEM_SEPARATOR == '\\'; 19 | } 20 | 21 | static { 22 | if (isSystemWindows()) { 23 | OTHER_SEPARATOR = '/'; 24 | } else { 25 | OTHER_SEPARATOR = '\\'; 26 | } 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/asm/matcher/impl/NewArrayMatch.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.asm.matcher.impl; 2 | 3 | import org.objectweb.asm.Opcodes; 4 | import org.objectweb.asm.tree.IntInsnNode; 5 | import uwu.narumi.deobfuscator.api.asm.matcher.Match; 6 | import uwu.narumi.deobfuscator.api.asm.matcher.MatchContext; 7 | 8 | public class NewArrayMatch extends Match { 9 | // https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-6.html#jvms-6.5.newarray 10 | private final int arrayTypeCode; // Example: Opcodes.T_INT 11 | 12 | private NewArrayMatch(int arrayTypeCode) { 13 | this.arrayTypeCode = arrayTypeCode; 14 | } 15 | 16 | public static NewArrayMatch of(int operand) { 17 | return new NewArrayMatch(operand); 18 | } 19 | 20 | @Override 21 | protected boolean test(MatchContext context) { 22 | return context.insn().getOpcode() == Opcodes.NEWARRAY && ((IntInsnNode) context.insn()).operand == this.arrayTypeCode; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/basics/inner/Test.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.inner; 2 | 3 | public class Test { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public Test(int var1) { 7 | } 8 | 9 | // $VF: Irreducible bytecode was duplicated to produce valid code 10 | public void run(int var1) { 11 | Exec var2 = new Exec(20620); 12 | Exec.Inner var3 = var2.new Inner(var2, 3, 22005); 13 | var3.doAdd(15352); 14 | Exec.Inner var4 = var2.new Inner(var2, 100, 22005); 15 | if (var1 >= 0) { 16 | do { 17 | var4.doAdd(15352); 18 | } while (var1 < 0); 19 | } 20 | 21 | if (var2.fuss == 108) { 22 | System.out.println("PASS"); 23 | } else { 24 | System.out.println("ERROR"); 25 | } 26 | 27 | while (var1 < 0) { 28 | System.out.println("PASS"); 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/reflects/res/Accesor.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.res; 2 | 3 | public class Accesor { 4 | public int BRANCHLOCK_DOT_NET_DEMO; 5 | 6 | public Accesor(int var1) { 7 | } 8 | 9 | public void run(int var1) { 10 | try { 11 | if (Accesor.class.getResourceAsStream("/pack/tests/reflects/res/file").read() != 97) { 12 | throw new RuntimeException(); 13 | } 14 | 15 | if (Accesor.class.getResourceAsStream("file2").read() != 114) { 16 | throw new RuntimeException(); 17 | } 18 | 19 | if (Accesor.class.getClassLoader().getResourceAsStream("pack/tests/reflects/res/file3").read() != 99) { 20 | throw new RuntimeException(); 21 | } 22 | 23 | System.out.println("PASS"); 24 | } catch (Exception var2) { 25 | System.out.println("FAIL"); 26 | } 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-flow-number/pack/tests/reflects/loader/Loader.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.loader; 2 | 3 | import java.io.ByteArrayInputStream; 4 | import java.io.InputStream; 5 | 6 | public class Loader extends ClassLoader { 7 | public int BRANCHLOCK_DOT_NET_DEMO; 8 | 9 | public Loader(int var1) { 10 | } 11 | 12 | public static byte[] readAllBytes(InputStream var0, int var1) { 13 | while (true) { 14 | } 15 | } 16 | 17 | @Override 18 | public InputStream getResourceAsStream(String var1) { 19 | return (InputStream)(var1.contains("TEST") ? new ByteArrayInputStream("PASS".getBytes()) : super.getResourceAsStream(var1)); 20 | } 21 | 22 | @Override 23 | public Class findClass(String var1) { 24 | byte[] var2 = readAllBytes(Loader.class.getClassLoader().getResourceAsStream("pack/tests/reflects/loader/LTest.class"), 20488); 25 | return this.defineClass(var1, var2, 0, var2.length); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/impl/exploit/WebExploitRemoveTransformer.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.core.other.impl.exploit; 2 | 3 | import uwu.narumi.deobfuscator.api.transformer.Transformer; 4 | 5 | public class WebExploitRemoveTransformer extends Transformer { 6 | 7 | private boolean changed = false; 8 | 9 | @Override 10 | protected void transform() throws Exception { 11 | changed |= context().getClassesMap().entrySet().removeIf(entry -> entry.getKey().contains("")); 12 | changed |= context().getFilesMap().entrySet().removeIf(entry -> entry.getKey().contains("")); 13 | 14 | scopedClasses().forEach(classWrapper -> { 15 | changed |= classWrapper.methods().removeIf(methodNode -> methodNode.name.contains("")); 16 | changed |= classWrapper.fields().removeIf(fieldNode -> fieldNode.name.contains("") || fieldNode.desc.contains("")); 17 | }); 18 | 19 | if (changed) { 20 | markChange(); 21 | } 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/transformer/VersionedComposedTransformer.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.transformer; 2 | 3 | import java.util.List; 4 | import java.util.Map; 5 | import java.util.function.Supplier; 6 | 7 | public abstract class VersionedComposedTransformer extends Transformer { 8 | 9 | private final String version; 10 | 11 | public VersionedComposedTransformer(String version) { 12 | this.version = version; 13 | } 14 | 15 | @Override 16 | protected void transform() { 17 | Map>> transformers = transformersByVersions(); 18 | if (!transformers.containsKey(version)) { 19 | throw new IllegalArgumentException(String.format("Version '%s' not found!", version)); 20 | } 21 | 22 | transformers 23 | .get(version) 24 | .forEach(transformer -> this.changes.addAndGet(Transformer.transform(transformer, scope(), context()))); 25 | } 26 | 27 | public abstract Map>> transformersByVersions(); 28 | } 29 | -------------------------------------------------------------------------------- /deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/impl/universal/UniversalFlowTransformer.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.core.other.impl.universal; 2 | 3 | import uwu.narumi.deobfuscator.api.transformer.ComposedTransformer; 4 | import uwu.narumi.deobfuscator.core.other.impl.clean.peephole.DeadCodeCleanTransformer; 5 | import uwu.narumi.deobfuscator.core.other.impl.universal.flow.CleanRedundantJumpsTransformer; 6 | import uwu.narumi.deobfuscator.core.other.impl.universal.flow.CleanRedundantSwitchesTransformer; 7 | 8 | public class UniversalFlowTransformer extends ComposedTransformer { 9 | public UniversalFlowTransformer() { 10 | super( 11 | // Clean up redundant ifs and switches 12 | CleanRedundantJumpsTransformer::new, 13 | CleanRedundantSwitchesTransformer::new, 14 | 15 | // Resolve all number operations 16 | UniversalNumberTransformer::new, 17 | 18 | // Last thing will be to clean up all dead code that is unreachable 19 | DeadCodeCleanTransformer::new 20 | ); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/transformer/ComposedTransformer.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.transformer; 2 | 3 | import java.util.List; 4 | import java.util.function.Supplier; 5 | 6 | import org.jetbrains.annotations.Nullable; 7 | 8 | public class ComposedTransformer extends Transformer { 9 | 10 | private final List> transformers; 11 | 12 | @SafeVarargs 13 | public ComposedTransformer(Supplier<@Nullable Transformer>... transformers) { 14 | this.transformers = List.of(transformers); 15 | } 16 | 17 | @SafeVarargs 18 | public ComposedTransformer(boolean rerunOnChange, Supplier... transformers) { 19 | this.transformers = List.of(transformers); 20 | this.rerunOnChange = rerunOnChange; 21 | } 22 | 23 | @Override 24 | protected void transform() { 25 | transformers.forEach(transformerSupplier -> { 26 | int changesCount = Transformer.transform(transformerSupplier, scope(), context()); 27 | this.changes.addAndGet(changesCount); 28 | }); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/classpath/ClassProvider.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.classpath; 2 | 3 | import org.jetbrains.annotations.Nullable; 4 | import org.objectweb.asm.tree.ClassNode; 5 | 6 | import java.util.Collection; 7 | 8 | public interface ClassProvider { 9 | /** 10 | * Gets class bytes by internal name 11 | * 12 | * @param name Internal name of class 13 | * @return Class bytes 14 | */ 15 | byte @Nullable [] getClass(String name); 16 | 17 | /** 18 | * Gets file bytes by name 19 | * 20 | * @param path File path 21 | * @return File bytes 22 | */ 23 | byte @Nullable [] getFile(String path); 24 | 25 | /** 26 | * Gets class node that holds only the class information. It is not guaranteed that the class holds code. 27 | * 28 | * @param name Internal name of class 29 | * @return Class node 30 | */ 31 | @Nullable 32 | ClassNode getClassInfo(String name); 33 | 34 | /** 35 | * Gets all classes in the provider. 36 | */ 37 | Collection getLoadedClasses(); 38 | } 39 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/asm/MethodRef.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.asm; 2 | 3 | import org.objectweb.asm.Handle; 4 | import org.objectweb.asm.tree.ClassNode; 5 | import org.objectweb.asm.tree.MethodInsnNode; 6 | import org.objectweb.asm.tree.MethodNode; 7 | 8 | /** 9 | * @param owner Class that owns this method 10 | * @param name Method's name 11 | * @param desc Method's descriptor 12 | */ 13 | public record MethodRef(String owner, String name, String desc) { 14 | public static MethodRef of(ClassNode classNode, MethodNode methodNode) { 15 | return new MethodRef(classNode.name, methodNode.name, methodNode.desc); 16 | } 17 | 18 | public static MethodRef of(MethodInsnNode methodInsn) { 19 | return new MethodRef(methodInsn.owner, methodInsn.name, methodInsn.desc); 20 | } 21 | 22 | public static MethodRef of(Handle handle) { 23 | return new MethodRef(handle.getOwner(), handle.getName(), handle.getDesc()); 24 | } 25 | 26 | @Override 27 | public String toString() { 28 | return owner + "." + name + desc; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/tests/reflects/loader/LTest.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.loader; 2 | 3 | import java.io.ByteArrayOutputStream; 4 | import java.io.IOException; 5 | import java.io.InputStream; 6 | import java.io.PrintStream; 7 | 8 | public class LTest { 9 | public static byte[] readAllBytes(InputStream var0, int var1) throws IOException { 10 | ByteArrayOutputStream var2 = new ByteArrayOutputStream(); 11 | ByteArrayOutputStream var5 = var2; 12 | byte[] var6 = new byte[1024]; 13 | 14 | while (true) { 15 | int var11 = var0.read(var6); 16 | if (var11 == -1) { 17 | return var5.toByteArray(); 18 | } 19 | 20 | var5.write(var6, 0, var11); 21 | } 22 | } 23 | 24 | public void run() throws Exception { 25 | PrintStream var1 = System.out; 26 | String var4 = "TEST"; 27 | byte[] var6 = readAllBytes(LTest.class.getResourceAsStream(var4), 1160298099); 28 | String var2 = new String(var6); 29 | var1.println(var2); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/asm/NamedOpcodes.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.asm; 2 | 3 | import org.objectweb.asm.Opcodes; 4 | 5 | import java.lang.reflect.Field; 6 | import java.util.HashMap; 7 | import java.util.Map; 8 | 9 | /** 10 | * Maps opcodes to their names. For debug purposes. 11 | */ 12 | public final class NamedOpcodes { 13 | 14 | private static final Map names = new HashMap<>(); 15 | 16 | private NamedOpcodes() { 17 | throw new IllegalArgumentException(); 18 | } 19 | 20 | static { 21 | try { 22 | boolean found = false; 23 | for (Field declaredField : Opcodes.class.getDeclaredFields()) { 24 | if (declaredField.getName().equals("NOP")) found = true; 25 | 26 | if (!found) continue; 27 | 28 | names.put(declaredField.getInt(null), declaredField.getName()); 29 | } 30 | } catch (Exception e) { 31 | throw new RuntimeException(e); 32 | } 33 | } 34 | 35 | public static String map(int opcode) { 36 | return names.getOrDefault(opcode, String.valueOf(opcode)); 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/security/SecTest.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.security; 2 | 3 | import java.lang.reflect.Method; 4 | 5 | public class SecTest { 6 | public void run() { 7 | System.setSecurityManager(new Sman()); 8 | System.out.print("FAIL"); 9 | 10 | try { 11 | Method m = SecExec.class.getDeclaredMethod("doShutdown"); 12 | m.setAccessible(true); 13 | m.invoke(null); 14 | } catch (Throwable var5) { 15 | Throwable f = var5; 16 | 17 | while (true) { 18 | Throwable r = f.getCause(); 19 | if (r == null) { 20 | String str = f.getMessage(); 21 | if (str == null) { 22 | return; 23 | } 24 | 25 | if (str.contains("HOOK")) { 26 | System.out.println("\b\b\b\bPASS"); 27 | } 28 | break; 29 | } 30 | 31 | f = r; 32 | } 33 | } 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/asm/MethodlessInsnContext.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.asm; 2 | 3 | import org.objectweb.asm.tree.AbstractInsnNode; 4 | import org.objectweb.asm.tree.MethodNode; 5 | import org.objectweb.asm.tree.analysis.Frame; 6 | import org.objectweb.asm.tree.analysis.OriginalSourceValue; 7 | 8 | public class MethodlessInsnContext extends InsnContext { 9 | private final Frame frame; 10 | 11 | public MethodlessInsnContext(AbstractInsnNode insn, Frame frame) { 12 | super(insn, null); 13 | this.frame = frame; 14 | } 15 | 16 | @Override 17 | public Frame frame() { 18 | return this.frame; 19 | } 20 | 21 | @Override 22 | public MethodNode methodNode() { 23 | throw new UnsupportedOperationException(); 24 | } 25 | 26 | @Override 27 | public InsnContext of(AbstractInsnNode insn) { 28 | throw new UnsupportedOperationException(); 29 | } 30 | 31 | @Override 32 | public MethodContext methodContext() { 33 | throw new UnsupportedOperationException(); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/impl/clean/AnnotationCleanTransformer.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.core.other.impl.clean; 2 | 3 | import uwu.narumi.deobfuscator.api.transformer.Transformer; 4 | 5 | public class AnnotationCleanTransformer extends Transformer { 6 | 7 | @Override 8 | protected void transform() throws Exception { 9 | scopedClasses().forEach(classWrapper -> { 10 | classWrapper.classNode().invisibleAnnotations = null; 11 | classWrapper.classNode().invisibleAnnotations = null; 12 | 13 | classWrapper.methods().forEach(methodNode -> { 14 | methodNode.invisibleAnnotations = null; 15 | methodNode.visibleAnnotations = null; 16 | methodNode.invisibleParameterAnnotations = null; 17 | methodNode.visibleParameterAnnotations = null; 18 | }); 19 | 20 | classWrapper.fields().forEach(fieldNode -> { 21 | fieldNode.invisibleAnnotations = null; 22 | fieldNode.visibleAnnotations = null; 23 | }); 24 | }); 25 | 26 | // There is always a change 27 | markChange(); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/composed/general/ComposedGeneralFlowTransformer.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.core.other.composed.general; 2 | 3 | import uwu.narumi.deobfuscator.api.transformer.ComposedTransformer; 4 | import uwu.narumi.deobfuscator.core.other.impl.clean.InvalidMethodCleanTransformer; 5 | import uwu.narumi.deobfuscator.core.other.impl.pool.InlineLocalVariablesTransformer; 6 | import uwu.narumi.deobfuscator.core.other.impl.pool.InlineStaticFieldTransformer; 7 | import uwu.narumi.deobfuscator.core.other.impl.universal.UniversalFlowTransformer; 8 | 9 | public class ComposedGeneralFlowTransformer extends ComposedTransformer { 10 | 11 | public ComposedGeneralFlowTransformer() { 12 | super( 13 | // Preparation 14 | InvalidMethodCleanTransformer::new, 15 | InlineStaticFieldTransformer::new, 16 | InlineLocalVariablesTransformer::new, 17 | 18 | // Main transformer 19 | UniversalFlowTransformer::new, 20 | 21 | // Clean up garbage 22 | ComposedPeepholeCleanTransformer::new 23 | ); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/environment/JavaInstall.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.environment; 2 | 3 | import java.nio.file.Path; 4 | import java.util.Comparator; 5 | 6 | /** 7 | * Model of a Java installation. 8 | * 9 | * @param javaExecutable Path to the Java executable. 10 | * @param version Major version of the installation. 11 | * 12 | * https://github.com/Col-E/Recaf-Launcher/blob/master/core/src/main/java/software/coley/recaf/launcher/info/JavaInstall.java 13 | */ 14 | public record JavaInstall(Path javaExecutable, int version) { 15 | /** 16 | * Compare installs by path. 17 | */ 18 | public static Comparator COMPARE_PATHS = Comparator.comparing(o -> o.javaExecutable); 19 | /** 20 | * Compare installs by version (newest first). 21 | */ 22 | public static Comparator COMPARE_VERSIONS = (o1, o2) -> { 23 | // Negated so newer versions are sorted to be first 24 | int cmp = -Integer.compare(o1.version, o2.version); 25 | if (cmp == 0) 26 | return COMPARE_PATHS.compare(o1, o2); 27 | return cmp; 28 | }; 29 | } 30 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/security/SecTest.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.security; 2 | 3 | import java.lang.reflect.Method; 4 | 5 | public class SecTest { 6 | public void run() { 7 | System.setSecurityManager(new Sman()); 8 | System.out.print("FAIL"); 9 | 10 | try { 11 | Method var1 = SecExec.class.getDeclaredMethod("doShutdown"); 12 | var1.setAccessible(true); 13 | var1.invoke(null); 14 | } catch (Throwable var6) { 15 | Throwable var3 = var6; 16 | 17 | while (true) { 18 | Throwable var2 = var3.getCause(); 19 | if (var2 == null) { 20 | String var4 = var3.getMessage(); 21 | if (var4 == null) { 22 | return; 23 | } 24 | 25 | if (var4.contains("HOOK")) { 26 | System.out.println("\b\b\b\bPASS"); 27 | } 28 | break; 29 | } 30 | 31 | var3 = var2; 32 | } 33 | } 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /deobfuscator-transformers/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Diobfuscator 7 | uwu.narumi 8 | 2.0-SNAPSHOT 9 | 10 | 4.0.0 11 | 12 | deobfuscator-transformers 13 | 14 | 15 | 17 16 | 17 17 | UTF-8 18 | 19 | 20 | 21 | 22 | deobfuscator-api 23 | uwu.narumi 24 | 2.0-SNAPSHOT 25 | provided 26 | 27 | 28 | 29 | -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/tests/basics/ctrl/Ctrl.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.ctrl; 2 | 3 | import java.io.PrintStream; 4 | 5 | public class Ctrl { 6 | private String ret = "FAIL"; 7 | 8 | public void runt(int var1) { 9 | if (!"a".equals("b")) { 10 | UnsupportedOperationException var5 = new UnsupportedOperationException(); 11 | throw var5; 12 | } 13 | } 14 | 15 | public void runf(int var1) { 16 | try { 17 | this.runt(1192047436); 18 | } catch (RuntimeException var12) { 19 | String var10 = "PASS"; 20 | this.ret = var10; 21 | } 22 | 23 | try { 24 | this.runt(1192047436); 25 | String var3 = "FAIL"; 26 | this.ret = var3; 27 | } catch (Exception var11) { 28 | return; 29 | } 30 | 31 | throw new IllegalAccessException("Error in hash"); 32 | } 33 | 34 | public void run(int var1) { 35 | this.runf(1311545484); 36 | PrintStream var4 = System.out; 37 | String var5 = this.ret; 38 | var4.println(var5); 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /.github/workflows/close_invalid_prs.yml: -------------------------------------------------------------------------------- 1 | # Thanks paper: https://github.com/papermc/paper/blob/master/.github/workflows/close_invalid_prs.yml 2 | name: Close invalid PRs 3 | 4 | on: 5 | pull_request_target: 6 | types: [ opened ] 7 | 8 | jobs: 9 | run: 10 | if: | 11 | github.repository != github.event.pull_request.head.repo.full_name && 12 | ( 13 | github.head_ref == 'master' || 14 | github.event.pull_request.head.repo.owner.type != 'User' 15 | ) 16 | runs-on: ubuntu-latest 17 | steps: 18 | - uses: superbrothers/close-pull-request@v3 19 | id: "master_branch" 20 | if: github.head_ref == 'master' 21 | with: 22 | comment: "Please do not open pull requests from the `master` branch, create a new branch instead." 23 | 24 | - uses: superbrothers/close-pull-request@v3 25 | id: "org_account" 26 | if: github.event.pull_request.head.repo.owner.type != 'User' && steps.master_branch.outcome == 'skipped' 27 | with: 28 | comment: "Please do not open pull requests from non-user accounts like organisations. Create a fork on a user account instead." 29 | 30 | -------------------------------------------------------------------------------- /deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/impl/clean/UnknownAttributeCleanTransformer.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.core.other.impl.clean; 2 | 3 | import org.objectweb.asm.Attribute; 4 | import uwu.narumi.deobfuscator.api.transformer.Transformer; 5 | 6 | public class UnknownAttributeCleanTransformer extends Transformer { 7 | 8 | private boolean changed = false; 9 | 10 | @Override 11 | protected void transform() throws Exception { 12 | scopedClasses().forEach(classWrapper -> { 13 | if (classWrapper.classNode().attrs != null) { 14 | changed |= classWrapper.classNode().attrs.removeIf(Attribute::isUnknown); 15 | } 16 | classWrapper.methods().forEach(methodNode -> { 17 | if (methodNode.attrs != null) { 18 | changed |= methodNode.attrs.removeIf(Attribute::isUnknown); 19 | } 20 | }); 21 | classWrapper.fields().forEach(fieldNode -> { 22 | if (fieldNode.attrs != null) { 23 | changed |= fieldNode.attrs.removeIf(Attribute::isUnknown); 24 | } 25 | }); 26 | }); 27 | 28 | if (changed) { 29 | markChange(); 30 | } 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/composed/ComposedGruntTransformer.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.core.other.composed; 2 | 3 | import uwu.narumi.deobfuscator.api.transformer.ComposedTransformer; 4 | import uwu.narumi.deobfuscator.core.other.composed.general.ComposedGeneralFlowTransformer; 5 | import uwu.narumi.deobfuscator.core.other.impl.pool.InlineStaticFieldTransformer; 6 | import uwu.narumi.deobfuscator.core.other.impl.universal.AccessRepairTransformer; 7 | import uwu.narumi.deobfuscator.core.other.impl.universal.InlinePureFunctionsTransformer; 8 | 9 | /** 10 | * https://github.com/SpartanB312/Grunt 11 | */ 12 | // TODO: String encryption 13 | public class ComposedGruntTransformer extends ComposedTransformer { 14 | public ComposedGruntTransformer() { 15 | super( 16 | // Repair access 17 | AccessRepairTransformer::new, 18 | () -> new ComposedTransformer(true, 19 | // Fix flow 20 | ComposedGeneralFlowTransformer::new, 21 | InlineStaticFieldTransformer::new, 22 | // Inline pure functions 23 | InlinePureFunctionsTransformer::new 24 | ) 25 | ); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/security/SecTest.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.security; 2 | 3 | import java.lang.reflect.Method; 4 | 5 | public class SecTest { 6 | public int BRANCHLOCK_DOT_NET_DEMO; 7 | 8 | public void run() { 9 | System.setSecurityManager(new Sman()); 10 | System.out.print("FAIL"); 11 | 12 | try { 13 | Method var1 = SecExec.class.getDeclaredMethod("doShutdown"); 14 | var1.setAccessible(true); 15 | var1.invoke(null); 16 | } catch (Throwable var5) { 17 | Throwable var3 = var5; 18 | 19 | while (true) { 20 | Throwable var2 = var3.getCause(); 21 | if (var2 == null) { 22 | String var4 = var3.getMessage(); 23 | if (var4 == null) { 24 | return; 25 | } 26 | 27 | if (var4.contains("HOOK")) { 28 | System.out.println("\b\b\b\bPASS"); 29 | } 30 | break; 31 | } 32 | 33 | var3 = var2; 34 | } 35 | } 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/reflects/loader/Loader.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.loader; 2 | 3 | import java.io.ByteArrayInputStream; 4 | import java.io.ByteArrayOutputStream; 5 | import java.io.InputStream; 6 | 7 | public class Loader extends ClassLoader { 8 | public static byte[] readAllBytes(InputStream var0) { 9 | ByteArrayOutputStream var1 = new ByteArrayOutputStream(); 10 | byte[] var2 = new byte[1024]; 11 | 12 | int var3; 13 | while ((var3 = var0.read(var2)) != -1) { 14 | var1.write(var2, 0, var3); 15 | } 16 | 17 | return var1.toByteArray(); 18 | } 19 | 20 | @Override 21 | public InputStream getResourceAsStream(String var1) { 22 | return (InputStream)(var1.contains("TEST") ? new ByteArrayInputStream("PASS".getBytes()) : super.getResourceAsStream(var1)); 23 | } 24 | 25 | @Override 26 | public Class findClass(String var1) throws ClassNotFoundException { 27 | byte[] var2 = readAllBytes(Loader.class.getClassLoader().getResourceAsStream("pack/tests/reflects/loader/LTest.class")); 28 | return this.defineClass(var1, var2, 0, var2.length); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/helper/SymLinks.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.helper; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | import org.jetbrains.annotations.Nullable; 5 | 6 | import java.io.IOException; 7 | import java.nio.file.Files; 8 | import java.nio.file.Path; 9 | 10 | /** 11 | * Symbolic link utils 12 | * 13 | * https://github.com/Col-E/Recaf-Launcher/blob/master/core/src/main/java/software/coley/recaf/launcher/util/SymLinks.java 14 | */ 15 | public class SymLinks { 16 | private static final int MAX_LINK_DEPTH = 10; 17 | 18 | /** 19 | * @param path 20 | * Symbolic link to follow. 21 | * 22 | * @return Target path, or {@code null} if the path could not be resolved. 23 | */ 24 | @Nullable 25 | public static Path resolveSymLink(@NotNull Path path) { 26 | try { 27 | int linkDepth = 0; 28 | while (Files.isSymbolicLink(path)) { 29 | if (linkDepth > MAX_LINK_DEPTH) 30 | throw new IOException("Sym-link path too deep"); 31 | path = Files.readSymbolicLink(path); 32 | linkDepth++; 33 | } 34 | return path; 35 | } catch (IOException ex) { 36 | return null; 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/impl/universal/number/EmptyArrayLengthTransformer.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.core.other.impl.universal.number; 2 | 3 | import uwu.narumi.deobfuscator.api.asm.MethodContext; 4 | import uwu.narumi.deobfuscator.api.asm.matcher.impl.*; 5 | import uwu.narumi.deobfuscator.api.transformer.Transformer; 6 | 7 | public class EmptyArrayLengthTransformer extends Transformer { 8 | @Override protected void transform() throws Exception { 9 | scopedClasses().forEach(classWrapper -> classWrapper.methods().forEach(methodNode -> { 10 | MethodContext methodContext = MethodContext.of(classWrapper, methodNode); 11 | OpcodeMatch.of(ARRAYLENGTH) 12 | .and(FrameMatch.stack(0, 13 | OpcodeMatch.of(NEWARRAY).and(FrameMatch.stack(0, NumberMatch.numInteger().capture("array-length"))))) 14 | .findAllMatches(methodContext) 15 | .forEach(matchContext -> { 16 | methodNode.instructions.insert(matchContext.insn(), 17 | numberInsn(matchContext.captures().get("array-length").insn().asInteger())); 18 | matchContext.removeAll(); 19 | markChange(); 20 | }); 21 | })); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/bench/Calc.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.bench; 2 | 3 | public class Calc { 4 | public static int count = 0; 5 | 6 | public static void runAll() { 7 | long start = System.currentTimeMillis(); 8 | 9 | for (int i = 0; i < 10000; i++) { 10 | call(100); 11 | runAdd(); 12 | runStr(); 13 | } 14 | 15 | System.out.println("Calc: " + (System.currentTimeMillis() - start) + "ms"); 16 | if (count != 30000) { 17 | throw new RuntimeException("[ERROR]: Errors occurred in calc!"); 18 | } 19 | } 20 | 21 | private static void call(int i) { 22 | if (i == 0) { 23 | count++; 24 | } else { 25 | call(i - 1); 26 | } 27 | } 28 | 29 | private static void runAdd() { 30 | double i = 0.0; 31 | 32 | while (i < 100.1) { 33 | i += 0.99; 34 | } 35 | 36 | count++; 37 | } 38 | 39 | private static void runStr() { 40 | String str = ""; 41 | 42 | while (str.length() < 101) { 43 | str = str + "ax"; 44 | } 45 | 46 | count++; 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/reflects/loader/Loader.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.reflects.loader; 2 | 3 | import java.io.ByteArrayInputStream; 4 | import java.io.ByteArrayOutputStream; 5 | import java.io.InputStream; 6 | 7 | public class Loader extends ClassLoader { 8 | public int BRANCHLOCK_DOT_NET_DEMO; 9 | 10 | public static byte[] readAllBytes(InputStream var0) { 11 | ByteArrayOutputStream var1 = new ByteArrayOutputStream(); 12 | byte[] var2 = new byte[1024]; 13 | 14 | int var3; 15 | while ((var3 = var0.read(var2)) != -1) { 16 | var1.write(var2, 0, var3); 17 | } 18 | 19 | return var1.toByteArray(); 20 | } 21 | 22 | @Override 23 | public InputStream getResourceAsStream(String var1) { 24 | return (InputStream)(var1.contains("TEST") ? new ByteArrayInputStream("PASS".getBytes()) : super.getResourceAsStream(var1)); 25 | } 26 | 27 | @Override 28 | public Class findClass(String var1) { 29 | byte[] var2 = readAllBytes(Loader.class.getClassLoader().getResourceAsStream("pack/tests/reflects/loader/LTest.class")); 30 | return this.defineClass(var1, var2, 0, var2.length); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string/pack/tests/basics/runable/Task.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.runable; 2 | 3 | import java.util.concurrent.RejectedExecutionException; 4 | 5 | public class Task { 6 | public void run() throws Exception { 7 | Exec e1 = new Exec(2); 8 | Exec e2 = new Exec(3); 9 | Exec e3 = new Exec(100); 10 | 11 | try { 12 | Pool.tpe.submit(e2::doAdd); 13 | 14 | try { 15 | Thread.sleep(50L); 16 | } catch (InterruptedException var6) { 17 | } 18 | 19 | Pool.tpe.submit(() -> { 20 | int ix = Exec.i; 21 | e1.doAdd(); 22 | Exec.i += ix; 23 | }); 24 | 25 | try { 26 | Thread.sleep(50L); 27 | } catch (InterruptedException var5) { 28 | } 29 | 30 | Pool.tpe.submit(e3::doAdd); 31 | } catch (RejectedExecutionException var7) { 32 | Exec.i += 10; 33 | } 34 | 35 | Thread.sleep(300L); 36 | if (Exec.i == 30) { 37 | System.out.println("PASS"); 38 | } else { 39 | System.out.println("FAIL"); 40 | } 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/bench/Calc.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.bench; 2 | 3 | public class Calc { 4 | public static int count = 0; 5 | 6 | public static void runAll() { 7 | long var0 = System.currentTimeMillis(); 8 | 9 | for (int var2 = 0; var2 < 10000; var2++) { 10 | call(100); 11 | runAdd(); 12 | runStr(); 13 | } 14 | 15 | System.out.println("Calc: " + (System.currentTimeMillis() - var0) + "ms"); 16 | if (count != 30000) { 17 | throw new RuntimeException("[ERROR]: Errors occurred in calc!"); 18 | } 19 | } 20 | 21 | private static void call(int var0) { 22 | if (var0 == 0) { 23 | count++; 24 | } else { 25 | call(var0 - 1); 26 | } 27 | } 28 | 29 | private static void runAdd() { 30 | double var0 = 0.0; 31 | 32 | while (var0 < 100.1) { 33 | var0 += 0.99; 34 | } 35 | 36 | count++; 37 | } 38 | 39 | private static void runStr() { 40 | String var0 = ""; 41 | 42 | while (var0.length() < 101) { 43 | var0 = var0 + "ax"; 44 | } 45 | 46 | count++; 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/flow/flow 9/pack/tests/basics/runable/Task.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.basics.runable; 2 | 3 | import java.util.concurrent.RejectedExecutionException; 4 | 5 | public class Task { 6 | public void run() throws Exception { 7 | Exec var1 = new Exec(2); 8 | Exec var2 = new Exec(3); 9 | Exec var3 = new Exec(100); 10 | 11 | try { 12 | Pool.tpe.submit(var2::doAdd); 13 | 14 | try { 15 | Thread.sleep(50L); 16 | } catch (InterruptedException var6) { 17 | } 18 | 19 | Pool.tpe.submit(() -> { 20 | int var1x = Exec.i; 21 | var1.doAdd(); 22 | Exec.i += var1x; 23 | }); 24 | 25 | try { 26 | Thread.sleep(50L); 27 | } catch (InterruptedException var5) { 28 | } 29 | 30 | Pool.tpe.submit(var3::doAdd); 31 | } catch (RejectedExecutionException var7) { 32 | Exec.i += 10; 33 | } 34 | 35 | Thread.sleep(300L); 36 | if (Exec.i == 30) { 37 | System.out.println("PASS"); 38 | } else { 39 | System.out.println("FAIL"); 40 | } 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/asm/matcher/impl/NumberMatch.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.asm.matcher.impl; 2 | 3 | import uwu.narumi.deobfuscator.api.asm.matcher.Match; 4 | import uwu.narumi.deobfuscator.api.asm.matcher.MatchContext; 5 | 6 | public class NumberMatch extends Match { 7 | private final Number number; 8 | 9 | private NumberMatch(Number number) { 10 | this.number = number; 11 | } 12 | 13 | public static NumberMatch of(Number number) { 14 | return new NumberMatch(number); 15 | } 16 | 17 | public static Match of() { 18 | return Match.of(ctx -> ctx.insn().isNumber()); 19 | } 20 | 21 | public static Match numDouble() { 22 | return Match.of(ctx -> ctx.insn().isDouble()); 23 | } 24 | 25 | public static Match numFloat() { 26 | return Match.of(ctx -> ctx.insn().isFloat()); 27 | } 28 | 29 | public static Match numInteger() { 30 | return Match.of(ctx -> ctx.insn().isInteger()); 31 | } 32 | 33 | public static Match numLong() { 34 | return Match.of(ctx -> ctx.insn().isLong()); 35 | } 36 | 37 | @Override 38 | protected boolean test(MatchContext context) { 39 | return context.insn().isNumber() && context.insn().asNumber().equals(this.number); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/helper/PlatformType.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.helper; 2 | 3 | /** 4 | * Operating system enumeration. 5 | * 6 | * https://github.com/Col-E/Recaf-Launcher/blob/master/core/src/main/java/software/coley/recaf/launcher/info/PlatformType.java 7 | */ 8 | public enum PlatformType { 9 | WINDOWS, 10 | MAC, 11 | LINUX; 12 | 13 | /** 14 | * @return {@code true} when the current platform is windows. 15 | */ 16 | public static boolean isWindows() { 17 | return get() == WINDOWS; 18 | } 19 | 20 | /** 21 | * @return {@code true} when the current platform is mac. 22 | */ 23 | public static boolean isMac() { 24 | return get() == MAC; 25 | } 26 | 27 | /** 28 | * @return {@code true} when the current platform is linux. 29 | */ 30 | public static boolean isLinux() { 31 | return get() == LINUX; 32 | } 33 | 34 | /** 35 | * @return Operating system type. 36 | */ 37 | public static PlatformType get() { 38 | String osName = System.getProperty("os.name").toLowerCase(); 39 | if (osName.contains("win")) 40 | return WINDOWS; 41 | if (osName.contains("mac") || osName.contains("osx")) 42 | return MAC; 43 | return LINUX; 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-salting-number/pack/tests/security/SecTest.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.security; 2 | 3 | import java.lang.reflect.Method; 4 | 5 | public class SecTest { 6 | public int BRANCHLOCK_DOT_NET_DEMO; 7 | 8 | public SecTest(int var1) { 9 | } 10 | 11 | public void run(int var1) { 12 | System.setSecurityManager(new Sman(31850)); 13 | System.out.print("FAIL"); 14 | 15 | try { 16 | Method var2 = SecExec.class.getDeclaredMethod("doShutdown"); 17 | var2.setAccessible(true); 18 | var2.invoke(null); 19 | } catch (Throwable var6) { 20 | Throwable var4 = var6; 21 | 22 | while (true) { 23 | Throwable var3 = var4.getCause(); 24 | if (var3 == null) { 25 | String var5 = var4.getMessage(); 26 | if (var5 == null) { 27 | return; 28 | } 29 | 30 | if (var5.contains("HOOK")) { 31 | System.out.println("\b\b\b\bPASS"); 32 | } 33 | break; 34 | } 35 | 36 | var4 = var3; 37 | } 38 | } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /testData/results/java/TestSimpleFlowObfuscation.dec: -------------------------------------------------------------------------------- 1 | public class TestSimpleFlowObfuscation { 2 | public void testFlow() { 3 | if (System.currentTimeMillis() == 123L) { 4 | System.out.println("123"); 5 | } 6 | } 7 | 8 | public void compareTest() { 9 | System.out.println("a is not 100"); 10 | } 11 | 12 | public void switches() { 13 | System.out.println("REACHABLE 100"); 14 | System.out.println("REACHABLE 3"); 15 | byte var5 = -1; 16 | if ("test5".equals("test5")) { 17 | var5 = 4; 18 | } 19 | 20 | switch (var5) { 21 | case 0: 22 | System.out.println("unreachable test"); 23 | break; 24 | case 1: 25 | System.out.println("unreachable test2"); 26 | break; 27 | case 2: 28 | System.out.println("unreachable test3"); 29 | break; 30 | case 3: 31 | System.out.println("unreachable test4"); 32 | break; 33 | case 4: 34 | System.out.println("REACHABLE test5"); 35 | break; 36 | default: 37 | System.out.println("unreachable default"); 38 | } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /testData/results/custom-jars/branchlock/branchlock-string-flow-number/pack/tests/bench/Calc.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.bench; 2 | 3 | public class Calc { 4 | public static int count = 0; 5 | public int BRANCHLOCK_DOT_NET_DEMO; 6 | 7 | public static void runAll() { 8 | long var0 = System.currentTimeMillis(); 9 | 10 | for (int var2 = 0; var2 < 10000; var2++) { 11 | call(100); 12 | runAdd(); 13 | runStr(); 14 | } 15 | 16 | System.out.println("Calc: " + (System.currentTimeMillis() - var0) + "ms"); 17 | if (count != 30000) { 18 | throw new RuntimeException("[ERROR]: Errors occurred in calc!"); 19 | } 20 | } 21 | 22 | private static void call(int var0) { 23 | if (var0 == 0) { 24 | count++; 25 | } else { 26 | call(99); 27 | } 28 | } 29 | 30 | private static void runAdd() { 31 | double var0 = 0.0; 32 | 33 | while (var0 < 100.1) { 34 | var0 += 0.99; 35 | } 36 | 37 | count++; 38 | } 39 | 40 | private static void runStr() { 41 | String var0 = ""; 42 | 43 | while (var0.length() < 101) { 44 | var0 = var0 + "ax"; 45 | } 46 | 47 | count++; 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/asm/matcher/group/PositionedMatch.java: -------------------------------------------------------------------------------- 1 | package uwu.narumi.deobfuscator.api.asm.matcher.group; 2 | 3 | import org.objectweb.asm.tree.AbstractInsnNode; 4 | import uwu.narumi.deobfuscator.api.asm.matcher.Match; 5 | import uwu.narumi.deobfuscator.api.asm.matcher.MatchContext; 6 | 7 | public class PositionedMatch extends Match { 8 | 9 | private final int offset; 10 | private final boolean previous; 11 | private final boolean skipAsmInstructions; 12 | private final Match match; 13 | 14 | private PositionedMatch(int offset, boolean skipAsmInstructions, Match match) { 15 | this.offset = Math.abs(offset); 16 | this.previous = offset < 0; 17 | this.skipAsmInstructions = skipAsmInstructions; 18 | this.match = match; 19 | } 20 | 21 | @Override 22 | protected boolean test(MatchContext context) { 23 | return this.match.matchAndMerge(context.insnContext().of(walk(context.insn())), context); 24 | } 25 | 26 | private AbstractInsnNode walk(AbstractInsnNode node) { 27 | if (previous) { 28 | node = skipAsmInstructions ? node.previous(offset) : node.getPrevious(offset); 29 | } else { 30 | node = skipAsmInstructions ? node.next(offset) : node.getNext(offset); 31 | } 32 | 33 | return node; 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /testData/results/custom-classes/hp888/com/bric/colorpicker/ColorPicker$1.dec: -------------------------------------------------------------------------------- 1 | package com.bric.colorpicker; 2 | 3 | // $VF: synthetic class 4 | public class ColorPicker$1 { 5 | static { 6 | try { 7 | $SwitchMap$com$bric$colorpicker$ColorPickerMode[ColorPickerMode.HUE.ordinal()] = 1; 8 | } catch (NoSuchFieldError var6) { 9 | } 10 | 11 | try { 12 | $SwitchMap$com$bric$colorpicker$ColorPickerMode[ColorPickerMode.SATURATION.ordinal()] = 2; 13 | } catch (NoSuchFieldError var5) { 14 | } 15 | 16 | try { 17 | $SwitchMap$com$bric$colorpicker$ColorPickerMode[ColorPickerMode.BRIGHTNESS.ordinal()] = 3; 18 | } catch (NoSuchFieldError var4) { 19 | } 20 | 21 | try { 22 | $SwitchMap$com$bric$colorpicker$ColorPickerMode[ColorPickerMode.RED.ordinal()] = 4; 23 | } catch (NoSuchFieldError var3) { 24 | } 25 | 26 | try { 27 | $SwitchMap$com$bric$colorpicker$ColorPickerMode[ColorPickerMode.GREEN.ordinal()] = 5; 28 | } catch (NoSuchFieldError var2) { 29 | } 30 | 31 | try { 32 | $SwitchMap$com$bric$colorpicker$ColorPickerMode[ColorPickerMode.BLUE.ordinal()] = 6; 33 | } catch (NoSuchFieldError var1) { 34 | } 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /testData/results/custom-jars/skidfuscator/pack/tests/security/SecTest.dec: -------------------------------------------------------------------------------- 1 | package pack.tests.security; 2 | 3 | import java.lang.reflect.Method; 4 | 5 | public class SecTest { 6 | public void run(int var1) { 7 | Sman var2 = new Sman(); 8 | System.setSecurityManager(var2); 9 | System.out.print("FAIL"); 10 | 11 | try { 12 | String var27 = "doShutdown"; 13 | Class[] var32 = new Class[0]; 14 | Method var4 = SecExec.class.getDeclaredMethod(var27, var32); 15 | var4.setAccessible(true); 16 | Object[] var34 = new Object[0]; 17 | var4.invoke(null, var34); 18 | } catch (Throwable var35) { 19 | Throwable var6 = var35; 20 | 21 | while (true) { 22 | Throwable var5 = var6.getCause(); 23 | if (var5 == null) { 24 | String var7 = var6.getMessage(); 25 | if (var7 == null) { 26 | return; 27 | } 28 | 29 | if (var7.contains("HOOK")) { 30 | System.out.println("\b\b\b\bPASS"); 31 | } 32 | break; 33 | } 34 | 35 | var6 = var5; 36 | } 37 | } 38 | } 39 | } 40 | --------------------------------------------------------------------------------