PHPのお勉強!

PHP TOP

base64_encode

(PHP 4, PHP 5, PHP 7, PHP 8)

base64_encodeMIME base64 方式でデータをエンコードする

説明

base64_encode(string $string): string

指定した string を base64 でエンコードします。

このエンコードは、メールの本体のように 8 ビットクリーンではないトランスポート層を通じても、 バイナリデータが生き残れるように設計されています。

Base64 でエンコードされたデータは、エンコード前のデータにくらべて 33% 余計に容量が必要です。

パラメータ

string

エンコードするデータ。

戻り値

エンコードされたデータを文字列で返します。

例1 base64_encode() の例

<?php
$str
= 'This is an encoded string';
echo
base64_encode($str);
?>

上の例の出力は以下となります。

VGhpcyBpcyBhbiBlbmNvZGVkIHN0cmluZw==

参考

add a note

User Contributed Notes 32 notes

up
265
gutzmer at usa dot net
13 years ago
For anyone interested in the 'base64url' variant encoding, you can use this pair of functions:

<?php
function base64url_encode($data) {
return
rtrim(strtr(base64_encode($data), '+/', '-_'), '=');
}

function
base64url_decode($data) {
return
base64_decode(str_pad(strtr($data, '-_', '+/'), strlen($data) % 4, '=', STR_PAD_RIGHT));
}
?>
up
34
Rasmus Schultz
6 years ago
In PHP 7, the padding issue with base64_decode() is no more - the following is totally fine:

function base64_encode_url($string) {
return str_replace(['+','/','='], ['-','_',''], base64_encode($string));
}

function base64_decode_url($string) {
return base64_decode(str_replace(['-','_'], ['+','/'], $string));
}

Checked here with random_bytes() and random lengths:

https://3v4l.org/aEs4o
up
33
biziclop at vipmail dot hu
7 years ago
gutzmer at usa dot net's ( http://php.net/manual/en/function.base64-encode.php#103849 ) base64url_decode() function doesn't pad longer strings with '='s. Here is a corrected version:

<?php
function base64url_encode( $data ){
return
rtrim( strtr( base64_encode( $data ), '+/', '-_'), '=');
}

function
base64url_decode( $data ){
return
base64_decode( strtr( $data, '-_', '+/') . str_repeat('=', 3 - ( 3 + strlen( $data )) % 4 ));
}

// proof
for( $i = 0, $s = ''; $i < 24; ++$i, $s .= substr("$i", -1 )){
$base64_encoded = base64_encode( $s );
$base64url_encoded = base64url_encode( $s );
$base64url_decoded = base64url_decode( $base64url_encoded );
$base64_restored = strtr( $base64url_encoded, '-_', '+/')
.
str_repeat('=',
3 - ( 3 + strlen( $base64url_encoded )) % 4
);
echo
"$s<br>$base64url_decoded<br>$base64_encoded<br>$base64_restored<br>$base64url_encoded<br><br>";
}
?>
up
1
Daniel Klein
2 years ago
Improvement on "gutzmer at usa dot net", "biziclop at vipmail dot hu", and "ivanm at duck dot com".

<?php
function base64url_encode($data) {
return
rtrim(strtr(base64_encode($data), '+/', '-_'), '=');
}

function
base64url_decode($data) {
return
base64_decode(strtr($data, '-_', '+/'));
}
?>

None of the padding for strings longer than 4 characters worked. Padding the decode function with = is unnecessary, and has been since at least PHP 5.4 (as far back as I checked before posting) so I removed it.
up
20
Hayley Watson
11 years ago
Base64 encoding of large files.

Base64 encoding converts triples of eight-bit symbols into quadruples of six-bit symbols. Reading the input file in chunks that are a multiple of three bytes in length results in a chunk that can be encoded independently of the rest of the input file. MIME additionally enforces a line length of 76 characters plus the CRLF. 76 characters is enough for 19 quadruples of six-bit symbols thus representing 19 triples of eight-bit symbols. Reading 57 eight-bit symbols provides exactly enough data for a complete MIME-formatted line. Finally, PHP's default buffer size is 8192 bytes - enough for 143 MIME lines' worth of input.

