@iflyrpa/actions 1.2.23 → 1.2.24

package/dist/index.mjs

@@ -2610,57 +2610,366 @@ const searchXiaohongshuLocation = async (_task, params)=>{
         return (0, __WEBPACK_EXTERNAL_MODULE__iflyrpa_share_f7afdc8c__.success)([]);
     }
 };
-class XsEncrypt {
-    async encryptMD5(url) {
-        return __WEBPACK_EXTERNAL_MODULE_node_crypto_9ba42079__["default"].createHash("md5").update(url, "utf8").digest("hex");
-    }
-    async encryptText(text) {
-        const textEncoded = __WEBPACK_EXTERNAL_MODULE_node_buffer_fb286294__.Buffer.from(text).toString("base64");
-        const cipher = __WEBPACK_EXTERNAL_MODULE_node_crypto_9ba42079__["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 = __WEBPACK_EXTERNAL_MODULE_node_buffer_fb286294__.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 __WEBPACK_EXTERNAL_MODULE_node_buffer_fb286294__.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 = __WEBPACK_EXTERNAL_MODULE_node_buffer_fb286294__.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;
     }
-    dumps(...rest) {
-        const [data, replacer = null, space = 0] = rest;
-        return JSON.stringify(data, replacer, space).replace(/\n/g, "").replace(/":\s+"/g, '":"');
+    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 = __WEBPACK_EXTERNAL_MODULE_node_buffer_fb286294__.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;
+    }
+    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 = __WEBPACK_EXTERNAL_MODULE_node_buffer_fb286294__.Buffer.from(s, 'utf-8');
+        return [
+            buf.length,
+            ...Array.from(buf)
         ];
-        this.keyBytes = __WEBPACK_EXTERNAL_MODULE_node_buffer_fb286294__.Buffer.concat(this.words.map((word)=>new Uint8Array(__WEBPACK_EXTERNAL_MODULE_node_buffer_fb286294__.Buffer.from([
-                word >> 24 & 0xff,
-                word >> 16 & 0xff,
-                word >> 8 & 0xff,
-                0xff & word
-            ]))));
-        this.iv = __WEBPACK_EXTERNAL_MODULE_node_buffer_fb286294__.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 = __WEBPACK_EXTERNAL_MODULE_node_buffer_fb286294__.Buffer.from(stringParam, 'utf-8').length;
+        arr.push(...this.intToLeBytes(stringParamLength));
+        const md5Bytes = __WEBPACK_EXTERNAL_MODULE_node_buffer_fb286294__.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 __WEBPACK_EXTERNAL_MODULE_node_crypto_9ba42079__["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: {
@@ -2688,9 +2997,8 @@ const searchXiaohongshuTopicList = async (_task, params)=>{
                 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",
@@ -3522,10 +3830,10 @@ async function getXiaohongshuData(params) {
                 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",
@@ -3886,7 +4194,7 @@ async function handleBaijiahaoData(params) {
 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,
@@ -3907,8 +4215,12 @@ async function handleXiaohongshuData(params) {
         });
         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",
@@ -3916,7 +4228,8 @@ async function handleXiaohongshuData(params) {
                 headers: {
                     "x-s": xs,
                     "x-t": xt
-                }
+                },
+                params: serveParams
             });
         }
         const articleInfo = await fetchArticles(pageNum, a1Cookie, onlySuccess);
@@ -5538,7 +5851,7 @@ const xiaohongshuPublish_mock_errnoMap = {
     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;
@@ -5547,13 +5860,14 @@ const xiaohongshuPublish_mock_mockAction = async (task, params)=>{
         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;
@@ -5566,9 +5880,16 @@ const xiaohongshuPublish_mock_mockAction = async (task, params)=>{
             };
         }
     });
-    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",
@@ -5577,7 +5898,8 @@ const xiaohongshuPublish_mock_mockAction = async (task, params)=>{
         headers: {
             "x-s": xs,
             "x-t": xt
-        }
+        },
+        params: fetchCoverParams
     });
     let uploadInfos = [];
     coverIdInfo.data.uploadTempPermits.forEach((item)=>{
@@ -5651,9 +5973,8 @@ const xiaohongshuPublish_mock_mockAction = async (task, params)=>{
             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",
@@ -5752,9 +6073,8 @@ const xiaohongshuPublish_mock_mockAction = async (task, params)=>{
         } : {}
     };
     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",
@@ -5770,7 +6090,7 @@ const xiaohongshuPublish_mock_mockAction = async (task, params)=>{
     return (0, __WEBPACK_EXTERNAL_MODULE__iflyrpa_share_f7afdc8c__.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: "/",
@@ -5801,7 +6121,8 @@ const xiaohongshuPublish_rpa_rpaAction = async (task, params)=>{
         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) {
@@ -5819,9 +6140,8 @@ const xiaohongshuPublish_rpa_rpaAction = async (task, params)=>{
             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(),
@@ -5988,7 +6308,7 @@ const xiaohongshuPublish = async (task, params)=>{
     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){