Tutorial zur Datenverschlüsselung
 
*** Vorwort
Dateiverschlüsselungen sind so alt wie die Computer selbst. Dabei sollten diese Daten immer "unlesbar" gemacht werden, um Manipulationen oder auch nur die Einsicht zu verhindern. Da ich jedoch keinem Programm traue, was ich nicht selber geschrieben habe, blieb mir keine andere Wahl, als mir ein Verschlüsselungsprogramm selbst zu schreiben. Die Routine muß folgende Voraussetzungen erfüllen:
 
• weder Format, noch Inhalt der Originaldatei dürfen auch nur Ansatzweise zu erraten sein.
• die Verschlüsselung darf die Zieldaten nicht aufblähen.
 
Im Folgenden geschilderte Verfahren erfüllt diese Bedingungen und wird auch verwendet in meinem Programm CHEW Version 2.0 (engl.chew - kauen, zermalmen) -
 
CHEW steht zum Herunterladen bereit unter www.east-power-soft.de/download/chewrout.zip
 
*** Einleitung
Die recht hohe Sicherheit basiert auf einem gesteuerten Zufallsgenerator, der "Datenmüll" aus der Quelldatei erzeugt. Um die Verschlüsselungstiefe zu prüfen, habe ich den Datenblock von WAV und BMP Dateien verschlüsselt. Diesem Datenblock habe ich danach wieder den originalen Header verpaßt und geöffnet. Ergebniss: Aus einem recht unansehnlichen Bild von meiner Fresse wurde ein gleichmäßig, buntes, pixeliges (und recht beschauliches) Bild von überhaupt gar nichts. Aus einer klangvollen Musikdatei wurde ein gleichmäßiges, nervtötendes Rauschen.
 
*** Arbeitsweise
Der Zufallsgenerator (RND) ist sicher nicht das, was der Name vermuten läßt. Denn in einem Computer passieren zwar "Unfälle", aber diese sind absolut nicht "zufällig".
 
Der Zufallsgenerator (RND) kann zwar durch setzen eines Startwert (RANDOMIZE) gesteuert werden, aber er produziert dabei auch wirklich nur "zufällige" Zahlenreihen, auch wenn der Startwert immer der selbe ist. Um immer die selben "zufälligen" Zahlenreihen zu ermitteln, muß der RND einen "RESET" ausführen. Das geht über den Befehl "A = RND(-1)". Dieses Kommando resetiert den Zufallsgenerator vollständig, daß dieser danach keine "zufälligen" Zahlen mehr ermitteln kann (auch wenn diese immer noch "zufällig" aussehen). Nach einem solchen "RESET" kann der RND mit einem Startwert weiter gesteuert werden. Das Ergebnis sind "zufällig-aussehende" Zahlenreihen, die bei gleichen RANDOMIZE die gleichen Werte haben.
 
Wenn nun die Wertebereiche des RND auf Bytegröße (0-255) begrenzt werden, kann man diese "nicht zufälligen" Zahlenreihen für eine "hundsgemeine" Verschlüsselung verwenden. Obwohl der RANDOMIZE nur Zahlenwerte mit maximal 64bit verarbeiten kann, ist eine Verschlüsselung dieser Art kaum (oder nur mit gigantischem Aufwand) zu knacken und der Aufwand würde in keinem Verhältnis zum Nutzen stehen.
 
Im Beispielprogramm habe ich einen String (Block$ = "Arbeitsweise Chew") benutzt, der die Arbeitsweise veranschaulichen soll. Die Bildschirmausgabe ist zweckgebunden einfach.
 
Original | Code 100
---------+-----------
A 65 | 120
r 114 | 46
b 98 | 250
e 101 | 25
i 105 | 233
t 116 | 160
s 115 | 33
w 119 | 254
e 101 | 114
i 105 | 32
s 115 | 39
e 101 | 30
32 | 7
C 67 | 85
h 104 | 141
e 101 | 147
w 119 | 238
 
