So überprüfen Sie, ob eine Zeichenfolge Base64-codiert ist oder nicht

Ich möchte eine Base64-codierte Zeichenfolge dekodieren und dann in meiner Datenbank speichern. Wenn die Eingabe nicht Base64-codiert ist, muss ich einen Fehler auslösen.

Wie kann ich überprüfen, ob eine Zeichenfolge Base64-codiert ist?

Mit dem folgenden regulären Ausdruck können Sie überprüfen, ob eine Zeichenfolge base64-codiert ist oder nicht:

^([A-Za-z0-9+/]{4})*([A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)?$

Bei der Base64-Codierung lautet der Zeichensatz [A-Z, a-z, 0-9, and + /]. Wenn die Restlänge weniger als 4 beträgt, wird die Zeichenfolge mit '='Zeichen aufgefüllt .

^([A-Za-z0-9+/]{4})* bedeutet, dass die Zeichenfolge mit 0 oder mehr base64-Gruppen beginnt.

([A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)$bedeutet , dass die Schnurenden in einer von drei Formen: [A-Za-z0-9+/]{4}, [A-Za-z0-9+/]{3}=oder [A-Za-z0-9+/]{2}==.

Wenn Sie Java verwenden, können Sie tatsächlich die Commons-Codec- Bibliothek verwenden

import org.apache.commons.codec.binary.Base64;

String stringToBeChecked = "...";
boolean isBase64 = Base64.isArrayByteBase64(stringToBeChecked.getBytes());

Ja, du kannst:

• Überprüfen Sie, ob die Länge ein Vielfaches von 4 Zeichen ist
• Überprüfen Sie, ob sich jedes Zeichen in der Menge AZ, az, 0-9, +, / befindet, mit Ausnahme des Auffüllens am Ende, das aus 0, 1 oder 2 '=' Zeichen besteht

Wenn Sie erwarten, dass es sich um base64 handelt, können Sie wahrscheinlich einfach die auf Ihrer Plattform verfügbare Bibliothek verwenden, um zu versuchen , sie in ein Byte-Array zu dekodieren. Wenn dies keine gültige Base 64 ist, wird eine Ausnahme ausgelöst. Dies hängt von Ihrer Plattform ab. natürlich.

Ab Java 8 können Sie einfach java.util.Base64 verwenden , um zu versuchen, die Zeichenfolge zu dekodieren:

String someString = "...";
Base64.Decoder decoder = Base64.getDecoder();

try {
    decoder.decode(someString);
} catch(IllegalArgumentException iae) {
    // That string wasn't valid.
}

Versuchen Sie dies für PHP5

//where $json is some data that can be base64 encoded
$json=some_data;

//this will check whether data is base64 encoded or not
if (base64_decode($json, true) == true)
{          
   echo "base64 encoded";          
}
else 
{
   echo "not base64 encoded"; 
}

Verwenden Sie dies für PHP7

 //$string parameter can be base64 encoded or not

function is_base64_encoded($string){
 //this will check if $string is base64 encoded and return true, if it is.
 if (base64_decode($string, true) !== false){          
   return true;        
 }else{
   return false;
 }
}

var base64Rejex = /^(?:[A-Z0-9+\/]{4})*(?:[A-Z0-9+\/]{2}==|[A-Z0-9+\/]{3}=|[A-Z0-9+\/]{4})$/i;
var isBase64Valid = base64Rejex.test(base64Data); // base64Data is the base64 string

if (isBase64Valid) {
    // true if base64 formate
    console.log('It is base64');
} else {
    // false if not in base64 formate
    console.log('it is not in base64');
}

Überprüfen Sie , WENN die Länge der Zeichenfolge ist ein Vielfaches von 4 Aftwerwards verwenden diese Regex um sicherzustellen , dass alle Zeichen in der Zeichenfolge sind Base64 - Zeichen.

\A[a-zA-Z\d\/+]+={,2}\z

Wenn die von Ihnen verwendete Bibliothek eine neue Zeile hinzufügt, um die Regel mit maximal 76 Zeichen pro Zeile zu beachten, ersetzen Sie sie durch leere Zeichenfolgen.

Es gibt viele Varianten von Base64. Stellen Sie also fest, ob Ihre Zeichenfolge der erwarteten Variablen ähnelt . Als solche müssen Sie die Regex unten in Bezug auf den Index und Füllzeichen einzustellen (dh +, /, =).

class String
  def resembles_base64?
    self.length % 4 == 0 && self =~ /^[A-Za-z0-9+\/=]+\Z/
  end
end

Verwendung:

raise 'the string does not resemble Base64' unless my_string.resembles_base64?

Versuche dies:

public void checkForEncode(String string) {
    String pattern = "^([A-Za-z0-9+/]{4})*([A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)$";
    Pattern r = Pattern.compile(pattern);
    Matcher m = r.matcher(string);
    if (m.find()) {
        System.out.println("true");
    } else {
        System.out.println("false");
    }
}

Es ist unmöglich zu überprüfen, ob eine Zeichenfolge base64-codiert ist oder nicht. Es ist nur möglich zu überprüfen, ob diese Zeichenfolge ein Base64-codiertes Zeichenfolgenformat hat. Dies würde bedeuten, dass es sich um eine Zeichenfolge handelt, die durch Base64-Codierung erzeugt wird (um zu überprüfen, ob die Zeichenfolge gegen einen regulären Ausdruck validiert werden kann oder eine Bibliothek verwendet werden kann, können viele verwendet werden Andere Antworten auf diese Frage bieten gute Möglichkeiten, dies zu überprüfen, sodass ich nicht auf Details eingehen werde.

Beispielsweise ist string floweine gültige base64-codierte Zeichenfolge. Es ist jedoch unmöglich zu wissen, ob es sich nur um eine einfache Zeichenfolge, ein englisches Wort flowoder um eine Basis-64-codierte Zeichenfolge handelt~Z0

/^([A-Za-z0-9+\/]{4})*([A-Za-z0-9+\/]{4}|[A-Za-z0-9+\/]{3}=|[A-Za-z0-9+\/]{2}==)$/

Dieser reguläre Ausdruck hat mir geholfen, die base64 in meiner Anwendung in Rails zu identifizieren. Ich hatte nur ein Problem: Er erkennt die Zeichenfolge "errorDescripcion". Ich generiere einen Fehler, um sie zu lösen. Überprüfen Sie einfach die Länge einer Zeichenfolge.

Dies funktioniert in Python:

import base64

def IsBase64(str):
    try:
        base64.b64decode(str)
        return True
    except Exception as e:
        return False

if IsBase64("ABC"):
    print("ABC is Base64-encoded and its result after decoding is: " + str(base64.b64decode("ABC")).replace("b'", "").replace("'", ""))
else:
    print("ABC is NOT Base64-encoded.")

if IsBase64("QUJD"):
    print("QUJD is Base64-encoded and its result after decoding is: " + str(base64.b64decode("QUJD")).replace("b'", "").replace("'", ""))
else:
    print("QUJD is NOT Base64-encoded.")

Zusammenfassung: IsBase64("string here") Gibt true zurück , wenn string hereBase64-codiert ist, und false, wenn string hereNICHT Base64-codiert ist.

C # Das ist großartig:

static readonly Regex _base64RegexPattern = new Regex(BASE64_REGEX_STRING, RegexOptions.Compiled);

private const String BASE64_REGEX_STRING = @"^[a-zA-Z0-9\+/]*={0,3}$";

private static bool IsBase64(this String base64String)
{
    var rs = (!string.IsNullOrEmpty(base64String) && !string.IsNullOrWhiteSpace(base64String) && base64String.Length != 0 && base64String.Length % 4 == 0 && !base64String.Contains(" ") && !base64String.Contains("\t") && !base64String.Contains("\r") && !base64String.Contains("\n")) && (base64String.Length % 4 == 0 && _base64RegexPattern.Match(base64String, 0).Success);
    return rs;
}

Es gibt keine Möglichkeit, Zeichenfolge und Base64-Codierung zu unterscheiden, es sei denn, die Zeichenfolge in Ihrem System weist eine bestimmte Einschränkung oder Identifikation auf.

Dieses Snippet kann nützlich sein, wenn Sie die Länge des ursprünglichen Inhalts kennen (z. B. eine Prüfsumme). Es wird überprüft, ob das codierte Formular die richtige Länge hat.

public static boolean isValidBase64( final int initialLength, final String string ) {
  final int padding ;
  final String regexEnd ;
  switch( ( initialLength ) % 3 ) {
    case 1 :
      padding = 2 ;
      regexEnd = "==" ;
      break ;
    case 2 :
      padding = 1 ;
      regexEnd = "=" ;
      break ;
    default :
      padding = 0 ;
      regexEnd = "" ;
  }
  final int encodedLength = ( ( ( initialLength / 3 ) + ( padding > 0 ? 1 : 0 ) ) * 4 ) ;
  final String regex = "[a-zA-Z0-9/\\+]{" + ( encodedLength - padding ) + "}" + regexEnd ;
  return Pattern.compile( regex ).matcher( string ).matches() ;
}

Wenn die RegEx nicht funktioniert und Sie den Formatstil der ursprünglichen Zeichenfolge kennen, können Sie die Logik umkehren, indem Sie für dieses Format eine Regexing durchführen.

Zum Beispiel arbeite ich mit Base64-codierten XML-Dateien und überprüfe nur, ob die Datei ein gültiges XML-Markup enthält. Wenn nicht, kann ich davon ausgehen, dass es base64 dekodiert ist. Dies ist nicht sehr dynamisch, funktioniert aber gut für meine kleine Anwendung.

Dies funktioniert in Python:

def is_base64(string):
    if len(string) % 4 == 0 and re.test('^[A-Za-z0-9+\/=]+\Z', string):
        return(True)
    else:
        return(False)

Versuchen Sie dies mit einem zuvor erwähnten regulären Ausdruck:

String regex = "^([A-Za-z0-9+/]{4})*([A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)$";
if("TXkgdGVzdCBzdHJpbmc/".matches(regex)){
    System.out.println("it's a Base64");
}

... Wir können auch eine einfache Validierung durchführen, z. B. wenn Leerzeichen vorhanden sind, kann es sich nicht um Base64 handeln:

String myString = "Hello World";
 if(myString.contains(" ")){
   System.out.println("Not B64");
 }else{
    System.out.println("Could be B64 encoded, since it has no spaces");
 }

Wenn beim Dekodieren eine Zeichenfolge mit ASCII-Zeichen angezeigt wird, wurde die Zeichenfolge nicht codiert

(RoR) Rubinlösung:

def encoded?(str)
  Base64.decode64(str.downcase).scan(/[^[:ascii:]]/).count.zero?
end

def decoded?(str)
  Base64.decode64(str.downcase).scan(/[^[:ascii:]]/).count > 0
end

Ich versuche das zu benutzen, ja das hier funktioniert

^([A-Za-z0-9+/]{4})*([A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)?$

aber ich habe die Bedingung hinzugefügt, um zu überprüfen, ob mindestens das Ende des Zeichens = ist

string.lastIndexOf("=") >= 0