בקרת גישה באמצעות תלונות בהתאמה אישית וכללי אבטחה

ה-SDK של Firebase לאדמינים תומך בהגדרת מאפיינים מותאמים אישית בחשבונות משתמשים. התכונה הזו מאפשרת להטמיע באפליקציות Firebase אסטרטגיות שונות של בקרת גישה, כולל בקרת גישה מבוססת-תפקידים. המאפיינים המותאמים אישית האלה יכולים לתת למשתמשים רמות גישה שונות (תפקידים), שמיושמות בכללי האבטחה של האפליקציה.

אפשר להגדיר תפקידי משתמשים במקרים הנפוצים הבאים:

  • הענקת הרשאות אדמין למשתמש כדי לגשת לנתונים ולמשאבים.
  • הגדרת קבוצות שונות שהמשתמש משתייך אליהן.
  • מתן גישה בכמה רמות:
    • הבחנה בין מנויים בתשלום לבין מנויים שלא משלמים.
    • הבחנה בין מנהלים לבין משתמשים רגילים.
    • בקשה של מורה/תלמיד/ה וכו'.
  • הוספת מזהה נוסף למשתמש. לדוגמה, משתמש Firebase יכול להיות ממופה למזהה משתמש אחר במערכת אחרת.

נניח שרוצים להגביל את הגישה לצומת מסד הנתונים adminContent. אפשר לעשות את זה באמצעות חיפוש במסד נתונים של רשימת משתמשי אדמין. עם זאת, אפשר להשיג את אותה מטרה בצורה יעילה יותר באמצעות תביעת משתמש מותאמת אישית בשם admin עם הכלל Realtime Database הבא:

{
  "rules": {
    "adminContent": {
      ".read": "auth.token.admin === true",
      ".write": "auth.token.admin === true",
    }
  }
}

אפשר לגשת להצהרות משתמש בהתאמה אישית דרך אסימוני האימות של המשתמש. בדוגמה שלמעלה, רק למשתמשים שערך הטענה admin באסימון שלהם מוגדר כ-true תהיה גישת קריאה/כתיבה לצומת adminContent. מכיוון שאסימון ה-ID כבר מכיל את ההצהרות האלה, לא נדרש עיבוד או חיפוש נוסף כדי לבדוק את הרשאות האדמין. בנוסף, אסימון המזהה הוא מנגנון מהימן להעברת ההצהרות המותאמות אישית האלה. כל גישה מאומתת חייבת לאמת את אסימון ה-ID לפני עיבוד הבקשה המשויכת.

בדוגמאות הקוד ובפתרונות שמתוארים בדף הזה נעשה שימוש בממשקי ה-API של Firebase Auth בצד הלקוח ובממשקי ה-API של Auth בצד השרת שזמינים ב-Admin SDK.

הגדרה ואימות של טענות משתמש בהתאמה אישית באמצעות Admin SDK

טענות מותאמות אישית יכולות להכיל נתונים רגישים, ולכן צריך להגדיר אותן רק בסביבת שרת עם הרשאות באמצעות Firebase Admin SDK.

Node.js

// Set admin privilege on the user corresponding to uid.

getAuth()
  .setCustomUserClaims(uid, { admin: true })
  .then(() => {
    // The new custom claims will propagate to the user's ID token the
    // next time a new one is issued.
  });

Java

// Set admin privilege on the user corresponding to uid.
Map<String, Object> claims = new HashMap<>();
claims.put("admin", true);
FirebaseAuth.getInstance().setCustomUserClaims(uid, claims);
// The new custom claims will propagate to the user's ID token the
// next time a new one is issued.

Python

# Set admin privilege on the user corresponding to uid.
auth.set_custom_user_claims(uid, {'admin': True})
# The new custom claims will propagate to the user's ID token the
# next time a new one is issued.

Go

// Get an auth client from the firebase.App
client, err := app.Auth(ctx)
if err != nil {
	log.Fatalf("error getting Auth client: %v\n", err)
}

// Set admin privilege on the user corresponding to uid.
claims := map[string]interface{}{"admin": true}
err = client.SetCustomUserClaims(ctx, uid, claims)
if err != nil {
	log.Fatalf("error setting custom claims %v\n", err)
}
// The new custom claims will propagate to the user's ID token the
// next time a new one is issued.
auth.go

C#‎

// Set admin privileges on the user corresponding to uid.
var claims = new Dictionary<string, object>()
{
    { "admin", true },
};
await FirebaseAuth.DefaultInstance.SetCustomUserClaimsAsync(uid, claims);
// The new custom claims will propagate to the user's ID token the
// next time a new one is issued.

