?WikiName? - Souls Modding Wiki

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== DSR Network Protocol ======
This is a copy of the article 'Dissecting the network-protocol and -crypto behind Dark Souls Remastered.' originally written and published October 2, 2019.

===== Introduction =====

This post covers the complete game server messaging protocol of Dark Souls Remastered. All the information presented was obtained through reverse engineering of the patch 1.03 client, which is the latest version as of the writing of this article.

<code>
DarkSoulsRemastered.exe: 
    SHA-1 : F0ECFBE20D780751248DFB2A9759D6215E246676
</code>

===== Overview =====

Before we get into the details let’s look at the protocol at a very high level. The general timeline of a FromNet connection is as follows:

    * Client establishes TCP connection with fhd-steam-prod.fromsoftware-game.net.
    * Client sends init packet to initiate the key exchange.
    * Client and server negotiate a shared key and a pair of nonces. The key and nonces are used to encrypt all communications after this point.
    * Client authentication via ISteamUser::GetAuthSessionTicket.
    * Bidirectional communication using a request–response style message exchange until either party disconnects.

At the highest level of abstraction there are seven unique message types which can be identified by their opcodes. Each message type is discussed in more detail below.

<code C++>
enum class OpCode : uint8_t {
    init = 0x01,
    server_key_exchange = 0x02,
    client_key_exchange = 0x03,
    client_request = 0x04,
    client_request_response = 0x05,
    server_push_request = 0x06,
    heart_beat = 0x07
};
</code>

===== Initialization (op:01) =====

The first packet sent by the client after the tcp connection is established is very simple and just contains the message size (msg_size fields never include the size of the msg_size field itself), an opcode and a constant magic byte with the value 0x64. It’s not entirely clear what the byte represents but it’s presumably a client version or an id that indicates the requested service. Changing the magic byte to any other value results in the termination of the connection by the server.

<code C++>
struct Init {
    uint32_t msg_size; //0x02
    uint8_t  opcode    //0x01
    uint8_t  magic;    //0x64
};
</code>

===== Cryptography & Key exchange (op:02-03) =====

With the exception of the init packet, all communication is encrypted and authenticated. This is achieved through the use of the XSalsa20Poly1305 stream cipher. RTTI strings and the correlation of the clients assembly code with known implementations of the cipher shows that the particular implementation in use is provided by the libsodium library. The specific functions used to en/decrypt messages are crypto_secretbox_detached and crypto_secretbox_open_detached respectively.
Messages sent prior to completion of the key exchange are encrypted with a pre-shared encryption key that is stored in an obfuscated form inside the client binary. MAC, nonce and a message size field are prepended to the cipher text or in other words, the cipher text struct inherits from:

<code C++>
struct StaticKeyMessage {
    uint32_t msg_size;
    uint8_t  nonce[0x18];
    uint8_t  MAC[0x10];
};
</code>

Messages sent after a successful key/nonce exchange drop the nonce member as it’s not required anymore going forward.

<code C++>
struct DynamicKeyMessage {
    uint32_t msg_size;
    uint8_t  MAC[0x10];
};
</code>

The key exchange process aims to share 2 nonces and one key between the client and the server. Each nonce is used for one unique message direction and incremented by byte from left to right after each use. The exchange is initiated by the server and extends over two messages, below referred to as ServerKeyExch and ClientKeyExch. The server key exchange message provides the upper 0x10 bytes of the shared key, while the client message provides the lower 0x10 key bytes as well as both nonces. All the keys and nonces are randomly generated. The message structures are as follows:

<code C++>
struct ServerKeyExch : public StaticKeyMessage {
    uint8_t opcode; // 0x02
    uint8_t unique_token[0x40];
    uint8_t upper_key_fragment[0x10];
};
struct ClientKeyExch : public StaticKeyMessage {
    uint8_t opcode; // 0x03
    uint8_t unique_token[0x40];
    uint8_t lower_key_fragment[0x10];
    uint8_t c2s_nonce[0x18]; //used to encrypt client -> server messages
    uint8_t s2c_nonce[0x18]; //used to encrypt server -> client messages
};
</code>

The unique_token featured in both key exchange packets is a randomly generated array of bytes that gets generated by the server and echoed back by the client in the ClientKeyExch message. It doesn’t seem to have any other purpose.

The following shows a complete key exchange and the resulting key and nonces for reference:

<code>
Init...
(client) 02 00 00 00 01 64
KeyExchange:
ServerAckStep...
(server) 02 ae ca 75 0c a3 5b f7 15 ec b1 97 99 44 f2 e3 23 ea f2 c3 58 7d 53 bc 83 2b e0 c1 b2 d7 0d 1b da c9 14 1c fe 36 60 54 1a 7b 0f 93 61 a8 c0 11 a6 74 71 9f 00 d5 90 4a 86 b9 f0 ff 7c c8 20 f5 6e 66 4a 20 10 52 7d e9 54 ce 5e 90 1a 33 84 d9 dc
ClientAckStep...
(client) 03 ca 8c c7 7d fe bf da 4b 75 a8 e2 ad 75 1b e1 6e 5e 38 53 d0 a1 95 00 6f f0 10 3a 53 33 d8 59 55 4c d8 d3 d5 2d fd dd a5 5f ed 72 8f 35 0e f3 39 38 ab 90 bb a6 ab b0 0c 60 59 8c ac 23 5c cb ee 6c 83 d0 2b 0d b8 85 ef 1a 22 f4 d3 a8 7b 2a ad aa 55 f9 f6 1c 52 72 ed 3a 5f 13 d8 e0 52 96 5c 58 32 4c 26 e9 a3 2f 51 76 f1 06 fa be 8c ba 38 c5 a5 9e cd 73 4d 58 d2 22 cb 64 c9 49 37 eb 34 0a 0e c6 78 b1 6c 11 4b ab d2 d5 15 4c ae 86 05 63 e3 9f a6 38 68 c3 91 09 fe a3 20 4e 0b a9 a9 33 44 dd 06 36 6b 8a e6 50 57 cc 96 44 0c 71 22 93 73 6b 30 54 92 54 10 48 94 14 ab e3 86 66 5d 93 11 f3 b6 1c 7a 67 43 c6 fb 04 69 b1 6b 41 07 45 41 7b 97 90 20 86 88 12 2b 8b 5d cf c7 ec 9e 7c fd 22 41 10 43 8d c0 f7 92 65 f2 89 7a e5 61 ac c9 4c 39 ed 7e 76 0a 87 bc 70 09 73 75 ce 82 79 ba c9 e4 65 08 00 45 16 ef a4 b5 2c 13 5e ee 0e c3 51 ce 73 22 d4 9a f5 f8 95 f7 dc ae ab ba 18 7c 50 86 55 81 4b 5d d9 b4 3f 96 98 55 f9 99 2c b4 f9 8d 62 fb 23 78 dc c8 da c3 40 51 d9 2d d3 30 39 ba 02 3e b7 bc 56 05 dd 12 76 18 b2 24 0d d6 19 53 8a c0 d6 83 e4 32 00 35 2f 5f 4d e0 e3 dd 20 e9 0d 72 1f 55 81 ee 47 df 6d 44 77 89 43 19 8b 3a 04 d3 43 2e c8 2d e5 d9 8e 6c 2d 3c bc 01 b0 19 c6 f3 65 08 a4 6d de a2 4a 47 a5 23 c2 a8 5c be cc 53 d0 41 54 d1 9b 34 74 af 32 ef 95 53 59 96 dc a5 11 c7 08 3a cc 7f 74 cc cb 53 f1 43 00 72 e5 62 90 bd 61 a1 90 43 4b 83 89 f7 70 7f 08 ce 35 74 8e eb 6f 85 16 80 e4 5a 2b 95 93 49 64 20 d3 71 ac a6 b2 00 2f c6 0e c4 12 ce 06 b4 ef a2 06 c6 63 e4 b4 0b cc e7 d8 77 17 b3 ba
Key Exchange finished.
Shared key: 6c 83 d0 2b 0d b8 85 ef 1a 22 f4 d3 a8 7b 2a ad d8 f0 5c 24 38 9c c9 89 3a 86 f8 5f ea 14 22 4c
Encr nonce: aa 55 f9 f6 1c 52 72 ed 3a 5f 13 d8 e0 52 96 5c 58 32 4c 26 e9 a3 2f 51
Decr nonce: 76 f1 06 fa be 8c ba 38 c5 a5 9e cd 73 4d 58 d2 22 cb 64 c9 49 37 eb 34
</code>

===== Request/Response (op:04-05) =====

