## 🎯 암호화, 왜 이렇게 중요할까? 요즘 세상에서 데이터 보안은 선택이 아니라 필수야! 🛡️ 매일같이 뉴스에서 들리는 개인정보 유출 사건들을 보면 정말 등골이 오싹하지 않아? 사용자 비밀번호를 평문으로 저장했다가는... 상상만 해도 끔찍해. 😱

Go언어는 이런 보안 문제를 해결하기 위해 강력한 crypto 패키지를 기본으로 제공하고 있어. 구글이 만든 언어답게 보안에 대한 고민이 정말 깊게 녹아있지. 오늘은 친구처럼 편하게 Go의 암호화 세계를 함께 탐험해볼 거야! 🗺️

## 🔍 해싱 vs 암호화: 헷갈리지 말자! 많은 사람들이 해싱과 암호화를 같은 거라고 생각하는데, 이건 완전히 다른 개념이야! 🤔

암호화(Encryption)는 양방향이야. 열쇠(키)만 있으면 원래 데이터로 되돌릴 수 있지. 마치 자물쇠를 잠그고 여는 것처럼 말이야. 🔑

반면 해싱(Hashing)은 일방향이야. 한번 해시값으로 변환하면 절대 원본으로 되돌릴 수 없어. 고기를 갈아서 햄버거 패티를 만들면 다시 원래 고기 덩어리로 못 돌리는 것처럼! 🍔

구분	암호화 (Encryption)	해싱 (Hashing)
방향성	양방향 (복호화 가능)	일방향 (복원 불가능)
키 필요	필요 (암호화/복호화 키)	불필요
출력 길이	입력에 따라 변함	항상 고정
주요 용도	데이터 전송, 저장	비밀번호, 무결성 검증
예시	AES, RSA	SHA-256, bcrypt

비밀번호를 저장할 때는 해싱을 써야 해! 왜냐하면 서비스 제공자조차 사용자의 원본 비밀번호를 알 필요가 없거든. 사용자가 로그인할 때 입력한 비밀번호를 해싱해서 저장된 해시값과 비교만 하면 되니까! 🎯 ## 🏗️ Go crypto 패키지의 구조 파헤치기 Go의 crypto 패키지는 정말 잘 설계되어 있어! 마치 레고 블록처럼 각각의 서브 패키지들이 명확한 역할을 가지고 있지. 🧱

여기서 중요한 포인트! 🎯 math/rand와 crypto/rand는 완전히 다른 패키지야. 보안이 중요한 상황에서는 반드시 crypto/rand를 써야 해. math/rand는 예측 가능한 난수를 생성하기 때문에 보안에 취약하거든! 😨 ## 💎 SHA-256: 가장 많이 쓰이는 해싱 알고리즘 SHA-256은 현재 가장 널리 사용되는 해싱 알고리즘 중 하나야. 256비트(32바이트)의 고정된 길이를 가진 해시값을 생성하지. 비트코인도 SHA-256을 사용한다는 사실! 🪙

기본적인 SHA-256 해싱 구현

package main

import (
    "crypto/sha256"
    "encoding/hex"
    "fmt"
)

func main() {
    // 해싱할 데이터
    data := "안녕하세요! 재능넷입니다 🎉"
    
    // SHA-256 해시 생성
    hash := sha256.Sum256([]byte(data))
    
    // 16진수 문자열로 변환
    hashString := hex.EncodeToString(hash[:])
    
    fmt.Printf("원본: %s\n", data)
    fmt.Printf("해시: %s\n", hashString)
}

이 코드를 실행하면 항상 같은 해시값이 나와. 입력이 같으면 출력도 항상 같다는 게 해싱의 핵심 특성이야! 🎯

파일 무결성 검증하기

SHA-256은 파일이 변조되지 않았는지 확인하는 데도 자주 쓰여. 다운로드한 파일의 해시값을 계산해서 공식 사이트에 공개된 해시값과 비교하면 되거든! 🔍

package main

import (
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "io"
    "os"
)

func calculateFileHash(filename string) (string, error) {
    // 파일 열기
    file, err := os.Open(filename)
    if err != nil {
        return "", err
    }
    defer file.Close()
    
    // SHA-256 해시 객체 생성
    hasher := sha256.New()
    
    // 파일 내용을 해시 객체에 복사
    if _, err := io.Copy(hasher, file); err != nil {
        return "", err
    }
    
    // 최종 해시값 계산
    hashBytes := hasher.Sum(nil)
    
    return hex.EncodeToString(hashBytes), nil
}

func main() {
    filename := "important_file.zip"
    
    hash, err := calculateFileHash(filename)
    if err != nil {
        fmt.Printf("에러 발생: %v\n", err)
        return
    }
    
    fmt.Printf("파일: %s\n", filename)
    fmt.Printf("SHA-256: %s\n", hash)
    
    // 공식 해시값과 비교
    officialHash := "abc123def456..." // 공식 사이트에서 제공하는 해시
    if hash == officialHash {
        fmt.Println("✅ 파일 무결성 검증 성공!")
    } else {
        fmt.Println("❌ 파일이 변조되었거나 손상되었습니다!")
    }
}

큰 파일을 처리할 때는 sha256.New()로 해시 객체를 만들고 io.Copy()를 사용하는 게 메모리 효율적이야! 전체 파일을 메모리에 올리지 않고 스트리밍 방식으로 처리할 수 있거든. 💪 ## 🧂 솔트(Salt)와 페퍼(Pepper): 해싱의 양념 비밀번호를 그냥 해싱만 하면 안전할까? 🤔 아니야! 레인보우 테이블(Rainbow Table) 공격이라는 게 있어. 미리 계산된 해시값들의 거대한 데이터베이스를 만들어서 역추적하는 방법이지.

이걸 막기 위해 솔트(Salt)를 사용해! 솔트는 비밀번호에 추가하는 랜덤한 값이야. 마치 요리할 때 소금을 뿌리는 것처럼! 🧂

솔트를 사용한 비밀번호 해싱

package main

import (
    "crypto/rand"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
)

// 솔트 생성 함수
func generateSalt(length int) ([]byte, error) {
    salt := make([]byte, length)
    _, err := rand.Read(salt)
    if err != nil {
        return nil, err
    }
    return salt, nil
}

// 비밀번호 해싱 함수
func hashPassword(password string, salt []byte) string {
    // 비밀번호와 솔트를 결합
    passwordWithSalt := append([]byte(password), salt...)
    
    // SHA-256 해싱
    hash := sha256.Sum256(passwordWithSalt)
    
    return hex.EncodeToString(hash[:])
}

func main() {
    password := "mySecretPassword123!"
    
    // 16바이트 솔트 생성
    salt, err := generateSalt(16)
    if err != nil {
        fmt.Printf("솔트 생성 실패: %v\n", err)
        return
    }
    
    // 비밀번호 해싱
    hashedPassword := hashPassword(password, salt)
    
    fmt.Printf("원본 비밀번호: %s\n", password)
    fmt.Printf("솔트(hex): %s\n", hex.EncodeToString(salt))
    fmt.Printf("해시된 비밀번호: %s\n", hashedPassword)
    
    // 데이터베이스에는 솔트와 해시를 함께 저장해야 함!
    fmt.Println("\n💾 DB 저장 형식:")
    fmt.Printf("salt: %s\n", hex.EncodeToString(salt))
    fmt.Printf("hash: %s\n", hashedPassword)
}

페퍼(Pepper)는 뭐야?

페퍼는 솔트와 비슷하지만 중요한 차이가 있어! 🌶️

• 솔트: 각 비밀번호마다 다르고, 데이터베이스에 저장됨
• 페퍼: 모든 비밀번호에 동일하게 적용되고, 코드나 환경변수에 저장됨 (DB에 저장 안 함!)

페퍼는 추가적인 보안 레이어야. 만약 데이터베이스가 유출되더라도 페퍼를 모르면 비밀번호를 크랙할 수 없지! 🛡️

package main

import (
    "crypto/rand"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "os"
)

// 페퍼는 환경변수나 설정 파일에서 가져옴
func getPepper() string {
    pepper := os.Getenv("PASSWORD_PEPPER")
    if pepper == "" {
        // 실제 운영환경에서는 반드시 설정되어야 함!
        pepper = "default-pepper-change-me-in-production"
    }
    return pepper
}

func hashPasswordWithSaltAndPepper(password string, salt []byte) string {
    pepper := getPepper()
    
    // 비밀번호 + 솔트 + 페퍼 결합
    combined := password + string(salt) + pepper
    
    hash := sha256.Sum256([]byte(combined))
    return hex.EncodeToString(hash[:])
}

func generateSalt(length int) ([]byte, error) {
    salt := make([]byte, length)
    _, err := rand.Read(salt)
    return salt, err
}

func main() {
    password := "userPassword456"
    
    salt, _ := generateSalt(16)
    hashedPassword := hashPasswordWithSaltAndPepper(password, salt)
    
    fmt.Printf("해시된 비밀번호: %s\n", hashedPassword)
    fmt.Printf("솔트: %s\n", hex.EncodeToString(salt))
    fmt.Println("페퍼는 코드에 저장되어 있음 (DB에 저장 안 함)")
}

## 🔒 bcrypt: 비밀번호 해싱의 왕자 SHA-256도 좋지만, 비밀번호 해싱에는 bcrypt가 훨씬 더 적합해! 왜냐하면 bcrypt는 의도적으로 느리게 설계되었거든. "느린 게 왜 좋아?" 라고 물을 수 있는데, 바로 이게 핵심이야! 🐌