אובייקט התביעות המותאמות אישית לא יכול להכיל שמות מפתחות שמורים של OIDC או שמות שמורים של Firebase. המטען הייעודי (payload) של טענות בהתאמה אישית לא יכול לחרוג מ-1,000 בייט.

אפשר להשתמש ב-Admin SDK כדי לאמת את הזהות של המשתמש ואת רמת הגישה שלו באמצעות אסימון מזהה שנשלח לשרת קצה עורפי, באופן הבא:

Node.js

// Verify the ID token first.
getAuth()
  .verifyIdToken(idToken)
  .then((claims) => {
    if (claims.admin === true) {
      // Allow access to requested admin resource.
    }
  });

Java

// Verify the ID token first.
FirebaseToken decoded = FirebaseAuth.getInstance().verifyIdToken(idToken);
if (Boolean.TRUE.equals(decoded.getClaims().get("admin"))) {
  // Allow access to requested admin resource.
}

Python

# Verify the ID token first.
claims = auth.verify_id_token(id_token)
if claims['admin'] is True:
    # Allow access to requested admin resource.
    pass

Go

// Verify the ID token first.
token, err := client.VerifyIDToken(ctx, idToken)
if err != nil {
	log.Fatal(err)
}

claims := token.Claims
if admin, ok := claims["admin"]; ok {
	if admin.(bool) {
		//Allow access to requested admin resource.
	}
}
auth.go

C#‎

// Verify the ID token first.
FirebaseToken decoded = await FirebaseAuth.DefaultInstance.VerifyIdTokenAsync(idToken);
object isAdmin;
if (decoded.Claims.TryGetValue("admin", out isAdmin))
{
    if ((bool)isAdmin)
    {
        // Allow access to requested admin resource.
    }
}

אפשר גם לבדוק את הטענות המותאמות אישית הקיימות של משתמש, שזמינות כמאפיין באובייקט המשתמש:

Node.js

// Lookup the user associated with the specified uid.
getAuth()
  .getUser(uid)
  .then((userRecord) => {
    // The claims can be accessed on the user record.
    console.log(userRecord.customClaims['admin']);
  });

Java

// Lookup the user associated with the specified uid.
UserRecord user = FirebaseAuth.getInstance().getUser(uid);
System.out.println(user.getCustomClaims().get("admin"));

Python

# Lookup the user associated with the specified uid.
user = auth.get_user(uid)
# The claims can be accessed on the user record.
print(user.custom_claims.get('admin'))

Go

// Lookup the user associated with the specified uid.
user, err := client.GetUser(ctx, uid)
if err != nil {
	log.Fatal(err)
}
// The claims can be accessed on the user record.
if admin, ok := user.CustomClaims["admin"]; ok {
	if admin.(bool) {
		log.Println(admin)
	}
}
auth.go

C#‎

// Lookup the user associated with the specified uid.
UserRecord user = await FirebaseAuth.DefaultInstance.GetUserAsync(uid);
Console.WriteLine(user.CustomClaims["admin"]);

כדי למחוק טענות בהתאמה אישית של משתמש, מעבירים ערך null ל-customClaims.

הפצה של טענות מותאמות אישית ללקוח

אחרי שמשנים הצהרות חדשות אצל משתמש באמצעות Admin SDK, הן מועברות למשתמש מאומת בצד הלקוח באמצעות אסימון המזהה בדרכים הבאות:

  • משתמש נכנס לחשבון או מבצע אימות מחדש אחרי שמשנים את ההצהרות המותאמות אישית. האסימון המזהה שיונפק כתוצאה מכך יכיל את ההצהרות העדכניות.
  • אסימון מזהה של סשן משתמש קיים מתרענן אחרי שאסימון ישן יותר פג.
  • מתבצע רענון בכפייה של אסימון מזהה על ידי קריאה ל-currentUser.getIdToken(true).

גישה לטענות מותאמות אישית בלקוח

אפשר לאחזר הצהרות מותאמות אישית רק דרך אסימון המזהה של המשתמש. יכול להיות שתצטרכו גישה לטענות האלה כדי לשנות את ממשק המשתמש של הלקוח בהתאם לתפקיד או לרמת הגישה של המשתמש. עם זאת, תמיד צריך לאכוף גישה לעורף המערכת באמצעות טוקן ה-ID אחרי אימותו וניתוח הטענות שלו. אין לשלוח טענות מותאמות אישית ישירות אל ה-backend, כי אי אפשר לסמוך עליהן מחוץ לאסימון.

