මැක් ඕඑස් එක්ස් හි ටර්මිනල් විධානයක් තිබේද, එය පදනම් 64 ගොනුවක් සංකේතවත් කරයිද?

opensslඔබට මෙය කළ හැකි අතර, ඒ සියල්ල පෙරනිමියෙන් OS X සමඟ ස්ථාපනය කර ඇත; darwinports ස්ථාපනය කිරීමට අවශ්‍ය නැත.

$ openssl base64 -in <infile> -out <outfile>

-inවිකල්පය නොමැතිව stdin වෙතින් කියවීම

Openssl වඩාත් සංක්ෂිප්තව භාවිතා කළ හැකිය:

echo -n 'input' | openssl base64

[echo -n -> භාවිතා කළ යුතුය, නැතහොත් නව රේඛා අක්‍ෂර ඇතුළුව කේතීකරණය සිදු කෙරේ]

හෝ

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

භාවිතා කිරීමට උත්සාහ කරන්න:

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

එය පෙරනිමියෙන් OS X වෙතින් ලබා ගත යුතුය.

base64 මගේ OS X 10.9.4 හි විධානය පෙරනිමියෙන් ලබා ගත හැකිය.

ඔබට භාවිතා කළ හැකි base64 <<< stringහා base64 -D <<< stringආවරණ සහ ටර්මිනලය වැලක් විකේතනය, හෝ base64 -in fileසහ base64 -D -in fileආවරණ සහ ගොනු විකේතනය.

මැකෝස් මත මම සැමවිටම භාවිතා කරන්නේ:

echo -n "STRING" | base64

-n යනු පේළියේ අවසානයේ නව රේඛා අක්ෂරයක් වළක්වා ගැනීමයි.

පෙරනිමියෙන් පයිතන් OS X සමඟ සපයා ඇති බැවින්, ඔබට එය පහත පරිදි භාවිතා කළ හැකිය:

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

නැතහොත් විධානය සපයන බ rew ( ) coreutilsහරහා ස්ථාපනය කරන්න :brew install coreutilsbase64

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

වේගය අනුව, මම opensl භාවිතා කරන්නේ perl හා පසුව uuencode ය. අතේ ගෙන යාහැකි ලෙස, මම uuencode භාවිතා කර පර්ල් පසුව opensl භාවිතා කරමි (හැකිතාක් කොටස් වේදිකා වැනි යුනික්ස් වැනි කේතය නැවත භාවිතා කිරීම ගැන ඔබ සැලකිලිමත් වන්නේ නම්). සෑම යුනික්ස් ප්‍රභේදයක්ම -m ස්විචයට සහය නොදක්වන හෙයින් ප්‍රවේශම් වන්න (iirc AIX, HP / UX, Solaris සහාය නොදක්වයි).

$ 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

RFC1521 හි නිශ්චිතව දක්වා ඇති පරිදි පදනම් 64 ට umencode file_in.txt වෙත -m මාරුව භාවිතා කර එය filename.b64 වෙත ලියන්න (විකේතනය කරන විට පෙරනිමි ගොනු නාමය ලෙස filename_when_uudecoded.txt සමඟ):

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

STDIN උදාහරණය:

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

ඔබට එය ක්ලිප්බෝඩ් එකට නල කළ හැකිය (අවම වශයෙන් මැක් මත):

openssl base64 -in [filename] | pbcopy

පයිතන්

පයිතන් වර්තමානයේ සියලුම මැක් වල පෙර ස්ථාපනය කර ඇත.

ටර්මිනල් ධාවනයේදී python(හෝ අයිපයිතන් ).

ගොනුවක් එන්කෝඩ් කරන්න:

 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)

ඇත්ත වශයෙන්ම, මෙහෙයුම් දෙකම ඔන්ලයින් යන්ත්‍රයක් බවට පරිවර්තනය කළ හැකි නමුත් මේ ආකාරයෙන් එය වඩාත් කියවිය හැකිය.

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

