管理用户会话

Firebase 身份验证会话的有效期很长。每当用户登录时，系统会将用户凭据发送到 Firebase 身份验证后端，用以交换 Firebase ID 令牌 (JWT) 和刷新令牌。Firebase ID 令牌只在一小时内有效；刷新令牌可以用来获取新的 ID 令牌。只有出现以下任一情况时，刷新令牌才会过期：

• 用户被删除
• 用户被停用
• 检测到用户帐号出现重大变化，例如密码或电子邮件地址更新等事件。

Firebase Admin SDK 允许撤消指定用户的刷新令牌。此外，我们还提供了一个用来检查 ID 令牌撤消情况的 API。借助这些功能，您可以更好地控制用户会话。该 SDK 还允许您添加限制以防止会话被用于可疑情况，并提供了恢复机制来应对可能的令牌失窃问题。

撤消刷新令牌

当用户报告设备丢失或被盗时，您可以撤消该用户现有的刷新令牌。同样，如果您发现普遍性的漏洞或怀疑有大量有效令牌泄露，可以使用 listUsers API 来查看所有用户并撤消他们用于指定项目的令牌。

重设密码也会撤消用户的现有令牌；但在这种情况下，Firebase 身份验证后端会自动处理此类撤消。撤消令牌后，系统会使用户退出登录并提示用户重新进行身份验证。

以下是使用 Admin SDK 撤消某个指定用户的刷新令牌的一个实现代码示例。 要初始化 Admin SDK，请按照设置页面上的说明进行操作。

Node.js

// Revoke all refresh tokens for a specified user for whatever reason.
// Retrieve the timestamp of the revocation, in seconds since the epoch.
admin.auth().revokeRefreshTokens(uid)
  .then(() => {
    return admin.auth().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);

Python

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

Go

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

检测 ID 令牌撤消

由于 Firebase ID 令牌是无状态的 JWT，您只能通过从 Firebase 身份验证后端请求该令牌的状态来确定令牌是否已撤消。因此，在服务器上执行此类检查是一项代价很高的操作，需要额外的网络往返。您可以设置用于检查撤消的 Firebase 规则，而不使用 Admin SDK 进行此类检查，从而避免发出上述网络请求。

通过数据库规则检测 ID 令牌撤消

为了能够使用数据库规则来检测 ID 令牌撤消，我们必须首先存储一些专门针对特定用户的元数据。

在 Firebase 实时数据库中更新专门针对特定用户的元数据。

保存刷新令牌的撤消时间戳。在通过 Firebase 规则来跟踪 ID 令牌撤消时需要此时间戳。通过它可以在数据库内进行高效的检查。在下面的代码示例中，使用在上一部分中获得的 uid 和撤消时间。

Node.js

const metadataRef = admin.database().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);

Python

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

将检查添加到数据库规则

要执行此检查，请设置一条没有客户端写入权限的规则，按用户存储撤消时间。如上文示例所示，您可以使用上次撤消的世界协调时间 (UTC) 时间戳进行更新：

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

任何需要通过身份验证才能访问的数据都必须配置以下规则。此逻辑仅允许持有未撤消的 ID 令牌且通过身份验证的用户访问受保护的数据：

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

通过 SDK 检测 ID 令牌撤消。

在您的服务器中，针对刷新令牌撤消和 ID 令牌验证实现以下逻辑：

用户的 ID 令牌若要通过验证，必须将额外的 checkRevoked 布尔型标记传递给 verifyIdToken。如果用户的令牌被撤消，用户会在客户端上被退出登录，或被要求使用 Firebase 身份验证客户端 SDK 提供的重新验证 API 重新进行身份验证。

要针对您的平台初始化 Admin SDK，请按照设置页面上的说明进行操作。verifyIdToken 部分中介绍了检索 ID 令牌的几个示例。

Node.js

// Verify the ID token while checking if the token is revoked by passing
// checkRevoked true.
let checkRevoked = true;
admin.auth().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.getErrorCode().equals("id-token-revoked")) {
    // Token has been revoked. Inform the user to re-authenticate or signOut() the user.
  } else {
    // Token is invalid.
  }
}

Python

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.AuthError as exc:
    if exc.code == 'ID_TOKEN_REVOKED':
        # Token revoked, inform the user to reauthenticate or signOut().
        pass
    else:
        # Token is invalid
        pass

Go

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

在客户端上响应令牌撤消

如果令牌已通过 Admin SDK 撤消，客户端会收到撤消通知，并且用户应该要重新进行身份验证或被退出登录：

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

高级安全措施：实施 IP 地址限制

一种检测令牌失窃的常见安全机制是跟踪请求 IP 地址的来源。例如，如果请求始终来自同一 IP 地址（发出请求的服务器），则可实施单一 IP 地址会话。或者，如果您检测到用户的 IP 地址突然改变了地理定位，或者收到来自可疑来源的请求，则可以撤消相关用户的令牌。

要基于 IP 地址执行安全检查，请针对通过身份验证的每一次请求检查 ID 令牌，并检查发出请求的 IP 地址是否与之前的可信 IP 地址相符或在可信范围之内，然后再决定是否允许访问受限数据。例如：

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