1

Sveučilište u Zagrebu

Fakultet elektrotehnike i računarstva

Seminarski rad

Simulator OTP uređaja

Kolegij:

Sigurnost računalnih sustava

Nositelj:

Prof. dr. sc. Marin Golub

Student:

Predrag Brođanac, dipl. inž.

2

Sadržaj

1 Uvod ................................................................................................................................................ 3

2 Jednokratna lozinka ......................................................................................................................... 4

2.1 Generiranje OTP-a na osnovu brojača ..................................................................................... 4

2.2 Generiranje OTP-a na osnovu vremena .................................................................................. 4

3 HOTP algoritam ............................................................................................................................... 5

3.1 HMAC ....................................................................................................................................... 6

3.2 Generiranje HOTP vrijednosti .................................................................................................. 6

3.3 Sinkronizacija brojača na poslužitelju...................................................................................... 7

3.4 Sigurnost HOTP algoritma ....................................................................................................... 7

3.4.1 Analiza sigurnosti ............................................................................................................. 8

4 Simulator OTP uređaja .................................................................................................................. 10

4.1 Modul OTP ............................................................................................................................. 10

4.2 Simulator OTP uređaja .......................................................................................................... 11

4.2.1 Modul OTPTokenClass ................................................................................................... 13

4.2.2 Modul OTPToken ........................................................................................................... 15

4.3 Simulator servisa koji koriste OTP ......................................................................................... 16

4.3.2 Modul OTPServerClass .................................................................................................. 19

4.3.3 Modul OTPServer .......................................................................................................... 21

5 Zaključak ........................................................................................................................................ 23

6 Literatura ....................................................................................................................................... 24

3

1 Uvod

U današnje vrijeme računalna sve više pronalaze svoju upotrebu unutar svakodnevnice. Sve više

svakodnevnih radnji je doživjelo svoj preobražaj na način da se izvode pomoću računala. Tako je

primjerice sve manji broj ljudi koji svoje račune plaćaju u ustanovama za plaćanje (banke i sl.), dok je

sve veći broj onih koji to rade putem nekog oblika e-bankarstva. Kupnja putem Interneta sve je

prisutnija. E-mail je postao standard komunikacije i sl. Međutim uvijek dolazimo do pitanja koliko je

sve to sigurno? Je li logiranje na stranice e-bankarstva te transfer novca uistinu siguran? Zasigurno

nije u potpunosti siguran no uz današnje sigurnosne protokole su mogućnosti zloupotrebe ovakvih

sustava svedene na prihvatljivu razinu. Takvi sustavi se neprekidno mijenjaju. Neki sustavi za koje se

je smatralo da su dovoljno sigurni danas više nisu u upotrebi ili nisu u upotrebi u tom obliku jer su se

tijekom vremena pronašli nedostaci odnosno pronađeni su sigurniji sustavi. Jedan od standardnih

načina logiranja u sustave jest upisivanje korisničkog imena i lozinke. Korisničko ime je u tom slučaju

javni podatak dok je lozinka podatak koji je poznat samo osobi koja je vlasnik korisničkog računa za

pristup tom sustavu. Kod takvih sustava lozinka je statička i rijetko se mijenja čime su povećane

mogućnosti neovlaštenog pristupa. Danas su sve češće autorizacije s dva koraka (2-step verification).

Danas postoji više različitih tipova ovakve autorizacije. U nastavku će biti riječi o autorizaciji pomoću

tokena koji generira jednokratnu lozinku za pristup sustavu.

4

2 Jednokratna lozinka

Jednokratna lozinka (OTP – One-time Password) omogućava pristup različitim informacijskim

sustavima na način da je lozinka za pristup svaki puta drugačija. Na ovaj način se izbjegava niz

nedostataka standardne, trajne lozinke. Za generiranje ovakvih lozinki najčešće se koriste posebni

uređaji tzv. tokeni, no isto tako je moguće da ulogu tokena preuzmu mobilni uređaji, računalni

programi ili sl. Algoritmi na kojima se temelji rad ovakvih uređaja uglavnom se temelje na

nasumičnosti. To je obavezno iz razloga što bi inače bilo moguće predvidjeti sljedeću lozinku. Niz je

algoritama koji se koriste za generiranje tokena a u glavnom se temelje na nekom od sljedećih

principa:

• algoritam koji novu lozinku generira na osnovu brojača

• vremenska sinkronizacija između tokena i pripadnog poslužitelja

2.1 Generiranje OTP-a na osnovu brojača

Ovaj algoritam se temelji na internom brojaču koji se nalazi u samom OTP uređaju te na poslužitelju.

Postoji niz algoritama koji se za to koriste. U ovom radu će biti razmatran tzv. HOTP (HMAC-Based

One-Time Password) algoritam. Kod navedenog algoritma lozinka se generira pomoću tzv. HMAC-

SHA-1 funkcije a na osnovu brojača te još jednog ključa koji je najčešće oznaka token uređaja. Opći

