├── xhs_md5.py └── xy_main.py /xhs_md5.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | def F(x,y,z): 4 | return (x & y) | ((~x) & z) 5 | 6 | def G(x,y,z): 7 | return (x & z) | (y & (~z)) 8 | 9 | def H(x,y,z): 10 | return x ^ y ^ z 11 | 12 | def I(x,y,z): 13 | return y ^ (x | (~z)) 14 | 15 | def ROTATE_LEFT(value, offset): 16 | value &= 0xFFFFFFFF 17 | temp = value >> offset 18 | mas = 0 19 | for i in range(offset): 20 | mas += pow(2,i) 21 | return temp | (value & mas) << 32 - offset 22 | 23 | def FF(a, b, c, d, x, s, ac): 24 | a = a + F((b), (c), (d)) + (x) + (ac) 25 | a = ROTATE_LEFT(a,s) 26 | a = a + b 27 | return a # must assign this to a 28 | 29 | 30 | def GG(a, b, c, d, x, s, ac): 31 | a = a + G((b), (c), (d)) + (x) + (ac) 32 | a = ROTATE_LEFT((a), (s)) 33 | a = a + b 34 | return a # must assign this to a 35 | 36 | 37 | def HH(a, b, c, d, x, s, ac): 38 | a = a + H((b), (c), (d)) + (x) + (ac) 39 | a = ROTATE_LEFT((a), (s)) 40 | a = a + b 41 | return a # must assign this to a 42 | 43 | 44 | def II(a, b, c, d, x, s, ac): 45 | a = a + I((b), (c), (d)) + (x) + (ac) 46 | a = ROTATE_LEFT((a), (s)) 47 | a = a + b 48 | return a # must assign this to a 49 | 50 | def b2iu(b): 51 | if b<0: 52 | return b & 0x7F + 128 53 | else: 54 | return b 55 | 56 | def BIC(value, mas): 57 | value &= 0xFFFFFFFF 58 | return value & ~mas 59 | 60 | class XHS_MD5: 61 | 62 | PADDING = [-128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 63 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 65 | 0, 0, 0, 0, 0, 0, 0] 66 | 67 | def __init__(self): 68 | self.count = [0,0] 69 | self.state = [0, 0, 0, 0] 70 | 71 | 72 | self.state[0] = 0x10325476 73 | self.state[1] = 0x98badcfe 74 | self.state[2] = 0xefcdab89 75 | self.state[3] = 0x67452301 76 | 77 | self.buffer = [0 for i in range(64)] 78 | self.digest = [0 for i in range(16)] 79 | 80 | def md5Memcpy(self,output,input,outops,inops,len): 81 | 82 | output[outops:outops+len] = input[inops:inops+len] 83 | 84 | def md5Update(self,input, inputLen): 85 | block = [0 for i in range(64)] 86 | index = int(self.count[0] >> 3) & 0x3F 87 | self.count[0] = self.count[0] + (inputLen << 3) 88 | if self.count[0] < (inputLen << 3): 89 | self.count[1] += 1 90 | self.count[1] += (inputLen >> 29) 91 | partLen = 64 - index 92 | if inputLen >= partLen: 93 | self.md5Memcpy(self.buffer,input,index,0,partLen) 94 | # self.buffer = self.buffer[:index] + input[:partLen] 95 | self.md5Transform(self.buffer) 96 | i = partLen 97 | while i+63 < inputLen: 98 | self.md5Memcpy(block, input, 0 ,i ,i+64) 99 | self.md5Transform(block) 100 | i = i + 64 101 | index = 0 102 | else: 103 | i = 0 104 | self.md5Memcpy(self.buffer, input, index, i, inputLen-i) 105 | 106 | # def md5Update(self, input, inputLen=1): 107 | # inputLen = len(input) 108 | # index = int(self.count >> 3) & 0x3F 109 | # self.count = self.count + (inputLen << 3) # update number of bits 110 | # partLen = XHS_MD5.block_size - index 111 | # 112 | # # apply compression function to as many blocks as we have 113 | # if inputLen >= partLen: 114 | # self.buffer = self.buffer[:index] + input[:partLen] 115 | # self.state = self.md5Transform(self.state, self.buffer) 116 | # i = partLen 117 | # while i + 63 < inputLen: 118 | # self.state = self.md5Transform(self.state, input[i:i + XHS_MD5.block_size]) 119 | # i = i + XHS_MD5.block_size 120 | # index = 0 121 | # else: 122 | # i = 0 123 | # 124 | # # buffer remaining output 125 | # self.buffer = self.buffer[:index] + input[i:inputLen] 126 | 127 | 128 | def md5Final(self,data=None): 129 | bits = [0 for i in range(8)] 130 | self.Encode(bits,self.count,8) 131 | if data != None: 132 | temp = [0 for i in range(64)] 133 | temp[0:len(data)] = data[0:len(data)] 134 | temp[len(data)] = 0x80 135 | temp[56] = 0x80 136 | temp[57] = 2 137 | self.md5Update(temp,64) 138 | else: 139 | index = int(self.count[0] >> 3) & 0x3f 140 | if index < 56: 141 | padLen = 56 - index 142 | else: 143 | padLen = 120 - index 144 | self.md5Update(self.PADDING, padLen) 145 | self.md5Update(bits,8) 146 | self.Encode(self.digest, self.state, 16) 147 | return self.digest 148 | 149 | 150 | def md5Transform(self,block): 151 | a = self.state[0] 152 | b = self.state[1] 153 | c = self.state[2] 154 | d = self.state[3] 155 | x = [0 for i in range(16)] 156 | self.Decode(x, block, 64) 157 | # round1 158 | a = FF(a, b, c, d, x[0], 26, 0xd76aa478) 159 | d = FF(d, a, b, c, x[1], 19, 0xe8c7b756) 160 | c = FF(c, d, a, b, x[2], 15, 0x242070db) 161 | b = FF(b, c, d, a, x[3], 11, 0xc1bdceee) 162 | a = FF(a, b, c, d, x[4], 25, 0xf57c0faf) 163 | d = FF(d, a, b, c, x[5], 20, 0x4787c62a) 164 | c = FF(c, d, a, b, x[6], 15, 0xa8304613) 165 | b = FF(b, c, d, a, x[7], 12, 0xfd469501) 166 | a = FF(a, b, c, d, x[8], 25, 0x698098d8) 167 | d = FF(d, a, b, c, x[9], 20, 0x8b44f7af) 168 | c = FF(c, d, a, b, x[10], 16, 0xffff5bb1) 169 | b = FF(b, c, d, a, x[11], 10, 0x895cd7be) 170 | a = FF(a, b, c, d, x[12], 25, 0x6b901122) 171 | d = FF(d, a, b, c, x[13], 19, 0xfd987193) 172 | c = FF(c, d, a, b, x[14], 15, 0xa679438e) 173 | b = FF(b, c, d, a, x[15], 10, 0x49b40821) 174 | 175 | # round2 176 | a = GG(a, b, c, d, x[1], 27, BIC(0xf61e2562, 0xFF00FF)) 177 | d = GG(d, a, b, c, x[6], 23, 0xc040b340) 178 | c = GG(c, d, a, b, x[11], 18, 0x265e5a51) 179 | b = GG(b, c, d, a, x[0], 12, 0xe9b6c7aa & 0xFF0011FF) 180 | a = GG(a, b, c, d, x[5], 27, 0xd62f105d) 181 | d = GG(d, a, b, c, x[10], 23, 0x2441453) 182 | c = GG(c, d, a, b, x[15], 18, 0xd8a1e681) 183 | b = GG(b, c, d, a, x[4], 12, 0xe7d3fbc8) 184 | a = GG(a, b, c, d, x[9], 27, 0x21e1cde6) 185 | d = GG(d, a, b, c, x[14], 23, 0xc33707d6) 186 | c = GG(c, d, a, b, x[3], 18, 0xf4d50d87) 187 | b = GG(b, c, d, a, x[8], 12, 0x455a14ed) 188 | a = GG(a, b, c, d, x[13], 27, 0xa9e3e905) 189 | d = GG(d, a, b, c, x[2], 23, 0xfcefa3f8 & 0xFF110011) 190 | c = GG(c, d, a, b, x[7], 18, 0x676f02d9) 191 | b = GG(b, c, d, a, x[12], 12, 0x8d2a4c8a) 192 | # round3 193 | a = HH(a, b, c, d, x[5], 28, 0xfffa3942) 194 | d = HH(d, a, b, c, x[8], 21, 0x8771f681) 195 | c = HH(c, d, a, b, x[11], 16, 0x6d9d6122) 196 | b = HH(b, c, d, a, x[14], 9, 0xfde5380c) 197 | a = HH(a, b, c, d, x[1], 28, 0xa4beea44) 198 | d = HH(d, a, b, c, x[4], 21, 0x4bdecfa9) 199 | c = HH(c, d, a, b, x[7], 16, 0xf6bb4b60) 200 | a = HH(a, b, c, d, x[13], 28, 0x289b7ec6) 201 | b = HH(b, c, d, a, x[10], 9, 0xbebfbc70) 202 | c = HH(c, d, a, b, x[3], 16, 0xd4ef3085) 203 | d = HH(d, a, b, c, x[0], 21, 0xeaa127fa) 204 | b = HH(b, c, d, a, x[6], 9, 0x4881d05) 205 | a = HH(a, b, c, d, x[9], 28, 0xd9d4d039) 206 | d = HH(d, a, b, c, x[12], 21, 0xe6db99e5) 207 | c = HH(c, d, a, b, x[15], 16, 0x1fa27cf8) 208 | b = HH(b, c, d, a, x[2], 9, 0xc4ac5665) 209 | 210 | # round4 211 | a = II(a, b, c, d, x[0], 26, 0xf4292244) 212 | d = II(d, a, b, c, x[7], 22, 0x432aff97) 213 | c = II(c, d, a, b, x[14], 17, 0xab9423a7) 214 | b = II(b, c, d, a, x[5], 11, 0xfc93a039) 215 | a = II(a, b, c, d, x[12], 26, 0x655b59c3) 216 | d = II(d, a, b, c, x[3], 22, 0x8f0ccc92) 217 | c = II(c, d, a, b, x[10], 17, 0xffeff47d) 218 | b = II(b, c, d, a, x[1], 11, 0x85845dd1) 219 | a = II(a, b, c, d, x[8], 26, 0x6fa87e4f) 220 | d = II(d, a, b, c, x[15], 22, 0xfe2ce6e0) 221 | c = II(c, d, a, b, x[6], 17, 0xa3014314) 222 | b = II(b, c, d, a, x[13], 11, 0x4e0811a1) 223 | a = II(a, b, c, d, x[4], 26, 0xf7537e82) 224 | d = II(d, a, b, c, x[11], 22, 0xbd3af235) 225 | c = II(c, d, a, b, x[2], 17, 0x2ad7d2bb) 226 | b = II(b, c, d, a, x[9], 11, 0xeb86d391) 227 | 228 | self.state[0] += a 229 | self.state[1] += b 230 | self.state[2] += c 231 | self.state[3] += d 232 | 233 | 234 | def Encode(self, output, input, len_input): 235 | j = 0 236 | i = 0 237 | while j < len_input: 238 | output[j] = (input[i] & 0xff) 239 | output[j + 1] = ((input[i] >> 8) & 0xff) 240 | output[j + 2] = ((input[i] >> 16) & 0xff) 241 | output[j + 3] = ((input[i] >> 24) & 0xff) 242 | i += 1 243 | j += 4 244 | 245 | def Decode(self, output, input, len_input): 246 | j = 0 247 | i = 0 248 | while j < len_input: 249 | output[i] = b2iu(input[j]) | (b2iu(input[j + 1]) << 8) | (b2iu(input[j + 2]) << 16) | (b2iu(input[j + 3]) << 24) 250 | i += 1 251 | j += 4 252 | 253 | 254 | 255 | if __name__ == '__main__': 256 | xymd5 = XHS_MD5() 257 | strlen = "/api/sns/v1/note/feednote_id=611e3446000000002103e745&page=1&has_ads_tag=false&num=5&fetch_mode=1&source=explore&ads_track_id=fm_fwfm_ol_30day%4028y6fh5sgzc4a916hbx23fid=162925699210bf9c0d3447ec1a57edbfc9b9f44f9625&device_fingerprint=20210810140918508c2ccd6e986960ec8432e9c2edd16b01265a5749ac3489&device_fingerprint1=20210810140918508c2ccd6e986960ec8432e9c2edd16b01265a5749ac3489&launch_id=1629451556&tz=Asia%2FShanghai&channel=YingYongBao&versionName=7.6.0&deviceId=879246a0-b385-3400-b59d-76f63fa5baff&platform=android&sid=session.1629264087421090169948&identifier_flag=4&t=1629451595&project_id=ECFAAF&build=7060188&x_trace_page_current=explore_feed&lang=zh-Hans&app_id=ECFAAF01&uis=lightplatform=android&build=7060188&deviceId=879246a0-b385-3400-b59d-76f63fa5baff".encode() 258 | strl = list(strlen) 259 | xymd5.md5Update(input=strl,inputLen=len(strl)) 260 | print(bytearray(xymd5.md5Final()).hex()) 261 | 262 | 263 | 264 | -------------------------------------------------------------------------------- /xy_main.py: -------------------------------------------------------------------------------- 1 | import base64 2 | import binascii 3 | 4 | from xhs_aes import XHS_AES 5 | from xhs_md5 import XHS_MD5 6 | 7 | 8 | 9 | class Shield: 10 | 11 | def __init__(self,versioncode,platform="ios",md5_k=0): 12 | """ 13 | :param device_key: 小红书返回的x-ter-str 14 | :param device_id: 设备id 15 | :param content: 加密的内容 16 | """ 17 | if platform == 'ios': 18 | self.__app_id = "ecfaaf02" 19 | self.flag = "02" 20 | if platform == "android": 21 | self.__app_id = "ecfaaf01" 22 | self.flag = "01" 23 | self.version_build = versioncode 24 | 25 | @staticmethod 26 | def strT0Hexstr(str): 27 | return binascii.hexlify(str.encode()).decode('utf-8') 28 | 29 | def get_oldsign(self,path='', params='', xy_common_params='', xy_platform_info='', data='', content='', 30 | main_hmac='', device_id=''): 31 | xhs = XHS_AES(xy_ter_str=main_hmac,deviceid=device_id) 32 | key = bytearray(xhs.key_hash) 33 | content = bytearray(content, encoding='utf-8') or bytearray( 34 | ''.join([path, params, xy_common_params, xy_platform_info, data]), encoding='utf-8') 35 | #hmac部分计算 36 | key_len = len(key) 37 | IPADKey = [0 for i in range(key_len)] 38 | for i in range(64): 39 | IPADKey[i] = key[i] ^ 0x36 40 | xhs1 = XHS_MD5() 41 | xhs1.md5Update(IPADKey, len(IPADKey)) 42 | content = list(content) 43 | xhs1.md5Update(content,len(content)) 44 | bytes1 = xhs1.md5Final() 45 | 46 | OPADKey = [0 for i in range(key_len)] 47 | for i in range(64): 48 | OPADKey[i] = key[i] ^ 0x5C 49 | xhs2 = XHS_MD5() 50 | xhs2.md5Update(OPADKey, len(IPADKey)) 51 | res = xhs2.md5Final(bytes1) 52 | return res 53 | 54 | def getSign(self, path='', params='', xy_common_params='', xy_platform_info='', data='', content='', 55 | main_hmac='', device_id=''): 56 | """ 57 | 生成签名 根据main_hmac device_id解密出一个key。 58 | """ 59 | _res = self.get_oldsign(path=path, params=params, xy_common_params=xy_common_params, 60 | xy_platform_info=xy_platform_info, data=data, 61 | content=content, main_hmac=main_hmac, device_id=device_id) 62 | _res = bytearray(_res).hex() 63 | print(_res) 64 | newsign = self.calc_shield(device_id=device_id, oldsign=_res) 65 | return newsign 66 | 67 | def init_table(self): 68 | a1 = [0 for i in range(0x102)] 69 | a2 = 13 70 | a3 = [0x73, 0x74, 0x64, 0x3a, 0x3a, 0x61, 0x62, 0x6f, 0x72, 0x74, 0x28, 0x29, 0x3b] 71 | a1[0] = 0 72 | a1[1] = 0 73 | v11 = 0 74 | v7 = 0 75 | for i in range(256): 76 | a1[i + 2] = i 77 | for j in range(0, 256, 4): 78 | v15 = a1[j + 2] 79 | v8 = (a3[v11] + v15 + v7) & 0xff 80 | v12 = v11 + 1 81 | if v12 == a2: 82 | v12 = 0 83 | a1[j + 2] = a1[v8 + 2] 84 | a1[v8 + 2] = v15 85 | 86 | v16 = a1[j + 3] 87 | v9 = (a3[v12] + v16 + v8) & 0xff 88 | v13 = v12 + 1 89 | if v13 == a2: 90 | v13 = 0 91 | a1[j + 3] = a1[v9 + 2] 92 | a1[v9 + 2] = v16 93 | 94 | v17 = a1[j + 4] 95 | v10 = (a3[v13] + v17 + v9) & 0xff 96 | v14 = v13 + 1 97 | if v14 == a2: 98 | v14 = 0 99 | a1[j + 4] = a1[v10 + 2] 100 | a1[v10 + 2] = v17 101 | 102 | v18 = a1[j + 5] 103 | v7 = (a3[v14] + v18 + v10) & 0xff 104 | v11 = v14 + 1 105 | if v11 == a2: 106 | v11 = 0 107 | a1[j + 5] = a1[v7 + 2] 108 | a1[2 + v7] = v18 109 | return a1 110 | 111 | def init_base64_table(self, input_byte): 112 | input_len = len(input_byte) 113 | output_byte = [0 for i in range(input_len)] 114 | a1 = self.init_table() 115 | a2 = 0x53 116 | a3 = input_byte 117 | a4 = output_byte 118 | v51 = a1[0] 119 | v43 = a1[1] 120 | v59 = a1[2:] 121 | count = 0 122 | i = a2 >> 3 123 | while i > 0: 124 | v52 = (v51 + 1) & 0xff 125 | v28 = v59[v52] 126 | v44 = (v28 + v43) & 0xff 127 | v13 = v59[v44] 128 | v59[v52] = v13 129 | v59[v44] = v28 130 | a4[count] = (v59[(v28 + v13) & 0xff] ^ a3[count]) 131 | v53 = (v52 + 1) & 0xff 132 | v29 = v59[v53] 133 | v45 = (v29 + v44) & 0xff 134 | v14 = v59[v45] 135 | v59[v53] = v14 136 | v59[v45] = v29 137 | a4[count + 1] = (v59[(v29 + v14) & 0xff] ^ a3[count + 1]) 138 | v54 = (v53 + 1) & 0xff 139 | v30 = v59[v54] 140 | v46 = (v30 + v45) & 0xff 141 | v15 = v59[v46] 142 | v59[v54] = v15 143 | v59[v46] = v30 144 | a4[count + 2] = (v59[(v30 + v15) & 0xff] ^ a3[count + 2]) 145 | v55 = (v54 + 1) & 0xff 146 | v31 = v59[v55] 147 | v47 = (v31 + v46) & 0xff 148 | v16 = v59[v47] 149 | v59[v55] = v16 150 | v59[v47] = v31 151 | a4[count + 3] = (v59[(v31 + v16) & 0xff] ^ a3[count + 3]) 152 | v56 = (v55 + 1) & 0xff 153 | v32 = v59[v56] 154 | v48 = (v32 + v47) & 0xff 155 | v17 = v59[v48] 156 | v59[v56] = v17 157 | v59[v48] = v32 158 | a4[count + 4] = (v59[(v32 + v17) & 0xff] ^ a3[count + 4]) 159 | v57 = (v56 + 1) & 0xff 160 | v33 = v59[v57] 161 | v49 = (v33 + v48) & 0xff 162 | v18 = v59[v49] 163 | v59[v57] = v18 164 | v59[v49] = v33 165 | a4[count + 5] = (v59[(v33 + v18) & 0xff] ^ a3[count + 5]) 166 | v58 = (v57 + 1) & 0xff 167 | v34 = v59[v58] 168 | v50 = (v34 + v49) & 0xff 169 | v19 = v59[v50] 170 | v59[v58] = v19 171 | v59[v50] = v34 172 | a4[count + 6] = (v59[(v34 + v19) & 0xff] ^ a3[count + 6]) 173 | v51 = (v58 + 1) & 0xff 174 | v35 = v59[v51] 175 | v43 = (v35 + v50) & 0xff 176 | v20 = v59[v43] 177 | v59[v51] = v20 178 | v59[v43] = v35 179 | a4[count + 7] = (v59[(v35 + v20) & 0xff] ^ a3[count + 7]) 180 | count += 8 181 | i -= 1 182 | v6 = a2 & 7 183 | if (v6 != 0): 184 | while v6 > 0: 185 | v51 = (v51 + 1) & 0xff 186 | v36 = v59[v51] 187 | v43 = (v36 + v43) & 0xff 188 | v21 = v59[v43] 189 | v59[v51] = v21 190 | v59[v43] = v36 191 | a4[count] = (v59[(v36 + v21) & 0xff] ^ a3[count]) 192 | v7 = v6 - 1 193 | if (v7 == 0): 194 | break 195 | v51 = (v51 + 1) & 0xff 196 | v37 = v59[v51] 197 | v43 = (v37 + v43) & 0xff 198 | v22 = v59[v43] 199 | v59[v51] = v22 200 | v59[v43] = v37 201 | a4[count + 1] = (v59[(v37 + v22) & 0xff] ^ a3[count + 1]) 202 | v8 = v7 - 1 203 | if (v8 == 0): 204 | break 205 | v51 = (v51 + 1) & 0xff 206 | v37 = v59[v51] 207 | v43 = (v37 + v43) & 0xff 208 | v22 = v59[v43] 209 | v59[v51] = v22 210 | v59[v43] = v37 211 | a4[count + 2] = (v59[(v37 + v22) & 0xff] ^ a3[count + 2]) 212 | v8 = v8 - 1 213 | if (v8 == 0): 214 | break 215 | v51 = (v51 + 1) & 0xff 216 | v37 = v59[v51] 217 | v43 = (v37 + v43) & 0xff 218 | v22 = v59[v43] 219 | v59[v51] = v22 220 | v59[v43] = v37 221 | a4[count + 3] = (v59[(v37 + v22) & 0xff] ^ a3[count + 3]) 222 | v8 = v8 - 1 223 | if (v8 == 0): 224 | break 225 | v51 = (v51 + 1) & 0xff 226 | v37 = v59[v51] 227 | v43 = (v37 + v43) & 0xff 228 | v22 = v59[v43] 229 | v59[v51] = v22 230 | v59[v43] = v37 231 | a4[count + 4] = (v59[(v37 + v22) & 0xff] ^ a3[count + 4]) 232 | v8 = v8 - 1 233 | if (v8 == 0): 234 | break 235 | v51 = (v51 + 1) & 0xff 236 | v37 = v59[v51] 237 | v43 = (v37 + v43) & 0xff 238 | v22 = v59[v43] 239 | v59[v51] = v22 240 | v59[v43] = v37 241 | a4[count + 5] = (v59[(v37 + v22) & 0xff] ^ a3[count + 5]) 242 | v8 = v8 - 1 243 | if (v8 == 0): 244 | break 245 | v51 = (v51 + 1) & 0xff 246 | v37 = v59[v51] 247 | v43 = (v37 + v43) & 0xff 248 | v22 = v59[v43] 249 | v59[v51] = v22 250 | v59[v43] = v37 251 | a4[count + 6] = (v59[(v37 + v22) & 0xff] ^ a3[count + 6]) 252 | v6 = v8 - 1 253 | return output_byte 254 | 255 | def shield_init(self, device_id, oldsign): 256 | "version长度7 device_id长度24 旧shield长度10" 257 | appid_hex_str = self.__app_id.lower() 258 | appversion_hex_str = self.strT0Hexstr(self.version_build) 259 | deviceid_hex_str = self.strT0Hexstr(device_id) 260 | oldshield_hex_str = oldsign 261 | calc_str = f"000000{self.flag}{appid_hex_str}00000002000000070000002400000010{appversion_hex_str}{deviceid_hex_str}{oldshield_hex_str}" 262 | print(calc_str) 263 | b_res = self.init_base64_table(bytes.fromhex(calc_str)) 264 | return b_res 265 | 266 | def calc_shield(self, device_id, oldsign): 267 | output2 = [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 83, 0, 0, 0, 83] 268 | output1 = self.shield_init(device_id, oldsign) 269 | b64_encode_str = output2 + output1 270 | _res = base64.b64encode(bytearray(b64_encode_str)) 271 | return "XY" + _res.decode("utf-8") 272 | 273 | shield = Shield(versioncode="7200370") 274 | zz = shield.getSign(path="/api/sns/v1/system_service/check_code",params="code=147147&phone=15270065469&zone=86", 275 | device_id="C803DBA8-13A0-4B22-8FB2-B18A298AE2AA",xy_common_params="app_id=ECFAAF02&build=7200370&deviceId=C803DBA8-13A0-4B22-8FB2-B18A298AE2AA&device_fingerprint=20180919204408e9d9645bd8bc29c430aeb399145525fc01a5fc5ff3bf7585&fid=1639361924-0-0-6e8e5b4ec5fe4d1a01ba41b25a04edc7&identifier_flag=1&lang=zh-Hans&launch_id=661745425&platform=iOS&project_id=ECFAAF&sid=session.1639643018619800674202&t=1640052914&teenager=0&tz=Asia/Shanghai&uis=light&version=7.20", 276 | xy_platform_info="platform=iOS&version=7.20&build=7200370&deviceId=C803DBA8-13A0-4B22-8FB2-B18A298AE2AA&bundle=com.xingin.discover", 277 | main_hmac="Nl4PQ+hRr0vv4UQtkQJ5m8ALtCVvGlSTB1mSd9XGddEt5aP3dnB7DKI4Q1wuWtWhOJVXrqNTS0pkqw9Uf4uDxNp5l/IKGqihjYesf5fkD3HGVBGj+zGgApdkQe77moEE") 278 | print(zz) 279 | 280 | --------------------------------------------------------------------------------