Base64 decode data: Difference between revisions

From Rosetta Code
Content added Content deleted
(Added base64Decode for SenseTalk)
Line 1,341: Line 1,341:
{{out}}
{{out}}
<pre>Is the Rosetta Code icon the same (byte for byte) encoded then decoded: TRUE</pre>
<pre>Is the Rosetta Code icon the same (byte for byte) encoded then decoded: TRUE</pre>

=={{header|SenseTalk}}==
<lang sensetalk>

put base64Decode ("VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuIC0tUGF1bCBSLkVocmxpY2g=")

end myFunc</lang>
Output:
<lang sensetalk>To err is human, but to really foul things up you need a computer. --Paul R.Ehrlich</lang>


=={{header|Sidef}}==
=={{header|Sidef}}==

Revision as of 14:46, 1 October 2021

Task
Base64 decode data
You are encouraged to solve this task according to the task description, using any language you may know.

See Base64 encode data.

Now write a program that takes the output of the Base64 encode data task as input and regenerate the original file.

When working on the VBA implementation I found several 'solutions' on the net, including one from the software maker himself, that showed output with incorrect padding. Obviously with incorrect padding in the output you can not decode correctly to the original file again.

Ada

Library: AWS

<lang Ada>with Ada.Text_IO;

with AWS.Translator;

procedure Decode_AWS is 

  Input  : constant String :=
    "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVw" &
    "IHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=";
  Result : constant String := AWS.Translator.Base64_Decode (Input);

begin 

  Ada.Text_IO.Put_Line (Input);
  Ada.Text_IO.New_Line;
  Ada.Text_IO.Put_Line (Result);

end Decode_AWS;</lang>

Output:
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=

To err is human, but to really foul things up you need a computer.
    -- Paul R. Ehrlich

Arturo

<lang rebol>text: "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="

print decode text</lang>

Output:
To err is human, but to really foul things up you need a computer.
    -- Paul R. Ehrlich

BaCon

Using the result from the Base64 encode data task as requested, but the result is abbreviated in the code below. <lang bacon>data$ = "AAABAAIAEBAAAAAAAABoBQAAJgAAACAgAAAAAAAAqAgAAI4FAAAoAAAAE.......QAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAE=" ico$ = B64DEC$(data$) BSAVE ico$ TO "favicon.ico" SIZE LEN(ico$)</lang>

Bash

Translation of: Bash

<lang bash>#! /bin/bash declare -a encodeTable=(

  1. + , - . / 0 1 2 3 4 5 6 7 8 9  :
62  -1  -1  -1  63  52  53  54  55  56  57  58  59  60  61  -1
  1. ; < = >  ? @ A B C D E F G H I J
-1  -1  -1  -1  -1  -1   0   1   2   3   4   5   6   7   8   9
  1. K L M N O P Q R S T U V W X Y Z
