openssl può fare questo per voi, ed è tutto installato con OS X di default; non è necessario installare darwinports.

$ openssl base64 -in <infile> -out <outfile>
``` &001 


Senza l'opzione `-in` legge da stdin

Openssl può essere usato in modo più succinto:

echo -n 'input' | openssl base64

[echo -n -> deve essere usato, o la codifica sarà fatta includendo il nuovo carattere di linea]

o

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

Provare ad utilizzare:

base64 -i <in-file> -o <outfile>
``` &001 


Dovrebbe essere disponibile di default su OS X.

Il comando base64 è disponibile di default sul mio OS X 10.9.4.

È possibile utilizzare base64 <<< string e base64 -D <<< string per codificare e decodificare una stringa nel terminale, oppure base64 -in file e base64 -D -in file per codificare e decodificare un file.

Su macOS uso sempre:

echo -n "STRING" | base64 &007

-n è per evitare un nuovo carattere di linea a fine linea.

Poiché Python è fornito di default con OS X, è possibile utilizzarlo come segue:

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

O installare coreutils tramite Brew (brew install coreutils) che fornirà il comando base64:

&001

In termini di velocità, userei openssl seguito da perl, seguito da uuencode. In termini di portabilità, userei uuencode seguito da Perl seguito da openssl (se vi interessa riutilizzare il codice su quante più piattaforme UNIX possibile). Attenzione però, perché non tutte le varianti UNIX supportano lo switch -m (iirc AIX lo fa, HP/UX lo fa, Solaris no).

$ 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
``` ```
uuencode -m -o filename.b64 file_in.txt filename_when_uudecoded.txt

Usa lo switch -m per il file uuencode_in. txt per base64 come specificato da RFC1521 e scriverlo nel nome del file.b64 (con il nome del file _quando _uudecoded.txt come nome del file predefinito quando decodificato):

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


STDIN esempio: 



&001

Si può anche piombarla direttamente negli appunti (almeno su mac):

openssl base64 -in [filename] | pbcopy

Python

Python viene preinstallato su tutti i macs al giorno d'oggi.

In Terminal run python (o ipython ).

Encode a file:

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

Decodificare un file:

## 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
``` ```
## encode to base64
base64 < myfile.jpg > myfile.jpg.b64

## decode from base64 (OSX) (note the uppercase 'D')
base64 -D < myfile.jpg.b64 > myfile.jpg

## decode from base64 (Linux) (note the lowercase 'd')
base64 -d < myfile.jpg.b64 > myfile.jpg

Naturalmente, entrambe le operazioni possono essere convertite in un oneliner ma in questo modo è più leggibile.

OpenSSL

&001 &001

Omettendo il -out/-output... filename si stampa su stdout.

base64

Un'altra utility ootb presente sia in OSX che in Ubuntu:

&001

Per qualche ragione, echo -n <data> | openssl base64 ha aggiunto una nuova linea al centro dei dati della mia base64. Suppongo che sia stato perché i miei dati di base64 erano davvero lunghi.

L'uso di echo -n <data> | base64 per codificare e echo -n <base64-ed data> | base64 -D per decodificare ha funzionato bene.

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

Dove nome è il nome da visualizzare nell'intestazione codificata.

Esempio:

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

o

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

Oltre alla risposta di Steve Folly di cui sopra, quando si esegue la crittografia in modalità stdin, per evitare di passare altre newline, premere due volte CTRL+D per terminare l'input senza ulteriori newline. L'uscita apparirà subito dopo la stessa linea.

Per esempio:

$ openssl base64 [Enter]
input<CTRL+D><CTRL+D>aW5wdXQ=
$

In alternativa, si può usare printf:

$ printf 'input' | openssl base64
aW5wdXQ=
$

C'è Perl plus MIME::Base64:

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

Questo viene fornito preinstallato. Si possono specificare file separati sulla riga di comando (o fornire i dati su input standard); ogni file è codificato separatamente. Si può anche fare:

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


Questo esegue il backup del file1 su file1.txt, e scrive l'output codificato Base-64 sopra il file originale.

Se state codificando in base64 un file di font, potete farlo:

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

Lo uso sempre su un Mac (10.10).

Nota : Non ci saranno interruzioni di linea.

recode dovrebbe fare il trucco per voi

recode ../b64 < file.txt > file.b64
``` &001 



recode è disponibile per OS X via [ MacPorts ](https://www.macports.org/).

Soluzioni multipiattaforma

Abbiamo compilato una lista di comandi shell multipiattaforma per codificare un file come base64. I seguenti comandi prendono un file di input (chiamato deploy.key negli esempi) e lo convertono in base64 senza alcun newline wrapping. L'uscita di base64 è stampata sul terminale tramite 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
``` &001 


Per reindirizzare l'uscita ad un file, aggiungere `> base64-encoded.txt` (usando un nome di file a vostra scelta). 


Questi comandi sono stati prototipati come parte di questa [ pull request ](https://github.com/manubot/rootstock/pull/243 "manubot/rootstock#243: Switch to Travis settings env var to store private key") dove volevamo che i comandi shell multipiattaforma codificassero in base64 una chiave privata SSH per rimuovere le nuove linee.

Una semplice versione NodeJS:

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