Base 64 encoder / decoder

[NOVARSEG]

Encodes  base 256  to base 64
Decodes base 64 to base 256

The code is more of an example of the math behind base to base conversions.

The earlier version had a bug  - now corrected.

Code: QB64: [Select]

1. 'BASE 64 encoder / decoder
2.  
3. 'prints the string to be encoded
4. 'prints the encoded base 64 string
5. 'prints the decoded base 64 string
6.  
7. DIM s AS DOUBLE
8. DIM os AS DOUBLE
9. DIM a AS INTEGER
10. DIM b AS INTEGER
11. DIM c AS INTEGER
12. DIM d AS INTEGER
13. DIM e AS STRING
14. DIM f AS STRING
15. DIM g AS STRING
16. DIM h AS STRING
17. DIM string1 AS STRING
18. DIM string2 AS STRING
19. _FULLSCREEN
20.  
21. string1 = "ASCII stands for American Standard Code for Information Interchange.."
22.  
23. PRINT "STRING1 "; string1
24. PRINT
25. FOR x% = 1 TO LEN(string1) STEP 3
26.     a = ASC(MID$(string1, x%, 1))
27.     b = ASC(MID$(string1, x% + 1, 1))
28.     c = ASC(MID$(string1, x% + 2, 1))
29.  
30.  
31.     s = a * 256 ^ 2 + b * 256 + c
32.  
33.  
34.     IF s >= 64 ^ 3 THEN
35.         i = INT(s / 64 ^ 3)
36.         s = s - i * 64 ^ 3
37.         e = CHR$(i + 48)
38.     END IF
39.  
40.     IF s >= 64 ^ 2 THEN
41.         i = INT(s / 64 ^ 2)
42.         s = s - i * 64 ^ 2
43.         f = CHR$(i + 48)
44.     END IF
45.  
46.     IF s >= 64 ^ 1 THEN
47.         i = INT(s / 64 ^ 1)
48.         s = s - i * 64 ^ 1
49.         g = CHR$(i + 48)
50.     END IF
51.  
52.     IF s >= 64 ^ 0 THEN
53.         i = INT(s / 64 ^ 0)
54.         s = s - i * 64 ^ 0
55.         h = CHR$(i + 48)
56.     END IF
57.  
58.  
59.     string2 = string2 + (e + f + g + h)
60. NEXT x%
61. PRINT "STRING2 "; string2
62. PRINT
63. string1 = ""
64. '********************
65. FOR x% = 1 TO LEN(string2) STEP 4
66.     a = ASC(MID$(string2, x%, 1)) - 48
67.     b = ASC(MID$(string2, x% + 1, 1)) - 48
68.     c = ASC(MID$(string2, x% + 2, 1)) - 48
69.     d = ASC(MID$(string2, x% + 3, 1)) - 48
70.  
71.  
72.     s = a * 64 ^ 3 + b * 64 ^ 2 + c * 64 + d
73.  
74.     IF s >= 256 ^ 2 THEN
75.         i = INT(s / 256 ^ 2)
76.         s = s - i * 256 ^ 2
77.         e = CHR$(i)
78.     END IF
79.  
80.     IF s >= 256 ^ 1 THEN
81.         i = INT(s / 256 ^ 1)
82.         s = s - i * 256 ^ 1
83.         f = CHR$(i)
84.     END IF
85.  
86.     IF s >= 256 ^ 0 THEN
87.         i = INT(s / 256 ^ 0)
88.         s = s - i * 256 ^ 0
89.         g = CHR$(i)
90.     END IF
91.  
92.     string1 = string1 + (e + f + g)
93.  
94. NEXT x%
95.  
96. PRINT "STRING1 "; string1
97.  
98.  
99. END
100.  

[bplus]

What's the POINT?

Wouldn't numbers be more handy for processing?

ColorNumber~& = _RGB32(red, green, blue, alpha)

And the reverse, simple handy SUB for analyzing a color:

Code: QB64: [Select]

1. SUB cAnalysis (c AS _UNSIGNED LONG, outRed, outGrn, outBlu, outAlp)
2.     outRed = _RED32(c): outGrn = _GREEN32(c): outBlu = _BLUE32(c): outAlp = _ALPHA32(c)
3. END SUB
4.  

Demo test:

Code: QB64: [Select]