공격자가 수백만 개의 비밀번호를 시도하려면 엄청난 시간이 걸리게 만드는 거지. 그리고 컴퓨터가 빨라져도 작업 계수(work factor)를 높여서 계속 느리게 유지할 수 있어! 🎯

Go에서 bcrypt를 사용하려면 외부 패키지를 설치해야 해:

go get golang.org/x/crypto/bcrypt

bcrypt로 비밀번호 해싱하기

package main

import (
    "fmt"
    "golang.org/x/crypto/bcrypt"
)

// 비밀번호 해싱
func hashPassword(password string) (string, error) {
    // cost는 10~12 정도가 적당 (숫자가 클수록 느림)
    bytes, err := bcrypt.GenerateFromPassword([]byte(password), 12)
    return string(bytes), err
}

// 비밀번호 검증
func checkPassword(password, hash string) bool {
    err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password))
    return err == nil
}

func main() {
    password := "mySecurePassword123!"
    
    // 비밀번호 해싱
    hash, err := hashPassword(password)
    if err != nil {
        fmt.Printf("해싱 실패: %v\n", err)
        return
    }
    
    fmt.Printf("원본 비밀번호: %s\n", password)
    fmt.Printf("해시: %s\n\n", hash)
    
    // 올바른 비밀번호로 검증
    fmt.Println("=== 로그인 시도 1 ===")
    if checkPassword(password, hash) {
        fmt.Println("✅ 로그인 성공!")
    } else {
        fmt.Println("❌ 로그인 실패!")
    }
    
    // 잘못된 비밀번호로 검증
    fmt.Println("\n=== 로그인 시도 2 ===")
    wrongPassword := "wrongPassword"
    if checkPassword(wrongPassword, hash) {
        fmt.Println("✅ 로그인 성공!")
    } else {
        fmt.Println("❌ 로그인 실패!")
    }
}

bcrypt의 멋진 점은 같은 비밀번호를 해싱해도 매번 다른 결과가 나온다는 거야! 왜냐하면 내부적으로 랜덤 솔트를 생성하고 그걸 해시값에 포함시키거든. 그래서 솔트를 따로 저장할 필요가 없어! 😎

작업 계수(Cost Factor) 선택하기

작업 계수는 2의 거듭제곱으로 계산돼. cost가 10이면 2^10 = 1024번의 반복 작업을 수행하는 거지. 🔢

Cost	반복 횟수	대략적인 시간	권장 사항
10	1,024	~100ms	최소 권장값
11	2,048	~200ms	-
12	4,096	~400ms	⭐ 추천
13	8,192	~800ms	높은 보안
14	16,384	~1.6s	매우 높은 보안

실전 예제: 사용자 인증 시스템

package main

import (
    "fmt"
    "golang.org/x/crypto/bcrypt"
    "time"
)

// 사용자 구조체
type User struct {
    Username     string
    PasswordHash string
    CreatedAt    time.Time
}

// 사용자 데이터베이스 (실제로는 DB 사용)
var users = make(map[string]User)

// 회원가입
func registerUser(username, password string) error {
    // 이미 존재하는 사용자인지 확인
    if _, exists := users[username]; exists {
        return fmt.Errorf("이미 존재하는 사용자입니다")
    }
    
    // 비밀번호 해싱
    hash, err := bcrypt.GenerateFromPassword([]byte(password), 12)
    if err != nil {
        return err
    }
    
    // 사용자 저장
    users[username] = User{
        Username:     username,
        PasswordHash: string(hash),
        CreatedAt:    time.Now(),
    }
    
    return nil
}

// 로그인
func loginUser(username, password string) (bool, error) {
    // 사용자 찾기
    user, exists := users[username]
    if !exists {
        return false, fmt.Errorf("사용자를 찾을 수 없습니다")
    }
    
    // 비밀번호 검증
    err := bcrypt.CompareHashAndPassword(
        []byte(user.PasswordHash),
        []byte(password),
    )
    
    if err != nil {
        return false, nil
    }
    
    return true, nil
}

func main() {
    fmt.Println("🎉 재능넷 사용자 인증 시스템 데모")
    fmt.Println("=====================================\n")
    
    // 회원가입
    fmt.Println("📝 회원가입 중...")
    err := registerUser("gopher", "iLoveGo2024!")
    if err != nil {
        fmt.Printf("회원가입 실패: %v\n", err)
        return
    }
    fmt.Println("✅ 회원가입 성공!\n")
    
    // 올바른 비밀번호로 로그인
    fmt.Println("🔐 로그인 시도 1 (올바른 비밀번호)")
    success, err := loginUser("gopher", "iLoveGo2024!")
    if err != nil {
        fmt.Printf("에러: %v\n", err)
    } else if success {
        fmt.Println("✅ 로그인 성공! 환영합니다!\n")
    } else {
        fmt.Println("❌ 비밀번호가 틀렸습니다.\n")
    }
    
    // 잘못된 비밀번호로 로그인
    fmt.Println("🔐 로그인 시도 2 (잘못된 비밀번호)")
    success, err = loginUser("gopher", "wrongPassword")
    if err != nil {
        fmt.Printf("에러: %v\n", err)
    } else if success {
        fmt.Println("✅ 로그인 성공! 환영합니다!\n")
    } else {
        fmt.Println("❌ 비밀번호가 틀렸습니다.\n")
    }
    
    // 존재하지 않는 사용자
    fmt.Println("🔐 로그인 시도 3 (존재하지 않는 사용자)")
    success, err = loginUser("hacker", "anyPassword")
    if err != nil {
        fmt.Printf("❌ 에러: %v\n", err)
    }
}

## 🔐 HMAC: 메시지 인증의 강자 HMAC(Hash-based Message Authentication Code)은 메시지의 무결성과 인증을 동시에 보장하는 기술이야! 🛡️ API 인증, JWT 토큰, 웹훅 검증 등에 엄청 많이 쓰여.

HMAC의 핵심은 비밀 키를 사용한다는 거야. 해시 함수에 비밀 키를 섞어서 계산하기 때문에, 키를 모르면 같은 HMAC 값을 만들 수 없어! 🔑

HMAC-SHA256 구현하기

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
)

// HMAC 생성
func generateHMAC(message, key string) string {
    h := hmac.New(sha256.New, []byte(key))
    h.Write([]byte(message))
    return hex.EncodeToString(h.Sum(nil))
}

// HMAC 검증
func verifyHMAC(message, key, receivedHMAC string) bool {
    expectedHMAC := generateHMAC(message, key)
    return hmac.Equal([]byte(expectedHMAC), []byte(receivedHMAC))
}

func main() {
    secretKey := "my-super-secret-key-2024"
    message := "중요한 메시지입니다!"
    
    // HMAC 생성
    mac := generateHMAC(message, secretKey)
    
    fmt.Printf("메시지: %s\n", message)
    fmt.Printf("비밀 키: %s\n", secretKey)
    fmt.Printf("HMAC: %s\n\n", mac)
    
    // 검증 성공
    fmt.Println("=== 검증 1: 올바른 메시지 ===")
    if verifyHMAC(message, secretKey, mac) {
        fmt.Println("✅ 검증 성공! 메시지가 변조되지 않았습니다.\n")
    } else {
        fmt.Println("❌ 검증 실패! 메시지가 변조되었습니다.\n")
    }
    
    // 검증 실패 (메시지 변조)
    fmt.Println("=== 검증 2: 변조된 메시지 ===")
    tamperedMessage := "중요한 메시지입니다!!"  // 느낌표 하나 추가
    if verifyHMAC(tamperedMessage, secretKey, mac) {
        fmt.Println("✅ 검증 성공! 메시지가 변조되지 않았습니다.\n")
    } else {
        fmt.Println("❌ 검증 실패! 메시지가 변조되었습니다.\n")
    }
}

실전 예제: API 웹훅 검증

많은 서비스들이 웹훅을 보낼 때 HMAC 서명을 함께 보내. GitHub, Stripe, Slack 등이 다 이 방식을 써! 🚀

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "encoding/json"
    "fmt"
    "net/http"
    "io"
)

// 웹훅 페이로드 구조체
type WebhookPayload struct {
    Event     string `json:"event"`
    UserID    int    `json:"user_id"`
    Timestamp int64  `json:"timestamp"`
}

// HMAC 서명 생성
func signPayload(payload []byte, secret string) string {
    h := hmac.New(sha256.New, []byte(secret))
    h.Write(payload)
    return hex.EncodeToString(h.Sum(nil))
}

// 웹훅 핸들러
func webhookHandler(w http.ResponseWriter, r *http.Request) {
    // 웹훅 비밀키 (실제로는 환경변수에서 가져와야 함)
    webhookSecret := "webhook-secret-key-12345"
    
    // 요청 본문 읽기
    body, err := io.ReadAll(r.Body)
    if err != nil {
        http.Error(w, "요청 읽기 실패", http.StatusBadRequest)
        return
    }
    
    // 헤더에서 서명 가져오기
    receivedSignature := r.Header.Get("X-Webhook-Signature")
    if receivedSignature == "" {
        http.Error(w, "서명이 없습니다", http.StatusUnauthorized)
        return
    }
    
    // 서명 검증
    expectedSignature := signPayload(body, webhookSecret)
    if !hmac.Equal([]byte(expectedSignature), []byte(receivedSignature)) {
        http.Error(w, "서명이 유효하지 않습니다", http.StatusUnauthorized)
        return
    }
    
    // 페이로드 파싱
    var payload WebhookPayload
    if err := json.Unmarshal(body, &payload); err != nil {
        http.Error(w, "JSON 파싱 실패", http.StatusBadRequest)
        return
    }
    
    // 웹훅 처리
    fmt.Printf("✅ 웹훅 검증 성공!\n")
    fmt.Printf("이벤트: %s\n", payload.Event)
    fmt.Printf("사용자 ID: %d\n", payload.UserID)
    
    w.WriteHeader(http.StatusOK)
    w.Write([]byte("웹훅 처리 완료"))
}

func main() {
    // 웹훅 시뮬레이션
    fmt.Println("🎯 웹훅 서명 데모")
    fmt.Println("===================\n")
    
    webhookSecret := "webhook-secret-key-12345"
    
    payload := WebhookPayload{
        Event:     "user.created",
        UserID:    12345,
        Timestamp: 1234567890,
    }
    
    payloadBytes, _ := json.Marshal(payload)
    signature := signPayload(payloadBytes, webhookSecret)
    
    fmt.Printf("페이로드: %s\n", string(payloadBytes))
    fmt.Printf("서명: %s\n", signature)
    fmt.Println("\n이 서명을 HTTP 헤더에 포함해서 전송하면 됩니다!")
    fmt.Println("예: X-Webhook-Signature: " + signature)
}

## 🎲 암호학적으로 안전한 난수 생성 난수 생성은 암호화에서 정말 중요해! 🎯 솔트, 토큰, 세션 ID 등을 만들 때 예측 불가능한 난수가 필요하거든.

안전한 난수 생성 예제

package main

import (
    "crypto/rand"
    "encoding/base64"
    "encoding/hex"
    "fmt"
    "math/big"
)

// 랜덤 바이트 생성
func generateRandomBytes(n int) ([]byte, error) {
    b := make([]byte, n)
    _, err := rand.Read(b)
    if err != nil {
        return nil, err
    }
    return b, nil
}

// 랜덤 문자열 생성 (hex)
func generateRandomHex(n int) (string, error) {
    bytes, err := generateRandomBytes(n)
    if err != nil {
        return "", err
    }
    return hex.EncodeToString(bytes), nil
}

// 랜덤 문자열 생성 (base64)
func generateRandomBase64(n int) (string, error) {
    bytes, err := generateRandomBytes(n)
    if err != nil {
        return "", err
    }
    return base64.URLEncoding.EncodeToString(bytes), nil
}

// 범위 내 랜덤 정수 생성
func generateRandomInt(max int64) (int64, error) {
    n, err := rand.Int(rand.Reader, big.NewInt(max))
    if err != nil {
        return 0, err
    }
    return n.Int64(), nil
}

func main() {
    fmt.Println("🎲 암호학적으로 안전한 난수 생성")
    fmt.Println("===================================\n")
    
    // 32바이트 랜덤 바이트
    randomBytes, _ := generateRandomBytes(32)
    fmt.Printf("랜덤 바이트 (32): %x\n\n", randomBytes)
    
    // API 토큰 생성 (hex)
    apiToken, _ := generateRandomHex(32)
    fmt.Printf("API 토큰 (hex): %s\n\n", apiToken)
    
    // 세션 ID 생성 (base64)
    sessionID, _ := generateRandomBase64(32)
    fmt.Printf("세션 ID (base64): %s\n\n", sessionID)
    
    // 랜덤 정수 (1-100)
    randomNum, _ := generateRandomInt(100)
    fmt.Printf("랜덤 숫자 (1-100): %d\n\n", randomNum)
    
    // 여러 개 생성해서 중복 확인
    fmt.Println("🔍 중복 테스트 (10개 생성):")
    tokens := make(map[string]bool)
    for i := 0; i < 10; i++ {
        token, _ := generateRandomHex(16)
        tokens[token] = true
        fmt.Printf("%d. %s\n", i+1, token)
    }
    fmt.Printf("\n생성된 토큰 수: %d (모두 고유함!)\n", len(tokens))
}

실전 예제: 안전한 토큰 생성기

package main

import (
    "crypto/rand"
    "encoding/base64"
    "fmt"
    "time"
)

// 토큰 구조체
type Token struct {
    Value     string
    CreatedAt time.Time
    ExpiresAt time.Time
}

// 토큰 생성
func generateToken(length int, expiryHours int) (*Token, error) {
    // 랜덤 바이트 생성
    bytes := make([]byte, length)
    if _, err := rand.Read(bytes); err != nil {
        return nil, err
    }
    
    // base64 인코딩
    tokenValue := base64.URLEncoding.EncodeToString(bytes)
    
    now := time.Now()
    return &Token{
        Value:     tokenValue,
        CreatedAt: now,
        ExpiresAt: now.Add(time.Duration(expiryHours) * time.Hour),
    }, nil
}

// 토큰 유효성 검사
func (t *Token) IsValid() bool {
    return time.Now().Before(t.ExpiresAt)
}

// 토큰 만료까지 남은 시간
func (t *Token) TimeUntilExpiry() time.Duration {
    return time.Until(t.ExpiresAt)
}

