ยืนยันโทเค็น App Check จากแบ็กเอนด์ที่กำหนดเอง

คุณปกป้องทรัพยากรที่ไม่ใช่ Firebase ของแอป เช่น แบ็กเอนด์ที่โฮสต์เอง ได้โดยใช้ App Check โดยคุณจะต้องดำเนินการทั้ง 2 อย่างต่อไปนี้

แก้ไขไคลเอ็นต์แอปให้ส่งโทเค็น App Check พร้อมกับคำขอแต่ละรายการไปยังแบ็กเอนด์ ตามที่อธิบายไว้ในหน้าสำหรับ iOS+, Android และเว็บ
แก้ไขแบ็กเอนด์ให้กำหนดให้มีโทเค็น App Check ที่ถูกต้องกับคำขอทุกรายการ ตามที่อธิบายไว้ในหน้านี้

การยืนยันโทเค็น

หากต้องการยืนยันโทเค็น App Check ในแบ็กเอนด์ ให้เพิ่มตรรกะลงในปลายทาง API ที่ทําสิ่งต่อไปนี้

ตรวจสอบว่าคําขอแต่ละรายการมีโทเค็น App Check
ยืนยันโทเค็น App Check โดยใช้ Admin SDK

หากการยืนยันสําเร็จ Admin SDK จะแสดงApp Check โทเค็นที่ถอดรหัสแล้ว การยืนยันที่สำเร็จจะบ่งบอกว่าโทเค็นมาจากแอปที่เป็นของโปรเจ็กต์ Firebase

ปฏิเสธคำขอที่ไม่ผ่านการตรวจสอบอย่างใดอย่างหนึ่ง เช่น

Node.js

ติดตั้ง Node.js Admin SDK หากยังไม่ได้ดำเนินการ

จากนั้นให้ใช้มิดเดิลแวร์ Express.js เป็นตัวอย่าง

import express from "express";
import { initializeApp } from "firebase-admin/app";
import { getAppCheck } from "firebase-admin/app-check";

const expressApp = express();
const firebaseApp = initializeApp();

const appCheckVerification = async (req, res, next) => {
    const appCheckToken = req.header("X-Firebase-AppCheck");

    if (!appCheckToken) {
        res.status(401);
        return next("Unauthorized");
    }

    try {
        const appCheckClaims = await getAppCheck().verifyToken(appCheckToken);

        // If verifyToken() succeeds, continue with the next middleware
        // function in the stack.
        return next();
    } catch (err) {
        res.status(401);
        return next("Unauthorized");
    }
}

expressApp.get("/yourApiEndpoint", [appCheckVerification], (req, res) => {
    // Handle request.
});

Python

ติดตั้ง Python Admin SDK หากยังไม่ได้ดำเนินการ

จากนั้นในตัวแฮนเดิลปลายทาง API ให้เรียก app_check.verify_token() และปฏิเสธคำขอหากดำเนินการไม่สำเร็จ ในตัวอย่างต่อไปนี้ ฟังก์ชันที่ประดับด้วย @before_request จะทํางานนี้สําหรับคําขอทั้งหมด

import firebase_admin
from firebase_admin import app_check
import flask
import jwt

firebase_app = firebase_admin.initialize_app()
flask_app = flask.Flask(__name__)

@flask_app.before_request
def verify_app_check() -> None:
    app_check_token = flask.request.headers.get("X-Firebase-AppCheck", default="")
    try:
        app_check_claims = app_check.verify_token(app_check_token)
        # If verify_token() succeeds, okay to continue to route handler.
    except (ValueError, jwt.exceptions.DecodeError):
        flask.abort(401)

@flask_app.route("/yourApiEndpoint")
def your_api_endpoint(request: flask.Request):
    # Handle request.
    ...

Go

ติดตั้ง Admin SDK สําหรับ Go หากยังไม่ได้ดำเนินการ

จากนั้นในตัวแฮนเดิลปลายทาง API ให้เรียก appcheck.Client.VerifyToken() และปฏิเสธคำขอหากดำเนินการไม่สำเร็จ ในตัวอย่างต่อไปนี้ ฟังก์ชัน Wrapper จะเพิ่มตรรกะนี้ลงในตัวแฮนเดิลอุปกรณ์ปลายทาง

package main

import (
    "context"
    "log"
    "net/http"

    firebaseAdmin "firebase.google.com/go/v4"
    "firebase.google.com/go/v4/appcheck"
)

var (
    appCheck *appcheck.Client
)

