Remedy Archive System - Revision history

RavuAlHemio: /* RAS1+2 (Max Payne 1+2) */ clarify reduction-to-s8

2025-11-23T23:08:05Z

‎RAS1+2 (Max Payne 1+2): clarify reduction-to-s8

RavuAlHemio: reformulate sign bit treatment in xor

2025-11-23T23:03:39Z

reformulate sign bit treatment in xor

RavuAlHemio: /* RAS1+2 (Max Payne 1+2) */ improve bitwise xor explanation

2025-11-23T23:02:51Z

‎RAS1+2 (Max Payne 1+2): improve bitwise xor explanation

RavuAlHemio: /* RAS1+2 (Max Payne 1+2) */ define and use ReduceU32ToS8 on i

2025-11-23T18:59:45Z

‎RAS1+2 (Max Payne 1+2): define and use ReduceU32ToS8 on i

RavuAlHemio: /* RAS1+2 (Max Payne 1+2) */ fix DivideS32U8 return type

2025-11-23T18:51:04Z

‎RAS1+2 (Max Payne 1+2): fix DivideS32U8 return type

RavuAlHemio: S/I inconsistency

2025-11-23T18:46:56Z

S/I inconsistency

RavuAlHemio: /* RAS1+2 (Max Payne 1+2) */ precise description of the algorithm

2025-11-23T18:41:14Z

‎RAS1+2 (Max Payne 1+2): precise description of the algorithm

RavuAlHemio at 15:47, 22 November 2025

2025-11-22T15:47:03Z

RavuAlHemio: table row

2025-11-22T15:36:08Z

table row

RavuAlHemio: MP2 uses the same decryption method

2025-11-22T15:32:43Z

MP2 uses the same decryption method

@@ Line 182: / Line 182: @@
    // perform a bitwise exclusive-or operation
    // on the bits of operand1 with the corresponding bits of operand2
-   // with the sign bits treated equally as all the other bits
+   // with the sign bits treated equally to all the other bits
    return ...
 function ReduceS32ToS8(i: s32): s8
    // remove the topmost 24 bits of `i`,
-   // returning the remaining bits as a signed 8-bit integer;
+   // returning the remaining bits as an 8-bit signed two's-complement integer;
-   // if the topmost bit of the resulting integer happens to be 1,
+   // no modification is made to the topmost remaining bit
-   // the result is negative
+   // (which becomes the result's sign bit)
    return ...
 function ReduceU32ToS8(u: u32): s8
    // remove the topmost 24 bits of `u`,
-   // returning the remaining bits as a signed 8-bit integer;
+   // returning the remaining bits as an 8-bit signed two's-complement integer;
-   // if the topmost bit of the resulting integer happens to be 1,
+   // no modification is made to the topmost remaining bit
-   // the result is negative
+   // (which becomes the result's sign bit)
    return ...

@@ Line 182: / Line 182: @@
    // perform a bitwise exclusive-or operation
    // on the bits of operand1 with the corresponding bits of operand2
-   // with no special provisions for the sign bit
+   // with the sign bits treated equally as all the other bits
    return ...

@@ Line 181: / Line 181: @@
 function BitwiseXorS32(operand1: s32, operand2: s32): s32
    // perform a bitwise exclusive-or operation
-   // on the bits of operand1 and operand2
+   // on the bits of operand1 with the corresponding bits of operand2
    // with no special provisions for the sign bit
    return ...

@@ Line 187: / Line 187: @@
 function ReduceS32ToS8(i: s32): s8
    // remove the topmost 24 bits of `i`,
    // returning the remaining bits as a signed 8-bit integer;
    // if the topmost bit of the resulting integer happens to be 1,
@@ Line 207: / Line 214: @@
      key := AddS32(d, f)
-     g := ReduceS32ToS8(i)
+     g := ReduceU32ToS8(i)
      h := SignExtendS8ToS32(g)
      j := AddS32(h, 3)

@@ Line 169: / Line 169: @@
    return ...
-function DivideS32U8(dividend: s32, divisor: u8): u8
+function DivideS32U8(dividend: s32, divisor: u8): s32
    // divide `dividend` by `divisor` and return the quotient;
    // always round toward 0

@@ Line 152: / Line 152: @@
    return ...
-function RotateLeftI8(i: s8, by: u8): s8
+function RotateLeftS8(i: s8, by: u8): s8
    // rotate the 8-bit value `i` left by the number of bits in `by`
    // (shift the value `i` left by `by` bits,
@@ Line 199: / Line 199: @@
      a := BitCastU8ToS8(buf[i])
      b := ModuloU32U8(i, 5)
-     c := RotateLeftI8(a, b)
+     c := RotateLeftS8(a, b)
      buf[i] := BitCastS8ToU8(c)

