Point de départ

// ── Un cadre de pile, avec ses variables voisines ─────────────────────────
// La zone est un tableau d'octets ; chaque variable occupe une plage.
function creerCadre() {
  const OCTETS = 40;
  const memoire = new Array(OCTETS).fill(0);
  const PLAN = {
    "T[0..4]":      { debut: 0,  taille: 20 },   // int T[5], 4 octets chacun
    "secret":       { debut: 20, taille: 4 },
    "adresseRetour":{ debut: 24, taille: 4 },
  };
  const INTERDIT = 36;   // au-delà : page non allouée

  function nomDe(octet) {
    for (const [nom, p] of Object.entries(PLAN)) {
      if (octet >= p.debut && octet < p.debut + p.taille) return nom;
    }
    return "zone non allouée";
  }

  return {
    plan: PLAN,
    // Écrit un int de 4 octets à l'indice i du tableau T. AUCUN contrôle.
    ecrireT(i, valeur) {
      const octet = 0 + i * 4;
      if (octet >= INTERDIT) return { erreur: "Segmentation fault (adresse " + octet + ")" };
      memoire[octet] = valeur;
      return { touche: nomDe(octet), octet };
    },
    lire(nom) {
      const p = PLAN[nom];
      return memoire[p.debut];
    },
    poser(nom, v) { memoire[PLAN[nom].debut] = v; },
  };
}

// ── Version défensive ─────────────────────────────────────────────────────
// La seule protection en C : la taille voyage avec le tableau.
function ecrireSur(cadre, i, n, valeur) {
  // ← à écrire : refuser si i est hors de [0, n[, sinon écrire
  return cadre.ecrireT(i, valeur);
}

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Écrivez T[5], T[6] et T[12]. Que touche chacun ?
// 2. Écrivez ecrireSur() et vérifiez qu'elle refuse proprement.
// 3. Comparez le parcours d'une matrice 4x4 par lignes et par colonnes :
//    même nombre d'accès, quelle différence sur les adresses visitées ?

const c = creerCadre();
c.poser("secret", 1234);
c.poser("adresseRetour", 9999);
console.log("T[2] :", JSON.stringify(c.ecrireT(2, 42)));

Solution

function creerCadre() {
  const OCTETS = 40;
  const memoire = new Array(OCTETS).fill(0);
  const PLAN = {
    "T[0..4]":       { debut: 0,  taille: 20 },
    "secret":        { debut: 20, taille: 4 },
    "adresseRetour": { debut: 24, taille: 4 },
  };
  const INTERDIT = 36;

  function nomDe(octet) {
    for (const [nom, p] of Object.entries(PLAN)) {
      if (octet >= p.debut && octet < p.debut + p.taille) return nom;
    }
    return "zone non allouée";
  }

  return {
    plan: PLAN,
    ecrireT(i, valeur) {
      const octet = i * 4;
      if (octet >= INTERDIT) return { erreur: "Segmentation fault (adresse " + octet + ")" };
      memoire[octet] = valeur;
      return { touche: nomDe(octet), octet };
    },
    lire(nom) { return memoire[PLAN[nom].debut]; },
    poser(nom, v) { memoire[PLAN[nom].debut] = v; },
  };
}

function ecrireSur(cadre, i, n, valeur) {
  // La seule protection dont on dispose en C : la vérifier soi-même, avec
  // une taille qu'on s'est donné la peine de transmettre.
  if (i < 0 || i >= n) return { erreur: "indice " + i + " hors de [0, " + n + "[" };
  return cadre.ecrireT(i, valeur);
}

console.log("— écriture sans contrôle —");
const c = creerCadre();
c.poser("secret", 1234);
c.poser("adresseRetour", 9999);
for (const i of [2, 4, 5, 6, 12]) {
  const r = c.ecrireT(i, 42);
  const etiquette = "T[" + i + "]";
  if (r.erreur) console.log("   " + etiquette.padEnd(7) + "-> " + r.erreur);
  else console.log("   " + etiquette.padEnd(7) + "-> octet " + String(r.octet).padStart(2) +
                   ", touche « " + r.touche + " »" +
                   (i >= 5 ? "   << HORS BORNES, et aucune erreur" : ""));
}
console.log("   secret vaut maintenant " + c.lire("secret") +
            " (il valait 1234) et adresseRetour " + c.lire("adresseRetour") + " (il valait 9999)");