algoritam se može jednostavno opisati sljedećom relacijom:

HOTP(K, C) = Truncate(HMAC-SHA-1(K, C))

Dakle, OTP se dobije na osnovu vrijednosti funkcije HMAC-SHA-1 nad parametrima C (brojač) te K

(ključ – oznaka uređaja). Budući da je vrijednost funkcije HMAC-SHA-1 160-bitovna a OTP najčešće

sadrži 6 do 8 znamenaka onda se koristi poseban algoritam (funkcija Truncate), koji će ovu vrijednost

svesti na 32-bitovnu iz koje će se onda dobiti OTP.

2.2 Generiranje OTP-a na osnovu vremena

Ovakvi OTP uređaji imaju u sebi integriran sat koji je sinkroniziran sa pripadnim poslužiteljem. Kod

takvih sustava lozinka se generira na osnovu trenutnog vremena. Princip je vrlo sličan generiranju

ključa pomoću brojača, no ovdje je brojač zamijenjen vremenskom varijablom T:

TOTP = HOTP(K, T)

gdje je T prirodan broj i predstavlja broj vremenskih koraka između inicijalne vrijednosti brojača (T0) i

trenutnog vremena.

� = �������� ��� ��� − ��� �

pri čemu je X unaprijed definirani period.

5

3 HOTP algoritam

Kao što je rečeno u prethodnom poglavlju HOTP algoritam generira sljedeću lozinku na osnovu

HMAC-SHA-1 funkcije te sljedeća dva parametra:

• K – ključ

• C – brojač

Algoritam za generiranje OTP-a treba zadovoljavati sljedeće zahtjeve:

1. algoritam se treba temeljiti na sekvencama ili brojačima te se treba moći ugraditi u različite

tipove uređaja (tokene, mobilne telfone,...)

2. algoritam treba biti ekonomičan za implementaciju na način da za rad troši minimalno

energije, minimalni broj gumba, i sl.

3. algoritam treba raditi na uređajima koji ne podržavaju nikakve tipkovnice

4. vrijednost koja se prikazuje na ekranu uređaja treba biti jednostavno čitljiva

5. lozinke trebaju imati minimalno 6 numeričkih vrijednosti

6. treba biti implementirana korisniku pogodna mogućnost sinkronizacije brojača

7. algoritam treba koristiti javni ključ čija vrijednost treba biti minimalno 128-bitovna

Osnovni parametri algoritma dani su sljedećom tablicom:

Parametar Značenje

C Brojač – 8-bajtovna vrijednost koja mora biti sinkronizirana s poslužiteljem

K Ključ – najčešće oznaka tokena. Svaki token mora imati svoju jedinstvenu vrijednost ključa

T Broj pokušaja utipkavanja lozinke nakon koje će poslužitelj blokirati uređaj

S Parametar sinkronizacije:server će računati s vrijednosti HOTP-a prije nego što "zaključi" da se radi o pogrešnoj lozinki

D Duljina lozinke

Tablica 1 – Parametri HOTP algoritma

OTP se dobije iz relacije:

HOTP(K, C) = Truncate(HMAC-SHA-1(K, C))

6

3.1 HMAC

HMAC (Key-Hashing for Message Authentication) omogućava provjeru integriteta podataka koji se

šalju putem nekog sustava, najčešće računalne mreže. Temelji se na tzv. MAC-u (Message

Authentication Codes). U nastavku će biti riječi o MAC algoritmu koji se temelji na kriptografskoj hash

funkciji (HMAC).

HMAC je moguće koristiti u kombinaciji s bilo kojom kriptografskom hash funkcijom (MD5, SHA-1,...).

Algoritam se temelji na višestrukoj primjeni funkcije kompresije na bloku podataka.

Neka je B duljina bloka podataka (u bajtovima) te neka je L duljina izlaza hash funkcije (u bajtovima)

(L=16 za MD5 funkciju, L=20 za SHA-1 funkciju). Ključ K može biti bilo koje duljine manje ili jednake od

B (duljina bloka hash funkcije). Najmanja preporučena duljina ključa K je L bajtova. Nadalje

definiramo dva različita stringa:

• ipad = bajt 0x36 ponavljan B puta

• opad = bajt 0x5C ponovljen B puta

Računanje vrijednosti funkcije HMAC nad zadanim tekstom (text) dana je sljedećom relacijom:

H (K XOR opad, H (K XOR ipad, text))

pri čemu je H neka hash funkcija.

3.2 Generiranje HOTP vrijednosti

HOTP vrijednost dobiva se u sljedeća 4 koraka:

1. HS = HMAC-SHA-1(K, C) – HS je duljine 20 bajtova

2. Sbit = DT(HS) – generiranje 4-bajtovnog stringa na osnovu vrijednosti HS

3. Snum = StrToNum(Sbit) – konvertira binarnu vrijednost S u broj

4. return D = Snum MOD 10 D – vraća vrijednost lozinke pri čemu je D duljina lozinke

