Brief explanation

B0Bot is a CyberSecurity News API tailored for automated bots on social media platforms. It is a cutting-edge Flask-based API that grants seamless access to the latest cybersecurity and hacker news. Users can effortlessly retrieve news articles either through specific keywords or without, streamlining the information acquisition process. Once a user requests our API, it retrieves news data from our knowledge base and feeds it to the LLM. After the LLM processes the data, the API obtains the response and returns it in JSON format. The API is powered by LangChain and a Huggingface endpoint, ensuring that users receive accurate and up-to-date information.

Expected results

This year, we are planning to integrate the following features into b0bot:

• Implement CDC via RSS feed readers or debezium connectors with kafka bus.
• Implement caching mechanisms (e.g. Redis) to reduce response time for frequent requests.
• Add a subscription feature for users to receive daily or weekly summaries, over email.
• Create an agentic AI framework using Langchain/LangGraph to create planner and executor agents. Example of possible agents can be scraper agent, responder agent, notification agent, analyzer agent. Thorough research is expected from the contributor before deciding the agentic framework.
• Extend the LLM to support multi-turn dialogue, allowing users to engage in conversational interactions with the API.
• Extend data sources to various social media websites by using their APIs.
• Creating tests for the API and proper error handling.
• Improved UI, possibly creating a dashboard.
  
  

Knowledge Prerequisite

Python, Large Language Models, Huggingface, LangChain, Database management, Pinecone, Flask, Agentic Frameworks

Mentors

Hardik Jindal (hardik1408), Nipuna

Estimate Project Length

350 hours

Github URL

https://github.com/c2siorg/b0bot

Difficulty

Hard

Slack channel

#b0bot

Brief explanation

WebiU is a dynamic organization website which uses reusable components concept that fetches project data in real-time from GitHub repositories, ensuring live updates without manual intervention. It provides configurable templates to showcase project details such as title, description, technology stack, and demo links and organisation updates.

WebiU aims to improve the system by optimizing APIs for faster and lighter responses, exploring serverless backend solutions for real-time data handling, and integrating CI/CD workflows to streamline development and deployment.

Key Objectives

1. API Optimization
   • Refactor APIs to reduce response times and payload sizes.
   • Implement in-memory caching and compression (e.g., GZIP).
   • Explore modern API solutions like GraphQL for efficient data fetching.
     
     
2. Alternative Backend Strategies
   • Leverage serverless architectures to handle real-time data effectively and scale dynamically.
     
     
3. CI/CD Integration
   • Automate testing, building, and deployment with tools like GitHub Actions.
   • Ensure smooth rollback mechanisms and error handling for deployments.
     
     
4. Admin Features
   • Expand admin controls with project analytics and manual API refresh options.
     
     

Expected Results

By the end of the summer We are planning to make the project live by completing it end to end integrations and will deliver faster, lightweight APIs, a robust real-time data architecture, and automated CI/CD workflows. These improvements will enhance user experience, scalability, and developer productivity.

Skills Required:

Proficiency in REST/GraphQL, Node.js, serverless technologies, Angular, and CI/CD tools.

Mentor

Mahender Goud Thanda (Maahi10001), Charith

Estimate Project Length

350 hours

Github URL

https://github.com/c2siorg/Webiu

Difficulty

Medium

Slack channel

#WebiU

Brief explanation

GDB-UI is a modern, web-based interface for the GNU Debugger (GDB), designed to simplify the debugging process for developers working with C, and C++. It provides real-time interaction with GDB, enabling features like monitoring program execution, inspecting variables, setting breakpoints, and more, all through an intuitive web application.

GDB-UI enhances the debugging workflow by offering a sleek, user-friendly UI, replacing the traditional command-line experience with a visual and accessible alternative. It supports both Docker-based and manual setups, allowing seamless integration into various development environments.

Key Objectives

1. First Deployment:
   • Deploy the project for initial use, ensuring the application is accessible and functional for all users.
     
     
2. CI/CD Integration:
   • Automate the testing, building, and deployment processes using tools like GitHub Actions.
   • Ensure smooth deployment pipelines with robust rollback mechanisms and proper error handling.
     
     
3. Session Management for Multiuser Support:
   • Implement a system to store debugging sessions uniquely for each user to enable multiuser functionality.
   • Ensure session persistence and isolation to prevent interference between users.
     
     
4. Real-Time Debugging Results:
   • Design the application to display debugger results in real time without requiring page refreshes.
   • Use WebSockets or similar technologies to handle live updates efficiently.
     
     

Expected Results

By the completion of the project, the application will be fully deployed with multiuser support, persistent session management, real-time debugging results, and a robust CI/CD pipeline. These enhancements will provide a seamless debugging experience, improve scalability, and simplify the development workflow for contributors.

