Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00324 004417 14686871 na godz. na dobę w sumie
Splątana sieć. Przewodnik po bezpieczeństwie nowoczesnych aplikacji WWW - książka
Splątana sieć. Przewodnik po bezpieczeństwie nowoczesnych aplikacji WWW - książka
Autor: Liczba stron: 360
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-4477-3 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> hacking >> bezpieczeństwo systemów
Porównaj ceny (książka, ebook, audiobook).
Dokładna i wyczerpująca analiza, przygotowana przez jednego z najpoważniejszych ekspertów od bezpieczeństwa przeglądarek
Tavis Ormandy, Google Inc.

Nowoczesne aplikacje WWW są jak splątany kłębek, złożony z powiązanych wzajemnie technologii, które powstawały w różnym czasie i których współpraca nie przebiega całkiem gładko. Użycie w stosie aplikacji WWW dowolnego elementu - od żądań HTTP, aż po skrypty działające w przeglądarce - pociąga za sobą ważne, choć subtelne konsekwencje związane z bezpieczeństwem. Twórcy aplikacji chcący chronić użytkowników muszą pewnie poruszać się w tym środowisku.

Michał Zalewski, jeden z czołowych ekspertów od bezpieczeństwa przeglądarek, prezentuje w Splątanej sieci porywające objaśnienie metod działania przeglądarek i powodów niedostatecznego poziomu ich bezpieczeństwa. Nie podaje uproszczonych porad dotyczących różnych podatności, ale przegląda cały model bezpieczeństwa i wskazuje jego słabe punkty. Pokazuje też sposoby poprawienia bezpieczeństwa aplikacji WWW.

Z książki dowiesz się, jak:

Unikalny podręcznik poświęcony bezpieczeństwu!


Michał Zalewski jest uznanym na całym świecie ekspertem ds. bezpieczeństwa informacji. Może poszczycić się wykryciem setek różnego rodzaju podatności i często wymieniany jest wśród osób mających największy wpływ na bezpieczeństwo w sieci. Jest autorem Ciszy w sieci, dostępnego na stronach Google Browser Security Handbook, oraz wielu ważnych artykułów.


