布丁账号 授权登录,打通你的应用

布丁互联(Pudding Connect)是布丁生态圈的开放平台。基于标准 OAuth 2.0 授权码模式,几行代码即可完成接入。

OAuth 2.0授权码模式,业界通用
App-to-App拉起 PuddingChat 授权
PKCE移动端安全授权
双端Android + iOS 全覆盖
Web SDK

网页应用接入

基于标准 OAuth 2.0 授权码模式,几行代码即可让你的网站支持布丁账号登录。 支持 PHP、Node.js、Go、Python 等多种服务端语言。

标准 OAuth 2.0 授权码模式

用户在你的网站点击"布丁登录",跳转到 PuddingChat 授权页完成登录, 然后回调到你的网站,换取 access_token 获取用户信息。

  • ✓ 布丁账号一键登录
  • ✓ 获取用户头像、昵称、布丁号
  • ✓ 标准 OAuth 2.0,业界通用
  • ✓ 支持多种服务端语言
查看接入文档 →
· 网页授权流程 ·
🌐
你的网站
点击布丁登录
→
🔐
授权页
用户登录授权
→
✅
回调成功
获取用户信息
Mobile SDK

移动应用接入

接入布丁互联平台,让你的移动应用支持布丁账号一键登录。 一次接入,覆盖 iOS 和 Android 双平台。

App-to-App 授权登录

用户在你的 APP 点击"布丁登录",直接拉起 PuddingChat APP 完成授权确认, 无需跳转到浏览器,登录体验更流畅,安全性更高。

  • ✓ 布丁账号一键登录
  • ✓ 获取用户头像、昵称、布丁号
  • ✓ PKCE 安全授权,无需暴露 client_secret
  • ✓ 未安装 PuddingChat 时自动降级到网页授权
查看接入文档 →
· App-to-App 授权流程 ·
📱
第三方 APP
点击布丁登录
logo
PuddingChat
拉起授权确认
✓
授权完成
回调 code 换 token
① 第三方 APP 通过 URL Scheme 拉起 PuddingChat
② 用户在 PuddingChat 内确认授权范围
③ PuddingChat 回调第三方 APP,带回 authorization code
④ 第三方 APP 用 code 换取 access_token,获取用户信息
Getting started

四步接入

先在开发者中心创建应用获取凭证,再按标准 OAuth 2.0 流程完成授权。 无需人工介入 —— 提交审核通过后即可获取 client_id。

网页应用接入步骤

1

注册开发者

用布丁账号登录开发者中心,填一个能收信的邮箱并完成验证。邮箱是唯一联系方式 —— 审核结果、密钥找回、违规通知都发这里。

2

创建应用

选择"网页应用"类型,提交应用名称、简介、主页地址与回调地址白名单。审核通过后即可获取 client_id 与 client_secret。

3

发起授权

将用户浏览器重定向至 /v1/oauth2/authorize。用户在授权页确认后,浏览器携带 code 回调至应用地址。

4

换令牌取资料

拿 code 在服务端换 access_token,再用它调 /userinfo 拿昵称和头像。至此登录完成。

移动应用接入步骤(App-to-App 授权)

1

注册开发者

用布丁账号登录开发者中心,填一个能收信的邮箱并完成验证。邮箱是唯一联系方式 —— 审核结果、密钥找回、违规通知都发这里。

2

创建移动应用

选择"移动应用"类型,提交应用名称、简介、主页地址与回调地址白名单。审核通过后即可获取 client_id。

3

发起 App-to-App 授权

在你的 APP 内调用 /v1/oauth2/authorize/app,直接拉起 PuddingChat APP 完成授权确认,无需跳转到浏览器。

4

获取用户信息

授权成功后,使用 PKCE 流程换取 access_token,再调 /userinfo 拿昵称和头像。至此登录完成。

一次完整登录的时序
用户浏览器
① GET /authorize?client_id&redirect_uri&state
布丁互联
布丁互联
② 展示授权页(应用名 + 将获取的权限)
用户浏览器
用户浏览器
③ 用户点「同意授权」
布丁互联
布丁互联
④ 302 到 redirect_uri?code=…&state=…
你的服务端
你的服务端
⑤ POST /token(带 client_secret)
布丁互联
布丁互联
⑥ access_token + refresh_token
你的服务端
你的服务端
⑦ GET /userinfo(带 access_token)
布丁互联
布丁互联
⑧ {uid, nickname, avatar, short_no}
你的服务端
🔑
第 ⑤ 步必须在服务端做。 client_secret 是应用的身份证,一旦放进网页前端、App 安装包或公开的代码仓库, 任何人都能拿它冒充你的应用。浏览器应只拿到一次性的 code,code 使用后即失效。
API reference

接口文档

