본문으로 건너뛰기
· backend · 6분 읽기

웹 인증과 인가: Basic Auth부터 Passkey까지

웹 서비스를 만들면 가장 먼저 부딪히는 문제가 있다. “이 요청을 보낸 사람이 누구인지 어떻게 알지?” 그리고 바로 뒤따르는 질문. “이 사람이 이 작업을 해도 되는 건지 어떻게 판단하지?”

이 두 질문이 바로 인증(Authentication)과 인가(Authorization)다. 비슷해 보이지만 완전히 다른 문제이고, 혼동하면 보안 구멍이 생긴다. 두 개념의 차이부터 시작해서, 웹에서 쓰이는 주요 인증/인가 방식을 코드와 함께 정리해봤다.

인증 vs 인가

인증(Authentication)은 신원 확인이다. 공항에서 여권을 보여주는 것과 같다. “이 사람이 사용자 A가 맞는가?”

인가(Authorization)는 권한 확인이다. 비행기 탑승구에서 보딩패스를 보여주는 것과 같다. “이 사람이 이 비행기에 탈 수 있는가?”

HTTP 응답 코드로 보면 명확하다.

  • 401 Unauthorized: 인증 실패. 누군지 모르겠다. 로그인부터 해라.
  • 403 Forbidden: 서버가 요청을 이해했지만 수행을 거절한다. 인증된 사용자의 권한 부족이 한 사례이며, 항상 사용자 신원을 안다는 뜻은 아니다.

이름이 헷갈리는데, 401의 이름이 “Unauthorized”인 건 HTTP 스펙의 역사적 실수에 가깝다. 실제로는 “Unauthenticated”가 더 정확하다.

인증된 사용자에게 권한을 검사하는 흐름이 흔하지만, 공개 자원이나 익명 사용자에 대한 인가 정책도 가능하다.

Basic Auth & Digest Auth

Basic Auth

HTTP 인증의 가장 원시적인 형태다. 사용자 ID와 비밀번호를 Base64로 인코딩해서 매 요청마다 보낸다.

typescript
// Basic Auth 헤더 구성
const username = "admin";
const password = "secret123";
const credentials = btoa(`${username}:${password}`);

const response = await fetch("https://api.example.com/users", {
  headers: {
    Authorization: `Basic ${credentials}`,
  },
});

Base64는 인코딩이지 암호화가 아니다. atob()으로 누구나 원문을 복원할 수 있다. HTTPS 없이 Basic Auth를 쓰면 비밀번호가 평문으로 돌아다니는 것과 같다.

Digest Auth

Basic Auth의 보안 문제를 개선한 방식이다. 비밀번호를 직접 전송하지 않고, 해시값을 보낸다.

서버의 nonce와 요청 정보, 자격 증명에서 계산한 해시 응답을 보낸다. 과거 MD5 방식 외에 RFC 7616은 SHA-256 등을 정의한다. Digest도 TLS를 대체하지 않으며 약한 비밀번호와 구현·호환성 문제를 고려해야 한다. Basic 역시 TLS와 적절한 자격 증명 관리가 전제다.

API Key

API Key는 사용자가 아닌 ‘앱이나 서비스를 식별’하는 방식이다.

typescript
// API Key를 헤더에 포함
const response = await fetch("https://api.example.com/forecast", {
  headers: {
    "X-API-Key": "sk-abc123def456",
  },
});

구글 맵 API, 스트라이프 결제 API 같은 B2B 연동에서 주로 쓴다. 발급받은 키를 요청에 넣으면 서버가 “이 요청은 어느 서비스에서 온 건지” 식별한다.

다만 주의할 게 있다.

  • 비밀 API Key는 프론트엔드에 넣지 않는다. 제공자가 공개용으로 설계한 키는 허용 origin과 권한 등 해당 제품의 제한 정책을 따른다.
  • 키가 유출되면 즉시 재발급해야 한다. 비밀번호처럼 로테이션 정책이 필요하다.
  • API Key는 “누가 호출했는가”를 식별하지만, “그 사람이 누구인가”를 인증하지는 않는다.