Prvi korak ovog algoritma je trivijalan i odnosi se na pozivanje poznate funkcije HMAC-SHA-1. Koraci

3. i 4. su također trivijalni. Jedini problem u ovom trenutku jest korak 2. I njega ćemo detaljnije

obraditi u nastavku. Kao što možemo vidjeti to je funkcija Truncate – koju smo naveli na početku

ovog poglavlja.

• zadan string HS duljine 20 bajtova.

• OffsetBits = posljednja 4 bita 20. bajta stringa HS ( HS[19])

• P = HS[Offset] HS[Offset + 1] HS[Offset + 2] HS[Offset + 3]

• return posljednja 31 bita stringa P

7

Primjer 1:

Zadan je string HS u bajtovnom obliku:

HS = 1F8698690E02CA16618550EF7F19DA8E945B555A te neka je D = 6

Prikaz ovog stringa po bajtovima je sljedeći:

Redni

broj

bajta

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

Vr. bajta 1F 86 98 69 0E 02 CA 16 61 85 50 EF 7F 19 DA 8E 94 5B 55 5A

Posljednja četiri bita 20. bajta su: 0xA (posljednji bajt je 5A te su njegova posljednja 4 bita A).

Dakle OffsetBit = A te je pripadna OffsetValue = 10. P su dakle vrijednosti 10., 11., 12. i 13. bajta.

P = 0x50EF7F19

Posljednjih 31 bitova ovog stringa su: 010000111011110111111100011001, što u dekadskom sustavu

iznosi: 284131097.

Budući da je D = 6 dobivamo da je 284131097 MOD 106 = 131097. Dakle dobiveni HOTP je 131097.

3.3 Sinkronizacija brojača na poslužitelju

Budući da se brojač na poslužitelju ne mora nužno povećati svaki puta kada se poveća brojač na

token uređaju, često se događa da brojači nemaju jednaku vrijednost. U tom slučaju, budući da

vrijednosti brojača nisu jednake niti pripadne lozinke neće biti jednake te bi se autorizacija tretirala

kao neuspješna. Kako se to ne bi dogodilo na poslužitelju se definira parametar S – parametar

resinkronizacije. Konkretno to znaći da ukoliko je vrijednost brojača na poslužitelju jednaka CP onda

će se provjeravati brojaći CP, CP + 1, CP + 2,... CP + S – 1. Ukoliko neki od brojača (CP + i) zajedno s

pripadnim ključem K da OTP broj koji je ekvivalentan broju dobivenom na tokenu autorizacija će biti

uspješna te će nova vrijednost brojača postati jednaka vrijednost za koju su se OTP-ovi poklopili (CP =

CP + i).

3.4 Sigurnost HOTP algoritma

Svaki OTP algoritam siguran je onoliko koliko je sigurna aplikacija odnosno njen pripadni

autentifikacijski protokol. Veliki odraz na sigurnost imaju parametri T (broj pokušaja utipkavanja

lozinke nakon kojeg će sustav onemogućiti ponovni pristup) i S (parametar resinkronizacije).

Sljedeći važan parametar je duljina lozinke (D). Kraća lozinka omogućava probijanje lozinke metodom

grube sile, stoga poslužiteljska aplikacija treba biti u mogućnosti detektirati takav napad te ga

zaustaviti. To se postiže definiranjem parametra T. Nakon što korisnik unese pogrešnu lozinku sustav

za odgovarajućeg korisnika povećava broj pogrešnih pokušaja za 1 te u trenutku kada broj pogrešnih

pokušaja dosegne vrijednost T sustav blokira tog korisnika i on se više ne može logirati u sustav.

Preporuča se da vrijednost parametra T ne bude velika.

8

Druga mogućnost za suzbijanje napada grubom silom jest da se nakon svakog neuspješnog pokušaja

logiranja sustav „zamrzne“ na neko dodatno vrijeme A. Tako primjerice za prvi pogrešan pokušaj

logiranja sustav će biti blokiran na A sekundi, nakon 2 uzastopna pokušaja će biti blokiran na 2*A

sekundi, odnosno nakon K uzastopnih bezuspješnih pokušaja sustav će biti blokiran K * A sekundi.

Ovakav pristup onemogućava napade koji se temelje na tehnici paralelnog pogađanja.

3.4.1 Analiza sigurnosti

Kako bismo imali uspješno implementiran HOTP sustav korisnik i poslužitelj trebaju imati isti:

• ključ - K

• algoritam za računanje OTP-a – ALG

• brojač - C

Korisnik se autentificira slanjem vrijednosti ALG(K, C) poslužitelju. Dobivenu vrijednost z poslužitelj će

prihvatiti ukoliko postoji broj i takav da je z = ALG(K, i), pri čemu je i neki od brojeva iz skupa: CP, CP +

1,.... CP + S – 1. Pri čemu je CP trenutna vrijednost brojača na poslužitelju a S je parametar

resinhronizacije. Ukoliko postoji takav i za koji je z = ALG(K, i) tada će vrijednost poslužiteljskog

