RETON: Reverse Engineering RTON (RE RTON -> RETON)

Basic

RTON file is a serialize type that very similar to JSON but it use bytecode.
RTON file begin with 52 54 4F 4E (RTON in ASCII) follow by 4-byte little-endian indicate version of RTON (usually 01 00 00 00) and end with 44 4F 4E 45 (DONE in ASCII).

RTON Cheatsheet

Bytecode	Type	Note
`0x0`	false
`0x1`	true
`0x8`	int8_t	int 8 bit
`0x9`	0	0 int int8_t?
`0xa`	uint8_t	unsigned int 8 bit
`0xb`	0	0 in uint8_t?
`0x10`	int16_t	int 16 bit
`0x11`	0	0 in int16_t?
`0x12`	uint16_t	unsigned int 16 bit
`0x13`	0	0 in uint16_t?
`0x20`	int32_t	int 32 bit
`0x21`	0	0 in int32_t?
`0x22`	float	Single-precision floating-point
`0x23`	0.0	0 in float?
`0x24`	uRTON_t	unsigned RTON number
`0x25`	RTON_t	RTON number
`0x26`	uint32_t	unsigned int 32 bit
`0x27`	0	0 in uint32_t?
`0x28`	uRTON_t	unsigned RTON number
`0x29`?	RTON_t	RTON number
`0x41`	0.0	0 in double
`0x42`	double	Double-precision floating-point
`0x44`	uRTON_t	unsigned RTON number
`0x45`	RTON_t	RTON number
`0x81`	String
`0x82`	Utf-8 string
`0x83`	RTID	RTON ID
`0x85`	Object
`0x86`	Array
`0x90`	Cached string
`0x91`	Cached string recall
`0x92`	Cached utf-8 string
`0x93`	Cached utf-8 string recall
`0xfd`	Begin of array
`0xfe`	End of array
`0xff`	End of object

Unsigned RTON Number

`0x24`, `0x28` and `0x44`

It read 1 byte at a time and keep reading til it found a byte that SMALLER or EQUAL 0x7f

After that it do something like this pseudocode:

uint64_t unsigned_RTON_num2int(vector <uint8_t> q){
    if (q.size() == 1){
        if (q[0] > 0x7f) return UINT_MAX; //return max when RTON number has 1 byte and > 0x7f
        else return q[0];
    }
    uint64_t near_last_byte, last_byte = q[q.size() - 1];
    q.pop_back();
    while(q.size() > 0){
        near_last_byte = q[q.size() - 1];
        if (last_byte % 2 == 0) near_last_byte &= 0x7f;
        near_last_byte += last_byte / 2 * 0x100;
        last_byte = near_last_byte;
        q.pop_back();
    }
    return last_byte;
}

Example:

52 54 4F 4E 01 00 00 00
    90 05 56 61 6C 75 65 24 3D
    90 09 53 6F 6D 65 56 61 6C 75 65 24 FE 01
FF
44 4F 4E 45

JSON decode:

{
    "Value": 61,
    "SomeValue": 254
}

RTON Number

`0x25`, `0x29` and `0x45`

Pseudocode:

RTON_number = unsigned_RTON_number;
if (RTON_number % 2) RTON_number = -(RTON_number + 1);
RTON_number /= 2;

String

`0x81`

81 xx [string] create a [string] that has EXACTLY xx unsigned RTON number of bytes.

UTF-8 String

`0x82`

82 [L1] [L2] [string] where [L1] is unsigned RTON number characters in utf-8 and [L2] is unsigned RTON number bytes of [string].

RTID

`0x83`

0x83 begin the RTID (RTON ID???) of RTON (cross-reference???).
It has 2 subsets (0x2 and 0x3)

`0x3` Subset

83 03 [L1] [L2] [string] [L3] [L4] [string 2]

Format: RTID([string 2]@[string])
After 0x8303 is 2 strings format: [L1] [L2] [string] and [L3] [L4] [string 2] same as 0x82

Example:

52 54 4F 4E 01 00 00 00
    90 0C 52 54 49 44 20 45 78 61 6D 70 6C 65
    83 03
        09 09 31 73 74 53 74 72 69 6E 67
        09 09 32 6E 64 53 74 72 69 6E 67 
FF 
44 4F 4E 45

JSON decode:

{
    "RTID Example": "RTID(2ndString@1stString)"
}

`0x2` Subset (may not be correct)

83 02 [L1] [L2] [string] [U2] [U1] [4 bytes ID]

Format: RTID([U1].[U2].[4 bytes ID]@[string]) (this is my assumption, it may not correct)
[L1] [L2] [string] is same as 0x82
[U2] is the second number in uid
[U1] is the first number in uid
[ID] the third (hex) number in uid

Example:

52 54 4F 4E 01 00 00 00 
    90 09 6D 5F 74 68 69 73 50 74 72 83 02 0C 0C 51 75 65 73 74 73 41 63 74 69 76 65 00 01 7D A7 7B 6D
FF
44 4F 4E 45

JSON decode:

{
    "m_thisPtr": "RTID(1.0.6d7ba77d@QuestsActive)"
}

Object

`0x85`

Create an object as value

Example:

52 54 4F 4E 01 00 00 00 
    90 07 54 65 73 74 69 6E 67
    85
        90 05 48 65 6C 6C 6F 90 02 48 69
    FF
FF
44 4F 4E 45

JSON decode:

{
    "Testing": {
        "Hello": "Hi"
    }
}

Array

`0x86`, `0xfd` and `0xfe`

0x86 is declare an array
Array begin with 0xfd xx and end with 0xfe, where xx is unsigned RTON number of elements in array.

Example:

52 54 4F 4E 01 00 00 00
    90 0E 41 6E 45 78 61 6D 70 6C 65 41 72 72 61 79
    86 FD 03
        90 0A 31 73 74 45 6C 65 6D 65 6E 74
        90 0A 32 6E 64 45 6C 65 6D 65 6E 74
        90 0A 33 72 64 45 6C 65 6D 65 6E 74
    FE
FF
44 4F 4E 45

JSON decode:

{
    "AnExampleArray": [
        "1stElement",
        "2ndElement",
        "3rdElement"
    ]
}

Cached String

`0x90` and `0x91`

90 xx [string], the xx [string] is just like 0x81
By using 0x90, the string will push in a stack then it can be recall by 91 xx, xx is unsigned RTON number-th element in the stack (starting from 0). Let's call the stack is ASCII_CACHE.
Example: the following dump contain 2 objects:
```
52 54 4F 4E 01 00 00 00
    90 08 23 63 6F 6D 6D 65 6E 74 90 33 50 6C 61 6E 74 20 6C 65 76 65 6C 69 6E 67 20 64 61 74 61 21 20 20 42 65 77 61 72 65 20 79 65 20 61 6C 6C 20 77 68 6F 20 65 6E 74 65 72 20 68 65 72 65 21
    90 07 54 65 73 74 69 6E 67 91 00
FF
44 4F 4E 45
```
- The 1st object it create a 8 bytes string key 23 63 6F 6D 6D 65 6E 74 (#comment in ASCII) (1st in ASCII_CACHE stack), value inside it is 51 bytes long string (0x33) Plant leveling data! Beware ye all who enter here! (2nd in ASCII_CACHE stack).
- The 2nd object create 7 bytes string key 54 65 73 74 69 6E 67 (Testing in ASCII) , value inside it is 91 00 which mean recall the 1st string in ASCII_CACHE stack.
- JSON decode:
```
{
    "#comment": "Plant leveling data!  Beware ye all who enter here!",
    "Testing": "#comment"
}
```

Cached UTF-8 String

`0x92` and `0x93`

Very much like the Cached String, 0x92 and 0x93 different is use the utf-8 encode
92 [L1] [L2] [string], the [L1] [L2] [string] same as 0x82.
Example:
```
52 54 4F 4E 01 00 00 00
    90 05 48 65 6C 6C 6F 92 0B 0E C4 90 C3 A2 79 20 6C C3 A0 20 75 74 66 38
    90 04 54 65 73 74 92 0A 0E 54 68 E1 BB AD 20 6E 67 68 69 E1 BB 87 6D
    93 01 93 00
FF 44 4F 4E 45
```
- The 1st object it create a 5 bytes string key 48 65 6C 6C 6F (Hello in ASCII) (1st in ASCII_CACHE stack), value inside it is 11 characters (0x0B), 14 bytes long utf-8 string (0x0E) Đây là utf8 (This is utf8 in Vietnamese) (1st in UTF8_CACHE stack).
- The 2nd object create 4 bytes string key 54 65 73 74 (Test in ASCII) (2nd in ASCII_CACHE stack), value inside it is 10 characters (0x0A), 14 bytes long utf-8 string (0x0E) Thử nghiệm (Test in Vietnamese) (2nd in UTF8_CACHE stack).
- The 3rd object with key using 93 01 recall the 2nd string in UTF8_CACHE Thử nghiệm and the value 93 00 recall the 1st string Đây là utf8.
- JSON decode:
```
{
    "Hello": "Đây là utf8",
    "Test": "Thử nghiệm",
    "Thử nghiệm": "Đây là utf8"
}
```

End of Object

`0xff`

Mark end of an object.

Example:

52 54 4F 4E 01 00 00 00
FF
44 4F 4E 45

JSON decode:

{}

TODO:

Find the correct format of 0x8302
Support regex input e.g: rton-json *.rton
Check for endianness
Write a header file act like extension to json.hpp, something like json::from_cbor() and json::to_cbor()

Credit

Niels Lohmann for his awesome json parser and fifo_map

P/s:

If there is anything wrong feel free to open an issue on github

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

README.md

README.md

RETON: Reverse Engineering RTON (RE RTON -> RETON)

Basic

RTON Cheatsheet

Unsigned RTON Number

`0x24`, `0x28` and `0x44`

RTON Number

`0x25`, `0x29` and `0x45`

String

`0x81`

UTF-8 String

`0x82`

RTID

`0x83`

`0x3` Subset

`0x2` Subset (may not be correct)

Object

`0x85`

Array

`0x86`, `0xfd` and `0xfe`

Cached String

`0x90` and `0x91`

Cached UTF-8 String

`0x92` and `0x93`

End of Object

`0xff`

TODO:

Credit

P/s:

Files

README.md

Latest commit

History

README.md

File metadata and controls

RETON: Reverse Engineering RTON (RE RTON -> RETON)

Basic

RTON Cheatsheet

Unsigned RTON Number

0x24, 0x28 and 0x44

RTON Number

0x25, 0x29 and 0x45

String

0x81

UTF-8 String

0x82

RTID

0x83

0x3 Subset

0x2 Subset (may not be correct)

Object

0x85

Array

0x86, 0xfd and 0xfe

Cached String

0x90 and 0x91

Cached UTF-8 String

0x92 and 0x93

End of Object

0xff

TODO:

Credit

P/s:

`0x24`, `0x28` and `0x44`

`0x25`, `0x29` and `0x45`

`0x81`

`0x82`

`0x83`

`0x3` Subset

`0x2` Subset (may not be correct)

`0x85`

`0x86`, `0xfd` and `0xfe`

`0x90` and `0x91`

`0x92` and `0x93`

`0xff`