File encryption / decryption

[NOVARSEG]

Basic file encryptor
Don't try this on important files as it has not been tested

**********************

DIM string1(16384) AS STRING 
DIM string2(16384) AS STRING
DIM LFILE AS _UNSIGNED LONG
DIM FPOS AS _UNSIGNED LONG
DIM NBYTES  AS _UNSIGNED LONG
FPOS = 1
string1 = string$(16384,"a") 'string1 could randomized for better security
OPEN TEST.TXT FOR BINARY AS #1

LFILE = LOF (1)

DO
IF LFILE  = 0  THEN EXIT DO
 
  IF LFILE  < 16384  THEN
  GET #1, ,string2(LFILE) 'file read
  FPOS = FPOS  + LFILE    'FPOS = file position after GET
  nbytes = LFILE 
  GOSUB  XORstring2      'encrypt or decrypt
  SEEK 1, FPOS - LFILE    'adjust file pointer 
  PUT #1, ,string2(LFILE) 'file write
  LFILE = 0
  END IF 

  IF LFILE =>16384  THEN
  GET #1, ,string2(16384) 'file read
  FPOS = FPOS  + 16384    'FPOS = file position after GET 
  nbytes = 16384 
  GOSUB XORstring2        'encrypt or decrypt
  SEEK 1, FPOS - 16384    'adjust file pointer
  PUT #1, ,string2(16384) 'file write
  LFILE = LFILE - 16384
  END IF 

LOOP
CLOSE 1
END

XORstring2:
FOR x% = 1 to nbytes
a$ = MID$(string1),x%,1)
b$ = MID$(string2),x%,1)
b$ xor a$
MID$(string2),x%,1) = b$
NEXT x%
RETURN

*****
Question
In the above code is:
DIM string1(16384) AS STRING
equivalent to
DIM string1 AS STRING * 16384
for the application as shown?
****

[bplus]

*****
Question
In the above code is:
DIM string1(16384) AS STRING
equivalent to
DIM string1 AS STRING * 16384
for the application as shown?
****

Oh man, I just saw this question when I started playing around with a file Encryption of my own.
Sorry but you had it buried in what I thought was code. I saw the XOR code method in quick glance and passed at looking at until I decided to test my encryptor with a copy of your post put in a text file, when decrypting my description I saw the question. Well better late that never...

No, those 2 things are not equivalent:
DIM string1(16384) AS STRING > is a string array with 16384 items
DIM string1 AS STRING * 16384 > is a Fixed string of fixed length 16384

Do you know how to post code in code tabs?  [ code ]  your code here   [ /code ]

  [ You are not allowed to view this attachment ]


Put your code in editor, highlight it all, and then click the QB64 icon button.

or click the button and paste the code between    code] x[/code  where x is (not much room).

[Bert22306]

Interesting. In your scheme, however, you will need to input two long strings, in order to encrypt or decrypt the actual plaintext file. If I read this correctly. The plaintext string1 and this string2. Or perhaps, both strings make up the plaintext?

Another way to do this, create one string, consisting of the plaintext, and then XOR each byte with a pseudo-random byte from the QB64 RANDOMIZE function.

Then, all you have to send to the receiver is the seed used in the encryption step. This has a formal name: "symmetric key stream cipher." Pretty hard to crack, as long as the random number sequence is at least as long as the plaintext.

Or, instead of XORing, another possibility is multiplication in encryption, and division in decryption. But that will create a longer ciphertext than plaintext.

Fun stuff.

[NOVARSEG]

Hi bplus
so they are not the same exactly?

DIM string1(16384) AS STRING
DIM string1 AS STRING * 16384
GET or PUT seems to like the array type. 

****
Hi Bert22306

Interesting. In your scheme, however, you will need to input two long strings, in order to encrypt or decrypt the actual plaintext file. If I read this correctly. The plaintext string1 and this string2. Or perhaps, both strings make up the plaintext?

string2 is the buffer for read from file and write to file.

string1 is the random string. It is shown as all "a" for simplicity

basically the code does:  string2 XOR string1

Another way to do this, create one string, consisting of the plaintext, and then XOR each byte with a pseudo-random byte from the QB64 RANDOMIZE function.

That is what the code does. string1 is the random string, just have to use the RANDOMIZE function

Then, all you have to send to the receiver is the seed used in the encryption step. This has a formal name: "symmetric key stream cipher." Pretty hard to crack, as long as the random number sequence is at least as long as the plaintext.

There are various methods. The one I like is the long password system. A long password, say, 512 bytes is hashed and then that is used as the password.  The hash function has to be written correctly to obliterate any repetitions etc in the hash itself.

Or, instead of XORing, another possibility is multiplication in encryption, and division in decryption. But that will create a longer ciphertext than plaintext.

There are other ways but XOR works just fine if done right.

The code overwrites the plain text file with XORed bytes to create cipher text
and when run again
 the code overwrites the cipher text file with XORed bytes to create plain text

[bplus]

Hi bplus
so they are not the same exactly?

DIM string1(16384) AS STRING
DIM string1 AS STRING * 16384
GET or PUT seems to like the array type.

I will show a difference:

Code: QB64: [Select]

1. DIM string1(16384) AS STRING
2. DIM string2 AS STRING * 16384
3.  
4. FOR i = 1 TO 16384
5.     string1(i) = STR$(i)
6. NEXT
7. ' no error
8.  
9. FOR i = 1 TO 16384
10.     string2(i) = STR$(i)   ' <<<<<<<<<<<<< red lined!!!
11. NEXT
12.  

Here's another:

Code: QB64: [Select]

1. DIM string1(16384) AS STRING
2. DIM string2 AS STRING * 16384
3.  
4. PRINT LEN(string1(1))
5. PRINT LEN(string2)
6.  
7.  
8.  

[NOVARSEG]

bplus
Interesting
whoop made a mistake i had 2 string1
****

DIM string1(16384) AS STRING
DIM string2 AS STRING * 16384
 
PRINT LEN(string1())
PRINT LEN(string2)

are they the same length?
 

[bplus]

bplus
Interesting
whoop made a mistake i had 2 string1
****

DIM string1(16384) AS STRING
DIM string2 AS STRING * 16384
 
PRINT LEN(string1())
PRINT LEN(string2)

are they the same length?

;-)) well you could run the code but yes! string2 is a fixed length string always it will have length 16384 because that's how you DIM'd it.

String1 is an array of variable length strings we have 16384 of those dimensioned for that array of strings, so at the moment it has a length of 0 because it hasn't been assigned a value yet.

[bplus]

@NOVARSEG

I just put your code in the IDE, no offense but it's a mess, which tells me you hadn't tried it yourself.

Not good.

Not only should we not try it on important files, we shouldn't try it at all, not safe.
But we couldn't run this one, as is, so there's that ;-))

I suggest trying XOR on 2 strings before moving up to files. It's a nice idea if it works.

[SMcNeill]

Interesting. In your scheme, however, you will need to input two long strings, in order to encrypt or decrypt the actual plaintext file. If I read this correctly. The plaintext string1 and this string2. Or perhaps, both strings make up the plaintext?

Another way to do this, create one string, consisting of the plaintext, and then XOR each byte with a pseudo-random byte from the QB64 RANDOMIZE function.

Then, all you have to send to the receiver is the seed used in the encryption step. This has a formal name: "symmetric key stream cipher." Pretty hard to crack, as long as the random number sequence is at least as long as the plaintext.

Or, instead of XORing, another possibility is multiplication in encryption, and division in decryption. But that will create a longer ciphertext than plaintext.

Fun stuff.

As Bert said, this isn't that complicated to do.   Here's a quick example of a normal string, encrypted, and then decrypted, using a simple seed and RND with XOR:

Code: QB64: [Select]

