oauth

1.什么是oauth？

oauth协议为用户资源的授权提供了一个安全的、开放而又建议的标准。oauth的授权不会是第三方初级到用户的账号信息（如用户名与密码），及第三方无需使用用户的用户名与密码就可以申请获得该用户资源的授权，因此oauth是安全的。oauth是Open Authorization的简写

---

2.什么时候用oauth？

为了理解OAuth的适用场合，让我举一个假设的例子。
有一个"云冲印"的网站，可以将用户储存在Google的照片，冲印出来。用户为了使用该服务，必须让"云冲印"读取自己储存在Google上的照片。
问题是只有得到用户的授权，Google才会同意"云冲印"读取这些照片。那么，"云冲印"怎样获得用户的授权呢？

传统方法是，用户将自己的Google用户名和密码，告诉"云冲印"，后者就可以读取用户的照片了。这样的做法有以下几个严重的缺点。

（1）"云冲印"为了后续的服务，会保存用户的密码，这样很不安全。
（2）Google不得不部署密码登录，而我们知道，单纯的密码登录并不安全。
（3）"云冲印"拥有了获取用户储存在Google所有资料的权力，用户没法限制"云冲印"获得授权的范围和有效期。
（4）用户只有修改密码，才能收回赋予"云冲印"的权力。但是这样做，会使得其他所有获得用户授权的第三方应用程序全部失效。
（5）只要有一个第三方应用程序被破解，就会导致用户密码泄漏，以及所有被密码保护的数据泄漏。

OAuth就是为了解决上面这些问题而诞生的。

---

3.oauth用在哪里？

---

4.oauth怎么用？

OAuth在"客户端"与"服务提供商"之间，设置了一个授权层（authorization layer）。"客户端"不能直接登录"服务提供商"，只能登录授权层，以此将用户与客户端区分开来。"客户端"登录授权层所用的令牌（token），与用户的密码不同。用户可以在登录的时候，指定授权层令牌的权限范围和有效期。

"客户端"登录授权层以后，"服务提供商"根据令牌的权限范围和有效期，向"客户端"开放用户储存的资料。

 

oauth.png

（A）用户打开客户端以后，客户端要求用户给予授权。
（B）用户同意给予客户端授权。
（C）客户端使用上一步获得的授权，向认证服务器申请令牌。
（D）认证服务器对客户端进行认证以后，确认无误，同意发放令牌。
（E）客户端使用令牌，向资源服务器申请获取资源。
（F）资源服务器确认令牌无误，同意向客户端开放资源。

客户端的授权模式：
客户端必须得到用户的授权（authorization grant），才能获得令牌（access token）。OAuth 2.0定义了四种授权方式。

• 授权码模式（authorization code）
• 简化模式（implicit）
• 密码模式（resource owner password credentials）
• 客户端模式（client credentials）

import base64
  import random
  import time
  import json
  import hmac
  from datetime import datetime, timedelta
  from flask import Flask, request, redirect,             make_response

  app = Flask(__name__)

  users = {
      ‘lisir‘: [‘123456‘]
  }
  redirect_uri = ‘http://localhost:8888/client/passport‘
  client_id = ‘666666‘
  # 添加用户名到users字典中
  users[client_id] = []
  auth_code = {}
  # 存放重定向uri
  oauth_redirect_uri = []
  #过期时间
  timeout = 3600 * 2

  #新版本token生成器
  def get_token(data):
      ‘‘‘获取token‘‘‘
      data = data.copy()
      if "salt" not in data:
          #随机生成的一个实数，在[0,1)范围内
          data[‘salt‘] = random.random()
      if "expires" not in data:
          #设置过期时间
          data[‘expires‘] = time.time() + timeout
      payload = json.dumps(data).encode(‘utf8‘)
      #生成签名
      sig = _get_signature(payload)
      return encode_token_bytes(payload+sig)


  def get_code(uri, user_id):
      ‘‘‘授权码生成器‘‘‘
      code = random.randint(0, 10000)
      auth_code[code] = [uri, user_id]
      return code


  def verify_token(token):
      ‘‘‘token验证‘‘‘
     decode_token = decode_token_bytes(token)
      payload = decode_token[:-16]
      sig = decode_token[-16:]
      #生成签名
      expected_sig = _get_signature(payload)
      if sig != expected_sig:
          print(‘token验证失败‘)
          return {}
      data = json.loads(payload.decode(‘utf8‘))
      print(data)
      if data.get(‘expires‘) >= time.time():
          return data
      return 0

  #使用hmac为消息生成签名
  def _get_signature(value):
      a = hmac.new(b‘secret1234656‘, value).digest()
      return a

  #base64编码
  def encode_token_bytes(data):
      b = base64.urlsafe_b64encode(data)
      print(b)
      return b

  def decode_token_bytes(data):
      return base64.urlsafe_b64decode(data)


  @app.route(‘/index‘, methods=[‘POST‘, ‘GET‘])
  def index():
      print(request.headers)
      return "hello"

  @app.route(‘/login‘, methods=[‘GET‘, ‘POST‘])
  def login():
      uid, pw =       base64.b64decode(request.headers[‘Authorization‘].split(‘     ‘)[-1]).split(‘:‘)
      if users.get(uid)[0] == pw:
          return get_token(dict(user=uid, pw=pw))
       else:
          return ‘error‘


  @app.route(‘/oauth‘, methods=[‘GET‘, ‘POST‘])
  def oauth():
