C++ 보안 프로그래밍 | 메모리 안전·암호화·취약점 방지

들어가며: “우선 돌아가게”가 보안 버그를 만든다

왜 C++ 보안 프로그래밍이 중요한가?

C++는 금융, 게임, 임베디드, 서버 등 크리티컬 시스템에서 널리 쓰이지만, 수동 메모리 관리와 저수준 API 때문에 보안 취약점이 쉽게 발생한다. 버퍼 오버플로우로 메모리 손상·RCE(Remote Code Execution), 입력 검증 실패로 인젝션·DoS, 암호화 사용 실수로 데이터 유출·위조가 발생한다. 이 글에서는 실제 문제 시나리오부터 완전한 예제, 일반적인 에러, 프로덕션 패턴까지 다룬다. 목표

• 개념 이해

• 실전 구현

• 취약점 방지

• 실무 활용 요구 환경: C++17 이상 이 글을 읽으면

• 핵심 보안 개념을 이해할 수 있습니다.

• 버퍼 오버플로우·인젝션·암호화 실수를 예방할 수 있습니다.

• 실전에서 활용할 수 있는 패턴을 익힐 수 있습니다.

---

실제 문제 시나리오

시나리오 1: 할당 크기 오버플로우로 인한 힙 버퍼 오버플로우

사용자 입력: count=1000000, item_size=4096
개발자 코드: buffer = malloc(count * item_size);
결과: count * item_size가 size_t 범위를 넘어 0 또는 작은 값으로 래핑
→ malloc(작은 크기) 후 대량 쓰기 → 힙 손상, RCE

시나리오 2: rand()로 생성한 세션 토큰 예측

개발자: session_token = rand() % 1000000;
공격자: rand() 시드가 time(NULL)이면 1초 내 가능한 값만 브루트포스
→ 세션 하이재킹

시나리오 3: EVP 함수 반환값 미검사

개발자: EVP_EncryptUpdate(ctx, out, &len, in, in_len);  // 반환값 무시
실제: 내부 에러 시 0 반환, out에 쓰레기 또는 부분 암호문
→ 복호화 실패, 데이터 손상, 또는 정보 유출

시나리오 4: SQL 인젝션

개발자: query = "SELECT * FROM users WHERE id='" + user_input + "'";
공격자 입력: ' OR '1'='1
결과: 인증 우회, 전체 데이터 유출

시나리오 5: 포맷 스트링 버그

개발자: printf(user_input);  // 사용자 입력을 그대로 포맷
공격자 입력: %x%x%x%x%n
결과: 스택 메모리 유출, 임의 쓰기

---

1. 기본 개념

보안 프로그래밍의 핵심 원칙

flowchart TB
    subgraph input[입력]
        I1[사용자 입력]
        I2[네트워크]
        I3[파일]
    end
    subgraph validate[검증]
        V1[길이 검사]
        V2[타입 검사]
        V3[화이트리스트]
    end
    subgraph process[처리]
        P1[안전한 API]
        P2[범위 검사]
        P3[에러 처리]
    end
    subgraph output[출력]
        O1[인코딩]
        O2[권한 검사]
    end
    subgraph defense[방어]
        D1[최소 권한]
        D2[다층 방어]
        D3[실패 시 안전]
    end
    input --> validate
    validate --> process
    process --> output
    process --> defense

핵심 아이디어

• 검증: 모든 외부 입력을 신뢰하지 않고 검증
• 안전한 API: strcpy 대신 strncpy/std::string, sprintf 대신 snprintf
• 범위 검사: 인덱스·크기 계산 전 검증
• 최소 권한: 필요한 권한만 사용

---

2. 버퍼 오버플로우 방지

정수 오버플로우 방지

할당 크기 계산 시 a * b가 오버플로우하면 undefined behavior가 발생합니다. 반드시 사전 검사가 필요합니다.

#include <limits>
#include <cstddef>
#include <stdexcept>
// a * b가 오버플로우 없이 계산 가능한지 검사
bool safe_multiply(size_t a, size_t b, size_t& out) {
    if (a == 0 || b == 0) {
        out = 0;
        return true;
    }
    if (a > std::numeric_limits<size_t>::max() / b)
        return false;
    out = a * b;
    return true;
}
// 사용 예: 버퍼 할당 전 검사
void allocate_buffer(size_t count, size_t item_size) {
    size_t total;
    if (!safe_multiply(count, item_size, total))
        throw std::overflow_error("allocation size overflow");
    auto buf = std::make_unique<char[]>(total);
    // ...
}

스택 버퍼 오버플로우 방지

#include <cstdio>
#include <cstdarg>
#include <cstring>
#include <string>
#include <span>
// ❌ 위험: 크기 제한 없음
void bad_copy(char* dest, const char* src) {
    strcpy(dest, src);  // 버퍼 오버플로우
}
// ✅ 안전: snprintf 사용
bool safe_format(char* dest, size_t dest_size, const char* fmt, ...) {
    if (dest_size == 0) return false;
    va_list args;
    va_start(args, fmt);
    int n = vsnprintf(dest, dest_size, fmt, args);
    va_end(args);
    return n >= 0 && static_cast<size_t>(n) < dest_size;
}
// ✅ C++17: std::string 사용 (권장)
std::string safe_concat(const std::string& a, const std::string& b) {
    return a + b;  // 크기 자동 관리
}
// ✅ C++20: std::span으로 범위 명시
void process_span(std::span<const uint8_t> data) {
    for (size_t i = 0; i < data.size(); ++i) {
        // bounds-safe 접근
    }
}

배열 인덱스 검증

#include <vector>
#include <cassert>
template<typename T>
T& safe_at(std::vector<T>& v, size_t i) {
    if (i >= v.size())
        throw std::out_of_range("index out of range");
    return v[i];
}
// size_t로 받을 때 음수 방지: signed를 받으면 검증
template<typename T>
T& safe_at_signed(std::vector<T>& v, ptrdiff_t i) {
    if (i < 0 || static_cast<size_t>(i) >= v.size())
        throw std::out_of_range("index out of range");
    return v[static_cast<size_t>(i)];
}

완전한 버퍼 오버플로우 방지 예제

#include <memory>
#include <vector>
#include <string>
#include <stdexcept>
// 안전한 문자열 복사 (C 스타일)
bool safe_str_copy(char* dest, size_t dest_size, const char* src) {
    if (!dest || !src || dest_size == 0) return false;
    size_t src_len = strnlen(src, dest_size - 1);
    if (src_len >= dest_size) return false;
    memcpy(dest, src, src_len + 1);
    return true;
}
// 안전한 문자열 연결 (C 스타일)
bool safe_str_append(char* dest, size_t dest_size, const char* src) {
    if (!dest || !src || dest_size == 0) return false;
    size_t used = strnlen(dest, dest_size);
    if (used >= dest_size) return false;
    size_t src_len = strnlen(src, dest_size - used - 1);
    if (used + src_len >= dest_size) return false;
    memcpy(dest + used, src, src_len + 1);
    return true;
}
// C++ 스타일: std::string 사용 (권장)
std::string safe_join(const std::vector<std::string>& parts, const std::string& sep) {
    std::string result;
    for (size_t i = 0; i < parts.size(); ++i) {
        if (i > 0) result += sep;
        result += parts[i];
    }
    return result;
}

---

3. 인젝션 방지

SQL 인젝션 방지

C++에서 SQL을 직접 문자열 조합할 때 인젝션이 발생합니다. 파라미터화된 쿼리 또는 prepared statement를 사용합니다.

#include <string>
#include <sstream>
// ❌ 위험: 문자열 연결
std::string bad_query(const std::string& user_id) {
    return "SELECT * FROM users WHERE id='" + user_id + "'";
    // user_id = "1' OR '1'='1" → 인증 우회
}
// ✅ 안전: 파라미터화 (SQLite 예시)
// sqlite3_stmt* stmt;
// sqlite3_prepare_v2(db, "SELECT * FROM users WHERE id=?", -1, &stmt, nullptr);
// sqlite3_bind_text(stmt, 1, user_id.c_str(), -1, SQLITE_TRANSIENT);
// ✅ 안전: 화이트리스트 검증 (ID가 숫자만 허용하는 경우)
bool is_valid_id(const std::string& id) {
    if (id.empty() || id.size() > 20) return false;
    for (char c : id) {
        if (c < '0' || c > '9') return false;
    }
    return true;
}

명령어 인젝션 방지

#include <string>
#include <cstdlib>
#include <vector>
#include <stdexcept>
// ❌ 위험: system()에 사용자 입력 전달
void bad_execute(const std::string& filename) {
    std::string cmd = "cat " + filename;  // filename = "file; rm -rf /"
    system(cmd.c_str());
}
// ✅ 안전: execvp 사용, 인자 배열로 분리 (POSIX: Linux/macOS)
#include <unistd.h>
#include <sys/wait.h>
void safe_execute(const std::string& program, const std::vector<std::string>& args) {
    std::vector<char*> argv;
    argv.push_back(const_cast<char*>(program.c_str()));
    for (const auto& a : args) {
        argv.push_back(const_cast<char*>(a.c_str()));
    }
    argv.push_back(nullptr);
    pid_t pid = fork();
    if (pid == 0) {
        execvp(program.c_str(), argv.data());
        _exit(127);
    }
    waitpid(pid, nullptr, 0);
}

포맷 스트링 버그 방지

#include <cstdio>
#include <string>
// ❌ 위험: 사용자 입력을 포맷으로 직접 사용
void bad_log(const char* user_input) {
    printf(user_input);  // user_input = "%x%x%n" → 스택 유출/쓰기
}
// ✅ 안전: %s로 문자열 출력
void safe_log(const char* user_input) {
    printf("%s", user_input);
}
// ✅ C++: std::cout 사용
#include <iostream>
void safe_log_cpp(const std::string& msg) {
    std::cout << msg << std::endl;
}

---

4. 암호화 안전 사용

암호학적 난수 생성

#include <openssl/rand.h>
#include <vector>
#include <stdexcept>
std::vector<uint8_t> secure_random_bytes(size_t n) {
    std::vector<uint8_t> buf(n);
    if (RAND_bytes(buf.data(), static_cast<int>(n)) != 1) {
        throw std::runtime_error("RAND_bytes failed");
    }
    return buf;
}
// 세션 토큰 생성 (32바이트 = 256비트)
std::vector<uint8_t> generate_session_token() {
    return secure_random_bytes(32);
}

HMAC-SHA256 (메시지 무결성 검증)

#include <openssl/evp.h>
#include <openssl/hmac.h>
#include <openssl/crypto.h>
#include <vector>
#include <cstring>
#include <stdexcept>
std::vector<uint8_t> hmac_sha256(const uint8_t* key, size_t key_len,
                                 const uint8_t* data, size_t data_len) {
    unsigned int len = 0;
    std::vector<uint8_t> out(EVP_MAX_MD_SIZE);
    unsigned char* result = HMAC(EVP_sha256(), key, static_cast<int>(key_len),
                                 data, static_cast<int>(data_len),
                                 out.data(), &len);
    if (!result) {
        throw std::runtime_error("HMAC failed");
    }
    out.resize(len);
    return out;
}
// 헬퍼: 바이트를 hex 문자열로
std::string bytes_to_hex(const std::vector<uint8_t>& bytes) {
    static const char hex[] = "0123456789abcdef";
    std::string s;
    for (uint8_t b : bytes) {
        s += hex[b >> 4];
        s += hex[b & 0xf];
    }
    return s;
}
// 타이밍 공격 방지: CRYPTO_memcmp 사용
bool verify_signature(const std::string& secret, const std::string& payload,
                     const std::string& received_hex) {
    auto mac = hmac_sha256(
        reinterpret_cast<const uint8_t*>(secret.data()), secret.size(),
        reinterpret_cast<const uint8_t*>(payload.data()), payload.size());
    std::string computed_hex = bytes_to_hex(mac);
    return computed_hex.size() == received_hex.size() &&
           CRYPTO_memcmp(computed_hex.data(), received_hex.data(),
                         computed_hex.size()) == 0;
}

AES-256-GCM 대칭 암호화 (인증 암호화)

