📌 핵심 용어 정리

호스트(Host): 컴파일을 실행하는 시스템 (예: 너의 개발 PC)
타겟(Target): 컴파일된 프로그램이 실행될 시스템 (예: 임베디드 디바이스)
빌드(Build): 컴파일러가 실행되는 시스템 (대부분 호스트와 동일)
툴체인(Toolchain): 컴파일러, 링커, 라이브러리 등 빌드에 필요한 도구 모음

🎯 주요 크로스 컴파일 툴체인

1. GNU 툴체인 (GCC 기반)

가장 널리 사용되는 오픈소스 툴체인이야. 거의 모든 플랫폼을 지원하고, 안정성이 검증되어 있어.

# ARM Linux용 GCC 툴체인 설치 (Ubuntu/Debian)
sudo apt-get install gcc-arm-linux-gnueabihf g++-arm-linux-gnueabihf

# ARM64용 툴체인
sudo apt-get install gcc-aarch64-linux-gnu g++-aarch64-linux-gnu

# Windows용 MinGW 툴체인
sudo apt-get install mingw-w64

2. LLVM/Clang 툴체인

모던하고 빠른 컴파일 속도를 자랑해. 특히 macOS와 iOS 개발에는 필수적이지.

# Clang 설치
sudo apt-get install clang

# 크로스 컴파일 시 타겟 지정
clang++ --target=arm-linux-gnueabihf -o output main.cpp

3. 플랫폼 특화 툴체인

특정 플랫폼을 위한 전용 툴체인도 있어. Android NDK, iOS SDK, Raspberry Pi 툴체인 등이 대표적이야.

📝 기본 CMakeLists.txt 구조

cmake_minimum_required(VERSION 3.15)
project(CrossPlatformApp VERSION 1.0.0 LANGUAGES CXX)

# C++ 표준 설정
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# 소스 파일 정의
set(SOURCES
    src/main.cpp
    src/utils.cpp
    src/platform_specific.cpp
)

# 실행 파일 생성
add_executable(${PROJECT_NAME} ${SOURCES})

# 플랫폼별 설정
if(WIN32)
    target_compile_definitions(${PROJECT_NAME} PRIVATE PLATFORM_WINDOWS)
elseif(APPLE)
    target_compile_definitions(${PROJECT_NAME} PRIVATE PLATFORM_MACOS)
elseif(UNIX)
    target_compile_definitions(${PROJECT_NAME} PRIVATE PLATFORM_LINUX)
endif()

# 컴파일 옵션
target_compile_options(${PROJECT_NAME} PRIVATE
    $<$<CXX_COMPILER_ID:MSVC>:/W4>
    $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-Wall -Wextra -pedantic>
)

Windows는 다른 플랫폼과 비교했을 때 몇 가지 독특한 점이 있어:

1. 런타임 라이브러리 선택

MSVC를 사용할 때는 런타임 라이브러리 링크 방식을 선택해야 해. 정적 링크(/MT)와 동적 링크(/MD) 중 하나를 골라야 하는데, 이게 프로젝트 전체에 일관되게 적용되어야 해.

# CMake에서 런타임 라이브러리 설정
if(MSVC)
    set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
endif()

2. DLL 의존성 관리

Windows에서는 실행 파일과 같은 디렉토리나 시스템 PATH에 DLL이 있어야 해. 배포할 때 필요한 DLL을 모두 포함시켜야 한다는 점, 잊지 마!

# 필요한 DLL 복사 (CMake)
if(WIN32)
    add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
        COMMAND ${CMAKE_COMMAND} -E copy_if_different
        "${PROJECT_SOURCE_DIR}/libs/external.dll"
        $<TARGET_FILE_DIR:${PROJECT_NAME}>
    )
endif()

3. 경로 구분자 처리

Windows는 백슬래시(\)를 사용하지만, C++ 코드에서는 슬래시(/)도 잘 작동해. 하지만 std::filesystem을 사용하면 플랫폼 독립적으로 경로를 다룰 수 있어!

#include <filesystem>
namespace fs = std::filesystem;

// 플랫폼 독립적 경로 처리
fs::path config_path = fs::current_path() / "config" / "settings.ini";
std::cout << config_path.string() << std::endl;

Linux는 오픈소스 생태계의 중심이라 개발 도구가 풍부하지만, 배포판마다 차이가 있어 주의가 필요해.

1. 배포판별 차이

Ubuntu, Fedora, Arch Linux 등 배포판마다 기본 라이브러리 버전이 달라. 정적 링크를 사용하거나 AppImage 같은 포맷을 활용하면 호환성 문제를 줄일 수 있어.

# 정적 링크 옵션
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libgcc -static-libstdc++")

# 또는 완전 정적 빌드
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static")

2. RPATH 설정

공유 라이브러리를 사용할 때는 RPATH를 제대로 설정해야 해. 이게 없으면 실행 시 라이브러리를 찾지 못할 수 있어.

# CMake RPATH 설정
set(CMAKE_INSTALL_RPATH "$ORIGIN/../lib")
set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)

3. 권한 및 실행 속성

Linux에서는 실행 파일에 실행 권한이 필요해. 배포 시 이 점을 고려해야 하지.

# 설치 시 실행 권한 부여
install(TARGETS ${PROJECT_NAME}
    RUNTIME DESTINATION bin
    PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ
                GROUP_EXECUTE GROUP_READ
                WORLD_EXECUTE WORLD_READ
)

macOS는 특히 M1/M2 칩 도입 이후 ARM64 아키텍처 지원이 중요해졌어.

1. 유니버설 바이너리

Intel(x86_64)과 Apple Silicon(ARM64) 모두를 지원하는 유니버설 바이너리를 만들 수 있어.

# 유니버설 바이너리 빌드
set(CMAKE_OSX_ARCHITECTURES "x86_64;arm64")

# 또는 개별 빌드 후 lipo로 합치기
# lipo -create -output app_universal app_x86_64 app_arm64

2. 코드 서명 및 공증

macOS 10.15 이상에서는 앱 배포 시 코드 서명과 공증(Notarization)이 필요해. 이게 없으면 사용자가 실행할 때 경고가 뜨거든.

# 코드 서명 (개발자 인증서 필요)
codesign --force --deep --sign "Developer ID Application: Your Name" YourApp.app

# 공증 제출
xcrun altool --notarize-app --file YourApp.zip \
    --primary-bundle-id "com.yourcompany.yourapp" \
    --username "your@email.com" --password "@keychain:AC_PASSWORD"

3. 프레임워크 의존성

macOS는 시스템 프레임워크를 많이 사용해. CMake에서 이를 쉽게 링크할 수 있어.

if(APPLE)
    find_library(COCOA_LIBRARY Cocoa)
    find_library(IOKIT_LIBRARY IOKit)
    target_link_libraries(${PROJECT_NAME} 
        ${COCOA_LIBRARY}
        ${IOKIT_LIBRARY}
    )
endif()

📁 권장 디렉토리 구조

MyProject/
├── CMakeLists.txt              # 루트 CMake 파일
├── README.md
├── LICENSE
├── .gitignore
│
├── src/                        # 소스 코드
│   ├── main.cpp
│   ├── core/                   # 핵심 로직 (플랫폼 독립적)
│   │   ├── engine.cpp
│   │   └── engine.h
│   └── platform/               # 플랫폼별 구현
│       ├── windows/
│       │   └── window_impl.cpp
│       ├── linux/
│       │   └── window_impl.cpp
│       └── macos/
│           └── window_impl.cpp
│
├── include/                    # 공개 헤더 파일
│   └── myproject/
│       └── api.h
│
├── libs/                       # 외부 라이브러리
│   ├── external_lib1/
│   └── external_lib2/
│
├── toolchains/                 # 크로스 컴파일 툴체인 파일
│   ├── arm-linux.cmake
│   ├── mingw-w64.cmake
│   └── android-ndk.cmake
│
├── scripts/                    # 빌드 및 배포 스크립트
│   ├── build_all.sh
│   ├── package.sh
│   └── deploy.py
│
├── tests/                      # 테스트 코드
│   ├── unit_tests/
│   └── integration_tests/
│
└── docs/                       # 문서
    ├── build_instructions.md
    └── api_reference.md

// platform_detection.h
#ifndef PLATFORM_DETECTION_H
#define PLATFORM_DETECTION_H

// 플랫폼 감지
#if defined(_WIN32) || defined(_WIN64)
    #define PLATFORM_WINDOWS
    #ifdef _WIN64
        #define PLATFORM_WINDOWS_64
    #else
        #define PLATFORM_WINDOWS_32
    #endif
#elif defined(__APPLE__) || defined(__MACH__)
    #include <TargetConditionals.h>
    #if TARGET_OS_MAC
        #define PLATFORM_MACOS
    #elif TARGET_OS_IPHONE
        #define PLATFORM_IOS
    #endif
#elif defined(__linux__)
    #define PLATFORM_LINUX
    #if defined(__ANDROID__)
        #define PLATFORM_ANDROID
    #endif
#elif defined(__unix__)
    #define PLATFORM_UNIX
#endif

// 아키텍처 감지
#if defined(__x86_64__) || defined(_M_X64)
    #define ARCH_X64
#elif defined(__i386) || defined(_M_IX86)
    #define ARCH_X86
#elif defined(__aarch64__) || defined(_M_ARM64)
    #define ARCH_ARM64
#elif defined(__arm__) || defined(_M_ARM)
    #define ARCH_ARM
#endif

// 컴파일러 감지
#if defined(__clang__)
    #define COMPILER_CLANG
#elif defined(__GNUC__) || defined(__GNUG__)
    #define COMPILER_GCC
#elif defined(_MSC_VER)
    #define COMPILER_MSVC
#endif

#endif // PLATFORM_DETECTION_H