-out/ ඉවත් කිරීමෙන් -output... filenamestdout වෙත මුද්‍රණය කෙරේ.

base64

OSX සහ උබුන්ටු යන දෙවර්ගයේම තවත් ootb උපයෝගීතාවයක් ඇත:

## 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

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

කොහෙද නම ද කේතනාංකය සහිත ශීර්ෂය තුළ ප්රදර්ශනය කිරීමට නම.

උදාහරණයක්:

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

හෝ

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

කිසියම් හේතුවක් නිසා, echo -n <data> | openssl base64මගේ base64 දත්ත මධ්‍යයේ නව රේඛාවක් එක් කරන ලදි. මම හිතන්නේ මගේ base64 දත්ත ඇත්තටම දිගු නිසා.

භාවිතා echo -n <data> | base64ආවරණ සහ echo -n <base64-ed data> | base64 -Dවැඩ දඩ විකේතනය.

ඉහත ස්ටීව් ෆෝලිගේ පිළිතුරට අමතරව, ස්ටැඩින් මාදිලියේ සංකේතාංකනය කිරීමේදී, අමතර නව රේඛා සම්මත වීම වළක්වා ගැනීම සඳහා, අතිරේක නව රේඛා නොමැතිව ආදානය අවසන් කිරීමට CTRL + D දෙවරක් ඔබන්න. ප්‍රතිදානය එකම පේළියට පසුව පෙන්වනු ඇත.

උදාහරණයක් වශයෙන්:

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

විකල්පයක් ලෙස, ඔබට භාවිතා කළ හැකිය printf:

$ printf 'input' | openssl base64
aW5wdXQ=
$

පර්ල් ප්ලස් MIME :: Base64:

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

මෙය පෙර ස්ථාපනය කර ඇත. විධාන රේඛාවේ ඔබට වෙනම ලිපිගොනු නියම කළ හැකිය (නැතහොත් සම්මත ආදානයේ දත්ත සැපයීම); සෑම ගොනුවක්ම වෙන වෙනම කේතනය කර ඇත. ඔබට ද කළ හැකිය:

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

මෙය file1 ට file1.txt වෙත උපස්ථ වන අතර මුල් ගොනුවට වඩා Base-64 කේතනය කළ ප්‍රතිදානය ලියයි.

සරල NodeJS අනුවාදය:

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

recode ඔබ වෙනුවෙන් උපක්‍රමය කළ යුතුය

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

OSP සඳහා මැක්පෝර්ට්ස් හරහා රෙකෝඩ් ලබා ගත හැකිය .

ඔබ පදනම් 64 අකුරු ගොනුවක් කේතනය කරන්නේ නම්, ඔබට මෙය කළ හැකිය:

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

මම මෙය නිතරම මැක් (10.10) මත භාවිතා කරමි.

සටහන : රේඛීය කඩනයන් නොමැත.

හරස් වේදිකා විසඳුම්

ගොනුවක් පදනම් 64 ලෙස කේතනය කිරීම සඳහා අපි හරස් වේදිකා ෂෙල් විධාන ලැයිස්තුවක් සම්පාදනය කළෙමු. පහත දැක්වෙන විධානයන් ආදාන ගොනුවක් ( deploy.keyඋදාහරණ ලෙස නම් කර ඇත) ගෙන එය නව රේඛා එතීමකින් තොරව base64 බවට පරිවර්තනය කරයි. Base64 ප්‍රතිදානය 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

ප්‍රතිදානය ගොනුවකට හරවා යැවීමට, එකතු කරන්න > base64-encoded.txt(ඔබ තෝරාගත් ගොනු නාමයක් භාවිතා කරමින්).

මෙම විධානයන් මූලාකෘතිගත කරන ලද්දේ මෙම අදින්න ඉල්ලීමේ කොටසක් ලෙස ය . නව රේඛා ඉවත් කිරීම සඳහා SSH පුද්ගලික යතුරක් කේතනය කිරීමට base64 වෙත හරස් වේදිකා ෂෙල් විධාන අවශ්‍ය විය.