wake-up-neo.com

So prüfen Sie, ob ein String in base64 gültig ist PHP

Ich habe eine Zeichenfolge und möchte mit PHP testen, ob es sich um eine gültige Base64-Verschlüsselung handelt oder nicht.

48
Alias

Ich weiß, dass dies ein altes Thema ist, aber die Verwendung des strikten Parameters ist nicht unbedingt hilfreich.

Das Ausführen von base64_decode in einer Zeichenfolge wie "Ich bin keine 64-codierte Basisstation" gibt nicht "false" zurück.

Wenn Sie jedoch versuchen, den String mit strict zu decodieren und ihn mit base64_encode erneut zu codieren, können Sie das Ergebnis mit den Originaldaten vergleichen, um festzustellen, ob es sich um einen gültigen bas64-codierten Wert handelt:

if ( base64_encode(base64_decode($data, true)) === $data){
    echo '$data is valid';
} else {
    echo '$data is NOT valid';
}
85
PottyBert

Sie können diese Funktion verwenden:

 function is_base64($s)
{
      return (bool) preg_match('/^[a-zA-Z0-9\/\r\n+]*={0,2}$/', $s);
}
20
Vega

Dieser Code sollte funktionieren, da die Decodierungsfunktion FALSE zurückgibt, wenn die Zeichenfolge nicht gültig ist:

if (base64_decode($mystring, true)) {
    // is valid
} else {
    // not valid
}

Mehr über die Funktion base64_decode erfahren Sie in der Dokumentation .

10
EdoDodo

Ich denke, die einzige Möglichkeit, dies zu tun, besteht darin, eine base64_decode() mit dem $strict-Parameter auf true zu setzen und zu sehen, ob es false zurückgibt.

6
Pekka 웃

Nur für Zeichenfolgen können Sie diese Funktion verwenden, die mehrere base64-Eigenschaften überprüft, bevor sie true zurückgibt:

function is_base64($s){
    // Check if there are valid base64 characters
    if (!preg_match('/^[a-zA-Z0-9\/\r\n+]*={0,2}$/', $s)) return false;

    // Decode the string in strict mode and check the results
    $decoded = base64_decode($s, true);
    if(false === $decoded) return false;

    // Encode the string again
    if(base64_encode($decoded) != $s) return false;

    return true;
}
4
merlucin

Dies ist eine wirklich alte Frage, aber ich fand den folgenden Ansatz praktisch kugelsicher. Es berücksichtigt auch die seltsamen Zeichenfolgen mit ungültigen Zeichen, die beim Validieren eine Ausnahme auslösen würden.

    public static function isBase64Encoded($str) 
{
    try
    {
        $decoded = base64_decode($str, true);

        if ( base64_encode($decoded) === $str ) {
            return true;
        }
        else {
            return false;
        }
    }
    catch(Exception $e)
    {
        // If exception is caught, then it is not a base64 encoded string
        return false;
    }

}

Ich habe die Idee von dieser Seite und an PHP angepasst.

2
Lucio Mollinedo

Ich schreibe, dass diese Methode bei meinen Projekten perfekt funktioniert. Wenn Sie das base64-Image an diese Methode übergeben, geben Sie true zurück, andernfalls false. Lassen Sie uns versuchen, etwas Falsches mitzuteilen. Ich werde in der Funktion bearbeiten und lernen.

/**
 * @param $str
 * @return bool
 */
private function isValid64base($str){
    if (base64_decode($str, true) !== false){
        return true;
    } else {
        return false;
    }
}
1
Niroshan

Ich habe folgendes versucht:

  • base64 decodiert den String mit dem strikten Parameter auf true.
  • base64 codiert das Ergebnis des vorherigen Schritts. Wenn das Ergebnis nicht mit der Originalzeichenfolge übereinstimmt, wird die Originalzeichenfolge nicht Base64-kodiert
  • wenn das Ergebnis mit der vorherigen Zeichenfolge identisch ist, prüfen Sie, ob die dekodierte Zeichenfolge druckbare Zeichen enthält. Ich habe die PHP-Funktion ctype_print verwendet, um nach nicht druckbaren Zeichen zu suchen. Die Funktion gibt false zurück, wenn die Eingabezeichenfolge ein oder mehrere nicht druckbare Zeichen enthält.

