F e i n e n t w u r f - TU Braunschweig...1.0 08.05.09 Gruppe 1 Erstfassung 2.0 13.05.09 Gruppe 1...

1

E n t w i c k l u n g e i n e s s i c h e r e n

V i d e o ü b e r t r a g u n g s s y s t e m s

Softwareentwicklungspraktikum

Sommersemester 2009 The Security Gurus [Gruppe 1]

Phasenverantwortlicher Justus Hummelsheim

F e i n e n t w u r f

Auftraggeber Technische Universität Braunschweig

Institut für Betriebssysteme und Rechnerverbund Prof. Dr.-Ing Lars Wolf

Mühlenpfordtstraße 23, 1. OG 38106 Braunschweig

Betreuer: Kai Homeier, Jens Brandt, Timo Veit

Auftragnehmer: Name E - Mail

Johannes Bürdek [email protected]

Daniel Fischer [email protected]

Justus Hummelsheim [email protected]

Sebastian Nieke [email protected]

Jan-Marc Reinhardt [email protected]

Mengzhi Zhang [email protected]

Braunschweig, 08.05.2009

2

Versionsübersicht

Version Datum Autor Status Kommentar

1.0 08.05.09 Gruppe 1 Erstfassung

2.0 13.05.09 Gruppe 1 überarbeitete Version

3

I n h a l t s v e r z e i c h n i s

ENTWICKLUNG EINES SICHEREN VIDEOÜBERTRAGUNGSSYSTEMS .......................... 1

FEINENTWURF .................................................................................................................... 1

INHALTSVERZEICHNIS................................. ...................................................................... 3

ABBILDUNGSVERZEICHNIS.............................. ................................................................. 5

1 EINLEITUNG........................................................................................................... 6

2 ERFÜLLUNG DER KRITERIEN............................ .................................................. 6

2.1 MUSSKRITERIEN ........................................................................................................ 6

2.2 WUNSCHKRITERIEN ................................................................................................... 8

2.3 ABGRENZUNGSKRITERIEN .......................................................................................... 9

3 IMPLEMENTIERUNGSENTWURF.......................................................................... 6

3.1 GESAMTSYSTEM ......................................................................................................10

3.2 IMPLEMENTIERUNG DER KOMPONENTE PLAYER .........................................................10

3.2.1 KLASSENDIAGRAMM...........................................................................................12

3.2.2 ERLÄUTERUNG ..................................................................................................13

3.3 IMPLEMENTIERUNG DER KOMPONENTE UPLOADER ....................................................16


3.3.2 ERLÄUTERUNG ..................................................................................................18

3.4 IMPLEMENTIERUNG DER KOMPONENTE SERVERRECEIVER..........................................21


3.4.2 ERLÄUTERUNG ..................................................................................................23

3.5 IMPLEMENTIERUNG DER KOMPONENTE STREAMSERVER ............................................26


3.5.2 ERLÄUTERUNG ..................................................................................................28

3.6 IMPLEMENTIERUNG DER KOMPONENTE GUI...............................................................31


3.6.2 ERLÄUTERUNG ..................................................................................................33

3.7 IMPLEMENTIERUNG DER KOMPONENTE DATENBANK ..................................................36


3.7.2 ERLÄUTERUNG ..................................................................................................37

4 DATENMODELL ........................................ ............................................................42

4.1 DIAGRAMM ..............................................................................................................42

4.2 ERLÄUTERUNG .........................................................................................................42

A b b i l d u n g s v e r z e i c h n i s

Diagramm 3-1: Komponentendiagramm............................................................................... 10

Diagramm 3-2: Klassendiagramm Player ............................................................................. 13

Diagramm 3-3: Klassendiagramm Uploader ......................................................................... 17

Diagramm 3-4: Klassendiagramm ServerReceiver ................................................................. 1

Diagramm 3-5: Klassendiagramm StreamServer.................................................................. 27

Diagramm 3-6: Klassendiagramm GUI ................................................................................. 32

Diagramm 3-7: Klassendiagramm Datenbank ...................................................................... 36

Diagramm 3-8: Klassendiagramm Ver- und Entschlüsselung ............................................... 40

Diagramm 4-1: Klassendiagramm Datenmodell ……………………………………...................42

1 Einleitung

Das vorliegende Dokument beschreibt die Implementierungsdetails für das Softwareprojekt

„Entwicklung eines sicheren Videoübertragungssystems“

In Kapitel 2 wird auf die praktische Umsetzung der im Pflichtenheft festgehaltenen Muss-,

Wunsch- und Abgrenzungskriterien eingegangen.

Kapitel 3 behandelt die im Grobentwurf ermittelten Komponenten und beschreibt ihre

Beziehungen untereinander mit Hilfe von Klassendiagrammen.

Im abschließenden, vierten Kapitel wird das verwendete Datenmodell erläutert.

2 Erfüllung der Kriterien

Im Folgenden wird die Umsetzung der Kriterien konkretisiert.

2.1 Musskriterien

2.1.1 /M10/ Speichern von verschlüsselten Videos au f dem Server

Der Server soll in der Lage sein verschlüsselte Videos zu speichern. Zusätzlich dazu

soll er Informationen wie den Uploader, den Zeitpunkt und Laufzeit vermerken. Zudem

ist jedem Video ein Schlüssel zugeordnet der ebenfalls gespeichert werden muss.

2.1.2 /M20/ Streamen von Videos vom Server

Der Server soll auf Anforderung hin in der Lage sein, verschlüsselte Videos zu einem

Client zu streamen.

2.1.3 /M30/ Bereitstellung einer Datenbank zur Benu tzerverwaltung

durch den Server

Um Informationen über Nutzer zu speichern, soll der Server eine entsprechende

Datenbank zur Verfügung stellen. Diese enthält Nutzerdaten wie den Namen, das

Passwort, eine E-Mail Adresse und Verweise auf Videos des Nutzers. Zusätzlich

verwaltet die Datenbank die Rechte der User.

2.1.4 /M40/ Authentifizierung der Benutzer durch de n Server

Fordert ein Client Zugriff auf die Datenbank oder die Videos des Servers, so muss ein

entsprechendes Formular ausgefüllt werden. Der Server gleicht die gemachten

Angaben dann mit der Datenbank ab und gewährt oder verweigert den Zugriff.

2.1.5 /M50/ Bereitstellung von Interfaces zur Benut zerverwaltung durch

den Server

