首页
/ 构建网络安全防护体系：从密码学原理到实战应用

构建网络安全防护体系：从密码学原理到实战应用

2026-04-05 09:33:05作者：蔡丛锟
interview
Java 笔试、面试 知识整理
项目地址：https://gitcode.com/gh_mirrors/intervi/interview

解析密码学基础：构建安全通信的核心技术

如何在数字世界中确保信息传递的机密性和完整性？密码学作为网络安全的基石，提供了一系列核心技术来解决这一挑战。本章将深入剖析密码学的基本原理及其在现代安全体系中的应用。

理解对称加密：高效数据保护的基础

对称加密（使用相同密钥进行加密和解密的方式）是数据加密的基础技术，其核心优势在于加密解密速度快，适合处理大量数据。想象对称加密如同使用同一把钥匙锁门和开门，密钥的安全保管至关重要。

常见对称加密算法对比

算法 密钥长度 安全性 性能 应用场景
AES 128/256位 高 高 磁盘加密、VPN
DES 56位 低 中 已淘汰，仅用于兼容性
3DES 168位 中 低 金融系统遗留应用
Blowfish 32-448位 高 高 嵌入式系统

AES加密实现示例

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;

public class AESEncryption {
    private static final String ALGORITHM = "AES";
    private static final String TRANSFORMATION = "AES/ECB/PKCS5Padding";
    
    public static String encrypt(String data, String key) throws Exception {
        SecretKeySpec secretKey = new SecretKeySpec(key.getBytes(), ALGORITHM);
        Cipher cipher = Cipher.getInstance(TRANSFORMATION);
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);
        byte[] encryptedData = cipher.doFinal(data.getBytes());
        return Base64.getEncoder().encodeToString(encryptedData);
    }
    
    public static String decrypt(String encryptedData, String key) throws Exception {
        SecretKeySpec secretKey = new SecretKeySpec(key.getBytes(), ALGORITHM);
        Cipher cipher = Cipher.getInstance(TRANSFORMATION);
        cipher.init(Cipher.DECRYPT_MODE, secretKey);
        byte[] decryptedData = cipher.doFinal(Base64.getDecoder().decode(encryptedData));
        return new String(decryptedData);
    }
}

⚠️ 注意事项：

  • 避免使用ECB模式，因其不提供随机性，相同明文会产生相同密文
  • 密钥管理是对称加密的薄弱环节，需使用安全的密钥分发机制
  • 定期更换密钥可降低密钥泄露风险

实战清单：

  1. 优先选择AES-256算法进行敏感数据加密
  2. 实施严格的密钥生命周期管理，包括生成、分发、存储和销毁
  3. 使用密钥派生函数（如PBKDF2）从密码生成加密密钥
  4. 结合消息认证码（MAC）确保数据完整性

掌握非对称加密：解决密钥分发难题

如何在没有预先共享密钥的情况下安全通信？非对称加密（公钥-私钥配对加密方式）通过数学原理解决了这一挑战，使安全通信成为可能。

非对称加密使用一对相关联的密钥：公钥可以公开分享，任何人都可以用它加密消息；私钥必须保密，用于解密用公钥加密的消息。这一机制彻底改变了密钥分发的安全性。

CA数字签名生成与验证流程

CA数字签名生成与验证流程，展示了如何通过非对称加密确保证书的真实性和完整性

RSA加密实现示例

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import javax.crypto.Cipher;
import java.util.Base64;

public class RSAEncryption {
    private static final String ALGORITHM = "RSA";
    
    public static KeyPair generateKeyPair() throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);
        keyPairGenerator.initialize(2048);
        return keyPairGenerator.generateKeyPair();
    }
    
    public static String encrypt(String data, PublicKey publicKey) throws Exception {
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] encryptedData = cipher.doFinal(data.getBytes());
        return Base64.getEncoder().encodeToString(encryptedData);
    }
    
    public static String decrypt(String encryptedData, PrivateKey privateKey) throws Exception {
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] decryptedData = cipher.doFinal(Base64.getDecoder().decode(encryptedData));
        return new String(decryptedData);
    }
}