// T[5] a écrasé une variable voisine : corruption silencieuse. T[6] a écrasé
// l'adresse de retour : c'est là qu'un attaquant prend la main. T[12] tombe
// dans une page interdite, et c'est le seul cas où le programme s'arrête —
// donc le plus favorable, contre toute intuition.

console.log("");
console.log("— version défensive —");
const d = creerCadre();
for (const i of [2, 5]) {
  const r = ecrireSur(d, i, 5, 42);
  console.log("   T[" + i + "] -> " + (r.erreur ?? "écrit dans « " + r.touche + " »"));
}

console.log("");
console.log("— matrice 4x4 : ordre des adresses visitées —");
const N = 4;
const adresse = (i, j) => (i * N + j) * 4;
const parLignes = [], parColonnes = [];
for (let i = 0; i < N; i++) for (let j = 0; j < N; j++) parLignes.push(adresse(i, j));
for (let j = 0; j < N; j++) for (let i = 0; i < N; i++) parColonnes.push(adresse(i, j));
console.log("   par lignes   : " + parLignes.join(" "));
console.log("   par colonnes : " + parColonnes.join(" "));
const saut = (t) => t.slice(1).reduce((s, a, k) => s + Math.abs(a - t[k]), 0);
console.log("   distance totale parcourue : " + saut(parLignes) + " octets par lignes, " +
            saut(parColonnes) + " par colonnes");
// Mêmes seize accès, mêmes seize adresses — mais dans un ordre qui saute.
// Le cache rapporte une ligne de 64 octets à chaque défaut : par lignes,
// elle sert quatre fois de suite ; par colonnes, une seule.

Avant de commencer

• Les TP 1 à 4
• gcc avec -fsanitize=address

Énoncé

1. Écrire à côté — Déclarez un tableau de cinq entiers et écrivez à l'indice 5, 6, puis 100. Compilez avec -Wall et exécutez. Notez ce qui plante et ce qui ne plante pas.
2. Écraser une variable choisie — Déclarez une variable juste après le tableau, affichez son adresse et celle du tableau, puis modifiez-la en écrivant hors du tableau. Vous venez de faire un débordement dirigé. Indice : La différence des adresses vous donne l'indice à viser.
3. L'outil qui voit — Recompilez avec le détecteur d'adresses et relancez. Lisez le rapport : il donne le tableau, l'indice, et la ligne. Comparez à votre diagnostic sans outil.
4. sizeof, et où il ment — Affichez la taille d'un tableau dans la fonction qui le déclare, puis dans une fonction à laquelle vous le passez. Expliquez l'écart.
5. Tableau à deux dimensions — Créez une matrice, remplissez-la par lignes puis par colonnes, et chronométrez. Retrouvez le résultat du TP 7 d'Architecture, cette fois dans votre propre code.
6. Au fil rouge — Ajoutez à journal un histogramme du nombre de lignes par heure, sur 24 cases. Faites-le d'abord sans contrôle d'indice, testez avec une heure invalide, puis protégez.
7. La bonne façon de passer un tableau — Réécrivez toutes vos fonctions prenant un tableau pour qu'elles prennent aussi sa taille. Ajoutez const là où c'est possible, et vérifiez que le compilateur refuse une modification.

C'est réussi quand

• ✓ Vous provoquez un débordement qui ne plante PAS, et vous savez pourquoi c'est le cas dangereux
• ✓ Le détecteur d'adresses vous donne la ligne exacte que vous cherchiez à la main
• ✓ Toutes vos fonctions reçoivent la taille du tableau qu'elles parcourent

Correction