Der Server muss über entsprechende Interfaces Zugriff auf die Benutzerverwaltung

gewähren.

2.1.6 /M60/ Bereitstellung von Interfaces zum Uploa d und Ändern bzw.

Löschen von Daten durch den Server

Der Server muss über entsprechende Interfaces die Möglichkeit geben Videos und

Angaben zu den Videos hochzuladen, zu löschen und zu ändern.

2.1.7 /M70/ Verbinden und authentisieren des Player s mit dem Server

Der Player muss sich mit dem Server verbinden und authentisieren können.

2.1.8 /M80/ Entschlüsseln und Abspielen von Videos mit dem Player

Der Videoplayer muss die Videos entschlüsseln und abspielen können.

2.1.9 /M90/ Verbinden und authentisieren des Upload ers mit dem Server

Der Uploader muss sich mit dem Server verbinden und authentisieren können.

2.1.10 /M100/ Verschlüsseln und übermitteln von Vid eos durch den

Uploader zum Server

Der Uploader soll in der Lage sein Videos zu verschlüsseln und nach dem

Authentisierungsvorgang, diese an den Server zu senden.

2.1.11 /M110/ Löschen von Videos auf dem Server dur ch den Uploader

Der Uploader soll in der Lage sein nach dem Authentisierungsvorgang, dem Server

die Anweisung zu geben, Videos auf dem Server zu löschen.

2.1.12 /M120/ Verbinden und authentisieren der Benu tzerverwaltung mit

dem Server

Die Benutzerverwaltung soll sich mit dem Server verbinden und sich dort

authentisieren können.

2.1.13 /M130/ Ansprechen der Serverinterfaces durch die

Benutzerverwaltung

Die Benutzerverwaltung muss in der Lage sein die Interfaces des Servers

anzusprechen.

2.1.14 /M140/ Anlegen, verändern und löschen von Be nutzern durch die

Benutzerverwaltung

Die Benutzerverwaltung muss in der Lage sein, neue Benutzer zu erstellen oder aber

bereits vorhandene zu ändern bzw. zu löschen.

2.1.15 /M150/ Rechteverwaltung der Benutzer durch d ie

Benutzerverwaltung

Die Benutzerverwaltung muss in der Lage sein die Rechte der Nutzer zu verwalten.

2.1.16 /M160/ Zurücksetzen, ändern und verschicken der Passwörter

durch die Benutzerverwaltung

Die Benutzerverwaltung muss in der Lage sein die Passwörter der Nutzer zu ändern,

zurückzusetzen und an die Benutzer zu verschicken.

2.2 Wunschkriterien

2.2.1 /W10/ Speichern von Videos durch den Videopla yer

Optional kann der Videoplayer die gestreamten Videos über ein zusätzliches Menü

speichern.

2.2.2 /W20/ Durchspulen von Videos mit dem Videopla yer

Optional kann der Videoplayer durch ein empfangenes oder gespeichertes Video

spulen. Dafür wird die Gesamtlaufzeit benötigt.

2.2.3 /W30/ E-Mail Benachrichtigungen bei neuen Vid eos durch den

Server

Optional kann der Server Benachrichtigungen bei neuen Videouploads ausgeben. Dazu

wird eine Liste benötigt in die sich berechtigte Nutzer selbst eintragen können.

2.3 Abgrenzungskriterien

2.3.1 /A10/ Einseitigkeit des Videoplayers

Der Player muss nicht alle Standards unterstützen und auch keine lokal vorhandenen

Medien abspielen können. Er muss nur mit der angedachten Server-Software

zusammen arbeiten können.

3 Implementierungsentwurf

3.1 Gesamtsystem

Diagramm 3-1: Komponentendiagramm

Erläuterung :

Die Komponenten Kamera und Video Player können über die Schnittstelle upload mit der

Komponente Server kommunizieren und Videos übertragen. Die Komponenten Uploader und

Video Player authentisieren sich über die Schnittstelle userinformation bei der Komponente

Server. Die Komponente Server wiederum kann über diese Schnittstelle Änderungen in der

Komponente Benutzerverwaltung vornehmen. Über die Schnittstelle download können

Videodateien von der Komponente Server zur Komponente Video Player gestreamt werden.

Zur genaueren Betrachtung werden die Komponenten aus der Abbildung im Folgenden noch

einmal aufgeteilt.

3.2 Implementierung der Komponente Player

Der Player besteht hauptsächlich aus der Klasse PlayerReceiver, der über andere Klassen

die Verbindungen verwaltet, die Streams ausliest und anzeigt oder speichert. Damit er diese

korrekt steuern kann, implementiert der Receiver die drei Schnittstellen

javax.media.rtp.SessionListener,

javax.media.rtp.ReceiveStreamListener und

javax.media.ControllerListener,

mit denen er wichtige Events verarbeiten kann. Die Daten des Servers werden in einem

Objekt der Klasse Target gespeichert. Um Streams empfangen zu können wird die Klasse

javax.media.rtp.RTPManager benutzt. Diese öffnet und verarbeitet die Streams vom Server.

Für die Verarbeitung wird die Klasse DecipherDepacketizer benutzt, welche das Interface

javax.media.Codec implementiert. Wurde ein Video empfangen und entschlüsselt, kann es

entweder über ein Objekt der Klasse javax.media.DataSink gespeichert werden, oder mit

einem Objekt der Klasse javax.media.Player abgespielt werden. Um das Video anzuzeigen

kann man mit dem Aufruf der Funktion getVisualComponent() des Players ein Objekt vom

Typ java.awt.Component erhalten welches das Video anzeigt. Wenn man die Funktion

getControlPanelComponent() des Players aufruft erhält man ein Objekt vom Typ

java.awt.Component, mit dem sich die Wiedergabe des Videos steuern lässt.

3.2.1 Klassendiagramm

Pla

ye

rRe

ce

ive

r

+P

laye

rRe

ce

ive

r(m

ain

Pro

gra

m:

Ma

inP

rog

ram

, ta

rge

t :Ta

rge

t, k

ey

: b

yte

[])

: P

laye

rRe

ce

ive

r

+clo

se

() :

vo

id

+u

pd

ate

(evt

: C

on

tro

llerE

ve

nt)

: vo

id

+u

pd

ate

(evt

: R

ece

ive

Str

ea

mE

ve

nt)

: vo

id

+u

pd

ate

(evt

: S

essio

nE

ve

nt)

: vo

id

Ta