אחרי שהטענות העדכניות מועברות לאסימון המזהה של המשתמש, אפשר לאחזר אותן על ידי אחזור אסימון המזהה:

JavaScript

firebase.auth().currentUser.getIdTokenResult()
  .then((idTokenResult) => {
     // Confirm the user is an Admin.
     if (!!idTokenResult.claims.admin) {
       // Show admin UI.
       showAdminUI();
     } else {
       // Show regular user UI.
       showRegularUI();
     }
  })
  .catch((error) => {
    console.log(error);
  });

Android

user.getIdToken(false).addOnSuccessListener(new OnSuccessListener<GetTokenResult>() {
  @Override
  public void onSuccess(GetTokenResult result) {
    boolean isAdmin = result.getClaims().get("admin");
    if (isAdmin) {
      // Show admin UI.
      showAdminUI();
    } else {
      // Show regular user UI.
      showRegularUI();
    }
  }
});

Swift

user.getIDTokenResult(completion: { (result, error) in
  guard let admin = result?.claims?["admin"] as? NSNumber else {
    // Show regular user UI.
    showRegularUI()
    return
  }
  if admin.boolValue {
    // Show admin UI.
    showAdminUI()
  } else {
    // Show regular user UI.
    showRegularUI()
  }
})

Objective-C

user.getIDTokenResultWithCompletion:^(FIRAuthTokenResult *result,
                                      NSError *error) {
  if (error != nil) {
    BOOL *admin = [result.claims[@"admin"] boolValue];
    if (admin) {
      // Show admin UI.
      [self showAdminUI];
    } else {
      // Show regular user UI.
      [self showRegularUI];
    }
  }
}];

שיטות מומלצות לשימוש בהצהרות מותאמות אישית

הצהרות מותאמות אישית משמשות רק כדי לספק בקרת גישה. הם לא מיועדים לאחסון נתונים נוספים (כמו פרופיל ונתונים מותאמים אישית אחרים). יכול להיות שזה נראה כמו מנגנון נוח לעשות את זה, אבל אנחנו לא ממליצים על השיטה הזו כי התביעות האלה מאוחסנות בטוקן המזהה, והן עלולות לגרום לבעיות בביצועים כי כל הבקשות שעברו אימות תמיד מכילות טוקן מזהה של Firebase שמתאים למשתמש המחובר.

  • אפשר להשתמש בטענות מותאמות אישית רק כדי לאחסן נתונים לצורך שליטה בגישת המשתמשים. את כל שאר הנתונים צריך לאחסן בנפרד באמצעות מסד הנתונים בזמן אמת או אחסון אחר בצד השרת.
  • הגודל של טענות מותאמות אישית מוגבל. העברת מטען ייעודי (payload) של טענות מותאמות אישית בגודל של יותר מ-1,000 בייט תגרום לשגיאה.

דוגמאות ותרחישי שימוש

בדוגמאות הבאות מוצגים טענות בהתאמה אישית בהקשר של תרחישי שימוש ספציפיים ב-Firebase.

הגדרת תפקידים באמצעות Firebase Functions כשיוצרים משתמש

בדוגמה הזו, טענות מותאמות אישית מוגדרות למשתמש בזמן היצירה באמצעות Cloud Functions.

אפשר להוסיף הצהרות מותאמות אישית באמצעות Cloud Functions ולהפיץ אותן באופן מיידי באמצעות Realtime Database. הפונקציה מופעלת רק כשנרשמים באמצעות טריגר onCreate. אחרי שמגדירים את הטענות המותאמות אישית, הן מועברות לכל הסשנים הקיימים ולסשנים עתידיים. בפעם הבאה שהמשתמש ייכנס באמצעות פרטי הכניסה שלו, האסימון יכלול את ההצהרות המותאמות אישית.

הטמעה בצד הלקוח (JavaScript)

const provider = new firebase.auth.GoogleAuthProvider();
firebase.auth().signInWithPopup(provider)
.catch(error => {
  console.log(error);
});

let callback = null;
let metadataRef = null;
firebase.auth().onAuthStateChanged(user => {
  // Remove previous listener.
  if (callback) {
    metadataRef.off('value', callback);
  }
  // On user login add new listener.
  if (user) {
    // Check if refresh is required.
    metadataRef = firebase.database().ref('metadata/' + user.uid + '/refreshTime');
    callback = (snapshot) => {
      // Force refresh to pick up the latest custom claims changes.
      // Note this is always triggered on first call. Further optimization could be
      // added to avoid the initial trigger when the token is issued and already contains
      // the latest claims.
      user.getIdToken(true);
    };
    // Subscribe new listener to changes on that node.
    metadataRef.on('value', callback);
  }
});