Once the shared key encryptor is initialized, the transfer of data relevant to the game can begin. The data exchange generally follows a Request-Response protocol. Client requests use the opcode 04, responses use the opcode 05. Corresponding request-response pairs are identified by a matching, unique sequence number. The actual data is transmitted in the form of a flatbuffer. Reversing the flatbuffer structure and deserializing the contained data is fairly complex and a topic for another day. Request structures aren’t padded and the size of the flatbuffer can be calculated using the message size field in the request header.

<code C++>
struct Request : public DynamicKeyMessage {
    uint8_t opcode; // 0x04/0x05
    uint32_t sequence_number;
    uint8_t flatbuffer[0];
};
</code>

===== Push Requests (op:06) =====

Push requests are server messages that notify the client about activities managed by the game server. For example area event and matchmaking related status messages. Push requests are unidirectional and aren’t directly answered by the client, the client might send requests in response to receiving a push request though.

<code C++>
struct PushRequest : public DynamicKeyMessage {
    uint8_t opcode; // 0x06
    uint8_t flatbuffer[0];
};
</code>

===== Heart Beat (op:07) =====

Heart beat messages are sent by the server when there hasn’t been any message exchange for longer than about 5 seconds. Heart beat messages are typically echoed back to the server, alternatively the client can send a request. If the client doesn’t respond at all, the connection will be terminated by the server.

<code C++>
struct HeartBeat : public DynamicKeyMessage {
    uint8_t opcode; // 0x07
    uint8_t magic;  // 0x64
};
</code>

===== Composite Messages =====

Messages are typically sent in isolation but there are cases where multiple messages are sent in a single buffer. Consequently, all recv buffers have to be inspected and potentially be split into individual messages. An example of such a composite is the buffer that contains the client key exchange message, this buffer will always contain a client request of type RequestLogin directly following the key exchange message. Decomposing receive buffers correctly is critical as dropping a message will result in desynchronisation of the shared key encryptor instances used to en/decrypt the network traffic.

===== Security =====

The described protocol has a number of severe design and security issues that allow a man in the middle (MITM) to fully decrypt, inspect and modify all transmitted data. This holds true even if the attacker has no knowledge of the pre-shared key and/or only captured the session traffic partially. One might argue that game server traffic isn’t very security critical but I strongly disagree. During the login, Steam auth packets are exchanged, which an attacker could use to impersonate and permanently ban a user from the service. From Software is also very well known for shipping buggy and exploitable parser code as part of their networking solution.
The following paragraphs briefly outline three of the major issues of the protocol:

1. Pre-shared key
The first and most obvious issue is a key exchange based on symmetric cryptography with a pre-shared key. Hiding keys in the client is futile and all information contained in the game client should be assumed to be compromised when designing a protocol. Knowledge of the embedded key allows a MITM to decrypt, inspect and modify all traffic if the message exchange is captured from the beginning.

2. Insecure client side RNG usage
During key exchange, the client provides 0x10 bytes of key material, as well as two xSalsa20 nonces. All those bytes originate from an insecurely seeded mt19937 RNG. The use of mt19937, which isn’t a cryptographically secure random number generator, completely breaks the security of the protocol, even if the key exchange wasn’t observed by a MITM. The insecure seeding is merely an additional convenience that reduces the time needed to reverse the keys.

3. Insecure server side RNG usage
This insecure RNG use isn’t limited to the client but also applies to the server, where the upper 0x10 bytes of the xSalsa20 keys are generated. This flaw has much bigger implications on the server side. With each login attempt, an attacker can exfiltrate 0x10 bytes from the server side RNG which allows the reverse engineering of the internal state of the RNG instance, which in turn allows the calculation of all, past and future, key material the server has and will produce until the server instance is rebooted.

===== Solutions =====

Secure key exchange is for the most part a solved issue and the protocol should use one of the well tested and believed to be secure protocols like the Diffie-Hellman key exchange protocol. From Software tried to fix the insecure key exchange in later products by using RSA. Unfortunately they didn’t really improve the security by doing so but that’s a story for another day.
The insecure RNG could be fixed by switching to a more suitable generator. This should be fairly simple since the client already links against libcrypto but unfortunately this issue has never been addressed in later iterations of the engine.
?WikiName? - Souls Modding Wiki

User Tools

Site Tools

Page Tools
