How to encode base64 via command line in macOS/OS X?

Question

Is there a terminal command in macOS/OS X which will base64 encode a file or stdin?

Answer 1

openssl can do this for you, and it's all installed with OS X by default; no need to install darwinports.

$ openssl base64 -in <infile> -out <outfile>           # file
$ openssl base64 -in <infile> | tr -d '\n' | pbcopy    # clipboard

Without the -in option reads from stdin

Answer 2

OpenSSL can be used more succinctly:

echo -n 'input' | openssl base64

echo -n -> must be used, or encoding will be done including new line character.

Or:

openssl base64 <ENTER> [type input] <CTRL+D>

Answer 3

Try using:

base64 -i <in-file> -o <outfile>

It should be available by default on OS X.

Answer 4

On macOS I always use:

echo -n "STRING" | base64

-n is to avoid a new line character on the end of the line.

Answer 5

base64 command is available by default on my OS X 10.9.4.

You can use base64 <<< string and base64 -D <<< string to encode and decode a string in the terminal, or base64 -in file and base64 -D -in file to encode and decode a file.

Answer 6

Since Python is provided with OS X by default, you can use it as below:

$ echo FOO | python -m base64
Rk9PCg==
$ echo Rk9PCg== | python -m base64 -d
FOO

Or install coreutils via Brew (brew install coreutils) which will provide base64 command:

$ echo FOO | base64
Rk9PCg==
$ echo Rk9PCg== | base64 -d
FOO

Answer 7

You can also pipe it right to the clipboard (at least on mac):

openssl base64 -in [filename] | pbcopy

Answer 8

Python

Python3 comes preinstalled on all modern macs and linuces nowadays. The base64 module in the standard library exposes a cli interface (see python3 -m base64 -h)

Encode

# encode /etc/hosts to hosts.b64 in the current folder
# passing -e is optional since it's the default operation
python3 -m base64 -e < /etc/hosts > hosts.b64
encode a literal string to stdout (❗️appends a new line char)
python3 -m base64 <<< 'nobody expects the spanish inq..'
OUT: bm9ib2R5IGV4cGVjdHMgdGhlIHNwYW5pc2ggaW5xLi4K

Decode

# decode hosts.b64 to hosts.txt
python3 -m base64 -d < hosts.b64 > hosts.txt

The python code in case you need to script it from python:

Encode a file:

base64data = open('myfile.jpg','rb').read().encode('base64')
open('myfile.txt','w').write(base64data)

Encode a byte string without including the trailing new line:

import binascii 
encoded = binascii.b2a_base64(b'nobody expects..', newline=False)
print(encoded)
# OUT: b'bm9ib2R5IGV4cGVjdHMuLg=='
alternative solution
import base64
encoded = base64.standard_b64encode(b'nobody expects..')
print(encoded)
OUT: b'bm9ib2R5IGV4cGVjdHMuLg=='

Decode a file:

data = open('myfile.b64').read().decode('base64')
open('myfile.jpg','wb').write(data)

OpenSSL

# encode to base64 (on OSX use `-output`)
openssl base64 -in myfile.jpg -output myfile.jpg.b64
encode to base64 (on Linux use -out)
openssl base64 -in myfile.jpg -out myfile.jpg.b64
decode from base64 (on OSX -output should be used)
openssl base64 -d -in myfile.jpg.b64 -output myfile.jpg
decode from base64 (on Linux -out should be used)
openssl base64 -d -in myfile.jpg.b64 -out myfile.jpg

Omitting the -out/-output... filename will print to stdout.

You can also pass the input data as a stream in a OS-agnostic way, e.g.