#include <openssl/evp.h>
#include <openssl/rand.h>
#include <vector>
#include <stdexcept>
#include <cstring>
struct AesGcmResult {
    std::vector<uint8_t> ciphertext;
    std::vector<uint8_t> tag;  // 16 bytes for GCM
    std::vector<uint8_t> iv;   // 12 bytes recommended for GCM
};
AesGcmResult aes_gcm_encrypt(const uint8_t* key, size_t key_len,
                              const uint8_t* plaintext, size_t plain_len,
                              const uint8_t* aad, size_t aad_len) {
    if (key_len != 32) throw std::invalid_argument("key must be 32 bytes");
    EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
    if (!ctx) throw std::runtime_error("EVP_CIPHER_CTX_new failed");
    AesGcmResult result;
    result.iv.resize(12);
    if (RAND_bytes(result.iv.data(), 12) != 1) {
        EVP_CIPHER_CTX_free(ctx);
        throw std::runtime_error("RAND_bytes failed");
    }
    if (EVP_EncryptInit_ex(ctx, EVP_aes_256_gcm(), nullptr, key, result.iv.data()) != 1) {
        EVP_CIPHER_CTX_free(ctx);
        throw std::runtime_error("EVP_EncryptInit_ex failed");
    }
    if (aad_len > 0 && EVP_EncryptUpdate(ctx, nullptr, nullptr, aad, static_cast<int>(aad_len)) != 1) {
        EVP_CIPHER_CTX_free(ctx);
        throw std::runtime_error("EVP_EncryptUpdate AAD failed");
    }
    result.ciphertext.resize(plain_len + EVP_CIPHER_block_size(EVP_aes_256_gcm()));
    int out_len = 0;
    if (EVP_EncryptUpdate(ctx, result.ciphertext.data(), &out_len, plaintext, static_cast<int>(plain_len)) != 1) {
        EVP_CIPHER_CTX_free(ctx);
        throw std::runtime_error("EVP_EncryptUpdate failed");
    }
    result.ciphertext.resize(out_len);
    int final_len = 0;
    if (EVP_EncryptFinal_ex(ctx, result.ciphertext.data() + out_len, &final_len) != 1) {
        EVP_CIPHER_CTX_free(ctx);
        throw std::runtime_error("EVP_EncryptFinal_ex failed");
    }
    result.ciphertext.resize(out_len + final_len);
    result.tag.resize(16);
    if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_GET_TAG, 16, result.tag.data()) != 1) {
        EVP_CIPHER_CTX_free(ctx);
        throw std::runtime_error("EVP_CTRL_GCM_GET_TAG failed");
    }
    EVP_CIPHER_CTX_free(ctx);
    return result;
}

암호화 사용 시 주의사항

// ❌ 위험: ECB 모드 (패턴 노출)
// EVP_EncryptInit_ex(ctx, EVP_aes_256_ecb(), ...);
// ✅ 권장: GCM, CBC+HMAC 등 인증 암호화
// EVP_EncryptInit_ex(ctx, EVP_aes_256_gcm(), ...);
// ❌ 위험: IV/Nonce 재사용
// uint8_t iv[12] = {0};  // 고정 IV
// ✅ 권장: 매 암호화마다 새 IV 생성
// RAND_bytes(iv, 12);

AES-GCM 복호화 (태그 검증 포함)

