基于标准 OAuth 2.0 授权码模式,几行代码即可让你的网站支持布丁账号登录。 支持 PHP、Node.js、Go、Python 等多种服务端语言。
用户在你的网站点击"布丁登录",跳转到 PuddingChat 授权页完成登录, 然后回调到你的网站,换取 access_token 获取用户信息。
接入布丁互联平台,让你的移动应用支持布丁账号一键登录。 一次接入,覆盖 iOS 和 Android 双平台。
用户在你的 APP 点击"布丁登录",直接拉起 PuddingChat APP 完成授权确认, 无需跳转到浏览器,登录体验更流畅,安全性更高。
先在开发者中心创建应用获取凭证,再按标准 OAuth 2.0 流程完成授权。
无需人工介入 —— 提交审核通过后即可获取 client_id。
用布丁账号登录开发者中心,填一个能收信的邮箱并完成验证。邮箱是唯一联系方式 —— 审核结果、密钥找回、违规通知都发这里。
选择"网页应用"类型,提交应用名称、简介、主页地址与回调地址白名单。审核通过后即可获取 client_id 与 client_secret。
将用户浏览器重定向至 /v1/oauth2/authorize。用户在授权页确认后,浏览器携带 code 回调至应用地址。
拿 code 在服务端换 access_token,再用它调 /userinfo 拿昵称和头像。至此登录完成。
用布丁账号登录开发者中心,填一个能收信的邮箱并完成验证。邮箱是唯一联系方式 —— 审核结果、密钥找回、违规通知都发这里。
选择"移动应用"类型,提交应用名称、简介、主页地址与回调地址白名单。审核通过后即可获取 client_id。
在你的 APP 内调用 /v1/oauth2/authorize/app,直接拉起 PuddingChat APP 完成授权确认,无需跳转到浏览器。
授权成功后,使用 PKCE 流程换取 access_token,再调 /userinfo 拿昵称和头像。至此登录完成。
client_secret 是应用的身份证,一旦放进网页前端、App 安装包或公开的代码仓库,
任何人都能拿它冒充你的应用。浏览器应只拿到一次性的 code,code 使用后即失效。
生产环境基址 https://sdk.idcbdy.com。全部接口走 HTTPS,
生产环境不支持 http:// 授权回调(浏览器会拦,我们也会拒)。
| 方法 | 路径 | 说明 | 适用类型 | 调用方 |
|---|---|---|---|---|
| GET | /v1/oauth2/authorize | 把用户送到授权页。参数:client_id、redirect_uri、response_type=code、state、scope,可选 code_challenge + code_challenge_method=S256 |
通用 | 浏览器跳转 |
| GET | /v1/oauth2/authorize/info | 只取应用信息与权限文案,供你自绘授权页。不产生授权码 | 通用 | 浏览器 / 服务端 |
| POST | /v1/oauth2/authorize/decision | 提交用户的授权决定。仅使用自绘授权页时需要 | 网页 | 浏览器 |
| POST | /v1/oauth2/authorize/app | 移动应用 App-to-App 授权确认。直接拉起 PuddingChat APP 完成授权,无需跳浏览器 | 移动 | APP 端调用 |
| POST | /v1/oauth2/token | 用 code 换令牌,或用 refresh_token 续期。需 client_secret服务端 |
通用 | 服务器 → 服务器 |
| GET | /v1/oauth2/userinfo | 取用户资料。需带 access_token服务端 |
通用 | 服务器 → 服务器 |
| POST | /v1/oauth2/revoke | 撤销访问令牌。用户执行「解除绑定」时调用 | 通用 | 服务器 → 服务器 |
| GET | /v1/oauth2/health | 健康检查。无需鉴权,可用于探活 | 通用 | 任意 |
code。不支持 token 简化模式userinfocode_verifier/userinfo 时放在 Authorization: BearerBeareruid,但该标识不跨应用共享 ——
其他应用获取的 uid 与本应用无关联关系。建议以 uid 建立本地账号,
昵称和头像仅作为展示字段,每次登录时重新获取。
布丁互联遵循标准 OAuth 2.0 规范,官方 SDK 为可选组件 —— 开发者可使用任一符合 OAuth 2.0 规范的客户端库,或直接调用 HTTP 接口。 以下是最小可运行版本,替换三个常量即可运行。
# ── 第 1 步:把用户浏览器送到这里(在浏览器地址栏打开)────────────
# 用户点「同意授权」后,会 302 回你的 redirect_uri 并带上 code
https://sdk.idcbdy.com/v1/oauth2/authorize?\
client_id=你的client_id&\
redirect_uri=https%3A%2F%2Fexample.com%2Fcallback&\
response_type=code&\
scope=userinfo&\
state=<your_state>
# ── 第 2 步:拿 code 换令牌(★ 必须在服务端执行)───────────────
curl -s -X POST https://sdk.idcbdy.com/v1/oauth2/token \
-H 'Content-Type: application/x-www-form-urlencoded' \
-d 'grant_type=authorization_code' \
-d 'client_id=你的client_id' \
-d 'client_secret=你的client_secret' \
-d 'code=授权码(授权页回调携带的 code)' \
-d 'redirect_uri=https://example.com/callback'
# ── 第 3 步:取用户资料 ───────────────────────────────────
curl -s https://sdk.idcbdy.com/v1/oauth2/userinfo \
-H 'Authorization: Bearer 访问令牌(上一步获取的 access_token)'
// 布丁互联接入 —— Node.js(Express 版,无第三方依赖)
import express from 'express'
import crypto from 'node:crypto'
const app = express()
// ★ 这三个从环境变量读,绝不写进代码、绝不进版本库
const CLIENT_ID = process.env.PUDDING_CLIENT_ID
const CLIENT_SECRET = process.env.PUDDING_CLIENT_SECRET
const REDIRECT_URI = 'https://example.com/callback'
const BASE = 'https://sdk.idcbdy.com/v1/oauth2'
// ① 跳到布丁授权页
app.get('/login', (req, res) => {
// state 必须为随机字符串,用于防 CSRF 攻击,禁止使用固定值
const state = crypto.randomBytes(16).toString('hex')
req.session.state = state
const q = new URLSearchParams({
client_id: CLIENT_ID,
redirect_uri: REDIRECT_URI,
response_type: 'code',
scope: 'userinfo',
state,
})
res.redirect(`${BASE}/authorize?${q}`)
})
// ② 处理回调:换令牌 + 取资料
app.get('/callback', async (req, res) => {
const { code, state } = req.query
// state 校验失败应直接拒绝请求;缺失此校验将导致授权码被冒用
if (!state || state !== req.session.state) return res.status(400).send('state 校验失败')
const tr = await fetch(`${BASE}/token`, {
method: 'POST',
headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
body: new URLSearchParams({
grant_type: 'authorization_code',
client_id: CLIENT_ID,
client_secret: CLIENT_SECRET,
code,
redirect_uri: REDIRECT_URI,
}),
})
const tk = await tr.json()
if (!tr.ok) return res.status(502).send('换令牌失败: ' + JSON.stringify(tk))
const ur = await fetch(`${BASE}/userinfo`, {
headers: { Authorization: `Bearer ${tk.access_token}` },
})
const me = await ur.json()
// ★ 用 uid 认人,别用 nickname —— 昵称随时能改
const user = await findOrCreateUser({ uid: me.uid, name: me.nickname, avatar: me.avatar })
req.session.uid = user.id
res.redirect('/')
})
// 布丁互联接入 —— Go(标准库,无第三方依赖)
package main
import (
"context"
"encoding/json"
"fmt"
"net/http"
"net/url"
"os"
"strings"
)
const puddingBase = "https://sdk.idcbdy.com/v1/oauth2"
var (
clientID = os.Getenv("PUDDING_CLIENT_ID")
clientSecret = os.Getenv("PUDDING_CLIENT_SECRET")
redirectURI = "https://example.com/callback"
)
// AuthURL 生成给用户点的那条链接。state 由调用方随机生成并先存进会话。
func AuthURL(state string) string {
q := url.Values{}
q.Set("client_id", clientID)
q.Set("redirect_uri", redirectURI)
q.Set("response_type", "code")
q.Set("scope", "userinfo")
q.Set("state", state)
return puddingBase + "/authorize?" + q.Encode()
}
type Token struct {
AccessToken string `json:"access_token"`
RefreshToken string `json:"refresh_token"`
ExpiresIn int `json:"expires_in"`
}
// Exchange 用 code 换令牌。★ 必须在服务端调 —— client_secret 不能下发到浏览器。
func Exchange(ctx context.Context, code string) (*Token, error) {
form := url.Values{}
form.Set("grant_type", "authorization_code")
form.Set("client_id", clientID)
form.Set("client_secret", clientSecret)
form.Set("code", code)
form.Set("redirect_uri", redirectURI)
req, err := http.NewRequestWithContext(ctx, http.MethodPost,
puddingBase+"/token", strings.NewReader(form.Encode()))
if err != nil {
return nil, err
}
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
resp, err := http.DefaultClient.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
// HTTP 400 响应体包含错误详情,请务必解析后再处理
var out Token
if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
return nil, fmt.Errorf("解析令牌响应失败: %w", err)
}
return &out, nil
}
type Profile struct {
UID string `json:"uid"`
Nickname string `json:"nickname"`
Avatar string `json:"avatar"`
ShortNo string `json:"short_no"`
}
// UserInfo 取用户资料。用 UID 建本地账号,别用昵称。
func UserInfo(ctx context.Context, accessToken string) (*Profile, error) {
req, err := http.NewRequestWithContext(ctx, http.MethodGet,
puddingBase+"/userinfo", nil)
if err != nil {
return nil, err
}
req.Header.Set("Authorization", "Bearer "+accessToken)
resp, err := http.DefaultClient.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
var p Profile
if err := json.NewDecoder(resp.Body).Decode(&p); err != nil {
return nil, err
}
return &p, nil
}
// 布丁互联接入 —— PHP(无 Composer 依赖)
<?php
const BASE = 'https://sdk.idcbdy.com/v1/oauth2';
$clientId = getenv('PUDDING_CLIENT_ID');
$clientSecret = getenv('PUDDING_CLIENT_SECRET');
$redirectUri = 'https://example.com/callback';
// ① 生成授权链接。state 存进 session,回来要逐字比对。
function authUrl($clientId, $redirectUri) {
$state = bin2hex(random_bytes(16));
$_SESSION['oauth_state'] = $state;
return BASE . '/authorize?' . http_build_query([
'client_id' => $clientId,
'redirect_uri' => $redirectUri,
'response_type' => 'code',
'scope' => 'userinfo',
'state' => $state,
]);
}
// ② 用 code 换令牌
function exchange($clientId, $clientSecret, $code, $redirectUri) {
$ch = curl_init(BASE . '/token');
curl_setopt_array($ch, [
CURLOPT_POST => true,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_TIMEOUT => 10,
CURLOPT_POSTFIELDS => http_build_query([
'grant_type' => 'authorization_code',
'client_id' => $clientId,
'client_secret' => $clientSecret,
'code' => $code,
'redirect_uri' => $redirectUri,
]),
]);
$body = curl_exec($ch);
curl_close($ch);
return json_decode($body, true);
}
// ③ 取用户资料
function userinfo($accessToken) {
$ch = curl_init(BASE . '/userinfo');
curl_setopt_array($ch, [
CURLOPT_RETURNTRANSFER => true,
CURLOPT_TIMEOUT => 10,
CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $accessToken],
]);
$body = curl_exec($ch);
curl_close($ch);
return json_decode($body, true);
}
// ④ 回调处理
if (isset($_GET['code'])) {
// ★ state 必须校验:不校验的话,攻击者能拿别人的 code 登进我们的账号
if (!hash_equals($_SESSION['oauth_state'] ?? '', $_GET['state'] ?? '')) {
http_response_code(400); exit('state 校验失败');
}
$tk = exchange($clientId, $clientSecret, $_GET['code'], $redirectUri);
$me = userinfo($tk['access_token']);
// ★ 用 uid 认人
$_SESSION['uid'] = $me['uid'];
}
# 布丁互联接入 —— Python(Flask + requests)
import os, secrets, requests
from flask import Flask, request, session, redirect
app = Flask(__name__)
BASE = "https://sdk.idcbdy.com/v1/oauth2"
CLIENT_ID = os.environ["PUDDING_CLIENT_ID"]
CLIENT_SECRET = os.environ["PUDDING_CLIENT_SECRET"]
REDIRECT_URI = "https://example.com/callback"
# ① 跳去授权页
@app.get("/login")
def login():
# state 每次都要重新随机:写死或复用等于没有防护
session["state"] = secrets.token_urlsafe(16)
q = {
"client_id": CLIENT_ID,
"redirect_uri": REDIRECT_URI,
"response_type": "code",
"scope": "userinfo",
"state": session["state"],
}
return redirect(BASE + "/authorize?" + urlencode(q))
# ② 回调:换令牌 + 取资料
@app.get("/callback")
def callback():
# ★ 不校验 state,攻击者就能把别人的 code 塞给我们的回调
if not secrets.compare_digest(session.pop("state", ""), request.args.get("state", "")):
return "state 校验失败", 400
# ★ 换令牌只在服务端做,且必须带同一个 redirect_uri
r = requests.post(BASE + "/token", data={
"grant_type": "authorization_code",
"client_id": CLIENT_ID,
"client_secret": CLIENT_SECRET,
"code": request.args["code"],
"redirect_uri": REDIRECT_URI,
}, timeout=10)
tk = r.json()
me = requests.get(BASE + "/userinfo", headers={
"Authorization": f"Bearer {tk['access_token']}",
}, timeout=10).json()
# ★ 用 uid 认人,nickname 随时会变
user = find_or_create(uid=me["uid"], name=me["nickname"], avatar=me["avatar"])
session["uid"] = user.id
return redirect("/")
// 布丁互联接入 —— Java 11+(java.net.http,无第三方依赖)
import java.net.URI;
import java.net.URLEncoder;
import java.net.http.*;
import java.nio.charset.StandardCharsets;
import java.net.URLDecoder;
import java.security.SecureRandom;
import java.util.HexFormat;
public final class PuddingConnect {
private static final String BASE = "https://sdk.idcbdy.com/v1/oauth2";
private static final HttpClient HTTP = HttpClient.newHttpClient();
private final String clientId = System.getenv("PUDDING_CLIENT_ID");
private final String clientSecret = System.getenv("PUDDING_CLIENT_SECRET");
private final String redirectUri = "https://example.com/callback";
// ① 生成授权链接。state 随机生成后必须先存进会话,回调时逐字比对。
public String authUrl(String state) {
return BASE + "/authorize?"
+ "client_id=" + enc(clientId)
+ "&redirect_uri=" + enc(redirectUri)
+ "&response_type=code"
+ "&scope=userinfo"
+ "&state=" + enc(state);
}
// ② 用 code 换令牌。★ 必须在服务端调 —— client_secret 不能下发到浏览器。
public String exchange(String code) throws Exception {
String form = "grant_type=authorization_code"
+ "&client_id=" + enc(clientId)
+ "&client_secret=" + enc(clientSecret)
+ "&code=" + enc(code)
+ "&redirect_uri=" + enc(redirectUri);
HttpRequest req = HttpRequest.newBuilder(URI.create(BASE + "/token"))
.header("Content-Type", "application/x-www-form-urlencoded")
.timeout(java.time.Duration.ofSeconds(10))
.POST(HttpRequest.BodyPublishers.ofString(form))
.build();
return HTTP.send(req, HttpResponse.BodyHandlers.ofString()).body();
}
// ③ 取用户资料
public String userinfo(String accessToken) throws Exception {
HttpRequest req = HttpRequest.newBuilder(URI.create(BASE + "/userinfo"))
.header("Authorization", "Bearer " + accessToken)
.timeout(java.time.Duration.ofSeconds(10))
.GET()
.build();
return HTTP.send(req, HttpResponse.BodyHandlers.ofString()).body();
}
private static String enc(String s) {
return URLEncoder.encode(s, StandardCharsets.UTF_8);
}
}
// 布丁互联 App-to-App 授权 —— Android (Kotlin)
// 无需 SDK,纯 Intent + HttpURLConnection 即可完成
import android.content.Intent
import android.net.Uri
import android.os.Bundle
import android.util.Base64
import androidx.appcompat.app.AppCompatActivity
import java.net.HttpURLConnection
import java.net.URL
import java.security.MessageDigest
import java.security.SecureRandom
class PuddingLoginActivity : AppCompatActivity() {
private val clientId = "你的client_id"
private val redirectScheme = "yourapp" // 你的 APP 的 URL Scheme
private val redirectHost = "oauth2redirect"
private val baseUrl = "https://sdk.idcbdy.com/v1/oauth2"
private lateinit var codeVerifier: String
private lateinit var state: String
// ① 点击「布丁登录」按钮时调用
fun loginWithPudding() {
// 生成 PKCE code_verifier(43~128 字符随机串)
codeVerifier = generateCodeVerifier()
val codeChallenge = generateCodeChallenge(codeVerifier)
// 生成 state 防 CSRF
state = ByteArray(16).also { SecureRandom().nextBytes(it) }
.joinToString("") { "%02x".format(it) }
// 构造授权 URL
val redirectUri = "$redirectScheme://$redirectHost"
val authUri = Uri.parse("$baseUrl/authorize").buildUpon()
.appendQueryParameter("client_id", clientId)
.appendQueryParameter("redirect_uri", redirectUri)
.appendQueryParameter("response_type", "code")
.appendQueryParameter("scope", "userinfo")
.appendQueryParameter("state", state)
.appendQueryParameter("code_challenge", codeChallenge)
.appendQueryParameter("code_challenge_method", "S256")
.build()
// 先尝试拉起 PuddingChat APP(App-to-App)
val puddingUri = Uri.parse("puddingchat://oauth/authorize").buildUpon()
.appendQueryParameter("client_id", clientId)
.appendQueryParameter("redirect_uri", redirectUri)
.appendQueryParameter("state", state)
.appendQueryParameter("code_challenge", codeChallenge)
.appendQueryParameter("code_challenge_method", "S256")
.build()
val appIntent = Intent(Intent.ACTION_VIEW, puddingUri)
if (appIntent.resolveActivity(packageManager) != null) {
// PuddingChat 已安装,直接拉起 APP 授权
startActivity(appIntent)
} else {
// 未安装 PuddingChat,降级到网页授权
startActivity(Intent(Intent.ACTION_VIEW, authUri))
}
}
// ② 在 AndroidManifest.xml 注册回调 Activity,接收授权 code
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
val uri = intent?.data ?: return
if (uri.scheme == redirectScheme && uri.host == redirectHost) {
val code = uri.getQueryParameter("code") ?: return
val returnedState = uri.getQueryParameter("state") ?: return
// 校验 state
if (returnedState != state) {
// state 不匹配,可能是 CSRF 攻击,拒绝
finish()
return
}
// ③ 用 code 换 token(PKCE 模式无需 client_secret)
exchangeCodeForToken(code)
}
}
private fun exchangeCodeForToken(code: String) {
Thread {
val redirectUri = "$redirectScheme://$redirectHost"
val formBody = "grant_type=authorization_code" +
"&client_id=" + clientId +
"&code=" + code +
"&redirect_uri=" + Uri.encode(redirectUri, "UTF-8") +
"&code_verifier=" + codeVerifier
val conn = (URL("$baseUrl/token").openConnection() as HttpURLConnection).apply {
requestMethod = "POST"
setRequestProperty("Content-Type", "application/x-www-form-urlencoded")
doOutput = true
connectTimeout = 10000
outputStream.use { it.write(formBody.toByteArray()) }
}
val response = conn.inputStream.bufferedReader().readText()
// 解析 JSON,拿到 access_token,再调 /userinfo 获取用户资料
runOnUiThread {
// 登录成功,跳转到主界面
finish()
}
}.start()
}
private fun generateCodeVerifier(): String {
val buffer = ByteArray(32)
SecureRandom().nextBytes(buffer)
return Base64.encodeToString(buffer, Base64.URL_SAFE or Base64.NO_PADDING or Base64.NO_WRAP)
}
private fun generateCodeChallenge(verifier: String): String {
val digest = MessageDigest.getInstance("SHA-256")
val hash = digest.digest(verifier.toByteArray())
return Base64.encodeToString(hash, Base64.URL_SAFE or Base64.NO_PADDING or Base64.NO_WRAP)
}
}
// 布丁互联 App-to-App 授权 —— iOS (Swift)
// 在 Info.plist 注册 URL Scheme yourapp,以及 LSApplicationQueriesSchemes 添加 puddingchat
import UIKit
class PuddingLoginManager {
private let clientId = "你的client_id"
private let redirectScheme = "yourapp"
private let redirectHost = "oauth2redirect"
private let baseUrl = "https://sdk.idcbdy.com/v1/oauth2"
private var codeVerifier: String = ""
private var state: String = ""
private var completion: ((Result<[String: Any], Error>) -> Void)?
// ① 点击「布丁登录」按钮时调用
func login(completion: @escaping (Result<[String: Any], Error>) -> Void) {
self.completion = completion
// 生成 PKCE code_verifier
codeVerifier = randomString(length: 64)
let codeChallenge = sha256(codeVerifier)
// 生成 state
state = randomString(length: 32)
let redirectUri = "\(redirectScheme)://\(redirectHost)"
// 先尝试拉起 PuddingChat APP
var puddingComponents = URLComponents(string: "puddingchat://oauth/authorize")!
puddingComponents.queryItems = [
URLQueryItem(name: "client_id", value: clientId),
URLQueryItem(name: "redirect_uri", value: redirectUri),
URLQueryItem(name: "state", value: state),
URLQueryItem(name: "code_challenge", value: codeChallenge),
URLQueryItem(name: "code_challenge_method", value: "S256")
]
if let puddingURL = puddingComponents.url, UIApplication.shared.canOpenURL(puddingURL) {
// PuddingChat 已安装,直接拉起 APP
UIApplication.shared.open(puddingURL)
} else {
// 未安装,降级到网页授权
var webComponents = URLComponents(string: "\(baseUrl)/authorize")!
webComponents.queryItems = [
URLQueryItem(name: "client_id", value: clientId),
URLQueryItem(name: "redirect_uri", value: redirectUri),
URLQueryItem(name: "response_type", value: "code"),
URLQueryItem(name: "scope", value: "userinfo"),
URLQueryItem(name: "state", value: state),
URLQueryItem(name: "code_challenge", value: codeChallenge),
URLQueryItem(name: "code_challenge_method", value: "S256")
]
UIApplication.shared.open(webComponents.url!)
}
}
// ② 在 AppDelegate / SceneDelegate 中接收回调
func handleRedirect(_ url: URL) -> Bool {
guard url.scheme == redirectScheme, url.host == redirectHost else { return false }
guard let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
let items = components.queryItems else { return false }
let params = Dictionary(uniqueKeysWithValues: items.map { ($0.name, $0.value ?? "") })
guard let code = params["code"],
let returnedState = params["state"],
returnedState == state else {
// state 不匹配或缺少参数,拒绝
return false
}
// ③ 用 code 换 token
exchangeCodeForToken(code)
return true
}
private func exchangeCodeForToken(_ code: String) {
let redirectUri = "\(redirectScheme)://\(redirectHost)"
var request = URLRequest(url: URL(string: "\(baseUrl)/token")!)
request.httpMethod = "POST"
request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
let body = "grant_type=authorization_code&client_id=\(clientId)&code=\(code)&redirect_uri=\(redirectUri)&code_verifier=\(codeVerifier)"
request.httpBody = body.data(using: .utf8)
URLSession.shared.dataTask(with: request) { data, response, error in
guard let data = data, error == nil else {
self.completion?.(.failure(error!))
return
}
do {
let json = try JSONSerialization.jsonObject(with: data, options: []) as! [String: Any]
self.completion?.(.success(json))
} catch {
self.completion?.(.failure(error))
}
}.resume()
}
private func randomString(length: Int) -> String {
let chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~"
return String((0..<length).map { _ in chars.randomElement()! })
}
private func sha256(_ input: String) -> String {
let data = Data(input.utf8)
var hash = [UInt8](repeating: 0, count: Int(CC_SHA256_DIGEST_LENGTH))
data.withUnsafeBytes { _ in CC_SHA256($0.baseAddress, CC_LONG(data.count), &hash) }
return hash.map { String.format("%.2x", $0) }.joined()
}
}
如果你的应用为移动客户端或纯前端单页应用(SPA),客户端不具备保存密钥的安全环境 ——
反编译、看网络请求都能拿到。这种情况下请开 PKCE:
授权时多带一个 code_challenge,
换令牌时把原始 code_verifier 带上。
这样即使 code 在中途被截走,没有 verifier 也换不出令牌。
BASE64URL(SHA256(verifier)),授权时带S256。不支持 plain官方不强制 SDK —— 标准 OAuth 2.0 用现成库就好。 如需快速接入,可下载下方示例工程,包含上述六种语言的完整可运行实现。
仅申请必要的权限范围。权限范围越大,用户同意授权的概率越低,审核周期也越长。
未来新增的授权范围(scope)将通过开发者中心公告,且需用户重新授权确认 —— 不会出现「上次已同意,本次擅自追加一项权限」的情况。
error 与 error_description,别只看 HTTP 状态码;
② invalid_grant 九成是 code 用第二次了 —— code 是一次性的;
③ 还是不通就比对 redirect_uri:平台的是精确字符串匹配,
https://a.com/cb 与 https://a.com/cb/ 是两个不同的地址。
不要写进前端、App 包、代码仓库、日志。client_secret 服务端仅存储哈希值,泄露后无法还原,只能重置 —— 重置会导致所有在线令牌立即失效。
随机生成、存进会话、回调时逐字比对、用完即弃。不校验 state 是 OAuth 接入最常见的漏洞,攻击者能借此把别人的账号绑到自己的会话上。
平台仅对白名单执行精确匹配,不支持通配符、不支持前缀匹配。这样即便有人伪造一条带恶意回调的授权链接,用户点进去也拿不到任何东西。
昵称可被用户修改,作为主键存在重复与丢失风险。头像建议每次登录时刷新获取,不作为唯一身份凭据缓存。