rge

t

+ip

: s

trin

g

+p

ort

: in

t

+lo

ca

lPo

rt:

int

+Ta

rge

t(ip

: s

trin

g,

po

rt :

in

t, lo

ca

lPo

rt:

int)

:Ta

rge

t

<<

inte

rfa

ce

>>

java

x.m

ed

ia.C

on

tro

llerL

iste

ne

r

<<

inte

rfa

ce

>>

java

x.m

ed

ia.r

tp.R

ece

ive

Str

ea

mL

iste

ne

r

De

cip

he

rDe

pa

cke

tizer

+P

LU

GIN

_N

AM

E :

str

ing

+C

US

TO

M_

PC

M :

str

ing

+H

DR

_S

IZE

: in

t

+D

EFA

ULT

_R

AT

E :

in

t

+D

EFA

ULT

_S

IZE

: in

t

+D

EFA

ULT

_C

HN

LS

: in

t

-su

pp

ort

ed

Inp

utF

orm

ats

: ja

va

x.m

ed

ia.F

orm

at[

]

-su

pp

ort

ed

Ou

tpu

tFo

rma

ts:

java

x.m

ed

ia.F

orm

at[

]

-in

Vid

eo

Fo

rma

t :

java

x.m

ed

ia.V

ide

oC

od

ec

-o

utV

ide

oF

orm

at

: ja

va

x.m

ed

ia.V

ide

oC

ode

c

-ke

y:

byte

[]

-cry

pto

: C

ryp

to

+D

ecip

he

rDe

pa

cke

tize

r(ke

y:

byte

[])

: D

ecip

he

rDe

pa

cke

tize

r

+m

atc

he

s(in

pu

t :

Fo

rma

t, s

up

po

rte

d:

Fo

rma

t[])

: b

oo

l

+o

pe

n()

: v

oid

+clo

se

() :

vo

id

+g

etC

on

tro

l(ty

pe

: str

ing

):

Ob

ject

+g

etC

on

tro

ls()

: O

bje

ct[

]

+g

etI

np

utF

orm

at(

) :

Vid

eo

Fo

rma

t

+g

etO

utp

utF

orm

at(

) :

Fo

rma

t

+g

etN

am

e()

: s

trin

g

+g

etS

up

po

rte

dIn

pu

tFo

rma

ts()

: F

orm

at[

]

+g

etS

up

po

rte

dO

utp

utF

orm

ats

():

Fo

rma

t[]

+p

roce

ss(in

Bu

f:

Bu

ffe

r, o

utB

uf

: B

uffe

r) :

in

t

+re

se

t()

: vo

id

+se

tIn

pu

tFo

rma

t(fo

rma

t:

Fo

rma

t) :

Fo

rmat

+se

tOu

tpu

tFo

rma

t(fo

rma

t:

Fo

rma

t) :

Fo

rma

t

<<

inte

rfa

ce

>>

java

x.m

ed

ia.C

od

ec

java

x.m

ed

ia.D

ata

Sin

k

info

sa

bo

ut

se

rve

ru

se

dto

sa

ve

vid

eo

s

<<

inte

rfa

ce

>>

java

x.m

ed

ia.r

tp.S

essio

nL

iste

ne

r java

x.m

ed

ia.r

tp.R

TP

Ma

na

ge

ru

se

dto

re

ce

ive

str

ea

ms

use

dto

de

co

de

str

ea

ms

11

11

11

11

1

1

java

x.m

ed

ia.P

laye

r

use

dto

ha

nd

le v

ide

os

Diagramm 3 -2:

Klassendiagramm

Player

Diagramm 3-2: Klassendiagramm Player

3.2.2 Erläuterung

Klasse PlayerReceiver

Methode Beschreibung

PlayerReceiver(mainProgram:

MainProgram, target: Target, key: byte[])

Konstruktor, der alle Einstellungen vornimmt,

den Schlüssel speichert und den Empfang

startet

close() schließt den Stream und beendet damit die

Verbindung

update(evt: ControllerEvent) bearbeitet Events vom Player

update(evt: ReceiveStreamEvent) bearbeitet Events die den eingehenden

Stream betreffen

update(evt: SessionEvent) bearbeitet Events welche die Verbindung im

Allgemeinen betreffen und nicht zu den

ReceiveStreamEvents gehören

Attribut Beschreibung

- -

Kommunikationspartner Dauerhaft?

javax.media.DataSink Nein

javax.media.Player Ja

Target Nein

javax.media.rtp.RTPManager Ja

MainWin Ja

Klasse Target


Target(ip: String, port: int, localPort: int) Konstruktor der nur die Daten speichert


ip: String speichert die IP-Adresse des Servers

port: int speichert den Port des Servers

localPort: int speichert den Port des lokalen Rechners


PlayerReceiver nein

Klasse DecipherDepacketizer


DecipherDepacketizer(byte[] key) Konstruktor der den Schlüssel zum

entschlüsseln und die unterstützten Eingabe-

und Ausgabeformate speichert

matches(input: Format, supportet: Format[]) überprüft ob das gegebene Format input in

der Liste der (unterstützten) Formate

enthalten ist

open() leere Funktion die durch das Interface

gefordert wird

close() leere Funktion die durch das Interface

gefordert wird

process(inBuf: Buffer, outBuf: Buffer) verrichtet eigentliche arbeit (aus Paketen

zusammensetzen, entschlüsseln, usw.)

reset() leere Funktion die durch das Interface

gefordert wird


PLUGIN_NAME: String speichert den Namen des Plugins

CUSTOM_PCM: String speichert einen String zur Identifizierung des

Inhalts des Ausgabestreams

DEFAULT_RATE: int speichert Standardwerte für die Datenrate

des Ausgabeformates was wichtig ist, damit

das Plugin seinen Dienst tun kann

DEFAULT_SIZE: int speichert Standardwerte für die Datengröße



DEFAULT_CHNLS: int speichert Standardwerte für die Kanalanzahl



supportedInputFormats: Format[] speichert eine Liste mit gültigen

Eingabeformaten

supportedOutputFormats: Format[] speichert eine Liste mit möglichen

Ausgabeformaten

inVideoFormat: Format speichert das ausgewählte Eingabeformat

outVideoFormat: Format speichert das ausgewählte Ausgabeformat

key: byte[] speichert den Schlüssel zum entschlüsseln

des Videos

crypto: Crypto wird für die Entschlüsselung benutzt