func main() {
    fmt.Println("🎫 안전한 토큰 생성 시스템")
    fmt.Println("============================\n")
    
    // 액세스 토큰 (1시간 유효)
    accessToken, _ := generateToken(32, 1)
    fmt.Println("📱 액세스 토큰:")
    fmt.Printf("값: %s\n", accessToken.Value)
    fmt.Printf("생성 시간: %s\n", accessToken.CreatedAt.Format("2006-01-02 15:04:05"))
    fmt.Printf("만료 시간: %s\n", accessToken.ExpiresAt.Format("2006-01-02 15:04:05"))
    fmt.Printf("유효 여부: %v\n", accessToken.IsValid())
    fmt.Printf("남은 시간: %v\n\n", accessToken.TimeUntilExpiry())
    
    // 리프레시 토큰 (7일 유효)
    refreshToken, _ := generateToken(64, 24*7)
    fmt.Println("🔄 리프레시 토큰:")
    fmt.Printf("값: %s\n", refreshToken.Value)
    fmt.Printf("만료 시간: %s\n", refreshToken.ExpiresAt.Format("2006-01-02 15:04:05"))
    fmt.Printf("남은 시간: %v\n\n", refreshToken.TimeUntilExpiry())
    
    // API 키 (만료 없음)
    apiKey, _ := generateToken(48, 24*365*10) // 10년
    fmt.Println("🔑 API 키:")
    fmt.Printf("값: %s\n", apiKey.Value)
}

## 🔄 해시 체이닝과 키 스트레칭 단순히 한 번 해싱하는 것보다 여러 번 반복해서 해싱하면 더 안전해! 이걸 키 스트레칭(Key Stretching)이라고 해. 🏋️

PBKDF2(Password-Based Key Derivation Function 2)가 대표적인 키 스트레칭 알고리즘이야. bcrypt도 내부적으로 이런 방식을 사용하고 있어!

PBKDF2 구현하기

package main

import (
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "golang.org/x/crypto/pbkdf2"
    "time"
)

// PBKDF2로 키 생성
func deriveKey(password, salt []byte, iterations, keyLen int) []byte {
    return pbkdf2.Key(password, salt, iterations, keyLen, sha256.New)
}

func main() {
    password := []byte("myPassword123")
    salt := []byte("randomSalt12345")
    
    fmt.Println("🔄 PBKDF2 키 스트레칭 데모")
    fmt.Println("============================\n")
    
    // 다양한 반복 횟수로 테스트
    iterations := []int{1000, 10000, 100000, 200000}
    
    for _, iter := range iterations {
        start := time.Now()
        key := deriveKey(password, salt, iter, 32)
        elapsed := time.Since(start)
        
        fmt.Printf("반복 횟수: %d\n", iter)
        fmt.Printf("생성된 키: %s\n", hex.EncodeToString(key))
        fmt.Printf("소요 시간: %v\n\n", elapsed)
    }
    
    fmt.Println("💡 반복 횟수가 많을수록 안전하지만 느려집니다!")
    fmt.Println("   실무에서는 100,000~200,000 정도를 권장합니다.")
}

알고리즘	반복 방식	권장 반복 횟수	특징
PBKDF2	해시 반복	100,000~200,000	표준화됨, 구현 간단
bcrypt	Blowfish 기반	2^10~2^12	자동 솔트, 검증됨
scrypt	메모리 집약적	N=32768, r=8, p=1	ASIC 공격 방어
Argon2	메모리+CPU	설정 가능	최신, 가장 안전

## 🛡️ 실전 보안 체크리스트 이제 배운 내용을 정리해서 실전에서 꼭 지켜야 할 보안 체크리스트를 만들어볼게! ✅

실전 예제: 완전한 사용자 인증 시스템

이제 배운 모든 걸 종합해서 실전에서 쓸 수 있는 완전한 인증 시스템을 만들어보자! 🚀

package main

import (
    "crypto/rand"
    "encoding/base64"
    "fmt"
    "golang.org/x/crypto/bcrypt"
    "time"
)

// 사용자 구조체
type User struct {
    ID           int
    Username     string
    Email        string
    PasswordHash string
    CreatedAt    time.Time
    LastLogin    *time.Time
}

// 세션 구조체
type Session struct {
    Token     string
    UserID    int
    CreatedAt time.Time
    ExpiresAt time.Time
}

// 사용자 저장소 (실제로는 데이터베이스)
var users = make(map[string]*User)
var sessions = make(map[string]*Session)
var userIDCounter = 1

