Przejdź do treści
Wiedza, która chroni Twoją cyfrową codzienność.

Ochrona przed atakami typu Prototype Pollution w JavaScript: jakich bibliotek unikać?

Zielone liczby i strumienie kodu binarnego na ekranie komputera
4/5 - (1 vote)

Prototype Pollution: jakie ryzyko trzeba wyeliminować przed wyborem biblioteki

Na czym polega zanieczyszczenie prototypu

Prototype Pollution to podatność charakterystyczna dla JavaScriptu, w którym obiekty mogą dziedziczyć właściwości z innych obiektów poprzez łańcuch prototypów. Atak pojawia się wtedy, gdy aplikacja pozwala nieufnym danym wpływać na klucze obiektu, a następnie bez odpowiednich zabezpieczeń przypisuje je, scala lub interpretuje jako ścieżki zagnieżdżonych właściwości. [2]

Najbardziej niebezpieczne nazwy kluczy to zwykle __proto__, constructor oraz prototype. Same w sobie nie zawsze oznaczają atak. Problem zaczyna się wtedy, gdy zostaną wykorzystane w kodzie, który rekurencyjnie przechodzi po obiekcie albo buduje strukturę na podstawie ścieżki przekazanej przez użytkownika.

const target = {};
const input = JSON.parse('{"__proto__":{"isAdmin":true}}');

// Niebezpieczny wzorzec w uproszczonej formie:
for (const key in input) {
  target[key] = input[key];
}

W zależności od mechanizmu przypisania oraz środowiska wykonawczego taki kod może doprowadzić do zmiany prototypu obiektu docelowego albo do późniejszego zanieczyszczenia obiektów tworzonych przez aplikację. Groźniejsze od jednorazowej zmiany konkretnego obiektu jest zanieczyszczenie Object.prototype. Wówczas właściwość może być pozornie obecna w wielu zwykłych obiektach, nawet jeśli nigdy nie została do nich jawnie dodana.

// Skutek po zanieczyszczeniu globalnego prototypu:
if (user.isAdmin) {
  grantPrivilegedAccess(user);
}

Jeżeli kod sprawdza właściwość odziedziczoną tak samo jak właściwość własną, ustawione przez atakującego isAdmin, enabled, debug albo allowUnsafe może zmienić logikę aplikacji. Skutkiem może być obejście warunku autoryzacji, aktywacja niepożądanej opcji, niepoprawna walidacja, zmiana parametrów zapytania lub błąd w mechanizmie kontroli dostępu.

Różnica między modyfikacją obiektu a zmianą dziedziczenia

Zwykłe przypisanie config.theme = "dark" modyfikuje jeden konkretny obiekt. Prototype Pollution wykorzystuje fakt, że część operacji na nazwach właściwości ma szczególne znaczenie. Gdy biblioteka wykonuje głębokie scalanie danych lub tworzy obiekt według ścieżki a.b.c, może nieświadomie wejść w łańcuch prototypów zamiast pozostać w granicach bezpiecznych, własnych właściwości. [4]

To ważne rozróżnienie podczas audytu. Nie każdy kod korzystający z dynamicznych kluczy jest automatycznie krytyczny. Ryzyko rośnie, gdy występują jednocześnie trzy elementy: klucz kontrolowany przez użytkownika, operacja głęboka lub rekurencyjna oraz obiekt, którego właściwości wpływają później na decyzje biznesowe albo bezpieczeństwo.

Monitory z kodem w ciemnym pomieszczeniu o tematyce cyberbezpieczeństwa
Źródło: Pexels | Autor: Tima Miroshnichenko

Kiedy sama podatna zależność nie oznacza jeszcze exploitu

Alert z narzędzia SCA, wpis CVE albo wynik npm audit nie jest jeszcze dowodem, że aplikację da się zaatakować. Oznacza natomiast, że trzeba przeanalizować konkretną ścieżkę danych. Do realnego wykorzystania luki zwykle potrzebne są: podatna wersja pakietu, wywołanie niebezpiecznej funkcji, dane kontrolowane przez użytkownika i użycie wyniku w sposób, który ma znaczenie dla działania systemu.

