go-vuln-dos

Audit Go source files for DoS and resource exhaustion vulnerabilities.

74|10|Updated Mar 5, 2026
One-click install
npx skills add https://github.com/yhy0/ghsa-skill-builder --skill go-vuln-dos
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: go-vuln-dos
Source: https://github.com/yhy0/ghsa-skill-builder/tree/main/vuln-skills/skills/go-vuln-dos
Command: npx skills add https://github.com/yhy0/ghsa-skill-builder --skill go-vuln-dos

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill helps identify and prevent Denial of Service (DoS) and resource exhaustion vulnerabilities in Go applications, ensuring stability and availability.

Core Features & Use Cases

  • Resource Leak Detection: Identifies potential goroutine leaks, unbounded memory allocations, and channel deadlocks.
  • Input Validation: Checks for unvalidated external inputs that could lead to excessive resource consumption (e.g., large HTTP bodies, deeply nested data structures).
  • Use Case: When auditing a Go web service, use this Skill to find endpoints that might crash the server if an attacker sends excessively large request bodies or creates too many concurrent goroutines.

Quick Start

Use the go-vuln-dos skill to audit the provided Go code for potential denial of service vulnerabilities.

Frequently Asked Questions about go-vuln-dos

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I detect goroutine leaks and resource exhaustion vulnerabilities in Go code?

Static analysis of Go source files identifies insecure practices like unbounded reads and unhandled panics to detect resource exhaustion vulnerabilities. It traces external inputs to sinks to find patterns causing excessive resource consumption.

What causes denial of service vulnerabilities in Go web services from unvalidated inputs?

Unvalidated external inputs allow attackers to send excessively large HTTP request bodies or deeply nested data structures, causing unbounded memory allocations that crash the Go web service and create denial of service conditions.

How do I audit Go source files for unbounded reads and resource exhaustion sinks?

To audit Go source files, perform static analysis to trace data from sources to sinks and check for sanitization gaps. This identifies unbounded reads, unhandled panics, and resource exhaustion patterns matching CWE-400 and CWE-770.

Can I use static analysis to find channel deadlocks and unhandled panics in Go applications?

Yes, static analysis can find channel deadlocks and unhandled panics in Go applications. It identifies insecure resource management practices that lead to goroutine leaks and application crashes, ensuring service stability and availability.

What are the limitations of static analysis for preventing DoS attacks in Go?

Static analysis for preventing DoS attacks in Go is limited to detecting known insecure patterns like unbounded reads, resource leaks, and sanitization gaps within the source code. It requires direct access to Go source files and may miss novel runtime vectors.