Nền tảng lập trình & ScriptingProgramming & Scripting Foundations

Thuộc bộ kiến thức DevSecOps Roadmap.

Tổng quan

DevSecOps không phải là vai trò “đứng ngoài xem”. Các security engineer chỉ biết đọc dashboard và tạo ticket sẽ bị giới hạn trong những check mà người khác đã xây sẵn. Ngay khi bạn có thể viết một script, bạn có thể tự động hóa việc scan hàng nghìn host thay vì click từng cái một, parse output lộn xộn của một tool thành thứ mà pipeline có thể dùng để gate, nối hai tool vốn không được thiết kế để nói chuyện với nhau, hoặc triage một incident bằng cách grep log nhanh hơn bất kỳ giao diện đồ họa nào.

Note này bao quát các ngôn ngữ quan trọng nhất trong công việc DevSecOps hằng ngày — mỗi ngôn ngữ mạnh ở điểm nào, một ví dụ runnable cho từng ngôn ngữ, và một bảng so sánh giúp bạn chọn đúng công cụ cho đúng việc. Mục tiêu không phải là thành thạo tuyệt đối một ngôn ngữ nào, mà là đủ fluency ở mỗi ngôn ngữ để đọc được tooling của người khác, tự viết các utility nhỏ, và biết nên dùng ngôn ngữ nào cho tình huống nào. Note này tiếp nối Introduction to DevSecOps, vốn bao quát phần culture và process của discipline này, còn note này cung cấp bộ công cụ kỹ thuật tương ứng.

Vì sao điều này quan trọng riêng cho công việc security

• Tự động hóa scan — hầu hết security tool (Nmap, Trivy, Semgrep, OWASP ZAP, Nikto) đều CLI-first. Wrap chúng trong script là cách biến một check thủ công thành một control có thể lặp lại, lên lịch, và gate trong CI.
• Parse output — security tool xuất ra JSON, XML, hoặc text lộn xộn. Biến chúng thành tín hiệu pass/fail, ticket, hoặc metric đòi hỏi code, không phải copy-paste.
• Nối các pipeline lại với nhau — một security gate trong CI/CD hiếm khi chỉ là một tool; nó thường là một script chạy scanner, parse kết quả, so với policy, rồi fail build (hoặc mở ticket) tương ứng.
• Incident response — dưới áp lực thời gian, một script năm dòng grep mọi log trên cả một fleet host để tìm IOC (indicator of compromise) nhanh hơn nhiều so với SSH thủ công vào từng máy.
• Tự xây tooling riêng — đôi khi tool bạn cần chưa tồn tại, hoặc tool có sẵn không phù hợp với môi trường của bạn. Một secret scanner tùy chỉnh, một Slack bot post digest vulnerability, một proxy nhỏ để fuzz API — những thứ này thường chỉ vài trăm dòng code, không phải một sản phẩm hoàn chỉnh.

Kiến thức nền tảng

Bảng so sánh ngôn ngữ ở mức tổng quan

Ngôn ngữ	Use case security điển hình	Ví dụ tool viết bằng ngôn ngữ này
Bash	Nối các CLI tool lại, loop qua host, cron job, check nhanh khi incident response	Nhiều script hardening/audit trên Linux (ví dụ lynis dùng shell rất nhiều)
Python	Automation tổng quát, script gọi API, helper tooling cho SAST/DAST, exploit PoC	bandit (SAST cho Python), sqlmap, các tool dựa trên Scapy
Go	Scanner chạy concurrent, security CLI tool portable phân phối dưới dạng single binary	nuclei, trivy, gitleaks, subfinder
PowerShell	Audit/hardening Windows và Active Directory, offensive AD tooling	PowerView, PowerSploit, các script security baseline của chính Microsoft
Ruby	Phát triển exploit và module trong một framework có sẵn	Metasploit Framework
Rust	Fuzzer và parser memory-safe cho input không tin cậy, CLI tool hiệu năng cao	cargo-fuzz, RustScan
JavaScript/Node.js	Tooling security cho web app, headless browser automation, check trong pipeline JS	Scanner dựa trên Puppeteer/Playwright, ESLint security plugin
C/C++	Network tool low-level, scanner cổ điển, phát triển exploit cho lỗi memory-corruption	Nmap (phần core), payload native của Metasploit