3.3 Implementierung der Komponente Uploader

Der Uploader muss im Gegensatz zum Player kein Interface implementieren. Um das zu

streamende Video lesen zu können wird ein Objekt vom Typ javax.media.Processor benötigt,

welches über eine DataSource über ein MediaLocator initialisiert wird. Wieder in einem

Objekt vom Typ Target werden die Daten des anderen Rechners, in diesem Fall des Clients,

gespeichert. Zu diesem Client wird mithilfe des javax.media.rtp.RTPManager’s eine Verbin-

dung hergestellt und ein Stream zur Videoübertragung geöffnet. Um das Video zu verpacken

und zu verschlüsseln benutzt der RTPManager den CipherPacketizer, welcher das Interface

javax.media.Codec implementiert. Über den StateListener wird der Status des Processors

überwacht und Statusänderungen bekannt gegeben. Hierfür implementiert der StateListener

das javax.media.ControllerListener Interface.


Up

loa

de

r

-M

YP

CM

_P

AY

LO

AD

: in

t

-m

yP

CM

Fo

rma

t :

Fo

rma

t

-fa

iled

: b

oo

l

-lo

ca

tor

: ja

va

x.m

ed

ia.M

ed

iaL

oca

tor

+U

plo

ad

er(

loca

tor

: M

ed

iaL

oca

tor,

ta

rge

t :Ta

rge

t, f

orm

at

: F

orm

at,

ke

y :

byte

[])

: U

plo

ad

er

+sta

rt()

: s

trin

g

+sto

p()

: v

oid

+re

gis

terC

usto

mP

aylo

ad

() :

bo

ol

+cre

ate

Pro

ce

sso

r()

: str

ing

+cre

ate

Tra

nsm

itte

r()

: str

ing

+se

tFa

iled

() :

vo

id

+w

aitF

orS

tate

(pro

ce

sso

r :

Pro

ce

sso

r, s

tate

: in

t) :

bo

ole

an

java

x.m

ed

ia.P

roce

sso

r

java

x.m

ed

ia.r

tp.R

TP

Ma

na

ge

r

Sta

teL

iste

ne

r

+co

ntr

olle

rUp

da

te(c

e :

Co

ntr

olle

rEve

nt)

: v

oid

Cip

he

rPa

cke

tize

r

+P

LU

GIN

_N

AM

E :

str

ing

+C

US

TO

M_

PC

M :

str

ing

+H

DR

_S

IZE

: in

t

+D

EFA

ULT

_R

AT

E :

in

t

+D

EFA

ULT

_S

IZE

: in

t

+D

EFA

ULT

_C

HN

LS

: in

t

-su

pp

ort

ed

Inp

utF

orm

ats

: ja

va

x.m

ed

ia.F

orm

at[

]

-su

pp

ort

ed

Ou

tpu

tFo

rma

ts :

ja

va

x.m

ed

ia.F

orm

at[

]

-in

Vid

eo

Fo

rma

t :

java

x.m

ed

ia.V

ide

oC

od

ec

-o

utV

ide

oF

orm

at

: ja

va

x.m

ed

ia.V

ide

oC

od

ec

-ke

y :

byte

[]

-cry

pto

: C

ryp

to

+C

iph

erP

acke

tize

r(ke

y :

byte

[])

: C

iph

erP

acke

tize

r

+m

atc

he

s(in

pu

t :

Fo

rma

t, s

up

po

rte

d :

Fo

rma

t[])

: b

oo

l

+o

pe

n()

: v

oid

+clo

se

() :

vo

id

+g

etC

on

tro

l(ty

pe

: s

trin

g)

: O

bje

ct

+g

etC

on

tro

ls()

: O

bje

ct[

]

+g

etI

np

utF

orm

at(

) :

Vid

eo

Fo

rma

t

+g

etO

utp

utF

orm

at(

) :

Fo

rma

t

+g

etN

am

e()

: s

trin

g

+g

etS

up

po

rte

dIn

pu

tFo

rma

ts()

: F

orm

at[

]

+g

etS

up

po

rte

dO

utp

utF

orm

ats

() :

Fo

rma

t[]

+p

roce

ss(in

Bu

f :

Bu

ffe

r, o

utB

uf

: B

uffe

r) :

in

t

+re

se

t()

: vo

id

+se

tIn

pu

tFo

rma

t(fo

rma

t :

Fo

rma

t) :

Fo

rma

t

+se

tOu

tpu

tFo

rma

t(fo

rma

t :

Fo

rma

t) :

Fo

rma

t

use

s t

o p

roce

ss m

ed

ia

to c

rea

te s

tre

am

s

use

d t

o m

on

ito

r sta

tes

use

s

<<

inte

rfa

ce

>>

java

x.m

ed

ia.c

od

ec

Ta

rge

t

+ip

: s

trin

g

+p

ort

: in

t

+lo

ca

lPo

rt :

in

t

+Ta

rge

t(ip

: s

trin

g,

po

rt :

in

t, lo

ca

lPo

rt :

in

t) :

Ta

rge

t

<<

inte

rfa

ce

>>

java

x.m

ed

ia.C

on

tro

llerL

iste

ne

r

co

nn

ecte

d w

ith

1 1

11

1 1

1

11

1

Diagramm 3-3: Klassendiagramm Uploader

3.3.2 Erläuterung

Klasse Uploader


Uploader(locator: MediaLocator, target:

Target, format: Format, key: byte[])

Konstruktor der den Speicherort des Videos

und dessen Format, die Daten des Clients

und den Schlüssel des Videos speichert

start() beginnt die Übertragung des Videos

stop() stoppt eine schon begonnene Übertragung

registerCustomPayload() registriert den CipherPacketizer am

PlugInManager

createProcessor() erstellt einen Processor um das Video zu

lesen

createTransmitter() erstellt einen RTPManager um die

Verbindung zum Client herzustellen

setFailed() setzt die Variable failed auf true um

anzuzeigen dass etwas schief gegangen ist

waitForState(processor: Processor,

state: int)

wartet auf einen gegebenen Status des

Processor’s


MYPCM_PAYLOAD: int speichert die ID-Nummer für die Datenart

myPCMFormat: Format speichert das Format der Daten

failed: bool speichert ob ein Fehler vorliegt

locator: javax.media.MediaLocator speichert den Speicherort des Videos


Target Nein

javax.media.processor Ja

StateListener Ja

javax.rtp.RTPManager Ja

