Fix error handling, work on native backend issues.

retrixe · retrixe · commit b47fc6ee8d96 · 2022-08-28T22:10:38.000+05:30
Share encryption packet handling between JS and native backends.
diff --git a/TODO b/TODO
diff --git a/android/app/src/main/java/com/enderchat/modules/connection/ConnectionModule.kt b/android/app/src/main/java/com/enderchat/modules/connection/ConnectionModule.kt
@@ -186,7 +186,6 @@ class ConnectionModule(reactContext: ReactApplicationContext)
                     buffer.write(bytes, packet.totalLength!!, bytes.size - packet.totalLength)
 
                     // We can handle Keep Alive, Login Success and Set Compression.
-                    // TODO: Maybe handle Keep Alive in JS. The overhead is minimal and would take away the disconnect timer from here.
                     if (packet.id.value == keepAliveClientBoundId) {
                         directlyWriteToConnection(keepAliveServerBoundId, packet.data)
                         continue
@@ -239,11 +238,15 @@ class ConnectionModule(reactContext: ReactApplicationContext)
             .emit(eventName, params)
     }
 
-    @ReactMethod fun addListener(/* eventName: String */) {
+    @ReactMethod
+    @Suppress("UNUSED_PARAMETER")
+    fun addListener(eventName: String) {
         // Set up any upstream listeners or background tasks as necessary
     }
 
-    @ReactMethod fun removeListeners(/* count: Int */) {
+    @ReactMethod
+    @Suppress("UNUSED_PARAMETER")
+    fun removeListeners(count: Int) {
         // Remove upstream listeners, stop unnecessary background tasks
     }
 }
diff --git a/src/minecraft/connection/javascript.ts b/src/minecraft/connection/javascript.ts
@@ -6,30 +6,19 @@ import {
   Cipher,
   createCipheriv,
   createDecipheriv,
-  createHash,
-  Decipher,
-  publicEncrypt
+  Decipher
 } from 'react-native-crypto'
 import {
   concatPacketData,
   makeBaseCompressedPacket,
   makeBasePacket,
   Packet,
-  PacketDataTypes,
   parseCompressedPacket,
   parsePacket
 } from '../packet'
-import {
-  readVarInt,
-  writeVarInt,
-  resolveHostname,
-  mcHexDigest,
-  protocolMap,
-  getRandomBytes
-} from '../utils'
-import { joinMinecraftSession } from '../api/mojang'
 import { ServerConnection, ConnectionOptions } from '.'
-import { getLoginPacket, parseEncryptionRequestPacket } from './shared'
+import { getLoginPacket, handleEncryptionRequest } from './shared'
+import { readVarInt, writeVarInt, resolveHostname, protocolMap } from '../utils'
 
 export declare interface JavaScriptServerConnection {
   on: ((event: 'packet', listener: (packet: Packet) => void) => this) &
@@ -200,56 +189,19 @@ const initiateJavaScriptConnection = async (opts: ConnectionOptions) => {
                   conn.close()
                   continue
                 }
-                // https://wiki.vg/Protocol_Encryption
-                const [serverId, publicKey, verifyToken] =
-                  parseEncryptionRequestPacket(packet)
-                ;(async () => {
-                  const secret = await getRandomBytes(16) // Generate random 16-byte shared secret.
-                  // Generate hash.
-                  const sha1 = createHash('sha1')
-                  sha1.update(serverId) // ASCII encoding of the server id string from Encryption Request
-                  sha1.update(secret)
-                  sha1.update(publicKey) // Server's encoded public key from Encryption Request
-                  const hash = mcHexDigest(sha1.digest())
-                  // Send hash to Mojang servers.
-                  const req = await joinMinecraftSession(
-                    accessToken,
-                    selectedProfile,
-                    hash
-                  )
-                  if (!req.ok) {
-                    throw new Error('Mojang online mode network request failed')
-                  }
-                  // Encrypt shared secret and verify token with public key.
-                  const pk =
-                    '-----BEGIN PUBLIC KEY-----\n' +
-                    publicKey.toString('base64') +
-                    '\n-----END PUBLIC KEY-----'
-                  const ePrms = { key: pk, padding: 1 } // RSA_PKCS1_PADDING
-                  const encryptedSharedSecret = publicEncrypt(ePrms, secret)
-                  const encryptedVerifyToken = publicEncrypt(ePrms, verifyToken)
-                  // Send encryption response packet.
-                  // From this point forward, everything is encrypted, including the Login Success packet.
-                  const response: PacketDataTypes[] = [
-                    writeVarInt(encryptedSharedSecret.byteLength),
-                    encryptedSharedSecret,
-                    writeVarInt(encryptedVerifyToken.byteLength),
-                    encryptedVerifyToken
-                  ]
-                  if (is119) {
-                    conn.msgSalt = await getRandomBytes(8)
-                    response.splice(2, 0, true)
+                handleEncryptionRequest(
+                  packet,
+                  accessToken,
+                  selectedProfile,
+                  conn,
+                  is119,
+                  async (secret: Buffer, response: Buffer) => {
+                    const AES_ALG = 'aes-128-cfb8'
+                    conn.aesDecipher = createDecipheriv(AES_ALG, secret, secret)
+                    await conn.writePacket(0x01, response)
+                    conn.aesCipher = createCipheriv(AES_ALG, secret, secret)
                   }
-                  const AES_ALG = 'aes-128-cfb8'
-                  conn.aesDecipher = createDecipheriv(AES_ALG, secret, secret)
-                  await conn.writePacket(0x01, concatPacketData(response))
-                  conn.aesCipher = createCipheriv(AES_ALG, secret, secret)
-                })().catch(e => {
-                  console.error(e)
-                  conn.disconnectReason =
-                    '{"text":"Failed to authenticate with Mojang servers!"}'
-                  conn.close()
-                })
+                )
               }
               conn.emit('packet', packet)
             } else break
diff --git a/src/minecraft/connection/native.ts b/src/minecraft/connection/native.ts
@@ -4,19 +4,10 @@ import {
   NativeModules
 } from 'react-native'
 import events from 'events'
-import { createHash, publicEncrypt } from 'react-native-crypto'
-import { concatPacketData, Packet, PacketDataTypes } from '../packet'
-import {
-  readVarInt,
-  writeVarInt,
-  resolveHostname,
-  mcHexDigest,
-  protocolMap,
-  getRandomBytes
-} from '../utils'
-import { joinMinecraftSession } from '../api/mojang'
 import { ServerConnection, ConnectionOptions } from '.'
-import { getLoginPacket, parseEncryptionRequestPacket } from './shared'
+import { concatPacketData, Packet } from '../packet'
+import { getLoginPacket, handleEncryptionRequest } from './shared'
+import { readVarInt, writeVarInt, resolveHostname, protocolMap } from '../utils'
 
 const { ConnectionModule } = NativeModules
 
@@ -65,6 +56,10 @@ export class NativeServerConnection
     this.eventEmitter.addListener('packet', (event: NativePacketEvent) => {
       console.log(event)
       if (event.connectionId !== this.id) return
+      // Handle timeout after 20 seconds of no data. (TODO: Handle this natively.)
+      if (this.disconnectTimer) clearTimeout(this.disconnectTimer)
+      this.disconnectTimer = setTimeout(() => this.close(), 20000)
+      // Run after interactions to improve user experience.
       InteractionManager.runAfterInteractions(() => {
         const packet: Packet = {
           id: event.id,
@@ -75,16 +70,15 @@ export class NativeServerConnection
           lengthLength: event.lengthLength
         }
 
-        // Internally handle login packets.
-        // We aren't handling these in native for improved code sharing.
-        // TODO: Actually share code with the JavaScript back-end.
+        // Internally handle login packets. We aren't handling these in native to share code.
         const is1164 = options.protocolVersion >= protocolMap['1.16.4']
         const is117 = options.protocolVersion >= protocolMap[1.17]
         const is119 = options.protocolVersion >= protocolMap[1.19]
         const is1191 = options.protocolVersion >= protocolMap['1.19.1']
         // Set Compression and Keep Alive are handled in native for now.
-        if (packet.id === 0x02 && !this.loggedIn) {
-          this.loggedIn = true // Login Success
+        // When modifying this code, apply the same changes to the JavaScript back-end.
+        if (packet.id === 0x02 && !this.loggedIn /* Login Success */) {
+          this.loggedIn = true
         } else if (
           // Disconnect (login) or Disconnect (play)
           (packet.id === 0x00 && !this.loggedIn) ||
@@ -111,56 +105,19 @@ export class NativeServerConnection
             this.close()
             return
           }
-          // https://wiki.vg/Protocol_Encryption
-          const [serverId, publicKey, verifyToken] =
-            parseEncryptionRequestPacket(packet)
-          ;(async () => {
-            const secret = await getRandomBytes(16) // Generate random 16-byte shared secret.
-            // Generate hash.
-            const sha1 = createHash('sha1')
-            sha1.update(serverId) // ASCII encoding of the server id string from Encryption Request
-            sha1.update(secret)
-            sha1.update(publicKey) // Server's encoded public key from Encryption Request
-            const hash = mcHexDigest(sha1.digest())
-            // Send hash to Mojang servers.
-            const req = await joinMinecraftSession(
-              accessToken,
-              selectedProfile,
-              hash
-            )
-            if (!req.ok) {
-              throw new Error('Mojang online mode network request failed')
-            }
-            // Encrypt shared secret and verify token with public key.
-            const pk =
-              '-----BEGIN PUBLIC KEY-----\n' +
-              publicKey.toString('base64') +
-              '\n-----END PUBLIC KEY-----'
-            const ePrms = { key: pk, padding: 1 } // RSA_PKCS1_PADDING
-            const encryptedSharedSecret = publicEncrypt(ePrms, secret)
-            const encryptedVerifyToken = publicEncrypt(ePrms, verifyToken)
-            // Send encryption response packet.
-            // From this point forward, everything is encrypted, including the Login Success packet.
-            const response: PacketDataTypes[] = [
-              writeVarInt(encryptedSharedSecret.byteLength),
-              encryptedSharedSecret,
-              writeVarInt(encryptedVerifyToken.byteLength),
-              encryptedVerifyToken
-            ]
-            if (is119) {
-              this.msgSalt = await getRandomBytes(8)
-              response.splice(2, 0, true)
+          handleEncryptionRequest(
+            packet,
+            accessToken,
+            selectedProfile,
+            this,
+            is119,
+            async (secret: Buffer, response: Buffer) => {
+              // const AES_ALG = 'aes-128-cfb8'
+              // conn.aesDecipher = createDecipheriv(AES_ALG, secret, secret)
+              await this.writePacket(0x01, response)
+              // conn.aesCipher = createCipheriv(AES_ALG, secret, secret)
             }
-            // const AES_ALG = 'aes-128-cfb8'
-            // this.aesDecipher = createDecipheriv(AES_ALG, secret, secret)
-            await this.writePacket(0x01, concatPacketData(response))
-            // this.aesCipher = createCipheriv(AES_ALG, secret, secret)
-          })().catch(e => {
-            console.error(e)
-            this.disconnectReason =
-              '{"text":"Failed to authenticate with Mojang servers!"}'
-            this.close()
-          })
+          )
         }
 
         this.emit('packet', packet)
@@ -200,7 +157,7 @@ export class NativeServerConnection
 
 const initiateNativeConnection = async (opts: ConnectionOptions) => {
   const [host, port] = await resolveHostname(opts.host, opts.port)
-  const id = await ConnectionModule.createConnection({
+  const id = await ConnectionModule.openConnection({
     loginPacket: getLoginPacket(opts).toString('base64'),
     ...opts,
     host,
diff --git a/src/minecraft/connection/shared.ts b/src/minecraft/connection/shared.ts
@@ -1,6 +1,14 @@
-import { ConnectionOptions } from '.'
+import { createHash, publicEncrypt } from 'react-native-crypto'
+import { ConnectionOptions, ServerConnection } from '.'
+import { joinMinecraftSession } from '../api/mojang'
 import { concatPacketData, Packet, PacketDataTypes } from '../packet'
-import { protocolMap, readVarInt, writeVarInt } from '../utils'
+import {
+  getRandomBytes,
+  mcHexDigest,
+  protocolMap,
+  readVarInt,
+  writeVarInt
+} from '../utils'
 
 export const parseEncryptionRequestPacket = (packet: Packet) => {
   // ASCII encoding of the server id string
@@ -49,3 +57,57 @@ export const getLoginPacket = (opts: ConnectionOptions) => {
   }
   return concatPacketData(data)
 }
+
+export const handleEncryptionRequest = (
+  packet: Packet,
+  accessToken: string,
+  selectedProfile: string,
+  connection: ServerConnection,
+  is119: boolean,
+  callback: (secret: Buffer, response: Buffer) => Promise<void>
+) => {
+  // https://wiki.vg/Protocol_Encryption
+  const [serverId, publicKey, verifyToken] =
+    parseEncryptionRequestPacket(packet)
+  ;(async () => {
+    const secret = await getRandomBytes(16) // Generate random 16-byte shared secret.
+    // Generate hash.
+    const sha1 = createHash('sha1')
+    sha1.update(serverId) // ASCII encoding of the server id string from Encryption Request
+    sha1.update(secret)
+    sha1.update(publicKey) // Server's encoded public key from Encryption Request
+    const hash = mcHexDigest(sha1.digest())
+    // Send hash to Mojang servers.
+    const req = await joinMinecraftSession(accessToken, selectedProfile, hash)
+    if (!req.ok) {
+      throw new Error('Mojang online mode network request failed')
+    }
+    // Encrypt shared secret and verify token with public key.
+    const pk =
+      '-----BEGIN PUBLIC KEY-----\n' +
+      publicKey.toString('base64') +
+      '\n-----END PUBLIC KEY-----'
+    const ePrms = { key: pk, padding: 1 } // RSA_PKCS1_PADDING
+    const encryptedSharedSecret = publicEncrypt(ePrms, secret)
+    const encryptedVerifyToken = publicEncrypt(ePrms, verifyToken)
+    // Send encryption response packet.
+    // From this point forward, everything is encrypted, including the Login Success packet.
+    const response: PacketDataTypes[] = [
+      writeVarInt(encryptedSharedSecret.byteLength),
+      encryptedSharedSecret,
+      writeVarInt(encryptedVerifyToken.byteLength),
+      encryptedVerifyToken
+    ]
+    if (is119) {
+      connection.msgSalt = await getRandomBytes(8)
+      response.splice(2, 0, true)
+    }
+    // This callback will send the response and enable the ciphers.
+    await callback(secret, concatPacketData(response))
+  })().catch(e => {
+    console.error(e)
+    connection.disconnectReason =
+      '{"text":"Failed to authenticate with Mojang servers!"}'
+    connection.close()
+  })
+}
diff --git a/src/screens/chat/ChatScreen.tsx b/src/screens/chat/ChatScreen.tsx
@@ -159,10 +159,14 @@ const ChatScreen = ({ navigation, route }: Props) => {
         .then(conn => {
           if (statusRef.current !== 'CLOSED') {
             if (isConnection(conn)) setConnection(conn)
-            else setDisconnectReason(conn)
+            else {
+              closeChatScreen()
+              setDisconnectReason(conn)
+            }
           } else if (isConnection(conn)) conn.connection.close() // No memory leaky
         })
-        .catch(() => {
+        .catch(e => {
+          console.error(e)
           closeChatScreen()
           setDisconnectReason({
             server: route.params.serverName,
diff --git a/src/screens/chat/sessionBuilder.ts b/src/screens/chat/sessionBuilder.ts
@@ -33,7 +33,6 @@ export const createConnection = async (
   const [host, port] = await resolveHostname(hostname, portNumber)
   const activeAccount = Object.keys(accounts).find(e => accounts[e].active)
   if (!activeAccount) {
-    closeChatScreen()
     return {
       server,
       reason:
@@ -86,7 +85,6 @@ export const createConnection = async (
       }
       setSession(activeAccount, session)
     } catch (e) {
-      closeChatScreen()
       const reason =
         'Failed to create session! You may need to re-login with your Microsoft Account in the Accounts tab.'
       return { server, reason }
@@ -116,7 +114,7 @@ export const createConnection = async (
     newConn.on('error', onCloseOrError)
     return { serverName: server, connection: newConn }
   } catch (e) {
-    closeChatScreen()
+    console.error(e)
     return { server, reason: 'Failed to connect to server!' }
   }
 }

Original file line number	Diff line number	Diff line change
`@@ -186,7 +186,6 @@ class ConnectionModule(reactContext: ReactApplicationContext)`
`186`	`186`	`buffer.write(bytes, packet.totalLength!!, bytes.size - packet.totalLength)`
`187`	`187`
`188`	`188`	`// We can handle Keep Alive, Login Success and Set Compression.`
`189`		`- // TODO: Maybe handle Keep Alive in JS. The overhead is minimal and would take away the disconnect timer from here.`
`190`	`189`	`if (packet.id.value == keepAliveClientBoundId) {`
`191`	`190`	`directlyWriteToConnection(keepAliveServerBoundId, packet.data)`
`192`	`191`	`continue`
`@@ -239,11 +238,15 @@ class ConnectionModule(reactContext: ReactApplicationContext)`
`239`	`238`	`.emit(eventName, params)`
`240`	`239`	`}`
`241`	`240`
`242`		`- @ReactMethod fun addListener(/* eventName: String */) {`
	`241`	`+ @ReactMethod`
	`242`	`+ @Suppress("UNUSED_PARAMETER")`
	`243`	`+ fun addListener(eventName: String) {`
`243`	`244`	`// Set up any upstream listeners or background tasks as necessary`
`244`	`245`	`}`
`245`	`246`
`246`		`- @ReactMethod fun removeListeners(/* count: Int */) {`
	`247`	`+ @ReactMethod`
	`248`	`+ @Suppress("UNUSED_PARAMETER")`
	`249`	`+ fun removeListeners(count: Int) {`
`247`	`250`	`// Remove upstream listeners, stop unnecessary background tasks`
`248`	`251`	`}`
`249`	`252`	`}`