Bash — chất keo cho automation security trên Linux

Bash là ngôn ngữ mặc định của shell. Bạn không thực sự “chọn” nó vì mỗi lần SSH vào một máy bạn đã đứng trong nó rồi. Với DevSecOps, các use case cốt lõi của Bash là: loop qua danh sách host, nối các CLI tool bằng pipe, chạy như cron job theo lịch, và các check nhanh khi xử lý incident.

Các construct đáng nhớ nằm lòng:

# Looping over a list of hosts read from a file
while read -r host; do
  echo "Scanning $host..."
  nmap -Pn -p 22,80,443 "$host" -oG - | grep -q "22/open" && echo "$host: SSH exposed"
done < hosts.txt

# Command substitution + conditionals
if ! systemctl is-active --quiet fail2ban; then
  echo "WARNING: fail2ban is not running" >&2
fi

# Safer script defaults
set -euo pipefail

set -euo pipefail là dòng quan trọng nhất cần đặt ở đầu bất kỳ Bash script nào liên quan đến security: -e khiến script exit ngay khi command đầu tiên fail, -u coi biến chưa được set là lỗi, và -o pipefail khiến cả pipeline fail nếu bất kỳ stage nào trong đó fail (chứ không chỉ stage cuối). Nếu thiếu dòng này, script sẽ âm thầm chạy tiếp sau khi gặp lỗi — đúng kiểu failure mode mà bạn không muốn có trong một security check.

Ví dụ: một security check nhỏ dựa trên log-grep. Script này scan auth log để tìm một chuỗi đăng nhập SSH thất bại dồn dập từ cùng một IP và flag bất kỳ trường hợp nào vượt ngưỡng — một brute-force detector tối giản, phù hợp để chạy trong cron job:

#!/usr/bin/env bash
set -euo pipefail

LOG_FILE="${1:-/var/log/auth.log}"
THRESHOLD=10

echo "Checking $LOG_FILE for SSH brute-force attempts (threshold: $THRESHOLD)..."

grep "Failed password" "$LOG_FILE" \
  | grep -oE "from [0-9]{1,3}(\.[0-9]{1,3}){3}" \
  | awk '{print $2}' \
  | sort \
  | uniq -c \
  | sort -rn \
  | while read -r count ip; do
      if (( count >= THRESHOLD )); then
        echo "ALERT: $ip had $count failed login attempts"
      fi
    done

Lưu thành check_ssh_bruteforce.sh, chmod +x rồi đưa vào cron:

# /etc/cron.d/ssh-bruteforce-check — run every 15 minutes
*/15 * * * * root /usr/local/bin/check_ssh_bruteforce.sh /var/log/auth.log >> /var/log/bruteforce-alerts.log 2>&1

Điểm yếu của Bash lộ ra rất nhanh khi logic phức tạp lên: không có cấu trúc dữ liệu thực sự ngoài array, thao tác string khá vất vả, và lỗi quoting rất dễ bị bỏ sót. Khi một “script nhanh” phình lên quá ~50 dòng, hoặc cần parse JSON/handle retry/gọi API, đó là tín hiệu để chuyển sang Python.

Python — ngôn ngữ mặc định của DevSecOps

Python là thứ gần nhất với một lingua franca trong DevSecOps. Nó đọc gần giống pseudocode, có standard library đồ sộ, và một hệ sinh thái package chuyên biệt cho security còn đồ sộ hơn: requests cho HTTP, paramiko/fabric cho automation qua SSH, boto3 cho AWS, python-nmap để wrap Nmap, scapy để craft packet, và các framework như bandit (SAST cho chính Python) cũng được viết bằng Python.

Ví dụ: một scanner đơn giản phát hiện secret bị lộ. Script này duyệt qua một cây thư mục và flag các file trông như chứa credential hardcode — một phiên bản rút gọn của những gì các tool như gitleaks hay trufflehog làm:

#!/usr/bin/env python3
"""secret_scan.py — flag likely hardcoded secrets in a source tree."""

import re
import sys
from pathlib import Path

PATTERNS = {
    "AWS Access Key": re.compile(r"AKIA[0-9A-Z]{16}"),
    "Generic API Key": re.compile(r"(?i)api[_-]?key\s*[:=]\s*['\"][A-Za-z0-9_\-]{16,}['\"]"),
    "Private Key Block": re.compile(r"-----BEGIN (RSA|EC|OPENSSH|DSA) PRIVATE KEY-----"),
    "Slack Token": re.compile(r"xox[baprs]-[0-9A-Za-z-]{10,}"),
}

SKIP_DIRS = {".git", "node_modules", "venv", "__pycache__"}


def scan_file(path: Path) -> list[tuple[str, str, int]]:
    findings = []
    try:
        text = path.read_text(errors="ignore")
    except (UnicodeDecodeError, PermissionError):
        return findings

    for line_no, line in enumerate(text.splitlines(), start=1):
        for name, pattern in PATTERNS.items():
            if pattern.search(line):
                findings.append((name, str(path), line_no))
    return findings


def main(root: str) -> int:
    root_path = Path(root)
    all_findings = []

    for path in root_path.rglob("*"):
        if any(part in SKIP_DIRS for part in path.parts):
            continue
        if path.is_file():
            all_findings.extend(scan_file(path))

    if all_findings:
        print(f"Found {len(all_findings)} potential secret(s):\n")
        for name, file_path, line_no in all_findings:
            print(f"  [{name}] {file_path}:{line_no}")
        return 1

    print("No secrets found.")
    return 0


if __name__ == "__main__":
    target = sys.argv[1] if len(sys.argv) > 1 else "."
    sys.exit(main(target))

Chạy bằng python3 secret_scan.py . và nó sẽ exit non-zero khi tìm thấy gì đó — đúng contract exit-code mà một CI pipeline cần để fail build khi phát hiện vấn đề.

Một pattern phổ biến thứ hai là gọi thẳng security API:

import requests

def check_vulners(cve_id: str, api_key: str) -> dict:
    resp = requests.get(
        "https://vulners.com/api/v3/search/id/",
        params={"id": cve_id},
        headers={"X-Api-Key": api_key},
        timeout=10,
    )
    resp.raise_for_status()
    return resp.json()

Điểm yếu chính của Python cho security tooling là distribution: ship một Python script nghĩa là ship (hoặc giả định có sẵn) một interpreter và các dependency — đây chính xác là thứ mà Go giải quyết.

Go — ngôn ngữ của security tooling hiện đại

Một phần lớn security tool được xây trong thập kỷ qua (nuclei, subfinder, trivy, gitleaks, amass, phần lớn toolkit của ProjectDiscovery, và các security tool cloud-native/Kubernetes nói chung) đều được viết bằng Go. Hai lý do chính:

1. Single static binary. go build tạo ra một executable tự chứa duy nhất, không phụ thuộc runtime — copy nó sang bất kỳ máy Linux/macOS/Windows nào và nó chạy được ngay. Điều này cực kỳ quan trọng với các security tool cần chạy trong container tối giản, trên hệ thống air-gapped, hoặc như một phần của CI image mà không cần cài language runtime.
2. Concurrency có sẵn. Goroutine và channel khiến việc “scan 10,000 host/URL đồng thời” trở thành một pattern tự nhiên và rẻ — đúng profile workload của scanner, crawler, và brute-forcer.

Ví dụ: một port checker nhỏ chạy concurrent, minh họa cả hai điểm trên:

package main

import (
	"fmt"
	"net"
	"sync"
	"time"
)

func checkPort(host string, port int, wg *sync.WaitGroup, results chan<- string) {
	defer wg.Done()
	address := fmt.Sprintf("%s:%d", host, port)
	conn, err := net.DialTimeout("tcp", address, 2*time.Second)
	if err == nil {
		conn.Close()
		results <- fmt.Sprintf("%s: OPEN", address)
	}
}

func main() {
	host := "127.0.0.1"
	ports := []int{22, 80, 443, 3306, 6379, 8080}

	var wg sync.WaitGroup
	results := make(chan string, len(ports))

	for _, port := range ports {
		wg.Add(1)
		go checkPort(host, port, &wg, results)
	}

	wg.Wait()
	close(results)

	for r := range results {
		fmt.Println(r)
	}
}

go build -o portcheck main.go tạo ra một binary duy nhất mà bạn có thể đưa cho đồng nghiệp hoặc bake vào một container image scratch/distroless — không cần pip install, không lo runtime version mismatch.