1. red = 50: green = 100: blue = 200: alpha = 100
2. ColorNumber~& = _RGBA32(red, green, blue, alpha)
3. PRINT red, green, blue, alpha, ColorNumber~&
4. cAnalysis ColorNumber~&, outR, outG, outB, outA
5. PRINT outR, outG, outB, outA
6.  
7.  
8. 'And the reverse, simple handy SUB for analyzing a color:
9.  
10. SUB cAnalysis (c AS _UNSIGNED LONG, outRed, outGrn, outBlu, outAlp)
11.     outRed = _RED32(c): outGrn = _GREEN32(c): outBlu = _BLUE32(c): outAlp = _ALPHA32(c)
12. END SUB
13.  

Convert red, green, blue, alpha to Binary, Hex, Oct....

[SMcNeill]

Here's my Base-128 converter:

Code: QB64: [Select]

1. SCREEN _NEWIMAGE(640, 480, 32)
2.  
3. a$ = "  The Old Woman and the Wine-Jar" + CHR$(10)
4. a$ = a$ + "AN OLD WOMAN found an empty jar which had lately been full of prime old wine and which still retained the fragrant smell of its former contents.  She greedily placed it several times to her nose, and drawing it backwards and forwards said, 'O most delicious! How nice must the Wine itself have been, when it leaves behind in the very vessel which contained it so sweet a perfume!'" + CHR$(10)
5. a$ = a$ + "The memory of a good deed lives.     "
6.  
7. d$ = B256to128$(a$)
8. i$ = B128to256$(d$)
9. PRINT a$
10. PRINT "-----------------"
11. SLEEP
12. PRINT d$
13. PRINT "-----------------"
14. SLEEP
15. PRINT i$
16. PRINT "-----------------"
17. SLEEP
18. PRINT
19. PRINT
20. PRINT "Length of original:"; LEN(a$)
21. PRINT "Length of 128-bit DATA ready conversion:"; LEN(d$)
22. PRINT "Length of restored:"; LEN(i$)
23.  
24.  
25.  
26.  
27.  
28. FUNCTION B256to128$ (temp$)
29.     text$ = _DEFLATE$(temp$)
30.     l = 8 * LEN(text$)
31.     DIM A(1 TO l) AS _UNSIGNED _BIT, b AS _UNSIGNED _BYTE
32.     'convert the text to the 8 bit array
33.     FOR i = 1 TO LEN(text$)
34.         b = ASC(text$, i)
35.         p = (i - 1) * 8 + 1
36.         FOR j = 0 TO 7
37.             IF b AND (2 ^ j) THEN A(p + j) = 1 'ELSE A(p + j) = 0
38.         NEXT
39.     NEXT
40.     'convert the array to 7bit strings
41.     FOR i = 1 TO l STEP 7
42.         b = 0
43.         FOR j = 6 TO 0 STEP -1
44.             IF i + j < l THEN
45.                 IF A(i + j) THEN b = b + (2 ^ j)
46.             END IF
47.         NEXT
48.         b = b + 59
49.         t$ = t$ + CHR$(b)
50.  
51.     NEXT
52.     B256to128 = t$
53. END FUNCTION
54.  
55. FUNCTION B128to256$ (text$)
56.     l = 7 * LEN(text$)
57.     DIM A(1 TO l) AS _UNSIGNED _BIT, b AS _UNSIGNED _BYTE
58.     'convert the text to the 8 bit array
59.     FOR i = 1 TO LEN(text$)
60.         b = ASC(text$, i) - 59
61.         FOR j = 0 TO 6
62.             p = p + 1: IF p > l THEN EXIT FOR
63.             IF b AND (2 ^ j) THEN A(p) = 1 ELSE A(p) = 0
64.         NEXT
65.     NEXT
66.     'convert the array to 8bit strings
67.     p = 0
68.     FOR i = 1 TO l STEP 8
69.         b = 0
70.         FOR j = 0 TO 7
71.             p = p + 1
72.             IF p > l THEN EXIT FOR
73.             IF A(p) THEN b = b + (2 ^ j)
74.         NEXT
75.         t$ = t$ + CHR$(b)
76.     NEXT
77.     B128to256 = _INFLATE$(t$)
78. END FUNCTION

With this, I can take file assets such as images, sounds, or memblocks, and I can convert them down from BASE-256 characters to compressed BASE-128 characters, so that they'll paste into a DATA statement without any invalid characters causing problems.

For example, we can't have this in QB64:

DATA He said, "Foobar on your toolbar."

Those quotes and commas are problematic, as would a CHR$(0) or ":" be.  Not all 256 characters play nice with DATA statements, so I convert my data down to 128-bytes and place them into a program instead. 

Note: Routines above haven't been optimized for speed, so they may take a few seconds to convert and restore your data, in the case of large image or sound files.  I should honestly fix that sometime soon, but since I usually only use these routines for small assets (such as storing internal data for such things such as character information), it's never been too much of an issue for me.  Just be aware:  Large files can take a while to process with this method -- especially on an older, slower machine.

[NOVARSEG]

with base 256 to base 64 conversion, it will  require 4 base 64 characters to encode 3 bytes.

with base 256 to base 128 conversion, it will require 4 base 128 characters to encode 3 bytes.

4 characters are required for both methods

base 256 to base 64 conversion is exactly efficient because 256^3 = 64^4

Any encoded characters like "," or quotes, can be mapped to other characters which is much easier since there are only 64 characters in the encoding set.

[SMcNeill]

with base 256 to base 64 conversion, it will  require 4 base 64 characters to encode 3 bytes.

with base 256 to base 128 conversion, it will require 4 base 128 characters to encode 3 bytes.

4 characters are required for both methods

base 256 to base 64 conversion is exactly efficient because 256^3 = 64^4

Any encoded characters like "," or quotes, can be mapped to other characters which is much easier since there are only 64 characters in the encoding set.

Base 64 lets you pack 6 bits of data per character.
Base 128 lets you pack 7 bits of data per character.

So 7 bytes of ASCII data is 56-BITS.

In base-64, you'll need 56/6 = 10 characters to hold your data.  (Round up, as you don't have fractional characters.)

In base-128, you'll need 56/7 = 8 characters to hold your data. 

It's simple to see how base-128 packs more data into 7-bits than base-64 can pack into 6-bits.

How often are you converting ONLY 3 bytes?  Why not convert a whole row of pixels at once?  Or the whole screen?  No need to do pixel by pixel, when you can do image by image.

[NOVARSEG]

SMcNeill

Hi
In the previous example I'm processing 3 bytes at a time.

For longer strings say 21 bytes * 8 = 168 bits

base 64 encoding would require 28 characters

Putting the 21 bytes into 7 bit bytes would require  only 24 characters

So that is 14.2% smaller encoding for the 7 bit method.

***************
In a convertor that Dav posted the encoded data looks to be base 64. Here is a bit of code from his convertor.

   

A$ = A$ + "8d;ai7=B`OhkhbAWZm^?Fbe6f0W?h7feD]G466?ShkeZZW3K;QCaWihI9W;b"
    A$ = A$ + "m7>F^WijPf?n<[cniJbW=]JNo=`efa5IkHO:\:hK`cP[1WSWQlL;oH2edC1C"
    A$ = A$ + "RWe`X`^Ah<df0J?9fHHG>Uf:aCK9X=SfEH9oghnoIT6[dl==i<0]513JdFZF"
    A$ = A$ + "J[dL\g7hoVf;;GYSbeoo[Y#?aO#e;iaGn9YJgl`V>EKUKf^17RH4R69RI0a3"
    A$ = A$ + "H\V;AOG;C;FShWNlA?7?O^oJcanNNR=IRbe6ZEii?g0BFQ6TLg9jEnYO__Ul"
    A$ = A$ + "gn7mk:O_?ok;OQGlnb[Om;:_be?_l_jCoZbgi;nITk<aPfkdn?oI9;MJ?SaW"
    A$ = A$ + "Xo1n;K6coLUIm\CAVcDWZ\\i?OIQcIfR?;HnbbFlRlDlI9b9>jQTSOT38[Ni"
    A$ = A$ + ";FFa2V[\YE^2eN[E9Kc_EJfd6PZKJk:_Jo[OEbagF0VV2G<c;#]W>g4>Q5cK"
    A$ = A$ + "\IRo3Q]0Wa]=n<[CaC<g?VIK5U2lVS`XYiYm14eGQUh\KS2eOMjUH9n?1MGH"
    A$ = A$ + "38<#HB=DXfnH9I;iYJb8_3Yn1e=XnbPeGaTnN9Ge>WJb#]W9g<dg=EKLR?:k"
    A$ = A$ + "H;8fCJea:9aH\SSmAMdRC8JS=DJBaJJJZ;kd\j`lIHMiYf7Q=<dFNmh_jdRc"
    A$ = A$ + "N_7MED7ZV<CdhB`Thc`ZQiRo\QMbkEh?9>g3DGijcg`<o9ae0^XSS`faGC\M"

The encoded bytes range from ASC 48  "0"  to ASC 111 "o".  111 - 48  = 63 (64 characters). In that range, the comma and quotes are avoided.

However, the base 128 encoding packs in more data.

[SMcNeill]

If you're curious, here's where Petr and I had a nice discussion over Base64 encoding/decoding: https://www.qb64.org/forum/index.php?topic=2017.msg112422#msg112422

[NOVARSEG]

I just fixed major bugs in my code up top.  It works now.

I read the link you posted. 

 7 bytes = 8  (7 bit) bytes Ok I will try that.

[NOVARSEG]

Here is a  base 256 to base 128 encoder.
Does not decode yet.   Encodes 7 bytes at a time.

Code: QB64: [Select]

1.  'BASE 128 encoder
2.  
3. DIM b8, b7, b6, b5, b4, b3, b2, b1 AS INTEGER
4.  
5. DIM s8 AS STRING
6. DIM s7 AS STRING
7. DIM s6 AS STRING
8. DIM s5 AS STRING
9. DIM s4 AS STRING
10. DIM s3 AS STRING
11. DIM s2 AS STRING
12. DIM s1 AS STRING
13.  
14. DIM n AS INTEGER
15. DIM string1 AS STRING 'input string
16. DIM string2 AS STRING 'output string
17. '
18. string1 = "ASCII stands for American Standard Code for Information Interchange..."
19. PRINT LEN(string1) 'must be a multiple of 7
20.  
21. PRINT "STRING1 "; string1
22. PRINT
23.  
24. n = 45 'offset into ASCII table
25.  
26.  
27. FOR x% = 1 TO LEN(string1) STEP 7
28.     b7 = ASC(MID$(string1, x%, 1))
29.     b6 = ASC(MID$(string1, x% + 1, 1))
30.     b5 = ASC(MID$(string1, x% + 2, 1))
31.     b4 = ASC(MID$(string1, x% + 3, 1))
32.     b3 = ASC(MID$(string1, x% + 4, 1))
33.     b2 = ASC(MID$(string1, x% + 5, 1))
34.     b1 = ASC(MID$(string1, x% + 6, 1))
35.  
36.  
37.     IF b7 >= 128 THEN
38.         b8 = 64
39.         b7 = b7 - 128
40.     END IF
41.     s7 = CHR$(b7 + n)
42.  
43.     IF b6 >= 128 THEN
44.         b8 = b8 + 32
45.         b6 = b6 - 128
46.     END IF
47.     s6 = CHR$(b6 + n)
48.  
49.     IF b5 >= 128 THEN
50.         b8 = b8 + 16
51.         b5 = b5 - 128
52.     END IF
53.     s5 = CHR$(b5 + n)
54.  
55.     IF b4 >= 128 THEN
56.         b8 = b8 + 8
57.         b4 = b4 - 128
58.     END IF
59.     s4 = CHR$(b4 + n)
60.  
61.     IF b3 >= 128 THEN
62.         b8 = b8 + 4
63.         b3 = b3 - 128
64.     END IF
65.     s3 = CHR$(b3 + n)
66.  
67.     IF b2 >= 128 THEN
68.         b8 = b8 + 2
69.         b2 = b2 - 128
70.     END IF
71.     s2 = CHR$(b2 + n)
72.  
73.     IF b1 >= 128 THEN
74.         b8 = b8 + 1
75.         b1 = b1 - 128
76.     END IF
77.     s1 = CHR$(b1 + n)
78.  
79.     s8 = CHR$(b8+n)
80.    
81.     string2 = string2 + (s8 + s7 + s6 + s5 + s4 + s3 + s2 + s1)
82. NEXT x%
83.  
84.  
85. PRINT string2
86.  
87. END
88.  

[SpriggsySpriggs]

@NOVARSEG

My API collection has WinAPI code for encoding and decoding in Base 64. Feel free to check it out.

[SMcNeill]

@NOVARSEG

My API collection has WinAPI code for encoding and decoding in Base 64. Feel free to check it out.

@SpriggsySpriggs -- I was looking at your encoder/decoder...  Are you certain you need to add a CHR$(0) to the code?

        encode = encode + CHR$(0)

This isn't a null-terminated C-function; you have to specify the length of the string for it to work properly.  As it is, you're adding characters to your conversion routines, as below:

Code: QB64: [Select]

1. OPTION _EXPLICIT
2.  
3. DIM encode AS STRING
4. PRINT "My name is Inigo Montoya", LEN("My name is Inigo Montoya")
5. encode = encodeBase64("My name is Inigo Montoya")
6.  
7. PRINT encode, LEN(encode)
8.  
9. DIM decode AS STRING
10. decode = decodeBase64(encode)
11.  
12. PRINT decode, LEN(decode)
13.  
14.  
15. $IF WIN THEN
16.     'DECLARE LIBRARY ".\pipecom"
17.     '    FUNCTION pipecom$ (cmd AS STRING)
18.     'END DECLARE
19.     'FUNCTION encodeBase64$ (encode AS STRING)
20.     '    DIM encoded AS STRING
21.     '    DIM encodefile AS INTEGER
22.     '    encodefile = FREEFILE
23.     '    OPEN "3nc0deb64" FOR OUTPUT AS #encodefile
24.     '    PRINT #encodefile, encode
25.     '    CLOSE #encodefile
26.     '    encoded = pipecom("certutil -encode 3nc0deb64 3nc0dedb64 && type 3nc0dedb64 && del 3nc0dedb64 && del 3nc0deb64")
27.     '    encoded = MID$(encoded, INSTR(encoded, "-----BEGIN CERTIFICATE-----") + LEN("-----BEGIN CERTIFICATE-----") + 1)
28.     '    encoded = MID$(encoded, 1, INSTR(encoded, "-----END CERTIFICATE-----") - 2)
29.     '    encodeBase64 = encoded
30.     'END FUNCTION
31.  
32.     'FUNCTION decodeBase64$ (decode AS STRING)
33.     '    DIM decoded AS STRING
34.     '    DIM decodefile AS INTEGER
35.     '    decodefile = FREEFILE
36.     '    OPEN "d3c0deb64" FOR OUTPUT AS #decodefile
37.     '    PRINT #decodefile, decode
38.     '    CLOSE #decodefile
39.     '    decoded = pipecom("certutil -decode d3c0deb64 d3c0dedb64 && type d3c0dedb64 && del d3c0deb64 && del d3c0dedb64")
40.     '    decoded = MID$(decoded, _INSTRREV(decoded, "successfully.") + 1 + LEN("successfully."))
41.     '    decoded = MID$(decoded, 1, LEN(decoded) - 1)
42.     '    decodeBase64 = decoded
43.     'END FUNCTION
44.  
45.     DECLARE DYNAMIC LIBRARY "Crypt32"
46.         FUNCTION CryptBinaryToString%% ALIAS CryptBinaryToStringA (BYVAL pbBinary AS _OFFSET, BYVAL cbBinary AS LONG, BYVAL dwFlags AS LONG, BYVAL pszString AS _OFFSET, BYVAL pcchString AS _OFFSET)
47.         FUNCTION CryptStringToBinary%% ALIAS CryptStringToBinaryA (BYVAL pszString AS _OFFSET, BYVAL cchString AS LONG, BYVAL dwFlags AS LONG, BYVAL pbBinary AS _OFFSET, BYVAL pcbBinary AS _OFFSET, BYVAL pdwSkip AS _OFFSET, BYVAL pdwFlags AS _OFFSET)
48.     END DECLARE
49.  
50.     FUNCTION encodeBase64$ (encode AS STRING)
51.         CONST CRYPT_STRING_NOCRLF = &H40000000
52.         CONST CRYPT_STRING_BASE64 = &H00000001
53.  
54.         DIM a AS _BYTE
55.         DIM lengthencode AS LONG
56.         DIM encoded AS STRING
57.         DIM lengthencoded AS LONG
58.  
59.         encode = encode + CHR$(0)
60.         lengthencode = LEN(encode)
61.  
62.         a = CryptBinaryToString(_OFFSET(encode), lengthencode, CRYPT_STRING_BASE64 OR CRYPT_STRING_NOCRLF, 0, _OFFSET(lengthencoded))
63.         'Calculate buffer length
64.         IF a <> 0 THEN
65.             encoded = SPACE$(lengthencoded)
66.         ELSE
67.             encodeBase64 = ""
68.             EXIT FUNCTION
69.         END IF
70.         a = CryptBinaryToString(_OFFSET(encode), lengthencode, CRYPT_STRING_BASE64 OR CRYPT_STRING_NOCRLF, _OFFSET(encoded), _OFFSET(lengthencoded))
71.         'Acual conversion
72.         IF a <> 0 THEN
73.             encodeBase64 = encoded
74.         ELSE
75.             encodeBase64 = ""
76.         END IF
77.     END FUNCTION
78.  
79.     FUNCTION decodeBase64$ (decode AS STRING)
80.         CONST CRYPT_STRING_BASE64_ANY = &H00000006
81.  
82.         DIM a AS _BYTE
83.         DIM lengthdecode AS LONG
84.         DIM decoded AS STRING
85.         DIM lengthdecoded AS LONG
86.  
87.         decode = decode + CHR$(0)
88.         lengthdecode = LEN(decode) - 1
89.         a = CryptStringToBinary(_OFFSET(decode), lengthdecode, CRYPT_STRING_BASE64_ANY, 0, _OFFSET(lengthdecoded), 0, 0)
90.         'Calculate buffer length
91.         IF a <> 0 THEN
92.             decoded = SPACE$(lengthdecoded)
93.         ELSE
94.             decodeBase64 = ""
95.             EXIT FUNCTION
96.         END IF
97.         a = CryptStringToBinary(_OFFSET(decode), lengthdecode, CRYPT_STRING_BASE64_ANY, _OFFSET(decoded), _OFFSET(lengthdecoded), 0, 0)
98.         'Actual conversion
99.         IF a <> 0 THEN
100.             decodeBase64 = decoded
101.         ELSE
102.             decodeBase64 = ""
103.         END IF
104.     END FUNCTION
105. $ELSE
106.     DECLARE LIBRARY "./pipecom"
107.     FUNCTION pipecom$ (cmd AS STRING)
108.     END DECLARE
109.  
110.     FUNCTION encodeBase64$ (encode AS STRING)
111.     DIM encoded AS STRING
112.     DIM encodefile AS INTEGER
113.     encodefile = FREEFILE
114.     OPEN "3nc0deb64" FOR OUTPUT AS #encodefile
115.     PRINT #encodefile, encode
116.     CLOSE #encodefile
117.     encoded = pipecom("base64 3nc0deb64")
118.     KILL "3nc0deb64"
119.     encodeBase64 = MID$(encoded, 1, LEN(encoded) - 1)
120.     END FUNCTION
121.  
122.     FUNCTION decodeBase64$ (decode AS STRING)
123.     DIM decoded AS STRING
124.     DIM decodefile AS INTEGER
125.     decodefile = FREEFILE
126.     OPEN "d3c0deb64" FOR OUTPUT AS #decodefile
127.     PRINT #decodefile, decode
128.     CLOSE #decodefile
129.     decoded = pipecom("base64 -d d3c0deb64")
130.     KILL "d3c0deb64"
131.     decodeBase64 = decoded
132.     END FUNCTION
133. $END IF

If you notice, you've tacked a stray CHR$(0) onto the end of the decoded results. 

[SpriggsySpriggs]

@SMcNeill

https://docs.microsoft.com/en-us/windows/win32/api/wincrypt/nf-wincrypt-cryptstringtobinarya

What I should have done instead is make the length argument be zero or just not do a CHR$(0). I think there might have been issues and that's why I did that but feel free to comment that one line out.

[SpriggsySpriggs]

@SMcNeill

Yeah, I just got used to having to do null-terminated strings. I'll fix the code in the zip folder momentarily.

 

Code: QB64: [Select]

1. OPTION _EXPLICIT
2. $CONSOLE:ONLY
3. _DEST _CONSOLE
4. 'DIM encode AS STRING
5. 'encode = encodeBase64("My name is Inigo Montoya")
6. DIM encoded AS STRING
7. 'PRINT encode
8. DO
9.     LINE INPUT "Input Base64 String: ", encoded
10. LOOP UNTIL encoded <> ""
11. DIM decode AS STRING
12. decode = decodeBase64(encoded)
13.  
14. PRINT decode
15. SLEEP
16.  
17. $IF WIN THEN
18.     'DECLARE LIBRARY ".\pipecom"
19.     '    FUNCTION pipecom$ (cmd AS STRING)
20.     'END DECLARE
21.     'FUNCTION encodeBase64$ (encode AS STRING)
22.     '    DIM encoded AS STRING
23.     '    DIM encodefile AS INTEGER
24.     '    encodefile = FREEFILE
25.     '    OPEN "3nc0deb64" FOR OUTPUT AS #encodefile
26.     '    PRINT #encodefile, encode
27.     '    CLOSE #encodefile
28.     '    encoded = pipecom("certutil -encode 3nc0deb64 3nc0dedb64 && type 3nc0dedb64 && del 3nc0dedb64 && del 3nc0deb64")
29.     '    encoded = MID$(encoded, INSTR(encoded, "-----BEGIN CERTIFICATE-----") + LEN("-----BEGIN CERTIFICATE-----") + 1)
30.     '    encoded = MID$(encoded, 1, INSTR(encoded, "-----END CERTIFICATE-----") - 2)
31.     '    encodeBase64 = encoded
32.     'END FUNCTION
33.  
34.     'FUNCTION decodeBase64$ (decode AS STRING)
35.     '    DIM decoded AS STRING
36.     '    DIM decodefile AS INTEGER
37.     '    decodefile = FREEFILE
38.     '    OPEN "d3c0deb64" FOR OUTPUT AS #decodefile
39.     '    PRINT #decodefile, decode
40.     '    CLOSE #decodefile
41.     '    decoded = pipecom("certutil -decode d3c0deb64 d3c0dedb64 && type d3c0dedb64 && del d3c0deb64 && del d3c0dedb64")
42.     '    decoded = MID$(decoded, _INSTRREV(decoded, "successfully.") + 1 + LEN("successfully."))
43.     '    decoded = MID$(decoded, 1, LEN(decoded) - 1)
44.     '    decodeBase64 = decoded
45.     'END FUNCTION
46.  
47.     DECLARE DYNAMIC LIBRARY "Crypt32"
48.         FUNCTION CryptBinaryToString%% ALIAS CryptBinaryToStringA (BYVAL pbBinary AS _OFFSET, BYVAL cbBinary AS LONG, BYVAL dwFlags AS LONG, BYVAL pszString AS _OFFSET, BYVAL pcchString AS _OFFSET)
49.         FUNCTION CryptStringToBinary%% ALIAS CryptStringToBinaryA (BYVAL pszString AS _OFFSET, BYVAL cchString AS LONG, BYVAL dwFlags AS LONG, BYVAL pbBinary AS _OFFSET, BYVAL pcbBinary AS _OFFSET, BYVAL pdwSkip AS _OFFSET, BYVAL pdwFlags AS _OFFSET)
50.     END DECLARE
51.  
52.     FUNCTION encodeBase64$ (encode AS STRING)
53.         CONST CRYPT_STRING_NOCRLF = &H40000000
54.         CONST CRYPT_STRING_BASE64 = &H00000001
55.  
56.         DIM a AS _BYTE
57.         DIM lengthencode AS LONG
58.         DIM encoded AS STRING
59.         DIM lengthencoded AS LONG
60.  
61.         lengthencode = LEN(encode)
62.  
63.         a = CryptBinaryToString(_OFFSET(encode), lengthencode, CRYPT_STRING_BASE64 OR CRYPT_STRING_NOCRLF, 0, _OFFSET(lengthencoded))
64.         'Calculate buffer length
65.         IF a <> 0 THEN
66.             encoded = SPACE$(lengthencoded)
67.         ELSE
68.             encodeBase64 = ""
69.             EXIT FUNCTION
70.         END IF
71.         a = CryptBinaryToString(_OFFSET(encode), lengthencode, CRYPT_STRING_BASE64 OR CRYPT_STRING_NOCRLF, _OFFSET(encoded), _OFFSET(lengthencoded))
72.         'Acual conversion
73.         IF a <> 0 THEN
74.             encodeBase64 = encoded
75.         ELSE
76.             encodeBase64 = ""
77.         END IF
78.     END FUNCTION
79.  
80.     FUNCTION decodeBase64$ (decode AS STRING)
81.         CONST CRYPT_STRING_BASE64_ANY = &H00000006
82.  
83.         DIM a AS _BYTE
84.         DIM lengthdecode AS LONG
85.         DIM decoded AS STRING
86.         DIM lengthdecoded AS LONG
87.  
88.         lengthdecode = LEN(decode)
89.         a = CryptStringToBinary(_OFFSET(decode), lengthdecode, CRYPT_STRING_BASE64_ANY, 0, _OFFSET(lengthdecoded), 0, 0)
90.         'Calculate buffer length
91.         IF a <> 0 THEN
92.             decoded = SPACE$(lengthdecoded)
93.         ELSE
94.             decodeBase64 = ""
95.             EXIT FUNCTION
96.         END IF
97.         a = CryptStringToBinary(_OFFSET(decode), lengthdecode, CRYPT_STRING_BASE64_ANY, _OFFSET(decoded), _OFFSET(lengthdecoded), 0, 0)
98.         'Actual conversion
99.         IF a <> 0 THEN
100.             decodeBase64 = decoded
101.         ELSE
102.             decodeBase64 = ""
103.         END IF
104.     END FUNCTION
105. $ELSE
106.     DECLARE LIBRARY "./pipecom"
107.     FUNCTION pipecom$ (cmd AS STRING)
108.     END DECLARE
109.  
110.     FUNCTION encodeBase64$ (encode AS STRING)
111.     DIM encoded AS STRING
112.     DIM encodefile AS INTEGER
113.     encodefile = FREEFILE
114.     OPEN "3nc0deb64" FOR OUTPUT AS #encodefile
115.     PRINT #encodefile, encode
116.     CLOSE #encodefile
117.     encoded = pipecom("base64 3nc0deb64")
118.     KILL "3nc0deb64"
119.     encodeBase64 = MID$(encoded, 1, LEN(encoded) - 1)
120.     END FUNCTION
121.  
122.     FUNCTION decodeBase64$ (decode AS STRING)
123.     DIM decoded AS STRING
124.     DIM decodefile AS INTEGER
125.     decodefile = FREEFILE
126.     OPEN "d3c0deb64" FOR OUTPUT AS #decodefile
127.     PRINT #decodefile, decode
128.     CLOSE #decodefile
129.     decoded = pipecom("base64 -d d3c0deb64")
130.     KILL "d3c0deb64"
131.     decodeBase64 = decoded
132.     END FUNCTION
133. $END IF

