iOS 13+原生Sign In with Apple接入Go后端方案咨询

嘿，我完全懂你现在的卡点——原生Sign In with Apple和之前WebView那套流程确实不一样，后端没法直接收到Apple的回调，得靠Swift客户端把关键数据转递给后端才行。下面是适配你Go后端的完整流程，一步步来：

第一步：Swift客户端获取Apple登录凭证并传给后端 #

当用户在iOS13+上完成原生Apple登录后，ASAuthorizationController的回调会返回ASAuthorizationAppleIDCredential，这里面有两个核心数据必须传给后端：identityToken（JWT格式，包含用户身份信息）和authorizationCode（用来向Apple验证登录合法性的授权码）。如果是用户首次登录，还会拿到email和fullName，这些也要一并传给后端。

给你一段Swift代码示例，处理登录成功后的逻辑：

func authorizationController(controller: ASAuthorizationController, didCompleteWithAuthorization authorization: ASAuthorization) {
    guard let appleIDCredential = authorization.credential as? ASAuthorizationAppleIDCredential else {
        print("获取Apple登录凭证失败")
        return
    }
    
    // 解析身份令牌和授权码为字符串
    guard let identityToken = appleIDCredential.identityToken,
          let tokenString = String(data: identityToken, encoding: .utf8) else {
        print("解析identityToken失败")
        return
    }
    guard let authorizationCode = appleIDCredential.authorizationCode,
          let codeString = String(data: authorizationCode, encoding: .utf8) else {
        print("解析authorizationCode失败")
        return
    }
    
    // 准备传给后端的参数
    var loginParams: [String: Any] = [
        "identity_token": tokenString,
        "authorization_code": codeString,
        "apple_user_id": appleIDCredential.user // Apple给用户的唯一标识，后续登录都会返回这个
    ]
    
    // 首次登录时才会有email和fullName，追加到参数里
    if let email = appleIDCredential.email {
        loginParams["email"] = email
    }
    if let fullName = appleIDCredential.fullName {
        let fullNameStr = "\(fullName.givenName ?? "") \(fullName.familyName ?? "")"
        loginParams["full_name"] = fullNameStr
    }
    
    // 调用后端的Apple登录接口（用你常用的网络库，比如Alamofire或者URLSession）
    let url = URL(string: "https://your-backend-domain.com/api/apple-login")!
    var request = URLRequest(url: url)
    request.httpMethod = "POST"
    request.setValue("application/json", forHTTPHeaderField: "Content-Type")
    request.httpBody = try? JSONSerialization.data(withJSONObject: loginParams)
    
    URLSession.shared.dataTask(with: request) { data, response, error in
        if let error = error {
            print("请求后端失败：\(error)")
            return
        }
        // 处理后端返回的会话令牌，保存到本地（比如Keychain），后续请求后端接口时带上
        if let data = data {
            let result = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
            let backendToken = result?["token"] as? String
            // 保存token逻辑...
        }
    }.resume()
}

第二步：Go后端验证Apple凭证并同步用户状态 #

后端需要接收客户端传来的参数，然后向Apple的官方验证接口发起请求，确认凭证的合法性，之后就可以复用你之前WebView流程的用户管理逻辑了。

核心步骤： #

1. 接收客户端的POST请求，解析参数；
2. 向https://appleid.apple.com/auth/token发送验证请求，带上你的App Bundle ID、提前生成的client_secret、客户端传的authorization_code；
3. 验证通过后，解析Apple返回的id_token（JWT），拿到用户的唯一标识sub，和客户端传的apple_user_id对比确保一致；
4. 创建/更新用户记录，生成后端自己的会话令牌（比如JWT）返回给客户端。

给你一段Go代码示例：

package main

import (
    "encoding/json"
    "net/http"
    "net/url"
    "github.com/golang-jwt/jwt/v5"
)

// 定义接收客户端参数的结构体
type AppleLoginReq struct {
    IdentityToken     string `json:"identity_token"`
    AuthorizationCode string `json:"authorization_code"`
    AppleUserID       string `json:"apple_user_id"`
    Email             string `json:"email,omitempty"`
    FullName          string `json:"full_name,omitempty"`
}

