├── requirements.txt
├── .gitignore
├── README.md
├── main.py
├── LICENSE
└── crypto.txt
/requirements.txt:
--------------------------------------------------------------------------------
1 | about-time==3.1.1
2 | alive-progress==2.1.0
3 | beautifulsoup4==4.11.1
4 | certifi==2021.10.8
5 | charset-normalizer==2.0.12
6 | commonmark==0.9.1
7 | dataclasses==0.8
8 | grapheme==0.6.0
9 | html5lib==1.1
10 | idna==3.3
11 | Pygments==2.12.0
12 | requests==2.27.1
13 | rich==12.4.1
14 | six==1.16.0
15 | soupsieve==2.3.2.post1
16 | typing-extensions==4.1.1
17 | urllib3==1.26.9
18 | webencodings==0.5.1
19 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # Byte-compiled / optimized / DLL files
2 | __pycache__/
3 | *.py[cod]
4 | *$py.class
5 |
6 | # C extensions
7 | *.so
8 |
9 | # Distribution / packaging
10 | .Python
11 | build/
12 | develop-eggs/
13 | dist/
14 | downloads/
15 | eggs/
16 | .eggs/
17 | lib/
18 | lib64/
19 | parts/
20 | sdist/
21 | var/
22 | wheels/
23 | pip-wheel-metadata/
24 | share/python-wheels/
25 | *.egg-info/
26 | .installed.cfg
27 | *.egg
28 | MANIFEST
29 |
30 | # PyInstaller
31 | # Usually these files are written by a python script from a template
32 | # before PyInstaller builds the exe, so as to inject date/other infos into it.
33 | *.manifest
34 | *.spec
35 |
36 | # Installer logs
37 | pip-log.txt
38 | pip-delete-this-directory.txt
39 |
40 | # Unit test / coverage reports
41 | htmlcov/
42 | .tox/
43 | .nox/
44 | .coverage
45 | .coverage.*
46 | .cache
47 | nosetests.xml
48 | coverage.xml
49 | *.cover
50 | *.py,cover
51 | .hypothesis/
52 | .pytest_cache/
53 |
54 | # Translations
55 | *.mo
56 | *.pot
57 |
58 | # Django stuff:
59 | *.log
60 | local_settings.py
61 | db.sqlite3
62 | db.sqlite3-journal
63 |
64 | # Flask stuff:
65 | instance/
66 | .webassets-cache
67 |
68 | # Scrapy stuff:
69 | .scrapy
70 |
71 | # Sphinx documentation
72 | docs/_build/
73 |
74 | # PyBuilder
75 | target/
76 |
77 | # Jupyter Notebook
78 | .ipynb_checkpoints
79 |
80 | # IPython
81 | profile_default/
82 | ipython_config.py
83 |
84 | # pyenv
85 | .python-version
86 |
87 | # pipenv
88 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
89 | # However, in case of collaboration, if having platform-specific dependencies or dependencies
90 | # having no cross-platform support, pipenv may install dependencies that don't work, or not
91 | # install all needed dependencies.
92 | #Pipfile.lock
93 |
94 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow
95 | __pypackages__/
96 |
97 | # Celery stuff
98 | celerybeat-schedule
99 | celerybeat.pid
100 |
101 | # SageMath parsed files
102 | *.sage.py
103 |
104 | # Environments
105 | .env
106 | .venv
107 | env/
108 | venv/
109 | ENV/
110 | env.bak/
111 | venv.bak/
112 |
113 | # Spyder project settings
114 | .spyderproject
115 | .spyproject
116 |
117 | # Rope project settings
118 | .ropeproject
119 |
120 | # mkdocs documentation
121 | /site
122 |
123 | # mypy
124 | .mypy_cache/
125 | .dmypy.json
126 | dmypy.json
127 |
128 | # Pyre type checker
129 | .pyre/
130 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 |
2 |
3 | 
4 |
5 |
6 | 
7 |
8 |
9 | 
10 |
11 |
12 | 
13 |
14 |
15 |
16 |
17 | ## :cl: 最近更新
18 |
19 | - 2022.5.17 暴力跳过视频类型任务点的验证码检测
20 | - 2022.5.26 修复无法登录失败问题(密码登录加密模式更新了)
21 | - 使用教程:
22 | 1. [点我查看源码](https://github.com/Hyrmm/chaoxingSpider/blob/main/crypto.txt),也可在当前脚本目录下用记事本打开复制
23 | 2. 复制`cypoto.txt`文件内的JavaScript源码
24 | 3. 打开浏览器,按`F12`打开控制台(`CONSOLE`),粘贴源码,回车
25 | 4. 在控制台输入`des("你的密码")`，注:双引号不要丢
26 | 5. 举例:`des("123456")`
27 | 6. 控制台会输出你的des密码，拿着这个密码去登录，可以保存下来，密码不更改，des密码也不会变动。
28 | 7. 复制控制台的密码时，注意复制双引号内的内容
29 | - 2022.5.28 一系列修复
30 | - 修复密码登录后,提交刷课问题
31 | - 添加自定义倍速
32 |
33 |
34 |
35 | ## :wrench: 功能介绍
36 |
37 | ### :one:智能自动化
38 |
39 | - 自动跳过非任务点视频，ppt，word
40 | - 自动根据历史进度完成视频播放(自己之前手动看过的进度)
41 | - 自动完成当前任务继续完成下个任务,直至本课程全部完成
42 |
43 | ### :two:支持多类型任务点
44 |
45 | - Document(ppt、word等)
46 | - Video(视频类型)
47 | - Work(没有题库，暂且不整)
48 |
49 | ### :three:可自定义视频类型任务点观看速率
50 |
51 | - 倍速有风险,谨慎而为之
52 |
53 | ## :orange_book:使用教程
54 |
55 | ### :one:可执行文件运行(小白推荐,不稳定)
56 |
57 | - 教程:待跟新
58 |
59 | ### :two:源码运行(更稳定)
60 |
61 | 1. 准备Python =3.6
62 | 2. git clone 项目至本地
63 | 3. pip install -r requirements.txt
64 | 4. python main.py 运行程序
65 |
66 | ## :warning: 免责声明
67 | - 本代码遵循 [GPL-3.0 License](https://github.com/Samueli924/chaoxing/blob/main/LICENSE)协议，允许**开源/免费使用和引用/修改/衍生代码的开源/免费使用**，不允许**修改和衍生的代码作为闭源的商业软件发布和销售**，禁止**使用本代码盈利**，以此代码为基础的程序**必须**同样遵守[GPL-3.0 License](https://github.com/Samueli924/chaoxing/blob/main/LICENSE)协议
68 | - 本代码仅用于**学习讨论**，禁止**用于盈利**
69 | - 他人或组织使用本代码进行的任何**违法行为**与本人无关
70 |
--------------------------------------------------------------------------------
/main.py:
--------------------------------------------------------------------------------
1 | import json, time, hashlib, base64, requests, re
2 | from urllib import parse
3 | from bs4 import BeautifulSoup
4 | from rich import print as rprint
5 | from rich.panel import Panel
6 | from rich.console import Console
7 | from rich.table import Table
8 | from alive_progress import alive_bar
9 |
10 | console = Console()
11 |
12 | # 所有课程列表
13 | courses_list = []
14 | post_time = 1
15 |
16 |
17 | def print_course():
18 | course_table = Table()
19 | course_table.add_column("序号", justify="center", style="cyan")
20 | course_table.add_column("名称", justify="center", no_wrap=True)
21 | course_table.add_column("状态", justify="center")
22 | for index, course in enumerate(courses_list):
23 | if (index < 10):
24 | index_str = "0" + str(index)
25 | else:
26 | index_str = str(index)
27 | course_table.add_row(index_str, course['course_name'], "未结课")
28 | return course_table
29 |
30 |
31 | # 获取所有课程名称
32 | def get_course_unit():
33 | console.rule("正在获取所有课程")
34 | course_heades = {
35 | "Content-Type": "application/x-www-form-urlencoded",
36 | 'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36 QIHU 360SE'
37 | }
38 | course_data = {
39 | "courseType": "1",
40 | "courseFolderId": "0",
41 | "baseEducation": "0",
42 | "courseFolderSize": "0"
43 | }
44 | course_url = "https://mooc1-1.chaoxing.com/visit/courselistdata"
45 |
46 | course_response = requests.post(url=course_url, headers=course_heades, cookies=cookies, data=parse.urlencode(course_data))
47 | soup = BeautifulSoup(course_response.content.decode("utf8"), 'html5lib')
48 | list = soup.find_all(attrs={"class", "color1"})
49 | for i in list:
50 | query = parse.parse_qs(parse.urlparse(i.get("href"))[4])
51 | courseid = query["courseid"][0]
52 | clazzid = query["clazzid"][0]
53 | cpi = query["cpi"][0]
54 | courses_list.append({"course_name": i.span.string, "courseId": courseid, "clazzid": clazzid, "cpi": cpi})
55 | # 准备打印课程
56 | course_table = print_course()
57 | console.print(course_table)
58 | console.rule("所有课程获取完成")
59 |
60 |
61 | # 获取当前课程所有章节信息,以及当前章节总体完成状态
62 | def get_chapterUnit(courseid, clazzid, cpi):
63 | # 所有任务章节情况
64 | classUrl = f"https://mooc2-ans.chaoxing.com/mycourse/studentcourse?courseid={courseid}&clazzid={clazzid}&cpi={cpi}&ut=s"
65 | missonResponse = requests.get(url=classUrl, headers=headers, cookies=cookies)
66 | soupMisson = BeautifulSoup(missonResponse.content.decode('utf8'), 'html5lib')
67 | # 所有章节
68 | chapter_unit = soupMisson.find_all("div", class_="chapter_unit")
69 | for chapter_index, chapter in enumerate(chapter_unit):
70 | chapter_title = chapter.find(attrs={"class", "chapter_item"}).find(attrs={"class", "catalog_name"}).span["title"]
71 | rprint(Panel(chapter_title, style="bright_blue"))
72 | try:
73 | chapter_child_unit = chapter.find(attrs={"class", "catalog_level"}).find_all("li")
74 | for chapter_child_index, chapter_child in enumerate(chapter_child_unit):
75 | chapter_child_title = chapter_child.find(attrs={"class", "chapter_item"})["title"]
76 | chapter_child_id = chapter_child.find(attrs={"class", "chapter_item"})["onclick"]
77 | str = chapter_child_id[7:]
78 | str = str[:-2]
79 | # 是否完成
80 | if (chapter_child.find(attrs={"class", "chapter_item"}).find(attrs={"class": "bntHoverTips"}).contents[0] == "已完成"):
81 | print("{}.{}:{}:[章节ID:{}]".format(chapter_index + 1, chapter_child_index + 1, chapter_child_title, str.rsplit("', '")[1]))
82 | console.print("[该章节已全部已完成]\n", style="green", )
83 | else:
84 | print("{}.{}:{}:[章节ID:{}]".format(chapter_index + 1, chapter_child_index + 1, chapter_child_title, str.rsplit("', '")[1]))
85 | get_missionData(courseid, clazzid, str.rsplit("', '")[1], cpi)
86 | except Exception as e:
87 | print("没有子章节")
88 |
89 |
90 | # 获取当前章节当前任务块所有任务点信息
91 | def get_missionData(courseid, clazzid, knowledgeid, cpi):
92 | # 块节点,不知道这个章节有多少个快,+1去请求,直到拿不到mArg,就返回
93 | # 当Num=0,mArg都取不到,说明该章节不存在任何任务点
94 |
95 | for missionParts_index in range(5):
96 | url = "https://mooc1-1.chaoxing.com/knowledge/cards?clazzid={}&courseid={}&knowledgeid={}&num={}&ut=s&cpi={}&v=20160407-1".format(clazzid, courseid, knowledgeid, missionParts_index, cpi)
97 | response = requests.get(url=url, headers=headers, cookies=cookies)
98 | soup = BeautifulSoup(response.content.decode("utf8"), "html5lib")
99 | # 节点任务的重要信息dict
100 | if (missionParts_index == 0):
101 | # setlog 需要的encode
102 | try:
103 | enc = re.search(r"var _from = '(.*?)';", response.content.decode("utf8"), flags=re.M).group(1).split("_")[3]
104 | url = f"https://mooc1.chaoxing.com/mycourse/studentstudy?chapterId={knowledgeid}&courseId={courseid}&clazzid={clazzid}&enc={enc}&mooc2=1&cpi={cpi}"
105 | res = BeautifulSoup(requests.get(url=url, headers=headers, cookies=cookies).content.decode('utf8'), 'html5lib')
106 | try:
107 | headers1 = {
108 | 'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36 QIHU 360SE',
109 | "Referer": url + "&openc=11628298bef5833a1b9464ec954f691d",
110 | "Sec-Fetch-Dest": "script",
111 | "Host": "fystat-ans.chaoxing.com",
112 | "sec-ch-ua-mobile": "?0"
113 | }
114 | for src in res.find_all("script"):
115 | if ("https://fystat-ans.chaoxing.com/log/setlog?" in src["src"]):
116 | temp = src["src"] + f"&_={int(round(time.time() * 1000))}"
117 | res = requests.get(temp, headers=headers1, cookies=cookies)
118 | print("[该章节完成学习打卡]")
119 | except:
120 | pass
121 | except:
122 | console.log("setLog错误")
123 | pass
124 | try:
125 | missonData = json.loads(re.search(r'mArg =(.*?);(\s\S)catch', soup.body.find_all("script")[0].string, flags=re.M).group(1))
126 |
127 | # print("当前章节子节点{}有{}个任务点".format(missionParts_index, len(missonData["attachments"])))
128 | for missonDataItem_index, missonDataItem in enumerate(missonData["attachments"]):
129 | # 捕捉异常 有的没有类型,插入可能是图片 很恶心
130 | try:
131 | if (missonDataItem["type"] == "video"):
132 | def is_job():
133 | try:
134 | temp = missonDataItem["jobid"]
135 | console.print("检测到任务:[yellow]Viedo[not b not uu red]\t[未完成]")
136 | get_videoMission_data(missonDataItem, missonData["defaults"], missionParts_index, missonDataItem_index)
137 | except:
138 | console.print("检测到任务:[yellow]Viedo[not b not uu blue]\t[非任务]")
139 |
140 | # 判断完成了没
141 | try:
142 | if (missonDataItem["isPassed"]):
143 | console.print("检测到任务:[yellow]Viedo[not b not uu green]\t[已完成]")
144 | else:
145 | # 未完成
146 | is_job()
147 | except:
148 | # 报错就是未完成
149 | is_job()
150 | elif ((missonDataItem["type"] == "document")):
151 | # 加层判断 pdf不做处理 虽然有任务id 但是不作为任务点
152 | if (missonDataItem["property"]['type'] != ".pdf"):
153 | def is_job():
154 | try:
155 | temp = missonDataItem["jobid"]
156 | console.print("检测到任务:[yellow]Document[not b not uu red]\t[未完成]")
157 | post_document(missonDataItem, missonData["defaults"], missionParts_index, missonDataItem_index)
158 | except:
159 | console.print("检测到任务:[yellow]Document[not b not uu blue]\t[非任务]")
160 |
161 | # 判断完成了没
162 | try:
163 | if (missonDataItem["isPassed"]):
164 | console.print("检测到任务:[yellow]Document[not b not uu green]\t[已完成]")
165 | else:
166 | # 未完成
167 | is_job()
168 | except:
169 | # 报错就是未完成
170 | is_job()
171 | else:
172 | # 题目类型workid
173 | console.print("检测到任务:[yellow]Work[red]\t[已跳过]")
174 | except:
175 | console.print("检测到任务:[yellow]混淆任务[red]\t[已过滤]")
176 |
177 | except Exception as e:
178 | # if (missionParts_index == 0):
179 | # print("-当前章节所有任务点遍历完成-")
180 | # else:
181 | # print("-当前章节所有任务点遍历完成-")
182 | continue
183 | console.print("[cyan][当前章节所有任务点遍历完成]\n")
184 |
185 |
186 | # 获取video类型任务点信息
187 | def get_videoMission_data(missonDataItem, missonData_defaults, missionParts_index, missonDataItem_index):
188 | # missionParts_index:当前章节任务块索引
189 | # missonDataItem_index:当前任务块视频任务索引
190 | headers = {
191 | "Referer": "https://mooc1.chaoxing.com/ananas/modules/video/index.html?v=2022-0406-1945",
192 | 'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36 QIHU 360SE'
193 | }
194 | url = "https://mooc1.chaoxing.com/ananas/status/{}".format(missonDataItem["objectId"])
195 | response = requests.get(url=url, cookies=cookies, headers=headers)
196 | video_data = json.loads(response.content.decode('utf8'))
197 | start_videoMission(missonDataItem, missonData_defaults, video_data, missionParts_index, missonDataItem_index)
198 |
199 |
200 | # 开始刷课
201 | def start_videoMission(missonDataItem, missonData_defaults, video_data, missionParts_index, missonDataItem_index):
202 | # missionParts_index:当前章节任务块索引
203 | # missonDataItem_index:当前任务块视频任务索引
204 | response_json = {"isPassed": "false"}
205 |
206 | def get_test(courseid, clazzid, knowledgeid, cpi):
207 | url = "https://mooc1-1.chaoxing.com/knowledge/cards?clazzid={}&courseid={}&knowledgeid={}&num={}&ut=s&cpi={}&v=20160407-1".format(clazzid, courseid, knowledgeid, missionParts_index, cpi)
208 | response = requests.get(url=url, headers=headers, cookies=cookies)
209 | soup = BeautifulSoup(response.content.decode("utf8"), "html5lib")
210 | missonData = json.loads(re.search(r'mArg =(.*?);(\s\S)catch', soup.body.find_all("script")[0].string, flags=re.M).group(1))
211 | current_missonDataItem = missonData["attachments"][missonDataItem_index]
212 | # 加个判断,第一次看视频,检测服务器保存的进度为空
213 | # try:
214 | # console.print(f'[完成提交进度]{current_missonDataItem["playTime"]}ms', justify="center")
215 | # except:
216 | # console.print(f'[完成提交进度]{0}ms', justify="center")
217 |
218 | def post(isdrag):
219 | # [clazzId][userid][jobid][objectid][playingTime*1000][d_yHJ!$pdA~5][duration*1000][0_duration] md5
220 | encStr = '[{}][{}][{}][{}][{}][{}][{}][{}]'
221 | encStr = encStr.format(missonData_defaults["clazzId"], missonData_defaults["userid"], missonDataItem['jobid'], missonDataItem["objectId"], playTime, "d_yHJ!$pdA~5",
222 | int(video_data['duration']) * 1000, "0_" + str(video_data['duration']))
223 | md5 = hashlib.md5(encStr.encode("utf8"))
224 | enc = md5.hexdigest()
225 | try:
226 | rt = missonDataItem["property"]['rt']
227 | except:
228 | rt = "0.9"
229 | data = {
230 | "clazzId": missonData_defaults["clazzId"], # 获取到
231 | "playingTime": int(int(playTime) / 1000), # 当前播放到的时间 秒
232 | "duration": video_data['duration'], # 视频总时长 秒
233 | "clipTime": "0_" + str(video_data['duration']), # 视频总时长 秒
234 | "objectId": missonDataItem["objectId"], # 获取到
235 | "otherInfo": missonDataItem["otherInfo"], # 获取到
236 | "jobid": missonDataItem['jobid'], # 获取到
237 | "userid": missonData_defaults["userid"], # 获取到
238 | "isdrag": isdrag, # 固定 3首次开始播放 2暂停 0播放自己提交
239 | "view": "pc", # 固定
240 | "enc": enc, # md5加密
241 | "rt": rt, # 固定
242 | "dtype": "Video", # 固定
243 | "_t": int(round(time.time() * 1000)) # 时间戳 固定
244 | }
245 | lt = []
246 | for k, v in data.items():
247 | lt.append(k + '=' + str(v))
248 | query_string = '&'.join(lt)
249 | url = "https://mooc1.chaoxing.com/multimedia/log/a/{}/{}?{}".format(missonData_defaults['cpi'], video_data["dtoken"], query_string)
250 | response = requests.get(url=url, cookies=cookies, headers=headers)
251 | try:
252 | # 加个判断 防止提交进度出问题，好定位bug
253 | rjson = json.loads(response.content.decode('utf8'))
254 | if (rjson["isPassed"]):
255 | # 已经通过了
256 | return True
257 | else:
258 | return False
259 | except:
260 | # t =math.floor(2147483647*random.random())
261 | # verify_soup = BeautifulSoup(response.content.decode('utf8'), "html5lib")
262 | # print(verify_soup.find("img"))
263 | # img_headers = {
264 | # "Accept": "image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8",
265 | # "Accept-Encoding": "gzip, deflate, br",
266 | # "Cache-Control": "no-cache",
267 | # "Connection": "keep-alive",
268 | # "Host": "mooc1-2.chaoxing.com",
269 | # "Pragma": "no-cache",
270 | # "sec-ch-ua-mobile": "?0",
271 | # "sec-ch-ua-platform": "\"Windows\"",
272 | # "Sec-Fetch-Dest": "image",
273 | # "Sec-Fetch-Mode": "no-cors",
274 | # "Sec-Fetch-Site": "same-origin",
275 | # "Referer": "https://mooc1-2.chaoxing.com/antispiderShowVerify.ac",
276 | # "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.64 Safari/537.36 Edg/101.0.1210.47"
277 | # }
278 | # imgUrl = f"https://mooc1-2.chaoxing.com/processVerifyPng.ac?t={math.floor(random.random() * 2147483647)}"
279 | # res = requests.get(imgUrl, cookies=cookies, headers=img_headers)
280 | # print(res.content)
281 | # with open("./code.png", "wb") as f:
282 | # r = requests.get(imgUrl)
283 | # f.write(r.content)
284 | # f.close()
285 |
286 | # 暴力破解过验证码
287 | console.print("[red][系统拦截]:拦截到验证码检测,已经跳过验证码检测...")
288 | # get_url = f"https://mooc1-2.chaoxing.com/html/processVerify.ac?app=0&ucode={verify_code}"
289 | # print(requests.get(get_url, cookies=cookies, headers=headers).content.decode("utf8"))
290 | return False
291 |
292 | headers = {
293 | "Referer": "https://mooc1.chaoxing.com/ananas/modules/video/index.html?v=2022-0406-1945",
294 | 'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36 QIHU 360SE'
295 | }
296 | try:
297 | playTime = int(missonDataItem["playTime"])
298 | except:
299 | playTime = 0
300 |
301 | try:
302 | isPassed = missonDataItem["isPassed"]
303 | except:
304 | isPassed = False
305 |
306 | if (not isPassed):
307 | global post_time
308 |
309 | console.rule("[bold green]开 始 刷 课")
310 | console.print(f"{playTime}ms/{int(video_data['duration']) * 1000}ms", style="green", justify="center")
311 | console.print(f"{video_data['filename']}", style="green", justify="center")
312 | isPassed_count = 0
313 | with alive_bar(int(video_data['duration']) * 1000, manual=True) as bar:
314 | while True:
315 | # 60秒提交一次 模拟自动提交 isdrag=0
316 | # 睡之前判断下还剩多少时长,小于60之内直接睡剩下的时间
317 | if (int(video_data["duration"] * 1000) - int(playTime) < 1000 * post_time):
318 | time.sleep(1)
319 | playTime += int(video_data["duration"] * 1000) - int(playTime)
320 | else:
321 | time.sleep(1)
322 | playTime += 1000 * post_time
323 | isPassed_bool = post("0")
324 | # console.print("[已提交进度]{}ms/{}ms".format(playTime, int(video_data["duration"] * 1000)), justify="center")
325 | if (isPassed_bool):
326 | # 说明已经返回isPassed为True了,为了防止数据不准,当5次返回都true时,说明完成了,记录一下测试,只有有一次false就清理
327 | isPassed_count += 1
328 | if (isPassed_count == 10):
329 | break
330 | else:
331 | console.print(f"当前视频已经完成,正在进行{isPassed_count}次检测[red](需要完成10测检测即完成当前任务点)", style="blue")
332 | else:
333 | isPassed_count = 0
334 | bar(playTime / int(video_data["duration"] * 1000))
335 | console.rule("[bold red]学 习 完 成")
336 |
337 |
338 | def post_document(missonDataItem, missonData_defaults, missionParts_index, missonDataItem_index):
339 | console.rule("开始文档类型提交")
340 | console.print(f'文档名称:{missonDataItem["property"]["name"]}', justify="center")
341 | # document类型提交
342 | headers = {
343 | "Referer": "https://mooc1.chaoxing.com/ananas/modules/pdf/index.html?v=2022-0218-1135",
344 | "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54"
345 | }
346 | data = {
347 | "jobid": missonDataItem["jobid"],
348 | "knowledgeid": missonData_defaults["knowledgeid"],
349 | "courseid": missonData_defaults["courseid"],
350 | "clazzid": missonData_defaults["clazzId"],
351 | "jtoken": missonDataItem["jtoken"],
352 | "_dc": int(round(time.time() * 1000))
353 | }
354 | url = f"https://mooc1.chaoxing.com/ananas/job/document?jobid={data['jobid']}&knowledgeid={data['knowledgeid']}&courseid={data['courseid']}&clazzid={data['clazzid']}&jtoken={data['jtoken']}&_dc={data['_dc']}"
355 |
356 | # 检查文档类型学习提交是否通过
357 | while True:
358 |
359 | try:
360 | res = requests.get(url=url, cookies=cookies, headers=headers)
361 | if (json.loads(res.content.decode("utf8"))["status"]):
362 | console.print(f'[blue][{time.strftime("%H:%M", time.localtime())}][green]任务点提交成功!')
363 | console.rule("完成文档类型提交")
364 | break
365 | except:
366 | print("提交异常,即将重新尝试提交")
367 |
368 |
369 | def login(uname, passward):
370 | headers = {
371 | 'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36 QIHU 360SE',
372 | }
373 | login = requests.get("http://passport2.chaoxing.com/login?fid=&newversion=true&refer=http://i.chaoxing.com", headers=headers)
374 | global cookies
375 | cookies = login.cookies
376 | login_heades = {
377 | "Content-Type": "application/x-www-form-urlencoded",
378 | 'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36 QIHU 360SE',
379 | # 'Referer': 'http://passport2.chaoxing.com/login?fid=&newversion=true&refer=http://i.chaoxing.com',
380 | # "Origin": "http://passport2.chaoxing.com"
381 | }
382 | login_url = "http://passport2.chaoxing.com/fanyalogin"
383 | login_data = {
384 | "fid": "-1",
385 | "uname": uname,
386 | # "password": base64.b64encode(passward.encode("utf8")),
387 | "password": passward,
388 | "refer": "http://i.chaoxing.com",
389 | "t": "true",
390 | }
391 | login_response = requests.post(url=login_url, headers=login_heades, cookies=cookies, data=parse.urlencode(login_data))
392 | cookies.update(login_response.cookies)
393 | get_course_unit()
394 | try:
395 | return login_response.json()["status"]
396 | except:
397 | return False
398 |
399 |
400 | # 登录
401 | headers = {
402 | 'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36 QIHU 360SE',
403 | }
404 | cookies = ""
405 |
406 | while True:
407 | uname = input("请输入账号(手机号):")
408 | passward = input("请输入密码(des加密):")
409 | if (login(uname, passward)):
410 | break
411 | else:
412 | console.print("[red][登录失败,请尝试重新登录]")
413 | console.print("[red][登录失败已修复,请查看github使用说明]")
414 | while True:
415 | command = input("输入需要刷课的课程序号:")
416 | try:
417 | try:
418 | speed = int(input("请输入当前学习视频倍速:"))
419 | post_time = speed
420 | print(f"当前倍速为:{speed}x")
421 | except:
422 | print("输入有问题,启用默认倍速:1x")
423 | post_time = 1
424 | get_chapterUnit(courses_list[int(command)]["courseId"], courses_list[int(command)]["clazzid"], courses_list[int(command)]["cpi"])
425 | console.print(print_course())
426 |
427 | except:
428 | print("指令出错")
429 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | GNU GENERAL PUBLIC LICENSE
2 | Version 3, 29 June 2007
3 |
4 | Copyright (C) 2007 Free Software Foundation, Inc.
5 | Everyone is permitted to copy and distribute verbatim copies
6 | of this license document, but changing it is not allowed.
7 |
8 | Preamble
9 |
10 | The GNU General Public License is a free, copyleft license for
11 | software and other kinds of works.
12 |
13 | The licenses for most software and other practical works are designed
14 | to take away your freedom to share and change the works. By contrast,
15 | the GNU General Public License is intended to guarantee your freedom to
16 | share and change all versions of a program--to make sure it remains free
17 | software for all its users. We, the Free Software Foundation, use the
18 | GNU General Public License for most of our software; it applies also to
19 | any other work released this way by its authors. You can apply it to
20 | your programs, too.
21 |
22 | When we speak of free software, we are referring to freedom, not
23 | price. Our General Public Licenses are designed to make sure that you
24 | have the freedom to distribute copies of free software (and charge for
25 | them if you wish), that you receive source code or can get it if you
26 | want it, that you can change the software or use pieces of it in new
27 | free programs, and that you know you can do these things.
28 |
29 | To protect your rights, we need to prevent others from denying you
30 | these rights or asking you to surrender the rights. Therefore, you have
31 | certain responsibilities if you distribute copies of the software, or if
32 | you modify it: responsibilities to respect the freedom of others.
33 |
34 | For example, if you distribute copies of such a program, whether
35 | gratis or for a fee, you must pass on to the recipients the same
36 | freedoms that you received. You must make sure that they, too, receive
37 | or can get the source code. And you must show them these terms so they
38 | know their rights.
39 |
40 | Developers that use the GNU GPL protect your rights with two steps:
41 | (1) assert copyright on the software, and (2) offer you this License
42 | giving you legal permission to copy, distribute and/or modify it.
43 |
44 | For the developers' and authors' protection, the GPL clearly explains
45 | that there is no warranty for this free software. For both users' and
46 | authors' sake, the GPL requires that modified versions be marked as
47 | changed, so that their problems will not be attributed erroneously to
48 | authors of previous versions.
49 |
50 | Some devices are designed to deny users access to install or run
51 | modified versions of the software inside them, although the manufacturer
52 | can do so. This is fundamentally incompatible with the aim of
53 | protecting users' freedom to change the software. The systematic
54 | pattern of such abuse occurs in the area of products for individuals to
55 | use, which is precisely where it is most unacceptable. Therefore, we
56 | have designed this version of the GPL to prohibit the practice for those
57 | products. If such problems arise substantially in other domains, we
58 | stand ready to extend this provision to those domains in future versions
59 | of the GPL, as needed to protect the freedom of users.
60 |
61 | Finally, every program is threatened constantly by software patents.
62 | States should not allow patents to restrict development and use of
63 | software on general-purpose computers, but in those that do, we wish to
64 | avoid the special danger that patents applied to a free program could
65 | make it effectively proprietary. To prevent this, the GPL assures that
66 | patents cannot be used to render the program non-free.
67 |
68 | The precise terms and conditions for copying, distribution and
69 | modification follow.
70 |
71 | TERMS AND CONDITIONS
72 |
73 | 0. Definitions.
74 |
75 | "This License" refers to version 3 of the GNU General Public License.
76 |
77 | "Copyright" also means copyright-like laws that apply to other kinds of
78 | works, such as semiconductor masks.
79 |
80 | "The Program" refers to any copyrightable work licensed under this
81 | License. Each licensee is addressed as "you". "Licensees" and
82 | "recipients" may be individuals or organizations.
83 |
84 | To "modify" a work means to copy from or adapt all or part of the work
85 | in a fashion requiring copyright permission, other than the making of an
86 | exact copy. The resulting work is called a "modified version" of the
87 | earlier work or a work "based on" the earlier work.
88 |
89 | A "covered work" means either the unmodified Program or a work based
90 | on the Program.
91 |
92 | To "propagate" a work means to do anything with it that, without
93 | permission, would make you directly or secondarily liable for
94 | infringement under applicable copyright law, except executing it on a
95 | computer or modifying a private copy. Propagation includes copying,
96 | distribution (with or without modification), making available to the
97 | public, and in some countries other activities as well.
98 |
99 | To "convey" a work means any kind of propagation that enables other
100 | parties to make or receive copies. Mere interaction with a user through
101 | a computer network, with no transfer of a copy, is not conveying.
102 |
103 | An interactive user interface displays "Appropriate Legal Notices"
104 | to the extent that it includes a convenient and prominently visible
105 | feature that (1) displays an appropriate copyright notice, and (2)
106 | tells the user that there is no warranty for the work (except to the
107 | extent that warranties are provided), that licensees may convey the
108 | work under this License, and how to view a copy of this License. If
109 | the interface presents a list of user commands or options, such as a
110 | menu, a prominent item in the list meets this criterion.
111 |
112 | 1. Source Code.
113 |
114 | The "source code" for a work means the preferred form of the work
115 | for making modifications to it. "Object code" means any non-source
116 | form of a work.
117 |
118 | A "Standard Interface" means an interface that either is an official
119 | standard defined by a recognized standards body, or, in the case of
120 | interfaces specified for a particular programming language, one that
121 | is widely used among developers working in that language.
122 |
123 | The "System Libraries" of an executable work include anything, other
124 | than the work as a whole, that (a) is included in the normal form of
125 | packaging a Major Component, but which is not part of that Major
126 | Component, and (b) serves only to enable use of the work with that
127 | Major Component, or to implement a Standard Interface for which an
128 | implementation is available to the public in source code form. A
129 | "Major Component", in this context, means a major essential component
130 | (kernel, window system, and so on) of the specific operating system
131 | (if any) on which the executable work runs, or a compiler used to
132 | produce the work, or an object code interpreter used to run it.
133 |
134 | The "Corresponding Source" for a work in object code form means all
135 | the source code needed to generate, install, and (for an executable
136 | work) run the object code and to modify the work, including scripts to
137 | control those activities. However, it does not include the work's
138 | System Libraries, or general-purpose tools or generally available free
139 | programs which are used unmodified in performing those activities but
140 | which are not part of the work. For example, Corresponding Source
141 | includes interface definition files associated with source files for
142 | the work, and the source code for shared libraries and dynamically
143 | linked subprograms that the work is specifically designed to require,
144 | such as by intimate data communication or control flow between those
145 | subprograms and other parts of the work.
146 |
147 | The Corresponding Source need not include anything that users
148 | can regenerate automatically from other parts of the Corresponding
149 | Source.
150 |
151 | The Corresponding Source for a work in source code form is that
152 | same work.
153 |
154 | 2. Basic Permissions.
155 |
156 | All rights granted under this License are granted for the term of
157 | copyright on the Program, and are irrevocable provided the stated
158 | conditions are met. This License explicitly affirms your unlimited
159 | permission to run the unmodified Program. The output from running a
160 | covered work is covered by this License only if the output, given its
161 | content, constitutes a covered work. This License acknowledges your
162 | rights of fair use or other equivalent, as provided by copyright law.
163 |
164 | You may make, run and propagate covered works that you do not
165 | convey, without conditions so long as your license otherwise remains
166 | in force. You may convey covered works to others for the sole purpose
167 | of having them make modifications exclusively for you, or provide you
168 | with facilities for running those works, provided that you comply with
169 | the terms of this License in conveying all material for which you do
170 | not control copyright. Those thus making or running the covered works
171 | for you must do so exclusively on your behalf, under your direction
172 | and control, on terms that prohibit them from making any copies of
173 | your copyrighted material outside their relationship with you.
174 |
175 | Conveying under any other circumstances is permitted solely under
176 | the conditions stated below. Sublicensing is not allowed; section 10
177 | makes it unnecessary.
178 |
179 | 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
180 |
181 | No covered work shall be deemed part of an effective technological
182 | measure under any applicable law fulfilling obligations under article
183 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or
184 | similar laws prohibiting or restricting circumvention of such
185 | measures.
186 |
187 | When you convey a covered work, you waive any legal power to forbid
188 | circumvention of technological measures to the extent such circumvention
189 | is effected by exercising rights under this License with respect to
190 | the covered work, and you disclaim any intention to limit operation or
191 | modification of the work as a means of enforcing, against the work's
192 | users, your or third parties' legal rights to forbid circumvention of
193 | technological measures.
194 |
195 | 4. Conveying Verbatim Copies.
196 |
197 | You may convey verbatim copies of the Program's source code as you
198 | receive it, in any medium, provided that you conspicuously and
199 | appropriately publish on each copy an appropriate copyright notice;
200 | keep intact all notices stating that this License and any
201 | non-permissive terms added in accord with section 7 apply to the code;
202 | keep intact all notices of the absence of any warranty; and give all
203 | recipients a copy of this License along with the Program.
204 |
205 | You may charge any price or no price for each copy that you convey,
206 | and you may offer support or warranty protection for a fee.
207 |
208 | 5. Conveying Modified Source Versions.
209 |
210 | You may convey a work based on the Program, or the modifications to
211 | produce it from the Program, in the form of source code under the
212 | terms of section 4, provided that you also meet all of these conditions:
213 |
214 | a) The work must carry prominent notices stating that you modified
215 | it, and giving a relevant date.
216 |
217 | b) The work must carry prominent notices stating that it is
218 | released under this License and any conditions added under section
219 | 7. This requirement modifies the requirement in section 4 to
220 | "keep intact all notices".
221 |
222 | c) You must license the entire work, as a whole, under this
223 | License to anyone who comes into possession of a copy. This
224 | License will therefore apply, along with any applicable section 7
225 | additional terms, to the whole of the work, and all its parts,
226 | regardless of how they are packaged. This License gives no
227 | permission to license the work in any other way, but it does not
228 | invalidate such permission if you have separately received it.
229 |
230 | d) If the work has interactive user interfaces, each must display
231 | Appropriate Legal Notices; however, if the Program has interactive
232 | interfaces that do not display Appropriate Legal Notices, your
233 | work need not make them do so.
234 |
235 | A compilation of a covered work with other separate and independent
236 | works, which are not by their nature extensions of the covered work,
237 | and which are not combined with it such as to form a larger program,
238 | in or on a volume of a storage or distribution medium, is called an
239 | "aggregate" if the compilation and its resulting copyright are not
240 | used to limit the access or legal rights of the compilation's users
241 | beyond what the individual works permit. Inclusion of a covered work
242 | in an aggregate does not cause this License to apply to the other
243 | parts of the aggregate.
244 |
245 | 6. Conveying Non-Source Forms.
246 |
247 | You may convey a covered work in object code form under the terms
248 | of sections 4 and 5, provided that you also convey the
249 | machine-readable Corresponding Source under the terms of this License,
250 | in one of these ways:
251 |
252 | a) Convey the object code in, or embodied in, a physical product
253 | (including a physical distribution medium), accompanied by the
254 | Corresponding Source fixed on a durable physical medium
255 | customarily used for software interchange.
256 |
257 | b) Convey the object code in, or embodied in, a physical product
258 | (including a physical distribution medium), accompanied by a
259 | written offer, valid for at least three years and valid for as
260 | long as you offer spare parts or customer support for that product
261 | model, to give anyone who possesses the object code either (1) a
262 | copy of the Corresponding Source for all the software in the
263 | product that is covered by this License, on a durable physical
264 | medium customarily used for software interchange, for a price no
265 | more than your reasonable cost of physically performing this
266 | conveying of source, or (2) access to copy the
267 | Corresponding Source from a network server at no charge.
268 |
269 | c) Convey individual copies of the object code with a copy of the
270 | written offer to provide the Corresponding Source. This
271 | alternative is allowed only occasionally and noncommercially, and
272 | only if you received the object code with such an offer, in accord
273 | with subsection 6b.
274 |
275 | d) Convey the object code by offering access from a designated
276 | place (gratis or for a charge), and offer equivalent access to the
277 | Corresponding Source in the same way through the same place at no
278 | further charge. You need not require recipients to copy the
279 | Corresponding Source along with the object code. If the place to
280 | copy the object code is a network server, the Corresponding Source
281 | may be on a different server (operated by you or a third party)
282 | that supports equivalent copying facilities, provided you maintain
283 | clear directions next to the object code saying where to find the
284 | Corresponding Source. Regardless of what server hosts the
285 | Corresponding Source, you remain obligated to ensure that it is
286 | available for as long as needed to satisfy these requirements.
287 |
288 | e) Convey the object code using peer-to-peer transmission, provided
289 | you inform other peers where the object code and Corresponding
290 | Source of the work are being offered to the general public at no
291 | charge under subsection 6d.
292 |
293 | A separable portion of the object code, whose source code is excluded
294 | from the Corresponding Source as a System Library, need not be
295 | included in conveying the object code work.
296 |
297 | A "User Product" is either (1) a "consumer product", which means any
298 | tangible personal property which is normally used for personal, family,
299 | or household purposes, or (2) anything designed or sold for incorporation
300 | into a dwelling. In determining whether a product is a consumer product,
301 | doubtful cases shall be resolved in favor of coverage. For a particular
302 | product received by a particular user, "normally used" refers to a
303 | typical or common use of that class of product, regardless of the status
304 | of the particular user or of the way in which the particular user
305 | actually uses, or expects or is expected to use, the product. A product
306 | is a consumer product regardless of whether the product has substantial
307 | commercial, industrial or non-consumer uses, unless such uses represent
308 | the only significant mode of use of the product.
309 |
310 | "Installation Information" for a User Product means any methods,
311 | procedures, authorization keys, or other information required to install
312 | and execute modified versions of a covered work in that User Product from
313 | a modified version of its Corresponding Source. The information must
314 | suffice to ensure that the continued functioning of the modified object
315 | code is in no case prevented or interfered with solely because
316 | modification has been made.
317 |
318 | If you convey an object code work under this section in, or with, or
319 | specifically for use in, a User Product, and the conveying occurs as
320 | part of a transaction in which the right of possession and use of the
321 | User Product is transferred to the recipient in perpetuity or for a
322 | fixed term (regardless of how the transaction is characterized), the
323 | Corresponding Source conveyed under this section must be accompanied
324 | by the Installation Information. But this requirement does not apply
325 | if neither you nor any third party retains the ability to install
326 | modified object code on the User Product (for example, the work has
327 | been installed in ROM).
328 |
329 | The requirement to provide Installation Information does not include a
330 | requirement to continue to provide support service, warranty, or updates
331 | for a work that has been modified or installed by the recipient, or for
332 | the User Product in which it has been modified or installed. Access to a
333 | network may be denied when the modification itself materially and
334 | adversely affects the operation of the network or violates the rules and
335 | protocols for communication across the network.
336 |
337 | Corresponding Source conveyed, and Installation Information provided,
338 | in accord with this section must be in a format that is publicly
339 | documented (and with an implementation available to the public in
340 | source code form), and must require no special password or key for
341 | unpacking, reading or copying.
342 |
343 | 7. Additional Terms.
344 |
345 | "Additional permissions" are terms that supplement the terms of this
346 | License by making exceptions from one or more of its conditions.
347 | Additional permissions that are applicable to the entire Program shall
348 | be treated as though they were included in this License, to the extent
349 | that they are valid under applicable law. If additional permissions
350 | apply only to part of the Program, that part may be used separately
351 | under those permissions, but the entire Program remains governed by
352 | this License without regard to the additional permissions.
353 |
354 | When you convey a copy of a covered work, you may at your option
355 | remove any additional permissions from that copy, or from any part of
356 | it. (Additional permissions may be written to require their own
357 | removal in certain cases when you modify the work.) You may place
358 | additional permissions on material, added by you to a covered work,
359 | for which you have or can give appropriate copyright permission.
360 |
361 | Notwithstanding any other provision of this License, for material you
362 | add to a covered work, you may (if authorized by the copyright holders of
363 | that material) supplement the terms of this License with terms:
364 |
365 | a) Disclaiming warranty or limiting liability differently from the
366 | terms of sections 15 and 16 of this License; or
367 |
368 | b) Requiring preservation of specified reasonable legal notices or
369 | author attributions in that material or in the Appropriate Legal
370 | Notices displayed by works containing it; or
371 |
372 | c) Prohibiting misrepresentation of the origin of that material, or
373 | requiring that modified versions of such material be marked in
374 | reasonable ways as different from the original version; or
375 |
376 | d) Limiting the use for publicity purposes of names of licensors or
377 | authors of the material; or
378 |
379 | e) Declining to grant rights under trademark law for use of some
380 | trade names, trademarks, or service marks; or
381 |
382 | f) Requiring indemnification of licensors and authors of that
383 | material by anyone who conveys the material (or modified versions of
384 | it) with contractual assumptions of liability to the recipient, for
385 | any liability that these contractual assumptions directly impose on
386 | those licensors and authors.
387 |
388 | All other non-permissive additional terms are considered "further
389 | restrictions" within the meaning of section 10. If the Program as you
390 | received it, or any part of it, contains a notice stating that it is
391 | governed by this License along with a term that is a further
392 | restriction, you may remove that term. If a license document contains
393 | a further restriction but permits relicensing or conveying under this
394 | License, you may add to a covered work material governed by the terms
395 | of that license document, provided that the further restriction does
396 | not survive such relicensing or conveying.
397 |
398 | If you add terms to a covered work in accord with this section, you
399 | must place, in the relevant source files, a statement of the
400 | additional terms that apply to those files, or a notice indicating
401 | where to find the applicable terms.
402 |
403 | Additional terms, permissive or non-permissive, may be stated in the
404 | form of a separately written license, or stated as exceptions;
405 | the above requirements apply either way.
406 |
407 | 8. Termination.
408 |
409 | You may not propagate or modify a covered work except as expressly
410 | provided under this License. Any attempt otherwise to propagate or
411 | modify it is void, and will automatically terminate your rights under
412 | this License (including any patent licenses granted under the third
413 | paragraph of section 11).
414 |
415 | However, if you cease all violation of this License, then your
416 | license from a particular copyright holder is reinstated (a)
417 | provisionally, unless and until the copyright holder explicitly and
418 | finally terminates your license, and (b) permanently, if the copyright
419 | holder fails to notify you of the violation by some reasonable means
420 | prior to 60 days after the cessation.
421 |
422 | Moreover, your license from a particular copyright holder is
423 | reinstated permanently if the copyright holder notifies you of the
424 | violation by some reasonable means, this is the first time you have
425 | received notice of violation of this License (for any work) from that
426 | copyright holder, and you cure the violation prior to 30 days after
427 | your receipt of the notice.
428 |
429 | Termination of your rights under this section does not terminate the
430 | licenses of parties who have received copies or rights from you under
431 | this License. If your rights have been terminated and not permanently
432 | reinstated, you do not qualify to receive new licenses for the same
433 | material under section 10.
434 |
435 | 9. Acceptance Not Required for Having Copies.
436 |
437 | You are not required to accept this License in order to receive or
438 | run a copy of the Program. Ancillary propagation of a covered work
439 | occurring solely as a consequence of using peer-to-peer transmission
440 | to receive a copy likewise does not require acceptance. However,
441 | nothing other than this License grants you permission to propagate or
442 | modify any covered work. These actions infringe copyright if you do
443 | not accept this License. Therefore, by modifying or propagating a
444 | covered work, you indicate your acceptance of this License to do so.
445 |
446 | 10. Automatic Licensing of Downstream Recipients.
447 |
448 | Each time you convey a covered work, the recipient automatically
449 | receives a license from the original licensors, to run, modify and
450 | propagate that work, subject to this License. You are not responsible
451 | for enforcing compliance by third parties with this License.
452 |
453 | An "entity transaction" is a transaction transferring control of an
454 | organization, or substantially all assets of one, or subdividing an
455 | organization, or merging organizations. If propagation of a covered
456 | work results from an entity transaction, each party to that
457 | transaction who receives a copy of the work also receives whatever
458 | licenses to the work the party's predecessor in interest had or could
459 | give under the previous paragraph, plus a right to possession of the
460 | Corresponding Source of the work from the predecessor in interest, if
461 | the predecessor has it or can get it with reasonable efforts.
462 |
463 | You may not impose any further restrictions on the exercise of the
464 | rights granted or affirmed under this License. For example, you may
465 | not impose a license fee, royalty, or other charge for exercise of
466 | rights granted under this License, and you may not initiate litigation
467 | (including a cross-claim or counterclaim in a lawsuit) alleging that
468 | any patent claim is infringed by making, using, selling, offering for
469 | sale, or importing the Program or any portion of it.
470 |
471 | 11. Patents.
472 |
473 | A "contributor" is a copyright holder who authorizes use under this
474 | License of the Program or a work on which the Program is based. The
475 | work thus licensed is called the contributor's "contributor version".
476 |
477 | A contributor's "essential patent claims" are all patent claims
478 | owned or controlled by the contributor, whether already acquired or
479 | hereafter acquired, that would be infringed by some manner, permitted
480 | by this License, of making, using, or selling its contributor version,
481 | but do not include claims that would be infringed only as a
482 | consequence of further modification of the contributor version. For
483 | purposes of this definition, "control" includes the right to grant
484 | patent sublicenses in a manner consistent with the requirements of
485 | this License.
486 |
487 | Each contributor grants you a non-exclusive, worldwide, royalty-free
488 | patent license under the contributor's essential patent claims, to
489 | make, use, sell, offer for sale, import and otherwise run, modify and
490 | propagate the contents of its contributor version.
491 |
492 | In the following three paragraphs, a "patent license" is any express
493 | agreement or commitment, however denominated, not to enforce a patent
494 | (such as an express permission to practice a patent or covenant not to
495 | sue for patent infringement). To "grant" such a patent license to a
496 | party means to make such an agreement or commitment not to enforce a
497 | patent against the party.
498 |
499 | If you convey a covered work, knowingly relying on a patent license,
500 | and the Corresponding Source of the work is not available for anyone
501 | to copy, free of charge and under the terms of this License, through a
502 | publicly available network server or other readily accessible means,
503 | then you must either (1) cause the Corresponding Source to be so
504 | available, or (2) arrange to deprive yourself of the benefit of the
505 | patent license for this particular work, or (3) arrange, in a manner
506 | consistent with the requirements of this License, to extend the patent
507 | license to downstream recipients. "Knowingly relying" means you have
508 | actual knowledge that, but for the patent license, your conveying the
509 | covered work in a country, or your recipient's use of the covered work
510 | in a country, would infringe one or more identifiable patents in that
511 | country that you have reason to believe are valid.
512 |
513 | If, pursuant to or in connection with a single transaction or
514 | arrangement, you convey, or propagate by procuring conveyance of, a
515 | covered work, and grant a patent license to some of the parties
516 | receiving the covered work authorizing them to use, propagate, modify
517 | or convey a specific copy of the covered work, then the patent license
518 | you grant is automatically extended to all recipients of the covered
519 | work and works based on it.
520 |
521 | A patent license is "discriminatory" if it does not include within
522 | the scope of its coverage, prohibits the exercise of, or is
523 | conditioned on the non-exercise of one or more of the rights that are
524 | specifically granted under this License. You may not convey a covered
525 | work if you are a party to an arrangement with a third party that is
526 | in the business of distributing software, under which you make payment
527 | to the third party based on the extent of your activity of conveying
528 | the work, and under which the third party grants, to any of the
529 | parties who would receive the covered work from you, a discriminatory
530 | patent license (a) in connection with copies of the covered work
531 | conveyed by you (or copies made from those copies), or (b) primarily
532 | for and in connection with specific products or compilations that
533 | contain the covered work, unless you entered into that arrangement,
534 | or that patent license was granted, prior to 28 March 2007.
535 |
536 | Nothing in this License shall be construed as excluding or limiting
537 | any implied license or other defenses to infringement that may
538 | otherwise be available to you under applicable patent law.
539 |
540 | 12. No Surrender of Others' Freedom.
541 |
542 | If conditions are imposed on you (whether by court order, agreement or
543 | otherwise) that contradict the conditions of this License, they do not
544 | excuse you from the conditions of this License. If you cannot convey a
545 | covered work so as to satisfy simultaneously your obligations under this
546 | License and any other pertinent obligations, then as a consequence you may
547 | not convey it at all. For example, if you agree to terms that obligate you
548 | to collect a royalty for further conveying from those to whom you convey
549 | the Program, the only way you could satisfy both those terms and this
550 | License would be to refrain entirely from conveying the Program.
551 |
552 | 13. Use with the GNU Affero General Public License.
553 |
554 | Notwithstanding any other provision of this License, you have
555 | permission to link or combine any covered work with a work licensed
556 | under version 3 of the GNU Affero General Public License into a single
557 | combined work, and to convey the resulting work. The terms of this
558 | License will continue to apply to the part which is the covered work,
559 | but the special requirements of the GNU Affero General Public License,
560 | section 13, concerning interaction through a network will apply to the
561 | combination as such.
562 |
563 | 14. Revised Versions of this License.
564 |
565 | The Free Software Foundation may publish revised and/or new versions of
566 | the GNU General Public License from time to time. Such new versions will
567 | be similar in spirit to the present version, but may differ in detail to
568 | address new problems or concerns.
569 |
570 | Each version is given a distinguishing version number. If the
571 | Program specifies that a certain numbered version of the GNU General
572 | Public License "or any later version" applies to it, you have the
573 | option of following the terms and conditions either of that numbered
574 | version or of any later version published by the Free Software
575 | Foundation. If the Program does not specify a version number of the
576 | GNU General Public License, you may choose any version ever published
577 | by the Free Software Foundation.
578 |
579 | If the Program specifies that a proxy can decide which future
580 | versions of the GNU General Public License can be used, that proxy's
581 | public statement of acceptance of a version permanently authorizes you
582 | to choose that version for the Program.
583 |
584 | Later license versions may give you additional or different
585 | permissions. However, no additional obligations are imposed on any
586 | author or copyright holder as a result of your choosing to follow a
587 | later version.
588 |
589 | 15. Disclaimer of Warranty.
590 |
591 | THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
592 | APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
593 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
594 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
595 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
596 | PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
597 | IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
598 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
599 |
600 | 16. Limitation of Liability.
601 |
602 | IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
603 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
604 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
605 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
606 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
607 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
608 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
609 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
610 | SUCH DAMAGES.
611 |
612 | 17. Interpretation of Sections 15 and 16.
613 |
614 | If the disclaimer of warranty and limitation of liability provided
615 | above cannot be given local legal effect according to their terms,
616 | reviewing courts shall apply local law that most closely approximates
617 | an absolute waiver of all civil liability in connection with the
618 | Program, unless a warranty or assumption of liability accompanies a
619 | copy of the Program in return for a fee.
620 |
621 | END OF TERMS AND CONDITIONS
622 |
623 | How to Apply These Terms to Your New Programs
624 |
625 | If you develop a new program, and you want it to be of the greatest
626 | possible use to the public, the best way to achieve this is to make it
627 | free software which everyone can redistribute and change under these terms.
628 |
629 | To do so, attach the following notices to the program. It is safest
630 | to attach them to the start of each source file to most effectively
631 | state the exclusion of warranty; and each file should have at least
632 | the "copyright" line and a pointer to where the full notice is found.
633 |
634 |
635 | Copyright (C)
636 |
637 | This program is free software: you can redistribute it and/or modify
638 | it under the terms of the GNU General Public License as published by
639 | the Free Software Foundation, either version 3 of the License, or
640 | (at your option) any later version.
641 |
642 | This program is distributed in the hope that it will be useful,
643 | but WITHOUT ANY WARRANTY; without even the implied warranty of
644 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
645 | GNU General Public License for more details.
646 |
647 | You should have received a copy of the GNU General Public License
648 | along with this program. If not, see .
649 |
650 | Also add information on how to contact you by electronic and paper mail.
651 |
652 | If the program does terminal interaction, make it output a short
653 | notice like this when it starts in an interactive mode:
654 |
655 | Copyright (C)
656 | This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
657 | This is free software, and you are welcome to redistribute it
658 | under certain conditions; type `show c' for details.
659 |
660 | The hypothetical commands `show w' and `show c' should show the appropriate
661 | parts of the General Public License. Of course, your program's commands
662 | might be different; for a GUI interface, you would use an "about box".
663 |
664 | You should also get your employer (if you work as a programmer) or school,
665 | if any, to sign a "copyright disclaimer" for the program, if necessary.
666 | For more information on this, and how to apply and follow the GNU GPL, see
667 | .
668 |
669 | The GNU General Public License does not permit incorporating your program
670 | into proprietary programs. If your program is a subroutine library, you
671 | may consider it more useful to permit linking proprietary applications with
672 | the library. If this is what you want to do, use the GNU Lesser General
673 | Public License instead of this License. But first, please read
674 | .
675 |
--------------------------------------------------------------------------------
/crypto.txt:
--------------------------------------------------------------------------------
1 | function crypto() {
2 | var t = t || function (t, r) {
3 | var e = Object.create || function () {
4 | function t() { }
5 | return function (r) {
6 | var e;
7 | return t.prototype = r,
8 | e = new t,
9 | t.prototype = null,
10 | e
11 | }
12 | }()
13 | , i = {}
14 | , n = i.lib = {}
15 | , o = n.Base = function () {
16 | return {
17 | extend: function (t) {
18 | var r = e(this);
19 | return t && r.mixIn(t),
20 | r.hasOwnProperty("init") && this.init !== r.init || (r.init = function () {
21 | r.$super.init.apply(this, arguments)
22 | }
23 | ),
24 | r.init.prototype = r,
25 | r.$super = this,
26 | r
27 | },
28 | create: function () {
29 | var t = this.extend();
30 | return t.init.apply(t, arguments),
31 | t
32 | },
33 | init: function () { },
34 | mixIn: function (t) {
35 | for (var r in t)
36 | t.hasOwnProperty(r) && (this[r] = t[r]);
37 | t.hasOwnProperty("toString") && (this.toString = t.toString)
38 | },
39 | clone: function () {
40 | return this.init.prototype.extend(this)
41 | }
42 | }
43 | }()
44 | , s = n.WordArray = o.extend({
45 | init: function (t, e) {
46 | t = this.words = t || [],
47 | e != r ? this.sigBytes = e : this.sigBytes = 4 * t.length
48 | },
49 | toString: function (t) {
50 | return (t || c).stringify(this)
51 | },
52 | concat: function (t) {
53 | var r = this.words
54 | , e = t.words
55 | , i = this.sigBytes
56 | , n = t.sigBytes;
57 | if (this.clamp(),
58 | i % 4)
59 | for (var o = 0; o < n; o++) {
60 | var s = e[o >>> 2] >>> 24 - o % 4 * 8 & 255;
61 | r[i + o >>> 2] |= s << 24 - (i + o) % 4 * 8
62 | }
63 | else
64 | for (var o = 0; o < n; o += 4)
65 | r[i + o >>> 2] = e[o >>> 2];
66 | return this.sigBytes += n,
67 | this
68 | },
69 | clamp: function () {
70 | var r = this.words
71 | , e = this.sigBytes;
72 | r[e >>> 2] &= 4294967295 << 32 - e % 4 * 8,
73 | r.length = t.ceil(e / 4)
74 | },
75 | clone: function () {
76 | var t = o.clone.call(this);
77 | return t.words = this.words.slice(0),
78 | t
79 | },
80 | random: function (r) {
81 | for (var e, i = [], n = function (r) {
82 | var r = r
83 | , e = 987654321
84 | , i = 4294967295;
85 | return function () {
86 | e = 36969 * (65535 & e) + (e >> 16) & i,
87 | r = 18e3 * (65535 & r) + (r >> 16) & i;
88 | var n = (e << 16) + r & i;
89 | return n /= 4294967296,
90 | n += .5,
91 | n * (t.random() > .5 ? 1 : -1)
92 | }
93 | }, o = 0; o < r; o += 4) {
94 | var a = n(4294967296 * (e || t.random()));
95 | e = 987654071 * a(),
96 | i.push(4294967296 * a() | 0)
97 | }
98 | return new s.init(i, r)
99 | }
100 | })
101 | , a = i.enc = {}
102 | , c = a.Hex = {
103 | stringify: function (t) {
104 | for (var r = t.words, e = t.sigBytes, i = [], n = 0; n < e; n++) {
105 | var o = r[n >>> 2] >>> 24 - n % 4 * 8 & 255;
106 | i.push((o >>> 4).toString(16)),
107 | i.push((15 & o).toString(16))
108 | }
109 | return i.join("")
110 | },
111 | parse: function (t) {
112 | for (var r = t.length, e = [], i = 0; i < r; i += 2)
113 | e[i >>> 3] |= parseInt(t.substr(i, 2), 16) << 24 - i % 8 * 4;
114 | return new s.init(e, r / 2)
115 | }
116 | }
117 | , h = a.Latin1 = {
118 | stringify: function (t) {
119 | for (var r = t.words, e = t.sigBytes, i = [], n = 0; n < e; n++) {
120 | var o = r[n >>> 2] >>> 24 - n % 4 * 8 & 255;
121 | i.push(String.fromCharCode(o))
122 | }
123 | return i.join("")
124 | },
125 | parse: function (t) {
126 | for (var r = t.length, e = [], i = 0; i < r; i++)
127 | e[i >>> 2] |= (255 & t.charCodeAt(i)) << 24 - i % 4 * 8;
128 | return new s.init(e, r)
129 | }
130 | }
131 | , l = a.Utf8 = {
132 | stringify: function (t) {
133 | try {
134 | return decodeURIComponent(escape(h.stringify(t)))
135 | } catch (t) {
136 | throw new Error("Malformed UTF-8 data")
137 | }
138 | },
139 | parse: function (t) {
140 | return h.parse(unescape(encodeURIComponent(t)))
141 | }
142 | }
143 | , f = n.BufferedBlockAlgorithm = o.extend({
144 | reset: function () {
145 | this._data = new s.init,
146 | this._nDataBytes = 0
147 | },
148 | _append: function (t) {
149 | "string" == typeof t && (t = l.parse(t)),
150 | this._data.concat(t),
151 | this._nDataBytes += t.sigBytes
152 | },
153 | _process: function (r) {
154 | var e = this._data
155 | , i = e.words
156 | , n = e.sigBytes
157 | , o = this.blockSize
158 | , a = 4 * o
159 | , c = n / a;
160 | c = r ? t.ceil(c) : t.max((0 | c) - this._minBufferSize, 0);
161 | var h = c * o
162 | , l = t.min(4 * h, n);
163 | if (h) {
164 | for (var f = 0; f < h; f += o)
165 | this._doProcessBlock(i, f);
166 | var u = i.splice(0, h);
167 | e.sigBytes -= l
168 | }
169 | return new s.init(u, l)
170 | },
171 | clone: function () {
172 | var t = o.clone.call(this);
173 | return t._data = this._data.clone(),
174 | t
175 | },
176 | _minBufferSize: 0
177 | })
178 | , u = (n.Hasher = f.extend({
179 | cfg: o.extend(),
180 | init: function (t) {
181 | this.cfg = this.cfg.extend(t),
182 | this.reset()
183 | },
184 | reset: function () {
185 | f.reset.call(this),
186 | this._doReset()
187 | },
188 | update: function (t) {
189 | return this._append(t),
190 | this._process(),
191 | this
192 | },
193 | finalize: function (t) {
194 | t && this._append(t);
195 | var r = this._doFinalize();
196 | return r
197 | },
198 | blockSize: 16,
199 | _createHelper: function (t) {
200 | return function (r, e) {
201 | return new t.init(e).finalize(r)
202 | }
203 | },
204 | _createHmacHelper: function (t) {
205 | return function (r, e) {
206 | return new u.HMAC.init(t, e).finalize(r)
207 | }
208 | }
209 | }),
210 | i.algo = {});
211 | return i
212 | }(Math);
213 | return function () {
214 | function r(t, r, e) {
215 | for (var i = [], o = 0, s = 0; s < r; s++)
216 | if (s % 4) {
217 | var a = e[t.charCodeAt(s - 1)] << s % 4 * 2
218 | , c = e[t.charCodeAt(s)] >>> 6 - s % 4 * 2;
219 | i[o >>> 2] |= (a | c) << 24 - o % 4 * 8,
220 | o++
221 | }
222 | return n.create(i, o)
223 | }
224 | var e = t
225 | , i = e.lib
226 | , n = i.WordArray
227 | , o = e.enc;
228 | o.Base64 = {
229 | stringify: function (t) {
230 | var r = t.words
231 | , e = t.sigBytes
232 | , i = this._map;
233 | t.clamp();
234 | for (var n = [], o = 0; o < e; o += 3)
235 | for (var s = r[o >>> 2] >>> 24 - o % 4 * 8 & 255, a = r[o + 1 >>> 2] >>> 24 - (o + 1) % 4 * 8 & 255, c = r[o + 2 >>> 2] >>> 24 - (o + 2) % 4 * 8 & 255, h = s << 16 | a << 8 | c, l = 0; l < 4 && o + .75 * l < e; l++)
236 | n.push(i.charAt(h >>> 6 * (3 - l) & 63));
237 | var f = i.charAt(64);
238 | if (f)
239 | for (; n.length % 4;)
240 | n.push(f);
241 | return n.join("")
242 | },
243 | parse: function (t) {
244 | var e = t.length
245 | , i = this._map
246 | , n = this._reverseMap;
247 | if (!n) {
248 | n = this._reverseMap = [];
249 | for (var o = 0; o < i.length; o++)
250 | n[i.charCodeAt(o)] = o
251 | }
252 | var s = i.charAt(64);
253 | if (s) {
254 | var a = t.indexOf(s);
255 | a !== -1 && (e = a)
256 | }
257 | return r(t, e, n)
258 | },
259 | _map: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
260 | }
261 | }(),
262 | function (r) {
263 | function e(t, r, e, i, n, o, s) {
264 | var a = t + (r & e | ~r & i) + n + s;
265 | return (a << o | a >>> 32 - o) + r
266 | }
267 | function i(t, r, e, i, n, o, s) {
268 | var a = t + (r & i | e & ~i) + n + s;
269 | return (a << o | a >>> 32 - o) + r
270 | }
271 | function n(t, r, e, i, n, o, s) {
272 | var a = t + (r ^ e ^ i) + n + s;
273 | return (a << o | a >>> 32 - o) + r
274 | }
275 | function o(t, r, e, i, n, o, s) {
276 | var a = t + (e ^ (r | ~i)) + n + s;
277 | return (a << o | a >>> 32 - o) + r
278 | }
279 | var s = t
280 | , a = s.lib
281 | , c = a.WordArray
282 | , h = a.Hasher
283 | , l = s.algo
284 | , f = [];
285 | !function () {
286 | for (var t = 0; t < 64; t++)
287 | f[t] = 4294967296 * r.abs(r.sin(t + 1)) | 0
288 | }();
289 | var u = l.MD5 = h.extend({
290 | _doReset: function () {
291 | this._hash = new c.init([1732584193, 4023233417, 2562383102, 271733878])
292 | },
293 | _doProcessBlock: function (t, r) {
294 | for (var s = 0; s < 16; s++) {
295 | var a = r + s
296 | , c = t[a];
297 | t[a] = 16711935 & (c << 8 | c >>> 24) | 4278255360 & (c << 24 | c >>> 8)
298 | }
299 | var h = this._hash.words
300 | , l = t[r + 0]
301 | , u = t[r + 1]
302 | , d = t[r + 2]
303 | , v = t[r + 3]
304 | , p = t[r + 4]
305 | , _ = t[r + 5]
306 | , y = t[r + 6]
307 | , g = t[r + 7]
308 | , B = t[r + 8]
309 | , w = t[r + 9]
310 | , k = t[r + 10]
311 | , S = t[r + 11]
312 | , m = t[r + 12]
313 | , x = t[r + 13]
314 | , b = t[r + 14]
315 | , H = t[r + 15]
316 | , z = h[0]
317 | , A = h[1]
318 | , C = h[2]
319 | , D = h[3];
320 | z = e(z, A, C, D, l, 7, f[0]),
321 | D = e(D, z, A, C, u, 12, f[1]),
322 | C = e(C, D, z, A, d, 17, f[2]),
323 | A = e(A, C, D, z, v, 22, f[3]),
324 | z = e(z, A, C, D, p, 7, f[4]),
325 | D = e(D, z, A, C, _, 12, f[5]),
326 | C = e(C, D, z, A, y, 17, f[6]),
327 | A = e(A, C, D, z, g, 22, f[7]),
328 | z = e(z, A, C, D, B, 7, f[8]),
329 | D = e(D, z, A, C, w, 12, f[9]),
330 | C = e(C, D, z, A, k, 17, f[10]),
331 | A = e(A, C, D, z, S, 22, f[11]),
332 | z = e(z, A, C, D, m, 7, f[12]),
333 | D = e(D, z, A, C, x, 12, f[13]),
334 | C = e(C, D, z, A, b, 17, f[14]),
335 | A = e(A, C, D, z, H, 22, f[15]),
336 | z = i(z, A, C, D, u, 5, f[16]),
337 | D = i(D, z, A, C, y, 9, f[17]),
338 | C = i(C, D, z, A, S, 14, f[18]),
339 | A = i(A, C, D, z, l, 20, f[19]),
340 | z = i(z, A, C, D, _, 5, f[20]),
341 | D = i(D, z, A, C, k, 9, f[21]),
342 | C = i(C, D, z, A, H, 14, f[22]),
343 | A = i(A, C, D, z, p, 20, f[23]),
344 | z = i(z, A, C, D, w, 5, f[24]),
345 | D = i(D, z, A, C, b, 9, f[25]),
346 | C = i(C, D, z, A, v, 14, f[26]),
347 | A = i(A, C, D, z, B, 20, f[27]),
348 | z = i(z, A, C, D, x, 5, f[28]),
349 | D = i(D, z, A, C, d, 9, f[29]),
350 | C = i(C, D, z, A, g, 14, f[30]),
351 | A = i(A, C, D, z, m, 20, f[31]),
352 | z = n(z, A, C, D, _, 4, f[32]),
353 | D = n(D, z, A, C, B, 11, f[33]),
354 | C = n(C, D, z, A, S, 16, f[34]),
355 | A = n(A, C, D, z, b, 23, f[35]),
356 | z = n(z, A, C, D, u, 4, f[36]),
357 | D = n(D, z, A, C, p, 11, f[37]),
358 | C = n(C, D, z, A, g, 16, f[38]),
359 | A = n(A, C, D, z, k, 23, f[39]),
360 | z = n(z, A, C, D, x, 4, f[40]),
361 | D = n(D, z, A, C, l, 11, f[41]),
362 | C = n(C, D, z, A, v, 16, f[42]),
363 | A = n(A, C, D, z, y, 23, f[43]),
364 | z = n(z, A, C, D, w, 4, f[44]),
365 | D = n(D, z, A, C, m, 11, f[45]),
366 | C = n(C, D, z, A, H, 16, f[46]),
367 | A = n(A, C, D, z, d, 23, f[47]),
368 | z = o(z, A, C, D, l, 6, f[48]),
369 | D = o(D, z, A, C, g, 10, f[49]),
370 | C = o(C, D, z, A, b, 15, f[50]),
371 | A = o(A, C, D, z, _, 21, f[51]),
372 | z = o(z, A, C, D, m, 6, f[52]),
373 | D = o(D, z, A, C, v, 10, f[53]),
374 | C = o(C, D, z, A, k, 15, f[54]),
375 | A = o(A, C, D, z, u, 21, f[55]),
376 | z = o(z, A, C, D, B, 6, f[56]),
377 | D = o(D, z, A, C, H, 10, f[57]),
378 | C = o(C, D, z, A, y, 15, f[58]),
379 | A = o(A, C, D, z, x, 21, f[59]),
380 | z = o(z, A, C, D, p, 6, f[60]),
381 | D = o(D, z, A, C, S, 10, f[61]),
382 | C = o(C, D, z, A, d, 15, f[62]),
383 | A = o(A, C, D, z, w, 21, f[63]),
384 | h[0] = h[0] + z | 0,
385 | h[1] = h[1] + A | 0,
386 | h[2] = h[2] + C | 0,
387 | h[3] = h[3] + D | 0
388 | },
389 | _doFinalize: function () {
390 | var t = this._data
391 | , e = t.words
392 | , i = 8 * this._nDataBytes
393 | , n = 8 * t.sigBytes;
394 | e[n >>> 5] |= 128 << 24 - n % 32;
395 | var o = r.floor(i / 4294967296)
396 | , s = i;
397 | e[(n + 64 >>> 9 << 4) + 15] = 16711935 & (o << 8 | o >>> 24) | 4278255360 & (o << 24 | o >>> 8),
398 | e[(n + 64 >>> 9 << 4) + 14] = 16711935 & (s << 8 | s >>> 24) | 4278255360 & (s << 24 | s >>> 8),
399 | t.sigBytes = 4 * (e.length + 1),
400 | this._process();
401 | for (var a = this._hash, c = a.words, h = 0; h < 4; h++) {
402 | var l = c[h];
403 | c[h] = 16711935 & (l << 8 | l >>> 24) | 4278255360 & (l << 24 | l >>> 8)
404 | }
405 | return a
406 | },
407 | clone: function () {
408 | var t = h.clone.call(this);
409 | return t._hash = this._hash.clone(),
410 | t
411 | }
412 | });
413 | s.MD5 = h._createHelper(u),
414 | s.HmacMD5 = h._createHmacHelper(u)
415 | }(Math),
416 | function () {
417 | var r = t
418 | , e = r.lib
419 | , i = e.WordArray
420 | , n = e.Hasher
421 | , o = r.algo
422 | , s = []
423 | , a = o.SHA1 = n.extend({
424 | _doReset: function () {
425 | this._hash = new i.init([1732584193, 4023233417, 2562383102, 271733878, 3285377520])
426 | },
427 | _doProcessBlock: function (t, r) {
428 | for (var e = this._hash.words, i = e[0], n = e[1], o = e[2], a = e[3], c = e[4], h = 0; h < 80; h++) {
429 | if (h < 16)
430 | s[h] = 0 | t[r + h];
431 | else {
432 | var l = s[h - 3] ^ s[h - 8] ^ s[h - 14] ^ s[h - 16];
433 | s[h] = l << 1 | l >>> 31
434 | }
435 | var f = (i << 5 | i >>> 27) + c + s[h];
436 | f += h < 20 ? (n & o | ~n & a) + 1518500249 : h < 40 ? (n ^ o ^ a) + 1859775393 : h < 60 ? (n & o | n & a | o & a) - 1894007588 : (n ^ o ^ a) - 899497514,
437 | c = a,
438 | a = o,
439 | o = n << 30 | n >>> 2,
440 | n = i,
441 | i = f
442 | }
443 | e[0] = e[0] + i | 0,
444 | e[1] = e[1] + n | 0,
445 | e[2] = e[2] + o | 0,
446 | e[3] = e[3] + a | 0,
447 | e[4] = e[4] + c | 0
448 | },
449 | _doFinalize: function () {
450 | var t = this._data
451 | , r = t.words
452 | , e = 8 * this._nDataBytes
453 | , i = 8 * t.sigBytes;
454 | return r[i >>> 5] |= 128 << 24 - i % 32,
455 | r[(i + 64 >>> 9 << 4) + 14] = Math.floor(e / 4294967296),
456 | r[(i + 64 >>> 9 << 4) + 15] = e,
457 | t.sigBytes = 4 * r.length,
458 | this._process(),
459 | this._hash
460 | },
461 | clone: function () {
462 | var t = n.clone.call(this);
463 | return t._hash = this._hash.clone(),
464 | t
465 | }
466 | });
467 | r.SHA1 = n._createHelper(a),
468 | r.HmacSHA1 = n._createHmacHelper(a)
469 | }(),
470 | function (r) {
471 | var e = t
472 | , i = e.lib
473 | , n = i.WordArray
474 | , o = i.Hasher
475 | , s = e.algo
476 | , a = []
477 | , c = [];
478 | !function () {
479 | function t(t) {
480 | for (var e = r.sqrt(t), i = 2; i <= e; i++)
481 | if (!(t % i))
482 | return !1;
483 | return !0
484 | }
485 | function e(t) {
486 | return 4294967296 * (t - (0 | t)) | 0
487 | }
488 | for (var i = 2, n = 0; n < 64;)
489 | t(i) && (n < 8 && (a[n] = e(r.pow(i, .5))),
490 | c[n] = e(r.pow(i, 1 / 3)),
491 | n++),
492 | i++
493 | }();
494 | var h = []
495 | , l = s.SHA256 = o.extend({
496 | _doReset: function () {
497 | this._hash = new n.init(a.slice(0))
498 | },
499 | _doProcessBlock: function (t, r) {
500 | for (var e = this._hash.words, i = e[0], n = e[1], o = e[2], s = e[3], a = e[4], l = e[5], f = e[6], u = e[7], d = 0; d < 64; d++) {
501 | if (d < 16)
502 | h[d] = 0 | t[r + d];
503 | else {
504 | var v = h[d - 15]
505 | , p = (v << 25 | v >>> 7) ^ (v << 14 | v >>> 18) ^ v >>> 3
506 | , _ = h[d - 2]
507 | , y = (_ << 15 | _ >>> 17) ^ (_ << 13 | _ >>> 19) ^ _ >>> 10;
508 | h[d] = p + h[d - 7] + y + h[d - 16]
509 | }
510 | var g = a & l ^ ~a & f
511 | , B = i & n ^ i & o ^ n & o
512 | , w = (i << 30 | i >>> 2) ^ (i << 19 | i >>> 13) ^ (i << 10 | i >>> 22)
513 | , k = (a << 26 | a >>> 6) ^ (a << 21 | a >>> 11) ^ (a << 7 | a >>> 25)
514 | , S = u + k + g + c[d] + h[d]
515 | , m = w + B;
516 | u = f,
517 | f = l,
518 | l = a,
519 | a = s + S | 0,
520 | s = o,
521 | o = n,
522 | n = i,
523 | i = S + m | 0
524 | }
525 | e[0] = e[0] + i | 0,
526 | e[1] = e[1] + n | 0,
527 | e[2] = e[2] + o | 0,
528 | e[3] = e[3] + s | 0,
529 | e[4] = e[4] + a | 0,
530 | e[5] = e[5] + l | 0,
531 | e[6] = e[6] + f | 0,
532 | e[7] = e[7] + u | 0
533 | },
534 | _doFinalize: function () {
535 | var t = this._data
536 | , e = t.words
537 | , i = 8 * this._nDataBytes
538 | , n = 8 * t.sigBytes;
539 | return e[n >>> 5] |= 128 << 24 - n % 32,
540 | e[(n + 64 >>> 9 << 4) + 14] = r.floor(i / 4294967296),
541 | e[(n + 64 >>> 9 << 4) + 15] = i,
542 | t.sigBytes = 4 * e.length,
543 | this._process(),
544 | this._hash
545 | },
546 | clone: function () {
547 | var t = o.clone.call(this);
548 | return t._hash = this._hash.clone(),
549 | t
550 | }
551 | });
552 | e.SHA256 = o._createHelper(l),
553 | e.HmacSHA256 = o._createHmacHelper(l)
554 | }(Math),
555 | function () {
556 | function r(t) {
557 | return t << 8 & 4278255360 | t >>> 8 & 16711935
558 | }
559 | var e = t
560 | , i = e.lib
561 | , n = i.WordArray
562 | , o = e.enc;
563 | o.Utf16 = o.Utf16BE = {
564 | stringify: function (t) {
565 | for (var r = t.words, e = t.sigBytes, i = [], n = 0; n < e; n += 2) {
566 | var o = r[n >>> 2] >>> 16 - n % 4 * 8 & 65535;
567 | i.push(String.fromCharCode(o))
568 | }
569 | return i.join("")
570 | },
571 | parse: function (t) {
572 | for (var r = t.length, e = [], i = 0; i < r; i++)
573 | e[i >>> 1] |= t.charCodeAt(i) << 16 - i % 2 * 16;
574 | return n.create(e, 2 * r)
575 | }
576 | };
577 | o.Utf16LE = {
578 | stringify: function (t) {
579 | for (var e = t.words, i = t.sigBytes, n = [], o = 0; o < i; o += 2) {
580 | var s = r(e[o >>> 2] >>> 16 - o % 4 * 8 & 65535);
581 | n.push(String.fromCharCode(s))
582 | }
583 | return n.join("")
584 | },
585 | parse: function (t) {
586 | for (var e = t.length, i = [], o = 0; o < e; o++)
587 | i[o >>> 1] |= r(t.charCodeAt(o) << 16 - o % 2 * 16);
588 | return n.create(i, 2 * e)
589 | }
590 | }
591 | }(),
592 | function () {
593 | if ("function" == typeof ArrayBuffer) {
594 | var r = t
595 | , e = r.lib
596 | , i = e.WordArray
597 | , n = i.init
598 | , o = i.init = function (t) {
599 | if (t instanceof ArrayBuffer && (t = new Uint8Array(t)),
600 | (t instanceof Int8Array || "undefined" != typeof Uint8ClampedArray && t instanceof Uint8ClampedArray || t instanceof Int16Array || t instanceof Uint16Array || t instanceof Int32Array || t instanceof Uint32Array || t instanceof Float32Array || t instanceof Float64Array) && (t = new Uint8Array(t.buffer, t.byteOffset, t.byteLength)),
601 | t instanceof Uint8Array) {
602 | for (var r = t.byteLength, e = [], i = 0; i < r; i++)
603 | e[i >>> 2] |= t[i] << 24 - i % 4 * 8;
604 | n.call(this, e, r)
605 | } else
606 | n.apply(this, arguments)
607 | }
608 | ;
609 | o.prototype = i
610 | }
611 | }(),
612 | function (r) {
613 | function e(t, r, e) {
614 | return t ^ r ^ e
615 | }
616 | function i(t, r, e) {
617 | return t & r | ~t & e
618 | }
619 | function n(t, r, e) {
620 | return (t | ~r) ^ e
621 | }
622 | function o(t, r, e) {
623 | return t & e | r & ~e
624 | }
625 | function s(t, r, e) {
626 | return t ^ (r | ~e)
627 | }
628 | function a(t, r) {
629 | return t << r | t >>> 32 - r
630 | }
631 | var c = t
632 | , h = c.lib
633 | , l = h.WordArray
634 | , f = h.Hasher
635 | , u = c.algo
636 | , d = l.create([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8, 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12, 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2, 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13])
637 | , v = l.create([5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12, 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2, 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13, 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14, 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11])
638 | , p = l.create([11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8, 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12, 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5, 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12, 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6])
639 | , _ = l.create([8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6, 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11, 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5, 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8, 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11])
640 | , y = l.create([0, 1518500249, 1859775393, 2400959708, 2840853838])
641 | , g = l.create([1352829926, 1548603684, 1836072691, 2053994217, 0])
642 | , B = u.RIPEMD160 = f.extend({
643 | _doReset: function () {
644 | this._hash = l.create([1732584193, 4023233417, 2562383102, 271733878, 3285377520])
645 | },
646 | _doProcessBlock: function (t, r) {
647 | for (var c = 0; c < 16; c++) {
648 | var h = r + c
649 | , l = t[h];
650 | t[h] = 16711935 & (l << 8 | l >>> 24) | 4278255360 & (l << 24 | l >>> 8)
651 | }
652 | var f, u, B, w, k, S, m, x, b, H, z = this._hash.words, A = y.words, C = g.words, D = d.words, R = v.words, E = p.words, M = _.words;
653 | S = f = z[0],
654 | m = u = z[1],
655 | x = B = z[2],
656 | b = w = z[3],
657 | H = k = z[4];
658 | for (var F, c = 0; c < 80; c += 1)
659 | F = f + t[r + D[c]] | 0,
660 | F += c < 16 ? e(u, B, w) + A[0] : c < 32 ? i(u, B, w) + A[1] : c < 48 ? n(u, B, w) + A[2] : c < 64 ? o(u, B, w) + A[3] : s(u, B, w) + A[4],
661 | F |= 0,
662 | F = a(F, E[c]),
663 | F = F + k | 0,
664 | f = k,
665 | k = w,
666 | w = a(B, 10),
667 | B = u,
668 | u = F,
669 | F = S + t[r + R[c]] | 0,
670 | F += c < 16 ? s(m, x, b) + C[0] : c < 32 ? o(m, x, b) + C[1] : c < 48 ? n(m, x, b) + C[2] : c < 64 ? i(m, x, b) + C[3] : e(m, x, b) + C[4],
671 | F |= 0,
672 | F = a(F, M[c]),
673 | F = F + H | 0,
674 | S = H,
675 | H = b,
676 | b = a(x, 10),
677 | x = m,
678 | m = F;
679 | F = z[1] + B + b | 0,
680 | z[1] = z[2] + w + H | 0,
681 | z[2] = z[3] + k + S | 0,
682 | z[3] = z[4] + f + m | 0,
683 | z[4] = z[0] + u + x | 0,
684 | z[0] = F
685 | },
686 | _doFinalize: function () {
687 | var t = this._data
688 | , r = t.words
689 | , e = 8 * this._nDataBytes
690 | , i = 8 * t.sigBytes;
691 | r[i >>> 5] |= 128 << 24 - i % 32,
692 | r[(i + 64 >>> 9 << 4) + 14] = 16711935 & (e << 8 | e >>> 24) | 4278255360 & (e << 24 | e >>> 8),
693 | t.sigBytes = 4 * (r.length + 1),
694 | this._process();
695 | for (var n = this._hash, o = n.words, s = 0; s < 5; s++) {
696 | var a = o[s];
697 | o[s] = 16711935 & (a << 8 | a >>> 24) | 4278255360 & (a << 24 | a >>> 8)
698 | }
699 | return n
700 | },
701 | clone: function () {
702 | var t = f.clone.call(this);
703 | return t._hash = this._hash.clone(),
704 | t
705 | }
706 | });
707 | c.RIPEMD160 = f._createHelper(B),
708 | c.HmacRIPEMD160 = f._createHmacHelper(B)
709 | }(Math),
710 | function () {
711 | var r = t
712 | , e = r.lib
713 | , i = e.Base
714 | , n = r.enc
715 | , o = n.Utf8
716 | , s = r.algo;
717 | s.HMAC = i.extend({
718 | init: function (t, r) {
719 | t = this._hasher = new t.init,
720 | "string" == typeof r && (r = o.parse(r));
721 | var e = t.blockSize
722 | , i = 4 * e;
723 | r.sigBytes > i && (r = t.finalize(r)),
724 | r.clamp();
725 | for (var n = this._oKey = r.clone(), s = this._iKey = r.clone(), a = n.words, c = s.words, h = 0; h < e; h++)
726 | a[h] ^= 1549556828,
727 | c[h] ^= 909522486;
728 | n.sigBytes = s.sigBytes = i,
729 | this.reset()
730 | },
731 | reset: function () {
732 | var t = this._hasher;
733 | t.reset(),
734 | t.update(this._iKey)
735 | },
736 | update: function (t) {
737 | return this._hasher.update(t),
738 | this
739 | },
740 | finalize: function (t) {
741 | var r = this._hasher
742 | , e = r.finalize(t);
743 | r.reset();
744 | var i = r.finalize(this._oKey.clone().concat(e));
745 | return i
746 | }
747 | })
748 | }(),
749 | function () {
750 | var r = t
751 | , e = r.lib
752 | , i = e.Base
753 | , n = e.WordArray
754 | , o = r.algo
755 | , s = o.SHA1
756 | , a = o.HMAC
757 | , c = o.PBKDF2 = i.extend({
758 | cfg: i.extend({
759 | keySize: 4,
760 | hasher: s,
761 | iterations: 1
762 | }),
763 | init: function (t) {
764 | this.cfg = this.cfg.extend(t)
765 | },
766 | compute: function (t, r) {
767 | for (var e = this.cfg, i = a.create(e.hasher, t), o = n.create(), s = n.create([1]), c = o.words, h = s.words, l = e.keySize, f = e.iterations; c.length < l;) {
768 | var u = i.update(r).finalize(s);
769 | i.reset();
770 | for (var d = u.words, v = d.length, p = u, _ = 1; _ < f; _++) {
771 | p = i.finalize(p),
772 | i.reset();
773 | for (var y = p.words, g = 0; g < v; g++)
774 | d[g] ^= y[g]
775 | }
776 | o.concat(u),
777 | h[0]++
778 | }
779 | return o.sigBytes = 4 * l,
780 | o
781 | }
782 | });
783 | r.PBKDF2 = function (t, r, e) {
784 | return c.create(e).compute(t, r)
785 | }
786 | }(),
787 | function () {
788 | var r = t
789 | , e = r.lib
790 | , i = e.Base
791 | , n = e.WordArray
792 | , o = r.algo
793 | , s = o.MD5
794 | , a = o.EvpKDF = i.extend({
795 | cfg: i.extend({
796 | keySize: 4,
797 | hasher: s,
798 | iterations: 1
799 | }),
800 | init: function (t) {
801 | this.cfg = this.cfg.extend(t)
802 | },
803 | compute: function (t, r) {
804 | for (var e = this.cfg, i = e.hasher.create(), o = n.create(), s = o.words, a = e.keySize, c = e.iterations; s.length < a;) {
805 | h && i.update(h);
806 | var h = i.update(t).finalize(r);
807 | i.reset();
808 | for (var l = 1; l < c; l++)
809 | h = i.finalize(h),
810 | i.reset();
811 | o.concat(h)
812 | }
813 | return o.sigBytes = 4 * a,
814 | o
815 | }
816 | });
817 | r.EvpKDF = function (t, r, e) {
818 | return a.create(e).compute(t, r)
819 | }
820 | }(),
821 | function () {
822 | var r = t
823 | , e = r.lib
824 | , i = e.WordArray
825 | , n = r.algo
826 | , o = n.SHA256
827 | , s = n.SHA224 = o.extend({
828 | _doReset: function () {
829 | this._hash = new i.init([3238371032, 914150663, 812702999, 4144912697, 4290775857, 1750603025, 1694076839, 3204075428])
830 | },
831 | _doFinalize: function () {
832 | var t = o._doFinalize.call(this);
833 | return t.sigBytes -= 4,
834 | t
835 | }
836 | });
837 | r.SHA224 = o._createHelper(s),
838 | r.HmacSHA224 = o._createHmacHelper(s)
839 | }(),
840 | function (r) {
841 | var e = t
842 | , i = e.lib
843 | , n = i.Base
844 | , o = i.WordArray
845 | , s = e.x64 = {};
846 | s.Word = n.extend({
847 | init: function (t, r) {
848 | this.high = t,
849 | this.low = r
850 | }
851 | }),
852 | s.WordArray = n.extend({
853 | init: function (t, e) {
854 | t = this.words = t || [],
855 | e != r ? this.sigBytes = e : this.sigBytes = 8 * t.length
856 | },
857 | toX32: function () {
858 | for (var t = this.words, r = t.length, e = [], i = 0; i < r; i++) {
859 | var n = t[i];
860 | e.push(n.high),
861 | e.push(n.low)
862 | }
863 | return o.create(e, this.sigBytes)
864 | },
865 | clone: function () {
866 | for (var t = n.clone.call(this), r = t.words = this.words.slice(0), e = r.length, i = 0; i < e; i++)
867 | r[i] = r[i].clone();
868 | return t
869 | }
870 | })
871 | }(),
872 | function (r) {
873 | var e = t
874 | , i = e.lib
875 | , n = i.WordArray
876 | , o = i.Hasher
877 | , s = e.x64
878 | , a = s.Word
879 | , c = e.algo
880 | , h = []
881 | , l = []
882 | , f = [];
883 | !function () {
884 | for (var t = 1, r = 0, e = 0; e < 24; e++) {
885 | h[t + 5 * r] = (e + 1) * (e + 2) / 2 % 64;
886 | var i = r % 5
887 | , n = (2 * t + 3 * r) % 5;
888 | t = i,
889 | r = n
890 | }
891 | for (var t = 0; t < 5; t++)
892 | for (var r = 0; r < 5; r++)
893 | l[t + 5 * r] = r + (2 * t + 3 * r) % 5 * 5;
894 | for (var o = 1, s = 0; s < 24; s++) {
895 | for (var c = 0, u = 0, d = 0; d < 7; d++) {
896 | if (1 & o) {
897 | var v = (1 << d) - 1;
898 | v < 32 ? u ^= 1 << v : c ^= 1 << v - 32
899 | }
900 | 128 & o ? o = o << 1 ^ 113 : o <<= 1
901 | }
902 | f[s] = a.create(c, u)
903 | }
904 | }();
905 | var u = [];
906 | !function () {
907 | for (var t = 0; t < 25; t++)
908 | u[t] = a.create()
909 | }();
910 | var d = c.SHA3 = o.extend({
911 | cfg: o.cfg.extend({
912 | outputLength: 512
913 | }),
914 | _doReset: function () {
915 | for (var t = this._state = [], r = 0; r < 25; r++)
916 | t[r] = new a.init;
917 | this.blockSize = (1600 - 2 * this.cfg.outputLength) / 32
918 | },
919 | _doProcessBlock: function (t, r) {
920 | for (var e = this._state, i = this.blockSize / 2, n = 0; n < i; n++) {
921 | var o = t[r + 2 * n]
922 | , s = t[r + 2 * n + 1];
923 | o = 16711935 & (o << 8 | o >>> 24) | 4278255360 & (o << 24 | o >>> 8),
924 | s = 16711935 & (s << 8 | s >>> 24) | 4278255360 & (s << 24 | s >>> 8);
925 | var a = e[n];
926 | a.high ^= s,
927 | a.low ^= o
928 | }
929 | for (var c = 0; c < 24; c++) {
930 | for (var d = 0; d < 5; d++) {
931 | for (var v = 0, p = 0, _ = 0; _ < 5; _++) {
932 | var a = e[d + 5 * _];
933 | v ^= a.high,
934 | p ^= a.low
935 | }
936 | var y = u[d];
937 | y.high = v,
938 | y.low = p
939 | }
940 | for (var d = 0; d < 5; d++)
941 | for (var g = u[(d + 4) % 5], B = u[(d + 1) % 5], w = B.high, k = B.low, v = g.high ^ (w << 1 | k >>> 31), p = g.low ^ (k << 1 | w >>> 31), _ = 0; _ < 5; _++) {
942 | var a = e[d + 5 * _];
943 | a.high ^= v,
944 | a.low ^= p
945 | }
946 | for (var S = 1; S < 25; S++) {
947 | var a = e[S]
948 | , m = a.high
949 | , x = a.low
950 | , b = h[S];
951 | if (b < 32)
952 | var v = m << b | x >>> 32 - b
953 | , p = x << b | m >>> 32 - b;
954 | else
955 | var v = x << b - 32 | m >>> 64 - b
956 | , p = m << b - 32 | x >>> 64 - b;
957 | var H = u[l[S]];
958 | H.high = v,
959 | H.low = p
960 | }
961 | var z = u[0]
962 | , A = e[0];
963 | z.high = A.high,
964 | z.low = A.low;
965 | for (var d = 0; d < 5; d++)
966 | for (var _ = 0; _ < 5; _++) {
967 | var S = d + 5 * _
968 | , a = e[S]
969 | , C = u[S]
970 | , D = u[(d + 1) % 5 + 5 * _]
971 | , R = u[(d + 2) % 5 + 5 * _];
972 | a.high = C.high ^ ~D.high & R.high,
973 | a.low = C.low ^ ~D.low & R.low
974 | }
975 | var a = e[0]
976 | , E = f[c];
977 | a.high ^= E.high,
978 | a.low ^= E.low
979 | }
980 | },
981 | _doFinalize: function () {
982 | var t = this._data
983 | , e = t.words
984 | , i = (8 * this._nDataBytes,
985 | 8 * t.sigBytes)
986 | , o = 32 * this.blockSize;
987 | e[i >>> 5] |= 1 << 24 - i % 32,
988 | e[(r.ceil((i + 1) / o) * o >>> 5) - 1] |= 128,
989 | t.sigBytes = 4 * e.length,
990 | this._process();
991 | for (var s = this._state, a = this.cfg.outputLength / 8, c = a / 8, h = [], l = 0; l < c; l++) {
992 | var f = s[l]
993 | , u = f.high
994 | , d = f.low;
995 | u = 16711935 & (u << 8 | u >>> 24) | 4278255360 & (u << 24 | u >>> 8),
996 | d = 16711935 & (d << 8 | d >>> 24) | 4278255360 & (d << 24 | d >>> 8),
997 | h.push(d),
998 | h.push(u)
999 | }
1000 | return new n.init(h, a)
1001 | },
1002 | clone: function () {
1003 | for (var t = o.clone.call(this), r = t._state = this._state.slice(0), e = 0; e < 25; e++)
1004 | r[e] = r[e].clone();
1005 | return t
1006 | }
1007 | });
1008 | e.SHA3 = o._createHelper(d),
1009 | e.HmacSHA3 = o._createHmacHelper(d)
1010 | }(Math),
1011 | function () {
1012 | function r() {
1013 | return s.create.apply(s, arguments)
1014 | }
1015 | var e = t
1016 | , i = e.lib
1017 | , n = i.Hasher
1018 | , o = e.x64
1019 | , s = o.Word
1020 | , a = o.WordArray
1021 | , c = e.algo
1022 | , h = [r(1116352408, 3609767458), r(1899447441, 602891725), r(3049323471, 3964484399), r(3921009573, 2173295548), r(961987163, 4081628472), r(1508970993, 3053834265), r(2453635748, 2937671579), r(2870763221, 3664609560), r(3624381080, 2734883394), r(310598401, 1164996542), r(607225278, 1323610764), r(1426881987, 3590304994), r(1925078388, 4068182383), r(2162078206, 991336113), r(2614888103, 633803317), r(3248222580, 3479774868), r(3835390401, 2666613458), r(4022224774, 944711139), r(264347078, 2341262773), r(604807628, 2007800933), r(770255983, 1495990901), r(1249150122, 1856431235), r(1555081692, 3175218132), r(1996064986, 2198950837), r(2554220882, 3999719339), r(2821834349, 766784016), r(2952996808, 2566594879), r(3210313671, 3203337956), r(3336571891, 1034457026), r(3584528711, 2466948901), r(113926993, 3758326383), r(338241895, 168717936), r(666307205, 1188179964), r(773529912, 1546045734), r(1294757372, 1522805485), r(1396182291, 2643833823), r(1695183700, 2343527390), r(1986661051, 1014477480), r(2177026350, 1206759142), r(2456956037, 344077627), r(2730485921, 1290863460), r(2820302411, 3158454273), r(3259730800, 3505952657), r(3345764771, 106217008), r(3516065817, 3606008344), r(3600352804, 1432725776), r(4094571909, 1467031594), r(275423344, 851169720), r(430227734, 3100823752), r(506948616, 1363258195), r(659060556, 3750685593), r(883997877, 3785050280), r(958139571, 3318307427), r(1322822218, 3812723403), r(1537002063, 2003034995), r(1747873779, 3602036899), r(1955562222, 1575990012), r(2024104815, 1125592928), r(2227730452, 2716904306), r(2361852424, 442776044), r(2428436474, 593698344), r(2756734187, 3733110249), r(3204031479, 2999351573), r(3329325298, 3815920427), r(3391569614, 3928383900), r(3515267271, 566280711), r(3940187606, 3454069534), r(4118630271, 4000239992), r(116418474, 1914138554), r(174292421, 2731055270), r(289380356, 3203993006), r(460393269, 320620315), r(685471733, 587496836), r(852142971, 1086792851), r(1017036298, 365543100), r(1126000580, 2618297676), r(1288033470, 3409855158), r(1501505948, 4234509866), r(1607167915, 987167468), r(1816402316, 1246189591)]
1023 | , l = [];
1024 | !function () {
1025 | for (var t = 0; t < 80; t++)
1026 | l[t] = r()
1027 | }();
1028 | var f = c.SHA512 = n.extend({
1029 | _doReset: function () {
1030 | this._hash = new a.init([new s.init(1779033703, 4089235720), new s.init(3144134277, 2227873595), new s.init(1013904242, 4271175723), new s.init(2773480762, 1595750129), new s.init(1359893119, 2917565137), new s.init(2600822924, 725511199), new s.init(528734635, 4215389547), new s.init(1541459225, 327033209)])
1031 | },
1032 | _doProcessBlock: function (t, r) {
1033 | for (var e = this._hash.words, i = e[0], n = e[1], o = e[2], s = e[3], a = e[4], c = e[5], f = e[6], u = e[7], d = i.high, v = i.low, p = n.high, _ = n.low, y = o.high, g = o.low, B = s.high, w = s.low, k = a.high, S = a.low, m = c.high, x = c.low, b = f.high, H = f.low, z = u.high, A = u.low, C = d, D = v, R = p, E = _, M = y, F = g, P = B, W = w, O = k, U = S, I = m, K = x, X = b, L = H, j = z, N = A, T = 0; T < 80; T++) {
1034 | var Z = l[T];
1035 | if (T < 16)
1036 | var q = Z.high = 0 | t[r + 2 * T]
1037 | , G = Z.low = 0 | t[r + 2 * T + 1];
1038 | else {
1039 | var J = l[T - 15]
1040 | , $ = J.high
1041 | , Q = J.low
1042 | , V = ($ >>> 1 | Q << 31) ^ ($ >>> 8 | Q << 24) ^ $ >>> 7
1043 | , Y = (Q >>> 1 | $ << 31) ^ (Q >>> 8 | $ << 24) ^ (Q >>> 7 | $ << 25)
1044 | , tt = l[T - 2]
1045 | , rt = tt.high
1046 | , et = tt.low
1047 | , it = (rt >>> 19 | et << 13) ^ (rt << 3 | et >>> 29) ^ rt >>> 6
1048 | , nt = (et >>> 19 | rt << 13) ^ (et << 3 | rt >>> 29) ^ (et >>> 6 | rt << 26)
1049 | , ot = l[T - 7]
1050 | , st = ot.high
1051 | , at = ot.low
1052 | , ct = l[T - 16]
1053 | , ht = ct.high
1054 | , lt = ct.low
1055 | , G = Y + at
1056 | , q = V + st + (G >>> 0 < Y >>> 0 ? 1 : 0)
1057 | , G = G + nt
1058 | , q = q + it + (G >>> 0 < nt >>> 0 ? 1 : 0)
1059 | , G = G + lt
1060 | , q = q + ht + (G >>> 0 < lt >>> 0 ? 1 : 0);
1061 | Z.high = q,
1062 | Z.low = G
1063 | }
1064 | var ft = O & I ^ ~O & X
1065 | , ut = U & K ^ ~U & L
1066 | , dt = C & R ^ C & M ^ R & M
1067 | , vt = D & E ^ D & F ^ E & F
1068 | , pt = (C >>> 28 | D << 4) ^ (C << 30 | D >>> 2) ^ (C << 25 | D >>> 7)
1069 | , _t = (D >>> 28 | C << 4) ^ (D << 30 | C >>> 2) ^ (D << 25 | C >>> 7)
1070 | , yt = (O >>> 14 | U << 18) ^ (O >>> 18 | U << 14) ^ (O << 23 | U >>> 9)
1071 | , gt = (U >>> 14 | O << 18) ^ (U >>> 18 | O << 14) ^ (U << 23 | O >>> 9)
1072 | , Bt = h[T]
1073 | , wt = Bt.high
1074 | , kt = Bt.low
1075 | , St = N + gt
1076 | , mt = j + yt + (St >>> 0 < N >>> 0 ? 1 : 0)
1077 | , St = St + ut
1078 | , mt = mt + ft + (St >>> 0 < ut >>> 0 ? 1 : 0)
1079 | , St = St + kt
1080 | , mt = mt + wt + (St >>> 0 < kt >>> 0 ? 1 : 0)
1081 | , St = St + G
1082 | , mt = mt + q + (St >>> 0 < G >>> 0 ? 1 : 0)
1083 | , xt = _t + vt
1084 | , bt = pt + dt + (xt >>> 0 < _t >>> 0 ? 1 : 0);
1085 | j = X,
1086 | N = L,
1087 | X = I,
1088 | L = K,
1089 | I = O,
1090 | K = U,
1091 | U = W + St | 0,
1092 | O = P + mt + (U >>> 0 < W >>> 0 ? 1 : 0) | 0,
1093 | P = M,
1094 | W = F,
1095 | M = R,
1096 | F = E,
1097 | R = C,
1098 | E = D,
1099 | D = St + xt | 0,
1100 | C = mt + bt + (D >>> 0 < St >>> 0 ? 1 : 0) | 0
1101 | }
1102 | v = i.low = v + D,
1103 | i.high = d + C + (v >>> 0 < D >>> 0 ? 1 : 0),
1104 | _ = n.low = _ + E,
1105 | n.high = p + R + (_ >>> 0 < E >>> 0 ? 1 : 0),
1106 | g = o.low = g + F,
1107 | o.high = y + M + (g >>> 0 < F >>> 0 ? 1 : 0),
1108 | w = s.low = w + W,
1109 | s.high = B + P + (w >>> 0 < W >>> 0 ? 1 : 0),
1110 | S = a.low = S + U,
1111 | a.high = k + O + (S >>> 0 < U >>> 0 ? 1 : 0),
1112 | x = c.low = x + K,
1113 | c.high = m + I + (x >>> 0 < K >>> 0 ? 1 : 0),
1114 | H = f.low = H + L,
1115 | f.high = b + X + (H >>> 0 < L >>> 0 ? 1 : 0),
1116 | A = u.low = A + N,
1117 | u.high = z + j + (A >>> 0 < N >>> 0 ? 1 : 0)
1118 | },
1119 | _doFinalize: function () {
1120 | var t = this._data
1121 | , r = t.words
1122 | , e = 8 * this._nDataBytes
1123 | , i = 8 * t.sigBytes;
1124 | r[i >>> 5] |= 128 << 24 - i % 32,
1125 | r[(i + 128 >>> 10 << 5) + 30] = Math.floor(e / 4294967296),
1126 | r[(i + 128 >>> 10 << 5) + 31] = e,
1127 | t.sigBytes = 4 * r.length,
1128 | this._process();
1129 | var n = this._hash.toX32();
1130 | return n
1131 | },
1132 | clone: function () {
1133 | var t = n.clone.call(this);
1134 | return t._hash = this._hash.clone(),
1135 | t
1136 | },
1137 | blockSize: 32
1138 | });
1139 | e.SHA512 = n._createHelper(f),
1140 | e.HmacSHA512 = n._createHmacHelper(f)
1141 | }(),
1142 | function () {
1143 | var r = t
1144 | , e = r.x64
1145 | , i = e.Word
1146 | , n = e.WordArray
1147 | , o = r.algo
1148 | , s = o.SHA512
1149 | , a = o.SHA384 = s.extend({
1150 | _doReset: function () {
1151 | this._hash = new n.init([new i.init(3418070365, 3238371032), new i.init(1654270250, 914150663), new i.init(2438529370, 812702999), new i.init(355462360, 4144912697), new i.init(1731405415, 4290775857), new i.init(2394180231, 1750603025), new i.init(3675008525, 1694076839), new i.init(1203062813, 3204075428)])
1152 | },
1153 | _doFinalize: function () {
1154 | var t = s._doFinalize.call(this);
1155 | return t.sigBytes -= 16,
1156 | t
1157 | }
1158 | });
1159 | r.SHA384 = s._createHelper(a),
1160 | r.HmacSHA384 = s._createHmacHelper(a)
1161 | }(),
1162 | t.lib.Cipher || function (r) {
1163 | var e = t
1164 | , i = e.lib
1165 | , n = i.Base
1166 | , o = i.WordArray
1167 | , s = i.BufferedBlockAlgorithm
1168 | , a = e.enc
1169 | , c = (a.Utf8,
1170 | a.Base64)
1171 | , h = e.algo
1172 | , l = h.EvpKDF
1173 | , f = i.Cipher = s.extend({
1174 | cfg: n.extend(),
1175 | createEncryptor: function (t, r) {
1176 | return this.create(this._ENC_XFORM_MODE, t, r)
1177 | },
1178 | createDecryptor: function (t, r) {
1179 | return this.create(this._DEC_XFORM_MODE, t, r)
1180 | },
1181 | init: function (t, r, e) {
1182 | this.cfg = this.cfg.extend(e),
1183 | this._xformMode = t,
1184 | this._key = r,
1185 | this.reset()
1186 | },
1187 | reset: function () {
1188 | s.reset.call(this),
1189 | this._doReset()
1190 | },
1191 | process: function (t) {
1192 | return this._append(t),
1193 | this._process()
1194 | },
1195 | finalize: function (t) {
1196 | t && this._append(t);
1197 | var r = this._doFinalize();
1198 | return r
1199 | },
1200 | keySize: 4,
1201 | ivSize: 4,
1202 | _ENC_XFORM_MODE: 1,
1203 | _DEC_XFORM_MODE: 2,
1204 | _createHelper: function () {
1205 | function t(t) {
1206 | return "string" == typeof t ? m : w
1207 | }
1208 | return function (r) {
1209 | return {
1210 | encrypt: function (e, i, n) {
1211 | return t(i).encrypt(r, e, i, n)
1212 | },
1213 | decrypt: function (e, i, n) {
1214 | return t(i).decrypt(r, e, i, n)
1215 | }
1216 | }
1217 | }
1218 | }()
1219 | })
1220 | , u = (i.StreamCipher = f.extend({
1221 | _doFinalize: function () {
1222 | var t = this._process(!0);
1223 | return t
1224 | },
1225 | blockSize: 1
1226 | }),
1227 | e.mode = {})
1228 | , d = i.BlockCipherMode = n.extend({
1229 | createEncryptor: function (t, r) {
1230 | return this.Encryptor.create(t, r)
1231 | },
1232 | createDecryptor: function (t, r) {
1233 | return this.Decryptor.create(t, r)
1234 | },
1235 | init: function (t, r) {
1236 | this._cipher = t,
1237 | this._iv = r
1238 | }
1239 | })
1240 | , v = u.CBC = function () {
1241 | function t(t, e, i) {
1242 | var n = this._iv;
1243 | if (n) {
1244 | var o = n;
1245 | this._iv = r
1246 | } else
1247 | var o = this._prevBlock;
1248 | for (var s = 0; s < i; s++)
1249 | t[e + s] ^= o[s]
1250 | }
1251 | var e = d.extend();
1252 | return e.Encryptor = e.extend({
1253 | processBlock: function (r, e) {
1254 | var i = this._cipher
1255 | , n = i.blockSize;
1256 | t.call(this, r, e, n),
1257 | i.encryptBlock(r, e),
1258 | this._prevBlock = r.slice(e, e + n)
1259 | }
1260 | }),
1261 | e.Decryptor = e.extend({
1262 | processBlock: function (r, e) {
1263 | var i = this._cipher
1264 | , n = i.blockSize
1265 | , o = r.slice(e, e + n);
1266 | i.decryptBlock(r, e),
1267 | t.call(this, r, e, n),
1268 | this._prevBlock = o
1269 | }
1270 | }),
1271 | e
1272 | }()
1273 | , p = e.pad = {}
1274 | , _ = p.Pkcs7 = {
1275 | pad: function (t, r) {
1276 | for (var e = 4 * r, i = e - t.sigBytes % e, n = i << 24 | i << 16 | i << 8 | i, s = [], a = 0; a < i; a += 4)
1277 | s.push(n);
1278 | var c = o.create(s, i);
1279 | t.concat(c)
1280 | },
1281 | unpad: function (t) {
1282 | var r = 255 & t.words[t.sigBytes - 1 >>> 2];
1283 | t.sigBytes -= r
1284 | }
1285 | }
1286 | , y = (i.BlockCipher = f.extend({
1287 | cfg: f.cfg.extend({
1288 | mode: v,
1289 | padding: _
1290 | }),
1291 | reset: function () {
1292 | f.reset.call(this);
1293 | var t = this.cfg
1294 | , r = t.iv
1295 | , e = t.mode;
1296 | if (this._xformMode == this._ENC_XFORM_MODE)
1297 | var i = e.createEncryptor;
1298 | else {
1299 | var i = e.createDecryptor;
1300 | this._minBufferSize = 1
1301 | }
1302 | this._mode && this._mode.__creator == i ? this._mode.init(this, r && r.words) : (this._mode = i.call(e, this, r && r.words),
1303 | this._mode.__creator = i)
1304 | },
1305 | _doProcessBlock: function (t, r) {
1306 | this._mode.processBlock(t, r)
1307 | },
1308 | _doFinalize: function () {
1309 | var t = this.cfg.padding;
1310 | if (this._xformMode == this._ENC_XFORM_MODE) {
1311 | t.pad(this._data, this.blockSize);
1312 | var r = this._process(!0)
1313 | } else {
1314 | var r = this._process(!0);
1315 | t.unpad(r)
1316 | }
1317 | return r
1318 | },
1319 | blockSize: 4
1320 | }),
1321 | i.CipherParams = n.extend({
1322 | init: function (t) {
1323 | this.mixIn(t)
1324 | },
1325 | toString: function (t) {
1326 | return (t || this.formatter).stringify(this)
1327 | }
1328 | }))
1329 | , g = e.format = {}
1330 | , B = g.OpenSSL = {
1331 | stringify: function (t) {
1332 | var r = t.ciphertext
1333 | , e = t.salt;
1334 | if (e)
1335 | var i = o.create([1398893684, 1701076831]).concat(e).concat(r);
1336 | else
1337 | var i = r;
1338 | return i.toString(c)
1339 | },
1340 | parse: function (t) {
1341 | var r = c.parse(t)
1342 | , e = r.words;
1343 | if (1398893684 == e[0] && 1701076831 == e[1]) {
1344 | var i = o.create(e.slice(2, 4));
1345 | e.splice(0, 4),
1346 | r.sigBytes -= 16
1347 | }
1348 | return y.create({
1349 | ciphertext: r,
1350 | salt: i
1351 | })
1352 | }
1353 | }
1354 | , w = i.SerializableCipher = n.extend({
1355 | cfg: n.extend({
1356 | format: B
1357 | }),
1358 | encrypt: function (t, r, e, i) {
1359 | i = this.cfg.extend(i);
1360 | var n = t.createEncryptor(e, i)
1361 | , o = n.finalize(r)
1362 | , s = n.cfg;
1363 | return y.create({
1364 | ciphertext: o,
1365 | key: e,
1366 | iv: s.iv,
1367 | algorithm: t,
1368 | mode: s.mode,
1369 | padding: s.padding,
1370 | blockSize: t.blockSize,
1371 | formatter: i.format
1372 | })
1373 | },
1374 | decrypt: function (t, r, e, i) {
1375 | i = this.cfg.extend(i),
1376 | r = this._parse(r, i.format);
1377 | var n = t.createDecryptor(e, i).finalize(r.ciphertext);
1378 | return n
1379 | },
1380 | _parse: function (t, r) {
1381 | return "string" == typeof t ? r.parse(t, this) : t
1382 | }
1383 | })
1384 | , k = e.kdf = {}
1385 | , S = k.OpenSSL = {
1386 | execute: function (t, r, e, i) {
1387 | i || (i = o.random(8));
1388 | var n = l.create({
1389 | keySize: r + e
1390 | }).compute(t, i)
1391 | , s = o.create(n.words.slice(r), 4 * e);
1392 | return n.sigBytes = 4 * r,
1393 | y.create({
1394 | key: n,
1395 | iv: s,
1396 | salt: i
1397 | })
1398 | }
1399 | }
1400 | , m = i.PasswordBasedCipher = w.extend({
1401 | cfg: w.cfg.extend({
1402 | kdf: S
1403 | }),
1404 | encrypt: function (t, r, e, i) {
1405 | i = this.cfg.extend(i);
1406 | var n = i.kdf.execute(e, t.keySize, t.ivSize);
1407 | i.iv = n.iv;
1408 | var o = w.encrypt.call(this, t, r, n.key, i);
1409 | return o.mixIn(n),
1410 | o
1411 | },
1412 | decrypt: function (t, r, e, i) {
1413 | i = this.cfg.extend(i),
1414 | r = this._parse(r, i.format);
1415 | var n = i.kdf.execute(e, t.keySize, t.ivSize, r.salt);
1416 | i.iv = n.iv;
1417 | var o = w.decrypt.call(this, t, r, n.key, i);
1418 | return o
1419 | }
1420 | })
1421 | }(),
1422 | t.mode.CFB = function () {
1423 | function r(t, r, e, i) {
1424 | var n = this._iv;
1425 | if (n) {
1426 | var o = n.slice(0);
1427 | this._iv = void 0
1428 | } else
1429 | var o = this._prevBlock;
1430 | i.encryptBlock(o, 0);
1431 | for (var s = 0; s < e; s++)
1432 | t[r + s] ^= o[s]
1433 | }
1434 | var e = t.lib.BlockCipherMode.extend();
1435 | return e.Encryptor = e.extend({
1436 | processBlock: function (t, e) {
1437 | var i = this._cipher
1438 | , n = i.blockSize;
1439 | r.call(this, t, e, n, i),
1440 | this._prevBlock = t.slice(e, e + n)
1441 | }
1442 | }),
1443 | e.Decryptor = e.extend({
1444 | processBlock: function (t, e) {
1445 | var i = this._cipher
1446 | , n = i.blockSize
1447 | , o = t.slice(e, e + n);
1448 | r.call(this, t, e, n, i),
1449 | this._prevBlock = o
1450 | }
1451 | }),
1452 | e
1453 | }(),
1454 | t.mode.ECB = function () {
1455 | var r = t.lib.BlockCipherMode.extend();
1456 | return r.Encryptor = r.extend({
1457 | processBlock: function (t, r) {
1458 | this._cipher.encryptBlock(t, r)
1459 | }
1460 | }),
1461 | r.Decryptor = r.extend({
1462 | processBlock: function (t, r) {
1463 | this._cipher.decryptBlock(t, r)
1464 | }
1465 | }),
1466 | r
1467 | }(),
1468 | t.pad.AnsiX923 = {
1469 | pad: function (t, r) {
1470 | var e = t.sigBytes
1471 | , i = 4 * r
1472 | , n = i - e % i
1473 | , o = e + n - 1;
1474 | t.clamp(),
1475 | t.words[o >>> 2] |= n << 24 - o % 4 * 8,
1476 | t.sigBytes += n
1477 | },
1478 | unpad: function (t) {
1479 | var r = 255 & t.words[t.sigBytes - 1 >>> 2];
1480 | t.sigBytes -= r
1481 | }
1482 | },
1483 | t.pad.Iso10126 = {
1484 | pad: function (r, e) {
1485 | var i = 4 * e
1486 | , n = i - r.sigBytes % i;
1487 | r.concat(t.lib.WordArray.random(n - 1)).concat(t.lib.WordArray.create([n << 24], 1))
1488 | },
1489 | unpad: function (t) {
1490 | var r = 255 & t.words[t.sigBytes - 1 >>> 2];
1491 | t.sigBytes -= r
1492 | }
1493 | },
1494 | t.pad.Iso97971 = {
1495 | pad: function (r, e) {
1496 | r.concat(t.lib.WordArray.create([2147483648], 1)),
1497 | t.pad.ZeroPadding.pad(r, e)
1498 | },
1499 | unpad: function (r) {
1500 | t.pad.ZeroPadding.unpad(r),
1501 | r.sigBytes--
1502 | }
1503 | },
1504 | t.mode.OFB = function () {
1505 | var r = t.lib.BlockCipherMode.extend()
1506 | , e = r.Encryptor = r.extend({
1507 | processBlock: function (t, r) {
1508 | var e = this._cipher
1509 | , i = e.blockSize
1510 | , n = this._iv
1511 | , o = this._keystream;
1512 | n && (o = this._keystream = n.slice(0),
1513 | this._iv = void 0),
1514 | e.encryptBlock(o, 0);
1515 | for (var s = 0; s < i; s++)
1516 | t[r + s] ^= o[s]
1517 | }
1518 | });
1519 | return r.Decryptor = e,
1520 | r
1521 | }(),
1522 | t.pad.NoPadding = {
1523 | pad: function () { },
1524 | unpad: function () { }
1525 | },
1526 | function (r) {
1527 | var e = t
1528 | , i = e.lib
1529 | , n = i.CipherParams
1530 | , o = e.enc
1531 | , s = o.Hex
1532 | , a = e.format;
1533 | a.Hex = {
1534 | stringify: function (t) {
1535 | return t.ciphertext.toString(s)
1536 | },
1537 | parse: function (t) {
1538 | var r = s.parse(t);
1539 | return n.create({
1540 | ciphertext: r
1541 | })
1542 | }
1543 | }
1544 | }(),
1545 | function () {
1546 | var r = t
1547 | , e = r.lib
1548 | , i = e.BlockCipher
1549 | , n = r.algo
1550 | , o = []
1551 | , s = []
1552 | , a = []
1553 | , c = []
1554 | , h = []
1555 | , l = []
1556 | , f = []
1557 | , u = []
1558 | , d = []
1559 | , v = [];
1560 | !function () {
1561 | for (var t = [], r = 0; r < 256; r++)
1562 | r < 128 ? t[r] = r << 1 : t[r] = r << 1 ^ 283;
1563 | for (var e = 0, i = 0, r = 0; r < 256; r++) {
1564 | var n = i ^ i << 1 ^ i << 2 ^ i << 3 ^ i << 4;
1565 | n = n >>> 8 ^ 255 & n ^ 99,
1566 | o[e] = n,
1567 | s[n] = e;
1568 | var p = t[e]
1569 | , _ = t[p]
1570 | , y = t[_]
1571 | , g = 257 * t[n] ^ 16843008 * n;
1572 | a[e] = g << 24 | g >>> 8,
1573 | c[e] = g << 16 | g >>> 16,
1574 | h[e] = g << 8 | g >>> 24,
1575 | l[e] = g;
1576 | var g = 16843009 * y ^ 65537 * _ ^ 257 * p ^ 16843008 * e;
1577 | f[n] = g << 24 | g >>> 8,
1578 | u[n] = g << 16 | g >>> 16,
1579 | d[n] = g << 8 | g >>> 24,
1580 | v[n] = g,
1581 | e ? (e = p ^ t[t[t[y ^ p]]],
1582 | i ^= t[t[i]]) : e = i = 1
1583 | }
1584 | }();
1585 | var p = [0, 1, 2, 4, 8, 16, 32, 64, 128, 27, 54]
1586 | , _ = n.AES = i.extend({
1587 | _doReset: function () {
1588 | if (!this._nRounds || this._keyPriorReset !== this._key) {
1589 | for (var t = this._keyPriorReset = this._key, r = t.words, e = t.sigBytes / 4, i = this._nRounds = e + 6, n = 4 * (i + 1), s = this._keySchedule = [], a = 0; a < n; a++)
1590 | if (a < e)
1591 | s[a] = r[a];
1592 | else {
1593 | var c = s[a - 1];
1594 | a % e ? e > 6 && a % e == 4 && (c = o[c >>> 24] << 24 | o[c >>> 16 & 255] << 16 | o[c >>> 8 & 255] << 8 | o[255 & c]) : (c = c << 8 | c >>> 24,
1595 | c = o[c >>> 24] << 24 | o[c >>> 16 & 255] << 16 | o[c >>> 8 & 255] << 8 | o[255 & c],
1596 | c ^= p[a / e | 0] << 24),
1597 | s[a] = s[a - e] ^ c
1598 | }
1599 | for (var h = this._invKeySchedule = [], l = 0; l < n; l++) {
1600 | var a = n - l;
1601 | if (l % 4)
1602 | var c = s[a];
1603 | else
1604 | var c = s[a - 4];
1605 | l < 4 || a <= 4 ? h[l] = c : h[l] = f[o[c >>> 24]] ^ u[o[c >>> 16 & 255]] ^ d[o[c >>> 8 & 255]] ^ v[o[255 & c]]
1606 | }
1607 | }
1608 | },
1609 | encryptBlock: function (t, r) {
1610 | this._doCryptBlock(t, r, this._keySchedule, a, c, h, l, o)
1611 | },
1612 | decryptBlock: function (t, r) {
1613 | var e = t[r + 1];
1614 | t[r + 1] = t[r + 3],
1615 | t[r + 3] = e,
1616 | this._doCryptBlock(t, r, this._invKeySchedule, f, u, d, v, s);
1617 | var e = t[r + 1];
1618 | t[r + 1] = t[r + 3],
1619 | t[r + 3] = e
1620 | },
1621 | _doCryptBlock: function (t, r, e, i, n, o, s, a) {
1622 | for (var c = this._nRounds, h = t[r] ^ e[0], l = t[r + 1] ^ e[1], f = t[r + 2] ^ e[2], u = t[r + 3] ^ e[3], d = 4, v = 1; v < c; v++) {
1623 | var p = i[h >>> 24] ^ n[l >>> 16 & 255] ^ o[f >>> 8 & 255] ^ s[255 & u] ^ e[d++]
1624 | , _ = i[l >>> 24] ^ n[f >>> 16 & 255] ^ o[u >>> 8 & 255] ^ s[255 & h] ^ e[d++]
1625 | , y = i[f >>> 24] ^ n[u >>> 16 & 255] ^ o[h >>> 8 & 255] ^ s[255 & l] ^ e[d++]
1626 | , g = i[u >>> 24] ^ n[h >>> 16 & 255] ^ o[l >>> 8 & 255] ^ s[255 & f] ^ e[d++];
1627 | h = p,
1628 | l = _,
1629 | f = y,
1630 | u = g
1631 | }
1632 | var p = (a[h >>> 24] << 24 | a[l >>> 16 & 255] << 16 | a[f >>> 8 & 255] << 8 | a[255 & u]) ^ e[d++]
1633 | , _ = (a[l >>> 24] << 24 | a[f >>> 16 & 255] << 16 | a[u >>> 8 & 255] << 8 | a[255 & h]) ^ e[d++]
1634 | , y = (a[f >>> 24] << 24 | a[u >>> 16 & 255] << 16 | a[h >>> 8 & 255] << 8 | a[255 & l]) ^ e[d++]
1635 | , g = (a[u >>> 24] << 24 | a[h >>> 16 & 255] << 16 | a[l >>> 8 & 255] << 8 | a[255 & f]) ^ e[d++];
1636 | t[r] = p,
1637 | t[r + 1] = _,
1638 | t[r + 2] = y,
1639 | t[r + 3] = g
1640 | },
1641 | keySize: 8
1642 | });
1643 | r.AES = i._createHelper(_)
1644 | }(),
1645 | function () {
1646 | function r(t, r) {
1647 | var e = (this._lBlock >>> t ^ this._rBlock) & r;
1648 | this._rBlock ^= e,
1649 | this._lBlock ^= e << t
1650 | }
1651 | function e(t, r) {
1652 | var e = (this._rBlock >>> t ^ this._lBlock) & r;
1653 | this._lBlock ^= e,
1654 | this._rBlock ^= e << t;
1655 | }
1656 | var i = t
1657 | , n = i.lib
1658 | , o = n.WordArray
1659 | , s = n.BlockCipher
1660 | , a = i.algo
1661 | , c = [57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18, 10, 2, 59, 51, 43, 35, 27, 19, 11, 3, 60, 52, 44, 36, 63, 55, 47, 39, 31, 23, 15, 7, 62, 54, 46, 38, 30, 22, 14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 28, 20, 12, 4]
1662 | , h = [14, 17, 11, 24, 1, 5, 3, 28, 15, 6, 21, 10, 23, 19, 12, 4, 26, 8, 16, 7, 27, 20, 13, 2, 41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48, 44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32]
1663 | , l = [1, 2, 4, 6, 8, 10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28]
1664 | , f = [{
1665 | 0: 8421888,
1666 | 268435456: 32768,
1667 | 536870912: 8421378,
1668 | 805306368: 2,
1669 | 1073741824: 512,
1670 | 1342177280: 8421890,
1671 | 1610612736: 8389122,
1672 | 1879048192: 8388608,
1673 | 2147483648: 514,
1674 | 2415919104: 8389120,
1675 | 2684354560: 33280,
1676 | 2952790016: 8421376,
1677 | 3221225472: 32770,
1678 | 3489660928: 8388610,
1679 | 3758096384: 0,
1680 | 4026531840: 33282,
1681 | 134217728: 0,
1682 | 402653184: 8421890,
1683 | 671088640: 33282,
1684 | 939524096: 32768,
1685 | 1207959552: 8421888,
1686 | 1476395008: 512,
1687 | 1744830464: 8421378,
1688 | 2013265920: 2,
1689 | 2281701376: 8389120,
1690 | 2550136832: 33280,
1691 | 2818572288: 8421376,
1692 | 3087007744: 8389122,
1693 | 3355443200: 8388610,
1694 | 3623878656: 32770,
1695 | 3892314112: 514,
1696 | 4160749568: 8388608,
1697 | 1: 32768,
1698 | 268435457: 2,
1699 | 536870913: 8421888,
1700 | 805306369: 8388608,
1701 | 1073741825: 8421378,
1702 | 1342177281: 33280,
1703 | 1610612737: 512,
1704 | 1879048193: 8389122,
1705 | 2147483649: 8421890,
1706 | 2415919105: 8421376,
1707 | 2684354561: 8388610,
1708 | 2952790017: 33282,
1709 | 3221225473: 514,
1710 | 3489660929: 8389120,
1711 | 3758096385: 32770,
1712 | 4026531841: 0,
1713 | 134217729: 8421890,
1714 | 402653185: 8421376,
1715 | 671088641: 8388608,
1716 | 939524097: 512,
1717 | 1207959553: 32768,
1718 | 1476395009: 8388610,
1719 | 1744830465: 2,
1720 | 2013265921: 33282,
1721 | 2281701377: 32770,
1722 | 2550136833: 8389122,
1723 | 2818572289: 514,
1724 | 3087007745: 8421888,
1725 | 3355443201: 8389120,
1726 | 3623878657: 0,
1727 | 3892314113: 33280,
1728 | 4160749569: 8421378
1729 | }, {
1730 | 0: 1074282512,
1731 | 16777216: 16384,
1732 | 33554432: 524288,
1733 | 50331648: 1074266128,
1734 | 67108864: 1073741840,
1735 | 83886080: 1074282496,
1736 | 100663296: 1073758208,
1737 | 117440512: 16,
1738 | 134217728: 540672,
1739 | 150994944: 1073758224,
1740 | 167772160: 1073741824,
1741 | 184549376: 540688,
1742 | 201326592: 524304,
1743 | 218103808: 0,
1744 | 234881024: 16400,
1745 | 251658240: 1074266112,
1746 | 8388608: 1073758208,
1747 | 25165824: 540688,
1748 | 41943040: 16,
1749 | 58720256: 1073758224,
1750 | 75497472: 1074282512,
1751 | 92274688: 1073741824,
1752 | 109051904: 524288,
1753 | 125829120: 1074266128,
1754 | 142606336: 524304,
1755 | 159383552: 0,
1756 | 176160768: 16384,
1757 | 192937984: 1074266112,
1758 | 209715200: 1073741840,
1759 | 226492416: 540672,
1760 | 243269632: 1074282496,
1761 | 260046848: 16400,
1762 | 268435456: 0,
1763 | 285212672: 1074266128,
1764 | 301989888: 1073758224,
1765 | 318767104: 1074282496,
1766 | 335544320: 1074266112,
1767 | 352321536: 16,
1768 | 369098752: 540688,
1769 | 385875968: 16384,
1770 | 402653184: 16400,
1771 | 419430400: 524288,
1772 | 436207616: 524304,
1773 | 452984832: 1073741840,
1774 | 469762048: 540672,
1775 | 486539264: 1073758208,
1776 | 503316480: 1073741824,
1777 | 520093696: 1074282512,
1778 | 276824064: 540688,
1779 | 293601280: 524288,
1780 | 310378496: 1074266112,
1781 | 327155712: 16384,
1782 | 343932928: 1073758208,
1783 | 360710144: 1074282512,
1784 | 377487360: 16,
1785 | 394264576: 1073741824,
1786 | 411041792: 1074282496,
1787 | 427819008: 1073741840,
1788 | 444596224: 1073758224,
1789 | 461373440: 524304,
1790 | 478150656: 0,
1791 | 494927872: 16400,
1792 | 511705088: 1074266128,
1793 | 528482304: 540672
1794 | }, {
1795 | 0: 260,
1796 | 1048576: 0,
1797 | 2097152: 67109120,
1798 | 3145728: 65796,
1799 | 4194304: 65540,
1800 | 5242880: 67108868,
1801 | 6291456: 67174660,
1802 | 7340032: 67174400,
1803 | 8388608: 67108864,
1804 | 9437184: 67174656,
1805 | 10485760: 65792,
1806 | 11534336: 67174404,
1807 | 12582912: 67109124,
1808 | 13631488: 65536,
1809 | 14680064: 4,
1810 | 15728640: 256,
1811 | 524288: 67174656,
1812 | 1572864: 67174404,
1813 | 2621440: 0,
1814 | 3670016: 67109120,
1815 | 4718592: 67108868,
1816 | 5767168: 65536,
1817 | 6815744: 65540,
1818 | 7864320: 260,
1819 | 8912896: 4,
1820 | 9961472: 256,
1821 | 11010048: 67174400,
1822 | 12058624: 65796,
1823 | 13107200: 65792,
1824 | 14155776: 67109124,
1825 | 15204352: 67174660,
1826 | 16252928: 67108864,
1827 | 16777216: 67174656,
1828 | 17825792: 65540,
1829 | 18874368: 65536,
1830 | 19922944: 67109120,
1831 | 20971520: 256,
1832 | 22020096: 67174660,
1833 | 23068672: 67108868,
1834 | 24117248: 0,
1835 | 25165824: 67109124,
1836 | 26214400: 67108864,
1837 | 27262976: 4,
1838 | 28311552: 65792,
1839 | 29360128: 67174400,
1840 | 30408704: 260,
1841 | 31457280: 65796,
1842 | 32505856: 67174404,
1843 | 17301504: 67108864,
1844 | 18350080: 260,
1845 | 19398656: 67174656,
1846 | 20447232: 0,
1847 | 21495808: 65540,
1848 | 22544384: 67109120,
1849 | 23592960: 256,
1850 | 24641536: 67174404,
1851 | 25690112: 65536,
1852 | 26738688: 67174660,
1853 | 27787264: 65796,
1854 | 28835840: 67108868,
1855 | 29884416: 67109124,
1856 | 30932992: 67174400,
1857 | 31981568: 4,
1858 | 33030144: 65792
1859 | }, {
1860 | 0: 2151682048,
1861 | 65536: 2147487808,
1862 | 131072: 4198464,
1863 | 196608: 2151677952,
1864 | 262144: 0,
1865 | 327680: 4198400,
1866 | 393216: 2147483712,
1867 | 458752: 4194368,
1868 | 524288: 2147483648,
1869 | 589824: 4194304,
1870 | 655360: 64,
1871 | 720896: 2147487744,
1872 | 786432: 2151678016,
1873 | 851968: 4160,
1874 | 917504: 4096,
1875 | 983040: 2151682112,
1876 | 32768: 2147487808,
1877 | 98304: 64,
1878 | 163840: 2151678016,
1879 | 229376: 2147487744,
1880 | 294912: 4198400,
1881 | 360448: 2151682112,
1882 | 425984: 0,
1883 | 491520: 2151677952,
1884 | 557056: 4096,
1885 | 622592: 2151682048,
1886 | 688128: 4194304,
1887 | 753664: 4160,
1888 | 819200: 2147483648,
1889 | 884736: 4194368,
1890 | 950272: 4198464,
1891 | 1015808: 2147483712,
1892 | 1048576: 4194368,
1893 | 1114112: 4198400,
1894 | 1179648: 2147483712,
1895 | 1245184: 0,
1896 | 1310720: 4160,
1897 | 1376256: 2151678016,
1898 | 1441792: 2151682048,
1899 | 1507328: 2147487808,
1900 | 1572864: 2151682112,
1901 | 1638400: 2147483648,
1902 | 1703936: 2151677952,
1903 | 1769472: 4198464,
1904 | 1835008: 2147487744,
1905 | 1900544: 4194304,
1906 | 1966080: 64,
1907 | 2031616: 4096,
1908 | 1081344: 2151677952,
1909 | 1146880: 2151682112,
1910 | 1212416: 0,
1911 | 1277952: 4198400,
1912 | 1343488: 4194368,
1913 | 1409024: 2147483648,
1914 | 1474560: 2147487808,
1915 | 1540096: 64,
1916 | 1605632: 2147483712,
1917 | 1671168: 4096,
1918 | 1736704: 2147487744,
1919 | 1802240: 2151678016,
1920 | 1867776: 4160,
1921 | 1933312: 2151682048,
1922 | 1998848: 4194304,
1923 | 2064384: 4198464
1924 | }, {
1925 | 0: 128,
1926 | 4096: 17039360,
1927 | 8192: 262144,
1928 | 12288: 536870912,
1929 | 16384: 537133184,
1930 | 20480: 16777344,
1931 | 24576: 553648256,
1932 | 28672: 262272,
1933 | 32768: 16777216,
1934 | 36864: 537133056,
1935 | 40960: 536871040,
1936 | 45056: 553910400,
1937 | 49152: 553910272,
1938 | 53248: 0,
1939 | 57344: 17039488,
1940 | 61440: 553648128,
1941 | 2048: 17039488,
1942 | 6144: 553648256,
1943 | 10240: 128,
1944 | 14336: 17039360,
1945 | 18432: 262144,
1946 | 22528: 537133184,
1947 | 26624: 553910272,
1948 | 30720: 536870912,
1949 | 34816: 537133056,
1950 | 38912: 0,
1951 | 43008: 553910400,
1952 | 47104: 16777344,
1953 | 51200: 536871040,
1954 | 55296: 553648128,
1955 | 59392: 16777216,
1956 | 63488: 262272,
1957 | 65536: 262144,
1958 | 69632: 128,
1959 | 73728: 536870912,
1960 | 77824: 553648256,
1961 | 81920: 16777344,
1962 | 86016: 553910272,
1963 | 90112: 537133184,
1964 | 94208: 16777216,
1965 | 98304: 553910400,
1966 | 102400: 553648128,
1967 | 106496: 17039360,
1968 | 110592: 537133056,
1969 | 114688: 262272,
1970 | 118784: 536871040,
1971 | 122880: 0,
1972 | 126976: 17039488,
1973 | 67584: 553648256,
1974 | 71680: 16777216,
1975 | 75776: 17039360,
1976 | 79872: 537133184,
1977 | 83968: 536870912,
1978 | 88064: 17039488,
1979 | 92160: 128,
1980 | 96256: 553910272,
1981 | 100352: 262272,
1982 | 104448: 553910400,
1983 | 108544: 0,
1984 | 112640: 553648128,
1985 | 116736: 16777344,
1986 | 120832: 262144,
1987 | 124928: 537133056,
1988 | 129024: 536871040
1989 | }, {
1990 | 0: 268435464,
1991 | 256: 8192,
1992 | 512: 270532608,
1993 | 768: 270540808,
1994 | 1024: 268443648,
1995 | 1280: 2097152,
1996 | 1536: 2097160,
1997 | 1792: 268435456,
1998 | 2048: 0,
1999 | 2304: 268443656,
2000 | 2560: 2105344,
2001 | 2816: 8,
2002 | 3072: 270532616,
2003 | 3328: 2105352,
2004 | 3584: 8200,
2005 | 3840: 270540800,
2006 | 128: 270532608,
2007 | 384: 270540808,
2008 | 640: 8,
2009 | 896: 2097152,
2010 | 1152: 2105352,
2011 | 1408: 268435464,
2012 | 1664: 268443648,
2013 | 1920: 8200,
2014 | 2176: 2097160,
2015 | 2432: 8192,
2016 | 2688: 268443656,
2017 | 2944: 270532616,
2018 | 3200: 0,
2019 | 3456: 270540800,
2020 | 3712: 2105344,
2021 | 3968: 268435456,
2022 | 4096: 268443648,
2023 | 4352: 270532616,
2024 | 4608: 270540808,
2025 | 4864: 8200,
2026 | 5120: 2097152,
2027 | 5376: 268435456,
2028 | 5632: 268435464,
2029 | 5888: 2105344,
2030 | 6144: 2105352,
2031 | 6400: 0,
2032 | 6656: 8,
2033 | 6912: 270532608,
2034 | 7168: 8192,
2035 | 7424: 268443656,
2036 | 7680: 270540800,
2037 | 7936: 2097160,
2038 | 4224: 8,
2039 | 4480: 2105344,
2040 | 4736: 2097152,
2041 | 4992: 268435464,
2042 | 5248: 268443648,
2043 | 5504: 8200,
2044 | 5760: 270540808,
2045 | 6016: 270532608,
2046 | 6272: 270540800,
2047 | 6528: 270532616,
2048 | 6784: 8192,
2049 | 7040: 2105352,
2050 | 7296: 2097160,
2051 | 7552: 0,
2052 | 7808: 268435456,
2053 | 8064: 268443656
2054 | }, {
2055 | 0: 1048576,
2056 | 16: 33555457,
2057 | 32: 1024,
2058 | 48: 1049601,
2059 | 64: 34604033,
2060 | 80: 0,
2061 | 96: 1,
2062 | 112: 34603009,
2063 | 128: 33555456,
2064 | 144: 1048577,
2065 | 160: 33554433,
2066 | 176: 34604032,
2067 | 192: 34603008,
2068 | 208: 1025,
2069 | 224: 1049600,
2070 | 240: 33554432,
2071 | 8: 34603009,
2072 | 24: 0,
2073 | 40: 33555457,
2074 | 56: 34604032,
2075 | 72: 1048576,
2076 | 88: 33554433,
2077 | 104: 33554432,
2078 | 120: 1025,
2079 | 136: 1049601,
2080 | 152: 33555456,
2081 | 168: 34603008,
2082 | 184: 1048577,
2083 | 200: 1024,
2084 | 216: 34604033,
2085 | 232: 1,
2086 | 248: 1049600,
2087 | 256: 33554432,
2088 | 272: 1048576,
2089 | 288: 33555457,
2090 | 304: 34603009,
2091 | 320: 1048577,
2092 | 336: 33555456,
2093 | 352: 34604032,
2094 | 368: 1049601,
2095 | 384: 1025,
2096 | 400: 34604033,
2097 | 416: 1049600,
2098 | 432: 1,
2099 | 448: 0,
2100 | 464: 34603008,
2101 | 480: 33554433,
2102 | 496: 1024,
2103 | 264: 1049600,
2104 | 280: 33555457,
2105 | 296: 34603009,
2106 | 312: 1,
2107 | 328: 33554432,
2108 | 344: 1048576,
2109 | 360: 1025,
2110 | 376: 34604032,
2111 | 392: 33554433,
2112 | 408: 34603008,
2113 | 424: 0,
2114 | 440: 34604033,
2115 | 456: 1049601,
2116 | 472: 1024,
2117 | 488: 33555456,
2118 | 504: 1048577
2119 | }, {
2120 | 0: 134219808,
2121 | 1: 131072,
2122 | 2: 134217728,
2123 | 3: 32,
2124 | 4: 131104,
2125 | 5: 134350880,
2126 | 6: 134350848,
2127 | 7: 2048,
2128 | 8: 134348800,
2129 | 9: 134219776,
2130 | 10: 133120,
2131 | 11: 134348832,
2132 | 12: 2080,
2133 | 13: 0,
2134 | 14: 134217760,
2135 | 15: 133152,
2136 | 2147483648: 2048,
2137 | 2147483649: 134350880,
2138 | 2147483650: 134219808,
2139 | 2147483651: 134217728,
2140 | 2147483652: 134348800,
2141 | 2147483653: 133120,
2142 | 2147483654: 133152,
2143 | 2147483655: 32,
2144 | 2147483656: 134217760,
2145 | 2147483657: 2080,
2146 | 2147483658: 131104,
2147 | 2147483659: 134350848,
2148 | 2147483660: 0,
2149 | 2147483661: 134348832,
2150 | 2147483662: 134219776,
2151 | 2147483663: 131072,
2152 | 16: 133152,
2153 | 17: 134350848,
2154 | 18: 32,
2155 | 19: 2048,
2156 | 20: 134219776,
2157 | 21: 134217760,
2158 | 22: 134348832,
2159 | 23: 131072,
2160 | 24: 0,
2161 | 25: 131104,
2162 | 26: 134348800,
2163 | 27: 134219808,
2164 | 28: 134350880,
2165 | 29: 133120,
2166 | 30: 2080,
2167 | 31: 134217728,
2168 | 2147483664: 131072,
2169 | 2147483665: 2048,
2170 | 2147483666: 134348832,
2171 | 2147483667: 133152,
2172 | 2147483668: 32,
2173 | 2147483669: 134348800,
2174 | 2147483670: 134217728,
2175 | 2147483671: 134219808,
2176 | 2147483672: 134350880,
2177 | 2147483673: 134217760,
2178 | 2147483674: 134219776,
2179 | 2147483675: 0,
2180 | 2147483676: 133120,
2181 | 2147483677: 2080,
2182 | 2147483678: 131104,
2183 | 2147483679: 134350848
2184 | }]
2185 | , u = [4160749569, 528482304, 33030144, 2064384, 129024, 8064, 504, 2147483679]
2186 | , d = a.DES = s.extend({
2187 | _doReset: function () {
2188 | for (var t = this._key, r = t.words, e = [], i = 0; i < 56; i++) {
2189 | var n = c[i] - 1;
2190 | e[i] = r[n >>> 5] >>> 31 - n % 32 & 1
2191 | }
2192 | for (var o = this._subKeys = [], s = 0; s < 16; s++) {
2193 | for (var a = o[s] = [], f = l[s], i = 0; i < 24; i++)
2194 | a[i / 6 | 0] |= e[(h[i] - 1 + f) % 28] << 31 - i % 6,
2195 | a[4 + (i / 6 | 0)] |= e[28 + (h[i + 24] - 1 + f) % 28] << 31 - i % 6;
2196 | a[0] = a[0] << 1 | a[0] >>> 31;
2197 | for (var i = 1; i < 7; i++)
2198 | a[i] = a[i] >>> 4 * (i - 1) + 3;
2199 | a[7] = a[7] << 5 | a[7] >>> 27
2200 | }
2201 | for (var u = this._invSubKeys = [], i = 0; i < 16; i++)
2202 | u[i] = o[15 - i]
2203 | },
2204 | encryptBlock: function (t, r) {
2205 | this._doCryptBlock(t, r, this._subKeys)
2206 | },
2207 | decryptBlock: function (t, r) {
2208 | this._doCryptBlock(t, r, this._invSubKeys)
2209 | },
2210 | _doCryptBlock: function (t, i, n) {
2211 | this._lBlock = t[i],
2212 | this._rBlock = t[i + 1],
2213 | r.call(this, 4, 252645135),
2214 | r.call(this, 16, 65535),
2215 | e.call(this, 2, 858993459),
2216 | e.call(this, 8, 16711935),
2217 | r.call(this, 1, 1431655765);
2218 | for (var o = 0; o < 16; o++) {
2219 | for (var s = n[o], a = this._lBlock, c = this._rBlock, h = 0, l = 0; l < 8; l++)
2220 | h |= f[l][((c ^ s[l]) & u[l]) >>> 0];
2221 | this._lBlock = c,
2222 | this._rBlock = a ^ h
2223 | }
2224 | var d = this._lBlock;
2225 | this._lBlock = this._rBlock,
2226 | this._rBlock = d,
2227 | r.call(this, 1, 1431655765),
2228 | e.call(this, 8, 16711935),
2229 | e.call(this, 2, 858993459),
2230 | r.call(this, 16, 65535),
2231 | r.call(this, 4, 252645135),
2232 | t[i] = this._lBlock,
2233 | t[i + 1] = this._rBlock
2234 | },
2235 | keySize: 2,
2236 | ivSize: 2,
2237 | blockSize: 2
2238 | });
2239 | i.DES = s._createHelper(d);
2240 | var v = a.TripleDES = s.extend({
2241 | _doReset: function () {
2242 | var t = this._key
2243 | , r = t.words;
2244 | this._des1 = d.createEncryptor(o.create(r.slice(0, 2))),
2245 | this._des2 = d.createEncryptor(o.create(r.slice(2, 4))),
2246 | this._des3 = d.createEncryptor(o.create(r.slice(4, 6)))
2247 | },
2248 | encryptBlock: function (t, r) {
2249 | this._des1.encryptBlock(t, r),
2250 | this._des2.decryptBlock(t, r),
2251 | this._des3.encryptBlock(t, r)
2252 | },
2253 | decryptBlock: function (t, r) {
2254 | this._des3.decryptBlock(t, r),
2255 | this._des2.encryptBlock(t, r),
2256 | this._des1.decryptBlock(t, r)
2257 | },
2258 | keySize: 6,
2259 | ivSize: 2,
2260 | blockSize: 2
2261 | });
2262 | i.TripleDES = s._createHelper(v)
2263 | }(),
2264 | function () {
2265 | function r() {
2266 | for (var t = this._S, r = this._i, e = this._j, i = 0, n = 0; n < 4; n++) {
2267 | r = (r + 1) % 256,
2268 | e = (e + t[r]) % 256;
2269 | var o = t[r];
2270 | t[r] = t[e],
2271 | t[e] = o,
2272 | i |= t[(t[r] + t[e]) % 256] << 24 - 8 * n
2273 | }
2274 | return this._i = r,
2275 | this._j = e,
2276 | i
2277 | }
2278 | var e = t
2279 | , i = e.lib
2280 | , n = i.StreamCipher
2281 | , o = e.algo
2282 | , s = o.RC4 = n.extend({
2283 | _doReset: function () {
2284 | for (var t = this._key, r = t.words, e = t.sigBytes, i = this._S = [], n = 0; n < 256; n++)
2285 | i[n] = n;
2286 | for (var n = 0, o = 0; n < 256; n++) {
2287 | var s = n % e
2288 | , a = r[s >>> 2] >>> 24 - s % 4 * 8 & 255;
2289 | o = (o + i[n] + a) % 256;
2290 | var c = i[n];
2291 | i[n] = i[o],
2292 | i[o] = c
2293 | }
2294 | this._i = this._j = 0
2295 | },
2296 | _doProcessBlock: function (t, e) {
2297 | t[e] ^= r.call(this)
2298 | },
2299 | keySize: 8,
2300 | ivSize: 0
2301 | });
2302 | e.RC4 = n._createHelper(s);
2303 | var a = o.RC4Drop = s.extend({
2304 | cfg: s.cfg.extend({
2305 | drop: 192
2306 | }),
2307 | _doReset: function () {
2308 | s._doReset.call(this);
2309 | for (var t = this.cfg.drop; t > 0; t--)
2310 | r.call(this)
2311 | }
2312 | });
2313 | e.RC4Drop = n._createHelper(a)
2314 | }(),
2315 | t.mode.CTRGladman = function () {
2316 | function r(t) {
2317 | if (255 === (t >> 24 & 255)) {
2318 | var r = t >> 16 & 255
2319 | , e = t >> 8 & 255
2320 | , i = 255 & t;
2321 | 255 === r ? (r = 0,
2322 | 255 === e ? (e = 0,
2323 | 255 === i ? i = 0 : ++i) : ++e) : ++r,
2324 | t = 0,
2325 | t += r << 16,
2326 | t += e << 8,
2327 | t += i
2328 | } else
2329 | t += 1 << 24;
2330 | return t
2331 | }
2332 | function e(t) {
2333 | return 0 === (t[0] = r(t[0])) && (t[1] = r(t[1])),
2334 | t
2335 | }
2336 | var i = t.lib.BlockCipherMode.extend()
2337 | , n = i.Encryptor = i.extend({
2338 | processBlock: function (t, r) {
2339 | var i = this._cipher
2340 | , n = i.blockSize
2341 | , o = this._iv
2342 | , s = this._counter;
2343 | o && (s = this._counter = o.slice(0),
2344 | this._iv = void 0),
2345 | e(s);
2346 | var a = s.slice(0);
2347 | i.encryptBlock(a, 0);
2348 | for (var c = 0; c < n; c++)
2349 | t[r + c] ^= a[c]
2350 | }
2351 | });
2352 | return i.Decryptor = n,
2353 | i
2354 | }(),
2355 | function () {
2356 | function r() {
2357 | for (var t = this._X, r = this._C, e = 0; e < 8; e++)
2358 | a[e] = r[e];
2359 | r[0] = r[0] + 1295307597 + this._b | 0,
2360 | r[1] = r[1] + 3545052371 + (r[0] >>> 0 < a[0] >>> 0 ? 1 : 0) | 0,
2361 | r[2] = r[2] + 886263092 + (r[1] >>> 0 < a[1] >>> 0 ? 1 : 0) | 0,
2362 | r[3] = r[3] + 1295307597 + (r[2] >>> 0 < a[2] >>> 0 ? 1 : 0) | 0,
2363 | r[4] = r[4] + 3545052371 + (r[3] >>> 0 < a[3] >>> 0 ? 1 : 0) | 0,
2364 | r[5] = r[5] + 886263092 + (r[4] >>> 0 < a[4] >>> 0 ? 1 : 0) | 0,
2365 | r[6] = r[6] + 1295307597 + (r[5] >>> 0 < a[5] >>> 0 ? 1 : 0) | 0,
2366 | r[7] = r[7] + 3545052371 + (r[6] >>> 0 < a[6] >>> 0 ? 1 : 0) | 0,
2367 | this._b = r[7] >>> 0 < a[7] >>> 0 ? 1 : 0;
2368 | for (var e = 0; e < 8; e++) {
2369 | var i = t[e] + r[e]
2370 | , n = 65535 & i
2371 | , o = i >>> 16
2372 | , s = ((n * n >>> 17) + n * o >>> 15) + o * o
2373 | , h = ((4294901760 & i) * i | 0) + ((65535 & i) * i | 0);
2374 | c[e] = s ^ h
2375 | }
2376 | t[0] = c[0] + (c[7] << 16 | c[7] >>> 16) + (c[6] << 16 | c[6] >>> 16) | 0,
2377 | t[1] = c[1] + (c[0] << 8 | c[0] >>> 24) + c[7] | 0,
2378 | t[2] = c[2] + (c[1] << 16 | c[1] >>> 16) + (c[0] << 16 | c[0] >>> 16) | 0,
2379 | t[3] = c[3] + (c[2] << 8 | c[2] >>> 24) + c[1] | 0,
2380 | t[4] = c[4] + (c[3] << 16 | c[3] >>> 16) + (c[2] << 16 | c[2] >>> 16) | 0,
2381 | t[5] = c[5] + (c[4] << 8 | c[4] >>> 24) + c[3] | 0,
2382 | t[6] = c[6] + (c[5] << 16 | c[5] >>> 16) + (c[4] << 16 | c[4] >>> 16) | 0,
2383 | t[7] = c[7] + (c[6] << 8 | c[6] >>> 24) + c[5] | 0
2384 | }
2385 | var e = t
2386 | , i = e.lib
2387 | , n = i.StreamCipher
2388 | , o = e.algo
2389 | , s = []
2390 | , a = []
2391 | , c = []
2392 | , h = o.Rabbit = n.extend({
2393 | _doReset: function () {
2394 | for (var t = this._key.words, e = this.cfg.iv, i = 0; i < 4; i++)
2395 | t[i] = 16711935 & (t[i] << 8 | t[i] >>> 24) | 4278255360 & (t[i] << 24 | t[i] >>> 8);
2396 | var n = this._X = [t[0], t[3] << 16 | t[2] >>> 16, t[1], t[0] << 16 | t[3] >>> 16, t[2], t[1] << 16 | t[0] >>> 16, t[3], t[2] << 16 | t[1] >>> 16]
2397 | , o = this._C = [t[2] << 16 | t[2] >>> 16, 4294901760 & t[0] | 65535 & t[1], t[3] << 16 | t[3] >>> 16, 4294901760 & t[1] | 65535 & t[2], t[0] << 16 | t[0] >>> 16, 4294901760 & t[2] | 65535 & t[3], t[1] << 16 | t[1] >>> 16, 4294901760 & t[3] | 65535 & t[0]];
2398 | this._b = 0;
2399 | for (var i = 0; i < 4; i++)
2400 | r.call(this);
2401 | for (var i = 0; i < 8; i++)
2402 | o[i] ^= n[i + 4 & 7];
2403 | if (e) {
2404 | var s = e.words
2405 | , a = s[0]
2406 | , c = s[1]
2407 | , h = 16711935 & (a << 8 | a >>> 24) | 4278255360 & (a << 24 | a >>> 8)
2408 | , l = 16711935 & (c << 8 | c >>> 24) | 4278255360 & (c << 24 | c >>> 8)
2409 | , f = h >>> 16 | 4294901760 & l
2410 | , u = l << 16 | 65535 & h;
2411 | o[0] ^= h,
2412 | o[1] ^= f,
2413 | o[2] ^= l,
2414 | o[3] ^= u,
2415 | o[4] ^= h,
2416 | o[5] ^= f,
2417 | o[6] ^= l,
2418 | o[7] ^= u;
2419 | for (var i = 0; i < 4; i++)
2420 | r.call(this)
2421 | }
2422 | },
2423 | _doProcessBlock: function (t, e) {
2424 | var i = this._X;
2425 | r.call(this),
2426 | s[0] = i[0] ^ i[5] >>> 16 ^ i[3] << 16,
2427 | s[1] = i[2] ^ i[7] >>> 16 ^ i[5] << 16,
2428 | s[2] = i[4] ^ i[1] >>> 16 ^ i[7] << 16,
2429 | s[3] = i[6] ^ i[3] >>> 16 ^ i[1] << 16;
2430 | for (var n = 0; n < 4; n++)
2431 | s[n] = 16711935 & (s[n] << 8 | s[n] >>> 24) | 4278255360 & (s[n] << 24 | s[n] >>> 8),
2432 | t[e + n] ^= s[n]
2433 | },
2434 | blockSize: 4,
2435 | ivSize: 2
2436 | });
2437 | e.Rabbit = n._createHelper(h)
2438 | }(),
2439 | t.mode.CTR = function () {
2440 | var r = t.lib.BlockCipherMode.extend()
2441 | , e = r.Encryptor = r.extend({
2442 | processBlock: function (t, r) {
2443 | var e = this._cipher
2444 | , i = e.blockSize
2445 | , n = this._iv
2446 | , o = this._counter;
2447 | n && (o = this._counter = n.slice(0),
2448 | this._iv = void 0);
2449 | var s = o.slice(0);
2450 | e.encryptBlock(s, 0),
2451 | o[i - 1] = o[i - 1] + 1 | 0;
2452 | for (var a = 0; a < i; a++)
2453 | t[r + a] ^= s[a]
2454 | }
2455 | });
2456 | return r.Decryptor = e,
2457 | r
2458 | }(),
2459 | function () {
2460 | function r() {
2461 | for (var t = this._X, r = this._C, e = 0; e < 8; e++)
2462 | a[e] = r[e];
2463 | r[0] = r[0] + 1295307597 + this._b | 0,
2464 | r[1] = r[1] + 3545052371 + (r[0] >>> 0 < a[0] >>> 0 ? 1 : 0) | 0,
2465 | r[2] = r[2] + 886263092 + (r[1] >>> 0 < a[1] >>> 0 ? 1 : 0) | 0,
2466 | r[3] = r[3] + 1295307597 + (r[2] >>> 0 < a[2] >>> 0 ? 1 : 0) | 0,
2467 | r[4] = r[4] + 3545052371 + (r[3] >>> 0 < a[3] >>> 0 ? 1 : 0) | 0,
2468 | r[5] = r[5] + 886263092 + (r[4] >>> 0 < a[4] >>> 0 ? 1 : 0) | 0,
2469 | r[6] = r[6] + 1295307597 + (r[5] >>> 0 < a[5] >>> 0 ? 1 : 0) | 0,
2470 | r[7] = r[7] + 3545052371 + (r[6] >>> 0 < a[6] >>> 0 ? 1 : 0) | 0,
2471 | this._b = r[7] >>> 0 < a[7] >>> 0 ? 1 : 0;
2472 | for (var e = 0; e < 8; e++) {
2473 | var i = t[e] + r[e]
2474 | , n = 65535 & i
2475 | , o = i >>> 16
2476 | , s = ((n * n >>> 17) + n * o >>> 15) + o * o
2477 | , h = ((4294901760 & i) * i | 0) + ((65535 & i) * i | 0);
2478 | c[e] = s ^ h
2479 | }
2480 | t[0] = c[0] + (c[7] << 16 | c[7] >>> 16) + (c[6] << 16 | c[6] >>> 16) | 0,
2481 | t[1] = c[1] + (c[0] << 8 | c[0] >>> 24) + c[7] | 0,
2482 | t[2] = c[2] + (c[1] << 16 | c[1] >>> 16) + (c[0] << 16 | c[0] >>> 16) | 0,
2483 | t[3] = c[3] + (c[2] << 8 | c[2] >>> 24) + c[1] | 0,
2484 | t[4] = c[4] + (c[3] << 16 | c[3] >>> 16) + (c[2] << 16 | c[2] >>> 16) | 0,
2485 | t[5] = c[5] + (c[4] << 8 | c[4] >>> 24) + c[3] | 0,
2486 | t[6] = c[6] + (c[5] << 16 | c[5] >>> 16) + (c[4] << 16 | c[4] >>> 16) | 0,
2487 | t[7] = c[7] + (c[6] << 8 | c[6] >>> 24) + c[5] | 0
2488 | }
2489 | var e = t
2490 | , i = e.lib
2491 | , n = i.StreamCipher
2492 | , o = e.algo
2493 | , s = []
2494 | , a = []
2495 | , c = []
2496 | , h = o.RabbitLegacy = n.extend({
2497 | _doReset: function () {
2498 | var t = this._key.words
2499 | , e = this.cfg.iv
2500 | , i = this._X = [t[0], t[3] << 16 | t[2] >>> 16, t[1], t[0] << 16 | t[3] >>> 16, t[2], t[1] << 16 | t[0] >>> 16, t[3], t[2] << 16 | t[1] >>> 16]
2501 | , n = this._C = [t[2] << 16 | t[2] >>> 16, 4294901760 & t[0] | 65535 & t[1], t[3] << 16 | t[3] >>> 16, 4294901760 & t[1] | 65535 & t[2], t[0] << 16 | t[0] >>> 16, 4294901760 & t[2] | 65535 & t[3], t[1] << 16 | t[1] >>> 16, 4294901760 & t[3] | 65535 & t[0]];
2502 | this._b = 0;
2503 | for (var o = 0; o < 4; o++)
2504 | r.call(this);
2505 | for (var o = 0; o < 8; o++)
2506 | n[o] ^= i[o + 4 & 7];
2507 | if (e) {
2508 | var s = e.words
2509 | , a = s[0]
2510 | , c = s[1]
2511 | , h = 16711935 & (a << 8 | a >>> 24) | 4278255360 & (a << 24 | a >>> 8)
2512 | , l = 16711935 & (c << 8 | c >>> 24) | 4278255360 & (c << 24 | c >>> 8)
2513 | , f = h >>> 16 | 4294901760 & l
2514 | , u = l << 16 | 65535 & h;
2515 | n[0] ^= h,
2516 | n[1] ^= f,
2517 | n[2] ^= l,
2518 | n[3] ^= u,
2519 | n[4] ^= h,
2520 | n[5] ^= f,
2521 | n[6] ^= l,
2522 | n[7] ^= u;
2523 | for (var o = 0; o < 4; o++)
2524 | r.call(this)
2525 | }
2526 | },
2527 | _doProcessBlock: function (t, e) {
2528 | var i = this._X;
2529 | r.call(this),
2530 | s[0] = i[0] ^ i[5] >>> 16 ^ i[3] << 16,
2531 | s[1] = i[2] ^ i[7] >>> 16 ^ i[5] << 16,
2532 | s[2] = i[4] ^ i[1] >>> 16 ^ i[7] << 16,
2533 | s[3] = i[6] ^ i[3] >>> 16 ^ i[1] << 16;
2534 | for (var n = 0; n < 4; n++)
2535 | s[n] = 16711935 & (s[n] << 8 | s[n] >>> 24) | 4278255360 & (s[n] << 24 | s[n] >>> 8),
2536 | t[e + n] ^= s[n]
2537 | },
2538 | blockSize: 4,
2539 | ivSize: 2
2540 | });
2541 | e.RabbitLegacy = n._createHelper(h)
2542 | }(),
2543 | t.pad.ZeroPadding = {
2544 | pad: function (t, r) {
2545 | var e = 4 * r;
2546 | t.clamp(),
2547 | t.sigBytes += e - (t.sigBytes % e || e)
2548 | },
2549 | unpad: function (t) {
2550 | for (var r = t.words, e = t.sigBytes - 1; !(r[e >>> 2] >>> 24 - e % 4 * 8 & 255);)
2551 | e--;
2552 | t.sigBytes = e + 1
2553 | }
2554 | },
2555 | t
2556 | }
2557 | var a = crypto()
2558 | function des(message, key="u2oh6Vu^HWe40fj") {
2559 | var keyHex = a.enc.Utf8.parse(key);
2560 | var encrypted = a.DES.encrypt(message, keyHex, {
2561 | mode: a.mode.ECB,
2562 | padding: a.pad.Pkcs7
2563 | });
2564 | return encrypted.ciphertext.toString();
2565 | }
2566 |
--------------------------------------------------------------------------------