మాడ్యూల్ పాఠాలు (4/4)
ReDoS-సురక్షిత నమూనాలను వ్రాయడం
ReDoS (రెగ్యులర్ ఎక్స్‌ప్రెషన్ ఆఫ్ సర్వీస్ నిరాకరణ) అనేది దాడుల తరగతి జాగ్రత్తగా రూపొందించిన ఇన్‌పుట్ రీజెక్స్ యొక్క మ్యాచింగ్ సమయాన్ని పేలేలా చేస్తుంది. JS ఇంజిన్ బ్యాక్‌ట్రాకింగ్ని ఉపయోగిస్తుంది: ఒక నమూనా "అస్పష్టంగా" ఉంటే, ఒక దురదృష్టకర ఇన్‌పుట్ ఇది ఘాతాంక సంఖ్యలో ప్రయత్నాలను చేయగలదు.
క్లాసిక్ విపత్తు నమూనా
Pattern: ^(a+)+$
Input: "aaaaaaaaaaaaaaaaaaaaab"సరిపోలడానికి, ఇంజిన్ మధ్య "a" యొక్క ప్రతి సాధ్యం విభజనను ప్రయత్నిస్తుంది
రెండు + క్వాంటిఫైయర్‌లు. 20 "a"లలో 2^20 = ~1 మిలియన్ ప్రయత్నాలు.
30 "a" లలో, ఒక బిలియన్.
ఇతర ప్రమాదకరమైన ఉదాహరణలు:
(a*)*b-- "నెస్టెడ్ స్టార్స్".(a|a)*-- అతివ్యాప్తి చెందుతున్న ప్రత్యామ్నాయాలు.(\w+)+@-- బయటి క్వాంటిఫైయర్‌తో అత్యాశ సమూహాలు.
ప్రమాదాన్ని ఎలా గుర్తించాలి
ఈ నిర్మాణాల కోసం చూడండి:
- క్వాంటిఫైయర్ లోపల క్వాంటిఫైయర్:
(...+)+,(...*)*,(...{n,})+. - ** క్వాంటిఫైయర్ కింద అతివ్యాప్తి చెందుతున్న ప్రత్యామ్నాయాలు**:
(a|ab)*,(\w|\d)+. - లుక్‌హెడ్/లుక్‌బిహైండ్ సంక్లిష్ట ప్రత్యామ్నాయాలతో పునరావృతం.
డిఫెన్సివ్ రీరైటింగ్
Dangerous: ^(\w+\s+)+$
Safe: ^(?:\w+\s+)*\w+$సురక్షిత సంస్కరణ **బేస్ కేస్‌ను రిపీట్ కేస్ నుండి వేరు చేస్తుంది, తీసివేస్తుంది అస్పష్టత. ఇతర పద్ధతులు:
- పొసెసివ్ క్వాంటిఫైయర్‌లు (
a++) -- JSలో మద్దతు లేదు, కానీ ఇతర ఇంజిన్‌లలో అందుబాటులో ఉంటుంది. - అటామిక్ నమూనాలు (
(?>...)) -- JSలో కాదు. - ** సరిపోల్చడానికి ముందు ఇన్‌పుట్ యొక్క పొడవు**ని పరిమితం చేయండి.
- టైమ్ అవుట్ సరిపోలికపై (ఈ కోర్సు యొక్క ఎడిటర్ 500 ఎంఎస్‌ల సమయం ముగిసింది)
ReDoS-సురక్షిత నమూనాల కోసం సిఫార్సులు
- ప్రత్యామ్నాయంలోని ఎంపికలు పరస్పరం ప్రత్యేకమైనవని నిర్ధారించుకోండి (ఉదా.
(a|a+)ని ఉపయోగించవద్దు). - అతివ్యాప్తి చెందుతున్న వ్యక్తీకరణలకు (ఉదా.
(\\s*)*) నెస్టెడ్ క్వాంటిఫైయర్‌లను వర్తింపజేయడం మానుకోండి. - ఎల్లప్పుడూ జెనరిక్ వైల్డ్‌కార్డ్ డాట్ (
.*) కంటే నిర్దిష్ట నిరాకరణ అక్షర తరగతులకు ([^\\n]*) ప్రాధాన్యత ఇవ్వండి.
దీనిని ప్రయత్నించండి
పునరావృతమయ్యే అక్షరాల నమూనాలను గుర్తించండి -- కానీ ReDoS-సురక్షిత మార్గంలో. (a+)+ వంటి సమూహ సమూహాలను కాకుండా ఒకే అక్షర తరగతిని ఉపయోగించండి.
సూచనను చూపించు
ప్రమాదకరమైన (a+)+ని సాధారణ a+తో భర్తీ చేయండి. ఫలితం అదే, కానీ సురక్షితం.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది
వ్యాయామం సమీక్షించండి
ReDoS-సురక్షిత మార్గంలో ఖాళీల ద్వారా వేరు చేయబడిన పదాల క్రమాన్ని గుర్తించండి. `(word+space+)+`కి బదులుగా `(?:word+spaces+)*word` నిర్మాణాన్ని ఉపయోగించండి.
సూచనను చూపించు
సంగ్రహించే సమూహాన్ని భర్తీ చేయండి (\\w+\\s+)+ విభజిత వెర్షన్ (?:\\w+\\s+)*\\w+తో.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది
అదనపు సవాలు
Make the vulnerable pattern `(\w+\s*)+:` which causes ReDoS safe, by removing the overlapping whitespace recursion.
సూచనను చూపించు
స్పేస్‌ను తరలించండి, తద్వారా ఇది సమూహ పునరావృతంతో అతివ్యాప్తి చెందదు: (?:\\w+\\s+)*\\w+:
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది