crypto.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
深澜系统加密模块
实现srun认证所需的各种加密算法
"""

import hashlib
import base64
import json

class SrunCrypto:
    """深澜系统加密类"""
    
    def __init__(self):
        self.enc_version = "srun_bx1"
        self.n = 200
        self.type = 1
        # 修复: 定义深澜自定义的Base64字母表
        self.srun_base64_alphabet = "LVoJPiCN2R8G90yg+hmFHuacZ1OWMnrsSTXkYpUq/3dlbfKwv6xztjI7DeBE45QA"
        self.std_base64_alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
        # 创建翻译表
        self.srun_b64_trans = str.maketrans(self.std_base64_alphabet, self.srun_base64_alphabet)

    def md5(self, text):
        if isinstance(text, str):
            text = text.encode('utf-8')
        return hashlib.md5(text).hexdigest()
    
    def sha1(self, text):
        if isinstance(text, str):
            text = text.encode('utf-8')
        return hashlib.sha1(text).hexdigest()
    
    def hmac_md5(self, password, token):
        return self.md5(password + token)
    
    def base64_encode(self, text):
        """使用深澜自定义的Base64字母表进行编码"""
        # 1. 使用标准Base64编码，注意输入编码为latin1
        std_b64_bytes = base64.b64encode(text.encode('latin1'))
        std_b64_str = std_b64_bytes.decode('latin1')
        # 2. 将标准Base64字符串翻译为深澜自定义Base64字符串
        return std_b64_str.translate(self.srun_b64_trans)

    def xEncode(self, text, key):
        if not text:
            return ""
        
        def str_to_long_array(text, include_length):
            length = len(text)
            v = []
            for i in range(0, length, 4):
                char0 = ord(text[i]) if i < length else 0
                char1 = ord(text[i + 1]) if i + 1 < length else 0
                char2 = ord(text[i + 2]) if i + 2 < length else 0
                char3 = ord(text[i + 3]) if i + 3 < length else 0
                val = char0 | (char1 << 8) | (char2 << 16) | (char3 << 24)
                v.append(val & 0xFFFFFFFF)
            if include_length:
                v.append(length)
            return v
        
        def long_array_to_str(v, include_length):
            length = len(v)
            c = (length - 1) << 2
            if include_length:
                m = v[length - 1]
                if m < c - 3 or m > c:
                    return None
                c = m
            result = []
            for i in range(length):
                val = v[i] & 0xFFFFFFFF
                chars = [
                    chr(val & 0xff),
                    chr((val >> 8) & 0xff),
                    chr((val >> 16) & 0xff),
                    chr((val >> 24) & 0xff)
                ]
                result.extend(chars)
            result_str = ''.join(result)
            if include_length:
                return result_str[:c]
            else:
                return result_str

        v = str_to_long_array(text, True)
        k = str_to_long_array(key, False)
        
        while len(k) < 4:
            k.append(0)
        
        n = len(v) - 1
        if n < 0:
            return ""
        if n == 0:
            return long_array_to_str(v, False)

        z = v[n]
        y = v[0]
        delta = 0x9e3779b9
        q = 6 + 52 // (n + 1)
        sum_val = 0
        
        while q > 0:
            sum_val = (sum_val + delta) & 0xFFFFFFFF
            e = (sum_val >> 2) & 3
            
            for p in range(n):
                y = v[p + 1]
                m1 = (z >> 5) ^ (y << 2)
                m2 = ((y >> 3) ^ (z << 4)) ^ (sum_val ^ y)
                m3 = (k[(p & 3) ^ e] ^ z)
                mx = (m1 + m2 + m3) & 0xFFFFFFFF
                z = v[p] = (v[p] + mx) & 0xFFFFFFFF
            
            y = v[0]
            m1 = (z >> 5) ^ (y << 2)
            m2 = ((y >> 3) ^ (z << 4)) ^ (sum_val ^ y)
            m3 = (k[(n & 3) ^ e] ^ z)
            mx = (m1 + m2 + m3) & 0xFFFFFFFF
            z = v[n] = (v[n] + mx) & 0xFFFFFFFF
            
            q -= 1
        
        return long_array_to_str(v, False)

    def create_info_string(self, username, password, ip, ac_id, token):
        info_data = {
            'username': username,
            'password': password,
            'ip': ip,
            'acid': ac_id,
            'enc_ver': self.enc_version
        }
        json_str = json.dumps(info_data, separators=(',', ':'))
        encrypted = self.xEncode(json_str, token)
        return f"{{SRBX1}}{self.base64_encode(encrypted)}"
    
    def create_chksum(self, token, username, hmd5_password, ac_id, ip, info):
        chkstr = token + username
        chkstr += token + hmd5_password
        chkstr += token + ac_id
        chkstr += token + ip
        chkstr += token + str(self.n)
        chkstr += token + str(self.type)
        chkstr += token + info
        return self.sha1(chkstr)
    
    def get_os_info(self):
        import platform
        system = platform.system()
        if system == 'Darwin':
            return {'device': 'Mac OS', 'platform': 'Macintosh'}
        elif system == 'Windows':
            return {'device': 'Windows NT', 'platform': 'Windows'}
        elif system == 'Linux':
            return {'device': 'Linux', 'platform': 'Linux'}
        else:
            return {'device': 'Unknown', 'platform': 'Unknown'}