UploadWin Nein

Klasse Target




ip: String speichert die IP-Adresse des Servers

port: int speichert den Port des Servers



Uploader nein

Klasse StateListener


controllerUpdate(ce ControllerEvent) reagiert auf eine Veränderung des Status bei

einem Controller, benachrichtigt alle die auf

eine Statusänderung warten und setzt die

Variable failed falls ein Fehler aufgetreten ist


- -


Uploader Ja

Klasse CipherPacketizer


CipherPacketizer(byte[] key) Konstruktor der den Schlüssel zum

verschlüsseln und die unterstützten Eingabe-




enthalten ist


gefordert wird


gefordert wird

process(inBuf: Buffer, outBuf: Buffer) verrichtet eigentliche arbeit (Pakete

aufteilen, verschlüsseln, usw.)


gefordert wird















Eingabeformaten


Ausgabeformaten



key: byte[] speichert den Schlüssel zum verschlüsseln

des Videos

crypto: Crypto wird für die Verschlüsselung benutzt



3.4 Implementierung der Komponente ServerReceiver

Der ServerReceiver ist der Teil des FileServer’s welcher verschlüsselte oder unverschlüs-

selte Videos vom Client annimmt, gegebenenfalls verschlüsselt und dann speichert. Der

ServerReceiver implementiert die drei Schnittstellen

javax.media.rtp.SessionListener,

javax.media.rtp.ReceiveStreamListener und

javax.media.ControllerListener,

um auf alle wichtigen Events reagieren zu können. Die Daten des Clients werden in einem

Objekt der Klasse Target gespeichert. Um Streams empfangen zu können wird die Klasse

javax.media.rtp.RTPManager benutzt. Diese öffnet und verarbeitet die Streams vom Client.

Für die Verarbeitung wird entweder die Klasse CipherDepacketizer (wenn das Video noch

nicht verschlüsselt ist) oder die Klasse Depacketizer (wenn es schon verschlüsselt ist)

benutzt, welche beide das Interface javax.media.Codec implementieren. Wurde ein Video

empfangen und gegebenenfalls verschlüsselt, wird es über ein Objekt der Klasse

javax.media.DataSink gespeichert.


Diagramm 3-4: Klassendiagramm ServerReceiver

3.4.2 Erläuterung

Klasse ServerReceiver


ServerReceiver(mainProgram:

MainProgram, target: Target)

Konstruktor, der alle Einstellungen vornimmt

und den Empfang startet

close() schließt den Stream und beendet damit die

Verbindung

update(evt: ControllerEvent) bearbeitet Events vom DataSink

update(evt: ReceiveStreamEvent) bearbeitet Events die den eingehenden

Stream betreffen

update(evt: SessionEvent) bearbeitet Events welche die Verbindung im

Allgemeinen betreffen und nicht zu den

ReceiveStreamEvents gehören


- -


javax.media.DataSink Nein

Target Nein


MainProgram Nein

Klasse Target




ip: String speichert die IP-Adresse des Clients

port: int speichert den Port des Clients



ServerReceiver nein

Klasse Depacketizer


Depacketizer() Konstruktor der nur die unterstützten

Eingabe- und Ausgabeformate speichert



enthalten ist


gefordert wird


gefordert wird




gefordert wird















Eingabeformaten


Ausgabeformaten





Klasse CipherDepacketizer


CipherPacketizer(key: byte[]) Konstruktor der den Schlüssel zum

verschlüsseln und die unterstützten Eingabe-




enthalten ist


gefordert wird


gefordert wird




gefordert wird















Eingabeformaten


Ausgabeformaten



key: byte[] speichert den Schlüssel zum verschlüsseln

des Videos

crypto: Crypto wird zur Verschlüsselung benutzt



3.5 Implementierung der Komponente StreamServer

Der StreamServer streamt verschlüsselte Videos zum Client. Er besteht hauptsächlich aus

der Klasse StreamServer, welche die Steuerung der Übertragung übernimmt. Die Daten des

Clients werden in einem Objekt der Klasse Target gespeichert. Das Video wird mit einem

javax.media.Processor von einem javax.media.MediaLocator gelesen. Dabei werden die

verschiedenen Status des Processor’s von einem StateListener überwacht, welcher das

Interface javax.media.ControllerListener implementiert. Durch ein Objekt der Klasse

javax.media.rtp.RTPManager wird schließlich eine Verbindung zum Client hergestellt. Für die

korrekte Verarbeitung des Streams benutzt dieser ein Objekt vom Typ Packetizer, welcher

das Interface javax.media.Codec implementiert.


Str

eam

Serv

er

-M

YP

CM

_P

AY

LO

AD

: int

-m

yP

CM

Form

at : F

orm

at

-fa

iled : b

ool

-lo

cato

r : ja

vax.m

edia

.Media

Locato

r

+S

tream

Serv

er(

locato

r : M

edia

Locato

r, targ

et :Targ

et, form

at : F

orm

at)

: S

tream

Serv

er

+sta

rt()

: s

trin

g

+sto

p()

: v

oid

+re

gis

terC

usto

mP

aylo

ad()

: b

ool

+cre

ate

Pro

cessor(

) : str

ing

+cre

ate

Tra

nsm

itte

r()

: str

ing

+setF

aile

d()

: v

oid

+w

aitF

orS

tate

(pro

cessor

: P

rocessor,

sta

te : int)

: b

oole

an

Packetizer

+P

LU

GIN

_N

AM

E :

str

ing

+C

US

TO

M_P

CM

: s

trin

g

+H

DR

_S

IZE

: int

+D

EF

AU

LT

_R

AT

E :

int

+D

EF

AU

LT

_S

IZE

: int

+D

EF

AU

LT

_C

HN

LS

: int

-support

edIn

putF

orm

ats

: javax.m

edia

.Form

at[

]

-support

edO

utp

utF

orm

ats

: javax.m

edia

.Form

at[

]

-in

Vid

eoF

orm

at

: ja

vax.m

edia

.Vid

eoC

odec

-outV

ideoF

orm

at

: ja

vax.m

edia

.Vid

eoC

odec

+P

acketizer(

) :

Packetizer

+m

atc

hes(input

: F

orm

at,

support

ed : F

orm

at[

]) :

bool

+open()

: v

oid

+clo

se()

: v

oid

+getC

ontr

ol(ty

pe :

str

ing)

: O

bje

ct

+getC

ontr

ols

() :

Obje

ct[

]

+getI

nputF

orm

at(

) :

Vid

eoF

orm

at

+getO

utp

utF

orm

at(

) :

Form

at

+getN

am

e()

: s

trin

g

+getS

upport

edIn

putF

orm

ats

() :

Form

at[

]

+getS

upport

edO

utp

utF

orm

ats

() :

Form

at[

]

+pro

cess(inB

uf

: B

uffer,

outB

uf

: B

uffer)

: int

+re

set(

) :

void

+setI

nputF

orm

at(

form

at

: F

orm

at)

: F

orm

at

+setO

utp

utF

orm

at(

form

at

: F

orm

at)

: F

orm

at

javax.m

edia

.Pro

cessor

Sta

teLis

tener

+contr

olle

rUpdate

(ce : C

ontr

olle

rEvent)

: v

oid

<<

inte

rface>

>

javax.m

edia

.Contr

olle

rLis

tener

Targ

et

+ip

: s

trin

g

+port

: int

+lo

calP

ort

: int

+Targ

et(

ip : s

trin

g, port

: int, localP

ort

: int)

:Targ

et

uses to p

rocess m

edia

uses to m

onitor

sta

tes

connecte

d w

ith

rjavax.m

edia

.rtp

.RT

PM

anager

<<

inte

rface>

>

javax.m

edia

.codec

used to c

reate

str

eam

s

used to p

ack d

ata

befo

re s

endin

g

1 1

11

1 1

1

11

1

Diagramm 3-5: Klassendiagramm StreamServer

3.5.2 Erläuterung

Klasse StreamServer


StreamServer(locator: MediaLocator, target:

Target, format: Format)

Konstruktor der den Speicherort des Videos,

dessen Format und die Daten des Clients

speichert

start() beginnt die Übertragung des Videos

stop() stoppt eine schon begonnene Übertragung

registerCustomPayload() registriert den Packetizer am PlugInManager

createProcessor() erstellt einen Processor um das Video zu

lesen

createTransmitter() erstellt einen RTPManager um die

Verbindung zum Client herzustellen

setFailed() setzt die Variable failed auf true um

anzuzeigen dass etwas schief gegangen ist

waitForState(processor: Processor,

state: int)

wartet auf einen gegebenen Status des

Processor’s


MYPCM_PAYLOAD: int speichert die ID-Nummer für die Datenart

myPCMFormat: Format speichert das Format der Daten

failed: bool speichert ob ein Fehler vorliegt

locator: javax.media.MediaLocator speichert den Speicherort des Videos


Target Nein

javax.media.processor Ja

StateListener Ja

javax.rtp.RTPManager Ja

Klasse Target




ip: String speichert die IP-Adresse des Clients

port: int speichert den Port des Clients



StreamServer nein

Klasse StateListener


controllerUpdate(ce ControllerEvent) reagiert auf eine Veränderung des Status bei

einem Controller, benachrichtigt alle die auf

eine Statusänderung warten und setzt die

Variable failed falls ein Fehler aufgetreten ist


- -


Uploader Ja

Klasse Packetizer


Packetizer() Konstruktor der die unterstützten Eingabe-




enthalten ist


gefordert wird


gefordert wird




gefordert wird















Eingabeformaten


Ausgabeformaten





3.6 Implementierung der Komponente GUI

Die GUI-Komponente wird aktiviert sobald das Hauptprogramm gestartet wird. Es werden

drei Klassen aufgerufen: MainWin (das Hauptfenster), UploadWin (das Uploadfenster) und

UserManagementWin (das Benutzerverwaltungsfenster). Beim Starten des Programms wird

nur das Hauptfenster angezeigt. Wenn die Methode uploadMenuItemActionPerformed(evt:

ActionEvent) oder btnVideoAddActionPerformed(evt: ActionEvent) aufgerufen wird, ruft diese

zuerst die Methode UploadWin auf welche dann das Uploadfenster anzeigt. Wenn die

Methode btnUserChangeActionPerformed(evt: ActionEvent) aufgerufen wird, wird das

Benutzerverwaltungsfenster durch die Methode UserManagementWin angezeigt.


Diagramm 3-6: Klassendiagramm GUI

3.6.2 Erläuterung

Klasse MainWin


openUploadWin() Diese Methode öffnet das Fenster

UploadWin.

openUserManagementWin() Diese Methode öffnet das Fenster

UserManagementWin.

exitMenuItemActionPerformed

(evt:ActionEvent):

Diese Methode wird vom ActionListener des

Bedienelements exitMenuItem aufgerufen

und beendet das Programm.

*ActionPerformed(evt:ActionEvent) Analog wie oben. Die Buttons und

MenuItems werden vom ActionListener der

unterschiedlichen Bedienelemente

aufgerufen.

setPlayerStateActiv() Setzt den Wert playerStateActiv auf „true“.

setPlayerStateInactiv() Setzt den Wert playerStateActiv auf „false“.


userManagementWin: UserManagementWin Eine Instanz von UserManagementWin.

uploadWin: UploadWin Eine Instanz von UploadWin.

playerStateActiv: boolean Ein Boolean-Wert, der im Fall „False“ das

Ende des Videos angibt.

playerReceiver: PlayerReceiverPanel Der im Hauptfenster eingebettete

Videoplayer(PlayerReceiver).


UploadWin Nein

UserManagementWin Nein

PlayerReceiverPanel Ja

Klasse UploadWin


btnUploadYesActionPerformed(evt:

ActionEvent)


Bedienelements btnUplaodYes aufgerufen

und bestätigt die Hochladen des Videos.

btnUploadCancelActionPerformed(evt:

ActionEvent)


Bedienelements btnUploadCancel

aufgerufen und beendet dieses Fenster.

btnUploadOpenActionPerformed(evt:

ActionEvent)


Bedienelements btnUploadOpen aufgerufen

und öffnet das Verzeichnis auf der lokalen

Festplatte.

setUploadStateActiv() Setzt den Wert uploadStateActiv auf „true“.

setUploadStateInactiv() Setzt den Wert uploadStateActiv auf „false“.


uploadStateActiv: boolean Ein Boolean-Wert, der im Fall „False“ das

Ende des Hochladens eines Videos anzeigt.


MainWin Nein

Uploader Nein

Klasse UserManagementWin


createUser(name: String, pw: String, right:

int)

Diese Methode erstellt einen neuen

Benutzernamen im Array userl.