#处理表单登录，同时设置cookie
if request.method == "POST" and request.form[‘user‘]:
    u = request.form[‘user‘]
    p = request.form[‘pw‘]

    if "".join(users.get(u)) == p and oauth_redirect_uri:
        uri = oauth_redirect_uri[0] + ‘?code=%s‘ % get_code(oauth_redirect_uri[0], u)
        print(uri)
        expire_date = datetime.now() + timedelta(minutes=1)
        #设置cookie
        #make_response接受字符串或错误码会返回一个response对象
        resp = make_response(redirect(uri))
        resp.set_cookie(‘login‘, ‘_‘.join([u, p]), expires=expire_date)
        return resp

#验证授权码，发放token
if request.args.get(‘code‘):
    auth_info = auth_code.get(int(request.args.get(‘code‘)))
    if auth_info[0] == request.args.get(‘redirect_uri‘):
        #可以在授权码的auth_code中存储用户名，曾进token中
        return get_token(dict(client_id=request.args.get(‘client_id‘), user_id=auth_info[1]))

#如果登录用户有Cookie，则直接验证成功，否则需要填写登录表单
if request.args.get(‘redirect_uri‘):
    oauth_redirect_uri.append(request.args.get(‘redirect_uri‘))
    print(oauth_redirect_uri)
    if request.cookies.get(‘login‘):
        u, p = request.cookies.get(‘login‘).split(‘_‘)
        if users.get(u)[0] == p:
            uri = oauth_redirect_uri[0] + ‘?code=%s‘ % get_code(oauth_redirect_uri[0], u)
            print(u, p)
            print(uri)
            return redirect(uri)

    return ‘‘‘
        <form action=‘/oauth‘ method=‘POST‘>
        <p><input type=text name=user>
        <p><input type=text name=pw>
        <p><input type=submit value=Login>
    ‘‘‘



  @app.route(‘/client/login‘, methods=[‘POST‘, ‘GET‘])
  def client_login():
      uri = ‘/oauth?response_type=code&client_id=%s&redirect_uri=%s‘ %     (client_id, redirect_uri)
    return redirect(uri)


@app.route(‘/client/passport‘, methods=[‘POST‘, ‘GET‘])
  def client_passport():
      code = request.args.get(‘code‘)
      uri = ‘http://localhost:8888/oauth?grant_type=authorization_code&code=%s&redirect_uri=%      s&client_id=%s‘ % (code, redirect_uri, client_id )
      print(‘------------‘)
      print(code)
      print(uri)
      return redirect(uri)
      # return code

  #资源服务器
  @app.route(‘/test1‘, methods=[‘GET‘, ‘POST‘])
  def test():
      token = request.args.get(‘token‘)
      print(token)
      ret = verify_token(token)
      if ret:
         return json.dumps(ret)
      else:
          return ‘error‘



  if __name__ == ‘__main__‘:
      app.run(debug=True, port=8888)

对生成token和验证token简单的简单说明，
生成token时:
生成token函数里的参数是一个字典，字典里有user_id 和授权码，在此字典中加上一个随机数salt和过期时间expires，然后使用hmac生成签名；
生成签名后将签名与字典拼接，使用b64进行编码

生成签名：
生成签名函数中，对传来的数据，在加上密匙，然后生成签名，

验证token：
首先对token进行base64解码，然后进行切割成原来的，字典与签名，然后将字典部分进行生成签名，生成后的签名与之前切割出来的签名进行对比验证；
验证通过后，从切割中出来的字典里获取过期时间，与当前时间对比，判断是否过期

简单举例：
生成token
      将数据A进行生成签名为B，将A和B拼接后编码，
验证token
      将token进行解码，切割成A和B，将A进行生成签名为C ，将B和C进行对比验证，验证成功后从A中获取过期时间与当前时间对比判断是否过期，

授权码：
  生成：  随机生成一个数字（0，10000）为键，uri和user_id为值保存为字典
  验证：从字典中获取出uri，与之前oauth_redirect_uri保存的uri对比，验证。