לוגיקה של Cloud Functions

נוסף צומת חדש של מסד נתונים (metadata/($uid)} עם הרשאות קריאה/כתיבה שמוגבלות למשתמש המאומת.

const functions = require('firebase-functions');
const { initializeApp } = require('firebase-admin/app');
const { getAuth } = require('firebase-admin/auth');
const { getDatabase } = require('firebase-admin/database');

initializeApp();

// On sign up.
exports.processSignUp = functions.auth.user().onCreate(async (user) => {
  // Check if user meets role criteria.
  if (
    user.email &&
    user.email.endsWith('@admin.example.com') &&
    user.emailVerified
  ) {
    const customClaims = {
      admin: true,
      accessLevel: 9
    };

    try {
      // Set custom user claims on this newly created user.
      await getAuth().setCustomUserClaims(user.uid, customClaims);

      // Update real-time database to notify client to force refresh.
      const metadataRef = getDatabase().ref('metadata/' + user.uid);

      // Set the refresh time to the current UTC timestamp.
      // This will be captured on the client to force a token refresh.
      await  metadataRef.set({refreshTime: new Date().getTime()});
    } catch (error) {
      console.log(error);
    }
  }
});

כללים למסד נתונים

{
  "rules": {
    "metadata": {
      "$user_id": {
        // Read access only granted to the authenticated user.
        ".read": "$user_id === auth.uid",
        // Write access only via Admin SDK.
        ".write": false
      }
    }
  }
}

הגדרת תפקידים באמצעות בקשת HTTP

בדוגמה הבאה מוגדרות טענות משתמש בהתאמה אישית למשתמש שנכנס לחשבון באמצעות בקשת HTTP.

הטמעה בצד הלקוח (JavaScript)

const provider = new firebase.auth.GoogleAuthProvider();
firebase.auth().signInWithPopup(provider)
.then((result) => {
  // User is signed in. Get the ID token.
  return result.user.getIdToken();
})
.then((idToken) => {
  // Pass the ID token to the server.
  $.post(
    '/setCustomClaims',
    {
      idToken: idToken
    },
    (data, status) => {
      // This is not required. You could just wait until the token is expired
      // and it proactively refreshes.
      if (status == 'success' && data) {
        const json = JSON.parse(data);
        if (json && json.status == 'success') {
          // Force token refresh. The token claims will contain the additional claims.
          firebase.auth().currentUser.getIdToken(true);
        }
      }
    });
}).catch((error) => {
  console.log(error);
});

הטמעה בקצה העורפי (Admin SDK)

app.post('/setCustomClaims', async (req, res) => {
  // Get the ID token passed.
  const idToken = req.body.idToken;

  // Verify the ID token and decode its payload.
  const claims = await getAuth().verifyIdToken(idToken);

  // Verify user is eligible for additional privileges.
  if (
    typeof claims.email !== 'undefined' &&
    typeof claims.email_verified !== 'undefined' &&
    claims.email_verified &&
    claims.email.endsWith('@admin.example.com')
  ) {
    // Add custom claims for additional privileges.
    await getAuth().setCustomUserClaims(claims.sub, {
      admin: true
    });

    // Tell client to refresh token on user.
    res.end(JSON.stringify({
      status: 'success'
    }));
  } else {
    // Return nothing.
    res.end(JSON.stringify({ status: 'ineligible' }));
  }
});

אפשר להשתמש באותו תהליך גם כשמשדרגים את רמת הגישה של משתמש קיים. לדוגמה, משתמש בחינם שמשדרג למינוי בתשלום. טוקן מזהה המשתמש נשלח עם פרטי התשלום לשרת הקצה העורפי באמצעות בקשת HTTP. כשהתשלום מעובד בהצלחה, המשתמש מוגדר כמנוי בתשלום באמצעות Admin SDK. תגובת HTTP מוצלחת מוחזרת ללקוח כדי לאלץ רענון של הטוקן.

הגדרת תפקידים באמצעות סקריפט בקצה העורפי

אפשר להגדיר סקריפט חוזר (שלא מופעל מהלקוח) שיפעל כדי לעדכן טענות מותאמות אישית של משתמשים:

Node.js

