किसी कस्टम बैकएंड से, ऐप्लिकेशन की जांच वाले टोकन की पुष्टि करें

App Check का इस्तेमाल करके, अपने ऐप्लिकेशन के लिए Google के अलावा अन्य कस्टम बैकएंड रिसॉर्स को सुरक्षित किया जा सकता है. जैसे, खुद होस्ट किया गया बैकएंड. इसके लिए, आपको ये दोनों काम करने होंगे:

  • अपने ऐप्लिकेशन क्लाइंट में बदलाव करें, ताकि वह आपके बैकएंड को हर अनुरोध के साथ App Check टोकन भेज सके. इसके बारे में iOS+, Android, वेब, Flutter, Unity या C++ के पेजों पर बताया गया है.
  • अपने बैकएंड में बदलाव करें, ताकि हर अनुरोध के साथ मान्य App Check टोकन की ज़रूरत पड़े. इसके बारे में इस पेज पर बताया गया है.

टोकन की पुष्टि करना

अपने बैकएंड पर App Check टोकन की पुष्टि करने के लिए, अपने एपीआई एंडपॉइंट में ऐसा लॉजिक जोड़ें जो ये काम करता हो:

  • देख लें कि हर अनुरोध में App Check टोकन शामिल हो.

  • Admin SDK का इस्तेमाल करके, App Check टोकन की पुष्टि करें.

    पुष्टि हो जाने पर, 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 इंस्टॉल नहीं किया है, तो इसे इंस्टॉल करें.

इसके बाद, अपने एपीआई एंडपॉइंट हैंडलर में 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.
    ...

शुरू करें

अगर आपने Admin SDK for Go को पहले से इंस्टॉल नहीं किया है, तो इसे इंस्टॉल करें.

इसके बाद, अपने एपीआई एंडपॉइंट हैंडलर में appcheck.Client.VerifyToken() को कॉल करें और अगर अनुरोध पूरा नहीं होता है, तो उसे अस्वीकार करें. यहां दिए गए उदाहरण में, रैपर फ़ंक्शन एंडपॉइंट हैंडलर में यह लॉजिक जोड़ता है:

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.
}

अन्य

अगर आपका बैकएंड किसी दूसरी भाषा में लिखा गया है, तो App Check टोकन की पुष्टि करने के लिए, सामान्य तौर पर इस्तेमाल की जाने वाली JWT लाइब्रेरी का इस्तेमाल किया जा सकता है. जैसे, jwt.io पर मौजूद लाइब्रेरी.

आपके टोकन की पुष्टि करने के लॉजिक को ये चरण पूरे करने होंगे:

  1. App Check JWKS एंडपॉइंट से, Firebase App Check का सार्वजनिक JSON वेब कुंजी (JWK) सेट पाएं: https://firebaseappcheck.googleapis.com/v1/jwks
  2. App Check टोकन के हस्ताक्षर की पुष्टि करें, ताकि यह पक्का किया जा सके कि यह सही है.
  3. पक्का करें कि टोकन के हेडर में RS256 एल्गोरिदम का इस्तेमाल किया गया हो.
  4. पक्का करें कि टोकन के हेडर का टाइप JWT हो.
  5. पक्का करें कि टोकन, आपके प्रोजेक्ट के लिए Firebase App Check ने जारी किया हो.
  6. पक्का करें कि टोकन की समयसीमा खत्म न हुई हो.
  7. पक्का करें कि टोकन के दर्शक, आपके प्रोजेक्ट से मेल खाते हों.
  8. ज़रूरी नहीं: पुष्टि करें कि टोकन का विषय, आपके ऐप्लिकेशन के App ID से मेल खाता हो.

JWT लाइब्रेरी की सुविधाएं अलग-अलग हो सकती हैं. इसलिए, यह पक्का करें कि आपने लाइब्रेरी के ज़रिए हैंडल नहीं किए गए सभी चरणों को मैन्युअल तरीके से पूरा कर लिया हो.

यहां दिए गए उदाहरण में, Rack मिडलवेयर लेयर के तौर पर jwt gem का इस्तेमाल करके, Ruby में ज़रूरी चरणों को पूरा करने का तरीका बताया गया है.

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() कॉल में नेटवर्क राउंड ट्रिप जुड़ जाती है. इसलिए, इसका इस्तेमाल करने वाले किसी भी एंडपॉइंट के लिए इंतज़ार का समय बढ़ जाता है. इस वजह से, हमारा सुझाव है कि आप रीप्ले सुरक्षा की सुविधा को सिर्फ़ उन एंडपॉइंट पर चालू करें जो खास तौर पर संवेदनशील हैं.

रीप्ले सुरक्षा का इस्तेमाल करने के लिए, यह तरीका अपनाएं:

  1. Cloud Console में, टोकन की पुष्टि करने के लिए इस्तेमाल किए गए सेवा खाते को "Firebase App Check Token Verifier" की भूमिका असाइन करें.

    • अगर आपने Admin SDK को Admin SDK सेवा खाते के क्रेडेंशियल के साथ शुरू किया है, तो ज़रूरी भूमिका पहले से ही असाइन कर दी जाती है. ये क्रेडेंशियल, Firebase कंसोल से डाउनलोड किए जाते हैं.
    • अगर डिफ़ॉल्ट Admin SDK कॉन्फ़िगरेशन के साथ पहली जनरेशन के Cloud Functions का इस्तेमाल किया जा रहा है, तो App Engine के डिफ़ॉल्ट सेवा खाते को भूमिका असाइन करें. सेवा खाते की अनुमतियां बदलना लेख पढ़ें.
    • अगर डिफ़ॉल्ट Admin SDK कॉन्फ़िगरेशन के साथ दूसरी जनरेशन के Cloud Functions का इस्तेमाल किया जा रहा है, तो डिफ़ॉल्ट कंप्यूट सेवा खाते को भूमिका असाइन करें.

  2. इसके बाद, टोकन का इस्तेमाल करने के लिए, verifyToken() तरीके को { consume: true } पास करें और नतीजे वाले ऑब्जेक्ट की जांच करें. अगर 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() सेट नहीं है, तो verifyToken() इस्तेमाल किए गए टोकन को अस्वीकार नहीं करता. साथ ही, यह भी नहीं देखता कि टोकन का इस्तेमाल किया गया है या नहीं.)consume

किसी एंडपॉइंट के लिए इस सुविधा को चालू करने पर, आपको अपने ऐप्लिकेशन के क्लाइंट कोड को भी अपडेट करना होगा. इससे, एंडपॉइंट के साथ इस्तेमाल करने के लिए, सीमित इस्तेमाल वाले टोकन हासिल किए जा सकेंगे. Apple प्लैटफ़ॉर्म, Android, और वेब के लिए क्लाइंट-साइड के दस्तावेज़ देखें.