* 5 *

Protokoller og dataintegritet

Ukens faktum

Data encryption standard DES ble adoptert på 70-tallet som en standard for kryptering av ikke topp-hemmelige dokumenter i USAs regjering. Den effektive nøkkel lengden på 56 bits (i 8 bytes) gir bare svak kryptering idag. Algoritmen kan brukes med tre seperate 56 bit nøkler (i 24 bytes) ved hjelp av såkallt 3DES kryptering. DES har overlevd ti år lenger enn det som opprinnelig var ventet! I 1997 ble AES eller "Advanced Encryption Standard" annonsert, og en konkurranse ble holdt for å finne en passende algoritme. I Oktober 2000 vant Rijndael, laget av to Belgiske forskere. Denne algoritme ligner på DES men er modernisert.

Kapittel 10 Gollmann, kapittel 4 Stallings
En teori om utviklingen av intelligens i mennesker baserer seg på ideen at intelligens ble brukt for å jukse og lure andre. Erfaring viser stadig at, uten muligheten til å bekrefte fakta og sannheter, går samfunnet over i korrupsjon og endeløse maktkamper. Det ligger i menneskets natur. Autentiseringssystemer er et essensielt skritt i utviklingen av informasjonssystemer for korrupsjonsfrie og fredelige mål.

Sist brukte vi en del tid på å tenke gjennom hvordan autentisering og integritet kan avgjøres ved hjelp av hemmeligheter, unike egenskaper, kryptering og digitale signaturer. Før vi går videre i kurset, la oss se på noen eksempler på bruk av disse metodene.

Autentisering

Secure shell

Secure Shell er blitt en de-facto standard for Unix autentisering. Den bruker offentlig/privat nøkkelkryptering for å autentisere begge parter i en samtale .

Maskinene begynner ved å forsøke å bekrefte hverandres indentiteter. Først sjekker serveren IP adresse og hostname til brukerens maskin, så sender brukeren en offentlig nøkkel første gang han/hun logger seg på. Her et et utdrag fra manualen:

Each user creates a public / private key pair for authentication purposes. The server knows the user's public key, and only the user has the private key. The filenames of private keys that are used in authentication are set in $HOME/.ssh2/identification. When the user tries to authenticate himself, the server checks $HOME/.ssh2/authorization for filenames of matching public keys and sends a challenge to the user end. User is authenticated by signing the challenge using the private key.

Ssh2 automatically maintains and checks a database con- taining public keys of hosts. When logging on to a host for the first time, the host's public key is stored to a file .ssh2/hostkey_PORTNUMBER_HOSTNAME.pub in the user's home directory. If a host's identification changes, ssh2 issues warning and disables password authentication to prevent a Trojan horse from getting the user's password. Another purpose of this mechanism is to prevent man-in- the-middle attacks which could otherwise be used to cir- cumvent the encryption.

Maskinene sjekker om de kjenner den offentlige nøkkelen til brukeren fra før. Hvis så og nøklene ikke matcher, blir det en autentiseringsfeil. Hvis alt går bra, avtaler maskinene en sesjonsnøkkel som brukes for videre kryptering. Denne bruker ikke RSA da det ville kostet for mye regnetid. Istedet bruker de en vanlig symmetrisk nøkkel DESab(t), som er mye billigere i bruk.

    |      ( authentication )      |
    |           passord            |  
  A |  --------->PUBa -----------> |  B (kan offentlig n0kkel)
    |                              |
    | --- sign PRIV a -----------> |
    |                              |
    |          ( data )            |
    |                              |
    |  ---- >  DESab(t)  ----->    |
    |  <----   DESab(t)  -----     |

Det er også mulig å slippe passord dersom man overfører offentlig nøkkel manuelt i forveien, eller deler et felles homedir med den andre maskinen (f.eks. med NFS).

Cfengine - secure copy

I cfengine filkopiering, autentiseres nettverksforbindelser først med IP adresse og hostname. Siden streng fortrolighet ikke trengs i systemadministrasjon, brukes en relativt billig og lett-administrert form for kryptering videre. En felles 3DES nøkkel brukes av alle maskiner i en tillits-sone. Denne nøkkelen brukes for å utveklse en 3DES sesjonsnøkkel som brukes i videre kommunikasjon, for å unngå gjentagelser.

    |     ( authentication )       |
    |                              |  
  A |  -->DESab(DESab(t)) -------> |  B
    |                              |
    |  <--------DESab(t) --------- |
    |                              |
    |          ( data )            |
    |                              |
    |  ---- >  DESab(t)  ----->    |
    |  <----   DESab(t)  -----     |