func main() {
    app, err := firebaseAdmin.NewApp(context.Background(), nil)
    if err != nil {
        log.Fatalf("error initializing app: %v\n", err)
    }

    appCheck, err = app.AppCheck(context.Background())
    if err != nil {
        log.Fatalf("error initializing app: %v\n", err)
    }

    http.HandleFunc("/yourApiEndpoint", requireAppCheck(yourApiEndpointHandler))
    log.Fatal(http.ListenAndServe(":8080", nil))
}

func requireAppCheck(handler func(http.ResponseWriter, *http.Request)) func(http.ResponseWriter, *http.Request) {
    wrappedHandler := func(w http.ResponseWriter, r *http.Request) {
        appCheckToken, ok := r.Header[http.CanonicalHeaderKey("X-Firebase-AppCheck")]
        if !ok {
            w.WriteHeader(http.StatusUnauthorized)
            w.Write([]byte("Unauthorized."))
            return
        }

        _, err := appCheck.VerifyToken(appCheckToken[0])
        if err != nil {
            w.WriteHeader(http.StatusUnauthorized)
            w.Write([]byte("Unauthorized."))
            return
        }

        // If VerifyToken() succeeds, continue with the provided handler.
        handler(w, r)
    }
    return wrappedHandler
}

func yourApiEndpointHandler(w http.ResponseWriter, r *http.Request) {
    // Handle request.
}

อื่นๆ

หากแบ็กเอนด์เขียนด้วยภาษาอื่น คุณสามารถใช้ไลบรารี JWT อเนกประสงค์ เช่น ไลบรารีที่พบใน jwt.io เพื่อยืนยันโทเค็น App Check

ตรรกะการยืนยันโทเค็นต้องทําตามขั้นตอนต่อไปนี้

รับชุดคีย์เวิร์ด JSON (JWK) สาธารณะของ Firebase App Check จากปลายทาง App ตรวจสอบ JWKS ดังนี้ https://firebaseappcheck.googleapis.com/v1/jwks
ตรวจสอบลายเซ็นของโทเค็น App Check เพื่อให้แน่ใจว่าถูกต้อง
ตรวจสอบว่าส่วนหัวของโทเค็นใช้อัลกอริทึม RS256
ตรวจสอบว่าส่วนหัวของโทเค็นเป็นประเภท JWT
ตรวจสอบว่าโทเค็นดังกล่าวออกโดย Firebase App Check ในโปรเจ็กต์ของคุณ
ตรวจสอบว่าโทเค็นยังไม่หมดอายุ
ตรวจสอบว่ากลุ่มเป้าหมายของโทเค็นตรงกับโปรเจ็กต์ของคุณ
ไม่บังคับ: ตรวจสอบว่าเรื่องในโทเค็นตรงกับรหัสแอปของแอป

ความสามารถของไลบรารี JWT อาจแตกต่างกันไป ดังนั้นโปรดทำตามขั้นตอนที่ไม่ได้จัดการโดยไลบรารีที่คุณเลือกให้เสร็จสมบูรณ์ด้วยตนเอง

ตัวอย่างต่อไปนี้แสดงขั้นตอนที่จำเป็นใน Ruby โดยใช้ jwt gem เป็นเลเยอร์มิดเดิลแวร์ของ Rack

require 'json'
require 'jwt'
require 'net/http'
require 'uri'

class AppCheckVerification
def initialize(app, options = {})
    @app = app
    @project_number = options[:project_number]
end

def call(env)
    app_id = verify(env['HTTP_X_FIREBASE_APPCHECK'])
    return [401, { 'Content-Type' => 'text/plain' }, ['Unauthenticated']] unless app_id
    env['firebase.app'] = app_id
    @app.call(env)
end

def verify(token)
    return unless token

    # 1. Obtain the Firebase App Check Public Keys
    # Note: It is not recommended to hard code these keys as they rotate,
    # but you should cache them for up to 6 hours.
    uri = URI('https://firebaseappcheck.googleapis.com/v1/jwks')
    jwks = JSON(Net::HTTP.get(uri))

    # 2. Verify the signature on the App Check token
    payload, header = JWT.decode(token, nil, true, jwks: jwks, algorithms: 'RS256')

    # 3. Ensure the token's header uses the algorithm RS256
    return unless header['alg'] == 'RS256'

    # 4. Ensure the token's header has type JWT
    return unless header['typ'] == 'JWT'

    # 5. Ensure the token is issued by App Check
    return unless payload['iss'] == "https://firebaseappcheck.googleapis.com/#{@project_number}"

    # 6. Ensure the token is not expired
    return unless payload['exp'] > Time.new.to_i

    # 7. Ensure the token's audience matches your project
    return unless payload['aud'].include? "projects/#{@project_number}"

    # 8. The token's subject will be the app ID, you may optionally filter against
    # an allow list
    payload['sub']
