YOUR C LEARNING COMPANION

Kahan se padhein?

Learning path
Sahi aur reliable CChapter 63 of 73

Defensive C aur security boundaries

Sizes/meanings validate, buffer contracts preserve, formats trusted aur hardening ki limits samjhein.

6 min readIntermediateC17 baseline
Offline reading
Is chapter mein8 sections

Program ko decide karna hota hai ki kaun-se inputs aur resource requests accept karega. Bounds checks, size calculations aur trust boundaries is decision ko clear banate hain. Defensive code ko protected resources aur regions ka clear model chahiye.

1. Storage limits ke saath meaning bhi validate karein

Bounded string unauthorized file name ya invalid state transition request kar sakti hai. Valid integer application quota exceed kar sakta hai. Length, syntax, authorization aur resource limits different questions hain. External data ko format strings/command languages jaisi control instructions se separate aur reviewable contracts wale interfaces choose karein.

2. Allocation arithmetic compute karne se pehle prove karein

Complete C17 program
#include <assert.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>

static bool storage_size(size_t count, size_t element_size, size_t extra, size_t *result)
{
    if (result == NULL) return false;
    if (element_size != 0 && count > (SIZE_MAX - extra) / element_size) return false;
    *result = count * element_size + extra;
    return true;
}

int main(void)
{
    size_t result = 99;
    bool accepted = storage_size(3, 4, 2, &result);
    assert(accepted && result == 14);
    bool rejected = storage_size(SIZE_MAX, 2, 1, &result);
    assert(!rejected && result == 14);
    bool empty = storage_size(0, 4, 2, &result);
    assert(empty && result == 2);
    bool zero_element = storage_size(SIZE_MAX, 0, 2, &result);
    assert(zero_element && result == 2);
    return 0;
}

Comparison multiplication aur addition dono guard karti hai. Extra size_t hai, isliye SIZE_MAX - extra representable hai; division pehle overflowing product compute nahi hone deti. Zero element size division-by-zero ke bina handled hai. Helper sirf size report karta hai, object allocate/access ki permission nahi. Caller meaningful count, zero-size policy, failure handling aur type/alignment contract enforce kare.

Unsigned wrap defined hai par huge request ko small allocation bana sakta hai. Signed overflow undefined hai. Negative count ko validation se pehle size_t convert karna huge positive value de sakta hai. Original domain validate, phir conversion aur har arithmetic step prove karein; sirf wrapped final result check nahi.

3. Buffer operation ka full contract visible rakhein

Complete C17 program
#include <assert.h>
#include <stdbool.h>
#include <stddef.h>
#include <string.h>

/* Source has length readable bytes; destination has capacity writable bytes. */
static bool copy_label(char *destination, size_t capacity, const char *source, size_t length)
{
    if (destination == NULL || source == NULL || length >= capacity) return false;
    if (memchr(source, '\0', length) != NULL) return false;
    memmove(destination, source, length);
    destination[length] = '\0';
    return true;
}

int main(void)
{
    char label[5] = "old";
    bool rejected = copy_label(label, sizeof label, "longer", 6);
    assert(!rejected && strcmp(label, "old") == 0);
    bool accepted = copy_label(label, sizeof label, "new", 3);
    assert(accepted && strcmp(label, "new") == 0);
    const char embedded[] = { 'a', '\0', 'b' };
    bool nul_rejected = copy_label(label, sizeof label, embedded, sizeof embedded);
    assert(!nul_rejected && strcmp(label, "new") == 0);
    char overlap[8] = "coded";
    bool moved = copy_label(overlap, sizeof overlap, overlap + 2, 3);
    assert(moved && strcmp(overlap, "ded") == 0);
    return 0;
}

Interface explicit readable source length accept, input NUL reject, terminator ki room reserve aur memmove se valid overlap allow karta hai. Rejection par destination unchanged rehti hai. Capacity check length + 1 fit hone ka proof bhi deta hai bina pehle sum compute kiye. Non-null argument claimed readable/writable regions establish nahi karta; live objects caller supply karta hai.

Function name mein n ya safe hona universal guarantee nahi. Memcpy valid nonoverlapping regions maangta hai; strncpy destination always terminate nahi karta; fgets sirf chunk de sakta hai. Exact contract aur return value padhein. Terminated string establish kiye bina storage ki length discover karne ke liye strlen use na karein.

4. Format string ko executable instructions ki tarah treat karein

Complete C17 program
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    const char *label = "progress 100%";
    if (printf("%s\n", label) < 0) return EXIT_FAILURE;
    return fflush(stdout) == EOF ? EXIT_FAILURE : EXIT_SUCCESS;
}

Fixed format conversion control karta hai aur label data rehta hai. Untrusted string ko format banane se missing/wrongly typed arguments request aur undefined behavior ho sakta hai; particular implementations par disclosure ya unintended writes consequences ho sakte hain. Har platform par guaranteed arbitrary-memory capability nahi. Fixed format ya suitable plain-text output function use karein.

