x站播放量_app端_逆向+代理

import re
import datetime
import base64
import requests
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad
import string
import random
import time
import hashlib
import json
import numpy
import blblbf

class BiliBili(object):
    def __init__(self, aid, bvid, cid, duration, proxies):
        self.aid, self.bvid, self.cid, self.duration = aid, bvid, cid, duration

        self.wifi_mac = self.create_random_mac().upper()
        self.device_id = self.create_device_id(self.wifi_mac)
        self.buvid = self.create_buvid_by_wifi()
        self.android_id = self.create_random_mac(sep="").lower()
        
        self.session_id = self.create_session_id()

        self.build_brand = "HUAWEI"
        self.build_model = 'Mate 10 Pro'

        self.fp_local = self.create_local(self.buvid, self.build_model, self.build_brand)
        self.fp_remote = self.create_local(self.buvid, self.build_model, self.build_brand)

        self.build_fingerprint = "OnePlus/OnePlus2/OnePlus2:6.0.1/MMB29M/1447841200:user/release-keys"
        self.build_display = "V417IR release-keys"
        self.app_first_run_time = str(int(time.time()) - random.randint(0, 24 * 60 * 60))  # fts

        self.cookie_dict = {}
        self.hash = None
        self.rsa_pub_key = None
        self.guest_id = None

        self.ts = str(int(time.time() - 10))

        self.session = requests.Session()
        self.session.proxies = proxies

    @staticmethod
    def get_video_id_info(exec_url):
        session = requests.Session()
        header = blblbf.headers
        session.headers.update(header)
        
        res = session.get(exec_url)
        res_text = res.text
        str_data = re.search(r'__INITIAL_STATE__=(.+?);\(func',
                            res_text, flags=re.S).groups()[0]
        data_dict = json.loads(str_data)

        aid = data_dict['aid']
        cid = data_dict['videoData']['cid']
        bvid= data_dict['videoData']['bvid']
        view_count = data_dict['videoData']['stat']['viewseo'] 
        duration = data_dict['videoData']['duration']

        print(f"视频{bvid}平台播放量为：{view_count}")
        return aid, bvid, cid, duration, int(view_count)

    def create_random_mac(self, sep=":"):
        data_list = []
        for i in range(1, 7):
            part = "".join(random.sample("0123456789ABCDEF", 2))
            data_list.append(part)
        mac = sep.join(data_list)
        return mac

    def create_device_id(self, mac):

        def gen_sn():
            return "".join(random.sample("123456789" + string.ascii_lowercase, 10))

        def base64_encrypt(data_string):
            data_bytes = bytearray(data_string.encode('utf-8'))
            data_bytes[0] = data_bytes[0] ^ (len(data_bytes) & 0xFF)
            for i in range(1, len(data_bytes)):
                data_bytes[i] = (data_bytes[i - 1] ^ data_bytes[i]) & 0xFF
            res = base64.encodebytes(bytes(data_bytes))
            return res.strip().strip(b"==").decode('utf-8')


        mac_str = mac


        mac_str = re.sub("[^0-9A-Fa-f]", "", mac_str)
        mac_str = mac_str.lower()

        sn = gen_sn()

        total_string = "{}|||{}".format(mac_str, sn)
        return base64_encrypt(total_string)

    def create_buvid_by_wifi(self):

        md5 = hashlib.md5()
        md5.update(self.wifi_mac.encode('utf-8'))
        v0_1 = md5.hexdigest()
        return "XY{}{}{}{}".format(v0_1[2], v0_1[12], v0_1[22], v0_1).upper()

    def create_session_id(self):
        return "".join([hex(item)[2:] for item in numpy.random.bytes(4)])

    def create_local(self, buvid, phone_model, phone_band):
        
        def a_b(arg8):
            v3 = 0
            v4 = 60
            v0_1 = 2
            v5 = 0
            while True:
                v6 = arg8[v3:v3 + 2]
                v5 += int(v6, base=16)
                if v3 != v4:
                    v3 += v0_1
                    continue
                break
            data = "%02x" % (v5 % 0x100,)
            return data

        def misc_helper_kt(data_bytes):
            data_list = []
            v7 = len(data_bytes)
            v0 = 0
            while v0 < v7:
                v2 = data_bytes[v0]
                data_list.append("%02x" % v2)
                v0 += 1
            return ''.join(data_list)

        data_string = "{}{}{}".format(buvid, phone_model, phone_band)
        hash_object = hashlib.md5()
        hash_object.update(data_string.encode('utf-8'))
        data = hash_object.digest()

        arg1 = misc_helper_kt(data)
        arg2 = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
        arg3 = misc_helper_kt(numpy.random.bytes(8))

        str2 = "{}{}{}".format(arg1, arg2, arg3)
        fp_local = str2 + a_b(str2)
        return fp_local

    def x_report_click_android2(self):
        SALT = "9cafa6466a028bfb"
        KEY = "fd6b639dbcff0c2a1b03b389ec763c4b"
        IV = "77b07a672d57d64c"

        def sha_256_encrypt(data_string):
            sha = hashlib.sha256()
            sha.update(data_string.encode('utf-8'))
            sha.update(SALT.encode('utf-8'))
            return sha.hexdigest()

        def aes_encrypt(data_string):
            aes = AES.new(
                key=KEY.encode('utf-8'),
                mode=AES.MODE_CBC,
                iv=IV.encode('utf-8')
            )
            raw = pad(data_string.encode('utf-8'), 16)
            return aes.encrypt(raw)

        ctime = int(time.time())
        info = {
            'aid': self.aid,
            'cid': self.cid,
            'part': 1,
            'mid': 0,
            'lv': 0,
            'ftime': ctime - random.randint(100, 1000),
            'stime': ctime,
            'did': self.device_id,
            'type': 3,
            'sub_type': 0,
            'sid': '0',
            'epid': '',
            'auto_play': 0,
            'build': 6240300,
            'mobi_app': 'android',
            'spmid': 'main.ugc-video-detail.0.0',
            'from_spmid': 'search.search-result.0.0'
        }
        data = "&".join(["{}={}".format(key, info[key]) for key in sorted(info.keys())])
        sign = sha_256_encrypt(data).lower()
        data = "{}&sign={}".format(data, sign)
        aes_string = aes_encrypt(data)

        res = self.session.post(
            url="https://api.bilibili.com/x/report/click/android2",
            headers={
                "accept-length": "gzip",
                "content-type": "application/json; charset=utf-8",
                "app-key": "android",
                "User-Agent": "Mozilla/5.0 BiliDroid/8.0.0 (bbcallen@gmail.com) os/android model/Mate 10 Pro mobi_app/android build/8000200 channel/alifenfa innerVer/8000210 osVer/12 network/2",
                "env": "prod",
                "buvid": self.buvid,
                "device-id": self.device_id,
                "session_id": self.session_id,
                "fp_local": self.fp_local,
                "fp_remote": self.fp_remote,
            },
            data=aes_string,
            timeout=10

        )
        res.close()


def get_tunnel_proxies(url_get_ip):
    req = requests.get(url=url_get_ip).json()
    proxy_ip = req['data'][0]['ip']
    proxy_port = req['data'][0]['port']
    proxy = str(proxy_ip)+':' + str(proxy_port)
    print('调用ip  '+str(proxy))
    proxies = {"http": f'http://{proxy}', "https": f'http://{proxy}'}
    return proxies

def run(url,c,url_get_ip):
    print('视频链接：'+url)
    aid, bvid, cid, duration, view_count = BiliBili.get_video_id_info(url)
    for i in range(c):
        proxies = get_tunnel_proxies(url_get_ip)
        bili = BiliBili(aid, bvid, cid, duration, proxies=proxies)
        bili.x_report_click_android2()
        bili.session.close()
        view_count += 1
        print("当前理论播放量为", view_count)
        BiliBili.get_video_id_info(url)
        time.sleep(3*random.random()+3)

if __name__ == '__main__':
    url = 'https://www.bilibili.com/video/BVXXXXXXXXX/'
    c =1
    url_get_ip = '代理api'
    run(url,c,url_get_ip)