DEV Community: famatyyk

Zbudowałem darmowy linter C++/Lua/Python w 100 liniach — oto co wykrywa

famatyyk — Sat, 08 Aug 2026 23:45:05 +0000

Dlaczego darmowy linter?

Większość "audytorów kodu" to zamknięte SaaS-y z subskrypcją. Chciałem czegoś, co:

działa offline, bez wysyłania kodu na serwer,
ma zero zależności (tylko stdlib Pythona),
daje natychmiastowy feedback w terminalu.

Tak powstał ctoai-lint — lekki linter statyczny C++ / Lua / Python.

Co wykrywa?

Język	Wzorzec	Ryzyko
C/C++	`strcpy`, `strcat`, `gets`, `sprintf`, `scanf`	HIGH
Lua	`load`, `loadstring`, `os.execute`, `io.popen`	HIGH
Python	`eval`, `exec`, `os.system`, `subprocess.call`, `pickle.loads`	MEDIUM
Wszystkie	podejrzane przypisania `api_key=...`, `password=...`	HIGH

Project Health

health = max(0, 100 - 8*high - 3*medium)

Przykład na demo pliku (tests/sample_cpp.cpp z strcpy + sprintf):

$ ctoai-lint tests
ctoai-lint: 2 plikow, 2 znalezisk, HIGH=2
Project Health: 84/100

Instalacja (bez PyPI)

pip install git+https://github.com/famatyyk/CTOAi-Lint
ctoai-lint . --json

Dlaczego to legalne / bezpieczne?

Tylko analiza plików tekstowych. Brak modyfikacji kodu, brak injection, brak sieci.
To demo silnika za CTOAi Project Doctor — tam jest pełna wersja (CMake, JS/TS, 5 kroków naprawczych, GitHub Action).

Spróbuj

Zrób fork, wrzuć swój kod, zobacz health.⭐ na GitHubie pomaga mi budować pełną wersję.

MIT — używaj swobodnie.

7 legalnych narzędzi C++ / Lua / Windows, które zbudowałem zamiast cheatów

famatyyk — Sat, 08 Aug 2026 21:14:13 +0000

Dlaczego?

Większość ludzi zainteresowanych reverse engineeringiem i automatyzacją ląduje w szarej strefie: injectory, bypassy anti-cheat, boty do gier. To droga donikąd — ToS, ban, ryzyko prawne.

Postanowiłem pójść w drugą stronę: narzędzia, które wykrywają i diagnozują, zamiast łamać. Wszystkie są read-only, działają w Twoim środowisku i nie dotykają obcych procesów.

Oto 7 narzędzi, które zbudowałem i które możesz kupić / obejrzeć za darmo na GitHubie.

1. Project Doctor — statyczny audyt kodu

Analizuje Python / C++ / Lua / JS / TS. Wykrywa:

surowe new i strcpy w C++
brak target_compile_features w CMake
load / os.execute w Lua
wycieki sekretów, brak testów

Wynik: Health 0–100 + 5 kroków naprawczych.
Cena: od 19 € (C++ / Build 29 €)

2. Lua Script Hub

Gotowe, bezpieczne skrypty Lua dla modderów (love2d / GMod / Factorio). Wzorce bez load/os.execute — edukacyjne, kopiowalne.
Cena: 19 €

3. WinAPI Toolkit

Legalna automatyzacja Windows przez Win32 API (C++). Przykład: enumeracja widocznych okien i ich tytułów — read-only, bez wstrzykiwania.
Cena: 29 €

4. CTF Pack

Generator edukacyjnych zadań RE/CTF (ukryta flaga w blobie, quiz analizy kodu). Bez malware, bez crackme chronionego softu.
Cena: 19 €

5. Anti-Cheat Lab

TYLKO detekcja. Skanuje sygnatury nazw modułów (cheatengine, speedhack, aimbot) — jak antywirus. Brak bypassu anti-cheat, brak cheatów.
Cena: 29 €

6. Memory Scanner

Skaner wzorców bajtów w własnej pamięci (debug-tool C++). Read-only, brak obcych procesów.
Cena: 29 €

7. Game Mod Audit

Statyczny audyt modów (Factorio / Minecraft). Sprawdza manifest + ryzykowne wzorce Lua przed publikacją.
Cena: 19 €

Gdzie to zobaczyć?

Landing: https://ctoai-funnel.fly.dev/
Wszystkie repo: github.com/famatyyk (CTOAi-Project-Doctor, CTOAi-LuaHub, CTOAi-WinToolkit, CTOAi-CTFGen, CTOAi-ACLab, CTOAi-MemScan, CTOAi-ModAudit)

Co dalej?

Buduję CTOAi Doctor CI — GitHub Action, który odpala audyt na każdym PR. Jeśli chcesz być w beta, napisz na landingu.

Legalnie. Read-only. Bez ingerencji w obce procesy.

"I ran a static analyzer on a tiny C++ file — it caught 4 real issues in 10 lines"

famatyyk — Sat, 08 Aug 2026 06:04:44 +0000

I ran a static analyzer on a tiny C++ file — it caught 4 real issues in 10 lines

I build Project Doctor — a static audit tool for repos (Python, C++, Lua, JS/TS). It doesn't run your code, doesn't install deps, doesn't read secrets. It just inventories structure, scans for risk patterns, and gives you a prioritized report.

To sanity-check the C++ analyzer, I threw a deliberately ugly 10-line snippet at it:

#include <cstdio>
#include <cstring>

int main() {
    char* buf = new char[256];      // raw new
    strcpy(buf, "hello");           // unsafe function
    printf("val=%d\n", 42);         // printf family
    int* p = (int*)buf;             // C-style cast
    goto cleanup;                    // goto
    cleanup:
    return 0;
}

What it flagged

Severity	Issue	Why it matters
HIGH	`strcpy` (unsafe C function)	Buffer overflow risk — use `std::string` / `snprintf`
MEDIUM	Raw `new` without ownership	Leak risk — use `std::unique_ptr` / `std::shared_ptr`
LOW	C-style cast	Prefer `static_cast` / `const_cast` for type safety
LOW	`goto`	Hurts readability — use loops/functions/`std::expected`

Result: 16/100. (Yes, a 10-line toy file scores 16. Real projects with tests/CI/clean structure score much higher.)

Why this isn't "just use clang-tidy"

clang-tidy is great. But it requires you to set up the build, compile flags, and a working toolchain. Project Doctor is for the moment before that — when you want to know what to fix without configuring a pipeline. It's the "pre-flight check" for a client handoff or open-source release.

Try it

From 19 EUR (Python/Lua/JS/TS) · 29 EUR (C++)
Report in Markdown + JSON, 24–48h
100% static — no code execution, no dependency install

👉 https://ctoai-funnel.fly.dev/

Sample audit of requests (Python) here: https://github.com/famatyyk/project-doctor-samples

Found something wrong in this post? Comment — I'll fix it. (I audit my own tool's repo too.)