비밀 API Key는 보유자를 인증하는 자격 증명으로 쓰일 수 있다. 다만 그것만으로 호출한 최종 사용자의 신원을 증명하지는 않는다.

세션 기반 인증

웹에서 가장 오래되고 직관적인 인증 방식이다. 흐름은 단순하다.

  1. 사용자가 ID/PW로 로그인한다
  2. 서버가 세션을 생성하고 세션 ID를 발급한다
  3. 세션 ID를 쿠키에 담아 브라우저에 보낸다
  4. 이후 요청마다 브라우저가 쿠키를 자동으로 전송한다
  5. 서버가 세션 ID로 사용자를 식별한다
typescript
import express from "express";
import session from "express-session";

const app = express();
app.use(express.json());

app.use(
  session({
    secret: process.env.SESSION_SECRET!, // 시작 시 존재 여부와 충분한 엔트로피 검사
    resave: false,
    saveUninitialized: false,
    cookie: {
      httpOnly: true,
      secure: true,
      sameSite: "lax",
      maxAge: 1000 * 60 * 60 * 24, // 1일
    },
  })
);

app.post("/login", (req, res, next) => {
  const { username, password } = req.body;
  const user = authenticate(username, password);

  if (user) {
    req.session.regenerate((err) => {
      if (err) return next(err);
      req.session.userId = user.id;
      req.session.save((err) => {
        if (err) return next(err);
        res.json({ message: "로그인 성공" });
      });
    });
  } else {
    res.status(401).json({ message: "인증 실패" });
  }
});

app.get("/profile", (req, res) => {
  if (!req.session.userId) {
    return res.status(401).json({ message: "로그인 필요" });
  }
  const user = findUser(req.session.userId);
  res.json(user);
});

이 코드는 동기식 authenticate와 findUser를 가정한 흐름 예제다. TypeScript에서는 SessionData의 userId 타입을 확장해야 한다. 운영에서는 기본 MemoryStore 대신 외부 저장소를 설정하고, HTTPS 프록시 구성에 맞게 trust proxy를 제한한다. 로그인 시 세션 ID를 재발급해 세션 고정을 방지한다.

쿠키 옵션의 역할은 다음과 같다.

옵션역할
httpOnlyJavaScript의 쿠키 직접 읽기 차단. XSS 자체를 막지는 않음
secureHTTPS에서만 쿠키 전송
sameSite: "strict"다른 사이트에서 보내는 요청에 쿠키 미포함. CSRF 방어
sameSite: "lax"크로스 사이트 최상위 탐색의 안전한 메서드 등에 쿠키 허용. 같은 사이트의 POST는 차단하지 않음
sameSite: "none"크로스 사이트 허용. secure 필수

세션 기반 인증의 가장 큰 한계는 서버가 상태를 가진다는 점이다. 서버가 한 대일 때는 문제 없지만, 서버를 여러 대 띄우면 세션을 공유해야 한다. Redis 같은 외부 저장소를 세션 스토어로 쓰는 게 일반적이다.

모바일 앱에서도 쿠키 관리가 번거롭다. 그래서 나온 게 토큰 기반 인증이다.

JWT (JSON Web Token)

JWT는 클레임을 표현하는 토큰 형식이다. 서명한 JWT를 로컬 검증하는 인증 구조에 사용할 수 있지만, 폐기·세션 상태를 서버에서 관리하는 구현도 가능하다.

아래는 서명된 JWS Compact 형식이며 세 부분을 점(.)으로 구분한다. 암호화된 JWE 형식과는 구별한다.

eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0In0.signature
|--- Header ---|--- Payload ---|--- Signature ---|
  • Header: 서명 알고리즘 (HS256, RS256 등)
  • Payload: 사용자 정보 (sub, exp, iat 등의 클레임)
  • Signature: Header + Payload를 비밀키로 서명한 값
typescript
import jwt from "jsonwebtoken";

const SECRET = process.env.JWT_SECRET!; // 시작 시 강한 비밀키 검증

// JWT 생성
function createToken(userId: string): string {
  return jwt.sign(
    { sub: userId },
    SECRET,
    { expiresIn: "1h", algorithm: "HS256", issuer: "https://auth.example.com", audience: "sample-api" }
  );
}

