Что нового?

Вопрос Дайте идей методов для обфы

  • Автор темы Автор темы r3z
  • Дата начала Дата начала
r3z
aka wqzxqz
Начинающий
r3z
Начинающий
Статус
Оффлайн
Регистрация
24 Ноя 2024
Сообщения
671
Реакции
11
вот щас у меня такой пример обфусцированного класса (моего же обфускатора):

Java:
Expand Collapse Copy 
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.jar.JarOutputStream;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.Label;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.FieldInsnNode;
import org.objectweb.asm.tree.InsnList;
import org.objectweb.asm.tree.InsnNode;
import org.objectweb.asm.tree.IntInsnNode;
import org.objectweb.asm.tree.JumpInsnNode;
import org.objectweb.asm.tree.LabelNode;
import org.objectweb.asm.tree.LdcInsnNode;
import org.objectweb.asm.tree.MethodInsnNode;
import org.objectweb.asm.tree.MethodNode;
import org.objectweb.asm.tree.VarInsnNode;

public class JarObfuscator {
   private static final Random random = new Random();
   private static final String[] chineseChars = new String[]{"一", "丁", "丂", "七", "丄", "丅", "丆", "万", "丈", "三", "上", "下", "丌", "不", "与", "丏", "丐", "丑", "丒", "专", "且", "丕", "世", "丗", "丘", "丙", "业", "丛", "东", "丝"};

   public static void main(String[] args) throws IOException {
      if (args.length != 2) {
         System.out.println(IIlIIlll(new String("七丂丅丆万丈三上下丌不与丏丐丑丒专且丕世丗丘丙业丛东丝").intern()));
         return;
      }

      String inputJarPath = args[0];
      String outputJarPath = args[1];
      lllIlIIl(inputJarPath, outputJarPath);
   }

   public static void lllIlIIl(String inputJarPath, String outputJarPath) throws IOException {
      java.io.File inputJarFile = new java.io.File(inputJarPath);
      java.io.File outputJarFile = new java.io.File(outputJarPath);
      if (!inputJarFile.exists()) {
         System.out.println(IIlIIlll(new String("七丂丅丆万丈三上不与丏丐丑丒专且丕世丗丘丙业丛东丝丝").intern()) + inputJarPath);
         return;
      }

      JarFile jarFile = new JarFile(inputJarFile);

      try {
         JarOutputStream jarOutputStream = new JarOutputStream(new java.io.FileOutputStream(outputJarFile));

         try {
            jarFile.stream().forEach((jarEntry) -> {
               try {
                  jarOutputStream.putNextEntry(new JarEntry(jarEntry.getName()));
                  if (jarEntry.isDirectory()) {
                     return;
                  }

                  if (jarEntry.getName().endsWith(IIlIIlll(new String("七七丂丂丁").intern()))) {
                     ClassReader classReader = new ClassReader(jarFile.getInputStream(jarEntry));
                     ClassNode classNode = new ClassNode();
                     classReader.accept(classNode, 0);
                     lIIlIIlI(classNode);
                     ClassWriter classWriter = new ClassWriter(3);
                     classNode.accept(classWriter);
                     byte[] modifiedBytecode = classWriter.toByteArray();
                     jarOutputStream.write(modifiedBytecode);
                  } else {
                     InputStream inputStream = jarFile.getInputStream(jarEntry);
                     byte[] buffer = inputStream.readAllBytes();
                     jarOutputStream.write(buffer);
                     inputStream.close();
                  }

                  jarOutputStream.closeEntry();
               } catch (IOException var11) {
                  var11.printStackTrace();
               }

            });
         } catch (Throwable var13) {
            try {
               jarOutputStream.close();
            } catch (Throwable var12) {
               var13.addSuppressed(var12);
            }

            throw var13;
         }

         jarOutputStream.close();
      } catch (Throwable var14) {
         try {
            jarFile.close();
         } catch (Throwable var10) {
            var14.addSuppressed(var10);
         }

         throw var14;
      }

      jarFile.close();
      System.out.println(IIlIIlll(new String("丆万丈三上不与丏丐丑丒专且丕世丗丘丙业丛东丝丝丝丝丝").intern()) + outputJarPath);
   }

   private static void lIIlIIlI(ClassNode classNode) {
      HashMap methodRenameMap = new HashMap();
      IllIIlIl(classNode);
      Iterator var2 = classNode.methods.iterator();

      while(var2.hasNext()) {
         MethodNode methodNode = (MethodNode)var2.next();
         if (!methodNode.name.equals(IIlIIlll(new String("与丗").intern())) && !methodNode.name.equals(IIlIIlll(new String("与丐丙丝").intern())) && !methodNode.name.equals(IIlIIlll(new String("与上丅丐").intern())) && !methodNode.name.equals(IIlIIlll(new String("丅专专专").intern())) && !methodNode.name.equals(IIlIIlll(new String("丅七丝七丅").intern()))) {
            lIllIIII(methodNode, methodRenameMap);
         }

         lIlIIlll(methodNode);
         IllIlIll(methodNode);
         lIIIIlll(methodNode);
         lIIlIlll(methodNode);
      }

      lIIlIlIl(classNode, methodRenameMap);
   }

   private static void lIllIIII(MethodNode methodNode, Map renameMap) {
      String originalName = methodNode.name;
      String obfuscatedName = IllIIIIl();
      methodNode.name = obfuscatedName;
      renameMap.put(originalName, obfuscatedName);
   }

   private static String IllIIIIl() {
      StringBuilder sb = new StringBuilder();
      int length = random.nextInt(50) + 2;

      for(int i = 0; i < length; ++i) {
         sb.append(random.nextBoolean() ? 'l' : 'I');
      }

      return sb.toString();
   }

   private static void lIIlIlIl(ClassNode classNode, Map renameMap) {
      Iterator var2 = classNode.methods.iterator();

      while(var2.hasNext()) {
         MethodNode methodNode = (MethodNode)var2.next();
         Iterator var4 = methodNode.instructions.iterator();

         while(var4.hasNext()) {
            AbstractInsnNode insn = (AbstractInsnNode)var4.next();
            if (insn instanceof MethodInsnNode) {
               MethodInsnNode methodInsn = (MethodInsnNode)insn;
               if (renameMap.containsKey(methodInsn.name) && methodInsn.owner.equals(classNode.name)) {
                  methodInsn.name = (String)renameMap.get(methodInsn.name);
               }
            }
         }
      }

   }

   private static void IllIIlIl(ClassNode classNode) {
      MethodNode deadMethod = new MethodNode(2, IIlIIlll(new String("上丅丐丙丝丁").intern()) + random.nextInt(1000), IIlIIlll(new String("专专丝").intern()), (String)null, (String[])null);
      deadMethod.instructions.add((AbstractInsnNode)(new FieldInsnNode(178, IIlIIlll(new String("丈上丝专丈专").intern()), IIlIIlll(new String("与丝丅").intern()), IIlIIlll(new String("丁专丈与丝丕丁丅丝丝").intern()))));
      deadMethod.instructions.add((AbstractInsnNode)(new LdcInsnNode(IIlIIlll(new String("丅丝丅丅丁丕丐丙丝").intern()))));
      deadMethod.instructions.add((AbstractInsnNode)(new MethodInsnNode(182, IIlIIlll(new String("丁专丈与丝丕丁丅丝丝").intern()), IIlIIlll(new String("丙丝丁丅丝丝").intern()), IIlIIlll(new String("专丁专丈与丝丕丁丅丝丝丅丙丝").intern()), false)));
      deadMethod.instructions.add((AbstractInsnNode)(new InsnNode(177)));
      classNode.methods.add(deadMethod);
      Iterator var1 = classNode.methods.iterator();

      while(var1.hasNext()) {
         MethodNode method = (MethodNode)var1.next();
         InsnList instructions = method.instructions;
         if (instructions.size() > 0) {
            LabelNode startLabel = new LabelNode();
            instructions.insert(instructions.getFirst(), startLabel);
            instructions.insert(startLabel, new JumpInsnNode(167, startLabel));
            instructions.remove(startLabel.getNext());
         }
      }

   }

   private static void lIlIIlll(MethodNode methodNode) {
      InsnList instructions = methodNode.instructions;
      if (instructions.size() > 0) {
         for(int i = 0; i < instructions.size(); i += 2) {
            AbstractInsnNode insn = instructions.get(i);
            if (insn.getOpcode() != 159 && insn.getOpcode() != 132) {
               LabelNode label = new LabelNode();
               instructions.insertBefore(insn, label);
               instructions.insertBefore(insn, new InsnNode(0));
               instructions.insertBefore(insn, new JumpInsnNode(154, label));
               instructions.insertBefore(insn, new InsnNode(4));
            }
         }
      }

   }

   private static void IllIlIll(MethodNode methodNode) {
      List stringLiterals = new ArrayList();
      Iterator var2 = methodNode.instructions.iterator();

      while(var2.hasNext()) {
         AbstractInsnNode insn = (AbstractInsnNode)var2.next();
         if (insn instanceof LdcInsnNode && ((LdcInsnNode)insn).cst instanceof String) {
            stringLiterals.add((LdcInsnNode)insn);
         }
      }

      Iterator var6 = stringLiterals.iterator();

      while(var6.hasNext()) {
         LdcInsnNode stringLiteral = (LdcInsnNode)var6.next();
         String originalString = (String)stringLiteral.cst;
         String encryptedString = IIllllIl(originalString);
         String decryptMethodName = IllIIIIl();
         String decryptMethodDesc = IIlIIlll(new String("丁专丈与丝丕丁丅丝丝丅丙丝专丁专丈与丝").intern());
         if (!IllIlIlI(methodNode.classNode, decryptMethodName, decryptMethodDesc)) {
            lIllIllI(methodNode.classNode, decryptMethodName, decryptMethodDesc);
         }

         methodNode.instructions.insertBefore(stringLiteral, new LdcInsnNode(encryptedString));
         methodNode.instructions.set(stringLiteral, new MethodInsnNode(184, methodNode.classNode.name, decryptMethodName, decryptMethodDesc, false));
      }

   }

   private static String IIllllIl(String original) {
      StringBuilder sb = new StringBuilder();
      char[] var2 = original.toCharArray();
      int var3 = var2.length;

      for(int var4 = 0; var4 < var3; ++var4) {
         char c = var2[var4];
         sb.append(chineseChars[c % chineseChars.length]);
      }

      return sb.toString();
   }

   private static void lIllIllI(ClassNode classNode, String methodName, String methodDesc) {
      MethodNode decryptMethod = new MethodNode(10, methodName, methodDesc, (String)null, (String[])null);
      decryptMethod.visitCode();
      decryptMethod.visitTypeInsn(187, IIlIIlll(new String("丈丝丕专丅丝丙").intern()));
      decryptMethod.visitInsn(89);
      decryptMethod.visitMethodInsn(183, IIlIIlll(new String("丈丝丕专丅丝丙").intern()), IIlIIlll(new String("丅专专专").intern()), IIlIIlll(new String("专专丝专专丝").intern()), false);
      decryptMethod.visitVarInsn(58, 1);
      decryptMethod.visitVarInsn(25, 0);
      decryptMethod.visitMethodInsn(182, IIlIIlll(new String("丈丝丕专丅丝丙").intern()), IIlIIlll(new String("丙丅丅七丁专丈丕丝丝").intern()), IIlIIlll(new String("专专丁专专絲丝").intern()), false);
      decryptMethod.visitVarInsn(58, 2);
      decryptMethod.visitVarInsn(25, 2);
      decryptMethod.visitInsn(190);
      decryptMethod.visitVarInsn(54, 3);
      decryptMethod.visitInsn(3);
      decryptMethod.visitVarInsn(54, 4);
      Label labelStartLoop = new Label();
      decryptMethod.visitLabel(labelStartLoop);
      decryptMethod.visitVarInsn(21, 4);
      decryptMethod.visitVarInsn(21, 3);
      Label labelEndLoop = new Label();
      decryptMethod.visitJumpInsn(162, labelEndLoop);
      decryptMethod.visitVarInsn(25, 2);
      decryptMethod.visitVarInsn(21, 4);
      decryptMethod.visitInsn(50);
      decryptMethod.visitVarInsn(58, 5);
      decryptMethod.visitVarInsn(25, 1);
      decryptMethod.visitVarInsn(25, 5);
      decryptMethod.visitMethodInsn(182, IIlIIlll(new String("丈丝丕专丅丝丙").intern()), IIlIIlll(new String("与丙丙丝丝丁").intern()), IIlIIlll(new String("丁专专丝丁丈丝丕专丅丝丙絲丝").intern()), false);
      decryptMethod.visitInsn(87);
      decryptMethod.visitIincInsn(4, 1);
      decryptMethod.visitJumpInsn(167, labelStartLoop);
      decryptMethod.visitLabel(labelEndLoop);
      decryptMethod.visitVarInsn(25, 1);
      decryptMethod.visitMethodInsn(182, IIlIIlll(new String("丈丝丕专丅丝丙").intern()), IIlIIlll(new String("丅丝丝丁丙丝丝").intern()), IIlIIlll(new String("专专丝专专丝").intern()), false);
      decryptMethod.visitInsn(176);
      decryptMethod.visitMaxs(3, 6);
      decryptMethod.visitEnd();
      classNode.methods.add(decryptMethod);
   }

   private static boolean IllIlIlI(ClassNode classNode, String methodName, String methodDesc) {
      Iterator var3 = classNode.methods.iterator();

      MethodNode method;
      do {
         if (!var3.hasNext()) {
            return false;
         }

         method = (MethodNode)var3.next();
      } while(!method.name.equals(methodName) || !method.desc.equals(methodDesc));

      return true;
   }

   private static void lIIIIlll(MethodNode methodNode) {
      List numberLiterals = new ArrayList();
      Iterator var2 = methodNode.instructions.iterator();

      while(var2.hasNext()) {
         AbstractInsnNode insn = (AbstractInsnNode)var2.next();
         if (insn instanceof LdcInsnNode && ((LdcInsnNode)insn).cst instanceof Integer) {
            numberLiterals.add((LdcInsnNode)insn);
         }
      }

      Iterator var6 = numberLiterals.iterator();

      while(var6.hasNext()) {
         LdcInsnNode numberLiteral = (LdcInsnNode)var6.next();
         int originalNumber = (Integer)numberLiteral.cst;
         String obfuscatedNumber = lIlllIII(originalNumber);
         methodNode.instructions.insertBefore(numberLiteral, new LdcInsnNode(obfuscatedNumber));
         methodNode.instructions.remove(numberLiteral);
      }

   }

   private static String lIlllIII(int number) {
      return IIlIIlll(new String("专").intern()) + number + IllIIIIl();
   }

   private static void lIIlIlll(MethodNode methodNode) {
      if (methodNode.instructions.size() > 2) {
         InsnList nestedLoops = new InsnList();
         LabelNode startLoop1 = new LabelNode();
         LabelNode endLoop1 = new LabelNode();
         LabelNode startLoop2 = new LabelNode();
         LabelNode endLoop2 = new LabelNode();
         LabelNode startLoop3 = new LabelNode();
         LabelNode endLoop3 = new LabelNode();
         nestedLoops.add((AbstractInsnNode)(new InsnNode(3)));
         nestedLoops.add((AbstractInsnNode)(new VarInsnNode(54, 10)));
         nestedLoops.add(startLoop1);
         nestedLoops.add((AbstractInsnNode)(new VarInsnNode(21, 10)));
         pushInt(nestedLoops, 5);
         nestedLoops.add((AbstractInsnNode)(new JumpInsnNode(162, endLoop1)));
         nestedLoops.add((AbstractInsnNode)(new InsnNode(3)));
         nestedLoops.add((AbstractInsnNode)(new VarInsnNode(54, 11)));
         nestedLoops.add(startLoop2);
         nestedLoops.add((AbstractInsnNode)(new VarInsnNode(21, 11)));
         pushInt(nestedLoops, 100);
         nestedLoops.add((AbstractInsnNode)(new JumpInsnNode(162, endLoop2)));
         nestedLoops.add((AbstractInsnNode)(new InsnNode(3)));
         nestedLoops.add((AbstractInsnNode)(new VarInsnNode(54, 12)));
         nestedLoops.add(startLoop3);
         nestedLoops.add((AbstractInsnNode)(new VarInsnNode(21, 12)));
         pushInt(nestedLoops, 100);
         nestedLoops.add((AbstractInsnNode)(new JumpInsnNode(162, endLoop3)));
         nestedLoops.add((AbstractInsnNode)(new InsnNode(0)));
         nestedLoops.add((AbstractInsnNode)(new IincInsnNode(12, 1)));
         nestedLoops.add((AbstractInsnNode)(new JumpInsnNode(167, startLoop3)));
         nestedLoops.add(endLoop3);
         nestedLoops.add((AbstractInsnNode)(new IincInsnNode(11, 1)));
         nestedLoops.add((AbstractInsnNode)(new JumpInsnNode(167, startLoop2)));
         nestedLoops.add(endLoop2);
         nestedLoops.add((AbstractInsnNode)(new IincInsnNode(10, 1)));
         nestedLoops.add((AbstractInsnNode)(new JumpInsnNode(167, startLoop1)));
         nestedLoops.add(endLoop1);
         methodNode.instructions.insertBefore(methodNode.instructions.getFirst(), nestedLoops);
      }

   }

   private static void pushInt(InsnList list, int value) {
      if (value >= -1 && value <= 5) {
         list.add((AbstractInsnNode)(new InsnNode(3 + value)));
      } else if (value >= -128 && value <= 127) {
         list.add((AbstractInsnNode)(new IntInsnNode(16, value)));
      } else if (value >= -32768 && value <= 32767) {
         list.add((AbstractInsnNode)(new IntInsnNode(17, value)));
      } else {
         list.add((AbstractInsnNode)(new LdcInsnNode(value)));
      }

   }

   private static String IIlIIlll(String str) {
      StringBuilder sb = new StringBuilder();
      char[] var2 = str.toCharArray();
      int var3 = var2.length;

      for(int var4 = 0; var4 < var3; ++var4) {
         char c = var2[var4];
         sb.append(c);
      }

      return sb.toString();
   }
}

чо можно добавить? идеи в комменты кидайте, попробуйте деобфнуть
 
Ну как минимум крошить сурсы flow-вом ибо это тупо декомпилируеться и вставляться в проект без появления ошибок, а далее дебажиться
 
r3z написал(а):
вот щас у меня такой пример обфусцированного класса (моего же обфускатора):

Java:
Expand Collapse Copy 
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.jar.JarOutputStream;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.Label;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.FieldInsnNode;
import org.objectweb.asm.tree.InsnList;
import org.objectweb.asm.tree.InsnNode;
import org.objectweb.asm.tree.IntInsnNode;
import org.objectweb.asm.tree.JumpInsnNode;
import org.objectweb.asm.tree.LabelNode;
import org.objectweb.asm.tree.LdcInsnNode;
import org.objectweb.asm.tree.MethodInsnNode;
import org.objectweb.asm.tree.MethodNode;
import org.objectweb.asm.tree.VarInsnNode;

public class JarObfuscator {
   private static final Random random = new Random();
   private static final String[] chineseChars = new String[]{"一", "丁", "丂", "七", "丄", "丅", "丆", "万", "丈", "三", "上", "下", "丌", "不", "与", "丏", "丐", "丑", "丒", "专", "且", "丕", "世", "丗", "丘", "丙", "业", "丛", "东", "丝"};

   public static void main(String[] args) throws IOException {
      if (args.length != 2) {
         System.out.println(IIlIIlll(new String("七丂丅丆万丈三上下丌不与丏丐丑丒专且丕世丗丘丙业丛东丝").intern()));
         return;
      }

      String inputJarPath = args[0];
      String outputJarPath = args[1];
      lllIlIIl(inputJarPath, outputJarPath);
   }

   public static void lllIlIIl(String inputJarPath, String outputJarPath) throws IOException {
      java.io.File inputJarFile = new java.io.File(inputJarPath);
      java.io.File outputJarFile = new java.io.File(outputJarPath);
      if (!inputJarFile.exists()) {
         System.out.println(IIlIIlll(new String("七丂丅丆万丈三上不与丏丐丑丒专且丕世丗丘丙业丛东丝丝").intern()) + inputJarPath);
         return;
      }

      JarFile jarFile = new JarFile(inputJarFile);

      try {
         JarOutputStream jarOutputStream = new JarOutputStream(new java.io.FileOutputStream(outputJarFile));

         try {
            jarFile.stream().forEach((jarEntry) -> {
               try {
                  jarOutputStream.putNextEntry(new JarEntry(jarEntry.getName()));
                  if (jarEntry.isDirectory()) {
                     return;
                  }

                  if (jarEntry.getName().endsWith(IIlIIlll(new String("七七丂丂丁").intern()))) {
                     ClassReader classReader = new ClassReader(jarFile.getInputStream(jarEntry));
                     ClassNode classNode = new ClassNode();
                     classReader.accept(classNode, 0);
                     lIIlIIlI(classNode);
                     ClassWriter classWriter = new ClassWriter(3);
                     classNode.accept(classWriter);
                     byte[] modifiedBytecode = classWriter.toByteArray();
                     jarOutputStream.write(modifiedBytecode);
                  } else {
                     InputStream inputStream = jarFile.getInputStream(jarEntry);
                     byte[] buffer = inputStream.readAllBytes();
                     jarOutputStream.write(buffer);
                     inputStream.close();
                  }

                  jarOutputStream.closeEntry();
               } catch (IOException var11) {
                  var11.printStackTrace();
               }

            });
         } catch (Throwable var13) {
            try {
               jarOutputStream.close();
            } catch (Throwable var12) {
               var13.addSuppressed(var12);
            }

            throw var13;
         }

         jarOutputStream.close();
      } catch (Throwable var14) {
         try {
            jarFile.close();
         } catch (Throwable var10) {
            var14.addSuppressed(var10);
         }

         throw var14;
      }

      jarFile.close();
      System.out.println(IIlIIlll(new String("丆万丈三上不与丏丐丑丒专且丕世丗丘丙业丛东丝丝丝丝丝").intern()) + outputJarPath);
   }

   private static void lIIlIIlI(ClassNode classNode) {
      HashMap methodRenameMap = new HashMap();
      IllIIlIl(classNode);
      Iterator var2 = classNode.methods.iterator();

      while(var2.hasNext()) {
         MethodNode methodNode = (MethodNode)var2.next();
         if (!methodNode.name.equals(IIlIIlll(new String("与丗").intern())) && !methodNode.name.equals(IIlIIlll(new String("与丐丙丝").intern())) && !methodNode.name.equals(IIlIIlll(new String("与上丅丐").intern())) && !methodNode.name.equals(IIlIIlll(new String("丅专专专").intern())) && !methodNode.name.equals(IIlIIlll(new String("丅七丝七丅").intern()))) {
            lIllIIII(methodNode, methodRenameMap);
         }

         lIlIIlll(methodNode);
         IllIlIll(methodNode);
         lIIIIlll(methodNode);
         lIIlIlll(methodNode);
      }

      lIIlIlIl(classNode, methodRenameMap);
   }

   private static void lIllIIII(MethodNode methodNode, Map renameMap) {
      String originalName = methodNode.name;
      String obfuscatedName = IllIIIIl();
      methodNode.name = obfuscatedName;
      renameMap.put(originalName, obfuscatedName);
   }

   private static String IllIIIIl() {
      StringBuilder sb = new StringBuilder();
      int length = random.nextInt(50) + 2;

      for(int i = 0; i < length; ++i) {
         sb.append(random.nextBoolean() ? 'l' : 'I');
      }

      return sb.toString();
   }

   private static void lIIlIlIl(ClassNode classNode, Map renameMap) {
      Iterator var2 = classNode.methods.iterator();

      while(var2.hasNext()) {
         MethodNode methodNode = (MethodNode)var2.next();
         Iterator var4 = methodNode.instructions.iterator();

         while(var4.hasNext()) {
            AbstractInsnNode insn = (AbstractInsnNode)var4.next();
            if (insn instanceof MethodInsnNode) {
               MethodInsnNode methodInsn = (MethodInsnNode)insn;
               if (renameMap.containsKey(methodInsn.name) && methodInsn.owner.equals(classNode.name)) {
                  methodInsn.name = (String)renameMap.get(methodInsn.name);
               }
            }
         }
      }

   }

   private static void IllIIlIl(ClassNode classNode) {
      MethodNode deadMethod = new MethodNode(2, IIlIIlll(new String("上丅丐丙丝丁").intern()) + random.nextInt(1000), IIlIIlll(new String("专专丝").intern()), (String)null, (String[])null);
      deadMethod.instructions.add((AbstractInsnNode)(new FieldInsnNode(178, IIlIIlll(new String("丈上丝专丈专").intern()), IIlIIlll(new String("与丝丅").intern()), IIlIIlll(new String("丁专丈与丝丕丁丅丝丝").intern()))));
      deadMethod.instructions.add((AbstractInsnNode)(new LdcInsnNode(IIlIIlll(new String("丅丝丅丅丁丕丐丙丝").intern()))));
      deadMethod.instructions.add((AbstractInsnNode)(new MethodInsnNode(182, IIlIIlll(new String("丁专丈与丝丕丁丅丝丝").intern()), IIlIIlll(new String("丙丝丁丅丝丝").intern()), IIlIIlll(new String("专丁专丈与丝丕丁丅丝丝丅丙丝").intern()), false)));
      deadMethod.instructions.add((AbstractInsnNode)(new InsnNode(177)));
      classNode.methods.add(deadMethod);
      Iterator var1 = classNode.methods.iterator();

      while(var1.hasNext()) {
         MethodNode method = (MethodNode)var1.next();
         InsnList instructions = method.instructions;
         if (instructions.size() > 0) {
            LabelNode startLabel = new LabelNode();
            instructions.insert(instructions.getFirst(), startLabel);
            instructions.insert(startLabel, new JumpInsnNode(167, startLabel));
            instructions.remove(startLabel.getNext());
         }
      }

   }

   private static void lIlIIlll(MethodNode methodNode) {
      InsnList instructions = methodNode.instructions;
      if (instructions.size() > 0) {
         for(int i = 0; i < instructions.size(); i += 2) {
            AbstractInsnNode insn = instructions.get(i);
            if (insn.getOpcode() != 159 && insn.getOpcode() != 132) {
               LabelNode label = new LabelNode();
               instructions.insertBefore(insn, label);
               instructions.insertBefore(insn, new InsnNode(0));
               instructions.insertBefore(insn, new JumpInsnNode(154, label));
               instructions.insertBefore(insn, new InsnNode(4));
            }
         }
      }

   }

   private static void IllIlIll(MethodNode methodNode) {
      List stringLiterals = new ArrayList();
      Iterator var2 = methodNode.instructions.iterator();

      while(var2.hasNext()) {
         AbstractInsnNode insn = (AbstractInsnNode)var2.next();
         if (insn instanceof LdcInsnNode && ((LdcInsnNode)insn).cst instanceof String) {
            stringLiterals.add((LdcInsnNode)insn);
         }
      }

      Iterator var6 = stringLiterals.iterator();

      while(var6.hasNext()) {
         LdcInsnNode stringLiteral = (LdcInsnNode)var6.next();
         String originalString = (String)stringLiteral.cst;
         String encryptedString = IIllllIl(originalString);
         String decryptMethodName = IllIIIIl();
         String decryptMethodDesc = IIlIIlll(new String("丁专丈与丝丕丁丅丝丝丅丙丝专丁专丈与丝").intern());
         if (!IllIlIlI(methodNode.classNode, decryptMethodName, decryptMethodDesc)) {
            lIllIllI(methodNode.classNode, decryptMethodName, decryptMethodDesc);
         }

         methodNode.instructions.insertBefore(stringLiteral, new LdcInsnNode(encryptedString));
         methodNode.instructions.set(stringLiteral, new MethodInsnNode(184, methodNode.classNode.name, decryptMethodName, decryptMethodDesc, false));
      }

   }

   private static String IIllllIl(String original) {
      StringBuilder sb = new StringBuilder();
      char[] var2 = original.toCharArray();
      int var3 = var2.length;

      for(int var4 = 0; var4 < var3; ++var4) {
         char c = var2[var4];
         sb.append(chineseChars[c % chineseChars.length]);
      }

      return sb.toString();
   }

