You want security researchers to audit your code, but not AI systems to train on it. Traditional licenses (MIT, Apache, GPL) don't address this gap.
Forum Threads
📢 RCF Protocol: Code Integrity & AI-Scraping Protection 🛡️⚡
Hello developer community!
We are excited to share the **Restricted Correlation Framework (RCF) Protocol** CLI tools and SDKs designed to be **100% free, local, and private** code integrity and ownership verification utilities.
---
## What is RCF?
RCF is a licensing protocol and security framework designed for the AI era. Traditional open-source licenses (like MIT or GPL) protect text, but fail to prevent automated scraper bots from harvesting, correlating, and replicating the *underlying methodology* of your code to train commercial models without attribution.
RCF bridges this gap by introducing **Visible Source, Protected Logic**:
- **Visibility Rights**: Anyone is free to read, study, and audit your code.
- **Usage Rights**: Machine-readable block markers (`[RCF:PROTECTED]`, `[RCF:RESTRICTED]`) signal to AI scrapers that copying/training on specific core algorithms is legally prohibited.
---
## The Local Security Toolkit
Our CLI tool (`rcf-cli`) is available on both **NPM** and **PyPI**. It provides:
1. **`rcf-cli init`**: Set up RCF compliance files (`NOTICE.md`, `.rcfignore`).
2. **`rcf-cli audit`**: Generate a cryptographic `RCF-AUDIT-REPORT.json` containing SHA-256 integrity chains of protected code blocks. **(Runs entirely locally on your host)**
3. **`rcf-cli verify`**: Deep integrity checking to detect tampering or stripped licenses.
4. **`rcf-cli prove`**: Compute a court-grade similarity proof (using Z-scores and E-values) between two files to prove intellectual property theft.
5. **`rcf-cli noise`**: Inject adversarial AST noise into protected files to disrupt code-harvesting neural networks.
6. **`rcf-cli gateway`**: Instantly generate Nginx and Cloudflare Workers WAF rules to block malicious AI bots at the gateway level.
---
## 100% Local & Private (Zero-Cloud)
All computations, audits, and similarity proofs run entirely locally. **No source code, cryptographic hashes, or project metadata are ever sent to external servers.**
Your proprietary algorithms stay fully private on your machine.
---
## Get Started
**Node.js / TypeScript:**
```bash
npm install -g rcf-protocol
# Or run instantly:
npx rcf-cli init
```
**Python:**
```bash
pip install rcf-cli
rcf-cli init
```
## We Want Your Feedback!
Is RCF-PL the license you've been waiting for? How can we improve our Tree-sitter AST similarity engine?
We invite you to audit the code, submit pull requests, and share your thoughts!
**GitHub Repository**: [github.com/aliyevaladddin/rcf-protocol](https://github.com/aliyevaladddi...)
**Documentation**: [aliyev.site/rcf](https://aliyev.site/rcf)
Protect your code logic from AI semantic replication
RCF Protocol Restricted Correlation Framework
Hey Product Hunt
We built RCF Protocol after running into a gap no existing license covers.
An LLM can ingest your open-source repository, extract the mathematical logic of your algorithm, translate it accurately into a different language, rename everything and ship it. Under MIT or Apache, nothing illegal happened. The text changed. The semantics didn't.
RCF
Why RCF > other code protections: Obfuscation gets broken by AI. Watermarking is too late. Licenses get ignored. RCF: Visible for humans + technical barriers + legal line "Visibility Usage Rights". This powers Aurora Access dOS. GitHub: https://github.com/AuroraAccess cc @balajis @VitalikButerin #PostQuantum #DigitalSovereignty
Next-Gen Hardware Root-of-Trust with Post-Quantum Security & A-VM
👋 Intro: The Problem
Intellectual property theft and unauthorized code execution are the silent killers of decentralized hardware. How do you guarantee that a dOS node, a security key, or an IoT sensor is running exactly what it should—and doing so in a way that's future-proof against quantum attacks?
🛡️ The Solution: RCF Firmware
RCF Firmware is a standardized, high-security root-of-trust specifically designed for the Aurora Access ecosystem. It doesn’t just run code; it enforces the Restricted Correlation Framework (RCF-PL v1.2.8) directly at the machine level.
🛠️ Key Technical Features:
Aurora A-VM: A high-performance virtual machine for executing signed
.acode modules. We’ve moved beyond raw binaries to a safe, sandboxed execution environment.
Post-Quantum Security (PQC): Built-in verification using Dilithium2 signatures. Your hardware is secured against tomorrow's quantum threats, today.
RCF Hardware Protocol (v1.2.9): A unified abstraction layer for peripherals. Whether it's SDIO (48MHz), SPI, or UART, the A-VM interacts with physical hardware through secure, standardized opcodes (0x30 range).
RCF Bunker: Isolated shielding for sensitive cryptographic operations, ensuring zero-leakage during key generation.
100% Compliance: Fully audited with the rcf-cli suite for RCF-PL v1.2.8 compliance.
🌍 For the Developer Community:
We’ve turned complex STM32 HAL registers into simple, secure A-VM commands. If you’re building high-security decentralized systems, RCF Firmware provides the "Hardware OS" foundation you need to protect your IP and ensure node integrity.
🚀 Get Started:
Documentation: rcf.aliyev.site/firmware
Source Code: github.com/aliyevaladddin/rcf-firmware
Hardware Specs:
SDIO,
SPI,
UART
Categories: Developer Tools, Security, Hardware
Tags: #CyberSecurity #PQC #OpenHardware #Firmware #RCF
We’d love to hear your thoughts on hardware-level license enforcement and the future of PQC! Let’s chat in the comments! 👇
RCF Protocol
Protect code from AI scraping and automated cloning
Tagline: A new IP protection model for developers who want visibility without exploitation
Description:
RCF Protocol solves a problem that traditional open-source licenses ignore: your code is visible, but that doesn't mean it should be free to exploit.
The visibility/usage boundary:
Table
✅ ALLOWED
🚫 RESTRICTED
Manual reading
Automated extraction
Personal study
AI/ML training
Research reference
Commercial replication
Bug reports
Methodology copying
Three-layer enforcement:
Legal — explicit license terms
Technical — optional protection measures
Self-enforcement — community accountability
Built for:
Security researchers sharing tools
Developers of proprietary algorithms
Educators protecting course methodologies
Teams open-sourcing for audit, not adoption
Website: rcf.aliyev.site
MIT. Apache. GPL. None of Them Protect You From This.
Here is a scenario happening to developers right now.
You build a high-performance correlation algorithm in C. It's your edge. Your IP. Your competitive moat.
You publish it under MIT — not to give it away, but to build trust. To show your work. To be transparent.
An AI training pipeline ingests your repository.
It doesn't copy your code verbatim. It does something far more dangerous:
It analyzes the mathematical and logical structure of your algorithm.
It translates the logic — 100% accurately — into Python.
It renames the variables, restructures the folders, and ships it.
Your competitor now runs on your proprietary math. And under MIT, Apache, or GPL? No infringement occurred. The text changed. The AI never "copied" anything.
This Is the AI Scraping Gap — and It's Hiding in Plain Sight
Traditional open-source licenses were built for a world where copying meant copying text.
That world no longer exists.
LLMs don't copy syntax. They extract semantics. They understand what your code does — not just what it says. And no existing license covers that.
MIT protects your words. It does not protect your logic. GPL enforces attribution. It does not protect your math. Apache grants patents. It does not protect your algorithms.
If you are an independent developer or a small team shipping real innovations, your IP is exposed in a way the law has not caught up to yet.
We Built RCF Protocol to Close This Gap
After hitting this wall ourselves, we created the Restricted Correlation Framework (RCF) — a legal and technical standard built specifically for the era of automated mass replication.
The core principle is simple: Visibility ≠ Usage Rights.
You can keep your code public for audits, trust, and transparency — while explicitly prohibiting AI systems from correlating and replicating your proprietary logic.
Here is how it works technically:
Block-Level Markers You annotate proprietary sections directly in your codebase with inline markers: [RCF:PROTECTED]. Under DMCA §1202 (Copyright Management Information), stripping these machine-readable markers triggers severe legal liability. This isn't just a comment — it's a legally recognized signal.
Cryptographic Baseline The rcf-cli scans your codebase and produces a signed RCF-AUDIT-REPORT.json — a SHA-256 hash baseline of every protected block. Tampering with protected logic becomes provable, not just alleged.
Continuous Enforcement The rcf-guardian GitHub Action monitors every pull request in real time. If a marker is stripped or an audited block is altered, the pipeline flags it immediately. Your protection doesn't expire between audits.
Why This Matters Beyond Your Codebase
This is not just a technical problem. It's a structural shift in who owns innovation.
Right now, the default is: if your logic is visible, it is harvestable. AI companies have industrialized this at a scale no legal team can track manually.
If we don't establish a clear standard — one that draws a hard line between seeing code and using its logic — independent developers will be systematically stripped of their competitive advantage. Not through hacking. Not through theft. Through translation.
The Sovereign Code Initiative is our answer to that.
We Just Launched on Product Hunt
RCF Protocol is live. The specification is open. The tooling is real.
If you build software and care about owning what you create, I'd genuinely value your perspective.
👉 Full Specification & Docs: https://aliyev.site/rcf
Protect your logic before it gets translated away.
What's your take — should open-source licenses evolve to cover semantic replication, or is this a problem that needs an entirely new legal framework?
RCF Protocol — Open-source code protection for the AI era.Humans can read, study, research & audit your code.
AI scraping, training, and commercial machine replication? Blocked.Traditional licenses (MIT/GPL) no longer cut it when bots vacuum everything.
New rules. Machine-readable restrictions.
You stay in control.Try it: https://aliyev.site/rcf/
Docs & implementation: https://aliyev.site/rcf
#AIProtection #OpenSource #CodeSecurity #IntellectualProperty