Skills Required:

Proficiency in REST, Flask, React, WebSockets, Docker, CI/CD tools (e.g., GitHub Actions), session management, and real-time data handling

Mentor

Shubh Mehta (Shubh942), Nipuna, EMSDV

Github URL

https://github.com/c2siorg/GDB-UI

Estimate Project Length

350 hours

Difficulty

Medium

Slack channel

#gdb-ui

Brief Explanation

CodeLabz is an interactive, cloud-based learning platform designed to facilitate engagement with online tutorials. It enables organizations to create, manage, and share structured learning resources with users. The platform is built with a ReactJS frontend, complemented by a scalable backend powered by Google Cloud Firestore and Firebase Realtime Database, ensuring seamless real-time data synchronization and an intuitive user experience.

This project focuses on optimizing learning workflows by integrating an enhanced UI, efficient data management, and dynamic real-time updates. CodeLabz serves as a centralized solution for tutorial creation, consumption, and collaboration, ensuring an effective and scalable educational experience. It currently requires the following improvements.

Key Objectives

1. Backend and Deployment:
   • The app is temporarily deployed on the client side using Firebase Hosting, so we need a no-cost solution for serverless deployment.
   • Find a free serverless hosting solution and migrate APIs from Firebase Functions while ensuring scalability, reliability, and minimal maintenance.
     
2. Implement Real-Time Notification System (No Cost):
   • Research and implement a real-time notification system integrated with in-app notifications.
   • Ensure functionality for push and in-app notifications within free-tier limits.
     
3. Managing Org-Setting (Including Roles) and Implement Admin Features:
   • Develop functionalities for managing organization settings.
   • Implement role-based access control to ensure secure and controlled access.
   • Enhance the admin dashboard with real-time API refresh and analytics.
     
4. Optimize NoSQL Queries for Performance:
   • Identify key indexes, optimize slow queries, and implement caching or denormalization strategies to improve retrieval times.
     
5. Containerization & Dockerization:
   • Implement Docker for consistent development and production environments..
     
6. UI/UX Refinement:
   • Improve design consistency, usability, and responsiveness across all devices with proper design principles.
   • The codebase contains partial migrations and multiple MUI versions, so make it consistent and update it to the latest versions.
     
7. Ensure Proper Migration and Consistency:
   • The codebase includes deprecated npm libraries and modules, update or replace them.
   • Convert the existing JavaScript codebase to TypeScript, ensuring type safety and maintainability.
     
     

Expected results

By the completion of this project, CodeLabz will achieve:

• Optimized API performance: Faster response times, reduced server load, and enhanced data retrieval, improving overall API performance.
• Better looking UI/UX: A visually appealing and responsive interface that works seamlessly across all devices, improving user satisfaction.
• Scalable real-time backend: A scalable, serverless backend that handles real-time data synchronization and notifications efficiently.
• Refined CI/CD pipelines and faster deployment cycles: Improved consistency and reproducibility of environments through Docker.
• Enhanced data security and privacy: Improved data security with role-based access control, ensuring only authorized users access sensitive information.
• Improved admin functionality: Advanced analytics, data monitoring, and administrative control tools.
• Updated and consistent codebase: Fully migrated, consistent, scalable and maintainable codebase.
  
  

Knowledge Prerequisite

Proficiency in React.js, Redux, Material-UI, TypeScript, Node.js, Express.js, Firebase, API design, Docker, CI/CD (GitHub Actions), Figma, NoSQL design patterns, query optimization, caching strategies, OAuth, and Role-Based Access Control (RBAC).

Mentor

Mallepally Lokeshwar Reddy(lokeshwar777), Utkarsh Raj(rajutkarsh07)

Github URL

https://github.com/c2siorg/codelabz

Estimate Project Length

350 hours

Difficulty

Medium

Slack channel

#codelabz

Brief explanation

This project aims to develop a data storing and querying engine for Hyperledger Fabric that leverages the SmartQC transaction model proposed in the paper (arxiv.org). The goal is to enable efficient storage and retrieval of complex data transactions while ensuring immutability, auditability, and efficient query execution on Hyperledger Fabric. The transaction model introduces a novel way of structuring data that goes into the ledger (Similar to a relational database schema). The idea of this project is to implement an off-chain service/node that provides endpoints to manage transactions and act as the intermediary validator before pushing the transaction into the hyperledger. Then utilise the structure and schema (metadata) of the transactions to perform advanced querying.

Key Objectives

• Implementation of the transaction model validator node in GoLang
  • A rest API to facilitate transactions
  • A rest API to facilitate transactions
• Implement a Hyperledger Fabric Smart Contract (Chain code) to manage transactions
• An architecture for the querying engine that facilitates faster and more complex queries (using an Off-chain DB that keeps a ledger copy or indexing mechanism before putting it into the ledger)
• Performance analysis
  
  