Integriteten i overførte filer sjekkes med en MD5 sjekksum etter overførsel. Dermed etablerer vi tillit og integritet, med grei nok fortrolighet.

Kerberos

Kerberos er et autentiseringssystem laget som en del av prosjektet Athena ved Massachusetts Institute of Technology (MIT). Athena var opprinnelig et åtte års prosjekt, sammen med IBM og DEC (nå Compaq), for å skape et rimelig sikkert miljø for studentbruk av arbeidstasjoner, der passordavlytting var et problem. Autentiseringssystemet Kerberos har vunnet stor aksept blant OS leverandører, til tross for opplagte designproblemer. Ironisk nok, selv om Kerberos ble laget for Unix arbeidstasjoner, passer det bedre for NT hvor bare en bruker om gangen tillates på en arbeidstasjon.

Kerberos bruker DES kryptering (ikke RSA) for å beskytte følsom informasjon på nettet. Når en bruker logger seg på en maskin som kjører Kerberos, får han/hun en ticket/billett fra en Ticket Granting Server (TGS) (dette er en slags sesjonsnøkkel). Deretter må denne billetten vises i alle transaksjoner. All informasjon som sendes av Kerberos krypteres med en nøkkel som er basert på brukerens passord, slik at avlytting er umulig. I tillegg sendes passord aldri over nettet.

Kerberos autentisering er basert på passord som lagres på en Kerberos Authentication Server (KAS). I motsetning til Unix og NT passord, som krypteres med enveis hash-funskjoner, krypteres Kerberos passord med vanlig DES, slik at de kan dekrypteres av serveren når det er nødvendig. Dette blir sett på av mange som et alvorlig problem med Kerberos systemet.

Bruk av Kerberos er mer eller mindre transparent for brukere. Hoved forskjellen er at Kerberos billettene varer bare noen timer. Når billetten går ut, må brukere autentisere seg selv pånytt. Dette for å unngå muligheten for at noen skal kunne gjette eller skaffe kunnskaper om billetter til andre etter tid har gått. Det brukes to forskjellige versjoner av Kerberos: versjoner 4 og 5. Detaljene omkring disse er litt forskjellige, men hovedprinsippet er det samme. Her er en veldig forenklet beskrivelse (se Gollmann 10.2.1 for en bedre en). Anta at maskin A trenger en tjeneste fra maskin BV:

  1. En bruker skriver inn loginnavn og passord på maskin A ved sesjonsstart.
  2. Brukernavnet/ID sendes da med en random challenge og navnet på TGS, i klartekst til autentiseringsserveren (KAS).
  3. KAS svarer med en sesjonsnøkkel eller et engangspassord som skal brukes for å snakke med Ticket server som er kryptert med brukerens passord (lagret på KAS).
  4. Brukeren kan dekryptere sesjonsnøkkelen dersom passordet matcher den på serveren. Dersom alt går bra, får brukeren nøkkelen K_tgs som bevis på autentisering.
  5. Ved å bruke sesjonsnøkkelen K_tgs, skaffer brukerens arbeidstasjon en krypteringsnøkkel fra TGS hver gang den trenger å snakke med en server. Brukerens passord trengs ikke lenger; billetten brukes i stedet. Ticket Serveren er altså en engangspassord-server som bruker nøkkelen K_tgs som legitimasjon.
Kerberos har en del svakheter:

DCE - Distributed Computing Environment

Digital Equipment Corporation (DEC, nå Compaq) har i samarbeid med andre utviklet sitt eget system for distribuert computing. Dette heter DCE. Det bruker et system lik det til Kerberos.

Directory Services: LDAP, NDS, AD

An idea which has become popular recently is that of directory services. Directory serviecs began as a way of disseminating user data (names, passwords, telephone numbers etc) throughout a complex organization. The concept has since spread into a general description of hierarchical network management, including security policies and access control mechanisms.

GNU/Linux and Unix-like systems are basing their efforts on an open standard directory service called L/DAP, devised by the University of Michigan.

Microsoft's recent addition to Windows 2000 is called the Active Directory. In Windows NT the domain was a separate entity requiring the security to be applied to each separate domain. Active Directory allows the security to be managed from the top down allowing for a consistent security policy through out the organization. Active Direcrory uses a version of Kerberos 5 for internal users. When a client PC requests authentication to a server the request goes to the Key Distribution Server (KDS). This responds to the client with the requested servers key, the client sends this key along with its request to the intended server, the server then authenticates the user. All of this communication is encrypted for use over an unprotected network.