So if you read from the input file in chunks of 8151 (=57*143) bytes you will get (up to) 8151 eight-bit symbols, which encode as exactly 10868 six-bit symbols, which then wrap to exactly 143 MIME-formatted lines. There is no need to retain left-over symbols (either six- or eight-bit) from one chunk to the next. Just read a chunk, encode it, write it out, and go on to the next chunk. Obviously the last chunk will probably be shorter, but encoding it is still independent of the rest.

<?php

while(!feof($input_file))
{
$plain = fread($input_file, 57 * 143);
$encoded = base64_encode($plain);
$encoded = chunk_split($encoded, 76, "\r\n");
fwrite($output_file, $encoded);
}

?>

Conversely, each 76-character MIME-formatted line (not counting the trailing CRLF) contains exactly enough data for 57 bytes of output without needing to retain leftover bits that need prepending to the next line. What that means is that each line can be decoded independently of the others, and the decoded chunks can then be concatenated together or written out sequentially. However, this does make the assumption that the encoded data really is MIME-formatted; without that assurance it is necessary to accept that the base64 data won't be so conveniently arranged.
up
16
MitMacher
15 years ago
Unfortunately my "function" for encoding base64 on-the-fly from 2007 [which has been removed from the manual in favor of this post] had 2 errors!
The first led to an endless loop because of a missing "$feof"-check, the second caused the rare mentioned errors when encoding failed for some reason in larger files, especially when
setting fgets($fh, 2) for example. But lower values then 1024 are bad overall because they slow down the whole process, so 4096 will be fine for all purposes, I guess.
The error was caused by the use of "empty()".

Here comes the corrected version which I have tested for all kind of files and length (up to 4,5 Gb!) without any error:

<?php
$fh
= fopen('Input-File', 'rb');
//$fh2 = fopen('Output-File', 'wb');

$cache = '';
$eof = false;

while (
1) {

if (!
$eof) {
if (!
feof($fh)) {
$row = fgets($fh, 4096);
} else {
$row = '';
$eof = true;
}
}

if (
$cache !== '')
$row = $cache.$row;
elseif (
$eof)
break;

$b64 = base64_encode($row);
$put = '';

if (
strlen($b64) < 76) {
if (
$eof) {
$put = $b64."\n";
$cache = '';
} else {
$cache = $row;
}

} elseif (
strlen($b64) > 76) {
do {
$put .= substr($b64, 0, 76)."\n";
$b64 = substr($b64, 76);
} while (
strlen($b64) > 76);

$cache = base64_decode($b64);

} else {
if (!
$eof && $b64{75} == '=') {
$cache = $row;
} else {
$put = $b64."\n";
$cache = '';
}
}

if (
$put !== '') {
echo
$put;
//fputs($fh2, $put);
//fputs($fh2, base64_decode($put)); // for comparing
}
}

//fclose($fh2);
fclose($fh);
?>
up
19
luke at lukeoliff.com
13 years ago
A function I'm using to return local images as base64 encrypted code, i.e. embedding the image source into the html request.

This will greatly reduce your page load time as the browser will only need to send one server request for the entire page, rather than multiple requests for the HTML and the images. Requests need to be uploaded and 99% of the world are limited on their upload speed to the server.

<?php
function base64_encode_image ($filename=string,$filetype=string) {
if (
$filename) {
$imgbinary = fread(fopen($filename, "r"), filesize($filename));
return
'data:image/' . $filetype . ';base64,' . base64_encode($imgbinary);
}
}
?>

used as so

<style type="text/css">
.logo {
background: url("<?php echo base64_encode_image ('img/logo.png','png'); ?>") no-repeat right 5px;
}
</style>

or