10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25
  1. [ \ ] ^ _ ` a b c d e f g h i j
-1  -1  -1  -1  -1  -1  26  27  28  29  30  31  32  33  34  35
  1. k l m n o p q r s t u v w x y z
36  37  38  39  40  41  42  43  44  45  46  47  48  49  50  51

) function a2b6() { 

   if [ $1 -lt 43 -o $1 -gt 122 ]
   then
       echo -1
   else
       echo ${encodeTable[$(($1-43))]}
   fi

}

function flush() { 

   for (( k=2; k>=4-CNT; k-- ))
   do
       (( b8=BUF>>(k*8)&255 ))
       printf -v HEX %x $b8
       printf \\x$HEX
   done

}

while read INPUT do 

   for (( i=0; i<${#INPUT}; i++ ))
   do
       printf -v NUM %d "'${INPUT:$i:1}"
       if (( NUM==61 ))
       then
           flush
           exit 0
       else
           DEC=$( a2b6 $NUM )
           if (( DEC>=0 ))
           then
               (( BUF|=DEC<<6*(3-CNT) ))
               if (( ++CNT==4 ))
               then
                   flush
                   (( CNT=0, BUF=0 ))
               fi
           fi
       fi
   done

done</lang>

C

Translation of: C++

<lang c>#include <stdio.h>

  1. include <stdlib.h>

typedef unsigned char ubyte; const ubyte BASE64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

int findIndex(const ubyte val) { 

   if ('A' <= val && val <= 'Z') {
       return val - 'A';
   }
   if ('a' <= val && val <= 'z') {
       return val - 'a' + 26;
   }
   if ('0' <= val && val <= '9') {
       return val - '0' + 52;
   }
   if (val == '+') {
       return 62;
   }
   if (val == '/') {
       return 63;
   }
   return -1;

}

int decode(const ubyte source[], ubyte sink[]) { 

   const size_t length = strlen(source);
   const ubyte *it = source;
   const ubyte *end = source + length;
   int acc;

   if (length % 4 != 0) {
       return 1;
   }

   while (it != end) {
       const ubyte b1 = *it++;
       const ubyte b2 = *it++;
       const ubyte b3 = *it++;         // might be the first padding byte
       const ubyte b4 = *it++;         // might be the first or second padding byte

       const int i1 = findIndex(b1);
       const int i2 = findIndex(b2);

       acc = i1 << 2;                  // six bits came from the first byte
       acc |= i2 >> 4;                 // two bits came from the first byte
       *sink++ = acc;                  // output the first byte

       if (b3 != '=') {
           const int i3 = findIndex(b3);

           acc = (i2 & 0xF) << 4;      // four bits came from the second byte
           acc += i3 >> 2;             // four bits came from the second byte
           *sink++ = acc;              // output the second byte

           if (b4 != '=') {
               const int i4 = findIndex(b4);

               acc = (i3 & 0x3) << 6;  // two bits came from the third byte
               acc |= i4;              // six bits came from the third byte
               *sink++ = acc;          // output the third byte
           }
       }
   }

   *sink = '\0';   // add the sigil for end of string
   return 0;

}

int main() { 

   ubyte data[] = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo";
   ubyte decoded[1024];

   printf("%s\n\n", data);
   decode(data, decoded);
   printf("%s\n\n", decoded);

   return 0;

}</lang>

Output:
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo

To err is human, but to really foul things up you need a computer.
    --Paul R.Ehrlich

C#

Translation of: Visual Basic .NET

<lang csharp>using System; using System.Text;

namespace Base64DecodeData { 

   class Program {
       static void Main(string[] args) {
           var data = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=";
           Console.WriteLine(data);
           Console.WriteLine();

           var decoded = Encoding.ASCII.GetString(Convert.FromBase64String(data));
           Console.WriteLine(decoded);
       }
   }

}</lang>

Output:
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=

To err is human, but to really foul things up you need a computer.
    -- Paul R. Ehrlich

C++

Works with: C++14

<lang cpp>#include <algorithm>

  1. include <iostream>
  2. include <string>
  3. include <vector>

typedef unsigned char ubyte; const auto BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

std::vector<ubyte> encode(const std::vector<ubyte>& source) { 

   auto it = source.cbegin();
   auto end = source.cend();

   std::vector<ubyte> sink;
   while (it != end) {
       auto b1 = *it++;
       int acc;

       sink.push_back(BASE64[b1 >> 2]);            // first output (first six bits from b1)

       acc = (b1 & 0x3) << 4;                      // last two bits from b1
       if (it != end) {
           auto b2 = *it++;
           acc |= (b2 >> 4);                       // first four bits from b2

           sink.push_back(BASE64[acc]);            // second output

           acc = (b2 & 0xF) << 2;                  // last four bits from b2
           if (it != end) {
               auto b3 = *it++;
               acc |= (b3 >> 6);                   // first two bits from b3

               sink.push_back(BASE64[acc]);        // third output
               sink.push_back(BASE64[b3 & 0x3F]);  // fouth output (final six bits from b3)
           } else {
               sink.push_back(BASE64[acc]);        // third output
               sink.push_back('=');                // fourth output (1 byte padding)
           }
       } else {
           sink.push_back(BASE64[acc]);            // second output
           sink.push_back('=');                    // third output (first padding byte)
           sink.push_back('=');                    // fourth output (second padding byte)
       }
   }
   return sink;

}

int findIndex(ubyte val) { 

   if ('A' <= val && val <= 'Z') {
       return val - 'A';
   }
   if ('a' <= val && val <= 'z') {
       return val - 'a' + 26;
   }
   if ('0' <= val && val <= '9') {
       return val - '0' + 52;
   }
   if ('+' == val) {
       return 62;
   }
   if ('/' == val) {
       return 63;
   }
   return -1;

}

std::vector<ubyte> decode(const std::vector<ubyte>& source) { 

   if (source.size() % 4 != 0) {
       throw new std::runtime_error("Error in size to the decode method");
   }

   auto it = source.cbegin();
   auto end = source.cend();

   std::vector<ubyte> sink;
   while (it != end) {
       auto b1 = *it++;
       auto b2 = *it++;
       auto b3 = *it++; // might be first padding byte
       auto b4 = *it++; // might be first or second padding byte

       auto i1 = findIndex(b1);
       auto i2 = findIndex(b2);
       auto acc = i1 << 2;     // six bits came from the first byte
       acc |= i2 >> 4;         // two bits came from the first byte

       sink.push_back(acc);    // output the first byte

       if (b3 != '=') {
           auto i3 = findIndex(b3);

           acc = (i2 & 0xF) << 4;  // four bits came from the second byte
           acc |= i3 >> 2;         // four bits came from the second byte

           sink.push_back(acc);    // output the second byte

           if (b4 != '=') {
               auto i4 = findIndex(b4);

               acc = (i3 & 0x3) << 6;  // two bits came from the third byte
               acc |= i4;              // six bits came from the third byte

               sink.push_back(acc);    // output the third byte
           }
       }
   }
   return sink;

}

int main() { 

   using namespace std;

   string data = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo";
   vector<ubyte> datav{ begin(data), end(data) };
   cout << data << "\n\n" << decode(datav).data() << endl;

   return 0;

}</lang>

Output:
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo

To err is human, but to really foul things up you need a computer.
    --Paul R.Ehrlich

Caché ObjectScript

USER>Write $System.Encryption.Base64Decode("VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=")
To err is human, but to really foul things up you need a computer.
                                                                      -- Paul R. Ehrlich

Clojure

<lang clojure>(defn decode [str] 

 (String. (.decode (java.util.Base64/getDecoder) str)))

(decode "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=") </lang>

Output:
"To err is human, but to really foul things up you need a computer.\n    -- Paul R. Ehrlich"

Common Lisp

Similar to the BASE64 encoding task I am using the cl-base64 library.

<lang lisp>(eval-when (:load-toplevel :compile-toplevel :execute) 

 (ql:quickload "cl-base64"))
* The package definition

(defpackage :base64-decode 

 (:use :common-lisp :cl-base64))

(in-package :base64-decode)

* The encoded data

(defvar *base64-data* 

 "AAABAAIAEBAAAAAAAABoBQAAJgAAACAgAAAAAAAAqAgAAI4FAAAoAAAAEAAAACAAAAABAAgAAAAAAEABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///wCGiYcARkhHAL/CwAAmKScAam1rAOPm5ACgo6EAV1pYABcZGADO0c8AODs5AK2wrgBzdnQA6+7sAPz//QAAAwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQBAYMBQUMBgQQEBAQEBAQBhEJDQsLDQkFBxAQEBAQBBEJEBAQEBAQEBAQEBAQEA0RDhAQEBAQEBAQEBAQEBAPCgoLEBAQEAkMDxAQEBAQEAsMEQwJAwoREQ8QERAQEAIGEAcNCAgLCwsQEBEQEA0DEBAQEBAQEBAQEBARDwQMBxAQEBAQEBAQEBAQEQMMAw8QEBAQEBAQEBAQEBEQEAgJEBAQEBAQEBAQEBAREBAEDBAQEBAQEBAQEBAQEQ4GBQgQEBAQEBAQEBAQEAQEBA8QEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAAAACAAAABAAAAAAQAIAAAAAACABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///8AfoJ/AD9BQAC+wb8A3uHfAB8iIACeoZ8AXmFfAA4SEADO0c8ArrKvAG5xbwDu8e8AT1FPAI6RkAAuMS8A5unnABcaGADW2dcANjk3AMbJxwC2ubcAZmlnAHZ5dwD2+fcApqmoAJaamACGiYcABgkHAEZJRwBWWFcAKCspAIuNjACUlJQA8vXzAOrt6wAkJyUA4uXjANrd2wAyNTMA0tXTADo9OwDKzcsAwsXDALq9uwBiZWMAam1rAKKlowBydXMACwsLAPr9+wBKTkwAGx0cAFJVUwBbXVsAgoWDAEJFQwCqrKsAmpubACsuLACztrQAe398AAsPDABYW1kAiIyJAN3e3QDBwsEASUtKALm6uQCRk5IA+fn5AO3t7QAEBwUACAsJAPz//QD09/UA8PPxACEkIgDo6+kA5OflAODk4QAwMzEA2NvZADw/PQDQ09EAREdFAMzPzQCxtLIAYGNhAGRnZQBoa2kApKelAKCjoQB0d3UAnJ+dAISHhQCMj40Afn9+AMTGxQBNUE4AUFNRALzAvQBcX10AbHBtAICDgQCYmpkADxAPAPz8/AD4/PoA9vb2AB4gHwDy8vIA8PDwADU3NgBAQ0EAv8PAAKiqqQBvc3AAcXRyAJWYlgAGBwYA7e/uAOjp6ADIycgAXl9eAKaopgCUlpUA/f//AObn5wA8PT0A0NHRABYZFwD+/v4A+/78APv7+wAgIyEA+fv5ACIlIwD3+vgA+Pj4APf39wD1+PYAKi0rAPP29AAsLy0A8/PzAPH08gDp7OoANzo4AOXo5gA7PjwA4+bkAN/i4ABDRkQA3eDeAEVIRgDb3twAR0pIANXZ1gDT1tQAUVRSAMvOzABXWlgAyczKAFlcWgDFyMYAX2JgAMHEwgBhZGIAY2ZkAGVoZgC7vrwAZ2poALm8ugBpbGoAa25sALW4tgC0t7UAdXh2AHd6eACjpqQAoaSiAIGEggCDhoQAnaCeAIWIhgCbnpwAh4qIAJmcmgCKjYsAi46MAI2QjgCSlJMAkJSRAAoLCgAKDAsAGBoZAP3+/QD8/f0A7/HwADEzMgDv8O8A7O/tAOzt7ADn6ugA3+DfANzf3QBIS0kA2dvaAExPTQBPUlAAW15cAMDDwQC9wL4AuLu5AHx/fQCnqqgAfYB+AImMigCPkpAAk5aUAA8QEAAPEhAAHiEfACEjIQD+//8A/v/+AP3//gD9/v4A/P79APv//AD7/v0A/P78APv9/AD7/PwA+/37AC4wLwD5/PoA+fv6APj7+QD4+fkA+Pn4APb69wD3+fcA9/j3APb49wDy9PMA8fPyAO/z8QDw8vEA8PHwAERGRQDu8u8A7/HvAEVHRgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIaFhenp6enphobmhYWF5osjeiRPzXvNTyR6I4uFhcYAgAEBAQEBAQEBAQEBAQEBzaKyfrsbeBu7fj0rlgEBAQCGAQEBAQEBAQEBAQHuUS14GKeh0FaaVtChCLPd1fP0AIYBAUtLS0tL4wEBgS24ozkeodSqq62rqtTTnJqvZpgAhgEBS0tLS0sBhfeuDJGEj2ccXK4sFSyuXGAIlw620QCGAQFLS0vk5OLyn7hSHeDUtnzODUyLTA2bptm+RkOWAIYBAUtLS+IB5A0Wo98/odmUR8dL5OLkSzPwjpOSjIkAhgEBS0tL4gHoljBzSRJ3VwEBAQEBAQEBAQEBAQEBhQCGAQFLS0viAYaW2R5Kxa/VhgEBAQEBAQEB4vBM8WzsAIYBAUtLS+TixvrWpcR5/7Z6AQEBAQEBAQEmPRsaKcsA5gEBAeRLS+QB45lB7TIGF7JRevvIDcpImbY3UjS1mwDlAQEB4ktLSwEBSysCgoRO0l4PB7UwOyFeOd4ACWATAO5ucSMzS0vkAYX2UbHYVuHgEERnqi4f/Mlva8OI3CcA/QTdWE3k5AEBlKQLtl29YqpA1C6rLghnZ31nfXZ0TwBQvJUxEQEBASPVIXa6183MoK7ZB1+9BwvWY6h0VyMZAFFeEmdQAQHyn8Bnr3VCAQEBk1EToClTlpDw80zqAeYAJj4lF08BhdF+L1lqUIcBAQHkM/Dwi+6G5OLi4gEB5gCYAo9oJAF7fjFbRoMBAQFL4gEBAQEBAQEBAQEBAQHpAFC3INQVmFhbZAJV6wEB5Evk5OLi4uLi4uTk5OQBAekAEUGKyRi/qhQDwU0BAeRLS0tLS0tLS0tLS0tLSwEB6QDNYQY1DmdkVKF/nWyF5EtLS0tLS0tLS0tLS0tLAQHpABFBinK4IkbYs7d+KfXj5EtLS0tLS0tLS0tLS0sBAekAmGkgLidwkgq5L69+/gEBS0tLS0tLS0tLS0tLSwEB6QAm2jyzAQEBhqxanr8kAQFLS0tLS0tLS0tLS0tLAQHpAJjaJS4FR43P2VkORssBAUtLS0tLS0tLS0tLS0sBAekAUNiEKrlFOkGrZbALIwEBS0tLS0tLS0tLS0tLSwEB6QBPwjwoMduzNh6puZ/wAeJLS0tLS0tLS0tLS0tLAQHpAPl0d6u3wDi0t36g+Evk5EtLS0tLS0tLS0tLS0sBAekAi0ykLQR0LAomkOIBAQEBAQEBAQEBAQEBAQEBAQEB6QDkAQHkbRnnAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAOaFhYbu7zPmhYWF5oaGhoaGhoaGhoaGhoaGhoaFhekA/////wAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAE="
"See BASE64-ENCODE for the origin of this
data. http://rosettacode.org/wiki/Base64_encode_data")
* The function

(defun base64-decode (&optional (data *base64-data*) (file #p"favicon-2.ico")) 

 "Returns the original FILE BASE64 encoded in DATA."
 (with-open-file (stream file :direction :output :element-type 'unsigned-byte
                         :if-exists :supersede :if-does-not-exist :create)
   (let* ((array (base64-string-to-usb8-array data))
          (len (length array)))
     (write-sequence array stream)
     (format t "Wrote ~D bytes in file ~A~%" len file))))</lang>
Output:
Wrote 3638 bytes in file favicon-2.ico

Crystal

<lang ruby>require "base64"

encoded_string = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="

decoded_string = Base64.decode_string(encoded_string) puts decoded_string</lang>

Output:
To err is human, but to really foul things up you need a computer.
    -- Paul R. Ehrlich

D

Translation of: Raku

<lang d>import std.base64; import std.stdio;

void main() { 

   auto data = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=";
   writeln(data);
   writeln;

   auto decoded = cast(char[])Base64.decode(data);
   writeln(decoded);

}</lang>

Output:
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=

To err is human, but to really foul things up you need a computer.
    -- Paul R. Ehrlich

Delphi

<lang delphi>program Base64Decoder;

{$APPTYPE CONSOLE}

uses 

 System.SysUtils, System.NetEncoding;

const 

 Src = 'VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=';

begin 

 WriteLn(Format('Source string: ' + sLineBreak + '"%s"', [Src]));
 WriteLn(Format('Decoded string: ' + sLineBreak + '"%s"', [TNetEncoding.Base64.Decode(Src)]));

end. </lang>

Output:
Source string:
"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="
Decoded string:
"To err is human, but to really foul things up you need a computer.
    -- Paul R. Ehrlich"

F#

Standard Library

<lang fsharp> open System open System.IO

let encoded = "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"

let decoded = Convert.FromBase64String encoded

File.WriteAllBytes("favicon.ico", decoded) </lang>

Output:

Rosetta Code Icon

Manual Implementation

<lang fsharp> open System open System.IO

let encoded = "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"


let decode (s: string) = 

   let chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".ToCharArray()
   let filtered = String.filter (fun c -> Array.contains c chars || c = '=') s
   let paddingSize = filtered |> String.filter ((=) '=') |> String.length
   let s = filtered.Replace('=', 'A').ToCharArray() |> Array.map int
   let ints = chars |> Array.map int
   let calc c =
       let n = [c..(c + 3)]
               |> List.sumBy (fun k -> Array.IndexOf(ints, s.[k]) <<< (18 - 6 * (k % 4)))
       [16; 8; 0]
       |> List.map (fun k -> (n >>> k) &&& 255 |> char |> string) |> List.reduce (+)
   [0..4..Array.length s - 1]
   |> List.map calc
   |> List.reduce (+)
   |> fun r -> r.Substring(0, String.length r - paddingSize).ToCharArray()
   |> Array.map byte

let decoded = decode encoded

File.WriteAllBytes("favicon.ico", decoded) </lang>

Output:

Rosetta Code Icon

Factor

<lang factor>USING: base64 io strings ;

"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo" base64> >string print</lang>

Output:
To err is human, but to really foul things up you need a computer.
    --Paul R.Ehrlich



Forth

Works with: gforth version 0.7.3

Inspired from Wikipedia. Use of a buffer. May be also of interest : github.com/lietho/base64-forth <lang forth>variable bitsbuff

char>6bits ( c -- u )
  dup 43 =          if drop 62   exit then    ( + case )
  dup 47 =          if drop 63   exit then    ( / case )
  dup 48 58 within  if 48 - 52 + exit then    ( 0-9 case )
  dup 65 91 within  if 65 -      exit then    ( A-Z case )
  dup 97 123 within if 97 - 26 + exit then    ( a-z case )
  drop 0                                      ( padding )
6bitsin ( v -- ) bitsbuff @ 6 lshift + bitsbuff ! ;
4charsin ( addr -- addr+4 )
  $0 bitsbuff !
  dup 4 + dup rot
  do I c@ char>6bits 6bitsin loop ;
3bytes, ( -- )
  bitsbuff @ 16 rshift $ff and c,
  bitsbuff @  8 rshift $ff and c,
  bitsbuff @           $ff and c, ;


b64dec ( addr1 n1 -- addr2 n2 )
  here rot rot ( addr2 addr1 n1 )
  4 /          ( addr2 addr1 n1/4 )
  0 do
     4charsin 3bytes,
  loop                                   ( addr2 addr1+4x )
  ( get back for padding )
  1 - dup c@ 61 = if 1 else 0 then swap  ( addr2 0|1 addr1+4x-1 )
  1 -     c@ 61 = if 1 else 0 then +     ( addr2 0|1|2 )
  swap            ( 0|1|2 addr2 )
  dup here swap - ( 0|1|2 addr2 n' )
  rot -           ( addr2 n2 )

</lang>

Output:
s" VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo" b64dec cr type cr 
To err is human, but to really foul things up you need a computer.
    --Paul R.Ehrlich
 ok

( encode with b64enc as coded for Base64 encode data task )
s" VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo" b64dec b64enc cr type 
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo ok

s" YW55IGNhcm5hbCBwbGVhc3VyZS4=" b64dec cr type cr
any carnal pleasure.
 ok

s" YW55IGNhcm5hbCBwbGVhc3VyZQ==" b64dec cr type cr 
any carnal pleasure
 ok


FreeBASIC

<lang freebasic>Dim Shared As String B64 B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" & _ "abcdefghijklmnopqrstuvwxyz" & _ "0123456789+/"

Function MIMEDecode(s As String ) As Integer 

   If Len(s) Then
       MIMEdecode = Instr(B64,s) - 1
   Else
       MIMEdecode = -1
   End If

End Function

Function Decode64(s As String) As String 

   Dim As Integer w1, w2, w3, w4
   Dim As String  mD
   For n As Integer = 1 To Len(s) Step 4
       w1 = MIMEdecode(Mid(s,n+0,1))
       w2 = MIMEdecode(Mid(s,n+1,1))
       w3 = MIMEdecode(Mid(s,n+2,1))
       w4 = MIMEdecode(Mid(s,n+3,1))
       If w2 >-1 Then mD+= Chr(((w1* 4 + Int(w2/16)) And 255))
       If w3 >-1 Then mD+= Chr(((w2*16 + Int(w3/ 4)) And 255))
       If w4 >-1 Then mD+= Chr(((w3*64 + w4        ) And 255))
   Next n
   Return mD

End Function

Dim As String msg64 = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVw" & _ "IHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=" Print msg64 Print: Print(Decode64(msg64)) Sleep</lang>

Output:
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=

To err is human, but to really foul things up you need a computer.
    -- Paul R. Ehrlich


Go

As images can no longer be uploaded to RC, I've encoded and decoded a string rather than the Rosetta Code icon. <lang go>package main

import ( 

   "encoding/base64"
   "fmt"

)

func main() { 

   msg := "Rosetta Code Base64 decode data task"
   fmt.Println("Original :", msg)
   encoded := base64.StdEncoding.EncodeToString([]byte(msg))
   fmt.Println("\nEncoded  :", encoded)
   decoded, err := base64.StdEncoding.DecodeString(encoded)
   if err != nil {
       fmt.Println(err)
       return
   }
   fmt.Println("\nDecoded  :", string(decoded))

}</lang>

Output:
Original : Rosetta Code Base64 decode data task

Encoded  : Um9zZXR0YSBDb2RlIEJhc2U2NCBkZWNvZGUgZGF0YSB0YXNr

Decoded  : Rosetta Code Base64 decode data task

Groovy

Translation of: Java

<lang groovy>import java.nio.charset.StandardCharsets

class Decode { 

   static void main(String[] args) {
       String data = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="
       Base64.Decoder decoder = Base64.getDecoder()
       byte[] decoded = decoder.decode(data)
       String decodedStr = new String(decoded, StandardCharsets.UTF_8)
       System.out.println(decodedStr)
   }

}</lang>

Output:
To err is human, but to really foul things up you need a computer.
    -- Paul R. Ehrlich

Haskell

Simple implementation that decodes an ASCII string. <lang haskell>--Decodes Base64 to ASCII import qualified Data.Map.Strict as Map (Map, lookup, fromList) import Data.Maybe (fromJust, listToMaybe, mapMaybe) import Numeric (readInt, showIntAtBase) import Data.Char (chr, digitToInt) import Data.List.Split (chunksOf)

byteToASCII :: String -> String byteToASCII = map chr . decoder

--generates list of bytes (represented by Int) decoder :: String -> [Int] decoder = 

 map readBin .
 takeWhile (\x -> length x == 8) .
 chunksOf 8 . concatMap toBin . mapMaybe (`Map.lookup` table) . filter (/= '=')

--turns decimal into a list of char that represents a binary number toBin :: Int -> String toBin n = leftPad $ showIntAtBase 2 ("01" !!) n ""

--this adds all the zeros to the left that showIntAtBase omitted leftPad :: String -> String leftPad a = replicate (6 - length a) '0' ++ a

--turns list of '0' and '1' into list of 0 and 1 readBin :: String -> Int readBin = fromJust . fmap fst . listToMaybe . readInt 2 (`elem` "01") digitToInt

--lookup list for the sextets table :: Map.Map Char Int table = 

 Map.fromList $
 zip "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" [0 ..]

main :: IO () main = 

 putStrLn $
 byteToASCII
   "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCi0tIFBhdWwgUi4gRWhybGljaA=="</lang>
Output:
To err is human, but to really foul things up you need a computer.
-- Paul R. Ehrlich


or in terms of Data.ByteString.Base64:

<lang haskell>{-# LANGUAGE OverloadedStrings #-}

import qualified Data.ByteString.Base64 as Base64 (decode, encode) import qualified Data.ByteString.Char8 as B (putStrLn)

main :: IO () main = do 

 B.putStrLn $
   Base64.encode
     "To err is human, but to really foul things up you need a computer.\n-- Paul R. Ehrlich"
 B.putStrLn "\n-->\n"
 either print B.putStrLn $
   Base64.decode
     "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCi0tIFBhdWwgUi4gRWhybGljaA=="</lang>
Output:
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCi0tIFBhdWwgUi4gRWhybGljaA==

-->

To err is human, but to really foul things up you need a computer.
-- Paul R. Ehrlich

Haxe

<lang haxe>class Main { 

 static function main() {
   var data = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVw" + 
              "IHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=";
   Sys.println('$data\n');
   var decoded = haxe.crypto.Base64.decode(data);
   Sys.println(decoded);
 }

}</lang>

Output:
To err is human, but to really foul things up you need a computer.
    -- Paul R. Ehrlich

Java

Translation of: Kotlin

<lang java>import java.nio.charset.StandardCharsets; import java.util.Base64;

public class Decode { 

   public static void main(String[] args) {
       String data = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=";
       Base64.Decoder decoder = Base64.getDecoder();
       byte[] decoded = decoder.decode(data);
       String decodedStr = new String(decoded, StandardCharsets.UTF_8);
       System.out.println(decodedStr);
   }

}</lang>

Output:
To err is human, but to really foul things up you need a computer.
    -- Paul R. Ehrlich

jq

Simply pipe the base64 string into: 

   jq -rR base64d

Jsish

See Base64_encode_data#Jsish for base64.jsi.

<lang javascript>/* Base64 decode, in Jsish */ var data = exec('jsish base64.jsi', {retAll:true}).data; // or use File.read('stdin'); var icon = Util.base64(data, true); File.write('rosetta-favicon.ico', icon);</lang>

Julia

Using an IOBuffer here, though not really needed to decode a string, shows how we could pipe a network stream or file though Julia's builtin Base64 decoder. <lang julia>using Base64

io = IOBuffer()

iob64_decode = Base64DecodePipe(io)

write(io, "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo")

seekstart(io)

println(String(read(iob64_decode)))

</lang>

Output:
To err is human, but to really foul things up you need a computer.
    --Paul R.Ehrlich

Kotlin

Translation of: D

<lang scala>import java.util.Base64

fun main() { 

   val data =
       "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="
   val decoder = Base64.getDecoder()
   val decoded = decoder.decode(data)
   val decodedStr = String(decoded, Charsets.UTF_8)
   println(decodedStr)

}</lang>

Output:
To err is human, but to really foul things up you need a computer.
    -- Paul R. Ehrlich

Lua

<lang lua>-- Start taken from https://stackoverflow.com/a/35303321 local b='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' -- You will need this for encoding/decoding

-- decoding function dec(data) 

   data = string.gsub(data, '[^'..b..'=]', )
   return (data:gsub('.', function(x)
       if (x == '=') then return  end
       local r,f=,(b:find(x)-1)
       for i=6,1,-1 do r=r..(f%2^i-f%2^(i-1)>0 and '1' or '0') end
       return r;
   end):gsub('%d%d%d?%d?%d?%d?%d?%d?', function(x)
       if (#x ~= 8) then return  end
       local c=0
       for i=1,8 do c=c+(x:sub(i,i)=='1' and 2^(8-i) or 0) end
           return string.char(c)
   end))

end -- end of copy

local data = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo" print(data) print()

local decoded = dec(data) print(decoded)</lang>

Output:
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo

To err is human, but to really foul things up you need a computer.
    --Paul R.Ehrlich

Mathematica/Wolfram Language

<lang Mathematica>ImportString[ 

  "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo",
  "Base64"

]</lang>

Output:
To err is human, but to really foul things up you need a computer.
    -- Paul R. Ehrlich

Nim

<lang Nim>import base64

const Source = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="

echo Source.decode()</lang>

Output:
To err is human, but to really foul things up you need a computer.
    -- Paul R. Ehrlich

OCaml

We continue from the same toplevel session from the previous page: 

# let plain = Base64.decode_exn enc;;
val plain : string =
  "\000\000\001\000\002\000\016\016\000\000\000\000\000\000h\005\000\000&\000"... (* string length 3638; truncated *)

Ol

<lang scheme> (define base64-codes "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/") (define kernel (alist->ff (map cons (string->bytes base64-codes) (iota (string-length base64-codes)))))

returns n bits from input binary stream

(define (bits n hold) 

  (let loop ((hold hold))
     (vector-apply hold (lambda (v i l)
        (cond
           ((null? l)
              (values (>> v (- i n)) #false))
           ((pair? l)
              (if (not (less? i n))
                 (values (>> v (- i n)) (vector (band v (- (<< 1 (- i n)) 1)) (- i n) l))
                 (loop (vector
                    (bor (<< v 6) (kernel (car l) 0))
                    (+ i 6)
                    (unless (eq? (car l) "=") (cdr l))))))
           (else
              (loop (vector v i (l)))))))))
decoder.

(define (decode str) 

  (print "decoding string '" str "':")
  (let loop ((hold [0 0 (str-iter str)]))
     (let*((bit hold (bits 8 hold)))
        (unless (zero? bit) (display (string bit)))
        (when hold
           (loop hold))))
  (print)(print))
TESTING

(decode "SGVsbG8sIExpc3Ah")

(decode "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=")

(decode "TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGludWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4=") </lang>

Output:
Hello, Lisp!

To err is human, but to really foul things up you need a computer.
    -- Paul R. Ehrlich

Man is distinguished, not only by his reason, but by this singular passion from other animals, which is a lust of the mind, that by a perseverance of delight in the continued and indefatigable generation of knowledge, exceeds the short vehemence of any carnal pleasure.

Perl

The MIME::Base64 module is to be preferred, but this works too. <lang perl>sub decode_base64 { 

   my($d) = @_;
   $d =~ tr!A-Za-z0-9+/!!cd;
   $d =~ s/=+$//;
   $d =~ tr!A-Za-z0-9+/! -_!;
   my $r = ;
   while( $d =~ /(.{1,60})/gs ){
       my $len = chr(32 + length($1)*3/4);
       $r .= unpack("u", $len . $1 );
   }
   $r;

}

$data = <<EOD; J1R3YXMgYnJpbGxpZywgYW5kIHRoZSBzbGl0aHkgdG92ZXMKRGlkIGd5cmUgYW5kIGdpbWJsZSBp biB0aGUgd2FiZToKQWxsIG1pbXN5IHdlcmUgdGhlIGJvcm9nb3ZlcywKQW5kIHRoZSBtb21lIHJh dGhzIG91dGdyYWJlLgo= EOD

print decode_base64($data) . "\n";</lang>

Output:
'Twas brillig, and the slithy toves
Did gyre and gimble in the wabe:
All mimsy were the borogoves,
And the mome raths outgrabe.

Phix

<lang Phix>include builtins\base64.e string s = "Rosetta Code Base64 decode data task" string e = encode_base64(s) ?e ?decode_base64(e)</lang>

Output:
"Um9zZXR0YSBDb2RlIEJhc2U2NCBkZWNvZGUgZGF0YSB0YXNr"
"Rosetta Code Base64 decode data task"

PHP

<lang PHP>$encoded = 'VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVw' . 

          'IHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=';

echo 

   $encoded, PHP_EOL,
   base64_decode($encoded), PHP_EOL;</lang>
Output:
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=
To err is human, but to really foul things up you need a computer.
    -- Paul R. Ehrlich

PicoLisp

<lang PicoLisp>(setq *Char64 

  `'(chop
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" ) )