int t[5] = {0};
t[5]   = 42;   /* hors bornes : compile, s'exécute, NE PLANTE PAS */
t[6]   = 42;   /* idem */
t[100] = 42;   /* peut-être hors de la pile → Segmentation fault */

gcc -Wall : aucun avertissement sur t[i] avec i variable

int t[5];
int secret = 1;
printf("%p %p\n", (void*)t, (void*)&secret);
0x7ffd4c00  0x7ffd4c14      → 20 octets d'écart = 5 entiers

t[5] = 999;
printf("%d\n", secret);   → 999

gcc -fsanitize=address -g journal.c && ./a.out

==12345==ERROR: AddressSanitizer: stack-buffer-overflow
WRITE of size 4 at 0x7ffd4c14 thread T0
  #0 0x… in main journal.c:12
Address is located in stack of thread T0 at offset 36
'tab' (line 10) <== 0 bytes to the right of this 20-byte region

void f(int t[]) { printf("%zu\n", sizeof t); }   /* 8 : un POINTEUR */

int main(void) {
  int t[5];
  printf("%zu\n", sizeof t);   /* 20 : le tableau entier */
  f(t);
}

int par_heure[24] = {0};

/* sans contrôle : une heure lue à 99 écrit hors du tableau */
par_heure[heure]++;

/* protégé */
if (heure < 0 || heure >= 24) { lignes_invalides++; continue; }
par_heure[heure]++;

/* avant */
int somme(int t[]);

/* après : taille explicite, et const quand on ne modifie pas */
int somme(const int *t, size_t n);

somme accepte désormais un tableau constant, et le compilateur
REFUSE toute écriture dans t à l'intérieur de la fonction

Point de départ

// La mémoire : un tampon de 8 octets, puis une variable voisine.
function creerMemoire() {
  const m = new Array(16).fill(0);
  const TAMPON = 0, TAILLE = 8, VOISIN = 8;
  m[VOISIN] = 1234;
  return {
    tampon: TAMPON, taille: TAILLE,
    ecrire(i, code) { m[i] = code; },
    lire(i) { return m[i]; },
    voisin: () => m[VOISIN],
    vue() {
      return m.slice(0, 12).map((c, i) => {
        const s = c === 0 ? "\\0" : (i >= VOISIN ? String(c) : String.fromCharCode(c));
        return (i === VOISIN ? "| " : "") + s;
      }).join(" ");
    },
  };
}

// Pose une chaîne littérale dans le tampon, SANS aucun contrôle — comme strcpy.
function monStrcpy(m, depart, texte) {
  let i = 0;
  for (; i < texte.length; i++) m.ecrire(depart + i, texte.charCodeAt(i));
  // ← à écrire : et le marqueur de fin ? combien d'octets au total ?
  return i;
}

// Longueur : on compte jusqu'au marqueur. AUCUNE borne.
function monStrlen(m, depart, compteur = { n: 0 }) {
  let i = 0;
  while (m.lire(depart + i) !== 0) { compteur.n++; i++; if (i > 40) return -1; }
  return i;
}

function monStrcmp(m, a, b) {
  return 0;   // ← à écrire : 0 si égales, sinon le signe de la différence
}

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Faites copier le marqueur par monStrcpy, puis copiez « Alice » dans le
//    tampon de 8 : combien d'octets ? Et « personnage » ?
// 2. Écrasez le marqueur et relancez monStrlen : que lit-elle ?
// 3. Comptez les caractères examinés avec strlen DANS la condition d'une
//    boucle, puis calculée une seule fois avant.

const m = creerMemoire();
monStrcpy(m, 0, "chat");
console.log("mémoire :", m.vue());
console.log("longueur :", monStrlen(m, 0), "| voisin :", m.voisin());

Solution