#include <openssl/evp.h>
#include <vector>
#include <stdexcept>
std::vector<uint8_t> aes_gcm_decrypt(const uint8_t* key, size_t key_len,
                                     const uint8_t* iv, size_t iv_len,
                                     const uint8_t* ciphertext, size_t cipher_len,
                                     const uint8_t* tag, size_t tag_len,
                                     const uint8_t* aad, size_t aad_len) {
    if (key_len != 32 || iv_len != 12 || tag_len != 16)
        throw std::invalid_argument("invalid key/iv/tag length");
    EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
    if (!ctx) throw std::runtime_error("EVP_CIPHER_CTX_new failed");
    if (EVP_DecryptInit_ex(ctx, EVP_aes_256_gcm(), nullptr, key, iv) != 1) {
        EVP_CIPHER_CTX_free(ctx);
        throw std::runtime_error("EVP_DecryptInit_ex failed");
    }
    if (aad_len > 0 && EVP_DecryptUpdate(ctx, nullptr, nullptr, aad, static_cast<int>(aad_len)) != 1) {
        EVP_CIPHER_CTX_free(ctx);
        throw std::runtime_error("EVP_DecryptUpdate AAD failed");
    }
    std::vector<uint8_t> plaintext(cipher_len);
    int out_len = 0;
    if (EVP_DecryptUpdate(ctx, plaintext.data(), &out_len, ciphertext, static_cast<int>(cipher_len)) != 1) {
        EVP_CIPHER_CTX_free(ctx);
        throw std::runtime_error("EVP_DecryptUpdate failed");
    }
    // 태그 설정: 반드시 DecryptFinal 전에 호출
    if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_TAG, 16, const_cast<uint8_t*>(tag)) != 1) {
        EVP_CIPHER_CTX_free(ctx);
        throw std::runtime_error("EVP_CTRL_GCM_SET_TAG failed");
    }
    int final_len = 0;
    if (EVP_DecryptFinal_ex(ctx, plaintext.data() + out_len, &final_len) != 1) {
        EVP_CIPHER_CTX_free(ctx);
        throw std::runtime_error("복호화 실패: 태그 불일치 (데이터 변조됨)");
    }
    plaintext.resize(out_len + final_len);
    EVP_CIPHER_CTX_free(ctx);
    return plaintext;
}

주의: EVP_DecryptFinal_ex가 실패하면 태그 불일치 = 데이터 변조를 의미합니다. 이 경우 평문을 사용하면 안 됩니다.

SHA-256 해시 (파일·메시지 무결성)

#include <openssl/evp.h>
#include <vector>
#include <stdexcept>
std::vector<uint8_t> sha256(const uint8_t* data, size_t len) {
    std::vector<uint8_t> out(EVP_MAX_MD_SIZE);
    unsigned int out_len = 0;
    EVP_MD_CTX* ctx = EVP_MD_CTX_new();
    if (!ctx) throw std::runtime_error("EVP_MD_CTX_new failed");
    if (EVP_DigestInit_ex(ctx, EVP_sha256(), nullptr) != 1 ||
        EVP_DigestUpdate(ctx, data, len) != 1 ||
        EVP_DigestFinal_ex(ctx, out.data(), &out_len) != 1) {
        EVP_MD_CTX_free(ctx);
        throw std::runtime_error("SHA256 failed");
    }
    EVP_MD_CTX_free(ctx);
    out.resize(out_len);
    return out;
}

---

5. 시큐어 메모리 관리

시큐어 메모리 제로화

#include <openssl/crypto.h>
#include <vector>
#include <cstring>
// memset은 컴파일러가 "dead store"로 최적화 제거할 수 있음
// OPENSSL_cleanse는 안전하게 덮어쓰고 최적화되지 않도록 설계됨
void secure_zero(void* ptr, size_t len) {
    OPENSSL_cleanse(ptr, len);
}
// 사용 예: 키 사용 후 제로화
void use_key_then_clear(std::vector<uint8_t>& key) {
    // ... 키 사용 ...
    secure_zero(key.data(), key.size());
    key.clear();
}

RAII로 리소스 관리

#include <memory>
#include <openssl/evp.h>
#include <openssl/ssl.h>
struct EVP_PKEY_Deleter { void operator()(EVP_PKEY* p) const { EVP_PKEY_free(p); } };
using UniqueEVP_PKEY = std::unique_ptr<EVP_PKEY, EVP_PKEY_Deleter>;
struct EVP_CIPHER_CTX_Deleter { void operator()(EVP_CIPHER_CTX* p) const { EVP_CIPHER_CTX_free(p); } };
using UniqueEVP_CIPHER_CTX = std::unique_ptr<EVP_CIPHER_CTX, EVP_CIPHER_CTX_Deleter>;
// 사용 예: 자동 해제
UniqueEVP_PKEY key(EVP_PKEY_new());
if (!key) {
    // 에러 처리
    return;
}
// key가 스코프를 벗어나면 자동으로 EVP_PKEY_free 호출

---

6. 자주 발생하는 에러와 해결법

