Hur man skriver säker C-kod för att förhindra buffertöverflöden

Validering och Size Management

Även med säkra funktioner måste du validera ingångslängder, säkerställa korrekt buffertstorlekar och hantera eventuell truncation graciöst.

Kontrollera ingångslängder

Innan du kopierar eller bearbetar extern inmatning (användarinmatning, nätverksdata, filinnehåll), bestämma dess maximala acceptabla längd och avvisa eller trunkera data som överstiger den.

#define MAX_INPUT 255
char buffer[MAX_INPUT + 1]; // +1 for null
if (strlen(user_input) > MAX_INPUT) {
 // Handle error: reject or truncate
 fputs("Input too long", stderr);
 return -1;
}
strncpy(buffer, user_input, sizeof(buffer) - 1);
buffer[sizeof(buffer) - 1] = '\0';

Använd fixerade storleksbuffertar med kända gränser

När det är möjligt, definiera buffertar med en konstant storlek och genomdriva den genom hela koden. Undvik variabel-längd arrays (VLA) som kan orsaka stack överflöden om stora storlekar levereras. Istället fördela dynamiskt med explicita storlekskontroller.

Hantera godkännande explicit

Funktioner som ] och ] kan truncera data. Var medveten om returvärdet för att upptäcka truncation och besluta om de truncerade data är acceptabla eller om ett fel ska höjas. Att ignorera truncation kan lämna buffertar i ett oväntat tillstånd.

Kompilator säkerhetsflaggor och Runtime Protections

Moderna kompilatorer erbjuder flaggor som lägger till buffertöverflödesdetektering och begränsning utan kodändringar.

• [[]][]]]/ ]] - Insatser stack canaries (slumpmässiga värden) innan returadresser. Om en buffertöverflöde överskrider kanarien innan returadressen ändras, så gör programmet aborter innan exploaten slutförs.
• []] — Ersätter samtal till osäkra funktioner som ]]] och ]]]] med kontrollerade versioner som aborterar om destinationsbufferten är för liten. Krav [] eller högre optimering.
• []]] - Varnar om sårbarheter i formatsträngar som kan leda till överflöden av buffertar eller informationsläckor.
• [][] -- AddressSanitizer (ASan) instrumentkod för att upptäcka buffertöverflöden, användning-efter-fri och andra minnesfel vid driftstopp. Långsamt utförande men är ovärderligt för testning.
• []] - Undviker att optimera bort kontroller över flödet (använd försiktighet).

Operativsystemskydd

Stack kanarier är bara ett lager. Exploit mitigation teknik i moderna operativsystem inkluderar:

• ]] Data Execution Prevention (DEP) / NX bit - Marks stack och hög som icke-verkställbar, förhindrar skalkodexekvering.
• Address Space Layout Randomization (ASLR) - Randomizes minnesadresser (stack, hög, delade bibliotek) för att göra det svårare att förutsäga mål.
• Relocation Read-Only (RELRO) - Skyddar GOT (Global Offset Table) från överskrivning.

Att möjliggöra dessa skydd (vanligtvis standard) höjer ribban för exploatering men ersätter inte säker kodning.

Kodrevisioner och statisk analys

Mänsklig granskning kombinerad med automatiserad statisk analys kan fånga buffertöverflödesproblem tidigt. integrera dessa i ditt utvecklingsarbete.

• ] Manuell kodgranskning[ - Leta efter användning av osäkra funktioner, saknade storlekskontroller och slingor som skriver utöver buffertgränser.
• ]]Statiska analysverktyg - Verktyg som ]], ]]]]] ]]]]]]]]] och ]]] upptäcker potentiella överflöden, användning av farliga funktioner och fel som inte kan köras i CI-ledningar.
• Fuzzing[ -- Använd libFuzzer, AFL eller andra fuzzers för att automatiskt testa ingångshantering med oväntade data som kan utlösa överflöden.

Praktiska exempel på säker kod

Säker sträng kopia med gränskontroll

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

int safe_string_copy(char *dest, size_t dest_size, const char *src) {
 if (!dest || !src || dest_size == 0) {
 return -1; // Invalid parameters
 }
 size_t src_len = strlen(src);
 if (src_len >= dest_size) {
 // Source too large; truncation or error
 // Option: copy what fits and null-terminate
 strncpy(dest, src, dest_size - 1);
 dest[dest_size - 1] = '\0';
 return 1; // Truncation occurred
 }
 strncpy(dest, src, dest_size);
 // strncpy fills remaining with null, so dest_size fits; no need to null-terminate if src shorter
 return 0; // Success, no truncation
}

Säker Integer Handling för Buffert Storlekar

Buffertöverflöde kan också resultera från heltalsöverflöden när datorstorlekar. Kontrollera alltid aritmetik före tilldelning.

#include <stdlib.h>
#include <limits.h>
#include <errno.h>

void *safe_malloc_array(size_t nmemb, size_t size) {
 if (nmemb == 0 || size == 0) {
 return NULL; // Or handle zero-size allocation
 }
 if (nmemb > SIZE_MAX / size) {
 // Integer overflow would occur
 errno = ENOMEM;
 return NULL;
 }
 return malloc(nmemb * size);
}

Använda snprintf för formaterade strängar

char log_message[256];
int ret = snprintf(log_message, sizeof(log_message),
 "User %s logged in from %s", username, ip_address);
if (ret < 0) {
 // Output error
} else if ((size_t)ret >= sizeof(log_message)) {
 // Truncation occurred; handle if needed
}

Ytterligare bästa praxis

• ]Initialisera buffertar - Alltid nollinitialisera buffertar för att undvika att läcka oinitialiserat minne.
• ] Återkommande med obundet djup - Stack överflöden kan uppstå från djup återkommande; använd iteration eller gränsdjup.
• ] Använd ]] kvalificator - Hjälper kompilatorn att optimera och kan fånga aliasing problem, men inte direkt förhindra överflöden.
• ]] ]-korrekthet - Förhindrar oavsiktlig modifiering av ingångssträngar och genomdriver avsikt.
• ]] Implementera felhantering - ignorera inte returvärden från funktioner som ], ]], ], etc.

Resurser för vidare lärande

• ] SEI CERT C Coding Standard - Omfattande regler för säker C-kodning.
• ]CWE-120: Buffer Copy utan att kontrollera storleken på ingång - MITRE klassificering av buffert överflödessvagheter.
• ]OWASP Buffer Overflow - Praktisk vägledning från Open Web Application Security Project.
• GNU C Library Manual: String and Array Utilities - Dokumentation för säkra strängfunktioner.
• ]AddressSanitizer -- En snabb minnesfeldetektor.

Slutsats

Att förebygga buffertöverflöden i C är inte valfritt; det är ett grundläggande ansvar för alla utvecklare som arbetar med språket. Genom att förstå mekanismerna för överflöden, ersätta farliga funktioner med säkrare alternativ, rigoröst validera ingångar och storlekar, vilket möjliggör kompilatorskydd och använda statisk analys och testning, kan du dramatiskt minska risken för dessa sårbarheter. Ingen enda teknik är tillräcklig; försvar i djupet - kombinera kodning disciplin, kompilatorflaggor, OS mitigationer och thorough tester kodning kodning kodning