1. SCREEN _NEWIMAGE(720, 1024, 32)
2. _CONTROLCHR OFF
3.  
4. _TITLE "String Encryption"
5. a$ = "The Ass and the Lapdog.    A Farmer one day came to the stables to see to his beasts of burden: among them was his favourite Ass, that was always well fed and often carried his master.  With the Farmer came his Lapdog, who danced about and licked his hand and frisked about as happy as could be.  The Farmer felt in his pocket, gave the Lapdog some dainty food, and sat down while he gave his orders to his servants.  The Lapdog jumped into his master's lap, and lay there blinking while the Farmer stroked his ears.  The Ass, seeing this, broke loose from his halter and commenced prancing about in imitation of the Lapdog.  The Farmer could not hold his sides with laughter, so the Ass went up to him, and putting his feet upon the Farmer's shoulder attempted to climb into his lap.  The Farmer's servants rushed up with sticks and pitchforks and soon taught the Ass that Clumsy jesting is no joke."
6. PRINT a$
7. SLEEP
8.  
9. RANDOMIZE USING -1973 'a nice random seed
10. FOR i = 1 TO LEN(a$)
11.     b$ = b$ + CHR$(ASC(a$, i) XOR INT(RND * 255))
12. NEXT
13. PRINT
14. PRINT "-----------------------------------------------------------------------------------------"
15. PRINT
16. PRINT b$
17. SLEEP
18.  
19. RANDOMIZE USING -1973 'the same seed as above nice random seed
20. FOR i = 1 TO LEN(b$)
21.     c$ = c$ + CHR$(ASC(b$, i) XOR INT(RND * 255))
22. NEXT
23. PRINT
24. PRINT "-----------------------------------------------------------------------------------------"
25. PRINT
26. PRINT c$
27. SLEEP

[SMcNeill]

Personally, an even easier way I find to encrypt things is to just do something really simple with a compressed file:

Code: QB64: [Select]

1. SCREEN _NEWIMAGE(1024, 720, 32)
2. _CONTROLCHR OFF
3.  
4. _TITLE "String Encryption"
5. a$ = "The Ass and the Lapdog.    A Farmer one day came to the stables to see to his beasts of burden: among them was his favourite Ass, that was always well fed and often carried his master.  With the Farmer came his Lapdog, who danced about and licked his hand and frisked about as happy as could be.  The Farmer felt in his pocket, gave the Lapdog some dainty food, and sat down while he gave his orders to his servants.  The Lapdog jumped into his master's lap, and lay there blinking while the Farmer stroked his ears.  The Ass, seeing this, broke loose from his halter and commenced prancing about in imitation of the Lapdog.  The Farmer could not hold his sides with laughter, so the Ass went up to him, and putting his feet upon the Farmer's shoulder attempted to climb into his lap.  The Farmer's servants rushed up with sticks and pitchforks and soon taught the Ass that Clumsy jesting is no joke."
6. b$ = _DEFLATE$(a$)
7. FOR i = LEN(b$) TO 1 STEP -1
8.     c$ = c$ + MID$(b$, i, 1) 'A simple reverse order of the compressed file, to "encrypt it".
9. NEXT
10. PRINT a$
11. PRINT
12. PRINT "--------------------------------"
13. PRINT
14. PRINT b$
15. PRINT
16. PRINT "--------------------------------"
17. PRINT
18. PRINT c$
19.  
20. d$ = _INFLATE$(c$)
21. PRINT
22. PRINT "--------------------------------"
23. PRINT
24. PRINT d$; "Notice this is blank?  It's not a valid compressed file, so it fails on decompression and returns nothing."
25. FOR i = LEN(c$) TO 1 STEP -1
26.     e$ = e$ + MID$(c$, i, 1) 'A simple reverse order of the compressed file, to "decrypt it".
27. NEXT
28. f$ = _INFLATE$(e$)
29. PRINT
30. PRINT "--------------------------------"
31. PRINT
32. PRINT f$

All I'm doing here is compressing my string, and then reversing it.  That's it, and yet, it'd be hard as heck for anyone to sort out what type of file it is, or what the contents are.  You could NOT each byte, or XOR each byte, or do whatever the heck else you want to do with it, but unless the other person knows the same process, they're not going to have an easy time decoding whatever the contents are.

File encryption/decryption doesn't have to be that hard of a process to implement -- it's just BASIC programming, in the end.  :P

[bplus]

