New handshake method?

[leandrobattochio]

Apparently there is a new preInit response. The handshake was changed rendering some parts of this documentation obsolete. Has anyone managed to get past the new handshake?

[TheGreenPlanet]

I reversed the protocol myself around 3 months ago, and just now found this repo. This is how i decode the current handshake:

Slitherio handshake protocol:

1. Client connects to server (WebSocket).
2. Client sends byte 0x01.
3. Client sends 2 bytes where first is "c" (0x63 0x00).
4. Server responds with '6' + runtime id-builder payload string (server_version).
5. Client decodes payload to extract idba string, performs an additional runtime ceaser cipher transformation and sends the cipher text back.
6. Server responds with current world state.

join_packet.js:

const CLIENT_VERSION = 291; // 0x01 0x23
const CPW = Uint8Array.from([
  54,206,204,169,97,178,74,136,124,117,14,210,106,236,8,208,136,213,140,111
]);

function asciize(s) {
  let out = "";
  for (let i = 0; i < s.length; i++) {
    const v = s.charCodeAt(i);
    out += (v < 32 || v > 127) ? " " : String.fromCharCode(v);
  }
  return out;
}

/**
 * Creates the 's' join packet:
 * [0]='s'(115) [1]=30 [2..3]=client_version (BE)
 * [4..23]=cpw[20] [24]=cv [25]=nick_len [26..]=nick [m]=0x00 [m+1]=0xFF
 * (no custom skin bytes by default)
 */
function buildJoinPacket(nick, cv = 0, customSkinBytes = []) {
  let s = asciize(String(nick || "")).slice(0, 24);
  const nickBytes = Buffer.from(s, "utf8");

  const ba = Buffer.alloc(8 + 20 + nickBytes.length + customSkinBytes.length);
  ba[0] = 115;                 // 's'
  ba[1] = 30;
  ba[2] = (CLIENT_VERSION >> 8) & 255;  // 0x01
  ba[3] = CLIENT_VERSION & 255;         // 0x23

  for (let i = 0; i < 20; i++) ba[4 + i] = CPW[i];

  ba[24] = cv & 255;
  ba[25] = nickBytes.length & 255;

  let m = 26;
  nickBytes.copy(ba, m);
  m += nickBytes.length;

  ba[m++] = 0x00; 
  ba[m++] = 0xFF;

  for (let i = 0; i < customSkinBytes.length; i++) {
    ba[m++] = customSkinBytes[i] & 255;
  }

  return ba;
}

slither_client.js:

...
  _buildJoin() {
    this.lgba = buildJoinPacket(this.nick, this.cv);
    console.log(
      `(${this.id})[i] built join packet (len=${this.lgba.length}) nick="${this.nick}" cv=${this.cv}`
    );
  }

  _beginHandshake() {
    if (!this.ws || this.ws.readyState !== this.ws.OPEN) return;

    // Stage 1: [0x01]
    this.ws.send(Buffer.from([0x01]));
    this.connection_stage = CONN_STAGE.SENT_01;

    // Stage 2: "c\0"
    const a = Buffer.alloc(2);
    a[0] = "c".charCodeAt(0);
    this.ws.send(a);
    this.connection_stage = CONN_STAGE.SENT_CSTR;
    this.awaitingServerVersion = true;
  }

  _handleServerVersionFrame(buf) {
    // buf[0] === '6'
    const server_version = buf.slice(1).toString("latin1");
    const payload = decodePayloadFromServerVersion(server_version);
    const idba = extractIdbaString(payload);
    if (!idba) {
      console.log(`(${this.id})[!] extractIdbaString failed → reconnect()`);
      this.reconnect();
      return;
    }
    const idbaBuf = qff9xTransformExact(idba);

    // Stage 3: send transformed idba
    this.ws.send(idbaBuf);
    this.connection_stage = CONN_STAGE.SENT_IDBA;

    // Stage 4: send join, immediate ping, start loop
    if (this.lgba) {
      setTimeout(() => {
        if (!this.ws || this.ws.readyState !== this.ws.OPEN) return;
        this.ws.send(this.lgba); // send the join packet
        this.connection_stage = CONN_STAGE.JOINED;
        this._startPingLoop();
        this._disarmHandshakeTimeout();
      }, 30);
    }
  }
...

handshake.js:

function decodePayloadFromServerVersion(c) {
  let a = "", d = 0, e = 23, f = 0;
  for (let g = 0; g < c.length; ) {
    let b = c.charCodeAt(g++);
    if (b <= 96) b += 32;
    b = (b - 97 - e) % 26; if (b < 0) b += 26;
    d = d * 16 + b; e += 17;
    if (f === 1) { a += String.fromCharCode(d); f = 0; d = 0; }
    else f++;
  }
  return a;
}

// may change, received as payload blob from server
function extractIdbaString(payloadSrc) {
    if (payloadSrc[8] !== '"' || payloadSrc[19] !== '"') {
        throw new Error("New Idba decryption scheme: " + payloadSrc);
    }

    let var_a_equals_string = payloadSrc.substring(9, 14)
    let var_a_appends_string = payloadSrc.substring(20, 42)
    let full_string = var_a_equals_string + var_a_appends_string

    if (full_string.length !== 27) {
        throw new Error("Idba string length != 27: " + full_string);
    }

    return full_string
}


// may change, received as payload blob from server
function qff9xTransformExact(idStr) {
  const out = new Uint8Array(27);
  for (let i = 0; i < 27; i++) out[i] = idStr.charCodeAt(i);

  let roll = 0;
  for (let c = 0; c < out.length; c++) {
    let base = 65;      // 'A'
    let a = out[c];
    if (a >= 97) {      // lowercase
      base += 32;       // remember original case
      a -= 32;          // to uppercase
    }
    a -= 65;            // may be negative for non-letters
    if (c === 0) roll = 3 + a;
    const e = (a + roll) % 26;   // raw JS remainder (can be negative -> punctuation)
    roll += 2 + a;
    out[c] = e + base;
  }
  return Buffer.from(out);
}