Skapa din egen Chrome-stil för moduler. Lägga till en accent Lägga till enkla snedstreck

Detta är en vanlig sårbarhet för klassen inklusive PHP. Men personen som jag gjorde granskningen för sa till mig att denna sårbarhet inte kan utnyttjas, så den räknas inte. Jag var tvungen att argumentera med honom

Vad är PHP-include

Låt oss genomföra ett litet utbildningsprogram om denna sårbarhet. PHP-include är en sårbarhet som låter dig "inkludera" en godtycklig fil, till exempel denna kod:

$modul=$_REQUEST["modul"]; include("moduler/".$modul);

Och eftersom det vanligtvis inte finns några PHP-taggar i filen "/etc/passwd" (), så kommer den att visas i webbläsaren, precis som html-koden skulle visas bakom php-taggarna i ett vanligt php-skript. Naturligtvis är att läsa filer bara en av de möjliga implementeringarna av denna attack. Det viktigaste är införandet av de nödvändiga filerna med den nödvändiga PHP-koden.

Låt oss gå tillbaka till exemplet. Låt oss komplicera det:

$modul=$_REQUEST["modul"]; include("modules/".$module."/module.class.php");

Som du kan se läggs nu en rad till vår variabel i slutet, vilket hindrar oss från att inkludera någon fil. Så många PHP-funktioner är inte binärsäkra, det vill säga sådana funktioner betraktar en NULL-byte som slutet på en sträng. Vi kommer åt skriptet så här:

script.php?module=../../../../../../../../../../../etc/passwd%00

Och om direktivet magic_quotes är inaktiverat, kommer vi återigen att se innehållet i /etc/passwd

Finns det en sårbarhet?

Låt oss gå tillbaka till vår kod:

$module=addslashes($_REQUEST["modul"]); include("modules/".$module."/module.class.php");

Som du kan se tvingas vår variabel gå igenom "addslashes" och om vi försöker använda en NULL-byte kommer den att konverteras till "\0" och inkluderingen kommer inte att fungera.

Men framstegen står inte stilla! Det visar sig att några killar från USH hittade en intressant funktion i PHP: PHP-filsystem attackvektorer (engelska). För att kort sammanfatta artikelns kärna, bearbetar php sökvägar med flera funktioner:

• Banavkortning- php trunkerar sökvägssträngen till den angivna längden MAXPATHLEN (på Windows upp till 270 tecken, på NIX - vanligtvis 4096, på BSD - vanligtvis 1024)
• Bannormalisering— php bearbetar sökvägen på ett speciellt sätt och tar bort extra tecken "/" och "/." och deras olika kombinationer
• Reduktion till kanonisk form— onödiga övergångar tas bort, till exempel konverteras "dir1/dir2/../dir3" till "dir1/dir3/" medan förekomsten av katalogen "dir2" inte kontrolleras, och andra liknande transformationer (d.v.s. fortsättning av normaliseringen )

Nu, i ordning, vad händer med den passerade vägen:

1. Om sökvägen är relativ, ersätts först värdena från include_path-direktivet
2. Banan trimmas sedan till en viss längd beroende på plattform
3. Banan håller på att normaliseras
4. Stigen reduceras till kanonisk form

Låt oss nu försöka använda detta. Låt oss försöka inkludera en viss fil "test.php" som finns i katalogen "modules/". För att göra detta, lägg till symbolen "/." till slutet. så att den totala längden, tillsammans med filnamnet och värdet från include_path, uppenbarligen är större än 4096 tecken.
script.php?module=test.php/././.[...]/././.

I det här fallet måste du gissa så att hela vägsträngen (redan trimmad) slutar med en prick (viktigt!), och inte med ett snedstreck. För att göra detta kan du lägga till ett snedstreck så här:

Och ett av dessa alternativ kommer definitivt att fungera.

Analyserar

Låt oss titta i ordning på vilka förändringar som kommer att hända med vägen
modules/test.php//././.[...]/./././module.class.php
4200 tecken

Det första som händer med raden är att värdet från include_path läggs till den:
/home/site/public_html/modules/test.php//././.[...]/./././module.class.php
4223 tecken

Strängen trunkeras sedan till MAXPATHLEN (låt oss säga 4096):
/home/site/public_html/modules/test.php//././.[...]/./.
4096 tecken

Här kan du se varför det var nödvändigt att lägga till ytterligare ett snedstreck (annars hade linjen klippts av till snedstrecket). Nu är den här linjen normaliserad, först tar du bort de extra snedstrecket:
/home/site/public_html/modules/test.php/././.[...]/./.
4095 tecken

Som ett resultat får vi rätt sökväg till filen vi behöver, och denna sökväg kommer redan att överföras till include, och filen vi behöver kommer att inkluderas.

Det vill säga, det är så här vi kommer att inkludera vår "test.php"-fil framgångsrikt.
script.php?module=test.php//././.[...]/././.

Det betyder att sårbarheten inte är teoretisk. Som ett resultat förlorade min klient vadet, och jag vann vadet och de 10 rubel vi satsat på. Naturligtvis, förutom 10 rubel, vann jag också förtroende och respekt i klientens ögon, vilket också är viktigt.