   private static void lIllIllI(ClassNode classNode, String methodName, String methodDesc) {
      MethodNode decryptMethod = new MethodNode(10, methodName, methodDesc, (String)null, (String[])null);
      decryptMethod.visitCode();
      decryptMethod.visitTypeInsn(187, IIlIIlll(new String("丈丝丕专丅丝丙").intern()));
      decryptMethod.visitInsn(89);
      decryptMethod.visitMethodInsn(183, IIlIIlll(new String("丈丝丕专丅丝丙").intern()), IIlIIlll(new String("丅专专专").intern()), IIlIIlll(new String("专专丝专专丝").intern()), false);
      decryptMethod.visitVarInsn(58, 1);
      decryptMethod.visitVarInsn(25, 0);
      decryptMethod.visitMethodInsn(182, IIlIIlll(new String("丈丝丕专丅丝丙").intern()), IIlIIlll(new String("丙丅丅七丁专丈丕丝丝").intern()), IIlIIlll(new String("专专丁专专絲丝").intern()), false);
      decryptMethod.visitVarInsn(58, 2);
      decryptMethod.visitVarInsn(25, 2);
      decryptMethod.visitInsn(190);
      decryptMethod.visitVarInsn(54, 3);
      decryptMethod.visitInsn(3);
      decryptMethod.visitVarInsn(54, 4);
      Label labelStartLoop = new Label();
      decryptMethod.visitLabel(labelStartLoop);
      decryptMethod.visitVarInsn(21, 4);
      decryptMethod.visitVarInsn(21, 3);
      Label labelEndLoop = new Label();
      decryptMethod.visitJumpInsn(162, labelEndLoop);
      decryptMethod.visitVarInsn(25, 2);
      decryptMethod.visitVarInsn(21, 4);
      decryptMethod.visitInsn(50);
      decryptMethod.visitVarInsn(58, 5);
      decryptMethod.visitVarInsn(25, 1);
      decryptMethod.visitVarInsn(25, 5);
      decryptMethod.visitMethodInsn(182, IIlIIlll(new String("丈丝丕专丅丝丙").intern()), IIlIIlll(new String("与丙丙丝丝丁").intern()), IIlIIlll(new String("丁专专丝丁丈丝丕专丅丝丙絲丝").intern()), false);
      decryptMethod.visitInsn(87);
      decryptMethod.visitIincInsn(4, 1);
      decryptMethod.visitJumpInsn(167, labelStartLoop);
      decryptMethod.visitLabel(labelEndLoop);
      decryptMethod.visitVarInsn(25, 1);
      decryptMethod.visitMethodInsn(182, IIlIIlll(new String("丈丝丕专丅丝丙").intern()), IIlIIlll(new String("丅丝丝丁丙丝丝").intern()), IIlIIlll(new String("专专丝专专丝").intern()), false);
      decryptMethod.visitInsn(176);
      decryptMethod.visitMaxs(3, 6);
      decryptMethod.visitEnd();
      classNode.methods.add(decryptMethod);
   }

   private static boolean IllIlIlI(ClassNode classNode, String methodName, String methodDesc) {
      Iterator var3 = classNode.methods.iterator();

      MethodNode method;
      do {
         if (!var3.hasNext()) {
            return false;
         }

         method = (MethodNode)var3.next();
      } while(!method.name.equals(methodName) || !method.desc.equals(methodDesc));

      return true;
   }

   private static void lIIIIlll(MethodNode methodNode) {
      List numberLiterals = new ArrayList();
      Iterator var2 = methodNode.instructions.iterator();

      while(var2.hasNext()) {
         AbstractInsnNode insn = (AbstractInsnNode)var2.next();
         if (insn instanceof LdcInsnNode && ((LdcInsnNode)insn).cst instanceof Integer) {
            numberLiterals.add((LdcInsnNode)insn);
         }
      }

      Iterator var6 = numberLiterals.iterator();

      while(var6.hasNext()) {
         LdcInsnNode numberLiteral = (LdcInsnNode)var6.next();
         int originalNumber = (Integer)numberLiteral.cst;
         String obfuscatedNumber = lIlllIII(originalNumber);
         methodNode.instructions.insertBefore(numberLiteral, new LdcInsnNode(obfuscatedNumber));
         methodNode.instructions.remove(numberLiteral);
      }

   }

   private static String lIlllIII(int number) {
      return IIlIIlll(new String("专").intern()) + number + IllIIIIl();
   }

   private static void lIIlIlll(MethodNode methodNode) {
      if (methodNode.instructions.size() > 2) {
         InsnList nestedLoops = new InsnList();
         LabelNode startLoop1 = new LabelNode();
         LabelNode endLoop1 = new LabelNode();
         LabelNode startLoop2 = new LabelNode();
         LabelNode endLoop2 = new LabelNode();
         LabelNode startLoop3 = new LabelNode();
         LabelNode endLoop3 = new LabelNode();
         nestedLoops.add((AbstractInsnNode)(new InsnNode(3)));
         nestedLoops.add((AbstractInsnNode)(new VarInsnNode(54, 10)));
         nestedLoops.add(startLoop1);
         nestedLoops.add((AbstractInsnNode)(new VarInsnNode(21, 10)));
         pushInt(nestedLoops, 5);
         nestedLoops.add((AbstractInsnNode)(new JumpInsnNode(162, endLoop1)));
         nestedLoops.add((AbstractInsnNode)(new InsnNode(3)));
         nestedLoops.add((AbstractInsnNode)(new VarInsnNode(54, 11)));
         nestedLoops.add(startLoop2);
         nestedLoops.add((AbstractInsnNode)(new VarInsnNode(21, 11)));
         pushInt(nestedLoops, 100);
         nestedLoops.add((AbstractInsnNode)(new JumpInsnNode(162, endLoop2)));
         nestedLoops.add((AbstractInsnNode)(new InsnNode(3)));
         nestedLoops.add((AbstractInsnNode)(new VarInsnNode(54, 12)));
         nestedLoops.add(startLoop3);
         nestedLoops.add((AbstractInsnNode)(new VarInsnNode(21, 12)));
         pushInt(nestedLoops, 100);
         nestedLoops.add((AbstractInsnNode)(new JumpInsnNode(162, endLoop3)));
         nestedLoops.add((AbstractInsnNode)(new InsnNode(0)));
         nestedLoops.add((AbstractInsnNode)(new IincInsnNode(12, 1)));
         nestedLoops.add((AbstractInsnNode)(new JumpInsnNode(167, startLoop3)));
         nestedLoops.add(endLoop3);
         nestedLoops.add((AbstractInsnNode)(new IincInsnNode(11, 1)));
         nestedLoops.add((AbstractInsnNode)(new JumpInsnNode(167, startLoop2)));
         nestedLoops.add(endLoop2);
         nestedLoops.add((AbstractInsnNode)(new IincInsnNode(10, 1)));
         nestedLoops.add((AbstractInsnNode)(new JumpInsnNode(167, startLoop1)));
         nestedLoops.add(endLoop1);
         methodNode.instructions.insertBefore(methodNode.instructions.getFirst(), nestedLoops);
      }

   }

   private static void pushInt(InsnList list, int value) {
      if (value >= -1 && value <= 5) {
         list.add((AbstractInsnNode)(new InsnNode(3 + value)));
      } else if (value >= -128 && value <= 127) {
         list.add((AbstractInsnNode)(new IntInsnNode(16, value)));
      } else if (value >= -32768 && value <= 32767) {
         list.add((AbstractInsnNode)(new IntInsnNode(17, value)));
      } else {
         list.add((AbstractInsnNode)(new LdcInsnNode(value)));
      }

   }

   private static String IIlIIlll(String str) {
      StringBuilder sb = new StringBuilder();
      char[] var2 = str.toCharArray();
      int var3 = var2.length;

      for(int var4 = 0; var4 < var3; ++var4) {
         char c = var2[var4];
         sb.append(c);
      }

      return sb.toString();
   }
}

чо можно добавить? идеи в комменты кидайте, попробуйте деобфнуть
Нажмите для раскрытия...
чуть переделал обфускатор, теперь такая обфа после:

Java:
Expand Collapse Copy 
import org.objectweb.asm.*;
import org.objectweb.asm.tree.*;
import java.io.*;
import java.util.*;
import java.util.jar.*;

public class JarObfuscator {

    private static final Random RANDOM = new Random();
    private static final String CHINESE_CHARS = "的了一是不在人有我他这为之大来以个中上们到说国和地也子时道得经都去对家可过还发用作你物自成方后多事于学机能无经与出小口setcounter此间么样看起生里头本加电相面想前所两西行动作教总";
    private static final String NAME_CHARS = "lI";

    public static void main(String[] args) throws IOException {
        InsnList deadCode0 = lIIlIIlI();
        if (args.length != Integer.parseInt("1Il0")) {
            InsnList emptyLoop0 = lIlIIlll();
            System.out.println("的了是不在人有我他这为之大来以个中上们到说国和地也子时道得经都去对家可过还发用作你物自成方后多事于学机能无经与出小口setcounter此间么样看起生里头本加电相面想前所两西行动作教总的了是不在人有我他这为之大来");
            return;
        }
        String lIlIIlII = args[Integer.parseInt("10")];
        String IllIllIl = args[Integer.parseInt("1l")];

        IlllIIlIlI(lIlIIlII, IllIllIl);
        System.out.println("的了是不在人有我他这为之大来以个中上们到说国和地也子时道得经都去对家可过还发用作你物自成方后多事于学机能无经与出小口setcounter此间么样看起生里头本加电相面想前所两西行动作教总的了是不在人有我他这为之大来" + IllIllIl);
    }

