lang-c

Fornece padrões de engenharia de software em C moderno baseados na norma internacional ISO/IEC 9899 (com foco em C23 - ISO/IEC 9899:2024, C17, C11 e C99) e nas referências oficiais de en.cppreference.

SKILL.md

GitHub

Habilidade de IA: Engenharia de C Moderno (ISO/IEC 9899 & cppreference Specialist)

Esta skill orienta a inteligência artificial a atuar como especialista na linguagem C moderno, baseando-se estritamente na norma internacional oficial ISO/IEC 9899 (publicada pelo ISO JTC1/SC22/WG14 em iso-9899.info) e na documentação oficial de referência do C em en.cppreference.com/w/c. O foco principal é a versão mais recente C23 (ISO/IEC 9899:2024), mantendo suporte às revisões C17, C11 e C99 para a construção de sistemas de baixo nível de alta performance, seguros e isentos de Comportamentos Indefinidos (Undefined Behavior - UB).


🧭 Especificações da Linguagem C (en.cppreference.com/w/c)

Ao desenvolver em C, consulte a especificação e as tabelas formais dos cabeçalhos da Biblioteca Padrão no cppreference:

1. ISO/IEC 9899:2024 (C23 - Padrão Mais Recente)

  • Novas Palavras-Chave Nativas:
    • nullptr: Tipo estrito nullptr_t para ponteiros nulos, substituindo a ambiguidade numérica do NULL.
    • bool, true, false: Tipos booleanos nativos (sem dependência de <stdbool.h>).
    • constexpr: Avaliação de constantes imutáveis no tempo de compilação.
    • auto: Inferência automática de tipos na declaração de variáveis.
    • typeof e typeof_unqual: Operadores de inspeção de tipo em tempo de compilação.
    • static_assert, alignas, alignof, thread_local: Palavras-chave simplificadas (sem prefixo _).
  • Sintaxe Unificada de Atributos ([[attribute]]):
    • [[nodiscard]]: Alerta se o valor retornado por uma função for ignorado.
    • [[maybe_unused]]: Suprime avisos para variáveis ou parâmetros intencionalmente não utilizados.
    • [[deprecated("motivo")]]: Sinaliza funções ou tipos obsoletos.
    • [[likely]] / [[unlikely]]: Pistas de otimização para previsão de desvio (branch prediction).
    • [[fallthrough]]: Declaração explícita de queda intencional em instruções switch.
    • [[noreturn]]: Indica que a função nunca retorna (ex: exit, abort).
  • Novos Cabeçalhos e Funções de Segurança da Libc:
    • <stdckdint.h>: Operações aritméticas inteiras com checagem de estouro (checked integer arithmetic): ckd_add, ckd_sub, ckd_mul.
    • <stdbit.h>: Manipulação de bits padronizada: stdc_count_ones, stdc_leading_zeros, stdc_trailing_zeros, stdc_has_single_bit, stdc_bit_ceil.
    • memset_explicit: Sanitização de memória confidencial (senhas, chaves) imune a otimizações de eliminação do compilador.
    • memalignment: Verificação de alinhamento em bytes de ponteiros.
    • strdup e strndup: Alocação e duplicação dinâmica de strings padronizada na libc.
    • unreachable(): Macro de otimização para caminhos de código inalcançáveis (<stddef.h>).
  • Pré-processador e E/S Modernos:
    • #embed: Inclusão direta de recursos binários em dados no tempo de compilação.
    • #elifdef e #elifndef, macros __has_include e __VA_OPT__.
    • Formato de inteiros binários %b e %B em printf/scanf e literais 0b1010.
    • Inicialização nula com chaves vazias: struct Buffer buf = {};.

2. ISO/IEC 9899:2018 (C17) & 9899:2011 (C11)

  • <threads.h> (C11): Gestão de threads nativas (thrd_create, thrd_join), exclusão mútua (mtx_t, mtx_lock, mtx_unlock) e variáveis de condição (cnd_t).
  • <stdatomic.h> (C11): Tipos e operações atômicas sem lock (atomic_int, atomic_store, atomic_load, atomic_compare_exchange_strong).
  • _Generic: Seleção genérica de expressões baseada em tipos para macros polimórficas.
  • C17: Correções técnicas e esclarecimentos de ambiguidades da norma C11 sem adição de novas características sintáticas.

3. ISO/IEC 9899:1999 (C99)

  • Comentários de linha //, inicializadores nomeados (.field = val), literais compostos, inline, qualificador restrict, inteiros de largura fixa em <stdint.h> e tipos complexos <complex.h>.

🛠️ Diretrizes de Engenharia e Prevenção de Defeitos