<img src="<?php echo base64_encode_image ('img/logo.png','png'); ?>"/>
up
2
ivanm at duck dot com
2 years ago
Slight improvement on the padding problem in gutzmer at usa dot net (https://www.php.net/manual/en/function.base64-encode.php#103849) and biziclop at vipmail dot hu (https://www.php.net/manual/en/function.base64-encode.php#121767):

<?php
function base64url_encode($data) {
return
rtrim(strtr(base64_encode($data), '+/', '-_'), '=');
}

function
base64url_decode($data) {
return
base64_decode(str_pad(strtr($data, '-_', '+/'), 4 - ((strlen($data) % 4) ?: 4), '=', STR_PAD_RIGHT));
}
?>
up
5
massimo dot scamarcia at gmail dot com
18 years ago
function urlsafe_b64encode($string) {
$data = base64_encode($string);
$data = str_replace(array('+','/','='),array('-','_',''),$data);
return $data;
}

function urlsafe_b64decode($string) {
$data = str_replace(array('-','_'),array('+','/'),$string);
$mod4 = strlen($data) % 4;
if ($mod4) {
$data .= substr('====', $mod4);
}
return base64_decode($data);
}

Php version of perl's MIME::Base64::URLSafe, that provides an url-safe base64 string encoding/decoding (compatible with python base64's urlsafe methods)
up
1
dawgeatschikin at hotmail dot com
18 years ago
Just a minor tweak of massimo's functions.

<?
$data = str_replace(array('+','/','='),array('-','_','.'),$data);
//replace '=' with '.' instead of with nothing, that way the process is reversible. '.' is uri-safe according to http://www.w3.org/Addressing/URL/5_URI_BNF.html
?>
up
1
Gabriel Malca
18 years ago
If the function doesn't exist, this is a messy but effective way of doing it:

<?

echo bencode("Gabriel Malca");
// R2FicmllbCBNYWxjYQ==

function bencode($string='') {
$binval = convert_binary_str($string);
$final = "";
$start = 0;
while ($start < strlen($binval)) {
if (strlen(substr($binval,$start)) < 6)
$binval .= str_repeat("0",6-strlen(substr($binval,$start)));
$tmp = bindec(substr($binval,$start,6));
if ($tmp < 26)
$final .= chr($tmp+65);
elseif ($tmp > 25 && $tmp < 52)
$final .= chr($tmp+71);
elseif ($tmp == 62)
$final .= "+";
elseif ($tmp == 63)
$final .= "/";
elseif (!$tmp)
$final .= "A";
else
$final .= chr($tmp-4);
$start += 6;
}
if (strlen($final)%4>0)
$final .= str_repeat("=",4-strlen($final)%4);
return $final;
}

function convert_binary_str($string) {
if (strlen($string)<=0) return;
$tmp = decbin(ord($string[0]));
$tmp = str_repeat("0",8-strlen($tmp)).$tmp;
return $tmp.convert_binary_str(substr($string,1));
}

?>
up
0
jonb at wobblymusic dot com
15 years ago
Note that some applications, such as OpenSSL's enc command, require that there be a line break every 64 characters in order for their base64 decode function to work. The following function will take care of this problem:

<?php
function ($encodeMe) {
$data = base64_encode($encodeMe);
$datalb = "";
while (
strlen($data) > 64) {
$datalb .= substr($data, 0, 64) . "\n";
$data = substr($data,64);
}
$datalb .= $data;
return
$datalb;
}
?>
up
-1
Naser Mirzaei
10 years ago
<?php
$image
= 'example.png';

// Read image path, convert to base64 encoding
$imageData = base64_encode(file_get_contents($image));

// Format the image SRC: data:{mime};base64,{data};
$src = 'data: '.mime_content_type($image).';base64,'.$imageData;

// Echo out a sample image
echo "<img src=\"$src\" alt=\"\" />";
?>
up
0
massimo dot scamarcia at gmail dot com
18 years ago
$data = str_replace(array('+','/','='),array('-','_',),$data); // MIME::Base64::URLSafe implementation

$data = str_replace(array('+','/'),array('-','_'),$data); // Python raise "TypeError: Incorrect padding" if you remove "=" chars when decoding
up
0
juha at kuhazor dot idlegames dot com
20 years ago
If you use base64encoded strings as cookie names, make sure you remove '=' characters. At least Internet Explorer refuses cookie names containing '=' characters or urlencoded cookie names containing %xx character replacements. Use the function below to turn base64 encoded strings to bare alphabets (get rid of / and + characters as well)

<?php
function base64clean($base64string)
{
$base64string = str_replace(array('=','+','/'),'',$base64string);

return
$base64string;
}
?>
up
-1
Gerard
11 years ago
To make base64_encode encode a URL safe string compatible with .net HttpServerUtility.UrlTokenEncode function use this:

<?php
url_safe_base64_encode
($string)
{
#First base64 encode
$data = base64_encode($string);

#Base64 strings can end in several = chars. These need to be translated into a number
$no_of_eq = substr_count($data, "=");
$data = str_replace("=", "", $data);
$data = $data.$no_of_eq;

#Then replace all non-url safe characters
$data = str_replace(array('+','/'),array('-','_'),$data);
return
$data;
}
?>
up
-1
Andi
16 years ago
I needed a simple way to obfuscate auto_increment primary keys in databases when they are visible to users in URIs or API calls. The users should not be able to increment the id in the URL and see the next data record in the database table.

My solution (uses modified base64 functions by Tom):

function base64url_encode($plainText) {

$base64 = base64_encode($plainText);
$base64url = strtr($base64, '+/=', '-_,');
return $base64url;
}

function base64url_decode($plainText) {

$base64url = strtr($plainText, '-_,', '+/=');
$base64 = base64_decode($base64url);
return $base64;
}

function encryptId($int, $class='') {

return base64url_encode($int.'-'.substr(sha1($class.$int.encryptionKey), 0, 6));
}

function decryptId($string, $class='') {

$parts = explode('-', base64url_decode($string));
if (count($parts) != 2) {

return 0;
}

$int = $parts[0];
return substr(sha1($class.$int.encryptionKey), 0, 6) === $parts[1]
? (int)$int
: 0;
}

- The optional 2nd argument is the class name, so two equal ids of different tables will not result in two equal obfuscated ids.

- encryptionKey is a global secret key for encryption.

- decryptId() checks if the second part of the base64 encoded string is correct.
up
-1
Tom
18 years ago
This function supports "base64url" as described in Section 5 of RFC 4648, "Base 64 Encoding with URL and Filename Safe Alphabet"

<?php
function base64url_encode($plainText)
{
$base64 = base64_encode($plainText);
$base64url = strtr($base64, '+/', '-_');
return (
$base64url);
}
?>

You may wish to rtrim (or escape) trailing ='s for use in a URI.
up
-1
guy at bhaktiandvedanta dot com
22 years ago
You can use base64_encode to transfer image file into string text and then display them. I used this to store my images in a database and display them form there. First I open the files using fread, encoded the result, and stored that result in the database. Useful for creating random images.

image.php:

<?

header(" Content-Type: image/jpeg");
header(" Content-Disposition: inline");
$sql = "SELECT data FROM image where name='".$img."'";
$result = mysql_query($sql);
$row = mysql_fetch_row($result);
$image = $row[0];
echo base64_decode($image);

?>

And in the html file you put:

<img src="image.php?img=test3" border="0" alt="">

Guy Laor
up
-3
andronick(dot)mail(dog)gmail(dot)com
14 years ago
output images into html:

<?php

$imgfile
= "test.gif";

$handle = fopen($filename, "r");

$imgbinary = fread(fopen($imgfile, "r"), filesize($imgfile));

echo
'<img src="data:image/gif;base64,' . base64_encode($imgbinary) . '" />';

?>

gif - data:image/gif;base64,...
jpg - data:image/jpeg;base64,...
png - data:image/png;base64,...
etc.