이제 이 헤더를 포함하면 어디서든 플랫폼을 확인할 수 있어:

#include "platform_detection.h"

void initializeSystem() {
#ifdef PLATFORM_WINDOWS
    // Windows 초기화
    initWinSock();
#elif defined(PLATFORM_LINUX)
    // Linux 초기화
    initPosixSignals();
#elif defined(PLATFORM_MACOS)
    // macOS 초기화
    initCocoaApp();
#endif
}

Conan은 C/C++를 위한 강력한 패키지 매니저야. Python의 pip나 Node.js의 npm처럼 의존성을 쉽게 관리할 수 있게 해줘.

설치 및 기본 사용법:

# Conan 설치
pip install conan

# 프로파일 감지
conan profile detect --force

# conanfile.txt 작성
[requires]
boost/1.81.0
openssl/3.1.0
fmt/9.1.0

[generators]
CMakeDeps
CMakeToolchain

[options]
boost:shared=False
openssl:shared=True

CMakeLists.txt에서 Conan 통합:

cmake_minimum_required(VERSION 3.15)
project(MyProject)

# Conan으로 설치한 의존성 찾기
find_package(Boost REQUIRED)
find_package(OpenSSL REQUIRED)
find_package(fmt REQUIRED)

add_executable(myapp main.cpp)

target_link_libraries(myapp
    Boost::boost
    OpenSSL::SSL
    fmt::fmt
)

크로스 컴파일 시 Conan 프로파일 사용:

# arm-linux-profile
[settings]
os=Linux
arch=armv7
compiler=gcc
compiler.version=11
compiler.libcxx=libstdc++11
build_type=Release

[buildenv]
CC=arm-linux-gnueabihf-gcc
CXX=arm-linux-gnueabihf-g++

# 프로파일 사용해서 의존성 설치
conan install . --profile=arm-linux-profile --build=missing

Microsoft가 만든 vcpkg도 훌륭한 선택지야. 특히 Windows 개발자들에게 친숙하고, CMake와의 통합이 매끄러워.

# vcpkg 설치 (Linux/macOS)
git clone https://github.com/Microsoft/vcpkg.git
cd vcpkg
./bootstrap-vcpkg.sh

# 라이브러리 설치
./vcpkg install boost:x64-linux
./vcpkg install openssl:x64-linux
./vcpkg install fmt:x64-linux

# 크로스 컴파일용 트리플렛
./vcpkg install boost:arm-linux
./vcpkg install boost:x64-windows
./vcpkg install boost:arm64-osx

CMake에서 vcpkg 사용:

cmake -B build -S . \
    -DCMAKE_TOOLCHAIN_FILE=[vcpkg root]/scripts/buildsystems/vcpkg.cmake

# 또는 환경변수 설정
export CMAKE_TOOLCHAIN_FILE=/path/to/vcpkg/scripts/buildsystems/vcpkg.cmake

1. 단위 테스트 (Unit Testing)

Google Test나 Catch2 같은 프레임워크를 사용하면 플랫폼 독립적인 테스트를 작성할 수 있어.

// CMakeLists.txt에 테스트 추가
enable_testing()

# Google Test 추가
include(FetchContent)
FetchContent_Declare(
    googletest
    GIT_REPOSITORY https://github.com/google/googletest.git
    GIT_TAG release-1.12.1
)
FetchContent_MakeAvailable(googletest)

# 테스트 실행 파일
add_executable(unit_tests
    tests/test_core.cpp
    tests/test_utils.cpp
)

target_link_libraries(unit_tests
    gtest_main
    myproject_lib
)

add_test(NAME UnitTests COMMAND unit_tests)

플랫폼별 테스트 케이스:

#include <gtest/gtest.h>
#include "platform_detection.h"

TEST(PlatformTest, FileSystemOperations) {
    // 플랫폼 독립적 테스트
    auto path = std::filesystem::temp_directory_path();
    EXPECT_TRUE(std::filesystem::exists(path));
}

#ifdef PLATFORM_WINDOWS
TEST(WindowsTest, RegistryAccess) {
    // Windows 전용 테스트
    // 레지스트리 접근 테스트
}
#endif

#ifdef PLATFORM_LINUX
TEST(LinuxTest, ProcFileSystem) {
    // Linux 전용 테스트
    EXPECT_TRUE(std::filesystem::exists("/proc/cpuinfo"));
}
#endif

2. CI/CD 파이프라인 구축

GitHub Actions, GitLab CI, Jenkins 등을 활용하면 여러 플랫폼에서 자동으로 빌드하고 테스트할 수 있어.

# .github/workflows/build.yml
name: Multi-Platform Build

on: [push, pull_request]

jobs:
  build-linux:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Install dependencies
        run: sudo apt-get install -y cmake g++
      - name: Build
        run: |
          mkdir build && cd build
          cmake ..
          make -j$(nproc)
      - name: Test
        run: cd build && ctest --output-on-failure

  build-windows:
    runs-on: windows-latest
    steps:
      - uses: actions/checkout@v3
      - name: Build
        run: |
          mkdir build
          cd build
          cmake ..
          cmake --build . --config Release
      - name: Test
        run: cd build && ctest -C Release --output-on-failure

  build-macos:
    runs-on: macos-latest
    steps:
      - uses: actions/checkout@v3
      - name: Build
        run: |
          mkdir build && cd build
          cmake ..
          make -j$(sysctl -n hw.ncpu)
      - name: Test
        run: cd build && ctest --output-on-failure

  build-cross-arm:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Install ARM toolchain
        run: sudo apt-get install -y gcc-arm-linux-gnueabihf g++-arm-linux-gnueabihf
      - name: Cross compile
        run: |
          mkdir build-arm && cd build-arm
          cmake -DCMAKE_TOOLCHAIN_FILE=../toolchains/arm-linux.cmake ..
          make -j$(nproc)

각 컴파일러마다 최적화 옵션이 조금씩 달라. 플랫폼별로 적절한 옵션을 설정해주는 게 중요해.

# CMake에서 플랫폼별 최적화 설정
if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
    # GCC/Clang 최적화
    set(CMAKE_CXX_FLAGS_RELEASE "-O3 -march=native -mtune=native -flto")
    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -ffast-math")
    
    # ARM 특화 최적화
    if(CMAKE_SYSTEM_PROCESSOR MATCHES "arm")
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfpu=neon -mfloat-abi=hard")
    endif()
    
elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
    # MSVC 최적화
    set(CMAKE_CXX_FLAGS_RELEASE "/O2 /GL /arch:AVX2")
    set(CMAKE_EXE_LINKER_FLAGS_RELEASE "/LTCG")
endif()

# 디버그 빌드 최적화 (디버깅 가능하면서도 적당한 속도)
set(CMAKE_CXX_FLAGS_DEBUG "-O1 -g")

최적화의 첫 단계는 측정이야. 어디가 느린지 알아야 개선할 수 있으니까!

플랫폼별 프로파일링 도구:

간단한 프로파일링 코드 예제:

#include <chrono>
#include <iostream>

class Timer {
    std::chrono::high_resolution_clock::time_point start;
    const char* name;
public:
    Timer(const char* n) : name(n) {
        start = std::chrono::high_resolution_clock::now();
    }
    
    ~Timer() {
        auto end = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
        std::cout << name << ": " << duration.count() << " μs\n";
    }
};

void criticalFunction() {
    Timer t("criticalFunction");
    // 측정할 코드
    for(int i = 0; i < 1000000; ++i) {
        // 작업 수행
    }
}

플랫폼마다 메모리 정렬 요구사항이 다를 수 있어. 특히 ARM 같은 아키텍처에서는 정렬되지 않은 메모리 접근이 성능 저하나 크래시를 일으킬 수 있어.

// 메모리 정렬 지정
struct alignas(16) AlignedData {
    float x, y, z, w;
};

// 캐시 라인 크기 고려 (보통 64바이트)
struct alignas(64) CacheAligned {
    int data[16];
};

// 컴파일러별 정렬 속성
#ifdef _MSC_VER
    #define ALIGN(n) __declspec(align(n))
#else
    #define ALIGN(n) __attribute__((aligned(n)))
#endif

ALIGN(32) float simd_data[8];

SIMD 최적화:

플랫폼별 SIMD 명령어를 활용하면 성능을 크게 향상시킬 수 있어.

#include <immintrin.h>  // Intel SSE/AVX

void vectorAdd(float* a, float* b, float* result, size_t size) {
#if defined(__AVX__)
    // AVX 사용 가능 (8개 float 동시 처리)
    for(size_t i = 0; i < size; i += 8) {
        __m256 va = _mm256_load_ps(&a[i]);
        __m256 vb = _mm256_load_ps(&b[i]);
        __m256 vr = _mm256_add_ps(va, vb);
        _mm256_store_ps(&result[i], vr);
    }
#elif defined(__ARM_NEON)
    // ARM NEON 사용 (4개 float 동시 처리)
    for(size_t i = 0; i < size; i += 4) {
        float32x4_t va = vld1q_f32(&a[i]);
        float32x4_t vb = vld1q_f32(&b[i]);
        float32x4_t vr = vaddq_f32(va, vb);
        vst1q_f32(&result[i], vr);
    }
#else
    // 일반 스칼라 연산
    for(size_t i = 0; i < size; ++i) {
        result[i] = a[i] + b[i];
    }
#endif
}

Android 앱에서 C++ 코드를 사용하려면 NDK(Native Development Kit)가 필요해.

1. NDK 설치 및 환경 설정

# Android Studio를 통해 NDK 설치하거나
# 직접 다운로드: https://developer.android.com/ndk/downloads

# 환경 변수 설정
export ANDROID_NDK_HOME=/path/to/android-ndk
export PATH=$PATH:$ANDROID_NDK_HOME

