@iflyrpa/actions 1.2.23 → 1.2.24

package/dist/index.js

@@ -2661,57 +2661,366 @@ var __webpack_exports__ = {};
     const external_node_buffer_namespaceObject = require("node:buffer");
     const external_node_crypto_namespaceObject = require("node:crypto");
     var external_node_crypto_default = /*#__PURE__*/ __webpack_require__.n(external_node_crypto_namespaceObject);
-    class XsEncrypt {
-        async encryptMD5(url) {
-            return external_node_crypto_default().createHash("md5").update(url, "utf8").digest("hex");
-        }
-        async encryptText(text) {
-            const textEncoded = external_node_buffer_namespaceObject.Buffer.from(text).toString("base64");
-            const cipher = external_node_crypto_default().createCipheriv("aes-128-cbc", new Uint8Array(this.keyBytes), new Uint8Array(this.iv));
-            const ciphertext = cipher.update(textEncoded, "utf8", "base64");
-            return ciphertext + cipher.final("base64");
-        }
-        async base64ToHex(encodedData) {
-            const decodedData = external_node_buffer_namespaceObject.Buffer.from(encodedData, "base64");
-            return decodedData.toString("hex");
-        }
-        async encryptPayload(payload, platform) {
-            const hexPayload = await this.base64ToHex(payload);
-            const obj = {
-                signSvn: "56",
-                signType: "x2",
-                appID: platform,
-                signVersion: "1",
-                payload: hexPayload
+    class CryptoConfig {
+        static{
+            this.MAX_32BIT = 0xFFFFFFFF;
+        }
+        static{
+            this.MAX_SIGNED_32BIT = 0x7FFFFFFF;
+        }
+        static{
+            this.BASE58_ALPHABET = "NOPQRStuvwxWXYZabcyz012DEFTKLMdefghijkl4563GHIJBC7mnop89+/AUVqrsOPQefghijkABCDEFGuvwz0123456789xy";
+        }
+        static{
+            this.STANDARD_BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+        }
+        static{
+            this.CUSTOM_BASE64_ALPHABET = "ZmserbBoHQtNP+wOcza/LpngG8yJq42KWYj0DSfdikx3VT16IlUAFM97hECvuRX5";
+        }
+        static{
+            this.BASE58_BASE = 58;
+        }
+        static{
+            this.BYTE_SIZE = 256;
+        }
+        static{
+            this.HEX_KEY = "af572b95ca65b2d9ec76bb5d2e97cb653299cc663399cc663399cce673399cce6733190c06030100000000008040209048241289c4e271381c0e0703018040a05028148ac56231180c0683c16030984c2693c964b259ac56abd5eaf5fafd7e3f9f4f279349a4d2e9743a9d4e279349a4d2e9f47a3d1e8f47239148a4d269341a8d4623110884422190c86432994ca6d3e974baddee773b1d8e47a35128148ac5623198cce6f3f97c3e1f8f47a3d168b45aad562b158ac5e2f1f87c3e9f4f279349a4d269b45aad56";
+        }
+        static{
+            this.TIMESTAMP_BYTES_COUNT = 16;
+        }
+        static{
+            this.TIMESTAMP_XOR_KEY = 41;
+        }
+        static{
+            this.STARTUP_TIME_OFFSET_MIN = 1000;
+        }
+        static{
+            this.STARTUP_TIME_OFFSET_MAX = 4000;
+        }
+        static{
+            this.EXPECTED_HEX_LENGTH = 32;
+        }
+        static{
+            this.OUTPUT_BYTE_COUNT = 8;
+        }
+        static{
+            this.HEX_CHUNK_SIZE = 2;
+        }
+        static{
+            this.VERSION_BYTES = [
+                119,
+                104,
+                96,
+                41
+            ];
+        }
+        static{
+            this.FIXED_SEPARATOR_BYTES = [
+                16,
+                0,
+                0,
+                0,
+                15,
+                5,
+                0,
+                0,
+                47,
+                1,
+                0,
+                0
+            ];
+        }
+        static{
+            this.RANDOM_BYTE_COUNT = 4;
+        }
+        static{
+            this.FIXED_INT_VALUE_1 = 15;
+        }
+        static{
+            this.FIXED_INT_VALUE_2 = 1291;
+        }
+        static{
+            this.ENV_STATIC_BYTES = [
+                1,
+                249,
+                83,
+                102,
+                103,
+                201,
+                181,
+                131,
+                99,
+                94,
+                7,
+                68,
+                250,
+                132,
+                21
+            ];
+        }
+        static{
+            this.SIGNATURE_DATA_TEMPLATE = {
+                x0: "4.2.2",
+                x1: "xhs-pc-web",
+                x2: "Windows",
+                x3: "",
+                x4: "object"
             };
-            const jsonString = JSON.stringify(obj, null, 0);
-            return external_node_buffer_namespaceObject.Buffer.from(jsonString).toString("base64");
         }
-        async encryptXs(url, a1, ts, platform = "xhs-pc-web") {
-            const text = `x1=${await this.encryptMD5(`url=${url}`)};x2=0|0|0|1|0|0|1|0|0|0|1|0|0|0|0|1|0|0|0;x3=${a1};x4=${ts};`;
-            return `XYW_${await this.encryptPayload(await this.encryptText(text), platform)}`;
+        static{
+            this.X3_PREFIX = "mns0101_";
+        }
+        static{
+            this.XYS_PREFIX = "XYS_";
+        }
+    }
+    class RandomGenerator {
+        generateRandomBytes(byteCount) {
+            return Array.from({
+                length: byteCount
+            }, ()=>Math.floor(Math.random() * CryptoConfig.BYTE_SIZE));
+        }
+        generateRandomByteInRange(minVal, maxVal) {
+            return Math.floor(Math.random() * (maxVal - minVal + 1)) + minVal;
+        }
+        generateRandomInt() {
+            return Math.floor(Math.random() * (CryptoConfig.MAX_32BIT + 1));
+        }
+    }
+    class HexProcessor {
+        hexStringToBytes(hexString) {
+            const byteValues = [];
+            for(let i = 0; i < hexString.length; i += CryptoConfig.HEX_CHUNK_SIZE){
+                const hexChunk = hexString.substr(i, CryptoConfig.HEX_CHUNK_SIZE);
+                byteValues.push(parseInt(hexChunk, 16));
+            }
+            return byteValues;
+        }
+        processHexParameter(hexString, xorKey) {
+            if (hexString.length !== CryptoConfig.EXPECTED_HEX_LENGTH) throw new Error(`hex parameter must be ${CryptoConfig.EXPECTED_HEX_LENGTH} characters`);
+            const byteValues = this.hexStringToBytes(hexString);
+            return byteValues.map((byteVal)=>byteVal ^ xorKey).slice(0, CryptoConfig.OUTPUT_BYTE_COUNT);
+        }
+    }
+    class BitOperations {
+        normalizeTo32bit(value) {
+            return value & CryptoConfig.MAX_32BIT;
+        }
+        toSigned32bit(unsignedValue) {
+            if (unsignedValue > CryptoConfig.MAX_SIGNED_32BIT) return unsignedValue - 0x100000000;
+            return unsignedValue;
+        }
+        computeSeedValue(seed32bit) {
+            const normalizedSeed = this.normalizeTo32bit(seed32bit);
+            const shift15Bits = normalizedSeed >> 15;
+            const shift13Bits = normalizedSeed >> 13;
+            const shift12Bits = normalizedSeed >> 12;
+            const shift10Bits = normalizedSeed >> 10;
+            const xorMaskedResult = shift15Bits & ~shift13Bits | shift13Bits & ~shift15Bits;
+            const shiftedResult = (xorMaskedResult ^ shift12Bits ^ shift10Bits) << 31 & CryptoConfig.MAX_32BIT;
+            return this.toSigned32bit(shiftedResult);
+        }
+        xorTransformArray(sourceIntegers) {
+            const resultBytes = new Uint8Array(sourceIntegers.length);
+            const hexKeyBytes = external_node_buffer_namespaceObject.Buffer.from(CryptoConfig.HEX_KEY, 'hex');
+            for(let index = 0; index < sourceIntegers.length; index++)resultBytes[index] = (sourceIntegers[index] ^ hexKeyBytes[index]) & 0xFF;
+            return resultBytes;
+        }
+    }
+    class Base58Encoder {
+        encodeToB58(inputBytes) {
+            const bytesArray = Array.isArray(inputBytes) ? inputBytes : Array.from(inputBytes);
+            const numberAccumulator = this.bytesToNumber(bytesArray);
+            const leadingZerosCount = this.countLeadingZeros(bytesArray);
+            const encodedCharacters = this.numberToBase58Chars(numberAccumulator);
+            encodedCharacters.push(...Array(leadingZerosCount).fill(CryptoConfig.BASE58_ALPHABET[0]));
+            return encodedCharacters.reverse().join('');
+        }
+        bytesToNumber(inputBytes) {
+            const bytesArray = Array.isArray(inputBytes) ? inputBytes : Array.from(inputBytes);
+            let result = 0n;
+            const BYTE_SIZE = 256n;
+            for (const byteValue of bytesArray)result = result * BYTE_SIZE + BigInt(byteValue);
+            return result;
+        }
+        countLeadingZeros(inputBytes) {
+            let count = 0;
+            for (const byteValue of inputBytes)if (0 === byteValue) count++;
+            else break;
+            return count;
+        }
+        numberToBase58Chars(number) {
+            const characters = [];
+            const base = BigInt(CryptoConfig.BASE58_BASE);
+            while(number > 0n){
+                const remainder = number % base;
+                characters.push(CryptoConfig.BASE58_ALPHABET[Number(remainder)]);
+                number /= base;
+            }
+            return characters;
+        }
+    }
+    class Base64Encoder {
+        encodeToB64(dataToEncode) {
+            const dataBytes = external_node_buffer_namespaceObject.Buffer.from(dataToEncode, 'utf-8');
+            const standardEncodedString = dataBytes.toString('base64');
+            let result = '';
+            for (const char of standardEncodedString){
+                const index = CryptoConfig.STANDARD_BASE64_ALPHABET.indexOf(char);
+                if (-1 !== index) result += CryptoConfig.CUSTOM_BASE64_ALPHABET[index];
+                else result += char;
+            }
+            return result;
+        }
+    }
+    class RequestSignatureValidator {
+        static validateMethod(method) {
+            if ('string' != typeof method) throw new TypeError(`method must be string, got ${typeof method}`);
+            const upperMethod = method.trim().toUpperCase();
+            if ('GET' !== upperMethod && 'POST' !== upperMethod) throw new Error(`method must be 'GET' or 'POST', got '${upperMethod}'`);
+            return upperMethod;
         }
-        dumps(...rest) {
-            const [data, replacer = null, space = 0] = rest;
-            return JSON.stringify(data, replacer, space).replace(/\n/g, "").replace(/":\s+"/g, '":"');
+        static validateUri(uri) {
+            if ('string' != typeof uri) throw new TypeError(`uri must be string, got ${typeof uri}`);
+            if (!uri.trim()) throw new Error('uri cannot be empty');
+            return uri.trim();
         }
+        static validateA1Value(a1Value) {
+            if ('string' != typeof a1Value) throw new TypeError(`a1_value must be string, got ${typeof a1Value}`);
+            if (!a1Value.trim()) throw new Error('a1_value cannot be empty');
+            return a1Value.trim();
+        }
+        static validateXsecAppid(xsecAppid) {
+            if ('string' != typeof xsecAppid) throw new TypeError(`xsec_appid must be string, got ${typeof xsecAppid}`);
+            if (!xsecAppid.trim()) throw new Error('xsec_appid cannot be empty');
+            return xsecAppid.trim();
+        }
+        static validatePayload(payload) {
+            if (null !== payload && 'object' != typeof payload) throw new TypeError(`payload must be object or null, got ${typeof payload}`);
+            if (null != payload) {
+                for(const key in payload)if ('string' != typeof key) throw new TypeError(`payload keys must be string, got ${typeof key} for key '${key}'`);
+            }
+            return payload;
+        }
+    }
+    class CryptoProcessor {
         constructor(){
-            this.words = [
-                929260340,
-                1633971297,
-                895580464,
-                925905270
+            this.bitOps = new BitOperations();
+            this.b58encoder = new Base58Encoder();
+            this.b64encoder = new Base64Encoder();
+            this.hexProcessor = new HexProcessor();
+            this.randomGen = new RandomGenerator();
+        }
+        encodeTimestamp(ts, randomizeFirst = true) {
+            const key = Array(8).fill(CryptoConfig.TIMESTAMP_XOR_KEY);
+            const arr = this.intToLeBytes(ts, 8);
+            const encoded = arr.map((a, i)=>a ^ key[i]);
+            if (randomizeFirst) encoded[0] = this.randomGen.generateRandomByteInRange(0, 255);
+            return encoded;
+        }
+        intToLeBytes(val, length = 4) {
+            const arr = [];
+            for(let i = 0; i < length; i++){
+                arr.push(0xFF & val);
+                val >>>= 8;
+            }
+            return arr;
+        }
+        strToLenPrefixedBytes(s) {
+            const buf = external_node_buffer_namespaceObject.Buffer.from(s, 'utf-8');
+            return [
+                buf.length,
+                ...Array.from(buf)
             ];
-            this.keyBytes = external_node_buffer_namespaceObject.Buffer.concat(this.words.map((word)=>new Uint8Array(external_node_buffer_namespaceObject.Buffer.from([
-                    word >> 24 & 0xff,
-                    word >> 16 & 0xff,
-                    word >> 8 & 0xff,
-                    0xff & word
-                ]))));
-            this.iv = external_node_buffer_namespaceObject.Buffer.from("4uzjr7mbsibcaldp", "utf8");
+        }
+        buildEnvironmentBytes() {
+            return [
+                CryptoConfig.ENV_STATIC_BYTES[0],
+                this.randomGen.generateRandomByteInRange(10, 254),
+                ...CryptoConfig.ENV_STATIC_BYTES.slice(1)
+            ];
+        }
+        buildPayloadArray(hexParameter, a1Value, appIdentifier = "xhs-pc-web", stringParam = "") {
+            const randNum = this.randomGen.generateRandomInt();
+            const ts = Date.now();
+            const startupTs = ts - (CryptoConfig.STARTUP_TIME_OFFSET_MIN + this.randomGen.generateRandomByteInRange(0, CryptoConfig.STARTUP_TIME_OFFSET_MAX - CryptoConfig.STARTUP_TIME_OFFSET_MIN));
+            const arr = [];
+            arr.push(...CryptoConfig.VERSION_BYTES);
+            const randBytes = this.intToLeBytes(randNum, 4);
+            arr.push(...randBytes);
+            const xorKey = randBytes[0];
+            arr.push(...this.encodeTimestamp(ts, true));
+            arr.push(...this.intToLeBytes(startupTs, 8));
+            arr.push(...this.intToLeBytes(CryptoConfig.FIXED_INT_VALUE_1));
+            arr.push(...this.intToLeBytes(CryptoConfig.FIXED_INT_VALUE_2));
+            const stringParamLength = external_node_buffer_namespaceObject.Buffer.from(stringParam, 'utf-8').length;
+            arr.push(...this.intToLeBytes(stringParamLength));
+            const md5Bytes = external_node_buffer_namespaceObject.Buffer.from(hexParameter, 'hex');
+            const xorMd5Bytes = Array.from(md5Bytes).map((b)=>b ^ xorKey);
+            arr.push(...xorMd5Bytes.slice(0, 8));
+            arr.push(...this.strToLenPrefixedBytes(a1Value));
+            arr.push(...this.strToLenPrefixedBytes(appIdentifier));
+            arr.push(CryptoConfig.ENV_STATIC_BYTES[0], this.randomGen.generateRandomByteInRange(0, 255), ...CryptoConfig.ENV_STATIC_BYTES.slice(1));
+            return arr;
         }
     }
-    const searchXiaohongshuTopicList_xsEncrypt = new XsEncrypt();
+    class Xhshow {
+        constructor(){
+            this.cryptoProcessor = new CryptoProcessor();
+        }
+        buildContentString(method, uri, payload) {
+            payload = payload || {};
+            if ("POST" === method.toUpperCase()) return uri + JSON.stringify(payload);
+            if (!payload || 0 === Object.keys(payload).length) return uri;
+            {
+                const params = Object.entries(payload).map(([key, value])=>{
+                    let valueStr = '';
+                    if (Array.isArray(value)) valueStr = value.map((v)=>String(v)).join(',');
+                    else if (null != value) valueStr = String(value);
+                    return `${key}=${valueStr}`;
+                });
+                return `${uri}?${params.join('&')}`;
+            }
+        }
+        generateDValue(content) {
+            return external_node_crypto_default().createHash('md5').update(content, 'utf-8').digest('hex');
+        }
+        buildSignature(dValue, a1Value, xsecAppid = "xhs-pc-web", stringParam = "") {
+            const payloadArray = this.cryptoProcessor.buildPayloadArray(dValue, a1Value, xsecAppid, stringParam);
+            const xorResult = this.cryptoProcessor.bitOps.xorTransformArray(payloadArray);
+            return this.cryptoProcessor.b58encoder.encodeToB58(xorResult);
+        }
+        signXs(method, uri, a1Value, xsecAppid = "xhs-pc-web", payload) {
+            const validatedMethod = RequestSignatureValidator.validateMethod(method);
+            const validatedUri = RequestSignatureValidator.validateUri(uri);
+            const validatedA1Value = RequestSignatureValidator.validateA1Value(a1Value);
+            const validatedXsecAppid = RequestSignatureValidator.validateXsecAppid(xsecAppid);
+            const validatedPayload = RequestSignatureValidator.validatePayload(payload);
+            const signatureData = {
+                ...CryptoConfig.SIGNATURE_DATA_TEMPLATE
+            };
+            const contentString = this.buildContentString(validatedMethod, validatedUri, validatedPayload);
+            const dValue = this.generateDValue(contentString);
+            signatureData.x3 = CryptoConfig.X3_PREFIX + this.buildSignature(dValue, validatedA1Value, validatedXsecAppid, contentString);
+            return CryptoConfig.XYS_PREFIX + this.cryptoProcessor.b64encoder.encodeToB64(JSON.stringify(signatureData));
+        }
+        signXsGet(uri, a1Value, xsecAppid = "xhs-pc-web", params) {
+            const validatedUri = RequestSignatureValidator.validateUri(uri);
+            const validatedA1Value = RequestSignatureValidator.validateA1Value(a1Value);
+            const validatedXsecAppid = RequestSignatureValidator.validateXsecAppid(xsecAppid);
+            const validatedParams = RequestSignatureValidator.validatePayload(params);
+            return this.signXs("GET", validatedUri, validatedA1Value, validatedXsecAppid, validatedParams);
+        }
+        signXsPost(uri, a1Value, xsecAppid = "xhs-pc-web", payload) {
+            const validatedUri = RequestSignatureValidator.validateUri(uri);
+            const validatedA1Value = RequestSignatureValidator.validateA1Value(a1Value);
+            const validatedXsecAppid = RequestSignatureValidator.validateXsecAppid(xsecAppid);
+            const validatedPayload = RequestSignatureValidator.validatePayload(payload);
+            return this.signXs("POST", validatedUri, validatedA1Value, validatedXsecAppid, validatedPayload);
+        }
+    }
+    const searchXiaohongshuTopicList_xsEncrypt = new Xhshow();
     const searchXiaohongshuTopicList = async (_task, params)=>{
         const http = new Http({
             headers: {
@@ -2739,9 +3048,8 @@ var __webpack_exports__ = {};
                     page: 1
                 }
             };
-            const topicDataStr = searchXiaohongshuTopicList_xsEncrypt.dumps(topicData);
-            const fatchTopic = `/web_api/sns/v1/search/topic${topicDataStr}`;
-            const xs = await searchXiaohongshuTopicList_xsEncrypt.encryptXs(fatchTopic, a1Cookie, xt);
+            const fatchTopic = "/web_api/sns/v1/search/topic";
+            const xs = searchXiaohongshuTopicList_xsEncrypt.signXsPost(fatchTopic, a1Cookie, "xhs-pc-web", topicData);
             const result = await http.api({
                 method: "post",
                 url: "https://edith.xiaohongshu.com/web_api/sns/v1/search/topic",
@@ -3573,10 +3881,10 @@ var __webpack_exports__ = {};
                     origin: "https://creator.xiaohongshu.com"
                 }
             });
-            const xsEncrypt = new XsEncrypt();
+            const xsEncrypt = new Xhshow();
             const xt = Date.now().toString();
             const sevenDataUrl = "/api/galaxy/v2/creator/datacenter/account/base";
-            const xs = await xsEncrypt.encryptXs(sevenDataUrl, a1Cookie, xt);
+            const xs = xsEncrypt.signXsGet(sevenDataUrl, a1Cookie, "xhs-pc-web", null);
             const [overAllData, sevenData] = await Promise.all([
                 http.api({
                     method: "get",
@@ -3937,7 +4245,7 @@ var __webpack_exports__ = {};
     async function handleXiaohongshuData(params) {
         try {
             const { cookies, pageNum = 1, pageSize = 10, showOriginalData = false, onlySuccess = false } = params;
-            const xsEncrypt = new XsEncrypt();
+            const xsEncrypt = new Xhshow();
             const a1Cookie = cookies.find((it)=>"a1" === it.name)?.value;
             if (!a1Cookie) return {
                 code: 200,
@@ -3958,8 +4266,12 @@ var __webpack_exports__ = {};
             });
             async function fetchArticles(pageNum, a1Cookie, onlySuccess = false) {
                 const xt = Date.now().toString();
-                const serveUrl = `/web_api/sns/v5/creator/note/user/posted?tab=${onlySuccess ? 1 : 0}&page=${pageNum - 1}`;
-                const xs = await xsEncrypt.encryptXs(serveUrl, a1Cookie, xt);
+                const serveUrl = "/web_api/sns/v5/creator/note/user/posted";
+                const serveParams = {
+                    tab: onlySuccess ? 1 : 0,
+                    page: pageNum - 1
+                };
+                const xs = xsEncrypt.signXsGet(serveUrl, a1Cookie, "xhs-pc-web", serveParams);
                 return await http.api({
                     method: "get",
                     baseURL: "https://edith.xiaohongshu.com",
@@ -3967,7 +4279,8 @@ var __webpack_exports__ = {};
                     headers: {
                         "x-s": xs,
                         "x-t": xt
-                    }
+                    },
+                    params: serveParams
                 });
             }
             const articleInfo = await fetchArticles(pageNum, a1Cookie, onlySuccess);
@@ -5589,7 +5902,7 @@ var __webpack_exports__ = {};
         902: "登录已过期，请重新登录！",
         906: "账号存在风险，请重新登录"
     };
-    const mock_xsEncrypt = new XsEncrypt();
+    const mock_xsEncrypt = new Xhshow();
     const xiaohongshuPublish_mock_mockAction = async (task, params)=>{
         const tmpCachePath = task.getTmpPath();
         const a1Cookie = params.cookies.find((it)=>"a1" === it.name)?.value;
@@ -5598,13 +5911,14 @@ var __webpack_exports__ = {};
             message: "账号数据异常，请重新绑定账号后重试。",
             data: ""
         };
+        const headers = {
+            cookie: params.cookies.map((it)=>`${it.name}=${it.value}`).join(";"),
+            origin: "https://creator.xiaohongshu.com",
+            referer: "https://creator.xiaohongshu.com/",
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36"
+        };
         const http = new Http({
-            headers: {
-                cookie: params.cookies.map((it)=>`${it.name}=${it.value}`).join(";"),
-                origin: "https://creator.xiaohongshu.com",
-                referer: "https://creator.xiaohongshu.com/",
-                "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36"
-            }
+            headers
         });
         http.addResponseInterceptor((response)=>{
             const responseData = response.data;
@@ -5617,9 +5931,16 @@ var __webpack_exports__ = {};
                 };
             }
         });
-        const fetchCoverUrl = `/api/media/v1/upload/creator/permit?biz_name=spectrum&scene=image&file_count=${params.banners.length}&version=1&source=web`;
+        const fetchCoverUrl = "/api/media/v1/upload/creator/permit";
+        const fetchCoverParams = {
+            biz_name: "spectrum",
+            scene: "image",
+            file_count: params.banners.length,
+            version: 1,
+            source: "web"
+        };
         const xt = Date.now().toString();
-        const xs = await mock_xsEncrypt.encryptXs(fetchCoverUrl, a1Cookie, xt);
+        const xs = mock_xsEncrypt.signXsGet(fetchCoverUrl, a1Cookie, "xhs-pc-web", fetchCoverParams);
         const coverIdInfo = await http.api({
             method: "get",
             baseURL: "https://creator.xiaohongshu.com",
@@ -5628,7 +5949,8 @@ var __webpack_exports__ = {};
             headers: {
                 "x-s": xs,
                 "x-t": xt
-            }
+            },
+            params: fetchCoverParams
         });
         let uploadInfos = [];
         coverIdInfo.data.uploadTempPermits.forEach((item)=>{
@@ -5702,9 +6024,8 @@ var __webpack_exports__ = {};
                 const topicData = {
                     topic_names: topic["name"]
                 };
-                const topicDataStr = mock_xsEncrypt.dumps(topicData);
                 const publishXt = Date.now().toString();
-                const publishXs = await mock_xsEncrypt.encryptXs(`/web_api/sns/capa/postgw/topic/batch_customized${topicDataStr}`, a1Cookie, publishXt);
+                const publishXs = mock_xsEncrypt.signXsPost("/web_api/sns/capa/postgw/topic/batch_customized", a1Cookie, "xhs-pc-web", topicData);
                 let createTopic = await http.api({
                     method: "POST",
                     url: "https://edith.xiaohongshu.com/web_api/sns/capa/postgw/topic/batch_customized",
@@ -5803,9 +6124,8 @@ var __webpack_exports__ = {};
             } : {}
         };
         publishData.common.business_binds = JSON.stringify(business_binds);
-        const publishDataStr = mock_xsEncrypt.dumps(publishData);
         const publishXt = Date.now().toString();
-        const publishXs = await mock_xsEncrypt.encryptXs(`/web_api/sns/v2/note${publishDataStr}`, a1Cookie, publishXt);
+        const publishXs = mock_xsEncrypt.signXsPost("/web_api/sns/v2/note", a1Cookie, "xhs-pc-web", publishData);
         const xscommon = GenXSCommon(a1Cookie, publishXt, publishXs);
         const publishResult = await http.api({
             method: "post",
@@ -5821,7 +6141,7 @@ var __webpack_exports__ = {};
         return (0, share_namespaceObject.success)(publishResult.data?.id);
     };
     const rpa_GenXSCommon = __webpack_require__("./src/utils/XhsXsCommonEnc.js");
-    const rpa_xsEncrypt = new XsEncrypt();
+    const rpa_xsEncrypt = new Xhshow();
     const xiaohongshuPublish_rpa_rpaAction = async (task, params)=>{
         const commonCookies = {
             path: "/",
@@ -5852,7 +6172,8 @@ var __webpack_exports__ = {};
             const url = request.url();
             if (interceptUrls.some((pattern)=>url.includes(pattern))) {
                 const urlObj = new URL(url);
-                const fetchCoverUrl = urlObj.pathname + urlObj.search;
+                urlObj.pathname, urlObj.search;
+                const fetchCoverParams = Object.fromEntries(new URLSearchParams(urlObj.search));
                 const xt = Date.now().toString();
                 const a1Cookie = params.cookies.find((it)=>"a1" === it.name)?.value;
                 if (!a1Cookie) {
@@ -5870,9 +6191,8 @@ var __webpack_exports__ = {};
                 const isNoteRequest = urlObj.pathname.includes(interceptUrls[5]);
                 const xs = await (isNoteRequest ? (async ()=>{
                     const publishData = JSON.parse(request.postData() || "");
-                    const publishDataStr = rpa_xsEncrypt.dumps(publishData);
-                    return rpa_xsEncrypt.encryptXs(interceptUrls[5] + publishDataStr, a1Cookie, xt);
-                })() : rpa_xsEncrypt.encryptXs(fetchCoverUrl, a1Cookie, xt));
+                    return rpa_xsEncrypt.signXsPost(interceptUrls[5], a1Cookie, "xhs-pc-web", publishData);
+                })() : rpa_xsEncrypt.signXsGet(urlObj.pathname, a1Cookie, "xhs-pc-web", fetchCoverParams));
                 const xscommon = rpa_GenXSCommon(a1Cookie, xt, xs);
                 const newHeaders = {
                     ...request.headers(),
@@ -6039,7 +6359,7 @@ var __webpack_exports__ = {};
         return executeAction(xiaohongshuPublish_mock_mockAction, xiaohongshuPublish_rpa_rpaAction)(task, params);
     };
     var package_namespaceObject = {
-        i8: "1.2.22"
+        i8: "1.2.23"
     };
     class Action {
         constructor(task){