python Alibaba Cloud oss Implementation of Direct Signature and Callback Verification Example Method

Signature

import base64
import json
import time
from datetime import datetime
import hmac
from hashlib import sha1

access_key_id = ''
#  Please fill out your AccessKeySecret . 
access_key_secret = ''
# host The format of is  bucketname.endpoint  Please replace with your real information. 
host = ''
# callback_url For   Upload the callback server's URL Please set the following IP And Port Configure it as your own true information. 
callback_url = ""
#  The prefix specified by the user when uploading the file. 
upload_dir = 'user-dir-prefix/'
expire_time = 1200
expire_syncpoint = int(time.time() + expire_time)

policy_dict = {
  'expiration': datetime.utcfromtimestamp(expire_syncpoint).isoformat() + 'Z',
  'conditions': [
    {"bucket": "test-paige"},
    ['starts-with', '$key', 'user/test/']
  ]
}
policy = json.dumps(policy_dict).strip()
policy_encode = base64.b64encode(policy.encode())
signature = base64.encodebytes(hmac.new(access_key_secret.encode(), policy_encode, sha1).digest())

callback_dict = {
  'callbackUrl': callback_url,
  'callbackBody': 'filename=${object}&size=${size}&mimeType=${mimeType}&height=${imageInfo.height}&width=${'
          'imageInfo.width}',
  'callbackBodyType': 'application/json'
}

callback = base64.b64encode(json.dumps(callback_dict).strip().encode()).decode()

var = {
  'accessid': access_key_id,
  'host': host,
  'policy': policy_encode.decode(),
  'signature': signature.decode().strip(),
  'expire': expire_syncpoint,
  'callback': callback
}

Callback check

import asyncio
import base64
import time
import aiomysql
import rsa
from aiohttp import web, ClientSession
from urllib import parse
import uuid


def success(msg='', data=None):
  if data is None:
    data = {}
  dict_data = {
    'code': 1,
    'msg': msg,
    'data': data
  }
  return web.json_response(dict_data)


def failed(msg='', data=None):
  if data is None:
    data = {}
  dict_data = {
    'code': 0,
    'msg': msg,
    'data': data
  }
  return web.json_response(dict_data)


async def handle(request):
  """
   Get connection pool 
  :param web.BaseRequest request:
  :return:
  """
  authorization_base64 = request.headers['authorization']
  x_oss_pub_key_url_base64 = request.headers['x-oss-pub-key-url']
  pub_key_url = base64.b64decode(x_oss_pub_key_url_base64.encode())
  authorization = base64.b64decode(authorization_base64.encode())
  path = request.path

  async with ClientSession() as session:
    async with session.get(pub_key_url.decode()) as resp:
      pub_key_body = await resp.text()
      pubkey = rsa.PublicKey.load_pkcs1_openssl_pem(pub_key_body.encode())
      body = await request.content.read()
      auth_str = parse.unquote(path) + '\n' + body.decode()
      parse_url = parse.parse_qs(body.decode())
      print(parse_url)
      try:
        rsa.verify(auth_str.encode(), authorization, pubkey)
        pool = request.app['mysql_pool']
        async with pool.acquire() as conn:
          async with conn.cursor() as cur:
            id = str(uuid.uuid4())
            url = parse_url['filename'][0]
            mime = parse_url['mimeType'][0]
            disk = 'oss'
            time_at = time.strftime("%Y-%m-%d %H:%I:%S", time.localtime())
            sql = "INSERT INTO media(id,url,mime,disk,created_at,updated_at) VALUES(%s,%s,%s,%s,%s,%s)"
            await cur.execute(sql, (id, url, mime, disk, time_at, time_at))
            await conn.commit()
        dict_data = {
          'id': id,
          'url': url,
          'cdn_url': 'https://cdn.***.net' + '/' + url,
          'mime': mime,
          'disk': disk,
          'created_at': time_at,
          'updated_at': time_at,
        }
        return success(data=dict_data)
      except rsa.pkcs1.VerificationError:
        return failed(msg=' Validation error ')


async def init(loop):
  #  Create a connection pool 
  mysql_pool = await aiomysql.create_pool(host='127.0.0.1', port=3306,
                      user='', password='',
                      db='', loop=loop)

  async def on_shutdown(application):
    """
     Upon receiving the off signal , To close the connection pool first , And wait for the connection pool to close successfully .
    :param web.Application application:
    :return:
    """
    application['mysql_pool'].close()
    #  No one will report an error without the following sentence  RuntimeError: Event loop is closed , Because the connection pool closed without really closing the program , Trigger python Error reporting of 
    await application['mysql_pool'].wait_closed()

  application = web.Application()
  application.on_shutdown.append(on_shutdown)
  #  Put the connection pool in  application  In an instance 
  application['mysql_pool'] = mysql_pool
  application.add_routes([web.get('/', handle), web.post('/oss', handle)])
  return application


if __name__ == '__main__':
  loop = asyncio.get_event_loop()
  application = loop.run_until_complete(init(loop))
  web.run_app(application, host='127.0.0.1')
  loop.close()