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

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

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

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

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

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

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

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

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

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

// 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.
  });

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

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

// 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

// 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. עומס העבודה של הצהרות בהתאמה אישית לא יכול לחרוג מ-1,000 בייטים.

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

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

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

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

// 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

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

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

// 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']);
  });

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

# 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'))

// 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

// 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).

גישה להצהרות בהתאמה אישית בצד הלקוח

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

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

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);
  });

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();
    }
  }
});

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()
  }
})

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 שתואם למשתמש שנכנס לחשבון.

• שימוש בהצהרות מותאמות אישית לאחסון נתונים לצורך בקרה על הגישה של משתמשים בלבד. כל שאר הנתונים צריכים להיות מאוחסנים בנפרד באמצעות מסד הנתונים בזמן אמת או אחסון אחר בצד השרת.
• הגודל של הצהרות בהתאמה אישית מוגבל. העברה של עומס עבודה בהצהרות בהתאמה אישית גדול מ-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

בדוגמה הבאה מוגדר טענת נכוֹנוּת (claim) מותאמת אישית של משתמש שנכנס לחשבון באמצעות בקשת 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 מוצלחת מוחזרת ללקוח כדי לאלץ רענון של הטוקן.

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

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

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);
  });

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);
}

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

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

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:

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);
  });

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);
}

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)

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

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);
}