[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"project-2291":3},{"id":4,"name":5,"fullName":6,"owner":7,"repo":5,"description":8,"homepage":9,"htmlUrl":9,"language":10,"languages":9,"totalLinesOfCode":9,"stars":11,"forks":12,"watchers":13,"openIssues":12,"contributorsCount":12,"subscribersCount":12,"size":12,"stars1d":12,"stars7d":12,"stars30d":14,"stars90d":12,"forks30d":12,"starsTrendScore":12,"compositeScore":15,"rankGlobal":9,"rankLanguage":9,"license":16,"archived":17,"fork":17,"defaultBranch":18,"hasWiki":19,"hasPages":17,"topics":20,"createdAt":9,"pushedAt":9,"updatedAt":21,"readmeContent":22,"aiSummary":23,"trendingCount":12,"starSnapshotCount":12,"syncStatus":24,"lastSyncTime":25,"discoverSource":26},2291,"privacy-preserving-secure-aggregation-fl","Mallikarjun501\u002Fprivacy-preserving-secure-aggregation-fl","Mallikarjun501","Implementation of PSSA: Homomorphic Encryption + Differential Privacy + Byzantine-Resilient Aggregation for Federated Learning on NSL-KDD",null,"Python",101,0,102,1,40.1,"MIT License",false,"main",true,[],"2026-06-12 04:00:14","\u003Cdiv align=\"center\">\n\n# PSSA: Privacy-Preserving and Scalable Secure Aggregation for Federated Learning in Edge Computing\n\nIEEE ICC-ROBINS 2025 - Research Implementation  \nTTEH Lab\n\n![Python](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FPython-3.11-blue)\n![PyTorch](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FPyTorch-2.0+-orange)\n![Paillier HE](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FPaillier_HE-phe_1.5-green)\n![Federated Learning](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FFederated%20Learning-5%20Clients-yellow)\n![Dataset](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FDataset-NSL--KDD-purple)\n![IEEE](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FIEEE-ICC--ROBINS%202025-blue)\n\nImplementation of \"Privacy-Preserving and Scalable Secure Aggregation for Federated Learning in Edge Computing\".\n\nPaper DOI: https:\u002F\u002Fdoi.org\u002F10.1109\u002FICC-ROBINS64345.2025.11086126\n\n\u003C\u002Fdiv>\n\n---\n\n## Overview\n\nPSSA is a practical, end-to-end federated learning implementation designed for edge scenarios where three constraints exist at the same time: data privacy, limited communication capacity, and adversarial reliability risks. Instead of treating these as independent features, this project combines them into one training workflow that can be executed and evaluated directly.\n\nAt runtime, the system launches 6 independent processes (1 server + 5 clients) and trains collaboratively on NSL-KDD shards. Each client trains locally and sends only protected sparse updates, never raw training data. The server coordinates rounds, aggregates updates, applies the global model update rule, evaluates performance, and logs experiment metrics.\n\nThe implementation integrates four key mechanisms in sequence:\n\n- Paillier Homomorphic Encryption (HE) for secure aggregation of encrypted values.\n- Differential Privacy (DP) noise on client deltas to reduce information leakage.\n- Adaptive quantization and sparse gradient sharing to reduce communication payload.\n- Krum-based Byzantine scoring to monitor potentially malicious or anomalous client updates.\n\nThis repository is structured as a reproducible research implementation: it includes distributed server\u002Fclient code, dataset handling, round-level metric logging, and a baseline comparison script (`comparison.py`) that reports FedAvg, SecAgg, DP-FL, and PSSA outcomes. The result is a working FL pipeline that is not only paper-aligned in design, but also runnable and inspectable on a standard development system.\n\nWhen a CUDA-capable GPU is available, the client-side training and server-side evaluation steps automatically move to GPU while the cryptographic aggregation path stays CPU-based.\n\n**Keywords:** Privacy-Preserving, Federated Learning, Secure Aggregation, Homomorphic Encryption, Differential Privacy, Byzantine-Robust, Gradient Compression, Edge Computing, Cybersecurity, NSL-KDD Dataset\n\n---\n\n## Table of Contents\n\n1. Problem Statement\n2. Proposed Solution\n3. How it Works\n4. Pipeline\n5. Results and Metrics\n6. Datasets\n7. Differences from Paper\n8. Project Structure\n9. Setup and Usage\n10. System Requirements\n11. Limitations\n12. Future Improvements\n13. Team Members and Mentor\n14. Laboratory\n\n---\n\n## 1. Problem Statement\n\nFederated learning is attractive for edge and cybersecurity workloads because raw data remains local. However, real deployments face three connected problems:\n\n- Privacy leakage from raw gradients or plaintext updates.\n- Communication and encryption overhead on resource-constrained devices.\n- Adversarial or faulty clients that can poison global training.\n\nConventional FL pipelines often solve only one of these at a time. For example, plain FedAvg is lightweight but weak on privacy; strong secure aggregation improves privacy but can become expensive; Byzantine-robust aggregation helps integrity but adds complexity.\n\nThis project targets the combined problem: deliver a single end-to-end training workflow that is private, efficient, and robust enough to run in a realistic multi-process setup.\n\n---\n\n## 2. Proposed Solution\n\nThe proposed solution in this repository is an integrated PSSA training loop where every client update passes through privacy and efficiency controls before leaving the client.\n\nClient-side flow:\n\n- Train local model for 5 epochs.\n- Compute update delta against received global weights.\n- Apply DP Gaussian noise.\n- Apply adaptive quantization and sparse gradient sharing.\n- Encrypt all non-zero sparse values using Paillier.\n- Send encrypted sparse payload + indices + dataset size.\n\nServer-side flow:\n\n- Securely aggregate encrypted sparse updates.\n- Build per-client decrypted vectors for Krum scoring (monitoring\u002Fdetection role).\n- Apply Weighted FedAvg as the global model update rule.\n- Evaluate model performance and log per-round privacy\u002Fcommunication metrics.\n\nDesign choice used in this implementation:\n\n- Krum is used for Byzantine monitoring and winner logging.\n- Weighted FedAvg is used for the actual model update.\n\n### Core Components\n\n| Component | Purpose | Paper Section |\n|---|---|---|\n| Homomorphic Encryption | Encrypt updates and aggregate securely | III.B |\n| Differential Privacy | Add Gaussian noise to update deltas | III.C |\n| Adaptive Compression | Quantization + sparse sharing for lower comm cost | III.D |\n| Byzantine Resilience | Krum scoring for adversarial monitoring | III.E |\n\n---\n\n## 3. How it Works\n\nThis section explains the complete end-to-end execution flow from startup to final result logging.\n\n### End-to-End Workflow (Start to End)\n\nThe workflow is now structured exactly to match the architecture visually depicted below.\n\n1. **Initialization Phase (server.py, data_loader.py)**  \n   - NSL-KDD dataset is loaded and chunked into 5 client data shards.\n   - The Server initializes the Global Model and creates an Adaptive Controller to track hyper-parameters (\u0007daptive_controller.py).\n\n2. **Round Broadcast (server.py, utils.py)**  \n   - The loop begins for N total federated communication rounds.\n   - The Server broadcasts the Global Model weights and dynamic parameters (e.g. noise scope, sparsity limit) to all 5 client processes over TCP sockets. \n\n3. **Client Local Training (client.py)**  \n   - Each client trains the latest model natively upon its individual data shard.\n   - The client derives a gradient update (delta).\n\n4. **Security & Compression Pipeline (differential_privacy.py, pssa_compression.py)**  \n   - **DP**: Gaussian noise is injected into the local gradients dynamically.\n   - **Quantization**: Gradients are encoded\u002Fbinned down into smaller precision spaces using adaptive thresholds.\n   - **Sparse Sharing**: Only the most significant, non-zero gradient updates are selected for transmission.\n\n5. **Encryption (homomorphic_encryption.py)**  \n   - The client locks its non-zero sparse matrix values using 1024-bit Paillier Homomorphic Encryption.\n\n6. **Encrypted Aggregation & Decryption (server.py, homomorphic_encryption.py)**  \n   - Clients send their secured payloads back to the central server.\n   - The Server performs secure aggregation and then securely decrypts and reconstructs the multidimensional gradient update to a full dense vector shape.\n\n7. **Byzantine Resilience and Updating (\byzantine_resilience.py)**  \n   - A Krum Byzantine monitor reviews the decypted payload, identifying and rejecting potentially malicious outliers.\n   - Valid updates are merged via Weighted Federated Averaging (FedAvg).\n\n8. **Adaption and Evaluation (\u0007daptive_controller.py)**  \n   - The server evaluates the updated Global Model's accuracy.\n   - The Server's AdaptiveController tunes parameters based on evaluated performance loss\u002Fsuccess, dictating properties for the next communication round.\n\n9. **Loop & Result Logging (metrics_logger.py, comparison.py)**  \n   - The process logs epoch metrics like communication cost, testing accuracy, and privacy budgets to \nesults\u002Fmetrics.csv.\n   - The pipeline iterates until all rounds complete, and final plots are auto-generated.\n\n### File Path Mapping by Stage\n\n| Stage | Main File Paths |\n|---|---|\n| Launch and networking | `server.py`, `client.py`, `utils.py` |\n| Data ingest and preprocessing | `data_loader.py`, `KDDTrain+.txt`, `KDDTest+.txt` |\n| Model definition | `model.py` |\n| Differential privacy | `differential_privacy.py` |\n| Compression and sparsification | `pssa_compression.py` |\n| Homomorphic encryption | `homomorphic_encryption.py` |\n| Byzantine monitoring | `byzantine_resilience.py` |\n| Adaptive controls | `adaptive_controller.py` |\n| Metrics and outputs | `metrics_logger.py`, `results\u002Fmetrics.csv`, `results\u002F*.png` |\n\n### Visual Workflow\n\n#### Figure 1: Visual Workflow\n\n![Visual Workflow](images\u002Fvisual_workflow.png)\n\n---\n\n## 4. Pipeline\n\n### Client Pipeline\n\n```text\n1. Receive global model + public_key + adaptive params\n2. Train locally (5 epochs)\n3. Compute delta = trained - global\n4. Add DP noise\n5. Adaptive quantization\n6. Sparse sharing\n7. Encrypt all non-zero sparse values\n8. Send indices + encrypted values + sparse_weights + dataset_size\n```\n\n### Server Pipeline\n\n```text\n1. Wait for 5 clients\n2. Generate Paillier keypair\n3. For each round:\n   a) Broadcast model + public key + params\n   b) Collect encrypted updates + dataset sizes\n   c) HE secure aggregation\n   d) Krum scoring for byzantine monitoring\n   e) Weighted FedAvg update\n   f) Evaluate + log metrics\n4. Save metrics and shutdown clients\n```\n\n### Server Block Diagram\n\n```text\n                  +--------------------------------------+\n                  |           Federated Server           |\n                  +--------------------------------------+\n                                   |\n                                   v\n                    [Accept 5 Client Connections]\n                                   |\n                                   v\n                     [Generate Paillier Keypair]\n                                   |\n                                   v\n             [Broadcast Global Model + Public Key + Params]\n                                   |\n                                   v\n         [Collect Encrypted Sparse Updates + Dataset Sizes]\n                                   |\n                                   v\n                  [HE Secure Aggregation of Updates]\n                                   |\n                                   v\n            [Build Per-Client Vectors for Krum Scoring]\n                                   |\n                                   v\n            [Apply Weighted FedAvg Global Model Update]\n                                   |\n                                   v\n                  [Evaluate + Log Round Metrics]\n                                   |\n                                   v\n                     [Shutdown and Close Clients]\n```\n\n### Adaptive Controller\n\n| Condition | Load Range | DP sigma | Bit Precision | Threshold |\n|---|---:|---:|---:|---:|\n| Good | \u003C 0.33 | 0.005 | 8 | 0.001 |\n| Medium | 0.33 to 0.66 | 0.010 | 6 | 0.005 |\n| Poor | > 0.66 | 0.020 | 4 | 0.010 |\n\n---\n\n## 5. Results and Metrics\n\n### Real Baseline Comparison (20 rounds)\n\n```text\nFedAvg  final accuracy: 77.49%\nSecAgg  final accuracy: 78.47%\nDP-FL   final accuracy: 78.42%\nPSSA    final accuracy: 75.49%\n```\n\n### PSSA Training Complete - Final Summary\n\n| Item | Value |\n|---|---|\n| Dataset | NSL-KDD |\n| Clients | 5 (A, B, C, D, E) |\n| Rounds | 20 |\n| Local Epochs | 5 |\n| Final Accuracy | 75.49% |\n| Best Accuracy | 77.88% (Round 1) |\n| Avg Enc Time | 63,478.9 ms |\n| Avg Comm Cost | 0.0537 MB (sparse) |\n| Final GLA Rate | 12.50% |\n| Final Epsilon | 372.68 |\n| Krum Winners | {0: 6, 1: 5, 3: 5, 4: 4} |\n\nThe comparison plots regenerated from this run are saved in [results](results).\n\n### Comparison Table\n\n| Method | Paper Accuracy (180 rounds) | Our Accuracy (20 rounds) | Comm Cost | GLA Rate |\n|---|---:|---:|---:|---:|\n| FedAvg | 88.10% | 77.49% | 5.2 MB | 72.30% |\n| SecAgg | ~87% | 78.47% | 7.4 MB | 38.90% |\n| DP-FL | 84.90% | 78.42% | 6.9 MB | 24.20% |\n| PSSA | 90.30% | 75.49% | 4.1 MB | 12.50% |\n\n### Performance Graphs\n\n#### Figure 2: Global Accuracy Convergence (20 Rounds)\n![Accuracy Convergence](results\u002Ffig1_accuracy_convergence.png)\n*PSSA model shows convergence behavior with final accuracy of 75.49% after 20 training rounds*\n\n#### Figure 3: Accuracy Comparison Across Methods\n![Accuracy Comparison](results\u002Ffig2_accuracy_comparison.png)\n*Comparison of FedAvg, SecAgg, DP-FL, and PSSA methods showing PSSA maintains competitive accuracy while providing privacy and compression benefits*\n\n#### Figure 4: Communication Cost Analysis\n![Communication Cost](results\u002Ffig3_communication_cost.png)\n*PSSA keeps communication cost low through adaptive quantization and sparse gradient sharing*\n\n#### Figure 5: Privacy Attack Resilience (GLA Success Rate)\n![Privacy Attack Resilience](results\u002Ffig4_privacy_attack_resilience.png)\n*Gradient Leakage Attack (GLA) success rate decreases from 86.07% to 12.5% across rounds, demonstrating increasing privacy protection*\n\n#### Figure 6: Encryption Time Per Round\n![Encryption Time](results\u002Ffig5_encryption_time.png)\n*Average encryption time across rounds: 63,478.9 ms per round using Paillier HE with 1024-bit key length*\n\n### Metrics Summary (20 Rounds)\n\n| Round | Accuracy | Comm Cost (MB) | GLA Rate (%) | Encryption Time (ms) | Encrypted Params |\n|---:|---:|---:|---:|---:|---:|\n| 1 | 77.88% | 0.0548 | 86.07% | 59,773.38 | 37,808 |\n| 5 | 76.86% | 0.0548 | 47.24% | 61,932.15 | 38,970 |\n| 10 | 77.44% | 0.0548 | 22.31% | 63,106.01 | 39,992 |\n| 15 | 75.83% | 0.0548 | 12.50% | 70,287.56 | 44,387 |\n| 20 | 75.49% | 0.0548 | 12.50% | 61,015.13 | 38,736 |\n\n**Key Observations:**\n- Privacy improves significantly (GLA rate drops from 86% to 12.5%) as DP noise accumulates\n- Communication cost remains consistently low (0.0537 MB sparse average) due to compression\n- Encryption overhead is still the main bottleneck, but GPU support now reduces the local training and evaluation portion when CUDA is available\n- Model achieves 75.49% final accuracy with strong privacy guarantees\n\n---\n\n## 6. Datasets\n\n### NSL-KDD Dataset\n\nThe NSL-KDD dataset is a refined version of the KDD'99 Intrusion Detection dataset, specifically designed for evaluating network intrusion detection systems in cybersecurity applications.\n\n#### Dataset Download\n \n**Kaggle:** https:\u002F\u002Fwww.kaggle.com\u002Fdatasets\u002Fhassan06\u002Fnslkdd\n\n#### Dataset Properties\n\n| Property | Value | Description |\n|---|---|---|\n| **Dataset Size** | 148,517 records | Total instances in training + test sets |\n| **Training Samples** | ~125,973 | KDDTrain+.txt - used for federated training |\n| **Test Samples** | ~22,544 | KDDTest+.txt - used for model evaluation |\n| **Features** | 41 | Network-based features (protocol, service, flags, bytes, etc.) |\n| **Imbalance Ratio** | ~80:20 | ~80% normal, ~20% anomalous traffic |\n| **Data Format** | CSV | Comma-separated values, one sample per line |\n| **Missing Values** | None | Complete dataset, no missing values |\n| **Normalization** | Min-Max | Features scaled to [0, 1] during preprocessing |\n| **Cyber Domain** | Network Security | Designed for intrusion detection systems |\n\n#### Dataset Files in Project\n\n- **KDDTrain+.txt** (125,973 samples) - Training dataset used to create federated shards\n- **KDDTest+.txt** (22,544 samples) - Test dataset for model evaluation\n\n#### Feature Categories\n\n| Category | Features | Example |\n|---|---|---|\n| **Protocol** | 3 | TCP, UDP, ICMP |\n| **Service** | 70 | HTTP, FTP, DNS, SSH, etc. |\n| **Flags** | 11 | SYN, ACK, FIN, RST, etc. |\n| **Traffic Metrics** | 13 | src_bytes, dst_bytes, duration, etc. |\n| **Connection Info** | 20 | land, wrong_fragment, urgent, etc. |\n\n#### Data Distribution in Federated Setup\n\n```\nTraining Dataset: 125,973 samples\n         |\n         v\n   5 Clients (Shards)\n         |\n    +----+----+----+----+\n    |    |    |    |    |\n   25K  25K  25K  25K  25K  (samples per client)\n```\n\nEach client receives approximately 25,000 samples to train locally with differential privacy and secure aggregation.\n\n#### Dataset Relevance\n\n- **Cybersecurity Use Case**: NSL-KDD is specifically designed for network intrusion detection\n- **Edge Computing Scenario**: Suitable for distributed edge nodes monitoring network traffic\n- **Privacy Concerns**: Raw network traffic data is sensitive; PSSA ensures privacy during collaborative training\n- **Real-World Applicability**: Based on actual network packet data and attack patterns\n\n---\n\n## 7. Differences from Paper\n\nThis implementation is aligned with the paper at the algorithm level, but a few practical differences remain due to project scope and runtime constraints:\n\n1. Training horizon:\n- Paper reports full convergence with longer training (180 rounds).\n- This project commonly demonstrates 20-round runs for manageable execution time.\n\n2. Privacy attack evaluation style:\n- Paper evaluates privacy using direct gradient inversion attacks.\n- This implementation reports a simple proxy metric: the GLA trend (lower GLA means better privacy).\n\n3. Dataset scope:\n- Paper reports results in a multi-dataset benchmarking context.\n- This project uses only NSL-KDD to keep the cybersecurity setting focused.\n\n---\n\n## 8. Project Structure\n\n```text\nTTEH Project\u002F\n|-- server.py\n|-- client.py\n|-- model.py\n|-- data_loader.py\n|-- homomorphic_encryption.py\n|-- differential_privacy.py\n|-- pssa_compression.py\n|-- byzantine_resilience.py\n|-- adaptive_controller.py\n|-- metrics_logger.py\n|-- comparison.py\n|-- utils.py\n|-- requirements.txt\n|-- KDDTrain+.txt\n|-- KDDTest+.txt\n|-- images\u002F\n|-- results\u002F\n```\n\n---\n\n## 9. Setup and Usage\n\n### Install\n\n```bash\ngit clone \u003Cyour-repo-url>\ncd \u003Crepo-folder>\npython -m venv .venv\n```\n\nWindows PowerShell:\n\n```powershell\nSet-ExecutionPolicy -Scope Process -ExecutionPolicy RemoteSigned\n.\\.venv\\Scripts\\Activate.ps1\npip install -r requirements.txt\n```\n\n### Run (6 terminals)\n\nTerminal 1:\n\n```bash\npython server.py\n```\n\nTerminals 2 to 6:\n\n```bash\npython client.py A\npython client.py B\npython client.py C\npython client.py D\npython client.py E\n```\n\nOptional:\n\n```bash\npython comparison.py\n```\n\n---\n\n## 10. System Requirements\n\n### Minimum Requirements\n\n| Component | Minimum Specification |\n|---|---|\n| **Operating System** | Windows 10 \u002F Windows 11, macOS 10.15+, Ubuntu 18.04+ |\n| **Python Version** | Python 3.9+ |\n| **RAM** | 8 GB |\n| **Disk Space** | 2 GB (including virtual environment and datasets) |\n| **GPU** | NVIDIA GeForce RTX 20-series (or newer) with CUDA support |\n| **Network** | Local network connectivity for multi-process communication |\n\n### Tested Configuration\n\nThis project was developed and tested on:\n\n| Component | Specification |\n|---|---|\n| **OS** | Windows 11 (Build 22621+) |\n| **Processor** | Intel Core i7 (20 logical cores) |\n| **RAM** | 16 GB DDR5 |\n| **Storage** | SSD with 10+ GB free space |\n| **Python** | Python 3.11.x |\n| **GPU** | NVIDIA GeForce RTX 4050 (6 GB) |\n\n### Installation Verification\n\nAfter setup, verify the environment:\n\n```bash\npython -c \"import torch; import phe; import numpy; print('✓ All dependencies installed')\"\n```\n\n---\n\n## 11. Limitations\n\n- This project commonly reports 20-round runs for practical runtime reasons, so final accuracy trends should not be interpreted as full-convergence behavior compared with 180-round research settings.\n- Homomorphic encryption cost is high in this implementation because it uses Python `phe` without low-level acceleration; this increases per-round latency on standard hardware.\n- Privacy attack resilience reporting currently uses a documented proxy-style GLA trend rather than an end-to-end live inversion-attack benchmark pipeline.\n- Evaluation is focused on NSL-KDD, so cross-domain generalization (for example, vision benchmarks) is outside the validated scope of this version.\n- Deployment is validated in a controlled multi-terminal local\u002Fdistributed setup; large-scale heterogeneous edge orchestration is not fully benchmarked in this release.\n\n---\n\n## 12. Future Improvements\n\n- Extend training to longer schedules (for example 100-180 rounds) with checkpointing and early-stopping analysis to compare convergence behavior more directly with paper-scale results.\n- Replace or optimize the HE backend with faster cryptographic implementations (native extensions\u002FGPU-aware libraries) to reduce encryption and aggregation latency.\n- Add direct privacy-attack evaluation modules (gradient inversion and reconstruction tests) to report empirical privacy robustness beyond proxy indicators.\n- Expand dataset coverage and model families (for example CIFAR-10 or other edge-relevant datasets) for broader validation of PSSA behavior.\n- Introduce asynchronous and fault-tolerant orchestration features such as straggler handling, dropout recovery, and partial-client round completion.\n- Add experiment automation for reproducibility: config-driven runs, seed control, and one-command report generation.\n\n---\n\n## 13. Team Members and Mentor\n\n### Team\n\n| Name | USN | Email |\n|---|---|---|\n| MALLIKARJUN R | ENG24CY1003 | mallikarjunmallu501@gmial.com |\n| ADIL BAGWAN | ENG23CY0048 | adilb5556@gmail.com |\n| DEERAJ VAMSI M | ENG23CY0060 | deerajvamsi1@gmail.com |\n| B V SATHVIK | ENG23CY0008 | bv.sathvik4@gmail.com |\n\n### Mentor\n\nDr. Prajwalasimha S N  \nAssociate Professor, CSE (Cyber Security)  \nDayananda Sagar University  \nEmail: prajwasimha.sn1@gmail.com\n\n---\n\n## 14. 🔬Laboratory\n \nTTEH LAB · School of Engineering · Dayananda Sagar University  \nBangalore - 562112, Karnataka, India\n\n\u003Cp align=\"left\">\n   \u003Cimg src=\"images\u002FDayananda-Sagar-University-Logo.png\" alt=\"Dayananda Sagar University Logo\" width=\"300\"\u002F>\n\u003C\u002Fp>\n\n---\n\n## 15. License\n\nThis project is licensed under the MIT License. See the [LICENSE](LICENSE) file for the full text.\n\nThe license applies to the project source code and documentation. Third-party assets, including datasets and logos, may be subject to their own usage terms.\n\n\n","PSSA项目实现了基于同态加密、差分隐私和拜占庭容错聚合的联邦学习安全聚合方案，特别针对NSL-KDD数据集进行了应用。其核心功能包括使用Paillier同态加密技术确保模型更新的安全性，通过差分隐私机制降低信息泄露风险，并采用Krum评分方法增强对恶意或异常客户端更新的抵抗能力。此外，该项目还引入了自适应量化与稀疏梯度共享策略以减少通信开销。适合于边缘计算场景下需要同时保障数据隐私、限制通信成本及对抗攻击的联邦学习任务。",2,"2026-06-11 02:49:17","CREATED_QUERY"]