JavaJive

English | 简体中文 | Website

Une boîte à outils Java portable, pure-Go — extraite et allégée de yaklang — qui fait trois choses et rien d'autre :

• Décompiler — .class / .jar / .war / .zip → code source Java lisible.
• Analyser les classes — inspecter la structure d'un fichier .class (pool de constantes, champs, méthodes, version, drapeaux d'accès).
• (Dé)sérialiser — analyser et re-marshaler le format de sérialisation Java (ObjectStream) avec une fidélité octet par octet, et le convertir vers/depuis JSON.

Conçu pour la portabilité et l'intégration :

• Pure Go, binaire unique — pas de JDK, pas de cgo, pas de runtime ANTLR, pas de bibliothèques natives. Compilation croisée vers linux / macOS / windows sur amd64 et arm64.
• Un seul import — un package façade unifié javajive englobe les trois capacités ; les sous-packages restent disponibles pour un usage avancé.
• CLI de premier ordre — sous-commandes decompile, classinfo et serial, basées sur la bibliothèque standard.
• Testé en croisé contre un vrai JDK — la CI compile de vrais .class / .jar et des blobs sérialisés par le JDK avec javac/java, puis vérifie JavaJive contre eux (voir HARNESS-WORKFLOW.md).
• Graphe de dépendances allégé — utils / codec / log / go-funk sont réimplémentés sous forme d'un noyau internal/ minimal et autonome.

Validation de la v0.4.0

L'audit différentiel complet de 38 JAR ne rapporte aucune régression enregistrée par rapport à la base de référence figée : les 20 JAR précédemment compilables sans erreur sont conservés et 26 compilent désormais intégralement. Les défauts de la base de référence et 4 stubs de méthodes existants restent visibles. Voir les résultats par JAR et la reproduction.

250 allers-retours sémantiques isolés enregistrent séparément la compilation, la vérification JVM, les stubs et l'égalité à l'exécution ; les classes applicatives d'origine sont absentes des classpaths reconstruits. La CI exécute l'audit sémantique sur JDK 17 et 21, la comparaison historique complète, ainsi que les matrices OS/Go et race. Ces vérifications ne prouvent pas l'équivalence de chaque méthode de bibliothèque. Voir l'implémentation et les limites restantes.

Benchmarks historiques (v0.3.0)

Les chiffres suivants ont été rapportés pour la v0.3.0 le 2026-09-05. Ils ne constituent pas des résultats d'acceptation de la version actuelle ni une preuve d'équivalence comportementale.

Mesurés sur 34 jars réels (18 759 unités aplaties) via décompilation → recompilation javac --release 8 → rempaquetage → vérification JVM :

• Taux d'unités propres de 100 % — 18 759 / 18 759 unités aplaties (Outer$Inner.java) recompilent avec zéro erreur javac, et 0 erreur de syntaxe sur les 34 jars (une assertion stricte imposée par la CI, afin qu'aucune erreur de type ne puisse se cacher derrière un échec du lexer).
• Les 34 bibliothèques font un aller-retour complet — décompilation → recompilation → rempaquetage → vérification externe JVM -Xverify:all par classe réussit de bout en bout (le codec est identique octet par octet au jar d'origine selon un différentiel d'appels). Verrouillé dans provenClean.
• 14 / 14 algorithmes auto-hébergés (MD5 · SHA-256 · CRC32 · quicksort · Base64 · HeapSort · KMP · SwitchFSM · TryFinally · UnionFind · DiamondTryCatch · DiamondTryFinally · ForContinue · ComputeIfAbsent) font un aller-retour octet par octet.
• #1 dans une comparaison équitable à 3 sur l'ensemble original de 8 jars — taux d'unités propres 100 % contre Vineflower 1.10.1 (90,8 %) et CFR 0.152 (79,8 %) ; remportant les 8 jars contre les deux.

Voir BENCHMARK.md pour la méthodologie complète, les tableaux par jar et les commandes de reproduction.

Installation

# CLI
go install github.com/yaklang/javajive/cmd/javajive@latest

# Library
go get github.com/yaklang/javajive@latest

Ou compiler depuis les sources :

git clone https://github.com/yaklang/javajive
cd javajive
go build -o javajive ./cmd/javajive

Nécessite Go 1.22+.

CLI

javajive <command> [arguments]

Commands:
  decompile   decompile .class/.jar/.war/.zip or a directory into Java source
  classinfo   print the structure of a .class file (version, fields, methods)
  serial      Java serialization tools (subcommands: tojson, fromjson)
  version     print the version
  help        show help

decompile

# Single class: prints to stdout by default, or -o to write a file.
javajive decompile Foo.class
javajive decompile Foo.class -o Foo.java

# Archive: defaults to a "<input>.src" directory, or -o to choose one.
javajive decompile app.jar
javajive decompile app.war -o ./app-src

# Directory: recursively decompile .class files (requires -o output dir).
javajive decompile ./classes -o ./src

classinfo

javajive classinfo Foo.class

class:      InvisibleAnnoSeed
super:      java/lang/Object
version:    61.0
access:     public
constants:  18

fields (0):

methods (2):
   <init>()V
   run()I

serial

# Serialized binary -> JSON. (-hex: input is a hex string, -: read from stdin)
javajive serial tojson dump.bin
printf 'aced000574000568656c6c6f' | javajive serial tojson -hex -

# JSON -> serialized binary. (default prints hex; with -o writes raw bytes)
javajive serial fromjson dump.json -o out.bin
javajive serial fromjson dump.json          # prints hex

Bibliothèque

Utilisez le package façade unifié — un seul import couvre les trois capacités :

import "github.com/yaklang/javajive"

// Decompile a single class, or a whole archive into a directory.
src, err := javajive.Decompile(classBytes)
err = javajive.DecompileArchive("app.jar", "app-src")

// Inspect class structure.
obj, err := javajive.ParseClass(classBytes)
_ = obj.GetClassName()

// Java serialization: binary -> JSON -> binary.
objs, _ := javajive.ParseSerialized(raw)          // or ParseSerializedHex(hexStr)
jsonBytes, _ := javajive.SerializedToJSON(objs...)
restored, _ := javajive.SerializedFromJSON(jsonBytes)
out := javajive.MarshalSerialized(restored...)

API unifiée