2. CMake 툴체인 파일 사용

# android-toolchain.cmake (NDK에 포함됨)
cmake -DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK_HOME/build/cmake/android.toolchain.cmake \
      -DANDROID_ABI=arm64-v8a \
      -DANDROID_PLATFORM=android-24 \
      -DANDROID_STL=c++_shared \
      -B build-android

# 지원되는 ABI
# - armeabi-v7a (32-bit ARM)
# - arm64-v8a (64-bit ARM)
# - x86 (32-bit Intel)
# - x86_64 (64-bit Intel)

3. Gradle 통합

// app/build.gradle
android {
    defaultConfig {
        externalNativeBuild {
            cmake {
                cppFlags "-std=c++17 -frtti -fexceptions"
                abiFilters 'arm64-v8a', 'armeabi-v7a'
            }
        }
    }
    
    externalNativeBuild {
        cmake {
            path "src/main/cpp/CMakeLists.txt"
            version "3.22.1"
        }
    }
}

iOS 개발은 macOS에서만 가능하지만, 크로스 컴파일 개념은 여전히 적용돼. 시뮬레이터(x86_64)와 실제 기기(ARM64)가 다른 아키텍처니까!

# iOS 툴체인 파일 (ios.toolchain.cmake)
set(CMAKE_SYSTEM_NAME iOS)
set(CMAKE_OSX_SYSROOT iphoneos)
set(CMAKE_OSX_ARCHITECTURES arm64)

# 시뮬레이터용
# set(CMAKE_OSX_SYSROOT iphonesimulator)
# set(CMAKE_OSX_ARCHITECTURES x86_64)

# 빌드
cmake -DCMAKE_TOOLCHAIN_FILE=ios.toolchain.cmake \
      -GXcode \
      -B build-ios

유니버설 프레임워크 생성:

# 기기용 빌드
cmake --build build-ios --config Release -- -sdk iphoneos

# 시뮬레이터용 빌드
cmake --build build-ios-sim --config Release -- -sdk iphonesimulator

# XCFramework로 합치기
xcodebuild -create-xcframework \
    -framework build-ios/Release-iphoneos/MyLib.framework \
    -framework build-ios-sim/Release-iphonesimulator/MyLib.framework \
    -output MyLib.xcframework

임베디드 Linux 시스템은 리소스가 제한적이라 최적화가 특히 중요해!

# Raspberry Pi 4 (ARM Cortex-A72) 툴체인
set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_PROCESSOR arm)

set(CMAKE_C_COMPILER arm-linux-gnueabihf-gcc)
set(CMAKE_CXX_COMPILER arm-linux-gnueabihf-g++)

# Raspberry Pi 특화 최적화
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mcpu=cortex-a72 -mfpu=neon-fp-armv8")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3 -ffast-math")

# 정적 링크 (의존성 최소화)
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libgcc -static-libstdc++")

크기 최적화 (임베디드 시스템에서 중요!):

# 불필요한 심볼 제거
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -s")

# 링크 타임 최적화
set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)

# 사용하지 않는 함수 제거
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ffunction-sections -fdata-sections")
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--gc-sections")

# 결과 확인
# arm-linux-gnueabihf-size myapp
# arm-linux-gnueabihf-strip myapp  # 추가 크기 감소

🔒 플랫폼별 보안 기능

1. 코드 서명 (Code Signing)

// Windows: Authenticode
signtool sign /f certificate.pfx /p password /t http://timestamp.server.com myapp.exe

// macOS: codesign
codesign --force --deep --sign "Developer ID Application: Your Name" MyApp.app

// Linux: AppImage 서명
gpg --detach-sign MyApp.AppImage

2. 메모리 보호 기법

// CMake에서 보안 플래그 활성화
if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
    # Stack canary (스택 오버플로우 감지)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fstack-protector-strong")
    
    # Position Independent Executable
    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
    
    # RELRO (Relocation Read-Only)
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-z,relro,-z,now")
    
    # NX bit (실행 방지)
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-z,noexecstack")
endif()

if(MSVC)
    # Control Flow Guard
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /guard:cf")
    
    # Data Execution Prevention
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /NXCOMPAT")
    
    # Address Space Layout Randomization
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /DYNAMICBASE")
endif()

3. 안전한 문자열 처리

#include <string_view>
#include <span>

// 버퍼 오버플로우 방지
void safeStringCopy(char* dest, size_t destSize, const char* src) {
#ifdef _MSC_VER
    strcpy_s(dest, destSize, src);
#else
    strncpy(dest, src, destSize - 1);
    dest[destSize - 1] = '\0';
#endif
}

// 현대적 C++ 방식 (더 안전)
void processData(std::string_view data) {
    // string_view는 복사 없이 안전하게 문자열 참조
}

void processBuffer(std::span<const uint8_t> buffer) {
    // span은 경계 검사를 제공
    if(buffer.size() < 10) return;
    // 안전한 접근
}

📋 프로젝트 구조

