Analizando viejo stub.dll de troyano frutas RAT versión Piña

public class CrearJar implements ShowData {
     
    private static final Path STUB_PATH =  Paths.get("src/main/resources/stub.dll");
    private static final Path DESTINO_STUB = Paths.get("src/main/resources/clasesStub.jar");
     
    public CrearJar() {
        init();
    }
     
    /**
    * lee el path donde esta el stub.dll y lo volca el contenido en un .jar
     */
    private void init() {
     
        try(final JarInputStream jarInputStream = new JarInputStream(Files.newInputStream(STUB_PATH ));
        final BufferedOutputStream bos = new BufferedOutputStream(Files.newOutputStream(DESTINO_STUB ));
        final JarOutputStream jarOutputStream = new JarOutputStream(bos, jarInputStream.getManifest())) {
     
               JarEntry jarEntry;
     
               while((jarEntry = jarInputStream.getNextJarEntry()) != null) {
                   if(predicate(jarEntry)) {
                       getLogger().info(jarEntry.getName());
                       jarOutputStream.putNextEntry(jarEntry);
                       jarOutputStream.write(readAllBytes(jarInputStream));
                       jarOutputStream.flush();
                   }
               }
           }catch (IOException ex) {
               getLogger().severe(ex.getMessage(),ex);
           }
        }
     
    /**
    * Validar el jarEntry
    * @param jarEntry que se le hara el test
    * @return boolean true si son solo clases, y que no sean directorios, ni tengan $
    */
    private boolean predicate(final JarEntry jarEntry) {
        final Predicate predicate = p -> !jarEntry.isDirectory()
                                                      && jarEntry.getName().endsWith(".class")
                                                      && !jarEntry.getName().contains("$"),
                                                      || jarEntry.getName().contains("_");
        return predicate.test(jarEntry);
    }
        
    /**
    *
    * @return all bytes from stub
    */
    private byte[] readAllBytes(final InputStream input) {
        try(ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
              final byte[] bytesread = new byte[1024];
              int dataRead;
              while((dataRead = input.read(bytesread)) != -1) {
                  baos.write(bytesread,0,dataRead);
              }
              return baos.toByteArray();
        } catch (IOException ex) {
            getLogger().severe(null,ex);
        }
        return new byte[0];
    }
}           

package extra;
import java.io.ByteArrayOutputStream;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
     
public class Constante {
   public Constante() {
   }
     
    public static byte[] Constantino(String contrasena, byte[] input) {
        try {
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            SecretKeyFactory skf = SecretKeyFactory.getInstance(new String(new char[]{'D', 'E', 'S'}));
            DESKeySpec kspec = new DESKeySpec(contrasena.getBytes());
            SecretKey ks = skf.generateSecret(kspec);
            Cipher c = Cipher.getInstance(new String(new char[]{'D', 'E', 'S'}));
            c.init(2, ks);
            byte[] tmp = c.update(input, 0, input.length);
            out.write(tmp);
            tmp = c.doFinal();
            out.write(tmp);
            out.close();
            return out.toByteArray();
        } catch (Exception var8) {
            return null;
        }
     }
}