    public static void IlllIIlIlI(String lIlIIlII, String IllIllIl) throws IOException {
        File IllIIlII = new File(lIlIIlII);
        File lIIlIllI = new File(IllIllIl);

        InsnList deadCode1 = lIIlIIlI();
        if (!IllIIlII.exists()) {
            InsnList emptyLoop1 = lIlIIlll();
            System.err.println("的了是不在人有我他这为之大来以个中上们到说国和地也子时道得经都去对家可过还发用作你物自成方后多事于学机能无经与出小口setcounter此间么样看起生里头本加电相面想前所两西行动作教总的了是不在人有我他这为之大来" + lIlIIlII);
            return;
        }

        try (JarFile lIlIlIll = new JarFile(IllIIlII);
             JarOutputStream IllIlIlI = new JarOutputStream(new FileOutputStream(lIIlIllI))) {

            Enumeration<JarEntry> lIIIIlll = lIlIlIll.entries();
            while (lIIIIlll.hasMoreElements()) {
                JarEntry IllIIIII = lIIIIlll.nextElement();
                InputStream lIIlIIII = lIlIlIll.getInputStream(IllIIIII);

                if (IllIIIII.getName().endsWith("的了是不在人有我他这为之大来以个中上们到说国和地也子时道得经都去对家可过还发用作你物自成方后多事于学机能无经与出小口setcounter此间么样看起生里头本加电相面想前所两西行动作教总")) {
                    ClassNode lIIlIlII = new ClassNode();
                    ClassReader IllIllII = new ClassReader(lIIlIIII);
                    IllIllII.accept(lIIlIlII, Integer.parseInt("10"));

                    lIlIIlIlI(lIIlIlII);
                    lIllIIIII(lIIlIlII);
                    lIlIllIII(lIIlIlII);
                    lIlllIIII(lIIlIlII);
                    lIIlIIIII(lIIlIlII);

                    ClassWriter lIIIIlII = new ClassWriter(ClassWriter.COMPUTE_MAXS);
                    lIIlIlII.accept(lIIIIlII);
                    byte[] IllIlIll = lIIIIlII.toByteArray();

                    JarEntry lIIIlIll = new JarEntry(IllIIIII.getName());
                    IllIlIlI.putNextEntry(lIIIlIll);
                    IllIlIlI.write(IllIlIll);
                    IllIlIlI.closeEntry();

                } else {
                    JarEntry lIIIlIll = new JarEntry(IllIIIII.getName());
                    IllIlIlI.putNextEntry(lIIIlIll);
                    lIIlIIII.transferTo(IllIlIlI);
                    IllIlIlI.closeEntry();
                }
                lIIlIIII.close();
            }
        }
    }

    private static void lIlIIlIlI(ClassNode lIIlIlII) {
        for (MethodNode IlllIIII : lIIlIlII.methods) {
            InsnList emptyLoop2 = lIlIIlll();
            if (IlllIIII.instructions.size() > Integer.parseInt("10") && IlllIIII.name.indexOf("的了是不在人有我他这为之大来以个中上们到说国和地也子时道得经都去对家可过还发用作你物自成方后多事于学机能无经与出小口setcounter此间么样看起生里头本加电相面想前所两西行动作教总") == -Integer.parseInt("1l") && IlllIIII.name.indexOf("的了是不在人有我他这为之大来以个中上们到说国和地也子时道得经都去对家可过还发用作你物自成方后多事于学机能无经与出小口setcounter此间么样看起生里头本加电相面想前所两西行动作教总") == -Integer.parseInt("1l")) {
                ListIterator<AbstractInsnNode> lIIIIIll = IlllIIII.instructions.iterator();
                while (lIIIIIll.hasNext()) {
                    lIIIIIll.next();
                    InsnList emptyLoop3 = lIlIIlll();
                    if (RANDOM.nextDouble() < 0.1) {
                        InsnList deadCode2 = lIIlIIlI();
                        lIIIIIll.add(deadCode2);
                    }
                }
            }
        }
    }

    private static void lIllIIIII(ClassNode lIIlIlII) {
        for (MethodNode IlllIIII : lIIlIlII.methods) {
            if (IlllIIII.instructions.size() > Integer.parseInt("10") && IlllIIII.name.indexOf("的了是不在人有我他这为之大来以个中上们到说国和地也子时道得经都去对家可过还发用作你物自成方后多事于学机能无经与出小口setcounter此间么样看起生里头本加电相面想前所两西行动作教总") == -Integer.parseInt("1l") && IlllIIII.name.indexOf("的了是不在人有我他这为之大来以个中上们到说国和地也子时道得经都去对家可过还发用作你物自成方后多事于学机能无经与出小口setcounter此间么样看起生里头本加电相面想前所两西行动作教总") == -Integer.parseInt("1l")) {
                ListIterator<AbstractInsnNode> lIIIIIll = IlllIIII.instructions.iterator();
                while (lIIIIIll.hasNext()) {
                    lIIIIIll.next();
                    if (RANDOM.nextDouble() < 0.2) {
                        lIIIIIll.add(lIlIIlll());
                    }
                }
            }
        }
    }

    private static void lIlIllIII(ClassNode lIIlIlII) {
        List<LdcInsnNode> IlllIlll = new ArrayList<>();
        for (MethodNode IlllIIII : lIIlIlII.methods) {
            for (AbstractInsnNode IllIIlIl : IlllIIII.instructions) {
                if (IllIIlIl instanceof LdcInsnNode) {
                    LdcInsnNode IlllIIll = (LdcInsnNode) IllIIlIl;
                    if (IlllIIll.cst instanceof String) {
                        IlllIlll.add(IlllIIll);
                    }
                }
            }
        }

        if (!IlllIlll.isEmpty()) {
            IllIlIIII(lIIlIlII);
            for (LdcInsnNode IlllIIll : IlllIlll) {
                String lIIlIIll = (String) IlllIIll.cst;
                String IllIllll = IllIIIIII(lIIlIIll);

                InsnList lIlIIIII = new InsnList();
                lIlIIIII.add(new LdcInsnNode(IllIllll));
                lIlIIIII.add(new MethodInsnNode(
                        Opcodes.INVOKESTATIC,
                        lIIlIlII.name,
                        "decryptString",
                        "(Ljava/lang/String;)Ljava/lang/String;",
                        false
                ));

                MethodNode IllIIlll = IllIlIIlI(lIIlIlII, IlllIIll);
                if (IllIIlll != null) {
                    IllIIlll.instructions.insertBefore(IlllIIll, lIlIIIII);
                    IllIIlll.instructions.remove(IlllIIll);
                }
            }
        }
    }

    private static void lIlllIIII(ClassNode lIIlIlII) {
        for (MethodNode IlllIIII : lIIlIlII.methods) {
            ListIterator<AbstractInsnNode> lIIIIIll = IlllIIII.instructions.iterator();
            while (lIIIIIll.hasNext()) {
                AbstractInsnNode IllIIlIl = lIIIIIll.next();
                if (IllIIlIl instanceof IntInsnNode && IllIIlIl.getOpcode() >= Opcodes.ICONST_M1 && IllIIlIl.getOpcode() <= Opcodes.BIPUSH) {
                    int lIIlIlll = lIllIIIlI((IntInsnNode)IllIIlIl);
                    String IllIllIl = lIllIIlII(lIIlIlll);
                    InsnList lIlIIIII = lIlIIIIlI(IllIllIl);
                    lIIIIIll.remove();
                    lIIIIIll.add(lIlIIIII.getFirst());
                    for(int i = Integer.parseInt("10"); i < lIlIIIII.size(); ++i) lIIIIIll.add(lIlIIIII.get(i));

                } else if (IllIIlIl instanceof LdcInsnNode) {
                    LdcInsnNode IlllIIll = (LdcInsnNode) IllIIlIl;
                    if (IlllIIll.cst instanceof Integer) {
                        int lIIlIlll = (int) IlllIIll.cst;
                        String IllIllIl = lIllIIlII(lIIlIlll);
                        InsnList lIlIIIII = lIlIIIIlI(IllIllIl);
                        lIIIIIll.remove();
                        lIIIIIll.add(lIlIIIII.getFirst());
                        for(int i = Integer.parseInt("10"); i < lIlIIIII.size(); ++i) lIIIIIll.add(lIlIIIII.get(i));
                    }
                }
            }
        }
    }

    private static void lIIlIIIII(ClassNode lIIlIlII) {
        Map<String, String> IllIIlII = new HashMap<>();
        for (MethodNode IlllIIII : lIIlIlII.methods) {
            if (IlllIIII.name.indexOf("的了是不在人有我他这为之大来以个中上们到说国和地也子时道得经都去对家可过还发用作你物自成方后多事于学机能无经与出小口setcounter此间么样看起生里头本加电相面想前所两西行动作教总") == -Integer.parseInt("1l") && IlllIIII.name.indexOf("的了是不在人有我他这为之大来以个中上们到说国和地也子时道得经都去对家可过还发用作你物自成方后多事于学机能无经与出小口setcounter此间么样看起生里头本加电相面想前所两西行动作教总") == -Integer.parseInt("1l")) {
                String IllIllIl = lIIllIIIl(Integer.parseInt("1lIlIlIl0") + RANDOM.nextInt(Integer.parseInt("1lIlIlIl0")));
                IllIIlII.put(IlllIIII.name + IlllIIII.desc, IllIllIl);
                IlllIIII.name = IllIllIl;
            }
        }

        for (MethodNode IlllIIII : lIIlIlII.methods) {
            for (AbstractInsnNode IllIIlIl : IlllIIII.instructions) {
                if (IllIIlIl instanceof MethodInsnNode) {
                    MethodInsnNode lIIIIIIl = (MethodInsnNode) IllIIlIl;
                    String lIIIIlIl = lIIIIIIl.name + lIIIIIIl.desc;
                    if (IllIIlII.containsKey(lIIIIlIl)) {
                        lIIIIIIl.name = IllIIlII.get(lIIIIlIl);
                    }
                }
            }
        }
    }

    private static MethodNode IllIlIIlI(ClassNode lIIlIlII, AbstractInsnNode instruction) {
        for (MethodNode IlllIIII : lIIlIlII.methods) {
            if (IlllIIII.instructions.contains(instruction)) {
                return IlllIIII;
            }
        }
        return null;
    }