Thanks @SMcNeill

Your simple examples put the kibosh on the effort I was struggling with today. ;-))

Those 2 examples are simple. So that's how to do XOR! Cool.

[NOVARSEG]

I just put your code in the IDE, no offense but it's a mess, which tells me you hadn't tried it yourself.

Not good.

Not only should we not try it on important files, we shouldn't try it at all, not safe.
But we couldn't run this one, as is, so there's that ;-))

I expected it to have syntax errors but it is essentially correct.
I don't have any IDE at present

One error was
CLOSE 1
it should be CLOSE #1

OK I should try out my own code.

SMcNeill

compression method that works too

[bplus]

I don't have any IDE at present

@NOVARSEG   sorry to read, what's up with that?

[bplus]

Here is a peak what the IDE is red-lining, I commented out the first to get to 2nd... and repeat comment 2nd to get 3rd...

The middle section was left clear but I confess I don't understand what it's doing.

Code: QB64: [Select]

1.  
2. DIM string1(16384) AS STRING
3. DIM string2(16384) AS STRING
4. DIM LFILE AS _UNSIGNED LONG
5. DIM FPOS AS _UNSIGNED LONG
6. DIM NBYTES AS _UNSIGNED LONG
7. FPOS = 1
8. '''''''''' string1 is an array ' string1 = string$(16384,"a") 'string1 could randomized for better security
9. '''''''''' missing quotes '' OPEN TEST.TXT FOR BINARY AS #1
10.  
11. LFILE = LOF(1)
12.  
13. DO
14.     IF LFILE = 0 THEN EXIT DO
15.  
16.     IF LFILE < 16384 THEN
17.         GET #1, , string2(LFILE) 'file read
18.         FPOS = FPOS + LFILE 'FPOS = file position after GET
19.         NBYTES = LFILE
20.         GOSUB XORstring2 'encrypt or decrypt
21.         SEEK 1, FPOS - LFILE 'adjust file pointer
22.         PUT #1, , string2(LFILE) 'file write
23.         LFILE = 0
24.     END IF
25.  
26.     IF LFILE >= 16384 THEN
27.         GET #1, , string2(16384) 'file read
28.         FPOS = FPOS + 16384 'FPOS = file position after GET
29.         NBYTES = 16384
30.         GOSUB XORstring2 'encrypt or decrypt
31.         SEEK 1, FPOS - 16384 'adjust file pointer
32.         PUT #1, , string2(16384) 'file write
33.         LFILE = LFILE - 16384
34.     END IF
35.  
36. LOOP
37. CLOSE 1
38. END
39.  
40. XORstring2:
41. FOR x% = 1 TO NBYTES
42.     ''''''''''''''string1 is array '''''''''''''''''a$ = MID$(string1),x%,1)
43.     ''''''''''''' string2 is array '''''''''''''''''b$ = MID$(string2),x%,1)
44.     ''''''''''''' XOR need numbers '''''''''''''''''b$ xor a$
45.     ''''''''''''' string2 is array '''''''''''''''''MID$(string2),x%,1) = b$
46. NEXT x%
47. RETURN
48.  
49.  

[SMcNeill]

The middle section was left clear but I confess I don't understand what it's doing.

What the middle is an attempt to do, is to read a file in chunks of data of 16384 bytes (though I have no idea why such a number was chosen), XOR those chunks, and then put them back into the file.

OPEN “TEMP.TXT” FOR BINARY AS #1
l = LOF(1)
a$ = SPACE$(l)
GET #1, 1, a$
FOR i = 1 TO l
   b$ = b$ + CHR$(ASC(a$,i) XOR 97)
NEXT
PUT #1, 1, b$
CLOSE

There’s the exact same program, simplified down for usability and understandability.

Since string1 = string$(16384,"a"), it’s nothing more than a repetitive set of “a” characters, which is CHR$(97).  Since XOR works with numbers, I simply hardcoded that XOR 97 above and was done with it.

Read a file into a string.
XOR the contents of the string.
Write the string back to “encrypt” the file.

It’s that simple, unless folks just want to try and complicate things to obfuscate their code/process.