문제 1: “AddressSanitizer: heap-buffer-overflow” 에러

원인: 버퍼 크기를 넘어서 쓰기 해결법:

// ❌ 잘못된 코드
void process(char* buf, size_t len) {
    for (size_t i = 0; i <= len; ++i) {  // i <= len → 오버플로우
        buf[i] = 0;
    }
}
// ✅ 올바른 코드
void process(char* buf, size_t len) {
    for (size_t i = 0; i < len; ++i) {
        buf[i] = 0;
    }
}

문제 2: “EVP_EncryptUpdate failed” 에러

원인: OpenSSL 함수 반환값 미검사, 또는 에러 큐에 이전 에러가 남아 있음 해결법:

// ✅ 모든 반환값 검사
int ret = EVP_EncryptUpdate(ctx, out, &len, in, in_len);
if (ret != 1) {
    std::cerr << "EVP_EncryptUpdate failed: " << get_openssl_errors() << "\n";
    return -1;
}

문제 3: “Segmentation fault” on null pointer

원인: 포인터 검증 없이 역참조 해결법:

// ❌ 잘못된 코드
void use(const char* ptr) {
    size_t len = strlen(ptr);  // ptr가 nullptr면 크래시
}
// ✅ 올바른 코드
void use(const char* ptr) {
    if (!ptr) return;
    size_t len = strlen(ptr);
}

문제 4: signed/unsigned 비교 경고

원인: size_t와 int 비교 시 부호 불일치 해결법:

// ❌ 잘못된 코드
for (int i = 0; i < vec.size(); ++i) {  // 비교 경고
    vec[i] = 0;
}
// ✅ 올바른 코드
for (size_t i = 0; i < vec.size(); ++i) {
    vec[i] = 0;
}

문제 5: “RAND_bytes failed” 에러

원인: OpenSSL 초기화 누락, 또는 엔트로피 소스 부족 해결법:

// OpenSSL 3.x 초기화
#include <openssl/ssl.h>
void init_openssl() {
#if OPENSSL_VERSION_NUMBER >= 0x30000000L
    if (OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS | OPENSSL_INIT_LOAD_CRYPTO_STRINGS, nullptr) != 1) {
        throw std::runtime_error("OpenSSL init failed");
    }
#else
    SSL_library_init();
    SSL_load_error_strings();
    OpenSSL_add_all_algorithms();
#endif
}
// main에서 프로그램 시작 시 한 번 호출
int main() {
    init_openssl();
    // ...
}

문제 6: “EVP_DecryptFinal_ex failed: tag mismatch”

원인: GCM 태그 불일치 = 데이터 변조 또는 키/IV 오류 해결법: 태그 불일치 시 평문을 절대 사용하지 말 것. 에러 로그만 남기고 실패 처리.

if (EVP_DecryptFinal_ex(ctx, plaintext.data() + out_len, &final_len) != 1) {
    // 태그 불일치 = 변조된 데이터
    EVP_CIPHER_CTX_free(ctx);
    throw std::runtime_error("복호화 실패: 데이터 무결성 검증 실패");
}

---

7. 모범 사례

입력 검증

#include <string>
#include <algorithm>
#include <cctype>
// 화이트리스트: 허용된 문자만 통과
bool is_alphanumeric(const std::string& s) {
    return std::all_of(s.begin(), s.end(), [](unsigned char c) {
        return std::isalnum(c);
    });
}
// 길이 제한
bool validate_input(const std::string& input, size_t max_len = 1024) {
    if (input.empty() || input.size() > max_len) return false;
    if (!is_alphanumeric(input)) return false;
    return true;
}

에러 처리 시 정보 노출 방지

// ❌ 위험: 내부 경로·스택 트레이스 노출
catch (const std::exception& e) {
    log_to_user("Error: " + std::string(e.what()));  // /home/user/secret.key
}
// ✅ 안전: 사용자에게는 일반 메시지만
catch (const std::exception& e) {
    log_internal("internal error: " + std::string(e.what()));
    log_to_user("처리 중 오류가 발생했습니다. 다시 시도해 주세요.");
}

최소 권한 원칙