[SMcNeill]

One more pointer, which might be of interest to you:  When passing pointers, you can just declare it without BYVAL.

Instead of:
  FUNCTION CryptBinaryToString%% ALIAS CryptBinaryToStringA (BYVAL pbBinary AS _OFFSET....

You can go with:
  FUNCTION CryptBinaryToString%% ALIAS CryptBinaryToStringA (pbBinary AS STRING....

Then when you call the function, instead of this:
a = CryptBinaryToString(_OFFSET(encode)....

It'd be:
a = CryptBinaryToString(encode....



It might be a trick to help simplify your libraries a bit, and cut down on some typing for you.  (Not just on strings, but all cases where pointers to something is required, rather than the actual data value itself.)

Not that what you're doing is wrong; I just thought you might not realize WHY that BYVAL is there, and what we do when it's not.  ;)

With BYVAL, we pass the value.
Without it, we pass the offset to whatever.

[SpriggsySpriggs]

@SMcNeill

Yeah, I know I can. I typically pass _OFFSETs unless it is more convenient for myself to just pass it as text rather than a variable (usually it isn't, due to the number of arguments, so I just write a wrapper that does all that B.S.). So instead of foo(_OFFSET(stringvalue$)) I would just do foo("this is my string"). I try to stay consistent with my code. Since I've done almost all of my code using _OFFSET rather than passing the string itself I just go ahead and keep using _OFFSETs unless absolutely necessary. I don't mind the extra typing. I passed this variable as a string for this particular function (different topic) because it didn't require a null character at the end and would be too much work for a 3 character string.

Code: QB64: [Select]

1. GetDiskFreeSpace("L:\", 0, 0, _OFFSET(totalFreeBytesOnDisk))

But yeah, I typically don't pass a string to a function without _OFFSET unless I pass it as plain text.