removeUser() Diese Methoden löscht den Benutzernamen

aus dem Array userl.

searchUser(name: String) Diese Methode sucht im Array nach Namen

und gibt für den Index einen int-Wert zurück.

pwReset() Diese Methode setzt das Passwort des

ausgewählten Benutzers zurück.


userl: String[ ] Ein Array, das alle Benutzernamen

speichert.


MainWin Nein

Klasse PlayerReceiverPanel


getVisualComponent() Gibt eine Display-Komponente für den

Player zurück.

getControlPanelComponent() Gibt eine Komponente zurück, die ein

standard-user interface für die Kontrolle des

Players anbietet.


playerReceiver: PlayerReceiver Ein Objekt PlayerReceiver, das als Klasse

PlayerReceiver erzeugt wird.


MainWin Ja

3.7 Implementierung der Komponente Datenbank

Die Komponente Datenbank besteht aus der Klasse DatabaseConnection, die Methoden

bereitstellt um auf die Datenbank zuzugreifen und Daten auszulesen, und aus Klassen um

eine sichere Übertragung der Daten aus der Datenbank mittels SSL zu gewährleisten.

Die Klassen mit denen die Client-Server-Kommunikation über eine sichere SSL-Verbindung

erstellt werden kann heißen: SSLServer, SSLConnection und SSLClient. Mit der Klasse

SSLServer kann man auf der Serverseite eine Verbindungen vom Client entgegen nehmen

und diese wird von der Klasse an ein SSLConnection-Objekt weitergegeben. Die Klasse

SSLConnection kommuniziert serverseitig mit dem Client und die Klasse SSLClient dient

dazu vom Client aus mit dem Server zu kommunizieren.


SSLServer

- port : int

- sslServerSocketFactory : SSLServerSocketFactory

- sslServerSocket : SSLServerSocket

- sslSocket : SSLSocket

- connections : SSLConnection

+ SSLServer(port : int)

+ getPort() : int

+ setPort(port : int) : void

+ removeConnection(connection : SSLConnection) : void

+ run() : void

SSLClient

- port : int

- serverAddress : string

- sslSocketFactory : SSLSocketFactory

- target : SSLSocket

- bufferedReader : BufferedReader

- bufferedWriter : BufferedWriter

+ SSLClient(port : int, serverAddress : string)

+ getPort() : int

+ getServerAddress() : string

+ setPort(port : int) : void

+ setServerAddress(serverAddress : string) : void

+ connect(port : int, serverAddress : string) : void

+ closeConnection() : void

+ sendMsg(msg : string) : void

+ run() : void

SSLConnection

- target : SSLSocket

- sslServer : SSLServer

- bufferedReader : BufferedReader

- bufferedWriter : BufferedWriter

+ SSLConnection(sslServer : SSLServer, target : SSLSocket)

+ sendMsg(msg : string) : void

+ run() : void

<<interface>>

java.lang.runnable

DatabaseConnection

- database : string

- table : string

- connection : Connection

+ connect(database : string, table : string) : void

+ closeConnection() : void

+ addUser(data : string[]) : void

+ editUser(user : string, data : string[]) : void

+ removeUser(user : string)

+ changeUserRights(user : string, rights : string[]) : void

+ changePassword(user : string, password : string) : void

+ checkPassword(user : string, password : string) : boolean

+ checkRights(user : string, rights : string[]) : boolean

+ addGroup(name : string) : void

+ removeGroup(name : string) : void

+ changeGroupRights(name : string, rights : string[]) : void

+ addUsertoGroup(user : string, group : string) : void

+ removeUserFromGroup(user : string, group : string) : void

+ addVideon(name : string, data : string[]) : void

+ removeVideo(name : string) : void

*1

Diagramm 3-7: Klassendiagramm Datenbank

3.7.2 Erläuterung

Klasse DatabaseConnection


connect(database: string, table: string) Stellt eine Verbindung zu einer Datenbank

her.

close() Schließt die Verbindung zur Datenbank.

addUser(userData: string[]) Trägt einen Benutzer in die Datenbank ein.

editUser(user: string, newUserData: string[]) Ändert die Daten eines Benutzers.

removeUser(user: string) Löscht eine Benutzer aus der Datenbank.

changeUserRight(user: string, rights: string[]) Ändert die Rechte eines Benutzers.

changePassword(user: string,

password: string)

Ändert das Passwort eines Benutzers.

checkPassword(user: string,

password: string)

Überprüft das Passwort eines Benutzers.

checkRights(user: string, rights: string[]) Überprüft, ob der Benutzer bestimmte

Rechte hat.

addGroup(name: string) Fügt eine neue Gruppe in die Datenbank

ein.

removeGroup(name: string) Löscht eine Gruppe aus der Datenbank.

changeGroupRights(name: string,

rights: string[])

Ändert die Rechte einer Gruppe.

addUserToGroup(user: string, group: string) Fügt einen Benutzer zu einer Gruppe hinzu.

removeUserFromGroup(user: string,

group: string)

Entfernt einen Benutzer aus einer Gruppe.

