MiMe (Base64) and UUE Encoding

Purpose

Encode and Decode a memory block or string into Email data MiMe (Base64) and UUE formats.

Syntax

uustring$ = MemToUU (addr%, len%)
len% = UUToMem(uustring$, addr%)
uustring$ = UUEncode(string$)
string$ = UUDecode(uustring$)

mimestring$ = MemToMiMe (addr%, len%)
len% = MiMeToMem(mimestring$, addr%)
mimestring$ = MiMeEncode(string$)
string$ = MiMeDecode(mimestring$)

codedstring$ = _MiMeEncode(string$)
string$ = _MiMeDecode(codedstring$)

Description

All the above functions convert either memory blocks or GFABASIC strings into an encoded format and then convert them back to their original form.

UUE (Unix-to-Unix Encoding) was developed in 1980 while MIME (Multipurpose Internet Mail Extensions) was first developed in 1987 and has been built on since then; both are binary-to-text encoding formats and are used in the transmission of data, the former from computer to computer then early email data, the second predominately for email data. The MIME format supported by GFABASIC32 is padded Base64 (to make it 'unpadded', simply remove all trailing '=' characters from the end of the encoded string).

GFABASIC32 provides two methods of encoding and decoding, direct from a memory block and from a GFABASIC32 string:

• Encoding/Decoding using memory blocks:
  This method is useful if you wish to encode a picture, music or general data file. Encoding is done using the MemTo... function with the address and length of the data file being passed as arguments and the encoded string being returned, while decoding uses the ...ToMem functions which take the encoded string and address of the memory block to which the data should be read and returns the length of the decoded data block. NOTE: as, in many situations, you will need to obtain the length of the decoded string before creating the memory block, this value can be retrieved by using the ...ToMem function and setting the address value to zero.
  
  Example: Show
  
  

  // Courtesy of James Gaite

  // Open two windows

  OpenW 1, 0, 0, 400, 300 : Win_1.AutoRedraw = 1 : Win_1.Caption = "Original file"

  OpenW 2, 0, 350, 400, 300 : Win_2.AutoRedraw = 1 : Win_2.Caption = "Decoded file"

  // Find the picture file

  Local d$ = GetSetting("\\HKEY_CLASSES_ROOT\g32File\shell\open\command", , ""), p1 As Int32

  If Left(d$, 1) = #34 Then d$ = Mid(d$, 2)

  p1 = RInStr(d$, "\") : If p1 <> 0 Then d$ = Left(d$, p1 - 1)

  d$ = d$ & "\..\samples\bitmaps\splash.bmp"

  If Not Exist(d$) Then _

  MsgBox("Can not locate Splash.bmp file"#13#10#13#10"Please manually place it in the GFABASIC32\Samples\Bitmaps folder and try again.")  : End

  // Create Memory Block and load in the picture

  Local addr%, le% = FileLen(d$), pic As Picture, uu$

  addr% = mAlloc(le%)

  BLoad d$, addr%

  Debug.Print "Length of original string:    "; le%

  // Assign picture to Picture object and draw in Window 1

  Set pic = LoadPicture(d$)

  Output = Win_1 : PaintPicture pic, 10, 10

  // Convert the picture data into a UU-encoded string

  uu$ = MemToUU(addr%, le%)

  Debug.Print "Length of UUE encoded string: "; Len(uu$)

  // Free old memory block...

  ~mFree(addr%)

  // ...then call ...ToMem routine first to get decoded length (addr% set to 0 to prevent decoding)...

  le% = UUToMem(uu$, 0)

  Debug.Print "Length of UUE decoded string: "; le%

  // ...create new data block...

  addr% = mAlloc(le%)

  // ...then decode UU-encoded string into new data block...

  le% = UUToMem(uu$, addr%)

  // ...and save in temporary file

  BSave App.Path & "\temp.bmp", addr%, le%

  // Load decoded picture into Window 2

  Set pic = LoadPicture(App.Path & "\temp.bmp")

  Output = Win_2 : PaintPicture pic, 10, 10

  Debug.Show : Debug.Left = PixelsToTwipX(450) : Debug.Top = 0

  Win_1.SetFocus : Win_2.SetFocus

  Do : Sleep : Until IsNothing(Win_1) Or IsNothing(Win_2)

  CloseW 2 : CloseW 1 : Debug.Hide

  // Free memory block and delete temporary file

  ~mFree(addr%)

  Kill App.Path & "\temp.bmp"

  
  


• Encoding/Decoding using GFABASIC strings
  This method can also be used to encode a picture or data file as shown in the example below, but can also be used for text. Encoding is done using the ...Encode functions which take the plain string as an argument and return the encoded string, while decoding is achieved using the ...Decode functions which take the encoded string as an argument and return the decoded string.
  
  Example: Show
  
  

  // Courtesy of James Gaite

  // Open a window and draw a red, filled circle

  OpenW 1, 0, 0, 400, 300 : Win_1.AutoRedraw = 1

  Color 255 : PCircle 100, 100, 50 : ~DoEvents

  // Capture the circle and store in a string

  Local a$, r$, uu$ : Get 50, 50, 150, 150, a$

  Debug.Print "Length of original string:    "; Len(a$)

  // Call the ...Encode function to encode the string...

  uu$ = uuencode(a$)

  Debug.Print "Length of UUE encoded string: "; Len(uu$)

  // ...and then call the ...Decode function again to decode

  r$ = uudecode(uu$)

  Debug.Print "Length of UUE decoded string: "; Len(r$)

  // Draw the decoded picture next to the original

  Put 200, 50, r$

  Debug.Show : Debug.Left = PixelsToTwipX(450) : Debug.Top = 0

  Win_1.SetFocus

  Do : Sleep : Until Win_1 Is Nothing

  Debug.Hide

  
  

Remarks

_MiMeEncode and _MiMeDecode are odd functions as they do not have corresponding Memory block functions and they do not convert into a recognised format; whereas MIME Base64 concatenates the data to be encoded, splits it into 24-bit blocks and then further splits those into 6-bit blocks from left to right, the _MiMeEncode function splits the 24-bit blocks into 6-bit blocks working from right to left. The functions may well have been erroneous and replaced by MiMeEncode and MiMeDecode but not removed; however, more likely, they are a custom implementation to allow communication between enabled programs which, being non-standard, is harder to decipher (however, see next remark).

NOTE: UUE and MIME are encodings NOT cyphers and should not be used for the latter as they are well known and easy to reverse engineer; data encoded with _MiMeEncode would be harder to crack but not much - however, used in combination with another encoder or cypher, it would increase the security exponentially as it is a customised implementation (if indeed it is). That said, there are many far more secure cyphers available which it would be more advisable to use instead.

See Also

{Created by James Gaite; Last updated: 26/07/2020 by James Gaite}