    private static void IllIlIIII(ClassNode lIIlIlII) {
        MethodNode IllIllIl = new MethodNode(Opcodes.ACC_PRIVATE + Opcodes.ACC_STATIC, "decryptString", "(Ljava/lang/String;)Ljava/lang/String;", null, null);
        InsnList instructions = IllIllIl.instructions;

        instructions.add(new TypeInsnNode(Opcodes.NEW, "java/lang/StringBuilder"));
        instructions.add(new InsnNode(Opcodes.DUP));
        instructions.add(new MethodInsnNode(Opcodes.INVOKESPECIAL, "java/lang/StringBuilder", "<init>", "()V", false));
        instructions.add(new VarInsnNode(Opcodes.ASTORE, Integer.parseInt("1lIlIl00")));
        instructions.add(new InsnNode(Opcodes.ICONST_0));
        instructions.add(new VarInsnNode(Opcodes.ISTORE, Integer.parseInt("1Il0")));
        LabelNode loopStart = new LabelNode();
        LabelNode loopEnd = new LabelNode();
        instructions.add(loopStart);
        instructions.add(new VarInsnNode(Opcodes.ILOAD, Integer.parseInt("1Il0")));
        instructions.add(new VarInsnNode(Opcodes.ALOAD, Integer.parseInt("10")));
        instructions.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, "java/lang/String", "length", "()I", false));
        instructions.add(new JumpInsnNode(Opcodes.IF_ICMPGE, loopEnd));
        instructions.add(new VarInsnNode(Opcodes.ALOAD, Integer.parseInt("1lIlIl00")));
        instructions.add(new VarInsnNode(Opcodes.ALOAD, Integer.parseInt("10")));
        instructions.add(new VarInsnNode(Opcodes.ILOAD, Integer.parseInt("1Il0")));
        instructions.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, "java/lang/String", "charAt", "(I)C", false));
        instructions.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(C)Ljava/lang/StringBuilder;", false));
        instructions.add(new InsnNode(Opcodes.POP));
        instructions.add(new IincInsnNode(Integer.parseInt("1Il0"), Integer.parseInt("1l")));
        instructions.add(new JumpInsnNode(Opcodes.GOTO, loopStart));
        instructions.add(loopEnd);
        instructions.add(new VarInsnNode(Opcodes.ALOAD, Integer.parseInt("1lIlIl00")));
        instructions.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder", "toString", "()Ljava/lang/String;", false));
        instructions.add(new InsnNode(Opcodes.ARETURN));

        IllIllIl.maxStack = Integer.parseInt("1Il0");
        IllIllIl.maxLocals = Integer.parseInt("1ll");
        lIIlIlII.methods.add(IllIllIl);
    }

    private static String IllIIIIII(String text) {
        StringBuilder sb = new StringBuilder();
        for (int i = Integer.parseInt("10"); i < Integer.parseInt("1IllIll"); i++) {
            sb.append(CHINESE_CHARS.charAt(RANDOM.nextInt(CHINESE_CHARS.length())));
        }
        return sb.toString();
    }


    private static String lIllIIlII(int number) {
        String chars = "lI01";
        String prefix = "1";
        String suffix = String.valueOf(RANDOM.nextInt(Integer.parseInt("1Ill")));
        String middle = "";
        String numStr = String.valueOf(number);
        for(char digit : numStr.toCharArray()) {
            middle += chars.charAt(digit - '0');
        }
        return prefix + middle + suffix;
    }


    private static InsnList lIlIIIIlI(String obfuscatedNumber) {
        InsnList instructions = new InsnList();
        instructions.add(new LdcInsnNode(obfuscatedNumber));
        instructions.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "java/lang/Integer", "parseInt", "(Ljava/lang/String;)I", false));
        return instructions;
    }


    private static InsnList lIIlIIlI() {
        InsnList nestedLoops = new InsnList();
        LabelNode loop1Start = new LabelNode();
        LabelNode loop1End = new LabelNode();
        LabelNode loop2Start = new LabelNode();
        LabelNode loop2End = new LabelNode();
        LabelNode loop3Start = new LabelNode();
        LabelNode loop3End = new LabelNode();

        nestedLoops.add(new InsnNode(Opcodes.ICONST_0));
        nestedLoops.add(new VarInsnNode(Opcodes.ISTORE, Integer.parseInt("1llllll00")));

        nestedLoops.add(loop1Start);
        nestedLoops.add(new VarInsnNode(Opcodes.ILOAD, Integer.parseInt("1llllll00")));
        nestedLoops.add(new InsnNode(Opcodes.ICONST_3));
        nestedLoops.add(new JumpInsnNode(Opcodes.IF_ICMPGE, loop1End));

        nestedLoops.add(new InsnNode(Opcodes.ICONST_0));
        nestedLoops.add(new VarInsnNode(Opcodes.ISTORE, Integer.parseInt("1llllll0l")));

        nestedLoops.add(loop2Start);
        nestedLoops.add(new VarInsnNode(Opcodes.ILOAD, Integer.parseInt("1llllll0l")));
        nestedLoops.add(new InsnNode(Opcodes.ICONST_3));
        nestedLoops.add(new JumpInsnNode(Opcodes.IF_ICMPGE, loop2End));

        nestedLoops.add(new InsnNode(Opcodes.ICONST_0));
        nestedLoops.add(new VarInsnNode(Opcodes.ISTORE, Integer.parseInt("1llllll10")));

        nestedLoops.add(loop3Start);
        nestedLoops.add(new VarInsnNode(Opcodes.ILOAD, Integer.parseInt("1llllll10")));
        nestedLoops.add(new InsnNode(Opcodes.ICONST_3));
        nestedLoops.add(new JumpInsnNode(Opcodes.IF_ICMPGE, loop3End));

        nestedLoops.add(new InsnNode(Opcodes.NOP));

        nestedLoops.add(new IincInsnNode(Integer.parseInt("1llllll10"), Integer.parseInt("1l")));
        nestedLoops.add(new JumpInsnNode(Opcodes.GOTO, loop3Start));
        nestedLoops.add(loop3End);

        nestedLoops.add(new IincInsnNode(Integer.parseInt("1llllll0l"), Integer.parseInt("1l")));
        nestedLoops.add(new JumpInsnNode(Opcodes.GOTO, loop2Start));
        nestedLoops.add(loop2End);

        nestedLoops.add(new IincInsnNode(Integer.parseInt("1llllll00"), Integer.parseInt("1l")));
        nestedLoops.add(new JumpInsnNode(Opcodes.GOTO, loop1Start));
        nestedLoops.add(loop1End);

        return nestedLoops;
    }


    private static InsnList lIlIIlll() {
        InsnList emptyLoop = new InsnList();
        LabelNode loopStart = new LabelNode();
        LabelNode loopEnd = new LabelNode();

        emptyLoop.add(new InsnNode(Opcodes.ICONST_0));
        emptyLoop.add(new VarInsnNode(Opcodes.ISTORE, Integer.parseInt("1llllll11")));
        emptyLoop.add(loopStart);
        emptyLoop.add(new VarInsnNode(Opcodes.ILOAD, Integer.parseInt("1llllll11")));
        emptyLoop.add(new InsnNode(Opcodes.ICONST_2));
        emptyLoop.add(new JumpInsnNode(Opcodes.IF_ICMPGE, loopEnd));
        emptyLoop.add(new IincInsnNode(Integer.parseInt("1llllll11"), Integer.parseInt("1l")));
        emptyLoop.add(new JumpInsnNode(Opcodes.GOTO, loopStart));
        emptyLoop.add(loopEnd);
        return emptyLoop;
    }

    private static int lIllIIIlI(IntInsnNode insnNode) {
        int opcode = insnNode.getOpcode();
        if (opcode >= Opcodes.ICONST_M1 && opcode <= Opcodes.ICONST_5) {
            return opcode - Opcodes.ICONST_0;
        } else if (opcode == Opcodes.BIPUSH || opcode == Opcodes.SIPUSH) {
            return insnNode.operand;
        }
        return Integer.parseInt("10");
    }

    private static String lIIllIIIl(int length) {
        StringBuilder sb = new StringBuilder();
        for (int i = Integer.parseInt("10"); i < length; i++) {
            sb.append(NAME_CHARS.charAt(RANDOM.nextInt(NAME_CHARS.length())));
        }
        return sb.toString();
    }
}
 
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
r3z написал(а):
чуть переделал обфускатор, теперь такая обфа после:

Java:
Expand Collapse Copy 
import org.objectweb.asm.*;
import org.objectweb.asm.tree.*;
import java.io.*;
import java.util.*;
import java.util.jar.*;

public class JarObfuscator {

    private static final Random RANDOM = new Random();
    private static final String CHINESE_CHARS = "的了一是不在人有我他这为之大来以个中上们到说国和地也子时道得经都去对家可过还发用作你物自成方后多事于学机能无经与出小口setcounter此间么样看起生里头本加电相面想前所两西行动作教总";
    private static final String NAME_CHARS = "lI";

    public static void main(String[] args) throws IOException {
        InsnList deadCode0 = lIIlIIlI();
        if (args.length != Integer.parseInt("1Il0")) {
            InsnList emptyLoop0 = lIlIIlll();
            System.out.println("的了是不在人有我他这为之大来以个中上们到说国和地也子时道得经都去对家可过还发用作你物自成方后多事于学机能无经与出小口setcounter此间么样看起生里头本加电相面想前所两西行动作教总的了是不在人有我他这为之大来");
            return;
        }
        String lIlIIlII = args[Integer.parseInt("10")];
        String IllIllIl = args[Integer.parseInt("1l")];

        IlllIIlIlI(lIlIIlII, IllIllIl);
        System.out.println("的了是不在人有我他这为之大来以个中上们到说国和地也子时道得经都去对家可过还发用作你物自成方后多事于学机能无经与出小口setcounter此间么样看起生里头本加电相面想前所两西行动作教总的了是不在人有我他这为之大来" + IllIllIl);
    }