← Older revision		Revision as of 18:41, 23 November 2025
Line 132:		Line 132:

	Note that the algorithm relies heavily on signed-integer wraparound and C's integer promotion rules; an operation like <code>((int8_t)i) + 3</code> will sign-extend the 8-bit value of <code>i</code> to 32 bits before adding 3.		Note that the algorithm relies heavily on signed-integer wraparound and C's integer promotion rules; an operation like <code>((int8_t)i) + 3</code> will sign-extend the 8-bit value of <code>i</code> to 32 bits before adding 3.
		+
		+	A more complete description of the algorithm is as follows:
		+
		+	<pre>
		+	function BitCastU8ToS8(u: u8): s8
		+	// reinterpret the bits of `u`, an 8-bit unsigned integer,
		+	// as an 8-bit signed two's-complement integer
		+	return ...
		+
		+	function BitCastS8ToU8(i: s8): i8
		+	// reinterpret the bits of `i`, an 8-bit signed two's-complement integer,
		+	// as an 8-bit unsigned integer
		+	return ...
		+
		+	function SignExtendS8ToS32(i: s8): s32
		+	// expand `i` from 8 bits to 32 bits
		+	// by copying its topmost bit into the top 24 bits
		+	// and the bottom 8 bits being the same as the bits of `i`
		+	return ...
		+
		+	function RotateLeftI8(i: s8, by: u8): s8
		+	// rotate the 8-bit value `i` left by the number of bits in `by`
		+	// (shift the value `i` left by `by` bits,
		+	// shifting in the bits on the right that "fall out" on the left)
		+	return ...
		+
		+	function MultiplyS32(factor1: s32, factor2: s32): s32
		+	// sign-extend `factor1` and `factor2` each to s64,
		+	// multiply them, then take the bottom 32 bits of the product
		+	// and return it as s32
		+	return ...
		+
		+	function ModuloU32U8(dividend: u32, divisor: u8): u8
		+	// divide `dividend` by `divisor` and return the remainder;
		+	// this must be a value 0 ≤ value < divisor
		+	return ...
		+
		+	function DivideS32U8(dividend: s32, divisor: u8): u8
		+	// divide `dividend` by `divisor` and return the quotient;
		+	// always round toward 0
		+	return ...
		+
		+	function AddS32(summand1: s32, summand2: s32): s32
		+	// add `summand1` and `summand2`;
		+	// wrap around (drop any carry bits) if addition overflows
		+	return ...
		+
		+	function BitwiseXorS32(operand1: s32, operand2: s32): s32
		+	// perform a bitwise exclusive-or operation
		+	// on the bits of operand1 and operand2
		+	// with no special provisions for the sign bit
		+	return ...
		+
		+	function ReduceS32ToS8(i: s32): s8
		+	// remove the topmost 24 bits of `i`,
		+	// returning the remaining bits as a signed 8-bit integer;
		+	// if the topmost bit of the resulting integer happens to be 1,
		+	// the result is negative
		+	return ...
		+
		+	function Decrypt(buf: u8[], key: s32): void
		+	if key == 0
		+	key := 1
		+
		+	for i from 0 to buf.length-1
		+	a := BitCastU8ToS8(buf[i])
		+	b := ModuloU32U8(i, 5)
		+	c := RotateLeftI8(a, b)
		+	buf[i] := BitCastS8ToU8(c)
		+
		+	d := MultiplyS32(key, 171)
		+	e := DivideS32U8(key, 177)
		+	f := MultiplyS32(e, -30269)
		+	key := AddS32(d, f)
		+
		+	g := ReduceS32ToS8(i)
		+	h := SignExtendS8ToS32(g)
		+	j := AddS32(h, 3)
		+	k := MultiplyS32(j, 6)
		+	l := BitCastU8ToS8(buf[i])
		+	m := SignExtendS8ToS32(l)
		+	n := BitwiseXorS32(k, m)
		+	o := ReduceS32ToS8(key)
		+	p := SignExtendS8ToS32(o)
		+	q := AddS32(n, p)
		+	r := ReduceS32ToS8(q)
		+	buf[i] := BitCastS8ToU8(r)
		+	</pre>

	[[Category:Remedy Entertainment]]		[[Category:Remedy Entertainment]]

@@ Line 20: / Line 20: @@
 struct RASHeader {
    uint8_t magic[4]; // "RAS\0"
-   uint32_t encryptionKey;
+   int32_t encryptionKey;
 };
 </pre>
@@ Line 130: / Line 130: @@
+}
 </pre>
 [[Category:Remedy Entertainment]]

@@ Line 49: / Line 49: @@
 |-
 || 1.2 || 3 || Max Payne
 || 1.2 || 4 || Max Payne 2
 |}

@@ Line 49: / Line 49: @@
 |-
 || 1.2 || 3 || Max Payne
 |}
@@ Line 102: / Line 103: @@
 Depending on the generation of the RAS file format, different encryption schemes are used.
-=== RAS1 (Max Payne) ===
+=== RAS1+2 (Max Payne 1+2) ===
 <pre>