⚠️ 注意事项：

  • 非对称加密计算成本高，不适合大量数据加密
  • 通常与对称加密结合使用（混合加密），发挥各自优势
  • 私钥必须安全存储，泄露将导致完全失去安全性

实战清单：

  1. 使用2048位以上密钥长度的RSA算法或更现代的ECC算法
  2. 实施证书固定（Certificate Pinning）防止中间人攻击
  3. 定期轮换密钥对，特别是在怀疑私钥可能泄露时
  4. 使用数字签名验证数据发送者身份和数据完整性

应用密码学技术：构建安全通信通道

在理解密码学基础后，如何将这些技术应用到实际系统中构建安全通信通道？本章将探讨HTTPS协议的工作原理和分布式系统中的安全实践。

实现HTTPS安全通信：从握手到数据传输

如何确保客户端与服务器之间的通信不被窃听或篡改？HTTPS通过TLS/SSL协议在HTTP基础上添加了加密层，为互联网通信提供安全保障。

TLS握手过程是建立安全连接的关键，它通过一系列步骤协商加密参数并验证服务器身份：

TLS握手协议交互流程

TLS握手协议的完整交互流程，展示了客户端和服务器如何建立安全连接

TLS握手关键步骤：

  1. 客户端问候：发送支持的协议版本、加密套件和随机数
  2. 服务器响应：选择协议版本、加密套件，发送服务器证书和随机数
  3. 证书验证：客户端验证服务器证书的有效性
  4. 密钥交换：客户端生成预主密钥，用服务器公钥加密后发送
  5. 会话密钥生成：双方基于交换的随机数和预主密钥生成会话密钥
  6. 连接确认：双方使用会话密钥加密消息，确认安全连接建立

配置安全的HTTPS服务器示例（Nginx）