brojača postati i (CP = i).

Formalni "neprijatelj" B, koji želi napasti sustav trebao bi dakle uspjeti spoznati algoritam (ALG) te

ostale sistemske parametre (K i C).

Prije nego nastavimo s razmatranjima dokazat ćemo sljedeću lemu:

Lema 1:

Neka je 1 ≤ m ≤ N, prirodan broj te neka je N = m * q + r. Neka je z ∈ Zm za koji vrijedi:

P {N, M}(z) = p[x mod m = z : x ∈ Zn]

Tada za svaki z ∈ Zm vrijedi:

{ }( )

≤≤

<≤+

=mzrjeako

N

q

rzjeakoN

q

zmNP,

0,1

,

Dokaz:

Neka je nasumična varijabla X uniformno distribuirana nad Zn. Tada je:

9

{ }( ) [ ][ ] [ ] [ ] [ ]

≤≤

<≤+

≤≤−

−<≤−

⋅−+⋅=

<≤=⋅<≤+<=⋅<===

mzr

rzNN

q

mzmqN

mqNzmqNn

mqN

mN

mq

NXmqzmXpNXmqpmqXzmXpmqXp

zmXpzmNP

,0

0,1

,0

0,1

1

|mod|mod

mod,

g

Neka je N = 231, d = 6 i m = 10d

. Ako je x nasumičan broj iz Zn(x je nasumični 31-bitovni string).

Prema Lemi 1 slijedi da je vjerojatnost da će x biti traženi broj dana sa:

<≤⋅=≈

<≤⋅=≈=

66316-31

6316-31

10mod10mod2,100.999789774780.000000992

2147

10mod2mod0,101.000240240440.000001002