rescue
end
end

class Application
def call(env)
    [200, { 'Content-Type' => 'text/plain' }, ["Hello app #{env['firebase.app']}"]]
end
end

use AppCheckVerification, project_number: 1234567890
run Application.new

การป้องกันการเล่นซ้ำ (เบต้า)

หากต้องการปกป้องอุปกรณ์ปลายทางจากการโจมตีด้วยการเล่นซ้ำ คุณสามารถใช้โทเค็น App Check ได้หลังจากยืนยันแล้วเพื่อให้ใช้เพียงครั้งเดียว

การใช้การป้องกันการเล่นซ้ำจะเพิ่มการรับส่งข้อมูลแบบไปกลับของเครือข่ายไปยังverifyToken()การเรียกใช้ ซึ่งจะเพิ่มเวลาในการตอบสนองให้กับอุปกรณ์ปลายทางที่ใช้การป้องกันนี้ ด้วยเหตุนี้ เราจึงขอแนะนําให้คุณเปิดใช้การป้องกันการเล่นซ้ำเฉพาะกับปลายทางที่มีความละเอียดอ่อนเป็นพิเศษเท่านั้น

หากต้องการใช้การป้องกันการเล่นซ้ำ ให้ทำดังนี้

ในคอนโซล Cloud ให้มอบหมายบทบาท "โปรแกรมตรวจสอบโทเค็น Firebase App Check" ให้กับบัญชีบริการที่ใช้เพื่อยืนยันโทเค็น
- หากคุณเริ่มต้น Admin SDK ด้วยข้อมูลเข้าสู่ระบบบัญชีบริการ Admin SDK ที่คุณดาวน์โหลดจากคอนโซล Firebase ระบบจะให้บทบาทที่จําเป็นแล้ว
- หากคุณใช้ Cloud Functions รุ่นที่ 1 ที่มีการกำหนดค่า Admin SDK เริ่มต้น ให้มอบหมายบทบาทให้กับบัญชีบริการเริ่มต้นของ App Engine โปรดดูหัวข้อการเปลี่ยนสิทธิ์ของบัญชีบริการ
- หากคุณใช้ Cloud Functions รุ่นที่ 2 ที่มีการกำหนดค่า Admin SDK เริ่มต้น ให้มอบบทบาทให้กับบัญชีบริการประมวลผลเริ่มต้น
จากนั้น หากต้องการใช้โทเค็น ให้ส่ง { consume: true } ไปยังเมธอด verifyToken() และตรวจสอบออบเจ็กต์ผลลัพธ์ หากพร็อพเพอร์ตี้ alreadyConsumed มีค่าเป็น true ให้ปฏิเสธคำขอหรือดำเนินการแก้ไขบางอย่าง เช่น กำหนดให้ผู้เรียกใช้ต้องผ่านการตรวจสอบอื่นๆ

เช่น
```
const appCheckClaims = await getAppCheck().verifyToken(appCheckToken, { consume: true });

if (appCheckClaims.alreadyConsumed) {
    res.status(401);
    return next('Unauthorized');
}

// If verifyToken() succeeds and alreadyConsumed is not set, okay to continue.
```
ซึ่งจะยืนยันโทเค็นแล้วแจ้งว่าใช้แล้ว การเรียกใช้ verifyToken(appCheckToken, { consume: true }) ในอนาคตในโทเค็นเดียวกันจะตั้งค่า alreadyConsumed เป็น true (โปรดทราบว่า verifyToken() จะไม่ปฏิเสธโทเค็นที่ใช้แล้ว หรือแม้แต่ตรวจสอบว่าโทเค็นดังกล่าวใช้แล้วหรือไม่หากไม่ได้ตั้งค่า consume)

เมื่อเปิดใช้ฟีเจอร์นี้สําหรับอุปกรณ์ปลายทางหนึ่งๆ คุณต้องอัปเดตโค้ดไคลเอ็นต์แอปเพื่อรับโทเค็นแบบจำกัดการใช้งานที่บริโภคได้เพื่อใช้กับอุปกรณ์ปลายทางดังกล่าวด้วย ดูเอกสารฝั่งไคลเอ็นต์สำหรับแพลตฟอร์ม Apple, Android และเว็บ