server {
    listen 443 ssl;
    server_name example.com;
    
    # 证书配置
    ssl_certificate /etc/nginx/certs/example.com.crt;
    ssl_certificate_key /etc/nginx/certs/example.com.key;
    
    # 安全配置
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_prefer_server_ciphers on;
    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384;
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 10m;
    
    # HSTS配置
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
    
    # 其他配置...
    location / {
        proxy_pass http://localhost:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

⚠️ 注意事项：

  • 禁用不安全的TLS版本（TLSv1.0、TLSv1.1）和弱加密套件
  • 配置适当的HSTS头部防止降级攻击
  • 定期更新SSL证书，避免使用过期证书

实战清单：

  1. 使用SSL Labs测试工具评估服务器TLS配置安全性
  2. 实施HTTP到HTTPS的强制重定向
  3. 配置证书吊销检查（OCSP Stapling）
  4. 定期轮换SSL证书，采用自动化工具如Certbot管理Let's Encrypt证书

构建分布式系统安全：一致性与锁机制

在分布式系统中，如何在保证数据一致性的同时确保操作的安全性？分布式系统面临网络延迟、节点故障等挑战，需要特殊的安全机制。

分布式系统的一致性模型决定了系统如何处理多个节点间的数据同步：

分布式系统一致性模型对比

不同一致性模型在分布式系统中的表现差异，展示了线性化一致性、因果一致性和PRAM一致性的区别

分布式锁实现示例（基于Redis）

import redis.clients.jedis.Jedis;
import java.util.Collections;

public class RedisDistributedLock {
    private static final String LOCK_SUCCESS = "OK";
    private static final String SET_IF_NOT_EXIST = "NX";
    private static final String SET_WITH_EXPIRE_TIME = "PX";
    private static final Long RELEASE_SUCCESS = 1L;
    
    private final Jedis jedis;
    private final String lockKey;
    private final int expireTime;
    private String requestId;
    
    public RedisDistributedLock(Jedis jedis, String lockKey, int expireTime) {
        this.jedis = jedis;
        this.lockKey = lockKey;
        this.expireTime = expireTime;
    }
    
    public boolean acquire() {
        requestId = generateRequestId();
        String result = jedis.set(lockKey, requestId, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, expireTime);
        return LOCK_SUCCESS.equals(result);
    }
    
    public boolean release() {
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        Object result = jedis.eval(script, Collections.singletonList(lockKey), Collections.singletonList(requestId));
        return RELEASE_SUCCESS.equals(result);
    }
    
    private String generateRequestId() {
        return java.util.UUID.randomUUID().toString();
    }
}

⚠️ 注意事项：

  • 分布式锁必须设置过期时间，防止死锁
  • 使用唯一请求ID确保只能释放自己持有的锁
  • 考虑使用红锁（Redlock）算法提高分布式锁的可靠性

实战清单：

  1. 根据业务需求选择合适的一致性模型，平衡一致性与可用性
  2. 实现分布式锁时考虑网络延迟和节点故障情况
  3. 使用 fencing token 机制防止锁过期后的资源竞争
  4. 对关键操作实施幂等性设计，防止重复执行

应对安全风险：防御策略与合规要求

在构建安全系统的过程中，如何识别和应对潜在的安全风险？如何确保系统符合行业安全标准和法规要求？本章将探讨常见安全风险的防御策略和安全合规实践。

防御中间人攻击：从理论到实践

中间人攻击（MITM）是如何实施的？如何有效防御这种攻击以保护通信安全？中间人攻击通过拦截和篡改通信内容，可能导致敏感信息泄露或会话劫持。

中间人攻击防御策略：

  1. 证书验证机制

    • 严格验证服务器证书的有效性和完整性
    • 实施证书固定（Certificate Pinning）防止伪造证书
    • 检查证书吊销状态，及时发现已泄露的证书

  2. 安全通信配置

    • 使用TLS 1.2+协议和强加密套件
    • 启用HSTS防止降级攻击
    • 配置安全的Cookie属性（Secure、HttpOnly、SameSite）

  3. 异常检测

    • 监控异常的TLS握手模式
    • 检测证书指纹变化
    • 分析网络流量中的异常模式

证书验证实现示例

import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.security.cert.X509Certificate;

public class CertificatePinning {
    private static final String ALLOWED_CERT_FINGERPRINT = "AA:BB:CC:DD:EE:FF:11:22:33:44:55:66:77:88:99:00:AA:BB:CC:DD";
    
    public void setupSSLSocketFactory() throws Exception {
        SSLContext sslContext = SSLContext.getInstance("TLS");
        sslContext.init(null, new TrustManager[]{new X509TrustManager() {
            @Override
            public void checkClientTrusted(X509Certificate[] chain, String authType) {
                // 客户端证书验证
            }
            
            @Override
            public void checkServerTrusted(X509Certificate[] chain, String authType) {
                // 验证服务器证书指纹
                String fingerprint = getCertificateFingerprint(chain[0]);
                if (!ALLOWED_CERT_FINGERPRINT.equals(fingerprint)) {
                    throw new SecurityException("证书指纹不匹配，可能存在中间人攻击");
                }
            }
            
            @Override
            public X509Certificate[] getAcceptedIssuers() {
                return new X509Certificate[0];
            }
        }}, null);
        
        HttpsURLConnection.setDefaultSSLSocketFactory(sslContext.getSocketFactory());
    }
    
    private String getCertificateFingerprint(X509Certificate cert) {
        // 实现证书指纹计算逻辑
        return "";
    }
}

⚠️ 注意事项：

  • 证书固定可能导致证书更新困难，需设计合理的更新机制
  • 单一证书固定存在单点风险，可考虑固定证书链中的根或中间证书
  • 结合多种防御机制提高安全性，不要依赖单一措施

实战清单：

  1. 实施多层次防御策略，包括网络层、传输层和应用层安全措施
  2. 定期进行安全审计和渗透测试，发现潜在漏洞
  3. 建立安全事件响应机制，快速应对安全威胁
  4. 对开发人员进行安全意识培训，减少人为失误

遵循安全合规标准：行业规范与最佳实践

如何确保系统符合行业安全标准和法规要求？安全合规不仅是法律要求，也是构建用户信任的重要基础。

主要安全合规标准：

标准 适用领域 核心要求
GDPR 欧盟地区数据处理 数据隐私保护、用户知情权、数据删除权
HIPAA 医疗健康行业 患者数据保护、访问控制、审计跟踪
PCI DSS 支付卡行业 卡数据保护、网络安全、漏洞管理
ISO 27001 通用信息安全 信息安全管理体系、风险评估、控制措施

安全合规实施框架：

  1. 风险评估

    • 识别系统中的敏感数据和潜在风险
    • 评估安全威胁发生的可能性和影响
    • 制定风险处理计划

  2. 安全控制

    • 实施访问控制和权限管理
    • 建立数据分类和保护机制
    • 配置安全审计和日志记录

  3. 合规验证

    • 定期进行内部审计
    • 接受第三方合规认证
    • 持续监控和改进安全措施

数据保护实现示例

import java.util.ArrayList;
import java.util.List;

public class DataProtectionManager {
    // 数据分类级别
    public enum DataClassification {
        PUBLIC, INTERNAL, CONFIDENTIAL, RESTRICTED
    }
    
    // 数据脱敏策略
    public String maskSensitiveData(String data, DataClassification classification) {
        if (classification == DataClassification.PUBLIC) {
            return data;
        }
        
        // 对不同类型的敏感数据应用不同的脱敏规则
        if (isCreditCard(data)) {
            return maskCreditCard(data);
        } else if (isPhoneNumber(data)) {
            return maskPhoneNumber(data);
        } else if (isEmail(data)) {
            return maskEmail(data);
        }
        
        // 默认脱敏策略
        return maskDefault(data);
    }
    
    private boolean isCreditCard(String data) {
        // 实现信用卡号验证逻辑
        return false;
    }
    
    private String maskCreditCard(String cardNumber) {
        // 保留前6后4位，中间用*代替
        return cardNumber.replaceAll("(?<=\\d{6})\\d(?=\\d{4})", "*");
    }
    
    // 其他数据类型的验证和脱敏方法...
    
    private String maskDefault(String data) {
        if (data.length() <= 4) {
            return "****";
        }
        return data.substring(0, 2) + 
               "*".repeat(data.length() - 4) + 
               data.substring(data.length() - 2);
    }
}

⚠️ 注意事项：

  • 安全合规是持续过程，需定期更新以适应新的法规要求
  • 合规不仅是技术问题，还需要组织流程和人员意识的配合
  • 过度的安全控制可能影响用户体验，需平衡安全性和可用性

实战清单：

  1. 根据业务所在地区和行业选择适用的合规标准
  2. 建立数据分类机制，对不同级别数据实施差异化保护
  3. 实施数据生命周期管理，包括收集、存储、使用和销毁各阶段
  4. 定期进行合规培训，确保团队了解并遵循安全政策

探索未来趋势：密码学与网络安全的发展方向

随着技术的不断发展，网络安全面临着新的挑战和机遇。本章将探讨密码学和网络安全领域的新兴技术和未来发展趋势。

布隆过滤器：高效数据验证的新范式

如何在大数据场景下高效验证数据存在性并保护隐私？布隆过滤器提供了一种空间效率极高的概率型数据结构，特别适合解决缓存穿透和数据验证问题。

布隆过滤器通过多个哈希函数将元素映射到位数组中，实现快速的存在性判断。虽然存在一定的误判率，但通过合理的参数设置可以将误判率控制在可接受范围内。

布隆过滤器工作原理

布隆过滤器的核心机制，展示了如何通过多个哈希函数在位数组中标记元素

布隆过滤器实现示例

import java.util.BitSet;

public class BloomFilter {
    private final BitSet bitSet;
    private final int size;
    private final int hashCount;
    private final HashFunction[] hashFunctions;
    
    public BloomFilter(int size, int hashCount) {
        this.size = size;
        this.hashCount = hashCount;
        this.bitSet = new BitSet(size);
        this.hashFunctions = new HashFunction[hashCount];
        
        // 初始化多个不同的哈希函数
        for (int i = 0; i < hashCount; i++) {
            hashFunctions[i] = new HashFunction(size, i);
        }
    }
    
    public void add(String element) {
        for (HashFunction hashFunction : hashFunctions) {
            int index = hashFunction.hash(element);
            bitSet.set(index);
        }
    }
    
    public boolean contains(String element) {
        for (HashFunction hashFunction : hashFunctions) {
            int index = hashFunction.hash(element);
            if (!bitSet.get(index)) {
                return false;
            }
        }
        return true;
    }
    
    private static class HashFunction {
        private final int size;
        private final int seed;
        
        public HashFunction(int size, int seed) {
            this.size = size;
            this.seed = seed;
        }
        
        public int hash(String element) {
            int hash = 0;
            for (int i = 0; i < element.length(); i++) {
                hash = seed * hash + element.charAt(i);
            }
            return Math.abs(hash) % size;
        }
    }
}

⚠️ 注意事项：

  • 布隆过滤器存在误判率，不适合需要100%准确判断的场景
  • 无法从布隆过滤器中删除元素，如需支持删除需使用计数布隆过滤器
  • 合理选择位数组大小和哈希函数数量，平衡空间占用和误判率

实战清单：

  1. 使用布隆过滤器减轻数据库查询压力，防止缓存穿透
  2. 在分布式系统中用于节点发现和路由表管理
  3. 实现高效的垃圾邮件过滤和恶意URL检测
  4. 结合其他数据结构弥补布隆过滤器的局限性

分布式锁与Fencing Token：确保并发操作安全

在分布式系统中，如何防止因节点故障或网络延迟导致的资源竞争问题？Fencing Token机制为分布式锁提供了额外的安全保障。

Fencing Token是一个单调递增的数字，每次获取锁时由锁服务生成并返回。资源服务器只接受带有最新Token的操作请求，即使旧锁持有者恢复连接，其请求也会被拒绝。

分布式锁与Fencing Token防护机制

Fencing Token机制在分布式锁中的应用，防止GC暂停等异常场景下的数据冲突

基于Fencing Token的分布式锁实现

public class DistributedLockWithFencing {
    private final LockService lockService;
    private final String resourceId;
    private long currentToken;
    private boolean isLocked;
    
    public DistributedLockWithFencing(LockService lockService, String resourceId) {
        this.lockService = lockService;
        this.resourceId = resourceId;
        this.currentToken = -1;
        this.isLocked = false;
    }
    
    public boolean acquire() {
        LockResult result = lockService.acquireLock(resourceId);
        if (result.isSuccess()) {
            this.currentToken = result.getToken();
            this.isLocked = true;
            return true;
        }
        return false;
    }
    
    public void release() {
        if (isLocked) {
            lockService.releaseLock(resourceId, currentToken);
            isLocked = false;
            currentToken = -1;
        }
    }
    
    public <T> T executeWithLock(ResourceOperation<T> operation) {
        if (!isLocked) {
            throw new IllegalStateException("未获取锁");
        }
        
        // 传递当前Token给资源操作
        return operation.execute(currentToken);
    }
    
    // 资源操作接口
    @FunctionalInterface
    public interface ResourceOperation<T> {
        T execute(long fencingToken);
    }
    
    // 锁服务接口
    public interface LockService {
        LockResult acquireLock(String resourceId);
        void releaseLock(String resourceId, long token);
    }
    
    // 锁结果类
    public static class LockResult {
        private final boolean success;
        private final long token;
        
        public LockResult(boolean success, long token) {
            this.success = success;
            this.token = token;
        }
        
        public boolean isSuccess() { return success; }
        public long getToken() { return token; }
    }
}

资源服务器验证Token示例

public class ResourceServer {
    private final Map<String, Long> lastProcessedToken = new ConcurrentHashMap<>();
    
    public void processOperation(String resourceId, long token, Operation operation) {
        // 检查Token是否有效（单调递增）
        Long lastToken = lastProcessedToken.get(resourceId);
        if (lastToken != null && token <= lastToken) {
            throw new SecurityException("无效的Fencing Token，可能存在过期锁持有者");
        }
        
        // 执行操作
        operation.execute();
        
        // 更新最后处理的Token
        lastProcessedToken.put(resourceId, token);
    }
}

⚠️ 注意事项：

  • Fencing Token必须单调递增，确保旧Token无法被重用
  • 资源服务器必须严格验证Token有效性后再执行操作
  • 结合租约机制自动释放过期锁，防止死锁

实战清单：

  1. 在分布式系统中实现基于Fencing Token的安全锁机制
  2. 确保Token生成器的可靠性和单调性
  3. 在关键业务操作中实施Token验证，防止并发冲突
  4. 结合分布式追踪工具监控锁的获取和释放过程
interview
Java 笔试、面试 知识整理
项目地址：https://gitcode.com/gh_mirrors/intervi/interview
登录后查看全文

相关内容推荐

1 如何构建企业级网络安全架构：从基础到实战的进阶指南2 云安全全景指南：从架构设计到实战落地的完整图谱3 密码学安全实战：构建分布式系统防护体系4 如何构建云安全防线？从理论到实践的完整学习路径5 Linux内核模块安全加固深度剖析与实战指南6 破解智能汽车安全困局：揭秘UDS与CAN总线防御体系7 如何构建企业级云安全防护体系：从基础到实战的全面指南8 云安全防护体系构建：从认知到实践的进阶指南9 密码安全评估工具全解析：从原理到实战应用10 构建企业级云安全防御体系：从理论到实战的全面指南
热门项目推荐
相关项目推荐

热门内容推荐

1 编程实践项目探索指南：从零构建技术能力体系2 技术解构式学习：从0到1构建你的编程知识体系3 构建自己的技术世界：build-your-own-x项目的实践探索指南4 解锁编程技能的实践之旅：从零构建你的技术世界5 技术实践探索：从零开始构建核心系统的实践指南6 亲手锻造技术引擎：从0到1构建核心系统的实践指南

最新内容推荐

AcFunDown视频下载工具完全指南还在为数字笔记抓狂？这款开源神器让手写批注效率提升300%Windows笔记本电池健康管理全指南：从根源解决电池损耗问题gmx_MMPBSA分子间相互作用索引错误的深度诊断与解决Axure RP 11 本地化方案：Mac中文界面优化与原型设计工具汉化全指南如何高效获取教育资源？这款工具让教材下载效率提升80%视频元数据深度编辑：专业技巧与案例网盘直链下载技术解析与应用指南如何用DeepSeek-R1推理模型提升复杂任务解决能力：完整指南5个突破瓶颈技巧：硬件优化工具让你的电脑性能提升30%

项目优选

收起
docsdocs
暂无描述
Dockerfile
726
4.66 K
pytorchpytorch
Ascend Extension for PyTorch
Python
598
750
openHiTLSopenHiTLS
旨在打造算法先进、性能卓越、高效敏捷、安全可靠的密码套件，通过轻量级、可剪裁的软件技术架构满足各行业不同场景的多样化要求，让密码技术应用更简单，同时探索后量子等先进算法创新实践，构建密码前沿技术底座！
C
1.09 K
610
kernelkernel
deepin linux kernel
C
29
16
atomcodeatomcode
Claude Code 的开源替代方案。连接任意大模型，编辑代码，运行命令，自动验证 — 全自动执行。用 Rust 构建，极致性能。 ｜ An open-source alternative to Claude Code. Connect any LLM, edit code, run commands, and verify changes — autonomously. Built in Rust for speed. Get Started
Rust
998
138
kernelkernel
openEuler内核是openEuler操作系统的核心，既是系统性能与稳定性的基石，也是连接处理器、设备与服务的桥梁。
C
427
377
ops-mathops-math
本项目是CANN提供的数学类基础计算算子库，实现网络在NPU上加速计算。
C++
992
986
RuoYi-Vue3RuoYi-Vue3
🎉 (RuoYi)官方仓库 基于SpringBoot，Spring Security，JWT，Vue3 & Vite、Element Plus 的前后端分离权限管理系统
Vue
1.65 K
970
flutter_flutterflutter_flutter
暂无简介
Dart
969
246
MindSpeed-LLMMindSpeed-LLM
昇腾LLM分布式训练框架
Python
162
190