sean0x42/mineshark

A (work in progress) packet sniffing proxy that sits between a Minecraft client and server. Essentially a MITM attack with custom middleware

🍌

mineshark's Issues

Read UUIDs (Go)

Support compressed packet format

https://wiki.vg/Protocol#Set_Compression

Read strings (Go)

Race condition when establishing new connections

There appears to be a race condition that occurs at the start of every new connection. About 60% of the time, the client will send its first packet before we have opened a connection with the server (I think), causing the connection to go silent.

I did attempt to resolve this issue by collecting all packets into a queue until the server explicitly fires the connect event, and then releasing the queue. But this has not resolved the issue.

More investigation is needed.

Support parsing NBT tag data from packets

See: https://wiki.vg/NBT

Read integers and longs (Go)

Write Bytes

Support packet encryption

Associate proxy connections with player names

Write VarInts

Publish to docker hub

Add immer or similar for mutating packets in middleware

Packets should be immutable.

See: https://github.com/immerjs/immer

Read shorts (Go)

Signed and unsigned.

Accept env vars as an alternative to CLI args

Create cloudformation template

Write documentation for usage with docker and cloudformation

Render recently streamed packets

Send packets down all available websockets

Expand test cases for `PacketWriter` and `PacketReader`

I don't really have much confidence in the packet readers and writers at the moment. Would be good to create a comprehensive set of unit (and possibly integration) tests for these.

Change to a payload spec model in the packet registry

Currently writing a packet's registry entry is a pretty exhausting task. Writing a reader and writer involves a LOT of duplication. See example:

Click to see a large example registry entry

Registry.register({
  id: 0x26,
  kind: PacketKind.JoinGame,
  source: PacketSource.Server,
  state: State.Play,

  read: (reader) => ({
    kind: PacketKind.JoinGame,
    payload: {
      entityId: reader.readInt(),
      isHardcore: reader.readBoolean(),
      gamemode: reader.readUnsignedByte(),
      previousGamemode: reader.readByte(),
      worlds: reader.readIdentifierArray(),
      dimensionCodec: reader.readNbt(),
      dimension: reader.readNbt(),
      worldName: reader.readString(),
      hashedSeed: reader.readLong(),
      maxPlayers: reader.readVarInt(),
      viewDistance: reader.readVarInt(),
      reducedDebugInfo: reader.readBoolean(),
      enableRespawnScreen: reader.readBoolean(),
      isDebug: reader.readBoolean(),
      isFlat: reader.readBoolean(),
    },
  }),

  write: (writer, packet) => {
    const payload = (packet as JoinGamePacket).payload;
    writer
      .writeInt(payload.entityId)
      .writeBoolean(payload.isHardcore)
      .writeUnsignedByte(payload.gamemode)
      .writeByte(payload.previousGamemode)
      .writeIdentifierArray(payload.worlds)
      .writeNbt(payload.dimensionCodec)
      .writeNbt(payload.dimension)
      .writeString(payload.worldName)
      .writeLong(payload.hashedSeed)
      .writeVarInt(payload.maxPlayers)
      .writeVarInt(payload.viewDistance)
      .writeBoolean(payload.reducedDebugInfo)
      .writeBoolean(payload.enableRespawnScreen)
      .writeBoolean(payload.isDebug)
      .writeBoolean(payload.isFlat);
  },
});

It would be fantastic if we moved towards a different model, where you define a specification for the packet's payload instead. Something like:

Registry.register({
  id: 0x26,
  kind: PacketKind.JoinGame,
  source: PacketSource.Server,
  state: State.Play,

  payload: {
    entityId: DataType.Int,
    isHardcore: DataType.Boolean,
    gamemode: DataType.UnsignedByte,
    // ...

    // Custom data types could provide a callback reader and writer like the old way
    worlds: {
      read(reader) { /* ... */ },
      write(writer, packet) { /* ... */ }
    },
    // ...

    // Optional trailing data could be denoted with an extra flag
    isFlat: {
      type: DataType.Boolean,
      optional: true
    }
  }
});

Read VarInts (Go)

Previous implementation in typescript can be found here:

mineshark/src/reader/packetReader.ts

Line 33 in 0d2b40d

public readVarInt(): number {

Add actions workflow for building and uploading release artifacts

Read floats and doubles (Go)

Read chat (Go)

Read booleans (Go)

Support writing NBT data to packets

Add actions workflow for linting and testing

Catch exceptions from middleware

If a middleware throws an error, it would be good to catch that error and pass the packet to the next middleware in the chain. This would prevent middleware from bringing down the entire proxy when they encounter unexpected territory.

Read bytes (Go)

Both signed and unsigned.