Original | Code 200
---------+-----------
A 65 | 184
r 114 | 175
b 98 | 184
e 101 | 30
i 105 | 25
t 116 | 77
s 115 | 88
w 119 | 152
e 101 | 228
i 105 | 11
s 115 | 168
e 101 | 221
32 | 10
C 67 | 140
h 104 | 37
e 101 | 7
w 119 | 210
 
 
Ganz links stehen die ASCII-Zeichen des Strings und daneben dessen ASCII-Werte. In der zweiten Spalte (unter Code100) stehen die ASCII-Ergebnisse der ersten Verschlüsselung (mit RANDOMIZE 100). Daneben die "wiederhergestellten" Bytes. Unter "Code200" stehen die Werte der zweiten Verschlüsselung (mit RANDOMIZE 200) und daneben die "wiederhergestellten" Originale.
 
Verwendet man jetzt den Datenpuffer (BLOCK$) zum Lesen von Dateien, kann man diesen String an das Unterprogramm "Coden" übergeben und erhält einen "zerkauten" Block$ mit Datenmüll, den man dann wieder schreiben kann. Das Ergebnis ist eine Zieldatei mit der gleichen Größe, die aber nur noch Müll zu enthalten scheint. Wie in meinem Beispiel erklärt, funktioniert dieser Vorgang natürlich auch in umgekehrter Richtung.
 
*** Noch ein Hinweis
Um so größer der String ist, um so schneller werden Zugriffe auf den Datenträger. Jedes Byte einzeln gelesen, verschlüsselt und geschrieben dauert unverhältnismäßig länger, als Blöcke von z.B. 32KB Länge.
 
*** Ganz Wichtig !!!
Diese RND-Verschlüsselung ist nicht mit BlitzBasic realisierbar, weil BlitzBasic einen RND-Generator benutzt, dessen Funktion durch die DirectX Version und Windows eigene Komponenten bestimmt wird. Das führt bei bestimmten Kombinationen zu "Berechnungsfehlern" beim "Zufall". Meine RND-Routine für QuickBasic arbeitet überall zuverlässig. Bis jetzt ist mir nur bei der BlitzBasic-Version aufgefallen, daß diese Routine nicht zuverlässig arbeitet. Warum das so ist, oder was da schief läuft, kann ich noch nicht genau sagen. Dazu müßte ich mehr über den Kern von BlitzBasic in Erfahrung bringen...
 
 

Antwort 12
~~~~~~~~~~~~~~~~
[ Von einem Teilnehmer des QB-Forums, 2005 ]
.
Am einfachsten ist sicher eine XOR-Verschlüsselung. z.B. mit diesem Programm aus der QB-Wundertüte:
 