    public static void IlllIIlIlI(String lIlIIlII, String IllIllIl) throws IOException {
        File IllIIlII = new File(lIlIIlII);
        File lIIlIllI = new File(IllIllIl);

        InsnList deadCode1 = lIIlIIlI();
        if (!IllIIlII.exists()) {
            InsnList emptyLoop1 = lIlIIlll();
            System.err.println("的了是不在人有我他这为之大来以个中上们到说国和地也子时道得经都去对家可过还发用作你物自成方后多事于学机能无经与出小口setcounter此间么样看起生里头本加电相面想前所两西行动作教总的了是不在人有我他这为之大来" + lIlIIlII);
            return;
        }

        try (JarFile lIlIlIll = new JarFile(IllIIlII);
             JarOutputStream IllIlIlI = new JarOutputStream(new FileOutputStream(lIIlIllI))) {

            Enumeration<JarEntry> lIIIIlll = lIlIlIll.entries();
            while (lIIIIlll.hasMoreElements()) {
                JarEntry IllIIIII = lIIIIlll.nextElement();
                InputStream lIIlIIII = lIlIlIll.getInputStream(IllIIIII);

                if (IllIIIII.getName().endsWith("的了是不在人有我他这为之大来以个中上们到说国和地也子时道得经都去对家可过还发用作你物自成方后多事于学机能无经与出小口setcounter此间么样看起生里头本加电相面想前所两西行动作教总")) {
                    ClassNode lIIlIlII = new ClassNode();
                    ClassReader IllIllII = new ClassReader(lIIlIIII);
                    IllIllII.accept(lIIlIlII, Integer.parseInt("10"));

                    lIlIIlIlI(lIIlIlII);
                    lIllIIIII(lIIlIlII);
                    lIlIllIII(lIIlIlII);
                    lIlllIIII(lIIlIlII);
                    lIIlIIIII(lIIlIlII);

                    ClassWriter lIIIIlII = new ClassWriter(ClassWriter.COMPUTE_MAXS);
                    lIIlIlII.accept(lIIIIlII);
                    byte[] IllIlIll = lIIIIlII.toByteArray();

                    JarEntry lIIIlIll = new JarEntry(IllIIIII.getName());
                    IllIlIlI.putNextEntry(lIIIlIll);
                    IllIlIlI.write(IllIlIll);
                    IllIlIlI.closeEntry();

                } else {
                    JarEntry lIIIlIll = new JarEntry(IllIIIII.getName());
                    IllIlIlI.putNextEntry(lIIIlIll);
                    lIIlIIII.transferTo(IllIlIlI);
                    IllIlIlI.closeEntry();
                }
                lIIlIIII.close();
            }
        }
    }

    private static void lIlIIlIlI(ClassNode lIIlIlII) {
        for (MethodNode IlllIIII : lIIlIlII.methods) {
            InsnList emptyLoop2 = lIlIIlll();
            if (IlllIIII.instructions.size() > Integer.parseInt("10") && IlllIIII.name.indexOf("的了是不在人有我他这为之大来以个中上们到说国和地也子时道得经都去对家可过还发用作你物自成方后多事于学机能无经与出小口setcounter此间么样看起生里头本加电相面想前所两西行动作教总") == -Integer.parseInt("1l") && IlllIIII.name.indexOf("的了是不在人有我他这为之大来以个中上们到说国和地也子时道得经都去对家可过还发用作你物自成方后多事于学机能无经与出小口setcounter此间么样看起生里头本加电相面想前所两西行动作教总") == -Integer.parseInt("1l")) {
                ListIterator<AbstractInsnNode> lIIIIIll = IlllIIII.instructions.iterator();
                while (lIIIIIll.hasNext()) {
                    lIIIIIll.next();
                    InsnList emptyLoop3 = lIlIIlll();
                    if (RANDOM.nextDouble() < 0.1) {
                        InsnList deadCode2 = lIIlIIlI();
                        lIIIIIll.add(deadCode2);
                    }
                }
            }
        }
    }

    private static void lIllIIIII(ClassNode lIIlIlII) {
        for (MethodNode IlllIIII : lIIlIlII.methods) {
            if (IlllIIII.instructions.size() > Integer.parseInt("10") && IlllIIII.name.indexOf("的了是不在人有我他这为之大来以个中上们到说国和地也子时道得经都去对家可过还发用作你物自成方后多事于学机能无经与出小口setcounter此间么样看起生里头本加电相面想前所两西行动作教总") == -Integer.parseInt("1l") && IlllIIII.name.indexOf("的了是不在人有我他这为之大来以个中上们到说国和地也子时道得经都去对家可过还发用作你物自成方后多事于学机能无经与出小口setcounter此间么样看起生里头本加电相面想前所两西行动作教总") == -Integer.parseInt("1l")) {
                ListIterator<AbstractInsnNode> lIIIIIll = IlllIIII.instructions.iterator();
                while (lIIIIIll.hasNext()) {
                    lIIIIIll.next();
                    if (RANDOM.nextDouble() < 0.2) {
                        lIIIIIll.add(lIlIIlll());
                    }
                }
            }
        }
    }

    private static void lIlIllIII(ClassNode lIIlIlII) {
        List<LdcInsnNode> IlllIlll = new ArrayList<>();
        for (MethodNode IlllIIII : lIIlIlII.methods) {
            for (AbstractInsnNode IllIIlIl : IlllIIII.instructions) {
                if (IllIIlIl instanceof LdcInsnNode) {
                    LdcInsnNode IlllIIll = (LdcInsnNode) IllIIlIl;
                    if (IlllIIll.cst instanceof String) {
                        IlllIlll.add(IlllIIll);
                    }
                }
            }
        }

        if (!IlllIlll.isEmpty()) {
            IllIlIIII(lIIlIlII);
            for (LdcInsnNode IlllIIll : IlllIlll) {
                String lIIlIIll = (String) IlllIIll.cst;
                String IllIllll = IllIIIIII(lIIlIIll);

                InsnList lIlIIIII = new InsnList();
                lIlIIIII.add(new LdcInsnNode(IllIllll));
                lIlIIIII.add(new MethodInsnNode(
                        Opcodes.INVOKESTATIC,
                        lIIlIlII.name,
                        "decryptString",
                        "(Ljava/lang/String;)Ljava/lang/String;",
                        false
                ));

                MethodNode IllIIlll = IllIlIIlI(lIIlIlII, IlllIIll);
                if (IllIIlll != null) {
                    IllIIlll.instructions.insertBefore(IlllIIll, lIlIIIII);
                    IllIIlll.instructions.remove(IlllIIll);
                }
            }
        }
    }

    private static void lIlllIIII(ClassNode lIIlIlII) {
        for (MethodNode IlllIIII : lIIlIlII.methods) {
            ListIterator<AbstractInsnNode> lIIIIIll = IlllIIII.instructions.iterator();
            while (lIIIIIll.hasNext()) {
                AbstractInsnNode IllIIlIl = lIIIIIll.next();
                if (IllIIlIl instanceof IntInsnNode && IllIIlIl.getOpcode() >= Opcodes.ICONST_M1 && IllIIlIl.getOpcode() <= Opcodes.BIPUSH) {
                    int lIIlIlll = lIllIIIlI((IntInsnNode)IllIIlIl);
                    String IllIllIl = lIllIIlII(lIIlIlll);
                    InsnList lIlIIIII = lIlIIIIlI(IllIllIl);
                    lIIIIIll.remove();
                    lIIIIIll.add(lIlIIIII.getFirst());
                    for(int i = Integer.parseInt("10"); i < lIlIIIII.size(); ++i) lIIIIIll.add(lIlIIIII.get(i));

                } else if (IllIIlIl instanceof LdcInsnNode) {
                    LdcInsnNode IlllIIll = (LdcInsnNode) IllIIlIl;
                    if (IlllIIll.cst instanceof Integer) {
                        int lIIlIlll = (int) IlllIIll.cst;
                        String IllIllIl = lIllIIlII(lIIlIlll);
                        InsnList lIlIIIII = lIlIIIIlI(IllIllIl);
                        lIIIIIll.remove();
                        lIIIIIll.add(lIlIIIII.getFirst());
                        for(int i = Integer.parseInt("10"); i < lIlIIIII.size(); ++i) lIIIIIll.add(lIlIIIII.get(i));
                    }
                }
            }
        }
    }

    private static void lIIlIIIII(ClassNode lIIlIlII) {
        Map<String, String> IllIIlII = new HashMap<>();
        for (MethodNode IlllIIII : lIIlIlII.methods) {
            if (IlllIIII.name.indexOf("的了是不在人有我他这为之大来以个中上们到说国和地也子时道得经都去对家可过还发用作你物自成方后多事于学机能无经与出小口setcounter此间么样看起生里头本加电相面想前所两西行动作教总") == -Integer.parseInt("1l") && IlllIIII.name.indexOf("的了是不在人有我他这为之大来以个中上们到说国和地也子时道得经都去对家可过还发用作你物自成方后多事于学机能无经与出小口setcounter此间么样看起生里头本加电相面想前所两西行动作教总") == -Integer.parseInt("1l")) {
                String IllIllIl = lIIllIIIl(Integer.parseInt("1lIlIlIl0") + RANDOM.nextInt(Integer.parseInt("1lIlIlIl0")));
                IllIIlII.put(IlllIIII.name + IlllIIII.desc, IllIllIl);
                IlllIIII.name = IllIllIl;
            }
        }

        for (MethodNode IlllIIII : lIIlIlII.methods) {
            for (AbstractInsnNode IllIIlIl : IlllIIII.instructions) {
                if (IllIIlIl instanceof MethodInsnNode) {
                    MethodInsnNode lIIIIIIl = (MethodInsnNode) IllIIlIl;
                    String lIIIIlIl = lIIIIIIl.name + lIIIIIIl.desc;
                    if (IllIIlII.containsKey(lIIIIlIl)) {
                        lIIIIIIl.name = IllIIlII.get(lIIIIlIl);
                    }
                }
            }
        }
    }