// 회원가입
func register(username, email, password string) (*User, error) {
    // 중복 확인
    if _, exists := users[username]; exists {
        return nil, fmt.Errorf("이미 존재하는 사용자명입니다")
    }
    
    // 비밀번호 검증
    if len(password) < 8 {
        return nil, fmt.Errorf("비밀번호는 최소 8자 이상이어야 합니다")
    }
    
    // 비밀번호 해싱
    hash, err := bcrypt.GenerateFromPassword([]byte(password), 12)
    if err != nil {
        return nil, err
    }
    
    // 사용자 생성
    user := &User{
        ID:           userIDCounter,
        Username:     username,
        Email:        email,
        PasswordHash: string(hash),
        CreatedAt:    time.Now(),
    }
    
    users[username] = user
    userIDCounter++
    
    return user, nil
}

// 로그인
func login(username, password string) (*Session, error) {
    // 사용자 찾기
    user, exists := users[username]
    if !exists {
        return nil, fmt.Errorf("사용자를 찾을 수 없습니다")
    }
    
    // 비밀번호 검증
    err := bcrypt.CompareHashAndPassword(
        []byte(user.PasswordHash),
        []byte(password),
    )
    if err != nil {
        return nil, fmt.Errorf("비밀번호가 틀렸습니다")
    }
    
    // 세션 생성
    session, err := createSession(user.ID)
    if err != nil {
        return nil, err
    }
    
    // 마지막 로그인 시간 업데이트
    now := time.Now()
    user.LastLogin = &now
    
    return session, nil
}

// 세션 생성
func createSession(userID int) (*Session, error) {
    // 랜덤 토큰 생성
    tokenBytes := make([]byte, 32)
    if _, err := rand.Read(tokenBytes); err != nil {
        return nil, err
    }
    
    token := base64.URLEncoding.EncodeToString(tokenBytes)
    
    session := &Session{
        Token:     token,
        UserID:    userID,
        CreatedAt: time.Now(),
        ExpiresAt: time.Now().Add(24 * time.Hour), // 24시간 유효
    }
    
    sessions[token] = session
    return session, nil
}

// 세션 검증
func validateSession(token string) (*User, error) {
    session, exists := sessions[token]
    if !exists {
        return nil, fmt.Errorf("유효하지 않은 세션입니다")
    }
    
    // 만료 확인
    if time.Now().After(session.ExpiresAt) {
        delete(sessions, token)
        return nil, fmt.Errorf("세션이 만료되었습니다")
    }
    
    // 사용자 찾기
    for _, user := range users {
        if user.ID == session.UserID {
            return user, nil
        }
    }
    
    return nil, fmt.Errorf("사용자를 찾을 수 없습니다")
}

// 로그아웃
func logout(token string) error {
    if _, exists := sessions[token]; !exists {
        return fmt.Errorf("세션을 찾을 수 없습니다")
    }
    
    delete(sessions, token)
    return nil
}

func main() {
    fmt.Println("🎉 완전한 사용자 인증 시스템")
    fmt.Println("================================\n")
    
    // 1. 회원가입
    fmt.Println("📝 1단계: 회원가입")
    user, err := register("gopher", "gopher@example.com", "securePass123!")
    if err != nil {
        fmt.Printf("❌ 회원가입 실패: %v\n", err)
        return
    }
    fmt.Printf("✅ 회원가입 성공! 사용자 ID: %d\n\n", user.ID)
    
    // 2. 로그인
    fmt.Println("🔐 2단계: 로그인")
    session, err := login("gopher", "securePass123!")
    if err != nil {
        fmt.Printf("❌ 로그인 실패: %v\n", err)
        return
    }
    fmt.Printf("✅ 로그인 성공!\n")
    fmt.Printf("세션 토큰: %s\n", session.Token[:20]+"...")
    fmt.Printf("만료 시간: %s\n\n", session.ExpiresAt.Format("2006-01-02 15:04:05"))
    
    // 3. 세션 검증
    fmt.Println("🔍 3단계: 세션 검증")
    validatedUser, err := validateSession(session.Token)
    if err != nil {
        fmt.Printf("❌ 세션 검증 실패: %v\n", err)
        return
    }
    fmt.Printf("✅ 세션 유효!\n")
    fmt.Printf("사용자: %s\n", validatedUser.Username)
    fmt.Printf("이메일: %s\n\n", validatedUser.Email)
    
    // 4. 로그아웃
    fmt.Println("👋 4단계: 로그아웃")
    err = logout(session.Token)
    if err != nil {
        fmt.Printf("❌ 로그아웃 실패: %v\n", err)
        return
    }
    fmt.Println("✅ 로그아웃 성공!\n")
    
    // 5. 로그아웃 후 세션 검증 시도
    fmt.Println("🔍 5단계: 로그아웃 후 세션 검증")
    _, err = validateSession(session.Token)
    if err != nil {
        fmt.Printf("❌ 예상대로 실패: %v\n", err)
    }
}

## 🌟 Go 보안 베스트 프랙티스 마지막으로 Go에서 보안 코드를 작성할 때 꼭 기억해야 할 베스트 프랙티스들을 정리해볼게! 💎

1. 민감한 데이터 메모리 관리