'===========================================================================
' Subject: XOR ENCRYPTION/DECRYPTION Date: 08-10-96 (12:55)
' Author: Jonathan Leger Code: QB, QBasic, PDS
' Origin: leger*mail.dtx.net Packet: BINARY.ABC
'===========================================================================
'(*** XOR.BAS ***)
'(*************************************************************************)
'(*** This is a small demonstration of the XOR encryption/decryption ***)
'(*** method that will encrypt this file (assuming the name is XOR.BAS) ***)
'(*** and put it in the file XOR.XOR. If you want it to decrypt the ***)
'(*** XOR.XOR file once it's been encrypted, merely change the FILE$ ***)
'(*** to XOR.XOR and the OUTPUT$ to XOR.BAS (or whatever). The key ***)
'(*** we will be using is 15. You can change that for your purposes, ***)
'(*** but the key must be a value from 0 to 255. ***)
'(*************************************************************************)
'(*** This method of encryption is not very secure, since it can be ***)
'(*** broken easily by the brute force method (though it used to be a ***)
'(*** very popular form of encryption). However, for most purposes, ***)
'(*** such as game high scores or passwords, etc, it serves quite well, ***)
'(*** since the person has no way to know that the file was encrypted ***)
'(*** using this method, and most people wouldn't think to try and ***)
'(*** decrypt it themselves anyway. ***)
'(*************************************************************************)
'(*** The File.XOR function returns a FALSE value (0) if the input file ***)
'(*** (FILE$) does ***) not exist, otherwise it returns TRUE (-1). ***)
'(*************************************************************************)
DECLARE FUNCTION File.XOR% (FILE$, output$, ekey%, sbarx%, sbary%, sbarlen%)
SCREEN 0
WIDTH 80, 25
COLOR 7, 0
CLS
FILE$ = "xor.bas" '(*** We'll encrypt this file... ***)
output$ = "xor.xor" '(*** ...and put the results here. ***)
ekey% = 15 '(*** Our encryption key will be 15. ***)
LOCATE 1, 1
PRINT "Using XOR method of encryption/decription on " + UCASE$(FILE$) + "..."
'(*** Use a status bar for the encryption. ***)
COLOR 15, 1
ErrVal = File.XOR%(FILE$, output$, ekey%, 1, 2, 40)
IF ErrVal THEN '(*** No errors! ***)
LOCATE 1, 1: COLOR 7, 0
PRINT STRING$(80, " ");
LOCATE 1, 1
PRINT "Success! Results in file (" + UCASE$(output$) + ")."
ELSE
'(*** The file didn't exist! ***)
LOCATE 1, 1: COLOR 7, 0
PRINT STRING$(80, " ");
LOCATE 1, 1
PRINT "Input file ("; UCASE$(FILE$); ") does not exist."
END IF
DEFINT A-Z
'(*** File.XOR () ****)
'(*** ----------- ****)
'(*** Thie function will take a file (INPUT$) and XOR each byte with ***)
'(*** the given encryption key (EKEY), puting the results into a file ***)
'(*** (OUTPUT$). If you want a status bar showing progress, pass the ***)
'(*** x and y location of the status bar on-screen (SBARX, SBARY). If ***)
'(*** no status bar is desired, pass a 0 for the x and y. SBARLEN is ***)
'(*** the length you want the status bar to be. ***)
'(*** NOTICE: To unXOR the file, just pass the XORed file the the ***)
'(*** function with the _SAME_ encryption key. Given the nature of ***)
'(*** XOR, an individual decryption scheme is not needed. Note, too, ***)
'(*** that EKEY can only be from 0 to 255. ***)
'(*** --------------------------------------------------------------- ***)
FUNCTION File.XOR (FILE$, output$, ekey, sbarx, sbary, sbarlen)
'(*** Check if the input file passed exist. ***)
'(*** If the input file doesn't exist, exit with error ***)
'(*** value 0 [FALSE]. ***)
filenum = FREEFILE
OPEN FILE$ FOR BINARY AS filenum
IF LOF(filenum) = 0 THEN
'(*** Pass error value back since file didn't exist. ***)
File.XOR = 0
CLOSE filenum
'(*** Kill the 0 byte file we made by opening it. ***)
KILL FILE$
EXIT FUNCTION
END IF
'(*** Both files exist, open them. ***)
CLOSE filenum
OPEN FILE$ FOR INPUT AS filenum
outputnum = FREEFILE
OPEN output$ FOR OUTPUT AS outputnum
'(*** If we want a status bar, do the encryption with a status bar! ***)
IF sbarx > 0 THEN
'(*** Draw empty status bar and reset the byte count# to 0. ***)
LOCATE sbary, sbarx: PRINT STRING$(sbarlen, 177);
count# = 0
'(*** Encrypt/Decrypt the file. ***)
DO WHILE NOT EOF(1)

