Verschlüsslung von Dateien mit Vernam

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

Imports System
Imports System.Drawing 		' Verweis einbinden!
Imports System.IO

Namespace VernamVerschlüsselung
	Public Class Program
		Public Shared Sub Main()
			' Bild von Datei einlesen:
			Dim originalImage As Image = Image.FromFile("TestBild.jpg")

			' Bild verschlüsseln:
			EncryptImage(originalImage, "TestBild_verschlüsselt.jpg", "Schlüssel.dat")

			' Bild entschlüsseln:
			Dim newImage As Image = DecryptImage("TestBild_verschlüsselt.jpg", "Schlüssel.dat")

			' Bild in Datei speichern:
			newImage.Save("TestBild_entschlüsselt.jpg")
		End Sub
		'---------------------------------------------------------------------
		''' <summary>
		''' Verschlüsselt ein Bild nach Vernam
		''' </summary>
		''' <param name="img">
		''' zu verschlüsselndes Bild
		''' </param>
		''' <param name="encryptedFile">
		''' Dateiname in dem das verschlüsselte Bild geschrieben wird
		''' </param>
		''' <param name="keyFile">
		''' Dateiname in dem der Schlüssel geschrieben wird
		''' </param>
		Private Shared Sub EncryptImage(ByVal img As Image, ByVal encryptedFile As String, ByVal keyFile As String)
			' Byte-Array aus dem Bild erstellen (könnte auch über 
			' ImageConverter geschehen - bekomme ich aber in VB.net nicht hin)
			Dim originalBytes As Byte()
			Using ms As New MemoryStream()
				img.Save(ms, System.Drawing.Imaging.ImageFormat.Jpeg)
				originalBytes = ms.ToArray()
			End Using

			' Schlüssel erzeugen. Hier wird ein Zufallsschlüssel verwendet:
			Dim keyBytes As Byte() = New Byte(originalBytes.Length - 1) {}
			Dim rnd As New Random()
			rnd.NextBytes(keyBytes)

			' Schlüssel speichern:
			Using fs As New FileStream(keyFile, FileMode.Create)
				fs.Write(keyBytes, 0, keyBytes.Length)
			End Using

			' Bild mit Vernam-Algorithmus verschlüsseln (XOR).
			' Die Schlüssellänge entspricht der Originallänge da der
			' Schlüssel so erzeug worden ist.
			Dim encryptedBytes As Byte() = New Byte(originalBytes.Length - 1) {}
			Vernam(originalBytes, keyBytes, encryptedBytes)

			' Speichern des verschlüsselten Bildes. Da die Information
			' im byte-Array kein gültiges Image darstellt kann es nicht
			' als Image behandelt werden.
			Using fs As New FileStream("TestBild_verschlüsselt.jpg", FileMode.Create)
				fs.Write(encryptedBytes, 0, encryptedBytes.Length)
			End Using
		End Sub
		'---------------------------------------------------------------------
		''' <summary>
		''' Entschlüsselt ein Bild nach Vernam
		''' </summary>
		''' <param name="encryptedFile">
		''' Dateiname der verschlüsselten Datei
		''' </param>
		''' <param name="keyFile">
		''' Dateiname der Schlüsseldatei (muss den gleichen Inhalt haben wie 
		''' die Datei die beim Verschlüsseln erstellt wurde)
		''' </param>
		''' <returns>
		''' entschlüsseltes Bild
		''' </returns>
		Private Shared Function DecryptImage(ByVal encryptedFile As String, ByVal keyFile As String) As Image
			' Einlesen der verschlüsselten Bytes:
			Dim encryptedBytes As Byte()
			Using fs As New FileStream(encryptedFile, FileMode.Open)
				encryptedBytes = New Byte(fs.Length - 1) {}
				fs.Read(encryptedBytes, 0, CInt(fs.Length))
			End Using

			' Einlesen des Schlüssels:
			Dim keyBytes As Byte()
			Using fs As New FileStream(keyFile, FileMode.Open)
				keyBytes = New Byte(fs.Length - 1) {}
				fs.Read(keyBytes, 0, CInt(fs.Length))
			End Using

			' Entschlüsseln:
			Dim originalBytes As Byte() = New Byte(encryptedBytes.Length - 1) {}
			Vernam(encryptedBytes, keyBytes, originalBytes)

			' Image aus dem Byte-Array erzeugen:
			Dim ic As New ImageConverter()
			Return TryCast(ic.ConvertFrom(originalBytes), Image)
		End Function
		'---------------------------------------------------------------------
		''' <summary>
		''' Führt die Vernam-Verschlüsselung durch
		''' </summary>
		''' <param name="inBytes"></param>
		''' <param name="keyBytes"></param>
		''' <param name="outBytes"></param>
		Private Shared Sub Vernam(ByVal inBytes As Byte(), ByVal keyBytes As Byte(), ByRef outBytes As Byte())
			' Prüfen der Argumente:
			If (inBytes.Length <> keyBytes.Length) OrElse (keyBytes.Length <> outBytes.Length) Then
				Throw New ArgumentException("Ungleiche Länge")
			End If
			For i As Integer = 0 To inBytes.Length - 1

				' XOR:
				outBytes(i) = CByte((inBytes(i) Xor keyBytes(i)))
			Next
		End Sub
	End Class
End Namespace