External users can log on, using public key authentication, as in secure shell. When a user logs into AD an access token is created, these tokens consist of an individual Security Identifier (SID), a group SID for each group the user belongs to and user rights. When the user tries to access any AD object this token is compared to an Access Control List (ACL) to verify the user has authority to access the object.

Security is set in AD using group policies. This allows the administrator to set a uniform security policy across the domain. These policies can be set at the highest level of the organization and pushed down to all users.

PAM Pluggable Authentication Modules

En enkel måte å integrere flere autentiseringssystemer inn i et operativsystem ble innført av Sun Microsystems. Suns pluggable authentication modules for Solaris har siden blitt adoptert av flere OS leverandører og GNU/Linux distribusjoner. PAM kan settes opp til å bruke flere autentiseringssystemer ved innlogging. F. eks. kan en bruker taste inn ett passord som vil fungere som Unix innlogging og Kerberos innlogging. Andre muligheter er RADIUS (PC login), NDS, DCE og andre. Se /etc/pam.conf. PAM er en front-end mellom OS og mer omfattende autentisering.

Smartcards/Javacards

Smartcards have been around since the 1980's, particularly in Europe. They have small, dedicated microprocessor chips embedded. They typically consist of an 8-bit processor (8051/6805) and three classes of memory: ROM which holds a program, EPROM which holds customer data, and RAM (perhaps 16K) for performing computations.

Early bank cards in Norway used smartcards with embedded chips. These are now discontinued due to imcompatibilities with other systems, amongst other things. The main use today is in mobile phones and cable/satellite TV decoders, where SIMS (subscriber ID modules) are used to handle user details and encryption.

Smart cards were considered to be relatively tamper-proof and secure for years until European satellite TV started broadcasting Star Trek, and suddenly hundreds of computer-savvy geeks were looking for ways of breaking the codes.

Attacks on smartcards include:

Attacks on smartcards, their owners and makers are many: and so on...

Javacards are smartcards which contain a tiny Java virtual machine in ROM. The Java environment has a nnumber of features which are useful for smartcards. Applications can rely on a standard language and API (application programmer interface). There is also the promise of code standardization and platform independence. However, Java is not known for its resource efficiency, and the obstacles are many.

Integritet

Vi har diskutert data integritet ved hjelp av sjekksummer og digitale signaturer. Disse er regnemessig kostbare metoder for ekstra sikkerhet. Men hva med å sjekke om data ble oppfattet riktig? Dette er et mer fundamental problem som kan løses langt mer effektivt enn det å regne sjekksummer etter at dataene er sendt. Det er interessant å se hvordan dette grunnleggende problemet løses, før vi fortsetter med mer politisk motiverte saker.

Shannon: informasjonsteori

I dag er vi såpass vant til feilfri overførsel og lagring av data at vi tenker lite på problemer assosiert med datatap og feil. Men dette er selvsagt helt grunnleggende for informasjonssystemer. Hvis vi ønsker dataintegritet må vi først forstå hvordan data kan sendes og lagres med feiloppdagelse og korreksjon. Hvorfor er dette et sikkerhetstema? Det er to grunner: det første er at data ikke er sikret mot korrupsjon med mindre vi kan detektere og korrigere feil som oppstår mellom avsender og mottaker. Det andre er noe som vi nevnte i den første forelesningen. Tenk på mission critical systems. Vi trenger å være sikre på at våre instruksjoner kan kommuniseres uten tap eller feil. For eksempel, Galileo/Voyager romsondene svever langt ute i det ytre solsystemet. Det tar minutter eller timer å sende en beskjed til disse romskipene. Dersom det oppstår en feil ville det ikke være tid til å sende beskjeden pånytt. Støy er et problem over slike avstander, og sannsynligheten for at det vil oppstå feil er stor. Hva kan vi gjøre?

Dette problemet ble opprinnelig stillt av Claude Shannon ved Bell Labs på 40-tallet. Han løste også mange av de fundamentale problemene. En annen anvendelse av feilrettingsteknologier er parallele disksystemer (RAID) og minnebrikker.

Paritetssjekker