Przykładowy scenariusz wygląda tak: endpoint przyjmuje JSON z opcjami raportu, parser zamienia dane na obiekt, a następnie kod wywołuje funkcję merge z domyślną konfiguracją. Jeśli payload zawiera specjalnie przygotowane pola, biblioteka może zapisać je w niewłaściwym miejscu. Gdy wynik zostanie później użyty do oceny uprawnień, filtrów danych lub parametrów procesu, konsekwencje są realne.

Inny przypadek może być mniej groźny: podatna funkcja istnieje w zależności przechodniej, ale w aplikacji nigdy nie jest wykonywana na danych z zewnątrz. Nie wolno wtedy ignorować alertu, lecz priorytet może być niższy niż w usłudze publicznej, która scala dowolne obiekty przesyłane przez API.

Co sprawdzić przed dalszym audytem

  • Czy aplikacja przyjmuje zewnętrzny JSON, parametry query string, formularze, pliki konfiguracyjne lub importowane dane.
  • Czy takie dane trafiają do operacji typu deep merge, setterów ścieżkowych albo własnych funkcji rekurencyjnych.
  • Czy wynik scalenia wpływa na uprawnienia, konfigurację, walidację, zapytania lub generowanie odpowiedzi.

Krok 1. Zinwentaryzuj biblioteki i miejsca, w których powstają obiekty dynamiczne

Audyt bezpośrednich i przechodnich zależności

Pierwszy krok nie powinien ograniczać się do odczytania package.json. Plik manifestu pokazuje głównie zależności bezpośrednie, podczas gdy podatny pakiet często trafia do projektu przez framework, generator dokumentacji, middleware, narzędzie testowe lub inną bibliotekę pomocniczą.

W projekcie npm podstawowe polecenie to:

npm audit

W zależności od używanego menedżera pakietów można skorzystać także z yarn npm audit, funkcji audytowych pnpm albo firmowego narzędzia SCA. Wynik należy zapisać wraz z wersjami pakietów, poziomem zagrożenia i opisem ścieżki zależności. Samo automatyczne uruchomienie npm audit fix --force nie jest dobrą strategią, ponieważ może wprowadzić wersje łamiące kompatybilność bez sprawdzenia zachowania aplikacji.

Gdy alert dotyczy konkretnej paczki, ustal, kto ją instaluje:

npm ls lodash
npm explain lodash
npm ls qs
npm explain qs

W praktyce ważny jest również plik lock: package-lock.json, yarn.lock albo pnpm-lock.yaml. Dwie aplikacje z identycznym wpisem semver w package.json mogą mieć zainstalowane inne podwersje pakietu. Lockfile jest więc źródłem informacji o faktycznym drzewie zależności używanym przez build i wdrożenie.

Wyszukiwanie ryzykownych operacji w kodzie

Druga część inwentaryzacji dotyczy własnego kodu. Wyszukaj nie tylko nazwę podatnej biblioteki, ale przede wszystkim wzorce mogące prowadzić do Prototype Pollution. Szczególną uwagę wymagają funkcje o nazwach merge, mergeWith, defaultsDeep, set, setWith, zipObjectDeep, assignDeep, parse i ich lokalne odpowiedniki. [1]

grep -R "merge(" src
grep -R "defaultsDeep" src
grep -R "set(" src
grep -R "[path]" src
grep -R "__proto__" src

Wyszukiwanie tekstowe nie zastępuje analizy, ale szybko wskazuje miejsca wymagające ręcznej kontroli. Szczególnie ryzykowny jest kod, w którym zmienna path, key, field lub name pochodzi z żądania HTTP, formularza, pliku CSV, webhooka czy konfiguracji edytowanej przez użytkownika.