addVideo(name: string, data: string[] Fügt ein Video in die Datenbank ein.

removeVideo(name: string) Entfernt ein Video aus der Datenbank.


database: string Adresse der Datenbank.

table: string Tabelle auf die zugegriffen werden soll.

connection: Connection Speichert die Verbindung zur Datenbank.


SSLConnection Nein

Klasse SSLServer


SSLServer(port: int) Initialisisert das Objekt.

removeConnection(connection:

SSLConnection)

Löscht ein SSLConnection-Objekt aus der

connections-Liste.

run() Wartet auf eingehende Verbindungen und

erzeugt SSLConnection-Objekte.


port: int Port für eingehende Verbindungen.

sslServerSocketFactory:

SSLServerSocketFactory

Erstellen von SSLServerSockets.

sslServerSocket: SSLServerSocket Annehmen von sicheren SSL-

Verbindungsanfragen von Clients.

sslSocket: SSLSocket Kommunikation mit einem Client.

connections: List<SSLConnection> Speichert die Verbindungen zu den

einzelnen Clients.


SSLConnection Nein

SSLClient Nein

Klasse SSLConnection


SSLConnection(sslServer: SSLServer,

target: SSLSocket)

Konstruktor um ein SSLConnection-Objekt

zu erzeugen und zu initialisieren.

sendMsg(msg: string) Sendet eine Nachricht an den Client.

run() Wartet auf Nachrichten vom Client und

verarbeitet diese.


traget: SSLSocket Verbindung mit einem Client.

sslServer: SSLServer SSLServer der das Objekt erstellt hat.

bufferedReader: BufferedReader Empfangen von Nachrichten vom Client.

bufferedWriter: BufferedWriter Senden von Nachrichten an den Client.


SSLServer Nein

SSLClient Ja

DatabaseConnection Nein

Klasse SSLClient


SSLClient (port: int, serverAddress: string) Konstruktor um ein SSLClient-Objekt zu

erzeugen und zu initialisieren.

connect (port: int, serverAddress: string) Baut Verbindung zu Server auf.

close() Schließt Verbindung zum Server.

sendMsg(msg: string) Sendet eine Nachricht an den Server.

run() Wartet auf Nachrichten vom Server und

verarbeitet diese.


port: int Port des Zielservers.

serverAddress: string Adresse des Zielservers.

sslServerSocketFactory: SSLSocketFactory Erstellen von SSLServerSockets.

traget: SSLSocket Verbindung mit einem Server.

bufferedReader: BufferedReader Empfangen von Nachrichten vom Client.

bufferedWriter: BufferedWriter Senden von Nachrichten an den Client.


SSLConnection Ja

3.8 Implementierung der Komponente Ver- und Entschl üsselung

Die Komponente Ver- und Entschlüsselung wird vom Uploader und Server zum

Verschlüsseln von Videos und vom Player zum Entschlüsseln von Videos benutzt. Zum Ver-

und Entschlüsseln benutzt die Klasse Crypto die Klasse Cipher. Speziell zum Verschlüsseln

wird zunächst ein neues Crypto-Objekt erzeugt. Dabei wird der Konstruktor mit dem

Verschlüsselungsalgorithmus aber ohne den Parameter Key aufgerufen. Dadurch wird ein

zufälliger Key vom KeyGenerator erzeugt und in dem SecretKeySpec-Attribut gehalten.

Durch einen Aufruf der encrypt-Methode werden die Videodaten nun paketweise

verschlüsselt und die verschlüsselten Daten zurückgegeben. Zum Entschlüsseln wird

ebenfalls ein Crypto-Objekt erzeugt, jedoch wird dem Konstruktor nun neben dem

Verschlüsselungsalgorithmus auch der passende Key als Parameter übergeben. Auch dieser

Key wird dann im SecretKeySpec-Attribut gehalten. Durch einen Aufruf der decrypt-Methode

werden die übergebenen verschlüsselten Daten entschlüsselt und zurückgegeben.

Diagramm 3-8: Klassendiagramm Ver- und Entschlüssel ung

3.8.1 Erläuterung

Klasse Crypto


Crypto (in algorithm: String) Konstruktor um ein Crypto-Objekt zu erzeugen

und mit dem Verschlüsselungsalgorithmus zu

initialisieren.

Crypto (in algorithm: String, in key: byte[]) Konstruktor um ein Crypto-Objekt zu erzeugen

und mit dem Verschlüsselungsalgorithmus und

einem Key zu initialisieren.

byte[] getKey() Selektor zum Erhalten des Keys

byte[] setKey() Setzt den Key eines Crypto-Objekts

byte[] encrypt(in dec_data: byte[]) Verschlüsselt die unverschlüsselten Daten

und gibt sie verschlüsselt zurück

byte[] decrypt(in enc_data: byte[]) Entschlüsselt die verschlüsselten Daten und

gibt sie unverschlüsselt zurück


cipher: Cipher Das Cipher-Objekt zum Ver- und

Entschlüsseln der Videodaten

sKeySpec: SecretKeySpec Das SecretKeySpec-Objekt, welches den

Key zum Ver- und Entschlüsseln hält


Cipher Nein

4 Datenmodell

4.1 Diagramm

Diagramm 4-1: Klassendiagramm Datenmodell

4.2 Erläuterung

In dem Diagramm ist zu sehen, welche Daten in der Datenbank gespeichert werden und wie

diese verbunden sind.

Zu jedem Benutzer werden gespeichert:

• der Benutzername (name)

• das Passwort (password)

• der Vorname (firstName)

• der Nachname (lastName)

• die E-Mail-Adresse (eMailAddress)

• der Zeitpunkt des letzten Anmeldevorgangs (lastLogin)

• die Anzahl fehlgeschlagener Anmeldeversuche seit der letzten erfolgreichen

Anmeldung (failedLogins)

• einen Zeitpunkt, bis zu dem der Benutzer gesperrt ist (accessDeniedUntil)

Folgende Daten werden zu jedem Video gespeichert:

• eine eindeutige ID (id)

• der Name des Videos (name)

• der Zeitpunkt des Uploads (dateOfUpload)

• die Länge (length)

• der Schlüssel, mit dem das Video verschlüsselt wurde (key)

• die MD5-Prüfsumme (md5sum)

• der zur Verschlüsselung verwendete Algorithmus (cipher)

Zudem gibt es Benutzergruppen mit

• einer eindeutigen ID (id)

• einem Gruppennamen (name)

Ein Benutzer kann Mitglied beliebig vieler Benutzergruppen sein. Ebenso kann eine

Benutzergruppe beliebig viele Benutzer enthalten (Relation memberOf).

Einzelne Gruppen können das Recht haben, andere Gruppen und deren Benutzer zu

modifizieren (Relation mayModify). Damit kann festgelegt werden, wer bestimmten Gruppen

Benutzer hinzufügen, Benutzer bearbeiten oder löschen darf.

Außerdem wird jedem Video eindeutig der Benutzer zugeordnet, der es hochgeladen hat

(Relation hasUploaded).

Für die Beschreibung der Zugriffsrechte ist die Relation rights zuständig. Sie beschreibt für

jedes Video, welche Operationen für bestimmte Gruppen erlaubt sind. So lässt sich regeln,

wer auf Videos zugreifen, sich diese ansehen oder löschen darf.

Beziehungen Entität

Name der Beziehung Kardinalität memberOf *:* 01: User hasUploaded 1:* rights *:* 02: Video hasUploaded *:1 memberOf *:* rights *:* 03: Group

mayModify 1:*

Date post:	18-Sep-2020
Category:	Documents
Upload:	others
View:	0 times
Download:	0 times

F e i n e n t w u r f - TU Braunschweig...1.0 08.05.09 Gruppe 1 Erstfassung 2.0 13.05.09 Gruppe 1...

Documents