La oss anta at sannsynligheten for at det oppstår feil er liten. Dette er sant med dagens teknologi. Med `liten' så mener vi at sannsynligehten for at en enkelt bit blir feil i en beskjed er en liten brøkdel av en prosent (så liten som mulig). Vi ser helt bort fra slike katastrofale feil som riper eller brudd i media.

Paritet dreier seg om partall og oddetall. For å finne ut pariteten til en beskjed, legger vi sammen alle bitene. Dersom antallet 1'er er et partall sier vi at beskjeden har null paritet (even parity) eller paritet 0. Dersom summen er et oddetall, sier vi at beskjeden har odde paritet, eller paritet 1. En annen måte å uttrykke dette på er dette:

 Parity = Sum_av_bits mod 2
Ideen med paritetssjekking er en meget primitiv form for message digest. Vi bruker en bit i en bitstreng (vanligvis per byte) til å signalisere pariteten til beskjeden. Avsenderen beregner pariteten til beskjeden og legger til en bit som sier om den er 1 eller 0. Mottakeren beregner pariteten i beskjeden pånytt og sjekker om det stemmer med paritetsbiten som ble sendt. Dersom det er uenighet så må det ha oppstått en feil, og dataene må sendes pånytt. Det er jo to problemer med dette:

Overflødighet i sambandet

En ting vi kan gjøre for å unngå det å sende data pånytt, gitt at feil er sjeldne, er å legge inn en overflødighet i beskjeden, dvs en backup. For eksempel, anta at vi vil sende følgende bit-strengen
|1001|1100|0000|0101|
Vi kunne sende to backup kopier av hver gruppe N bytes, si N=4
|              |              |              |              |
|1001|1001|1001|1100|1100|1100|0000|0000|0000|0101|0101|0101|
|              |              |              |              |
Dersom en feil oppstår, slik at beskjed mottas som
|              |              |              |              |
|1001|1001|1001|1100|1100|1100|0010|0000|0000|0101|0101|0101|
|              |              |  ^           |              |
                                 | (error)
kan dette rettes ved å anta at majoriteten vinner. Dvs man ser på alle tre grupper og velger svaret som står i de fleste bytes. Det er usannsynlig at den samme feilen ville oppstå i to grupper.

To dimensjonal paritet

En slik overfødighet er kostbar! Kan vi adaptere ideen bak paritet (som var mye billigere) slik at vi ikke bare oppdage feil, men også kan rette dem automatisk? Ja! For å gjøre dette legger vi bitstrømmen ut som et MxN array.
          N
  ---------------------
  | 1 1 0 1 .... 0 | 1
  | 0 0 0 1 .... 1 | 1
M | ...            | .
  | ...            | .
  |________________|___
  | 1 1 0 0 .... 0 | 1
 

Vi begynner med den samme antagelse som før, nemlig at feil er sjeldne, slik at sjansen for at to feil oppstår i en rad eller søyle er meget liten. Nå legger vi til en paritetsbit per rad og en til per søyle i tabellen. Dette gir oss koordinater for å finne feil. Ved å regne ut pariteten til en rad og en søyle, finner vi hvilken rad og hvilken søyle feilen ligger i, og siden en bit bare kan være feil på ett vis, så kan vi rette feilen ved å bytte verdien på biten.

Denne metoden har de samme feilene som med enkel paritet, nemlig det at det er umulig å detektere doble feil. På en annen side har vi vunnet en enorm effektivitet i forhold til overflødighetsmetoden. Dersom vi definerer øverflødighet ved


 R =      Antallet bits brukt
      ---------------------------
       Antallet bits i beskjeden
så øker effektiviten enormt ettersom lengden på radene og søylene øker. Men da øker også sjansen for flere feil per rad/søyle...

n-dimensjonal paritet: Hamming codes og RAID 3/5

La oss nå se på en annen løsning som er en generalisering av denne ideen. Hvor mange paritets bits trenger vil for å ikke bare finne feil, men også rette dem? R. Hamming fant en løsning på dette problemet som er genial!

Vi går ut fra at vi skal legge til et antall bits (m) til en beskjed som er n bits lang fra før. Vi kaller de ekstra bits for syndromet. Dersom vi velger et syndrom som er m bits lang. La oss si at en bitverdi av null (0) i syndromet betyr ingen feil, så kan vi i beste fall finne

      m
     2  - 1
feil med m bits. Obs at feil også kan oppstå i selve syndromet, slik at
      m
     2  - 1  >=  n + m

eller      m
     n <= 2  - m - 1
F. eks., dersom vi skulle sende en beskjed som var 11 bits lang, ville vi måttet ha et syndrom på minst 4 bits (2^4-1 = 15 = 11 + 4 ). Effektiviten 11/15 er ikke spesielt bra, bare 70%, men hvis vi øker størrelsen til en beskjed på 1000 bits (2^10 = 1024), så trenger vi bare å legge til et 10 bits syndrom, som gir en effektivitet på 1000/1010 = 99%!

La oss nå undersøke hvordan dette virker i praksis. Metoden bruker den binære (logaritmiske) strukturen i syndromet til å lokalisere bits i en beskjed. Dersom vi teller desimalt, danner vi bitmønstre som dekker alle mulige bitpermutasjoner når vi ser på tallet binært. La oss bruke eksemplet med 11 bits beskjed og 4 bits syndrom abcd som er plassert et eller annet sted i beskjeden.

  Binary   Denary

    dcba   

    0000   0
    0001   1
    0010   2
    0011   3
    0100   4
    0101   5
    0110   6
    0111   7
    1000   8
    1001   9
    1010  10
    1011  11
    1100  12
    1101  13
    1110  14
    1111  15
La oss se på den biten som ligger lengst til høyre. Dersom verdien på denne biten er 1, kan den være en del av flere desimale tall: 1,3,5,7,9,11,13,15. Dersom den andre biten er 1 kunne den være en del av 2,3,6,7,10,11,14,15. Den tredje kan være en del av 4,5,6,7,12,13,14,15 og den fjerde: 8,9,10,11,12,13,14,15. Bortsett fra de tallene som er direkte potenser av 2 (1,2,4,8) er hvert tall dekket med minst to bits. Dvs at borsett fra potenser av 2 ligger det en overflødighet i kodingen av paritetsbitene. Det betyr at vi kan bruke dem som vi gjorde i et todimensjonalt array til å lokalisere feil, men nå kan vi øke antallet bits så mye vi vil. Det er som å ha flere dimensjoner i et slikt array.

Anta nå at verdien 1 i en syndrombit betyr at det er paritetsfeil, mens en verdi på null betyr ok. Vi plasserer syndrombitene på alle potens av 2 posisjonene, da disse har minst overflødighet. Så ser vi hva som skjer når vi sender en beskjed:

 Beskjed:  10111011011 
 Syndrome:  abcd

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Kodet beskjed a b 1 c 0 1 1 d 1 0 1 1 0 1 1

Vi kan regne ut syndromet for beskjeden:

Legg merke til hvordan bitene blir akkurat det som trengs for å lage totalt even-parity (paritet 0). Dette betyr at dersom vi regner ut pariteten (inkludert alle syndrom bits) så må svaret være 0 for en korrekt beskjed. Den kodete beskjeden er altså:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Kodet beskjed 1 0 1 1 0 1 1 1 1 0 1 1 0 1 1

Nå kan vi se hva som skjer når beskjeden korrupteres. Nå ser den slik ut:

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

For å finne feilen, regner vi ut syndromet pånytt. Hvis det var ingen feil ville alle bits være 0. Vi finner:

Nesten alle ble feil! Den binære verdien av dette tallet dcba=0111=7, som er feilens posisjon!!

Merk at selv om feilen ligger i selve syndromet, så fungerer dette allikevel, på grunn av den måten vi valgte å plassere syndrombitene. Hvis det bare er en bit feil, så kan vi også rette feilen.

Hva skjer om det skulle oppstå to feil? Da går det galt. Doble feil er usannsynlige men mulige. En ting vi kan gjøre er følgende. Vi har en ledig bit i et helt antall bytes (2^m-1). Vi kan bruke den siste biten som paritets sjekk på hele beskjeden. Dette tillater at vi kan detektere doble feil (men ikke rette dem).

Effektiviteten i dette eksemplet har vært lav, men ettersom vi øker antallet bits, så øker effektiviteten eksponensielt! I RAID diskteknologier lagres paritetsbitene distribuert på parallelle disker, slik at dersom bare en disk kræsjer eller ødelegges, så kan den rekonstrueres fra Hammingkodene på de andre.

Ukens tanke

Vet du hvordan autentisering fungerer på ditt nettverk? Hva slags software brukes? Hvor lett er det å angripe? Dersom noen setter en pistol mot hodet til en bruker, så klarer de å komme forbi autentiseringsproblemer... Vet du hvor pålitelig datalagring er hos deg?

Back