'(*** Read a byte from the file. ***)
bytes.left# = LOF(filenum) - LOF(outputnum)
IF bytes.left# < 100 THEN
read.bytes$ = INPUT$(bytes.left#, filenum)
chunk = bytes.left#
ELSE
read.bytes$ = INPUT$(100, filenum)
chunk = 100
END IF

'(*** Increment byte count#. ***)
count# = count# + chunk
'(*** XOR the bytes with encryption key. ***)
FOR byte.count = 1 TO chunk
changed.byte$ = changed.byte$ + CHR$(ASC(MID$(read.bytes$, byte.count, 1)) XOR ekey)
NEXT byte.count

'(*** Print it to the output file. ***)
PRINT #outputnum, changed.byte$;
changed.byte$ = ""
'(*** If a chunk of 100 bytes has been read, update status bar. ***)
IF count# MOD 1000 = 0 THEN
LOCATE sbary, sbarx
PRINT STRING$(sbarlen * (count# / LOF(1)), 219);
END IF
LOOP

LOCATE sbary, sbarx
PRINT STRING$(sbarlen, 219);
ELSE
'(*** We didn't want a status bar, so skip the status bar. This will ***)
'(*** give some extra speed because the print code is ignored. ***)

DO WHILE NOT EOF(1)

'(*** Read a byte from the file. ***)
bytes.left# = LOF(filenum) - LOF(outputnum)
IF bytes.left# < 100 THEN
read.bytes$ = INPUT$(bytes.left#, filenum)
chunk = bytes.left#
ELSE
read.bytes$ = INPUT$(100, filenum)
chunk = 100
END IF

'(*** XOR the bytes with encryption key. ***)
FOR byte.count = 1 TO chunk
changed.byte$ = changed.byte$ + CHR$(ASC(MID$(read.bytes$, byte.count, 1)) XOR ekey)
NEXT byte.count

'(*** Print it to the output file. ***)
PRINT #outputnum, changed.byte$;
changed.byte$ = ""
LOOP
END IF
'(*** Close the files we used. ***)
CLOSE filenum, outputnum
'(*** All done with no errors, so return a TRUE value. ***)
File.XOR = -1
END FUNCTION
 
 

Answer 13
~~~~~~~~~~
[ by Ethan Winer, 18.3.2004 ]
My program "Encrypt" is a text encryption routine. "Encrypt" is available in the above "Antwort" and on my website www.ethanwiner.com .
 
 
 

Answer 14
~~~~~~~~~~~~
[ by ANDY THOMAS, Sept 8, 1993 ]
 
*** Answer English
My following encryption/decryption program uses the property of' the QB RND function to return the same set of pseudo-random numbers for a given seed. While it's present form produces an encrypted string using the entire ASCII chart the routines could be altered to produce encrypted strings suitable for message posting. The original concept of this encryption system was designed for games, user configuration files and the like however.
 
*** Antwort deutsch
Dieses Q(uick)Basic-Programm verschluesselt und entschluesselt einen beliebigen Text mit Hilfe eines frei waehlbaren Passworts. Es kommt ein sehr interessanter Verschluesselungsalgorithmus zur Anwendung, der mit Zufalszahlen arbeitet und die QBasic-Befehle RND und RANDOMIZE verwendet.
 
Das Ergebnis der Verschluesselung ist jedesmal ein anderes. Trotzdem laesst sich der verschluesselte Text immer mit demselben Passwort entschluesseln.
 
*** Beispielprogramm CryptMe.bas
 
'**************************************************************************
' CryptMe.bas = Text Encryption and Decryption with Password Protection
' =========== Textverschluesselung u.-Entschluesselung mit Passwortschutz
'
' Deutsche Beschreibung
' ---------------------
' (von Thomas Antoni)
' Dieses Q(uick)Basic-Programm verschluesselt und entschluesselt einen
' beliebigen Text mit Hilfe eines frei waehlbaren Passworts. Es kommt
' ein sehr interessanter Verschluesselungsalgorithmus zur Anwendung,
' der mit Zufalszahlen arbeitet und die QBasic-Befehle RND und RANDOMIZE
' verwendet.
'
' Das Ergebnis der Verschluesselung ist jedesmal ein anderes. Trotzdem
' laesst sich der verschluesselte Text immer mit demselben Passwort
' entschluesseln.
'
' English Description
' ---------------------
' Recent discussions of encryption schemes led me to fool around
' with this idea of mine. Here's an encryption method based on QBs
' RND/RANDOMIZE statements.
'
' This encryption/decryption system uses the property of
' the QB RND function to return the same set of pseudo-
' random numbers for a given seed. While it's present form
' produces an encrypted string using the entire ASCII chart
' the routines could be altered to produce encrypted strings
' suitable for message posting. The original concept of this
' encryption system was designed for games, user configuration
' files and the like however.
'
' (c) by ANDY THOMAS, Sept 8, 1993
'****************************************************************************
DECLARE SUB Encrypt (Base$, PassWord$)
DECLARE SUB Decrypt (Base$, PassWord$)
'
'-------- Text and passoword input
Base$ = "This is a test of the Andy Thomas encryption system."
PassWord$ = "AndyThomas"
CLS
PRINT "Text to be encrypted:"
PRINT Base$ ' print original string
PRINT
'
'-------- 1st Enrcyption and decryption
Encrypt Base$, PassWord$ ' Encrypt string with password
'
PRINT "Encrypted text (1st Encryption):"
FOR I = 1 TO LEN(Base$) ' print encrypted characters
IF ASC(MID$(Base$, I, 1)) > 32 THEN
PRINT MID$(Base$, I, 1); ' print encrypted char.
ELSE
PRINT CHR$(249); ' or a dot if not printable
END IF
NEXT I
'
Decrypt Base$, PassWord$ ' decrypt string
PRINT : PRINT
PRINT "Decrypted text:"
PRINT Base$ ' print restored string
'
'-------- 2nd Encryption and decryption
Encrypt Base$, PassWord$ ' encrypt string again
PRINT
PRINT "Encrypted text (2nd Encryption)"
FOR I = 1 TO LEN(Base$) ' print encrypted characters
IF ASC(MID$(Base$, I, 1)) > 32 THEN
PRINT MID$(Base$, I, 1); ' print encrypted char.
ELSE
PRINT CHR$(249); ' or a dot if not printable
END IF
NEXT I
Decrypt Base$, PassWord$ ' decrypt string again
PRINT : PRINT
PRINT "Decrypted text:"
PRINT Base$ ' print restored string
PRINT : PRINT
PRINT "Notice this system creates a totally unique"
PRINT "series with every usage. Even given the same"
PRINT "string to encrypt and the same password."
SLEEP
END
DEFINT A-Z
'
'
SUB Decrypt (Base$, PassWord$)
' RND/RANDOMIZE Decryption SUB
' by Andy Thomas 9/93
'
BaseLen = LEN(Base$) - 4 ' true length of the encrypted string
'
' we must extract the RNDptr, and RandomizeValue Words from
' the encrypted string in the opposite order they were inserted.
PlacePtrRandomize! = (ASC(LEFT$(Base$, 1)) * 256!) + ASC(RIGHT$(Base$, 1))
Junk = RND(-1)
RANDOMIZE PlacePtrRandomize!
PlacePtr1 = INT((BaseLen - 3) * RND + 3)
PlacePtr2 = INT((BaseLen - 3) * RND + 3)
'
MsdRNDptr = ASC(MID$(Base$, PlacePtr1 + 1, 1))
Base$ = LEFT$(Base$, PlacePtr1) + MID$(Base$, PlacePtr1 + 2, BaseLen)
'
LsdRNDptr = ASC(MID$(Base$, PlacePtr2 + 1, 1))
Base$ = LEFT$(Base$, PlacePtr2) + MID$(Base$, PlacePtr2 + 2, BaseLen)
'
RNDptr = (MsdRNDptr * 256) + LsdRNDptr
MsdRandomizeValue = ASC(MID$(Base$, RNDptr + 1, 1))
LsdRandomizeValue = ASC(MID$(Base$, RNDptr + 2, 1))
'
RandomizeValue = (MsdRandomizeValue * 256) + LsdRandomizeValue
Base$ = LEFT$(Base$, RNDptr) + MID$(Base$, RNDptr + 3, BaseLen)
'
Junk = RND(-1)
RANDOMIZE RandomizeValue
'
IF PassWord$ <> "" THEN ' scroll for password
FOR I = 1 TO LEN(PassWord$)
PassValue = PassValue + (ASC(MID$(PassWord$, I, 1)) XOR I)
NEXT I
FOR I = 1 TO PassValue
Junk = RND
NEXT I
END IF
'
' decrypt the string
FOR I = 1 TO BaseLen
RNDvalue = INT(255 * RND + 1) ' get the next RND number
' the following could be optimized, this shows what's happening
' well however. Each character in Base$ is decrypted by XORing
' it with the random number selection. Exactly the same way
' it was encrypted.
SELECT CASE I
CASE 1 ' first character encrypted
Base$ = CHR$(ASC(MID$(Base$, I, 1)) XOR RNDvalue) + MID$(Base$, I + 1, BaseLen)
CASE BaseLen ' last character encrypted
Base$ = LEFT$(Base$, I - 1) + CHR$(ASC(MID$(Base$, I, 1)) XOR RNDvalue)
CASE ELSE ' in between characters encrypted
Base$ = LEFT$(Base$, I - 1) + CHR$(ASC(MID$(Base$, I, 1)) XOR RNDvalue) + MID$(Base$, I + 1, BaseLen)
END SELECT
NEXT I
END SUB
'
'
SUB Encrypt (Base$, PassWord$)
'
' RND/RANDOMIZE Encryption SUB
' by Andy Thomas 9/93
'
BaseLen = LEN(Base$) ' get length of string
'
RANDOMIZE TIMER
RNDptr = INT(BaseLen * RND + 1) ' random ptr value
RandomizeValue = INT(32767 * RND) ' random randomize value
'
' compute byte Word from RandomizeValue and RNDptr
' these two Words will be saved within the encrypted string
' increasing it's size by four bytes.
MsdRandomizeValue = ((RandomizeValue AND &HFF00) \ 256) AND &HFF
LsdRandomizeValue = RandomizeValue AND 255
MsdRNDptr = ((RNDptr AND &HFF00) \ 256) AND &HFF
LsdRNDptr = RNDptr AND 255
'
Junk = RND(-1) ' Junk value, sets up RND correctly
RANDOMIZE RandomizeValue ' Seed RND with Randomizevalue
'
' if a password exists, compute a unique number from that
' password and scroll through the RND function that number
' of Random numbers. This creates a unique starting point
' for the encrypted string.
IF PassWord$ <> "" THEN
FOR I = 1 TO LEN(PassWord$)
PassValue& = PassValue& + (ASC(MID$(PassWord$, I, 1)) XOR I)
NEXT I
FOR L& = 1 TO PassValue&
Junk = RND
NEXT L&
END IF
'
' Now actually encrypt the string
FOR I = 1 TO BaseLen
RNDvalue = INT(255 * RND + 1) ' get the next RND number
' the following could be optimized, this shows what's happening
' well however. Each character in Base$ is encrypted by XORing
' it with the random number selection.
SELECT CASE I
CASE 1 ' first character encrypted
Base$ = CHR$(ASC(MID$(Base$, I, 1)) XOR RNDvalue) + MID$(Base$, I + 1, BaseLen)
CASE BaseLen ' last character encrypted
Base$ = LEFT$(Base$, I - 1) + CHR$(ASC(MID$(Base$, I, 1)) XOR RNDvalue)
CASE ELSE ' in between characters encrypted
Base$ = LEFT$(Base$, I - 1) + CHR$(ASC(MID$(Base$, I, 1)) XOR RNDvalue) + MID$(Base$, I + 1, BaseLen)
END SELECT
NEXT I
'
' Now insert the Randomize Word into the string at location_
' RNDptr
Base$ = LEFT$(Base$, RNDptr) + CHR$(MsdRandomizeValue) + CHR$(LsdRandomizeValue) + MID$(Base$, RNDptr + 1, BaseLen)
'
' Now insert the RNDptr into the string
' to hide the location of the RNDptr I use the first and last
' characters in the encrypted string as a word for a single
' precision Randomize Seed.
PlacePtrRandomize! = (ASC(LEFT$(Base$, 1)) * 256!) + ASC(RIGHT$(Base$, 1))
Junk = RND(-1)
RANDOMIZE PlacePtrRandomize!
' then pick two random locations within the encrypted string
' to insert the RNDptr word--each byte separately.
' the RNDptr location can be neither within the first three
' or the last three characters of the string.
PlacePtr1 = INT((BaseLen - 3) * RND + 3)
PlacePtr2 = INT((BaseLen - 3) * RND + 3)
'
' insert the RNDptr word.
Base$ = LEFT$(Base$, PlacePtr2) + CHR$(LsdRNDptr) + MID$(Base$, PlacePtr2 + 1, BaseLen)
Base$ = LEFT$(Base$, PlacePtr1) + CHR$(MsdRNDptr) + MID$(Base$, PlacePtr1 + 1, BaseLen)
END SUB
 
Das obige Programm steht im Verzeichnis Progs\ zur Verfügung sowie online unter www.antonis.de/faq/progs/cryptme.bas .