제가 공부한 내용을 정리하는 블로그입니다. 아직 많이 부족하고 배울게 너무나도 많습니다. 틀린내용이 있으면 언제나 가감없이 말씀해주시면 감사하겠습니다😁
스프링부트와 리액트를 활용해 로그인을 구현 프로젝트를 진행합니다. 순서는 1. 프로젝트 초기화 2. 쿠키를 이용한 로그인 구현 3. 세션을 이용한 로그인 구현 4. JWT 토큰을 활용한 로그인 구현 입니다.
네번째는 Security 이론입니다.
Spring Security란
스프링 보안은 강력하고 고도로 사용자 지정 가능한 인증 및 액세스 제어 프레임워크입니다. 스프링 기반 애플리케이션을 보호하기 위한 사실상의 표준입니다.
Spring Security는 Java 애플리케이션에 인증과 권한 부여를 모두 제공하는 데 중점을 둔 프레임워크입니다. 모든 Spring 프로젝트와 마찬가지로 Spring Security의 진정한 힘은 사용자 지정 요구 사항을 충족하기 위해 얼마나 쉽게 확장할 수 있는지에서 찾을 수 있습니다 - Spring Security 공식 docs
Spring Security는 Spring 기반 애플리케이션의 인증, 권한관리 그리고 데이터 보호기능을 포함하는 프레임워크입니다. 인증(Authentication), 권한 부여(Authorization), 데이터 보호 등의 기능을 제공하여 애플리케이션의 보안 요구 사항을 쉽게 해결할 수 있도록 돕습니다. 특히 웹 애플리케이션의 다양한 보안 위협(CSRF, XSS 등)을 방어하고, 사용자가 인증된 상태에서 적절한 리소스 접근 권한을 갖도록 제어합니다.
Spring Security의 핵심 역할은 다음과 같습니다:
사용자가 누구인지 확인(인증)
사용자가 무엇을 할 수 있는지 결정(권한 부여)
웹 애플리케이션의 데이터를 안전하게 보호
Spring Security를 사용하는 이유
보안 위협 방어
Spring Security는 CSRF(Cross-Site Request Forgery), XSS(Cross-Site Scripting), 세션 고정 공격(Session Fixation) 등 다양한 보안 위협에 대한 기본 방어 기능을 제공합니다.
인증과 권한 관리의 편의성
기본적으로 제공되는 인증 및 권한 부여 로직을 활용하거나, 커스터마이징하여 복잡한 보안 요구 사항을 구현할 수 있습니다.
손쉬운 통합
Spring Security는 Spring Framework 및 Spring Boot와 자연스럽게 통합되며, 설정과 구성이 간단합니다.
확장성과 커스터마이징
사용자 정의 인증, 권한 정책, 필터 등을 구현하여 프로젝트 요구 사항에 맞는 보안 구조를 설계할 수 있습니다.
IoC/DI 패턴과 같은 확장 패턴을 염두하여 개발이 가능하였습니다.
업계 표준 준수
OAuth2, JWT, OpenID Connect 등 표준 보안 프로토콜을 지원하여 최신 보안 트렌드에 맞는 애플리케이션을 개발할 수 있습니다.
Spring Security 주요 개념
Authentication (인증) 인증은 사용자가 본인이 맞는지를 확인하는 과정입니다. 사용자가 올바른 자격 증명(예: 아이디와 비밀번호)을 제공했는지 확인합니다.
AuthenticationManager: 인증 처리를 담당하는 인터페이스.
UserDetailsService: 사용자 정보를 로드하는 서비스.
PasswordEncoder: 비밀번호 암호화 및 검증 처리.
인증방식
credential 방식: username, password를 이용하는 방식 principal -> 아이디(username), credential -> 비밀번호(password)
이중 인증(twofactor 인증): 사용자가 입력한 개인정보를 인증 후, 다른 인증 체계를 이용하여 두가지의 조합으로 인증하는 방식
하드웨어 인증: 자동차 키와 같은 방식
Authorization (인가) 권한 부여는 사용자가 특정 리소스나 작업을 수행할 권한이 있는지 확인하는 과정입니다.
GrantedAuthority: 사용자의 권한 정보.
AccessDecisionManager: 권한 부여 판단을 담당.
Security Context SecurityContextHolder를 통해 애플리케이션 전반에서 현재 사용자의 인증 및 권한 정보를 관리합니다.
Filter Chain Spring Security는 HTTP 요청을 처리하기 위해 여러 필터를 체인 형태로 연결합니다. 주요 필터:
UsernamePasswordAuthenticationFilter: 사용자 인증 처리.
BasicAuthenticationFilter: HTTP Basic 인증 처리.
CsrfFilter: CSRF 보호.
Spring Security 동작 원리
아키텍처
스프링 시큐리티 아키텍처
클라이언트가 서버에 요청을 보냅니다.
AuthenticationFilter가 요청을 인터셉트하고 이를 AuthenticationManager에 전달합니다.
AuthenticationManager는 등록된 AuthenticationProvider를 탐색하여 인증 처리를 위임합니다.
AuthenticationProvider는 사용자 데이터를 확인하고, 인증된 UserDetails 객체를 반환합니다.
인증 결과는 SecurityContextHolder에 저장되며, 저장된 사용자 정보는 Spring Controller에서 활용할 수 있습니다.
제가 공부한 내용을 정리하는 블로그입니다. 아직 많이 부족하고 배울게 너무나도 많습니다. 틀린내용이 있으면 언제나 가감없이 말씀해주시면 감사하겠습니다😁
스프링부트와 리액트를 활용해 로그인을 구현 프로젝트를 진행합니다. 순서는 1. 프로젝트 초기화 2. 쿠키를 이용한 로그인 구현 3. 세션을 이용한 로그인 구현 4. JWT 토큰을 활용한 로그인 구현 입니다.
세번째는 세션을 이용한 로그인 구현입니다.
서론
이전 쿠키 포스팅에서 STATELESS한 HTTP 프로토콜에서 STATEFUL한 서비스를 위한 장치로 헤더에 쿠키를 저장하는 로직으로 설계하였습니다.
하지만 해당 방법은 개인 정보들을 브라우저 단에 저장하여 위변조 및 도용이 쉽다는 문제가 있습니다. 보안적인 부분은 클라이언트가 아닌 서버에서 관리하여 외부로 해당 개인정보를 숨겨 보안성을 높여야합니다. 따라서 클라이언트는 키만 가지고 있으며 해당 정보는 서버에서 관리하고 있는 방법을 세션이라고 합니다.
저는 이 포스팅에서 세션을 두가지 방법으로 구현합니다. 첫번째는 쿠키를 이용한 세션과 속성 기반으로 세션을 구현할 예정입니다.
세션
정의
세션(Session)은 서버가 클라이언트의 상태를 유지하기 위해 일정 기간 동안 저장하는 정보를 의미합니다. 클라이언트의 요청마다 동일한 사용자임을 식별할 수 있도록 하는 상태 관리 방식입니다. 보통 서버는 클라이언트가 전달한 세션 ID를 기반으로 특정 사용자와 연결된 정보를 조회합니다.
역할
사용자 식별: 세션 ID를 통해 동일 클라이언트의 요청임을 서버가 식별합니다.
상태 유지: 로그인 상태, 장바구니 정보 등 사용자의 상태 정보를 서버에서 저장 및 관리합니다.
보안 강화: 민감한 정보는 서버에 저장하고, 클라이언트는 세션 ID만 전달하므로 정보 위변조 위험을 줄입니다.
구조
세션 구조
클라이언트 측
브라우저는 서버로부터 세션 ID를 받아 저장(주로 쿠키에 저장)하고, 이후 요청마다 세션 ID를 포함하여 서버에 전달합니다.
서버 측
서버는 세션 저장소(메모리, 데이터베이스 등)에 세션 ID와 상태 정보를 저장하고, 세션 ID를 키로 사용하여 클라이언트 데이터를 관리합니다.
장점
보안성
민감한 데이터가 서버에 저장되므로 클라이언트에서 정보가 노출될 위험이 줄어듭니다.
유연성
상태 정보는 서버에 저장되므로 클라이언트가 브라우저를 닫더라도 세션이 만료되지 않으면 상태를 유지할 수 있습니다.
확장성
서버의 세션 저장소를 확장하여 대량의 사용자 상태를 관리할 수 있습니다.
단점
서버 부담
세션 데이터를 서버에서 관리하므로 사용자 수가 많아질수록 서버 메모리나 저장소 사용량이 증가합니다.
스케일링 문제
서버가 분산 환경일 경우, 세션 데이터를 공유하기 위한 추가 작업(예: 세션 클러스터링)이 필요합니다.
만료 관리
세션 만료 시간 설정이 필요하며, 만료되지 않은 오래된 세션 데이터가 서버의 리소스를 점유할 수 있습니다.
Session-login(쿠키 기반)
Frontend
localhost:3000/login-session에 접근하기 위해 routepath를 지정합니다.
마찬가지로 username과 password를 토대로 member가 존재하면 SessionManager를 통해 쿠키를 생성하여 response에 넣어줍니다.
@Slf4j
@RestController
@RequestMapping("/session")
@RequiredArgsConstructor
@CrossOrigin(origins = "http://localhost:3000", allowedHeaders = "*", allowCredentials = "true")
public class SessionController {
private final AuthService authService;
private final SessionManager sessionManager;
@PostMapping("/loginV1")
public ResponseEntity<String> loginV1(@RequestParam String username,
@RequestParam String password,
HttpServletResponse response) {
log.info("session cookie login id: {}, password: {}", username, password);
// Authorization User
Member member = authService.login(username, password);
if (member != null) {
sessionManager.createSession(member, response);
return ResponseEntity.ok("Success session-login");
}
return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("Fail login");
}
@PostMapping("/logoutV1")
public ResponseEntity<String> logoutV1(HttpServletRequest request) {
log.info("logout session cookie");
if (sessionManager.expire(request)) {
return ResponseEntity.ok("Success session-logout");
}
return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("Fail logout");
}
}
이 프로젝트에서는 sessionManager를 메모리에서 관리합니다. 쿠키 이름을 spring-react-auth의 쿠키로 sessionId를 UUID 값으로 넣어줍니다.
@Component
public class SessionManager {
public static final String SESSION_COOKIE_NAME = "spring-react-auth";
private final Map<String, Object> sessionStore = new ConcurrentHashMap<>();
public void createSession(Object value, HttpServletResponse response) {
// Generate a unique session ID and store the session data.
String sessionId = UUID.randomUUID().toString();
sessionStore.put(sessionId, value);
// Create a session cookie with the generated session ID.
Cookie sessionCookie = new Cookie(SESSION_COOKIE_NAME, sessionId);
sessionCookie.setHttpOnly(true); // Enhance security by restricting client-side access
// sessionCookie.setPath("/"); // Make the cookie accessible across the application
response.addCookie(sessionCookie);
}
public boolean expire(HttpServletRequest request) {
Cookie sessionCookie = findCookie(request, SESSION_COOKIE_NAME);
System.out.println("sessionCookie = " + sessionCookie.getName());
if (sessionCookie != null) {
sessionStore.remove(sessionCookie.getValue());
return true;
}
return false;
}
public Cookie findCookie(HttpServletRequest request, String cookieName) {
if (request.getCookies() == null) {
return null; // No cookies present in the request
}
return Arrays.stream(request.getCookies())
.filter(cookie -> cookie.getName().equals(cookieName))
.findFirst()
.orElse(null);
}
}
.env 파일을 생성한 후 REACT_APP_BASE_URL="http://localhost:8080"을 입력해줍니다.
쿠키를 사용하기 위해 리액트에서 제공하는 npm install react-cookie를 설치한 후 다음과 같은 코드를 작성합니다.
const CookieLogin: React.FC = () => {
const [cookies, setCookie, removeCookie] = useCookies(['auth-token']);
const [username, setUsername] = useState<string>('');
const [password, setPassword] = useState<string>('');
const [error, setError] = useState<string>('');
const [isAuthenticated, setIsAuthenticated] = useState<boolean>(false);
// Check if the user is authenticated based on the "auth-token" cookie
useEffect(() => {
const token = cookies['auth-token'];
setIsAuthenticated(!!token); // Set authentication status based on cookie presence
}, [cookies]);
// Login API
const handleSubmit = async (e: React.FormEvent) => {
e.preventDefault();
try {
const response = await fetch(
`${process.env.REACT_APP_BASE_URL}/cookie/login?username=${username}&password=${password}`,
{
method: 'POST',
headers: {
'Content-Type': 'application/x-www-form-urlencoded',
},
}
);
if (response.ok) {
const token = await response.text(); // Assume the backend returns a token as plain text
setCookie('auth-token', token, { path: '/', maxAge: 3600 }); // Set the token in cookies
setIsAuthenticated(true);
alert('Login successful');
} else {
setError('Invalid username or password');
}
} catch (error) {
setError('An error occurred while logging in');
}
};
// Logout API
const handleLogout = async () => {
try {
const response = await fetch(`${process.env.REACT_APP_BASE_URL}/cookie/logout`, {
method: 'GET',
});
if (response.ok) {
removeCookie('auth-token', { path: '/' }); // Remove the token cookie
setIsAuthenticated(false);
alert('Logout successful');
} else {
console.error('Logout failed');
}
} catch (error) {
console.error('Logout error:', error);
}
};
// Render success page if authenticated
if (isAuthenticated) {
return (
<div>
<SuccessPage />
<button onClick={handleLogout} className="logout-button">
Logout
</button>
</div>
);
}
return (
<div className="login-container">
<div className="login-form">
<h2 className="login-title">Login with Cookie</h2>
<form onSubmit={handleSubmit}>
<div>
<label htmlFor="username">Username</label>
<input
type="text"
id="username"
className="input-field"
value={username}
onChange={(e) => setUsername(e.target.value)}
required
/>
</div>
<div>
<label htmlFor="password">Password</label>
<input
type="password"
id="password"
className="input-field"
value={password}
onChange={(e) => setPassword(e.target.value)}
required
/>
</div>
<button type="submit" className="login-button">
Login
</button>
</form>
{error && <p className="error-message">{error}</p>}
</div>
</div>
);
};
export default CookieLogin;
쿠키 로그인 화면
Backend
데이터가 없기에 샘플 데이터를 위한 클래스를 하나 만들어줍니다.
@Component
@RequiredArgsConstructor
public class DataInitializer implements CommandLineRunner {
private final MemberRepository repository;
@Override
public void run(String... args) throws Exception {
Member member = new Member("hiro", "qwer1234");
repository.save(member);
System.out.println("데이터 초기화 완료");
}
}
서버 실행 시 로그
Controller
login
기본적으로 보안은 생략하고 진행하겠습니다. username과 password를 받고 해당 유저가 있으면 로그인 가능하도록 로직을 설계하였습니다. h2 데이터베이스에 유저가 있으면 "auth-token"이라는 이름으로 Cookie를 생성하고 해당 value는 멤버의 pk값을 넣어주었습니다.(기본적으로 암호화된 값이나 유니크한 값으로 설정하는 것이 좋습니다.)
@PostMapping("/login")
public ResponseEntity<String> login(@RequestParam String username, @RequestParam String password, HttpServletResponse response) {
log.info("login id: {}, password: {}", username, password);
// Authorization User
Member member = authService.getMemberByUsername(username);
if (member != null) {
// create cookie & config
Cookie idCookie = new Cookie("auth-token", String.valueOf(member.getId()));
response.addCookie(idCookie);
return ResponseEntity.ok("Success login");
}
return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("Fail login");
}
사용자로부터 username과 password를 받아 인증 처리합니다.
authService.getMemberByUsername()를 통해 사용자를 데이터베이스에서 조회 후
사용자가 존재하면 auth-token 쿠키를 생성하여 응답에 추가합니다.
사용자 인증 실패 시Unauthorized(401)상태 반환합니다.
logout
로그아웃 시에는 쿠키를 삭제(만료)를 진행해주면 됩니다. 쿠키의 Age를 0으로 설정하면 쿠키가 삭제되는 것입니다.
제가 공부한 내용을 정리하는 블로그입니다. 아직 많이 부족하고 배울게 너무나도 많습니다. 틀린내용이 있으면 언제나 가감없이 말씀해주시면 감사하겠습니다😁
스프링부트와 리액트를 활용해 로그인을 구현 프로젝트를 진행합니다. 순서는 1. 프로젝트 초기화 2. 쿠키를 이용한 로그인 구현 3. 세션을 이용한 로그인 구현 4. JWT 토큰을 활용한 로그인 구현 입니다.
첫번째는 프론트와 백엔드 설정입니다.
서론
로그인은 현대 웹 애플리케이션에서 필수적인 기능으로 자리 잡았습니다. 사용자 인증은 단순히 애플리케이션에 접근하기 위한 절차를 넘어, 보안, 데이터 보호, 그리고 맞춤형 서비스 제공의 핵심 역할을 담당합니다. 따라서 신뢰할 수 있고 효율적인 로그인 시스템을 설계하고 구현하는 것은 개발자의 중요한 과제 중 하나입니다.
이 포스팅에서는 로그인 시스템을 체계적으로 정리하고자 합니다. 이를 통해 로그인 시스템의 기본 원리부터 실제 구현 방법까지 폭넓게 다루고자 합니다.
프론트는 react를 사용하고 백엔드는 Spring Framework를 활용하여 다음과 같은 방식으로 로그인 시스템을 구현할 예정입니다:
쿠키와 세션을 이용한 상태 관리
Spring Security를 활용한 인증 및 권한 부여
OAuth2를 통한 소셜 로그인 연동
Frontend 설정
프론트는 리액트를 활용하고 언어는 TypeScript를 이용할 것입니다. 리액트 프로젝트를 생성하기 위해 npx create-react-frontend를 통해 프로젝트를 생성합니다.
해당 프로젝트에서 TypeScript를 사용하기 위해 tsconfig.json을 설정해줍니다.
App.js 파일에서는 react-router-dom 라이브러리를 사용하여 애플리케이션의 라우팅을 설정합니다. 이 설정은 SPA(Single Page Application) 형태의 웹사이트에서 페이지 간 전환을 빠르고 부드럽게 구현할 수 있도록 해줍니다. BrowserRouter, Routes, Route 등의 컴포넌트를 사용하여 라우트 경로와 해당 경로에 매핑된 컴포넌트를 정의합니다.
npm install react-route-dom을 통해 라이브러리 설치를 진행해줍니다.
App.js
import AppRoutes from "./pages/AppRoutes";
function App() {
return (
<AppRoutes />
);
}
export default App;
AppRoutes.ts
import {BrowserRouter as Router, Route, Routes} from 'react-router-dom';
import { RoutePath } from '../interface/RoutePath';
import HomePage from './home/HomePage';
const AppRoutes = () => {
return (
<Router>
<Routes>
<Route path={RoutePath.HOMEPAGE} element={<HomePage />} />
</Routes>
</Router>
)
}
export default AppRoutes
RoutePath.ts
export enum RoutePath {
HOMEPAGE = "/",
}
HomePage.tsx 파일은 애플리케이션의 메인 페이지 역할을 하는 컴포넌트를 정의합니다.
이 페이지는 사용자가 사이트에 처음 방문했을 때 렌더링되는 기본 화면을 제공합니다. HomePage 컴포넌트는 React를 사용하여 작성되며, 사용자가 볼 수 있는 다양한 콘텐츠와 네비게이션 링크들을 포함할 수 있습니다.
서버가 제대로 띄워졌는지 확인하기 위한 healthCheck를 위한 컨트롤러를 만들어줍니다.
StatusController
@Slf4j
@RestController
@RequestMapping("/status")
@Tags(value = @Tag(name = "StatusController", description = "Retrieve any status"))
public class StatusController {
@GetMapping
public ResponseEntity<?> serverStatusCheck() {
log.info("this server is health");
return ResponseEntity.ok("ok");
}
@GetMapping("/all")
public ResponseEntity<?> anyOneCanAccess() {
log.info("all people can access");
return ResponseEntity.ok("all people can access");
}
}
서버가 제대로 실행되었는지 확인하기 위해 postman을 통해 확인해보면
health-check
다음과 같이 제대로 띄워져 있는 결과를 얻을 수 있습니다.
데이터베이스와의 연동 확인
데이터베이스와의 연동을 확인하기 위해 간단한 create 요청을 만들어 디비에 제대로 적제되었는지 확인해보겠습니다.
AccountDto와 SignUpRequest는 Java의 record를 사용해 생성됩니다. record는 Java 16 이상에서 제공되는 기능으로, 불변 객체를 간결하게 정의할 수 있게 해줍니다. 이를 통해 DTO(Data Transfer Object)와 요청 객체를 더 짧고 명확한 코드로 작성할 수 있습니다.
SignUpRequest
public record AccountDto() {
@Data
@NoArgsConstructor
@AllArgsConstructor
public static final class SignUpRequest {
private String username;
private String password;
}
}
다음은 controller를 생성합니다. @RequestBody를 통해 받은 SignUpRequest를 통해 service의 joinMember를 호출합니다.
@Entity
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
public class Member {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String username;
private String password;
public Member(String username, String password) {
this.username = username;
this.password = password;
}
}
TestService는 서비스 계층으로 Repository와의 상호작용을 담당하고 비즈니스 로직을 담당하는 부분입니다.
TestService
@Slf4j
@RequiredArgsConstructor
@Service
public class TestService {
private final MemberRepository memberRepository;
public String joinMember(String username, String password) throws Exception {
log.info("Service: joinMember");
if (memberRepository.existsByUsername(username)) {
throw new RuntimeException("fail join member");
}
Member member = new Member(username, password);
memberRepository.save(member);
return member.getUsername();
}
}
MemberRepository는 Spring Data JPA의 JpaRepository 인터페이스를 확장하여 데이터베이스와 상호작용하는 저장소(Repository)입니다. 이 인터페이스를 구현함으로써, 기본적인 CRUD(생성, 읽기, 업데이트, 삭제) 기능을 자동으로 제공받을 수 있습니다. 이를 통해 개발자는 복잡한 SQL 쿼리 작성 없이 간단한 메서드 호출만으로 데이터베이스 작업을 수행할 수 있습니다.
MemberRepository
@Repository
public interface MemberRepository extends JpaRepository<Member, Long> {
boolean existsById(Long id);
boolean existsByUsername(String username);
Member findByUsername(String username);
}
