SVEUČILIŠTE U ZAGREBU

FAKULTET ELEKTROTEHNIKE I RAČUNARSTVA

DIPLOMSKI RAD br. 1639

OSTVARENJE KERBEROS PROTOKOLA

U RAZLIČITIM PROGRAMSKIM

OKRUŽENJIMA

Vanja Vidović

Zagreb, prosinac 2006.

Vanja Vidović

0036369280

Sažetak Autentifikacijski protokol Kerberos je kreiran na MIT-u. Verzija 5 Kerberos protokola nudi fleksibilnu infrastrukturu koju je moguće iskoristiti u raznovrsnim organizacijskim strukturama, uključujući i one koje sadrže različite operacijske sustave. U svrhu boljeg razumijevanja problema interoperabilnosti, ovaj rad opisuje protokol Kerberos i mehanizme pomoću kojih je izgrañen. Osim toga, prezentira prednosti verzije 5 u odnosu na mnoga ograničenja koja posjeduje verzija 4 Kerberosa. Konačno, bavi se interoperabilnošću dviju dominantnih implementacija Kerberos protokola, MIT-eve i Microsoftove. Različiti scenariji interoperabilnosti demonstrirani su korištenjem jednostavnih klijentskih i poslužiteljskih aplikacija koje pristupaju Kerberos protokolu kroz generička programska sučelja, SSPI (u Windows okruženju) i GSSAPI (u Linux okruženju).

Abstract The Kerberos authentication protocol was originally developed at MIT. Upon reaching version 5, it has provided us with flexible infrastructure to be used in various organization environments, including different operating systems simultaneously. This paper describes underlying mechanisms on which Kerberos protocol is based, as well as Kerberos protocol itself, to give us better understanding for future interoperability issues. It also presents solutions version 5 has provided in respect to many limitations of version 4. Finally, it discusses interoperability of two dominant implementations of Kerberos protocol, one of MIT and the other of Microsoft. Interoperability scenarios are demonstrated using simple client and server applications that access Kerberos protocol through generic programming interfaces, SSPI (on Windows operating systems) and GSSAPI (on Linux-based operating systems).

Sadržaj 1. Uvod ....................................................................................................... 1 2. Osnovni koncepti autentifikacije na kojima se zasniva Kerberos .... 2 2.1. Autentifikacija putem ključa............................................................... 2 2.2. Autentifikatorske poruke i obostrana autentifikacija .......................... 2 2.3. Distribucija ključeva........................................................................... 3 2.4. Sjednička karta.................................................................................. 4 2.5. Karta za pristup sustavu dodjele sjedničkih karata............................ 5

3. Opis Kerberos protokola ...................................................................... 7 3.1. Komunikacija klijent – autentifikacijski servis .................................... 7 3.2. Komunikacija klijent – servis za izdavanje sjedničkih karata............. 8 3.3. Komunikacija klijent – poslužitelj ....................................................... 9 3.4. Autentifikacija meñu različitim domenama ...................................... 10

4. Usporedba verzije 4 i verzije 5 Kerberos protokola ......................... 13 4.1. Ograničenja verzije 4 ...................................................................... 13 4.1.1. Mane uvjetovane okruženjem .................................................. 13 4.1.2. Tehnički nedostaci ................................................................... 14

4.2. Promjene u verziji 5......................................................................... 15 4.2.1. Promjene izmeñu verzije 4 i 5 .................................................. 15 4.2.2. Nove mogućnosti protokola u verziji 5 ..................................... 17

4.3. Implementacijske značajke verzije 5 ............................................... 19 4.3.1. Osnovna implementacija.......................................................... 19 4.3.2. Interakcija s korisnicima........................................................... 21 4.3.3. Podrška kompatibilnosti s verzijom 4 ....................................... 21

5. Kerberos protokol u operacijskom sustavu Windows..................... 23 5.1. Autentifikacija unutar Windows domena ......................................... 23 5.2. Infrastruktura Kerberos protokola.................................................... 23 5.2.1. Standard .................................................................................. 23 5.2.2. Proširenje Kerberos protokola.................................................. 23 5.2.3. KDC ......................................................................................... 23 5.2.4. Baza podataka korisničkih računa ........................................... 24 5.2.5. Postavke Kerberosa................................................................. 24 5.2.6. Način implementacije Kerberosa ............................................. 25 5.2.7. Priručna memorija za korisničke isprave.................................. 26 5.2.8. Kerberos i DNS........................................................................ 26 5.2.9. Autorizacijski podaci ................................................................ 26

6. SSPI i GSSAPI modeli ......................................................................... 29 6.1. SSPI model ..................................................................................... 29 6.2. SSPI strukture podataka i funkcije .................................................. 30 6.3. GSSAPI model ................................................................................ 30 6.4. GSSAPI tipovi podataka i funkcije................................................... 31 6.5. Interoperabilnost izmeñu SSPI-a i GSSAPI-a ................................. 32

7. Interoperabilnost Kerberos protokola na primjeru različitih scenarija....................................................................................................... 34 7.1. Kerberos klijenti u Windows domeni ............................................... 34 7.2. Kerberos aplikacijski poslužitelji u Windows domeni....................... 34 7.3. Klijentski Windows sustavi u Kerberos području ............................. 35

7.4. Dijeljenje resursa izmeñu Kerberos područja i Windows domene... 35 7.5. Korištenje Kerberos područja kao domene za korisničke račune.... 36

8. Demonstriranje interoperabilnosti Kerberos protokola pomoću klijentskih i poslužiteljskih aplikacija ........................................................ 37 8.1. Implementacija klijentske i poslužiteljske aplikacije......................... 37 8.1.1. GSSAPI poslužitelj ................................................................... 37 8.1.2. GSSAPI klijent ......................................................................... 38 8.1.3. SSPI poslužitelj ........................................................................ 39 8.1.4. SSPI klijent............................................................................... 40

8.2. Windows domena............................................................................ 41 8.2.1. Kerberos klijent – Windows poslužitelj ..................................... 42 8.2.2. Windows klijent – Kerberos poslužitelj ..................................... 42 8.2.3. Kerberos klijent – Kerberos poslužitelj ..................................... 43 8.2.4. Windows klijent – Windows poslužitelj ..................................... 43

8.3. Kerberos područje........................................................................... 43 8.3.1. Kerberos klijent – Kerberos poslužitelj ..................................... 44 8.3.2. Windows klijent – Kerberos poslužitelj ..................................... 45

8.4. Autentifikacija izmeñu Kerberos područja i Windows domene ........ 46 9. Zaključak.............................................................................................. 47 10. Literatura.............................................................................................. 48 Dodatak A: Popis slika................................................................................49 Dodatak B: SSPI strukture i funkcije ......................................................... 50 Strukture .................................................................................................... 50 Funkcije za upravljanje sigurnosnim paketima........................................... 51 Funkcije za upravljanje ispravama............................................................. 52 Funkcije za upravljanje sigurnosnim kontekstom....................................... 57 Funkcije za podršku sigurnoj razmjeni poruka ........................................... 66

Dodatak C: GSSAPI funkcije ...................................................................... 69 Funkcije za upravljanje ispravama............................................................. 69 Funkcije za upravljanje sigurnosnim kontekstom....................................... 70 Funkcije za podršku sigurnoj razmjeni poruka ........................................... 78 Funkcije za upravljanje imenima................................................................ 82 Pomoćne funkcije....................................................................................... 84

Dodatak D: Izvorni tekstovi programa....................................................... 86 SSPI poslužitelj .......................................................................................... 86 Datoteka SSPI_Posluzitelj.c................................................................... 86 Datoteka SSPI_Razno.c......................................................................... 95 Datoteka SSPI_Razno.h ........................................................................ 99 Datoteka GSSAPI.h.............................................................................. 100

SSPI klijent .............................................................................................. 101 Datoteka SSPI_Klijent.c ....................................................................... 101

GSSAPI poslužitelj................................................................................... 116 Datoteka GSSAPI_posluzitelj.c ............................................................ 116 Datoteka GSSAPI_razno.c................................................................... 124 Datoteka GSSAPI_razno.h................................................................... 129

GSSAPI klijent ......................................................................................... 130 Datoteka GSSAPI_klijent.c................................................................... 130

1

1. Uvod

Kerberos je mrežni autentifikacijski protokol koji omogućuje sigurnu obostranu autentifikaciju preko nesigurne mreže u arhitekturi klijent-poslužitelj korištenjem enkripcije pomoću tajnog ključa.

Stvoren je na MIT-u (eng. Massachusetts Institute of Technology) s namjenom zaštite mrežnih usluga za potrebe projekta Athena. Protokol je nazvan prema Cerberusu, čudovišnom troglavom psu iz grčke mitologije koji je čuvao ulaz u Had.

Verzije protokola od 1 do 3 pojavile su se samo interno na MIT-u. Verzija 4 je takoñer bila namijenjena projektu Athena, no krajem 80-tih izdana je za širu uporabu. Sigurnosni problemi i ograničenja iz verzije 4 riješeni su verzijom 5 koja se pojavila 1993. godine u specifikaciji RFC 1510. Specifikacija je proširena 2005. godine u dokumentu RFC 4120, izmeñu ostaloga i da prihvati zahvate koji su se pojavili kod Microsoftove implementacije protokola u operacijskim sustavima Windows 2000, Windows XP i Windows Server 2003. Dok je Microsoftova implementacija protokola integrirana s operacijskim sustavom Windows, MIT-eva implementacija protokola je slobodno dostupna i isporučuje se nezavisno.

U današnje vrijeme zanimljiva je problematika interoperabilnosti Kerberos protokola, kako izmeñu verzije 5 i verzije 4, tako i izmeñu različitih operacijskih sustava. Da bi opisali interoperabilnost Kerberosa, potrebno je razumjeti specifičnosti mehanizama na kojima počiva protokol, kao i specifičnosti pojedinih implementacija.

Slika 1.1: Cerberus

2

2. Osnovni koncepti autentifikacije na kojima se zasniva Kerberos

2.1. Autentifikacija putem ključa

Mnogi oblici računalne autentifikacije zasnivaju se na ideji da pojedini entitet (osoba, proces...) može dokazati vlastiti identitet na način da dokaže da zna neki ključ (npr. zaporku) koji ne može znati nitko drugi osim tog entiteta.

Očit problem koji treba riješiti prilikom autentifikacije zasnovane na tajnom ključu (zaporki) jest taj da treba osigurati metode kojima se može (mora!) očuvati tajnost ključa. Naime, nipošto nije pametno da korisnik koji traži pristup nekim resursima direktno odaje svoju zaporku – netko bi mogao prisluškivati komunikacijski kanal (koji je najčešće neosiguran) ili bi korisnik mogao tražiti pristup na krivome mjestu (najčešće uz prijevaru). Da bi zaporka ostala tajna prilikom autentifikacije, mora postojati način da korisnik dokaže da zna zaporku bez da ju pritom otkrije. Protokol Kerberos zasnovan je na toj ideji – kod njega se takoñer radi o autentifikaciji putem ključa, no riječ je o tajnoj autentifikaciji kod koje se sadržaj ključa zapravo nikad ne otkriva.

Kako bi bilo moguće ostvariti navedenu tajnu autentifikaciju, obje strane (npr. klijent i poslužitelj) koje sudjeluju u transakciji moraju posjedovati jedan sjednički ključ, koji takoñer mora biti tajni, odnosno poznat samo njima. Riječ je o simetričnom kriptografskom ključu (dakle, koristi se i za enkripciju i za dekripciju). Princip autentifikacije tada je sljedeći: jedna strana (klijent) dokazuje svoje znanje ključa (a time i svoj identitet!) enkriptiranjem nekakve poruke, dok druga strana (poslužitelj) isto potvrñuje dekriptiranjem te iste poruke. Autentifikacija je obavljena, a da zaporka (u ovom slučaju sjednički ključ) nije ugrožena direktnim (javnim) obznanjivanjem.

2.2. Autentifikatorske poruke i obostrana autentifikacija

U prethodno navedenom postupku tajne autentifikacije klijent šalje poslužitelju nekakvu stvarnu poruku enkriptiranu sjedničkim ključem. Takva poruka naziva se autentifikatorskom porukom. Prilikom svakog ponavljanja postupka autentifikacije, potrebno je slati drugačiju autentifikatorsku poruku jer bi se u protivnom već korištena poruka mogla iskoristiti od strane neovlaštene osobe.

Već je prije navedeno da poslužitelj po primitku autentifikatorske poruke od strane klijenta istu pokušava dekriptirati sjedničkim ključem i ako dobije suvislu informaciju, potvrñen je identitet klijenta jer samo dva entiteta posjeduju sjednički ključ, a kako je jedna od njih poslužitelj, druga mora biti klijent.

Kada je riječ o obostranoj autentifikaciji, postupak se ponavlja, ali ovaj put od poslužitelja prema klijentu. No, poslužitelj sada ne može klijentu poslati bilo kakvu poruku – mora biti jednoznačno odreñeno da je poslužiteljeva autentifikatorska poruka direktan odgovor na klijentovu. Slanje iste poruke natrag ne dolazi u obzir jer bi se na taj način mogao bilo koji entitet lažno predstaviti kao poslužitelj. Autentifikatorska poruka poslužitelja u sebi sadržava enkriptiran samo dio informacije koju je enkriptirao klijent. Ako klijent nakon dekriptiranja ustanovi da primljena informacija odgovara traženom dijelu originalne klijentove poruke, onda zna da je poslužitelj bio u stanju ispravno dekriptirati originalnu poruku sjedničkim ključem (i zatim ponovno enkriptirati

3

njen odgovarajući dio), a kako jedino poslužitelj ima tu mogućnost, tako je klijent potvrdio poslužiteljev identitet i obostrana autentifikacija je uspješno obavljena.

2.3. Distribucija ključeva

Kod dosad opisanog postupka tajne autentifikacije putem ključa bilo je pretpostavljeno da klijent i poslužitelj oba posjeduju tajni sjednički ključ. No, nije dan odgovor na pitanje koje se logično postavlja: kako su klijent i poslužitelj došli do zajedničkog tajnog ključa? Kada bi riječ bila samo o dvojici ljudi, bilo bi moguće da se prethodno sretnu u tajnosti i dogovore tajni ključ. Meñutim, situacija postaje znatno kompliciranija kada je riječ o dvjema aplikacijama pokrenutim na klijentskom, odnosno poslužiteljskom računalu.

Javlja se još jedan problem, a taj je vezan uz činjenicu da će klijent željeti pristupiti većem broju različitih usluga, a time i različitim poslužiteljima, a to znači da će mu biti potreban poseban sjednički ključ za svaki poslužitelj (naravno, vrijedi i obratna situacija). Uz nezgrapnost takvog rješenja javlja se i vrlo ozbiljan sigurnosni problem pohrane svih tih ključeva na svim poslužiteljima i klijentima.

Kao rješenje se nameće uvoñenje specijaliziranog centra za distrubuciju ključeva (eng. Key Distribution Center - KDC). Riječ je o usluzi koja uživa povjerenje i od poslužitelja i od klijenta i služi kao posrednik u procesu njihove obostrane autentifikacije. Centar za distribuciju ključeva (u daljnjem tekstu KDC) nalazi se na fizički osiguranom poslužitelju i sadrži bazu podataka s informacijama o svim registriranim korisnicima autentifikacijskog sustava Kerberos u svojem području djelovanja (eng. realm), dakle o svim klijentima i svim poslužiteljima koji potencijalno mogu komunicirati. U bazi se, osim drugih podataka o korisnicima sustava, nalaze kriptografski ključevi koji su poznati samo pojedinom korisniku i KDC-u – takvi ključevi nazivaju se glavnim ključevima (eng. master key) i služe u meñusobnoj komunikaciji korisnika i KDC-a (napomena: treba razlikovati komunikaciju izmeñu dva korisnika sustava, klijenta sa poslužiteljem, od komunikacije pojedinog korisnika, klijenta ili poslužitelja s KDC-om). Glavni ključevi najčešće se generiraju iz zaporke korisnika pomoću neke hash-funkcije (funkcije koja je nereverzibilna, odnosno nije moguće od njenog rezultata doći do originalne zaporke). Na taj način je ipak osigurana tajnost izvorne zaporke korisnika.

Kako navedeni sustav funkcionira? Kada klijent želi uspostaviti sigurnu vezu sa poslužiteljem, započinje slanjem zahtjeva KDC-u umjesto poslužitelju kojem želi pristupiti. KDC tada generira sjednički ključ kojim će klijent i poslužitelj komunicirati. Kopiju generiranog sjedničkog ključa namijenjenu klijentu KDC enkriptira glavnim ključem klijenta, dok poslužiteljsku kopiju sjedničkog ključa enkriptira glavnim ključem poslužitelja. KDC bi sada mogao obaviti svoju ulogu posrednika na način da direktno pošalje jednu kopiju sjedničkog ključa poslužitelju, a jednu klijentu, no u praktičnoj primjeni taj postupak ne bi dobro funkcionirao zbog mnogih razloga. Klijent ionako mora kontaktirati poslužitelj s odreñenom kriptiranom porukom i nema smisla da poslužitelj prima dvije poruke, jednu od KDC-a, a drugu od klijenta, kad je dovoljno da mu sve pošalje klijent u jednoj poruci. Na taj način smanjuje se prostor za pogrešku (npr. zbog greške poslužitelj nije primio poruku od KDC-a, a primio je enkriptiranu poruku od klijenta koju tada ne može pročitati). Pored toga, rasterećuju se resursi KDC-a koji bi morao uspostavljati vezu sa poslužiteljem, a u tom slučaju bi na svakom poslužitelju trebao postojati

4

odgovarajući sustav autorizacije prema KDC-u, što dovodi do dodatnih sigurnosnih problema, itd.

Umjesto toga, KDC obje enkriptirane kopije sjedničkog ključa šalje samo klijentu. Osim ključeva, KDC u poruku uključuje i autorizacijske podatke o klijentu i enkriptira ih glavnim ključem poslužitelja. Ti autorizacijski podaci sa sjedničkim ključem (a sve skupa enkriptirano glavnim ključem poslužitelja) zajedno tvore sjedničku kartu (eng. session ticket).

2.4. Sjednička karta

Sjednička karta je struktura koja u sebi sadrži kopiju sjedničkog ključa namijenjenu poslužitelju i autorizacijske podatke vezane uz klijenta koji želi pristupiti poslužitelju. Sjednička karta enkriptirana je glavnim ključem poslužitelja i klijent ju ne može mijenjati (niti bilo tko drugi). Dužnost je klijenta da sjedničku kartu pohrani na sigurnom mjestu dok ne kontaktira poslužitelj.

Po primitku odgovora od KDC-a, klijent dekriptira svojim glavnim ključem kopiju sjedničkog ključa namijenjenu njemu. Da bi uspostavio sigurnu vezu sa poslužiteljem, mora mu poslati poruku koja u sebi sadrži sjedničku kartu i autentifikatorsku poruku (koja je enkriptirana sjedničkim ključem). Sjednička karta i autentifikatorska poruka zajedno tvore isprave klijenta prema poslužitelju (eng. credentials).

Kada poslužitelj primi isprave klijenta, dekriptira sjedničku kartu svojim glavnim ključem i iz nje vadi svoju kopiju sjedničkog ključa. Tim sjedničkim ključem zatim dekriptira autentifikatorsku poruku klijenta. Ako poruka ima smisla, poslužitelj zna da su klijentove isprave autentične i da su izdane od KDC-a kojem poslužitelj vjeruje. Da bi sada poslužitelj dovršio obostranu autentifikaciju (kako je već prije navedeno u poglavlju o obostranoj autentifikaciji), on iz autentifikatorske poruke klijenta vadi samo vremensku oznaku, enkriptira ju sjedničkim ključem i šalje natrag klijentu. Po primitku te poruke klijent usporeñuje vremensku oznaku s vremenskom oznakom na poruci koju je on inicijalno poslao poslužitelju i ukoliko su one identične, dokazan je identitet poslužitelja.

Jedna od prednosti navedenog postupka korištenja sjedničke karte jest da poslužitelj ne mora pohraniti sjednički ključ i brinuti o njegovoj sigurnosti, već klijent mora predočiti sjedničku kartu poslužitelju svaki put kad mu želi pristupiti, a onda poslužitelj jednostavno vadi sjednički ključ iz nje. Sjedničku kartu ionako može pročitati jedino poslužitelj koristeći vlastiti glavni ključ. Kad sjednički ključ više nije potreban poslužitelju, on ga briše.

Klijent ne mora pristupati KDC-u svaki put kad želi kontaktirati poslužitelj. Sjedničke karte mogu biti više puta iskorištavane. Da bi se spriječila moguća zloupotreba ukradene karte, svaka karta posjeduje rok trajanja, koji ovisi o postavkama Kerberos sustava na pojedinom području djelovanja, a u većini slučajeva riječ je o roku od 8 sati od trenutka izdavanja karte. Pored toga, svaka karta može biti korištena jedino u kontinuiranom periodu dok osoba koristi klijentsko računalo, odnosno bolje rečeno za vrijeme trajanja jedne korisničke sjednice za klijentskim računalom (eng. login session). U trenutku odspajanja korisnika s klijentskog računala, sve pripadne sjedničke karte i sjednički ključevi se brišu.

Najbitniji dijelovi sjedničke karte prikazani su sljedećom slikom:

5

Slika 2.1: Struktura sjedničke karte

Domena je ona u kojoj je sjednička karta izdana. Korisničko ime i domena

ponavljaju se unutar enkriptiranog dijela karte da bi se omogućila potvrda identiteta. Zastavicama su definirane dodatne opcije kao što su delegiranje korisnika, dodatna autorizacija putem pametne kartice i mnoge druge (više riječi o njima bit će kasnije). Vrijeme izdavanja i vrijeme trajanja odreñuju dokad je sjednička karta valjana. Adresa klijenta je jedna ili više IP-adresa koje odreñuju računalo za kojim se nalazi korisnik. Autorizacijske podatke koristi poslužitelj pri odreñivanju dozvola pristupa koje će dodijeliti korisniku.

2.5. Karta za pristup sustavu dodjele sjedničkih karata

Već je prije navedeno da klijent koristi vlastiti glavni ključ prilikom dekriptiranja poruka koje prima od KDC-a. Taj glavni ključ generira se iz zaporke korisnika pomoću neke hash-funkcije. U dosad opisanom postupku javlja se problem kad klijent mora više puta komunicirati s KDC-om (ako korisnik želi pristupiti različitim poslužiteljima) u tijeku iste korisničke sjednice. Tada bi klijent trebao ili pamtiti glavni ključ korisnika kojim bi mogao dekriptirati poruke od KDC-a, što predstavlja značajan sigurnosni problem (jer je korisnička zaporka dugoročni ključ), ili jednostavno tražiti od korisnika da svaki put iznova upiše zaporku i onda nanovo generirati glavni ključ, što bi moglo prečesto prekidati korisnika u radu.

Problem se može riješiti na način da KDC klijentu izda privremeni glavni ključ koji će vrijediti samo tijekom trenutne korisničke sjednice. Pohrana takvog glavnog ključa na računalu klijentu više ne predstavlja sigurnosni problem jer on ne ionako više ne vrijedi nakon što korisnik završi svoju korisničku sjednicu.

6

Kada se korisnik prvi put spoji na klijentsko računalo, klijent najprije zatraži sjedničku kartu za pristup KDC-u (od samog KDC-a), na isti način na koji bi postupio ukoliko bi želio kontaktirati bilo koji drugi poslužitelj. KDC generira sjednički ključ koji će se dalje koristiti u komunikaciji izmeñu klijenta i KDC-a i to je zapravo taj privremeni glavni ključ. Kao i u slučaju da je riječ o bilo kojem drugom poslužitelju, KDC klijentu šalje dvije kopije enkriptiranog sjedničkog ključa (privremenog glavnog ključa), jednu enkriptiranu glavnim ključem korisnika (generiranim pomoću hash-funkcije iz zaporke), a drugu enkriptiranu glavnim ključem samog KDC-a. Isto kao i prije, ta druga kopija se nalazi unutar sjedničke karte za KDC. Klijent svoju kopiju sjedničkog ključa dekriptira vlastitim glavnim ključem i to je jedino mjesto na kojem se od korisnika traži unošenje zaporke. Nakon toga klijent može pohraniti u memoriju privremeni glavni ključ i sjedničku kartu za sve daljnje pristupe KDC-u (za vrijeme trenutne korisničke sjednice, naravno), točnije njegovom dijelu koji dodjeljuje sjedničke karte za pristup svim ostalim poslužiteljima. Daljnja komunikacija se obavlja kako je bilo navedeno u prethodnim poglavljima, s jedinom razlikom što se sada koristi privremeni glavni ključ umjesto glavnog i što klijent prilikom svakog pristupa KDC-u mora poslati dodijeljenu mu sjedničku kartu.

Navedena sjednička karta koju klijent dobije pri prvom spajanju na KDC naziva se karta za pristup sustavu dodjele sjedničkih karata (eng. Ticket-Granting Ticket – u daljnjem tekstu TGT). Kada klijent od KDC-a traži sjedničku kartu za neki poslužitelj, mora mu predočiti isprave u vidu autentifikatorske poruke i sjedničke karte – u ovom slučaju TGT-a – na isti način na koji bi predočio isprave nekom poslužitelju. KDC dekriptira TGT vlastitim glavnim ključem, saznaje privremeni glavni ključ klijenta i pomoću njega enkriptira sjedničku kartu za traženi poslužitelj.

7

3. Opis Kerberos protokola

Osnovni Kerberos protokol može se podijeliti na tri dijela, odnosno podprotokola. Prvi se dešava izmeñu klijenta i dijela KDC-a koji se naziva autentifikacijski servis (eng. Authentication Service – u daljnjem tekstu AS). U tom dijelu KDC klijentu izdaje privremeni glavni ključ i TGT. U drugom podprotokolu dio KDC-a koji služi izdavanje sjedničkih karata (eng. Ticket-Granting Service – u daljnjem tekstu TGS) klijentu izdaje sjednički ključ i sjedničku kartu za poslužitelj kojem klijent želi pristupiti. Treći podprotokol dešava se izmeñu klijenta i poslužitelja i u njemu klijent predočava sjedničku kartu za pristup poslužitelju.

Takoñer je opisan i postupak autentifikacije u slučaju kada klijent i poslužitelj ne dijele zajednički KDC.

Objašnjenje svakog podprotokola sadrži grafički prikaz razmjene poruka (slike 3.1, 3.2 i 3.3). Korištene oznake na slikama u skladu su sa standardnom notacijom kod opisivanja Kerberos protokola:

• KX – tajni ključ entiteta X, pri čemu X može biti klijent (C), poslužitelj (S) ili KDC (K)

• {xyz}KX – bilo kakvi podaci "xyz" enkriptirani tajnim ključem entiteta X • {T}KX – sjednička karta enkriptirana tajnim ključem entiteta X • KX,Y – sjednički ključ kojeg koriste entiteti X i Y • {xyz} – bilo kakvi podaci "xyz" enkriptirani sjedničkim ključem kojeg

koriste entiteti X i Y • UID - oznaka korisnika registriranog u Kerberos sustavu.

3.1. Komunikacija klijent – autentifikacijski servis

Korisnik započinje rad priključivanjem na mrežu i unošenjem vlastitog korisničkog imena i zaporke. Kerberos klijent na korisnikovom računalu zaporku konvertira u glavni ključ pomoću hash-funkcije i sprema ju u programsku varijablu. Razmjena poruka izmeñu klijenta i AS-a obavlja se na sljedeći način:

1. Klijent šalje poruku tipa KRB_AS_REQ (eng. Kerberos Authentication Service Request). Prvi dio poruke kaže o kojem se korisniku radi, a drugi dio je autentifikatorska poruka enkriptirana glavnim ključem korisnika.

2. Po primitku poruke tipa KRB_AS_REQ, KDC traži navedenog korisnika u svojoj bazi podataka, nalazi njegov glavni ključ i pomoću njega dekriptira autentifikatorsku poruku. Ako je vremenska oznaka unutar nje valjana, KDC zna da poruka nije lažna, a samim time potvrñuje identitet klijenta.

3. KDC sada na slučajan način generira privremeni glavni ključ za klijenta i jednu kopiju enkriptira glavnim ključem korisnika. Drugu kopiju zajedno s autorizacijskim podacima o korisniku stavlja u TGT i enkriptira TGT glavnim ključem KDC-a.

8

4. KDC šalje kreirane isprave klijentu u poruci tipa KRB_AS_REP (eng. Kerberos Authentication Service Reply).

5. Klijent prima odgovor od KDC-a i pomoću vlastitog glavnog ključa (koji je izveden iz njegove zaporke) dekriptira privremeni glavni ključ koji mu je dodijelio KDC.

6. Klijent pohranjuje privremeni glavni ključ i dodijeljeni TGT u svoju memoriju za pohranu karata (eng. ticket cache).

Slika 3.1: Komunikacija klijent - autentifikacijski servis

3.2. Komunikacija klijent – servis za izdavanje sjedničkih karata

Kerberos klijent zahtijeva i dobiva isprave za poslužitelj kojem želi pristupiti na sljedeći način:

1. Klijent šalje poruku tipa KRB_TGS_REQ (eng. Kerberos Ticket-Granting Service Request). Poruka sadrži identitet poslužitelja kojem klijent želi pristupiti, autentifikatorsku poruku enkriptiranu privremenim glavnim ključem klijenta i TGT koju je klijentu izdao AS.

2. Kada primi poruku tipa KRB_TGS_REQ, KDC najprije dekriptira TGT vlastitim glavnim ključem i tako saznaje klijentov privremeni glavni ključ.

3. Pomoću klijentovog privremenog glavnog ključa KDC dekriptira klijentovu autentifikatorsku poruku i provjerava njenu valjanost. Ako je poruka ispravna, KDC na slučajan način generira sjednički ključ koji će klijent koristiti u komunikaciji sa traženim poslužiteljem.

4. KDC jednu kopiju sjedničkog ključa enkriptira privremenim glavnim ključem klijenta. Drugu kopiju zajedno s autorizacijskim podacima o

9

korisniku (koje je saznao iz TGT-a) stavlja u sjedničku kartu i enkriptira ju glavnim ključem poslužitelja kojem klijent želi pristupiti.

5. KDC kreirane isprave šalje klijentu u poruci tipa KRB_TGS_REP (eng. Kerberos Ticket-Granting Service Reply).

6. Po primitku odgovora, klijent dekriptira sjednički ključ koji mu je dodijeljen za komunikaciju sa poslužiteljem i pohranjuje ga zajedno sa sjedničkom kartom u svoju memoriju za pohranu karata.

Slika 3.2: Komunikacija klijent – servis za izdavanje sjedničkih karata

3.3. Komunikacija klijent – poslužitelj

Kada klijent u svom posjedu ima sjedničku kartu i sjednički ključ za pristup poslužitelju, može se uspostaviti sigurna veza. Komunikacija se odvija na sljedeći način:

1. Klijent šalje poruku tipa KRB_AP_REQ (eng. Kerberos Application

Request). Ona sadrži autentifikatorsku poruku enkriptiranu sjedničkim ključem, sjedničku kartu i zastavicu koja označava da li se zahtijeva obostrana autentifikacija (napomena: zastavica ovisi o postavkama samog sustava Kerberos, a ne o željama korisnika – korisnik ne smije biti u mogućnosti odlučivati je li obostrana autentifikacija potrebna).

2. Poslužitelj prima poruku tipa KRB_AP_REQ, sjedničku kartu dekriptira vlastitim glavnim ključem i tako saznaje sjednički ključ i autorizacijske podatke o klijentu.

3. Pomoću sjedničkog ključa poslužitelj dekriptira autentifikacijsku poruku klijenta i provjerava vremensku oznaku.

10

4. Ukoliko je vremenska oznaka poruke ispravna, poslužitelj je uvjeren u identitet klijenta. Poslužitelj dalje provjerava je li postavljena zastavica za obostranu autentifikaciju.

5. U slučaju da je zastavica postavljena, poslužitelj pomoću sjedničkog ključa enkriptira vremensku oznaku sa korisnikove autentifikatorske poruke i šalje ju natrag klijentu u poruci tipa KRB_AP_REP (eng. Kerberos Application Reply).

6. Kad klijent primi odgovor, sjedničkim ključem dekriptira poslužiteljevu autentifikacijsku poruku i usporeñuje ju s vremenskom oznakom na originalnoj autentifikatorskoj poruci. Ako su jednake, klijent je uvjeren u identitet poslužitelja i može nastaviti dalje komunicirati s njim.

Slika 3.3: Komunikacija klijent - poslužitelj

3.4. Autentifikacija meñu različitim domenama

Da bi se klijent autentificirao bilo kojem poslužitelju, bez obzira u kojoj domeni se taj poslužitelj nalazio, mora doći u posjed sjedničke karte za taj poslužitelj. No, sjedničku kartu za taj poslužitelj može izdati jedino KDC koji se nalazi u istoj domeni kao i poslužitelj (jer jedino on zna glavni ključ tog poslužitelja). Dakle, očito je da klijent mora zatražiti sjedničku kartu od KDC-a iz domene u kojoj se nalazi poslužitelj. A da bi korisnik mogao od tog KDC-a zatražiti sjednički ključ za bilo koji poslužitelj, mora mu najprije predočiti TGT za taj KDC. Prema tome, osnovni problem za klijenta je dobiti TGT za pristup KDC-u koji se nalazi u drugoj domeni (da bi se korisniku izdao TGT od strane KDC-a, KDC mora imati korisnika u svojoj bazi podataka). Kada jednom dobije potrebni TGT, klijent može bez problema pristupiti KDC-u iz druge domene jer KDC-ova usluga za dodjelu sjedničkih karata ne provjerava postojanje korisnika u svojoj bazi; taj dio posla obavlja autentifikacijski servis KDC-a.

11

Da bi klijent mogao dobiti TGT za KDC koji se nalazi u drugoj domeni, meñu tim dvjema domenama mora biti uspostavljena povjerljiva veza. Na isti način na koji svi klijenti i poslužitelji vjeruju KDC-u na kojem su registrirani, KDC-ovi izmeñu dvije navedene domene moraju takoñer imati potpuno povjerenje jedan u drugoga. Kada se uspostavlja povjerljiva, odnosno sigurna veza meñu dvjema domenama, kreira se zaporka koja je poznata jedino tim dvjema domenama (odnosno pripadajućim KDC-ovima). Ta zaporka koristi se pri enkriptiranju TGT-a koji se prenosi meñu domenama.

Postupak je sljedeći (pretpostavimo da je klijent već dobio TGT za pristup KDC-u u vlastitoj domeni):

1. Klijent predočava svoj TGT (enkriptiran glavnim ključem njegovog KDC-a) KDC-u u vlastitoj domeni i zahtijeva TGT za pristup KDC-u u drugoj domeni.

2. KDC mu šalje TGT za pristup KDC-u iz druge domene, ali taj TGT nije enkriptiran glavnim ključem KDC-a iz druge domene (kao što je slučaj kod poslužitelja iz iste domene), nego zaporkom koja je stvorena za komunikaciju meñu tim dvjema domenama i samo njima je poznata.

3. Klijent šalje novi TGT KDC-u iz druge domene (uz odgovarajući autentifikator) i zahtijeva sjednički ključ za poslužitelj iz te druge domene

4. KDC iz druge domene dekriptira TGT zaporkom koju dijeli s domenom u kojoj se nalazi klijent. On se pouzdava u KDC iz domene klijenta i vjeruje mu da je on prije izdavanja TGT-a provjerio identitet klijenta.

5. Postupak se dalje nastavlja kao i u slučaju kad je riječ o jednoj domeni.

Slika 3.4: Autentifikacija meñu različitim domenama

12

Iz grafičkog prikaza izbačeni su sjednički ključevi i autentifikatori zbog bolje preglednosti (koriste se na ranije opisan način prema slikama 3.1, 3.2 i 3.3). Oznaka KX predstavlja tajni ključ koji dijele KDC-ovi iz dviju domena.

Jasan je razlog zbog kojeg KDC iz prve domene ne može TGT za pristup KDC-u iz druge domene enkriptirati glavnim ključem KDC-a iz druge domene. Na taj način bi se narušio jedan od osnovnih principa sigurnosti na kojima funkcionira Kerberos, a to je tajnost glavnog ključa KDC-a.

Kerberos takoñer podržava tranzitivno povjerenje meñu domenama. To znači da ako postoji povjerljiva veza izmeñu domena A i B, a neovisno o njoj i izmeñu domena B i C, onda automatski se podrazumijeva povjerljiva veza izmeñu domena A i C. Zašto je to bitno? Kerberos domene su najčešće organizirane hijerarhijski – na taj način, a uvažavajući princip tranzitivnosti povjerenja meñu domenama, svaka domena mora posjedovati samo zaporke za komunikaciju s onim domenama koje su u hijerarhiji direktno iznad, odnosno ispod te domene, a Kerberos sustav se brine za ostale veze. Na taj način se znatno pojednostavljuje organizacija i smanjuje sigurnosna prijetnja, nego što bi bio slučaj kad bi morala postojati direktna povjerljiva veza (a samim time i posebna zaporka) izmeñu bilo koje dvije domene.

13

4. Usporedba verzije 4 i verzije 5 Kerberos protokola

Autentifikacijski sustav Kerberos, razvijen od strane MIT-a za potrebe projekta Athena, prihvaćen je od strane mnogih drugih organizacija u svrhu sigurne autentifikacije klijenata mrežnih servisa putem nesigurne veze. Iako je verzija 4 protokola već sama po sebi bila korak naprijed naspram tradicionalnog poimanja sigurnosti u mrežnim sustavima, bilo je potrebno nadograditi ju i proširiti u skladu s mnogim zahtjevima koji su postavljeni u okruženjima koja se po svojim karakteristikama razlikuju od onog na MIT-u. Verzija 5 oblikovana je u velikoj mjeri prema konkretnim iskustvima korisnika verzije 4, čineći ju na taj način korisnijom u većem broju slučajeva.

4.1. Ograničenja verzije 4

4.1.1. Mane uvjetovane okruženjem

Verzija 4 Kerberos protokola je bila namijenjena prvenstveno projektu Athena i kao takva u nekim područjima koristi pretpostavke i rješenja koja nije moguće primijeniti na univerzalan način.

Ovisnost o odreñenom načinu enkripcije

Verzija 4 koristi isključivo DES (eng. Data Encryption Standard) za enkripciju poruka. Izvoz DES-a izvan granica SAD-a je ograničen od strane vlade SAD-a, otežavajući na taj način širu primjenu Kerberosa.

Ovisnost o Internet protokolu

Verzija 4 zahtijeva korištenje IP adresa, što ju čini neprimjerenom u odreñenim okruženjima.

Poredak bajtova u porukama

Verzija 4 koristi filozofiju kodiranja višebajtnih vrijednosti u mrežnim porukama po principu “primatelj kreira ispravno” (eng. “receiver makes right”). Po tom principu, pošiljatelj kodira vrijednosti prema svom prirodnom ureñenju bajtova, a primatelj ih mora prebaciti u vlastiti prirodni poredak. To pojednostavljuje komunikaciju ukoliko i pošiljatelj i primatelj imaju jednako ureñenje bajtova, ali ne pridržava se ugovorenih konvencija i onemogućit će interoperabilnost ukoliko pošiljatelj posjeduje neuobičajeno ureñenje bajtova koje primatelj ne može prepoznati.

Vrijeme trajanja karata

Valjano vrijeme trajanja Kerberos karata u verziji 4 kodirano je UNIX-ovom oznakom vremena izdavanja karte i 8-bitnom količinom vremenskih jedinica od po 5 minuta, tako da je ograničeno na maksimalno vrijeme trajanja od (28 – 1) * 5 min. = 21 ¼ sata. Mnoga okruženja zahtijevaju dulji vijek trajanja za ispravan rad, primjerice neka dugotrajna simulacija koja zahtijeva valjane Kerberos isprave tijekom čitavog izvoñenja.

Prosljeñivanje autentifikacije

Verzija 4 ne predviña i ne dozvoljava da se isprave izdane na jednom računalu proslijede drugom u svrhu korištenja od strane drugog klijenta.

14

Podrška navedenom bila bi korisna u slučaju kad poslužitelj posrednik treba pristupiti nekim resursima koristeći klijentova prava pristupa. Primjerice, poslužitelj za ispis podataka treba pristupiti datotečnom poslužitelju da bi dohvatio osobni klijentov dokument za ispis.

Imenovanje korisnika

U verziji 4, naziv pojedinog korisnika sastoji se od tri dijela: imena, instance i područja djelovanja, od kojih se svaki dio može sastojati od maksimalno 39 znakova. Navedeno ograničenje je premaleno za neke aplikacije i instalacijska okruženja. Osim toga, ime ne smije sadržavati znak točku (.), a ona se u nekim sustavima koristi kao dio korisničkog računa. Takoñer, konvencija nalaže da ime korisničkog računa mora biti identično imenskom dijelu naziva korisnika, a to je neprihvatljivo u slučajevima kada se Kerberos instalira na već postojeću mrežu sa imenima korisničkih računa koja nisu unikatna.

Autentifikacija izmeñu različitih područja djelovanja

Verzija 4 omogućuje suradnju izmeñu različitih autentifikacijskih područja djelovanja na način da svaki par područja djelovanja može meñusobno razmijeniti sekundarni tajni ključ za pristup TGS-u. Klijent može pristupiti poslužitelju iz stranog područja djelovanja na način da najprije od svog KDC-a zatraži TGT za strano područje djelovanja, a zatim od stranog KDC-a zatraži karte za pristup stranom poslužitelju. Navedeni postupak je lako implementirati, ali zahtijeva O(n2) razmjena ključeva za povezivanje n područja djelovanja, čineći zadaću izdavanja i upravljanja ključevima neefikasnom i skupom, već i za slučaj manjeg broja područja djelovanja koje treba povezati.

4.1.2. Tehnički nedostaci

Osim mana uvjetovanih konkretnim okruženjem, verzija 4 posjeduje i nedostatke u samoj tehničkoj izvedbi.

Dvostruka enkripcija

U verziji 4, karta za pristup poslužitelju koju KDC izdaje klijentu je enkriptirana dvaput iako za tim nema potrebe. Umjesto prethodno opisanog formata poruke {T}KS{KC,S}KC,K , u verziji 4 on je bio {{T}KS, KC,S}KC,K. U slučaju da je enkripcija vremenski zahtjevna (a kod softverskih implementacija enkripcije upravo to je slučaj), radi se o nepotrebnom gubitku dragocjenog procesorskog vremena.

PCBC enkripcija

Verzija 4 Kerberosa koristi nestandardnu varijantu DES-a za enkripciju poruka. Umjesto normalne CBC (eng. cipher-block-chaining) varijante ulančavanja kodnih blokova DES-a, koristi modificiranu PCBC verziju (eng. plain- and cipher-block-chaining). Ideja iza toga je bila da se omogući enkripcija podataka i zaštita integriteta u jednoj operaciji. Nažalost, taj postupak omogućava uljezu da modificira poruku posebnim napadom zamjenom blokova koji može ostati neprimjećen od strane primatelja.

15

Autentifikatori i otkrivanje ponovne uporabe

Verzija 4 Kerberosa koristi enkriptiranu vremensku oznaku da bi odredila jesu li pokuke zastarjele i na taj način spriječila uljeza da uspješno izvede napad ponavljanjem poruka. Ako autentifikator sadržava vremensku oznaku koja je zastarjela ili ponovno poslana, aplikacijski poslužitelj odbacuje autentifikaciju. No, održavanje liste neisteklih autentifikatora koji su već bili predočeni servisu nije jednostavno implementirati, i takva implementacija zapravo niti ne postoji u verziji 4.

Napadi zaporkama

Prilikom inicijalne komunikacije klijenta i Kerberos poslužitelja, poslužitelj svoj odgovor enkriptira tajnim ključem klijenta. Uljez je u mogućnosti zabilježiti ovu razmjenu poruka i pokušati odgovor poslužitelja nesmetano (poruku) dekriptirati pogañanjem svi mogućih ključeva. Poruka sadržava niz teksta u nekodiranom obliku koji je moguće verificirati i na taj način prepoznati pravi ključ.

Sjednički ključevi

Mnogi klijenti će svoju sjedničku kartu iskoristiti više od jednog puta pri komunikaciji s poslužiteljem za vrijeme trajanja sjednice. Stoga, uljez može biti u mogućnosti ostvariti napad ponavljanjem poruka iz prethodne veze s klijentom ili poslužiteljem koji nisu zaštićeni na odgovarajući način. Verzija 4 ne implementira u potpunosti ovu zaštitu za odreñene tipove poruka. Osim navedenog, postoji i situacija u kojoj klijent želi podijeliti sjednički ključ sa više poslužitelja, a to u slučaju verzije 4 zahtijeva nestandardnu aplikacijsku komunikaciju i pregovore.

Sažetak poruke

MIT-eva implementacija funkcije za provjeru integriteta poruke je drukčija od one opisane standardom za verziju 4, a primjerenost te modificirane verzije za kreiranje sažetka poruke je nepoznata.

4.2. Promjene u verziji 5

Specifikacija verzije 5 Kerberos protokola prvi put je opisana 1993. godine u dokumentu RFC 1510, koji je 2005. godine nadomješten dokumentom RFC 4120, uz konačnu proširenu specifikaciju protokola. Verzija 5 rješava navedena ograničenja verzije 4 i omogućava dodatnu funkcionalnost.

4.2.1. Promjene izmeñu verzije 4 i 5

Korištenje enkripcije

Da bi se povećala modularnost i olakšale izvozne regulative softvera za verziju 5, korištenje enkripcije je izdvojeno u zasebne programske module koji se prema potrebi mogu nadomještati ili uklanjati od strane programera. Pri korištenju enkripcije u protokolarnim porukama enkriptirani dio poruke označen je identifikatorima tipa enkripcije tako da primatelj poruke zna koji algoritam treba koristiti pri dekriptiranju.

Kada se pojavljuju u porukama, ključevi su takoñer označeni svojim tipom i duljinom. Kako je moguće koristiti isti tip ključa u različitim enkripcijskim

16

sustavima (primjerice različite varijacije DES-a), tip ključa nije jednoznačno odreñen tipom enkripcije i obratno.

Svaki algoritam za kriptiranje je odgovoran za osiguravanje integriteta poruke tako da primatelj može provjeriti je li poruka promijenjena tijekom prijenosa. Ukoliko algoritam ne zadovoljava taj zahtjev, moguće ga je promijeniti dodavanjem sažetka na poruku prije enkripcije. Tako je moguće odbaciti manjkavu PCBC varijantu DES-a iz verzije 4 i koristiti standardnu CBC varijantu uz dodavanje sažetka izvorne poruke prije enkripcije.

U verziji 5 slaba DES enkripcija se koristi za potrebe kompatibilnosti sa verzijom 4, a inače je zamijenjena snažnijim 3-DES i RC4-HMAC enkripcijama.

Mrežne adrese

Kad se u protokolarnim porukama javljaju mrežne adrese, takoñer su označene tipom i duljinom, tako da ih primatelj može ispravno interpretirati. Ukoliko računalo podržava više mrežnih protokola ili posjeduje više adresa koje su istog tipa, svi tipovi i sve adrese mogu se navesti u karti.

Kodiranje poruka

U verziji 5 su mrežne poruke opisane korištenjem ASN.1 sintakse (eng. Abstract Syntax Notation One), opisanoj standardom ISO8824, a kodirane su prema osnovnim pravilima kodiranja prema standardu ISO8825. Na taj način se izbjegava nezavisno odreñivanje kodiranja višebajtnih vrijednosti, kako se radilo u verziji 4.

Promjene u kartama

Karte u verziji 5 Kerberos protokola imaju prošireni format da bi zadovoljili tražene promjene u odnosu na verziju 4. Podijeljene su na dva dijela, jedan enkriptirani i jedan kao običan tekst. Ime poslužitelja je zapisano kao običan tekst, jer poslužitelj s više identiteta (primjerice TGS koji djeluje izmeñu više područja djelovanja) može zatrebati ime da bi znao kojim tajnim ključem dekriptirati ostatak poruke. Sve osim imena poslužitelja je enkriptirano. Vremenske oznake su odreñene početnim vremenom i vremenom nakon kojega karta više ne vrijedi, na taj način eliminirajući kratak maksimalni rok trajanja iz verzije 4. Osim toga, nova karta sadrži nova polja za zastavice i druga polja namijenjena novim mogućnostima protokola.

Imenovanje korisnika

Identifikator korisnika se sastoji od dva dijela: područja djelovanja i ostatka imena. Područje djelovanja je zasebno da omogući jednostavnu implementaciju rutina i provjera prava pristupa koje se obavljaju izmeñu različitih područja djelovanja. Ostatak imena sadrži neograničen slijed komponenti potrebnih da imenuju korisnika. Područje djelovanja i svaka od komponenti ostatka imena su kodirani kao zasebni ASN.1 GeneralStrings tipovi, tako da postoji malen broj restrikcija na dozvoljene znakove za ime korisnika.

Podrška za različita područja djelovanja

U verziji 5, Kerberos područja djelovanja surañuju kroz hijerarhiju opisanu njihovim imenima. Polazno područje djelovanja može surañivati s odredišnim ukoliko dijeli ključ ili direktno s odredišnim područjem, ili dijeli ključ s drugim područjem koje može surañivati s odredišnim. Svako područje u hijerarhijskom stablu dijeli ključ samo sa svojim čvorom roditeljem i sa svim

17

svojim čvorovima djecom. Na taj način se složenost razmjene ključeva smanjuje sa O(n2) iz verzije 4 na O(log(n)).

Kada aplikacija traži pristup poslužitelju iz stranog područja djelovanja, obilazi stablo kontaktirajući svaki sljedeći KDC koji ga prosljeñuje u pravom smjeru. Ukoliko je KDC prethodno stvorio direktnu vezu s traženim KDC-om iz druge grane, može direktno preusmjeriti aplikaciju na njega. Na taj način, sva područja mogu surañivati, a putovi kojima se u velikoj mjeri prolazi mogu biti optimizirani direktnim vezama, odnosno prečacima.

Kada je konačna karta za servis u stranom području djelovanja napokon izdana, u sebi će sadržavati popis svih KDC-ova koji su kontaktirani u postupku izdavanja karte. Ukoliko je put vodio kroz odreñene KDC-ove s kojima poslužitelj nema uspostavljen povjerljiv odnos, ima mogućnost odbiti takvu autentifikaciju.

4.2.2. Nove mogućnosti protokola u verziji 5

Osim navedenih poboljšanja u odnosu na verziju 4, verzija 5 donosi i nekoliko novih naprednih mogućnosti.

Karte

U verziji 5 karte sadrže nekoliko dodatnih vremenskih oznaka i polja za zastavice. Te promjene omogućuju veću fleksibilnost u njihovom korištenju nego što je bila u verziji 4.

Svaka karta izdana od strane KDC-a za vrijeme inicijalne razmjene karata je posebno označena kao takva. To omogućava poslužiteljima kao što je poslužitelj za promjenu zaporke da zatraže od klijenta predočavanje karte koju su dobili pri direktnoj uporabi tajnog ključa KC, umjesto one primljene od strane TGT-a. Takav zahtjev sprječava napadača pri promjeni korisničke zaporke na radnoj stanici u kojoj je korisnik prijavljen, ali je trenutno odsutan.

Karte mogu biti izdane kao obnovljive karte, s dva vremena koja predstavljaju istek roka valjanosti, jedno s vremenom u bliskoj budućnosti, a drugo u daljoj. Karta prestaje vrijediti u ranijem navedenom vremenu, ali ukoliko je predočena KDC-u prije nego to vrijeme istekne, KDC izdaje novu zamjensku kartu s produženim periodom vremena trajanja. KDC neće produljiti vrijeme trajanja preko drugog vremena isteka roka valjanosti. Prednost ovog mehanizma je ta da iako isprave mogu biti korištene tijekom dužeg vremenskog perioda, KDC može odbiti obnoviti karte koje su prijavljene kao ukradene i na taj način onemogućiti njihovu daljnju uporabu.

Sličan mehanizam pomaže autentifikaciji tijekom izvoñenja unaprijed zakazanih procesa. Karta koja je izdana kao nevažeća i s nekim vremenom u budućnosti neće postati ispravna dok navedeno vrijeme ne proñe i dok nakon tog vremena nije zamijenjena valjanom. Kao i u prethodnom slučaju, klijent predočava kartu KDC-u na obnovu.

Prosljeñivanje autentifikacije implementira se kontaktiranjem KDC-a za potrebe dodatne razmjene karata i zahtijevanjem karte valjane za drukčiju adresu klijenta nego što je navedena u TGT-u koji se koristi pri tom zahtjevu. KDC će udovoljiti zahtjevu samo ukoliko TGT u sebi ima postavljenu odgovarajuću zastavicu koja dozvoljava uporabu TGT-a u tu svrhu. Kad su entitetu na udaljenom računalu omogućena samo ograničena prava pri korištenju autentifikacije, proslijeñene isprave nazivaju se posredničkim (eng. proxy). Posredničkim kartama se barata na sličan način kao i s proslijeñenim

18

kartama, razlika je jedino ta što se nove posredničke karte ne mogu izdati za TGS (odnosno, nije moguće pomoću njih dobiti nove karte za pristup drugim poslužiteljima), mogu se izdati isključivo umjesto karata za pristup aplikacijskim poslužiteljima.

U odreñenim situacijama, aplikacijski poslužitelj neće imati pouzdani i sigurni pristup tajnom ključu potrebnom za normalno sudjelovanje u ulozi poslužitelja u autentifikacijskoj razmjeni. U takvim slučajevima, ako poslužitelj ima pristup TGT-u korisnika poslužitelja i odgovarajućem sjedničkom ključu (navedeno je vjerojatno istina ukoliko se radi o radnoj stanici s jednim korisnikom), može poslati klijentu navedeni TGT. Klijent tada može ponovno kontaktirati KDC i predočiti mu vlastiti TGT i TGT primljen od strane poslužitelja, a KDC će odgovoriti izdavanjem klijentu nove karte enkriptirane sjedničkim ključem sa poslužiteljevog TGT-a. Poslužitelj sada posjeduje ključ kojim može dekriptirati i procesirati kartu koju će mu predočiti klijent.

Autorizacijski podaci

Kerberos je prije svega autentifikacijski protokol i nije direktno usredotočen na sigurnosne funkcije zadužene za autorizaciju i upravljanje korisničkim računima. No, Kerberos u verziji 5 nudi podršku implementaciji takvih funkcija od strane drugih servisa. Siguran prijenos autorizacijskih informacija i informacija o korisničkim računima omogućuje činjenica da se ti podaci nalaze unutar izdanih karata, unutar autorizacijskog polja podataka. Informacije koje se prenose zapravo predstavljaju ograničenja pri uporabi odgovarajuće karte. Dekodiranje i prepoznavanje pojedine restrikcije nije vezano uz sam Kerberos protokol, već uz odgovarajuće autorizacijske mehanizme koji su u tom trenutku na snazi. Prilikom izdavanja karte, tražena ograničenja se šalju KDC-u i on ih ubacuje u kartu i enkriptira, na taj način sprječavajući njihovu neovlaštenu izmjenu. Po izdavanju svake nove karte, KDC ne briše prethodno postavljene autorizacijske informacije, TGS te informacije uvijek najprije kopira iz TGT-a, a zatim dodaje dodatno zahtijevane restrikcije. Nakon što dekriptira odgovarajuću kartu, aplikacijski poslužitelj može u skladu s pročitanim restrikcijama ograničiti pristup klijenta vlastitim resursima. Jedna od primjena autorizacijskih podataka obuhvaća i uporabu prethodno opisanih posredničkih (proxy) karata. Prilikom zahtjeva za izdavanje posredničke karte zahtijeva se ograničeni pristup poslužitelju koji će imati korisnik posredničke karte i restrikcije se zapisuju u autorizacijsko polje.

Predautentifikacijski podaci

Verzija 5 donosi i dodatna polja koja se mogu koristiti tijekom inicijalne i dodatnih razmjena karata a koja su enkriptirana alternativnim zaporkama, primjerice od strane fizičkog ureñaja koji koristi vlastito unutrašnje sklopovlje za kontinuirano generiranje zaporki. Prilikom inicijalne razmjene karata, ovo polje može se iskoristiti za promjenu ključa KC kojim je enkriptiran odgovor KDC-a, tako da ga jedino klijent koji posjeduje navedeni fizički ureñaj može dekriptirati. Na taj način ukradena zaporka postaje beskorisna. Takoñer, navedeno polje može se iskoristiti za dokaz klijentovog identiteta prije nego što bilo koja karta bude izdana klijentu i na taj način otežati napadaču da doñe do poruke koju može iskoristiti za verificiranje napada pogañanjem zaporki.

19

U dodatnim razmjenama karata, klijent koristi navedeno polje za predočavanje TGT-a KDC-u. Polje nije fiksne veličine, tako da njime mogu biti proslijeñeni i dodatni podaci tijekom razmjene karata.

Dogovaranje podsjedničkih ključeva

Sjedničke karte su pohranjene u priručnoj memoriji klijenata za kasniju uporabu. Da bi se izbjegli sigurnosni problemi koji mogu nastati ponovnim korištenjem sjedničkog ključa kroz više različitih sjednica, klijent i poslužitelj mogu dogovoriti novi podsjednički ključ koji se koristi samo tijekom jedne sjednice i po njenom završetku se odbacuje. Dogovaranje podsjedničkih ključeva dozvoljava aplikaciji da zaštiti privatnost emitiranja poruka na više primatelja. Prije nego započne emitiranje poruka, aplikacija može ugovoriti zajednički podsjednički ključ sa svakim klijentom individualno.

Slijedni brojevi

Verzija 5 Kerberosa osigurava dva tipa poruka koje koriste aplikacije da bi zaštitile vlastitu komunikaciju. Prvi tip poruke je KRB_SAFE, u njima se koristi kriptografski sažetak za osiguravanje integriteta podataka. Drugi tip poruke, KRB_PRIV, koristi se enkripcijom da osigura integritet i privatnost podataka. U verziji 4 te poruke su kao kontrolnu informaciju sadržavale vremensku oznaku i mrežnu adresu pošiljatelja. U verziji 5, aplikacija može izabrati ili korištenje vremenske oznake kao i prije, ili slijedni broj. Ukoliko se koristi vremenska oznaka, primatelj poruke mora voditi računa o već pristiglim vremenskim oznakama da bi spriječio napad ponavljanjem poruka, dok kod slijednih brojeva primatelj mora utvrditi da poruke pristižu u pravilnom redoslijedu, bez preskakanja.

4.3. Implementacijske značajke verzije 5

4.3.1. Osnovna implementacija

Implementacija verzije 5 Kerberos protokola od strane MIT-a sastoji se od nekoliko biblioteka za povezivanje tijekom izvoñenja programa. Bazične biblioteke funkcija koristi svaka aplikacija, a ostali podsustavi mogu biti izostavljeni ili promijenjeni prema potrebi programera aplikacije. Trenutno je sav kod napisan u programskom jeziku C.

Bazične funkcije

Bazične funkcije sadrže rutine koje sastavljaju, rastavljaju i interpretiraju mrežne poruke. Meñu njima su rutine za kodiranje i dekodiranje prema ASN.1 standardu, rutine koje odreñuju kada su koje poruke potrebne i rutine koje provjeravaju je li na zahtjeve odgovoreno u skladu s očekivanim. Bazične funkcije prema potrebi pozivaju funkcije iz drugih biblioteka.

Enkripcijske rutine

Kako je istovremeno moguće koristiti više različitih tipova enkripcije, bazične funkcije pozivaju enkripcijske rutine preko funkcijske tablice. Tablica je ispunjena podacima od strane svake implementacije pojedinog enkripcijskog sustava. Bazična biblioteka osigurava podrazumijevanu tablicu koja inicijalizira listu poznatih tipova enkripcije. Programer može nadomjestiti podrazumijevanu

20

tablicu vlastitom i na taj način spriječiti korištenje podrazumijevanih enkripcijskih biblioteka. U svrhu smanjivanja izvoznih ograničenja, implementacija verzije 5 od strane MIT-a distribuira enkripcijske biblioteke odvojeno od ostatka sustava. MIT trenutno osigurava jedino DES.

Rutine za kreiranje i provjeru sažetka

Slično kao kod enkripcijskih rutina, bazične funkcije pozivaju sažetkovne rutine putem tablice, računajući potrebne veličine prema informacijama koje su u njoj pohranjene. Takoñer, zapisi u tablici daju informaciju o tome je li sažetak vezan uz ključ (eng. keyed) (odnosno algoritam za računanje sažetka je promiješan enkripcijskim ključem kojeg je nemoguće otkriti samo uz poznavanje algoritma i teksta nad kojim se traži sažetak) i je li otporan na koliziju (eng. collision proof) (odnosno nepraktično je proračunati drugačiji tekst koji ima isti sažetak). I u ovom slučaju bazična biblioteka osigurava podrazumijevanu tablicu. MIT trenutno osigurava podršku za četiri tipa sažetaka: CRC-32 (nije niti vezan uz ključ, niti otporan na koliziju, ali je koristan za provjeru integriteta unutar enkripcijskih sustava), DES MAC (eng. message authentication code) (vezan je uz ključ i otporan je na koliziju), MD4 i MD5 (oba su otporna na koliziju, ali nisu vezana uz ključ).

Rutine za upravljanje memorijom za pohranu isprava i tablicom ključeva

Kad klijenti trebaju pohraniti isprave i izdane im karte, bazične funkcije pozivaju preko posebne tablice odvojenu biblioteku u kojoj su implementirane rutine za pretraživanje i pohranjivanje isprava u odgovarajuće priručne memorije. Podrazumijevani tip i lokacija priručne memorije namijenjena ispravama zapisani su u varijabli okruženja, tako da korisnik može jednostavno mijenjati izmeñu različitih priručnih memorija za isprave, primjerice ako želi držati odvojenima isprave za dvije različite uloge. MIT-eva implementacija verzije 5 sadrži dvije implementacije memorije za pohranu isprava, jedna izgrañena pomoću C stdio rutina, a druga izgrañena pomoću semantike opisnika datoteka na UNIX-u. Poslužitelji na sličan način pohranjuju svoje tajne ključeve KS u tablice ključeva kojima pristupaju bazične funkcije preko funkcijske tablice. MIT-eva implementacija osigurava biblioteku za upravljanjem tablicom ključeva izgrañenu pomoću C stdio rutina.

Podrška za bazu podataka na KDC-u

Svi pristupi KDC-ovoj bazi podataka korisnika obavljaju se putem posebne biblioteke funkcija koju je prema potrebi moguće zamijeniti. MIT-eva implementacija koristi UNIX-ov dbm sustav baze podataka. Pošto dbm sustav ne osigurava zaključavanje podataka ili čitave baze, njegovo korištenje je nadopunjeno zasebnim kodom za zaključavanje podataka prilikom zapisivanja i čitanja iz baze. Administrativne zahvate nad bazom, kao što su dodavanje podataka i mijenjanje ključeva i zaporki moguće je obavljati dok je KDC u uporabi.

Podrška operacijskim sustavima

Iako je MIT-eva implementacija primarno namijenjena UNIX i Linux operacijskim sustavima, ne oslanja se direktno na funkcionalnosti koje

21

operacijski sustav nudi, već za sav pristup koristi posebnu biblioteku za podršku operacijskim sustavima. Ona je zadužena za slanje i primanje poruka putem mreže, pregledavanje konfiguracijskih datoteka, provjeravanje sistemskog vremena, prevoñenje izmeñu naziva korisničkih računa u Kerberos nazive (i obratno) i izvoñenje jednostavnih provjera pristupa korisničkim računima.

4.3.2. Interakcija s korisnicima

Ukoliko se svi dijelovi Kerberosa odvijaju normalno, korisnik uglavnom neće biti svjestan da se Kerberos autentifikacija koristi u aplikacijama koje pokreće. Tijekom procesa prijavljivanja na računalo pribavlja se i pohranjuje inicijalna TGT, a aplikacija automatski pribavlja karte prema potrebi. Kad autentifikacija ne uspije, korisnik postaje svjestan uporabe Kerberosa. Ako karte isteknu, korisniku je na raspolaganju program kinit koji pribavlja novu TGT po ponovnom unosu korisnikove zaporke. Takoñer, korisniku su na raspolaganju programi klist, za pregled dosad izdanih karata i kdestroy, za njihovo uništavanje. Prema konvenciji, imena korisnika su prikazana na način da su dijelovi imena odvojeni kosom crtom (/), a od naziva područja djelovanja znakom “at” (@). Primjerice, korisnik s imenom iz dva dijela ime i uloga u području djelovanja STARJAK.KK, bio bi prikazan na sljedeći način: ime/uloga@STARJAK.KK

Konverzija korisnikove zaporke u tajni ključ

Kerberos protokol osigurava rutine za pretvaranje korisnikove zaporke u tajni ključ. Algoritam zadužen za to obavlja neinverznu transformaciju iz zaporke u ključ, tako da napadač ne može otkriti korisnikovu zaporku poznavajući samo ključ KC. U verziji 5, kao dodatna ulazna varijabla u algoritmu koristi se niz znakova (najčešće ime područja djelovanja) koja mijenja izlazni ključ, tako da korisnik koji koristi istu zaporku u različitim područjima djelovanja ima različiti tajni ključ. Bez navedenog mijenjanja ključa korištenjem dodatnog niza znakova, napadač koji otkrije tajni ključ u jednom području djelovanja, može pristupiti i drugim područjima bez poznavanja zaporke. Ukoliko se ne koristi dodatni niz znakova, algoritam generira isti ključ koji se generirao algoritmom u verziji 4.

4.3.3. Podrška kompatibilnosti s verzijom 4

MIT-eva implementacija verzije 5 pruža nekoliko mogućnosti koje pomažu programerima i organizacijama prelazak s verzije 4 na verziju 5.

Kompatibilnost sučelja

MIT-eva implementacija verzije 5 sadrži posebnu poveznu biblioteku (eng. glue library) koja zadržava sučelje za programiranje aplikacija (eng. application programming interface - API) iz verzije 4, ali koja koristi rutine i protokolarne poruke iz verzije 5. Ta biblioteka vrši konverziju izmeñu struktura podatka iz verzije 4 i 5 onoliko koliko je to moguće zbog njihovih meñusobnih razlika. U mnogim slučajevima, a posebno u onim u kojima se koristi samo osnovni podskup funkcija verzije 4, dovoljno je navedenu aplikaciju samo ponovno povezati s ovom bibliotekom i ostatkom biblioteka iz verzije 5 da bi mogla koristiti verziju 5 protokola. No, takve aplikacije prestaju biti kompatibilne sa

22

procesima iz verzije 4, i dalje očekuju tip poruka prema verziji 4 i svako buduće održavanje moglo bi biti otežano.

Generičko autentifikacijsko sučelje

GSSAPI (eng. Generic Security Services API) je sučelje za programiranje aplikacija, neovisno o autentifikacijskom sustavu. GSSAPI programerima omogućava korištenje različitih autentifikacijskih sustava, bez potrebe za poznavanjem unutarnjeg ustroja bilo kojeg od njih. MIT je osigurao vezu izmeñu GSSAPI-a i implementacije verzije 5 Kerberosa.

Kompatibilnost protokola

Za one organizacije koje odluče unaprijediti Kerberos server na verziju 5, postoji opcija omogućavanja režima rada kompatibilnog s verzijom 4. U tom režimu rada KDC može prihvatiti tip zahtjeva iz verzije 4 i izdati karte i poruke iz verzije 4, istovremeno prihvaćajući i tipove zahtjeva prema verziji 5. To administratorima sustava omogućuje polagan prijelaz na verziju 5, uz podršku klijentima sa starijom verzijom. Ukoliko klijent želi istovremeno koristiti obje verzije protokola, korisnički ključ mora iz zaporke biti generiran algoritmom iz verzije 4. Verzija 5 će u svom odgovoru unutar predautentifikacijskog polja karte uključivati informaciju o tome koji algoritam za kreiranje ključa iz zaporke će koristiti klijent verzije 5.

Suživot različitih sučelja

MIT-eve biblioteke funkcija u verziji 5 napravljene su s namjerom da dozvole aplikaciji da istovremeno podržava i verziju 4 i verziju 5, a to je ujedno i sugerirani režim rada za aplikacije. Primjerice, program telnet koji se distribuira s MIT-evim kodom može automatski odabrati autentifikacijski sustav koji će koristiti pri spajanju na udaljeno računalo, ovisno o tome koji tip isprava korisnik posjeduje i koju će verziju autentifikacije prihvatiti udaljeni poslužitelj.

Kompatibilnost programa

Kompatibilni režim rada moguće je kreirati održavanjem zasebnih kopija mrežnih aplikacija koje koriste verziju 4 i verziju 5 Kerberos protokola. Korisnik bi koristio generičko ime za aplikaciju, a aplikacija bi pokušavala pristupiti svakom od autentifikacijskih sustava, pozivanjem odgovarajuće kopije aplikacije za odgovarajući sustav. Po uspješnoj autentifikaciji, aplikacija bi se nastavila odvijati normalno. I na klijentu, i na poslužitelju, ovaj pristup zahtijeva dvije kopije istog programa, svaka povezana sa odgovarajućim autentifikacijskim sustavom. Različite verzije na poslužitelju bi prihvaćale zahtjeve na različitim mrežnim ulazima, a različiti klijenti bi slali zahtjeve samo poslužiteljima koji podržavaju isti tip autentifikacije kao i oni. Navedeni pristup mogao bi se povezati s korištenjem poveznih biblioteka na način da klijentska kopija aplikacije u stvari koristi poveznu biblioteku i na taj način izbjegava dodatne programerske zahvate. Takoñer, nije potrebno raditi razdvajanje poslužiteljske aplikacije ukoliko razumije obje verzije protokola.

23

5. Kerberos protokol u operacijskom sustavu Windows

Kada se govori o Kerberos protokolu implementiranom u operacijskim sustavima Windows, onda se podrazumijeva da je riječ o operacijskim sustavima Windows 2000, Windows XP i Windows Server 2003 jer ga ranije verzije nisu implementirale. U daljnjem tekstu će se stoga naziv "operacijski sustav Windows" odnositi na sve gore navedene, osim u slučajevima kada će to biti posebno naglašeno. Isto vrijedi i za pojam Windows domene koji se u punom smislu uvodi tek operacijskim sustavom Windows 2000.

5.1. Autentifikacija unutar Windows domena

Za mrežnu autentifikaciju unutar Windows domena, na raspolaganju su dva protokola: NTLM (eng. Windows NT LAN Manager) i verzija 5 Kerberosa. NTLM se koristio za autentifikaciju u starijem operacijskom sustavu Windows NT 4.0 i zadržan je zbog kompatibilnosti sa starijim verzijama klijenata i poslužitelja (Windows 3.11, Windows 95, Windows 98, Windows NT 4.0). Kerberos protokol je podrazumijevani protokol za autentifikaciju putem mreže u operacijskim sustavima Windows 2000, Windows XP i Windows Server 2003. Prednosti Kerberos protokola naspram NTLM protokola su brže uspostavljanje veze izmeñu klijenta i poslužitelja, mogućnost obostrane autentifikacije, delegiranje autentifikacije, pojednostavljeno upravljanje uspostavljanjem povjerenja te veća interoperabilnost s drugim mrežama.

5.2. Infrastruktura Kerberos protokola

5.2.1. Standard

Implementacija Kerberos protokola u operacijskom sustavu Windows pridržava se specifikacije navedene u dokumentu RFC 1510. Dodatno, format i mehanizam za slanje sigurnosnih znački u Kerberos porukama pridržava se specifikacije navedene u dokumentu RFC 1964.

5.2.2. Proširenje Kerberos protokola

U operacijskom sustavu Windows implementirano je proširenje Kerberos protokola koje dozvoljava inicijalnu autentifikaciju korištenjem certifikata koji se služe infrastrukturom javnih ključeva, za razliku od konvencionalne metode autentifikacije putem zajedničkog tajnog ključa. Tim proširenjem se omogućuje podrška za prijavljivanje na sustav korištenjem pametne kartice.

5.2.3. KDC

U operacijskom sustavu Windows, KDC je implementiran kao jedan od domenskih servisa, a za bazu podataka koristi Active Directory. Na taj način, KDC je sastavni dio svakog upravitelja domene i nije ga moguće izdvojiti kao zasebnog poslužitelja. Kao i u drugim implementacijama Kerberosa, KDC je jedan proces koji pruža dva servisa: autentifikacijski servis AS (eng. Autentication Service) za izdavanje TGT-ova i servis za izdavanje karata TGS (eng. Ticket-Granting Service) za izdavanje sjedničkih karata za pristup poslužiteljima iz domene ili TGS-ovima iz drugih domena s kojima je

24

uspostavljeno povjerenje. Oba navedena servisa pokreću se automatski od strane LSA (eng. Local Security Authority) pojedinog upravitelja domene i odvijaju se u programskom prostoru namijenjenom za LSA. Riječ je o zaštićenom podsustavu i na taj način je osigurano njihovo sigurno izvoñenje. Niti jedan od navedenih servisa nije moguće zaustaviti vanjskom intervencijom. Dostupnost servisa je osigurana činjenicom da svaka domena može imati više upravitelja domenom, a samim time i više rezervnih KDC-ova.

Prema specifikaciji iz dokumenta RFC 1510, korisničko ime koje koristi KDC u Windows domeni je krbtgt. Ono se stvara automatski pri kreiranju nove domene i nije ga moguće izbrisati, niti mijenjati. Navedenim domenskim korisničkim računom služe se sve instance KDC-a u pojedinoj domeni.

Predautentifikacija

Podrazumijevano ponašanje KDC-a je da od svih korisničkih računa zahtijeva predautentifikaciju. Na taj način znatno se otežava verifikacija prilikom pogañanja zaporki na primjerku izdanog TGT-a u čiji posjed je došao napadač. No, u svrhu kompatibilnosti s drugim implementacijama Kerberos protokola, predautentifikaciju je moguće isključiti za pojedine korisničke račune.

5.2.4. Baza podataka korisničkih računa

Bazu podataka korisničkih računa kojom se služi KDC pruža domenski Active Directory. Svaki korisnik je predstavljen vlastitim objektom, a njegov tajni ključ pohranjen je kao atribut pojedinog objekta. Poslužitelji za upravljanje Active Directory-em mogu biti isključivo upravitelji domene. Svaki upravitelj domene posjeduje vlastitu lokalnu kopiju baze podataka koju je moguće mijenjati tako da se administrativni zahvati nad bazom mogu obavljati na bilo kojem upravitelju domene. Promjene na jednoj kopiji propagiraju se na sve preostale kopije. Pri tom nije implementiran Kerberos protokol za replikaciju, već se koristi zaseban replikacijski protokol putem sigurnog kanala izmeñu pojedinih upravitelja domenom. U svrhu onemogućavanja off-line napada od strane napadača s pristupom rezervnim kopijama baze podataka, atributi korisničkih objekata koji sadržavaju tajni ključ dodatno su enkriptirani sistemskim ključem. Sistemski administratori mogu odabrati gdje će sistemski ključ biti pohranjen (na nekom vanjskom mediju ili na upravitelju domenom, ali zaštićen disperzijskim mehanizmom), kao i koji od nekoliko algoritama će biti korišten pri enkripciji.

5.2.5. Postavke Kerberosa

U operacijskom sustavu Windows ponašajne značajke (eng. policy) Kerberosa definiraju se na razini domene i implementirane su od strane KDC-a. Pohranjene su u Active Directory-u kao podskup svih sigurnosnih ponašajnih značajki pojedine domene. Postavke mogu mijenjati isključivo članovi grupe domenskih administratora. Neke od postavki, zajedno s njihovim atributima su:

• Maksimalno vrijeme trajanja TGT-a o Vrijeme je iskazano u satima o Podrazumijevano vrijeme je deset sati

• Maksimalno vrijeme u kojem je moguće obnoviti TGT o Vrijeme je iskazano u danima o Podrazumijevano vrijeme je sedam dana

25

• Maksimalno vrijeme trajanja sjedničke karte o Vrijeme je iskazano u minutama o Mora biti veće od deset minuta i manje od maksimalnog vremena

trajanja TGT-a o Podrazumijevano vrijeme je deset sati

• Maksimalna tolerancija za sinkronizaciju vremena na računalima o Vrijeme je iskazano u minutama o Podrazumijevano vrijeme je pet minuta

• Provoñenje ograničenja na korisnikovo prijavljivanje na sustav o Kad je opcija uključena, KDC za svaki zahtjev za sjedničkom

kartom provjerava ima li korisnik prava pristupa traženom poslužitelju, lokalno ili putem mreže, taj dodatni korak može biti vremenski zahtjevan i usporiti mrežni pristup servisima

o Podrazumijevano je da je opcija uključena

Postavke delegiranja autentifikacije

Delegiranje autentifikacije, odnosno mogućnost da se servisi prema potrebi predstavljaju kao korisnik kada pristupaju drugim servisima, omogućuje se dozvoljavanjem prosljeñivanja karata, a to se postiže definiranjem odgovarajućih ponašajnih značajki Kerberos protokola na čitavom području domene. No, ukoliko iz sigurnosnih razloga želimo onemogućiti prosljeñivanje isprava, bilo na razini individualnog korisnika (zabrana svim poslužiteljima da prosljeñuju njegove isprave) ili pojedinog računala (zabrana prosljeñivanja svih korisničkih isprava putem tog računala), to je moguće izvesti kreiranjem posebnih ponašajnih značajki koje se primjenjuju na korisnike i računala unutar posebnih organizacijskih jedinica unutar domene.

5.2.6. Način implementacije Kerberosa

Autentifikacijski protokol Kerberos je implementiran kao pružatelj sigurnosne podrške (eng. Security Support Provider – u daljnjem tekstu SSP), u vidu dinamički povezive biblioteke Secur32.dll koja se isporučuje s operacijskim sustavom. Na isti način je implementiran i stariji protokol NTLM, no Kerberos SSP je uvijek prvi izbor pri autentifikaciji. Kerberos SSP se pokreće od dijela operacijskog sustava koji se u Windows okruženju naziva sustavom za upravljanje lokalnom sigurnosti (eng. local security authority – u daljnjem tekstu LSA). Riječ je o zaštićenom podsustavu koji se bavi autentifikacijom i prijavljivanjem korisnika na lokalni sustav, a osim toga nadzire i održava pravila koja pokrivaju sve aspekte sigurnosti na lokalnom sustavu (npr. dozvole pristupa pojedinim resursima, akcije koje se pokreću u slučaju neovlaštenog pristupa itd.) Sistemski servisi i aplikacije pristupaju ugrañenim SSP-ovima kroz za to predviñeno sučelje, SSPI (eng. Security Support Provider Interface). Uloga sučelja je osigurati metode za pobrojavanje svih ugrañenih SSP-ova, odabiranja jednog i zatim uspostavljanja autentifikacije njegovim korištenjem. Svi distribuirani servisi u operacijskom sustavu Windows koriste SSPI za pristup Kerberos SSP-u.

26

5.2.7. Priručna memorija za korisničke isprave

Sve karte i ključevi primljeni od KDC-a pohranjeni su u memoriji za isprave, području memorije zaštićenim od strane LSA. Ta memorija nikad se ne kopira na disk. Svi objekti u memoriji uništavaju se prilikom odjavljivanja korisnika ili prilikom gašenja sustava. Memorijom za isprave upravlja Kerberos SSP, unutar LSA-ovog sigurnosnog konteksta. Kada je potrebno pribaviti ili obnoviti karte, LSA za obavljanje zadaće poziva Kerberos SSP. LSA takoñer zadržava kopiju korisnikovog tajnog ključa. Na taj način, ukoliko TGT istekne u vrijeme dok je korisnik još prijavljen na sustav, Kerberos SSP koristi tu kopiju tajnog ključa za izdavanje novog TGT-a, bez prekidanja rada korisnika. Naravno, tajni ključ nije pohranjen za stalno i uništava se po prekidu korisnikove sjednice za računalom. Za razliku od navedenog baratanja tajnim ključem, sjedničkim ključevima upravlja se na drukčiji način. Oni su pohranjeni u zasebnom, sigurnom dijelu registry-a računala. Tamo su pohranjen i ključevi korisnika za lokalni pristup računalu, no oni se na koriste za pristup računalu putem mreže.

5.2.8. Kerberos i DNS

U Windows domeni su upravitelji domenom ne samo KDC poslužitelji, već su ujedno i LDAP poslužitelji (eng. Lightweight Directory Access Protocol). Oba servisa, KDC i LDAP su zabilježeni u DNS-ovim zapisima lociranja servisa (tzv. SRV zapisi). Klijenti koji žele saznati ime upravitelja domene, mogu to učiniti putem DNS upita za SRV zapisom _ldap._tcp.dc._msdcs.DnsDomainName, pri čemu DnsDomainName označava ime odgovarajuće domene. Slično, klijent može pronaći KDC servis putem DNS upita za SRV zapisom _kerberos._udp.DnsDomainName. Ukoliko računalo s operacijskim sustavom Windows pristupa Kerberos području koje nije Windows domena, DNS ime KDC-a mora biti zapisano u registry području klijentovog računala. Konfiguriranje klijentskog računala za sudjelovanje u Kerberos područjima koji nisu Windows domene obavlja se korištenjem alata ksetup.exe.

5.2.9. Autorizacijski podaci

Kerberos je protokol za autentifikaciju, a ne za autorizaciju. No, da bi pomogao prilikom procesa kontrole pristupa, Kerberos protokol pruža polje za autorizacijske podatke na kartama. Kerberos ne propisuje formu podataka, niti na koji način bi ih poslužitelji trebali koristiti.

Kontrola pristupa

U operacijskim sustavima Windows, svi resursi koji mogu biti dijeljeni izmeñu više procesa osigurani su od neovlaštenog pristupa posebnim mehanizmom koji provodi operacijski sustav. Zaglavlje svakog objekta sadrži sigurnosni opisnik sa listom kontrole pristupa (eng. Access Control List – u daljnjem tekstu ACL) koji održava vlasnik objekta i koji može odreñivati nivo autorizacije svakom procesu kojem je dozvoljen pristup tom objektu. Operacijski sustav provodi odluke vlasnika objekta provjeravajući prava pristupa iz ACL-a

27

prilikom svakog zahtjeva za pristupom zaštićenom objektu od strane bilo koje aplikacije. U navedenim operacijskim sustavima korisnici se ne identificiraju preko svog imena, već je svakom korisniku dodijeljen jedinstveni sigurnosni identifikator (eng. Security Identifier – u daljnjem tekstu SID). SID se sastoji iz dva dijela, prvi odreñuje domenu u kojoj je SID izdan, a drugi označava korisnički račun. Stari SID-ovi se nikada ne izdaju ponovno. Autorizacija se ne odreñuje samo na temelju korisnikovog SID-a, nego takoñer pripadnošću korisnika u odgovarajuću sigurnosnu grupu. Preferirana metoda kontrole pristupa resursima je zapravo putem dodjeljivanja prava pristupa grupama, a ne direktno pojedinim korisnicima. Na taj način je lakše kontinuirano održavati ACL-ove u mrežama sa tisućama korisnika i milijunima objekata. Dodjeljivanje prava pojedinom korisniku se obavlja indirektno, dodavanjem korisnika u grupu s odgovarajućom razinom pristupa. Dodatna fleksibilnost je ostvarena mogućim gniježñenjem grupa. Kao i pojedini korisnici, svaka grupa posjeduje vlastiti SID. Dakle, razina pristupa pojedinog korisnika odreñena je listom SID-ova, jedan SID je korisnikov, a preostali odreñuju grupe u koje korisnik pripada.

Kreiranje autorizacijskih podataka od strane KDC-a

Autorizacijski podaci koji se nalaze na sjedničkoj karti sadržavaju listu SID-ova koji odreñuju klijenta i njegovu pripadnost grupama. Oni se prikupljaju u dva zasebna koraka: u prvom koraku kada KDC priprema TGT i u drugom u kojem KDC priprema samu sjedničku kartu za pristup poslužitelju. Kada klijent zahtijeva TGT, KDC šalje upit prema Active Directory-u odgovarajuće domene. Podaci u Active Directory-u sadrže korisnikov SID, zajedno sa svim SID-ovima grupa u koje klijent pripada. Oni se po završetku upita zapisuju u autorizacijsko polje TGT-a. Ukoliko je riječ o okruženju s više domena, KDC takoñer ispituje globalni katalog ne bi li pronašao univerzalne grupe kojima pripada klijent ili neka od klijentovih grupa. Ukoliko ih pronañe, njihov SID se takoñer zapisuje u TGT.

Kada klijent od KDC-a zahtijeva sjedničku kartu za pristup poslužitelju, KDC u poslužiteljevoj domeni kopira listu SID-ova iz autorizacijskog polja TGT-a u autorizacijsko polje sjedničke karte. Ukoliko su klijent i poslužitelj iz različitih domena, KDC šalje upit Active Directory-u da bi saznao postoje li grupe u trenutnoj domeni kojima pripada klijent ili neka od klijentovih grupa. Ukoliko postoje, njihov SID se takoñer pridodaje listi. Da bi se spriječila izmjena autorizacijskih podataka, podaci su digitalno potpisani od strane KDC-a prije njihovog pohranjivanja u kartu.

Korištenje autorizacijskih podataka od strane poslužitelja

U operacijskim sustavima Windows, servisi na poslužiteljima se koriste vlastitim sigurnosnim kontekstom samo kada se bave pozadinskim radnjama koje nisu vezane za posao klijenta. Kada servis obavlja neki posao za klijenta, tada on utjelovljuje klijenta, koristeći klijentov sigurnosni kontekst. Tom prilikom servis mora preuzeti i klijentovu razinu pristupa. Kada klijent zatraži uspostavljanje veze s poslužiteljem i predoči sjedničku kartu, poslužitelj prosljeñuje sjedničku kartu i vlastiti tajni ključ Kerberos SSP-u na provjeru. Kerberos SSP provjerava autentičnost karte, dekriptira ju i prosljeñuje sadržaj autorizacijskog polja svom nadreñenom procesu, LSA. On

28

na temelju liste SID-ova gradi pristupnu značku koja predstavlja klijenta na lokalnom sustavu. Dodatno, LSA ispituje vlastitu bazu podataka da utvrdi je li klijent ili neka od njegovih grupa član neke od lokalnih sigurnosnih grupa. Ukoliko jest, i njihovi SID-ovi se dodaju u pristupnu značku, koja se na kraju predaje nazad Kerberos SSP-u da bude na raspolaganje poslužitelju. Sada poslužitelj može utjeloviti klijenta i kad god zahtijeva pristup nekom objektu, predočava kreiranu pristupnu značku. Operacijski sustav tada usporeñuje SID-ove iz pristupne značke sa SID-ovima u ACL-u objekta i ako pronañe odgovarajući par, provjerava dozvoljava li se za njega zahtijevana razina pristupa objektu i dalje postupa u skladu s tim.

29

6. SSPI i GSSAPI modeli

Kerberos API, odnosno programsko sučelje za korištenje Kerberosa nije standardizirano i postoje različite implementacije koje su meñusobno nekompatibilne. Za rješenje problema nekompatibilnosti, sa programerske strane na raspolaganju su dva univerzalna autentifikacijska sučelja, SSPI i GSSAPI. Konkretni autentifikacijski protokol (Kerberos) implementira standardizirano sučelje i na taj način osigurava kompatibilnost izmeñu svih aplikacija koje ga koriste.

SSPI (eng. Security Support Provider Interface) i GSSAPI (eng. Generic Security Service API) su univerzalna sučelja koja objedinjavaju zajedničke osobine različitih načina autentifikacije, kao što je primjerice arhitektura klijenta i poslužitelja te uzastopna razmjena poruka. Takoñer su neovisna o komunikacijskom protokolu koji se koristi pri autentifikaciji. Aplikacijama se na taj način omogućuje veća fleksibilnost i prenosivost pri korištenju različitih sigurnosnih modela koji implementiraju jednako sučelje. Osim toga, u slučaju da je potrebno zamijeniti metodu autentifikacije, samu aplikaciju nije potrebno ponovno pisati. Funkcije koje se koriste za potrebe uspostavljanja sigurne autentifikacije su generičkog oblika i prema programeru su predstavljene kao "crna kutija", odnosno da bi ih mogao koristiti, programer ne mora znati što se sve dešava u pozadini poziva pojedine funkcije, kao niti detalje vezane uz pojedini sigurnosni protokol.

Protokol kojim se uspostavlja sigurna veza uz autentifikaciju zasniva se na razmjeni sigurnosnih znački (eng. security tokens) izmeñu klijenta i poslužitelja:

1. Klijent pozivom odgovarajuće SSPI/GSSAPI funkcije od sigurnosnog paketa dobiva sigurnosnu značku. Klijent ju ne može interpretirati niti mijenjati.

2. Klijent šalje sigurnosnu značku poslužitelju kao poruku.

3. Poslužitelj takoñer ne može interpretirati niti mijenjati primljenu sigurnosnu značku. Pozivanjem odgovarajuće SSPI/GSSAPI funkcije prosljeñuje ju vlastitom sigurnosnom paketu radi interpretacije.

4. Sigurnosni paket obavještava poslužitelja o statusu klijentove autentifikacije (obavljena, odbijena ili se još uvijek uspostavlja) i dostavlja mu novu sigurnosnu značku.

5. Poslužitelj šalje sigurnosnu značku klijentu kao poruku.

6. Klijent prosljeñuje primljenu sigurnosnu značku vlastitom sigurnosnom paketu da bi ustanovio je li veza uspostavljena ili su potrebne daljnje razmjene sigurnosnih znački.

7. Postupak se dalje ponavlja do uspostavljanja sigurne veze.

6.1. SSPI model

SSPI model kreiran je od strane Microsofta kao sučelje za korištenje sigurnosnih paketa (SSP-ova) u operacijskim sustavima Windows. U operacijskim sustavima Windows na raspolaganju su sigurnosni paketi Negotiate, Kerberos, NTLM, Digest SSP i Schanell. Paket Negotiate je

30

specifičan i omogućuje veću fleksibilnost klijentskih i poslužiteljskih aplikacija. Naime, umjesto da programer prilikom pisanja aplikacije odmah definira korištenje odreñenog SSP-a, korištenjem paketa Negotiate odluka o odabiru SSP-a se donosi u tijeku izvoñenja programa, u skladu s postojećom sigurnosnom podrškom na klijentu i poslužitelju. Prvi izbor paketa Negotiate je upravo Kerberos SSP.

Slika 6.1: Kerberos autentifikacija preko SSPI-a

6.2. SSPI strukture podataka i funkcije

Strukture SecBuffer i SecBufferDesc

Komunikacija izmeñu klijenta i poslužitelja podrazumijeva razmjenu potencijalno velikih količina podataka ili količinu podataka nepoznate duljine. Da bi se mogla nositi s tim poteškoćama, kod SSPI-a se komunikacija odvija posredstvom dviju struktura: SecBuffer i SecBufferDesc. Struktura SecBuffer opisuje jedan meñuspremnik podataka, a SecBufferDesc opisuje polje struktura tipa SecBuffer. Obje strukture deklarirane su u datoteci Sspi.h, a pri prevoñenju programa potrebno je uključiti datoteku Security.h. Detaljan opis struktura nalazi se u dodatku.

SSPI funkcije

SSPI funkcije sačinjavaju četiri grupe: funkcije za upravljanje sigurnosnim paketima, funkcije za upravljanje ispravama, funkcije za upravljanje sigurnosnim kontekstom i funkcije za podršku sigurnoj razmjeni poruka. Sve funkcije deklarirane su u datoteci Sspi.h, pri prevoñenju programa potrebno je uključiti datoteku Security.h, a prilikom povezivanja (eng. linking) programa treba koristiti biblioteku Secur32.lib. Detaljan opis funkcija nalazi se u dodatku.

6.3. GSSAPI model

GSSAPI je standard koji opisuje univerzalno sučelje za autentifikaciju predložen od strane IETF-a (eng. Internet Engineering Task Force) kao rješenje

31

problema velikog broja sličnih, ali nekompatibilnih sigurnosnih usluga. Po svojim značajkama posjeduje dosta sličnosti sa Microsoftovim SSPI modelom, no zbog činjenice da nije namijenjen isključivo jednom tipu operacijskih sustava sadrži nešto veći broj sveobuhvatnijih funkcija. Poseban paket "SPNEGO" nudi mogućnost biranja autentifikacijskog protokola tijekom izvoñenja programa, slično kao i SSPI paket "Negotiate". Trenutno su na raspolaganju Kerberos i SPKM (eng. Simple Public-Key Mechanism). U najvećoj mjeri koristi se Kerberos implementacija GSSAPI-a. Aktualna verzija 2 GSSAPI-a opisana je dokumentom RFC 2743, a standard za programski jezik C opisan je dokumentom RFC 2774. GSSAPI je još standardiziran za programski jezik Javu, a radi se na standardu za C#. Daljnji tekst bavi se standardom za programski jezik C.

6.4. GSSAPI tipovi podataka i funkcije

Integer tipovi

GSSAPI koristi tip OM_uint32 koji je zapravo 32-bitni unsigned integer. Ovaj prenosivi tip podataka se koristi u definiciji GSSAPI funkcija u slučajevima kada je važan garantirani minimalni broj bitova. Odgovarajuće implementacije GSSAPI-a uključuju odgovarajuće "typedef" definicije za preklapanje ovog tipa podatka i njihovog ugrañenog tipa.

Strukture podataka

Mnoge GSSAPI funkcije koriste za argumente i povratne vrijednosti koje su opisane kontinuiranim nizom okteta (eng. string). Svi takvi podaci su opisani tipom podataka gss_buffer_t, koji je pokazivač na opisnik meñuspremnika. Opisnik sadrži void pokazivač na same podatke i duljinu polja koja odreñuje broj bajtova na koji pokazuje pokazivač. Navedeni tip podataka je definiran kao:

typedef struct gss_buffer_desc_struct { size_t length; void *value; } gss_buffer_desc, *gss_buffer_t;

Prema konvenciji, GSSAPI funkcije su odgovorne za rezerviranje memorije prilikom vraćanja podataka tipa gss_buffer_t. Ukoliko se koristi objekt gss_buffer_desc, odgovornost je na aplikaciji (gss_buffer_desc objekti koji se ne koriste mogu biti postavljeni na vrijednost GSS_C_EMPTY_BUFFER). Neke GSSAPI funkcije koriste parametre tipa gss_OID koji predstavlja identifikator objekta i koristi se od strane pozivatelja GSSAPI funkcija za odabir specifičnog sigurnosnog mehanizma. Tip je definiran kao: typedef struct gss_OID_desc_struct { OM_uint32 length; void *elements; } gss_OID_desc, *gss_OID;

Pokazivač elements pokazuje na prvi bajt niza okteta u kojima je prema standardu ASN.1 BER kodiran vrijednosni dio normalnog BER TLV kodiranja identifikatora objekta. Parametar length odreñuje duljinu polja. Primjerice, gss_OID vrijednost koja odgovara BER TLV zapisu {iso(1) identified-

32

organization(3) icd-ecma(12) member-company(2) dec(1011) cryptoAlgorithms(7) DASS(5)}, označavajući pritom DASS X.509 autentifikacijski mehanizam, prikazana je na sljedeći način: duljina polja je 7, a pokazivač elements pokazuje na niz od 7 okteta s vrijednostima 53, 14, 2, 207, 163, 7, 5.

GSSAPI funkcije

GSSAPI funkcije dijele se u pet grupa: funkcije za upravljanje ispravama, funkcije za upravljanje sigurnosnim kontekstom, funkcije za podršku sigurnoj razmjeni poruka, funkcije za upravljanje imenima i pomoćne funkcije. Sve funkcije deklarirane su u datoteci zaglavlja gssapi.h, a prilikom povezivanja programa potrebno je koristiti biblioteku funkcija /usr/lib/libgssapi_krb5.so. Detaljan opis najčešće korištenih funkcija nalazi se u dodatku.

6.5. Interoperabilnost izmeñu SSPI-a i GSSAPI-a

Ukoliko se želi postići interoperabilnost izmeñu aplikacija koje koriste SSPI i GSSAPI, potrebno je pridržavati se konvencija koje obuhvaćaju imenovanje korisnika, postupak autentifikacije i zaštitu tajnosti i integriteta. Osim toga, GSSAPI zahtijeva odreñeni način korištenja meñuspremničkih struktura kojeg se SSPI aplikacija mora pridržavati ako želi postići interoperabilnost.

Imenovanje korisnika

GSSAPI funkcije za imenovanje korisnika koriste format imena gss_nt_service_name koji podržava i skraćena imena kao što je primjerice ime@host.domena.com. Operacijski sustav Windows ne prepoznaje format gss_nt_service_name i stoga je potrebno koristiti puni naziv kao što je ime/host.domena.com@PODRUCJE.DJELOVANJA.

Postupak autentifikacije

Autentifikacija izmeñu klijenta (koji koristi SSPI) i poslužitelja (koji koristi GSSAPI) odvija se na sljedeći način:

1. Klijent dohvaća referencu na izlazne (eng. outbound) isprave pozivom funkcije AcquireCredentialsHandle, dok poslužitelj kreira ime servisa pozivom funkcije GSS_Import_name i dohvaća referencu na ulazne (eng. inbound) isprave pozivom funkcije GSS_Aquire_cred.

2. Klijent pozivom funkcije InitializeSecurityContext dohvaća sigurnosnu značku i šalje ju poslužitelju.

3. Poslužitelj analizira primljenu sigurnosnu značku pozivom funkcije GSS_Accept_sec_context, generira novu značku i šalje ju nazad klijentu. Ukoliko je potrebno nastaviti, poslužitelj čeka novu značku od klijenta. U protivnom, autentifikacija je uspostavljena.

4. Prema potrebi, klijent analizira značku primljenu od poslužitelja u novom pozivu funkcije InitializeSecurityContext. Generira novu značku i šalje ju poslužitelju.

5. Postupak se ponavlja do uspostavljanja sigurnosnog konteksta.

Zaštita tajnosti i integriteta poruka

Za zaštitu tajnosti i integriteta podataka koriste se SSPI funkcije EncryptMessage i DecryptMessage i njima ekvivalentne funkcije GSS_Wrap i GSS_Unwrap. Ukoliko je riječ o digitalnom potpisivanju poruka i verifikaciji

33

potpisa (odnosno samo o zaštiti integriteta), SSPI funkcije koje se mogu koristiti su MakeSignature i VerifySignature, a njima ekvivalentne GSSAPI funkcije su GSS_Get_mic i GSS_Verify_mic. Potrebno je naglasiti da ukoliko se koristi funkcija EncryptMessage podešena samo za potpisivanje poruka, nije moguća verifikacija potpisa korištenjem funkcije GSS_Verify_mic. Isto vrijedi i za interoperabilnost izmeñu funkcija GSS_Wrap i VerifySignature.

Korištenje struktura

Da bi GSSAPI funkcija GSS_Unwrap pravilno dekriptirala poruku enkriptiranu SSPI funkcijom EncryptMessage, potrebno je na ispravan način izgraditi strukturu poruke koja se enkriptira. Struktura tipa SECBUFFER_DATA koja sadrži tekst poruke mora se nalaziti izmeñu struktura SECBUFFER_TOKEN (veličine odreñene parametrom sizes.cbSecurityTrailer) i SECBUFFER_PADDING (veličine odreñene parametrom sizes.cbBlockSize), i takvo polje struktura treba predati kao ulaz funkciji EncryptMessage. Tri enkriptirana rezultata treba ulančati i poslati kao enkriptiranu poruku. Veličine pojedinih struktura treba pribaviti pozivom funkcije QueryContextAttributes, uz parametar SECPKG_ATTR_SIZES.

Kada SSPI aplikacija primi enkriptiranu poruku od GSSAPI funkcije GSS_Wrap, treba ju pohraniti u strukturu tipa SECBUFFER_STREAM, a u polje s njom dodati strukturu tipa SECBUFFER_DATA. Takvo polje struktura se predaje kao ulaz funkciji DecryptMessage, a dekriptirani tekst će se nalaziti u strukturi SECBUFFER_DATA.

34

7. Interoperabilnost Kerberos protokola na primjeru različitih scenarija

Dvije najraširenije implementacije Kerberos protokola su MIT-eva (namijenjena prije svega UNIX i Linux sustavima) i Microsoftova (u sklopu operacijskih sustava Windows 2000, Windows XP i Windows Server 2003) i logično je interoperabilnost protokola demonstrirati upravo na njihovom primjeru.

Da bi se izbjegle nejasnoće zbog specifičnosti Microsoftove implementacije KDC-a kao sastavnog dijela domenskog upravitelja, pod pojmom Windows domene podrazumijeva se Microsoftova implementacija Kerberosa, dok se pod pojmom Kerberosa podrazumijeva MIT-eva implementacija.

7.1. Kerberos klijenti u Windows domeni

Primjer ovakvog scenarija može se pronaći u heterogenim računalnim okruženjima koja trenutno ne koriste Kerberos. Ukoliko se operacijski sustav Windows koristi za upravljanje korisničkim računima i za autentifikaciju, moguće je njegovu nadležnost proširiti i nad drugim operacijskim sustavima u svrhu povećanja njihove sigurnosti.

Biblioteke i programi za klijentsku podršku verzije 5 Kerberos protokola su raspoloživi za većinu operacijskih sustava UNIX, Linux i Mac OS. Programi kinit, klist, kdestroy i drugi iz MIT-eve distribucije Kerberosa su uspješno testirani pri radu s Microsoftovim KDC-om.

Operacijski sustavi koji nisu Windows neće moći koristiti sadržaj autorizacijskog polja Kerberos karata izdanih od strane Microsoftovog KDC-a, Kerberos biblioteke će ga ignorirati. Tako će upravljanje pravima pristupa biti prepušteno pojedinim aplikacijama, što je uostalom i slučaj s većinom servisa na Linux operacijskim sustavima. Aplikacije koje koriste GSSAPI nastavit će ispravno funkcionirati u ovakvom okruženju.

Ovakav scenarij ne pogoduje organizacijama koje imaju namjeru koristiti servise namijenjene distribuiranom računalnom okruženju (eng. Distributed Computing Environment – DCE) jer DCE biblioteke koriste autorizacijske podatke karata različito od Microsoftovog KDC-a. Takoñer, scenarij ne odgovara ukoliko se zahtijeva podrška verziji 4 Kerberos protokola, jer je u operacijskim sustavima Windows implementirana samo verzija 5.

7.2. Kerberos aplikacijski poslužitelji u Windows domeni

Pretpostavimo da u prethodno navedenom slučaju postoji Linux poslužitelj baze podataka koji podržava autentifikaciju putem Kerberosa, a želimo pristup bazi omogućiti putem web sučelja korisnicima koji već imaju pristup Windows domeni. Program Internet Explorer i Microsoftov web poslužitelj IIS (eng. Internet Information Services) podržavaju autentifikaciju korištenjem SSPI sučelja, tako da je moguće kreirati aplikaciju iz dva dijela od kojih se jedan izvršava na klijentu, a drugi na poslužitelju (eng. multi-tier application), a koja koristi Kerberos za autentifikaciju.

35

Za Linux poslužitelje potrebno je unutar domene stvoriti odgovarajuće korisničke račune. Korisno bi ih bilo stvoriti unutar posebne organizacijske jedinice unutar Active Directory-a.

Takoñer potrebno je stvoriti i ugraditi posebne datoteke, tzv. keytab datoteke na aplikacijske poslužitelje. Keytab datoteke sadrže tajni ključ poslužitelja, a kreira ih se izvoñenjem programa Ktpass.exe na Microsoftovom KDC-u. Dobivenu keytab datoteku potrebno je sigurnim putem prebaciti na odgovarajućeg poslužitelja i spojiti s postojećom Linux keytab datotekom.

7.3. Klijentski Windows sustavi u Kerberos području

Pretpostavimo scenarij u kojem je postavljeno Kerberos područje djelovanja koje osigurava sve potrebne servise i mrežne resurse, a u koji želimo uvesti računala s operacijskim sustavom Windows. Nije namjera ponuditi bilo kakve Microsoftove aplikacijske servise ili mrežne resurse, već samo koristiti postojeće.

U tom slučaju, računala s operacijskim sustavom Windows neće biti članovi Windows domene. Autentifikacija će se obavljati korištenjem KDC-a koji nije Microsoftov, preko povezivanja (eng. mapping) lokalnih korisničkih računa na svakom od strojeva sa odgovarajućim korisničkim računom Kerberos područja.

Za konfiguriranje Windows računala na raspolaganju je program Ksetup.exe. Njime se na individualnom Windows računalu mogu zapisati podaci o Kerberos području, kao i uspostaviti povezivanje lokalnog korisničkog računa.

Povezivanje lokalnog računa može se izvesti po individualnom principu, odnosno jedan lokalni korisnički račun povezati s jednim korisničkim računom Kerberos područja. Takav model nije skalabilan jedan korisnik ima potrebu za različitim funkcijama. Alternativna metoda je povezivanje više individualnih korisničkih računa iz Kerberos područja s jednim lokalnim korisničkim računom. To u mnogim okruženjima nije prigodno zbog trenutne nejednoznačne uloge korisnika.

7.4. Dijeljenje resursa izmeñu Kerberos područja i Windows domene

U mnogim okruženjima zasebno postoje Windows domene i Kerberos područja, tako se istovremeno održavaju različiti tipovi korisničkih računa. Ukoliko se pojavi potreba za korištenjem servisa iz strane domene ili područja, jednostavnije je i praktičnije iskoristiti mehanizam uspostavljanja povjerenja izmeñu domene i područja nego kreirati novi korisnički račun.

Primjerice, neki korisnici Windows domene žele iskoristiti IMAP servis iz Kerberos područja (uz pretpostavku da on podržava verziju 5 Kerberos protokola). U Kerberos području potrebno je definirati da područje vjeruje odgovarajućoj Windows domeni. Korisnici Windows domene se inicijalno autentificiraju Microsoftovom KDC-u. Kada njihova aplikacija preko SSPI sučelja želi pristupiti IMAP servisu iz Kerberos područja, SSPI biblioteke će moći u pozadini obaviti autentifikaciju izmeñu domene i područja i predočiti odgovarajuću kartu IMAP poslužitelju. Naravno, poslužitelj neće moći koristiti Microsoftove autorizacijske podatke iz karte, već će koristiti vlastite metode odreñivanja prava pristupa.

36

Ovaj scenarij pogoduje postepenom prelasku svih klijenata iz Kerberos područja u Windows domenu, odnosno prelasku na uniformni tip korisničkih računa. U Kerberos području ostaju samo korisnički računi Linux aplikacijskih poslužitelja.

7.5. Korištenje Kerberos područja kao domene za korisničke račune

Ovaj scenarij se primjenjuje na MIT-u. Sustav se sastoji od jednog Kerberos područja i jedne Windows domene izmeñu kojih je uspostavljeno povjerenje. Kerberos područje koristi se kao domena korisničkih računa, a Windows domena služi ponajprije osiguravanju autorizacijskih podataka. To znači da se korisnici inicijalno autentificiraju u Kerberos području, ali i dalje imaju funkcionalan pristup Windows domeni i svim servisima koje ona nudi.

Kerberos područje je ATHENA.MIT.EDU, koristi se za autentifikaciju unutar MIT.EDU DNS domene i nekoliko poddomena. Nova Windows domena je WINDOWS.MIT.EDU domena što znači da sada postoji WINDOWS.MIT.EDU Kerberos područje i WINDOWS.MIT.EDU poddomena. U Novoj poddomeni nalaze se samo upravitelj domene i nekoliko poslužitelja. Sve radne stanice s operacijskim sustavom Windows nalaze se u najvišem nivou MIT.EDU DNS domene. Uspostavljeno je povjerenje na način da WINDOWS.MIT.EDU domena vjeruje ATHENA.MIT.EDU području. Svaki korisnik Kerberos područja ima odgovarajući korisnički račun unutar Windows domene. To je napravljeno korištenjem atributa altSecurityIdentities unutar Active Directory-a na način da svaki Windows korisnički račun ima taj atribut ispunjen informacijama o odgovarajućem korisničkom računu iz Kerberos područja. Primjerice, Windows korisnički račun ime_korisnika@WINDOWS.MIT.EDU posjeduje altSecurityIdentities atribut koji sadrži zapis Kerberos:ime_korisnika@ATHENA.MIT.EDU.

Ovakav sustav omogućuje nekom korisniku da se prijavi na sustav koji je dio Windows domene kao neki_korisnik@ATHENA.MIT.EDU. I dalje će posjedovati TGT za kasniji pristup području ATHENA.MIT.EDU, a TGT i sjedničke karte za pristup resursima Windows domene izdavat će mu se prema potrebi. Sve karte koje se dobiju unutar Windows domene uključivat će autorizacijske podatke korisnika na temelju kojih će se odreñivati prava pristupa domenskim resursima.

Uz ovakve postavke sustava nije potrebno brinuti o usklañivanju zaporki izmeñu Windows domene i Kerberos područja. Ukoliko doñe do kompromitiranja sigurnosti unutar Windows domene, resursi unutar Kerberos područja neće biti ugroženi.

37

8. Demonstriranje interoperabilnosti Kerberos protokola pomoću klijentskih i poslužiteljskih aplikacija

Klijentske i poslužiteljske aplikacije kojima se demonstrira interoperabilnost Kerberos protokola u različitim operacijskim sustavima, ujedno demonstriraju i interoperabilnost SSPI i GSSAPI programskih sučelja. Windows aplikacije koriste SSPI sučelje, dok se u Linux okruženju koristi GSSAPI sučelje. U svakom scenariju opisan je i postupak ispravnog konfiguriranja Kerberos područja, kao preduvjet za uspješno testiranje. Kao i u prethodnom poglavlju, zbog jasnije predodžbe će se pod pojmom Windows domene podrazumijevati Microsoftova implementacija Kerberosa, dok će se pod pojmom Kerberosa podrazumijevati MIT-eva implementacija.

U testnim scenarijima koriste se operacijski sustavi Windows XP SP2 (za klijentske aplikacije), Windows Server 2003 SP1 (za poslužiteljske aplikacije i za KDC) te Fedora Core 4 (kao Linux okruženje za klijentske i poslužiteljske aplikacije te za KDC). U Linux okruženju koristi se MIT-eva implementacija verzije 5 Kerberos protokola u inačici 1.5.1. Aplikacije su napisane u programskom jeziku C++.

Pomoćni programi koji se koriste prilikom konfiguriranja testnog okruženja dio su skupine alata podrške (eng. Support Tools) i isporučuju se s operacijskim sustavom Windows Server 2003. Konkretno, riječ je o programima setspn.exe, kvno.exe, ktpass.exe i ksetup.exe.

8.1. Implementacija klijentske i poslužiteljske aplikacije

Izvorni tekstovi programa nalaze se u dodatku, a mehanizmi autentifikacije i sigurne razmjene poruka su zbog preglednosti prikazani samo pseudokodom.

8.1.1. GSSAPI poslužitelj

Pseudokod:

GSSAPI_poslužitelj() { GSS_import_name( ime_poslužiteljske_usluge ); isprave = GSS_acquire_cred(); Primi(inicijalni_token); dok( traje_opsluživanje_klijenata ) {

kontekst = 0; ponavljaj { Primi( klijent_značka );

značka,kontekst=GSS_accept_sec_context(isprave,klijent_značka); Pošalji( značka );

} dok ( !kontekst ); GSS_release_name( ime_poslužiteljske_usluge ); GSS_display_name( klijent ); GSS_release_name( klijent ); Primi ( enkriptirana_poruka ); poruka = GSS_unwrap( enkriptirana_poruka, kontekst ); digitalni_potpis_poruke = GSS_get_mic( poruka, kontekst ); Pošalji( digitalni_potpis_poruke ); GSS_delete_sec_context( kontekst );

} GSS_release_cred( isprave ); }

38

Slika 8.1: Opcije programa GSSAPI_posluzitelj

Slika 8.2: Izvoñenje programa GSSAPI_posluzitelj

8.1.2. GSSAPI klijent

Pseudokod:

GSSAPI_klijent { GSS_import_name( ime_poslužiteljske_usluge ); poslužitelj_značka = 0; kontekst = 0; Pošalji(inicijalni_token); ponavljaj { značka,kontekst=GSS_init_sec_context(isprave, poslužitelj_značka); Pošalji( značka ); Primi( poslužitelj_značka );

} dok( !kontekst ); GSS_release_name( ime_poslužiteljske_usluge ); GSS_display_name( poslužitelj ); GSS_release_name( poslužitelj ); osobine_konteksta = GSS_inquire_context( kontekst ); enkriptirana_poruka = GSS_wrap( poruka, kontekst ); Pošalji( enkriptirana_poruka ); Primi( digitalni_potpis_poruke ); GSS_verify_mic( digitalni_potpis_poruke, kontekst ); GSS_delete_sec_context( kontekst );

}

39

Slika 8.3: Opcije programa GSSAPI_klijent

Slika 8.4: Izvoñenje programa GSSAPI_klijent

8.1.3. SSPI poslužitelj

Pseudokod:

SSPI_Poslužitelj() { isprave = AcquireCredentialsHandle(); Primi(inicijalni_token); dok( traje_opsluživanje_klijenata ) {

kontekst = 0; ponavljaj { Primi( klijent_značka ); značka,kontekst=AcceptSecurityContext(isprave,klijent_značka);

40

Pošalji( značka ); } dok ( !kontekst ); osobine_konteksta = QueryContextAttributes( kontekst ); Primi ( enkriptirana_poruka ); poruka = DecryptMessage( enkriptirana_poruka, kontekst ); digitalni_potpis_poruke = MakeSignature( poruka, kontekst ); Pošalji( digitalni_potpis_poruke ); DeleteSecurityContext( kontekst );

} FreeCredentialsHandle( isprave );

}

Slika 8.5: Opcije programa SSPI_Posluzitelj

Slika 8.6: Izvoñenje programa SSPI_Posluzitelj

8.1.4. SSPI klijent

Pseudokod:

SSPI_Klijent() { isprave = AcquireCredentialsHandle(); poslužitelj_značka = 0; kontekst = 0; Pošalji(inicijalni_token); ponavljaj { značka,kontekst=InitializeSecurityContext(isprave,

poslužitelj_značka); Pošalji( značka ); Primi( poslužitelj_značka ); } dok( !kontekst );

41

FreeCredentialsHandle( isprave ); osobine_konteksta = QueryContextAttributes( kontekst ); enkriptirana_poruka = EncryptMessage( poruka, kontekst ); Pošalji( enkriptirana_poruka ); Primi( digitalni_potpis_poruke ); VerifySignature( digitalni_potpis_poruke, kontekst ); DeleteSecurityContext( kontekst );

}

Slika 8.7: Sučelje programa SSPI_Klijent

8.2. Windows domena

Unutar Windows domene svaka usluga (eng. service) koja se izvodi na poslužiteljskom računalu, a koristi Kerberos protokol za autentifikaciju, mora posjedovati jedinstveni identifikator, odnosno korisničko ime usluge (eng. Service Principal Name – u daljnjem tekstu SPN). Sastoji se od klase usluge, imena računala na kojem se izvodi i pristupne točke usluge (porta), prema formatu: klasa_usluge/ime_racunala:port. SPN je registriran u Active Directory-u kao atribut korisničkog računa u kojem se usluga izvodi. Za upravljanje SPN-ovima koristi se program setspn.exe.

Ispravno podešavanje Windows KDC-a podrazumijeva ispravno podešavanje Windows domene.

42

Testna Windows domena ima sljedeće parametre: - Naziv domene: STARJAK.LOCAL - Podrazumijevani tip enkripcije je RC4-HMAC - DNS ime upravitelja domene (ujedno i KDC-a):

vserver.starjak.local - DNS ime Windows poslužitelja: vserver.starjak.local - DNS ime Kerberos poslužitelja: krbserv.starjak.local

Razlog zbog kojeg se Windows KDC i poslužitelj nalaze na istom

računalu je isključivo praktične prirode i ne utječe na rezultate testiranja.

8.2.1. Kerberos klijent – Windows poslužitelj

Unutar Active Directory-a potrebno je stvoriti novi korisnički račun u čijem kontekstu će se izvršavati poslužiteljska aplikacija. U testnom primjeru ime korisničkog računa je posluzitelj. U opcijama korisničkog računa potrebno je označiti sljedeće:

- Korisnički račun može delegirati druge - Nije dozvoljeno delegiranje korisničkog računa - Korisnik ne može mijenjati zaporku - Zaporka nikad ne ističe

Takoñer, ukoliko želimo omogućiti autentifikaciju starijih inačica MIT-eve verzije 5 Kerberos protokola, potrebno je omogućiti i opciju:

- Korisnički račun koristi DES enkripciju Zatim, potrebno je za taj korisnički račun stvoriti SPN korištenjem programa setspn.exe:

C:\setspn -A win_servis/vserver.starjak.local posluzitelj

Sada se na Windows poslužitelju može pokrenuti test aplikacija SSPI_Posluzitelj:

C:\SSPI_Posluzitelj win_servis/vserver.starjak.local Lozinka123 STARJAK.LOCAL

Na Kerberos klijentu potrebno je u konfiguracijskoj datoteci /etc/krb5.conf

postaviti odgovarajuća imena KDC-a (vserver.starjak.local) i domene (STARJAK.LOCAL) (opširniji postupak opisan je u poglavlju o testiranju Kerberos područja). Pozivom programa kinit potrebno je pribaviti TGT za Windows KDC (pretpostavka je da korisnik s istim imenom kao i lokalni Linux korisnik postoji u Active Directory-u). Sada se može pokrenuti klijentska aplikacija GSSAPI_klijent:

$./GSSAPI_klijent vserver.starjak.local win_servis@starjak.local Poruka

8.2.2. Windows klijent – Kerberos poslužitelj

Na isti način kao i u prethodnom slučaju, unutar Active Directory-a potrebno je stvoriti novi korisnički račun u čijem kontekstu će se izvršavati poslužiteljska aplikacija. SPN se kreira naredbom:

43

C:\setspn -A kerb_servis/vserver.starjak.local posluzitelj Osim toga, potrebno je kreirati keytab datoteku korištenjem programa ktpass.exe:

C:\ktpass -out keytab.dat -princ

kerb_servis/krbserver.starjak.local@STARJAK.LOCAL –pass <zaporka> -crypto DES-CBC-CRC -ptype KRB5_NT_PRINCIPAL -kvno <kvno>

Parametar <zaporka> je zaporka korisničkog računa poslužitelj. Parametar <kvno> se dobiva izvoñenjem programa kvno.exe:

C:\kvno.exe kerb_servis/krbserver.starjak.local@STARJAK.LOCAL

Datoteku keytab.dat potrebno je na sigurni način prebaciti na Kerberos poslužitelj i zatim spojiti s postojećom keytab datotekom korištenjem programa ktutil: $ ktutil ktutil: read_kt keytab.dat ktutil: write_kt /etc/krb5.keytab ktutil: q

Sada se može pokrenuti aplikacija GSSAPI_posluzitelj na Kerberos poslužitelju,

$./GSSAPI_posluzitelj kerb_servis@krbserver.starjak.local

a zatim i aplikacija SSPI_Klijent na Windows klijentu (s imenom servisa kerb_servis/krbserver.starjak.local i imenom hosta krbserver.starjak.local).

8.2.3. Kerberos klijent – Kerberos poslužitelj

Navedeni scenarij od Kerberos poslužitelja zahtijeva isti postupak kao i u prethodnom slučaju kada je bila riječ o Windows klijentu, a od Kerberos klijenta isti postupak kao i u slučaju s Windows poslužiteljem.

8.2.4. Windows klijent – Windows poslužitelj

Iako ovaj primjer ne demonstrira interoperabilnost, izvodi se zbog kompletnosti testiranja programa. Od Windows poslužitelja se zahtijeva isti postupak kao i u slučaju kada je bila riječ o Kerberos klijentu.

8.3. Kerberos područje

Podešavanje Kerberos postavki vezanih uz KDC, klijente i poslužitelje obavlja se u datotekama /etc/krb5.conf i /var/kerberos/krb5kdc/kdc.conf (zapravo, točna lokacija druge datoteke odreñena je unutar prve). Ovdje neće biti opisan kompletni postupak instaliranja i podešavanja Kerberosa, već samo detalji bitni za zahvate nad već funkcionalnim Kerberos područjem u svrhu njegovog prilagoñavanja.

44

Datoteka /etc/krb5.conf

Unutar [realms] odjeljka parametru kdc potrebno je pridijeliti naziv KDC-a za pojedino Kerberos područje. DNS ime računala na kojem se nalazi KDC mora biti navedeno u datoteci /etc/hosts ili dostupno preko DNS poslužitelja.

Unutar [kdc] odjeljka parametar profile sadrži lokaciju datoteke kdc.conf, ona je bitna samo ukoliko je računalo ujedno i KDC.

Unutar [libdefaults] odjeljka nalaze se podrazumijevani parametri za Kerberos područje, kao što je primjerice njegov naziv odreñen parametrom default_realm. Za klijentsku aplikaciju bitni su parametri default_tgt_enctypes i default_tgs_enctypes koji sadrže podrazumijevane tipove enkripcije koji će se zahtijevati od KDC-a pri izdavanju karata (Windows operacijski sustavi podržavaju tipove enkripcija des-cbc-crc, des-cbc-md5 i rc4-hmac). Gledano od strane KDC-a, parametar permitted_enctypes omogućuje sužavanje izbora tipova enkripcija koje se koriste. Koristan je prilikom ostvarivanja interoperabilnosti s Windows klijentom kada se unatoč zahtjevu dio karte enkriptira ključem koji Windows klijent ne podržava. Eksplicitnim postavljanjem tog parametra samo na one tipove enkripcije koje Windows klijent podržava, problem se rješava.

Datoteka /var/kerberos/krb5kdc/kdc.conf

Unutar [realms] odjeljka nalazi se parametar supported_enctypes koji odreñuje sve tipove enkripcije koji su podržani u Kerberos području. Potrebno je voditi računa o njemu jer je moguće da pri nadogradnji Kerberosa na noviju verziju novi tipovi enkripcije ne budu navedeni parametrom, iako za njih postoji podrška.

Testno Kerberos područje ima sljedeće parametre: - Naziv domene: LAPTOP.KK - Podrazumijevani tip enkripcije je RC4-HMAC - DNS ime KDC-a: kerberos.laptop.kk - DNS ime Kerberos poslužitelja: kerberos.laptop.kk - DNS ime Windows klijenta: winker.laptop.kk

Razlog zbog kojeg se Kerberos KDC i poslužitelj izvode na istom računalu

je isključivo praktične prirode i ne utječe na rezultate testiranja. U testnim scenarijima nema kombinacija s Windows poslužiteljem.

Windows aplikacijski poslužitelj koristi dozvole pristupa koje se nalaze u autorizacijskom dijelu Kerberos karata, a te autorizacijske podatke zbog specifičnosti Microsoftove implementacije jedini može ispravno generirati Windows KDC, odnosno upravitelj Windows domenom i stoga ovaj scenarij nije omogućen.

8.3.1. Kerberos klijent – Kerberos poslužitelj

Iako ovaj primjer ne demonstrira interoperabilnost, izvodi se zbog kompletnosti testiranja programa.

Poslužiteljska aplikacija će pri izvoñenju registrirati uslugu imena servis@kerberos.laptop.kk koja će predstavljati korisnika Kerberos područja s punim imenom servis/kerberos.laptop.kk@LAPTOP.KK. Da bi se poslužiteljska aplikacija mogla autentificirati kao vlasnik te usluge, potrebno je kreirati keytab datoteku s punim imenom usluge i spojiti ju s podrazumijevanom keytab

45

datotekom na poslužiteljskom računalu. Naravno, poslužiteljska aplikacija mora imati pristup keytab datoteci (odnosno pristup mora imati korisnički račun u čijem kontekstu se ona izvodi). Keytab datoteka kreira se na KDC-u programom kadmin.local:

$ kadmin.local kadmin.local: ktadd servis/kerberos.laptop.kk kadmin.local: q

U slučaju da je poslužitelj na različitom računalu od KDC-a (što je i sigurnosna preporuka u realnim izvedbama), potrebno je kreirati izlaznu keytab datoteku i kasnije ju sigurnim putem prebaciti na poslužiteljsko računalo gdje ju treba spojiti s podrazumijevanom keytab datotekom: # na KDC-u

$ kadmin.local kadmin.local: ktadd –k keytab.dat servis/kerberos.laptop.kk kadmin.local: q

# na poslužitelju $ ktutil ktutil: read_kt keytab.dat ktutil: write_kt /etc/krb5.keytab ktutil: q

8.3.2. Windows klijent – Kerberos poslužitelj

Da bi uopće uključili Windows računalo u Kerberos područje, najprije je na Kerberos KDC-u potrebno stvoriti korisnički račun za računalo domaćina (eng. host). Kada se Windows korisnik bude prijavljivao u Kerberos područje, zapravo će tražiti pristup vlastitom računalu koje je predstavljeno tim korisničkim računom. Programom kadmin.local na KDC-u se lokalno upravlja Kerberos bazom korisnika:

$ kadmin.local kadmin.local: addprinc pw <zaporka> host/winker.laptop.kk kadmin.local: q

Parametar <zaporka> predstavlja zaporku računala, ona mora biti jednaka zaporki koja se postavlja u kasnijem postupku na samom Windows računalu. Podešavanje Windows računala za korištenje KDC-a koji nije Microsoftov obavlja se programom ksetup.exe. Najprije se postavljaju domena (zapravo, Kerberos područje) i KDC:

C:\ksetup /SetRealm LAPTOP.KK C:\ksetup /AddKdc LAPTOP.KK kerberos.laptop.kk

Nakon ovog koraka Windows računalo automatski prestaje biti članom Windows domene i prema Windows terminologiji postaje članom radne grupe (eng. workgroup) naziva LAPTOP.KK. DNS naziv Kerberos KDC-a mora se nalaziti u datoteci hosts koja se na Windows računalu nalazi u mapi C:\Windows\system32\drivers\etc. Sada je potrebno postaviti zaporku računala koja mora odgovarati zaporki korisničkog računa u Kerberos bazi:

46

C:\ksetup /SetComputerPassword <zaporka>

Nakon ove i svake buduće akcije koja se odnosi na promjene postavki Kerberos KDC-a ili područja, potrebno je ponovno startati operacijski sustav Windows. Naposljetku je potrebno uspostaviti preslikavanje lokalnih korisničkih računa na korisničke račune iz Kerberos područja (u ovom slučaju izmeñu win_user lokalnog korisnika i ker_user Kerberos korisnika):

C:\ksetup /MapUser ker_user@LAPTOP.KK win_user

Ukoliko su imena lokalnih korisnika i Kerberos korisnika jednaka, sljedećom naredbom se uspostavlja preslikavanje izmeñu svih istoimenih: C:\ksetup /MapUser * *

Zahtjevi koji se postavljaju pred poslužitelja jednaki su zahtjevima iz

prethodnog scenarija.

8.4. Autentifikacija izmeñu Kerberos područja i Windows domene

Najprije je potrebno uspostaviti povjerenje izmeñu Windows domene i Kerberos područja. Podrazumijeva se da uspostavljeno povjerenje neće biti tranzitivno. Ukoliko se zahtijeva tranzitivnost, na raspolaganju je program netdom.exe koji se isporučuje s operacijskim sustavom Windows Server 2003. Na upravitelju Windows domene potrebno je naznačiti lokaciju MIT-evog KDC-a (naravno, prije korištenja novih postavki potrebno je ponovo pokrenuti operacijski sustav):

C:\ksetup /AddKdc LAPTOP.KK kerberos.laptop.kk

Zatim, potrebno je pokrenuti alat za upravljanje domenom: "Start" → "Programs" → "Administrative Tools" → "Active Directory Domains and Trusts" U osobinama Windows domene (eng. Properties) u odjeljku gdje su navedena povjerenja (eng. Trusts), klikom na tipku "New Trust" pokreće se interaktivni postupak za dodavanje povjerenja prema Kerberos području LAPTOP.KK. Na MIT-evom KDC-u potrebno je unutar Kerberos područja dodati dva nova korisnička računa koji će predstavljati posrednike izmeñu Windows domene i Kerberos područja: $ kadmin.local kadmin.local: addprinc pw <lozinka1> krbtgt/STARJAK.LOCAL@LAPTOP.KK kadmin.local: addprinc pw <lozinka2> krbtgt/LAPTOP.KK@STARJAK.LOCAL kadmin.local: q

Sada kad je uspostavljeno povjerenje, moguće je ponovo testirati već navedene kombinacije klijenata i poslužitelja, uz jednake zahtjeve koji su se pred njih postavljali.

47

9. Zaključak

Verzija 5 Kerberos protokola predstavlja veliki korak naprijed naspram verzije 4, kako u sigurnosnom pogledu, tako i u pogledu primjenjivosti u raznovrsnim okruženjima. Otvorenost standarda i mogućnost korištenja protokola putem generičkih autentifikacijskih sučelja osiguravaju veliku bazu mrežnih organizacija koje će odabrati upravo Kerberos za vlastiti autentifikacijski protokol. Takoñer, daljnji razvoj i unaprjeñenja nisu sputani tako da je primjena Kerberosa kao najozbiljnijeg sustava autentifikacije izgledna kroz duže vrijeme.

Što se tiče interoperabilnosti, potpuna interoperabilnost ne može biti deklarirana niti od strane izdavača nekog sustava, niti specificirana bilo kakvim standardom. Prava mjera interoperabilnosti može biti dana jedino od strane pojedinog korisnika protokola kao odgovor na pitanje: "Odgovara li sustav mojim potrebama?". Ukoliko se zanemare vrlo specifično postavljena pitanja tipa: "Može li se ostvariti puna funkcionalnost Windows domene bez korištenja Microsoftovog KDC-a?" (što je ionako nerealno očekivati da će Microsoft ikad omogućiti), može se doći do zaključka da je Microsoftova implementacija Kerberosa u velikoj mjeri interoperabilna s drugim implementacijama (posebno MIT-evom), kao što se vidi na primjeru konkretnih scenarija.

48

10. Literatura

Internet:

• Massachusetts Institute of Technology: "Kerberos: The Network Authentication Protocol", URL: http://web.mit.edu/Kerberos/

• John T. Kohl, B. Clifford Neuman, Theodore Y. Ts'o: "The Evolution of Kerberos Authentication Service", PS dokument, URL:<ftp://athena-dist.mit.edu/pub/kerberos/doc/krb_evol.PS>

• Paul B. Hill, "Kerberos Interoperability Issues", PDF dokument, URL:http://www.usenix.org/events/lisa-nt2000/hill/hill.pdf

• Microsoft: "Kerberos Authentication in Windows Server 2003" http://www.microsoft.com/windowsserver2003/technologies/security/kerberos

• Microsoft TechNet: "Windows 2000 Kerberos Authentication", URL:http://www.microsoft.com/technet/prodtechnol/windows2000serv/deploy/confeat/kerberos.mspx

• Microsoft TechNet: "Windows 2000 Step-by-Step Guide to Kerberos 5 Interoperability", URL:http://www.microsoft.com/technet/prodtechnol/windows2000serv/howto/kerbstep.mspx

• Microsoft TechNet: "Troubleshooting Kerberos Errors", URL:http://www.microsoft.com/technet/prodtechnol/windowsserver2003/technologies/security/tkerberr.mspx

• Keith Brown, "Security briefs: Explore the Security Support Provider Interface", URL:http://msdn.microsoft.com/msdnmag/issues/0800/security/default.aspx, 2000.

• Keith Brown, "Security briefs: The Security Support Provider Interface Revisited", URL:http://msdn.microsoft.com/msdnmag/issues/01/04/Security/default.aspx, 2001.

• IETF: "RFC 2744 - Generic Security Service API Version 2 : C-bindings" URL:ftp://ftp.rfc-editor.org/in-notes/rfc2744.txt

• "RFC Index" URL:http://www.rfc-editor.org

• “MSDN Library” URL:http://msdn.microsoft.com/library

49

Dodatak A: Popis slika

Slika 1.1: Cerberus............................................................................................. 1 Slika 2.1: Struktura sjedničke karte .................................................................... 5 Slika 3.1: Komunikacija klijent - autentifikacijski servis....................................... 8 Slika 3.2: Komunikacija klijent – servis za izdavanje sjedničkih karata .............. 9 Slika 3.3: Komunikacija klijent - poslužitelj ....................................................... 10 Slika 3.4: Autentifikacija meñu različitim domenama........................................ 11 Slika 6.1: Kerberos autentifikacija preko SSPI-a .............................................. 30 Slika 8.1: Opcije programa GSSAPI_posluzitelj ............................................... 38 Slika 8.2: Izvoñenje programa GSSAPI_posluzitelj .......................................... 38 Slika 8.3: Opcije programa GSSAPI_klijent...................................................... 39 Slika 8.4: Izvoñenje programa GSSAPI_klijent................................................. 39 Slika 8.5: Opcije programa SSPI_Posluzitelj .................................................... 40 Slika 8.6: Izvoñenje programa SSPI_Posluzitelj............................................... 40 Slika 8.7: Sučelje programa SSPI_Klijent......................................................... 41

50

Dodatak B: SSPI strukture i funkcije

Strukture

SecBufferDesc

Opis strukture

Struktura opisuje polje struktura tipa SecBuffer koje sadrže podatke koje transportna aplikacija predaje sigurnosnom paketu.

Deklaracija strukture

typedef struct _SecBufferDesc { ULONG ulVersion; ULONG cBuffers; PSecBuffer pBuffers; } SecBufferDesc, *PSecBufferDesc;

ulVersion Odreñuje verziju ove strukture, mora biti postavljen na vrijednost SECBUFFER_VERSION.

cBuffers Odreñuje broj struktura tipa SecBuffer na koje pokazuje parametar pBuffers.

Članovi strukture

pBuffers Pokazivač na polje struktura tipa SecBuffer.

SecBuffer

Opis strukture

Struktura opisuje jedan od meñuspremnika s podacima koje transportna aplikacija predaje sigurnosnom paketu.

Deklaracija strukture

typedef struct _SecBuffer { ULONG cbBuffer; ULONG BufferType; PVOID pvBuffer; } SecBuffer, *PSecBuffer; cbBuffer Odreñuje veličinu meñuspremnika (izraženu u

bajtovima) na koji pokazuje parametar pvBuffer. Članovi strukture

BufferType Zastavice koje odreñuju tip meñuspremnika. Moraju biti postavljene na jednu od sljedećih vrijednosti: SECBUFFER_EMPTY – ovaj meñuspremnik služi čuvanju mjesta u polju meñuspremnika, najčešće za interne potrebe SSP-a; SECBUFFER_DATA – ovaj tip se koristi za uobičajene podatke, primjerice poruku koju SSP treba enkriptirati ili dekriptirati; SECBUFFER_TOKEN – meñuspremnik služi prenošenju sigurnosne značke, dozvoljeno je samo čitanje za ulazne parametre, a čitanje i pisanje za izlazne; SECBUFFER_PKG_PARAMS – meñuspremnik sadrži podatke vezane uz specifične SSP-ove; SECBUFFER_MISSING – SSP koristi ovaj parametar da označi broj bajtova koji nedostaju u poruci, za ovaj tip se ignorira pvBuffer parametar; SECBUFFER_EXTRA – SSP koristi ovaj parametar da označi broj bajtova u poruci koji su višak ili nisu obrañeni;

51

SECBUFFER_STREAM_TRAILER – meñuspremnik sadrži završne podatke vezane uz protokol (najčešće nije od koristi pozivatelju); SECBUFFER_STREAM_HEADER – meñuspremnik sadrži zaglavlje podataka vezano uz protokol (najčešće nije od koristi pozivatelju); SECBUFFER_MECHLIST – meñuspremnik sadrži listu identifikatora objekata vezanu uz protokol (najčešće nije od koristi pozivatelju); SECBUFFER_MECHLIST_SIGNATURE - meñuspremnik sadrži potpis meñuspremnika SECBUFFER_MECHLIST (najčešće nije od koristi pozivatelju); SECBUFFER_TARGET – rezervirani meñuspremnik, ne smije se koristiti; SECBUFFER_CHANNEL_BINDINGS - meñuspremnik sadrži informacije o povezivanju Kerberos kanala; SECBUFFER_ATTRMASK - meñuspremnik sadrži masku bitova za meñuspremnik tipa SECBUFFER_READONLY_WITH_CHECKSUM; Dodatno, svaka od navedenih zastavica može se kombinirati sa jednom od sljedećih zastavica: SECBUFFER_READONLY – meñuspremnik je namijenjen samo čitanju i ne sadrži sažetak, namjena mu je slanje informacije zaglavlja SSP-u koja služi računanju sažetka, SSP može samo čitati iz meñuspremnika, a ne i pisati u njega; SECBUFFER_READONLY_WITH_CHECKSUM – meñuspremnik je moguće samo čitati i sadrži sažetak.

pvBuffer Pokazivač na meñuspremnik s podacima.

Funkcije za upravljanje sigurnosnim paketima

Ove funkcije namijenjene su pregledu dostupnih sigurnosnih paketa i ispitivanju atributa pojedinih paketa.

EnumerateSecurityPackages

Opis funkcije

Funkcija vraća polje struktura tipa SecPkgInfo koje opisuju dostupne sigurnosne pakete

Prototip funkcije

SECURITY_STATUS SEC_Entry EnumerateSecurityPackages( PULONG pcPackages, PSecPkgInfo* ppPackageInfo ); pcPackages Pokazivač na varijablu tipa ULONG u koju se

pohranjuje broj dostupnih sigurnosnih paketa Izlazni

parametri ppPackageInfo Pokazivač na varijablu koja prima pokazivač na

polje struktura tipa SecPkgInfo. Svaka struktura

52

sadržava podatke o odgovarajućem SSP-u, kao što su ime i mogućnosti koje nudi.

Povratne vrijednosti

Po uspješnom izvršavanju funkcija vraća vrijednost SEC_E_OK. Inače, vraća kod greške različit od nule.

Napomene Odabir sigurnosnog paketa može se obaviti prosljeñivanjem Name člana strukture SecPkgInfo funkciji AcquireCredentialsHandle. Nakon što je završena upotreba meñuspremnika na koji pokazuje ppPackageInfo, potrebno ga je osloboditi pozivom funkcije FreeContextBuffer.

InitSecurityInterface

Opis funkcije

Funkcija vraća pokazivač na SSPI tablicu usmjeravanja koja sadržava pokazivače na sve SSPI funkcije. Na taj način klijentu je omogućeno korištenje SSPI-a bez direktnog povezivanja s implementacijom sučelja.

Prototip funkcije

PSecurityFunctionTable SEC_Entry InitSecurityInterface( void);

Povratne vrijednosti

Po uspješnom izvršavanju funkcija vraća pokazivač na strukturu tipa SecurityFunctionTable. Inače, vraća vrijednost NULL.

QuerySecurityPackageInfo

Opis funkcije

Funkcija dohvaća informacije o zadanom sigurnosnom paketu. Informacije uključuju zadane granice veličina autentifikacijskih informacija, isprava i sigurnosnog konteksta.

Prototip funkcije

SECURITY_STATUS SEC_Entry QuerySecurityPackageInfo( SEC_CHAR* pszPackageName, PSecPkgInfo* ppPackageInfo);

Ulazni parametri

pszPackageName Pokazivač na niz znakova ograničen nul-vrijednošću koji odreñuje ime sigurnosnog paketa.

Izlazni parametri

ppPackageInfo Pokazivač na varijablu koja prima pokazivač na strukturu tipa SecPkgInfo.

Povratne vrijednosti

Po uspješnom izvršavanju funkcija vraća vrijednost SEC_E_OK. Inače, vraća kod greške različit od nule.

Napomene Nakon što je završena upotreba meñuspremnika na koji pokazuje ppPackageInfo, potrebno ga je osloboditi pozivom funkcije FreeContextBuffer.

Funkcije za upravljanje ispravama

Korištenjem ovih funkcija moguće je pribaviti i otpustiti referencu na korisnikove isprave koje su predstavljene sigurnosnim objektom. Aplikacija koja koristi isprave nema pristup stvarnom sadržaju sigurnosnog objekta, već samo referenci na objekt, tako da se objekt može nazvati neprozirnim (eng. opaque). Pristup sadržaju objekta ima isključivo sigurnosni paket kojem se predaje referenca. Aplikacije se služe referencom na isprave prilikom kreiranja sigurnosnog konteksta.

53

AcquireCredentialsHandle

Opis funkcije

Funkcija dohvaća referencu na postojeće sigurnosne isprave odgovarajućeg korisnika ili autonomnog procesa. Te reference zahtijevaju funkcije InitializeSecurityContext i AcceptSecurityContext tijekom autentifikacijskog procesa. Navedene isprave mogu biti već stvorene tijekom prijavljivanja na sustav ili pozivatelj funkcije može priložiti alternativne isprave.

Prototip funkcije

SECURITY_STATUS SEC_Entry AcquireCredentialsHandle( SEC_CHAR* pszPrincipal, SEC_CHAR* pszPackage, ULONG fCredentialUse, PLUID pvLogonID, PVOID pAuthData, SEC_GET_KEY_FN pGetKeyFn, PVOID pvGetKeyArgument, PCredHandle phCredential, PTimeStamp ptsExpiry ); pszPrincipal Pokazivač na niz znakova ograničen nul-

vrijednošću koji odreñuje ime korisnika na čije isprave će biti vraćena referenca.

pszPackage Pokazivač na niz znakova ograničen nul-vrijednošću koji odreñuje ime sigurnosnog paketa. Ime paketa je odreñeno Name članom strukture SecPkgInfo koja je vraćena pozivom funkcije EnumerateSecurityPackages.

fCredentialUse Zastavica koja odreñuje na koji način će isprave biti korištene. Može biti postavljena kao: SECPKG_CRED_OUTBOUND – klijentu se omogućava kreiranje izlazne sigurnosne značke (pri pozivu funkcije InitializeSecurityContext); SECPKG_CRED_INBOUND – omogućava se provjera poslužiteljevih isprava od strane autentifikacijskog sustava (pri pozivu funkcije AcceptSecurityContext); SECPKG_CRED_BOTH – postavlja obje prethodno navedene zastavice.

pvLogonID Pokazivač na jedinstveni lokalni identifikator (eng. local unique identifier - LUID) koji odreñuje korisnika. Može biti postavljen na NULL.

pAuthData Pokazivač na podatke ovisne o sigurnosnom paketu. Ukoliko je postavljen na NULL, pretpostavlja se korištenje podrazumijevanih isprava. Ukoliko se želi priložiti alternativne isprave, ovdje se treba proslijediti struktura tipa SEC_WINNT_AUTH_IDENTITY koja sadrži te isprave.

Ulazni parametri

pGetKeyFn Parametar se ne koristi i mora biti postavljen

54

na NULL. pvGetKeyArgument Parametar se ne koristi i mora biti postavljen

na NULL. phCredential Pokazivač na strukturu tipa CredHandle u

koju se pohranjuje referenca na isprave. Izlazni

parametri ptsExpiry Pokazivač na strukturu tipa TimeStamp u koju

se zapisuje vrijeme isteka valjanosti isprava. Povratne vrijednosti

Po uspješnom izvršavanju funkcija vraća vrijednost SEC_E_OK. Inače, vraća jedan od sljedećih kodova greške: SEC_E_INSUFFICIENT_MEMORY – nedovoljno memorije za obavljanje zadane operacije; SEC_E_INTERNAL_ERROR – pojavljivanje greške koja ne odgovara greškama iz SSPI sustava; SEC_E_NO_CREDENTIALS – nema dostupnih isprava za odabrani sigurnosni paket; SEC_E_NOT_OWNER – pozivatelj funkcije ne posjeduje odgovarajuće ovlasti za izdavanje isprava (npr. ukoliko zahtijeva izdavanje isprava drugog korisnika); SEC_E_SECPKG_NOT_FOUND – navedeni sigurnosni paket ne postoji; SEC_E_UNKNOWN_CREDENTIALS – dostavljene isprave nisu prepoznate.

Napomene U pravilu, funkcija ne dozvoljava procesu dohvaćanje isprava drugih korisnika koji su prijavljeni na isto računalo. No, ukoliko pozivatelj funkcije posjeduje privilegiju SE_TCB_NAME, može kroz parametar pvLogonID dohvatiti isprave bilo koje trenutne korisničke sjednice. U takvim slučajevima pozivatelj je najčešće komponenta jezgre operacijskog sustava koja iz nekog razloga mora obaviti neki posao u ime korisnika prijavljenog na sustav. Po završetku korištenja isprava, potrebno je osloboditi memoriju pozivom funkcije FreeCredentialsHandle.

ExportSecurityContext

Opis funkcije

Funkcija kreira serijalizirani prikaz (niz nula i jedinica pogodan za serijski prijenos) sigurnosnog konteksta kojeg je kasnije moguće uvesti u drugi proces pozivom funkcije ImportSecurityContext. Drugi proces mora se izvoditi na istom računalu kao i proces koji je pozvao funkciju ExportSecurityContext.

Prototip funkcije

SECURITY_STATUS SEC_Entry ExportSecurityContext( PCtxtHandle phContext, Ulong fFlags, PSecBuffer pPackedContext, HANDLE* pToken ); phContext Referenca na sigurnosni kontekst koji treba

eksportirati. Ulazni

parametri fFlags Ovaj parametar može biti rezultat ILI operacije

nad sljedećim bitovima: SECPKG_CONTEXT_EXPORT_RESET_NEW – novi sigurnosni kontekst je postavljen u

55

početno stanje; SECPKG_CONTEXT_EXPORT_DELETE_OLD – stari sigurnosni kontekst se briše;

pPackedContext Pokazivač na meñuspremnik tipa SECBUFFER_EMPTY u koji se sprema serijalizirani prikaz sigurnosnog konteksta.

Izlazni parametri

pToken Pokazivač za primanje reference na sigurnosnu značku konteksta. Korištenje je opcionalno.

Povratne vrijednosti

Po uspješnom izvršavanju funkcija vraća vrijednost SEC_E_OK. Inače, vraća jedan od sljedećih kodova greške: SEC_E_INSUFFICIENT_MEMORY – nedovoljno memorije za obavljanje zadane operacije; SEC_E_INVALID_HANDLE – parametar phContext ne pokazuje na valjanu referencu; SEC_E_NOT_SUPPORTED – Schanell režim rada ne podržava funkciju eksportiranja.

Napomene Po završetku rada, memoriju na koju pokazuju parametri pPackedCotext i pToken potrebno je osloboditi korištenjem funkcija FreeContextBuffer i CloseHandle, respektivno.

FreeCredentialsHandle

Opis funkcije

Funkcija obavještava sigurnosni paket da isprave više nisu potrebne. Njenim pozivom oslobaña se referenca na isprave dobivena pozivom funkcije AcquireCredentialsHandle. Potrebno je izbrisati sve reference na odgovarajuće isprave prije nego što se izbrišu i same isprave. U protivnom, doći će do pojave istjecanja memorije (eng. memory leaks).

Prototip funkcije

SECURITY_STATUS SEC_Entry FreeCredentialsHandle( PCredHandle phCredential );

Ulazni parametri

phCredential Pokazivač na referencu na isprave koja se dobila pozivom funkcije AcquireCredentialsHandle.

Povratne vrijednosti

Po uspješnom izvršavanju funkcija vraća vrijednost SEC_E_OK. Inače, vraća kod greške SEC_E_INVALID_HANDLE, koji označava neispravnost proslijeñene reference na isprave.

Napomene Funkcija omogućuje sigurnosnom sustavu oslobañanje svih resursa vezanih uz referencu na isprave. Prije poziva ove funkcije, aplikacija bi trebala pozvati funkciju DeleteSecurityContext da bi oslobodila sve reference na kontekst povezan s ispravama.

ImportSecurityContext

Opis funkcije

Funkcija u trenutni proces uvodi sigurnosni kontekst prethodno eksportiran funkcijom ExportSecurityContext.

Prototip funkcije

SECURITY_STATUS SEC_Entry ImportSecurityContext( PSECURITY_STRING* pszPackage, PSecBuffer pPackedContext, HANDLE pToken, PCtxtHandle phContext );

56

pszPackage Niz znakova koji sadrži ime sigurnosnog paketa u koji je eksportiran sigurnosni kontekst.

pPackedContext Pokazivač na meñuspremnik koji sadrži serijalizirani prikaz prethodno eksportiranog sigurnosnog konteksta.

Ulazni parametri

pToken Referenca na sigurnosnu značku konteksta. Koristi se opcionalno.

Izlazni parametri

phContext Referenca na novouspostavljeni sigurnosni kontekst.

Povratne vrijednosti

Po uspješnom izvršavanju funkcija vraća vrijednost SEC_E_OK. Inače, vraća jedan od sljedećih kodova greške: SEC_E_INSUFFICIENT_MEMORY – nedovoljno memorije za obavljanje zadane operacije; SEC_E_INTERNAL_ERROR – pojavljivanje greške koja ne odgovara greškama iz SSPI sustava; SEC_E_NO_CREDENTIALS – nema dostupnih isprava za odabrani sigurnosni paket; SEC_E_NOT_OWNER – pozivatelj funkcije ne posjeduje odgovarajuće ovlasti za izdavanje isprava (npr. ukoliko zahtijeva izdavanje isprava drugog korisnika); SEC_E_UNKNOWN_CREDENTIALS – dostavljene isprave nisu prepoznate.

Napomene Po završetku korištenja konteksta odreñenog parametrom phContext, potrebno je osloboditi zauzetu memoriju pozivom funkcije DeleteSecurityContext

QueryCredentialsAttributes

Opis funkcije

Funkcija dostavlja osobine isprava, primjerice koje ime je vezano uz njih. Informacija je valjana za svaki sigurnosni kontekst koji je kreiran pomoću navedenih isprava.

Prototip funkcije

SECURITY_STATUS SEC_Entry QueryCredentialsAttributes( PCredHandle phCredential, ULONG ulAttribute, PVOID pBuffer );

phCredential Referenca na isprave nad kojima treba vršiti upit. Ulazni parametri ulAttribute Parametar odreñuje nad kojim atributom isprava

će se vršiti upit. Jedini atribut bitan za Kerberos jest SECPKG_CRED_ATTR_NAMES, on odreñuje da se vrši upit nad imenom, rezultat se vraća u parametar pBuffer kao tip SecPkgCredentials_Names.

Izlazni parametri

pBuffer Pokazivač na meñuspremnik koji prima traženi atribut. Tip i struktura ovisi o vrijednosti parametra ulAttribute.

Povratne vrijednosti

Po uspješnom izvršavanju funkcija vraća vrijednost SEC_E_OK. Inače, vraća jedan od sljedećih kodova greške: SEC_E_INVALID_HANDLE – neispravnost proslijeñene reference na isprave;

57

SEC_E_INSUFFICIENT_MEMORY – nedovoljno memorije za obavljanje zadane operacije;

Napomene Pozivatelj funkcije mora sam rezervirati memoriju za meñuspremnik na koji pokazuje pBuffer. Sigurnosni paket rezervira memoriju za sve pokazivače koji se vraćaju u pBuffer meñuspremnik. Pozivatelj funkcije mora osloboditi svu memoriju koju je zauzeo sigurnosni paket pozivima funkcije FreeContextBuffer.

Funkcije za upravljanje sigurnosnim kontekstom

Pri uspostavljanju veze izmeñu klijenta i poslužitelja, pregovaranjem izmeñu obje strane stvara se zajednički sigurnosni kontekst. Sigurnosni kontekst predstavlja sigurnosne atribute, odnosno sigurnosna pravila koja su trenutno na snazi (primjerice sjednički ključ i odreñeno trajanje veze). Sigurnosni kontekst je predstavljen sigurnosnim neprozirnim objektom, odnosno aplikacija nema pristup njegovom sadržaju. Funkcije za upravljanje sigurnosnim kontekstom koriste samo reference na objekt, a za pristup stvarnom sadržaju zadužen je sigurnosni paket (odgovarajući SSP).

AcceptSecurityContext

Opis funkcije

Funkcija omogućuje poslužiteljskoj komponenti transportne aplikacije uspostavljanje sigurnosnog konteksta izmeñu poslužitelja i udaljenog klijenta. Klijent započinje postupak uspostave sigurnosnog konteksta pozivom funkcije InitializeSecurityContext. Poslužitelj prije završetka postupka može zahtijevati jedan ili više odgovora od klijenta u vidu sigurnosnih značaka.

Prototip funkcije

SECURITY_STATUS SEC_Entry AcceptSecurityContext( PCredHandle phCredential, PCtxtHandle phContext, PSecBufferDesc pInput, ULONG fContextReq, ULONG TargetDataRep, PCtxtHandle phNewContext, PSecBufferDesc pOutput, PULONG pfContextAttr, PTimeStamp ptsTimeStamp );

phCredential Referenca na isprave poslužitelja dobivena pozivom funkcije AcquireCredentialsHandle uz postavljenu zastavicu SECPKG_CRED_INBOUND ili SECPKG_CRED_BOTH.

pInput Pokazivač na strukturu tipa SecBufferDesc generiranu od strane klijenta pri pozivu funkcije InitializeSecurityContext, sadrži opisnik ulaznog meñuspremnika.

Ulazni parametri

fContextReq Skup zastavica (odreñuju se prefiksom ASC_REQ) koje predstavljaju osobine konteksta koje zahtijeva poslužitelj, moguće ih je

58

kombinirati ILI operacijom nad bitovima: ASC_REQ_CONFIDENTIALITY – poruke se enkriptiraju i dekriptiraju; ASC_REQ_CONNECTION – sigurnosni kontekst nije odgovoran za format poruka; ASC_REQ_DELEGATE – poslužitelju je dozvoljeno predstavljanje u ime klijenta; ASC_REQ_EXTENDED_ERROR – u slučaju greške, obavještava se i druga strana; ASC_REQ_INTEGRITY – poruke se potpisuju i potpisi se verificiraju; ASC_REQ_MUTUAL_AUTH – klijent je dužan predočiti certifikat koji se koristi za njegovu autentifikaciju; ASC_REQ_REPLAY_DETECT – otkrivanje ponovno poslanih paketa; ASC_REQ_SEQUENCE_DETECT – otkrivanje poruka primljenih izvan redoslijeda.

TargetDataRep Parametar odreñuje prikaz podataka na ciljanom sustavu, kao što je primjerice poredak bajtova. Može biti ili SECURITY_NATIVE_DREP ili SECURITY_NETWORK_DREP.

ptsTimeStamp Pokazivač na varijablu koja sadrži set zastavica koje predstavljaju atribute uspostavljenog konteksta. Zastavice koje se koriste s ovim parametrom imaju prefiks ASC_RET, za razliku od onih navedenih fContextReq parametrom, koje imaju prefiks ASC_REQ.

Izlazni parametri

ptsTimeStamp Pokazivač na strukturu podataka tipa TimeStamp u koju se vraća vrijeme isteka valjanosti konteksta.

phContext Pokazivač na strukturu tipa CtxtHandle. Prilikom prvog poziva funkcije, ovaj pokazivač je postavljen na NULL. U kasnijim pozivima sadržava referencu na djelomično kreirani kontekst koji je nakon prvog poziva funkcije vraćen parametrom phNewContext.

phNewContext Pokazivač na strukturu tipa CtxtHandle. Prilikom prvog poziva funkcije, ovaj pokazivač prima novu referencu konteksta. U kasnijim pozivima ta referenca može biti ista kao referenca navedena u parametru phContext.

Ulazno-izlazni

parametri

pOutput Pokazivač na strukturu tipa SecBufferDesc koja sadrži opisnik izlaznog meñuspremnika. Ovaj meñuspremnik se šalje klijentu kao ulaz u dodatnim pozivima funkciji InitializeSecurityContext. Svaki novi generirani meñuspremnik mora biti poslan natrag klijentu.

Povratne vrijednosti

Po uspješnom izvršavanju funkcija vraća sljedeće vrijednosti: SEC_E_OK – sigurnosni kontekst s klijentom je uspostavljen,

59

ukoliko je generirana izlazna sigurnosna značka, treba ju proslijediti klijentu; SEC_I_COMPLETE_NEEDED – poslužitelj mora dovršiti izgradnju poruke poslane od klijenta i zatim pozvati funkciju CompleteAuthToken; SEC_I_CONTINUE_NEEDED – poslužitelj mora poslati izlaznu značku klijentu i čekati na novu značku od klijenta koju treba proslijediti preko parametra pInput novom pozivu funkcije AcceptSecurityContext; SEC_I_COMPLETE_AND_CONTINUE – poslužitelj mora pozvati funkciju CompleteAuthToken i proslijediti izlaznu značku klijentu te potom čekati na odgovor klijenta i ponovno pozvati funkciju AcceptSecurityContext. U slučaju greške, funkcija vraća jedan od sljedećih kodova: SEC_E_INVALID_HANDLE – proslijeñena reference na isprave nije valjana; SEC_E_INSUFFICIENT_MEMORY – nedovoljno memorije za obavljanje zadane operacije; SEC_E_INTERNAL_ERROR – pojavljivanje greške koja ne odgovara greškama iz SSPI sustava; SEC_E_INVALID_TOKEN – proslijeñena sigurnosna značka nije valjana; SEC_E_LOGON_DENIED – prijavljivanje na sustav nije uspjelo; SEC_E_NO_AUTHENTICATING_AUTHORITY – zbog nekog razloga nije moguće kontaktirati KDC (neispravno ime domene, nedostupna domena, nije moguće uspostaviti povjerljivu vezu).

Napomene Ukoliko kontekst nije mogao biti uspostavljen, poslužitelj mora osloboditi djelomično stvoreni kontekst pozivom funkcije DeleteSecurityContext. Nakon što je sigurnosni kontekst uspostavljen, poslužitelj može pozivom funkcije QuerySecurityContextToken dohvatiti referencu na korisnički račun s kojim je povezan klijentov certifikat. Takoñer, poslužitelj se može predstaviti kao klijent pozivom funkcije ImpersonateSecurityContext.

DeleteSecurityContext

Opis funkcije

Funkcija briše lokalno kreirane strukture podataka povezane sa sigurnosnim kontekstom.

Prototip funkcije

SECURITY_STATUS SEC_Entry DeleteSecurityContext( PCtxtHandle phContext );

Ulazni parametri

phContext Referenca na sigurnosni kontekst koji treba izbrisati.

Povratne vrijednosti

Po uspješnom izvršavanju funkcija vraća vrijednost SEC_E_OK. Inače, vraća kod greške SEC_E_INVALID_HANDLE, koji označava neispravnost proslijeñene reference na isprave.

Napomene Nakon poziva funkcije uništava se sigurnosni kontekst. Svaka daljnja uporaba konteksta nakon što je uništen nije dozvoljena.

60

Ukoliko inicijalni pozivi funkcijama InitializeSecurityContext i AcceptSecurityContext uspiju, naposljetku će trebati pozvati funkciju DeleteSecurityContext, čak i ukoliko kasniji pozivi navedenim funkcijama iz nekog razloga vrate grešku i konačni kontekst ne bude uspostavljen.

FreeContextBuffer

Opis funkcije

Funkcija omogućava pozivatelju oslobañanje memorije zauzete od strane SSP-a pri inicijalizaciji meñuspremnika nakon poziva funkcija InitializeSecurityContext i AcceptSecurityContext.

Prototip funkcije

SECURITY_STATUS SEC_Entry FreeContextBuffer( PVOID pvContextBuffer );

Ulazni parametri

pvContextBuffer Pokazivač na memoriju koju je rezervirao SSP.

Povratne vrijednosti

Po uspješnom izvršavanju funkcija vraća vrijednost SEC_E_OK. Inače, vraća kod greške različit od nule.

Napomene Funkcija može osloboditi bilo koju memoriju koju je rezervirao SSP.

ImpersonateSecurityContext

Opis funkcije

Funkcija omogućuje poslužitelju da se predstavlja kao klijent korištenjem sigurnosne značke koju je prethodno dobio pozivom funkcije AcceptSecurityContext ili QuerySecurityContextToken. Prilikom utjelovljivanja klijenta, provodi se odgovarajuća kontrola pristupa.

Prototip funkcije

SECURITY_STATUS SEC_Entry ImpersonateSecurityContext( PCtxtHandle phContext );

Ulazni parametri

phContext Referenca na kontekst koji treba predstavljati.

Povratne vrijednosti

Po uspješnom izvršavanju funkcija vraća vrijednost SEC_E_OK. Inače, vraća jedan od sljedećih kodova greške: SEC_E_INVALID_HANDLE – neispravnost proslijeñene reference na isprave; SEC_E_NO_IMPERSONATION – nije bilo moguće predstavljati se kao klijent.

Napomene Ukoliko funkcija dojavi pogrešku, odnosno ukoliko predstavljanje kao klijent ne uspije, program se nastavlja izvršavati u sigurnosnom kontekstu poslužitelja, tako da ukoliko se radi o procesu sa posebnim ovlastima, klijentu mogu biti dozvoljene radnje za koje inače nema ovlasti. Zbog toga proces koji poziva ovu funkciju uvijek mora provjeriti povratnu vrijednost te uskratiti bilo kakve akcije klijentu ukoliko predstavljanje ne uspije.

InitializeSecurityContext

Opis Funkcija sliži kreiranju sigurnosnog konteksta s klijentove strane

61

funkcije na temelju reference na klijentove isprave. Pozivom funkcije generira se sigurnosna značka koja se šalje poslužitelju, koji ju prosljeñuje svom SSP-u pozivom funkcije AcceptSecurityContext.

Prototip funkcije

SECURITY_STATUS SEC_Entry InitializeSecurityContext( PCredHandle phCredential, PCtxtHandle phContext, SEC_CHAR* pszTargetName, ULONG fContextReq, ULONG Reserved1, ULONG TargetDataRep, PSecBufferDesc pInput, ULONG Reserved2, PCtxtHandle phNewContext, PSecBufferDesc pOutput, PULONG pfContextAttr, PTimeStamp ptsExpiry );

phCredential Referenca na isprave klijenta dobivena pozivom funkcije AcquireCredentialsHandle uz postavljenu zastavicu SECPKG_CRED_OUTBOUND.

pszTargetName Pokazivač na niz znakova ograničen nul-vrijednošću koji odreñuje ime prema kojem klijent identificira uslugu na poslužitelju (eng. service principal name - SPN) ili sigurnosni kontekst na odredišnom poslužitelju.

Ulazni parametri

fContextReq Skup zastavica (odreñuju se prefiksom ISC_REQ) koje predstavljaju zahtjeve nad kontekstom koji se uspostavlja, moguće ih je kombinirati ILI operacijom nad bitovima: ISC_REQ_ALLOCATE_MEMORY – sigurnosni kontekst se brine za rezerviranje memorije namijenjene izlaznim spremnicima (po završetku rada potrebno je osloboditi memoriju korištenjem funkcije FreeContextBuffer); ISC_REQ_CONFIDENTIALITY – poruke se enkriptiraju i dekriptiraju; ISC_REQ_CONNECTION – sigurnosni kontekst nije odgovoran za format poruka; ISC_REQ_DELEGATE – poslužitelju je dozvoljeno predstavljanje u ime klijenta (mora biti postavljena i zastavica ISC_REQ_MUTUAL_AUTH); ISC_REQ_EXTENDED_ERROR – u slučaju greške, obavještava se i druga strana; ISC_REQ_INTEGRITY – poruke se potpisuju i potpisi se verificiraju; ISC_REQ_MUTUAL_AUTH – obavit će se obostrana autentifikacija; ISC_REQ_REPLAY_DETECT – otkrivanje ponovno poslanih paketa; ISC_REQ_SEQUENCE_DETECT – otkrivanje

62

poruka primljenih izvan redoslijeda; ISC_REQ_STREAM – podrška tokovno orijentiranoj vezi; ISC_REQ_USE_SESSION_KEY – zahtijeva se ugovaranje novog sjedničkog ključa.

TargetDataRep Parametar odreñuje prikaz podataka na ciljanom sustavu, kao što je primjerice poredak bajtova. Može biti ili SECURITY_NATIVE_DREP ili SECURITY_NETWORK_DREP.

pOutput Pokazivač na strukturu tipa SecBufferDesc koja sadrži pokazivač na strukturu SecBuffer o kojoj se nalaze izlazni podaci (sigurnosna značka). Ukoliko je postavljena ISC_REQ_ALLOCATE_MEMORY zastavica, operacijski sustav se brine za rezerviranje memorije i popunjavanje adresa u strukturi SecBufferDesc.

pfContextAttr Pokazivač na varijablu koja sadrži set zastavica koje predstavljaju atribute uspostavljenog konteksta. Zastavice koje se koriste s ovim parametrom imaju prefiks ISC_RET, za razliku od onih navedenih fContextReq parametrom, koje imaju prefiks ISC_REQ.

Izlazni parametri

ptsExpiry Pokazivač na strukturu podataka tipa TimeStamp u koju se vraća vrijeme isteka valjanosti konteksta. Ovaj parametar je opcionalan i trebao bi biti postavljen na NULL ukoliko je riječ o kraćoj konekciji.

phContext Pokazivač na strukturu tipa CtxtHandle. Prilikom prvog poziva funkcije, ovaj pokazivač je postavljen na NULL. U kasnijim pozivima sadržava referencu na djelomično kreirani kontekst koji je nakon prvog poziva funkcije vraćen parametrom phNewContext.

pInput Pokazivač na strukturu tipa SecBufferDesc koja sadržava pokazivače na meñuspremnike koji su dostavljeni za ulaz prema sigurnosnom paketu. Pri prvom pozivu funkcije mora biti postavljen na NULL. U kasnijim pozivima, sadrži pokazivač na meñuspremnik u kojem se nalazi sigurnosna značka koju vraća udaljeni poslužitelj.

Ulazno – izlazni

parametri

phNewContext Pokazivač na strukturu tipa CtxtHandle. Prilikom prvog poziva funkcije, ovaj pokazivač prima novu referencu konteksta. U kasnijim pozivima ta referenca može biti ista kao referenca navedena u parametru phContext.

Rezervirane vrijednosti

Parametri Reserved1 i Reserved2 su rezervirane vrijednosti i moraju biti postavljene na nulu.

Povratne Po uspješnom izvršavanju funkcija vraća sljedeće vrijednosti:

63

vrijednosti SEC_E_OK – sigurnosni kontekst s klijentom je uspostavljen, ukoliko je generirana izlazna sigurnosna značka, treba ju proslijediti klijentu; SEC_I_COMPLETE_NEEDED – poslužitelj mora dovršiti izgradnju poruke poslane od klijenta i zatim pozvati funkciju CompleteAuthToken; SEC_I_CONTINUE_NEEDED – poslužitelj mora poslati izlaznu značku klijentu i čekati na novu značku od klijenta koju treba proslijediti preko parametra pInput novom pozivu funkcije AcceptSecurityContext; SEC_I_COMPLETE_AND_CONTINUE – poslužitelj mora pozvati funkciju CompleteAuthToken i proslijediti izlaznu značku klijentu te potom čekati na odgovor klijenta i ponovno pozvati funkciju AcceptSecurityContext. U slučaju greške, funkcija vraća jedan od sljedećih kodova: SEC_E_INVALID_HANDLE – proslijeñena reference na isprave nije valjana; SEC_E_INSUFFICIENT_MEMORY – nedovoljno memorije za obavljanje zadane operacije; SEC_E_INTERNAL_ERROR – pojavljivanje greške koja ne odgovara greškama iz SSPI sustava; SEC_E_INVALID_TOKEN – proslijeñena sigurnosna značka nije valjana; SEC_E_LOGON_DENIED – prijavljivanje na sustav nije uspjelo; SEC_E_NO_AUTHENTICATING_AUTHORITY – zbog nekog razloga nije moguće kontaktirati KDC (neispravno ime domene, nedostupna domena, nije moguće uspostaviti povjerljivu vezu).

Napomene Ukoliko se funkcija uspješno izvede prilikom prvog poziva, klijent će po završetku rada morati osloboditi stvoreni kontekst pozivom funkcije DeleteSecurityContext (neovisno o tome je li kontekst naposljetku uspješno uspostavljen ili nije). Nakon što je sigurnosni kontekst uspostavljen, klijent može ponovno pozvati funkciju InitializeSecurityContext i na taj način signalizirati SSP-u da zahtijeva ponovnu autentifikaciju.

QueryContextAttributes

Opis funkcije

Funkcija omogućuje aplikaciji ispitivanje osobina trenutno uspostavljenog sigurnosnog konteksta.

Prototip funkcije

SECURITY_STATUS SEC_Entry QueryContextAttributes( PCtxtHandle phContext, ULONG ulAttribute, PVOID pBuffer ); phContext Referenca na kontekst nad kojim se vrši upit. Ulazni

parametri ulAttribute Parametar odreñuje nad kojim atributom isprava će se vršiti upit i odreñuje tip strukture u koju će se informacije pohraniti. Može biti jedna od sljedećih vrijednosti: SECPKG_ATTR_ACCESS_TOKEN – vraća se

64

referenca na pristupnu značku pomoću pokazivača na strukturu tipa SecPkgContext_AccessToken; SECPKG_ATTR_AUTHORITY – vraća se ime autentifikacijskog autoriteta pomoću pokazivača na strukturu tipa SecPkgContext_Authority; SECPKG_ATTR_DCE_INFO – vraćaju se autorizacijski podaci koje koriste DCE servisi pomoću pokazivača na strukturu tipa SecPkgContext_DceInfo; SECPKG_ATTR_FLAGS – vraćaju se podaci o uspostavljenim zastavicama konteksta pomoću pokazivača na strukturu tipa SecPkgContext_Flags; SECPKG_ATTR_KEY_INFO – vraćaju se informacije o ključevima koji se koriste u sigurnosnom kontekstu pomoću pokazivača na strukturu tipa SecPkgContext_KeyInfo; SECPKG_ATTR_LIFESPAN – vraća se životni vijek konteksta pomoću pokazivača na strukturu tipa SecPkgContext_Lifespan; SECPKG_ATTR_NAMES – vraća se ime povezano sa sigurnosnim kontekstom pomoću pokazivača na strukturu tipa SecPkgContext_Names; SECPKG_ATTR_NATIVE_NAMES – vraća se korisničko ime iz vanjske (eng. outbound) karte pomoću pokazivača na strukturu tipa SecPkgContext_NativeNames; SECPKG_ATTR_NEGOTIATION_INFO – vraćaju se podaci o SSP-ovima koji će se koristiti u Negotiate sigurnosnom paketu, pomoću pokazivača na strukturu tipa SecPkgContext_NegotiationInfo; SECPKG_ATTR_PACKAGE_INFO – vraća se informacija u SSP-u koji se trenutno koristi pomoću pokazivača na strukturu tipa SecPkgContext_PackageInfo; SECPKG_ATTR_PASSWORD_EXPIRY – vraća se informacija o vremenu isteka zaporke pomoću pokazivača na strukturu tipa SecPkgContext_PasswordExpiry; SECPKG_ATTR_SESSION_KEY – vraćaju se informacije o sjedničkim ključevima pomoću pokazivača na strukturu tipa SecPkgContext_SessionKey; SECPKG_ATTR_SIZES – vraćaju se veličine struktura koje se koriste u funkcijama namijenjenim za baratanje porukama, pomoću pokazivača na strukturu tipa SecPkgContext_Sizes; SECPKG_ATTR_STREAM_SIZES – vraćaju se informacije o različitim tokovnim komponentama pomoću pokazivača na strukturu tipa SecPkgContext_StreamSizes;

65

SECPKG_ATTR_TARGET_INFORMATION – vraća se informacija o imenu udaljenog poslužitelja pomoću pokazivača na strukturu tipa SecPkgContext_TargetInformation.

Izlazni parametri

pBuffer Pokazivač na strukturu u koju će se pohraniti informacija o traženim osobinama. Tip strukture ovisi o vrijednosti parametra ulAttribute.

Povratne vrijednosti

Po uspješnom izvršavanju funkcija vraća vrijednost SEC_E_OK. Inače, vraća kod greške različit od nule.

Napomene Veličina strukture na koju pokazuje parametar pBuffer ovisi o tipu osobine koji se ispituje. Pozivatelj funkcije je odgovoran za rezerviranje memorije na koju pokazuje pBuffer, a SSP je odgovoran za rezerviranje memorije za sve članove strukture pBuffer koji su varijabilne veličine. Memoriju zauzetu od strane SSP-a treba osloboditi pozivom funkcije FreeContextBuffer.

QuerySecurityContextToken

Opis funkcije

Funkcija dohvaća pristupnu značku za klijentov sigurnosni kontekst. Pristupna značka sadrži klijentove sigurnosne podatke o trenutnom prijavljivanju na sustav kao što su identifikator, članstvo u grupama i privilegije.

Prototip funkcije

SECURITY_STATUS SEC_Entry QuerySecurityContextToken( PCtxtHandle phContext, HANDLE* phToken );

Ulazni parametri

phContext Referenca na kontekst nad kojim se vrši upit.

Izlazni parametri

phToken Referenca na pristupnu značku.

Povratne vrijednosti

Po uspješnom izvršavanju funkcija vraća vrijednost SEC_E_OK. Inače, vraća kod greške SEC_E_INVALID_HANDLE, koji odreñuje neispravnost proslijeñene reference na isprave.

Napomene Funkcija može biti pozvana od strane poslužitelja kada želi uspostaviti predstavljanje klijenta izvan SSPI sloja, primjerice pri pokretanju drugog procesa. Referenca na pristupnu značku mora po završetku korištenja biti izbrisana funkcijom CloseHandle.

RevertSecurityContext

Opis funkcije

Funkcija omogućava poslužitelju da prekine svoje predstavljanje u ime klijenta i ponovo uspostavi vlastiti sigurnosni kontekst.

Prototip funkcije

SECURITY_STATUS SEC_Entry RevertSecurityContext( PCtxtHandle phContext );

Ulazni parametri

phContext Referenca na kontekst koji se trenutno predstavlja.

Povratne vrijednosti

Po uspješnom izvršavanju funkcija vraća vrijednost SEC_E_OK. Inače, vraća kod greške SEC_E_INVALID_HANDLE, koji

66

odreñuje neispravnost proslijeñene reference na isprave. Napomene Referenca koja se predaje funkciji je ona koju je poslužitelj

proslijedio u pozivu funkcije ImpersonateSecurityContext.

Funkcije za podršku sigurnoj razmjeni poruka

Ove funkcije omogućavaju aplikaciji slanje i primanje poruka uz osiguranu zaštitu integriteta (kroz potpisivanje poruka i verifikaciju potpisa) i tajnosti (kroz enkripciju i dekripciju poruka). Funkcije pri radu koriste prethodno uspostavljeni sigurnosni kontekst.

DecryptMessage

Opis funkcije

Funkcija se koristi pri dekriptiranju poruka.

Prototip funkcije

SECURITY_STATUS SEC_Entry DecryptMessage( PCtxtHandle phContext, PSecBufferDesc pMessage, ULONG MessageSeqNo, PULONG pfQOP ); phContext Referenca na sigurnosni kontekst koji se koristi

prilikom dekriptiranja poruke. Ulazni

parametri MessageSeqNo Slijedni broj koji očekuje transportna aplikacija,

ukoliko ga očekuje. U protivnom, mora biti postavljen na nulu.

Izlazni parametri

pfQOP Pokazivač na varijablu tipa ULONG u koji se zapisuju zastavice (u ovisnosti o SSP-u) koje označavaju kvalitetu zaštite. Parametar može biti SECQOP_WRAP_NO_ENCRYPT koji označava da poruka nije enkriptirana, ali posjeduje zaglavlje (eng. header) ili dodatak na repu poruke (eng. trailer).

Ulazno – izlazni

parametri

pMessage Pokazivač na strukturu tipa SecBufferDesc u kojoj se nalaze pokazivači na meñuspremnike tipa SecBuffer. U jednom od njih nalazi se enkriptirana poruka. Po završetku izvoñenja funkcije na mjestu enkriptiranog sadržaja nalazi se dekriptirana poruka.

Povratne vrijednosti

Ukoliko funkcija utvrdi da je poruka poslana u pravilnom redoslijedu, vraća vrijednost SEC_E_OK. Ako poruka nije mogla biti dekriptirana, vraća se jedan od sljedećih kodova greške: SEC_E_INCOMPLETE_MESSAGE – podaci u ulaznom meñuspremniku nisu kompletni, potrebno je učitati još podataka i ponovno pozvati funkciju DecryptMessage; SEC_E_OUT_OF_SEQUENCE – poruka nije primljena u pravilnom redoslijedu.

Napomene Funkcije EncryptMessage i DecryptMessage mogu biti pozvane istovremeno iz dvije različite dretve unutar istog SSPI konteksta ukoliko jedna dretva služi samo za enkriptiranje, a druga samo za

67

dekriptiranje. Ukoliko postoji više dretvi koje se bave enkripcijom, ili ih se više bavi dekripcijom, svaka dretva bi trebala uspostaviti vlastiti sigurnosni kontekst.

EncryptMessage

Opis funkcije

Funkcija se koristi za enkriptiranje poruka, nudeći aplikaciji izbor izmeñu različitih kriptografskih algoritama.

Prototip funkcije

SECURITY_STATUS SEC_Entry EncryptMessage( PCtxtHandle phContext, ULONG fQOP, PSecBufferDesc pMessage, ULONG MessageSeqNo ); phContext Referenca na sigurnosni kontekst koji se koristi

prilikom enkriptiranja poruke. fQOP Zastavica ovisna o SSP-u koje odreñuje kvalitetu

zaštite. SSP može koristiti ovaj parametar do omogući odabir kriptografskih algoritama. Parametar može biti SECQOP_WRAP_NO_ENCRYPT koji označava da poruka neće biti enkriptirana, ali se treba kreirati zaglavlje (eng. header) ili dodatak na repu poruke (eng. trailer).

Ulazni parametri

MessageSeqNo Slijedni broj koji je odredila transportna aplikacija, ukoliko ga koristi. U protivnom, mora biti postavljen na nulu.

Ulazno -izlazni

parametri

pMessage Pokazivač na strukturu tipa SecBufferDesc u kojoj se nalaze pokazivači na strukture tipa SecBuffer od kojih je jedan tipa SECBUFFER_DATA i u njemu je poruka koju treba enkriptirati. Poruka se enkriptira na istom mjestu, brišući originalnu poruku. SecBuffer spremnici koji su tipa SECBUFFER_READONLY neće biti procesirani funkcijom. Veličina meñuspremnika u kojem se nalazi poruka ne smije veća od parametra cbMaximumMessage koji se može odrediti pozivom funkcije QueryContextAttributes uz atribut SECPKG_ATTR_STREAM_SIZES. Aplikacije koje ne koriste SSL moraju dostaviti SecBuffer meñuspremnik tipa SECBUFFER_PADDING.

Povratne vrijednosti

Po uspješnom izvršavanju funkcija vraća vrijednost SEC_E_OK. Inače, vraća se jedan od sljedećih kodova greške: SEC_E_BUFFER_TOO_SMALL – izlazni meñuspremnik je premalen; SEC_E_CONTEXT_EXPIRED – aplikacija referencira kontekst koji je prethodno zatvoren;

68

SEC_E_CRYPTO_SYSTEM_INVALID – sigurnosni kontekst ne podržava odabrani sigurnosni algoritam; SEC_E_INSUFFICIENT_MEMORY – nema dovoljno memorije za obavljanje tražene operacije; SEC_E_INVALID_HANDLE – predana je neispravna referenca na kontekst; SEC_E_INVALID_TOKEN – nije pronañen meñuspremnik tipa SECBUFFER_DATA; SEC_E_QOP_NOT_SUPPORTED – sigurnosni kontekst ne podržava niti tajnost podataka niti zaštitu integriteta.

Napomene Sljedeći tipovi meñuspremnika SecBuffer moraju biti dostavljeni i to u redoslijedu: SECBUFFER_STREAM_HEADER, SECBUFFER_DATA, SECBUFFER_STREAM_TRAILER, SECBUFFER_EMPTY. Svi osim meñuspremnika SECBUFFER_DATA se koriste interno i nije ih potrebno inicijalizirati. Funkcije EncryptMessage i DecryptMessage mogu biti pozvane istovremeno iz dvije različite dretve unutar istog SSPI konteksta ukoliko jedna dretva služi samo za enkriptiranje, a druga samo za dekriptiranje. Ukoliko postoji više dretvi koje se bave enkripcijom, ili ih se više bavi dekripcijom, svaka dretva bi trebala uspostaviti vlastiti sigurnosni kontekst.

69

Dodatak C: GSSAPI funkcije

Funkcije za upravljanje ispravama

gss_acquire_cred

Opis funkcije

Funkcija omogućuje aplikaciji dohvaćanje reference na prethodno kreirane isprave preko imena.

Prototip funkcije

OM_uint32 gss_acquire_cred ( OM_uint32 *minor_status, const gss_name_t desired_name, OM_uint32 time_req, const gss_OID_set desired_mechs, gss_cred_usage_t cred_usage, gss_cred_id_t *output_cred_handle, gss_OID_set *actual_mechs, OM_uint32 *time_rec );

desired_name Ime korisnika čije isprave treba dohvatiti. time_req Željeno vrijeme trajanja isprava izraženo u

sekundama. Ukoliko se želi postaviti na maksimalno dozvoljeno vrijeme, treba proslijediti vrijednost GSS_C_INDEFINITE.

desired_mechs Skup internih mehanizama koji se mogu koristiti. Za korištenje podrazumijevanih vrijednosti potrebno je proslijediti vrijednost GSS_C_NO_OID_SET.

Ulazni parametri

cred_usage Način na koji će se isprave koristiti, može biti jedna od sljedećih vrijednosti: GSS_C_INITIATE – koriste se samo za iniciranje sigurnosnog konteksta; GSS_C_ACCEPT – koriste se samo za prihvaćanje sigurnosnog konteksta; GSS_C_BOTH – mogu se koristiti i za iniciranje i prihvaćanje sigurnosnog konteksta.

output_cred_handle Referenca na dohvaćene isprave. actual_mechs Skup mehanizama za koje su isprave

valjane. Ukoliko se ne koristi, potrebno je postaviti vrijednost NULL.

time_rec Vrijeme trajanja isprava izraženo u sekundama. Ukoliko implementacija ne podržava istek roka trajanja isprava, vraća se vrijednost GSS_C_INDEFINITE. Ukoliko se ne koristi, potrebno je postaviti vrijednost NULL.

Izlazni parametri

minor_status Status internog mehanizma. Povratne vrijednosti

U slučaju uspješnog izvršavanja, funkcija vraća statusni kod GSS_S_COMPLETE. U protivnom, vraća jednu od sljedećih vrijednosti: GSS_S_BAD_MECH – zahtijevani mehanizam je nedostupan;

70

GSS_S_BAD_NAMETYPE – tip imena naveden u parametru desired_name nije podržan; GSS_S_BAD_NAME – vrijednost imena u parametru desired_name nije ispravno formirana; GSS_S_CREDENTIALS_EXPIRED – traženim ispravama isteklo je vrijeme trajanja; GSS_S_NO_CRED – ne postoje isprave za traženo ime.

Napomene Ukoliko je parametar desired_name postavljen na vrijednost GSS_C_NO_NAME, poziv funkcije se interpretira kao zahtjev za referencu na isprave koje će izazvati podrazumijevano ponašanje pri pozivu funkcije gss_init_sec_context() (ukoliko je parametar cred_usage postavljen na GSS_C_INITIATE ili GSS_C_BOTH) ili gss_accept_sec_context() (ukoliko je parametar cred_usage postavljen na GSS_C_ACCEPT ili GSS_C_BOTH). Resursi na koje se odnosi parametri output_cred_handle i actual_mechs moraju nakon završetka korištenja biti osloboñeni pozivima funkcija gss_release_cred() i gss_release_oid_set(), respektivno.

gss_release_cred

Opis funkcije

Funkcija obavještava GSSAPI da navedena referenca na isprave nije više potrebna i oslobaña pripadajuće resurse.

Prototip funkcije

OM_uint32 gss_release_cred ( OM_uint32 *minor_status, gss_cred_id_t *cred_handle );

cred_handle Referenca na isprave koje treba osloboditi. Izlazni parametri minor_status Status internog mehanizma. Povratne vrijednosti

U slučaju uspješnog izvršavanja, funkcija vraća statusni kod GSS_S_COMPLETE. U protivnom, vraća GSS_S_NO_CRED koji označava nemogućnost pristupa navedenim ispravama.

Funkcije za upravljanje sigurnosnim kontekstom

gss_init_sec_context

Opis funkcije

Funkcija sliži iniciranju sigurnosnog konteksta s klijentove strane na temelju reference na klijentove isprave. Pozivom funkcije generira se sigurnosna značka koja se šalje poslužitelju, koji ju koristi u pozivu funkcije gss_accept_sec_context().

Prototip funkcije

OM_uint32 gss_init_sec_context ( OM_uint32 *minor_status, const gss_cred_id_t initiator_cred_handle, gss_ctx_id_t *context_handle, const gss_name_t target_name, const gss_OID mech_type, OM_uint32 req_flags, OM_uint32 time_req, const gss_channel_bindings_t input_chan_bindings, const gss_buffer_t input_token gss_OID *actual_mech_type, gss_buffer_t output_token,

71

OM_uint32 *ret_flags, OM_uint32 *time_rec ); initiator_cred_handle Referenca na isprave pomoću kojih se

inicira sigurnosni kontekst. Ako se postavi vrijednost GSS_C_NO_CREDENTIAL, pretpostavlja se podrazumijevani korisnik za iniciranje. Ukoliko podrazumijevani korisnik nije definiran, funkcija vraća vrijednost GSS_S_NO_CRED.

context_handle Referenca na novi sigurnosni kontekst. Pri prvom pozivu treba postaviti vrijednost GSS_C_NO_CONTEXT, a pri budućim pozivima vrijednost vraćenu prvim pozivom.

target_name Naziv druge strane s kojom se uspostavlja sigurnosni kontekst.

mech_type Identifikator objekta željenog mehanizma. Ukoliko se želi koristiti podrazumijevani, treba postaviti vrijednost GSS_C_NO_OID.

req_flags Skup nezavisnih zastavica koje odreñuju osobine koje se zahtijevaju od sigurnosnog konteksta. Moguće ih je kombinirati logičkom funkcijom ILI: GSS_C_DELEG_FLAG – dozvoljava delegiranje isprava; GSS_C_MUTUAL_FLAG – zahtijeva obostranu autentifikaciju; GSS_C_REPLAY_FLAG – omogućava otkrivanje ponovnog slanja zaštićenih poruka; GSS_C_SEQUENCE_FLAG – omogućava otkrivanje zaštićenih poruka koje nisu poslane pravilnim redoslijedom; GSS_C_CONF_FLAG – zahtijeva se zaštita tajnosti poruka; GSS_C_INTEG_FLAG – zahtijeva se zaštita integriteta poruka; GSS_C_ANON_FLAG – identitet inicijatora se ne otkriva entitetu koji prihvaća sigurnosni kontekst.

Ulazni parametri

time_req Željeno vrijeme trajanja valjanosti konteksta izraženo u sekundama. Ukoliko se želi postaviti na podrazumijevanu vrijednost, parametar treba postaviti na 0.

72

input_chan_bindings Povezivanja kanala vezano uz aplikaciju. Omogućava aplikaciji sigurno povezivanje podataka o identifikaciji kanala skupa sa sigurnosnim kontekstom. Ukoliko se ne koristi povezivanje kanala, treba postaviti na GSS_C_NO_CHANNEL_BINDINGS.

input_token Sigurnosna značka primljena od poslužiteljske aplikacije. Pri prvom pozivu treba postaviti vrijednost GSS_C_NO_BUFFER ili proslijediti pokazivač na meñuspremnik s vrijednošću GSS_C_EMPTY_BUFFER.

actual_mech_type Konkretni mehanizam koji se koristi, aplikacija ne bi trebala pokušavati osloboditi navedeni resurs. Ukoliko nije bitan, parametar treba postaviti na NULL.

output_token Sigurnosna značka koju treba poslati poslužiteljskoj aplikaciji. Ukoliko je vraćena značka s poljem duljine postavljenim na 0, nije potrebno slati značku.

ret_flags Skup nezavisnih zastavica koje odreñuju osobine sigurnosnog konteksta koje su uspostavljene. Ispitivanje je li pojedina zastavica postavljena se provodi logičkom funkcijom I. Vrijednosti zastavica su iste kao za parametar req_flags, uz dvije dodatne: GSS_C_PROT_READY_FLAG – ukoliko je postavljena, označava da su usluge za zaštitu tajnosti i integriteta (definirane stanjima zastavica GSS_C_CONF_FLAG i GSS_C_INTEG_FLAG) dostupne za korištenje ako je pripadajuća povratna vrijednost funkcije ili GSS_S_COMPLETE, ili GSS_S_CONTINUE_NEEDED, u protivnom su dostupne samo uz povratnu vrijednost GSS_S_COMPLETE; GSS_C_TRANS_FLAG – dozvoljava se prenošenje sigurnosnog konteksta drugim procesima pozivom funkcije gss_export_sec_context().

Izlazni parametri

time_rec Vrijeme trajanja valjanosti konteksta izraženo u sekundama. Ukoliko implementacija ne podržava istek roka

73

trajanja konteksta, vraća se vrijednost GSS_C_INDEFINITE. Ukoliko se ne koristi, potrebno je postaviti vrijednost NULL.

minor_status Status internog mehanizma. Povratne vrijednosti

U slučaju uspješnog izvršavanja, funkcija vraća sljedeće statusne kodove: GSS_S_COMPLETE – kontekst je uspostavljen; GSS_S_CONTINUE_NEEDED – zahtijeva se značka od poslužiteljske aplikacije koju treba proslijediti u novom pozivu funkcije gss_init_sec_context(). U slučaju greške, funkcija vraća jednu od sljedećih vrijednosti: GSS_S_DEFECTIVE_TOKEN – sigurnosna značka u parametru input_token nije konzistentna; GSS_S_DEFECTIVE_CREDENTIAL – isprave nisu konzistentne; GSS_S_NO_CRED – priložene isprave nisu valjanje za inicijaciju uspostavljanja konteksta; GSS_S_CREDENTIALS_EXPIRED – predočenim ispravama istekao je rok trajanja; GSS_S_BAD_BINDINGS – povezivanja kanala navedena u parametrima input_token i input_chan_bindings se razlikuju; GSS_S_BAD_SIG – parametar input_token sadrži neispravni kod za provjeru integriteta (eng. message integrity code - MIC) ili MIC kojeg nije moguće provjeriti; GSS_S_OLD_TOKEN – sigurnosna značka u parametru input_token je previše stara (kritična greška); GSS_S_DUPLICATE_TOKEN - sigurnosna značka u parametru input_token je ispravna, ali je kopija znake koja je već obrañena (kritična greška); GSS_S_NO_CONTEXT – proslijeñena referenca na kontekst ne odgovara valjanom kontekstu; GSS_S_BAD_NAMETYPE – tip imena naveden u parametru target_name je neispravan ili nije podržan od implementacije; GSS_S_BAD_NAME – ime u parametru target_name nije ispravno formirano; GSS_S_BAD_MECH – traženi mehanizam nije prepoznat ili nije podržan od implementacije.

Napomene Resursi na koje pokazuju parametri context_handle i output_token moraju nakon korištenja biti osloboñeni funkcijama gss_delete_sec_context() i gss_release_buffer(), respektivno.

gss_accept_sec_context

Opis funkcije

Funkcija omogućuje poslužiteljskoj aplikaciji uspostavljanje sigurnosnog konteksta iniciranog od strane klijenta pozivom funkcije gss_init_sec_context(). Poslužitelj prije završetka postupka može zahtijevati jedan ili više odgovora od klijenta u vidu sigurnosnih značaka.

Prototip funkcije

OM_uint32 gss_accept_sec_context ( OM_uint32 *minor_status, gss_ctx_id_t *context_handle,

74

const gss_cred_id_t acceptor_cred_handle, const gss_buffer_t input_token_buffer, const gss_channel_bindings_t input_chan_bindings, const gss_name_t *src_name, gss_OID *mech_type, gss_buffer_t output_token, OM_uint32 *ret_flags, OM_uint32 *time_rec, gss_cred_id_t *delegated_cred_handle );

context_handle Referenca na novi sigurnosni kontekst. Pri prvom pozivu treba postaviti vrijednost GSS_C_NO_CONTEXT, a pri budućim pozivima vrijednost vraćenu prvim pozivom.

acceptor_cred_handle Referenca na isprave pomoću kojih prihvaća sigurnosni kontekst. Uz vrijednost GSS_C_NO_CREDENTIAL pretpostavlja se podrazumijevani korisnik za prihvaćanje konteksta. Ukoliko podrazumijevani korisnik nije definiran, funkcija vraća vrijednost GSS_S_NO_CRED.

input_token_buffer Sigurnosna značka primljena od strane klijentske aplikacije.

Ulazni parametri

input_chan_bindings Referenca na isprave pomoću kojih se inicira sigurnosni kontekst. Ako se postavi vrijednost GSS_C_NO_CREDENTIAL, pretpostavlja se podrazumijevani korisnik za iniciranje. Ukoliko podrazumijevani korisnik nije definiran, funkcija vraća vrijednost GSS_S_NO_CRED.

src_name Autentificirano ime inicijatora sigurnosnog konteksta (klijenta). Ukoliko nije potrebno, treba postaviti na NULL.

mech_type Konkretni mehanizam koji se koristi, aplikacija ne bi trebala pokušavati osloboditi navedeni resurs. Ukoliko nije bitan, parametar treba postaviti na NULL.

output_token Sigurnosna značka koju treba poslati klijentskoj aplikaciji. Ukoliko je vraćena značka s poljem duljine postavljenim na 0, nije potrebno slati značku.

Izlazni parametri

ret_flags Skup nezavisnih zastavica koje odreñuju osobine koje podržava sigurnosni kontekst. Ispitivanje je li pojedina zastavica postavljena se provodi logičkom funkcijom I: GSS_C_DELEG_FLAG – delegirane

75

isprave su dostupne putem parametra delegated_cred_handle; GSS_C_MUTUAL_FLAG – klijent je zahtijevao obostranu autentifikaciju; GSS_C_REPLAY_FLAG – ponovno slanja zaštićenih poruka bit će otkriveno; GSS_C_SEQUENCE_FLAG – zaštićenih poruke koje nisu poslane pravilnim redoslijedom bit će otkrivene; GSS_C_CONF_FLAG – zaštita tajnosti poruka je moguća korištenjem funkcije gss_wrap(); GSS_C_INTEG_FLAG – zaštita integriteta poruka je moguća korištenjem funkcija gss_wrap() ili gss_get_mic(); GSS_C_ANON_FLAG – klijent koji je inicirao kontekst ne želi biti autentificiran; GSS_C_PROT_READY_FLAG – ukoliko je postavljena, označava da su usluge za zaštitu tajnosti i integriteta (definirane stanjima zastavica GSS_C_CONF_FLAG i GSS_C_INTEG_FLAG) dostupne za korištenje ako je pripadajuća povratna vrijednost funkcije ili GSS_S_COMPLETE, ili GSS_S_CONTINUE_NEEDED, u protivnom su dostupne samo uz povratnu vrijednost GSS_S_COMPLETE; GSS_C_TRANS_FLAG – dozvoljava se prenošenje sigurnosnog konteksta drugim procesima pozivom funkcije gss_export_sec_context().

time_rec Vrijeme trajanja valjanosti konteksta izraženo u sekundama. Ukoliko se ne koristi, potrebno je postaviti vrijednost NULL.

delegated_cred_handle Ukoliko je postavljena zastavica GSS_C_DELEG_FLAG, parametar sadrži referencu na isprave koje su delegirane. U protivnom, parametar je postavljen na GSS_C_NO_CREDENTIAL.

minor_status Status internog mehanizma. Povratne vrijednosti

Funkcija vraća jednake vrijednosti kao i funkcija gss_init_sec_context(), uz iste opise.

Napomene Resursi na koje pokazuju parametri src_name, context_handle i output_token moraju nakon korištenja biti osloboñeni funkcijama gss_release_name(), gss_delete_sec_context() i

76

gss_release_buffer(), respektivno.

gss_delete_sec_context

Opis funkcije

Funkcija briše sigurnosni kontekst i sve lokalne strukture podataka povezane s njim. Služi brisanju uspostavljenih sigurnosnih konteksta, ali i onih koji su samo djelomično izgrañeni nepotpunim nizom poziva funkcija gss_init_sec_context() i gss_accept_sec_context().

Prototip funkcije

OM_uint32 gss_delete_sec_context ( OM_uint32 *minor_status, gss_ctx_id_t *context_handle, gss_buffer_t output_token );

Ulazni parametri

context_handle Referenca na kontekst koji treba izbrisati. Nakon izvoñenja referenca se postavlja na vrijednost GSS_C_NO_CONTEXT.

output_token Generiran značka koju treba poslati udaljenoj aplikaciji s naputkom da i ona izbriše kontekst. Preporuka je da se u aplikacijama prakticira samo lokalno brisanje konteksta te da se za ovaj parametar postavi vrijednost GSS_C_NO_BUFFER.

Izlazni parametri

minor_status Status internog mehanizma. Povratne vrijednosti

U slučaju uspješnog izvršavanja, funkcija vraća statusni kod GSS_S_COMPLETE. U protivnom, vraća GSS_S_NO_CONTEXT koji označava da nije naveden valjani sigurnosni kontekst.

Napomene Parametar output_token zadržan je samo zbog kompatibilnosti s verzijom 1 GSSAPI-a, preporuka je da se kontekst briše samo lokalno.

gss_inquire_context

Opis funkcije

Prototip funkcije

OM_uint32 gss_inquire_context ( OM_uint32 *minor_status, const gss_ctx_id_t context_handle, gss_name_t *src_name, gss_name_t *targ_name, OM_uint32 *lifetime_rec, gss_OID *mech_type, OM_uint32 *ctx_flags, int *locally_initiated, int *open );

Ulazni parametri

context_handle Referenca na kontekst koji se ispituje.

src_name Ime inicijatora konteksta (klijenta). Ukoliko se ne koristi, treba postaviti na NULL.

Izlazni parametri

targ_name Ime onog koji prihvaća kontekst (poslužitelj). Ukoliko se ne koristi, treba postaviti na NULL.

77

lifetime_rec Preostalo vrijeme trajanja valjanosti konteksta. Ako je isteklo, vrijednost je 0. Ako implementacija ne podržava istek roka valjanosti konteksta, vraća se vrijednost GSS_C_INDEFINITE. Ukoliko se ne koristi, treba postaviti na NULL.

mech_type Konkretni mehanizam koji se koristi, aplikacija ne bi trebala pokušavati osloboditi navedeni resurs. Ukoliko se ne koristi, parametar treba postaviti na NULL.

ctx_flags Skup nezavisnih zastavica koje odreñuju osobine koje podržava sigurnosni kontekst. Ispitivanje je li pojedina zastavica postavljena se provodi logičkom funkcijom I. Zastavice i njihovi opisi navedeni su u opisu funkcija gss_init_sec_context() i gss_accept_sec_context(). Ukoliko se ne koristi, parametar treba postaviti na NULL.

locally_initiated Parametar je različit od nule ukoliko je pozivatelj funkcije inicirao kontekst. Ukoliko se ne koristi, parametar treba postaviti na NULL.

open Ako je kontekst uspostavljen u potpunosti, parametar je različit od nule. Ukoliko se ne koristi, parametar treba postaviti na NULL.

minor_status Status internog mehanizma. Povratne vrijednosti

U slučaju uspješnog izvršavanja, funkcija vraća statusni kod GSS_S_COMPLETE. U protivnom, vraća GSS_S_NO_CONTEXT koji označava da nije moguće pristupiti sigurnosnom kontekstu.

gss_export_sec_context

Opis funkcije

Funkcija omogućuje dijeljenje posla izmeñu različitih procesa. Najčešće će biti korištena od strane poslužitelja koji prihvaća sigurnosni kontekst i zatim ga prosljeñuje jednom ili više različitih procesa za razmjenu poruka s klijentom. Svaki sigurnosni kontekst može biti aktivan samo u jednom procesu (proces koji šalje kontekst drugom procesu deaktivira ga za sebe).

Prototip funkcije

OM_uint32 gss_export_sec_context ( OM_uint32 *minor_status, gss_ctx_id_t *context_handle, gss_buffer_t interprocess_token );

Ulazni parametri

context_handle Referenca na kontekst koji će se prenijeti drugom procesu.

interprocess_token Sigurnosna značka iz koje će drugi proces stvoriti sigurnosni kontekst.

Izlazni parametri

*minor_status Status internog mehanizma. Povratne vrijednosti

U slučaju uspješnog izvršavanja, funkcija vraća statusni kod GSS_S_COMPLETE. U protivnom, vraća jednu od sljedećih vrijednosti:

78

GSS_S_CONTEXT_EXPIRED – istekao je rok valjanosti konteksta; GSS_S_NO_CONTEXT – kontekst nije ispravan; GSS_S_UNAVAILABLE – postupak nije podržan.

Napomene Sadržaj parametra interprocess_token mora nakon korištenja biti osloboñen funkcijom gss_release_buffer().

gss_import_sec_context

Opis funkcije

Funkcija omogućuje procesu uvoñenje sigurnosnog konteksta koji je prethodno uspostavio neki drugi proces putem sigurnosne značke. Svaka značka može biti uvedena samo jednom.

Prototip funkcije

OM_uint32 gss_import_sec_context ( OM_uint32 *minor_status, const gss_buffer_t interprocess_token, gss_ctx_id_t *context_handle );

Ulazni parametri

interprocess_token Značka primljena od drugog procesa.

context_handle Referenca sadrži novostvoreni kontekst. Izlazni parametri minor_status Status internog mehanizma. Povratne vrijednosti

U slučaju uspješnog izvršavanja, funkcija vraća statusni kod GSS_S_COMPLETE. U protivnom, vraća jednu od sljedećih vrijednosti: GSS_S_DEFECTIVE_TOKEN – značka nije ispravna; GSS_S_NO_CONTEXT – značka ne sadržava ispravni kontekst; GSS_S_UNAVAILABLE – postupak nije dostupan; GSS_S_UNAUTHORIZED – proces nema dozvolu za uvoñenje navedenog sigurnosnog konteksta.

Napomene Kontekst na koji pokazuje parametarcontext_handle mora nakon korištenja biti osloboñen funkcijom gss_delete_sec_context().

Funkcije za podršku sigurnoj razmjeni poruka

gss_get_mic

Opis funkcije

Funkcija računa kriptografski kod za provjeru integriteta poruke (MIC) i dodaje ga u značku koja će biti poslana udaljenoj aplikaciji. Nudi odabir izmeñu nekoliko kriptografskih algoritama, pod uvjetom da ih sigurnosni mehanizam podržava.

Prototip funkcije

OM_uint32 gss_get_mic ( OM_uint32 *minor_status, const gss_ctx_id_t context_handle, gss_qop_t qop_req, const gss_buffer_t message_buffer, gss_buffer_t msg_token );

context_handle Referenca na kontekst u kojem se šalje poruka. Ulazni parametri qop_req Odreñuje traženu kvalitetu zaštite. Zbog veće

prenosivosti aplikacija preporuka je korištenje podrazumijevane kvalitete zaštite koju nudi odabrani sigurnosni mehanizam, postavljanjem

79

parametra na vrijednost GSS_C_QOP_DEFAULT.

message_buffer Poruka koje je potrebno zaštititi. msg_token Meñuspremnik u koji će biti pohranjena značka. Izlazni

parametri minor_status Status internog mehanizma. Povratne vrijednosti

U slučaju uspješnog izvršavanja, funkcija vraća statusni kod GSS_S_COMPLETE. U protivnom, vraća jednu od sljedećih vrijednosti: GSS_S_CONTEXT_EXPIRED – istekao je rok valjanosti konteksta; GSS_S_NO_CONTEXT – referenca ne pokazuje na ispravni kontekst; GSS_S_BAD_QOP – mehanizam ne podržava traženu kvalitetu zaštite.

Napomene Nakon korištenja, memoriju na koju pokazuje parametar msg_token potrebno je osloboditi pozivom funkcije gss_release_buffer().

gss_verify_mic

Opis funkcije

Provjerava odgovara li primljenoj poruci kriptografski potpis (MIC) koji je sadržan u znački.

Prototip funkcije

OM_uint32 gss_verify_mic ( OM_uint32 *minor_status, const gss_ctx_id_t context_handle, const gss_buffer_t message_buffer, const gss_buffer_t token_buffer, gss_qop_t *qop_state ); context_handle Referenca na kontekst u kojem je primljena

poruka. message_buffer Poruka koju je potrebno provjeriti.

Ulazni parametri

token_buffer Značka povezana s porukom. qop_state Sadržava primijenjenu kvalitetu zaštite. Ako se

ne koristi, može se postaviti na NULL. Izlazni

parametri minor_status Status internog mehanizma.

Povratne vrijednosti

U slučaju uspješnog izvršavanja, funkcija vraća statusni kod GSS_S_COMPLETE. U protivnom, vraća jednu od sljedećih vrijednosti: GSS_S_CONTEXT_EXPIRED – istekao je rok valjanosti konteksta; GSS_S_NO_CONTEXT – referenca ne pokazuje na ispravni kontekst; GSS_S_DEFECTIVE_TOKEN – sigurnosna značka nije konzistentna; GSS_S_BAD_SIG – netočan MIC; GSS_S_DUPLICATE_TOKEN – značka je valjana i s ispravnim MIC-om, ali već je prethodno obrañena; GSS_S_OLD_TOKEN – značka je valjana i s ispravnim MIC-om, ali je previše stara za provjeru duplikata; GSS_S_UNSEQ_TOKEN - značka je valjana i s ispravnim MIC-

80

om, ali je primljena izvan pravilnog redoslijeda, već je primljena značka sa kasnijim rednim brojem; GSS_S_GAP_TOKEN - značka je valjana i s ispravnim MIC-om, ali je primljena izvan pravilnog redoslijeda, značka s ranijim rednim brojem još nije primljena.

gss_wrap

Opis funkcije

Funkcija dodaje poruci kriptografski kod za provjeru integriteta (MIC) i opcionalno enkriptira poruku, uz odabir izmeñu nekoliko kriptografskih algoritama, pod uvjetom da ih sigurnosni mehanizam podržava.

Prototip funkcije

OM_uint32 gss_wrap ( OM_uint32 *minor_status, const gss_ctx_id_t context_handle, int conf_req_flag, gss_qop_t qop_req, const gss_buffer_t input_message_buffer, int *conf_state, gss_buffer_t output_message_buffer );

context_handle Referenca na kontekst u kojem će poruka biti poslana.

conf_req_flag Zastavica kojom se odreñuje hoće li se koristiti i zaštita integriteta i zaštita tajnosti (postavljena na vrijednost različitu od nule) ili će se koristiti samo zaštita integriteta (postavljena na nulu).

qop_req Odreñuje traženu kvalitetu zaštite. Podrazumijevana vrijednost za sigurnosni mehanizam odabire se postavljanjem parametra na vrijednost GSS_C_QOP_DEFAULT.

Ulazni parametri

input_message_buffer Poruka koju je potrebno zaštititi. conf_state Zastavica koja označava primijenjenu

razinu zaštite. Ako je različita od nule, postavljena je zaštita i tajnosti i integriteta. Ako je nula, postavljena je samo zaštita integriteta. Ako se ne koristi, može se postaviti na NULL.

output_message_buffer Meñuspremnik u kojem se nalazi zaštićena poruka.

Izlazni parametri

minor_status Status internog mehanizma. Povratne vrijednosti

U slučaju uspješnog izvršavanja, funkcija vraća statusni kod GSS_S_COMPLETE. U protivnom, vraća jednu od sljedećih vrijednosti: GSS_S_CONTEXT_EXPIRED – istekao je rok valjanosti konteksta; GSS_S_NO_CONTEXT – referenca ne pokazuje na ispravni kontekst; GSS_S_BAD_QOP – mehanizam ne podržava traženu kvalitetu zaštite.

81

Napomene Nakon korištenja, memoriju na koju pokazuje parametar output_message_buffer potrebno je osloboditi pozivom funkcije gss_release_buffer().

gss_unwrap

Opis funkcije

Dekriptira poruku prethodno enkriptiranu funkcijom gss_wrap uz provjeru valjanosti uključenog MIC-a.

Prototip funkcije

OM_uint32 gss_unwrap ( OM_uint32 *minor_status, const gss_ctx_id_t context_handle, const gss_buffer_t input_message_buffer, gss_buffer_t output_message_buffer, int *conf_state, gss_qop_t *qop_state );

context_handle Referenca na kontekst u kojem je poruka primljena.

Ulazni parametri

input_message_buffer Primljena zaštićena poruka. output_message_buffer Meñuspremnik u kojem će biti

pohranjena dekriptirana poruka. conf_state Zastavica koja označava primijenjenu

razinu zaštite. Ako je različita od nule, postavljena je zaštita i tajnosti i integriteta. Ako je nula, postavljena je samo zaštita integriteta. Ako se ne koristi, može se postaviti na NULL.

qop_state Sadržava primijenjenu kvalitetu zaštite. Ako se ne koristi, može se postaviti na NULL.

Izlazni parametri

minor_status Status internog mehanizma. Povratne vrijednosti

U slučaju uspješnog izvršavanja, funkcija vraća statusni kod GSS_S_COMPLETE. U protivnom, vraća jednu od sljedećih vrijednosti: GSS_S_CONTEXT_EXPIRED – istekao je rok valjanosti konteksta; GSS_S_NO_CONTEXT – referenca ne pokazuje na ispravni kontekst; GSS_S_DEFECTIVE_TOKEN – sigurnosna značka nije konzistentna; GSS_S_BAD_SIG – netočan MIC; GSS_S_DUPLICATE_TOKEN – značka je valjana i s ispravnim MIC-om, ali već je prethodno obrañena; GSS_S_OLD_TOKEN – značka je valjana i s ispravnim MIC-om, ali je previše stara za provjeru duplikata; GSS_S_UNSEQ_TOKEN - značka je valjana i s ispravnim MIC-om, ali je primljena izvan pravilnog redoslijeda, već je primljena značka sa kasnijim rednim brojem; GSS_S_GAP_TOKEN - značka je valjana i s ispravnim MIC-om, ali je primljena izvan pravilnog redoslijeda, značka s ranijim rednim brojem još nije primljena.

82

Napomene Nakon korištenja, memoriju na koju pokazuje parametar output_message_buffer potrebno je osloboditi pozivom funkcije gss_release_buffer().

Funkcije za upravljanje imenima

gss_import_name

Opis funkcije

Funkcija pretvara ime iz tekstualnog oblika u interni oblik.

Prototip funkcije

OM_uint32 gss_import_name ( OM_uint32 *minor_status, const gss_buffer_t input_name_buffer, const gss_OID input_name_type, gss_name_t *output_name );

input_name_buffer Meñuspremnik koji sadrži tekstualni prikaz imena koje treba pretvoriti u interni oblik.

Ulazni parametri

input_name_type Identifikator objekta koji označava tip tekstualnog prikaza imena. Može se postaviti na vrijednost GSS_C_NO_OID ako se koristi podrazumijevani tip za interni mehanizam ili na identifikator specifičnog tipa imenovanja koji će prepoznati implementacija GSSAPI-a.

output_name Vraćeno ime zapisano u internom obliku. Izlazni parametri *minor_status Status internog mehanizma. Povratne vrijednosti

U slučaju uspješnog izvršavanja, funkcija vraća statusni kod GSS_S_COMPLETE. U protivnom, vraća jednu od sljedećih vrijednosti: GSS_S_BAD_NAMETYPE – tip u parametru input_name_type nije prepoznat; GSS_S_BAD_NAME – sadržaj parametra input_name nije mogao biti interpretiran kao ime navedenog tipa; GSS_S_BAD_MECH – naveden je tip imena GSS_C_NT_EXPORT_NAME, ali mehanizam na kojeg se odnosi ulazno ime nije podržan.

Napomene Sadržaj na koji pokazuje parametar output_name treba nakon korištenja osloboditi pozivom funkcije gss_release_name().

gss_display_name

Opis funkcije

Funkcija omogućuje aplikaciji tekstualni prikaz internog oblika imena korisnika. Sintaksa tekstualnog oblika za prikaz definirana je implementacijom GSSAPI-a.

Prototip funkcije

OM_uint32 gss_display_name ( OM_uint32 *minor_status, const gss_name_t input_name, gss_buffer_t output_name_buffer, gss_OID *output_name_type );

Ulazni parametri

input_name Ime koje želimo prikazati.

83

output_name_buffer Meñuspremnik koji sadrži tekstualni prikaz imena.

output_name_type Tip vraćenog imena. Aplikacija ne bi trebala pokušavati osloboditi navedeni resurs. Ukoliko se ne koristi, parametar treba postaviti na NULL.

Izlazni parametri

minor_status Status internog mehanizma. Povratne vrijednosti

U slučaju uspješnog izvršavanja, funkcija vraća statusni kod GSS_S_COMPLETE. U protivnom, vraća GSS_S_BAD_NAME koji označava da ulazno ime nije bilo ispravno formirano.

Napomene Resurse na koje pokazuje parametar output_name_buffer treba nakon korištenja osloboditi pozivom funkcije gss_release_buffer().

gss_release_name

Opis funkcije

Funkcija oslobaña memoriju rezerviranu od strane GSSAPI-a za prikaz imena u internom obliku.

Prototip funkcije

OM_uint32 gss_release_name ( OM_uint32 *minor_status, gss_name_t *name );

Ulazni parametri

name Ime koje je potrebno izbrisati.

Izlazni parametri

minor_status Status internog mehanizma.

Povratne vrijednosti

U slučaju uspješnog izvršavanja, funkcija vraća statusni kod GSS_S_COMPLETE. U protivnom, vraća GSS_S_BAD_NAME koji označava da ulazni parametar nije sadržavao valjano ime.

gss_inquire_names_for_mech

Opis funkcije

Funkcija vraća skup tipova imena koje podržava navedeni mehanizam.

Prototip funkcije

OM_uint32 gss_inquire_names_for_mech ( OM_uint32 *minor_status, const gss_OID mechanism, gss_OID_set *name_types );

Ulazni parametri

mechanism Mehanizam nad kojim se vrši upit.

name_types Skup tipova imena koje podržava navedeni mehanizam.

Izlazni parametri

minor_status Status internog mehanizma. Povratne vrijednosti

U slučaju uspješnog izvršavanja, funkcija vraća statusni kod GSS_S_COMPLETE.

Napomene Sadržaj na koji pokazuje parametar name_types treba nakon korištenja osloboditi pozivom funkcije gss_release_oid_set().

84

Pomoćne funkcije

gss_display_status

Opis funkcije

Funkcija omogućava aplikaciji da dohvati tekstualni opis statusnog koda GSSAPI-a (za potrebe prikaza korisniku ili za potrebe bilježenja). Odreñene statusne vrijednosti mogu se odnositi na više uvjeta, tako da je funkciju ponekad potrebno pozvati više puta, svaki put za generiranje novog tekstualnog niza.

Prototip funkcije

OM_uint32 gss_display_status ( OM_uint32 *minor_status, OM_uint32 status_value, int status_type, const gss_OID mech_type, OM_uint32 *message_context, gss_buffer_t status_string ); status_value Statusna vrijednost koji treba pretvoriti u

tekstualni opis. status_type Vrsta statusne vrijednosti, može biti postavljen

na dvije vrijednosti: GSS_C_GSS_CODE – statusna vrijednost je GSS statusni kod; GSS_C_MECH_CODE – statusna vrijednost je statusni kod mehanizma.

Ulazni parametri

mech_type Odreñuje mehanizam koji se koristi za interpretaciju statusne vrijednosti (ukoliko je odabran tip GSS_C_MECH_CODE). Da bi se koristio podrazumijevani mehanizam, treba parametar postaviti na GSS_C_NO_OID.

message_context Prije prvog poziva funkcije mora biti postavljen na nulu. Nakon poziva funkcije, ako je parametar različit od nule, moguće je dohvatiti nove poruke ponovnim pozivanjem funkcije uz prosljeñivanje istih parametara status_value, status_type, mech_type i message_context.

status_string Tekstualna interpretacija parametra status_value.

Izlazni parametri

minor_status Status internog mehanizma. Povratne vrijednosti

U slučaju uspješnog izvršavanja, funkcija vraća statusni kod GSS_S_COMPLETE. U protivnom, vraća jednu od sljedećih vrijednosti: GSS_S_BAD_MECH – zatražena je interpretacija u skladu s mehanizmom koji nije podržan; GSS_S_BAD_STATUS – statusna vrijednost nije prepoznata ili vrsta statusne vrijednosti nije niti GSS_C_GSS_CODE, niti GSS_C_MECH_CODE.

Napomene Sadržaj na koji pokazuje parametar status_string treba nakon korištenja osloboditi pozivom funkcije gss_release_buffer().

85

gss_release_buffer

Opis funkcije

Funkcija oslobaña memoriju koju zauzima meñuspremnik, a koju je rezervirala neka GSSAPI rutina. Dodatno, funkcija sva polja meñuspremnika koja se odnose na duljinu postavlja na nulu.

Prototip funkcije

OM_uint32 gss_release_buffer ( OM_uint32 *minor_status, gss_buffer_t buffer );

Ulazni parametri

buffer Meñuspremnik čiju memoriju treba osloboditi. Opisnik objekta (gss_buffer_desc) koji je meñuspremnik sadržavao neće se izbrisati, već će sva polja koja se odnose na duljinu biti postavljena na nulu.

Izlazni parametri

minor_status Status internog mehanizma.

Povratne vrijednosti

U slučaju uspješnog izvršavanja, funkcija vraća statusni kod GSS_S_COMPLETE.

Napomene Svaki meñuspremnički objekt koji vraća bilo koja GSSAPI rutina može se proslijediti funkciji gss_release_buffer().

gss_release_oid_set

Opis funkcije

Funkcija oslobaña memoriju vezanu uz objekte tipa gss_OID_set generiranih od strane GSSAPI rutina. Funkcija oslobaña memoriju svakog pojedinog člana skupa, polja članova i opisnika skupa (gss_OID_set_desc).

Prototip funkcije

OM_uint32 gss_release_oid_set ( OM_uint32 *minor_status, gss_OID_set *set );

Ulazni parametri

set Skup identifikatora objekata koji će biti izbrisan.

Izlazni parametri

minor_status Status internog mehanizma.

Povratne vrijednosti

U slučaju uspješnog izvršavanja, funkcija vraća statusni kod GSS_S_COMPLETE.

86

Dodatak D: Izvorni tekstovi programa

SSPI poslužitelj

Datoteka SSPI_Posluzitelj.c

#include "SSPI_Razno.h" FILE *log_datoteka; int verbose = 0; //detaljni ispis /* Podrazumijevane zastavice konteksta */ OM_uint32 global_asc_flags = ASC_REQ_ALLOCATE_MEMORY | ASC_REQ_MUTUAL_AUTH; /***************************************************************** Funkcija Koristenje ispisuje upute za koristenje programa u slucaju nepravilnog pokretanja aplikacije ******************************************************************/ void Koristenje() { fprintf(stderr, "\nKoristenje: SSPI_Posluzitelj [-port port] [-v] [-x] [-log datoteka] [-conf] [-deleg] [-integ] [-mut] [-rep] [-seq] servis lozinka domena\n\n"); fprintf(stderr, "-port: port na kojem posluzitelj osluskuje vezu\n"); fprintf(stderr, "-v: detaljni ispis postupka autentifikacije\n"); fprintf(stderr, "-x: uspostavlja se samo jedna konekcija\n"); fprintf(stderr, "-log: informacije se zapisuju u datoteku\n"); fprintf(stderr, "-conf: postavlja se ASC_REQ_CONFIDENTIALITY\n"); fprintf(stderr, "-deleg: postavlja se ASC_REQ_DELEGATE\n"); fprintf(stderr, "-integ: postavlja se ASC_REQ_INTEGRITY\n"); fprintf(stderr, "-rep: postavlja se ASC_REQ_REPLAY_DETECT \n"); fprintf(stderr, "-seq: postavlja se ASC_REQ_SEQUENCE_DETECT \n"); fprintf(stderr, "servis: puno ime servisa (ime_servisa/dns_hosta)\n"); fprintf(stderr, "lozinka: lozinka servisa\n"); fprintf(stderr, "domena: naziv domene servisa\n\n"); exit(1); } /***************************************************************** Funkcija: DohvatiPosluziteljskeIsprave Ulazni parametri: ime_servisa - ime servisa kojem ce pristupati klijenti lozinka_servisa - lozinka korisnickog racuna za koji je vezan SPN servisa domena_servisa - domena u kojoj se obavlja autentifikacija Izlazni parametri: isprave_posluzitelja - GSSAPI isprave posluzitelja vlasnika servisa Povratna vrijednost: Po uspjesnom izvrsavanju vraca 0, inace vraca -1 Opis funkcije: Funkcija pribavlja isprave za Kerberos autentifikacijski protokol pozivanjem funkcije AcquireCredentialsHandle. ******************************************************************/ int DohvatiPosluziteljskeIsprave(char *ime_servisa, char *lozinka_servisa, char *domena_servisa, CredHandle *isprave_posluzitelja) { OM_uint32 glavni_status; TimeStamp vrijeme_isteka;

87

wchar_t w_lozinka[100]; wchar_t w_domena[100]; SEC_WINNT_AUTH_IDENTITY_W auth_identity; memset(&auth_identity,0,sizeof(auth_identity)); mbstowcs(w_lozinka, lozinka_servisa, sizeof(w_lozinka) / sizeof(wchar_t)); auth_identity.Password = w_lozinka; auth_identity.PasswordLength = (ULONG)wcslen(w_lozinka); mbstowcs(w_domena, domena_servisa, sizeof(w_domena) / sizeof(wchar_t)); auth_identity.Domain = w_domena; auth_identity.DomainLength = (ULONG)wcslen(w_domena); auth_identity.Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE; glavni_status = AcquireCredentialsHandle( ime_servisa, "Kerberos", SECPKG_CRED_INBOUND, NULL, &auth_identity, NULL, NULL, isprave_posluzitelja, vrijeme_isteka); if (glavni_status != SEC_E_OK) { IspisiGreskuSSPI("funkcija AcquireCredentialsHandle", glavni_status); return -1; } return 0; } /************************************************************* Funkcija: UspostaviKontekstPosluzitelja Ulazni parametri: s - uspostavljena TCP veza s klijentom isprave_posluzitelja - GSSAPI isprave posluzitelja vlasnika servisa Izlazni parametri: context - uspostavljeni GSSAPI sigurnosni kontekst ret_flags - zastavice uspostavljenog konteksta Povratna vrijednost: Po uspjesnom izvrsavanju vraca 0, inace vraca -1 Opis funkcije: Funkcija uspostavlja sigurnosni kontekst sa svakim klijentom koji podnese valjan zahtjev. *************************************************************/ int UspostaviKontekstPosluzitelja(int s, CredHandle *isprave_posluzitelja, CtxtHandle *context, OM_uint32 *ret_flags) { SecBufferDesc input_desc; SecBufferDesc output_desc; SecBuffer send_tok, recv_tok; OM_uint32 glavni_status; TimeStamp vrijeme_isteka; PCtxtHandle context_handle = NULL; int token_flags; context->dwUpper = 0; context->dwLower = 0; input_desc.cBuffers = 1; input_desc.ulVersion = SECBUFFER_VERSION; input_desc.pBuffers = &recv_tok; output_desc.cBuffers = 1; output_desc.ulVersion = SECBUFFER_VERSION; output_desc.pBuffers = &send_tok;

88

/* Primanje inicijalnog tokena */ if (PrimiToken(s, &token_flags, &recv_tok) < 0) return -1; if (recv_tok.pvBuffer) { free (recv_tok.pvBuffer); recv_tok.pvBuffer = NULL; recv_tok.cbBuffer = 0; } if (!(token_flags & TOKEN_NOOP)) { if (log_datoteka) fprintf(log_datoteka, "Ocekivan je NOOP token, primljen je token sa zastavicama %d\n", token_flags); return -1; } else if (verbose && log_datoteka) fprintf(log_datoteka, "\nPrimljen je inicijalni token, zapocinje postupak autentifikacije...\n"); if (token_flags & TOKEN_CONTEXT_NEXT) { /* Glavna petlja u kojoj se uspostavlja sigurnosni kontekst */ do { /* Primanje klijentovog tokena */ if (PrimiToken(s, &token_flags, &recv_tok) < 0) return -1; if (verbose && log_datoteka) { fprintf(log_datoteka, "Primljen je token velicine %d bajtova\n", recv_tok.cbBuffer); IspisiToken(&recv_tok); } recv_tok.BufferType = SECBUFFER_TOKEN; send_tok.cbBuffer = 0; send_tok.pvBuffer = NULL; send_tok.BufferType = SECBUFFER_TOKEN; /* Generiranje novog tokena i prihvacanje konteksta */ glavni_status = AcceptSecurityContext( isprave_posluzitelja, context_handle, &input_desc, global_asc_flags, SECURITY_NATIVE_DREP, context, &output_desc, ret_flags, &vrijeme_isteka ); if (glavni_status!=SEC_E_OK && glavni_status != SEC_I_CONTINUE_NEEDED) { IspisiGreskuSSPI("funkcija AcceptSecurityContext", glavni_status); (void) free(recv_tok.pvBuffer); return -1; } context_handle = context; free(recv_tok.pvBuffer); if (send_tok.cbBuffer != 0) { if (verbose && log_datoteka) { fprintf(log_datoteka, "Salje se accept_sec_context token velicine %d bajtova", send_tok.cbBuffer); IspisiToken(&send_tok); } /* Slanje tokena klijentu */

89

if (PosaljiToken(s, TOKEN_CONTEXT, &send_tok) < 0) { fprintf(log_datoteka, "Greska prilikom slanja tokena\n"); return -1; } FreeContextBuffer(send_tok.pvBuffer); send_tok.pvBuffer = NULL; } if (verbose && log_datoteka) { if (glavni_status == SEC_I_CONTINUE_NEEDED) fprintf(log_datoteka, "potrebno je nastaviti razmjenu tokena...\n"); else fprintf(log_datoteka, "\n"); fflush(log_datoteka); } } while (glavni_status == SEC_I_CONTINUE_NEEDED); /* Zastavice uspostavljenog konteksta */ IspisiZastaviceKonteksta(*ret_flags); if (log_datoteka) fprintf(log_datoteka, "Uspostavljena je sigurna veza koristenjem Kerberos protokola.\n"); } else { if (log_datoteka) fprintf(log_datoteka, "Prihvacena je neautentificirana veza.\n"); } return 0; } /****************************************************************** Funkcija: KreirajSpojnuTocku Ulazni parametri: port - broj porta na kojem ce posluzitelj osluskivati vezu Povratna vrijednost: Po uspjesnom izvrsavanju vraca opisnik uspostavljenog socketa, inace vraca -1 Opis funkcije: Funcija kreira TCP spojnu tocku (socket) na kojoj ce osluskivati vezu. ******************************************************************/ int KreirajSpojnuTocku(u_short port) { struct sockaddr_in saddr; int s; int on = 1; saddr.sin_family = AF_INET; saddr.sin_port = htons(port); saddr.sin_addr.s_addr = INADDR_ANY; /* Kreiranje socketa */ if ((s = (int)socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) { fprintf(stderr, "Greska prilikom kreiranja socketa\n"); return -1; } /* Odmah se omogucava ponovno koristenje socketa */ (void) setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on));

90

/* Povezivanje socketa */ if (bind(s, (struct sockaddr *) &saddr, sizeof(saddr)) == SOCKET_ERROR) { fprintf(stderr, "Greska prilikom povezivanja socketa\n"); (void) closesocket(s); return -1; } /* osluskivanje socketa */ if (listen(s, 5) == SOCKET_ERROR) { fprintf(stderr, "Greska prilikom osluskivanja socketa\n"); (void) closesocket(s); return -1; } return s; } /****************************************************************** Funkcija: PrihvatiKlijenta Ulazni parametri: s - TCP spojna tocka na kojoj je prihvacena konekcija isprave_posluzitelja - GSSAPI isprave posluzitelja vlasnika servisa Povratna vrijednost: Po uspjesnom izvrsavanju vraca 0, inace vraca -1 Opis funkcije: Funkcija uspostavlja kontekst s klijentom (pozivajuci funkciju UspostaviKontekstPosluzitelja), prima poruku, potpisuje ju i potpis salje nazad klijentu. Nakon toga unistava kontekst i zatvara vezu. ******************************************************************/ int PrihvatiKlijenta(int s, CredHandle *isprave_posluzitelja) { SecBuffer xmit_buf, poruka_buf; SecBuffer wrap_bufs[2]; SecBufferDesc wrap_buf_desc; CtxtHandle context; OM_uint32 glavni_status; int ret_flags; int token_flags; char *cp; SecPkgContext_Names imena_konteksta; SecPkgContext_Sizes velicine_konteksta; ULONG qop; /* Uspostavljanje konteksta s klijentom */ if (UspostaviKontekstPosluzitelja(s, isprave_posluzitelja, &context, &ret_flags) < 0) return (-1); /* Ispitivanje osobina konteksta */ if (!(context.dwUpper == 0 && context.dwLower == 0)) { glavni_status = QueryContextAttributes(&context, SECPKG_ATTR_NAMES, &imena_konteksta); if (glavni_status != SEC_E_OK) { IspisiGreskuSSPI("funkcija QueryContextAttributes",glavni_status); return ( -1 ); } if ( log_datoteka ) fprintf(log_datoteka, "Uspostavljena veza s klijentom: \"%s\"\n", imena_konteksta.sUserName); (void) FreeContextBuffer(imena_konteksta.sUserName); glavni_status = QueryContextAttributes(&context, SECPKG_ATTR_SIZES, &velicine_konteksta); if (glavni_status != SEC_E_OK) {

91

IspisiGreskuSSPI("funkcija QueryContextAttributes",glavni_status); return ( -1 ); } } do { /* Prima se token poruke klijenta */ if (PrimiToken(s, &token_flags, &xmit_buf) < 0) return (-1); /* NOOP token oznacava kraj razmjene poruka */ if (token_flags & TOKEN_NOOP) { if (verbose && log_datoteka) fprintf(log_datoteka, "Primljen NOOP token - kraj razmjene poruka.\n"); if(xmit_buf.pvBuffer) { free(xmit_buf.pvBuffer); xmit_buf.pvBuffer = 0; xmit_buf.cbBuffer = 0; } break; } if (verbose && log_datoteka) { fprintf(log_datoteka, "Primljena je poruka velicine %d bajtova.\nZastavice poruke (%d):", xmit_buf.cbBuffer, token_flags); if ( token_flags & TOKEN_NOOP ) fprintf(log_datoteka, " NOOP"); if ( token_flags & TOKEN_CONTEXT ) fprintf(log_datoteka, " CONTEXT"); if ( token_flags & TOKEN_DATA ) fprintf(log_datoteka, " DATA"); if ( token_flags & TOKEN_MIC ) fprintf(log_datoteka, " MIC" ); if ( token_flags & TOKEN_CONTEXT_NEXT ) fprintf(log_datoteka, " CONTEXT_NEXT" ); if ( token_flags & TOKEN_WRAPPED ) fprintf(log_datoteka, " WRAPPED" ); if ( token_flags & TOKEN_ENCRYPTED ) fprintf(log_datoteka, " ENCRYPTED" ); if ( token_flags & TOKEN_SEND_MIC ) fprintf(log_datoteka, " SEND_MIC" ); fprintf(log_datoteka, "\n"); IspisiToken(&xmit_buf); } /* Ispituje se ima li klijent pravo pristupa */ if ((context.dwUpper == 0 && context.dwLower == 0) && (token_flags & (TOKEN_WRAPPED|TOKEN_ENCRYPTED|TOKEN_SEND_MIC))) { if (log_datoteka) fprintf(log_datoteka, "Greska, neautentificirani klijent zahtijeva pristup uslugama koje zahtijevaju autentifikaciju!\n"); if(xmit_buf.pvBuffer) { free (xmit_buf.pvBuffer); xmit_buf.pvBuffer = 0; xmit_buf.cbBuffer = 0; } return(-1); } if (token_flags & TOKEN_WRAPPED) { wrap_buf_desc.cBuffers = 2; wrap_buf_desc.pBuffers = wrap_bufs;

92

wrap_buf_desc.ulVersion = SECBUFFER_VERSION; wrap_bufs[0].BufferType = SECBUFFER_STREAM; wrap_bufs[0].pvBuffer = xmit_buf.pvBuffer; wrap_bufs[0].cbBuffer = xmit_buf.cbBuffer; wrap_bufs[1].BufferType = SECBUFFER_DATA; wrap_bufs[1].cbBuffer = 0; wrap_bufs[1].pvBuffer = NULL; /* Dekriptiranje poruke */ glavni_status = DecryptMessage( &context, &wrap_buf_desc, 0, &qop ); if (glavni_status != SEC_E_OK) { IspisiGreskuSSPI("funkcija DecryptMessage", glavni_status); return (-1); } poruka_buf = wrap_bufs[1]; } else poruka_buf = xmit_buf; /* Ispisivanje poruke */ if ( log_datoteka ) { fprintf(log_datoteka, "Primljena je %sporuka: ", (qop == KERB_WRAP_NO_ENCRYPT ? "(samo digitalno potpisana) ": "")); cp = (char *) poruka_buf.pvBuffer; if (isprint(cp[0]) && isprint(cp[1])) { unsigned int i; fprintf(log_datoteka,"\""); for ( i=0; i<poruka_buf.cbBuffer; i++) fprintf(log_datoteka, "%c", cp[i]); fprintf(log_datoteka,"\"\n"); } else { printf("\n"); IspisiToken(&poruka_buf); } } /* Kreira se potpis primljene poruke kojeg treba poslati nazad */ if (token_flags & TOKEN_SEND_MIC) { wrap_bufs[0] = poruka_buf; wrap_bufs[1].BufferType = SECBUFFER_TOKEN; wrap_bufs[1].cbBuffer = velicine_konteksta.cbMaxSignature; wrap_bufs[1].pvBuffer = malloc(velicine_konteksta.cbMaxSignature); if (wrap_bufs[1].pvBuffer == NULL) { fprintf(stderr, "Greska pri rezerviranju memorije za potpis!\n"); return (-1); } glavni_status = MakeSignature( &context, 0, &wrap_buf_desc, 0 ); if (glavni_status != SEC_E_OK) { IspisiGreskuSSPI("funkcija MakeSignature", glavni_status); return (-1); } free(xmit_buf.pvBuffer);

93

xmit_buf.pvBuffer = NULL; xmit_buf.cbBuffer = 0; xmit_buf = wrap_bufs[1]; if(verbose && log_datoteka) fprintf(log_datoteka, "Salje se potpis primljene poruke velicine %d bajtova\n", xmit_buf.cbBuffer ); /* Potpis poruke se salje nazad klijentu */ if (PosaljiToken(s, TOKEN_MIC, &xmit_buf) < 0) return (-1); free(wrap_bufs[1].pvBuffer); wrap_bufs[1].pvBuffer = NULL; } else { if ( poruka_buf.pvBuffer ) free(poruka_buf.pvBuffer); poruka_buf.pvBuffer = 0; poruka_buf.cbBuffer = 0; } if (PosaljiToken(s, TOKEN_NOOP, prazni_token) < 0) return(-1); } while ( 1 ); /* iz petlje se izlazi po primitku NOOP tokena */ if (context.dwUpper != 0 || context.dwLower != 0) { /* Unistavanje konteksta */ glavni_status = DeleteSecurityContext( &context ); if (glavni_status != SEC_E_OK) { IspisiGreskuSSPI("funkcija DeleteSecurityContext", glavni_status); return (-1); } } if ( log_datoteka ) fflush(log_datoteka); return (0); } /* Prema uputama navedenim u funkciji Koristenje, u funkciji main se inicijaliziraju ulazni parametri programa. Pozivaju se funkcije DohvatiPosluziteljskeIsprave i KreirajSpojnuTocku, a zatim se osluskuje veza i u petlji za svaku konekciju s klijentom poziva se funkcija PrihvatiKlijenta. */ int _cdecl main(int argc, char **argv) { SOCKET sock; int err; WSADATA socket_podaci; USHORT verzija = 0x0101; char *ime_servisa; char *lozinka_servisa; char *domena_servisa; CredHandle isprave_posluzitelja; u_short port = 4444; int s; int jedno_izvrsavanje = 0;

94

log_datoteka = stdout; prikaz_dat = stdout; argc--; argv++; while (argc) { if (strcmp(*argv, "-port") == 0) { argc--; argv++; if (!argc) Koristenje(); port = (u_short)atoi(*argv); } else if (strcmp(*argv, "-v") == 0) verbose = 1; else if (strcmp(*argv, "-x") == 0) jedno_izvrsavanje = 1; else if (strcmp(*argv, "-log") == 0) { argc--; argv++; if (!argc) Koristenje(); log_datoteka = fopen(*argv, "a"); prikaz_dat = log_datoteka; if (!log_datoteka) { perror(*argv); exit(1); } } else if (strcmp(*argv, "-conf") == 0) global_asc_flags |= ASC_REQ_CONFIDENTIALITY; else if (strcmp(*argv, "-integ") == 0) global_asc_flags |= ASC_REQ_INTEGRITY; else if (strcmp(*argv, "-deleg") == 0) global_asc_flags |= ASC_REQ_DELEGATE; else if (strcmp(*argv, "-rep") == 0) global_asc_flags |= ASC_REQ_REPLAY_DETECT; else if (strcmp(*argv, "-seq") == 0) global_asc_flags |= ASC_REQ_SEQUENCE_DETECT; else break; argc--; argv++; } if (argc != 3) Koristenje(); if ((*argv)[0] == '-') Koristenje(); ime_servisa = *argv; argv++; lozinka_servisa = *argv; argv++; domena_servisa = *argv; if (DohvatiPosluziteljskeIsprave(ime_servisa, lozinka_servisa, domena_servisa, &isprave_posluzitelja) < 0) return -1; err = WSAStartup(verzija, &socket_podaci); if (err) fprintf(stderr,"Greska u inicijalizaciji WSA: %d\n",err); else if ((sock = KreirajSpojnuTocku(port))) { do { fd_set rfds; FD_ZERO(&rfds); FD_SET((DWORD)sock, &rfds);

95

if ( select(FD_SETSIZE, &rfds, NULL, NULL, 0) <= 0 || !FD_ISSET(sock, &rfds) ) fprintf(stderr,"Greska prilikom poziva funkcije select() na socketu!\n"); /* Prihvacanje TCP konekcije */ if ((s = (int)accept(sock, NULL, 0)) == SOCKET_ERROR) fprintf(stderr,"Greska prilikom prihvacanja veze!\n"); else /* Pocetak autentifikacije */ PrihvatiKlijenta(s, &isprave_posluzitelja); } while (!jedno_izvrsavanje); closesocket(sock); } (void) FreeCredentialsHandle( &isprave_posluzitelja); return 0; }

Datoteka SSPI_Razno.c

#include "SSPI_Razno.h" FILE *prikaz_dat; SecBuffer prazni_token_buf = { 0, 0 }; PSecBuffer prazni_token = &prazni_token_buf; int Posalji(int fildes, char *buf, unsigned int nbyte) { int ret; char *ptr; for (ptr = buf; nbyte; ptr += ret, nbyte -= ret) { ret = send(fildes, ptr, nbyte,0); if (ret < 0) return (ret); else if (ret == 0) break; } return (int)(ptr-buf); } int Primi(int fildes, char *buf, unsigned int nbyte) { int ret; char *ptr; fd_set rfds; struct timeval tv; FD_ZERO(&rfds); FD_SET((DWORD)fildes, &rfds); tv.tv_sec = 10; tv.tv_usec = 0; for (ptr = buf; nbyte; ptr += ret, nbyte -= ret) { if ( (select(FD_SETSIZE, &rfds, NULL, NULL, &tv) <= 0) || !FD_ISSET(fildes, &rfds) ) { perror("poziv funkcije select"); return(ptr-buf); } ret = recv(fildes, ptr, nbyte,0);

96

if (ret < 0) return (ret); else if (ret == 0) break; } return (int)(ptr-buf); } /************************************************************* Funkcija: PosaljiToken Ulazni parametri: s - opisnik otvorene datoteke u koju se zapisuje token (rijec je o opisniku povezanim sa socketom, tako da je zapravo rijec o slanju tokena) flags - zastavice tokena koje treba zapisati (poslati) token - token koji treba zapisati (poslati) Povratna vrijednost: Po uspjesnom izvrsavanju vraca 0, inace vraca -1 Opis funkcije: Ako zastavice nisu NULL, funkcija ih zapisuje kao jedan bajt podataka. Nakon njih zapisuje se duljina tokena i na kraju podaci tokena. *************************************************************/ int PosaljiToken(int s, int flags, PSecBuffer token) { int ret; unsigned char char_flags = (unsigned char) flags; unsigned char lenbuf[4]; if (char_flags) { ret = Posalji(s, (char *)&char_flags, 1); if (ret != 1) { perror("slanje zastavica tokena"); return -1; } } if (token->cbBuffer > 0xffffffffUL) abort(); lenbuf[0] = (unsigned char)((token->cbBuffer >> 24) & 0xff); lenbuf[1] = (unsigned char)((token->cbBuffer >> 16) & 0xff); lenbuf[2] = (unsigned char)((token->cbBuffer >> 8) & 0xff); lenbuf[3] = (unsigned char)(token->cbBuffer & 0xff); ret = Posalji(s, (char*) lenbuf, 4); if (ret < 0) { perror("slanje duljine tokena"); return -1; } else if (ret != 4) { if(prikaz_dat) fprintf(prikaz_dat, "Greska prilikom slanja duljine tokena: poslano %d od %d bajtova!\n", ret, 4); return -1; } ret = Posalji(s, (char*) token->pvBuffer, token->cbBuffer); if (ret < 0) { perror("slanje podataka tokena"); return -1; } else if ((ULONG)ret != token->cbBuffer) { fprintf(prikaz_dat,

97

"Greska prilikom slanja duljine tokena: poslano %d od %d bajtova!\n", ret, token->cbBuffer); return -1; } return 0; } /************************************************************* Funkcija: PrimiToken Ulazni parametri: s - opisnik otvorene datoteke iz koje se cita token (rijec je o opisniku povezanim sa socketom, tako da je zapravo rijec o primanju tokena) Izlazni parametri: flags - procitane (primljene) zastavice tokena token - procitani (primljeni) token Povratna vrijednost: Po uspjesnom izvrsavanju vraca 0, inace vraca -1 Opis funkcije: Funkcija cita zastavice iz prvog bajta podataka, nakon njih cita duljinu tokena, rezervira memoriju za token i na kraju cita token. *************************************************************/ int PrimiToken(int s, int *flags, PSecBuffer token) { int ret; unsigned char char_flags; unsigned char lenbuf[4]; ret = Primi(s, (char *) &char_flags, 1); if (ret < 0) { perror("primanje zastavica tokena"); return -1; } else if (! ret) { if(prikaz_dat) fprintf(prikaz_dat,"Greska prilikom primanja zastavica tokena: primljeno 0 bajtova\n"); return -1; } else { *flags = (int) char_flags; } if (char_flags == 0 ) { lenbuf[0] = 0; ret = Primi(s, &lenbuf[1], 3); if (ret < 0) { perror("primanje duljine tokena"); return -1; } else if (ret != 3) { if (prikaz_dat) fprintf(prikaz_dat, "Greska prilikom primanja duljine tokena: primljeno %d od %d bajtova\n", ret, 3); return -1; } } else { ret = Primi(s, lenbuf, 4);

98

if (ret < 0) { perror("primanje duljine tokena"); return -1; } else if (ret != 4) { if (prikaz_dat) fprintf(prikaz_dat, "Greska prilikom primanja duljine tokena: primljeno %d od %d bajtova\n", ret, 4); return -1; } } token->cbBuffer = ((lenbuf[0] << 24) | (lenbuf[1] << 16) | (lenbuf[2] << 8) | lenbuf[3]); token->pvBuffer = (char *) malloc(token->cbBuffer ? token->cbBuffer : 1); if (token->cbBuffer && token->pvBuffer == NULL) { fprintf(prikaz_dat,"Greska pri rezerviranju memorije za podatke tokena\n"); return -1; } ret = Primi(s, (char *) token->pvBuffer, token->cbBuffer); if (ret < 0) { perror("primanje podataka tokena"); free(token->pvBuffer); return -1; } else if ((ULONG)ret != token->cbBuffer) { if(prikaz_dat) fprintf(prikaz_dat,"Greska prilikom primanja podataka tokena: primljeno %d od %d bajtova\n", ret, token->cbBuffer); free(token->pvBuffer); return -1; } return 0; } /************************************************************* Funkcija: IspisiGreskuSSPI Ulazni parametri: poruka - niz znakova poslan za ispis pored greske glavni_status - GSSAPI glavni statusni kod Opis funkcije: Funkcija ispisuje gresku u formatu "SSPI greska, <poruka>: maj_stat", pri cemu je poruka ime funkcije koja je izazvala gresku. *************************************************************/ void IspisiGreskuSSPI(char *poruka, ULONG glavni_status) { if(prikaz_dat) fprintf(prikaz_dat, "SSPI greska, %s: %x\n", poruka, glavni_status); } /* Funkcija ispisuje zastavice konteksta */ void IspisiZastaviceKonteksta(ULONG flags) { fprintf(prikaz_dat,"\nZastavice uspostavljenog konteksta:\n"); if (flags & GSS_C_DELEG_FLAG)

99

fprintf(prikaz_dat, "GSS_C_DELEG_FLAG\n"); if (flags & GSS_C_MUTUAL_FLAG) fprintf(prikaz_dat, "GSS_C_MUTUAL_FLAG\n"); if (flags & GSS_C_REPLAY_FLAG) fprintf(prikaz_dat, "GSS_C_REPLAY_FLAG\n"); if (flags & GSS_C_SEQUENCE_FLAG) fprintf(prikaz_dat, "GSS_C_SEQUENCE_FLAG\n"); if (flags & GSS_C_CONF_FLAG ) fprintf(prikaz_dat, "GSS_C_CONF_FLAG \n"); if (flags & GSS_C_INTEG_FLAG ) fprintf(prikaz_dat, "GSS_C_INTEG_FLAG \n"); } void IspisiToken(PSecBuffer token) { ULONG i; unsigned char *p = (PUCHAR) token->pvBuffer; if (!prikaz_dat) return; for (i=0; i < token->cbBuffer; i++, p++) { fprintf(prikaz_dat, "%02x ", *p); if ((i % 16) == 15) fprintf(prikaz_dat, "\n"); } fprintf(prikaz_dat, "\n"); fflush(prikaz_dat); }

Datoteka SSPI_Razno.h

#include <windows.h> #include <rpc.h> #include <stdio.h> #include <stdlib.h> #include <io.h> #include <fcntl.h> #define SECURITY_WIN32 #include <security.h> #include <ntsecapi.h> #include "GSSAPI.h" extern FILE *prikaz_dat; int PosaljiToken(int s, int flags, PSecBuffer token); int PrimiToken(int s, int *flags, PSecBuffer token); void IspisiGreskuSSPI(char *poruka, ULONG glavni_status); void IspisiZastaviceKonteksta(ULONG flags); void IspisiToken(PSecBuffer token); /* vrste tokena */ #define TOKEN_NOOP (1<<0) #define TOKEN_CONTEXT (1<<1) #define TOKEN_DATA (1<<2) #define TOKEN_MIC (1<<3) /* zastavice tokena */ #define TOKEN_CONTEXT_NEXT (1<<4) #define TOKEN_WRAPPED (1<<5) #define TOKEN_ENCRYPTED (1<<6) #define TOKEN_SEND_MIC (1<<7)

100

extern PSecBuffer prazni_token;

Datoteka GSSAPI.h

typedef unsigned long gss_uint32; typedef long gss_int32; typedef gss_uint32 OM_uint32; typedef OM_uint32 gss_qop_t; #define GSS_C_DELEG_FLAG 1 #define GSS_C_MUTUAL_FLAG 2 #define GSS_C_REPLAY_FLAG 4 #define GSS_C_SEQUENCE_FLAG 8 #define GSS_C_CONF_FLAG 16 #define GSS_C_INTEG_FLAG 32 #define GSS_C_ANON_FLAG 64 #define GSS_C_GSS_CODE 1 #define GSS_C_MECH_CODE 2

101

SSPI klijent

Datoteke SSPI_Razno.c, SSPI_Razno.h i GSSAPI.h već su navedene kod SSPI poslužitelja.

Datoteka SSPI_Klijent.c

#include "SSPI_Razno.h" namespace SSPIKlijent { using namespace System; using namespace System::ComponentModel; using namespace System::Collections; using namespace System::Windows::Forms; using namespace System::Data; using namespace System::Drawing; using namespace System::IO;

SecBuffer prazni_token_buf = { 0, 0 }; PSecBuffer prazni_token = &prazni_token_buf; char ispis_buffer[40000]; //pomocno polje za ispis public __gc class Form1 : public System::Windows::Forms::Form { public: //Konstruktor klase, inicijalizacija sucelja Form1(void) { InitializeComponent(); //podrazumijevano je da su sve opcije iz check liste omogucene int max = checkedListBox1->Items->get_Count();

for(int i=0; i<max; i++) checkedListBox1 -> SetItemChecked(i,1); //imena na sucelju button1->Text="Autentificiraj!"; button2->Text="Spremi"; button3->Text="Izbrisi"; //Ucitavanje podataka o servisima Char denominator[] = {'#'}; String *red; String *podaci[]; StreamReader *sr = File::OpenText("Lista servisa.txt"); while((red=sr->ReadLine()) != NULL){ podaci = red->Split(denominator); if(podaci->get_Count() != 4) continue; comboBox1->Items->Add(new Servis_Objekt(podaci[0],

podaci[1],podaci[2],podaci[3]));} sr->Close(); if(!comboBox1->Items->get_Count()) { //ako nema elemenata u listi servisa, podrazumijevane vrijednosti textBox1 -> Text = "test/vserver.starjak.local"; textBox2 -> Text = "vserver.starjak.local"; textBox3 -> Text = "4444"; }

102

else comboBox1->set_SelectedIndex(0); //poruka, statusni prozor i datoteka textBox4 -> Text = "Pozdrav od klijenta!"; textBox5 -> Text = ""; textBox6->Text = ""; textBox6->set_Enabled(0); } protected: void Dispose(Boolean disposing) { if (disposing && components) components->Dispose(); __super::Dispose(disposing); } /* Deklaracije komponenata sucelja*/ private: System::Windows::Forms::TextBox * textBox1; private: System::Windows::Forms::TextBox * textBox2; private: System::Windows::Forms::TextBox * textBox3; private: System::Windows::Forms::TextBox * textBox4; private: System::Windows::Forms::TextBox * textBox5; private: System::Windows::Forms::TextBox * textBox6; private: System::Windows::Forms::ComboBox * comboBox1; private: System::Windows::Forms::Button * button1; private: System::Windows::Forms::Button * button2; private: System::Windows::Forms::Button * button3; private: System::Windows::Forms::CheckBox * checkBox1; private: System::Windows::Forms::CheckBox * checkBox2; private: System::Windows::Forms::CheckedListBox * checkedListBox1; private: System::Windows::Forms::CheckedListBox * checkedListBox2; private: System::Windows::Forms::Label * label1; private: System::Windows::Forms::Label * label2; private: System::Windows::Forms::Label * label3; private: System::Windows::Forms::Label * label4; private: System::Windows::Forms::Label * label5; private: System::Windows::Forms::Label * label6; private: System::Windows::Forms::Label * label7; private: System::Windows::Forms::Label * label8; private: //zastavice za kontroliranje nacina izvodjenja programa static int verbose = 1; static int auth_flag = 1; static int wrap_flag = 1; static int encrypt_flag = 1; static int mic_flag = 1; static int poruka_iz_datoteke = 0; static int brojac_sjednice = 1; private: System::ComponentModel::Container * components;

void InitializeComponent(void){} private: System::Void button1_Click(System::Object * sender, System::EventArgs * e) { /* Glavni program */ Autentificiraj(); } private: System::Void button2_Click(System::Object * sender, System::EventArgs * e) { /* Spremanje servisa iz liste u datoteku "Lista servisa.txt" */

103

SpremiInfoServisa(); } private: System::Void button3_Click(System::Object * sender, System::EventArgs * e) { /* Brisanje servisa iz liste servisa */ int br = comboBox1->Items->get_Count(); if(!br) return; System::Windows::Forms::DialogResult dr; dr = MessageBox::Show("Jeste li sigurni?", "Brisanje clana liste servisa:", MessageBoxButtons::YesNo, MessageBoxIcon::Question ); if( dr == DialogResult::No ) return; int trenutni = comboBox1->get_SelectedIndex(); if(trenutni >= 0) comboBox1->get_Items()->RemoveAt(trenutni); if(trenutni) comboBox1->set_SelectedIndex(trenutni-1); else if(br > 1)comboBox1->set_SelectedIndex(0); SpremiListu(); comboBox1->Refresh(); } private: System::Void checkBox1_CheckedChanged(System::Object * sender, System::EventArgs * e) { /* indikator detaljnog ispisa postupka autentifikacije */ verbose = checkBox1->get_Checked(); } private: System::Void checkBox2_CheckedChanged(System::Object * sender, System::EventArgs * e) { /* indikator za ucitavanje poruke iz datoteke */ poruka_iz_datoteke = checkBox2->get_Checked(); textBox4->set_Enabled(!poruka_iz_datoteke); textBox6->set_Enabled(poruka_iz_datoteke); } private: System::Void comboBox1_SelectedIndexChanged(System::Object * sender, System::EventArgs * e) { /* Ucitavanje podataka o odabranom servisu iz liste servisa */ Char delimiter[]={'#'}; Servis_Objekt *item = (Servis_Objekt*) comboBox1-> get_SelectedItem(); String *rez[] = item->Podaci(); textBox1->Text = rez[0]; textBox2->Text = rez[1]; textBox3->Text = rez[2]; } private: System::Void textBox5_TextChanged(System::Object * sender, System::EventArgs * e) { /* pomicanje na kraj teksta */ textBox5->Select(textBox5->Text->get_Length(),0); textBox5->ScrollToCaret(); } /*********************************************************** Funkcija: UspostaviVezu Ulazni parametri: host - ime racunala na kojem se izvrsava servis port - port na kojem posluzitelj osluskuje vezu

104

Povratna vrijednost: Po uspjesnom izvrsavanju vraca opisnik socketa, inace vraca -1 Opis funkcije: Funkcija otvara TCP konekciju prema zadanom hostu na zadanom portu koristenjem parametra "saddr" koji se dobio pozivom funkcije DohvatiInfoPosluzitelja. ************************************************************/ int UspostaviVezu(char *host, u_short port) { struct sockaddr_in saddr; struct hostent *hp; int s; int err; WSADATA socket_data; USHORT verzija = 0x0101; err = WSAStartup(verzija, &socket_data); if (err) { sprintf(ispis_buffer,"Greska pri inicijal. WSA: %d\n",err); IspisiTekst(ispis_buffer); return (-1); } if ((hp = gethostbyname(host)) == NULL) { sprintf(ispis_buffer, "Nepoznati posluzitelj: %s\n", host); IspisiTekst(ispis_buffer); return -1; } saddr.sin_family = hp->h_addrtype; memcpy((char *)&saddr.sin_addr, hp->h_addr, sizeof(saddr.sin_addr)); saddr.sin_port = htons(port);

if ((s = (int)socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) {

IspisiTekst("Greska pri kreiranju socketa!\n"); return -1; } if (connect(s, (struct sockaddr *)&saddr, sizeof(saddr)) == SOCKET_ERROR) { IspisiTekst("Greska pri spajanju s posluziteljem!\n"); (void) closesocket(s); return -1; } return s; } /************************************************************ Funkcija: UspostaviKontekstKlijenta Ulazni parametri: s - uspostavljena TCP konekcija sa servisom ime_servisa - ime servisa s kojim je uspostavljena konekcija gss_flags - delegacijske zastavice klijenta auth_flag - zastavica koja odredjuje hoce li se obavljati autentifikacija ili ne Izlazni parametri: gss_context - uspostavljeni GSSAPI kontekst ret_flags - zastavice uspostavljenog konteksta Povratna vrijednost: Po uspjesnom izvrsavanju vraca 0, inace vraca -1 Opis funkcije:

105

Funkcija kreira GSSAPI ime servisa importiranjem parametra ime_servisa i zatim uspostavlja podrazumijevani (Kerberos) sigurnosni kontekst s tim servisom. ***********************************************************/ int UspostaviKontekstKlijenta(int s, char *ime_servisa, OM_uint32 gss_flags, CtxtHandle *gss_context, OM_uint32 *ret_flags) { if ( auth_flag ) { SecBuffer send_tok, recv_tok; SecBufferDesc input_desc, output_desc; OM_uint32 glavni_status; CredHandle cred_handle; TimeStamp istek_vremena; PCtxtHandle context_handle = NULL; int token_flags; input_desc.cBuffers = 1; input_desc.pBuffers = &recv_tok; input_desc.ulVersion = SECBUFFER_VERSION; recv_tok.BufferType = SECBUFFER_TOKEN; recv_tok.cbBuffer = 0; recv_tok.pvBuffer = NULL; output_desc.cBuffers = 1; output_desc.pBuffers = &send_tok; output_desc.ulVersion = SECBUFFER_VERSION; send_tok.BufferType = SECBUFFER_TOKEN; send_tok.cbBuffer = 0; send_tok.pvBuffer = NULL; cred_handle.dwLower = 0; cred_handle.dwUpper = 0; glavni_status = AcquireCredentialsHandle( NULL, "Kerberos", SECPKG_CRED_OUTBOUND, NULL, NULL, NULL, NULL, cred_handle, &istek_vremena); if (glavni_status != SEC_E_OK) { IspisiGreskuSSPI("funkcija AcquireCredentialsHandle",glavni_status); return (-1); } /* Slanje inicijalnog tokena */ if (verbose) IspisiTekst("Salje se inicijalni token...\n"); if (PosaljiToken(s, TOKEN_NOOP|TOKEN_CONTEXT_NEXT, prazni_token) < 0) { return -1; } gss_context->dwLower = 0; gss_context->dwUpper = 0; /* Glavna petlja za uspostavljanje sigurnosnog konteksta */ do { glavni_status = InitializeSecurityContext( &cred_handle, context_handle, ime_servisa, gss_flags, 0, SECURITY_NATIVE_DREP, &input_desc, 0,_context, &output_desc, ret_flags, &istek_vremena );

106

if (recv_tok.pvBuffer) { free(recv_tok.pvBuffer); recv_tok.pvBuffer = NULL; recv_tok.cbBuffer = 0; } context_handle = gss_context; if (glavni_status!=SEC_E_OK && glavni_status!=SEC_I_CONTINUE_NEEDED) { IspisiGreskuSSPI("funkcija InitializeSecurityContext", glavni_status); FreeCredentialsHandle(&cred_handle); return -1; } if (send_tok.cbBuffer != 0) { sprintf(ispis_buffer, "Salje se init_sec_context token velicine %d bajtova...\n", send_tok.cbBuffer); IspisiTekst(ispis_buffer); /* Salje se token posluzitelju */ if (PosaljiToken(s, TOKEN_CONTEXT, &send_tok) < 0) { FreeContextBuffer(send_tok.pvBuffer); FreeCredentialsHandle(&cred_handle); return -1; } } FreeContextBuffer(send_tok.pvBuffer); send_tok.pvBuffer = NULL; send_tok.cbBuffer = 0; if (glavni_status == SEC_I_CONTINUE_NEEDED) { IspisiTekst("Potrebno je nastaviti razmjenu tokena...\n"); /* Primanje tokena */ if (PrimiToken(s, &token_flags, &recv_tok) < 0) { FreeCredentialsHandle(&cred_handle); return -1; } sprintf(ispis_buffer, "Primljen je token velicine %d bajtova...\n", recv_tok.cbBuffer ); IspisiTekst(ispis_buffer); } } while (glavni_status == SEC_I_CONTINUE_NEEDED); FreeCredentialsHandle(&cred_handle); IspisiTekst("Kontekst uspostavljen!\n"); } else { /* Slanje zavrsnog tokena */ if (PosaljiToken(s, TOKEN_NOOP, prazni_token) < 0) return -1; } return 0; } /* Funkcija iz datoteke ucitava poruku namijenjenu posluzitelju */ void UcitajDatoteku(char *ime_dat, PSecBuffer in_buf) { int fd; ULONG ucitani_bajtovi, br; UCHAR buf[100]; if ((fd = _open(ime_dat, O_RDONLY, 0)) < 0) {

107

sprintf(ispis_buffer, "Greska u otvaranju datoteke %s\n", ime_dat); IspisiTekst(ispis_buffer); exit(1); } for (ucitani_bajtovi = 0; ; ucitani_bajtovi += br) { br = _read(fd, buf, sizeof(buf)); if (br < 0) exit(1); if (br == 0) break; } _close(fd); if ((fd = _open(ime_dat, O_RDONLY, 0)) < 0) { sprintf(ispis_buffer, "Greska u otvaranju datoteke %s\n", ime_dat); IspisiTekst(ispis_buffer); exit(1); } in_buf->cbBuffer = ucitani_bajtovi; in_buf->pvBuffer = malloc(in_buf->cbBuffer); if (in_buf->pvBuffer == 0) { sprintf(ispis_buffer, "Greska u rezerviranju %d bajtova za ucitavanje datoteke\n", in_buf->cbBuffer); IspisiTekst(ispis_buffer); exit(1); } memset(in_buf->pvBuffer, 0, in_buf->cbBuffer); for (ucitani_bajtovi = 0; ucitani_bajtovi < in_buf->cbBuffer; ucitani_bajtovi += br) { br = _read(fd, (PUCHAR) in_buf->pvBuffer+ucitani_bajtovi, in_buf->cbBuffer-ucitani_bajtovi); if (br < 0) exit(1); if (br == 0) break; } } /************************************************************* Funkcija: PozoviPosluzitelja Ulazni parametri: host - ime racunala na kojem se izvrsava servis port - port na kojem posluzitelj osluskuje vezu ime_servisa - ime servisa s kojim ce se uspostaviti konekcija gss_flags - delegacijske zastavice klijenta poruka - poruka ili ime datoteke koju treba poslati posluzitelju Povratna vrijednost: Po uspjesnom izvrsavanju vraca 0, inace vraca -1 Opis funkcije: Funkcija kreira TCP konekciju prema posluzitelju, uspostavlja sigurnosni kontekst, salje poruku posluzitelju, prima potpis poruke od posluzitelja i provjerava ga. *************************************************************/ int PozoviPosluzitelja(char *host, u_short port, char *ime_servisa, OM_uint32 gss_flags, char *poruka) { CtxtHandle context;

108

SecBuffer in_buf, out_buf; SecBuffer wrap_bufs[3]; SecBufferDesc in_buf_desc; SecPkgContext_Sizes sizes; int s; OM_uint32 ret_flags; OM_uint32 glavni_status; gss_qop_t qop_status; int token_flags; char ime_dat[200]; /* Otvaranje konekcije s posluziteljem */ if ((s = UspostaviVezu(host, port)) < 0) return -1; /* Uspostavljenje kosteksta s posluziteljem */ if (UspostaviKontekstKlijenta( s, ime_servisa, gss_flags, &context, &ret_flags) < 0) { (void) closesocket(s); return -1; } if (auth_flag && verbose) { IspisiZastaviceKonteksta(ret_flags); } if ( auth_flag && (wrap_flag || mic_flag) ) { glavni_status = QueryContextAttributes( &context, SECPKG_ATTR_SIZES, &sizes ); if (glavni_status != SEC_E_OK) { IspisiGreskuSSPI("funkcija QueryContextAttributes", glavni_status); return (-1); } } if (poruka_iz_datoteke) { int tmp = textBox6->Text->get_Length(); for(int i=0; i<tmp; i++) ime_dat[i] = textBox6->Text->get_Chars(i); UcitajDatoteku(ime_dat, &in_buf); } else { in_buf.pvBuffer = poruka; in_buf.cbBuffer = (ULONG)strlen(poruka) + 1; } /* Priprema za enripciju poruke */ if (verbose) { IspisiTekst("\nPriprema poruke:\n"); sprintf(ispis_buffer, "Velicine enkripcijskih struktura u bajtovima\nStruktura SECBUFFER_TOKEN: %d\nStruktura SECBUFFER_DATA: %d (poruka)\nStruktura SECBUFFER_PADDING: %d\n", sizes.cbSecurityTrailer, in_buf.cbBuffer, sizes.cbBlockSize); IspisiTekst(ispis_buffer); } if ( auth_flag && wrap_flag ) { in_buf_desc.cBuffers = 3; in_buf_desc.pBuffers = wrap_bufs; in_buf_desc.ulVersion = SECBUFFER_VERSION;

109

wrap_bufs[0].cbBuffer = sizes.cbSecurityTrailer; wrap_bufs[0].BufferType = SECBUFFER_TOKEN; wrap_bufs[0].pvBuffer = malloc(sizes.cbSecurityTrailer); if (wrap_bufs[0].pvBuffer == NULL) { sprintf(ispis_buffer, "Greska u rezerviranju memorije za strukturu SECBUFFER_TOKEN\n"); IspisiTekst(ispis_buffer); if (poruka_iz_datoteke) free(in_buf.pvBuffer); (void) closesocket(s); (void) DeleteSecurityContext(&context); return (-1); } wrap_bufs[1].BufferType = SECBUFFER_DATA; wrap_bufs[1].cbBuffer = in_buf.cbBuffer; wrap_bufs[1].pvBuffer = malloc(wrap_bufs[1].cbBuffer); if (wrap_bufs[1].pvBuffer == NULL) { free(wrap_bufs[0].pvBuffer); wrap_bufs[0].pvBuffer = NULL; sprintf(ispis_buffer,"Greska u rezerviranju memorije za strukturu SECBUFFER_DATA\n"); IspisiTekst(ispis_buffer); if (poruka_iz_datoteke) free(in_buf.pvBuffer); (void) closesocket(s); (void) DeleteSecurityContext(&context); return (-1); } wrap_bufs[2].BufferType = SECBUFFER_PADDING; wrap_bufs[2].cbBuffer = sizes.cbBlockSize; wrap_bufs[2].pvBuffer = malloc(wrap_bufs[2].cbBuffer); if (wrap_bufs[2].pvBuffer == NULL) { free(wrap_bufs[0].pvBuffer); wrap_bufs[0].pvBuffer = NULL; free(wrap_bufs[1].pvBuffer); wrap_bufs[1].pvBuffer = NULL; sprintf(ispis_buffer,"Greska u rezerviranju memorije za strukturu SECBUFFER_PADDING\n"); IspisiTekst(ispis_buffer); if (poruka_iz_datoteke) free(in_buf.pvBuffer); (void) closesocket(s); (void) DeleteSecurityContext(&context); return (-1); } memcpy( wrap_bufs[1].pvBuffer, in_buf.pvBuffer, in_buf.cbBuffer ); glavni_status = EncryptMessage( &context, encrypt_flag ? 0 : KERB_WRAP_NO_ENCRYPT, &in_buf_desc, 0); if (glavni_status != SEC_E_OK) { IspisiGreskuSSPI("funkcija EncryptMessage", glavni_status);

110

(void) closesocket(s); (void) DeleteSecurityContext(&context); return -1; } /*Kreiranje poruke za posluzitelja*/ out_buf.cbBuffer = wrap_bufs[0].cbBuffer + wrap_bufs[1].cbBuffer + wrap_bufs[2].cbBuffer; out_buf.pvBuffer = malloc(out_buf.cbBuffer); if (out_buf.pvBuffer == NULL) { free(wrap_bufs[0].pvBuffer); wrap_bufs[0].pvBuffer = NULL; free(wrap_bufs[1].pvBuffer); wrap_bufs[1].pvBuffer = NULL; free(wrap_bufs[2].pvBuffer); wrap_bufs[2].pvBuffer = NULL; sprintf(ispis_buffer,"Greska u rezerviranju memorije za izlaznu poruku\n"); IspisiTekst(ispis_buffer); if (poruka_iz_datoteke) free(in_buf.pvBuffer); (void) closesocket(s); (void) DeleteSecurityContext(&context); return (-1); } memcpy( out_buf.pvBuffer, wrap_bufs[0].pvBuffer, wrap_bufs[0].cbBuffer ); memcpy( (PUCHAR) out_buf.pvBuffer + (int) wrap_bufs[0].cbBuffer, wrap_bufs[1].pvBuffer, wrap_bufs[1].cbBuffer ); memcpy( (PUCHAR) out_buf.pvBuffer + wrap_bufs[0].cbBuffer + wrap_bufs[1].cbBuffer, wrap_bufs[2].pvBuffer, wrap_bufs[2].cbBuffer ); } else out_buf = in_buf; /* Posalji token posluzitelju */ if(verbose){ sprintf(ispis_buffer, "Salje se token poruke velicine %d bajtova...\n", out_buf.cbBuffer ); IspisiTekst(ispis_buffer); } if (PosaljiToken(s, TOKEN_DATA | (wrap_flag ? TOKEN_WRAPPED : 0) | (encrypt_flag ? TOKEN_ENCRYPTED : 0) | (mic_flag ? TOKEN_SEND_MIC : 0), &out_buf) < 0) { if ( auth_flag && wrap_flag ) { free(wrap_bufs[0].pvBuffer); wrap_bufs[0].pvBuffer = NULL; free(wrap_bufs[1].pvBuffer); wrap_bufs[1].pvBuffer = NULL; free(wrap_bufs[2].pvBuffer); wrap_bufs[2].pvBuffer = NULL; free(out_buf.pvBuffer); } out_buf.pvBuffer = NULL; out_buf.cbBuffer = 0; if (poruka_iz_datoteke) free(in_buf.pvBuffer); (void) closesocket(s);

111

(void) DeleteSecurityContext(&context); return -1; } sprintf(ispis_buffer, "Poruka uspjesno poslana.\n"); IspisiTekst(ispis_buffer); if ( auth_flag && wrap_flag ) { free(wrap_bufs[0].pvBuffer); wrap_bufs[0].pvBuffer = NULL; free(wrap_bufs[1].pvBuffer); wrap_bufs[1].pvBuffer = NULL; free(wrap_bufs[2].pvBuffer); wrap_bufs[2].pvBuffer = NULL; free(out_buf.pvBuffer); } out_buf.pvBuffer = NULL; out_buf.cbBuffer = 0; /* Primanje potpisa poruke */ if (PrimiToken(s, &token_flags, &out_buf) < 0) { if (poruka_iz_datoteke) free(in_buf.pvBuffer); (void) closesocket(s); (void) DeleteSecurityContext( &context); return -1; } if(verbose){ sprintf(ispis_buffer, "Primljena je poruka velicine %d bajtova...\n", out_buf.cbBuffer ); IspisiTekst(ispis_buffer); } if ( auth_flag && mic_flag ) { /* Verificiranje potpisa */ in_buf_desc.cBuffers = 2; wrap_bufs[0] = in_buf; wrap_bufs[0].BufferType = SECBUFFER_DATA; wrap_bufs[1] = out_buf; wrap_bufs[1].BufferType = SECBUFFER_TOKEN; glavni_status = VerifySignature(&context, &in_buf_desc, 0, &qop_status); if (glavni_status != SEC_E_OK) { IspisiGreskuSSPI("funkcija VerifySignature", glavni_status); free(out_buf.pvBuffer); if (poruka_iz_datoteke) free(in_buf.pvBuffer); (void) closesocket(s); (void) DeleteSecurityContext( &context); return -1; } sprintf(ispis_buffer, "Digitalni potpis verificiran.\n"); IspisiTekst(ispis_buffer); } else { sprintf(ispis_buffer, "Odgovor posluzitelja zaprimljen.\n"); IspisiTekst(ispis_buffer); } free(out_buf.pvBuffer); if (poruka_iz_datoteke) free(in_buf.pvBuffer);

112

/* Posalji NOOP token */ (void) PosaljiToken(s, TOKEN_NOOP, prazni_token); if ( auth_flag ) { /* Brisanje konteksta */ glavni_status = DeleteSecurityContext(&context); if (glavni_status != SEC_E_OK) { IspisiGreskuSSPI("funkcija DeleteSecurityContext", glavni_status); (void) closesocket(s); return -1; } } (void) closesocket(s); return 0; } /* Funkcija za ispisivanje teksta u multiline textbox*/ void IspisiTekst(char* tekst) { Char delimiter[] = {'#'}; String *stari_tekst[] = textBox5->get_Lines(); String *novo = tekst; novo = novo->Replace("\n","#"); String *spojeni = String::Concat(String::Join("#", stari_tekst ),novo) ; String *ukupni_tekst[] = spojeni->Split(delimiter); textBox5->set_Lines(ukupni_tekst); textBox5->Refresh(); } /*Funkcija za spremanje podataka o servisima u datoteku */ void SpremiListu() { Servis_Objekt *clan_liste; StreamWriter *sw = new StreamWriter("Lista servisa.txt"); int velicina_liste = comboBox1->Items->get_Count(); sw->set_NewLine("\n"); for(int i=0; i<velicina_liste; i++) { clan_liste = (Servis_Objekt *) comboBox1->Items->get_Item(i); sw->Write(clan_liste->DohvatiIme()); sw->Write("#"); sw->Write(clan_liste->Dohvati(0)); sw->Write("#"); sw->Write(clan_liste->Dohvati(1)); sw->Write("#"); sw->Write(clan_liste->Dohvati(2)); sw->WriteLine(); } sw->Close(); } /* Funkcija za dodavanje novog servisa s podacima u listu */ void SpremiInfoServisa() { String *tekst = comboBox1->get_Text(); int trenutni = comboBox1->FindStringExact(tekst); if( trenutni != -1 ) { System::Windows::Forms::DialogResult dr; dr = MessageBox::Show("Servis s odabranim imenom vec postoji u popisu servisa.\nZelite li ga zamijeniti?", "Unos imena servisa:", MessageBoxButtons::YesNo, MessageBoxIcon::Exclamation );

113

if( dr == DialogResult::Yes ) { Servis_Objekt *tmp = (Servis_Objekt *) comboBox1->Items->get_Item(trenutni); tmp->Popuni(tekst, textBox1->Text, textBox2->Text, textBox3->Text); SpremiListu(); } return; } Servis_Objekt *novi_clan = new Servis_Objekt(tekst, textBox1->Text, textBox2->Text, textBox3->Text); comboBox1->Items->Add(novi_clan); SpremiListu(); } /* Glavni program koji ucitava parametre zadane suceljem i pokrece postupak autentifikacije */ void Autentificiraj() { char ime_servisa[100], posluzitelj_host[100], poruka[2000]; u_short port = 4444; OM_uint32 gss_flags = ISC_REQ_ALLOCATE_MEMORY; //citanje podataka iz tekst polja: int tmp = textBox2->Text->get_Length(); for(int i=0; i<tmp; i++) posluzitelj_host[i] = textBox2->Text->get_Chars(i); tmp = textBox1->Text->get_Length(); for(int i=0; i<tmp; i++) ime_servisa[i] = textBox1->Text->get_Chars(i); tmp = textBox3->Text->get_Length(); char port_tekst[10]; for(int i=0; i<tmp; i++) port_tekst[i] = textBox3->Text->get_Chars(i); port = (u_short) atoi(port_tekst); if(!poruka_iz_datoteke) { //poruka iz text boxa tmp = textBox4->Text->get_Length(); for(int i=0; i<tmp; i++) poruka[i] = textBox4->Text->get_Chars(i); } else { //poruka iz datoteke tmp = textBox6->Text->get_Length(); for(int i=0; i<tmp; i++) poruka[i] = textBox6->Text->get_Chars(i); } //specijalne opcije izvodjenja encrypt_flag = !(checkedListBox2->GetItemChecked(2)); mic_flag = !(checkedListBox2->GetItemChecked(3)); wrap_flag = !(checkedListBox2->GetItemChecked(1)); if(!wrap_flag) { //~wrap implicira ~encrypt i ~mic checkedListBox2->SetItemChecked(2,1); checkedListBox2->SetItemChecked(3,1); encrypt_flag=0; mic_flag=0; } auth_flag = !(checkedListBox2->GetItemChecked(0)); if(!auth_flag) {

114

//~auth implicira ~wrap, ~encrypt i ~mic checkedListBox2->SetItemChecked(1,1); checkedListBox2->SetItemChecked(2,1); checkedListBox2->SetItemChecked(3,1); wrap_flag = encrypt_flag = mic_flag = 0; } //postavljanje zastavica if(checkedListBox1->GetItemChecked(0)) gss_flags |= ISC_REQ_CONFIDENTIALITY; else { gss_flags &= ~ISC_REQ_CONFIDENTIALITY; encrypt_flag = 0; //ako se ne trazi zastita sigurnosti, ne enkriptiraju se poruke checkedListBox2->SetItemChecked(2,1); } if(checkedListBox1->GetItemChecked(1)) gss_flags |= ISC_REQ_INTEGRITY; else gss_flags &= ~ISC_REQ_INTEGRITY; if(checkedListBox1->GetItemChecked(2)) gss_flags |= ISC_REQ_DELEGATE; else gss_flags &= ~ISC_REQ_DELEGATE; if(checkedListBox1->GetItemChecked(3)) gss_flags |= ISC_REQ_MUTUAL_AUTH; else gss_flags &= ~ISC_REQ_MUTUAL_AUTH; if(checkedListBox1->GetItemChecked(4)) gss_flags |= ISC_REQ_REPLAY_DETECT; else gss_flags &= ~ISC_REQ_REPLAY_DETECT; if(checkedListBox1->GetItemChecked(5)) gss_flags |= ISC_REQ_SEQUENCE_DETECT; else gss_flags &= ~ISC_REQ_SEQUENCE_DETECT; checkedListBox2->Refresh(); sprintf(ispis_buffer, "\nNOVA SJEDNICA (%d)\n", brojac_sjednice++); IspisiTekst(ispis_buffer); sprintf(ispis_buffer, "Racunalo: %hs \nServis: %hs\nPoruka: \"%hs\".\n\nUspostavljanje veze s posluziteljem:\n", posluzitelj_host, ime_servisa, poruka); IspisiTekst(ispis_buffer); //uspostavljanje veze if (PozoviPosluzitelja(posluzitelj_host, port, ime_servisa, gss_flags, poruka) < 0) IspisiTekst("Nije uspostavljena sigurna veza!\n"); } //pomocna klasa za prakticnije koristenje liste servisa comboboxa - ideja je overridanje funkcije ToString public: __gc class Servis_Objekt : public System::Object { private: String *detalji_servisa[]; String *prikazano_ime; public: Servis_Objekt(){} public: Servis_Objekt(const Servis_Objekt &x) { prikazano_ime = x.prikazano_ime; detalji_servisa = x.detalji_servisa; } public: Servis_Objekt(String __gc* init1, String __gc* init2, String __gc* init3, String __gc* init4) {

115

String* tmp[] = {init2,init3,init4}; prikazano_ime = init1; detalji_servisa = tmp; } public: String __gc * ToString() // overridanje funkcije za prikaz imena u combo boxu { eturn prikazano_ime; } public: void Popuni(String __gc* init1, String __gc* init2, String __gc* init3, String __gc* init4) { String* tmp[] = {init2,init3,init4}; prikazano_ime = init1; detalji_servisa = tmp; } public: String __gc* DohvatiIme() {return prikazano_ime;} public: String __gc* Podaci()[] {return detalji_servisa;} public: String __gc* Dohvati(int rbr) {return detalji_servisa[rbr];} }; }; }

116

GSSAPI poslužitelj

Datoteka GSSAPI_posluzitelj.c

#include <stdio.h> #include <sys/types.h> #include <sys/socket.h> #include <sys/time.h> #include <netinet/in.h> #include <pthread.h> #include <signal.h> #include <unistd.h> #include <stdlib.h> #include <ctype.h> #include <gssapi/gssapi_generic.h> #include "GSSAPI_razno.h" #include <string.h> FILE *log_dat; int verbose = 0; //detaljni ispis /***************************************************************** Funkcija Koristenje ispisuje upute za koristenje programa u slucaju nepravilnog pokretanja aplikacije ******************************************************************/ void Koristenje() { fprintf(stderr, "\nKoristenje: GSSAPI_posluzitelj [-port port] [-v] [-x] \n\t\t\t[-log datoteka] servis\n"); fprintf(stderr, "-port: broj porta na kojem ce se osluskivati veza\n"); fprintf(stderr, "-v: detaljan ispis uspostavljanja veze\n"); fprintf(stderr, "-x: prihvaca se samo jedna konekcija\n"); fprintf(stderr, "-log: tekst se ispisuje u datoteku umjesto na ekran\n"); fprintf(stderr, "servis: puno ime servisa (ime_servisa@dns_racunala)\n\n"); exit(1); } /* ***************************************************************** Funkcija: DohvatiPosluziteljskeIsprave Ulazni parametri: ime_servisa - ime servisa kojem ce pristupati klijenti Izlazni parametri: isprave_posluzitelja - GSSAPI isprave posluzitelja vlasnika servisa Povratna vrijednost: Po uspjesnom izvrsavanju vraca 0, inace vraca -1 Opis funkcije: Ime servisa se importira funkcijom gss_import_name, a zatim se pribavljaju isprave funkcijom gss_acquire_cred. ******************************************************************/ int DohvatiPosluziteljskeIsprave(ime_servisa, isprave_posluzitelja) char *ime_servisa; gss_cred_id_t *isprave_posluzitelja; { gss_buffer_desc ime_buffer; gss_name_t ime_posluzitelja; OM_uint32 maj_stat, min_stat;

117

ime_buffer.value = ime_servisa; ime_buffer.length = strlen(ime_buffer.value) + 1; maj_stat = gss_import_name(&min_stat, &ime_buffer, (gss_OID) gss_nt_service_name, &ime_posluzitelja); if (maj_stat != GSS_S_COMPLETE) { IspisiGreskuGSSAPI("funkcija gss_import_name", maj_stat, min_stat); return -1; } maj_stat = gss_acquire_cred(&min_stat, ime_posluzitelja, 0, GSS_C_NULL_OID_SET, GSS_C_ACCEPT, isprave_posluzitelja, NULL, NULL); if (maj_stat != GSS_S_COMPLETE) { IspisiGreskuGSSAPI("funkcija gss_acquire_cred", maj_stat, min_stat); return -1; } (void) gss_release_name(&min_stat, &ime_posluzitelja); return 0; } /* ***************************************************************** Funkcija: UspostaviKontekstPosluzitelja Ulazni parametri: s - uspostavljena TCP veza s klijentom isprave_posluzitelja - GSSAPI isprave posluzitelja vlasnika servisa Izlazni parametri: context - uspostavljeni GSSAPI sigurnosni kontekst ime_klijenta - ime klijenta s kojim se uspostavlja kontekst ret_flags - zastavice uspostavljenog konteksta Povratna vrijednost: Po uspjesnom izvrsavanju vraca 0, inace vraca -1 Opis funkcije: Funkcija uspostavlja sigurnosni kontekst sa svakim klijentom koji podnese valjan zahtjev. ******************************************************************/ int UspostaviKontekstPosluzitelja(s, isprave_posluzitelja, context, ime_klijenta, ret_flags) int s; gss_cred_id_t isprave_posluzitelja; gss_ctx_id_t *context; gss_buffer_t ime_klijenta; OM_uint32 *ret_flags; { gss_buffer_desc send_tok, recv_tok; gss_name_t klijent; gss_OID doid; OM_uint32 maj_stat, min_stat, acc_sec_min_stat; int token_flags; /* Primanje inicijalnog tokena */ if (PrimiToken(s, &token_flags, &recv_tok) < 0) return -1; if (recv_tok.value) { free (recv_tok.value); recv_tok.value = NULL; }

118

if (!(token_flags & TOKEN_NOOP)) { if (log_dat) fprintf(log_dat, "Greska, ocekivan je NOOP token, a primljen je %d token!\n",token_flags); return -1; } else if (log_dat) fprintf(log_dat, "\nPrimljen je inicijalni token\n"); *context = GSS_C_NO_CONTEXT; if (token_flags & TOKEN_CONTEXT_NEXT) { /* Glavna petlja u kojoj se uspostavlja sigurnosni kontekst */ do { /* Primanje klijentovog tokena */ if (PrimiToken(s, &token_flags, &recv_tok) < 0) return -1; if (verbose && log_dat) { fprintf(log_dat, "Primljen je token velicine %d bajtova\n", (int) recv_tok.length); IspisiToken(&recv_tok); } /* Generiranje novog tokena i prihvacanje konteksta */ maj_stat = gss_accept_sec_context(&acc_sec_min_stat, context, isprave_posluzitelja, &recv_tok, GSS_C_NO_CHANNEL_BINDINGS, &klijent, &doid, &send_tok, ret_flags, NULL, /* ignorira se time_rec */ NULL); /* ignorira se del_cred_handle */ if(recv_tok.value) { free(recv_tok.value); recv_tok.value = NULL; } if (send_tok.length != 0) { if (verbose && log_dat) { fprintf(log_dat, "Salje se accept_sec_context token velicine %d bajtova\n", (int) send_tok.length); IspisiToken(&send_tok); } /* Slanje tokena klijentu */ if (PosaljiToken(s, TOKEN_CONTEXT, &send_tok) < 0) { if (log_dat) fprintf(log_dat, "Greska prilikom slanja tokena!\n"); return -1; } (void) gss_release_buffer(&min_stat, &send_tok);

119

} if (maj_stat!=GSS_S_COMPLETE && maj_stat!=GSS_S_CONTINUE_NEEDED) { IspisiGreskuGSSAPI("funkcija gss_accept_sec_context", maj_stat, acc_sec_min_stat); if (*context != GSS_C_NO_CONTEXT) gss_delete_sec_context(&min_stat, context, GSS_C_NO_BUFFER); return -1; } if (verbose && log_dat) { if (maj_stat == GSS_S_CONTINUE_NEEDED) fprintf(log_dat, "Potrebno je nastaviti razmjenu tokena...\n"); else fprintf(log_dat, "\n"); fflush(log_dat); } } while (maj_stat == GSS_S_CONTINUE_NEEDED); /* Zastavice uspostavljenog konteksta */ IspisiZastaviceKonteksta(*ret_flags); maj_stat = gss_display_name(&min_stat, klijent, ime_klijenta, &doid); if (maj_stat != GSS_S_COMPLETE) { IspisiGreskuGSSAPI("funkcija gss_display_name", maj_stat, min_stat); return -1; } maj_stat = gss_release_name(&min_stat, &klijent); if (maj_stat != GSS_S_COMPLETE) { IspisiGreskuGSSAPI("funkcija gss_release_name", maj_stat, min_stat); return -1; } } else { ime_klijenta->length = *ret_flags = 0; if (log_dat) fprintf(log_dat, "Prihvacena je neautentificirana veza.\n"); } return 0; } /* ***************************************************************** Funkcija: KreirajSpojnuTocku Ulazni parametri: port - broj porta na kojem ce posluzitelj osluskivati vezu Povratna vrijednost: Po uspjesnom izvrsavanju vraca opisnik uspostavljenog socketa, inace vraca -1 Opis funkcije: Funcija kreira TCP spojnu tocku (socket) na kojoj ce osluskivati vezu. ******************************************************************/ int KreirajSpojnuTocku(port) u_short port; {

120

struct sockaddr_in saddr; int s; int on = 1; saddr.sin_family = AF_INET; saddr.sin_port = htons(port); saddr.sin_addr.s_addr = INADDR_ANY; /* Kreiranje socketa */ if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0) { perror("kreiranje socketa"); return -1; } /* Odmah se omogucava ponovno koristenje socketa */ (void) setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on)); /* Povezivanje socketa */ if (bind(s, (struct sockaddr *) &saddr, sizeof(saddr)) < 0) { perror("povezivanje socketa"); (void) close(s); return -1; } /* osluskivanje socketa */ if (listen(s, 5) < 0) { perror("osluskivanje socketa"); (void) close(s); return -1; } return s; } /****************************************************************** Funkcija: PrihvatiKlijenta Ulazni parametri: s - TCP spojna tocka na kojoj je prihvacena konekcija isprave_posluzitelja - GSSAPI isprave posluzitelja vlasnika servisa Povratna vrijednost: Po uspjesnom izvrsavanju vraca 0, inace vraca -1 Opis funkcije: Funkcija uspostavlja kontekst s klijentom (pozivajuci funkciju UspostaviKontekstPosluzitelja), prima poruku, potpisuje ju i potpis salje nazad klijentu. Nakon toga unistava kontekst i zatvara vezu. ******************************************************************/ static int PrihvatiKlijenta(s, isprave_posluzitelja) int s; gss_cred_id_t isprave_posluzitelja; { gss_buffer_desc ime_klijenta, xmit_buf, msg_buf; gss_ctx_id_t context; OM_uint32 maj_stat, min_stat; int i, conf_state, ret_flags; char *cp; int token_flags; /* Uspostavlja se kontekst s klijentom */ if (UspostaviKontekstPosluzitelja(s, isprave_posluzitelja, &context, &ime_klijenta, &ret_flags) < 0)

121

return(-1); if (context == GSS_C_NO_CONTEXT) { printf("Prihvacena neautentificirana veza.\n"); } else { printf("Uspostavljena je sigurna veza koristenjem Kerberos protokola.\nKlijent: %s\n",(char *) ime_klijenta.value); (void) gss_release_buffer(&min_stat, &ime_klijenta); } do { /* Prima se poruka klijenta */ if (PrimiToken(s, &token_flags, &xmit_buf) < 0) return(-1); /* NOOP token oznacava kraj razmjene poruka */ if (token_flags & TOKEN_NOOP) { if (log_dat) fprintf(log_dat, "Primljen NOOP token - kraj razmjene poruka.\n"); if(xmit_buf.value) { free(xmit_buf.value); xmit_buf.value = 0; } break; } if (verbose && log_dat) { fprintf(log_dat, "Primljen je token poruke duljine %d bajtova (zastavice=%d):\n", xmit_buf.length, token_flags); IspisiToken(&xmit_buf); } /* Ispituje se ima li klijent pravo pristupa */ if ((context == GSS_C_NO_CONTEXT) && ( token_flags & (TOKEN_WRAPPED|TOKEN_ENCRYPTED|TOKEN_SEND_MIC))) { if (log_dat) fprintf(log_dat, "Greska, neautentificirani klijent trazi pristup autentificiranim uslugama!\n"); if(xmit_buf.value) { free (xmit_buf.value); xmit_buf.value = 0; } return(-1); } /* Ispituje se je li token modificiran GSSAPI funkcijama */ if (token_flags & TOKEN_WRAPPED) { /* Dekriptiranje/citanje poruke */ maj_stat = gss_unwrap(&min_stat, context, &xmit_buf, &msg_buf, &conf_state, (gss_qop_t *) NULL); if (maj_stat != GSS_S_COMPLETE) { IspisiGreskuGSSAPI("funkcija gss_unwrap", maj_stat, min_stat); if(xmit_buf.value) { free (xmit_buf.value); xmit_buf.value = 0;

122

} return(-1); /* Ispituje se je li poruka enkriptirana */ } else if (! conf_state && (token_flags & TOKEN_ENCRYPTED)) { fprintf(stderr, "Upozorenje, poruka nije enkriptirana!\n"); } if(xmit_buf.value) { free (xmit_buf.value); xmit_buf.value = 0; } } /* Poruka je poslana kao obicni tekst */ else msg_buf = xmit_buf; /* Ispisivanje poruke */ if (log_dat) { fprintf(log_dat, "Primljena je poruka: "); cp = msg_buf.value; if ((isprint((int) cp[0]) || isspace((int) cp[0])) && (isprint((int) cp[1]) || isspace((int) cp[1]))) { fprintf(log_dat, "\"%s\"\n", (char *) msg_buf.value); } else { fprintf(log_dat, "\n"); IspisiToken(&msg_buf); } } if (token_flags & TOKEN_SEND_MIC) { /* Kreiranje potpisa primljene poruke */ maj_stat = gss_get_mic(&min_stat, context, GSS_C_QOP_DEFAULT, &msg_buf, &xmit_buf); if (maj_stat != GSS_S_COMPLETE) { IspisiGreskuGSSAPI("funkcija gss_get_mic", maj_stat, min_stat); return(-1); } if(msg_buf.value) { free (msg_buf.value); msg_buf.value = 0; } /* Slanje potpisa poruke nazad klijentu */ if (verbose && log_dat) fprintf(log_dat, "Salje se potpis primljene poruke velicine %d bajtova\n", (int) xmit_buf.length); if (PosaljiToken(s, TOKEN_MIC, &xmit_buf) < 0) return(-1); if(xmit_buf.value) { free (xmit_buf.value); xmit_buf.value = 0; } }

123

else { if(msg_buf.value) { free (msg_buf.value); msg_buf.value = 0; } if (PosaljiToken(s, TOKEN_NOOP, prazni_token) < 0) return(-1); } } while (1); /* iz petlje se izlazi po primitku NOOP tokena */ /* Unistavanje konteksta */ if (context != GSS_C_NO_CONTEXT) { maj_stat = gss_delete_sec_context(&min_stat, &context, NULL); if (maj_stat != GSS_S_COMPLETE) { IspisiGreskuGSSAPI("funkcija gss_delete_sec_context", maj_stat, min_stat); return(-1); } } if (log_dat) fflush(log_dat); return(0); } /****************************************************************** Prema uputama navedenim u funkciji Koristenje, u funkciji main se inicijaliziraju ulazni parametri programa. Pozivaju se funkcije DohvatiPosluziteljskeIsprave i KreirajSpojnuTocku, a zatim se osluskuje veza i u petlji za svaku konekciju s klijentom poziva se funkcija PrihvatiKlijenta. ******************************************************************/ int main(argc, argv) int argc; char **argv; { char *ime_servisa; gss_cred_id_t isprave_posluzitelja; OM_uint32 min_stat; u_short port = 4444; int once = 0; int s; signal(SIGPIPE, SIG_IGN); log_dat = stdout; prikaz_dat = stdout; argc--; argv++; while (argc) { if (strcmp(*argv, "-port") == 0) { argc--; argv++; if (!argc) Koristenje(); port = atoi(*argv); } else if (strcmp(*argv, "-v") == 0) { verbose = 1; } else if (strcmp(*argv, "-x") == 0) { once = 1; } else if (strcmp(*argv, "-log") == 0) { argc--; argv++; if (!argc) Koristenje(); //ako se ne zeli nikakav prikaz, argument je null

124

if (! strcmp(*argv, "null")) { log_dat = prikaz_dat = NULL; } else { log_dat = fopen(*argv, "a"); prikaz_dat = log_dat; if (!log_dat) { perror(*argv); exit(1); } } } else break; argc--; argv++; } if (argc != 1) Koristenje(); if ((*argv)[0] == '-') Koristenje(); ime_servisa = *argv; if (DohvatiPosluziteljskeIsprave(ime_servisa, &isprave_posluzitelja) < 0) return -1; int stmp; if ((stmp = KreirajSpojnuTocku(port)) >= 0) { if (listen(stmp, 0) < 0) perror("Greska prilikom osluskivanja socket-a"); do { /* Prihvaca se TCP konekcija */ if ((s = accept(stmp, NULL, 0)) < 0) { perror("Greska prilikom prihvacanja veze"); continue; } PrihvatiKlijenta(s, isprave_posluzitelja); closesocket(s); } while (!once); closesocket(stmp); } (void) gss_release_cred(&min_stat, &isprave_posluzitelja); return 0; }

Datoteka GSSAPI_razno.c

#include <stdio.h> #include <sys/types.h> #include <netinet/in.h> #include <sys/socket.h> #include <errno.h> #include <unistd.h> #include <string.h> #include <time.h> #include <gssapi/gssapi_generic.h> #include <stdlib.h>

125

#include "GSSAPI_razno.h" FILE *prikaz_dat; gss_buffer_desc prazni_token_buf = { 0, (void *) "" }; gss_buffer_t prazni_token = &prazni_token_buf; int Posalji(int s, char *buf, unsigned int nbyte) { int ret; char *ptr; for (ptr = buf; nbyte; ptr += ret, nbyte -= ret) {

ret = send(s, ptr, nbyte, 0); if (ret < 0) { if (errno == EINTR) continue; return(ret); } else if (ret == 0) { return(ptr-buf); } } return(ptr-buf); } int Primi(int s, char *buf, unsigned int nbyte) { int ret; char *ptr; fd_set rfds; struct timeval tv; FD_ZERO(&rfds); FD_SET(s, &rfds); tv.tv_sec = 10; tv.tv_usec = 0; for (ptr = buf; nbyte; ptr += ret, nbyte -= ret) { if (select(FD_SETSIZE, &rfds, NULL, NULL, &tv) <= 0 || !FD_ISSET(s, &rfds)) return(ptr-buf); ret = recv(s, ptr, nbyte, 0); if (ret < 0) { if (errno == EINTR) continue; return(ret); } else if (ret == 0) { return(ptr-buf); } } return(ptr-buf); } /* *************************************************************** Funkcija: PosaljiToken Ulazni parametri: s - opisnik otvorene datoteke u koju se zapisuje token (rijec je o opisniku povezanim sa socketom, tako da je rijec o slanju tokena) flags - zastavice tokena koje treba zapisati (poslati) token - token koji treba zapisati (poslati) Povratna vrijednost: Po uspjesnom izvrsavanju vraca 0, inace vraca -1 Opis funkcije:

126

Ako zastavice nisu NULL, funkcija ih zapisuje kao jedan bajt podataka. Nakon njih zapisuje se duljina tokena i na kraju podaci tokena. ****************************************************************/ int PosaljiToken(s, flags, token) int s; int flags; gss_buffer_t token; { int ret; unsigned char char_flags = (unsigned char) flags; unsigned char lenbuf[4]; if (char_flags) { ret = Posalji(s, (char *)&char_flags, 1); if (ret != 1) { perror("slanje zastavica tokena"); return -1; } } if (token->length > 0xffffffffUL) abort(); lenbuf[0] = (token->length >> 24) & 0xff; lenbuf[1] = (token->length >> 16) & 0xff; lenbuf[2] = (token->length >> 8) & 0xff; lenbuf[3] = token->length & 0xff; ret = Posalji(s, lenbuf, 4); if (ret < 0) { perror("slanje duljine tokena"); return -1; } else if (ret != 4) { if (prikaz_dat) fprintf(prikaz_dat, "Greska prilikom slanja duljine tokena: poslano %d od %d bajtova!\n", ret, 4); return -1; } ret = Posalji(s, token->value, token->length); if (ret < 0) { perror("slanje podataka tokena"); return -1; } else if (ret != token->length) { if (prikaz_dat) fprintf(prikaz_dat, "Greska prilikom slanja podataka tokena: poslano %d od %d bajtova!\n", ret, (int) token->length); return -1; } return 0; } /* *************************************************************** Funkcija: PrimiToken Ulazni parametri: s - opisnik otvorene datoteke iz koje se cita token (rijec je o opisniku povezanim sa socketom, tako da je rijec o primanju tokena) Izlazni parametri: flags - procitane (primljene) zastavice tokena token - procitani (primljeni) token Povratna vrijednost: Po uspjesnom izvrsavanju vraca 0, inace vraca -1 Opis funkcije: Funkcija cita zastavice iz prvog bajta podataka, nakon njih

127

cita duljinu tokena, rezervira memoriju za token i na kraju cita token. Nakon koristenja, token treba osloboditi pozivom funkcije gss_release_buffer. ****************************************************************/ int PrimiToken(s, flags, token) int s; int *flags; gss_buffer_t token; { int ret; unsigned char char_flags; unsigned char lenbuf[4]; ret = Primi(s, (char *) &char_flags, 1); if (ret < 0) { perror("primanje zastavica tokena"); return -1; } else if (! ret) { if (prikaz_dat) fputs("Greska prilikom primanja zastavica tokena: primljeno 0 bajtova!\n", prikaz_dat); return -1; } else { *flags = (int) char_flags; } if (char_flags == 0 ) {

lenbuf[0] = 0; ret = Primi(s, &lenbuf[1], 3); if (ret < 0) { perror("primanje duljine tokena"); return -1; } else if (ret != 3) { if (prikaz_dat) fprintf(prikaz_dat, "Greska prilikom primanja duljine tokena: primljeno %d od %d bajtova!\n", ret, 3); return -1; } } else { ret = Primi(s, lenbuf, 4); if (ret < 0) { perror("primanje duljine tokena"); return -1; } else if (ret != 4) { if (prikaz_dat) fprintf(prikaz_dat, "Greska prilikom primanja duljine tokena: primljeno %d od %d bajtova!\n", ret, 4); return -1; } } token->length = ((lenbuf[0] << 24) | (lenbuf[1] << 16) | (lenbuf[2] << 8) | lenbuf[3]); token->value = (char *) malloc(token->length ? token->length:1); if (token->length && token->value == NULL) { if (prikaz_dat) fprintf(prikaz_dat, "Greska pri rezerviranju memorije za podatke tokena!\n"); return -1; }

128

ret = Primi(s, (char *) token->value, token->length); if (ret < 0) { perror("primanje podataka tokena"); free(token->value); return -1; } else if (ret != token->length) { fprintf(stderr, "Greska prilikom primanja podataka tokena: primljeno %d od %d bajtova!\n", ret, (int) token->length); free(token->value); return -1; } return 0; } /* Pomocna funkcija za ispisivanje statusa GSSAPI greske */ void IspisiStatusGreske(poruka, kod_greske, tip_greske) char *poruka; OM_uint32 kod_greske; int tip_greske; { OM_uint32 maj_stat, min_stat; gss_buffer_desc msg; OM_uint32 msg_ctx; msg_ctx = 0; while (1) { maj_stat = gss_display_status(&min_stat, kod_greske, tip_greske, GSS_C_NULL_OID, &msg_ctx, &msg); if (prikaz_dat) fprintf(prikaz_dat, "GSSAPI greska, %s: %s\n", poruka, (char *)msg.value); (void) gss_release_buffer(&min_stat, &msg); if (!msg_ctx) break; } } /**************************************************************** Funkcija: IspisiGreskuGSSAPI Ulazni parametri: poruka - niz znakova poslan iz glavnog programa za ispis pored greske maj_stat - GSSAPI glavni statusni kod min_stat - GSSAPI sporedni statusni kod (vezan uz mehanizam koji implementira sucelje) Opis funkcije: Funkcija ispisuje gresku u formatu "GSSAPI greska, <poruka>: maj_stat, min_stat", pri cemu je poruka najcesce ime funkcije koja ja izazvala gresku. ****************************************************************/ void IspisiGreskuGSSAPI(poruka, maj_stat, min_stat) char *poruka; OM_uint32 maj_stat; OM_uint32 min_stat; { IspisiStatusGreske(poruka, maj_stat, GSS_C_GSS_CODE); IspisiStatusGreske(poruka, min_stat, GSS_C_MECH_CODE); } /* Funkcija ispisuje zastavice konteksta */ void IspisiZastaviceKonteksta(flags) OM_uint32 flags;

129

{ fprintf(prikaz_dat, "Zastavice uspostavljenog konteksta:\n"); if (flags & GSS_C_DELEG_FLAG) fprintf(prikaz_dat, "GSS_C_DELEG_FLAG\n"); if (flags & GSS_C_MUTUAL_FLAG) fprintf(prikaz_dat, "GSS_C_MUTUAL_FLAG\n"); if (flags & GSS_C_REPLAY_FLAG) fprintf(prikaz_dat, "GSS_C_REPLAY_FLAG\n"); if (flags & GSS_C_SEQUENCE_FLAG) fprintf(prikaz_dat, "GSS_C_SEQUENCE_FLAG\n"); if (flags & GSS_C_CONF_FLAG ) fprintf(prikaz_dat, "GSS_C_CONF_FLAG \n"); if (flags & GSS_C_INTEG_FLAG ) fprintf(prikaz_dat, "GSS_C_INTEG_FLAG \n"); } void IspisiToken(token) gss_buffer_t token; { int i; unsigned char *p = token->value; if (!prikaz_dat) return; for (i=0; i < token->length; i++, p++) { fprintf(prikaz_dat, "%02x ", *p); if ((i % 16) == 15) fprintf(prikaz_dat, "\n"); } fprintf(prikaz_dat, "\n"); fflush(prikaz_dat); }

Datoteka GSSAPI_razno.h

#include <gssapi/gssapi_generic.h> #include <stdio.h> extern FILE *prikaz_dat; int PosaljiToken(int s, int flags, gss_buffer_t tok); int PrimiToken(int s, int *flags, gss_buffer_t tok); void IspisiGreskuGSSAPI(char *msg, OM_uint32 maj_stat, OM_uint32 min_stat); void IspisiZastaviceKonteksta(OM_uint32 flags); void IspisiToken(gss_buffer_t tok); /* Vrste tokena */ #define TOKEN_NOOP (1<<0) #define TOKEN_CONTEXT (1<<1) #define TOKEN_DATA (1<<2) #define TOKEN_MIC (1<<3) /* Zastavice tokena */ #define TOKEN_CONTEXT_NEXT (1<<4) #define TOKEN_WRAPPED (1<<5) #define TOKEN_ENCRYPTED (1<<6) #define TOKEN_SEND_MIC (1<<7) extern gss_buffer_t prazni_token;

130

GSSAPI klijent

Datoteke GSSAPI_Razno.c i GSSAPI_Razno.h vec su navedene kod GSSAPI poslužitelja.

Datoteka GSSAPI_klijent.c

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <ctype.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <netdb.h> #include <errno.h> #include <sys/stat.h> #include <fcntl.h> #include <gssapi/gssapi_generic.h> #include "GSSAPI_razno.h" int verbose = 1; /******************************************************************** Funkcija Koristenje ispisuje upute za koristenje programa u slucaju nepravilnog pokretanja aplikacije ********************************************************************/ void Koristenje() { printf("\nNacin koristenja: GSSAPI-klijent [-noint] [-noconf] [-nodeleg] [-noseq]\n[-norep] [-nomut] [-na] [-nw] [-nx] [-nm] [-dat] [-port port] host servis poruka\n\n"); printf("-noint: ne postavlja se GSS_C_INTEG_FLAG\n"); printf("-noconf: ne postavlja se GSS_C_CONF_FLAG\n"); printf("-nodeleg: ne postavlja se GSS_C_DELEG_FLAG\n"); printf("-norep: ne postavlja se GSS_C_REPLAY_FLAG\n"); printf("-noseq: ne postavlja se GSS_C_SEQUENCE_FLAG\n"); printf("-nomut: ne postavlja se GSS_C_MUTUAL_FLAG\n"); printf("-na: ne obavlja se autentifikacija\n"); printf("-nw: poruke se ne modificiraju funkcijom gss_wrap\n"); printf("-nx: poruke se ne enkriptiraju\n"); printf("-nm: poruke se ne potpisuju\n"); printf("-doc: poruka sadrzi ime datoteke koja se salje\n"); printf("-port: port na kojem servis osluskuje vezu (podrazumijevano 4444)\n"); printf("host: dns ime posluzitelja\n"); printf("servis: puno ime servisa na posluzitelju (ime_servisa@dns_hosta)\n"); printf("poruka: poruka ili ime datoteke koja se salje posluzitelju\n\n"); exit(1); } struct sockaddr_in saddr; /* ******************************************************************* Funkcija: DohvatiInfoPosluzitelja Ulazni parametri:

131

host - ime racunala na kojem se izvrsava servis port - port na kojem posluzitelj osluskuje vezu Povratna vrijednost: Po uspjesnom izvrsavanju vraca 0, inace vraca -1 Opis funkcije: Funkcija dohvaca podatke o hostu pomocu funkcije gethostbyname(), a pomocu njih postavlja adresu socketa u varijablu "saddr". ********************************************************************/ int DohvatiInfoPosluzitelja(host, port) char *host; u_short port; { struct hostent *hp; if ((hp = gethostbyname(host)) == NULL) { fprintf(stderr, "Nepoznato ime racunala posluzitelja: %s\n", host); return -1; } saddr.sin_family = hp->h_addrtype; memcpy((char *)&saddr.sin_addr, hp->h_addr, sizeof(saddr.sin_addr)); saddr.sin_port = htons(port); return 0; } /******************************************************************** Funkcija: UspostaviVezu Ulazni parametri: host - ime racunala na kojem se izvrsava servis port - port na kojem posluzitelj osluskuje vezu Povratna vrijednost: Po uspjesnom izvrsavanju vraca opisnik socketa, inace vraca -1 Opis funkcije: Funkcija otvara TCP konekciju prema zadanom hostu na zadanom portu koristenjem parametra "saddr" koji se dobio pozivom funkcije DohvatiInfoPosluzitelja. ********************************************************************/ int UspostaviVezu() { int s; if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0) { fprintf(stderr, "Greska u kreiranju socketa!\n"); return -1; } if (connect(s, (struct sockaddr *)&saddr, sizeof(saddr)) < 0) { fprintf(stderr, "Greska pri spajanju na posluzitelj!\n"); (void) closesocket(s); return -1; } return s; } /******************************************************************** Funkcija: UspostaviKontekstKlijenta Ulazni parametri: s - uspostavljena TCP konekcija sa servisom ime_servisa - ime servisa s kojim je uspostavljena konekcija gss_flags - delegacijske zastavice klijenta

132

auth_flag - zastavica koja odredjuje hoce li se obavljati autentifikacija ili ne oid - id mehanizma koji ce se koristiti Izlazni parametri: gss_context - uspostavljeni GSSAPI kontekst ret_flags - zastavice uspostavljenog konteksta Povratna vrijednost: Po uspjesnom izvrsavanju vraca 0, inace vraca -1 Opis funkcije: Funkcija kreira GSSAPI ime servisa importiranjem parametra ime_servisa i zatim uspostavlja podrazumijevani (Kerberos) sigurnosni kontekst s tim servisom. ********************************************************************/ int UspostaviKontekstKlijenta(s, ime_servisa, gss_flags, auth_flag, oid, gss_context, ret_flags) int s; char *ime_servisa; gss_OID oid; OM_uint32 gss_flags; int auth_flag; gss_ctx_id_t *gss_context; OM_uint32 *ret_flags; { if (auth_flag) { gss_buffer_desc send_tok, recv_tok, *token_pokazivac; gss_name_t ciljano_ime; OM_uint32 maj_stat, min_stat, init_sec_min_stat; int token_flags; /* Importiranje imena servisa */ send_tok.value = ime_servisa; send_tok.length = strlen(ime_servisa) ; maj_stat = gss_import_name(&min_stat, &send_tok, (gss_OID) gss_nt_service_name, &ciljano_ime); if (maj_stat != GSS_S_COMPLETE) { IspisiGreskuGSSAPI("funkcija gss_import_name", maj_stat, min_stat); return -1; } /* Salje se inicijalni token */ if (verbose) printf("\nSalje se inicijalni token...\n"); if (PosaljiToken(s, TOKEN_NOOP|TOKEN_CONTEXT_NEXT, prazni_token) < 0) { (void) gss_release_name(&min_stat, &ciljano_ime); return -1; } token_pokazivac = GSS_C_NO_BUFFER; *gss_context = GSS_C_NO_CONTEXT; /* Glavna petlja u kojoj se uspostavlja sigurnosni kontekst */ do { maj_stat = gss_init_sec_context(&init_sec_min_stat, GSS_C_NO_CREDENTIAL, gss_context, ciljano_ime, oid, gss_flags,

133

0, NULL, /* ne koristi se povezivanje kanala */ token_pokazivac, NULL, /* ignorira se tip mehanizma */ &send_tok, ret_flags, NULL); /* ignorira se time_rec */ if (token_pokazivac != GSS_C_NO_BUFFER) free (recv_tok.value); if (send_tok.length != 0) { if (verbose) printf("Salje se init_sec_context token velicine %d bajtova...\n", (int) send_tok.length); /* Salje se generirani token */ if (PosaljiToken(s, TOKEN_CONTEXT, &send_tok) < 0) { (void) gss_release_buffer(&min_stat, &send_tok); (void) gss_release_name(&min_stat, &ciljano_ime); if (*gss_context != GSS_C_NO_CONTEXT) { gss_delete_sec_context(&min_stat, gss_context, GSS_C_NO_BUFFER); *gss_context = GSS_C_NO_CONTEXT; } return -1; } } (void) gss_release_buffer(&min_stat, &send_tok); if (maj_stat!=GSS_S_COMPLETE && maj_stat!=GSS_S_CONTINUE_NEEDED) { IspisiGreskuGSSAPI("funkcija gss_init_sec_context", maj_stat, init_sec_min_stat); (void) gss_release_name(&min_stat, &ciljano_ime); if (*gss_context != GSS_C_NO_CONTEXT) gss_delete_sec_context(&min_stat, gss_context, GSS_C_NO_BUFFER); return -1; } if (maj_stat == GSS_S_CONTINUE_NEEDED) { if (verbose) printf("Potrebno je nastaviti razmjenu tokena...\n"); /* Prima se token od posluzitelja */ if (PrimiToken(s, &token_flags, &recv_tok) < 0) { (void) gss_release_name(&min_stat, &ciljano_ime); return -1; } if (verbose) printf("Primljen je token velicine %d bajtova... ", (int) recv_tok.length); token_pokazivac = &recv_tok; } if (verbose) printf("\n"); } while (maj_stat == GSS_S_CONTINUE_NEEDED); (void) gss_release_name(&min_stat, &ciljano_ime); } else {

134

/* Ne obavlja se atentifikacija */ if (PosaljiToken(s, TOKEN_NOOP, prazni_token) < 0) return -1; } return 0; } /* Funkcija iz datoteke ucitava poruku namijenjenu posluzitelju */ void UcitajDatoteku(ime_datoteke, in_buf) char *ime_datoteke; gss_buffer_t in_buf; { int fd, br; struct stat stat_buf; if ((fd = open(ime_datoteke, O_RDONLY, 0)) < 0) { fprintf(stderr, "Greska u otvaranju datoteke %s!\n", ime_datoteke); exit(2); } if (fstat(fd, &stat_buf) < 0) { fprintf(stderr, "Greska pri pozivu funkcije fstat()!\n"); exit(3); } in_buf->length = stat_buf.st_size; if (in_buf->length == 0) { in_buf->value = NULL; return; } if ((in_buf->value = malloc(in_buf->length)) == 0) { fprintf(stderr, "Greska u rezerviranju %d bajtova za spremnik za citanje datoteke\n", (int) in_buf->length); exit(4); } br = read(fd, in_buf->value, in_buf->length); } /******************************************************************** Funkcija: PozoviPosluzitelja Ulazni parametri: host - ime racunala na kojem se izvrsava servis port - port na kojem posluzitelj osluskuje vezu oid - id mehanizma koji ce se koristiti ime_servisa - ime servisa s kojim ce se uspostaviti konekcija gss_flags - delegacijske zastavice klijenta auth_flag - zastavica koja odredjuje hoce li se obavljati autentifikacija ili ne wrap_flag - zastavica koja odredjuje hoce li se poruka modificirati GSSAPI funkcijom encrypt_flag - zastavica koja odredjuje hoce li se poruka enkriptirati mic_flag - zastavica koja odredjuje hoce li se zahtijevati potpis poruke od posluzitelja poruka - poruka ili ime datoteke koju treba poslati posluzitelju koristi_se_datoteka - oznacava je li parametar "poruka" ime datoteke ili obicna poruka Povratna vrijednost: Po uspjesnom izvrsavanju vraca 0, inace vraca -1

135

Opis funkcije: Funkcija kreira TCP konekciju prema posluzitelju, uspostavlja sigurnosni kontekst, salje poruku posluzitelju, prima potpis poruke od posluzitelja i provjerava ga. ********************************************************************/ int PozoviPosluzitelja(host, port, oid, ime_servisa, gss_flags, auth_flag, wrap_flag, encrypt_flag, mic_flag, poruka, koristi_se_datoteka) char *host; u_short port; gss_OID oid; char *ime_servisa; OM_uint32 gss_flags; int auth_flag, wrap_flag, encrypt_flag, mic_flag; char *poruka; int koristi_se_datoteka; { gss_ctx_id_t context; gss_buffer_desc in_buf, out_buf; int s, status; OM_uint32 ret_flags; OM_uint32 maj_stat, min_stat; gss_name_t ime_izvora, ime_cilja; gss_buffer_desc ime_izvora_desc, ime_cilja_desc; OM_uint32 vrijeme_trajanja; gss_OID mehanizam, tip_imena; int lokalna_veza; OM_uint32 context_flags; int otvorena_veza; gss_qop_t qop_status; size_t i; int token_flags; /* Uspostavljanje veze s posluziteljem */ if ((s = UspostaviVezu()) < 0) return -1; /* Uspostavljanje konteksta */ if (UspostaviKontekstKlijenta(s, ime_servisa, gss_flags, auth_flag, oid, &context, &ret_flags) < 0) { (void) closesocket(s); return -1; } /* Ispituje se treba li obavljati autentifikaciju */ if (auth_flag && verbose) { /* Zastavice uspostavljenog konteksta */ IspisiZastaviceKonteksta(ret_flags); /* Ispitivanje konteksta */ maj_stat = gss_inquire_context( &min_stat, context, &ime_izvora, &ime_cilja, &vrijeme_trajanja, &mehanizam, &context_flags, &lokalna_veza, &otvorena_veza); if (maj_stat != GSS_S_COMPLETE) { IspisiGreskuGSSAPI("funkcija gss_inquire_context", maj_stat, min_stat);

136

return -1; } maj_stat = gss_display_name(&min_stat, ime_izvora, &ime_izvora_desc, &tip_imena); if (maj_stat != GSS_S_COMPLETE) { IspisiGreskuGSSAPI("funkcija gss_display_name", maj_stat, min_stat); return -1; } maj_stat = gss_display_name(&min_stat, ime_cilja, &ime_cilja_desc, (gss_OID *) NULL); if (maj_stat != GSS_S_COMPLETE) { IspisiGreskuGSSAPI("funkcija gss_display_name", maj_stat, min_stat); return -1; } /* Ispisivanje podataka o kontekstu */ printf("Klijent:\t%s\nPosluzitelj:\t%s\nPreostalo vrijeme trajanja konteksta: %d sati, %d minuta, %d sekundi\n%s\n%s\n", (char *) ime_izvora_desc.value, (char *) ime_cilja_desc.value, vrijeme_trajanja/3600, (vrijeme_trajanja%3600)/60, vrijeme_trajanja%60, (lokalna_veza) ? "Veza je inicirana lokalno." : "Veza je inicirana s udaljenog racunala.", (otvorena_veza) ? "Veza je otvorena." : "Veza je zatvorena."); (void) gss_release_name(&min_stat, &ime_izvora); (void) gss_release_name(&min_stat, &ime_cilja); (void) gss_release_buffer(&min_stat, &ime_izvora_desc); (void) gss_release_buffer(&min_stat, &ime_cilja_desc); } if (koristi_se_datoteka) { UcitajDatoteku(poruka, &in_buf); } else { /* Priprema za slanje poruke posluzitelju */ in_buf.value = poruka; in_buf.length = strlen(poruka); } /* Ispituje se treba li modificirati poruku */ if (wrap_flag) { maj_stat = gss_wrap(&min_stat, context, encrypt_flag, GSS_C_QOP_DEFAULT, &in_buf, &status, &out_buf); if (maj_stat != GSS_S_COMPLETE) { IspisiGreskuGSSAPI("funkcija gss_wrap", maj_stat, min_stat); (void) closesocket(s); (void) gss_delete_sec_context(&min_stat, &context, GSS_C_NO_BUFFER); return -1; } else if (encrypt_flag && !status) { fprintf(stderr, "Greska, poruka nije enkriptirana.\n"); } } else out_buf = in_buf;

137

/* Slanje tokena posluzitelju */ if (verbose) printf("Salje se token poruke velicine %d bajtova...\n", (int) out_buf.length); if (PosaljiToken(s, TOKEN_DATA | (wrap_flag ? TOKEN_WRAPPED : 0) | (encrypt_flag ? TOKEN_ENCRYPTED : 0) | (mic_flag ? TOKEN_SEND_MIC : 0), &out_buf) < 0) { (void) closesocket(s); (void) gss_delete_sec_context(&min_stat, &context, GSS_C_NO_BUFFER); return -1; } if (out_buf.value != in_buf.value) (void) gss_release_buffer(&min_stat, &out_buf); /* Ucitavanje podataka s potpisom posluzitelja */ if (PrimiToken(s, &token_flags, &out_buf) < 0) { (void) closesocket(s); (void) gss_delete_sec_context(&min_stat, &context, GSS_C_NO_BUFFER); return -1; } if (verbose) printf("Primljena je poruka velicine %d bajtova...\n", (int) out_buf.length); if (mic_flag) { /* Verificiranje potpisa */ maj_stat = gss_verify_mic(&min_stat, context, &in_buf, &out_buf, &qop_status); if (maj_stat != GSS_S_COMPLETE) { IspisiGreskuGSSAPI("funkcija gss_verify_mic", maj_stat, min_stat); (void) closesocket(s); (void) gss_delete_sec_context(&min_stat, &context, GSS_C_NO_BUFFER); return -1; } if (verbose) printf("Digitalni potpis je verificiran.\n"); } else { if (verbose) printf("Odgovor posluzitelja je zaprimljen.\n"); } free (out_buf.value); if (koristi_se_datoteka) free(in_buf.value); /* Salje se NOOP token */ (void) PosaljiToken(s, TOKEN_NOOP, prazni_token); if (auth_flag) { /* Unistava se kontekst */ maj_stat = gss_delete_sec_context(&min_stat, &context, &out_buf); if (maj_stat != GSS_S_COMPLETE) {

138

IspisiGreskuGSSAPI("brisanje konteksta", maj_stat, min_stat); (void) closesocket(s); (void) gss_delete_sec_context(&min_stat, &context, GSS_C_NO_BUFFER); return -1; } (void) gss_release_buffer(&min_stat, &out_buf); } (void) closesocket(s); return 0; } char *ime_servisa, *posluzitelj_host, *poruka; u_short port = 4444; int koristi_se_datoteka = 0; OM_uint32 gss_flags = GSS_C_CONF_FLAG | GSS_C_INTEG_FLAG | GSS_C_DELEG_FLAG | GSS_C_MUTUAL_FLAG | GSS_C_REPLAY_FLAG | GSS_C_SEQUENCE_FLAG ; OM_uint32 min_stat; gss_OID oid = GSS_C_NULL_OID; int auth_flag, wrap_flag, encrypt_flag, mic_flag; /******************************************************************** Prema uputama navedenim u funkciji Koristenje, u funkciji main se inicijaliziraju ulazni parametri programa a zatim se pozivaju funkcije DohvatiInfoPosluzitelja i PozoviPosluzitelja. ********************************************************************/ int main(argc, argv) int argc; char **argv; { int i; prikaz_dat = stdout; auth_flag = wrap_flag = encrypt_flag = mic_flag = 1; argc--; argv++; while (argc) { if (strcmp(*argv, "-port") == 0) { argc--; argv++; if (!argc) Koristenje(); port = atoi(*argv); } else if (strcmp(*argv, "-noint") == 0) { gss_flags &= ~GSS_C_INTEG_FLAG; } else if (strcmp(*argv, "-noconf") == 0) { gss_flags &= ~GSS_C_CONF_FLAG;

} else if (strcmp(*argv, "-nodeleg") == 0) { gss_flags &= ~GSS_C_DELEG_FLAG; } else if (strcmp(*argv, "-noseq") == 0) { gss_flags &= ~GSS_C_SEQUENCE_FLAG; } else if (strcmp(*argv, "-norep") == 0) { gss_flags &= ~GSS_C_REPLAY_FLAG; } else if (strcmp(*argv, "-nomut") == 0) { gss_flags &= ~GSS_C_MUTUAL_FLAG; } else if (strcmp(*argv, "-dat") == 0) { koristi_se_datoteka = 1; } else if (strcmp(*argv, "-na") == 0) { auth_flag = wrap_flag = encrypt_flag = mic_flag = 0; } else if (strcmp(*argv, "-nw") == 0) { wrap_flag = 0;

} else if (strcmp(*argv, "-nx") == 0) {

139

encrypt_flag = 0; } else if (strcmp(*argv, "-nm") == 0) { mic_flag = 0; } else break; argc--; argv++; } if (argc != 3) Koristenje(); posluzitelj_host = *argv++; ime_servisa = *argv++; poruka = *argv++; if (DohvatiInfoPosluzitelja(posluzitelj_host, port) < 0) { exit(1); } /* Uspostavljanje veze s posluziteljem */ if(PozoviPosluzitelja(posluzitelj_host, port, oid, ime_servisa, gss_flags, auth_flag, wrap_flag, encrypt_flag, mic_flag, poruka, koristi_se_datoteka) < 0) exit(1); if (oid != GSS_C_NULL_OID) (void) gss_release_oid(&min_stat, &oid); return 0; }