Session ManagementSession Management

phiên đang hoạt độngactive sessions

1.2M

phiên đang hoạt độngactive sessions

thiết bị trung bình mỗi người dùngdevices per user on average

2–5

thiết bị trung bình mỗi người dùngdevices per user on average

từ lúc thu hồi tới khi thiết bị bị chặnfrom revocation to the device being blocked

< 1s

từ lúc thu hồi tới khi thiết bị bị chặnfrom revocation to the device being blocked

idle timeout / absolute timeoutidle timeout / absolute timeout

30 phút / 30 ngày

idle timeout / absolute timeoutidle timeout / absolute timeout

Mỗi lần đăng nhập tạo một dòng user_session; access token và refresh token đều mang sid của dòng đó. Gateway kiểm tra JWT rồi tra revoked:{sid} trong Redis. Session Service quản lý danh sách, thu hồi và giới hạn phiên, phát sự kiện cho bộ gửi cảnh báo. Bật “Vượt giới hạn 2 phiên” để xem phiên cũ nhất bị đẩy ra, “Hết idle timeout” để xem phiên hết hạn vì không dùng.Each sign-in creates a user_session row; both the access and refresh tokens carry its sid. The gateway verifies the JWT, then looks up revoked:{sid} in Redis. The session service handles listing, revocation and limits, and publishes events for the security notifier. Turn on “Over the 2-session limit” to see the oldest session evicted, and “Idle timeout” to see a session expire from inactivity.

1. 1

   JWT stateless thì thu hồi bằng cách nàoHow to revoke a stateless JWT

   Đặt sid vào claim của access token. Khi thu hồi, ghi revoked:{sid} vào Redis với TTL bằng thời hạn tối đa của access token (15 phút). Gateway chỉ tốn một lệnh EXISTS mỗi request; deny list luôn nhỏ vì tự hết hạn.Put the sid in the access token's claims. On revocation, write revoked:{sid} to Redis with a TTL equal to the maximum access token lifetime (15 minutes). The gateway pays one EXISTS per request, and the deny list stays small because entries expire.

   Proxy
2. 2

   Hai lần đăng nhập cùng lúc vượt giới hạnTwo simultaneous sign-ins beat the limit

   Đếm rồi chèn là check-then-act: hai request cùng thấy 1 phiên và cùng chèn. Khoá dòng app_user bằng SELECT … FOR UPDATE trước khi đếm, hoặc làm cả bước đếm, đẩy ra và chèn trong một Lua script nếu phiên nằm trong Redis.Count-then-insert is check-then-act: two requests both see one session and both insert. Lock the app_user row with SELECT … FOR UPDATE before counting, or run count, evict and insert as one Lua script when sessions live in Redis.

   Repository
3. 3

   Session fixationSession fixation

   Kẻ tấn công cài sẵn một session id cho nạn nhân rồi chờ nạn nhân đăng nhập. Luôn cấp sid mới tại thời điểm xác thực thành công và khi nâng quyền (bật MFA, đổi mật khẩu). Spring Security mặc định gọi changeSessionId(); ở Go phải tự sinh sid mới.An attacker plants a session id on the victim and waits for them to sign in. Always issue a new sid on successful authentication and on privilege changes (MFA enabled, password changed). Spring Security calls changeSessionId() by default; in Go you generate a new sid yourself.

   Strategy
4. 4

   Cập nhật last_seen mỗi requestUpdating last_seen on every request

   Ở 5.000 rps, mỗi request một UPDATE sẽ làm nghẽn Postgres. Chỉ ghi khi giá trị cũ quá 5 phút (SET last_seen:{sid} NX EX 300 làm cổng chặn), hoặc gom vào Redis rồi flush theo lô mỗi phút.At 5,000 rps, one UPDATE per request chokes Postgres. Write only when the stored value is over 5 minutes old (SET last_seen:{sid} NX EX 300 as a gate), or buffer in Redis and flush in batches every minute.

   Decorator
5. 5

   Idle timeout và absolute timeoutIdle versus absolute timeout

   Idle timeout (15–30 phút với ứng dụng nhạy cảm) đóng phiên không dùng; absolute timeout (8 giờ đến 30 ngày) đóng phiên dù vẫn hoạt động, để token bị lộ không sống mãi. Kiểm tra cả hai ở bước refresh; với session trong Redis thì idle chính là TTL được gia hạn mỗi request. Một decorator bọc handler gia hạn TTL đó mà không đụng code nghiệp vụ.An idle timeout (15–30 minutes for sensitive apps) closes unused sessions; an absolute timeout (8 hours to 30 days) closes sessions even while active, so a leaked token cannot live forever. Check both at refresh; with Redis sessions, idle is simply the TTL extended on each request. A handler decorator can extend that TTL without touching business code.

   Decorator
6. 6

   “Đăng xuất khỏi mọi thiết bị”“Sign out everywhere”

   Thu hồi mọi phiên của user trừ phiên hiện tại, đưa từng sid vào deny list. Khi đổi mật khẩu thì tăng app_user.token_version; token mang version cũ bị từ chối ở bước refresh mà không cần liệt kê từng phiên.Revoke every session of the user except the current one and put each sid on the deny list. On password change, bump app_user.token_version; tokens with an older version are refused at refresh without listing sessions.

   Repository
7. 7

   Báo cho các bên khi phiên thay đổiTelling others when sessions change

   Phát session.opened và session.revoked sau commit. Notifier gửi email thiết bị mới, WebSocket gateway ngắt kết nối của sid bị thu hồi, audit ghi lịch sử. Session Service không phải biết các bên này tồn tại.Publish session.opened and session.revoked after commit. The notifier emails about new devices, the WebSocket gateway drops connections for the revoked sid, audit records history. The session service does not need to know any of them exist.

   Observer

Mở phiên mới có giới hạn số phiên: khoá user, đẩy phiên ít dùng nhất, chèn phiên mới. Deny list và sự kiện chỉ chạy sau khi commit.Opening a session with a limit: lock the user, evict the least recently used session, insert the new one. The deny list and events run only after commit.

@Service
@RequiredArgsConstructor
public class SessionService {
    private final UserRepository users;
    private final UserSessionRepository sessions;
    private final ApplicationEventPublisher events;

    @Transactional
    public UserSession open(long userId, DeviceInfo device) {
        AppUser user = users.lockById(userId);              // SELECT … FOR UPDATE1
        List<UserSession> active = sessions.findActiveByLastSeenAsc(userId);
        int excess = active.size() - user.getMaxSessions() + 1;2
        for (int i = 0; i < excess; i++) {
            revoke(active.get(i), RevokeReason.LIMIT);
        }
        UserSession s = sessions.save(UserSession.open(userId, device));
        events.publishEvent(new SessionOpened(s.getId(), userId, device));
        return s;
    }

    @Transactional
    public void revokeOthers(long userId, String currentSid) {
        sessions.findActiveByLastSeenAsc(userId).stream()
                .filter(s -> !s.getId().equals(currentSid))
                .forEach(s -> revoke(s, RevokeReason.LOGOUT_ALL));
    }

    private void revoke(UserSession s, RevokeReason reason) {
        s.revoke(reason, Instant.now());                    // + its refresh tokens
        events.publishEvent(new SessionRevoked(s.getId(), s.getUserId(), reason));
    }
}

@Component
@RequiredArgsConstructor
class DenyListOnSessionRevoked {
    private final StringRedisTemplate redis;

    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)3
    void on(SessionRevoked e) {
        redis.opsForValue().set("revoked:" + e.sid(), e.reason().name(), Duration.ofMinutes(15));4
    }
}

type SessionService struct {
	tx     TxRunner
	redis  *redis.Client
	events Publisher
}

func (s *SessionService) Open(ctx context.Context, userID int64, d Device) (Session, error) {
	var opened Session
	var evicted []Session
	err := s.tx.Do(ctx, func(tx Tx) error {
		user, err := tx.LockUser(ctx, userID) // SELECT … FOR UPDATE1
		if err != nil {
			return err
		}
		active, err := tx.ActiveSessionsByLastSeen(ctx, userID)
		if err != nil {
			return err
		}
		for i := 0; i < len(active)-user.MaxSessions+1; i++ {2
			if err := tx.RevokeSession(ctx, active[i].ID, ReasonLimit); err != nil {
				return err
			}
			evicted = append(evicted, active[i])
		}
		opened, err = tx.InsertSession(ctx, NewSession(userID, d))
		return err
	})
	if err != nil {
		return Session{}, err
	}
	for _, e := range evicted { // only after commit3
		s.redis.Set(ctx, "revoked:"+e.ID, string(ReasonLimit), 15*time.Minute)
		s.events.Publish(ctx, SessionRevoked{SID: e.ID, UserID: userID, Reason: ReasonLimit})
	}
	s.events.Publish(ctx, SessionOpened{SID: opened.ID, UserID: userID, Device: d})
	return opened, nil
}

// Gateway middleware: one EXISTS per request.
func RequireLiveSession(rdb *redis.Client, next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		sid := ClaimsFrom(r.Context()).SID
		if n, err := rdb.Exists(r.Context(), "revoked:"+sid).Result(); err != nil || n > 0 {4
			http.Error(w, "session_revoked", http.StatusUnauthorized)
			return
		}
		next.ServeHTTP(w, r)
	})
}

Mỗi pattern mở bài học tương ứng trong menu Pattern.Each one opens its lesson in the Patterns menu.