# encode /etc/hosts to hosts.b64
openssl base64 < /etc/hosts > hosts.b64
decode hosts64.b64 to hosts.txt
openssl base64 -d < hosts.b64 > hosts.txt
decode raw data to stdout (don't use with binary files)
openssl base64 -d < hosts.b64

Base64

Another out of the box utility commonly available on both mac and Lunux:

# encode to base64
base64 < myfile.jpg > myfile.jpg.b64
decode from base64 (OSX) (note the uppercase '-D', '-d' might also be accepted newer OS's)
base64 -D < myfile.jpg.b64 > myfile.jpg
decode from base64 (Linux) (note the lowercase 'd')
base64 -d < myfile.jpg.b64 > myfile.jpg

Answer 9

In terms of speed, I would use OpenSSL followed by Perl, followed by uuencode. In terms of portability, I would use uuencode followed by Perl followed by openssl (If you care about reusing the code on as many other UNIX like stock platforms as possible). Be careful though because not all UNIX variants support the -m switch (If I recall correctly, AIX does, HP/UX does, Solaris doesn't).

$ time perl -MMIME::Base64 -e 'undef $/;while(<>){print encode_base64($_);}' \
> out.jpg 1>filename.b64
real    0m0.025s
$ time uuencode -m -o filename.b64 out.jpg filename_when_uudecoded.txt
real    0m0.051s
$  time openssl base64 -in out.jpg -out filename.b64 
real    0m0.017s

Use the -m switch to uuencode file_in.txt per base64 as specified by RFC1521 and write it to filename.b64 (with filename_when_uudecoded.txt as the default filename when decoded):

uuencode -m -o filename.b64 file_in.txt filename_when_uudecoded.txt

STDIN example:

cat file_in.txt | uuencode -m -o filename.b64 filename_when_uudecoded.txt

Answer 10

In addition to Steve Folly's answer, when encoding in stdin mode, to avoid passing extra newlines, press CTRL+D twice to end input without any additional newlines.

The output will show right after the same line.

For example:

$ openssl base64 <kbd>Enter</kbd>
input<kbd>CTRL</kbd>+<kbd>D</kbd><kbd>CTRL</kbd>+<kbd>D</kbd>aW5wdXQ=

Alternatively, you could use printf:

$ printf 'input' | openssl base64
aW5wdXQ=

Answer 11

uuencode -m [-o output_file] [file] name

Where name is the name to display in the encoded header.

Example:

cat docbook-xsl.css | uuencode -m docbook-xsl.css

or

uuencode -m -o docbook-xsl.css.b64 docbook-xsl.css docbook-xsl.css

Answer 12

For some reason, echo -n <data> | openssl base64 added a newline in the middle of my base64 data. I assume it was because my base64 data was really long.

Using echo -n <data> | base64 to encode and echo -n <base64-ed data> | base64 -D to decode worked fine.

Answer 13

There is Perl plus MIME::Base64:

perl -MMIME::Base64 -e 'undef $/;while(<>){print encode_base64($_);}'

This comes pre-installed. You can specify separate files on the command line (or supply the data on standard input); each file is separately encoded. You can also do:

perl -i.txt -MMIME::Base64 -e 'undef $/;while(<>){print encode_base64($_);}' file1

This backs up file1 to file1.txt, and writes the Base-64 encoded output over the original file.

Answer 14

Cross-platform solutions

We compiled a list of cross-platform shell commands to encode a file as base64. The following commands take an input file (named deploy.key in examples) and convert it to base64 without any newline wrapping. The base64 output is printed to the terminal via stdout.

# For systems with openssl
openssl base64 -A -in=deploy.key
For systems with Python (2 or 3) installed
python -c "import base64; print(base64.standard_b64encode(open('deploy.key', 'rb').read()).decode())"
For Windows or Linux systems that have the GNU coreutils base64 command
base64 --wrap=1000000 deploy.key
For macOS systems
base64 --break=1000000 deploy.key

To redirect the output to a file, append > base64-encoded.txt (using a file name of your choosing).

These commands were prototyped as part of this pull request where we wanted cross-platform shell commands to base64 encode an SSH private key to remove newlines.

Answer 15

There are many great answers already and mine does basically the same thing except the secret is never shown in the terminal.

I created these two aliases to encode a string from my clipboard and the encoded string is copied to my clipboard. The same applies to decoding:

alias decode='pbpaste | base64 --decode | pbcopy'
alias encode='pbpaste | base64 | pbcopy'

Answer 16

On Mac, you can simply encode and decode the current clipboard contents to/from base64 with:

1. Encode to base64:

   pbpaste | base64
   

2. Decode from base64:

   pbpaste | base64 --decode
   

Answer 17

A simple NodeJS version:

node -e "process.stdout.write(new Buffer(process.argv[1]).toString('base64'))" "Hello world!"

Answer 18

If you are base64 encoding a font file, you can do this:

base64 my-webfont.ttf > my-webfont.b64.ttf.txt

I use this on a Mac (10.10) all the time.

Note: There will be no linebreaks.

Answer 19

recode should do the trick for you

recode ../b64 < file.txt > file.b64

recode is available for OS X via MacPorts.