function creerMemoire() {
  const m = new Array(16).fill(0);
  const TAMPON = 0, TAILLE = 8, VOISIN = 8;
  m[VOISIN] = 1234;
  return {
    tampon: TAMPON, taille: TAILLE,
    ecrire(i, code) { m[i] = code; },
    lire(i) { return m[i]; },
    voisin: () => m[VOISIN],
    vue() {
      return m.slice(0, 12).map((c, i) => {
        const s = c === 0 ? "\\0" : (i >= VOISIN ? String(c) : String.fromCharCode(c));
        return (i === VOISIN ? "| " : "") + s;
      }).join(" ");
    },
  };
}

function monStrcpy(m, depart, texte) {
  let i = 0;
  for (; i < texte.length; i++) m.ecrire(depart + i, texte.charCodeAt(i));
  // Le marqueur FAIT PARTIE de la chaîne : strcpy le copie aussi, d'où
  // texte.length + 1 octets écrits. C'est le « + 1 » qu'on oublie.
  m.ecrire(depart + i, 0);
  return i + 1;
}

function monStrcpyBorne(m, depart, texte, taille) {
  // Ce que strncpy aurait dû être : on réserve la dernière case au marqueur.
  const n = Math.min(texte.length, taille - 1);
  for (let i = 0; i < n; i++) m.ecrire(depart + i, texte.charCodeAt(i));
  m.ecrire(depart + n, 0);
  return { ecrits: n + 1, tronque: n < texte.length };
}

function monStrlen(m, depart, compteur = { n: 0 }) {
  let i = 0;
  while (m.lire(depart + i) !== 0) { compteur.n++; i++; if (i > 40) return -1; }
  return i;
}

function monStrcmp(m, a, b) {
  let i = 0;
  while (m.lire(a + i) !== 0 && m.lire(a + i) === m.lire(b + i)) i++;
  // On compare les octets À LA PREMIÈRE DIFFÉRENCE, marqueurs compris : c'est
  // ce qui fait que 0 signifie « égales », d'où le piège du if (strcmp(...)).
  return m.lire(a + i) - m.lire(b + i);
}

console.log("— 1. le « + 1 » —");
for (const texte of ["chat", "Alice", "personnage"]) {
  const m = creerMemoire();
  const ecrits = monStrcpy(m, 0, texte);
  const debord = ecrits > m.taille;
  console.log("   « " + texte.padEnd(11) + " » : " + ecrits + " octets dans un tampon de " +
    m.taille + (debord ? "   << DÉBORDEMENT, voisin = " + m.voisin() : "   ok"));
}
console.log("   « Alice » fait 5 lettres et 6 octets : le marqueur déborde d'exactement");
console.log("   une case, ce qui passe la plupart des tests.");

console.log("");
console.log("— version bornée —");
const b = creerMemoire();
const r = monStrcpyBorne(b, 0, "personnage", b.taille);
console.log("   " + b.vue() + "   tronquée : " + r.tronque + ", voisin intact : " + b.voisin());

console.log("");
console.log("— 2. le marqueur perdu —");
const p = creerMemoire();
monStrcpy(p, 0, "chat");
console.log("   longueur normale : " + monStrlen(p, 0));
p.ecrire(4, 88);                  // on écrase le '\0' par un 'X'
console.log("   marqueur écrasé  : " + monStrlen(p, 0) +
            "   (lecture au-delà du tampon, jusqu'à un zéro fortuit ou la garde)");

console.log("");
console.log("— 3. strlen dans la condition —");
const q = creerMemoire();
for (let i = 0; i < 100; i++) q.ecrire(i, 65 + (i % 26));
q.ecrire(100, 0);
let dans = { n: 0 }, dehors = { n: 0 };
for (let i = 0; i < monStrlen(q, 0, dans); i++) { /* corps vide */ }
const n = monStrlen(q, 0, dehors);
for (let i = 0; i < n; i++) { /* corps vide */ }
console.log("   strlen DANS la condition : " + dans.n + " caractères examinés");
console.log("   strlen calculée une fois : " + dehors.n + " caractères examinés");
console.log("   rapport : " + Math.round(dans.n / dehors.n) + " fois plus, et il croît avec n.");

Avant de commencer

