使用API登录知乎并获得token

API_VERSION = '3.0.42'
APP_VERSION = '3.28.0'
APP_BUILD = 'release'
UUID = 'AJDA7XkI9glLBWc85sk-nJ_6F0jqALu4AlY='
UA = 'osee2unifiedRelease/3.28.0 (iPhone; iOS 10.2; Scale/2.00)'
APP_ZA = 'OS=iOS&Release=10.2&Model=iPhone8,1&VersionName=3.28.0&VersionCode=558&Width=750&Height='
CLIENT_ID = '8d5227e0aaaa4797a763ac64e0c3b8'
APP_SECRET = b'ecbefbf6b17e47ecb9035107866380'

ZHIHU_API_ROOT = 'https://api.zhihu.com'
LOGIN_URL = ZHIHU_API_ROOT + '/sign_in'
CAPTCHA_URL = ZHIHU_API_ROOT + '/captcha'

from requests.auth import AuthBase

from config import (
    API_VERSION, APP_VERSION, APP_BUILD, UUID, UA, APP_ZA, CLIENT_ID)


class ZhihuOAuth(AuthBase):
    def __init__(self, token=None):
        self._token = token

    def __call__(self, r):
        r.headers['X-API-Version'] = API_VERSION
        r.headers['X-APP_VERSION'] = APP_VERSION
        r.headers['X-APP-Build'] = APP_BUILD
        r.headers['x-app-za'] = APP_ZA
        r.headers['X-UDID'] = UUID
        r.headers['User-Agent'] = UA
        if self._token is None:
            auth_str = 'oauth {client_id}'.format(
               client_id=CLIENT_ID
            )
        else:
            auth_str = '{type} {token}'.format(
                type=str(self._token.type.capitalize()),
                token=str(self._token.token)
            )
        r.headers['Authorization'] = auth_str
        return r

class ZhihuToken:
    def __init__(self, user_id, uid, access_token, expires_in, token_type,
                 refresh_token, cookie, lock_in=None, unlock_ticket=None):
        self._create_at = time.time()
        self._user_id = uid
        self._uid = user_id
        self._access_token = access_token
        self._expires_in = expires_in
        self._expires_at = self._create_at + self._expires_in
        self._token_type = token_type
        self._refresh_token = refresh_token
        self._cookie = cookie

        # Not used
        self._lock_in = lock_in
        self._unlock_ticket = unlock_ticket

    @classmethod
    def from_file(cls, filename):
        with open(filename) as f:
            return cls.from_dict(json.load(f))

    @staticmethod
    def save_file(filename, data):
        with open(filename, 'w') as f:
            json.dump(data, f)

    @classmethod
    def from_dict(cls, json_dict):
        try:
            return cls(**json_dict)
        except TypeError:
            raise ValueError(
                '"{json_dict}" is NOT a valid zhihu token json.'.format(
                    json_dict=json_dict
                ))

In [1]: from client import ZhihuToken, TOKEN_FILE
In [2]: token = ZhihuToken.from_file(TOKEN_FILE)
In [3]: token._token_type
Out[3]: 'bearer'
In [4]: token._expires_at
Out[4]: 1486884430.011306

TOKEN_FILE = 'token.json'  # 事实上应该放在config.py里面


class ZhihuClient:
    def __init__(self, username=None, passwd=None, token_file=TOKEN_FILE):
        self._session = requests.session()
        self._session.verify = False
        self.username = username
        self.passwd = passwd

        if os.path.exists(token_file):
            self._token = ZhihuToken.from_file(token_file)
        else:
            self._login_auth = ZhihuOAuth()
            json_dict = self.login()
            ZhihuToken.save_file(token_file, json_dict)
        self._session.auth = ZhihuOAuth(self._token)

urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

LOGIN_DATA = {
     'grant_type': 'password',
     'source': 'com.zhihu.ios',
     'client_id': CLIENT_ID
 } 


class ZhihuClient:
    ...
    def login(self):
         data = LOGIN_DATA.copy()
         data['username'] = self.username
         data['password'] = self.passwd
         gen_login_signature(data)

         if self.need_captcha():
             captcha_image = self.get_captcha()
             with open(CAPTCHA_FILE, 'wb') as f:
                 f.write(captcha_image)
             print('Please open {0} for captcha'.format(
                 os.path.abspath(CAPTCHA_FILE)))

             captcha = input('captcha: ')
             os.remove(os.path.abspath(CAPTCHA_FILE))
             res = self._session.post(
                 CAPTCHA_URL,
                 auth=self._login_auth,
                 data={'input_text': captcha}
             )
             try:
                 json_dict = res.json()
                 if 'error' in json_dict:
                     raise LoginException(json_dict['error']['message'])
             except (ValueError, KeyError) as e:
                 raise LoginException('Maybe input wrong captcha value') 

         res = self._session.post(LOGIN_URL, auth=self._login_auth, data=data)
         try:
             json_dict = res.json()
             if 'error' in json_dict:
                 raise LoginException(json_dict['error']['message'])
             self._token = ZhihuToken.from_dict(json_dict)
             return json_dict
         except (ValueError, KeyError) as e:
             raise LoginException(str(e))

def need_captcha(self):
         res = self._session.get(CAPTCHA_URL, auth=self._login_auth)
         try:
             j = res.json()
             return j['show_captcha']
         except KeyError:
             raise LoginException('Show captcha fail!')

import hashlib
import hmac
import time

from config import APP_SECRET


def gen_login_signature(data):
    data['timestamp'] = str(int(time.time()))

    params = ''.join([
        data['grant_type'],
        data['client_id'],
        data['source'],
        data['timestamp'],
    ])

    data['signature'] = hmac.new(
        APP_SECRET, params.encode('utf-8'), hashlib.sha1).hexdigest()