81 넘침을 묻는 법 — <stdckdint.h>

81.1 사후 검사라는 함정

가장 흔한 손수 짠 검사부터 본다.

int sum = a + b;
if (sum < a) { /* 넘쳤다 */ }        /* ← 이 검사가 사라질 수 있다 */

if (n != 0 && bytes / n != sz) { /* 넘쳤다 */ }   /* 맞지만 읽기 어렵다 */

그래서 컴파일러들이 저마다 확장을 내놓았다 — GCC와 Clang의 __builtin_add_overflow 계열, MSVC의 SafeInt, 여러 프로젝트의 자체 매크로. 잘 동작했지만 이식성이 없었고, 이식성을 확보하려면 프로젝트마다 같은 껍데기를 다시 짜야 했다. 65장의 strlcpy 이야기와 같은 무늬다 — 현실이 먼저 답을 찾고 표준이 뒤늦게 추인한다.

81.2 C23의 답 — ckd_add·ckd_sub·ckd_mul

/* 넘침을 값이 아니라 "일어났는가"로 받는다 — C23 <stdckdint.h> */
#include <limits.h>
#include <stdckdint.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

/* 흔한 할당 계산: 원소 n 개 x 크기 sz. 곱셈이 넘치면 그릇이 작아진다. */
static void *alloc_array(size_t n, size_t sz)
{
    size_t bytes;
    if (ckd_mul(&bytes, n, sz)) {       /* 참이면 넘쳤다 */
        printf("  the size arithmetic overflowed - nothing is allocated\n");
        return NULL;
    }
    return malloc(bytes);
}

int main(void)
{
    /* 판정과 결과 읽기를 반드시 갈라 적는다 (한 표현식에 섞으면 순서가 없다) */
    int r;
    bool over = ckd_add(&r, INT_MAX, 1);
    printf("INT_MAX = %d\n", INT_MAX);
    printf("ckd_add(INT_MAX, 1)  overflow? %s   r = %d (the wrapped value)\n", over ? "yes" : "no", r);

    over = ckd_add(&r, 1, 2);
    printf("ckd_add(1, 2)        overflow? %s   r = %d\n", over ? "yes" : "no", r);

    /* 타입이 섞여도 수학적 값으로 판정한다 */
    signed char c;
    over = ckd_add(&c, 200, 100);
    printf("signed char <- 300   overflow? %s   c = %d\n", over ? "yes" : "no", c);

    /* 부호 없는 뺄셈: 감아 도는 것은 정의된 동작이지만, 여기서도 "넘쳤다"고 알린다 */
    unsigned u;
    over = ckd_sub(&u, 3u, 5u);
    printf("unsigned  <- 3 - 5   overflow? %s   u = %u\n", over ? "yes" : "no", u);

    printf("\nsize arithmetic for an allocation\n");
    void *ok = alloc_array(1000, sizeof(int));
    printf("  1000 x %zu -> %s\n", sizeof(int), ok ? "allocated" : "refused");
    free(ok);
    void *bad = alloc_array(SIZE_MAX / 2, sizeof(int));
    printf("  SIZE_MAX/2 x %zu -> %s\n", sizeof(int), bad ? "allocated" : "refused");
    free(bad);
    return 0;
}

INT_MAX = 2147483647
ckd_add(INT_MAX, 1)  overflow? yes   r = -2147483648 (the wrapped value)
ckd_add(1, 2)        overflow? no   r = 3
signed char <- 300   overflow? yes   c = 44
unsigned  <- 3 - 5   overflow? yes   u = 4294967294

size arithmetic for an allocation
  1000 x 4 -> allocated
  the size arithmetic overflowed - nothing is allocated
  SIZE_MAX/2 x 4 -> refused

읽는 법은 이렇다. 세 매크로 모두 모양이 같다.

bool 넘쳤는가 = ckd_add(&결과, 왼쪽, 오른쪽);

약속이 네 가지다.

1. 무한 정밀도로 계산한 뒤 그릇에 넣는다. 판정은 “수학적 결과가 결과 타입에 들어가는가”이고, 중간 계산에서 넘치는 일이 없다. 그래서 인자의 타입이 서로 달라도, 심지어 인자보다 결과 타입이 좁아도 정확히 판정한다 — 예제의 signed char <- 300이 그 확인이다.
2. 결과 타입은 첫 인자(포인터)가 정한다. 인자들의 승격 규칙(28장)이 결과를 좌우하지 않는다는 뜻이라, “어느 타입으로 계산되는가”를 두고 고민할 일이 없다.
3. 넘쳐도 결과는 저장된다. 그 값은 결과 타입으로 감아 돈 값이다. 예제의 INT_MAX + 1이 -2147483648로 남은 것이 그것이다 — 부호 있는 값이라도 이 자리에서는 정의된 동작이라는 점이 중요하다.
4. 부호 없는 감아 돌기도 “넘쳤다”고 알린다. 예제의 3u - 5u가 그 확인이다. 값 자체는 정의된 결과(4294967294)지만, 검사 산술은 수학적 값과 달라졌음을 알린다. 크기 계산에서 이것이 필요한 성질이다.

printf("%s %d", ckd_add(&r, a, b) ? "넘침" : "정상", r);   /* 위험 */

81.3 어디에 쓰는가 — 크기 계산이 첫 번째다

예제 뒷부분의 alloc_array가 전형이다. 할당 크기 계산은 검사 산술이 가장 절실한 자리다. n * sz가 넘치면 작은 그릇을 얻고 큰 줄 알고 쓰는 상태가 되어, 곧바로 버퍼 넘침 사고로 이어진다. 유명한 취약점 여럿이 정확히 이 경로였다.

마지막 줄이 중요하다. 검사 산술은 계산의 넘침을 잡을 뿐, 애초에 값이 너무 큰 것을 걸러 주지는 않는다. 입력 해석 단계의 검사(66장)와 계산 단계의 검사는 서로를 대신하지 못한다.

81.4 이 도구가 없는 곳에서

C23 헤더를 아직 못 쓰는 환경이라면 두 단계로 대비한다.

#if defined(__has_include)
#  if __has_include(<stdckdint.h>)
#    include <stdckdint.h>
#    define HAVE_CKDINT 1
#  endif
#endif

#ifndef HAVE_CKDINT                      /* GCC·Clang 확장으로 메운다 */
#  define ckd_add(r, a, b) __builtin_add_overflow((a), (b), (r))
#  define ckd_sub(r, a, b) __builtin_sub_overflow((a), (b), (r))
#  define ckd_mul(r, a, b) __builtin_mul_overflow((a), (b), (r))
#endif

인자 순서가 다르다는 점만 주의하면 된다 — 표준은 결과 포인터가 앞, 컴파일러 내장은 뒤다. 이런 껍데기를 한 자리에 모아 두는 것이 57장에서 말한 이식성 층의 실제 모습이고, 제12부의 라이브러리도 같은 일을 한다.

넘침을 계약대로 묻는 법을 익혔다. 다음 장은 이 부의 마지막이자, C23이 언어에 손댄 가장 눈에 띄는 변화다 — 매크로였던 것들이 키워드가 된 이야기다.