Der folgende Code implementiert die obigen Schritte:

public function IsBase64($data) {
    $decoded_data = base64_decode($data, true);
    $encoded_data = base64_encode($decoded_data);
    if ($encoded_data != $data) return false;
    else if (!ctype_print($decoded_data)) return false;

    return true;
}

Der obige Code kann unerwartete Ergebnisse zurückgeben. Für die Zeichenfolge "json" wird beispielsweise false zurückgegeben. "json" kann eine gültige Base64-codierte Zeichenfolge sein, da die Anzahl der Zeichen, die es enthält, ein Vielfaches von 4 ist und alle Zeichen im zulässigen Bereich für Base64-codierte Zeichenfolgen liegen. Es scheint, dass wir den Bereich der zulässigen Zeichen der Originalzeichenfolge kennen müssen und dann prüfen müssen, ob die decodierten Daten diese Zeichen enthalten.

0
Nadir Latif

ich weiß, dass ich eine sehr alte Frage aufgreife und alle vorgeschlagenen Methoden ausprobiert habe. Ich habe schließlich diese Regex, die fast alle meine Fälle abdeckt:

$decoded = base64_decode($string, true);
if (0 < preg_match('/((?![[:graph:]])(?!\s)(?!\p{L}))./', $decoded, $matched)) return false;

im Grunde überprüfe ich für jedes Zeichen, das nicht druckbar ist (: Graph :) ist kein Leerzeichen oder Tabulator (\ s) und kein Unicode-Buchstabe (alle Akzente wie: èéùìà usw.).

ich bekomme immer noch ein falsch positives Ergebnis mit diesen Zeichen: £ § °, aber ich verwende sie niemals in einer Zeichenfolge und ist vollkommen in Ordnung, um sie zu entwerten ... Ich fasse diese Prüfung mit der von @merlucin vorgeschlagenen Funktion zusammen

so das Ergebnis:

function is_base64($s)
{
  // Check if there are valid base64 characters
  if (!preg_match('/^[a-zA-Z0-9\/\r\n+]*={0,2}$/', $s)) return false;

  // Decode the string in strict mode and check the results
  $decoded = base64_decode($s, true);
  if(false === $decoded) return false;

  // if string returned contains not printable chars
  if (0 < preg_match('/((?![[:graph:]])(?!\s)(?!\p{L}))./', $decoded, $matched)) return false;

  // Encode the string again
  if(base64_encode($decoded) != $s) return false;

  return true;
}
0
m47730

Sie können die Zeichenfolge einfach durch base64_decode senden (wobei $ strict auf TRUE gesetzt ist). Wenn die Eingabe ungültig ist, wird FALSE zurückgegeben.

Sie können auch f.i verwenden. reguläre Ausdrücke sehen, ob die Zeichenfolge Zeichen außerhalb des base64-Alphabets enthält, und überprüfen, ob sie am Ende die richtige Auffüllung enthält (=-Zeichen). Die Verwendung von base64_decode ist jedoch viel einfacher und es sollte nicht die Gefahr bestehen, dass eine fehlerhafte Zeichenfolge Schaden verursacht.

0
Wim

base64_decode () sollte false zurückgeben, wenn Ihre base64-codierten Daten nicht gültig sind.

0
Scoop

Altes Thema, aber ich habe diese Funktion gefunden und es funktioniert:

function checkBase64Encoded($encodedString) {
$length = strlen($encodedString);

// Check every character.
for ($i = 0; $i < $length; ++$i) {
$c = $encodedString[$i];
if (
($c < '0' || $c > '9')
&& ($c < 'a' || $c > 'z')
&& ($c < 'A' || $c > 'Z')
&& ($c != '+')
&& ($c != '/')
&& ($c != '=')
) {
// Bad character found.
return false;
}
}
// Only good characters found.
return true;
}
0
Klian

Ich programmiere eine Lösung, um Bilder zu überprüfen, die die Sintaxie überprüfen

$image = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAABfVBMVEUAAAAxMhQAoIpFLCTimAE2IRs0IBodEg4OJyEAnYcAmoUAjnoALyn5rgNJLydEKyM5lWFFLCTuogI/JyBAKCHZnQoAlIAAkn48JR6fYgCIVACDUACPbAsAW06IWgAaDw0jFQscEQ4Am4XIfQDGewDhlwHelQEAi3gAe2oAd2cAXE8gFBAeEg8AVEgAtJwAsZn/vhMAuJ//xyMAu6BfQTf/wxv9wRlcPjVhQjj/vBBdQDb/xR9oSD1iRDlWOjH9xSL/uQr+twhkRTplRjxZPDPZpydILydAQD+pezNjRTNQNS3tuCZGLSX4sQn/tQTllgDhkgAArZUAqJFvTUD/wRgGtpp2m0aPaTl+azOIcjGkhS6OaS1ONCvNnirHmSrnsifHnSfFjyemfCfcqSa/jyLwuR/ptB/MmRxiPhnpqRX1sxHzqwnCfgb+tQTYjALnmQH2qQDzpQDejgAnsYQnsYNwTkBlRTtfQi9eQS+1kCy2kSuFYSuEYSvkpRfrqxQPeVhkAAAALnRSTlMADPz0qnhzNBPry5kH/vr36ubKxLy4sKmifVVNQT84Ih4Y2aWloqKMgHdJPDwse8ZSvQAAAbVJREFUOMuV0uVzggAYx3Gsbca6u3vDqSDqBigD25nrLrvX+bfvMSeId9vnBXD3+97zCuQ/ZhUDvV1dvQOKWfFdIWOZHfDMyhRi+4ibZHZLwS5Dukea97YzzAQFYEgTdtYm3DtkhAUKkmFI0mTCCFmH8ICbsEBRhmEWwi080U+xBNwApZlgqX7+rummWJcLEkAQLhdLdWt4wbSXOqX1Hu784uKc8+jpU8o7zQva7RSnb8BR9nZesGF/oelLT2X1XNL0q31dcOGDPnwKO7eBMxw+pD8FF2a8N9vcyfttKbh9O+HwG+8MLxiL3+FXDsc9Du4djiv8Lj7GC0bTMTx6dGzEgfH4KIrH0qO8YDyQjESMvyLJwDjCs5DaKsvlzOV3ah4RkFcCM+wlckRoymcG107ntRn4ppAmSzar9Tvh830lrFbbItJM0meDBcCzT4KIFfLOzB7IdMphFzUxWMjnC4MToqNkbWVY1RPw+wM9quHVSY1gnhyShlCd4aHo9xcfDTptSKnebPxjh0Kooewgmz2ofKFStaS+z2l1Nfv79c+gqlaog6io4HI1UKItKKuBVNuCFPmDH12fd4lDaGbkAAAAAElFTkSuQmCC';
$allowedExtensions = ['png', 'jpg', 'jpeg'];

// check if the data is empty
if (empty($image)) {
    echo "Empty data";
}

// check base64 format
$explode = explode(',', $image);
if(count($explode) !== 2){
    echo "This string isn't sintaxed as base64";
}
//https://stackoverflow.com/a/11154248/4830771
if (!preg_match('%^[a-zA-Z0-9/+]*={0,2}$%', $explode[1])) {
    echo "This string isn't sintaxed as base64";
}

// check if type is allowed
$format = str_replace(
        ['data:image/', ';', 'base64'], 
        ['', '', '',], 
        $explode[0]
);
if (!in_array($format, $allowedExtensions)) {
    echo "Image type isn't allowed";
}
echo "This image is base64";

Aber ein sicherer Weg ist die Verwendung von Intervention

use Intervention\Image\ImageManagerStatic;
try {
    ImageManagerStatic::make($value);
    return true;
} catch (Exception $e) {
    return false;
}
0
Ennio Sousa