agent-messenger 1.15.0 → 2.1.0

package/src/platforms/kakaotalk/protocol/connection.ts

@@ -0,0 +1,159 @@
+import { type Socket, connect as netConnect } from 'node:net'
+import { connect as tlsConnect } from 'node:tls'
+
+import { LocoCrypto } from './crypto'
+import { decodePacket, encodePacket } from './packet'
+import type { LocoPacket } from './types'
+
+const DEFAULT_SEND_TIMEOUT_MS = 15_000
+
+export class LocoConnection {
+  private socket: Socket | null = null
+  private crypto: LocoCrypto | null = null
+  private buffer = Buffer.alloc(0)
+  private decryptedBuffer = Buffer.alloc(0)
+  private packetIdCounter = 0
+  private pendingResolvers = new Map<number, { resolve: (packet: LocoPacket) => void; timer: ReturnType<typeof setTimeout> }>()
+  private timedOutIds = new Set<number>()
+  private pushHandler: ((packet: LocoPacket) => void) | null = null
+  private closeHandler: (() => void) | null = null
+
+  async connectTls(host: string, port: number): Promise<void> {
+    await new Promise<void>((resolve, reject) => {
+      const socket = tlsConnect({ host, port, rejectUnauthorized: true }, () => resolve())
+      this.socket = socket
+      socket.on('error', reject)
+      socket.on('data', (data: Buffer) => this.onData(data))
+      socket.on('close', () => this.handleClose())
+    })
+  }
+
+  async connectSecure(host: string, port: number): Promise<void> {
+    await new Promise<void>((resolve, reject) => {
+      const socket = netConnect({ host, port }, () => resolve())
+      this.socket = socket
+      socket.on('error', reject)
+      socket.on('data', (data: Buffer) => this.onData(data))
+      socket.on('close', () => this.handleClose())
+    })
+    await this.performHandshake()
+  }
+
+  private async performHandshake(): Promise<void> {
+    this.crypto = new LocoCrypto()
+    const handshakePacket = this.crypto.buildHandshakePacket()
+    await this.write(handshakePacket)
+  }
+
+  async sendPacket(method: string, body: Record<string, unknown> = {}): Promise<LocoPacket> {
+    const packetId = ++this.packetIdCounter
+    const packet: LocoPacket = {
+      packetId,
+      statusCode: 0,
+      method,
+      bodyType: 0,
+      body,
+    }
+
+    const raw = encodePacket(packet)
+    const data = this.crypto ? this.crypto.encrypt(raw) : raw
+    await this.write(data)
+
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingResolvers.delete(packetId)
+        this.timedOutIds.add(packetId)
+        reject(new Error(`LOCO packet timeout: ${method} (${DEFAULT_SEND_TIMEOUT_MS}ms)`))
+      }, DEFAULT_SEND_TIMEOUT_MS)
+      this.pendingResolvers.set(packetId, { resolve, timer })
+    })
+  }
+
+  onPush(handler: (packet: LocoPacket) => void): void {
+    this.pushHandler = handler
+  }
+
+  onClose(handler: () => void): void {
+    this.closeHandler = handler
+  }
+
+  close(): void {
+    this.socket?.destroy()
+    this.socket = null
+    this.timedOutIds.clear()
+  }
+
+  private write(data: Buffer): Promise<void> {
+    return new Promise((resolve, reject) => {
+      if (!this.socket) {
+        reject(new Error('Socket not connected'))
+        return
+      }
+      this.socket.write(data, (err) => (err ? reject(err) : resolve()))
+    })
+  }
+
+  private onData(chunk: Buffer): void {
+    this.buffer = Buffer.concat([this.buffer, chunk])
+    this.processBuffer()
+  }
+
+  private processBuffer(): void {
+    while (this.buffer.length > 0) {
+      if (this.crypto) {
+        // Decrypt each frame and accumulate into decryptedBuffer.
+        // A single LOCO packet may span multiple encrypted frames.
+        if (this.buffer.length < 4) return
+        const frameSize = this.buffer.readUInt32LE(0)
+        if (this.buffer.length < 4 + frameSize) return
+
+        const encryptedBody = this.buffer.subarray(4, 4 + frameSize)
+        this.buffer = this.buffer.subarray(4 + frameSize)
+
+        let decrypted: Buffer
+        try {
+          decrypted = this.crypto.decrypt(encryptedBody)
+        } catch (err) {
+          console.error(`[loco] decrypt failed: ${(err as Error).message}`)
+          continue
+        }
+
+        this.decryptedBuffer = Buffer.concat([this.decryptedBuffer, decrypted])
+
+        let result = decodePacket(this.decryptedBuffer)
+        while (result) {
+          this.decryptedBuffer = this.decryptedBuffer.subarray(result.bytesConsumed)
+          this.dispatchPacket(result.packet)
+          result = decodePacket(this.decryptedBuffer)
+        }
+      } else {
+        const result = decodePacket(this.buffer)
+        if (!result) return
+        this.buffer = this.buffer.subarray(result.bytesConsumed)
+        this.dispatchPacket(result.packet)
+      }
+    }
+  }
+
+  private dispatchPacket(packet: LocoPacket): void {
+    if (this.timedOutIds.delete(packet.packetId)) return
+
+    const entry = this.pendingResolvers.get(packet.packetId)
+    if (entry) {
+      clearTimeout(entry.timer)
+      this.pendingResolvers.delete(packet.packetId)
+      entry.resolve(packet)
+    } else {
+      this.pushHandler?.(packet)
+    }
+  }
+
+  private handleClose(): void {
+    for (const entry of this.pendingResolvers.values()) {
+      clearTimeout(entry.timer)
+      entry.resolve({ packetId: 0, statusCode: -1, method: '', bodyType: 0, body: { error: 'connection closed' } })
+    }
+    this.pendingResolvers.clear()
+    this.closeHandler?.()
+  }
+}