// JWT 검증
function verifyToken(token: string) {
  try {
    const payload = jwt.verify(token, SECRET, { algorithms: ["HS256"], issuer: "https://auth.example.com", audience: "sample-api" });
    return payload;
  } catch (err) {
    return null; // 만료되었거나 위변조된 토큰
  }
}

// 미들웨어에서 사용
function authMiddleware(req, res, next) {
  const authHeader = req.headers.authorization;
  if (!authHeader?.startsWith("Bearer ")) {
    return res.status(401).json({ message: "토큰 없음" });
  }

  const token = authHeader.split(" ")[1];
  const payload = verifyToken(token);

  if (!payload) {
    return res.status(401).json({ message: "유효하지 않은 토큰" });
  }

  req.user = payload;
  next();
}

JWT에 대해 가장 흔한 오해가 하나 있다. 이 예제의 서명된 JWT는 암호화되지 않는다. Payload는 Base64URL로 인코딩된 것일 뿐, 누구나 디코딩해서 내용을 볼 수 있다. 서명 검증이 확인하는 건 서명 키에 대한 무결성, 즉 “이 토큰이 위변조되지 않았다”는 것뿐이다. 민감한 정보(비밀번호, 카드번호)를 Payload에 넣으면 안 된다.

Access Token & Refresh Token

JWT를 실제 서비스에 적용하면 바로 딜레마에 부딪힌다. 토큰 유효기간을 길게 잡으면 보안 위험이 커지고, 짧게 잡으면 사용자가 자주 로그인해야 한다.

Access Token과 Refresh Token을 나눠서 쓰는 패턴이 이걸 해결한다.

  • Access Token. API 호출에 사용. 유효기간이 짧다 (15분~1시간).
  • Refresh Token. Access Token 재발급용. 유효기간이 길다 (7일~30일).
로그인 → 세션과 refresh token 식별자 저장 → access/refresh 발급
갱신 → refresh 검증 → 저장된 활성 상태·만료 확인
     → 이전 refresh 폐기 + 새 refresh 저장을 원자적으로 수행
     → 새 access/refresh 반환
재사용 감지 → 해당 세션 또는 token family 폐기 정책 적용

이는 상태 전이의 개요다. 중복 갱신 요청, 응답 유실, 재사용 감지와 쿠키·CSRF 처리를 포함한 구현이 별도로 필요하다. 공개 클라이언트는 refresh token 회전 또는 송신자 결합 방식으로 재전송 공격을 다뤄야 한다.

저장 위치가 중요하다.

  • Access Token은 클라이언트 메모리(JavaScript 변수)에 저장한다. localStorage에 넣으면 XSS로 탈취될 수 있다.
  • Refresh Token은 HttpOnly 쿠키에 저장한다. JavaScript로 쿠키를 직접 읽지는 못하지만 XSS가 인증된 요청을 보내는 것까지 막지는 못한다.

실무에서는 Refresh Token을 그대로 재사용하게 두면 안 된다. 재발급할 때마다 새 Refresh Token으로 교체하고, 이전 토큰은 폐기한다. 유출됐을 때 피해 범위를 줄이기 위해서다. 쿠키 기반으로 /refresh를 호출한다면 CSRF 방어도 같이 봐야 한다. SameSite만 믿지 말고 CSRF 토큰이나 origin 검증을 붙이는 편이 안전하다.

Access Token이 만료되면 클라이언트가 /refresh 엔드포인트를 호출해서 새 Access Token을 받는다. 사용자는 로그인을 다시 할 필요가 없다. Refresh Token까지 만료되면 그때 재로그인이 필요하다.

Passkey

비밀번호의 근본적 문제는 “사람이 관리해야 한다”는 점이다. 기억하기 어렵고, 재사용하고, 피싱에 당한다. Passkey는 비밀번호 자체를 없애는 방향으로 접근한다.

Passkey는 공개키 암호화(Public Key Cryptography) 기반이다.

  1. 등록 시: 기기가 공개키/비밀키 쌍을 생성한다. 비밀키는 인증기 또는 Passkey 제공자가 관리하고, 공개키를 서버에 보낸다.
  2. 로그인 시: 서버가 챌린지(랜덤 값)를 보내면, 기기가 비밀키로 서명해서 응답한다.
  3. 서버가 공개키로 서명을 검증한다. 검증되면 로그인 성공.

기기 종속 자격 증명과 여러 기기로 동기화되는 자격 증명이 있다. 후자는 제공자의 보호된 동기화 경로로 키가 복제될 수 있다. 생체인증이나 PIN은 키 사용을 승인하는 수단이다. 서버는 서명 외에도 challenge, origin, RP ID와 사용자 검증 정책을 확인한다.

비밀번호랑 비교해보면 차이가 크다.

비밀번호Passkey
피싱가짜 사이트에 입력 가능RP ID·origin 결합으로 피싱에 저항
유출서버 DB 해킹 시 위험공개키 유출만으로 로그인 서명 불가. 계정 데이터 침해는 별도 위험
재사용여러 사이트에 같은 비밀번호사이트마다 고유 키 쌍 생성
사용성기억해야 함생체인증으로 한 번에 처리

아직 모든 서비스에서 지원하는 건 아니지만, 구글, 애플, 마이크로소프트가 적극적으로 밀고 있다. 비밀번호를 대체하는 방향으로 가고 있다.

OAuth2 & OIDC

OAuth2: 권한 위임

“구글 계정으로 로그인” 버튼을 눌러본 적이 있을 것이다. 이 뒤에서 동작하는 게 OAuth2다.

OAuth2는 인증 프로토콜이 아니라 인가(권한 위임) 프레임워크다. “이 앱이 내 구글 캘린더를 읽어도 된다”처럼, 제3자에게 특정 권한을 위임하는 표준이다.

가장 많이 쓰이는 Authorization Code 흐름은 이렇다.

  1. 사용자가 “구글로 로그인” 클릭
  2. 구글 로그인 페이지로 리다이렉트
  3. 사용자가 동의(이메일, 프로필 정보 접근 등)
  4. 구글이 인가 코드(Authorization Code)를 콜백 URL로 전달
  5. 서버가 인가 코드를 구글에 보내서 Access Token으로 교환
  6. Access Token으로 구글 API(사용자 정보 등)를 호출

Google의 openid scope를 요청한다면 아래 흐름은 OIDC 로그인에 해당한다. 직접 HTTP 요청 몇 개를 연결하는 예제 대신 필요한 검증 절차를 정리한다.

로그인 시작
  → state, nonce, PKCE verifier 생성
  → 브라우저 세션에 결합해 짧은 만료 시간으로 보관
  → S256 challenge와 함께 인가 요청
콜백
  → 오류·code·state의 형식과 세션 일치·만료 검사
  → 해당 요청 정보를 일회성으로 소비
  → 같은 redirect URI와 verifier로 code 교환
  → 토큰 응답의 HTTP 상태와 필수 필드 검사
  → ID Token의 서명·alg·iss·aud·exp·nonce 검사
  → issuer + sub로 내부 계정 식별
  → 세션 ID 재발급 후 로그인 상태 저장

전역 state 목록에 존재하는지만 확인하면 로그인 요청을 시작한 브라우저와 결합되지 않는다. 서버 측 세션 저장소나 동등한 방식으로 결합하고, 검증된 OIDC 클라이언트 라이브러리를 사용한다. 이메일 문자열만으로 기존 계정을 자동 연결하지 않는다.

동의 화면에서 요구하는 정보 범위를 Scope라고 한다. email, profile, calendar.readonly 같은 것들이다. 사용자는 어떤 정보를 공유할지 직접 선택할 수 있다.

OIDC: OAuth2 + 인증

OAuth2 자체는 “이 토큰으로 API를 호출할 수 있다”는 인가만 담당한다. “이 사람이 누구인지”를 알려주는 표준이 없다.

OIDC(OpenID Connect)는 OAuth2 위에 인증 레이어를 추가한 확장이다. Access Token 외에 ID Token(JWT 형식)을 추가로 발급한다.

ID Token에는 사용자 정보(sub, email, name 등)가 들어있다. 서버가 구글 API를 따로 호출하지 않아도 ID Token만 검증하면 사용자를 식별할 수 있다.

검증에서는 제공자의 discovery/JWKS를 사용하고 허용 알고리즘을 제한한다. iss, aud, exp 등 필수 클레임과 요청 때 저장한 nonce를 확인한다. aud가 여러 값인 경우 azp 등 OIDC의 추가 조건도 적용한다. 단순 디코딩이나 서명 확인만으로 로그인 검증을 끝내지 않는다.

차이를 표로 보면 바로 보인다.

OAuth2OIDC
목적권한 위임 (인가)사용자 인증 + 권한 위임
발급 토큰Access TokenAccess Token + ID Token
사용자 정보API 호출 필요ID Token에 포함

소셜 로그인은 OIDC 또는 제공자별 OAuth 사용자 정보 API로 구현된다. 모든 소셜 로그인이 OIDC인 것은 아니다. OAuth2 자체는 최종 사용자 신원을 전달하는 공통 인증 계약을 정의하지 않는다.

SSO & Keycloak

SSO (Single Sign-On)

SSO는 연동된 서비스에서 반복 인증을 줄이는 방식이다. 각 서비스의 접근 권한은 별도 정책으로 검사한다. 구글 계정 하나로 Gmail, YouTube, Google Drive에 전부 로그인되는 것이 대표적인 예다.

SSO를 구현하는 표준은 두 가지가 있다.

SAMLOIDC
등장2005년2014년
포맷XMLJSON
토큰SAML AssertionJWT (ID Token)
주 사용처엔터프라이즈웹/모바일
복잡도높다상대적으로 낮다

새 프로젝트라면 OIDC를 선택하는 게 합리적이다. SAML은 레거시 엔터프라이즈 시스템과 연동할 때 어쩔 수 없이 쓰게 된다.

Keycloak

Keycloak은 오픈소스 인증/인가 서버다. 직접 인증 시스템을 구축하는 대신, Keycloak이 이 모든 걸 처리한다.

  • 소셜 로그인 (Google, GitHub, Apple 등)
  • SSO (OIDC, SAML)
  • MFA (다중 인증)
  • JWT 발급 및 검증
  • 사용자 관리 콘솔
  • 역할 기반 접근 제어 (RBAC)

인증 시스템을 직접 만드는 건 생각보다 범위가 넓다. 로그인/로그아웃, 비밀번호 재설정, 이메일 인증, 소셜 로그인, 토큰 관리, 세션 관리, 보안 정책… 이걸 전부 직접 구현하면 핵심 비즈니스 로직에 쓸 시간이 줄어든다.

Keycloak 같은 전용 솔루션을 두고 앱 서버는 토큰 검증과 자원별 인가를 수행하는 구조가 실무에서는 훨씬 현실적이다. 인증이라는 관심사를 별도 서비스로 분리하는 셈이다.

전체 흐름 정리

방식용도상태 관리현재 권장
Basic/Digest AuthHTTP 기본 인증없음 (매 요청 전송)레거시
API Key앱/서비스 식별없음B2B 연동 시
세션웹 로그인서버 (stateful)전통적 웹
JWT클레임 전달 형식폐기·세션 정책에 따라 달라짐인증 설계의 한 구성 요소
Passkey차세대 로그인기기 (비밀키)점진적 도입
OAuth2/OIDC소셜 로그인, SSO인증 서버표준

뭘 쓸지는 서비스 성격에 따라 다르다. 전통적인 서버 렌더링 웹이라면 세션이 가장 간단하다. SPA나 모바일 앱이라면 JWT. 여러 서비스를 운영한다면 OAuth2/OIDC 기반 SSO. 그리고 이 모든 걸 직접 구현하기보다는, Keycloak이나 Auth0 같은 검증된 솔루션 위에서 시작하는 게 현실적이다.

보안은 직접 만들수록 구멍이 생기기 쉽다. 검증된 도구를 쓰되, 내부 동작은 이해하고 있어야 문제가 생겼을 때 대응할 수 있다.

참고 자료

공유하기 X LinkedIn

관련 글