getAuth()
  .getUserByEmail('user@admin.example.com')
  .then((user) => {
    // Confirm user is verified.
    if (user.emailVerified) {
      // Add custom claims for additional privileges.
      // This will be picked up by the user on token refresh or next sign in on new device.
      return getAuth().setCustomUserClaims(user.uid, {
        admin: true,
      });
    }
  })
  .catch((error) => {
    console.log(error);
  });

Java

UserRecord user = FirebaseAuth.getInstance()
    .getUserByEmail("user@admin.example.com");
// Confirm user is verified.
if (user.isEmailVerified()) {
  Map<String, Object> claims = new HashMap<>();
  claims.put("admin", true);
  FirebaseAuth.getInstance().setCustomUserClaims(user.getUid(), claims);
}

Python

user = auth.get_user_by_email('user@admin.example.com')
# Confirm user is verified
if user.email_verified:
    # Add custom claims for additional privileges.
    # This will be picked up by the user on token refresh or next sign in on new device.
    auth.set_custom_user_claims(user.uid, {
        'admin': True
    })

Go

user, err := client.GetUserByEmail(ctx, "user@admin.example.com")
if err != nil {
	log.Fatal(err)
}
// Confirm user is verified
if user.EmailVerified {
	// Add custom claims for additional privileges.
	// This will be picked up by the user on token refresh or next sign in on new device.
	err := client.SetCustomUserClaims(ctx, user.UID, map[string]interface{}{"admin": true})
	if err != nil {
		log.Fatalf("error setting custom claims %v\n", err)
	}

}
auth.go

C#‎

UserRecord user = await FirebaseAuth.DefaultInstance
    .GetUserByEmailAsync("user@admin.example.com");
// Confirm user is verified.
if (user.EmailVerified)
{
    var claims = new Dictionary<string, object>()
    {
        { "admin", true },
    };
    await FirebaseAuth.DefaultInstance.SetCustomUserClaimsAsync(user.Uid, claims);
}

אפשר גם לשנות הצהרות בהתאמה אישית באופן מצטבר באמצעות Admin SDK:

Node.js

getAuth()
  .getUserByEmail('user@admin.example.com')
  .then((user) => {
    // Add incremental custom claim without overwriting existing claims.
    const currentCustomClaims = user.customClaims;
    if (currentCustomClaims['admin']) {
      // Add level.
      currentCustomClaims['accessLevel'] = 10;
      // Add custom claims for additional privileges.
      return getAuth().setCustomUserClaims(user.uid, currentCustomClaims);
    }
  })
  .catch((error) => {
    console.log(error);
  });

Java

UserRecord user = FirebaseAuth.getInstance()
    .getUserByEmail("user@admin.example.com");
// Add incremental custom claim without overwriting the existing claims.
Map<String, Object> currentClaims = user.getCustomClaims();
if (Boolean.TRUE.equals(currentClaims.get("admin"))) {
  // Add level.
  currentClaims.put("level", 10);
  // Add custom claims for additional privileges.
  FirebaseAuth.getInstance().setCustomUserClaims(user.getUid(), currentClaims);
}

Python

user = auth.get_user_by_email('user@admin.example.com')
# Add incremental custom claim without overwriting existing claims.
current_custom_claims = user.custom_claims
if current_custom_claims.get('admin'):
    # Add level.
    current_custom_claims['accessLevel'] = 10
    # Add custom claims for additional privileges.
    auth.set_custom_user_claims(user.uid, current_custom_claims)

Go

user, err := client.GetUserByEmail(ctx, "user@admin.example.com")
if err != nil {
	log.Fatal(err)
}
// Add incremental custom claim without overwriting existing claims.
currentCustomClaims := user.CustomClaims
if currentCustomClaims == nil {
	currentCustomClaims = map[string]interface{}{}
}

if _, found := currentCustomClaims["admin"]; found {
	// Add level.
	currentCustomClaims["accessLevel"] = 10
	// Add custom claims for additional privileges.
	err := client.SetCustomUserClaims(ctx, user.UID, currentCustomClaims)
	if err != nil {
		log.Fatalf("error setting custom claims %v\n", err)
	}

}
auth.go

C#‎

UserRecord user = await FirebaseAuth.DefaultInstance
    .GetUserByEmailAsync("user@admin.example.com");
// Add incremental custom claims without overwriting the existing claims.
object isAdmin;
if (user.CustomClaims.TryGetValue("admin", out isAdmin) && (bool)isAdmin)
{
    var claims = user.CustomClaims.ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
    // Add level.
    var level = 10;
    claims["level"] = level;
    // Add custom claims for additional privileges.
    await FirebaseAuth.DefaultInstance.SetCustomUserClaimsAsync(user.Uid, claims);
}