https支持检查机制详细文档

// Windows XP (5.1) 及以下版本不支持现代HTTPS
if (platform === 'win32') {
    const majorVersion = parseInt(release.split('.')[0]);
    if (majorVersion < 6) {  // Windows Vista及以上是6.0+
        log('操作系统版本过低不支持HTTPS，退化为HTTP请求');
        return false;
    }
}

// 并行检查多个TLS版本的注册表设置
const tlsVersionsToCheck = [
    { version: '1.3', path: 'TLS 1.3\\Client' },
    { version: '1.2', path: 'TLS 1.2\\Client' },
    { version: '1.1', path: 'TLS 1.1\\Client' }
];

tlsVersionsToCheck.forEach(({ version, path }) => {
    const regCommand = `reg query "HKLM\\SYSTEM\\CurrentControlSet\\Control\\SecurityProviders\\SCHANNEL\\Protocols\\${path}" /v Enabled`;
    
    exec(regCommand, (error, stdout, stderr) => {
        if (!error && stdout.indexOf('0x1') !== -1) {
            // TLS版本已启用
            registryResults.push({
                version: version,
                enabled: true,
                source: 'registry'
            });
        }
    });
});

// 中国国内可靠服务列表
const chineseServices = [
    { host: 'www.baidu.com', port: 443 },
    { host: 'www.qq.com', port: 443 },
    { host: 'www.taobao.com', port: 443 },
    { host: 'www.aliyun.com', port: 443 }
];

// 打乱服务顺序，避免总是从同一个服务开始
const shuffledServices = [...chineseServices].sort(() => Math.random() - 0.5);

function tryNextService() {
    if (attemptIndex >= shuffledServices.length) {
        // 所有服务都尝试失败
        resolve({ supported: false, reason: '所有测试服务均连接失败', version: null });
        return;
    }
    
    const service = shuffledServices[attemptIndex];
    const socket = tls.connect({
        host: service.host,
        port: service.port,
        rejectUnauthorized: false,
        timeout: 4000,
        servername: service.host // SNI参数
    }, () => {
        const version = socket.getProtocol();
        if (version && (version.includes('TLSv1.2') || version.includes('TLSv1.3'))) {
            resolve({ 
                supported: true, 
                version: version, 
                source: attemptIndex === 0 ? 'connection-test' : `connection-test-attempt-${attemptIndex + 1}`, 
                host: service.host,
                attemptCount: attemptIndex + 1
            });
        }
    });
}

servername: service.host // 指定SNI参数

const os = require('os');

// 平台检测
const platform = os.platform(); // 返回: 'win32', 'darwin', 'linux'

// 版本获取
const release = os.release(); // Windows示例: '10.0.19042'

const tls = require('tls');

const socket = tls.connect({
    host: 'www.baidu.com',
    port: 443,
    rejectUnauthorized: false, // 测试模式，忽略证书验证
    timeout: 4000,             // 连接超时
    servername: 'www.baidu.com' // SNI扩展
}, () => {
    // 成功回调
    const protocol = socket.getProtocol(); // 获取TLS版本
    const cipher = socket.getCipher();     // 获取加密套件信息
    const cert = socket.getPeerCertificate(); // 获取证书信息
    
    socket.end(); // 关闭连接
});

// 事件监听
socket.on('error', (error) => {
    // 连接错误处理
});

socket.on('timeout', () => {
    // 超时处理
});

const { exec } = require('child_process');

// Windows注册表查询
const regCommand = 'reg query "HKLM\\SYSTEM\\CurrentControlSet\\Control\\SecurityProviders\\SCHANNEL\\Protocols\\TLS 1.2\\Client" /v Enabled';

exec(regCommand, (error, stdout, stderr) => {
    if (error) {
        // 命令执行失败
        console.error('注册表查询失败:', error.message);
        return;
    }
    
    // 解析输出
    if (stdout.indexOf('0x1') !== -1) {
        console.log('TLS 1.2已启用');
    } else {
        console.log('TLS 1.2未启用');
    }
});

const { ipcMain } = require('electron');

ipcMain.handle('check-https-support', async () => {
    try {
        // 操作系统版本检查
        const platform = os.platform();
        const release = os.release();
        log('操作系统版本: ' + platform + ' ' + release);
        
        // Windows XP排除
        if (platform === 'win32') {
            const majorVersion = parseInt(release.split('.')[0]);
            if (majorVersion < 6) {
                log('操作系统版本过低不支持HTTPS，退化为HTTP请求');
                return false;
            }
        }

        // TLS支持检查
        const tlsSupport = await checkTLSSupport();
        if (!tlsSupport.supported) {
            log(`TLS版本检查失败: ${tlsSupport.reason}, 退化为HTTP请求`);
            return false;
        }

        return true;
    } catch (error) {
        log('检查HTTPS支持时出错: ' + error.message);
        return false;
    }
});

const { contextBridge, ipcRenderer } = require('electron');

contextBridge.exposeInMainWorld('electron', {
    checkHttpsSupport: () => ipcRenderer.invoke('check-https-support'),
    generateLog: (message) => ipcRenderer.invoke('generate-log', message)
});

// 在应用配置初始化时调用
async function initConfig() {
    if (import.meta.env.MODE !== 'development') {
        try {
            window.electron?.generateLog?.('开始检测当前系统HTTPS支持情况（中国国内环境）...');
            
            const supportsHttps = await window.electron.checkHttpsSupport();
            
            if (!supportsHttps) {
                const originalUrl = config.baseUrl;
                config.baseUrl = config.baseUrl.replace('https://', 'http://');
                console.warn('当前系统不支持HTTPS，已退化为HTTP请求');
                
                window.electron?.generateLog?.(`由于系统环境限制，API地址已从 ${originalUrl} 降级为 ${config.baseUrl}`);
            } else {
                window.electron?.generateLog?.('HTTPS支持检测通过，使用HTTPS连接访问服务');
            }
        } catch (error) {
            console.error('检查HTTPS支持时出错:', error);
            window.electron?.generateLog?.(`检查HTTPS支持时出错: ${error.message}`);
        }
    }
    return config;
}

// 检测到不支持HTTPS时
if (!supportsHttps) {
    const originalUrl = config.baseUrl; // 'https://api.example.com'
    config.baseUrl = config.baseUrl.replace('https://', 'http://'); // 'http://api.example.com'
    
    // 更新axios实例
    updateBaseURL(config.baseUrl);
}

// src/axios/index.js
export const updateBaseURL = (newBaseUrl) => {
    if (newBaseUrl) {
        request.defaults.baseURL = newBaseUrl;
        collectLogs(`已更新API基础URL: ${newBaseUrl}`);
    }
};

// src/main.js
import { initializeConfig } from './common/devConfig';
import { updateBaseURL } from './axios/index';

initializeConfig().then((config) => {
    console.log('配置初始化完成');
    updateBaseURL(config.baseUrl);
}).catch(error => {
    console.error('配置初始化失败:', error);
});

tls.connect({
    rejectUnauthorized: false, // 仅用于测试，生产环境应为true
    timeout: 4000,             // 避免长时间连接
    // 不传输敏感数据，仅用于协议检测
});