Saving and loading games in Bundesliga Manager Professional

Saving and loading games in Bundesliga Manager
Professional
1 Introduction
Roland Kübert
December 2010
This document describes how Software 2000’s Bundesliga Manager Professional
(BMP), also known as The Manager in English, saves and loads games. The
in-game data that is saved is encrypted and both the encryption and decryption
process are described in this document.
2 File format
A save game in BMP is 34369 bytes long. Out of these, 37 bytes are non-payload
data: the file header (34 bytes), a seed value (1 byte) and two checksums (1
byte each). All the rest is payload data, that is the data used by the game itself
and saving the player’s information.
2.1 File header
The file header consists of a 29 byte long text string (WeRnEr krahe & JeNs onnenBMP!),
followed by 5 more bytes, of which byte 3 and 4 are always both zero. The significance
of these values is yet unclear.
2.2 Seed
The seed value is a probably random value used in the encryption process. It is
yet unclear how this value is determined.
2.3 Checksums
The checksum bytes computed during the encryption process and are stored at
two times, once at offset 28006 and at offset 34368, the end of the file.
1

2.4 Payload
What the payload data contains is only partially known at this time. Look
at https://sourceforge.net/apps/mediawiki/freebmp/index.php?title=
MAN\_file\_format for up-to-date information.
3 The saving process
Savegame encryption is not overly complex, but nonetheless we firstly present
an example before defining the algorithm.
3.1 An example save game
The save game process starts by obtaining the seed value. For this example,
let the seed value be y = 0xC3 and let the first bytes be a0a1a2a3 =
0x040x050x060x07.
Initially, the checksum is set to be equal to the seed value, that is
.
3.1.1 Encrypting the first byte
checksum = C3
The encrypted value for our unencrypted byte a = 0x04 is computed like this:
aienc = (ai ⊕ y) + y%0x100
That is, the current value of y is xor’d with a and then y is added to the
result again. The result is taken mod 256, which just means that any value that
does not fit in one byt is discarded. For our example, this gives the following
result:
1
a0enc = (0x04 ⊕ 0xC3) + 0xC3 = 0xC7 + 0xC3 = 0x8A
As we have said, only the lowest byte of the result is used, therefore a0enc
results to 0x8A.
Another value, which we call z, comes into play now. This value is a static
value that is fixed to 0xD7 in BMP and that is used to compute the next value
of y like this:
y = y + z%100
1 Obviously, the result overflows into the next byte giving 0x18A as the result. However,
the overflow value is never used and therefore we omit from here on.
2

The new value of y is the result of the addition of the old value of y and the
value of z. Once again, only the low byte of this computation is kept. In our
case, this results in the new value of y being 0x9A:
y + z = 0xC3 + 0XD7 = 0x9A
The new checksum value is computed by adding the unencrypted value of ai
to the old checksum value (if the value exceeds one byte, only the lowest byte
is retained):
checksum = checksum + ai = 0xC3 + 0x04 = 0xC7
This concludes all computations for the first byte. As a result, the value of
a0enc = 0x8A, is written to the save file.
3.1.2 Encrypting the second byte
The same process as before is now applied to the second byte, a1 = 0x05.
We compute a1enc by xoring with y, adding y and keeping the low byte (we
omit mod 256 ):
a1enc = (a1 ⊕ y) + y = (0x05 ⊕ 0x9A) + 0x9A = 0x9F + 0x9A = 0x39
Therefore, a1enc = 0x39.
For the new value of y, we increase y by 0xD7, keeping only the low byte:
y = y + 0xD7 = 0x9A + 0xD7 = 0x71
We increase the checksum with the value of a1:
checksum = checksum + a1 = 0xC7 + 0x05 = 0xCC
This concludes all computations for the second byte. As a result, the value
of a1enc = 0x39, is written to the save file.
3.1.3 Encrypting the third byte
The same process as before is now applied to the third byte, a1 = 0x06.
We compute a2enc by xoring with y, adding y and keeping the low byte (we
omit mod 256 ):
a2enc = (a2 ⊕ y) + y = (0x06 ⊕ 0x71) + 0x71 = 0x77 + 0x71 = 0xE8
Therefore, a2enc = 0xE8.
For the new value of y, we increase y by 0xD7, keeping only the low byte:
y = y + 0xD7 = 0x71 + 0xD7 = 0x48
3

We increase the checksum with the value of a2:
checksum = checksum + a2 = 0xCC + 0x06 = 0xD2
This concludes all computations for the third byte. As a result, the value of
a2enc = 0xE8, is written to the save file.
3.1.4 Encrypting the fourth byte
The same process as before is now applied to the fourth byte, a3 = 0x07.
We compute a3enc by xoring with y, adding y and keeping the low byte (we
omit mod 256 ):
a3enc = (a3 ⊕ y) + y = (0x07 ⊕ 0x48) + 0x48 = 0x4F + 0x48 = 0x97
Therefore, a3enc = 0x97.
For the new value of y, we increase y by 0xD7, keeping only the low byte:
y = y + 0xD7 = 0x48 + 0xD7 = 0x1F
We increase the checksum with the value of a2:
checksum = checksum + a3 = 0xD2 + 0x07 = 0xD9
This concludes all computations for the third byte. As a result, the value of
a3enc = 0xD9, is written to the save file.
3.1.5 Encrypting the nth byte
We refrain from giving more example as the process is quite clear from the 4
examples above. The only special case is the first iteration, where the initial
values are set up. There are, however, two special occassions when the checksum
byte is written: once at offset 28006 and once at offset 34368. The last offset is
the last byte in the saved file, the other offset is some arbitrary value.
3.2 The encryption algorithm
The following listing shows the algorithm in kind of pseudo-code.
y = 0xC3 # Just use a f i x e d value f o r y
z = 0xD7 # Use a f i x e d value f o r z as w e l l
checksum = y
f o r o f f s e t in range ( 0 , payload bytes ) :
a dec = i n f i l e . read ( 1 )
a enc = ( a dec ˆ y ) + y ) % 0x100
y = ( y + z ) % 0 x100
4

