feat: Implement complete transform & Build & Upload FakeForwardMsg

2026-02-06 13:05:09 +00:00 · 2024-10-19 22:13:31 +08:00
parent 0377a30d02
commit 8edab4f20d
11 changed files with 290 additions and 146 deletions
--- a/src/core/apis/packet.ts
+++ b/src/core/apis/packet.ts
@@ -1,17 +1,18 @@
 import * as os from 'os';
-import { InstanceContext, NapCatCore } from '..';
+import {ChatType, InstanceContext, NapCatCore} from '..';
 import offset from '@/core/external/offset.json';
-import { PacketClient, RecvPacketData } from '@/core/packet/client';
-import { PacketSession } from "@/core/packet/session";
-import { PacketHexStr, PacketPacker } from "@/core/packet/packer";
-import { NapProtoMsg } from '@/core/packet/proto/NapProto';
-import { OidbSvcTrpcTcp0X9067_202_Rsp_Body } from '@/core/packet/proto/oidb/Oidb.0x9067_202';
-import { OidbSvcTrpcTcpBase, OidbSvcTrpcTcpBaseRsp } from '@/core/packet/proto/oidb/OidbBase';
-import { OidbSvcTrpcTcp0XFE1_2RSP } from '@/core/packet/proto/oidb/Oidb.0XFE1_2';
-import { LogWrapper } from "@/common/log";
-import { SendLongMsgResp } from "@/core/packet/proto/message/action";
-import { PacketMsg } from "@/core/packet/msg/message";
-import { OidbSvcTrpcTcp0x6D6Response } from "@/core/packet/proto/oidb/Oidb.0x6D6";
+import {PacketClient, RecvPacketData} from '@/core/packet/client';
+import {PacketSession} from "@/core/packet/session";
+import {PacketHexStr} from "@/core/packet/packer";
+import {NapProtoMsg} from '@/core/packet/proto/NapProto';
+import {OidbSvcTrpcTcp0X9067_202_Rsp_Body} from '@/core/packet/proto/oidb/Oidb.0x9067_202';
+import {OidbSvcTrpcTcpBase, OidbSvcTrpcTcpBaseRsp} from '@/core/packet/proto/oidb/OidbBase';
+import {OidbSvcTrpcTcp0XFE1_2RSP} from '@/core/packet/proto/oidb/Oidb.0XFE1_2';
+import {LogWrapper} from "@/common/log";
+import {SendLongMsgResp} from "@/core/packet/proto/message/action";
+import {PacketMsg} from "@/core/packet/msg/message";
+import {OidbSvcTrpcTcp0x6D6Response} from "@/core/packet/proto/oidb/Oidb.0x6D6";
+import {PacketMsgPicElement} from "@/core/packet/msg/element";

 interface OffsetType {
    [key: string]: {
@@ -28,14 +29,12 @@ export class NTQQPacketApi {
    logger: LogWrapper
    serverUrl: string | undefined;
    qqVersion: string | undefined;
-    packetPacker: PacketPacker;
    packetSession: PacketSession | undefined;

    constructor(context: InstanceContext, core: NapCatCore) {
        this.context = context;
        this.core = core;
        this.logger = core.context.logger;
-        this.packetPacker = new PacketPacker(this.logger);
        this.packetSession = undefined;
        const config = this.core.configLoader.configData;
        if (config && config.packetServer && config.packetServer.length > 0) {
@@ -70,13 +69,13 @@ export class NTQQPacketApi {
    }

    async sendPokePacket(group: number, peer: number) {
-        const data = this.packetPacker.packPokePacket(group, peer);
-        await this.sendPacket('OidbSvcTrpcTcp.0xed3_1', data, false);
+        const data = this.packetSession?.packer.packPokePacket(group, peer);
+        await this.sendPacket('OidbSvcTrpcTcp.0xed3_1', data!, false);
    }

    async sendRkeyPacket() {
-        const packet = this.packetPacker.packRkeyPacket();
-        const ret = await this.sendPacket('OidbSvcTrpcTcp.0x9067_202', packet, true);
+        const packet = this.packetSession?.packer.packRkeyPacket();
+        const ret = await this.sendPacket('OidbSvcTrpcTcp.0x9067_202', packet!, true);
        if (!ret?.hex_data) return [];
        const body = new NapProtoMsg(OidbSvcTrpcTcpBaseRsp).decode(Buffer.from(ret.hex_data, 'hex')).body;
        const retData = new NapProtoMsg(OidbSvcTrpcTcp0X9067_202_Rsp_Body).decode(body);
@@ -86,8 +85,8 @@ export class NTQQPacketApi {
    async sendStatusPacket(uin: number): Promise<{ status: number; ext_status: number; } | undefined> {
        let status = 0;
        try {
-            const packet = this.packetPacker.packStatusPacket(uin);
-            const ret = await this.sendPacket('OidbSvcTrpcTcp.0xfe1_2', packet, true);
+            const packet = this.packetSession?.packer.packStatusPacket(uin);
+            const ret = await this.sendPacket('OidbSvcTrpcTcp.0xfe1_2', packet!, true);
            const data = Buffer.from(ret.hex_data, 'hex');
            const ext = new NapProtoMsg(OidbSvcTrpcTcp0XFE1_2RSP).decode(new NapProtoMsg(OidbSvcTrpcTcpBase).decode(data).body).data.status.value;
            // ext & 0xff00 + ext >> 16 & 0xff
@@ -103,20 +102,37 @@ export class NTQQPacketApi {
    }

    async sendSetSpecialTittlePacket(groupCode: string, uid: string, tittle: string) {
-        const data = this.packetPacker.packSetSpecialTittlePacket(groupCode, uid, tittle);
-        await this.sendPacket('OidbSvcTrpcTcp.0x8fc_2', data, true);
+        const data = this.packetSession?.packer.packSetSpecialTittlePacket(groupCode, uid, tittle);
+        await this.sendPacket('OidbSvcTrpcTcp.0x8fc_2', data!, true);
+    }
+
+    private async uploadResources(msg: PacketMsg[], groupUin: number = 0){
+        const reqList = []
+        for (const m of msg){
+            for (const e of m.msg){
+                if (e instanceof PacketMsgPicElement){
+                    reqList.push(this.packetSession?.highwaySession.uploadImage({
+                        chatType: groupUin ? ChatType.KCHATTYPEGROUP : ChatType.KCHATTYPEC2C,
+                        peerUid: String(groupUin) ? String(groupUin) : this.core.selfInfo.uid
+                    }, e));
+                }
+            }
+        }
+        return Promise.all(reqList);
    }

    async sendUploadForwardMsg(msg: PacketMsg[], groupUin: number = 0) {
-        const data = this.packetPacker.packUploadForwardMsg(this.core.selfInfo.uid, msg, groupUin);
-        const ret = await this.sendPacket('trpc.group.long_msg_interface.MsgService.SsoSendLongMsg', data, true);
+        await this.uploadResources(msg, groupUin);
+        const data = await this.packetSession?.packer.packUploadForwardMsg(this.core.selfInfo.uid, msg, groupUin);
+        const ret = await this.sendPacket('trpc.group.long_msg_interface.MsgService.SsoSendLongMsg', data!, true);
+        this.logger.logDebug('sendUploadForwardMsg', ret);
        const resp = new NapProtoMsg(SendLongMsgResp).decode(Buffer.from(ret.hex_data, 'hex'));
        return resp.result.resId;
    }

    async sendGroupFileDownloadReq(groupUin: number, fileUUID: string) {
-        const data = this.packetPacker.packGroupFileDownloadReq(groupUin, fileUUID);
-        const ret = await this.sendPacket('OidbSvcTrpcTcp.0x6d6_2', data, true);
+        const data = this.packetSession?.packer.packGroupFileDownloadReq(groupUin, fileUUID);
+        const ret = await this.sendPacket('OidbSvcTrpcTcp.0x6d6_2', data!, true);
        const body = new NapProtoMsg(OidbSvcTrpcTcpBaseRsp).decode(Buffer.from(ret.hex_data, 'hex')).body;
        const resp = new NapProtoMsg(OidbSvcTrpcTcp0x6D6Response).decode(body);
        if (resp.download.retCode !== 0){
--- a/src/core/packet/highway/session.ts
+++ b/src/core/packet/highway/session.ts
@@ -34,16 +34,16 @@ export class PacketHighwaySession {
    protected packer: PacketPacker;
    private cachedPrepareReq: Promise<void> | null = null;

-    constructor(logger: LogWrapper, client: PacketClient) {
+    constructor(logger: LogWrapper, client: PacketClient, packer: PacketPacker) {
        this.packetClient = client;
        this.logger = logger;
-        this.packer = new PacketPacker(logger);
        this.sig = {
            uin: this.packetClient.napCatCore.selfInfo.uin,
            sigSession: null,
            sessionKey: null,
            serverAddr: [],
        }
+        this.packer = packer;
        this.packetHighwayClient = new PacketHighwayClient(this.sig, this.logger);
    }

--- a/src/core/packet/msg/converter.ts
+++ b/src/core/packet/msg/converter.ts
@@ -0,0 +1,131 @@
+import {
+    MessageElement,
+    RawMessage,
+    SendArkElement,
+    SendFaceElement,
+    SendFileElement,
+    SendMarkdownElement,
+    SendMarketFaceElement,
+    SendPicElement,
+    SendPttElement,
+    SendReplyElement,
+    SendStructLongMsgElement,
+    SendTextElement,
+    SendVideoElement
+} from "@/core";
+import {
+    IPacketMsgElement,
+    PacketMsgAtElement,
+    PacketMsgFaceElement,
+    PacketMsgFileElement,
+    PacketMsgLightAppElement,
+    PacketMsgMarkDownElement,
+    PacketMsgMarkFaceElement,
+    PacketMsgPicElement,
+    PacketMsgPttElement,
+    PacketMsgReplyElement,
+    PacketMsgTextElement,
+    PacketMsgVideoElement,
+    PacketMultiMsgElement
+} from "@/core/packet/msg/element";
+import {PacketMsg, PacketSendMsgElement} from "@/core/packet/msg/message";
+import {LogWrapper} from "@/common/log";
+
+type SendMessageElementMap = {
+    textElement: SendTextElement,
+    picElement: SendPicElement,
+    replyElement: SendReplyElement,
+    faceElement: SendFaceElement,
+    marketFaceElement: SendMarketFaceElement,
+    videoElement: SendVideoElement,
+    fileElement: SendFileElement,
+    pttElement: SendPttElement,
+    arkElement: SendArkElement,
+    markdownElement: SendMarkdownElement,
+    structLongMsgElement: SendStructLongMsgElement
+};
+
+type RawToPacketMsgConverters = {
+    [K in keyof SendMessageElementMap]: (
+        element: SendMessageElementMap[K],
+        msg?: RawMessage,
+        elementWrapper?: MessageElement,
+    ) => IPacketMsgElement<SendMessageElementMap[K]> | null;
+};
+
+export type rawMsgWithSendMsg = {
+    senderUin: number;
+    senderUid?: string;
+    senderName: string;
+    groupId?: number;
+    time: number;
+    msg: PacketSendMsgElement[]
+}
+
+export class PacketMsgConverter {
+    private logger: LogWrapper;
+
+    constructor(logger: LogWrapper) {
+        this.logger = logger;
+    }
+
+    rawMsgWithSendMsgToPacketMsg(msg: rawMsgWithSendMsg): PacketMsg {
+        return {
+            senderUid: msg.senderUid ?? '',
+            senderUin: msg.senderUin,
+            senderName: msg.senderName,
+            groupId: msg.groupId,
+            time: msg.time,
+            msg: msg.msg.map((element) => {
+                const key = (Object.keys(this.rawToPacketMsgConverters) as Array<keyof SendMessageElementMap>).find(
+                    (k) => (element as any)[k] !== undefined  // TODO:
+                );
+                if (key) {
+                    const elementData = (element as any)[key];  // TODO:
+                    if (elementData) return this.rawToPacketMsgConverters[key](element as any)
+                }
+                return null;
+            }).filter((e) => e !== null)
+        }
+    }
+
+    private rawToPacketMsgConverters: RawToPacketMsgConverters = {
+        textElement: (element: SendTextElement) => {
+            if (element.textElement.atType) {
+                return new PacketMsgAtElement(element)
+            }
+            return new PacketMsgTextElement(element)
+        },
+        picElement: (element: SendPicElement) => {
+            return new PacketMsgPicElement(element)
+        },
+        replyElement: (element: SendReplyElement) => {
+            return new PacketMsgReplyElement(element)
+        },
+        faceElement: (element: SendFaceElement) => {
+            return new PacketMsgFaceElement(element)
+        },
+        marketFaceElement: (element: SendMarketFaceElement) => {
+            return new PacketMsgMarkFaceElement(element)
+        },
+        videoElement: (element: SendVideoElement) => {
+            return new PacketMsgVideoElement(element)
+        },
+        fileElement: (element: SendFileElement) => {
+            return new PacketMsgFileElement(element)
+        },
+        pttElement: (element: SendPttElement) => {
+            return new PacketMsgPttElement(element)
+        },
+        arkElement: (element: SendArkElement) => {
+            return new PacketMsgLightAppElement(element)
+        },
+        markdownElement: (element: SendMarkdownElement) => {
+            return new PacketMsgMarkDownElement(element)
+        },
+        // TODO: check this logic, move it in arkElement?
+        structLongMsgElement: (element: SendStructLongMsgElement) => {
+            return new PacketMultiMsgElement(element)
+        }
+    }
+}
--- a/src/core/packet/msg/element.ts
+++ b/src/core/packet/msg/element.ts
@@ -248,7 +248,7 @@ export class PacketMsgFaceElement extends IPacketMsgElement<SendFaceElement> {
    }
 }

-export class PacketMarkFaceElement extends IPacketMsgElement<SendMarketFaceElement> {
+export class PacketMsgMarkFaceElement extends IPacketMsgElement<SendMarketFaceElement> {
    emojiName: string;
    emojiId: string;
    emojiPackageId: number;
@@ -357,16 +357,15 @@ export class PacketMultiMsgElement extends IPacketMsgElement<SendStructLongMsgEl
    resid: string;
    message: PacketMsg[];

-    constructor(rawElement: SendStructLongMsgElement)
    constructor(rawElement: SendStructLongMsgElement, message?: PacketMsg[]) {
        super(rawElement);
        this.resid = rawElement.structLongMsgElement.resId;
        this.message = message ?? [];
    }

-    buildElement(): NapProtoEncodeStructType<typeof Elem>[] {
+    get JSON() {
        const id = crypto.randomUUID();
-        const elementJson = {
+        return {
            app: "com.tencent.multimsg",
            config: {
                autosize: 1,
@@ -388,20 +387,23 @@ export class PacketMultiMsgElement extends IPacketMsgElement<SendStructLongMsgEl
                        text: `${packetMsg.senderName}: ${packetMsg.msg.map(msg => msg.toPreview()).join('')}`,
                    })),
                    resid: this.resid,
-                    source: "聊天记录",
+                    source: "聊天记录",  // TODO:
                    summary: `查看${this.message.length}条转发消息`,
                    uniseq: id,
                }
            },
            prompt: "[聊天记录]",
            ver: "0.0.0.5",
-            view: "contact"
+            view: "contact",
        }
+    }
+
+    buildElement(): NapProtoEncodeStructType<typeof Elem>[] {
        return [{
            lightAppElem: {
                data: Buffer.concat([
                    Buffer.from([0x01]),
-                    zlib.deflateSync(Buffer.from(JSON.stringify(elementJson), 'utf-8'))
+                    zlib.deflateSync(Buffer.from(JSON.stringify(this.JSON), 'utf-8'))
                ])
            }
        }]
--- a/src/core/packet/packer.ts
+++ b/src/core/packet/packer.ts
@@ -16,16 +16,22 @@ import {LogWrapper} from "@/common/log";
 import {PacketMsg} from "@/core/packet/msg/message";
 import {OidbSvcTrpcTcp0x6D6} from "@/core/packet/proto/oidb/Oidb.0x6D6";
 import {OidbSvcTrpcTcp0XE37_1200} from "@/core/packet/proto/oidb/Oidb.0xE37_1200";
+import {PacketMsgConverter} from "@/core/packet/msg/converter";
+import {PacketClient} from "@/core/packet/client";

 export type PacketHexStr = string & { readonly hexNya: unique symbol };

 export class PacketPacker {
-    private readonly logger: LogWrapper;
-    private readonly packetBuilder: PacketMsgBuilder;
+    readonly logger: LogWrapper;
+    readonly client: PacketClient;
+    readonly packetBuilder: PacketMsgBuilder;
+    readonly packetConverter: PacketMsgConverter;

-    constructor(logger: LogWrapper) {
+    constructor(logger: LogWrapper, client: PacketClient) {
        this.logger = logger;
+        this.client = client;
        this.packetBuilder = new PacketMsgBuilder(logger);
+        this.packetConverter = new PacketMsgConverter(logger);
    }

    private toHexStr(byteArray: Uint8Array): PacketHexStr {
@@ -96,8 +102,7 @@ export class PacketPacker {
        return this.toHexStr(this.packOidbPacket(0xfe1, 2, oidb_0xfe1_2));
    }

-    packUploadForwardMsg(selfUid: string, msg: PacketMsg[], groupUin: number = 0): PacketHexStr {
-        // this.logger.logDebug("packUploadForwardMsg START!!!", selfUid, msg, groupUin);
+    async packUploadForwardMsg(selfUid: string, msg: PacketMsg[], groupUin: number = 0): Promise<PacketHexStr> {
        const msgBody = this.packetBuilder.buildFakeMsg(selfUid, msg);
        const longMsgResultData = new NapProtoMsg(LongMsgResult).encode(
            {
--- a/src/core/packet/session.ts
+++ b/src/core/packet/session.ts
@@ -1,15 +1,18 @@
 import { PacketClient } from "@/core/packet/client";
 import { PacketHighwaySession } from "@/core/packet/highway/session";
 import { LogWrapper } from "@/common/log";
+import {PacketPacker} from "@/core/packet/packer";

 export class PacketSession {
    readonly logger: LogWrapper;
    readonly client: PacketClient;
+    readonly packer: PacketPacker;
    readonly highwaySession: PacketHighwaySession;

    constructor(logger: LogWrapper, client: PacketClient) {
        this.logger = logger;
        this.client = client;
-        this.highwaySession = new PacketHighwaySession(this.logger, this.client);
+        this.packer = new PacketPacker(this.logger, this.client);
+        this.highwaySession = new PacketHighwaySession(this.logger, this.client, this.packer);
    }
 }