비밀번호나 키 같은 민감한 데이터는 사용 후 메모리에서 지워야 해! 🧹

package main

import (
    "crypto/rand"
    "fmt"
)

func secureOperation() {
    // 민감한 데이터를 위한 버퍼
    sensitiveData := make([]byte, 32)
    rand.Read(sensitiveData)
    
    // 데이터 사용...
    fmt.Printf("데이터 사용 중...\n")
    
    // 사용 후 메모리 초기화
    defer func() {
        for i := range sensitiveData {
            sensitiveData[i] = 0
        }
        fmt.Println("✅ 민감한 데이터 메모리 초기화 완료")
    }()
}

func main() {
    secureOperation()
}

2. 타이밍 공격 방어

문자열 비교 시 타이밍 공격을 방어하려면 상수 시간 비교를 사용해야 해! ⏱️

package main

import (
    "crypto/subtle"
    "fmt"
)

func main() {
    secret1 := "mySecretToken123"
    secret2 := "mySecretToken123"
    secret3 := "wrongToken456"
    
    // ❌ 나쁜 예: 일반 비교 (타이밍 공격 취약)
    if secret1 == secret2 {
        fmt.Println("일반 비교: 일치")
    }
    
    // ✅ 좋은 예: 상수 시간 비교
    if subtle.ConstantTimeCompare([]byte(secret1), []byte(secret2)) == 1 {
        fmt.Println("상수 시간 비교: 일치")
    }
    
    if subtle.ConstantTimeCompare([]byte(secret1), []byte(secret3)) == 1 {
        fmt.Println("상수 시간 비교: 일치")
    } else {
        fmt.Println("상수 시간 비교: 불일치")
    }
}

3. 환경변수로 비밀 관리

절대 코드에 비밀키를 하드코딩하지 마! 환경변수나 비밀 관리 시스템을 사용해야 해. 🔐

package main

import (
    "fmt"
    "os"
)

func getSecretKey() string {
    key := os.Getenv("SECRET_KEY")
    if key == "" {
        // 개발 환경에서만 기본값 사용
        if os.Getenv("ENV") == "development" {
            return "dev-secret-key-not-for-production"
        }
        panic("SECRET_KEY 환경변수가 설정되지 않았습니다!")
    }
    return key
}

func main() {
    // 환경변수 설정 (실제로는 시스템에서 설정)
    os.Setenv("SECRET_KEY", "production-secret-key-12345")
    
    secretKey := getSecretKey()
    fmt.Printf("비밀키 로드 완료 (길이: %d)\n", len(secretKey))
}

4. 에러 메시지 주의

에러 메시지에 너무 상세한 정보를 포함하면 공격자에게 힌트를 줄 수 있어! 🚨

package main

import (
    "fmt"
)

// ❌ 나쁜 예
func badLogin(username, password string) error {
    if username != "admin" {
        return fmt.Errorf("사용자 '%s'를 찾을 수 없습니다", username)
    }
    if password != "secret" {
        return fmt.Errorf("비밀번호가 틀렸습니다")
    }
    return nil
}

// ✅ 좋은 예
func goodLogin(username, password string) error {
    if username != "admin" || password != "secret" {
        return fmt.Errorf("사용자명 또는 비밀번호가 틀렸습니다")
    }
    return nil
}

func main() {
    // 나쁜 예: 사용자 존재 여부를 알 수 있음
    err := badLogin("hacker", "wrong")
    fmt.Printf("나쁜 예: %v\n", err)
    
    // 좋은 예: 어떤 정보도 노출하지 않음
    err = goodLogin("hacker", "wrong")
    fmt.Printf("좋은 예: %v\n", err)
}

## 🎓 마무리하며 와! 여기까지 정말 긴 여정이었어! 🎉 Go의 crypto 패키지를 활용한 암호화와 해싱에 대해 깊이 있게 알아봤어.

오늘 배운 핵심 내용 정리:

🔹 해싱과 암호화의 차이점
🔹 SHA-256으로 데이터 무결성 검증하기
🔹 솔트와 페퍼로 비밀번호 보안 강화하기
🔹 bcrypt로 안전한 비밀번호 저장하기
🔹 HMAC으로 메시지 인증하기
🔹 crypto/rand로 안전한 난수 생성하기
🔹 실전 보안 베스트 프랙티스

보안은 한 번 설정하고 끝나는 게 아니야. 계속해서 학습하고 업데이트해야 하는 영역이지. 새로운 공격 기법이 나오면 방어 기법도 발전해야 하니까! 🛡️

기억해! 완벽한 보안은 없어. 하지만 기본을 충실히 지키면 대부분의 공격을 막을 수 있어. 오늘 배운 내용들이 여러분의 애플리케이션을 더 안전하게 만드는 데 도움이 되길 바라! 💪

Go로 안전한 애플리케이션을 만드는 여정, 함께 화이팅! 🎯

Happy Coding! 🚀✨