HTTP basic authentication

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// 사용자 이름과 비밀번호를 Base64로 인코딩
function encodeCredentials(username, password) {
  return btoa(`${username}:${password}`);
}

// 기본 인증을 사용한 API 요청
async function fetchWithBasicAuth(url, username, password) {
  const encodedCredentials = encodeCredentials(username, password);
  
  try {
    const response = await fetch(url, {
      headers: {
        'Authorization': `Basic ${encodedCredentials}`
      }
    });
    
    if (!response.ok) {
      if (response.status === 401) {
        throw new Error('인증 실패: 사용자 이름 또는 비밀번호가 잘못되었습니다.');
      }
      throw new Error(`요청 실패: ${response.status}`);
    }
    
    return await response.json();
  } catch (error) {
    console.error('요청 오류:', error);
    throw error;
  }
}

// 사용 예시
fetchWithBasicAuth('https://api.example.com/resource', 'username', 'password')
  .then(data => console.log('데이터:', data))
  .catch(error => console.error('오류:', error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

const express = require('express');
const app = express();

// 기본 인증 미들웨어
function basicAuth(req, res, next) {
  // Authorization 헤더 확인
  const authHeader = req.headers.authorization;
  
  if (!authHeader) {
    // 인증 헤더가 없으면 인증 요구
    res.setHeader('WWW-Authenticate', 'Basic realm="접근하려면 로그인하세요"');
    return res.status(401).send('인증이 필요합니다');
  }
  
  // Basic 인증 스키마 확인
  if (!authHeader.startsWith('Basic ')) {
    return res.status(401).send('지원되지 않는 인증 방식입니다');
  }
  
  // Base64 인코딩된 자격 증명 디코딩
  const base64Credentials = authHeader.split(' ')[1];
  const credentials = Buffer.from(base64Credentials, 'base64').toString('utf-8');
  const [username, password] = credentials.split(':');
  
  // 자격 증명 검증 (실제로는 데이터베이스 등에서 검증)
  if (username === 'admin' && password === 'secret') {
    // 인증 성공 시 요청 객체에 사용자 정보 추가
    req.user = { username };
    next();
  } else {
    // 인증 실패
    res.setHeader('WWW-Authenticate', 'Basic realm="접근하려면 로그인하세요"');
    res.status(401).send('잘못된 사용자 이름 또는 비밀번호');
  }
}

// 모든 라우트에 기본 인증 적용
app.use(basicAuth);

// 보호된 라우트
app.get('/api/protected', (req, res) => {
  res.json({
    message: '인증된 접근 성공',
    user: req.user.username
  });
});

app.listen(3000, () => {
  console.log('서버가 3000번 포트에서 실행 중입니다');
});

1
2
3
4
5

# 기본 인증 활성화
AuthType Basic
AuthName "제한된 영역"
AuthUserFile /path/to/.htpasswd
Require valid-user

1

htpasswd -c /path/to/.htpasswd username

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

from flask import Flask, request, Response
import base64

app = Flask(__name__)

# 사용자 데이터베이스 (실제로는 DB 사용)
USERS = {'admin': 'password'}

def check_auth(username, password):
    """사용자 이름과 비밀번호 검증"""
    return username in USERS and USERS[username] == password

def authenticate():
    """인증 요구 응답 생성"""
    return Response(
        'Could not verify your access level for that URL.\n'
        'You have to login with proper credentials', 401,
        {'WWW-Authenticate': 'Basic realm="Login Required"'})

def requires_auth(f):
    """기본 인증을 요구하는 데코레이터"""
    def decorated(*args, **kwargs):
        auth = request.authorization
        if not auth or not check_auth(auth.username, auth.password):
            return authenticate()
        return f(*args, **kwargs)
    return decorated

@app.route('/api/protected')
@requires_auth
def protected_resource():
    """인증이 필요한 보호된 리소스"""
    return {'message': '인증 성공!', 'user': request.authorization.username}

if __name__ == '__main__':
    app.run(debug=True)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeRequests(authorizeRequests ->
                authorizeRequests
                    .antMatchers("/public/**").permitAll()
                    .anyRequest().authenticated()
            )
            .httpBasic();
        
        return http.build();
    }

    @Bean
    public UserDetailsService userDetailsService() {
        UserDetails user = User.builder()
            .username("admin")
            .password("{bcrypt}$2a$10$GRLdNijSQMUvl/au9ofL.eDwmoohzzS7.rmNSJZ.0FxO/BTk76klW") // "password"
            .roles("ADMIN")
            .build();
            
        return new InMemoryUserDetailsManager(user);
    }
}

1
2
3

# Jenkins 웹훅 호출 예시
curl -X POST https://jenkins.example.com/job/build-project/build \
     -u username:api_token

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# Nginx 설정 예시
server {
    listen 80;
    server_name dev.example.com;
    
    auth_basic "Development Environment";
    auth_basic_user_file /etc/nginx/.htpasswd;
    
    location / {
        proxy_pass http://localhost:3000;
    }
}

1
2
3
4
5
6
7

# Python에서 API 키를 사용한 기본 인증 요청
import requests

response = requests.get(
    'https://api.example.com/data',
    auth=('api_key_12345', '')  # 비밀번호 부분은 빈 문자열
)