PowerShell — automation security cho Windows và Active Directory

Nếu Bash thống trị Linux thì PowerShell thống trị Windows — và cụ thể là Active Directory. Pipeline hướng object của nó (cmdlet truyền structured .NET object, không phải text) khiến nó phù hợp hơn Bash rất nhiều để query và thao tác những thứ như AD user, group membership, và event log. Đây cũng là ngôn ngữ được cả bên tấn công (offensive tooling như PowerView, PowerSploit, các script kiểu Mimikatz) và bên phòng thủ (script audit, hardening, detection) ưa chuộng, nên việc thành thạo cơ bản có giá trị cho cả góc nhìn red team lẫn blue team.

Ví dụ: tìm các AD account có password never expire (một finding phổ biến trong security audit):

Import-Module ActiveDirectory

Get-ADUser -Filter { PasswordNeverExpires -eq $true -and Enabled -eq $true } `
    -Properties PasswordNeverExpires, LastLogonDate |
    Select-Object Name, SamAccountName, LastLogonDate |
    Sort-Object LastLogonDate |
    Format-Table -AutoSize

Ví dụ: một security baseline check cục bộ, nhẹ nhàng:

$checks = @(
    @{ Name = "Windows Firewall (Domain)"; Test = { (Get-NetFirewallProfile -Profile Domain).Enabled } }
    @{ Name = "SMBv1 Disabled";            Test = { -not (Get-WindowsOptionalFeature -Online -FeatureName SMB1Protocol).State -eq "Enabled" } }
    @{ Name = "RDP NLA Enabled";           Test = { (Get-Item "HKLM:\System\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp").GetValue("UserAuthentication") -eq 1 } }
)

foreach ($check in $checks) {
    $result = & $check.Test
    $status = if ($result) { "PASS" } else { "FAIL" }
    Write-Host "[$status] $($check.Name)"
}

Vì PowerShell script cũng là một vector tấn công “living-off-the-land” ưa thích, các security team nên nắm rõ Set-ExecutionPolicy, script signing, và PowerShell logging/transcription (ScriptBlockLogging, Module Logging) — vừa để viết automation an toàn, vừa để phát hiện việc sử dụng độc hại.

Các ngôn ngữ khác, lướt qua

Ngôn ngữ	Vị trí trong security tooling
Ruby	Về mặt lịch sử là ngôn ngữ của Metasploit; vẫn còn liên quan cho phát triển exploit và scripting nhanh khi làm việc với các module Metasploit. Ít phổ biến hơn cho tooling mới ngày nay.
Rust	Đang phát triển nhanh cho các security tool cần memory safety cộng với hiệu năng native — fuzzer, parser cho input không tin cậy (một lớp vulnerability phổ biến), và các CLI tool thế hệ mới (tốc độ kiểu ripgrep cộng với đảm bảo an toàn). Learning curve dốc hơn Go.
JavaScript / Node.js	Thiết yếu cho web application security (khai thác phía browser, phân tích DOM-based XSS, headless browser automation qua Puppeteer/Playwright cho dynamic scanning) và để viết extension tùy chỉnh cho Burp Suite/ZAP hoặc các check CI trong pipeline dựa trên Node.
C / C++	Là nền tảng của các tool cổ điển (phần core của Nmap, nhiều exploit PoC) và thiết yếu để hiểu các vulnerability memory-corruption (buffer overflow, use-after-free) ở mức mà exploit developer cần — nhưng hiếm khi là lựa chọn đầu tiên để viết automation mới ngày nay.

Editor cho công việc security và incident-response

Phần lớn việc edit hằng ngày diễn ra trong một IDE đầy đủ (VS Code, GoLand, PyCharm), nhưng công việc DevSecOps thường xuyên đặt bạn vào một máy remote chỉ có terminal — một phiên incident response, một bastion host bị khóa, một container không có GUI. Trong tình huống đó, biết đủ rõ một terminal editor để không “vật lộn” với nó là điều quan trọng:

Editor	Nhìn nhanh
vim / neovim	Modal, learning curve ban đầu dốc, có sẵn trên gần như mọi hệ Linux (hoặc dưới tên vi). Đáng để học ít nhất: i để insert, Esc để quay về normal mode, :wq để save và quit, /pattern để search, dd để xóa một dòng. Lựa chọn mặc định cho tình huống “tôi vừa SSH vào một máy trong lúc incident và cần edit config ngay bây giờ.”
nano	Non-modal, hiển thị các phím tắt ngay trên màn hình (^O để save, ^X để exit), gần như không có learning curve. Lựa chọn dự phòng tốt khi cần edit nhanh mà không muốn nghĩ về mode.
emacs	Extensible, mặc định non-modal, mạnh mẽ nhưng nặng hơn và ít được cài sẵn phổ biến hơn vim/nano. Phổ biến hơn như một môi trường phát triển đầy đủ hơn là một editor edit nhanh trên máy remote.

Riêng với incident response: hạn chế tối đa những gì bạn cài thêm trên một máy có khả năng đã bị compromise. Nếu vim hoặc nano đã có sẵn (hầu như luôn luôn có), hãy dùng nó thay vì kéo thêm package mới có thể làm nhiễu trạng thái forensic hoặc đơn giản là không khả dụng trong môi trường air-gapped.

Version control — một tiền đề, không phải tùy chọn

Mọi script, playbook, và pipeline definition được nhắc trong note này đều thuộc về version control, vì những lý do tương tự như bất kỳ code nào khác: khả năng review, rollback, audit trail (ai đã thay đổi một security check và tại sao), và collaboration an toàn. Điều này càng đúng gấp đôi với security tooling, nơi một thay đổi không được review đối với một scan script hay một policy file có thể âm thầm vô hiệu hóa một control. Xem Version Control & Collaboration để biết các nền tảng Git, branching, và quy trình code review — không có gì trong note đó là security-specific, nhưng tất cả đều áp dụng trực tiếp vào cách bạn nên quản lý DevSecOps script và IaC.

Khái niệm chính

Idempotency trong security script

Một script scan host, apply firewall rule, hoặc rotate credential nên an toàn khi chạy hai lần. Script idempotent kiểm tra state hiện tại trước khi thay đổi nó (nếu rule chưa tồn tại thì thêm vào thay vì cứ thế thêm rule một cách mù quáng), điều này cực kỳ quan trọng khi cùng một script chạy cả interactive lẫn theo lịch (schedule).

Exit code như một contract với CI

Mọi security check dùng để gate một pipeline phải truyền đạt pass/fail thông qua exit code của nó (0 = pass, khác 0 = fail), chứ không chỉ qua text in ra. Đây là chi tiết duy nhất biến một script từ “thứ con người đọc” thành “thứ pipeline có thể enforce.”

python3 secret_scan.py . || { echo "Secrets found — failing build"; exit 1; }

Parse structured output của tool

Các security tool hiện đại ngày càng hỗ trợ output --json / -oJ chính xác là để script không phải regex-parse text dành cho con người đọc. Ưu tiên nmap -oX, trivy --format json, semgrep --json, v.v., và parse bằng thư viện JSON/XML native của ngôn ngữ thay vì scrape text đã format — output dạng format thay đổi giữa các version tool; JSON schema ổn định hơn nhiều.

import json, subprocess

result = subprocess.run(
    ["trivy", "image", "--format", "json", "myapp:latest"],
    capture_output=True, text=True, check=True,
)
report = json.loads(result.stdout)
critical = [
    v for r in report.get("Results", [])
    for v in r.get("Vulnerabilities", []) or []
    if v["Severity"] == "CRITICAL"
]
print(f"{len(critical)} CRITICAL vulnerabilities found")

Least privilege trong tooling, không chỉ trong infrastructure

Các script tự động hóa security task thường cần credential nâng quyền (một API token phạm vi rộng, root/sudo, một service account key). Áp dụng tư duy least-privilege cho credential của chính script cũng như bạn làm với một production service: scope token hẹp nhất có thể, tránh embed secret trực tiếp trong script (dùng environment variable hoặc secrets manager), và log những gì script đã làm, không phải secret nó đã dùng.

Chọn ngôn ngữ là một quyết định thiết kế, không phải sở thích cá nhân

Chọn ngôn ngữ cho một mảnh security tooling nên theo ràng buộc của nơi nó chạy và việc nó làm, chứ không chỉ theo ngôn ngữ bạn viết nhanh nhất: một check log một lần trên máy bạn đã SSH sẵn là việc của Bash; một scanner cần ship cho đồng nghiệp mà không cần cài Python là việc của Go; một cuộc audit AD là việc của PowerShell. Cố “chống lại” ngôn ngữ tự nhiên của môi trường thường tốn kém hơn thời gian tiết kiệm được khi dùng ngôn ngữ ưa thích.

Best Practices

• Mặc định dùng set -euo pipefail trong mọi Bash script không phải là one-liner tầm thường — nó biến các lỗi âm thầm thành lỗi ồn ào, dễ phát hiện.
• Không bao giờ hardcode secret trong script. Đọc từ environment variable, một file .env được loại trừ qua .gitignore, hoặc một secrets manager (Vault, AWS Secrets Manager, v.v.) — ví dụ scanner phát hiện secret bị lộ ở trên tồn tại chính vì rule này liên tục bị phá vỡ trong thực tế.
• Dùng exit code, không phải câu lệnh print, làm tín hiệu pass/fail cho bất kỳ thứ gì chạy trong CI.
• Ưu tiên structured output (JSON/XML) thay vì scrape text khi parse kết quả của một tool khác — text format có thể vỡ âm thầm giữa các version tool.
• Viết script idempotent ở bất kỳ nơi nào chúng thay đổi state (firewall rule, IAM policy, file) để việc chạy lại luôn an toàn.
• Đưa mọi script vào version control, kể cả các script incident-response tạm thời — commit chúng lại ngay cả sau khi incident đã đóng, để người xử lý incident tiếp theo không phải bắt đầu từ số 0. Xem Version Control & Collaboration.
• Chọn ngôn ngữ khớp với deployment target: Bash cho “đã có sẵn trên máy,” Python cho “hệ sinh thái phong phú và iterate nhanh,” Go cho “phải ship dưới dạng binary portable,” PowerShell cho “môi trường Windows/AD.”
• Log những gì script đã làm, không bao giờ log secret nó đã dùng — audit trail nên thể hiện hành động và kết quả, không phải token hay password.
• Giữ một repo snippet/script cá nhân. Phần lớn automation trong DevSecOps là các mảnh nhỏ, tái sử dụng được (một host-loop, một helper parse JSON, một bộ post webhook Slack) — đừng viết lại từ đầu mỗi lần.
• Học thật kỹ một terminal editor (vim là lựa chọn mặc định an toàn nhất nhờ tính khả dụng gần như phổ quát) để một phiên incident response không bao giờ biến thành một buổi học editor.

Tài liệu tham khảo

• roadmap.sh — DevSecOps Roadmap
• Google — Shell Style Guide
• Bash Manual — GNU
• Python requests documentation
• The Go Programming Language Specification
• Effective Go
• Microsoft — PowerShell Documentation
• gitleaks — secret scanning tool (Go)

# Looping over a list of hosts read from a file
while read -r host; do
  echo "Scanning $host..."
  nmap -Pn -p 22,80,443 "$host" -oG - | grep -q "22/open" && echo "$host: SSH exposed"
done < hosts.txt

# Command substitution + conditionals
if ! systemctl is-active --quiet fail2ban; then
  echo "WARNING: fail2ban is not running" >&2
fi

# Safer script defaults
set -euo pipefail

#!/usr/bin/env bash
set -euo pipefail

LOG_FILE="${1:-/var/log/auth.log}"
THRESHOLD=10

echo "Checking $LOG_FILE for SSH brute-force attempts (threshold: $THRESHOLD)..."

grep "Failed password" "$LOG_FILE" \
  | grep -oE "from [0-9]{1,3}(\.[0-9]{1,3}){3}" \
  | awk '{print $2}' \
  | sort \
  | uniq -c \
  | sort -rn \
  | while read -r count ip; do
      if (( count >= THRESHOLD )); then
        echo "ALERT: $ip had $count failed login attempts"
      fi
    done

# /etc/cron.d/ssh-bruteforce-check — run every 15 minutes
*/15 * * * * root /usr/local/bin/check_ssh_bruteforce.sh /var/log/auth.log >> /var/log/bruteforce-alerts.log 2>&1

#!/usr/bin/env python3
"""secret_scan.py — flag likely hardcoded secrets in a source tree."""

import re
import sys
from pathlib import Path

PATTERNS = {
    "AWS Access Key": re.compile(r"AKIA[0-9A-Z]{16}"),
    "Generic API Key": re.compile(r"(?i)api[_-]?key\s*[:=]\s*['\"][A-Za-z0-9_\-]{16,}['\"]"),
    "Private Key Block": re.compile(r"-----BEGIN (RSA|EC|OPENSSH|DSA) PRIVATE KEY-----"),
    "Slack Token": re.compile(r"xox[baprs]-[0-9A-Za-z-]{10,}"),
}

SKIP_DIRS = {".git", "node_modules", "venv", "__pycache__"}


def scan_file(path: Path) -> list[tuple[str, str, int]]:
    findings = []
    try:
        text = path.read_text(errors="ignore")
    except (UnicodeDecodeError, PermissionError):
        return findings

    for line_no, line in enumerate(text.splitlines(), start=1):
        for name, pattern in PATTERNS.items():
            if pattern.search(line):
                findings.append((name, str(path), line_no))
    return findings


def main(root: str) -> int:
    root_path = Path(root)
    all_findings = []

    for path in root_path.rglob("*"):
        if any(part in SKIP_DIRS for part in path.parts):
            continue
        if path.is_file():
            all_findings.extend(scan_file(path))

    if all_findings:
        print(f"Found {len(all_findings)} potential secret(s):\n")
        for name, file_path, line_no in all_findings:
            print(f"  [{name}] {file_path}:{line_no}")
        return 1

    print("No secrets found.")
    return 0


if __name__ == "__main__":
    target = sys.argv[1] if len(sys.argv) > 1 else "."
    sys.exit(main(target))

import requests

def check_vulners(cve_id: str, api_key: str) -> dict:
    resp = requests.get(
        "https://vulners.com/api/v3/search/id/",
        params={"id": cve_id},
        headers={"X-Api-Key": api_key},
        timeout=10,
    )
    resp.raise_for_status()
    return resp.json()

package main

import (
	"fmt"
	"net"
	"sync"
	"time"
)

func checkPort(host string, port int, wg *sync.WaitGroup, results chan<- string) {
	defer wg.Done()
	address := fmt.Sprintf("%s:%d", host, port)
	conn, err := net.DialTimeout("tcp", address, 2*time.Second)
	if err == nil {
		conn.Close()
		results <- fmt.Sprintf("%s: OPEN", address)
	}
}

func main() {
	host := "127.0.0.1"
	ports := []int{22, 80, 443, 3306, 6379, 8080}

	var wg sync.WaitGroup
	results := make(chan string, len(ports))

	for _, port := range ports {
		wg.Add(1)
		go checkPort(host, port, &wg, results)
	}

	wg.Wait()
	close(results)

	for r := range results {
		fmt.Println(r)
	}
}

Import-Module ActiveDirectory

Get-ADUser -Filter { PasswordNeverExpires -eq $true -and Enabled -eq $true } `
    -Properties PasswordNeverExpires, LastLogonDate |
    Select-Object Name, SamAccountName, LastLogonDate |
    Sort-Object LastLogonDate |
    Format-Table -AutoSize

$checks = @(
    @{ Name = "Windows Firewall (Domain)"; Test = { (Get-NetFirewallProfile -Profile Domain).Enabled } }
    @{ Name = "SMBv1 Disabled";            Test = { -not (Get-WindowsOptionalFeature -Online -FeatureName SMB1Protocol).State -eq "Enabled" } }
    @{ Name = "RDP NLA Enabled";           Test = { (Get-Item "HKLM:\System\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp").GetValue("UserAuthentication") -eq 1 } }
)

foreach ($check in $checks) {
    $result = & $check.Test
    $status = if ($result) { "PASS" } else { "FAIL" }
    Write-Host "[$status] $($check.Name)"
}

python3 secret_scan.py . || { echo "Secrets found — failing build"; exit 1; }

import json, subprocess

result = subprocess.run(
    ["trivy", "image", "--format", "json", "myapp:latest"],
    capture_output=True, text=True, check=True,
)
report = json.loads(result.stdout)
critical = [
    v for r in report.get("Results", [])
    for v in r.get("Vulnerabilities", []) or []
    if v["Severity"] == "CRITICAL"
]
print(f"{len(critical)} CRITICAL vulnerabilities found")