生产环境基址 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 健康检查。无需鉴权,可用于探活 通用 任意

请求参数

client_id应用 ID。在开发者中心创建应用后生成,可公开
client_secret应用密钥。只存哈希,丢了只能重置
redirect_uri回调地址。必须与白名单完全一致,不做前缀匹配
response_type固定 code。不支持 token 简化模式
state你生成的随机串,回来时原样带回。用来防 CSRF,务必校验
scope以空格分隔。默认 userinfo
code_challenge可选。传了就必须在换令牌时带 code_verifier

返回值

access_token访问令牌。调 /userinfo 时放在 Authorization: Bearer
refresh_token刷新令牌。access_token 过期后用它换新的
expires_inaccess_token 剩余有效秒数
token_type固定 Bearer
scope实际授予的权限,可能少于请求的
uid用户唯一标识。建议作为账号主键使用,禁止使用昵称作为主键
nickname昵称。用户随时可改,不适合做唯一标识
avatar头像 URL
short_no布丁号。给用户看的编号,比 uid 友好
关于 uid。 同一个布丁账号在本平台始终返回同一个 uid,但该标识不跨应用共享 —— 其他应用获取的 uid 与本应用无关联关系。建议以 uid 建立本地账号, 昵称和头像仅作为展示字段,每次登录时重新获取。
SDK & samples

SDK 与代码示例

布丁互联遵循标准 OAuth 2.0 规范,官方 SDK 为可选组件 —— 开发者可使用任一符合 OAuth 2.0 规范的客户端库,或直接调用 HTTP 接口。 以下是最小可运行版本,替换三个常量即可运行。

网页应用 SDK(服务端/浏览器)

移动应用 SDK(App-to-App 拉起授权)

# ── 第 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()
    }
}

关于 PKCE(移动端 / 单页应用必看)

如果你的应用为移动客户端或纯前端单页应用(SPA),客户端不具备保存密钥的安全环境 —— 反编译、看网络请求都能拿到。这种情况下请开 PKCE: 授权时多带一个 code_challenge, 换令牌时把原始 code_verifier 带上。 这样即使 code 在中途被截走,没有 verifier 也换不出令牌。

code_challengeBASE64URL(SHA256(verifier)),授权时带
code_challenge_method固定写 S256。不支持 plain
code_verifier原始随机串(43~128 字符),换令牌时带

SDK 下载

官方不强制 SDK —— 标准 OAuth 2.0 用现成库就好。 如需快速接入,可下载下方示例工程,包含上述六种语言的完整可运行实现。

⬇ 下载示例包(ZIP) 开发者中心
ℹ️
示例工程包含上述六种语言的最小可运行实现,未包含任何私有密钥,可直接纳入版本控制。
Scopes & errors

权限与错误码

仅申请必要的权限范围。权限范围越大,用户同意授权的概率越低,审核周期也越长。

权限范围(scope)

userinfo昵称、头像、布丁号。默认权限,不传 scope 时自动回落为它

未来新增的授权范围(scope)将通过开发者中心公告,且需用户重新授权确认 —— 不会出现「上次已同意,本次擅自追加一项权限」的情况。

常见错误

invalid_clientclient_id 不存在,或 client_secret 不对
invalid_grantcode 已用过 / 已过期,或 redirect_uri 与授权时不一致
invalid_request缺必填参数,或 response_type 不是 code
invalid_scope申请了不存在的 scope
access_denied用户在授权页点了「拒绝」
unauthorized_client应用被停用,或回调地址没在白名单里
✅
排障三步: ① 先看返回 JSON 里的 error 与 error_description,别只看 HTTP 状态码; ② invalid_grant 九成是 code 用第二次了 —— code 是一次性的; ③ 还是不通就比对 redirect_uri:平台的是精确字符串匹配, https://a.com/cb 与 https://a.com/cb/ 是两个不同的地址。
Security

接入前必须知道的四件事

!

secret 只留在服务端

不要写进前端、App 包、代码仓库、日志。client_secret 服务端仅存储哈希值,泄露后无法还原,只能重置 —— 重置会导致所有在线令牌立即失效。

!

state 必须校验

随机生成、存进会话、回调时逐字比对、用完即弃。不校验 state 是 OAuth 接入最常见的漏洞,攻击者能借此把别人的账号绑到自己的会话上。

!

redirect_uri 走白名单

平台仅对白名单执行精确匹配,不支持通配符、不支持前缀匹配。这样即便有人伪造一条带恶意回调的授权链接,用户点进去也拿不到任何东西。

!

uid 作为身份标识,昵称仅用于展示

昵称可被用户修改,作为主键存在重复与丢失风险。头像建议每次登录时刷新获取,不作为唯一身份凭据缓存。