Pastebin

import re
import time
import base64
import hashlib
import requests
import os
import struct
from urllib.parse import urlparse

'''
Supports:
https://vidfast.pro/
'''

class Colors:
    header = '\033[95m'
    okblue = '\033[94m'
    okcyan = '\033[96m'
    okgreen = '\033[92m'
    warning = '\033[93m'
    fail = '\033[91m'
    endc = '\033[0m'
    bold = '\033[1m'
    underline = '\033[4m'


# Constants
base_url = "https://vidfast.pro/movie/533535"
user_agent = "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Mobile Safari/537.36"
default_domain = '{uri.scheme}://{uri.netloc}/'.format(uri=urlparse(base_url))
aes_key = bytes.fromhex("50bb6a529bfb4abb1969c1a29c8cac6df1f00ec63a7297c4c06dcc9473cdacc4")
aes_iv = bytes.fromhex("ffe7765f45669a794181d0b4a8d9e96b")
xor_seed_key = bytes.fromhex("1a5d66c3fbf2")
headers = {
    "Accept": "*/*",
    "Referer": default_domain,
    "User-Agent": user_agent,
    "X-Csrf-Token": "22Xg4bhHnx4uUolyJWs7rdNBbIzYVz8z",
    "X-Requested-With": "XMLHttpRequest"
}

# --- Pure Python AES implementation ---

def xor_bytes(a, b):
    return bytes(x ^ y for x, y in zip(a, b))

def sub_bytes(state):
    SBOX = [
        0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76,
        0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0,0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0,
        0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc,0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15,
        0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a,0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2,0x75,
        0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0,0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84,
        0x53,0xd1,0x00,0xed,0x20,0xfc,0xb1,0x5b,0x6a,0xcb,0xbe,0x39,0x4a,0x4c,0x58,0xcf,
        0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85,0x45,0xf9,0x02,0x7f,0x50,0x3c,0x9f,0xa8,
        0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5,0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2,
        0xcd,0x0c,0x13,0xec,0x5f,0x97,0x44,0x17,0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73,
        0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90,0x88,0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb,
        0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c,0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79,
        0xe7,0xc8,0x37,0x6d,0x8d,0xd5,0x4e,0xa9,0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08,
        0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6,0xe8,0xdd,0x74,0x1f,0x4b,0xbd,0x8b,0x8a,
        0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e,0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e,
        0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94,0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf,
        0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68,0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16,
    ]
    return bytes(SBOX[b] for b in state)

def shift_rows(state):
    s = list(state)
    # Row 1: shift left by 1
    s[1],s[5],s[9],s[13] = s[5],s[9],s[13],s[1]
    # Row 2: shift left by 2
    s[2],s[6],s[10],s[14] = s[10],s[14],s[2],s[6]
    # Row 3: shift left by 3
    s[3],s[7],s[11],s[15] = s[15],s[3],s[7],s[11]
    return bytes(s)

def xtime(a):
    return ((a << 1) ^ 0x1b) & 0xff if a & 0x80 else (a << 1) & 0xff

def mix_column(col):
    a = col
    b = [xtime(x) for x in a]
    return [
        b[0] ^ a[3] ^ a[2] ^ b[1] ^ a[1],
        b[1] ^ a[0] ^ a[3] ^ b[2] ^ a[2],
        b[2] ^ a[1] ^ a[0] ^ b[3] ^ a[3],
        b[3] ^ a[2] ^ a[1] ^ b[0] ^ a[0],
    ]

def mix_columns(state):
    s = list(state)
    result = []
    for col in range(4):
        c = [s[col*4 + row] for row in range(4)]
        m = mix_column(c)
        result.extend(m)
    return bytes(result)

def add_round_key(state, round_key):
    return xor_bytes(state, round_key)

RCON = [0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x1b,0x36]