Anteckningar

Här kommer jag att titta på ett par intressanta funktioner för utnyttjande av denna sårbarhet.

Avsluta katalogen

Tänk på den här koden:

) ;

Låt oss hoppa över punkten att du kan använda RFI och inkludera en fil från en fjärrserver. Låt oss säga "allow_url_include=OFF" på servern.

Låt oss överväga en situation när vi behöver inkludera en fil från katalogen nedan:
script.php?module=../test.php/././.[...]/././.

En sådan begäran kommer att generera ett fel som att filen inte hittas. Och för att komma runt detta måste vi kalla det så här:
script.php?module=blabla/../../test.php/././.[...]/././.

Det var inte förgäves som jag beskrev kanoniseringen av stigar. Tack vare det behöver "blabla"-katalogen inte existera.

Lägga till enkla snedstreck

En uppmärksam läsare har säkert lagt märke till att jag i normaliseringsbeskrivningen skrev att extra snedstreck “/” och prickar med snedstreck “/.” tas bort, så varför inte bara använda snedstreck för att slippa onödigt krångel med punkten som slutar i slutet.

Allt handlar om algoritmerna, det vill säga ett snedstreck med en punkt "/." är helt borttagen. Men med enkla snedstreck är situationen lite mer komplicerad; under normaliseringen ersätts vartannat snedstreck med ett tills det bara finns ett (!) snedstreck kvar, exempel:

/home/site/public_html/modules/test.php///////////////////
57 tecken
↓
/home/site/public_html/modules/test.php//////////
48 tecken
↓
/home/site/public_html/modules/test.php/////
44 tecken
↓
/home/site/public_html/modules/test.php///
42 tecken
↓
/home/site/public_html/modules/test.php//
41 tecken
↓
/home/site/public_html/modules/test.php/
40 tecken

En liten utvikning:

Dessutom, om du uppmärksammar många populära hackresurser kommer du att märka detta fel. Som jag förstår det började detta fel med en artikel av en viss Raz0r där han föreslog en vektor:
index.php?act=../../../../../etc/passwd/////[…]/////