// 파일 권한: 필요한 권한만 부여
// chmod 600 secret.key  (소유자만 읽기/쓰기)
// 프로세스: 권한 상승 필요 시 최소 권한으로 실행
// setuid/setgid 사용 시 필요한 작업만 수행 후 권한 낮추기

---

8. 프로덕션 패턴

보안 로깅

#include <iostream>
#include <fstream>
#include <chrono>
#include <iomanip>
// 민감 정보 마스킹
std::string mask_sensitive(const std::string& secret, size_t visible = 4) {
    if (secret.size() <= visible) return "***";
    return secret.substr(0, visible) + std::string(secret.size() - visible, '*');
}
void secure_log(const std::string& msg, const std::string& api_key = "") {
    auto now = std::chrono::system_clock::now();
    auto time = std::chrono::system_clock::to_time_t(now);
    std::cerr << std::put_time(std::localtime(&time), "%Y-%m-%d %H:%M:%S")
              << " " << msg;
    if (!api_key.empty()) {
        std::cerr << " (key=" << mask_sensitive(api_key) << ")";
    }
    std::cerr << std::endl;
}

키 관리

#include <vector>
#include <memory>
#include <openssl/crypto.h>
// 키를 가능한 한 짧은 시간만 메모리에 보관
class ScopedKey {
    std::vector<uint8_t> key_;
public:
    explicit ScopedKey(size_t size) : key_(size) {}
    ~ScopedKey() {
        secure_zero(key_.data(), key_.size());
    }
    uint8_t* data() { return key_.data(); }
    size_t size() const { return key_.size(); }
    // 복사 방지
    ScopedKey(const ScopedKey&) = delete;
    ScopedKey& operator=(const ScopedKey&) = delete;
};

Sanitizer 통합 (CI/CD)

# AddressSanitizer로 빌드
g++ -fsanitize=address -g -O1 -o myapp main.cpp
# UndefinedBehaviorSanitizer로 빌드
g++ -fsanitize=undefined -g -O1 -o myapp main.cpp
# CMake 예시
cmake -DCMAKE_CXX_FLAGS="-fsanitize=address -g -O1" ..

공격 흐름과 방어 계층

flowchart TB
    subgraph attack[공격 벡터]
        A1[버퍼 오버플로우]
        A2[SQL 인젝션]
        A3[포맷 스트링]
        A4[암호화 취약점]
    end
    subgraph defense[방어 계층]
        D1[입력 검증]
        D2[안전한 API]
        D3[범위 검사]
        D4[에러 처리]
    end
    A1 --> D1
    A1 --> D2
    A2 --> D1
    A3 --> D2
    A4 --> D4
    D1 --> D2
    D2 --> D3
    D3 --> D4

OpenSSL 에러 큐 확인

#include <openssl/err.h>
#include <sstream>
#include <string>
std::string get_openssl_errors() {
    std::ostringstream oss;
    unsigned long err;
    while ((err = ERR_get_error()) != 0) {
        char buf[256];
        ERR_error_string_n(err, buf, sizeof(buf));
        oss << buf << "; ";
    }
    return oss.str();
}
// 사용 예: 암호화 실패 시
if (EVP_EncryptUpdate(ctx, out, &len, in, in_len) != 1) {
    std::cerr << "암호화 실패: " << get_openssl_errors() << "\n";
    return -1;
}

Use-After-Free 방지

#include <memory>
// ❌ 위험: raw pointer, 해제 후 사용 가능
int* bad_alloc() {
    int* p = new int(42);
    delete p;
    return p;  // use-after-free
}
// ✅ 안전: unique_ptr 사용
std::unique_ptr<int> good_alloc() {
    return std::make_unique<int>(42);
}
// ✅ 안전: shared_ptr (공유 소유권 필요 시)
std::shared_ptr<int> shared_alloc() {
    return std::make_shared<int>(42);
}

Double-Free 방지

#include <memory>
// ❌ 위험: 수동 해제
void bad_free(int* p) {
    delete p;
    delete p;  // double-free
}
// ✅ 안전: unique_ptr (소멸자에서 한 번만 해제)
void good_free() {
    auto p = std::make_unique<int>(42);
    // p가 스코프를 벗어나면 자동으로 한 번만 해제
}