package/src/platforms/kakaotalk/protocol/crypto.ts

@@ -0,0 +1,71 @@
+import { constants, createCipheriv, createDecipheriv, createPublicKey, publicEncrypt, randomBytes } from 'node:crypto'
+
+import {
+  GCM_NONCE_SIZE,
+  GCM_TAG_SIZE,
+  HANDSHAKE_ENCRYPT_TYPE,
+  HANDSHAKE_KEY_ENCRYPT_TYPE,
+  HANDSHAKE_KEY_SIZE,
+} from './types'
+import { LOCO_RSA_PUBLIC_KEY_DER_B64 } from './config'
+
+export class LocoCrypto {
+  private aesKey: Buffer
+
+  constructor(aesKey?: Buffer) {
+    this.aesKey = aesKey ?? randomBytes(16)
+  }
+
+  buildHandshakePacket(): Buffer {
+    // PKCS#1 DER → SPKI PEM so Node.js crypto can import it
+    const pkcs1Der = Buffer.from(LOCO_RSA_PUBLIC_KEY_DER_B64, 'base64')
+    const publicKey = createPublicKey({ key: pkcs1Der, format: 'der', type: 'pkcs1' })
+
+    const encryptedKey = publicEncrypt(
+      { key: publicKey, padding: constants.RSA_PKCS1_OAEP_PADDING, oaepHash: 'sha1' },
+      this.aesKey,
+    )
+
+    // Handshake: [key_size: 4 LE][key_encrypt_type: 4 LE][encrypt_type: 4 LE][encrypted_key: 256]
+    const buf = Buffer.alloc(12 + encryptedKey.length)
+    buf.writeUInt32LE(HANDSHAKE_KEY_SIZE, 0)
+    buf.writeUInt32LE(HANDSHAKE_KEY_ENCRYPT_TYPE, 4)
+    buf.writeUInt32LE(HANDSHAKE_ENCRYPT_TYPE, 8)
+    encryptedKey.copy(buf, 12)
+    return buf
+  }
+
+  // Wire format: [size: 4 LE][nonce: 12][ciphertext + GCM tag]
+  encrypt(plaintext: Buffer): Buffer {
+    const nonce = randomBytes(GCM_NONCE_SIZE)
+
+    const cipher = createCipheriv('aes-128-gcm', this.aesKey, nonce)
+    const encrypted = Buffer.concat([cipher.update(plaintext), cipher.final()])
+    const tag = cipher.getAuthTag()
+
+    const bodyLen = GCM_NONCE_SIZE + encrypted.length + tag.length
+    const buf = Buffer.alloc(4 + bodyLen)
+    buf.writeUInt32LE(bodyLen, 0)
+    nonce.copy(buf, 4)
+    encrypted.copy(buf, 4 + GCM_NONCE_SIZE)
+    tag.copy(buf, 4 + GCM_NONCE_SIZE + encrypted.length)
+    return buf
+  }
+
+  // Input: body after 4-byte size prefix — [nonce: 12][ciphertext + tag]
+  decrypt(data: Buffer): Buffer {
+    if (data.length < GCM_NONCE_SIZE + GCM_TAG_SIZE) {
+      throw new Error(`GCM data too short: ${data.length} bytes`)
+    }
+
+    const nonce = data.subarray(0, GCM_NONCE_SIZE)
+    const ciphertextWithTag = data.subarray(GCM_NONCE_SIZE)
+    const tagStart = ciphertextWithTag.length - GCM_TAG_SIZE
+    const ciphertext = ciphertextWithTag.subarray(0, tagStart)
+    const tag = ciphertextWithTag.subarray(tagStart)
+
+    const decipher = createDecipheriv('aes-128-gcm', this.aesKey, nonce)
+    decipher.setAuthTag(tag)
+    return Buffer.concat([decipher.update(ciphertext), decipher.final()])
+  }
+}