Och var uppmärksam även på tidningen ][aker upprepade detta misstag i sin artikel. Dessutom, även i den ursprungliga USH-artikeln skrevs det tydligt att det inte är tillrådligt att använda bara snedstreck, och det är nödvändigt att ett punkttecken lämnas i slutet innan normalisering. Men enkla snedstreck (även utan en prick i slutet) fungerar bara i PHP med Suhosin.

Det vill säga, använd ett snedstreck med en punkt "/." - en mer universell metod, eftersom den, till skillnad från snedstreck "/", fungerar för alla versioner av php.

Slutsats

Jag hoppas att den här artikeln hjälper dig att förstå att du inte bör lämna ens de minsta sårbarheter i dina skript, eftersom du förr eller senare kan utveckla din egen attackvektor för dem, vilket kan leda till allvarliga konsekvenser.

En av de fantastiska sakerna med PHP är hur det fungerar med HTML-formulär. Huvudsaken här är att varje formulärelement automatiskt blir tillgängligt för dina PHP-program. För detaljerad information om hur du använder formulär i PHP, läs avsnittet. Här är ett exempel på ett HTML-formulär:

Exempel #1 Enklaste HTML-formulär

Det är inget speciellt med denna form. Detta är ett vanligt HTML-formulär utan några speciella taggar. När användaren fyller i formuläret och klickar på knappen Skicka kommer sidan action.php att anropas. Den här filen kan ha något i stil med:

Exempel #2 Visar formulärdata

Hallå, .
Till digår.

Exempel på utdata från detta program:

Hej, Sergey. Du är 30 år gammal.

Om du inte tar hänsyn till kodbitarna med htmlspecialchars() Och (int), bör den här kodens funktionsprincip vara enkel och begriplig. htmlspecialchars() Säkerställer att "speciella" HTML-tecken är korrekt kodade så att skadlig HTML eller Javascript inte infogas på din sida. Åldersfältet, som vi vet ska vara ett tal, kan vi helt enkelt konvertera till heltal, som automatiskt tar bort oönskade tecken. PHP kan också göra detta automatiskt med filtertillägget. Variablerna $_POST["namn"] och $_POST["ålder"] ställs in automatiskt för dig av PHP. Tidigare använde vi $_SERVER superglobal variabel, men här använder vi också $_POST superglobal variabel, som innehåller alla POST-data. Lägg märke till att sändningsmetod(metoden) av vårt formulär är POST. Om vi ​​använde metoden SKAFFA SIG, då skulle vår formulärinformation finnas i den superglobala variabeln $_GET . Alternativt kan du använda variabeln $_REQUEST om datakällan inte spelar någon roll. Denna variabel innehåller en blandning av GET, POST, COOKIE-data.

15 år sedan

Enligt HTTP-specifikationen bör du använda POST-metoden när du använder formuläret för att ändra tillståndet för något på serversidan. Till exempel, om en sida har ett formulär som tillåter användare att lägga till sina egna kommentarer, som den här sida här ska formuläret använda POST. Om du klickar på "Ladda om" eller "Uppdatera" på en sida som du nådde via ett POST, är det nästan alltid ett fel -- du bör inte posta samma kommentar två gånger -- vilket är anledningen till att dessa sidor inte är bokmärkta eller cachade.

Du bör använda GET-metoden när ditt formulär, ja, tar bort något från servern och faktiskt inte ändrar någonting. Till exempel bör formuläret för en sökmotor använda GET, eftersom sökning på en webbplats inte bör ändra något som klienten kanske bryr sig om, och att bokmärka eller cachelagra resultaten av en sökmotorfråga är lika användbart som att bokmärka eller cachelagra en statisk HTML-sida.

2 år sedan

Värt att förtydliga:

POST är inte säkrare än GET.

Skälen till att välja GET vs POST involverar olika faktorer som avsikten med begäran (sänder du information?), storleken på begäran (det finns gränser för hur lång en URL kan vara och GET-parametrar skickas in webbadressen), och hur lätt du vill att åtgärden ska vara delbar -- Exempel, Google-sökningar är GET eftersom det gör det enkelt att kopiera och dela sökfrågan med någon annan helt enkelt genom att dela webbadressen.

Säkerhet är bara ett övervägande här på grund av det faktum att en GET är lättare att dela än en POST. Exempel: du vill inte att ett lösenord ska skickas av GET, eftersom användaren kan dela den resulterande webbadressen och oavsiktligt avslöja sitt lösenord.

En GET och en POST är dock lika lätta att fånga upp av en välplacerad illvillig person om du inte distribuerar TLS/SSL för att skydda själva nätverksanslutningen.

Alla formulär som skickas över HTTP (vanligtvis port 80) är osäkra, och idag (2017) finns det inte många goda skäl för en offentlig webbplats att inte använda HTTPS (vilket i grunden är HTTP + Transport Layer Security).

Som en bonus, om du använder TLS minimerar du risken för att dina användare får kod (ADs) injicerad i din trafik som inte lagts dit av dig.

Em-elementet representerar ett textstycke med betoning. Du kan använda den för att fästa läsarens uppmärksamhet på innebörden av en mening eller ett stycke. Jag ska berätta vad detta betyder efter , som beskriver em-elementet.

Tabell 8-6: em element

Bild 8-3: Använda em-elementet

I det här exemplet lägger jag betoning på I (I) i början av meningen. Om vi ​​tänker på em-elementet, när vi säger en mening högt, överväger vi det faktum att meningen är ett svar på en fråga. Föreställ dig till exempel att jag frågade: "Vem gillar äpplen och apelsiner?" Ditt svar blir: "Jag gillar äpplen och apelsiner." (När du säger detta högt och lägger tonvikten på I, gör du klart att du är en person som gillar dessa frukter).

Men om jag frågade: "Gillar du äpplen och vad mer?" Du kan svara: "Jag gillar äpplen och apelsiner." I det här fallet kommer tonvikten att ligga på det sista ordet, och betona att apelsiner är en annan frukt som du gillar. Det här alternativet i HTML skulle se ut så här:

Jag gillar äpplen och apelsiner .

Definition av främmande ord och facktermer

I-elementet betecknar ett stycke text som är av annan karaktär än det omgivande innehållet. Detta är en ganska vag definition, men vanliga exempel inkluderar ord från andra språk, tekniska eller vetenskapliga termer och till och med mänskliga tankar (i motsats till tal). Elementet i beskrivs.

Tabell 8-7: Element i

Bild 8-5: Använder elementet s

Identifiera viktig text

Det starka inslaget betecknar ett textstycke som är viktigt. Detta element beskrivs i.

Tabell 8-9: Element starkt

Bild 8-7: Använder elementet u

Lägger till litet typsnitt

Det lilla elementet betecknar litet teckensnitt och används ofta för meriter och förtydliganden. B representerar det lilla elementet.

Tabell 8-11: element liten

Bild 8-8: Använder det lilla elementet

Lägga till en upphöjd och en nedsänkt

Du kan använda sub- och sup-elementen för att beteckna upphöjd respektive nedsänkt. Upphöjda ord används för att skriva ord på vissa språk, och både upphöjd och nedsänkt används i enkla matematiska uttryck. Dessa element presenteras i.

Tabell 8-12: Sub- och sup-element

Bild 8-9: Använda sub- och sup-elementen

Vi har kort berört ämnet metoder för att visa innehåll i en mall. Låt oss nu titta närmare på vad det är och vad det äts med. Så metoddeklarationer jdoc finns i varje Joomla-mall och visa den eller den informationen i mallens brödtext (det vill säga på webbplatssidan). I allmänhet ser metoddeklarationen ut så här:

Den här raden visar information från komponenter på webbplatsen, till exempel artiklar från com_content. Typen av utdataelement anges i attributet.

1. typ - typer av utdataelement.

• komponent- som jag skrev ovan, visar huvudinnehållet på sidan. Kan endast anropas en gång per mall.
• huvud- meddelas också en gång efter öppningstaggen . Fungerar för att visa stilar, skript,