• Le TP 5 : tableaux et débordements
• Le TP 2 d'Architecture, sur UTF-8

Énoncé

1. Compter les octets — Déclarez une chaîne littérale et affichez sa longueur par strlen et sa taille par sizeof. Expliquez la différence d'exactement un.
2. Perdre le zéro — Remplissez un tableau de dix caractères avec dix lettres, sans terminateur, puis affichez-le avec %s. Recommencez plusieurs fois et notez la variabilité.
3. Le débordement classique — Copiez une chaîne de vingt caractères dans un tampon de dix avec strcpy. Exécutez, puis recompilez avec le détecteur d'adresses.
4. La fausse correction — Remplacez par strncpy avec la taille du tampon. Affichez le résultat et cherchez le nouveau problème. Écrivez ensuite la version réellement correcte. Indice : strncpy ne garantit PAS d'écrire le terminateur.
5. Comparer — Comparez deux chaînes de contenu identique avec l'opérateur d'égalité, puis avec strcmp. Expliquez pourquoi la première forme est parfois vraie.
6. Découper une ligne — Écrivez une fonction qui découpe une ligne en champs sur un séparateur, sans utiliser strtok. Testez avec des champs vides et des séparateurs consécutifs.
7. Au fil rouge — Branchez ce découpage dans journal : extraire l'adresse, la date, le code de réponse de chaque ligne. Testez sur une ligne tronquée et sur une ligne vide.
8. Les accents — Comptez les caractères d'une chaîne accentuée avec strlen, puis à la main. Écrivez une fonction qui compte les vrais caractères UTF-8.

C'est réussi quand

• ✓ Vous expliquez pourquoi sizeof vaut strlen plus un sur un littéral
• ✓ Votre version de la copie est sûre ET termine toujours la chaîne
• ✓ Votre découpage gère un champ vide entre deux séparateurs
• ✓ Votre compteur UTF-8 donne 8 pour « éléphant »

Correction

char s[] = "abc";
strlen(s)  → 3      (compte jusqu'au zéro, exclu)
sizeof s   → 4      (a, b, c, et le '\0')

en mémoire : 'a' 'b' 'c' '\0'

char t[10];
for (int i = 0; i < 10; i++) t[i] = 'A' + i;
printf("%s\n", t);

→ ABCDEFGHIJ suivi de déchets, jusqu'au premier octet nul
 rencontré par hasard — longueur variable d'une exécution à l'autre

char buf[10];

strcpy(buf, "chaîne bien trop longue");    /* DÉBORDEMENT */

strncpy(buf, source, sizeof buf);           /* pas de débordement,
                                             mais PAS DE '\0' si
                                             source fait 10 ou plus */

/* la version correcte */
strncpy(buf, source, sizeof buf - 1);
buf[sizeof buf - 1] = '\0';

/* ou, plus lisible, en vérifiant la troncature */
int n = snprintf(buf, sizeof buf, "%s", source);
if (n >= (int)sizeof buf) { /* tronqué : c'est une ERREUR, pas un détail */ }

char *a = "bonjour", *b = "bonjour";
a == b        → parfois VRAI : le compilateur a fusionné les littéraux
strcmp(a, b)  → 0 : contenus identiques

char c[] = "bonjour", d[] = "bonjour";
c == d        → FAUX : deux tableaux distincts

int decouper(char *ligne, char sep, char *champs[], int max) {
  int n = 0;
  char *debut = ligne;
  for (char *p = ligne; ; p++) {
      if (*p == sep || *p == '\0') {
          if (n >= max) return -1;
          char fin = *p;
          *p = '\0';              /* on coupe SUR PLACE */
          champs[n++] = debut;
          debut = p + 1;
          if (fin == '\0') break;
      }
  }
  return n;
}

strlen("éléphant") → 10 octets, pour 8 caractères

int caracteres_utf8(const char *s) {
  int n = 0;
  for (; *s; s++)
      if ((*s & 0xC0) != 0x80) n++;   /* on ignore les octets 10xxxxxx */
  return n;
}