So recently have been using Jawa in my tool to deobfuscate MC.

Today I found that it was erroring on a class file. Which I found that even eclipses resource loader thinks its not right.

But reporting it here anyways.

The following class causes

https://minecraft16.ml/mr.class

 File "C:\Python27\lib\site-packages\jawa\cf.py", line 99, in __init__
    self._from_io(fio)
  File "C:\Python27\lib\site-packages\jawa\cf.py", line 158, in _from_io
    self._constants.unpack(fio)
  File "C:\Python27\lib\site-packages\jawa\constants.py", line 427, in unpack
    fmt, size = _constant_fmts[tag]
IndexError: tuple index out of range

I have another tool that outputted "com.sun.org.apache.bcel.internal.classfile.ClassFormatException: Invalid byte tag in constant pool: 15" as an error on the same class. So it might be a error because of java 8 or something.

FYI, https://github.com/arngarden/python_java_datastream by @arngarden has a nice support for reading and writing Java DataInputStream which could be a nice addition

The new version no long runs on python 2.7

>>> from jawa.classloader import ClassLoader
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "C:\Python27\lib\site-packages\jawa\classloader.py", line 41
    def __init__(self, *sources, max_cache: int=50, klass=ClassFile,
                                         ^
SyntaxError: invalid syntax

There is a program created by a guy named Pokechu22 and he used this program in conjunction with his Python2 scripts. When I try to use his program in Python 2, it hitches here as this program is in Python 3. I'm sure there has to be Python 2 version of this somewhere, as his program would not have worked back then. Please let me know :)

Our current process is to update bytecode.yaml, run a small transform on it to fill in some defaults and convert it to JSON (so we don't add pyyaml as a distribution dependency). At runtime this JSON file is loaded and used as the bytecode reference.

Instead, lets transform bytecode.yaml directly into python. The primary reasoning for this is to support autocomplete, help tags and type hinting for operand values. For example in our yaml file we have ->

aaload:
    op: 0x32
    desc: load onto the stack a reference from an array
    stack:
        before:
            - ArrayRef
            - Index
        after:
            - Value
    runtime:
        - NullPointerException
        - ArrayIndexOutOfBoundsException

We can turn this into ->

class aaload(Instruction):
    """load onto the stack a reference from an array"""
    __slots__ = ('op', 'mnemonic', 'stack', 'runtime', 'operands')
    op = 0x32
    mnemonic = 'aaload'
    ...

So that we can do for example...

import jawa.bytecode as I

method.code.assemble((
    I.aaload,
    I.bipush(6),
    I.return_
))

(Re?)adds python 3 compatibility.

The only complicated change here is that StringIO has been replaced with BytesIO. While six.moves.cStringIO exists, it causes issues in the contexts it was used in (TypeError: initial_value must be str or None, not bytes). BytesIO works in both python 2 and python 3; I've also used a cStringIO when available (I'm not actually sure whether cStringIO is faster than BytesIO in python 2, but I assume it is).

Tested against burger (with another set of changes there for python 3), so most reading stuff is covered but writing might not be.

Not sure if I should submit this to develop or master. I found this while using burger on develop so that's the branch I made the change on, but it may make more sense on master.

This adds support for reading the Signature attribute (jvms 4.7.9). It does not attempt to parse it, however, as the parsing rules (jvms 4.7.9.1) are rather complicated.

• Characters are appended to a list buffer and converted to a unicode string at the end at once. This speeds up string processing when there is a large number of characters to decode and avoids the creation of many small intermediate strings.

Signed-off-by: Philippe Ombredanne [email protected]

Open defaults to 'r', which means that Windows' line endings would get converted, causing class files to get parsed incorrectly. This changes to explicitly use 'rb', avoiding that problem.

MethodTable.find's 'args' and 'returns' arguments are ignored.

From here:

args = descriptor[1:end_para]
if args is not None and args != args:
    continue
returns = descriptor[end_para + 1:]
if returns is not None and returns != returns:
    continue

args and returns need to be named something different than their respective parameters, as otherwise the if condition will never be true.

This gets entries for all of the various table attributes out of the AST.

For BootstrapMethods, it unrolls the MethodHandle constant. Admittedly I don't understand this recommendation 100%, but I don't have a good reason not to do it either. Constants are still rolled into all other attributes though, so let me know if I should be unrolling constants across the board. If that's the case we might want to look into a more universal to_attr method or something.

A TableAttribute base class is added

ReferenceKind is now an IntEnum

We should support something very close to Jasmin as both an input and output target.

• [x] Tokenizer
• [x] Parser
• [ ] .class -> ast transform
• [ ] ast pretty printer

• [ ] BootstrapMethods - Added in: 7 (J2SE_7)
• [ ] Code - Added in: 1.0.2 (JDK1_1)
• [ ] ConstantValue - Added in: 1.0.2 (JDK1_1)
• [ ] Deprecated - Added in: 1.1.0 (JDK1_1)
• [ ] EnclosingMethod - Added in: 5.0.0 (J2SE_5)
• [ ] Exceptions - Added in: 1.0.2 (JDK1_1)
• [ ] InnerClasses - Added in: 1.1.0 (JDK1_1)
• [ ] LineNumberTable - Added in: 1.0.2 (JDK1_1)
• [ ] LocalVariableTable - Added in: 1.0.2 (JDK1_1)
• [ ] LocalVariableTypeTable - Added in: 1.0.2 (JDK1_1)
• [ ] Signature - Added in: 5.0.0 (J2SE_5)
• [ ] SourceFile - Added in: 1.0.2 (JDK1_1)
• [ ] StackMapTable - Added in: 6.0.0 (J2SE_6)
• [ ] Synthetic - Added in: 5.0.0 (J2SE_5)

Jawa is currently only thoroughly tested up to Java 6. We should implement tests for 7 and 8, then implement any missing parts of the new specifications.

The assembler currently lacks support for stack maps, a newly required feature for targeting Java 7 and above.

• [x] Reading
• [ ] Writing (uncompressed, simple frames)
• [ ] Writing (compressed frames)