rocky/python-uncompyle6Un décompilateur de bytecode Python multi-version
|buildstatus| |Pypi Installs| |Latest Version| |Supported Python Versions|
|packagestatus|
.. contents::
Un décompilateur natif Python multi-versions et décompilateur de fragments. Le successeur de decompyle, uncompyle et uncompyle2.
J'ai donné une conférence à ce sujet au BlackHat Asia 2024 <https://youtu.be/H-7ZNrpsV50?si=nOaixgYHr7RbILVS>_.
uncompyle6 traduit le bytecode Python en code source Python équivalent. Il accepte les bytecodes des versions 1.0 à 3.8 de Python, couvrant plus de 24 ans de versions Python. Nous incluons le bytecode Python 2.5 de Dropbox et certains bytecodes PyPy.
D'accord, je vais le dire : ce logiciel est incroyable. Il est plus qu'un simple décompilateur bricolé. En utilisant la technologie compiler_, le programme crée un arbre syntaxique du programme à partir des instructions ; des nœuds aux niveaux supérieurs qui ressemblent un peu à ce qui pourrait provenir d'un AST Python. Nous pouvons donc vraiment classer et comprendre ce qui se passe dans les sections de bytecode Python.
En s'appuyant sur cela, une autre chose qui rend ce décompilateur différent des autres décompilateurs de bytecode CPython est qu'il peut déparser juste des fragments de code source et donner des informations sur le code source autour d'un offset de bytecode donné.
J'utilise les fragments d'arbre pour déparser des fragments de code au moment de l'exécution dans mes trepan_ debuggers_. Pour cela, les offsets de bytecode sont enregistrés et associés à des fragments du code source. Ce but, bien que compatible avec l'intention originale, est néanmoins un peu différent. Voir this_ pour plus d'informations.
Le déparsing de fragments Python, étant donné un offset d'instruction, est utile pour afficher les traces de pile et peut être intégré dans tout programme qui souhaite afficher un emplacement plus en détail qu'un simple numéro de ligne au moment de l'exécution. Ce code peut également être utilisé lorsque les informations de code source n'existent pas et qu'il n'y a que du bytecode. Encore une fois, mes débogueurs en tirent parti.
Il y avait (et il y a encore) plusieurs forks de decompyle, uncompyle, uncompyle2, uncompyle3. Beaucoup viennent essentiellement de la même base de code, et (presque?) tous ne sont plus activement maintenus. L'un était très bon pour décompiler Python 1.5-2.3, un autre est très bon pour Python 2.7, mais seulement cela. Un autre ne gère que Python 3.2 ; un autre l'a corrigé et ne gérait que 3.3. Vous voyez l'idée. Ce code rassemble tous ces forks et avance. Il y a une refactorisation et un nettoyage sérieux dans cette base de code par rapport à ces anciens forks. Une refactorisation encore plus expérimentale est en cours dans decompyle3_.
Ce projet fait démonstrativement le meilleur travail de décompilation Python sur toutes les versions de Python. Et même lorsqu'il existe un autre projet qui ne fournit la décompilation que pour un sous-ensemble de versions Python, nous faisons généralement démonstrativement mieux pour celles-ci également.
Comment le savons-nous ? En prenant le bytecode Python distribué avec cette version de Python et en le décompilant. Parmi ceux qui se décompilent avec succès, nous pouvons ensuite nous assurer que les programmes résultants sont syntaxiquement corrects en exécutant l'interpréteur Python pour cette version de bytecode. Enfin, dans les cas où le programme a un test pour lui-même, nous pouvons exécuter la vérification sur le code décompilé.
Nous utilisons des processus automatisés pour trouver des bogues. Dans les trackers de problèmes des autres décompilateurs, vous trouverez plusieurs bogues que nous avons découverts en cours de route. Très peu d'entre eux sont corrigés dans les autres décompilateurs.
Le code dans le dépôt git peut être exécuté de Python 2.4 à la dernière version de Python, à l'exception de Python 3.0 à 3.2. Les bénévoles sont les bienvenus pour remédier à ces lacunes si le désir s'en fait sentir.
La façon dont il fait cela, cependant, est en séparant les versions consécutives de Python dans des branches git :
master Python 3.11 et supérieur (utilise l'installation poetry et les idiomes Python plus récents) python-3.6-to-3.10 Python 3.6 à 3.10 (utilise les f-strings plus récentes, des idiomes plus modernes et des annotations de type plus modernes) python-3.3-to-3.5 Python 3.3 à 3.5 (Python 3 générique) python-3.0-to-3.2 Python 3.0 à 3.2 (Début Python 3 ; 3.0 était dans certains domaines plus proche de Python 2.6 que de Python 2.7) python-2.4-to-2.7 Python 2.4 à 2.7 (Python 2 générique)
PyPy à partir de la version 2.4 fonctionne également.
Les fichiers bytecode qu'il peut lire ont été testés sur les bytecodes Python des versions 1.4, 2.1-2.7, 3.0-3.8 et versions ultérieures de PyPy.
Pour les versions récentes de Python (Python 3.11+), vous pouvez installer depuis PyPI en utilisant le nom uncompyle6 ::
pip install uncompyle6
Pour les versions de Python antérieures à 3.11, n'installez pas via PyPI, mais installez plutôt en utilisant un fichier dans la section GitHub Releases. Les anciennes versions de Python utilisaient easy_install <https://python101.pythonlibrary.org/chapter29_pip.html#using-easy-install>_. Mais cela n'est plus supporté sur PyPi ni sur les versions plus récentes de Python. Et inversement, poetry ni pip, (les méthodes plus récentes) ne sont pas supportés sur les anciennes versions de Python.
Si la version de Python sur laquelle vous exécutez uncompyle6 se situe entre Python 2.4 et 2.7, utilisez une archive tar appelée uncompyle6_24-x.y.z.tar.gz.
Si la version de Python sur laquelle vous exécutez uncompyle6 se situe entre Python 3.0 et 3.2, utilisez une archive tar appelée uncompyle6_30-x.y.z.tar.gz.
Si la version de Python sur laquelle vous exécutez uncompyle6 se situe entre Python 3.3 et 3.5, utilisez une archive tar appelée uncompyle6_33-x.y.z.tar.gz.
Si la version de Python sur laquelle vous exécutez uncompyle6 se situe entre Python 3.6 et 3.11, utilisez une archive tar appelée uncompyle6_36-x.y.z.tar.gz.
Si la version de Python sur laquelle vous exécutez uncompyle6 est 3.11 ou ultérieure, utilisez une archive tar appelée uncompyle6-x.y.z.tar.gz.
Vous pouvez également essayer des eggs ou wheels qui ont la même désignation de version, par exemple uncompyle6-x.y.z-py39-none-any.whl pour une installation Python 3.9. *Cependant, notez que la version sans désignation signifie Python 3.11 ou supérieur.
De même, une archive tar sans _xx fonctionne uniquement à partir de Python 3.11 ou supérieur.
Justification de l'utilisation des branches Git +++++++++++++++++++++++++++++++++++++++++++++++
Il est actuellement impossible (sinon peu pratique) d'avoir un seul code source Python de cette complexité et avec autant de fonctionnalités qui puisse fonctionner à la fois sur Python 2.7 et Python 3.13+. Les langages ont tellement divergé, et le packaging est très différent. En fait, la pratique d'empaquetage pour Python 3.11+ est incompatible avec Python 2.7 (et avant jusqu'à Python 2.4), qui privilégiait 'easy_install'.
Installation à partir du code source +++++++++++++++++++++++++++++++++++++
Pour installer à partir du code source, assurez-vous d'avoir la bonne branche Git. Voir la section Prérequis pour les noms des branches Git.
Après avoir défini la bonne branche ::
$ pip install -e . # set up to run from source tree
Un Makefile GNU est également fourni, donc :code:make install (éventuellement en tant que root ou via sudo) effectuera les étapes ci-dessus.
::
make check
Un Makefile GNU a été ajouté pour faciliter la configuration et l'exécution de la bonne commande, et pour exécuter les tests du plus rapide au plus lent.