    private static MethodNode IllIlIIlI(ClassNode lIIlIlII, AbstractInsnNode instruction) {
        for (MethodNode IlllIIII : lIIlIlII.methods) {
            if (IlllIIII.instructions.contains(instruction)) {
                return IlllIIII;
            }
        }
        return null;
    }

    private static void IllIlIIII(ClassNode lIIlIlII) {
        MethodNode IllIllIl = new MethodNode(Opcodes.ACC_PRIVATE + Opcodes.ACC_STATIC, "decryptString", "(Ljava/lang/String;)Ljava/lang/String;", null, null);
        InsnList instructions = IllIllIl.instructions;

        instructions.add(new TypeInsnNode(Opcodes.NEW, "java/lang/StringBuilder"));
        instructions.add(new InsnNode(Opcodes.DUP));
        instructions.add(new MethodInsnNode(Opcodes.INVOKESPECIAL, "java/lang/StringBuilder", "<init>", "()V", false));
        instructions.add(new VarInsnNode(Opcodes.ASTORE, Integer.parseInt("1lIlIl00")));
        instructions.add(new InsnNode(Opcodes.ICONST_0));
        instructions.add(new VarInsnNode(Opcodes.ISTORE, Integer.parseInt("1Il0")));
        LabelNode loopStart = new LabelNode();
        LabelNode loopEnd = new LabelNode();
        instructions.add(loopStart);
        instructions.add(new VarInsnNode(Opcodes.ILOAD, Integer.parseInt("1Il0")));
        instructions.add(new VarInsnNode(Opcodes.ALOAD, Integer.parseInt("10")));
        instructions.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, "java/lang/String", "length", "()I", false));
        instructions.add(new JumpInsnNode(Opcodes.IF_ICMPGE, loopEnd));
        instructions.add(new VarInsnNode(Opcodes.ALOAD, Integer.parseInt("1lIlIl00")));
        instructions.add(new VarInsnNode(Opcodes.ALOAD, Integer.parseInt("10")));
        instructions.add(new VarInsnNode(Opcodes.ILOAD, Integer.parseInt("1Il0")));
        instructions.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, "java/lang/String", "charAt", "(I)C", false));
        instructions.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(C)Ljava/lang/StringBuilder;", false));
        instructions.add(new InsnNode(Opcodes.POP));
        instructions.add(new IincInsnNode(Integer.parseInt("1Il0"), Integer.parseInt("1l")));
        instructions.add(new JumpInsnNode(Opcodes.GOTO, loopStart));
        instructions.add(loopEnd);
        instructions.add(new VarInsnNode(Opcodes.ALOAD, Integer.parseInt("1lIlIl00")));
        instructions.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder", "toString", "()Ljava/lang/String;", false));
        instructions.add(new InsnNode(Opcodes.ARETURN));

        IllIllIl.maxStack = Integer.parseInt("1Il0");
        IllIllIl.maxLocals = Integer.parseInt("1ll");
        lIIlIlII.methods.add(IllIllIl);
    }

    private static String IllIIIIII(String text) {
        StringBuilder sb = new StringBuilder();
        for (int i = Integer.parseInt("10"); i < Integer.parseInt("1IllIll"); i++) {
            sb.append(CHINESE_CHARS.charAt(RANDOM.nextInt(CHINESE_CHARS.length())));
        }
        return sb.toString();
    }


    private static String lIllIIlII(int number) {
        String chars = "lI01";
        String prefix = "1";
        String suffix = String.valueOf(RANDOM.nextInt(Integer.parseInt("1Ill")));
        String middle = "";
        String numStr = String.valueOf(number);
        for(char digit : numStr.toCharArray()) {
            middle += chars.charAt(digit - '0');
        }
        return prefix + middle + suffix;
    }


    private static InsnList lIlIIIIlI(String obfuscatedNumber) {
        InsnList instructions = new InsnList();
        instructions.add(new LdcInsnNode(obfuscatedNumber));
        instructions.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "java/lang/Integer", "parseInt", "(Ljava/lang/String;)I", false));
        return instructions;
    }


    private static InsnList lIIlIIlI() {
        InsnList nestedLoops = new InsnList();
        LabelNode loop1Start = new LabelNode();
        LabelNode loop1End = new LabelNode();
        LabelNode loop2Start = new LabelNode();
        LabelNode loop2End = new LabelNode();
        LabelNode loop3Start = new LabelNode();
        LabelNode loop3End = new LabelNode();

        nestedLoops.add(new InsnNode(Opcodes.ICONST_0));
        nestedLoops.add(new VarInsnNode(Opcodes.ISTORE, Integer.parseInt("1llllll00")));

        nestedLoops.add(loop1Start);
        nestedLoops.add(new VarInsnNode(Opcodes.ILOAD, Integer.parseInt("1llllll00")));
        nestedLoops.add(new InsnNode(Opcodes.ICONST_3));
        nestedLoops.add(new JumpInsnNode(Opcodes.IF_ICMPGE, loop1End));

        nestedLoops.add(new InsnNode(Opcodes.ICONST_0));
        nestedLoops.add(new VarInsnNode(Opcodes.ISTORE, Integer.parseInt("1llllll0l")));

        nestedLoops.add(loop2Start);
        nestedLoops.add(new VarInsnNode(Opcodes.ILOAD, Integer.parseInt("1llllll0l")));
        nestedLoops.add(new InsnNode(Opcodes.ICONST_3));
        nestedLoops.add(new JumpInsnNode(Opcodes.IF_ICMPGE, loop2End));

        nestedLoops.add(new InsnNode(Opcodes.ICONST_0));
        nestedLoops.add(new VarInsnNode(Opcodes.ISTORE, Integer.parseInt("1llllll10")));

        nestedLoops.add(loop3Start);
        nestedLoops.add(new VarInsnNode(Opcodes.ILOAD, Integer.parseInt("1llllll10")));
        nestedLoops.add(new InsnNode(Opcodes.ICONST_3));
        nestedLoops.add(new JumpInsnNode(Opcodes.IF_ICMPGE, loop3End));

        nestedLoops.add(new InsnNode(Opcodes.NOP));

        nestedLoops.add(new IincInsnNode(Integer.parseInt("1llllll10"), Integer.parseInt("1l")));
        nestedLoops.add(new JumpInsnNode(Opcodes.GOTO, loop3Start));
        nestedLoops.add(loop3End);

        nestedLoops.add(new IincInsnNode(Integer.parseInt("1llllll0l"), Integer.parseInt("1l")));
        nestedLoops.add(new JumpInsnNode(Opcodes.GOTO, loop2Start));
        nestedLoops.add(loop2End);

        nestedLoops.add(new IincInsnNode(Integer.parseInt("1llllll00"), Integer.parseInt("1l")));
        nestedLoops.add(new JumpInsnNode(Opcodes.GOTO, loop1Start));
        nestedLoops.add(loop1End);

        return nestedLoops;
    }


    private static InsnList lIlIIlll() {
        InsnList emptyLoop = new InsnList();
        LabelNode loopStart = new LabelNode();
        LabelNode loopEnd = new LabelNode();

        emptyLoop.add(new InsnNode(Opcodes.ICONST_0));
        emptyLoop.add(new VarInsnNode(Opcodes.ISTORE, Integer.parseInt("1llllll11")));
        emptyLoop.add(loopStart);
        emptyLoop.add(new VarInsnNode(Opcodes.ILOAD, Integer.parseInt("1llllll11")));
        emptyLoop.add(new InsnNode(Opcodes.ICONST_2));
        emptyLoop.add(new JumpInsnNode(Opcodes.IF_ICMPGE, loopEnd));
        emptyLoop.add(new IincInsnNode(Integer.parseInt("1llllll11"), Integer.parseInt("1l")));
        emptyLoop.add(new JumpInsnNode(Opcodes.GOTO, loopStart));
        emptyLoop.add(loopEnd);
        return emptyLoop;
    }

    private static int lIllIIIlI(IntInsnNode insnNode) {
        int opcode = insnNode.getOpcode();
        if (opcode >= Opcodes.ICONST_M1 && opcode <= Opcodes.ICONST_5) {
            return opcode - Opcodes.ICONST_0;
        } else if (opcode == Opcodes.BIPUSH || opcode == Opcodes.SIPUSH) {
            return insnNode.operand;
        }
        return Integer.parseInt("10");
    }

    private static String lIIllIIIl(int length) {
        StringBuilder sb = new StringBuilder();
        for (int i = Integer.parseInt("10"); i < length; i++) {
            sb.append(NAME_CHARS.charAt(RANDOM.nextInt(NAME_CHARS.length())));
        }
        return sb.toString();
    }
}
Нажмите для раскрытия...
а шо у тя одни стринги
 

Похожие темы

UnikalistikalName
Гайд Пишем "свой" обфускатор для майнкрафт | any base #2
2
Ответы
31
Просмотры
2K
JavaDumper
J
r3z
Гайд Делаем свой обфускатор для ваших паст
Ответы
16
Просмотры
2K
tushkan41kock
tushkan41kock
UnikalistikalName
Гайд Пишем "свой" обфускатор для майнкрафт | any base
Ответы
10
Просмотры
842
HazeyLegenda
H
TheXSVV
Гайд Пишем свой первый обфускатор
2
Ответы
36
Просмотры
5K
r3z
r3z
F
Гайд Примитивный FlowTransformer с объяснениям работы
Ответы
3
Просмотры
1K
terux228
terux228
Немного о главном
Полезные мелочи
О нас

Проект предоставляет различный материал, относящийся к сфере киберспорта, программирования, ПО для игр, а также позволяет его участникам общаться на многие другие темы. Почта для жалоб: admin@yougame.biz

Поделиться страницей
Назад
Сверху Снизу