checksum = ( checksum + a dec ) % 0x100
o u t f i l e . w r i t e ( a enc )
# Write checksum bytes i f n e c e s s a r y
i f o f f s e t == 27970 or o f f s e t == 34331:
o u t f i l e . w r i t e ( checksum )
checksum = checksum new
4 The loading process
Given an encrypted game, how is the payload data extracted? This sections
answers this problem by demonstrating how a given file is read. The file format
is described in section 2, but table 4 summarizes the structure for your
convenience:
Offset Length Description
0 34 Header
34 1 Seed
35 27972 Payload data, part 1
28006 1 Checksum 1
28007 6360 Payload data, part 2
34368 1 Checksum 2
The seed value, which will be labeled with the variable y in this section’s
equations, is the first value that needs to be read (apart from the file header,
which can be used to identify if the file is even a save game file in the correct
format). Similar to section 3, we present how the algorithm works on the first
four bytes of a save game.
4.1 An example save game
The save game process starts by obtaining the seed value from the file. For this
example, let the seed value be y = 0xC3 and let the first bytes be a0a1a2a3 =
0x8A0x390xE80xD9.
Initially, the checksum is set to be equal to the seed value, that is
.
4.1.1 Decrypting the first byte
checksum = C3
The first byte is a0 = 0x8A. The decrypted value is obtained by the following
computation:
5

a0dec = (a0 − y) ⊕ y)
As when encoding, only the lower 8 bits of the result are used, which means
that an implicit mod 256 is applied, which we omit for the sake of clarity from
the equations. If y is greater than the value of the byte to decrypt, you can
assume an implicit addition of 256. The unencrypted value is:
a0dec = (0x8A−0xC3)⊕0xC3 = (0x18A−0xC3)⊕0xC3 = 0xC7⊕0xC3 = 0x04
As before, the value of y is increased by a fixed value (mod 256 ), called z,
which is always z = 0xD7:
y = y + z = 0xC3 + 0xD7 = 0x9A
The checksum is increased by the decrypted value of a0:
checksum = checksum + a0dec = 0xC3 + 0x04 = 0xC7
4.1.2 Decrypting the second byte
The second byte is a1 = 0x39, which we decrypt using y = 0x9A:
a1dec = (0x39−0x9A)⊕0x9A = (0x139−0x9A)⊕0x9A = 0x9F ⊕0x9A = 0x05
As before, the value of y is increased by a fixed value (mod 256 ), called z,
which is always z = 0xD7:
y = y + z = 0x9A + 0xD7 = 0x71
The checksum is increased by the decrypted value of a1:
checksum = checksum + a1dec = 0xC7 + 0x05 = 0xCC
4.1.3 Decrypting the third byte
The third byte is a2 = 0xE8, which we decrypt using y = 0x71:
a2dec = (0xEB − 0x71) ⊕ 0x71 = 0x7A ⊕ 0x71 = 0x06
As before, the value of y is increased by a fixed value (mod 256 ), called z,
which is always z = 0xD7:
y = y + z = 0x71 + 0xD7 = 0x48
The checksum is increased by the decrypted value of a2:
checksum = checksum + a2dec = 0xCC + 0x06 = 0xD2
6

4.1.4 Decrypting the fourth byte
The fourth byte is a3 = 0x97, which we decrypt using y = 0x48:
a3dec = (0x97 − 0x48) ⊕ 0x48 = 0x4F ⊕ 0x48 = 0x07
As before, the value of y is increased by a fixed value (mod 256 ), called z,
which is always z = 0xD7:
y = y + z = 0x48 + 0xD7 = 0x1F
The checksum is increased by the decrypted value of a3:
checksum = checksum + a3dec = 0xD2 + 0x07 = 0xD9
4.1.5 Decrypting the nth byte
We refrain from giving more example as the process is quite clear from the 4
examples above. The only special case is the first iteration, where the initial
values are set up. There are, however, two special occassions when the checksum
byte is read: once at offset 28006 and once at offset 34368. The last offset is the
last byte in the saved file, the other offset is some arbitrary value.
If the checksum is not correct, that is the file has been manipulated, the
game recognizes this through the checksum, prints an error message and hangs.
4.2 The decoding algorithm
The following listing shows the algorithm in kind of pseudo-code.
z = 0xD7 # Use a f i x e d value f o r z
# Read i n i t i a l y ( i n f i l e i s at o f f s e t 34 already )
y = i n f i l e . read ( 1 )
checksum = y
# I t e r a t e through a l l payload bytes
f o r i in range ( 0 , payload bytes ) :
a enc = i n f i l e . read ( 1 )
# Ignore the f i r s t and l a s t checksum byte , that i s , do not decode i t
i f o f f s e t == 27971 or o f f s e t == 34333:
# Skip checksum bytes at o f f s e t s 27971 and 34333
e l s e :
a dec = ( a enc − y ) ˆ y ) % 0x100
y = ( y + z ) % 256
checksum = ( checksum + a dec ) % 0x100
o u t f i l e . w r i t e ( a dec )
o f f s e t = o f f s e t + 1
7

5 Version
This file is revision number 127 from 2010-12-21 20:01:56Z, committed by rkuebert.
8