1. Prevenção Estrita de Comportamento Indefinido (Undefined Behavior - UB)

  • Gestão de Memória Segura:
    • Sempre zere ou inicialize memória alocada dinamicamente (malloc/calloc).
    • Atribua nullptr (C23) ou NULL a ponteiros imediatamente após liberá-los com free().
    • Em alocações contendo dados de senhas ou chaves, utilize memset_explicit() antes do free().
  • Estouro de Inteiros: Evite estouro de inteiros sinalizados utilizando as funções checked de <stdckdint.h> (C23) ou verificações prévias de limites.
  • Evitar VLAs (Variable Length Arrays): Prefira alocação dinâmica em heap ou tamanhos fixos para evitar estouro de pilha (stack overflow).

2. Análise Estática e Sanitizers

  • Compilação com avisos estritos ativados: -Wall -Wextra -Wpedantic -Wconversion -Wshadow -std=c23.
  • Execução com Sanitizers durante os testes: -fsanitize=address,undefined,leak.

🧰 Padrões de Código C23 Recomendados (cppreference style)

1. Aritmética Inteira Segura e Atributos (<stdckdint.h> & C23)

#include <stdio.h>
#include <stdckdint.h>

[[nodiscard]] bool safe_multiply_and_add(int a, int b, int c, int *result) {
    int temp = 0;
    
    // Multiplicação com checagem de estouro em C23
    if (ckd_mul(&temp, a, b)) {
        return false; // Estouro detectado
    }
    
    // Adição com checagem de estouro em C23
    if (ckd_add(result, temp, c)) {
        return false; // Estouro detectado
    }
    
    return true;
}

int main(void) {
    int val = 0;
    if (safe_multiply_and_add(100000, 200000, 50, &val)) {
        printf("[+] Resultado seguro: %d\n", val);
    } else {
        printf("[-] Erro: Estouro de inteiro prevenido!\n");
    }
    return 0;
}

2. Manipulação de Bits Nativa C23 (<stdbit.h>)

#include <stdio.h>
#include <stdbit.h>
#include <stdint.h>

int main(void) {
    uint32_t mask = 0b00111010;
    
    // Funções padronizadas de contagem de bits em C23 (stdbit.h)
    unsigned int ones = stdc_count_ones(mask);
    bool is_power_of_two = stdc_has_single_bit(mask);

    printf("[+] Número de bits 1: %u\n", ones);
    printf("[+] É potência de dois? %s\n", is_power_of_two ? "sim" : "não");

    return 0;
}

3. Uso do nullptr, Atributos e Limpeza Segura de Memória (memset_explicit)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    char username[32];
    char secret_token[64];
} UserAccountSecure;

void wipe_sensitive_data(UserAccountSecure *account) {
    if (account == nullptr) {
        return;
    }
    
    // memset_explicit garante que o compilador não otimizará a exclusão
    memset_explicit(account->secret_token, 0, sizeof(account->secret_token));
}

int main(void) {
    // Inicialização vazia C23
    UserAccountSecure user = {};
    snprintf(user.username, sizeof(user.username), "alice");
    snprintf(user.secret_token, sizeof(user.secret_token), "secret_12345");

    printf("[+] Usuário ativado: %s\n", user.username);

    wipe_sensitive_data(&user);
    return 0;
}

⚙️ Configuração de Build System Moderno (CMakeLists.txt C23)

cmake_minimum_required(VERSION 3.25)
project(c23_modern_project C)

# Define o padrão C23 (ISO/IEC 9899:2024)
set(CMAKE_C_STANDARD 23)
set(CMAKE_C_STANDARD_REQUIRED ON)
set(CMAKE_C_EXTENSIONS OFF)

add_executable(app_main src/main.c)

# Bateria estrita de avisos do compilador
if (MSVC)
    target_compile_options(app_main PRIVATE /W4 /WX)
else()
    target_compile_options(app_main PRIVATE -Wall -Wextra -Wpedantic -Wconversion -Wshadow -Werror)
endif()

🔒 Questões de Segurança e Práticas Seguras

  • Buffer Overflows (CWE-121 / CWE-122): Nunca use funções inseguras como strcpy, strcat, gets ou sprintf. Substitua-as por equivalentes seguras como strncpy, strncat, snprintf ou funções de strings dinâmicas.
  • Estouros de Inteiro (CWE-190): Valide operações aritméticas antes da execução se o resultado for usado para alocação de memória (ex: malloc(width * height)). Use checagens seguras (ou <stdckdint.h> em C23).
  • Use-After-Free & Double Free (CWE-416 / CWE-415): Sempre anule ponteiros imediatamente após liberá-los (free(ptr); ptr = NULL;) para mitigar ponteiros órfãos.
  • Strings de Formatação (CWE-134): Nunca passe entradas do usuário diretamente como o formato de funções de impressão (use printf("%s", input) em vez de printf(input)).

🔗 Integração com Outras Skills

  • Para compilar componentes em C++23 e interoperabilidade com C, consulte lang-cpp.
  • Para realizar testes unitários seguros de funções em C utilizando o framework Criterion, consulte framework-criterion.
  • Para auditoria de vulnerabilidades de estouro de buffer, format strings e ponteiros em código C, consulte sast-code-review e appsec-owasp-asvs.