package/src/platforms/kakaotalk/protocol/packet.ts

@@ -0,0 +1,47 @@
+import { BSON } from 'bson'
+
+import { LOCO_BODY_TYPE_BSON, LOCO_HEADER_SIZE, type LocoPacket } from './types'
+
+export function encodePacket(packet: LocoPacket): Buffer {
+  const bsonBody = BSON.serialize(packet.body)
+
+  const methodBuf = Buffer.alloc(11)
+  methodBuf.write(packet.method, 'ascii')
+
+  const header = Buffer.alloc(LOCO_HEADER_SIZE)
+  header.writeUInt32LE(packet.packetId, 0)
+  header.writeInt16LE(packet.statusCode, 4)
+  methodBuf.copy(header, 6)
+  header.writeUInt8(packet.bodyType, 17)
+  header.writeUInt32LE(bsonBody.length, 18)
+
+  return Buffer.concat([header, bsonBody])
+}
+
+export function decodePacket(data: Buffer): { packet: LocoPacket; bytesConsumed: number } | null {
+  if (data.length < LOCO_HEADER_SIZE) return null
+
+  const bodyLength = data.readUInt32LE(18)
+  const totalLength = LOCO_HEADER_SIZE + bodyLength
+  if (data.length < totalLength) return null
+
+  const packetId = data.readUInt32LE(0)
+  const statusCode = data.readInt16LE(4)
+
+  const methodBuf = data.subarray(6, 17)
+  const nullIdx = methodBuf.indexOf(0)
+  const method = methodBuf.subarray(0, nullIdx === -1 ? 11 : nullIdx).toString('ascii')
+
+  const bodyType = data.readUInt8(17)
+  const bodyBuf = data.subarray(LOCO_HEADER_SIZE, totalLength)
+
+  let body: Record<string, unknown> = {}
+  if (bodyType === LOCO_BODY_TYPE_BSON && bodyLength > 0) {
+    body = BSON.deserialize(bodyBuf, { promoteValues: true }) as Record<string, unknown>
+  }
+
+  return {
+    packet: { packetId, statusCode, method, bodyType, body },
+    bytesConsumed: totalLength,
+  }
+}

package/src/platforms/kakaotalk/protocol/session.ts

@@ -0,0 +1,156 @@
+import { Binary, Long } from 'bson'
+
+import {
+  APP_VERSION,
+  BOOKING_HOST,
+  BOOKING_PORT,
+  CHECKIN_HOST,
+  CHECKIN_PORT,
+  COUNTRY_ISO,
+  LANG,
+  MCCMNC,
+  PING_INTERVAL_MS,
+  PROTOCOL_VERSION,
+} from './config'
+import { LocoConnection } from './connection'
+import type { BookingResponse, CheckinResponse, LoginListResponse, LocoPacket } from './types'
+
+export class LocoSession {
+  private connection: LocoConnection | null = null
+  private pingTimer: ReturnType<typeof setInterval> | null = null
+  private pushHandler: ((packet: LocoPacket) => void) | null = null
+  private closeHandler: (() => void) | null = null
+
+  async login(oauthToken: string, userId: string, deviceUuid: string): Promise<LoginListResponse> {
+    const { host, port } = await this.bookAndCheckin(userId)
+
+    this.connection = new LocoConnection()
+    await this.connection.connectSecure(host, port)
+
+    if (this.pushHandler) {
+      this.connection.onPush(this.pushHandler)
+    }
+    if (this.closeHandler) {
+      this.connection.onClose(this.closeHandler)
+    }
+
+    const response = await this.connection.sendPacket('LOGINLIST', {
+      appVer: APP_VERSION,
+      prtVer: PROTOCOL_VERSION,
+      os: 'mac',
+      lang: LANG,
+      duuid: deviceUuid,
+      oauthToken,
+      ntype: 0,
+      MCCMNC: MCCMNC,
+      revision: 0,
+      chatIds: [],
+      maxIds: [],
+      lastTokenId: Long.fromNumber(0),
+      lbk: Long.fromNumber(0),
+      rp: new Binary(Buffer.from([0x00, 0x00, 0xff, 0xff, 0x00, 0x00])),
+      bg: false,
+    })
+
+    this.startPing()
+    return response.body as unknown as LoginListResponse
+  }
+
+  private async bookAndCheckin(userId: string): Promise<{ host: string; port: number }> {
+    const bookingConn = new LocoConnection()
+    await bookingConn.connectTls(BOOKING_HOST, BOOKING_PORT)
+
+    const bookingResponse = await bookingConn.sendPacket('GETCONF', {
+      os: 'mac',
+      model: '',
+    })
+    bookingConn.close()
+
+    const booking = bookingResponse.body as unknown as BookingResponse
+    const bookingBody = bookingResponse.body as Record<string, unknown>
+    const hosts = bookingBody.hosts as string[] | undefined
+    const checkinHost = hosts?.[0] ?? CHECKIN_HOST
+    const checkinPort = booking.wifi?.ports?.[0] ?? CHECKIN_PORT
+
+    const checkinConn = new LocoConnection()
+    await checkinConn.connectSecure(checkinHost, checkinPort)
+
+    const checkinResponse = await checkinConn.sendPacket('CHECKIN', {
+      userId: Number(userId),
+      os: 'mac',
+      ntype: 0,
+      appVer: APP_VERSION,
+      MCCMNC: MCCMNC,
+      lang: LANG,
+      countryISO: COUNTRY_ISO,
+      useSub: true,
+    })
+    checkinConn.close()
+
+    const checkin = checkinResponse.body as unknown as CheckinResponse
+    if (!checkin.host || !checkin.port) {
+      throw new Error(`Checkin failed: no host/port in response`)
+    }
+
+    return { host: checkin.host, port: checkin.port }
+  }
+
+  async sendMessage(chatId: Long, text: string): Promise<LocoPacket> {
+    if (!this.connection) throw new Error('Not connected')
+    return this.connection.sendPacket('WRITE', {
+      chatId,
+      msg: text,
+      type: 1,
+      noSeen: false,
+    })
+  }
+
+  async syncMessages(chatId: Long, count = 20, cursor?: Long, maxLogId?: Long): Promise<LocoPacket> {
+    if (!this.connection) throw new Error('Not connected')
+    return this.connection.sendPacket('SYNCMSG', {
+      chatId,
+      cur: cursor ?? Long.fromNumber(0),
+      cnt: count,
+      max: maxLogId ?? Long.fromNumber(0),
+    })
+  }
+
+  async getChatList(lastTokenId?: Long, lastChatId?: Long): Promise<LocoPacket> {
+    if (!this.connection) throw new Error('Not connected')
+    return this.connection.sendPacket('LCHATLIST', {
+      chatIds: [],
+      maxIds: [],
+      lastTokenId: lastTokenId ?? Long.fromNumber(0),
+      lastChatId: lastChatId ?? Long.fromNumber(0),
+    })
+  }
+
+  onPush(handler: (packet: LocoPacket) => void): void {
+    this.pushHandler = handler
+    if (this.connection) {
+      this.connection.onPush(handler)
+    }
+  }
+
+  onClose(handler: () => void): void {
+    this.closeHandler = handler
+    if (this.connection) {
+      this.connection.onClose(handler)
+    }
+  }
+
+  private startPing(): void {
+    this.pingTimer = setInterval(() => {
+      this.connection?.sendPacket('PING', {}).catch(() => {})
+    }, PING_INTERVAL_MS)
+  }
+
+  close(): void {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer)
+      this.pingTimer = null
+    }
+    this.connection?.close()
+    this.connection = null
+  }
+}

package/src/platforms/kakaotalk/protocol/types.ts

@@ -0,0 +1,42 @@
+export interface LocoPacket {
+  packetId: number
+  statusCode: number
+  method: string
+  bodyType: number
+  body: Record<string, unknown>
+}
+
+export interface BookingResponse {
+  wifi: {
+    ports: number[]
+  }
+}
+
+export interface CheckinResponse {
+  host: string
+  port: number
+}
+
+export interface ChatListResponse {
+  chatDatas: Array<Record<string, unknown>>
+  lastTokenId: { low: number; high: number }
+  lastChatId: { low: number; high: number }
+  eof: boolean
+  [key: string]: unknown
+}
+
+// LOGINLIST uses short BSON field names: c=chatId, t=type, a=activeMembers, etc.
+export interface LoginListResponse extends ChatListResponse {
+  userId: number
+  revision: number
+}
+
+export const LOCO_HEADER_SIZE = 22
+export const LOCO_BODY_TYPE_BSON = 0
+
+export const HANDSHAKE_KEY_SIZE = 256
+export const HANDSHAKE_KEY_ENCRYPT_TYPE = 16
+export const HANDSHAKE_ENCRYPT_TYPE = 3
+
+export const GCM_NONCE_SIZE = 12
+export const GCM_TAG_SIZE = 16