// Apple登录接口处理函数
func AppleLoginHandler(w http.ResponseWriter, r *http.Request) {
    var req AppleLoginReq
    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        http.Error(w, "请求参数格式错误", http.StatusBadRequest)
        return
    }

    // 1. 向Apple验证授权码和身份令牌
    appleTokenURL := "https://appleid.apple.com/auth/token"
    formData := url.Values{
        "client_id":     {"com.yourcompany.yourapp"}, // 替换成你的App Bundle ID
        "client_secret": {"your-generated-client-secret"}, // 替换成你生成的Client Secret
        "code":          {req.AuthorizationCode},
        "grant_type":    {"authorization_code"},
        "redirect_uri":  {"https://your-backend-domain.com/apple-callback"}, // 复用之前WebView的重定向URI即可
    }

    resp, err := http.PostForm(appleTokenURL, formData)
    if err != nil {
        http.Error(w, "连接Apple验证服务器失败", http.StatusInternalServerError)
        return
    }
    defer resp.Body.Close()

    // 解析Apple的验证响应
    var appleResp struct {
        AccessToken  string `json:"access_token"`
        RefreshToken string `json:"refresh_token"`
        IDToken      string `json:"id_token"`
        ExpiresIn    int    `json:"expires_in"`
    }
    if err := json.NewDecoder(resp.Body).Decode(&appleResp); err != nil {
        http.Error(w, "解析Apple响应失败", http.StatusInternalServerError)
        return
    }

    // 2. 验证并解析ID Token（JWT），确保签名合法且用户ID一致
    // 这里需要先获取Apple的公钥来验证JWT签名，建议缓存公钥避免重复请求
    applePublicKey, err := getApplePublicKey(appleResp.IDToken) // 你需要实现这个函数，从https://appleid.apple.com/auth/keys获取公钥
    if err != nil {
        http.Error(w, "获取Apple公钥失败", http.StatusInternalServerError)
        return
    }

    token, err := jwt.Parse(appleResp.IDToken, func(token *jwt.Token) (interface{}, error) {
        return applePublicKey, nil
    })
    if err != nil || !token.Valid {
        http.Error(w, "身份令牌无效", http.StatusUnauthorized)
        return
    }

    claims, ok := token.Claims.(jwt.MapClaims)
    if !ok {
        http.Error(w, "解析令牌信息失败", http.StatusInternalServerError)
        return
    }
    sub := claims["sub"].(string)
    if sub != req.AppleUserID {
        http.Error(w, "用户身份不匹配", http.StatusUnauthorized)
        return
    }

    // 3. 复用你之前的用户管理逻辑：创建/更新用户
    user, err := GetUserByAppleID(sub) // 你的查询用户函数
    if err != nil || user == nil {
        // 首次登录，创建新用户
        user = &User{
            AppleID:  sub,
            Email:    req.Email,
            FullName: req.FullName,
        }
        if err := SaveUser(user); err != nil {
            http.Error(w, "创建用户失败", http.StatusInternalServerError)
            return
        }
    } else {
        // 非首次登录，更新用户信息（如果有需要）
        if req.Email != "" {
            user.Email = req.Email
        }
        if req.FullName != "" {
            user.FullName = req.FullName
        }
        if err := UpdateUser(user); err != nil {
            http.Error(w, "更新用户失败", http.StatusInternalServerError)
            return
        }
    }

    // 4. 生成后端自己的会话令牌，返回给客户端
    backendToken, err := GenerateBackendSessionToken(user.ID) // 你的生成令牌函数
    if err != nil {
        http.Error(w, "生成会话令牌失败", http.StatusInternalServerError)
        return
    }

    // 返回响应
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(map[string]interface{}{
        "token": backendToken,
        "user":  user,
    })
}

// 辅助函数：获取Apple的公钥（示例逻辑，你需要完善）
func getApplePublicKey(idToken string) (interface{}, error) {
    // 逻辑：从https://appleid.apple.com/auth/keys获取公钥列表，根据ID Token的kid找到对应的公钥
    // 建议缓存公钥，避免每次请求
    return nil, nil
}

第三步：关键注意事项 #

• Client Secret生成：这是Apple用来验证你的后端身份的凭证，需要用开发者账号的私钥生成ES256算法的JWT，过期时间不能超过6个月。可以用Go的jwt/v5库来生成。
• 公钥缓存：Apple的公钥会定期更新，后端要缓存这些公钥，每次验证JWT时根据令牌的kid字段匹配对应的公钥，提升性能。
• 后续登录处理：用户非首次登录时，Apple不会返回email和fullName，所以后端必须在首次登录时保存这些信息，后续只需要验证identity_token和apple_user_id即可。
• 刷新令牌：如果需要长期保持登录状态，客户端可以保存Apple返回的refresh_token，当后端会话令牌过期时，把refresh_token传给后端，后端再向Apple请求新的access_token和refresh_token，更新用户状态。

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