Kullanıcı Oturumlarını Yönet

Firebase Kimlik Doğrulama oturumları uzun ömürlüdür. Bir kullanıcı her oturum açtığında, kullanıcı kimlik bilgileri Firebase Kimlik Doğrulaması arka ucuna gönderilir ve bir Firebase ID belirteci (bir JWT) ve yenileme belirteci ile değiştirilir. Firebase ID belirteçleri kısa ömürlüdür ve bir saat sürer; yenileme belirteci, yeni kimlik belirteçlerini almak için kullanılabilir. Yenileme belirteçleri yalnızca aşağıdakilerden biri gerçekleştiğinde sona erer:

• kullanıcı silindi
• kullanıcı devre dışı
• Kullanıcı için büyük bir hesap değişikliği algılandı. Buna parola veya e-posta adresi güncellemeleri gibi olaylar dahildir.

Firebase Admin SDK, belirli bir kullanıcı için yenileme belirteçlerini iptal etme olanağı sağlar. Ayrıca, kimlik belirteci iptalini kontrol etmek için bir API de kullanıma sunulmuştur. Bu yeteneklerle, kullanıcı oturumları üzerinde daha fazla kontrole sahip olursunuz. SDK, oturumların şüpheli durumlarda kullanılmasını önlemek için kısıtlamalar ekleme yeteneğinin yanı sıra olası belirteç hırsızlığından kurtarma mekanizması sağlar.

Yenileme belirteçlerini iptal et

Bir kullanıcı kayıp veya çalıntı bir cihaz bildirdiğinde, kullanıcının mevcut yenileme belirtecini iptal edebilirsiniz. Benzer şekilde, genel bir güvenlik açığı keşfederseniz veya geniş çaplı bir etkin belirteç sızıntısından şüphelenirseniz, tüm kullanıcıları aramak ve belirtilen proje için belirteçlerini iptal etmek için listUsers API'sini kullanabilirsiniz.

Parola sıfırlamaları ayrıca bir kullanıcının mevcut belirteçlerini de iptal eder; ancak Firebase Authentication arka ucu bu durumda iptali otomatik olarak işler. İptal sırasında, kullanıcının oturumu kapatılır ve yeniden kimlik doğrulaması istenir.

Burada, belirli bir kullanıcının yenileme belirtecini iptal etmek için Yönetici SDK'sını kullanan bir örnek uygulama verilmiştir. Yönetici SDK'sını başlatmak için kurulum sayfasındaki talimatları izleyin.

Node.js

// Revoke all refresh tokens for a specified user for whatever reason.
// Retrieve the timestamp of the revocation, in seconds since the epoch.
getAuth()
  .revokeRefreshTokens(uid)
  .then(() => {
    return getAuth().getUser(uid);
  })
  .then((userRecord) => {
    return new Date(userRecord.tokensValidAfterTime).getTime() / 1000;
  })
  .then((timestamp) => {
    console.log(`Tokens revoked at: ${timestamp}`);
  });

Java

FirebaseAuth.getInstance().revokeRefreshTokens(uid);
UserRecord user = FirebaseAuth.getInstance().getUser(uid);
// Convert to seconds as the auth_time in the token claims is in seconds too.
long revocationSecond = user.getTokensValidAfterTimestamp() / 1000;
System.out.println("Tokens revoked at: " + revocationSecond);

piton

# Revoke tokens on the backend.
auth.revoke_refresh_tokens(uid)
user = auth.get_user(uid)
# Convert to seconds as the auth_time in the token claims is in seconds.
revocation_second = user.tokens_valid_after_timestamp / 1000
print('Tokens revoked at: {0}'.format(revocation_second))

Gitmek

client, err := app.Auth(ctx)
if err != nil {
	log.Fatalf("error getting Auth client: %v\n", err)
}
if err := client.RevokeRefreshTokens(ctx, uid); err != nil {
	log.Fatalf("error revoking tokens for user: %v, %v\n", uid, err)
}
// accessing the user's TokenValidAfter
u, err := client.GetUser(ctx, uid)
if err != nil {
	log.Fatalf("error getting user %s: %v\n", uid, err)
}
timestamp := u.TokensValidAfterMillis / 1000
log.Printf("the refresh tokens were revoked at: %d (UTC seconds) ", timestamp)
auth.go

C#

await FirebaseAuth.DefaultInstance.RevokeRefreshTokensAsync(uid);
var user = await FirebaseAuth.DefaultInstance.GetUserAsync(uid);
Console.WriteLine("Tokens revoked at: " + user.TokensValidAfterTimestamp);
FirebaseAuthSnippets.cs

Kimlik belirteci iptalini algıla

Firebase Kimlik belirteçleri durumsuz JWT'ler olduğundan, yalnızca belirtecin durumunu Firebase Kimlik Doğrulaması arka ucundan talep ederek bir belirtecin iptal edildiğini belirleyebilirsiniz. Bu nedenle sunucunuzda bu kontrolü yapmak pahalı bir işlemdir ve ekstra ağ gidiş-dönüş gerektirir. Kontrolü yapmak için Yönetici SDK'sını kullanmak yerine iptali kontrol eden Firebase Güvenlik Kuralları ayarlayarak bu ağ isteğinde bulunmaktan kaçınabilirsiniz.

Firebase Güvenlik Kurallarında kimlik belirteci iptalini algıla

Güvenlik Kurallarını kullanarak kimlik belirteci iptalini tespit edebilmek için önce kullanıcıya özel bazı meta verileri saklamamız gerekir.

Firebase Realtime Database'de kullanıcıya özel meta verileri güncelleyin.

Yenileme belirteci iptal zaman damgasını kaydedin. Bu, Firebase Güvenlik Kuralları aracılığıyla kimlik belirteci iptalini izlemek için gereklidir. Bu, veritabanı içinde verimli kontrollere izin verir. Aşağıdaki kod örneklerinde, önceki bölümde elde edilen kullanıcı kimliğini ve iptal süresini kullanın.

Node.js

const metadataRef = getDatabase().ref('metadata/' + uid);
metadataRef.set({ revokeTime: utcRevocationTimeSecs }).then(() => {
  console.log('Database updated successfully.');
});

Java

DatabaseReference ref = FirebaseDatabase.getInstance().getReference("metadata/" + uid);
Map<String, Object> userData = new HashMap<>();
userData.put("revokeTime", revocationSecond);
ref.setValueAsync(userData);

piton

metadata_ref = firebase_admin.db.reference("metadata/" + uid)
metadata_ref.set({'revokeTime': revocation_second})

Firebase Güvenlik Kurallarına bir kontrol ekleyin

Bu denetimi zorlamak için, kullanıcı başına iptal süresini depolamak için istemci yazma erişimi olmayan bir kural ayarlayın. Bu, önceki örneklerde gösterildiği gibi son iptal zamanının UTC zaman damgasıyla güncellenebilir:

{
  "rules": {
    "metadata": {
      "$user_id": {
        // this could be false as it is only accessed from backend or rules.
        ".read": "$user_id === auth.uid",
        ".write": "false",
      }
    }
  }
}

Kimliği doğrulanmış erişim gerektiren tüm veriler aşağıdaki kuralın yapılandırılmış olması gerekir. Bu mantık, yalnızca kimliği doğrulanmış kullanıcıların korunan verilere erişmesine izin verir:

{
  "rules": {
    "users": {
      "$user_id": {
        ".read": "auth != null && $user_id === auth.uid && (
            !root.child('metadata').child(auth.uid).child('revokeTime').exists()
          || auth.token.auth_time > root.child('metadata').child(auth.uid).child('revokeTime').val()
        )",
        ".write": "auth != null && $user_id === auth.uid && (
            !root.child('metadata').child(auth.uid).child('revokeTime').exists()
          || auth.token.auth_time > root.child('metadata').child(auth.uid).child('revokeTime').val()
        )",
      }
    }
  }
}

SDK'da kimlik belirteci iptalini algıla.

Sunucunuzda, yenileme belirteci iptali ve kimlik belirteci doğrulaması için aşağıdaki mantığı uygulayın:

Bir kullanıcının kimlik belirteci doğrulanacaksa, ek checkRevoked boole bayrağının verifyIdToken iletilmesi gerekir. Kullanıcının belirteci iptal edilirse, kullanıcıdan istemcide oturumu kapatılmalı veya Firebase Authentication istemci SDK'ları tarafından sağlanan yeniden kimlik doğrulama API'lerini kullanarak yeniden kimlik doğrulaması yapması istenmelidir.

Platformunuz için Yönetici SDK'sını başlatmak için kurulum sayfasındaki talimatları izleyin. Kimlik belirtecini alma örnekleri verifyIdToken bölümündedir.

Node.js

// Verify the ID token while checking if the token is revoked by passing
// checkRevoked true.
let checkRevoked = true;
getAuth()
  .verifyIdToken(idToken, checkRevoked)
  .then((payload) => {
    // Token is valid.
  })
  .catch((error) => {
    if (error.code == 'auth/id-token-revoked') {
      // Token has been revoked. Inform the user to reauthenticate or signOut() the user.
    } else {
      // Token is invalid.
    }
  });

Java

try {
  // Verify the ID token while checking if the token is revoked by passing checkRevoked
  // as true.
  boolean checkRevoked = true;
  FirebaseToken decodedToken = FirebaseAuth.getInstance()
      .verifyIdToken(idToken, checkRevoked);
  // Token is valid and not revoked.
  String uid = decodedToken.getUid();
} catch (FirebaseAuthException e) {
  if (e.getAuthErrorCode() == AuthErrorCode.REVOKED_ID_TOKEN) {
    // Token has been revoked. Inform the user to re-authenticate or signOut() the user.
  } else {
    // Token is invalid.
  }
}

piton

try:
    # Verify the ID token while checking if the token is revoked by
    # passing check_revoked=True.
    decoded_token = auth.verify_id_token(id_token, check_revoked=True)
    # Token is valid and not revoked.
    uid = decoded_token['uid']
except auth.RevokedIdTokenError:
    # Token revoked, inform the user to reauthenticate or signOut().
    pass
except auth.UserDisabledError:
    # Token belongs to a disabled user record.
    pass
except auth.InvalidIdTokenError:
    # Token is invalid
    pass

Gitmek

client, err := app.Auth(ctx)
if err != nil {
	log.Fatalf("error getting Auth client: %v\n", err)
}
token, err := client.VerifyIDTokenAndCheckRevoked(ctx, idToken)
if err != nil {
	if err.Error() == "ID token has been revoked" {
		// Token is revoked. Inform the user to reauthenticate or signOut() the user.
	} else {
		// Token is invalid
	}
}
log.Printf("Verified ID token: %v\n", token)
auth.go

C#

try
{
    // Verify the ID token while checking if the token is revoked by passing checkRevoked
    // as true.
    bool checkRevoked = true;
    var decodedToken = await FirebaseAuth.DefaultInstance.VerifyIdTokenAsync(
        idToken, checkRevoked);
    // Token is valid and not revoked.
    string uid = decodedToken.Uid;
}
catch (FirebaseAuthException ex)
{
    if (ex.AuthErrorCode == AuthErrorCode.RevokedIdToken)
    {
        // Token has been revoked. Inform the user to re-authenticate or signOut() the user.
    }
    else
    {
        // Token is invalid.
    }
}
FirebaseAuthSnippets.cs

İstemcide belirteç iptaline yanıt verme

Belirteç Admin SDK aracılığıyla iptal edilirse, müşteriye iptal konusunda bilgi verilir ve kullanıcının yeniden kimlik doğrulaması yapması beklenir veya oturumu kapatılır:

function onIdTokenRevocation() {
  // For an email/password user. Prompt the user for the password again.
  let password = prompt('Please provide your password for reauthentication');
  let credential = firebase.auth.EmailAuthProvider.credential(
      firebase.auth().currentUser.email, password);
  firebase.auth().currentUser.reauthenticateWithCredential(credential)
    .then(result => {
      // User successfully reauthenticated. New ID tokens should be valid.
    })
    .catch(error => {
      // An error occurred.
    });
}

Gelişmiş Güvenlik: IP adresi kısıtlamalarını uygula

Belirteç hırsızlığını algılamak için yaygın bir güvenlik mekanizması, istek IP adresi kökenlerini takip etmektir. Örneğin, istekler her zaman aynı IP adresinden geliyorsa (aramayı yapan sunucu), tek IP adresi oturumları zorunlu kılınabilir. Veya, kullanıcının IP adresinin aniden coğrafi konumunu değiştirdiğini tespit ederseniz veya şüpheli bir kaynaktan bir istek alırsanız, bir kullanıcının belirtecini iptal edebilirsiniz.

IP adresine dayalı güvenlik kontrolleri yapmak için, kimliği doğrulanmış her istek için kimlik belirtecini inceleyin ve kısıtlı verilere erişime izin vermeden önce isteğin IP adresinin önceki güvenilir IP adresleriyle eşleşip eşleşmediğini veya güvenilir bir aralıkta olup olmadığını kontrol edin. Örneğin:

app.post('/getRestrictedData', (req, res) => {
  // Get the ID token passed.
  const idToken = req.body.idToken;
  // Verify the ID token, check if revoked and decode its payload.
  admin.auth().verifyIdToken(idToken, true).then((claims) => {
    // Get the user's previous IP addresses, previously saved.
    return getPreviousUserIpAddresses(claims.sub);
  }).then(previousIpAddresses => {
    // Get the request IP address.
    const requestIpAddress = req.connection.remoteAddress;
    // Check if the request IP address origin is suspicious relative to previous
    // IP addresses. The current request timestamp and the auth_time of the ID
    // token can provide additional signals of abuse especially if the IP address
    // suddenly changed. If there was a sudden location change in a
    // short period of time, then it will give stronger signals of possible abuse.
    if (!isValidIpAddress(previousIpAddresses, requestIpAddress)) {
      // Invalid IP address, take action quickly and revoke all user's refresh tokens.
      revokeUserTokens(claims.uid).then(() => {
        res.status(401).send({error: 'Unauthorized access. Please login again!'});
      }, error => {
        res.status(401).send({error: 'Unauthorized access. Please login again!'});
      });
    } else {
      // Access is valid. Try to return data.
      getData(claims).then(data => {
        res.end(JSON.stringify(data);
      }, error => {
        res.status(500).send({ error: 'Server error!' })
      });
    }
  });
});