5. Hardening design support karta hai, replace nahi

Warnings, stack protection, sanitizers, static analysis, reviews aur tests mistakes catch karne ke independent ways hain. Invalid pointer access ya unchecked arithmetic correct nahi banate. Suitable objects ki automatic storage duration hoti hai, lekin dynamically allocated memory ki ownership/release explicit aur ordinary array access mein required automatic bounds check nahi. Model ko C-manages-no-memory-at-all tak reduce na karein.

Diagnostics mein secrets protect aur exceeded limits ka behavior define karein. Standard rand cryptographic randomness interface nahi; secure key generation, authenticated communication aur platform permissions ko suitable dedicated facilities chahiye. Lesson memory/input boundaries develop karti hai, complete application-security ya cryptographic protocol design nahi.

Primary references aur aage ki reading

Aage badhne se pehle

  • Validation mein semantic domains, resource limits aur checked size arithmetic hain.
  • Pointer aur count contracts ko genuinely accessible regions phir bhi chahiye.
  • Defensive choices clear threat aur ownership model ke under specified risks reduce karti hain.
In ideas ko alag rakhein
Non-null pointer / Valid region
Non-null value akeli enough storage, lifetime, alignment ya permission prove nahi karti.
Apne words mein samjhaayein

Input-controlled element count ka space calculate aur allocate karne se pehle kya check karenge?

Optional: bolkar samjhein ya note rakhein. Tayyar hon toh aage badh sakte hain.

Apni understanding check karein

Optional hai. Answers save ya send nahi hote; chapter kabhi lock nahi hota.

Externally supplied data bounded buffer mein copy karne se pehle kya hona chahiye?
Har choice ki explanation padhein
  1. Claimed length ko capacity check kiye bina trust karein.

    Supplied length bhi input hai; woh receiving buffer ki bounds violate kar sakti hai.

  2. Operation safe banane ke liye buffer rename karein.

    Names intent communicate karte hain, valid copy enforce nahi karte.

  3. Copy contract ke liye length, capacity aur required arithmetic validate karein.

    ✓ Sahi reasoning. C string required ho to contract mein terminator ki space bhi account karein.

C17

Earlier edition ka quick reference

Existing section links aur saved passages ke liye retained. Connected ideas expanded lessons mein hain; exact corrections source review mein recorded hain.

Kyunki ISO C generally runtime bounds checks aur dynamically allocated memory release karne ki responsibility program par chhodti hai, historically significant software vulnerabilities ka ek bada hissa kuch recurring mistakes tak trace hota hai:

  • Buffer overflows. Ek fixed-size array ke end se aage likhna — classically strcpy ya ab-removed gets ke through ek char buffer — adjacent memory ko corrupt kar sakta hai, jisme stack par ek function ka saved return address bhi shamil hai, jo "stack smashing" exploits ka base hai.
  • Format string vulnerabilities. Untrusted input ko directly ek printf-family format string ke roop mein pass karna (printf(userInput) instead of printf("%s", userInput)) conversions se missing ya inappropriate arguments use karwa sakta hai, jisse undefined behavior hota hai. Implementation aur defenses par depend karke, isse information disclosure ya memory writes possible ho sakti hain.
  • Integer overflow. Signed overflow undefined behavior hai, aur unsigned overflow silently wrap around ho jaata hai — dono mein se koi bhi ek unexpectedly chhoti size value produce kar sakta hai jo phir ek undersized buffer allocate karne ka reason ban jaati hai.
  • Mitigations. Bounds-aware functions prefer karein (sprintf ke bajaye snprintf, gets ke bajaye fgets), hamesha ek literal ya validated format string pass karein, kisi allocation size mein feed hone wale arithmetic se pehle lengths validate karein, aur stack-protection aur warning flags enable karke compile karein (Section 32).

Agla idea padhne ke liye tayyar?

Mark this chapter as read whenever you feel ready.

CHAPTER 63 / 73

Is chapter mein

Defensive C aur security boundaries

Search all 73 chapters in both languages.EN + HG

Try “pointer”, “why int”, or “undefined behavior”.

Concepts connect. Follow your curiosity.↑ ↓ to explore · Enter to open
MAKE YOURSELF COMFORTABLE

Your reading space

Appearance

A clear canvas with balanced contrast.

Text size

100%
AA

Reading tools

Your data stays in this browser

Export a backup before changing browsers or replacing an older version of the reader.

YOUR PERSONAL MARGINS

My notebook

Saved on this device
A LITTLE CLARITY

The glossary

A starting meaning, then a chapter to go deeper.

A QUICK DEFINITION

A little clarity

Read the full explanation →

A thought worth keeping