FileCryptor/
├── CMakeLists.txt
├── src/
│   ├── main.cpp
│   ├── crypto/
│   │   ├── aes.cpp
│   │   └── aes.h
│   └── platform/
│       ├── file_io.h
│       ├── windows_file.cpp
│       ├── posix_file.cpp
│       └── platform_utils.h
├── toolchains/
│   ├── linux-arm.cmake
│   ├── mingw-w64.cmake
│   └── android.cmake
└── tests/
    └── crypto_tests.cpp

💻 핵심 코드 구현

1. 플랫폼 추상화 인터페이스

// platform/file_io.h
#pragma once
#include <string>
#include <vector>
#include <memory>

class IFileIO {
public:
    virtual ~IFileIO() = default;
    virtual bool readFile(const std::string& path, std::vector<uint8_t>& data) = 0;
    virtual bool writeFile(const std::string& path, const std::vector<uint8_t>& data) = 0;
    virtual bool fileExists(const std::string& path) = 0;
    virtual uint64_t getFileSize(const std::string& path) = 0;
};

std::unique_ptr<IFileIO> createFileIO();

2. Windows 구현

// platform/windows_file.cpp
#ifdef _WIN32
#include "file_io.h"
#include <windows.h>
#include <fstream>

class WindowsFileIO : public IFileIO {
public:
    bool readFile(const std::string& path, std::vector<uint8_t>& data) override {
        std::ifstream file(path, std::ios::binary | std::ios::ate);
        if(!file) return false;
        
        auto size = file.tellg();
        data.resize(size);
        file.seekg(0);
        file.read(reinterpret_cast<char*>(data.data()), size);
        return file.good();
    }
    
    bool writeFile(const std::string& path, const std::vector<uint8_t>& data) override {
        std::ofstream file(path, std::ios::binary);
        if(!file) return false;
        
        file.write(reinterpret_cast<const char*>(data.data()), data.size());
        return file.good();
    }
    
    bool fileExists(const std::string& path) override {
        DWORD attr = GetFileAttributesA(path.c_str());
        return (attr != INVALID_FILE_ATTRIBUTES);
    }
    
    uint64_t getFileSize(const std::string& path) override {
        WIN32_FILE_ATTRIBUTE_DATA fileInfo;
        if(!GetFileAttributesExA(path.c_str(), GetFileExInfoStandard, &fileInfo))
            return 0;
        
        LARGE_INTEGER size;
        size.HighPart = fileInfo.nFileSizeHigh;
        size.LowPart = fileInfo.nFileSizeLow;
        return size.QuadPart;
    }
};

std::unique_ptr<IFileIO> createFileIO() {
    return std::make_unique<WindowsFileIO>();
}
#endif

3. POSIX (Linux/macOS) 구현

// platform/posix_file.cpp
#if defined(__linux__) || defined(__APPLE__)
#include "file_io.h"
#include <sys/stat.h>
#include <fstream>

class PosixFileIO : public IFileIO {
public:
    bool readFile(const std::string& path, std::vector<uint8_t>& data) override {
        std::ifstream file(path, std::ios::binary | std::ios::ate);
        if(!file) return false;
        
        auto size = file.tellg();
        data.resize(size);
        file.seekg(0);
        file.read(reinterpret_cast<char*>(data.data()), size);
        return file.good();
    }
    
    bool writeFile(const std::string& path, const std::vector<uint8_t>& data) override {
        std::ofstream file(path, std::ios::binary);
        if(!file) return false;
        
        file.write(reinterpret_cast<const char*>(data.data()), data.size());
        return file.good();
    }
    
    bool fileExists(const std::string& path) override {
        struct stat buffer;
        return (stat(path.c_str(), &buffer) == 0);
    }
    
    uint64_t getFileSize(const std::string& path) override {
        struct stat st;
        if(stat(path.c_str(), &st) != 0)
            return 0;
        return st.st_size;
    }
};

std::unique_ptr<IFileIO> createFileIO() {
    return std::make_unique<PosixFileIO>();
}
#endif

4. 메인 애플리케이션

// main.cpp
#include <iostream>
#include <string>
#include "platform/file_io.h"
#include "crypto/aes.h"

int main(int argc, char* argv[]) {
    if(argc < 4) {
        std::cout << "Usage: filecryptor [encrypt|decrypt] input output\n";
        return 1;
    }
    
    std::string mode = argv[1];
    std::string inputPath = argv[2];
    std::string outputPath = argv[3];
    
    auto fileIO = createFileIO();
    
    // 파일 읽기
    std::vector<uint8_t> data;
    if(!fileIO->readFile(inputPath, data)) {
        std::cerr << "Failed to read file: " << inputPath << "\n";
        return 1;
    }
    
    std::cout << "Read " << data.size() << " bytes from " << inputPath << "\n";
    
    // 암호화/복호화
    std::vector<uint8_t> result;
    if(mode == "encrypt") {
        result = AES::encrypt(data, "my-secret-key");
        std::cout << "Encrypted successfully\n";
    } else if(mode == "decrypt") {
        result = AES::decrypt(data, "my-secret-key");
        std::cout << "Decrypted successfully\n";
    } else {
        std::cerr << "Invalid mode: " << mode << "\n";
        return 1;
    }
    
    // 파일 쓰기
    if(!fileIO->writeFile(outputPath, result)) {
        std::cerr << "Failed to write file: " << outputPath << "\n";
        return 1;
    }
    
    std::cout << "Wrote " << result.size() << " bytes to " << outputPath << "\n";
    return 0;
}