정적 분석 및 Sanitizer 활용

도구	용도	사용 시점
AddressSanitizer	힙/스택 버퍼 오버플로우, use-after-free	테스트 빌드
UndefinedBehaviorSanitizer	정수 오버플로우, null 역참조	테스트 빌드
ThreadSanitizer	데이터 레이스	멀티스레드 테스트
Clang-Tidy	정적 분석, 코딩 스타일	CI/CD
Coverity	정적 분석, 취약점 탐지	CI/CD

프로덕션 배포 전 체크

// 1. 디버그 심볼 제거 (프로덕션)
// strip myapp
// 2. PIE (Position Independent Executable) 활성화
// -fPIE -pie
// 3. 스택 보호 (스택 카나리)
// -fstack-protector-strong (GCC/Clang 기본)
// 4. RELRO (Relocation Read-Only)
// -Wl,-z,relro,-z,now

---

9. 구현 체크리스트

보안 검사 항목

• 모든 외부 입력 검증 (길이, 타입, 화이트리스트)
• strcpy, sprintf 대신 strncpy, snprintf 또는 std::string 사용
• 할당 크기 계산 시 오버플로우 검사
• 배열 인덱스 접근 전 범위 검사
• SQL/명령어 인젝션 방지 (파라미터화, 화이트리스트)
• 포맷 스트링 버그 방지 (%s 사용)
• 암호화: rand() 대신 RAND_bytes() 사용
• 암호화: ECB 대신 GCM/CBC+HMAC 사용
• IV/Nonce 매 암호화마다 새로 생성
• OpenSSL 등 모든 반환값 검사
• 민감 데이터 사용 후 시큐어 제로화
• 에러 메시지에 내부 정보 노출 방지

---

10. 정리

항목	설명
버퍼 오버플로우	safe_multiply, snprintf, std::string, std::span
인젝션	파라미터화, 화이트리스트, execvp
암호화	RAND_bytes, AES-GCM, CRYPTO_memcmp
메모리	OPENSSL_cleanse, RAII
검증	입력 검증, 반환값 검사
핵심 원칙:

1. 신뢰하지 않고 검증: 모든 외부 입력 검증
2. 안전한 API 사용: 위험한 함수 대체
3. 다층 방어: 한 단계 실패해도 다음 단계로 보호
4. 실패 시 안전: 에러 시 기본 거부

---

자주 묻는 질문 (FAQ)

Q. 이 내용을 실무에서 언제 쓰나요?

A. 금융 시스템, 인증 서버, 개인정보 처리, 보안 크리티컬 시스템 등에 필수적입니다. 실무에서는 위 본문의 예제와 선택 가이드를 참고해 적용하면 됩니다.

Q. 선행으로 읽으면 좋은 글은?

A. 각 글 하단의 이전 글 링크를 따라가면 순서대로 배울 수 있습니다. C++ 시리즈 목차에서 전체 흐름을 확인할 수 있습니다.

Q. 더 깊이 공부하려면?

A. cppreference와 해당 라이브러리 공식 문서를 참고하세요. 글 말미의 참고 자료 링크도 활용하면 좋습니다. 한 줄 요약: 메모리 안전·암호화·취약점 방지를 마스터할 수 있습니다.

관련 글

• C++ Buffer Overflow
• C++ 메모리 누수 | 서버 다운시킨 실제 사례와 Valgrind로 찾는 5가지 패턴
• C++ Exception Safety

---

같이 보면 좋은 글 (내부 링크)

이 주제와 연결되는 다른 글입니다.

• C++ 보안 코딩 가이드: 오버플로우 방지와 암호화 라이브러리(OpenSSL) 실전 연동 [#43-2]
• C++ Sanitizers | ASan·TSan으로 메모리 버그·data race 자동 탐지
• C++ 제약된 환경에서의 C++: Exception과 RTTI 없이 안전한 코드 짜기 [#42-1]

---

이 글에서 다루는 키워드 (관련 검색어)

C++, 보안, 암호화, 시큐어코딩, 취약점 등으로 검색하시면 이 글이 도움이 됩니다.