Patron medialny:


Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Tytuł oryginału: The Tangled Web: A Guide to Securing Modern Web Applications Tłumaczenie: Wojciech Moch ISBN: 978-83-246-4477-3 Original edition copyright © 2012 by Michał Zalewski. All rights reserved. Published by arrangement with No Starch Press, Inc. Polish edition copyright 2012 by HELION SA. All rights reserved. All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from the Publisher. Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/splasi Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis treĂci WST}P 15 PodziÚkowania ...........................................................................................................................17 1 19 BEZPIECZE”STWO W ¥WIECIE APLIKACJI WWW Podstawy bezpieczeñstwa informacji ........................................................................................19 Flirtowanie z rozwiÈzaniami formalnymi ............................................................................20 ZarzÈdzanie ryzykiem ........................................................................................................22 OĂwiecenie przez taksonomiÚ ...........................................................................................24 RozwiÈzania praktyczne .....................................................................................................26 Krótka historia sieci WWW ........................................................................................................27 OpowieĂci z epoki kamienia: 1945 do 1994 ......................................................................27 Pierwsze wojny przeglÈdarek: 1995 do 1999 ....................................................................30 Okres nudy: 2000 do 2003 ................................................................................................31 Web 2.0 i drugie wojny przeglÈdarek: 2004 i póěniej ........................................................32 Ewolucja zagroĝeñ .....................................................................................................................34 Uĝytkownik jako problem bezpieczeñstwa .......................................................................34 Chmura, czyli radoĂÊ ĝycia w spoïecznoĂci ........................................................................35 RozbieĝnoĂÊ wizji ...............................................................................................................36 Interakcje miÚdzy przeglÈdarkami: wspólna poraĝka .........................................................37 Rozpad podziaïu na klienta i serwer ...................................................................................38 CZ}¥m I: ANATOMIA SIECI WWW 41 2 WSZYSTKO ZACZYNA SI} OD ADRESU 43 Struktura adresu URL ................................................................................................................44 Nazwa schematu ................................................................................................................44 Jak rozpoznaÊ hierarchiczny adres URL? ............................................................................45 Dane uwierzytelniajÈce dostÚp do zasobu .........................................................................46 Adres serwera ....................................................................................................................47 Port serwera ......................................................................................................................48 Hierarchiczna Ăcieĝka do pliku ...........................................................................................48 Tekst zapytania .................................................................................................................. 48 Identyfikator fragmentu ..................................................................................................... 49 A teraz wszystko razem .................................................................................................... 50 Znaki zarezerwowane i kodowanie ze znakiem procenta ........................................................ 52 Obsïuga znaków spoza podstawowego zestawu ASCII .................................................... 54 Typowe schematy adresów URL i ich funkcje .......................................................................... 58 Obsïugiwane przez przeglÈdarkÚ protokoïy pobierania dokumentów ............................. 59 Protokoïy obsïugiwane przez aplikacje i wtyczki firm trzecich ......................................... 59 Pseudoprotokoïy niehermetyzujÈce .................................................................................. 60 Pseudoprotokoïy hermetyzujÈce ....................................................................................... 60 Ostatnia uwaga na temat wykrywania schematów ........................................................... 61 RozwiÈzywanie wzglÚdnych adresów URL ............................................................................... 61 ¥ciÈga ......................................................................................................................................... 64 Podczas tworzenia nowych adresów URL na podstawie danych otrzymanych od uĝytkownika ......................................................... 64 Podczas projektowania filtrów adresów URL ................................................................... 64 Podczas dekodowania parametrów otrzymanych w adresach URL ................................. 64 3 PROTOKӒ HTTP 65 Podstawowa skïadnia ruchu sieciowego HTTP ........................................................................ 66 Konsekwencje utrzymywania obsïugi standardu HTTP/0.9 .............................................. 68 Dziwna obsïuga znaków nowego wiersza ......................................................................... 69 ¿Èdania proxy .................................................................................................................... 70 Obsïuga konfliktujÈcych lub podwójnych nagïówków ....................................................... 72 WartoĂci nagïówków rozdzielane Ărednikami ................................................................... 73 Zestaw znaków nagïówka i schematy kodowania ............................................................. 74 Zachowanie nagïówka Referer .......................................................................................... 76 Typy ĝÈdañ HTTP ..................................................................................................................... 77 GET ................................................................................................................................... 77 POST ................................................................................................................................. 78 HEAD ................................................................................................................................ 78 OPTIONS .......................................................................................................................... 78 PUT ................................................................................................................................... 79 DELETE ............................................................................................................................. 79 TRACE ............................................................................................................................... 79 CONNECT ....................................................................................................................... 79 Inne metody HTTP ............................................................................................................ 79 Kody odpowiedzi serwera ........................................................................................................ 80 200 – 299: Sukces .............................................................................................................. 80 300 – 399: Przekierowanie i inne komunikaty o stanie ..................................................... 80 400 – 499: BïÚdy po stronie klienta ................................................................................... 81 500 – 599: BïÚdy po stronie serwera ................................................................................ 82 SpójnoĂÊ sygnaïów wynikajÈcych z kodów HTTP ............................................................. 82 Sesje podtrzymywane ................................................................................................................ 82 Przesyïanie danych w czÚĂciach ................................................................................................ 84 8 S p i s t r e Ă c i PamiÚÊ podrÚczna ......................................................................................................................85 Semantyka ciasteczek HTTP ......................................................................................................87 Uwierzytelnianie HTTP .............................................................................................................90 Szyfrowanie na poziomie protokoïu i certyfikaty klientów ........................................................91 Certyfikaty rozszerzonej kontroli poprawnoĂci .................................................................93 Reguïy obsïugi bïÚdów .......................................................................................................93 ¥ciÈga ..........................................................................................................................................95 Przy obsïudze nazw plików podanych przez uĝytkownika oraz nagïówków Content-Disposition ...............................................................................95 Przy umieszczaniu danych uĝytkownika w ciasteczkach HTTP .........................................95 Przy wysyïaniu kontrolowanych przez uĝytkownika nagïówków Location .......................95 Przy wysyïaniu kontrolowanych przez uĝytkownika nagïówków Redirect .......................95 Przy konstruowaniu innych rodzajów ĝÈdañ i odpowiedzi kontrolowanych przez uĝytkownika .............................................................96 4 97 J}ZYK HTML Podstawowe pojÚcia uĝywane w dokumentach HTML .............................................................98 Tryby parsowania dokumentu ...........................................................................................99 Walka o semantykÚ ..........................................................................................................101 PoznaÊ zachowanie parsera HTML ..........................................................................................102 Interakcje pomiÚdzy wieloma znacznikami ......................................................................103 Jawne i niejawne instrukcje warunkowe ..........................................................................104 Przydatne wskazówki do parsowania kodu HTML ..........................................................105 Kodowanie encji .......................................................................................................................105 Semantyka integracji HTTP/HTML ..........................................................................................107 HiperïÈcza i doïÈczanie treĂci ...................................................................................................108 Proste ïÈcza ......................................................................................................................109 Formularze i uruchamiane przez nie ĝÈdania ...................................................................109 Ramki ...............................................................................................................................112 DoïÈczanie treĂci okreĂlonego typu .................................................................................112 Uwaga dotyczÈca ataków miÚdzydomenowego faïszowania ĝÈdañ ................................114 ¥ciÈga ........................................................................................................................................116 Zasady higieny we wszystkich dokumentach HTML .......................................................116 Podczas generowania dokumentów HTML z elementami kontrolowanymi przez atakujÈcego ...........................................................116 Podczas przeksztaïcania dokumentu HTML w zwykïy tekst ...........................................117 Podczas pisania filtra znaczników dla treĂci tworzonych przez uĝytkownika ..................117 5 KASKADOWE ARKUSZE STYLÓW 119 Podstawy skïadni CSS ...............................................................................................................120 Definicje wïaĂciwoĂci .......................................................................................................121 Dyrektywy @ i wiÈzania XBL ..........................................................................................122 Interakcje z jÚzykiem HTML ............................................................................................122 S p i s t r e Ă c i 9 Ryzyko ponownej synchronizacji parsera ................................................................................ 123 Kodowanie znaków ................................................................................................................. 124 ¥ciÈga ....................................................................................................................................... 126 Podczas ïadowania zdalnych arkuszy stylów ................................................................... 126 Gdy wstawiasz do kodu CSS wartoĂci podane przez atakujÈcego .................................. 126 Podczas filtrowania stylów CSS podanych przez uĝytkownika ....................................... 126 Gdy umieszczasz w znacznikach HTML wartoĂci klas podane przez uĝytkownika ........ 127 6 SKRYPTY DZIA’AJkCE W PRZEGLkDARCE 129 Podstawowe cechy jÚzyka JavaScript ...................................................................................... 130 Model przetwarzania skryptów ....................................................................................... 131 ZarzÈdzanie wykonaniem kodu ....................................................................................... 135 MoĝliwoĂci badania kodu i obiektów ............................................................................... 136 Modyfikowanie Ărodowiska uruchomieniowego ............................................................. 137 JSON i inne metody serializacji danych ........................................................................... 139 E4X i inne rozszerzenia skïadni jÚzyka ............................................................................ 142 Standardowa hierarchia obiektów ........................................................................................... 143 Model DOM .................................................................................................................... 145 DostÚp do innych dokumentów ...................................................................................... 148 Kodowanie znaków w skryptach ............................................................................................. 149 Tryby doïÈczania kodu i ryzyko zagnieĝdĝania ........................................................................ 150 ¿ywy trup: Visual Basic ........................................................................................................... 152 ¥ciÈga ....................................................................................................................................... 153 Podczas ïadowania zdalnego skryptu .............................................................................. 153 Podczas parsowania danych JSON otrzymanych od serwera ......................................... 153 Gdy umieszczasz dane przesïane przez uĝytkownika w blokach JavaScriptu ................. 153 Podczas interakcji z obiektami przeglÈdarki po stronie klienta ....................................... 154 Jeĝeli chcesz pozwoliÊ na dziaïanie skryptów uĝytkownika na swojej stronie ................ 154 7 DOKUMENTY INNE NI¿ HTML 155 Pliki tekstowe .......................................................................................................................... 155 Obrazy bitmapowe .................................................................................................................. 156 Audio i wideo .......................................................................................................................... 157 Dokumenty zwiÈzane z formatem XML ................................................................................. 158 Ogólny widok XML ......................................................................................................... 159 Format SVG ..................................................................................................................... 160 MathML ........................................................................................................................... 161 XUL ................................................................................................................................. 161 WML ................................................................................................................................ 162 Kanaïy RSS i Atom ........................................................................................................... 163 Uwaga na temat nierysowanych typów plików ....................................................................... 163 ¥ciÈga ....................................................................................................................................... 165 UdostÚpniajÈc dokumenty w formacie wywiedzionym z XML ....................................... 165 W przypadku wszystkich typów dokumentów nie-HTML .............................................. 165 10 S p i s t r e Ă c i 8 RYSOWANIE TRE¥CI ZA POMOCk WTYCZEK PRZEGLkDARKI 167 Wywoïywanie wtyczki .............................................................................................................168 Zagroĝenia w obsïudze wartoĂci nagïówka Content-Type we wtyczkach ......................169 Funkcje wspomagajÈce rysowanie dokumentu ........................................................................171 Platformy aplikacji wykorzystujÈce wtyczki .............................................................................172 Adobe Flash ......................................................................................................................172 Microsoft Silverlight ..........................................................................................................175 Sun Java ............................................................................................................................176 XBAP ................................................................................................................................177 Kontrolki ActiveX ....................................................................................................................178 Inne wtyczki .............................................................................................................................179 ¥ciÈga ........................................................................................................................................181 Gdy udostÚpniasz pliki obsïugiwane za pomocÈ wtyczek ................................................181 Gdy osadzasz w stronach pliki obsïugiwane przez wtyczki .............................................181 Jeĝeli chcesz napisaÊ nowÈ wtyczkÚ dla przeglÈdarek albo kontrolkÚ ActiveX ...............182 CZ}¥m II: FUNKCJE BEZPIECZE”STWA PRZEGLkDAREK 183 9 LOGIKA IZOLACJI TRE¥CI 185 Reguïa tego samego pochodzenia w modelu DOM .................................................................186 document.domain ............................................................................................................187 postMessage(…) ..............................................................................................................188 Interakcje z danymi uwierzytelniajÈcymi ..........................................................................190 Reguïa tego samego pochodzenia i API XMLHttpRequest ......................................................191 Reguïa tego samego pochodzenia w technologii Web Storage ................................................193 Reguïy bezpieczeñstwa dla ciasteczek .....................................................................................194 Wpïyw ciasteczek na reguïÚ tego samego pochodzenia ..................................................196 Problemy z ograniczeniami domen ..................................................................................197 Nietypowe zagroĝenie wynikajÈce z nazwy „localhost” ..................................................198 Ciasteczka i „legalna” kradzieĝ domen ............................................................................199 Reguïy bezpieczeñstwa wtyczek ..............................................................................................200 Adobe Flash ......................................................................................................................201 Microsoft Silverlight ..........................................................................................................204 Java ...................................................................................................................................205 Obsïuga dwuznacznego lub nieoczekiwanego pochodzenia ....................................................206 Adresy IP ..........................................................................................................................206 Nazwy hostów z dodatkowymi kropkami .......................................................................207 Nie w peïni kwalifikowane nazwy hostów .......................................................................207 Pliki lokalne ......................................................................................................................208 Pseudoadresy URL ...........................................................................................................209 Rozszerzenia przeglÈdarek i interfejsu uĝytkownika ........................................................209 Inne zastosowania koncepcji pochodzenia ...............................................................................210 S p i s t r e Ă c i 11 ¥ciÈga ....................................................................................................................................... 211 Prawidïowa higiena reguï bezpieczeñstwa dla wszystkich witryn ................................... 211 Gdy uĝywasz ciasteczek HTTP w procesie uwierzytelniania .......................................... 211 Podczas miÚdzydomenowej komunikacji w skryptach JavaScript ................................... 211 Podczas wstawiania na stronÚ pochodzÈcych z zewnÚtrznych ěródeï aktywnych treĂci obsïugiwanych przez wtyczki ......................... 211 Gdy udostÚpniasz wïasne treĂci obsïugiwane przez wtyczki .......................................... 212 Gdy tworzysz wïasne rozszerzenia dla przeglÈdarek ...................................................... 212 10 DZIEDZICZENIE POCHODZENIA 213 Dziedziczenie pochodzenia dla stron about:blank ....................................................................... 214 Dziedziczenie pochodzenia dla adresów data: ........................................................................ 216 Dziedziczenie w przypadku adresów javascript: i vbscript: .................................................... 218 Uwagi na temat ograniczonych pseudoadresów URL ............................................................. 219 ¥ciÈga ....................................................................................................................................... 221 11 ¿YCIE OBOK REGU’Y TEGO SAMEGO POCHODZENIA 223 Interakcje z oknami i ramkami ................................................................................................ 224 Zmiana lokalizacji istniejÈcych dokumentów ................................................................... 224 Mimowolne umieszczanie w ramkach ............................................................................. 228 MiÚdzydomenowe wstawianie treĂci ...................................................................................... 232 Uwaga do miÚdzydomenowych podzasobów ................................................................. 235 Kanaïy poboczne wpïywajÈce na prywatnoĂÊ ......................................................................... 236 Inne luki w regule SOP i sposoby ich wykorzystania ............................................................... 238 ¥ciÈga ....................................................................................................................................... 239 Prawidïowa higiena bezpieczeñstwa dla wszystkich witryn ............................................ 239 Gdy wïÈczasz na stronÚ zasoby z innych domen ............................................................. 239 Gdy tworzysz miÚdzydomenowÈ komunikacjÚ w skryptach JavaScript .......................... 239 12 INNE FUNKCJE BEZPIECZE”STWA 241 Nawigowanie do wraĝliwych schematów ............................................................................... 242 DostÚp do sieci wewnÚtrznych ............................................................................................... 243 Porty zakazane ........................................................................................................................ 245 Ograniczenia nakïadane na ciasteczka stron trzecich .............................................................. 247 ¥ciÈga ....................................................................................................................................... 250 Podczas tworzenia aplikacji WWW w sieciach wewnÚtrznych ....................................... 250 Podczas uruchamiania usïug nie-HTTP, w szczególnoĂci dziaïajÈcych na niestandardowych portach ........................................... 250 Gdy uĝywasz ciasteczka stron trzecich w róĝnych gadĝetach lub treĂciach umieszczanych w piaskownicy ................................................................... 250 12 S p i s t r e Ă c i 13 MECHANIZMY ROZPOZNAWANIA TRE¥CI 251 Logika wykrywania rodzaju dokumentu ..................................................................................252 Nieprawidïowe typy MIME ..............................................................................................253 WartoĂci dla specjalnych rodzajów treĂci ........................................................................254 Nierozpoznane rodzaje treĂci ..........................................................................................256 Ochronne zastosowanie nagïówka Content-Disposition .................................................258 Dyrektywy Content dotyczÈce podzasobów ...................................................................259 Pobrane pliki i inne treĂci nie-HTTP ................................................................................260 Obsïuga zestawów znaków .....................................................................................................262 Znacznik kolejnoĂci bajtów ..............................................................................................264 Dziedziczenie i pokrywanie zestawu znaków ..................................................................265 Zestaw znaków przypisany znacznikiem do zasobu ........................................................266 Wykrywanie zestawu znaków w plikach przesïanych protokoïem innym niĝ HTTP ......267 ¥ciÈga ........................................................................................................................................269 Prawidïowe praktyki bezpieczeñstwa dla witryn .............................................................269 Gdy generujesz dokumenty zawierajÈce treĂci kontrolowane przez atakujÈcego ...........269 Gdy przechowujesz pliki wygenerowane przez uĝytkownika .........................................269 14 WALKA ZE Z’O¥LIWYMI SKRYPTAMI 271 Ataki odmowy Ăwiadczenia usïugi (DoS) .................................................................................272 Ograniczenia czasu wykonania i wykorzystania pamiÚci ..................................................273 Ograniczenie liczby poïÈczeñ ...........................................................................................274 Filtrowanie wyskakujÈcych okienek .................................................................................275 Ograniczenia uĝycia okien dialogowych ...........................................................................277 Problemy z wyglÈdem i pozycjÈ okien .....................................................................................278 Ataki czasowe na interfejs uĝytkownika ...................................................................................282 ¥ciÈga ........................................................................................................................................285 Gdy umoĝliwiasz umieszczanie na swojej stronie gadĝetów uĝytkownika zamkniÚtych w ramkach iframe ...........................................285 Gdy tworzysz bezpieczne interfejsy uĝytkownika ...........................................................285 15 UPRAWNIENIA WITRYN 287 Uprawnienia witryn definiowane w przeglÈdarkach i wtyczkach ............................................288 Z góry zdefiniowane domeny ..........................................................................................289 Menedĝery haseï ......................................................................................................................289 Model stref Internet Explorera ................................................................................................291 Mechanizmy mark of the web i Zone.Identifier ...............................................................294 ¥ciÈga ........................................................................................................................................296 Gdy ĝÈdasz podniesienia uprawnieñ dla aplikacji WWW .................................................296 Gdy tworzysz wtyczki lub rozszerzenia korzystajÈce z uprzywilejowanego pochodzenia ..................................................................................296 S p i s t r e Ă c i 13 CZ}¥m III: SPOJRZENIE W PRZYSZ’O¥m 297 16 299 PLANOWANE NOWE FUNKCJE BEZPIECZE”STWA Metody rozbudowy modelu bezpieczeñstwa ......................................................................... 300 ¿Èdania miÚdzydomenowe ............................................................................................. 300 XDomainRequest ............................................................................................................ 304 Inne zastosowania nagïówka Origin ................................................................................ 305 Schematy ograniczeñ modelu bezpieczeñstwa ....................................................................... 306 Reguïa bezpieczeñstwa treĂci .......................................................................................... 307 Ramki w piaskownicy ...................................................................................................... 312 Strict Transport Security ................................................................................................. 314 Tryby przeglÈdania prywatnego ...................................................................................... 316 Pozostaïe projekty ................................................................................................................... 316 PorzÈdkowanie kodu HTML w przeglÈdarce .................................................................. 317 Filtrowanie XSS ............................................................................................................... 318 ¥ciÈga ....................................................................................................................................... 320 17 321 INNE MECHANIZMY PRZEGLkDAREK Propozycje zmian w adresach URL i protokoïach ..................................................................... 322 Funkcje na poziomie treĂci ...................................................................................................... 324 Interfejsy wejĂcia-wyjĂcia ......................................................................................................... 326 18 TYPOWE PODATNO¥CI SIECI WWW 329 PodatnoĂci aplikacji WWW ...................................................................................................... 330 Problemy, o których trzeba pamiÚtaÊ podczas projektowania aplikacji WWW ...................... 332 Typowe problemy zwiÈzane z kodem dziaïajÈcym po stronie serwera .................................. 334 337 339 353 EPILOG UWAGI SKOROWIDZ 14 S p i s t r e Ă c i 6 Skrypty dziaïajÈce w przeglÈdarce Pierwszy mechanizm skryptowy dziaïajÈcy w przeglÈdarce pojawiï siÚ w Nestcape Navigatorze w roku 1995 jako wynik prac Brendana Eicha. Wbudowany jÚzyk Mocha (bo taka byïa jego pierwotna nazwa) dawaï twórcom stron moĝliwoĂÊ manipulowania dokumentami HTML, wyĂwietlania prostych systemowych okien dialogowych, otwierania i przesuwania okien przeglÈdarki i wykorzystywania innych prostych typów automatyzacji dziaïania strony klienta. W kolejnych wydaniach beta swojej przeglÈdarki Netscape ostatecznie zmieniï nazwÚ Mocha na LiveScript, a po dopiÚciu dziwacznych umów z firmÈ Sun Micro- systems ostatecznÈ nazwÈ jÚzyka staïo siÚ JavaScript. Byïo zaledwie kilka podo- bieñstw miÚdzy jÚzykiem Mocha Eicha Brendana a JavÈ Suna, ale w firmie Netscape wierzono, ĝe takie marketingowe maïĝeñstwo z pewnoĂciÈ pozwoli uzyskaÊ Java- Scriptowi dominacjÚ w lukratywnym Ăwiecie serwerów. Pragnienie to staïo siÚ jasne po pojawieniu siÚ w 1995 roku sïynnego i wprowadzajÈcego w bïÈd ogïoszenia zapowiadajÈcego nowy jÚzyk, które od razu wiÈzaïo go z ogromnÈ liczbÈ produktów komercyjnych1: Netscape i Sun prezentujÈ JavaScript, nowy, otwarty, miÚdzyplatformowy i obiektowy jÚzyk skryptowy dla sieci korporacyjnych i internetu. […] Netscape Navigator Gold 2.0 pozwala na tworzenie i edytowanie skryptów w jÚzyku JavaScript, natomiast Netscape LiveWire umoĝliwia instalowanie, uruchamianie i zarzÈdzanie programami napisanymi w tym jÚzyku, zarówno w sieci korporacyjnej, jak i w caïym internecie. Netscape LiveWire Pro dodaje funkcje ïÈczenia z jÚzykiem JavaScript wydajnych relacyjnych baz danych firm Illustra, Informix, Microsoft, Oracle i Sybase. Obsïuga jÚzyków Java i JavaScript zostaïa wbudowana w produkty firmy Netscape w celu stworzenia zunifikowanego Ărodowiska narzÚdzi klienckich i serwerowych przeznaczonych do tworzenia i wdraĝania aplikacji sieciowych. Mimo niewïaĂciwego przywiÈzania firmy Netscape do jÚzyka Java wartoĂÊ jÚ- zyka JavaScript dla rozwiÈzañ programistycznych dziaïajÈcych po stronie klienta wydawaïa siÚ caïkiem spora, co byïo zrozumiaïe równieĝ dla konkurencji. W 1996 roku Microsoft odpowiedziaï Internet Explorerem 3.0, w którym wprowadzona zostaïa niemal idealna kopia jÚzyka JavaScript oraz wïasna propozycja firmy: zmie- niona wersja jÚzyka Visual Basic o nazwie VBScript. Zaproponowana przez Microsoft alternatywa nie zyskaïa jednak popularnoĂci, a jej obsïuga nie zostaïa nawet zaim- plementowana w innych przeglÈdarkach, co mogïo wynikaÊ ze spóěnionej prezentacji albo z nieeleganckiej skïadni nowego jÚzyka. Ostatecznie to JavaScript zagarnÈï lwiÈ czÚĂÊ rynku, a od tego czasu nawet nie próbowano wprowadziÊ nowych jÚzyków skryptowych do przeglÈdarek, co równieĝ moĝe wynikaÊ z pierwotnej poraĝki Microsoftu na tym polu. Firma Netscape zachÚcona popularnoĂciÈ jÚzyka JavaScript czÚĂÊ odpowie- dzialnoĂci za jego rozwój i konserwacjÚ przekazaïa niezaleĝnemu stowarzyszeniu ECMA (European Computer Manufacturers Association). Nowy opiekun jÚzyka juĝ w 1999 roku udostÚpniï trzecie wydanie specyfikacji ECMAScript2, ale od tego mo- mentu rozwój jÚzyka staï siÚ duĝo trudniejszy. Czwarte wydanie specyfikacji, które caïkowicie przedefiniowaïo caïy jÚzyk, po kilku latach przepychanek miÚdzy twór- cami przeglÈdarek zostaïo odïoĝone na póïkÚ, a ograniczone wydanie piÈte3 mimo opublikowania w 2009 roku nadal nie cieszy siÚ peïnÈ obsïugÈ w przeglÈdarkach (choÊ ten stan ciÈgle siÚ poprawia). W 2008 roku rozpoczÚïy siÚ prace nad kolejnÈ iteracjÈ, nazywanÈ „Harmony”, ale sÈ one nadal dalekie od ukoñczenia. Z powodu braku obowiÈzujÈcego wszystkich i stale ewoluujÈcego standardu pojawiajÈ siÚ rozszerze- nia jÚzyka tworzone przez poszczególnych producentów przeglÈdarek, ale takie do- datki zwykle powodujÈ tylko problemy. Podstawowe cechy jÚzyka JavaScript JavaScript jest wzglÚdnie prostym jÚzykiem przeznaczonym do interpretowania w momencie uruchomienia. Charakteryzuje siÚ skïadniÈ podobnÈ do uĝywanej w jÚzyku C (z wyjÈtkiem arytmetyki wskaěników), prostym, bezklasowym modelem 130 R o z d z i a ï 6 obiektów, który podobno zostaï zainspirowany maïo znanym jÚzykiem programo- wania o nazwie Self, mechanizmem automatycznego zwalniania pamiÚci i sïabym ty- powaniem dynamicznym. JavaScript nie ma wbudowanych mechanizmów wejĂcia-wyjĂcia. W przeglÈ- darkach otrzymaï ograniczone moĝliwoĂci interakcji ze Ărodowiskiem komputera, realizowane za pomocÈ metod i wïaĂciwoĂci odwoïujÈcych siÚ do kodu samej prze- glÈdarki. Jednak w przeciwieñstwie do interfejsów znanych z innych jÚzyków pro- gramowania funkcje te majÈ bardzo ograniczone moĝliwoĂci i zostaïy przygoto- wane do realizowania konkretnych zadañ. WiÚkszoĂÊ gïównych funkcji jÚzyka JavaScript nie jest niczym niezwykïym i po- winny byÊ one znane programistom uĝywajÈcym juĝ jÚzyków C lub C++ oraz w mniejszym stopniu — Java. Prosty program JavaScript moĝe wyglÈdaÊ tak: var text = CzeĂÊ, mamo! ; function display_string(str) { alert(str); return 0; } // To wywoáanie wyĞwietli tekst CzeĞü, mamo! . display_str(text); Dokïadniejsze wyjaĂnienie semantyki jÚzyka JavaScript wykracza poza ramy tej ksiÈĝki, dlatego w tym rozdziale podsumujÚ tylko szczególne i wpïywajÈce na bez- pieczeñstwo cechy jÚzyka. Czytelnicy szukajÈcy bardziej systematycznego wprowa- dzenia do jÚzyka powinni zainteresowaÊ siÚ ksiÈĝkÈ Marjina Haverbeke’a Eloquent JavaScript (No Starch Press, 2011). Model przetwarzania skryptów Kaĝdy dokument HTML wyĂwietlany w przeglÈdarce — niezaleĝnie od tego, czy w osobnym oknie, czy teĝ w ramce — otrzymuje osobne Ărodowisko wykonania skryptów JavaScript razem z niezaleĝnÈ przestrzeniÈ nazw dla wszystkich zmien- nych globalnych oraz funkcjami tworzonymi przez ïadowane skrypty. Wszystkie skrypty wykonywane w ramach kontekstu konkretnego dokumentu wspóïdzielÈ miÚdzy sobÈ jednÈ piaskownicÚ, ale mogÈ teĝ kontaktowaÊ siÚ z innymi konteksta- mi za poĂrednictwem specjalnego API. Takie interakcje miÚdzy dokumentami mu- szÈ byÊ wykonywane w sposób otwarty, dlatego przypadkowe interferencje sÈ bar- dzo maïo prawdopodobne. Na pierwszy rzut oka reguïy izolowania skryptów bardzo przypominajÈ model szufladkowania procesów, znany z nowoczesnych systemów operacyjnych, ale nie sÈ one aĝ tak rozbudowane. W ramach jednego kontekstu wykonania wszystkie znalezione bloki JavaScriptu przetwarzane sÈ po kolei, niemal zawsze w ĂciĂle okreĂlonym porzÈdku. Kaĝdy blok kodu musi skïadaÊ siÚ z dowolnej liczby prawidïowo zbudowanych jednostek skïa- dniowych, które sÈ przetwarzane w trzech nastÚpujÈcych po sobie krokach o na- zwach: parsowanie, rozwiÈzywanie funkcji i wykonanie kodu. S k r y p t y d z i a ï a j È c e w p r z e g l È d a r c e 131 Parsowanie Na etapie parsowania sprawdzana jest skïadnia bloku skryptu, który najczÚĂciej konwertowany jest do poĂredniej postaci binarnej. Wykonanie skryptu zapisa- nego w tej postaci jest zdecydowanie szybsze. Sam kod nie ma ĝadnych globalnych skutków do czasu caïkowitego ukoñczenia prac na tym etapie. Jeĝeli pojawiÈ siÚ bïÚdy skïadniowe, to caïy problematyczny blok kodu jest porzucany, a parser przechodzi do kolejnego dostÚpnego bloku kodu. W ramach zobrazowania zachowania parsera zgodnego ze specyfikacjÈ jÚzyka JavaScript zachÚcam do przyjrzenia siÚ poniĝszemu wycinkowi kodu: blok nr 1: script var my_variable1 = 1; var my_variable2 = /script blok nr. 2: script 2; /script DoĂwiadczenie zdobyte w pracy z jÚzykiem C podpowiada, ĝe powyĝszy kod powinien zostaÊ zinterpretowany tak samo jak poniĝszy. W jÚzyku JavaScript tak siÚ jednak nie dzieje. script var my_variable1 = 1; var my_variable2 = 2; /script Wynika to z faktu, ĝe bloki script nie sÈ ze sobÈ ïÈczone przed rozpoczÚciem parsowania. W tym przypadku pierwszy segment skryptu spowoduje powstanie bïÚdu skïadniowego (przypisanie z brakujÈcÈ wartoĂciÈ po prawej stronie), przez co caïy blok zostanie zignorowany i nie przejdzie do etapu wykonania. Fakt, ĝe caïy segment jest pomijany, zanim bÚdzie mógï mieÊ jakikolwiek wpïyw na stronÚ, ozna- cza teĝ, iĝ pierwotny przykïad nie jest równowaĝny poniĝszemu: script var my_variable1 = 1; /script script 2; /script Ta cecha odróĝnia jÚzyk JavaScript od wielu innych jÚzyków skryptowych, takich jak Bash, w których etap parsowania nie zostaï tak mocno oddzielony od etapu wykonania. 132 R o z d z i a ï 6 W naszym oryginalnym przykïadzie po zignorowaniu pierwszego bloku kodu parser przejdzie do drugiego dostÚpnego bloku ( script 2; /script ), który zo- stanie obsïuĝony bez ĝadnych bïÚdów. Drugi blok kodu jest równowaĝny wykona- niu instrukcji pustej, poniewaĝ znajduje siÚ w nim tylko jedna instrukcja bÚdÈca wartoĂciÈ numerycznÈ. RozwiÈzywanie funkcji Po zakoñczeniu etapu parsowania w kolejnym kroku rejestrowane sÈ wszystkie na- zwane, globalne funkcje znalezione przez parsera w aktualnym bloku kodu. Od tego momentu kaĝda znaleziona funkcja bÚdzie dostÚpna w uruchomionym póěniej ko- dzie. DziÚki zastosowaniu tego kroku poniĝszy kod zadziaïa bez ĝadnych proble- mów, poniewaĝ funkcja hello_world() zostanie zarejestrowana jeszcze przed wy- konaniem pierwszego wiersza kodu, wywoïujÈcego tÚ wïaĂnie funkcjÚ. Jest to dziaïanie odmienne od tego, do jakiego przyzwyczaili siÚ programiĂci uĝywajÈcy jÚzyków C lub C++. script hello_world(); function hello_world() { alert( CzeĂÊ, mamo! ); } /script Z drugiej strony poniĝszy kod nie zachowa siÚ tak, jak byĂmy sobie tego ĝyczyli: script hello_world(); /script script function hello_world() { alert( CzeĂÊ, mamo! ); } /script Tak zmieniony kod zgïosi bïÚdy w czasie wykonania, poniewaĝ poszczególne bloki nie sÈ obsïugiwane razem, ale w kolejnoĂci, w jakiej zostajÈ zaprezento- wane mechanizmowi skryptowemu. W czasie gdy pierwszy blok jest juĝ wyko- nywany, blok definiujÈcy funkcjÚ hello_world() nie zostaï nawet sparsowany. ¿eby byïo jeszcze ciekawiej, okazuje siÚ, ĝe opisany tu nieco dziwny sposób roz- wiÈzywania nazw dotyczy wyïÈcznie funkcji, a deklaracje zmiennych sÈ z niego wy- ïÈczone. Zmienne sÈ rejestrowane sekwencyjnie w czasie wykonania, podobnie jak dzieje siÚ to we wszystkich innych jÚzykach interpretowanych. Oznacza to, ĝe poniĝ- szy przykïad, w którym funkcja hello_world() zostaïa zastÈpiona funkcjÈ anonimowÈ przypisywanÈ do zmiennej globalnej, nie bÚdzie dziaïaï tak, jak byĂmy tego chcieli: S k r y p t y d z i a ï a j È c e w p r z e g l È d a r c e 133 script hello_world(); var hello_world = function() { alert( CzeĂÊ, mamo! ); } /script W tym przypadku przypisanie wartoĂci do zmiennej hello_world wykonywane jest dopiero po próbie wywoïania hello_world(). Wykonywanie kodu Po zakoñczeniu procesu rozwiÈzywania nazw mechanizm skryptowy przystÚpuje do wykonywania wszystkich instrukcji znajdujÈcych siÚ poza blokami funkcji. Na tym etapie wykonywanie skryptu moĝe zostaÊ zatrzymane z powodu nieobsïuĝo- nego wyjÈtku lub z kilku innych, bardziej ezoterycznych powodów. Mimo wystÈ- pienia takiego bïÚdu nadal moĝliwe bÚdzie wywoïanie wszystkich funkcji znajdu- jÈcych siÚ w tym samym bloku kodu, a zmiany wprowadzone przez wykonany do tej pory kod pozostanÈ aktywne w ramach bieĝÈcego kontekstu. W poniĝszym (dïugawym, ale i interesujÈcym) wycinku kodu prezentowanych jest kilka innych cech wykonania kodu JavaScript, w tym i mechanizm wznawiania pracy po wystÈpieniu wyjÈtku: script function not_called() { return 42; } function hello_world() { alert( W tym programie wszystko jest moĝliwe! ); do_stuff(); } alert( Witamy w naszej przykïadowej aplikacji. ); hello_world(); alert( DziÚkujemy, zapraszamy ponownie. ); /script script alert( Skoro juĝ popracowaliĂmy, to moĝe partyjka szachów? ); /script 134 R o z d z i a ï 6 ProszÚ samodzielnie wypróbowaÊ dziaïanie tego przykïadu i sprawdziÊ, czy podane przy nim komentarze zgadzajÈ siÚ z rzeczywistoĂciÈ. Z tego maïego Êwiczenia wynika, ĝe nieoczekiwane i nieobsïuĝone wyjÈtki majÈ doĂÊ nietypowe konsekwencje. MogÈ one wprowadziÊ aplikacjÚ w stan niespójny, a mimo to umoĝliwiajÈcy dalsze wykonywanie kodu. Zadaniem wyjÈtków jest uniemoĝliwienie rozprzestrzenienia siÚ bïÚdów wynikajÈcych z nieoczekiwanych sytuacji, a zatem taki sposób wykonywania skryptów naleĝy uznaÊ za dziwny, tym bardziej ĝe na wielu innych frontach (na przykïad w sprawie zakazu uĝywania in- strukcji goto) jÚzyk JavaScript ma zdecydowanie twardsze zasady. ZarzÈdzanie wykonaniem kodu ChcÈc odpowiednio przeanalizowaÊ cechy bezpieczeñstwa pewnych popularnych wzorców projektowych aplikacji WWW, musimy dokïadnie poznaÊ model koor- dynacji i zarzÈdzania wykonywaniem kodu stosowany w jÚzyku JavaScript. Na szczÚĂcie model ten jest zadziwiajÈco rozsÈdny. Niemal caïy kod JavaScript, który znajduje siÚ w okreĂlonym kontekĂcie, wy- konywany jest w sposób synchroniczny. Jeĝeli kod skryptu jest wykonywany, to jego wykonywanie nie moĝe zostaÊ wznowione w wyniku dziaïania zewnÚtrznego zdarzenia. Nie istnieje teĝ mechanizm wÈtków, które mogïyby równoczeĂnie modyfi- kowaÊ wspólnÈ pamiÚÊ. W czasie gdy mechanizm skryptowy jest zajÚty, wstrzymana zostaje obsïuga wszystkich zdarzeñ, czasomierzy, ĝÈdañ nawigacji w stronach itp. W wiÚkszoĂci przypadków caïa przeglÈdarka, a przynajmniej moduï rysujÈcy HTML, przestaje odpowiadaÊ. Obsïuga zdarzeñ zapisanych w kolejce wznawiana jest do- piero po zakoñczeniu wykonywania skryptu, gdy mechanizm skryptowy prze- chodzi do stanu wstrzymania. Od tego momentu ponownie moĝna uruchomiÊ kod JavaScript. Co wiÚcej, jÚzyk JavaScript nie udostÚpnia funkcji sleep(…) lub pause(…), która tymczasowo zwalniaïaby procesor i po pewnym czasie wznawiaïaby wykonywanie kodu od tego samego miejsca. Jeĝeli programista chce opóěniÊ wykonywanie wy- konania skryptu, musi zarejestrowaÊ czasomierz, który póěniej ponownie uru- chomi wykonywanie kodu. Wykonywanie to musi siÚ jednak rozpoczÈÊ na po- czÈtku funkcji obsïugujÈcej zdarzenie czasomierza (albo na poczÈtku anonimowej funkcji wprowadzonej w czasie konfigurowania czasomierza). Takie warunki moĝna uznaÊ za irytujÈce, ale trzeba przyznaÊ, ĝe prawie do zera redukujÈ one ryzyko wystÈpienia warunków wyĂcigu (ang. race condition) w uruchomionym kodzie. UWAGA W tym synchronicznym modelu wykonywania kodu istnieje kilka raczej przypadko- wych luk. JednÈ z nich jest moĝliwoĂÊ wykonania kodu w czasie, gdy wykonanie innego bloku kodu zostaje wstrzymane w wyniku wywoïania funkcji alert(…) lub showModalDialog(…). Trzeba jednak pamiÚtaÊ, ĝe takie przypadki brzegowe nie wpïywajÈ zbyt czÚsto na sposób wykonywania kodu. Taki blokujÈcy przeglÈdarkÚ sposób wykonywania pÚtli w kodzie JavaScript wymusza na samych przeglÈdarkach wprowadzanie pewnych mechanizmów ïago- dzÈcych. Mechanizmy te opiszÚ dokïadniej w rozdziale 14. Na razie wystarczy S k r y p t y d z i a ï a j È c e w p r z e g l È d a r c e 135 powiedzieÊ, ĝe wiÈĝÈ siÚ one z innymi, i to doĂÊ nieoczekiwanymi konsekwencjami. Wykonanie kaĝdej nieskoñczonej pÚtli moĝe zostaÊ zakoñczone w sposób zbliĝony do rzucenia nieobsïuĝonego wyjÈtku. Mechanizm skryptowy wróci wtedy do stanu wstrzymania, ale kod nadal bÚdzie mógï byÊ wykonywany, poniewaĝ wszystkie czasomierze i zdarzenia pozostanÈ aktywne. MoĝliwoĂÊ nieoczekiwanego przerwania dïuĝej dziaïajÈcego kodu, który przez autora traktowany jest jako zawsze wykonujÈcy siÚ w caïoĂci, moĝe zostaÊ wyko- rzystana przez atakujÈcego do wprowadzenia aplikacji w stan niezdefiniowany. To nie wszystko, inna podobna konsekwencja takiej semantyki powinna byÊ widoczna i zrozumiaïa po przeczytaniu punktu „JSON i inne metody serializacji danych”. MoĝliwoĂci badania kodu i obiektów JÚzyk JavaScript udostÚpnia podstawowe metody badania dekompilowanego kodu ěródïowego dowolnych niestandardowych funkcji. Wystarczy wywoïaÊ metodÚ toString() lub toSource() na rzecz dowolnej funkcji, którÈ chcemy skontrolowaÊ. Poza tym moĝliwoĂci skontrolowania przepïywu dziaïajÈcego programu sÈ bardzo ograniczone. Aplikacje mogÈ próbowaÊ wykorzystywaÊ dostÚp do zapisanej w pa- miÚci reprezentacji gïównego dokumentu i poszukiwaÊ w niej bloków script , ale w ten sposób nie da siÚ przejrzeÊ zdalnie ïadowanego lub generowanego kodu. Za pomocÈ niestandardowej wïaĂciwoĂci caller moĝna teĝ uzyskaÊ wglÈd w stos wywoïañ dziaïajÈcego skryptu, ale nie da siÚ w ten sposób okreĂliÊ aktualnie wyko- nywanego wiersza kodu ani jego czÚĂci, która zostanie wykonana w nastÚpnej kolejnoĂci. Dynamiczne tworzenie nowego kodu JavaScript jest jednÈ z najwaĝniejszych cech tego jÚzyka. Istnieje tu moĝliwoĂÊ nakazania mechanizmowi skryptowemu, aby synchronicznie interpretowaï ciÈgi znaków przekazywanych poprzez wbudo- wanÈ funkcjÚ eval(…). Na przykïad poniĝsza instrukcja spowoduje wyĂwietlenie okienka z komunikatem: eval( alert(\ CzeĂÊ, mamo!\ ) ) BïÚdy skïadniowe wykryte w tekĂcie przekazanym do funkcji eval(…) spowo- dujÈ, ĝe funkcja ta rzuci wyjÈtek. Jeĝeli parsowanie siÚ powiedzie, to wszystkie nie- obsïuĝone wyjÈtki rzucone przez interpretowany kod równieĝ zostanÈ przekazane do funkcji wywoïujÈcej. W przypadku gdy interpretowany kod zostanie bezbïÚdnie przygotowany i wykonany, to jako wartoĂÊ zwracana przez funkcjÚ eval(…) potrakto- wana zostanie wartoĂÊ ostatniej instrukcji znajdujÈcej siÚ w przekazanym jej kodzie. Obok opisanej funkcji moĝna teĝ wykorzystaÊ mechanizmy dziaïajÈce na po- ziomie przeglÈdarki, aby z ich pomocÈ zaplanowaÊ opóěnione parsowanie i wyko- nywanie nowych bloków kodu JavaScript, które to operacje zostanÈ wykonane, gdy tylko mechanizm skryptowy powróci do stanu wstrzymania. Przykïadami takich mechanizmów mogÈ byÊ czasomierze (setTimeout, setInterval), funkcje obsïugi zdarzeñ (onclick, onload itd.) oraz interfejsy umoĝliwiajÈce dostÚp do parsera HTML (innerHTML, document.write(…) i inne). 136 R o z d z i a ï 6 Co prawda moĝliwoĂci badania kodu pozostawiajÈ wiele do ĝyczenia, ale juĝ moĝliwoĂci introspekcji obiektów dziaïajÈcego kodu zostaïy w jÚzyku JavaScript doĂÊ mocno rozbudowane. Aplikacje mogÈ wyliczaÊ niemal wszystkie metody lub wïaĂciwoĂci obiektu za pomocÈ prostych iteratorów for … in oraz for each … in, a takĝe uĝywaÊ takich operatorów jak typeof, instanceof lub „jest dokïadnie równy” (===) i wïaĂciwoĂci length. W ten sposób programy mogÈ poznaÊ szczegóïy wszyst- kich znalezionych przez siebie elementów. Wszystkie te mechanizmy sprawiajÈ, ĝe skrypty dziaïajÈce w tym samym kon- tekĂcie nie majÈ prawie ĝadnych moĝliwoĂci ukrycia przed sobÈ jakichkolwiek da- nych. Co wiÚcej, utrudniajÈ one ukrywanie danych nawet pomiÚdzy róĝnymi kon- tekstami dokumentów. Z tym problemem twórcy przeglÈdarek walczyli przez bardzo dïugi czas, a jak dowiemy siÚ w rozdziale 11., nadal nie udaïo im siÚ caïko- wicie go rozwiÈzaÊ. Modyfikowanie Ărodowiska uruchomieniowego Mimo wzglÚdnej prostoty jÚzyka JavaScript wykonywane w nim skrypty majÈ wiele moĝliwoĂci, ĝeby mocno wpïynÈÊ na zachowanie wïasnej piaskownicy tworzonej przez jÚzyk. W rzadkich przypadkach takie zachowania mogÈ wpïywaÊ nawet na inne dokumenty. Pokrywanie wbudowanych elementów Jednym z najbardziej zaskakujÈcych narzÚdzi, jakimi mogÈ posïugiwaÊ siÚ zïo- Ăliwe skrypty, jest moĝliwoĂÊ usuniÚcia, pokrycia albo przesïoniÚcia wiÚkszoĂci wbudowanych w jÚzyk JavaScript funkcji oraz praktycznie wszystkich metod wej- Ăcia-wyjĂcia udostÚpnianych przez przeglÈdarkÚ. ProszÚ przyjrzeÊ siÚ na przykïad dziaïaniu poniĝszego kodu: // To przypisanie nie spowoduje powstania báĊdu. eval = alert; // To wywoáanie spowoduje nieoczekiwane wyĞwietlenie okna z komunikatem. eval( CzeĂÊ, mamo! ); A to dopiero poczÈtek zabawy. W Chrome, Safari i Operze moĝliwe jest caïko- wite usuniÚcie funkcji eval(…). Wystarczy skorzystaÊ z operatora delete. Dziwne jest teĝ to, ĝe próba wykonania tej samej operacji w Firefoksie spowoduje przywró- cenie oryginalnej, wbudowanej funkcji i usuniÚcie wszystkich ewentualnych pokryÊ. Z kolei w Internet Explorerze próba usuniÚcia tej funkcji spowoduje opóěnione rzucenie wyjÈtku, który w tym miejscu raczej nie ma ĝadnego konkretnego celu. Zgodnie z tÈ zasadÈ niemal wszystkie obiekty, wïÈcznie z wbudowanymi typami String lub Array, sÈ tylko prototypami, które moĝna dowolnie modyfikowaÊ. Taki prototyp jest obiektem nadrzÚdnym, od którego wszystkie istniejÈce i przyszïe obiekty wywodzÈ swoje metody i wïaĂciwoĂci. Jest to zgrubne odwzorowanie mechanizmu dziedziczenia klas istniejÈcego w bardziej rozbudowanych jÚzykach programowania. S k r y p t y d z i a ï a j È c e w p r z e g l È d a r c e 137 MoĝliwoĂÊ modyfikowania prototypów obiektów moĝe powodowaÊ maïo intuicyj- ne zachowania nowo tworzonych obiektów, o czym moĝna siÚ przekonaÊ w poniĝ- szym przykïadzie: Number.prototype.toString = function() { return Mam ciÚ! ; }; // To wywoáanie wyĞwietli napis Mam ciĊ! , a nie 42 : alert(new Number(42)); Funkcje get i set Jeszcze bardziej interesujÈcÈ cechÈ modelu obiektów w uĝywanym powszechnie dialekcie jÚzyka JavaScript sÈ funkcje get i set, które umoĝliwiajÈ zdefiniowanie wïasnego kodu obsïugujÈcego odczytywanie i zapisywanie wartoĂci do wïaĂciwoĂci danego obiektu. Co prawda nie jest to mechanizm aĝ tak rozbudowany jak przeciÈ- ĝanie operatorów w jÚzyku C++, ale moĝna go wykorzystaÊ do zmuszenia istnie- jÈcych obiektów lub prototypów do zachowañ dalekich od standardu. W poniĝszym wycinku kodu operacje przypisania i odczytania wartoĂci do wïaĂciwoĂci zostaïy w prosty sposób podmienione: var evil_object = { set foo() { alert( Mam ciÚ! ); }, get foo() { return 2; } }; // To przypisanie spowoduje wyĞwietlenie komunikatu Mam ciĊ! . // Poza tym nie stanie siĊ nic wiĊcej. evil_object.foo = 1; // To porównanie na pewno siĊ nie uda. if (evil_object.foo != 1) alert( Co siÚ dzieje?! ); UWAGA Funkcje set i get powstaïy poczÈtkowo jako rozszerzenie jÚzyka, ale zostaïy wïÈ- czone do standardu ECMAScript wydanie 5. Funkcje te dostÚpne sÈ we wszystkich nowoczesnych przeglÈdarkach (z wyjÈtkiem Internet Explorera w wersji 6 i 7). Efekty potencjalnych przypadków uĝycia jÚzyka W wyniku zastosowania technik opisywanych w poprzednich dwóch podpunktach skrypt uruchomiony w danym kontekĂcie, który zostaï zmieniony przez niezaufane treĂci, nie ma ĝadnej pewnej metody na sprawdzenie swojego Ărodowiska ani na wykonanie dziaïañ korygujÈcych. Nie moĝna zaufaÊ nawet zachowaniu prostych wyraĝeñ warunkowych oraz pÚtli. Proponowane rozszerzenia jÚzyka najprawdo- podobniej spowodujÈ jeszcze wiÚksze skomplikowanie tej sytuacji. Na przykïad 138 R o z d z i a ï 6 nieudana propozycja z 4. wydania jÚzyka ECMAScript zawieraïa opis rozbudowa- nego mechanizmu przeciÈĝania operatorów i pomysï ten prawdopodobnie bÚ- dzie powracaï w przyszïoĂci. Bardzo ciekawe jest teĝ to, ĝe podjÚte decyzje projektowe utrudniajÈ teraz moĝliwoĂci sprawdzania kontekstu wykonania spoza piaskownicy tworzonej dla danej strony. Na przykïad Ălepe zaufanie w dziaïanie obiektu location w poten- cjalnie wrogim dokumencie doprowadziïo juĝ do wielu problemów z bezpieczeñ- stwem, zwiÈzanych z wtyczkami do przeglÈdarek, rozszerzeniami tworzonymi w jÚzy- ku JavaScript oraz w niektórych klasach aplikacji WWW dziaïajÈcych po stronie klienta. Wszystkie te problemy spowodowaïy ostatecznie powstanie róĝnorakich obejĂÊ na poziomie przeglÈdarki, które majÈ choÊ czÚĂciowo chroniÊ ten szczegól- ny obiekt przed sabotaĝem. Niestety wiÚkszoĂÊ pozostaïych obiektów nadal po- zostaje niechroniona. UWAGA MoĝliwoĂci modyfikowania wïasnego kontekstu wykonania zostaïy mocno ogra- niczone w trybie „strict” zdefiniowanym w 5. wydaniu specyfikacji ECMAScript. Niestety na razie ten tryb nie jest w peïni obsïugiwany przez ĝadnÈ przeglÈdarkÚ, a na dodatek ma byÊ mechanizmem dobrowolnym, z którego nie kaĝda strona bÚ- dzie musiaïa korzystaÊ. JSON i inne metody serializacji danych Bardzo waĝnÈ strukturÈ skïadniowÈ uĝywanÈ w jÚzyku JavaScript jest bardzo kom- paktowy i wygodny mechanizm serializacji danych, znany pod nazwÈ JavaScript Object Notation (notacja obiektów jÚzyka JavaScript) albo po prostu JSON (RFC 46274). Ten format danych wykorzystuje moĝliwoĂÊ przeciÈĝenia znaczenia symbolu otwierajÈcego nawiasu klamrowego ({). Nawias ten uĝywany jest normalnie do oznaczenia poczÈtku zagnieĝdĝonego bloku kodu, co oznacza, ĝe otwiera on nowÈ instrukcjÚ. Jeĝeli jednak nawias ten pojawi siÚ jako czÚĂÊ wyraĝenia, to traktowany jest jako poczÈtek zserializowanego obiektu. Poniĝszy przykïad przedstawia prawi- dïowe zastosowanie takiej skïadni do wyĂwietlenia prostego komunikatu: var impromptu_object = { given_name : Jan , family_name : Kowalski , lucky_numbers : [ 11630, 12067, 12407, 12887 ] }; // W okienku pojawi siĊ napis Jan . alert(impromptu_object.given_name); PrzeciÈĝenie operatora otwierajÈcego nawiasu klamrowego oznacza, ĝe bloki JSON nie zostanÈ wïaĂciwie rozpoznane, jeĝeli spróbujemy ich uĝyÊ jako osobnych instrukcji. Oznacza to, ĝe zachowujÈ siÚ one inaczej niĝ liczby, ciÈgi znaków i tablice, których serializacja nie ma takich dwuznacznoĂci. Moĝe siÚ to wydawaÊ maïo zna- S k r y p t y d z i a ï a j È c e w p r z e g l È d a r c e 139 czÈce, ale jest to caïkiem spora zaleta. Oznacza to, ĝe niemoĝliwe staje siÚ doïÈczanie do stron odpowiedzi zgodnych z tÈ skïadniÈ, przesyïanych przez serwer z innej domeny, z wykorzystaniem znaczników script src=… *. Przedstawiony niĝej listing spowoduje powstanie bïÚdu skïadniowego z powodu wykrycia nieprawidïowo umiej- scowionego znaku cudzysïowu (n) w miejscu, które interpreter traktuje jako ety- kietÚ kodu†. Taki bïÈd nie bÚdzie miaï tutaj ĝadnych efektów ubocznych. n script { given_name : Jan , family_name : Kowalski , lucky_numbers : [ 11630, 12067, 12407, 12887 ] }; /script UWAGA Brak moĝliwoĂci doïÈczenia danych w formacie JSON za pomocÈ znaczników script src=… jest bardzo interesujÈcÈ wïaĂciwoĂciÈ, ale nie jest to zabezpieczenie doskonaïe. Wystarczy umieĂciÊ odpowiedě serwera w nawiasach okrÈgïych lub kwadratowych albo usunÈÊ cudzysïowy otaczajÈce nazwy etykiet, a tak poprawionÈ skïadniÚ bÚ- dzie moĝna wykonaÊ jako osobny blok kodu, co moĝe mieÊ juĝ powaĝne efekty uboczne. BiorÈc pod uwagÚ szybko rozwijajÈcÈ siÚ skïadniÚ jÚzyka JavaScript, nie moĝna oczekiwaÊ, ĝe ten szczególny ukïad kodu bÚdzie juĝ zawsze powodowaÊ bïÚdy parsowania. W wielu maïo istotnych zastosowaniach ten poziom bezpieczeñstwa z pewnoĂciÈ bÚdzie wystarczajÈcy i moĝna go traktowaÊ jako bardzo prosty mecha- nizm zabezpieczajÈcy. Dane w formacie JSON otrzymane przez dowolny kanaï, taki jak na przykïad ĝÈdanie XMLHttpRequest, moĝna szybko i ïatwo przeksztaïciÊ w obiekty zapisane w pamiÚci. Wystarczy wywoïaÊ funkcjÚ JSON.parse(…) dostÚpnÈ we wszystkich po- pularnych przeglÈdarkach (z wyjÈtkiem Internet Explorera). Niestety w celu utrzy- mania zgodnoĂci z tÈ przeglÈdarkÈ, a czasami po prostu z przyzwyczajenia, wielu programistów uĝywa równie prostego wywoïania, które jednak jest zdecydowa- nie bardziej niebezpieczne: var parsed_object = eval( ( + json_text + ) ); * W przeciwieñstwie do innych sposobów wïÈczania treĂci do skryptów (takich jak XMLHTTPRequest) znaczniki script src=… nie podlegajÈ ograniczeniom odwoïañ miÚdzydomenowych, o których mówiÊ bÚdÚ w rozdziale 9. Oznacza to, ĝe mechanizm ten stanowi pewne ryzyko dla bezpieczeñstwa, w przypadku gdy poĂrednie dane uwierzytelniajÈce (na przykïad ciasteczka) uĝywane sÈ przez serwer do dynamicznego generowania kodu JavaScript dla konkretnego uĝytkownika. Ta klasa podatnoĂci opisywana jest skrótem XSSI — cross-site script inclusion. † ZaskakujÈcÈ funkcjÈ jÚzyka JavaScript jest obsïuga etykiet znanych z jÚzyka C, takich jak moja_etykieta: alert( CzeĂÊ, mamo! );. Jest to o tyle interesujÈce, ĝe jÚzyk nie obsïuguje instrukcji goto, a to oznacza, iĝ w wiÚkszoĂci przypadków takich etykiet po prostu nie da siÚ wykorzystaÊ. 140 R o z d z i a ï 6 UWAGA Problem polega na tym, ĝe funkcja eval(…) uĝywana tutaj do wyliczania „war- toĂci” danych w formacie JSON pozwala na przekazanie jej nie tylko zserializowa- nych danych, ale i peïnoprawnego kodu JavaSc
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Splątana sieć. Przewodnik po bezpieczeństwie nowoczesnych aplikacji WWW
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: