forked from sdvcrx/pan-baidu-download
/
bddown_core.py
258 lines (226 loc) · 8.96 KB
/
bddown_core.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
#!/usr/bin/env python2
# coding=utf-8
from __future__ import print_function
import re
import os
import pickle
from time import time
try:
from urllib import unquote as url_unquote
except ImportError:
from urllib.parse import unquote as url_unquote
import requests
from util import logger
from command.config import global_config
BAIDUPAN_SERVER = "http://pan.baidu.com/api/"
class Pan(object):
headers = {
'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko)'
' Chrome/37.0.2062.120 Safari/537.36'
}
def __init__(self):
self.baiduid = ''
self.bduss = ''
self.bdstoken = ''
self.session = requests.Session()
self._load_cookies_from_file()
self.cookies = self.session.cookies
def _load_cookies_from_file(self):
"""Load cookies file if file exist."""
if os.access(global_config.cookies, os.F_OK):
with open(global_config.cookies) as f:
cookies = requests.utils.cookiejar_from_dict(pickle.load(f))
self.session.cookies = cookies
# NOT SURE stoken is bdstoken!
# self.token = self.session.cookies.get('STOKEN')
self.baiduid = self.session.cookies.get('BAIDUID')
self.bduss = self.session.cookies.get('BDUSS')
return True
return False
def _save_img(self, img_url):
"""Download vcode image and save it to path of source code."""
r = self.session.get(img_url)
data = r.content
img_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'vcode.jpg')
with open(img_path, mode='wb') as fp:
fp.write(data)
print("Saved verification code to ", os.path.dirname(os.path.abspath(__file__)))
def _handle_captcha(self, bdstoken=None):
url = BAIDUPAN_SERVER + 'getcaptcha'
d = {}
extra_params = {
'prod': 'share',
}
if bdstoken:
extra_params['bdstoken'] = bdstoken
res = self._request(base_url=url, extra_params=extra_params)
if res.ok:
t = res.json()
self._save_img(t['vcode_img'])
vcode_input = raw_input("Please input the captcha:\n")
d['vcode_str'] = t['vcode_str']
d['vcode_input'] = vcode_input
return d
@staticmethod
def _dict_to_utf8(dictionary):
"""Convert dictionary's value to utf-8"""
if not isinstance(dictionary, dict):
return
for k, v in dictionary.items():
if isinstance(v, unicode):
dictionary[k] = v.encode('utf-8')
def _get_js(self, link, secret=None):
"""Get javascript code in html which contains share files info
:param link: netdisk sharing link(publib or private).
:type link: str
:return str or None
"""
req = self.session.get(link)
if 'init' in req.url:
self.verify_passwd(req.url, secret)
req = self.session.get(link)
data = req.text
js_pattern = re.compile('<script\stype="text/javascript">!function\(\)([^<]+)</script>', re.DOTALL)
js = re.findall(js_pattern, data)
return js[0] or None
def get_dlink(self, link, secret=None):
info = FileInfo()
js = self._get_js(link, secret)
if info.match(js):
extra_params = dict(bdstoken=info.bdstoken, sign=info.sign, timestamp=info.timestamp)
post_form = {
'encrypt': '0',
'product': 'share',
'uk': info.uk,
'primaryid': info.share_id,
'fid_list': '[{0}]'.format(info.fid_list),
}
if self.session.cookies.get('BDCLND'):
post_form['extra'] = '{"sekey":"%s"}' % (url_unquote(self.session.cookies['BDCLND'])),
logger.debug(post_form, extra={'type': 'form', 'method': 'POST'})
url = BAIDUPAN_SERVER + 'sharedownload'
while True:
response = self._request('POST', url, extra_params=extra_params, post_data=post_form)
if not response.ok:
raise UnknownError
_json = response.json()
errno = _json['errno']
logger.debug(_json, extra={'type': 'json', 'method': 'POST'})
if errno == 0:
# FIXME: only support single file for now
dlink = _json['list'][0]['dlink']
setattr(info, 'dlink', dlink)
break
elif errno == -20:
verify_params = self._handle_captcha(info.bdstoken)
post_form.update(verify_params)
response = self._request('POST', url, extra_params=extra_params, post_data=post_form)
_json = response.json()
errno = _json['errno']
continue
elif errno == 116:
raise DownloadError("The share file does not exist")
else:
raise UnknownError
return info
def verify_passwd(self, url, secret=None):
"""
Verify password if url is a private sharing.
:param url: link of private sharing. ('init' must in url)
:type url: str
:param secret: password of the private sharing
:type secret: str
:return: None
"""
if secret:
pwd = secret
else:
# FIXME: Improve translation
pwd = raw_input("Please input this sharing password\n")
data = {'pwd': pwd, 'vcode': ''}
url = "{0}&t={1}&".format(url.replace('init', 'verify'), int(time()))
logger.debug(url, extra={'type': 'url', 'method': 'POST'})
r = self.session.post(url=url, data=data, headers=self.headers)
mesg = r.json()
logger.debug(mesg, extra={'type': 'JSON', 'method': 'POST'})
errno = mesg.get('errno')
if errno == -63:
raise UnknownError
elif errno == -9:
raise VerificationError("提取密码错误\n")
def _request(self, method='GET', base_url='', extra_params=None, post_data=None, **kwargs):
"""
Send a request based on template.
:param method: http method, GET or POST
:param base_url: base url
:param extra_params: extra params for url
:type extra_params: dict
:param post_data: post data. Ignore if method is GET
:type post_data: dict
:return: requests.models.Response or None if invainvalid
"""
params = {
'channel': 'chunlei',
'clienttype': 0,
'web': 1,
'app_id': 250528,
'bdstoken': self.cookies.get('STOKEN')
}
if isinstance(extra_params, dict):
params.update(extra_params)
self._dict_to_utf8(params)
if method == 'GET' and base_url:
response = self.session.get(base_url, params=params, headers=self.headers, **kwargs)
elif method == 'POST' and base_url and post_data:
response = self.session.post(base_url, data=post_data, params=params, headers=self.headers, **kwargs)
else:
response = None
return response
class FileInfo(object):
pattern = re.compile('yunData\.(\w+\s=\s"\w+");')
filename_pattern = re.compile('"server_filename":"([^"]+)"', re.DOTALL)
def __init__(self):
self.share_id = None
self.bdstoken = None
self.uk = None
self.bduss = None
self.fid_list = None
self.sign = None
self.filename = None
self.timestamp = None
def __call__(self, js):
return self.match(js)
def __repr__(self):
return '<FileInfo %r>' % self.share_id
def match(self, js):
_filename = re.search(self.filename_pattern, js)
if _filename:
self.filename = _filename.group(1).decode('unicode_escape')
data = re.findall(self.pattern, js)
if not data:
return False
yun_data = dict([i.split(' = ', 1) for i in data])
logger.debug(yun_data, extra={'method': 'GET', 'type': 'javascript'})
#if 'single' not in yun_data.get('SHAREPAGETYPE') or '0' in yun_data.get('LOGINSTATUS'):
# return False
self.uk = yun_data.get('MYUK').strip('"')
# self.bduss = yun_data.get('MYBDUSS').strip('"')
self.share_id = yun_data.get('SHARE_ID').strip('"')
self.fid_list = yun_data.get('FS_ID').strip('"')
self.sign = yun_data.get('SIGN').strip('"')
if yun_data.get('MYBDSTOKEN'):
self.bdstoken = yun_data.get('MYBDSTOKEN').strip('"')
self.timestamp = yun_data.get('TIMESTAMP').strip('"')
#if self.bdstoken:
# return True
return True
class VerificationError(Exception):
pass
class GetFilenameError(Exception):
pass
class UnknownError(Exception):
pass
class DownloadError(Exception):
pass
if __name__ == '__main__':
pass