Expected Outcome

• Go Gin Rest API that implements the CRUD operations for transaction management.
• A connector to the Hyperledger Fabric
• Ledgerlens Hyperleder Fabric Chain code
• Querying algorithm
  
  

Knowledge Prerequisite

Go Programming Language (Gin), Docker, Blockchain & Distributed Ledger, Hyperledger Fabric, SmartQC Transaction Model

Mentor

Tharindu Ranathunga, Alan McGibney

Github URL

https://github.com/c2siorg/LedgerLens

Estimate Project Length

350 Hours

Difficulty

Intermediate

Slack channel

#LedgerLens

Brief explanation

FactBounty is a crowdsourced fact-checking platform designed to enhance the security, privacy, and trustworthiness of social media ecosystems. With the rise of misinformation, FactBounty leverages the power of intelligent crowds and AI-driven analytics to verify the authenticity of content. The platform features an intuitive user interface, real-time analytics, and seamless integration with various social media channels.

This project focuses on optimizing fact-checking workflows by incorporating AI-powered fake news detection, a refined UI/UX, and scalable backend architecture. FactBounty serves as a centralized solution for fact verification, ensuring a reliable and transparent digital experience.

Key Objectives

• UI/UX Design: Create the app’s user interface and experience by following proper design principles.
• AI-Powered Analytics: Integrate NLP-based analytics to detect and classify fake news efficiently.
• React Native Implementation: Expand the platform by developing a React Native app for cross-platform accessibility.
• Backend Migration: Transition the backend to Go (using Gin or Echo) for improved performance, scalability, and maintainability. Use Go-based async routes. Go provides built-in Swagger support for API documentation.
• CI/CD Integration: Automate testing and deployment using GitHub Actions with docker-conternarizations to ensure seamless updates.
  
  

Expected Results

By the completion of this project, FactBounty will achieve:

• Overall migration to more efficient frameworks and dependencies in Flask and Elasticsearch.
• AI-Driven Fact Checking: Improved misinformation detection through NLP-based analytics,semantic similarity matching for detecting duplicate fact-checks.
• Scalable and Efficient Backend: A Go-based backend for enhanced speed and reliability.
• Cross-Platform Accessibility: A React Native app ensuring a seamless mobile experience.
• Automated CI/CD Pipelines: Fully integrated build, test, and deployment workflows with Github actions.
• Modernize the Frontend: Upgrade React dependencies and remove unnecessary Chrome-only restrictions,consider replacing Redux Devtools dependency if not required.
  
  

Knowledge Prerequisite

Proficiency in ReactJS, React Native, TypeScript, Material-UI, Go (Gin/Echo), REST API design, Docker, Kubernetes, CI/CD (GitHub Actions), Figma, NoSQL/SQL design patterns, caching strategies, OAuth2, JWT.

Mentor

Utkarsh Raj (rajutkarsh07), Sameera

Github URL

https://github.com/c2siorg/fact-bounty

Estimate Project Length

350 hours

Difficulty

Hard

Slack channel

#fact-bounty-

Brief explanation

WebGPU is a novel framework for Federated Learning (FL) that supports machine learning model training over web browsers. The idea is to develop a comprehensive framework around web browsers with the support of the WebGPU access via the web browser. Users can deploy the server in a single machine and connect clients via browser using server url and strat the federated learning process on the client side. The server should handle the management process of the FL network.

Current implementation on WebGPU does not support advanced features such as differential privacy, personalization, client selection algorithms and asynchronization on FL etc. This project aims to fix the current implementation to support at least above 3 implementations + asynchronization.

Expected Results

At the end of your summer, we expect that you will complete at least the mentioned 3 implementations along with the issues on the current implementation. This includes but is not limited to fixing broken features, enhancing the UI on the browser and performance improvement on the server implementation and the client implementation. Also, you have to improve the wikis which are related to your development areas. Come up with a plan of what features you are gonna do when as a timeline. Consider improving the wikis also in your timeline.

Knowledge Prerequisite

The implementation requires basic understanding of Python and React(JavaScrip) and deep knowledge on machine learning along with federated learning.

Mentor

Tushar N, Shivak

Github URL

https://github.com/c2siorg/WebFL

Estimate Project Length

350 hours

Difficulty

Hard

Slack channel

#webfl

Brief explanation

ImageLab is a standalone tool designed to help users learn and experiment with image processing techniques interactively. It provides an intuitive environment for beginners to understand image processing concepts without deep programming knowledge. Advanced users can use ImageLab as a test environment before implementing actual image processing applications.

Expected Results

The goal of this year is to improve the ImageLab experience for the users and the developers alike.

• Make the UI responsive.
• Fix the UI/UX issues in the current project such as tooltips not being displayed correctly.
• Increase the library of the blocks / parameters of operations.
• Come up with a deployment/release strategy.
• Complete the documentation on the project to support both users and developers, making it easier to understand, contribute to, and maintain the project.
• Transition the application’s architecture from an experiment-centric to a project-based approach.
• Develop a project library for easy management and retrieval of user projects.
• Implement features to collect user analytics and feedback within the application.
• (Optional) Build features necessary for creating object detection pipelines.
  
  

Knowledge Prerequisite

Javascript / Typescript, OpenCV, Electron (Optional)

Mentor

Sahan Dissanayake, Oshan Mudannayake

Github URL

https://github.com/c2siorg/imagelab

Estimate Project Length

350 hours

Difficulty

Medium

Slack channel

#imagelab

Brief explanation

DataLoom is a web-based graphical interface designed to simplify data wrangling and transformation tasks for tabular datasets. It serves as an intuitive front-end for the pandas library, enabling users to perform complex data manipulation operations without requiring advanced programming expertise. By bridging the gap between data analysis and usability, DataLoom empowers users to streamline their data workflows efficiently.

Expected Results

• Redesign and modernize the UI to be more responsive, professional, and user-friendly.
• Introduce additional data transformation operations.
• Restructure the project to enhance readability, maintainability, and ease of contribution for new developers.
  
  

Knowledge Prerequisite

Backend: Python, Pandas, FastAPI (recommended) Frontend: HTML, CSS, JavaScript, React (recommended)

Mentor

Oshan Mudannayake, Danushka V

Github URL

https://github.com/c2siorg/dataloom

Estimate Project Length

350 hours

Difficulty

Easy

Slack channel

#dataLoom

Brief explanation

TensorMap is a web application that will allow the users to create machine learning algorithms visually. TensorMap supports reverse engineering of the visual layout to a Tensorflow implementation in preferred languages. The goal of the project is to let the beginners play with machine learning algorithms in Tensorflow without less background knowledge about the library.

Expected Results

• Clean up the project structure.
• Completely switch to poetry for dependency management.
• Complete the project Wiki.
• Implement additional visualizations such as 3D plots, heatmaps, and interactive graphs.
• Add built-in functions for common data augmentation techniques.
• Add more functionality to the application (open-ended).
  
  

Knowledge Prerequisite

Tensorflow, Python, Javascript

Mentor

Oshan Mudannayake, Utkarsh Raj (rajutkarsh07), UdeshUK

Github URL

https://github.com/c2siorg/tensormap

Estimate Project Length

350 hours

Difficulty

Hard

Slack channel

#tensormap

Brief explanation

This project aims to develop a VS Code extension that enhances the security of the developer environment by monitoring other installed extensions for suspicious behaviors. Malicious VS Code extensions can access the file system, execute scripts, and make network requests without the user’s knowledge, posing a significant security risk. This tool will analyze installed extensions, detect potential threats, and provide alerts to users.

Key Objectives

1. Extension Behavior Monitoring:
   • Track API calls made by installed extensions, including file access, network requests, and execution of system commands.
   • Identify extensions that request excessive permissions beyond their intended functionality.
     
     
2. Network Activity Analysis:
   • Log and analyze external API calls made by extensions to detect unauthorized data exfiltration.
   • Provide real-time alerts when an extension makes requests to suspicious domains.
     
     
3. File System Protection:
   • Detects when an extension reads or modifies critical user files (e.g., SSH keys, environment variables).
   • Provide users with granular control to restrict certain extensions from accessing specific directories.
     
     
4. Extension Reputation Scoring:
   • Gather metadata such as publisher information, update history, and marketplace ratings.
   • Cross-check extensions with known security reports and vulnerability databases.
     
     
5. User Alerts and Actionable Insights:
   • Generate real-time notifications when suspicious activity is detected.
   • Provide detailed reports and risk assessments for installed extensions.
     
     

Knowledge Prerequisite

JavaScript/TypeScript (for VS Code extension development). Knowledge of Node.js and system APIs. Experience with security auditing and threat detection methodologies. Familiarity with networking and process monitoring tools.

Mentor

Tushar N, Charith, EMSDV

Github URL

https://github.com/c2siorg/secureExtensionMonitor

Estimate Project Length

350 hours

Difficulty

Hard

Slack channel

#secure-extension-monitor

Brief explanation

An npm package for seamless integration of all NFT related functionalities in Web2 projects. This project helps web2 developers seamlessly integrate web3 functionality.

Expected Results

Currently we are able to mint NFT on Ethereum chain and upload metadata to multiple storage services. The current task is to improve the existing stuff with multi-chain support like Solana, Tezos and EVM compatible chains, add more ERC’s support, make different types of on-chain and off-chain algorithms for super fast batch minting of NFT and add support for Soulbound NFTs, dynamic NFT and nested NFT. A website with all these functionalities needs to be created along with required smart contracts.

Features we would like to implement in NFT-ToolBox Project:

• You need to refactor code
• Add onchain and offchain Batch Minting Support
• Add Multiple ERC support related to nfts in easy and feasible manner
• Add support for Solana NFT’s
• Add Support for Tezos NFT’s
• Add support for Flow Blockchian NFT’s
• Add support for Aptos Blockchian NFT’s
• Add Support for Cross Chain NFT’s
• Build An UI to mint NFT’s on any chain
• Make UI to deploy different kinds of NFT standards (Something like Thirdweb)
  
  Note: You don’t need to implement all these features this year. You have to come up with proposal of what things can be implemented in the GSoC timeline and How.
  
  

Knowledge Prerequisite

Solidity, NFT, Blockchain, Rust, 1Nodejs, Rust, ReactJs, Typescript, Cadence, Move

Mentor

Mohit Bhat, Tharindu

Github URL

https://github.com/c2siorg/NFT-Toolbox

Estimate Project Length

350 hours

Difficulty

Medium

Slack channel

#nft-toolbox

Brief explanation

AIXPlorer is an open-source, AI-powered blockchain explorer designed to provide transaction, address, and other blockchain data in an intuitive, human-centric manner. Our goal is to enhance accessibility and usability by leveraging AI to present complex blockchain information in a more digestible format.

Expected Results

This project is in its early stages, and we are focused on making it more robust and feature-complete. Key areas of improvement include:

• Expanding support for multiple blockchain networks, including Solana, Sui, and Aptos.
• Enhancing our existing AI capabilities, currently utilizing Vercel AI SDK, while exploring alternative lightweight agent frameworks or developing our own.
• Avoiding reliance on third-party APIs by building custom transaction parsers, data decoders, and indexing mechanisms.
• Creating APIs to enable seamless integration of our AI-powered agent for external use.
  
  

Key Objectives

• Codebase Optimization: Refactor and improve the existing codebase for better maintainability and performance.
• Advanced Event Decoding & Indexing: Improve transaction parsing, event decoding, and indexing mechanisms.
• Multi-Chain Support: Integrate support for Solana, Sui, and Aptos blockchains.
• Enhanced UI/UX: Design an improved, visually appealing UI that aligns with conventional blockchain explorers.
• Optimized AI Integration: Research and integrate the best AI agent frameworks for efficient data processing.
• Retrieval-Augmented Generation (RAG) Implementation: Incorporate RAG to reduce large language model (LLM) processing costs and improve response accuracy.
• API Development: Build APIs to allow external developers to easily integrate and use the AI-powered agent.
  
  

Scope & Implementation Plan

Not all features need to be implemented within this year’s GSoC timeline. Instead, participants should propose a structured plan outlining:

• Feasible milestones and deliverables within the GSoC period.
• The approach for integrating AI-driven enhancements.
• Strategies for optimizing indexing, event decoding, and multi-chain support.
• Research and justification for the best AI agent framework to use.
• API design and implementation strategy for seamless agent integration.
  
  

Knowledge Prerequisite

To contribute effectively, participants should have experience with:

Blockchain & Smart Contracts: Solidity, Cadence, Move Development & Infrastructure: Rust, Node.js, React.js, TypeScript AI & Machine Learning: LLMs, RAG, AI Agents, LangChain, AI SDKs, Agent Frameworks API Development: REST, GraphQL, WebSockets

This project presents an exciting opportunity to work at the intersection of blockchain and AI, pushing the boundaries of decentralized data exploration.

Mentor

Mohit Bhat, TharinduR

Github URL

https://github.com/c2siorg/AIXplorer

Estimate Project Length

350 hours

Difficulty

Medium

Slack channel

#ai-explorer

Brief explanation

Ecomm-Pet-App is a platform designed to connect cybersecurity researchers worldwide, providing an interactive space to test their skills, practice ethical hacking techniques, and engage with a like-minded community. The platform offers various tools and challenges to enhance cybersecurity expertise, including vulnerability scanning exercises, and discussion forums.

Expected Results

• Faster API response times with optimized queries.
• Better UI/UX with an intuitive, hacker-friendly design.
• Scalable backend with real-time features and GraphQL.
• Automated CI/CD pipelines for seamless updates.
• Enhanced admin tools for monitoring and moderation.
  
  

Key Objectives

• Community & Interaction: Implement a Stack Overflow-style community for discussions, real-time chat functionality, and user social pages.
• Deployment & DevOps: Host on Firebase, Vercel, or AWS, with automated CI/CD pipelines using GitHub Actions.
• UI/UX Refinement: Implement dark mode, responsive design, a Markdown editor, and syntax highlighting.
• Backend Optimization: Use microservices architecture, GraphQL, MongoDB/PostgreSQL, Redis caching, and WebSockets for real-time updates.
• Scalability & Security: Deploy using Docker & Kubernetes, implement RBAC, OAuth, JWT authentication, and 2FA for security.
• Admin Features: Provide real-time analytics dashboards and moderation tools for effective platform management.
  
  

Knowledge Prerequisite

React, Node.js, Docker, Kubernetes, GitHub Actions, Redis, AWS/Firebase Hosting, OAuth, JWT, 2FA, RBAC, MongoDB/PostgreSQL, GraphQL, web sockets.

Mentor

Shubh Mehta (Shubh942), Primal

Github URL

https://github.com/c2siorg/ecomm-pet-app

Estimate Project Length

350 hours

Difficulty

Medium

Slack channel

#ecomm-pet-app

Brief explanation

The goal of this project is to develop a QEMU plugin that dynamically instruments userspace binaries as they execute. Leveraging QEMU’s plugin infrastructure, the tool will provide comprehensive instrumentation capabilities including instruction tracing, memory access logging, and control-flow analysis without requiring modifications to the original binaries. The project will result in an open-source tool that can be used for performance profiling, debugging, and security analysis.

Expected Results

The tool will be evaluated using a bunch of packed and obstructed binaries.

Key Objectives

• Dynamic Instrumentation: Develop a plugin that intercepts key runtime events (e.g., instruction execution, memory accesses, system calls) in user-mode binaries using QEMU’s plugin API.
• Performance Profiling: Collect and report metrics such as instruction counts, basic block execution frequencies, cache behavior, and memory access patterns to help analyze performance bottlenecks.
• Modular and Extensible Design: Architect the plugin so that additional instrumentation features (such as logging, event correlation, and statistical analysis) can be added with minimal changes.
  
  

Knowledge Prerequisite

Low-level programming (C, ASM), Virtualization with QEMU, X86-64, Linux

Mentor

Danushka V, WiztaMax, Keneth

Github URL

https://github.com/c2siorg/QBinTracer

Estimate Project Length

350 hours

Difficulty

Hard

Slack channel

#QbinTracer

Brief explanation

Develop a scalable, cloud-native honeypot deployment framework that leverages Terraform to provision and manage honeypot instances across multiple geographic regions. This platform will help security teams gather threat intelligence, understand attacker methodologies, and improve defensive postures by simulating realistic targets in various cloud environments.

Expected Results

