如何在oapi-codegen中间件中检查接口所需权限范围？

作为oapi-codegen新手，我在OpenAPI规范中为/itworks接口定义了两种安全规则（JWT和API Key），配置如下：

/itworks:
    get:
      summary: Just a test endpoint
      description: |
        A test endpoint which will return some info
      operationId: itworks_get
      security:
        - bearerAuth: ["statistics"]  # JWT
        - apiKey: ["statistics"]    # API-Key
      responses:
        "200":
          $ref: "#/components/responses/200_OK_message"
        "401":
          $ref: "#/components/responses/401_Unauthorized"

生成的接口包装代码如下：

// ItworksGet operation middleware
func (siw *ServerInterfaceWrapper) ItworksGet(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()

    ctx = context.WithValue(ctx, BearerAuthScopes, []string{"statistics"})

    ctx = context.WithValue(ctx, ApiKeyScopes, []string{"statistics"})

    handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        siw.Handler.ItworksGet(w, r)
    }))

    for _, middleware := range siw.HandlerMiddlewares {
        handler = middleware(handler)
    }

    handler.ServeHTTP(w, r.WithContext(ctx))
}

我编写的自定义API Key认证中间件（截取核心部分）如下：

func AuthMiddleware(apiKey string) func(next http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            authHeader := r.Header.Get("Authorization")
            apiKeyHeader := r.Header.Get("ApiKey")

            if apiKeyHeader == apiKey {
                fmt.Printf("API Key found %s\n", generated.ApiKeyScopes)
                requiredScopes := r.Context().Value(generated.CSApiKeyScopes)
                if requiredScopes != nil {
                    fmt.Printf("API Key Scopes: %v\n", requiredScopes)
                }
                next.ServeHTTP(w, r)
                return
            }
            // 省略其他逻辑
        })
    }
}

我预期能从请求上下文中获取接口要求的权限范围，但实际并未成功。想了解这套机制的工作原理，以及如何在中间件中检测接口所需权限范围，另外是否必须在每个处理器中自行检查权限？

1. 上下文权限范围获取失败的原因 #

核心问题有两个：

• 上下文Key引用错误：生成的代码中使用的上下文Key是ApiKeyScopes，但你的中间件里误用了generated.CSApiKeyScopes，导致无法从上下文取出值。
• 中间件注册验证：需要确认你的AuthMiddleware已正确添加到siw.HandlerMiddlewares列表中，否则生成的代码不会将中间件应用到接口请求链中。

2. oapi-codegen安全范围传递机制的工作原理 #

oapi-codegen针对接口的security规则生成的包装函数逻辑如下：

1. 从原始请求中获取上下文，将当前接口要求的安全范围（比如statistics）存入上下文，使用预定义的Key（如ApiKeyScopes、BearerAuthScopes）。
2. 将实际接口处理函数包装成基础Handler。
3. 依次将所有注册的中间件应用到Handler上，形成中间件链。
4. 最终调用中间件链的ServeHTTP方法，传入携带了权限范围的请求上下文。

这意味着中间件在执行时，完全可以从请求上下文中获取到当前接口所需的权限范围，无需在处理器中重复处理。

3. 修正后的中间件实现 #

以下是能正确获取并校验权限范围的中间件示例：

func AuthMiddleware(apiKey string) func(next http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            apiKeyHeader := r.Header.Get("ApiKey")
            
            if apiKeyHeader == apiKey {
                // 从上下文获取当前接口要求的API Key权限范围
                requiredScopes, ok := r.Context().Value(generated.ApiKeyScopes).([]string)
                if ok && len(requiredScopes) > 0 {
                    fmt.Printf("API Key Required Scopes: %v\n", requiredScopes)
                    
                    // 替换为实际权限校验逻辑：比如查询当前API Key对应的权限列表
                    // 示例：假设当前API Key拥有"statistics"权限
                    userScopes := []string{"statistics"}
                    hasPermission := false
                    for _, reqScope := range requiredScopes {
                        for _, userScope := range userScopes {
                            if reqScope == userScope {
                                hasPermission = true
                                break
                            }
                        }
                        if hasPermission {
                            break
                        }
                    }
                    
                    if !hasPermission {
                        http.Error(w, "Insufficient permissions", http.StatusForbidden)
                        return
                    }
                }
                // 权限校验通过，放行请求
                next.ServeHTTP(w, r)
                return
            }
            
            // API Key验证失败，返回未授权
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
        })
    }
}

4. 是否需要在每个处理器中检查权限？ #

不需要。只要确保：

• 中间件已正确注册到接口的中间件链中。
• 中间件能从上下文正确获取接口所需的权限范围，并完成校验。

处理器就无需重复进行权限检查，专注于业务逻辑即可。

内容的提问来源于stack exchange，提问作者Skeeve