def key_expansion(key):
    SBOX = [
        0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76,
        0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0,0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0,
        0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc,0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15,
        0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a,0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2,0x75,
        0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0,0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84,
        0x53,0xd1,0x00,0xed,0x20,0xfc,0xb1,0x5b,0x6a,0xcb,0xbe,0x39,0x4a,0x4c,0x58,0xcf,
        0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85,0x45,0xf9,0x02,0x7f,0x50,0x3c,0x9f,0xa8,
        0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5,0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2,
        0xcd,0x0c,0x13,0xec,0x5f,0x97,0x44,0x17,0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73,
        0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90,0x88,0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb,
        0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c,0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79,
        0xe7,0xc8,0x37,0x6d,0x8d,0xd5,0x4e,0xa9,0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08,
        0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6,0xe8,0xdd,0x74,0x1f,0x4b,0xbd,0x8b,0x8a,
        0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e,0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e,
        0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94,0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf,
        0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68,0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16,
    ]
    key_len = len(key)  # 32 for AES-256
    n = key_len // 4    # 8 words
    rounds = 14         # AES-256 = 14 rounds
    total_words = (rounds + 1) * 4

    W = [key[i*4:(i+1)*4] for i in range(n)]

    for i in range(n, total_words):
        temp = list(W[i-1])
        if i % n == 0:
            # RotWord + SubWord + Rcon
            temp = temp[1:] + temp[:1]
            temp = [SBOX[b] for b in temp]
            temp[0] ^= RCON[i // n - 1]
        elif n > 6 and i % n == 4:
            temp = [SBOX[b] for b in temp]
        W.append(bytes(x ^ y for x, y in zip(W[i-n], temp)))

    return [b''.join(W[i*4:(i+1)*4]) for i in range(rounds + 1)]

def aes_encrypt_block(block, round_keys):
    state = add_round_key(block, round_keys[0])
    for rnd in range(1, 14):
        state = sub_bytes(state)
        state = shift_rows(state)
        state = mix_columns(state)
        state = add_round_key(state, round_keys[rnd])
    # Final round (no mix_columns)
    state = sub_bytes(state)
    state = shift_rows(state)
    state = add_round_key(state, round_keys[14])
    return state

def aes_cbc_encrypt(key, iv, data):
    round_keys = key_expansion(key)
    prev = iv
    result = b''
    for i in range(0, len(data), 16):
        block = data[i:i+16]
        block = xor_bytes(block, prev)
        encrypted_block = aes_encrypt_block(block, round_keys)
        result += encrypted_block
        prev = encrypted_block
    return result

# Utility Functions
def custom_encode(input_bytes):
    source_chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_"
    target_chars = "4jrpDdPNYKMiBLgwczuHGksmOIoS2-JVRCnbfl769A0UeE5Qyt_aWq1xTF3vhXZ8"
    translation_table = str.maketrans(source_chars, target_chars)
    encoded = base64.urlsafe_b64encode(input_bytes).decode().rstrip('=')
    return encoded.translate(translation_table)

def generate_ksa(seed, size):
    s = seed if isinstance(seed, bytes) else bytes(seed)
    state = (int.from_bytes(s[0:4],"little") ^ int.from_bytes(s[4:8],"little") ^
             int.from_bytes(s[8:12],"little") ^ int.from_bytes(s[12:16],"little")) & 0xffffffff

    S = list(range(size))
    for i in range(size-1, 0, -1):
        state ^= (state << 13) & 0xffffffff
        state ^= state >> 17
        state ^= (state << 5) & 0xffffffff
        state &= 0xffffffff
        j = state % (i+1)
        S[i], S[j] = S[j], S[i]
    return S

def transform_byte(input_byte, key_byte):
    r = key_byte % 8
    rotated = ((input_byte << r) | (input_byte >> (8 - r))) & 0xff
    return (rotated + (key_byte ^ 0xA5)) & 0xff

def shuffle_blocks(payload, pbox):
    payload_len = len(payload)
    num_blocks = len(pbox)

    if payload_len % num_blocks != 0:
        raise ValueError(f"Payload length ({payload_len}) must be divisible by pbox length ({num_blocks})")

    block_size = payload_len // num_blocks
    result = bytearray(payload_len)

    for dst_idx, src_block in enumerate(pbox):
        src_start = src_block * block_size
        dst_start = dst_idx * block_size
        result[dst_start:dst_start + block_size] = payload[src_start:src_start + block_size]

    return result

# Fetch page content
response = requests.get(base_url, headers=headers).text

# Extract raw data
match = re.search(r'\\"en\\":\\"(.*?)\\"', response)
if not match:
    exit(print("No data found!"))
raw_data = match.group(1)

# Get timestamp bytes
timestamp_bytes = bytearray(8)
timestamp = int(time.time() * 1000)
for i in range(8):
    timestamp_bytes[i] = timestamp & 255
    timestamp >>= 8

# Prepare Input
random_iv = os.urandom(16)
site_buffer = raw_data.encode()
combined_input = random_iv + timestamp_bytes + site_buffer

# PKCS7 padding
pad_len = 16 - len(combined_input) % 16
combined_input += bytes([pad_len]) * pad_len

# Encrypt
encrypted = aes_cbc_encrypt(aes_key, aes_iv, combined_input)
encrypted_bytes = bytearray(encrypted)

# Step 1 XOR
xor_seed = xor_seed_key + random_iv
xor_hash = hashlib.sha256(xor_seed).digest()
xor_output = bytearray(len(encrypted_bytes))

for i in range(len(encrypted_bytes)):
    if i > 0 and i % len(xor_hash) == 0:
        xor_hash = hashlib.sha256(xor_hash).digest()
    xor_output[i] = encrypted_bytes[i] ^ xor_hash[i % len(xor_hash)]

# Step 2 Byte Transform
transform_seed = aes_key + random_iv
transform_hash = hashlib.sha256(transform_seed).digest()
transform_output = bytearray(len(xor_output))
for i in range(len(xor_output)):
    transform_output[i] = transform_byte(xor_output[i], transform_hash[i % len(transform_hash)])

# Step 3 KSA
ksa_seed = random_iv + xor_seed_key + aes_iv
ksa_hash = hashlib.sha256(ksa_seed).digest()
ksa = generate_ksa(ksa_hash, 256)
payload_swaps = []

for b in transform_output:
    idx = b & 0xff
    payload_swaps.append(ksa[idx] & 0xff)

# Step 4 Block Shuffle
permutation_count = len(payload_swaps) // 16
block_shuffle_seed = xor_seed_key + random_iv
block_shuffle_hash = hashlib.sha256(block_shuffle_seed).digest()
perm_ksa = generate_ksa(block_shuffle_hash, permutation_count)
shuffled = shuffle_blocks(payload_swaps, perm_ksa)

# Step 5 Final Permutation
length_byte = bytes([len(shuffled)])
perm_seed = aes_key + random_iv + length_byte
perm_hash = hashlib.sha256(perm_seed).digest()
perm_s_box = generate_ksa(perm_hash, 112)

final_payload = []
for i in range(len(perm_s_box)):
    final_payload.append(shuffled[perm_s_box[i]])

swap_order = []
for v in perm_ksa:
    swap_order.extend([v, 0, 0, 0])

final_buffer = bytes(swap_order) + bytes(final_payload)

# Hash Footer
footer_hash = hashlib.sha256(final_buffer).digest()
footer = footer_hash[:8]
version_buf = bytes([1])
perm_length_buf = bytes([permutation_count, 0])
final_packet = (version_buf + random_iv + perm_length_buf + final_buffer + footer)

# Encode final packet
encoded = custom_encode(final_packet)
reversed_bytes = encoded.encode()[::-1]
servers_token = reversed_bytes.hex()

# Get streaming servers
static_path = "hezushon/8ee77bc2e110fd6e6ac7659b33c6f9146497cb81b1a2694590a68f22c5b495b9/APA91DQqR0e_8UTJpaNhNS9c2Bgrg21PeT12bVxpsCvoUhB9rNLJgMZMHxO7oigbPWv7eXn4NavycM9jt2EGVHBmkXIeSJUXh2AOEvWyji1iNx4Txr2OZONKK5IjKp8GBmmzCCb6-rh1I0o50c5eLc_cZ6KnwX7TrB_UsqfYsbMwBqhvWBEEZ1Q/bdf45bbf7c054d8a75d7575767e40745f967d0a8"
api_servers = f"https://vidfast.pro/{static_path}/N1dm4OEpPc8/{servers_token}"
response = requests.get(api_servers, headers=headers).json()

# Select a random server
server = response[0]['data']
api_stream = f"https://vidfast.pro/{static_path}/HSgMMZOauoo/{server}"
response = requests.get(api_stream, headers=headers).json()

# Extract video URL
video_url = response['url']

# Print results
print("\n" + "#" * 25 + "\n" + "#" * 25)
print(f"Captured URL: {Colors.okgreen}{video_url}{Colors.endc}")
print("#" * 25 + "\n" + "#" * 25)
print(f"{Colors.warning}### Use these headers to access the URL")
print(f"{Colors.okcyan}Referer:{Colors.endc} {default_domain}")