function setValue(target, path, value) {
  const parts = path.split(".");
  let current = target;

  for (let i = 0; i < parts.length - 1; i++) {
    current = current[parts[i]] ||= {};
  }

  current[parts.at(-1)] = value;
}

Powyższa funkcja wygląda niewinnie, lecz bez blokady krytycznych segmentów może przetwarzać ścieżki takie jak constructor.prototype.isAdmin. Podobne ryzyko występuje w narzędziach zamieniających płaskie pola na obiekty zagnieżdżone, np. preferences.theme.color, oraz w parserach query string obsługujących notację tablic i obiektów.

Źródła danych, których nie wolno uznać za bezpieczne

Nieufne dane nie oznaczają wyłącznie formularza dostępnego publicznie. Potencjalnym źródłem są również webhooki, konfiguracje tenantów, dane z panelu administratora, wiadomości z kolejki, importy CSV i JSON, cache współdzielony między usługami oraz odpowiedzi z zewnętrznych API. Uprawniony użytkownik także może przypadkowo lub celowo przesłać strukturę, która wywoła niebezpieczne zachowanie.

Typowym błędem jest założenie, że obiekt po JSON.parse() jest bezpieczny, ponieważ pochodzi z JSON-a. Parser nie wykonuje kodu, ale może zwrócić obiekt zawierający własny klucz "__proto__". Ryzyko ujawnia się dopiero podczas późniejszego kopiowania, scalania albo przekształcania tej struktury.

Co sprawdzić po inwentaryzacji

  • Pełne drzewo zależności, a nie tylko pakiety wpisane ręcznie do manifestu.
  • Własne funkcje rekurencyjnego scalania i dynamicznego ustawiania pól.
  • Parsery query string, importery konfiguracji oraz biblioteki budujące obiekty według ścieżek.
  • Źródło każdej wartości przekazywanej do funkcji manipulującej strukturą obiektu.

Krok 2. Oceń biblioteki wysokiego ryzyka i nie opieraj decyzji wyłącznie na nazwie pakietu

Biblioteki i klasy funkcji wymagające szczególnej kontroli

Największą uwagę należy poświęcić pakietom, których główną funkcją jest głębokie scalanie obiektów, kopiowanie właściwości, ustawianie wartości na zagnieżdżonej ścieżce, parsowanie parametrów do struktury obiektowej oraz konwersja danych płaskich na zagnieżdżone.

Kolorowy kod źródłowy wyświetlony na ekranie komputera
Źródło: Pexels | Autor: Markus Spiske

Do grupy wymagającej sprawdzenia należą między innymi starsze wydania popularnych bibliotek utility, w tym Lodash, jeżeli aplikacja używa metod takich jak merge, mergeWith, defaultsDeep, set albo zipObjectDeep. Historyczne podatności nie oznaczają, że każda aktualna wersja Lodash jest niebezpieczna ani że każda funkcja tej biblioteki stanowi problem. Znaczenie ma dokładna wersja, konkretne API i kontekst danych wejściowych.

Osobnej analizy wymagają pakiety o nazwach lub funkcjach podobnych do deepmerge, merge-deep, set-value, object-path, qs, dot-prop oraz ich forki. Nie chodzi o automatyczne usuwanie wszystkich tych bibliotek. Chodzi o sprawdzenie, czy używana wersja jest objęta advisory, czy poprawka istnieje oraz czy aplikacja przekazuje do niej dane nieufne.

Klasa narzędziaPrzykładowe ryzykoCo zweryfikować
Deep mergeRekurencyjne kopiowanie __proto__ lub ścieżek prototypuWersję, filtry kluczy, obsługę obiektów zewnętrznych
Setter ścieżkowyUstawienie constructor.prototype.xWalidację każdego segmentu ścieżki
Parser query stringZamiana parametrów URL na niebezpiecznie zagnieżdżone obiektyOpcje parsera i ograniczenia głębokości
Mapper konfiguracjiMasowe kopiowanie niezweryfikowanego JSON-aWhitelist pól oraz walidację schematu

Wersja pakietu i sposób użycia są ważniejsze niż sama nazwa

Krok 1 to odczytanie faktycznie zainstalowanej wersji z lockfile’a, a następnie porównanie jej z advisory producenta, rejestrem npm i bazą CVE lub GitHub Security Advisories. Krok 2 to sprawdzenie, czy podatne API jest wywoływane w aplikacji. Pakiet może występować w drzewie zależności, lecz nie obsługiwać danych zewnętrznych; z drugiej strony pozornie bezpieczna aktualizacja nie pomoże, gdy własny wrapper wokół biblioteki nadal przekazuje niezweryfikowane ścieżki.

Nie wystarczy też przyjąć, że nowsza wersja automatycznie rozwiązuje każdy problem. Poprawka może dotyczyć tylko wybranej funkcji, konkretnego formatu ścieżki albo domyślnych opcji parsera. Po aktualizacji uruchom test z wejściami zawierającymi __proto__, prototype i constructor, zarówno jako zwykłe klucze JSON, jak i segmenty ścieżki. Test powinien potwierdzić nie tylko brak wyjątku, lecz także brak pojawienia się nowych właściwości na Object.prototype oraz brak zmiany zachowania obiektów tworzonych później.

Typowy błąd polega na sprawdzeniu jedynie publicznego endpointu HTTP. Ten sam mechanizm scalania może być wywoływany przez import konfiguracji, zadanie z kolejki lub panel administracyjny. Jeżeli biblioteka jest potrzebna wyłącznie do prostego scalenia znanych pól, bezpieczniej ograniczyć wejście do jawnej listy właściwości niż przekazywać do niej cały obiekt otrzymany z zewnątrz.

Co sprawdzić przed pozostawieniem biblioteki w projekcie

  • Dokładną wersję z lockfile’a oraz dostępność poprawki dla zgłoszonej podatności.
  • Wszystkie wywołania ryzykownego API, w tym wrappery i funkcje pomocnicze.
  • Czy dane wejściowe mogą zawierać dowolne klucze lub segmenty ścieżki.
  • Czy testy odrzucają __proto__, constructor i prototype przed scaleniem albo ustawieniem wartości.

Skuteczna ochrona nie polega na unikaniu jednej nazwy pakietu, lecz na kontrolowaniu całego przepływu danych: od źródła wejścia, przez parser i bibliotekę, aż po obiekt używany przez aplikację.

Krok 3. Usuń podatne wzorce: aktualizacja, wymiana albo ograniczenie użycia

Po ustaleniu, które wywołania są rzeczywiście ryzykowne, wybierz dla każdego z nich jedną z trzech dróg: aktualizację, wymianę biblioteki albo ograniczenie zakresu jej użycia. Nie traktuj tego jako wyboru wyłącznie technicznego. Decyzja powinna zależeć od tego, czy dany mechanizm musi przyjmować swobodną strukturę danych od użytkownika.

Wariant A: aktualizacja zależności i kontrola zmiany

Jeżeli dostawca pakietu opublikował poprawkę, zacznij od aktualizacji do wersji, która usuwa zgłoszoną podatność. Zmieniaj wersję w kontrolowany sposób: najpierw w osobnej gałęzi, następnie uruchom testy jednostkowe, integracyjne i testy wejść nieufnych.

Kod HTML i CSS wyświetlony na ciemnym ekranie
Źródło: Pexels | Autor: Harold Vasquez
npm install lodash@latest
npm update qs
npm audit

Po zmianie sprawdź faktycznie rozwiązaną wersję, a nie tylko wpis w package.json:

npm ls lodash
npm ls qs
git diff package-lock.json

W projektach, w których podatny pakiet jest zależnością przechodnią, użyj mechanizmu wymuszenia wersji obsługiwanego przez wybrany menedżer pakietów. W npm może to być pole overrides:

{
  "overrides": {
    "nazwa-pakietu": "bezpieczna-wersja"
  }
}

Takie wymuszenie jest rozwiązaniem przejściowym, gdy pakiet nadrzędny nie został jeszcze zaktualizowany. Nie powinno jednak zastępować aktualizacji całej zależności nadrzędnej, szczególnie gdy nowa wersja pakietu zmienia API albo zachowanie wymagane przez bibliotekę zależną.

Kryteria akceptacji aktualizacji

  • Lockfile zawiera wersję usuwającą znane zgłoszenie bezpieczeństwa.
  • Testy aplikacji przechodzą bez wymuszania pomijania błędów typów lub ostrzeżeń.
  • Przypadki z niepożądanymi kluczami są odrzucane albo ignorowane zgodnie z założeniem aplikacji.
  • Po wykonaniu operacji nie pojawiają się dodatkowe właściwości na Object.prototype.
  • Zmiana została wdrożona również do środowisk budujących obrazy, funkcje serverless i narzędzia CLI.

Wariant B: wymiana biblioteki na prostszy mechanizm

Jeżeli biblioteka obsługuje znacznie więcej funkcji, niż potrzebuje aplikacja, bezpieczniejsza może być jej wymiana. Dotyczy to zwłaszcza sytuacji, w której pakiet służy tylko do skopiowania kilku znanych pól konfiguracji lub aktualizacji pojedynczych ustawień użytkownika.

Zamiast głęboko scalać cały obiekt przekazany przez klienta, kopiuj wyłącznie pola przewidziane przez kontrakt API:

function updatePreferences(current, input) {
  const next = {
    ...current,
    preferences: {
      ...current.preferences
    }
  };

  if (typeof input.theme === "string") {
    next.preferences.theme = input.theme;
  }

  if (typeof input.language === "string") {
    next.preferences.language = input.language;
  }

  return next;
}

Ten wzorzec jest celowo bardziej szczegółowy niż uniwersalne merge. Kod wskazuje, które pola mogą zostać zmienione, jaki mają typ i gdzie trafiają. Użytkownik nie może przez przypadek dopisać dowolnej właściwości tylko dlatego, że pojawiła się w przesłanym JSON-ie.

Gdy potrzebujesz przechowywać słownik danych o dynamicznych nazwach, rozważ użycie Map zamiast zwykłego obiektu:

const flags = new Map();

for (const [name, enabled] of Object.entries(input.flags)) {
  if (typeof name === "string" && typeof enabled === "boolean") {
    flags.set(name, enabled);
  }
}

Map nie korzysta z prototypu obiektów do przechowywania wpisów, ale nadal wymaga kontroli nazw i wartości biznesowych. Nie rozwiązuje na przykład problemu nieograniczonej liczby flag, zbyt długich kluczy ani nieuprawnionej zmiany konfiguracji.

Wariant C: ograniczenie użycia przez walidację i whitelistę

Nie zawsze można od razu wymienić bibliotekę albo przebudować format danych. Wtedy należy zablokować niebezpieczne nazwy przed przekazaniem danych do funkcji scalającej lub settera ścieżkowego. Filtr powinien działać na każdym poziomie zagnieżdżenia, a nie wyłącznie dla kluczy obiektu głównego. [3]

Programista pracujący przy kodzie na dwóch monitorach w ciemnym pokoju
Źródło: Pexels | Autor: Mikhail Nilov
const blockedKeys = new Set([
  "__proto__",
  "prototype",
  "constructor"
]);

function isAllowedKey(key) {
  return typeof key === "string" && !blockedKeys.has(key);
}

W przypadku ścieżek rozdzielanych kropką sprawdzaj każdy segment:

function assertSafePath(path) {
  if (typeof path !== "string" || path.length === 0) {
    throw new TypeError("Nieprawidłowa ścieżka");
  }

  const parts = path.split(".");

  if (parts.some((part) => !isAllowedKey(part))) {
    throw new Error("Niedozwolony segment ścieżki");
  }

  return parts;
}

function setSafeValue(target, path, value) {
  const parts = assertSafePath(path);
  let current = target;

  for (let i = 0; i < parts.length - 1; i++) {
    const key = parts[i];

    if (
      !Object.hasOwn(current, key) ||
      typeof current[key] !== "object" ||
      current[key] === null
    ) {
      current[key] = Object.create(null);
    }

    current = current[key];
  }

  current[parts.at(-1)] = value;
}

Użycie Object.create(null) ogranicza dziedziczenie właściwości z Object.prototype w obiektach tworzonych wewnątrz tej funkcji. Nie zwalnia jednak z blokowania segmentów ścieżki ani z walidacji wartości. Najbezpieczniej jest traktować tę technikę jako dodatkową warstwę ochrony.

Bezpieczne kopiowanie obiektu wejściowego

Jeżeli aplikacja musi przyjąć zagnieżdżony obiekt, przygotuj funkcję normalizującą, która tworzy nową strukturę i kopiuje tylko dozwolone dane. Nie używaj w tym celu bezpośredniego przypisania wszystkich pól do zwykłego obiektu docelowego.

function copySafeObject(value) {
  if (Array.isArray(value)) {
    return value.map(copySafeObject);
  }

  if (value === null || typeof value !== "object") {
    return value;
  }

  const result = Object.create(null);

  for (const [key, child] of Object.entries(value)) {
    if (!isAllowedKey(key)) {
      continue;
    }

    result[key] = copySafeObject(child);
  }

  return result;
}

W zależności od wymagań API odrzucenie całego żądania może być lepsze niż ciche pomijanie pola. Ciche usuwanie kluczy ma sens głównie wtedy, gdy klient może legalnie wysłać dodatkowe dane, które nie wpływają na wynik. Dla konfiguracji bezpieczeństwa, ról, uprawnień i reguł dostępu lepiej zwrócić błąd walidacji oraz zapisać zdarzenie w logu.

function validateSettings(input) {
  for (const key of Object.keys(input)) {
    if (!isAllowedKey(key)) {
      throw new Error(`Niedozwolone pole: ${key}`);
    }
  }

  return input;
}

Ograniczanie formatu wejścia przed scaleniem

Najmocniejszą ochroną jest schema danych, która definiuje dozwolone pola, ich typy, maksymalną głębokość i zakres wartości. Walidator powinien działać przed jakąkolwiek operacją transformującą strukturę danych. W praktyce oznacza to kolejność:

  1. Odbierz dane z żądania, pliku, kolejki albo webhooka.
  2. Sprawdź rozmiar wejścia i maksymalną głębokość struktury.
  3. Zweryfikuj schemat oraz listę dozwolonych pól.
  4. Odrzuć krytyczne nazwy kluczy i niedozwolone segmenty ścieżek.
  5. Dopiero potem utwórz obiekt domenowy albo wykonaj ograniczone scalenie.

Nie przekazuj bezpośrednio całego req.body do ustawień aplikacji, opcji biblioteki, konfiguracji klienta HTTP ani obiektu użytkownika. Przygotuj osobny obiekt wejściowy dla konkretnego przypadku użycia.

function createProfilePatch(body) {
  return {
    displayName:
      typeof body.displayName === "string"
        ? body.displayName.slice(0, 80)
        : undefined,
    locale:
      body.locale === "pl" || body.locale === "en"
        ? body.locale
        : undefined
  };
}

Tak przygotowany patch można bezpieczniej zastosować do modelu profilu, ponieważ jego struktura jest z góry znana. Nie zawiera dowolnych kluczy z oryginalnego żądania.

Testy regresyjne po naprawie

Każde miejsce naprawione przez aktualizację, wymianę albo filtr powinno otrzymać test regresyjny. Test nie może ograniczać się do sprawdzenia, że funkcja nie rzuca wyjątku. Musi potwierdzać, że wynik nie zawiera niedozwolonych danych i że globalny prototyp nie został zmieniony.

import { strict as assert } from "node:assert";

function assertPrototypeIsClean() {
  assert.equal(Object.prototype.polluted, undefined);
  assert.equal(({}).polluted, undefined);
}

delete Object.prototype.polluted;

assert.throws(() => {
  setSafeValue({}, "constructor.prototype.polluted", true);
});

assertPrototypeIsClean();

Dodaj analogiczne przypadki dla danych przekazywanych jako zwykły obiekt, JSON oraz parametr ścieżki. W aplikacji używającej parsera query string test powinien obejmować również rzeczywisty format parametrów URL obsługiwany przez framework.

Lista kontrolna wdrożenia naprawy

  • Przed zmianą: zapisz podatną wersję, miejsca wywołań i źródła danych docierających do danego API.
  • W trakcie: aktualizuj pakiet albo zastępuj ogólne scalanie kopiowaniem jawnie dozwolonych pól.
  • W trakcie: blokuj niepożądane klucze na każdym poziomie zagnieżdżenia i w każdym segmencie ścieżki.
  • Po zmianie: sprawdź lockfile, wynik npm ls oraz alerty z narzędzia SCA.
  • Po zmianie: uruchom testy z wejściami zawierającymi niedozwolone nazwy pól.
  • Po wdrożeniu: monitoruj błędy walidacji i odrzucone żądania, aby wykryć klientów używających starego lub nieprawidłowego formatu.

Najważniejsze ostrzeżenia operacyjne

  • Nie naprawiaj problemu wyłącznie przez usunięcie alertu z raportu bezpieczeństwa lub dodanie wyjątku w narzędziu SCA.
  • Nie stosuj ślepo npm audit fix --force na produkcyjnej gałęzi bez przeglądu zmian w lockfile i testów regresyjnych.
  • Nie ufaj wrapperowi tylko dlatego, że jego nazwa brzmi bezpiecznie; sprawdź, czy przekazuje dane dalej do funkcji merge lub set.
  • Nie filtruj wyłącznie klucza głównego obiektu, gdy aplikacja akceptuje dane zagnieżdżone.
  • Nie używaj obiektu wejściowego użytkownika jako konfiguracji wewnętrznej aplikacji bez utworzenia nowego, zwalidowanego modelu danych.

Najczęściej zadawane pytania (FAQ)

Czym jest Prototype Pollution?

To podatność JavaScriptu polegająca na niebezpiecznej modyfikacji łańcucha prototypów obiektów, często przez przetwarzanie nieufnych kluczy lub ścieżek właściwości.

Jakie klucze mogą zwiększać ryzyko ataku?

Szczególnej uwagi wymagają między innymi __proto__, constructor i prototype, zwłaszcza gdy są obsługiwane przez funkcje rekurencyjne lub settery ścieżkowe.

Czy każda podatna zależność oznacza możliwość ataku?

Nie. Trzeba sprawdzić wersję pakietu, używane API, źródło danych oraz to, czy wynik operacji wpływa na działanie aplikacji.

Jakie biblioteki wymagają szczególnej kontroli?

Przede wszystkim narzędzia do deep merge, ustawiania wartości według ścieżki, parsowania query stringów oraz tworzenia zagnieżdżonych obiektów. Należy ocenić ich konkretną wersję i konfigurację.

Jak rozpocząć audyt zależności?

Warto sprawdzić pełne drzewo zależności, lockfile, wyniki narzędzi SCA oraz miejsca w kodzie, gdzie dane zewnętrzne trafiają do funkcji scalających lub rekurencyjnych.

Źródła

Podziel się wiedzą: Ochrona przed atakami typu Prototype Pollution w JavaScript: jakich bibliotek unikać?Więcej artykułów