(de decode64 (S) 

  (let S (chop S)
     (pack
        (make
           (while S
              (let
                 (A (dec (index (++ S) *Char64))
                    B (dec (index (++ S) *Char64))
                    C (dec (index (++ S) *Char64))
                    D (dec (index (++ S) *Char64)) )
                 (link
                    (char (| (>> -2 A) (>> 4 B))) )
                 (and
                    C
                    (link
                       (char
                          (| (>> -4 (& B 15)) (>> 2 C)) ) )
                    D
                    (link
                       (char (| (>> -6 (& C 3)) D)) ) ) ) ) ) ) ) )

(prinl (decode64 "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo"))</lang>

Output:
To err is human, but to really foul things up you need a computer.
    --Paul R.Ehrlich

Pike

By necessity this also implements all of the Base64 encode task to avoid a humongous amount of icon data hardcoded in the program. <lang Pike> string icon = Protocols.HTTP.get_url_data("http://rosettacode.org/favicon.ico"); string encoded = MIME.encode_base64(icon); Stdio.write_file("favicon.ico", MIME.decode_base64(encoded)); </lang>

Prolog

In SWI-Prolog base64 is a built in predicate. https://www.swi-prolog.org/pldoc/doc_for?object=base64%3Abase64/2

This predicate is reversable and can encode or decode.

Output:
?- Encoded = 'VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=', 
base64(Plain, Encoded).

Plain = 'To err is human, but to really foul things up you need a computer.\n    -- Paul R. Ehrlich'.

PureBasic

<lang PureBasic>b64cd$ = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVw" + 

        "IHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="
  • p_buf = AllocateMemory(1024)

Base64Decoder(b64cd$, *p_buf, 1024) OpenConsole("") : PrintN(PeekS(*p_buf, -1, #PB_UTF8)) Input()</lang>

Output:
To err is human, but to really foul things up you need a computer.
    -- Paul R. Ehrlich

Python

<lang Python> import base64 data = 'VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=' print(base64.b64decode(data).decode('utf-8')) </lang>

Output:
To err is human, but to really foul things up you need a computer.
    -- Paul R. Ehrlich

QB64

<lang vb>Option _Explicit

Dim As String udata, decoded udata = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo"

decoded = decode(udata)

Print udata Print decoded

Function findIndex& (value As _Unsigned _Byte) 

   If Asc("A") <= value And value <= Asc("Z") Then
       findIndex = value - Asc("A")
       Exit Function
   End If
   If Asc("a") <= value And value <= Asc("z") Then
       findIndex = value - Asc("a") + 26
       Exit Function
   End If
   If Asc("0") <= value And value <= Asc("9") Then
       findIndex = value - Asc("0") + 52
       Exit Function
   End If
   If value = Asc("+") Then
       findIndex = 62
       Exit Function
   End If
   If value = Asc("/") Then
       findIndex = 63
       Exit Function
   End If
   findIndex = -1

End Function

Function encode$ (source As String) 

   Dim As String Base64: Base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
   Dim As _Unsigned _Integer64 length: length = Len(source)
   Dim As _Unsigned _Integer64 it, strend
   Dim As Long acc
   Dim As String sink
   strend = length
   While it <> strend
       Dim As _Unsigned _Byte b1, b2, b3, b4
       it = it + 1
       b1 = Asc(Mid$(source, it, 1))
       sink = sink + Mid$(Base64, _SHR(b1, 2), 1)
       acc = _SHL(b1 And &H3, 4)
       If it <> strend Then
           it = it + 1
           b2 = Asc(Mid$(source, it, 1))
           acc = acc Or _SHR(b2, 4)
           sink = sink + Mid$(Base64, acc, 1)
           acc = _SHL(b2 And &HF, 2)
           If it <> strend Then
               it = it + 1
               b3 = Asc(Mid$(source, it, 1))
               acc = acc Or _SHR(b3, 6)
               sink = sink + Mid$(Base64, acc, 1)
               sink = sink + Mid$(Base64, b3 And &H3F, 1)
           Else
               sink = sink + Mid$(Base64, acc, 1)
               sink = sink + "="
           End If
       Else
           sink = sink + Mid$(Base64, acc, 1)
           sink = sink + "="
           sink = sink + "="
       End If
   Wend
   encode = sink

End Function

Function decode$ (source As String) 

   Dim As _Unsigned _Integer64 length: length = Len(source)
   Dim As _Unsigned _Integer64 it, strend
   Dim As Long acc
   Dim As String sink
   strend = length
   While it <> strend
       Dim As _Unsigned _Byte b1, b2, b3, b4
       it = it + 1
       b1 = Asc(Mid$(source, it, 1))
       it = it + 1
       b2 = Asc(Mid$(source, it, 1))
       it = it + 1
       b3 = Asc(Mid$(source, it, 1))
       it = it + 1
       b4 = Asc(Mid$(source, it, 1))
       Dim As Long i1, i2
       i1 = findIndex(b1)
       i2 = findIndex(b2)
       acc = _SHL(i1, 2)
       acc = acc Or _SHR(i2, 4)
       sink = sink + Chr$(acc)
       If b3 <> Asc("=") Then
           Dim As Long i3
           i3 = findIndex(b3)
           acc = _SHL(i2 And &HF, 4)
           acc = acc Or _SHR(i3, 2)
           sink = sink + Chr$(acc)
           If b4 <> Asc("=") Then
               Dim As Long i4
               i4 = findIndex(b4)
               acc = _SHL(i3 And &H3, 6)
               acc = acc Or i4
               sink = sink + Chr$(acc)
           End If
       End If
   Wend
   decode = sink

End Function</lang>

Output:
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo
To err is human, but to really foul things up you need a computer.
    --Paul R.Ehrlich

Raku

(formerly Perl 6)

Works with: Rakudo version 2018.11

<lang perl6>my $e64 = ' VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY2 9tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g= ';

my @base64map = flat 'A' .. 'Z', 'a' .. 'z', ^10, '+', '/'; my %base64 is default(0) = @base64map.pairs.invert;

sub base64-decode-slow ($enc) { 

   my $buf = Buf.new;
   for $enc.subst(/\s/, , :g).comb(4) -> $chunck {
       $buf.append: |(sprintf "%06d%06d%06d%06d", |$chunck.comb.map:
           {%base64{$_}.base(2)}).comb(8).map: {:2($_)};
   }
   $buf

}

say 'Slow:'; say base64-decode-slow($e64).decode('utf8');


  1. Of course, the above routine is slow and is only for demonstration purposes.
  2. For real code you should use a module, which is MUCH faster and heavily tested.

say "\nFast:"; use Base64::Native; say base64-decode($e64).decode('utf8');</lang>

Output:
Slow:
To err is human, but to really foul things up you need a computer.
    -- Paul R. Ehrlich

Fast:
To err is human, but to really foul things up you need a computer.
    -- Paul R. Ehrlich

Red

<lang red>Red [Source: https://github.com/vazub/rosetta-red]

print to-string debase "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo" </lang>

Output:
To err is human, but to really foul things up you need a computer.
    -- Paul R. Ehrlich

Ring

<lang ring>

  1. ======================================#
  2. Sample: Base64 decode data
  3. Author: Gal Zsolt, Mansour Ayouni
  4. ======================================#

load "guilib.ring"

oQByteArray = new QByteArray() oQByteArray.append("Rosetta Code Base64 decode data task") oba = oQByteArray.toBase64().data() see oba + nl

oQByteArray = new QByteArray() oQByteArray.append(oba) see oQByteArray.fromBase64(oQByteArray).data() </lang>

Output:
Um9zZXR0YSBDb2RlIEJhc2U2NCBkZWNvZGUgZGF0YSB0YXNr
Rosetta Code Base64 decode data task

Ruby

<lang ruby>require 'base64'

raku_example =' VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY2 9tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g= ' puts Base64.decode64 raku_example</lang>

Output:
To err is human, but to really foul things up you need a computer.
    -- Paul R. Ehrlich

Rust

<lang rust>use std::str;

const INPUT: &str = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo"; const UPPERCASE_OFFSET: i8 = -65; const LOWERCASE_OFFSET: i8 = 26 - 97; const NUM_OFFSET: i8 = 52 - 48;

fn main() { 

   println!("Input: {}", INPUT);

   let result = INPUT.chars()
       .filter(|&ch| ch != '=')                                //Filter '=' chars
       .map(|ch| {                                             //Map char values using Base64 Characters Table
           let ascii = ch as i8;                           
           let convert = match ch {
               '0' ... '9' => ascii + NUM_OFFSET,
               'a' ... 'z' => ascii + LOWERCASE_OFFSET,
               'A' ... 'Z' => ascii + UPPERCASE_OFFSET,
               '+' => 62,
               '/' => 63,
               _ => panic!("Not a valid base64 encoded string")
           };
           format!("{:#08b}", convert)[2..].to_string()        //convert indices to binary format and remove the two first digits
       })
       .collect::<String>()                                    //concatenate the resulting binary values
       .chars()
       .collect::<Vec<char>>()
       .chunks(8)                                              //split into 8 character chunks
       .map(|chunk| {
           let num_str = chunk.iter().collect::<String>();
           usize::from_str_radix(&num_str, 2).unwrap() as u8   //convert the binary string into its u8 value
       })
       .collect::<Vec<_>>();

   let result = str::from_utf8(&result).unwrap();              //convert into UTF-8 string

   println!("Output: {}", result);

}</lang>

Output:
Input: VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo
Output: To err is human, but to really foul things up you need a computer.
    --Paul R.Ehrlich

Scala

Output:

Best seen in running your browser either by ScalaFiddle (ES aka JavaScript, non JVM) or Scastie (remote JVM).

<lang Scala>import java.util.Base64

object Base64Decode extends App { 

 def text2BinaryDecoding(encoded: String): String = {
   val decoded = Base64.getDecoder.decode(encoded)
   new String(decoded, "UTF-8")
 }

 def data =
   "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="

 println(text2BinaryDecoding(data))

}</lang>

Seed7

The Seed7 library encoding.s7i defines the functions toBase64 and fromBase64.

<lang seed7>$ include "seed7_05.s7i"; 

 include "gethttp.s7i";
 include "encoding.s7i";

const proc: main is func 

 local
   var string: original is "";
   var string: encoded is "";
 begin
   original := getHttp("rosettacode.org/favicon.ico");
   encoded := toBase64(original);
   writeln("Is the Rosetta Code icon the same (byte for byte) encoded then decoded: " <&
           fromBase64(encoded) = original);
 end func;</lang>
Output:
Is the Rosetta Code icon the same (byte for byte) encoded then decoded: TRUE

SenseTalk

<lang sensetalk>

put base64Decode ("VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuIC0tUGF1bCBSLkVocmxpY2g=")

end myFunc</lang> Output: <lang sensetalk>To err is human, but to really foul things up you need a computer. --Paul R.Ehrlich</lang>

Sidef

<lang ruby>var data = <<'EOT' VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY2 9tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g= EOT

say data.decode_base64</lang>

Output:
To err is human, but to really foul things up you need a computer.
    -- Paul R. Ehrlich

Smalltalk

Works with: Smalltalk/X

<lang smalltalk>data := ' VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY2 9tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g= '.

data base64Decoded asString printCR.</lang>

Output:
To err is human, but to really foul things up you need a computer.
    -- Paul R. Ehrlich

Standard ML

<lang Standard ML>val debase64 = fn input => let 

infix 2 Worb
infix 2 Wandb
fun (p Worb q )  =  Word.orb  (p,q);
fun (p Wandb q ) =  Word.andb (p,q);

fun decode #"/" = 0wx3F 

 | decode #"+" =  0wx3E
 | decode c    =  if Char.isDigit c then Word.fromInt (ord c) +  0wx04
             else if Char.isLower c then Word.fromInt (ord c) - 0wx047
             else if Char.isUpper c then Word.fromInt (ord c) - 0wx041
             else 0wx00 ;

fun convert (a::b::c::d::_) = 

        let
           val w = Word.<< (a,0wx12) Worb Word.<< (b,0wx0c) Worb Word.<< (c,0wx06) Worb d
        in
           [Word.>> (w,0wx10), Word.>> ((w Wandb 0wx00ff00),0wx08) , w Wandb 0wx0000ff ]
        end
 | convert _ = [] ;

fun decodeLst [] = [] 

 | decodeLst ilist = ( convert o  map decode )( List.take (ilist,4) ) @  decodeLst (List.drop (ilist,4))

in 

 String.implode ( List.map (chr o Word.toInt) ( decodeLst (String.explode input ))  )

end handle Subscript => "Invalid code\n" ;</lang> call 

val input = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=";
print (debase64 input) ;

To err is human, but to really foul things up you need a computer.
    -- Paul R. Ehrlich

Tcl

<lang tcl>package require tcl 8.6 set data VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=

puts [binary decode base64 $data]</lang>

Output:
To err is human, but to really foul things up you need a computer.
    -- Paul R. Ehrlich

Visual Basic .NET

Translation of: D

<lang vbnet>Module Module1 

   Sub Main()
       Dim data = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="
       Console.WriteLine(data)
       Console.WriteLine()

       Dim decoded = Text.Encoding.ASCII.GetString(Convert.FromBase64String(data))
       Console.WriteLine(decoded)
   End Sub

End Module</lang>

Output:
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=

To err is human, but to really foul things up you need a computer.
    -- Paul R. Ehrlich

Wren

Library: Wren-fmt
Library: Wren-str

From first principles using string manipulation. Quick enough here. <lang ecmascript>import "io" for Stdout import "/fmt" for Conv, Fmt import "/str" for Str

var alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

var decode = Fn.new { |s| 

  if (s == "") return s
  var d = ""
  for (b in s) {
      var ix = alpha.indexOf(b)
      if (ix >= 0) d = d + Fmt.swrite("$06b", ix)
  }
  if (s.endsWith("==")) {
       d = d[0..-5]
  } else if (s.endsWith("=")){
       d = d[0..-3]
  }
  var i = 0
  while (i < d.count) {
       var ch = String.fromByte(Conv.atoi(d[i..i+7], 2))
       System.write(ch)
       i = i + 8
  }
  Stdout.flush()

}

var s = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=" for (chunk in Str.chunks(s, 4)) decode.call(chunk) System.print()</lang>

Output:
To err is human, but to really foul things up you need a computer.
    -- Paul R. Ehrlich

zkl

Using shared libraries for cURL and message hashing: <lang zkl>var [const] MsgHash=Import("zklMsgHash"), Curl=Import("zklCurl");

icon:=Curl().get("http://rosettacode.org/favicon.ico"); //-->(Data(4,331),693,0) icon=icon[0][icon[1],*]; // remove header iconEncoded:=MsgHash.base64encode(icon); iconDecoded:=MsgHash.base64decode(iconEncoded); File("rosettaCodeIcon.ico","wb").write(iconDecoded); # eyeball checking says good println("Is the Rosetta Code icon the same (byte for byte) encoded then decoded: ", 

  icon==iconDecoded);</lang>
Output:
Is the Rosetta Code icon the same (byte for byte) encoded then decoded: True
Text based test:

<lang zkl>msg,b64 := "Rosetta Code Base64 decode data task", MsgHash.base64encode(msg); println("Original: %s\nEncoded: %s\nBytes: %s\nDecoded: %s" 

  .fmt(msg, b64.text, b64.bytes().apply("toString",16).concat(","),
       MsgHash.base64decode(b64).text));</lang>

Original: Rosetta Code Base64 decode data task
Encoded:  Um9zZXR0YSBDb2RlIEJhc2U2NCBkZWNvZGUgZGF0YSB0YXNr

Bytes:    55,6d,39,7a,5a,58,52,30,59,53,42,44,62,32,52,6c,49,45,4a,68,63,32,55,32,4e,43,42,6b,5a,57,4e,76,5a,47,55,67,5a,47,46,30,59,53,42,30,59,58,4e,72,a
Decoded:  Rosetta Code Base64 decode data task
Retrieved from "https://rosettacode.org/wiki/Base64_decode_data?oldid=287246"