2148

)(mxza

mxzaxp

Pogledajmo nadalje što se događa s vjerojatnošću pogađanja broja ukoliko imamo T pokušaja

pogađanja te ako je parametar resinkronizacije na serveru jednak S:

Propozicija 1:

Neka je N = 231, m = 10d, m < N. Nadalje neka je N = q * m + r i B napad s T mogućih pokušaja

pogađanja te a ≤ 2C – S. Tada je vjerojatnost da ćemo pogoditi traženu vrijednost u V pokušaja dana

sa:

( ) ( )N

qTSBp

1+⋅⋅≤ .

Promotrimo navedenu vrijednost za d = 6:

Budući da je d = 6 i N = 231, slijedi da je q = 2147. Za navedene parametre vrijedi:

( ) ( ) 631

1000024045,12

12147 −⋅⋅⋅≈+⋅⋅≤ TSTS

Bp

Promotrimo s druge strane vjerojatnost pogađanja broja x koji se sastoji od d znamenaka u T

pokušaja, pri čemu parametar resinkronizacije ima vrijednost S metodom grube sile:

Propozicija 2:

Neka je N = 231, m = 10d, m < N. Nadalje neka je N = q * m + r i S ≤ m. Napad grubom silom B s T

pokušaja bit će uspješan s vjerojatnošću:

10

( ) ( ) SqT

Bp

+−−=312

111

Što približno iznosi:

( ) ( )312

1+⋅⋅≈ qTSBp .

Iz navedenih razmatranja slijedi da je napad grubom silom efikasniji od bilo kojeg drugog napada.

4 Simulator OTP uređaja

Cilj ovog rada bio je kreirati računalni program koji će simulirati OTP uređaj. Simulator se sastoji od

dva dijela (aplikacije):

• aplikacija koja simulira OTP uređaj

• aplikacija koja simulira servise u koje se korisnik logira koristeći OTP

Aplikacije su izrađene u .NET tehnologiji te je za njihovo korištenje potrebno na računalu imati

instaliran .NET Framework 4.

Aplikacija je kreirana modularno te se pojedini moduli mogu kao gotovi koristiti u nekim budućim

aplikacijama.

4.1 Modul OTP

OTP je osnovni modula aplikacije koji je namijenjen računanju vrijednosti OTP-a na osnovu danih

parametara (ključa i brojača). Ovaj modul ima samo jednu klasu – OTPClass, koja se koristi u oba

dijela aplikacije (simulatoru OTP uređaja i simulatoru servisa koji koristi OTP). Ova klasa sadrži

osnovne podatke (svojstva) potrebne za generiranje OTP-a, metodu koja generira OTP te potrebne

konstruktore:

Element Opis

String TokenKey Oznaka tokena

int Counter Trenutna vrijednost brojača

int NUMDigit Duljina generiranog OTP-a

OTPClass() Konstruktor

OTPClass(String TokenKey) Konstruktor

OTPClass(String TokenKey, int Counter)

Konstruktor

11

OTPClass(String TokenKey, int Counter, int NUMDigit)

Konstruktor

String Next() Metoda koja generira OTP na osnovu trenutne

vrijednosti brojača te oznake tokena

Tablica 1: Svojstva i metode klase OTPClass

Najvažnija metoda ove klase jest metoda Next() koja na osnovu svojstava generira sljedeći OTP

algoritmom opisanim u prethodnom poglavlju. Budući da se radi o metodi koja je ovdje ključna u

nastavku je naveden njen cjelokpan programski kod:

public String Next() {

HMACSHA1 hma_sha_1 = new HMACSHA1( Encoding .Default.GetBytes(TokenKey)); byte [] hmac_result =

hma_sha_1.ComputeHash( Encoding .Default.GetBytes(Counter.ToString())); Counter++; int offset = hmac_result[19] & 0xf; int bin_code = (hmac_result[offset] & 0x7f) << 24 | (h mac_result[offset]

& 0xff) << 16 | (hmac_result[offset] & 0xff) << 8 | (hmac_result[offset] & 0xff);

bin_code %= ( int ) Math .Pow(10, NUMDigit); String tmp = bin_code.ToString(); while (tmp.Length < NUMDigit)

tmp = "0" + tmp; return tmp;

}

4.2 Simulator OTP uređaja

Cilj ovog modula jest simulirati rad OTP uređaja (tokena). Samo sučelje je kreirano na način da

"podsjeća" na OTP uređaj.

Slika 1: Simulator OTP uređaja

12

Ovaj simulator zamišljen je tako da se može istovremeno koristiti za više servisa. Popis servisa koje će

podržavati naveden je u postavkama simulatora i može se mijenjati.

Pokretanjem simulatora na ekranu će se pojaviti prozor kao na slici 1. Simulator ima svoj broj (Token

NO) koji predstavlja ključ (key) koji će se koristiti prilikom logiranja u neki od simulatora servisa.

Na samom početku od korisnika se traži da unese lozinku za pristup simulatoru. U inicijalnim

postavkama je lozinka postavljena na 0000 i ona se ne može programski mijenjati. Nakon ispravno

unesene lozinke na ekranu simulatora se pojavljuje prozor za odabir aplikacije za kuju želimo

generirati OTP (Slika 2).

Slika 2: Simulator OTP uređaja – ekran za odabir aplikacije.

Aplikacija se odabire na način da se unese redni broj aplikacije. Aplikacije su numerirane brojevima

od 0 do 9 a u inicijalnoj verziji programa su aktivne aplikacije s rednim brojevima 0, 1 i 2. Nakon

odabira aplikacije na ekranu se pojavljuje OTP. Broj znamenaka OTP-a za neku aplikaciju određen je

postavkama te aplikacije. Za generiranje sljedećeg OTP-a potrebno je pritisnuti tipku < na OTP

simulatoru. Svaka aplikacija ima svoj poseban brojač koji je također spremljen u postavkama

aplikacije te se prilikom svakog generiranja novog OTP-a taj brojač poveća za 1.

Aplikacija je realizirana kao Windows Forms Aplikacija koja se uvelike oslanja na modul

OTPTokenClass.

13

4.2.1 Modul OTPTokenClass

Ovaj modul sadrži implementaciju svih važnih dijelova programa OTP simulator. Slično kao i modul

OTP klase ovog modula moguće je koristiti i u nekim drugačijim implementacijama OTP simulatora

(simulator za mobilne uređaje, simulator za web i sl.). Modul OTPTokenClass sastoji se od dvije

klase:

• Token – sadrži sve potrebne podatke za neki OTP uređaj. U sljedećoj tablici su pobrojana

svojstva te konstruktori ove klase:

Element Opis

String Key Oznaka OTP uređaja

int Count Trenutna vrijednost brojača

int CodeLength Duljina OTP-a (broj znamenaka OTP-a)

Token() Konstruktor bez parametara

Token(String Key, int Count, int CodeLength)

Konstruktor s osnovnim parametrima

Tablica 2: Svojstva i metode klase Token

• TokenPresenter – sadrži implementaciju svih važnijih funkcionalnosti OTP simulatora:

Element Opis

TokenPresenter(ITokenView View) Konstruktor čiji je parametar naziv klase

koja implementira interface ITokenVIew

void ButtonPressed(int button) Na osnovu pritisnutog gumba mijenja vrijednost svojstva ScreenText – interfacea ITokenView odnosno sadržaj na ekranu tokena

void Tick() Isključuje simulator nakon zadanog vremenskog intervala neaktivnosti

void CreateCode() Kreira sljedeći OTP za zadanu aplikaciju te povećava i sprema pripadni brojač

Tablica 3: Svojstva i metode klase TokenPresenter

te sučelje:

• ITokenView – sadrži zaglavlja svih potrebnih svojstava i metoda koje će moći koristiti

sučelje OTP simulatora:

14

Element Opis

String TokenID Oznaka tokena

int NumberOfAttempts Redni broj krivog pokušaja logiranja u OTP uređaj

int TotalNumberOfAttempts Ukupni broj pogrešnih pokušaja nakon kojeg će se

simulator automatski zaključati

String ScreenText Sadržaj ekrana OTP simulatora

String ScreenMask Maskiranje ekrana

Boolean Generated Vraća true ako je OTP već generiran u trenutnom

korištenju aplikacije, inače vraća fals

int WaitUntilClose Nakon koliko sekundi će se simulator isključiti nakon što

nad njim neće biti nikakve aktivnosti

Boolean Logged Vraća vrijednost true ako je korisnik uspješno logiran u

OTP simulator, inače vraća false.

int ApplicationNumber Redni broj trenutno aktivne aplikacije na OTP simulatoru

IList<Token> AllTokens Popis svih aplikacija koje podržava OTP simulator

int PasswordLength Duljina OTP-a za danu aplikaciju

String Password Vrijednost lozinke koju je korisnik upisao u simulator

neposredno nakon uključivanja simulatora

void SaveData() Sprema vrijednosti brojača na za to predviđeno mjesto

(datoteka, konfiguracijska datoteka,...)

void LogIn() Logiranje korisnika

void Disable() Zaključava simulator (zbog prekoračenog broja

uzastopnih pokušaja ulaska u aplikaciju)

void CloseToken() Zatvara simulator

void ResetTimer() Resetira timer nakon kojeg će se simulator ugasiti

Tablica 4: Svojstva i metode sučelja ITokenView

15

4.2.2 Modul OTPToken

Implementacija simulatora nalazi se u modulu OTPToken. U ovom slučaju ta klasa predstavlja

Windows Forms Aplikaciju koja ima samo jednu klasu (prozor kao na slici 1) te implementira klasu

ITokenView.

Prilikom pokretanja ove aplikacije potrebno je učitati određene podatke koji su potreban za rad

simulatora. Svi ti podaci su u ovom slučaju spremljeni u konfiguracijsku datoteku programa

(app.config). Podaci su spremljeni kao svojstva aplikacije a radi se o sljedećim svojstvima:

• Pass – vrijednost passworda kriptiranog SHA funkcijom

• PasswordLength – broj znamenaka za početnu lozinku kod uključivanja simulatora

• TokenNumber – oznaka Tokena

• NumberOfError – ukupni broj pogrešnih pokušaja logiranja

• TotalNumberOfErrors – broj pokušaja logiranja u Simulator nakon kojeg će simulator

biti blokiran

• Tokens – popis aplikacija koje se mogu koristiti na simulatoru. Za svaku aplikaciju čuvaju se

sljedeće vrijednosti, koje su međusobno odvojene znakom "|", dok su podaci o aplikacijama

odvojeni znakom ";":

o Oznaka – broj simulatora u čijem nastavku slijedi redni broj aplikacije

o Trenutne vrijednosti brojača

o Duljina OTP-a koji će se generirati za aplikaciju

Npr. 123456780|135|6;123456781|0|7 – ovdje se radi o dvije aplikacije, čije su oznake: 123456780 i

123456781. Brojač prve aplikacije ima vrijednost 135 dok je brojač za drugu aplikaciju postavljen na 0

te prva aplikacija generira OTP duljine 6 znamenaka dok druga generira OTP od 7 znamenaka.

Klasa OTPToken u osnovi ne radi puno toga, ona sve poslove uglavnom delegira klasi

TokenPresenter koja obrađuje sav važan posao. Najvažnije metode klase OTPToken su

konstruktor koji iz konfiguracijske datoteke učitava sve parametre aplikacije:

public OTPToken() {

InitializeComponent(); tok = LoadTokens(); _tokenID = Properties. Settings .Default.TokenNumber; tokenNUM.Text = "Token NO: " + _tokenID; _numberOfAttempts = Properties. Settings .Default.NumberOfError; _totalAttemptsCount =Properties. Settings .Default.TotalNumberOffError; _password = Properties. Settings .Default.Pass; _passLength = Properties. Settings .Default.PasswordLength; _presenter = new TokenPresenter ( this );

}

16

te metoda LoadTokens() koja iz konfiguracijske datoteke učitava podatke o svim aplikacijama

koje podržava token:

private IList <Token > LoadTokens() {

String [] tmp = Properties. Settings .Default.Tokens.Split( ';' ); tok = new List <Token >(); foreach ( String s in tmp) {

String [] temp = s.Split( '|' ); Token t = new Token (temp[0], Convert .ToInt32(temp[1]),

Convert .ToInt32(temp[2])); tok.Add(t);

} return tok;

}

Nadalje je definirana metoda za svaki klik na gumb a svaka od tih metoda samo poziva metodu

ButtonPressed klase TokenPresenter prosljeđuje joj podatke o gumbu koji je pritisnut

(vrijednost koja piše na gumbu, za gumb < prosljeđuje vrijednost 10). Metoda ButtonPressed će

obraditi događaj te će putem svojstava i metoda sučelja ITokenView izmijeniti podatke na ekranu

simulatora. U nastavku definicije ove metode su još implementacije svih svojstava i metoda sučelja

ITokenView koje se uglavnom svode na postavljanje i vraćanje odgovarajučih svojstava.

4.3 Simulator servisa koji koriste OTP

Za ilustraciju rada OTP simulatora kreirana je aplikacija Servisi koja omogućava pokretanje triju

aplikacija koje za logiranje trebaju OTP. Pokretanjem aplikacije Servisi na ekranu će se pojaviti sljedeći

prozor:

Slika 3: Osnovni prozor aplikacije Servisi.

Kao što možemo primijetiti ovdje su definirana 3 servisa:

• Internet bankarstvo

17

• Internet kupovina • Online shop #2

Ovi servisi (aplikacije) predstavljaju tri aplikacije koje smo imali kod simulatora OTP uređaja (Internet

bankarstvo – aplikacija 0, Internet kupovina – aplikacija 1, Online shop #2 – aplikacija 2).

Klikom na neku od stavki na prozoru Servisi otvorit će se određeno sučelje za određeni servis:

Slika 4: Sučelje servisa Internet bankarstvo

Pokretanjem određenog servisa potrebno je upisati broj tokena (u osnovnim postavkama aplikacije je

to broj 12345678) te pročitati broj koji je na tokenu generiran nakon što je odabrana odgovarajuća

aplikacija. Dobiveni broj potrebno je prepisati u okvir za unos teksta OTP. Ukoliko su brojači

"sinkronizirani" te ukoliko su ispravno upisani broj tokena i OTP na ekranu će se pojaviti poruka da je

ulaz u aplikaciju moguć (Slika 5) u suprotnom će se pojaviti poruka o greški te broju pogrešnih

pokušaja (Slika 6).

18

Slika 5. Uspješno pokretanje servisa pomoću OTP-a

Slika 6. Neuspjeli pokušaj pokretanja servisa

Nakon što korisnik više puta (ovisno o servisu) uzastopno unese krivi OTP servis će biti blokiran.

Slično kao i Simulator OTP uređaja i ovaj simulator se sastoji od dva modula. Generički modul

(OTPServerClass) koji sadrži sve potrebne metode za implementaciju pojedinog servisa. Drugi

modul je OTPServer implementira konkretni servis koristeći metode i svojstva modula

OTPServerClass.

19

4.3.2 Modul OTPServerClass

Kao što je već rečeno ovaj modul sadrži čitavu funkcionalnost koja je potrebna za autentifikaciju

pomoću OTP-a. Sastoji se od dvije klase:

• Service – sadrži sve potrebne podatke o jednom servisu:

Element Opis

String ID Oznaka servisa

String Name Naziv servisa

int CodeLength Duljina OTP-a

int TotalNumberOfAttemts Ukupni broj dozvoljenih pogrešnih pokušaja logiranja u servis

nakon kojega će servis biti blokiran(inicijalno 3)

int ForwardLook Parametar resinkronizacije (koliko sljedećih vrijednosti brojača će

se na serveru provjeravati), inicijalno je vrijednost ovog svojstva

postavljena na 30

int Count Vrijednost brojača za zadani servis

int NumberOfAttempts Broj pogrešnih pokušaja logiranja u aplikaciju

Boolean Locked Zaključan servis

Service() Konstruktor klase

Service(String ID, int

Count, int NumberOfAttempts,

Boolean Locked)

Konstruktor klase

Tablica 5: Svojstva i metode klase Service

• ServerPresenter – sadrži osnovnu funkcionalnost za logiranje u jedan servis putem

OTP-a

Element Opis

ServerPresenter(IServerView View) Konstruktor klase čiji je parametar ulazna forma za

logiranje u neki servis a koja implementira sučelje

IServerView

void LogIn() Logira korisnika u servis putem oznake OTP uređaja te

vrijednosti OTP broja.

Ukoliko ne postoji servis sa zadanom oznakom vratit će

poruku o greški.

Isto tako poruku o greški će vratiti i ukoliko servis postoji a

20

pogrešno je unesen OTP. U tom će selućaju povečati brojač

za 1 te će provjeriti je li broj pogrešnih pokušaja dosegao

maksimalni dozvoljeni broj te će u tom slučaju pozvati

metodu za blokiranje servisa.

Ukoliko postoji servis i OTP je ispravan resetirat će se

brojač pogrešnih pokušaja logiranja u servis te će njegova

vrijednost postati 0 isto tako će vrijednost brojača

(Coutner) postaviti na trenutnu vrijednost.

Tablica 6: Svojstva i metode klase ServerPresenter

te sučelja:

• IServerView – sadrži zaglavlja svih metoda i svojstava koje omogućavaju kreiranje

instance jednog servisa

Element Opis

String TokenNO Oznaka tokena

String OTPNO Vrijednost OTP-a

int NumberOfAttempts Broj pogrešnih pokušaja logiranja u servis

int CodeLength Duljina OTP-a

int ForwardLook Vrijednost parametra resinkronizacije

Service ActiveService Vraća aktivni servis (na osnovu oznake tokena)

void UpdateCunter(Service u) Povećava vrijednost brojača

void ShowMainScreen() Prikazuje glavni ekran servisa (ukoliko je logiranje bilo

uspješno)

void ShowOTPError(int i) Ispisuje poruku da je unesen pogrešan OTP i-ti puta za

redom

void ShowServiceError() Ispisuje poruku da ne postoji token s unesenim brojem

void ShowLockedError() Ispisuje poruku da je servis blokiran

Tablica 7: Svojstva i metode sučelja IServerView

21

4.3.3 Modul OTPServer

Ovaj modul sadrži grafičko sučelje aplikacije za simuliranje rada servisa te se sastoji od osnovnog

prozora za prikaz svih aktivnih servisa (slika 3). Klikom na neku od stavki iz popisa otvara se prozor

pripadnog servisa.

Popis svih servisa zajedno sa pripadnim svojstvima u ovom se slučaju nalazi u bazi podataka. Baza

podataka se sastoji samo od jedne tablice (Tokens) koja ima sljedeći oblik:

Slika 7. Prikaz podataka u tablici Tokens

Svaki servis ima svoj ID. ID je ovdje kombinacija oznake tokena (12345678) te rednog broja aplikacije

unutar tokena (u ovom slučaju su to aplikacije 0, 1 i 2).

Nakon pokretanja glavnog prozora aplikacije Servisi korisnik će dvostrukim klikom na sličicu, iz popisa

servisa, pokrenuti prozor pojedinog servisa. Klikom na neki od servisa poziva se metoda koja pokreće

odgovarajući servis, te tom servisu prosljeđuje sve podatke važne za njega. U ovom slučaju ta metoda

ima sljedeći oblik:

private void ServiceTree_NodeMouseDoubleClick( object sender, TreeNodeMouseClickEventArgs e) {

Form f; switch (e.Node.Index) {

case 0: f = new OTPServer (Services[0]); f.ShowDialog(); break ;

case 1: f = new Service2 (Services[1]); f.ShowDialog(); break ;

case 2: f = new Service3 (Services[2]); f.ShowDialog(); break ;

} }

Svaki serivs u ovom slučaju ima karakterističan oblik i sastoji se od prozora za unos oznake tokena te

prozora za unos OTP-a (slika 4). Svaki servis je jedna Windows forma koja implementira sučelje

IServerView. Ta forma treba raspolagati sa svim podacima vezanim uz servis (ID, brojač,...) a te

podatke će dobiti iz glavnog prozora aplikacije (Servisi):

public Service2( Service s) {

InitializeComponent(); _presenter = new ServerPresenter ( this ); this .service = s; this .Text = s.Name;

22

this .serviceName.Text = s.Name; }

Nakon pokretanja servisa korisnik će u prozor upisati oznaku tokena te će iz OTP simulatora prepisati

broj i kliknuti na gumb za logiranje. Sam postupak logiranja svodi se na pozivanje metode LogIn

klase ServerPresenter.

23

5 Zaključak

Token uređaje uglavnom koristimo kako bismo postupak autoriziranja u neki sustav učinili sigurnijim

jer se zahtjeva logiranje u dva koraka. Radi se o tome da imamo token uređaj i poslužiteljsku

aplikaciju u koju se želimo logirati te je za potrebe logiranja potrebno unijeti oznaku tokena te broj

koji je generiran na tokenu koji fizički moramo imati.

U ovom radu ilustriran je jedan od načina funkcioniranja token uređaja te pripadne poslužiteljske

aplikacije. Svi dijelovi programa napisani su modularno na način da ih je moguće iskoristiti i za neke

druge tipove .NET aplikacija. Osim toga dana je ideja korištenja istog tokena za više aplikacija. Ova

ideja mogla bi se doraditi na način da se doradi postupak registriranja nove aplikacije na tokenu te

registriranje tokena na nekoj aplikaciji. Nakon što imamo uređaj ili simulator uređaja koji je

primjerice moguće instalirati na mobilni telefon, a koji podržava više aplikacija istovremeno, to bi

omogućilo širu i češću upotrebu ovakvih uređaja ne samo u elektroničkom bankarstvu, gdje se oni

danas uglavnom koriste, već i za neke druge usluge, primjerice: pristup webmailu, sigurnoj kupnji

putem Interneta i sl.

24

6 Literatura

[1] D. M'Raihi, M.Bellare, F. Hoornaert, D. Naccache, O. Ranen, HOTP: An HMAC-Vased One-

Time password Algorithm, Network Working Group, 2005

[2] D. M'Raihi, S. Machani, M. Pei, J. Rydell, TOTP: Time-Based One-Time Password Algorithm,

Internet Engineering Task Force, 2011

[3] H. Krawczyk, M. Bellare, R. Canetti, HMAC: Key-Hashing for Message Authentication,

Network Working Group, 1997

[4] http://en.wikipedia.org/wiki/One-time_password

[5] http://en.wikipedia.org/wiki/Security_token