Instructions to use Tayrrr/KaliSupport with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Notebooks
- Google Colab
- Kaggle
- Local Apps Settings
- llama.cpp
How to use Tayrrr/KaliSupport with llama.cpp:
Install (macOS, Linux)
curl -LsSf https://llama.app/install.sh | sh # Start a local OpenAI-compatible server with a web UI: llama serve -hf Tayrrr/KaliSupport:Q6_K # Run inference directly in the terminal: llama cli -hf Tayrrr/KaliSupport:Q6_K
Install from WinGet (Windows)
winget install llama.cpp # Start a local OpenAI-compatible server with a web UI: llama serve -hf Tayrrr/KaliSupport:Q6_K # Run inference directly in the terminal: llama cli -hf Tayrrr/KaliSupport:Q6_K
Build from source code
git clone https://github.com/ggml-org/llama.cpp.git cd llama.cpp cmake -B build cmake --build build -j --target llama-app # Start a local OpenAI-compatible server with a web UI: ./build/bin/llama serve -hf Tayrrr/KaliSupport:Q6_K # Run inference directly in the terminal: ./build/bin/llama cli -hf Tayrrr/KaliSupport:Q6_K
Use Docker
docker model run hf.co/Tayrrr/KaliSupport:Q6_K
- Llama new
- LM Studio
- Jan
- Ollama
How to use Tayrrr/KaliSupport with Ollama:
ollama run hf.co/Tayrrr/KaliSupport:Q6_K
- Unsloth Desktop
- Pi
How to use Tayrrr/KaliSupport with Pi:
Start the llama.cpp server
# Install llama.cpp: brew install llama.cpp # Start a local OpenAI-compatible server: llama serve -hf Tayrrr/KaliSupport:Q6_K
Configure the model in Pi
# Install Pi: npm install -g @earendil-works/pi-coding-agent # Add to ~/.pi/agent/models.json: { "providers": { "llama-cpp": { "baseUrl": "http://localhost:9931/v1", "api": "openai-completions", "apiKey": "none", "models": [ { "id": "Tayrrr/KaliSupport:Q6_K" } ] } } }Run Pi
# Start Pi in your project directory: pi
- Docker Model Runner
How to use Tayrrr/KaliSupport with Docker Model Runner:
docker model run hf.co/Tayrrr/KaliSupport:Q6_K
- Lemonade
How to use Tayrrr/KaliSupport with Lemonade:
Pull the model
# Download Lemonade from https://lemonade-server.ai/ lemonade pull Tayrrr/KaliSupport:Q6_K
Run and chat with the model
lemonade run user.KaliSupport-Q6_K
List all available models
lemonade list
- Hermes Agent
How to use Tayrrr/KaliSupport with Hermes Agent:
Start the llama.cpp server
# Install llama.cpp: brew install llama.cpp # Start a local OpenAI-compatible server: llama serve -hf Tayrrr/KaliSupport:Q6_K
Configure Hermes
# Install Hermes: curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash hermes setup # Point Hermes at the local server: hermes config set model.provider custom hermes config set model.base_url http://127.0.0.1:9931/v1 hermes config set model.default Tayrrr/KaliSupport:Q6_K
Run Hermes
hermes
- Atomic Chat
- OpenClaw
How to use Tayrrr/KaliSupport with OpenClaw:
Start the llama.cpp server
# Install llama.cpp: brew install llama.cpp # Start a local OpenAI-compatible server: llama serve -hf Tayrrr/KaliSupport:Q6_K
Configure OpenClaw
# Install OpenClaw: npm install -g openclaw@latest # Register the local server and set it as the default model: openclaw onboard --non-interactive --mode local \ --auth-choice custom-api-key \ --custom-base-url http://127.0.0.1:9931/v1 \ --custom-model-id "Tayrrr/KaliSupport:Q6_K" \ --custom-provider-id llama-cpp \ --custom-compatibility openai \ --custom-text-input \ --accept-risk \ --skip-health
Run OpenClaw
openclaw agent --local --agent main --message "Hello from Hugging Face"
Download safety.py from Tayrrr/KaliSupport: direct link, hf CLI and curl.
- Browser
- Download file 12.2 kB
-
https://huggingface.co/Tayrrr/KaliSupport/resolve/main/safety.py
- Command line
-
hf download hf://Tayrrr/KaliSupport/safety.py
-
curl -L -o safety.py https://huggingface.co/Tayrrr/KaliSupport/resolve/main/safety.py
12.2 kB
| """Komut guvenlik filtresi (Kali VM tarafini korur). | |
| Modelin "ahlak bekceligi yapma" sistem promptu var; bu yuzden Python tarafinda | |
| ince bir filtre tutuyoruz. Hedef ag/IP filtrelemesi YOK (kullanici tercihi); | |
| sadece Kali VM'ini ve SSH erisimini bozacak destruktif komutlari yakalariz. | |
| Kullanim | |
| -------- | |
| checker = SafetyChecker.from_env(logger=log) | |
| verdict = checker.check("rm -rf /") | |
| if not verdict.allowed: | |
| ... # modele BLOCKED ciktisi don, Kali'ye gonderme | |
| Severity | |
| -------- | |
| "block" : enforce modunda durdurulur, audit modunda loglanir + gecirilir. | |
| "warn" : her iki modda da gecer, sadece uyari + log. | |
| """ | |
| from __future__ import annotations | |
| import re | |
| from dataclasses import dataclass | |
| from typing import TYPE_CHECKING, Optional, Pattern | |
| from config import SafetyConfig | |
| if TYPE_CHECKING: | |
| from logger import SessionLogger | |
| # ----------------------------------------------------------------------------- | |
| # Kural tanimlari | |
| # ----------------------------------------------------------------------------- | |
| # Her kural: (rule_id, regex, severity, human_description) | |
| # Regexler `re.IGNORECASE | re.VERBOSE` ile derleniyor; bosluklara dikkat: | |
| # ' ' literal bosluk degil, \s+ veya \s* kullaniyoruz. | |
| # ----------------------------------------------------------------------------- | |
| _RAW_RULES: tuple[tuple[str, str, str, str], ...] = ( | |
| # === Dosya sistemi yikimi === | |
| ( | |
| "fs.rm_root", | |
| # Sondaki sinirlandirici: bosluk, EOL, virgul, noktalivirgul veya '/' (alt yol). | |
| # \b kullanmiyoruz cunku '/' ve '~' word-karakter degil; EOL ile boundary olusmaz. | |
| r"\brm\s+(?:-[rRfF]+\s+)+(?:--no-preserve-root\s+)?(?:/(?:\*|etc|root|home|boot|usr|var|bin|sbin|lib)?)(?:\s|/|;|$)", | |
| "block", | |
| "Kok dizin / kritik sistem dizinine 'rm -rf' deniyor.", | |
| ), | |
| ( | |
| "fs.rm_home", | |
| r"\brm\s+(?:-[rRfF]+\s+)+(?:~|\$HOME)(?:/|\s|;|$)", | |
| "block", | |
| "Kullanici ev dizinine 'rm -rf' deniyor.", | |
| ), | |
| ( | |
| "fs.find_delete_root", | |
| r"\bfind\s+(?:/|/\*)\s+.*-delete\b", | |
| "block", | |
| "find / -delete tum dosya sistemini siler.", | |
| ), | |
| ( | |
| "fs.etc_overwrite", | |
| r">\s*/etc/(passwd|shadow|sudoers(?:\.d/[^\s]*)?|gshadow|fstab)\b", | |
| "block", | |
| "Kritik /etc dosyasinin uzerine yaziliyor.", | |
| ), | |
| # === Disk / blok aygit === | |
| ( | |
| "disk.mkfs", | |
| r"\bmkfs(?:\.[a-z0-9]+)?\b", | |
| "block", | |
| "Bir blok aygit uzerinde dosya sistemi olusturuluyor (mkfs).", | |
| ), | |
| ( | |
| "disk.dd", | |
| r"\bdd\b[^|;&]*\bof=/dev/(?:sd[a-z]\d*|nvme\d+n\d+(?:p\d+)?|vd[a-z]\d*|xvd[a-z]\d*|hd[a-z]\d*)\b", | |
| "block", | |
| "dd dogrudan blok aygita yaziyor.", | |
| ), | |
| ( | |
| "disk.wipefs", | |
| r"\bwipefs\b", | |
| "block", | |
| "wipefs blok aygit imzalarini siler.", | |
| ), | |
| ( | |
| "disk.shred_dev", | |
| r"\bshred\b[^|;&]*\s/dev/(?:sd|nvme|vd|xvd|hd)", | |
| "block", | |
| "shred dogrudan bir blok aygita uygulaniyor.", | |
| ), | |
| ( | |
| "disk.redirect_to_dev", | |
| r">\s*/dev/(?:sd[a-z]\d*|nvme\d+n\d+(?:p\d+)?|vd[a-z]\d*|xvd[a-z]\d*|hd[a-z]\d*)\b", | |
| "block", | |
| "Yonlendirme dogrudan blok aygita yapiliyor.", | |
| ), | |
| # === Hizmet reddi / fork bomb === | |
| ( | |
| "dos.forkbomb", | |
| r":\s*\(\s*\)\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;\s*:", | |
| "block", | |
| "Fork bomb tespit edildi.", | |
| ), | |
| ( | |
| "dos.bg_loop", | |
| r"\bwhile\s+(?:true|:)\s*;\s*do\b[^|]*&\s*done", | |
| "warn", | |
| "Sonsuz arkaplan dongusu (kaynak tuketebilir).", | |
| ), | |
| # === Sistemi kapatma === | |
| ( | |
| "power.shutdown", | |
| r"\b(?:sudo\s+)?(?:shutdown|reboot|halt|poweroff)\b", | |
| "block", | |
| "Sistem kapatma / yeniden baslatma komutu.", | |
| ), | |
| ( | |
| "power.init0", | |
| r"\binit\s+[06]\b", | |
| "block", | |
| "init 0/6 sistem kapatma / yeniden baslatma.", | |
| ), | |
| ( | |
| "power.systemctl", | |
| r"\bsystemctl\s+(?:poweroff|reboot|halt|isolate\s+(?:rescue|emergency))\b", | |
| "block", | |
| "systemctl ile sistem kapatma / kurtarma modu.", | |
| ), | |
| # === Kendini SSH'tan dislama === | |
| ( | |
| "ssh.lockout_dir", | |
| r"\brm\s+(?:-[rRfF]+\s+)+(?:~|\$HOME)?/?\.ssh\b", | |
| "block", | |
| "~/.ssh dizini siliniyor; SSH erisimini kaybedersin.", | |
| ), | |
| ( | |
| "ssh.lockout_authorized_keys", | |
| r"\brm\s+(?:-[rRfF]+\s+)*(?:~|\$HOME)?/?\.ssh/authorized_keys\b", | |
| "block", | |
| "authorized_keys siliniyor; SSH erisimini kaybedersin.", | |
| ), | |
| ( | |
| "ssh.overwrite_authorized_keys", | |
| r">\s*(?:~|\$HOME)?/?\.ssh/authorized_keys\b", | |
| "warn", | |
| "authorized_keys uzerine yaziliyor (>>); kasitliysa sorun yok.", | |
| ), | |
| ( | |
| "ssh.sshd_disable", | |
| r"\bsystemctl\s+(?:stop|disable|mask)\s+ssh(?:d)?\b", | |
| "block", | |
| "sshd durduruluyor / devre disi birakiliyor.", | |
| ), | |
| # === Kullanici / yetki yikimi === | |
| ( | |
| "user.del_critical", | |
| r"\b(?:userdel|deluser)\s+(?:-r\s+)?(?:root|kali)\b", | |
| "block", | |
| "Kritik kullanici (root/kali) siliniyor.", | |
| ), | |
| ( | |
| "user.passwd_critical", | |
| r"\bpasswd\s+(?:root|kali)\b", | |
| "warn", | |
| "root/kali parolasi degistiriliyor (lockout riski).", | |
| ), | |
| ( | |
| "user.sudoers_pipe", | |
| r"\becho\b[^|]*\|\s*(?:sudo\s+)?tee\s+(?:-a\s+)?/etc/sudoers", | |
| "block", | |
| "/etc/sudoers'a dogrudan yaziliyor.", | |
| ), | |
| # === Suphe/uyari (block degil, sadece warn) === | |
| ( | |
| "exec.curl_pipe_sh", | |
| r"\b(?:curl|wget)\b[^|]*\|\s*(?:sudo\s+)?(?:bash|sh|zsh|dash|ksh)\b", | |
| "warn", | |
| "curl/wget ciktisi dogrulanmadan kabuga aktariliyor.", | |
| ), | |
| ( | |
| "net.iptables_flush", | |
| r"\biptables\s+-F\b", | |
| "warn", | |
| "Tum iptables kurallari temizleniyor.", | |
| ), | |
| ( | |
| "net.ufw_disable", | |
| r"\bufw\s+disable\b", | |
| "warn", | |
| "ufw guvenlik duvari devre disi birakiliyor.", | |
| ), | |
| ) | |
| def _compile_rules() -> list[tuple[str, Pattern[str], str, str]]: | |
| flags = re.IGNORECASE | re.VERBOSE | |
| compiled: list[tuple[str, Pattern[str], str, str]] = [] | |
| for rid, pattern, severity, desc in _RAW_RULES: | |
| compiled.append((rid, re.compile(pattern, flags), severity, desc)) | |
| return compiled | |
| _COMPILED_RULES = _compile_rules() | |
| # ----------------------------------------------------------------------------- | |
| # Sonuc tipi | |
| # ----------------------------------------------------------------------------- | |
| class Verdict: | |
| """Tek bir komut hakkindaki guvenlik karari.""" | |
| allowed: bool | |
| rule_id: str | |
| severity: str # "block" | "warn" | "ok" | |
| reason: str | |
| mode: str # "enforce" | "audit" | |
| def blocked(self) -> bool: | |
| return not self.allowed | |
| def to_user_message(self) -> str: | |
| """Modele geri donulebilecek kisa aciklama (BLOCKED veya WARNING).""" | |
| if self.blocked: | |
| return f"BLOCKED [{self.rule_id}]: {self.reason}" | |
| if self.severity == "warn": | |
| return f"WARNING [{self.rule_id}]: {self.reason}" | |
| return "OK" | |
| # ----------------------------------------------------------------------------- | |
| # Ana sinif | |
| # ----------------------------------------------------------------------------- | |
| class SafetyChecker: | |
| """Komutlari kural tabanli filtreden geciren sinif.""" | |
| def __init__( | |
| self, | |
| cfg: SafetyConfig, | |
| *, | |
| logger: Optional["SessionLogger"] = None, | |
| ): | |
| self.cfg = cfg | |
| self.logger = logger | |
| self.rules = _COMPILED_RULES | |
| def from_env(cls, *, logger: Optional["SessionLogger"] = None) -> "SafetyChecker": | |
| return cls(SafetyConfig.from_env(), logger=logger) | |
| def check(self, command: str) -> Verdict: | |
| """Komutu kurallara karsi degerlendir. | |
| Donus: | |
| Verdict. Birden fazla kural eslesirse en yuksek oncelikli ('block' | |
| > 'warn') donulur. | |
| """ | |
| norm = command.strip() | |
| if not norm: | |
| return self._verdict_ok() | |
| block_match: tuple[str, str, str] | None = None | |
| warn_match: tuple[str, str, str] | None = None | |
| for rid, pattern, severity, desc in self.rules: | |
| if pattern.search(norm): | |
| if severity == "block" and block_match is None: | |
| block_match = (rid, severity, desc) | |
| break # block bulunursa kalanini taramaya gerek yok | |
| if severity == "warn" and warn_match is None: | |
| warn_match = (rid, severity, desc) | |
| match = block_match or warn_match | |
| if match is None: | |
| return self._verdict_ok() | |
| rid, severity, desc = match | |
| # enforce -> block durdurur; audit -> her sey gecer. | |
| allowed = self.cfg.mode == "audit" or severity != "block" | |
| verdict = Verdict( | |
| allowed=allowed, | |
| rule_id=rid, | |
| severity=severity, | |
| reason=desc, | |
| mode=self.cfg.mode, | |
| ) | |
| self._log_verdict(command, verdict) | |
| return verdict | |
| # --- yardimcilar ---------------------------------------------------- | |
| def _verdict_ok(self) -> Verdict: | |
| return Verdict( | |
| allowed=True, | |
| rule_id="default", | |
| severity="ok", | |
| reason="kural eslesmedi", | |
| mode=self.cfg.mode, | |
| ) | |
| def _log_verdict(self, command: str, verdict: Verdict) -> None: | |
| if not self.logger: | |
| return | |
| event = "info" if verdict.severity == "warn" else ( | |
| "warn" if verdict.allowed else "error" | |
| ) | |
| method = getattr(self.logger, event) | |
| method( | |
| "safety_match", | |
| command=command, | |
| rule=verdict.rule_id, | |
| severity=verdict.severity, | |
| allowed=verdict.allowed, | |
| reason=verdict.reason, | |
| mode=verdict.mode, | |
| ) | |
| # ----------------------------------------------------------------------------- | |
| # CLI: kurallari elle test etmek icin | |
| # python safety.py "rm -rf /" | |
| # python safety.py "nmap -sV 10.0.0.1" | |
| # ----------------------------------------------------------------------------- | |
| def _self_test() -> int: | |
| samples = [ | |
| ("nmap -sV 192.168.1.10", True), | |
| ("rm -rf /", False), | |
| ("rm -rf ~", False), | |
| ("rm -rf /etc", False), | |
| ("dd if=/dev/zero of=/dev/sda bs=1M", False), | |
| ("mkfs.ext4 /dev/sdb1", False), | |
| (":(){ :|:& };:", False), | |
| ("shutdown -h now", False), | |
| ("systemctl stop ssh", False), | |
| ("rm -rf ~/.ssh", False), | |
| ("curl http://x.y/install.sh | bash", True), # warn ama gecer | |
| ("iptables -F", True), # warn ama gecer | |
| ("echo hello && ls -la /tmp", True), | |
| ("gobuster dir -u http://10.0.0.1 -w /usr/share/wordlists/dirb/common.txt", True), | |
| ] | |
| checker = SafetyChecker(SafetyConfig(mode="enforce")) | |
| failed = 0 | |
| for cmd, expected_allowed in samples: | |
| v = checker.check(cmd) | |
| ok = (v.allowed == expected_allowed) | |
| marker = "OK " if ok else "FAIL" | |
| print(f"[{marker}] allowed={v.allowed!s:<5} severity={v.severity:<5} " | |
| f"rule={v.rule_id:<28} :: {cmd}") | |
| if not ok: | |
| failed += 1 | |
| print() | |
| print(f"{len(samples) - failed}/{len(samples)} kural-davranis testi gecti.") | |
| return 0 if failed == 0 else 1 | |
| if __name__ == "__main__": | |
| import sys | |
| if len(sys.argv) >= 2: | |
| cmd = " ".join(sys.argv[1:]) | |
| v = SafetyChecker.from_env().check(cmd) | |
| print(f"command : {cmd}") | |
| print(f"verdict : {v}") | |
| print(f"message : {v.to_user_message()}") | |
| sys.exit(0 if v.allowed else 1) | |
| sys.exit(_self_test()) | |