5. CMakeLists.txt

cmake_minimum_required(VERSION 3.15)
project(FileCryptor VERSION 1.0.0 LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# 소스 파일
set(COMMON_SOURCES
    src/main.cpp
    src/crypto/aes.cpp
)

# 플랫폼별 소스
if(WIN32)
    list(APPEND PLATFORM_SOURCES src/platform/windows_file.cpp)
elseif(UNIX)
    list(APPEND PLATFORM_SOURCES src/platform/posix_file.cpp)
endif()

add_executable(filecryptor ${COMMON_SOURCES} ${PLATFORM_SOURCES})

target_include_directories(filecryptor PRIVATE src)

# 플랫폼별 링크
if(WIN32)
    # Windows 특별한 링크 없음
elseif(APPLE)
    # macOS 프레임워크
    target_link_libraries(filecryptor "-framework CoreFoundation")
elseif(UNIX)
    # Linux pthread
    target_link_libraries(filecryptor pthread)
endif()

# 설치 규칙
install(TARGETS filecryptor DESTINATION bin)

🐳 Docker를 활용한 멀티 플랫폼 빌드

1. 멀티 스테이지 Dockerfile

# Dockerfile.multiplatform
FROM ubuntu:22.04 AS base
RUN apt-get update && apt-get install -y \
    cmake \
    ninja-build \
    git \
    && rm -rf /var/lib/apt/lists/*

# Linux x86_64 빌드
FROM base AS build-linux-x64
RUN apt-get update && apt-get install -y g++
WORKDIR /app
COPY . .
RUN cmake -B build -G Ninja && cmake --build build
RUN cp build/filecryptor /output/filecryptor-linux-x64

# Linux ARM 크로스 컴파일
FROM base AS build-linux-arm
RUN apt-get update && apt-get install -y \
    gcc-arm-linux-gnueabihf \
    g++-arm-linux-gnueabihf
WORKDIR /app
COPY . .
COPY toolchains/linux-arm.cmake .
RUN cmake -B build -G Ninja -DCMAKE_TOOLCHAIN_FILE=linux-arm.cmake \
    && cmake --build build
RUN cp build/filecryptor /output/filecryptor-linux-arm

# Windows 크로스 컴파일
FROM base AS build-windows
RUN apt-get update && apt-get install -y mingw-w64
WORKDIR /app
COPY . .
COPY toolchains/mingw-w64.cmake .
RUN cmake -B build -G Ninja -DCMAKE_TOOLCHAIN_FILE=mingw-w64.cmake \
    && cmake --build build
RUN cp build/filecryptor.exe /output/filecryptor-windows.exe

# 최종 이미지 (모든 빌드 결과 수집)
FROM scratch AS export
COPY --from=build-linux-x64 /output/* /
COPY --from=build-linux-arm /output/* /
COPY --from=build-windows /output/* /

2. Docker Buildx로 멀티 아키텍처 빌드

# buildx 설정
docker buildx create --name multiplatform --use
docker buildx inspect --bootstrap

# 멀티 플랫폼 빌드 및 추출
docker buildx build \
    --platform linux/amd64,linux/arm64,linux/arm/v7 \
    --target export \
    --output type=local,dest=./dist \
    -f Dockerfile.multiplatform .

# 결과 확인
ls -lh dist/
# filecryptor-linux-x64
# filecryptor-linux-arm
# filecryptor-windows.exe

3. Docker Compose로 빌드 자동화

# docker-compose.yml
version: '3.8'

services:
  build-linux:
    image: gcc:12
    volumes:
      - .:/workspace
    working_dir: /workspace
    command: >
      bash -c "
        mkdir -p build-linux &&
        cd build-linux &&
        cmake .. &&
        make -j$(nproc)
      "
  
  build-windows:
    image: ubuntu:22.04
    volumes:
      - .:/workspace
    working_dir: /workspace
    command: >
      bash -c "
        apt-get update &&
        apt-get install -y cmake mingw-w64 &&
        mkdir -p build-windows &&
        cd build-windows &&
        cmake -DCMAKE_TOOLCHAIN_FILE=../toolchains/mingw-w64.cmake .. &&
        make -j$(nproc)
      "
  
  build-arm:
    image: ubuntu:22.04
    volumes:
      - .:/workspace
    working_dir: /workspace
    command: >
      bash -c "
        apt-get update &&
        apt-get install -y cmake gcc-arm-linux-gnueabihf g++-arm-linux-gnueabihf &&
        mkdir -p build-arm &&
        cd build-arm &&
        cmake -DCMAKE_TOOLCHAIN_FILE=../toolchains/linux-arm.cmake .. &&
        make -j$(nproc)
      "

# 실행
# docker-compose up

# meson.build
project('filecryptor', 'cpp',
  version : '1.0.0',
  default_options : ['cpp_std=c++17'])

sources = [
  'src/main.cpp',
  'src/crypto/aes.cpp',
]

# 플랫폼별 소스 추가
if host_machine.system() == 'windows'
  sources += 'src/platform/windows_file.cpp'
elif host_machine.system() in ['linux', 'darwin']
  sources += 'src/platform/posix_file.cpp'
endif

executable('filecryptor',
  sources,
  install : true)

# 크로스 컴파일 파일 (cross-arm.txt)
[binaries]
c = 'arm-linux-gnueabihf-gcc'
cpp = 'arm-linux-gnueabihf-g++'
ar = 'arm-linux-gnueabihf-ar'
strip = 'arm-linux-gnueabihf-strip'

[host_machine]
system = 'linux'
cpu_family = 'arm'
cpu = 'armv7'
endian = 'little'

# 빌드
# meson setup build --cross-file cross-arm.txt
# meson compile -C build

# BUILD
cc_binary(
    name = "filecryptor",
    srcs = [
        "src/main.cpp",
        "src/crypto/aes.cpp",
    ] + select({
        "@platforms//os:windows": ["src/platform/windows_file.cpp"],
        "@platforms//os:linux": ["src/platform/posix_file.cpp"],
        "@platforms//os:macos": ["src/platform/posix_file.cpp"],
    }),
    hdrs = [
        "src/crypto/aes.h",
        "src/platform/file_io.h",
    ],
    copts = ["-std=c++17"],
)

# 크로스 컴파일
# bazel build --platforms=@io_bazel_rules_go//go/toolchain:linux_arm64 //:filecryptor

❌ 문제 1: "Cannot find -lstdc++" 에러

원인: 크로스 컴파일 툴체인에 C++ 표준 라이브러리가 없음

해결:

# 필요한 라이브러리 설치
sudo apt-get install libstdc++-11-dev-armhf-cross

# 또는 정적 링크
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libstdc++")

❌ 문제 2: 실행 시 "cannot execute binary file"

원인: 잘못된 아키텍처로 컴파일됨

해결:

# 바이너리 정보 확인
file myapp
# 출력: myapp: ELF 32-bit LSB executable, ARM, ...

# 올바른 툴체인 사용 확인
which arm-linux-gnueabihf-g++

# CMake 캐시 삭제 후 재빌드
rm -rf build && mkdir build && cd build
cmake -DCMAKE_TOOLCHAIN_FILE=../toolchain.cmake ..

❌ 문제 3: 라이브러리 버전 불일치

원인: 호스트와 타겟의 라이브러리 버전이 다름

해결:

# 정적 링크 사용
set(BUILD_SHARED_LIBS OFF)

# 또는 타겟 시스템의 sysroot 사용
set(CMAKE_SYSROOT /path/to/target/sysroot)
set(CMAKE_FIND_ROOT_PATH ${CMAKE_SYSROOT})

# 의존성을 함께 배포
ldd myapp  # 필요한 .so 파일 확인
# 필요한 라이브러리를 함께 패키징

❌ 문제 4: 엔디안(Endianness) 문제

원인: 빅 엔디안과 리틀 엔디안 시스템 간 데이터 교환

해결:

#include <bit>  // C++20

// 엔디안 변환 함수
uint32_t swapEndian(uint32_t value) {
    return ((value & 0xFF000000) >> 24) |
           ((value & 0x00FF0000) >> 8) |
           ((value & 0x0000FF00) << 8) |
           ((value & 0x000000FF) << 24);
}

// 네트워크 바이트 순서 사용 (항상 빅 엔디안)
#include <arpa/inet.h>  // POSIX
uint32_t networkValue = htonl(hostValue);  // host to network
uint32_t hostValue = ntohl(networkValue);  // network to host

// C++20 방식
if constexpr (std::endian::native == std::endian::big) {
    // 빅 엔디안 처리
} else {
    // 리틀 엔디안 처리
}

❌ 문제 5: 플랫폼별 매크로 충돌

원인: Windows의 min/max 매크로 등이 C++ 코드와 충돌

해결:

// Windows.h 포함 전에
#define NOMINMAX  // min/max 매크로 비활성화
#define WIN32_LEAN_AND_MEAN  // 불필요한 헤더 제외
#include <windows.h>

// 또는 std::min/max 명시적 사용
int result = (std::min)(a, b);  // 괄호로 매크로 확장 방지

// CMake에서 전역 정의
if(WIN32)
    add_compile_definitions(NOMINMAX WIN32_LEAN_AND_MEAN)
endif()