Check project GeoDNSScanner (https://github.com/c2siorg/GeoDnsScanner), you will create something similar to this but to deploy honeypots

Key Objectives

• Automated Deployment: Use Terraform to automate the provisioning, configuration, and decommissioning of honeypot infrastructure across multiple regions and potentially multiple cloud providers.
• Distributed Architecture: Deploy honeypots in various regions (e.g., North America, Europe, Asia-Pacific) to capture a diverse range of attack vectors and adapt to region-specific threat landscapes.
• Data Enrichment: Integrate logging, monitoring, and analytics to enrich raw data, correlating attack patterns with global threat intelligence feeds.
• Scalability and Flexibility: Implement modular Terraform configurations and cloud-native services to enable rapid scaling, dynamic resource allocation, and easy modifications.
  
  

Knowledge Prerequisite

Cloud deployment, Terraform, bash

Mentor

Danushka V, WiztaMax, Keneth

Github URL

https://github.com/c2siorg/honeynet

Estimate Project Length

350 hours

Difficulty

Easy

Slack channel

#Honeynet

Brief explanation

Address Ownership Proof Protocol (AOPP) provides a streamlined way to verify ownership of a cryptocurrency address. Traditionally, users had to manually sign a message from an exchange using third-party wallets like Electrum to prove that they are the ones who own the wallet, which was time-consuming and error-prone.
This project aims to build a self-hosted, web-based AOPP signing service that simplifies the verification process. The web application will allow users to sign messages using self hosted software wallets (electrum, blue wallet) and hardware wallets (Ledger, Trezor, BitBox) while ensuring seamless backend communication. Once a message is signed, the service will notify a backend, confirming wallet ownership.

Expected Results

By the end of the project, the following features will be implemented:

• Web-based AOPP Service – A web app where users can sign ownership proof messages.
• Self-Hosted Wallet Support – Enable compatibility with wallets like Electrum, Sparrow, and others supporting message signing.
• Hardware Wallet Integration – Direct support for signing via Ledger, Trezor, and BitBox.
• AOPP-URL Handling – Implement the parsing and generation of AOPP-URLs for smooth integration.
• Backend Notification System – Securely notify the backend once a signature is verified.
• Security & Compliance Enhancements – Implement best practices for cryptographic security.
• Testing & Error Handling – Comprehensive unit tests, integration tests, and fail-safe mechanisms.
• Only Bitcoin for bitcoin wallets
  
  

Tech Stack

This project will be built using Go for backend development due to its efficiency, concurrency support, and compatibility with cryptographic libraries. The proposed stack includes:

• Backend: Go, PostgreSQL
• Cryptographic Libraries: btcsuite/btcd, github.com/decred/dcrd/dcrec/secp256k1, github.com/btcsuite/btcutil
• Wallet Integrations: ledgerhq/ledger-go, trezor-go, bitbox-go
• Web Interface: React/Vue.js for a simple, intuitive UI
• Deployment: Self-hostable via Docker
  
  

Knowledge Prerequisite

• Go programming & API development
• Bitcoin cryptography (ECDSA, Schnorr signatures, secp256k1)
• Experience with wallet integrations & hardware wallet communication
• Web technologies (REST APIs, WebSockets, OAuth/WebAuthn)
• Database management with PostgreSQL
  
  

Mentor

Raveen Harith Perera, Adem Bilican

Github URL

https://github.com/c2siorg/ProofOfMine

Estimate Project Length

350 hours

Difficulty

Medium to Hard

Slack channel

#proof-of-mine

Brief explanation

Skam Shield currently offers scam protection through manual reporting and browser extensions. This project aims to build a real-time scam detection system for Windows, macOS, and Android that runs in the background and automatically detects and blocks scam attempts without using AI. The system will rely on rule-based detection, regex filtering, and user behavior tracking to identify fraudulent activities such as tech support scams, fake pop ups, phishing attempts, and scam calls.

Expected Results

• Windows/macOS background service that detects and blocks scam popups, VoIP calls, and phishing links.
• Android app that blocks scam calls & SMS and prevents fraudulent transactions.
• Browser integration for detecting phishing URLs and scam warnings.
• Auto-updating scam blacklist (integrated with Skam Shield Firestore DB).
• Detailed scam attempt logs for forensic analysis.
  
  

Knowledge Prerequisite

• JavaScript (for browser extension)
• Python or C++ (for system-level monitoring)
• Firebase Firestore (for managing scam blacklists)
• Android/Kotlin/ React Native (for mobile call and SMS blocking)
  
  
  

Mentor

Rishabh K, Amrita KasunBn

Github URL

https://github.com/c2siorg/SkamSheild

Estimate Project Length

350 hours

Difficulty

Hard

Slack channel

#skamsheild

Brief explanation

Currently, App ELLY relies on real-time connectivity for data submission. This project will add offline support, enabling users to collect elephant data in remote locations without internet access. The data will be stored locally and automatically synced with the server once the device is online. This ensures continuous data collection, even in areas with poor network coverage.

Expected Results

• Local data storage on mobile devices (using SQLite or IndexedDB).
• Auto-sync mechanism that uploads data once the internet is available.
• Background sync service to retry failed uploads.
• UI indicators to show pending and successfully uploaded data.
  
  

Knowledge Prerequisite

• React Native (for mobile app development)
• Firebase Firestore/SQLite (for local and cloud storage)
• Background services (for auto-sync functionality)
  
  

Mentor

Rishabh K, Don, MadFeminine

Github URL

https://github.com/c2siorg/elly

Estimate Project Length

350 hours

Difficulty

Medium

Slack channel

#elly

Brief explanation

Quantum algorithms developed in different frameworks like Qiskit, Cirq, or Braket face challenges when being ported across various quantum hardware platforms such as IBM Q, Google Quantum Engine, or Rigetti. This project aims to develop a universal quantum circuit translation framework (QCTF) that enables seamless conversion of quantum circuits between major frameworks while optimizing for hardware-specific requirements. QCTF will handle basic gate translations and address gate optimization, qubit mapping, noise adaptation, and hardware-specific transpilation. This will empower researchers to develop quantum algorithms once and execute them on any supported quantum hardware without manual rewriting.

Expected Results

• Universal Circuit Converter:
  • Supports conversion between Qiskit, Cirq, Braket, and TKET quantum circuits.
• Hardware-Aware Transpilation:
  • Optimizes circuits for specific hardware gate sets (IBM, Google Sycamore, Rigetti Aspen).
• Noise-Adaptive Compilation:
  • Includes noise modeling to adjust circuits for real quantum device execution.
• Advanced Gate Support:
  • Handles custom parameterized gates, controlled operations, and mid-circuit measurements.
• Visualization Module:
  • Displays before-and-after circuit diagrams to track translation changes.
    
    

Knowledge Prerequisite

• Quantum SDKs: Qiskit, Cirq, Amazon Braket, TKET
• Quantum Circuit Theory: Gate sets, qubit topology, noise models
• Compiler Design: Intermediate representations, transpilation techniques
• Python Programming: For integration, APIs, and visualization
• Hardware APIs: IBM Quantum, Google Quantum Engine, Rigetti Forest
  
  

Mentor

Don, Amrita, MadFeminine

Github URL

https://github.com/c2siorg/QBridge

Estimate Project Length

350 hours

Difficulty

Advanced – Requires knowledge of quantum mechanics, circuit optimization, and cross-platform software development.

Slack channel

#qbridge

Brief explanation

This project aims to explore and implement distributed quantum computing by leveraging multiple Quantum Processing Units (QPUs) across various hardware platforms. By integrating quantum circuits across IBM Quantum, Amazon Braket, Azure Quantum, and other quantum devices, the goal is to enhance the scalability and efficiency of quantum algorithms. The project will focus on coordinating the execution of quantum tasks on different QPUs, addressing the limitations of cross-hardware compatibility and entanglement, and developing methods for seamless integration of these diverse quantum systems into a unified architecture.

Expected Results

• Successful distribution of quantum circuits across multiple QPUs from different vendors (e.g., IBM, Rigetti, IonQ).
• Creation of a hybrid quantum-classical orchestration system for resource management and job scheduling.
• Execution of a quantum algorithm that spans multiple quantum devices and provides insights into how to improve quantum communication between these devices.
• Evaluation of the latency, performance, and error rates of distributed quantum executions compared to single-device operations.
  
  

Knowledge Prerequisite

• Quantum Computing Frameworks: Familiarity with Qiskit (IBM), Amazon Braket SDK, Azure Quantum, and t-ket⟩ (Cambridge Quantum).
• Quantum Hardware Access: Access to multiple QPUs (e.g., IBM Quantum, IonQ, Rigetti).
• Distributed Systems: Basic knowledge of cloud-based orchestration for hybrid quantum-classical systems.
• Quantum Communication: Understanding of entanglement swapping, quantum teleportation, and quantum repeaters.
• Classical Programming: Expertise in Python, API integrations, and cloud orchestration (AWS, Azure).
  
  

Mentor

Don, Rishabh, RashmiS

Github URL

https://github.com/c2siorg/QNet

Estimate Project Length

350 hours

Difficulty

High

Slack channel

#QNet

Brief explanation

QuantumMonitor will be a real-time monitoring tool specifically designed to track the performance and health of quantum hardware. It will collect and visualize critical metrics, including qubit health, noise levels, temperature, and error rates. The tool will provide a comprehensive dashboard that offers insights into quantum processor stability, enabling researchers and engineers to monitor quantum devices more effectively and ensure that they are operating optimally.

Expected Results

• A real-time dashboard displaying vital metrics like qubit coherence, gate fidelity, temperature, and noise levels.
• Alerts for when performance metrics exceed predefined thresholds, signaling potential hardware issues.
• Integration with various quantum hardware providers (IBM Q, Google, Honeywell, etc.) to provide a unified view of hardware performance.
• A historical log of performance data for trend analysis and diagnostic purposes.
• Ability to display health status for individual qubits, including error rates and failures.
  
  

Knowledge Prerequisite

• React Native & React.js: To build interactive web and mobile interfaces for the monitoring tool.
• Quantum Hardware APIs: Knowledge of APIs from hardware vendors like IBM Q, Google Quantum AI, or Rigetti to extract real-time metrics.
• Firebase Firestore: For storing historical data and logs of performance metrics.
• Cloud Integration: To enable remote monitoring and store performance data in the cloud for easy access and analysis.
• Data Visualization Tools: Experience with data visualization libraries (e.g., D3.js) for building real-time charts and graphs to display hardware performance.
  
  

Mentor

Amrita, Don

Github URL

https://github.com/c2siorg/QuantumMonitor

Estimate Project Length

350 hours

Difficulty

Medium-High

Slack channel

#quantum-monitor

Brief explanation

RustCloud is a rust library which hides the difference between different APIs provided by varied cloud providers (AWS, GCP, Azure etc.) and allows you to manage different cloud resources through a unified and easy to use API.

Expected Results

• By the end of the project, API for BigQuery, Vertex AI, GenAI for AWS, GCP, Azure
• Documentation - Improve and maintain documentation related to the development areas, ensuring clarity for future contributors.
  
  

Knowledge Prerequisite

Rust, AWS, GCP, Azure

Mentor

Pratik Dhanave, Mohit Bhat

Github URL

https://github.com/c2siorg/RustCloud

Estimate Project Length

350 hours

Difficulty

Medium

Slack channel

#rust-cloud