Come verificare se una stringa è codificata Base64 oppure no

Voglio decodificare una stringa codificata Base64, quindi memorizzarla nel mio database. Se l'input non è codificato Base64, devo generare un errore.

Come posso verificare se una stringa è codificata Base64?

È possibile utilizzare la seguente espressione regolare per verificare se una stringa è codificata base64 o meno:

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

Nella codifica base64, il set di caratteri è [A-Z, a-z, 0-9, and + /]. Se la lunghezza del resto è inferiore a 4, la stringa è riempita con '='caratteri.

^([A-Za-z0-9+/]{4})* indica che la stringa inizia con 0 o più gruppi base64.

([A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)$intendono le estremità delle corde in una delle tre forme: [A-Za-z0-9+/]{4}, [A-Za-z0-9+/]{3}=o [A-Za-z0-9+/]{2}==.

Se stai usando Java, puoi effettivamente usare la libreria commons-codec

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

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

Bene puoi:

• Verifica che la lunghezza sia un multiplo di 4 caratteri
• Controlla che ogni carattere sia nel set AZ, az, 0-9, +, / tranne che per il riempimento alla fine che sia 0, 1 o 2 caratteri '='

Se ci si aspetta che sarà in Base64, allora probabilmente si può semplicemente usare qualsiasi libreria è disponibile sulla vostra piattaforma per cercare di decodificare in un array di byte, un'eccezione se non è valida base 64. Tale dipende dalla vostra piattaforma, ovviamente.

A partire da Java 8, puoi semplicemente usare java.util.Base64 per provare a decodificare la stringa:

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

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

Prova in questo modo per 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"; 
}

Usa questo per 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');
}

Controlla se la lunghezza della stringa è un multiplo di 4. In seguito usa questa regex per assicurarti che tutti i caratteri nella stringa siano caratteri base64.

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

Se la libreria che usi aggiunge una nuova riga come modo di osservare i 76 caratteri massimi per regola di riga, sostituiscili con stringhe vuote.

Esistono molte varianti di Base64 , quindi prendi in considerazione solo la possibilità di stabilire se la stringa è simile alla varietà che prevedi di gestire. Come tale, potrebbe essere necessario regolare l'espressione regolare sotto rispetto ai caratteri dell'indice e imbottitura (cioè +, /, =).

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

Uso:

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

Prova questo:

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");
    }
}

È impossibile verificare se una stringa è codificata in base64 o meno. È possibile validare solo se quella stringa ha un formato stringa codificato in base64, il che significherebbe che potrebbe essere una stringa prodotta dalla codifica base64 (per verificare che la stringa possa essere convalidata rispetto a una regexp o che sia possibile utilizzare una libreria, molti altre risposte a questa domanda forniscono buoni modi per verificarlo, quindi non entrerò nei dettagli).

Ad esempio, stringa flowè una stringa codificata in base64 valida. Ma è impossibile sapere se è solo una stringa semplice, una parola inglese flowo è una stringa codificata in base 64~Z0

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

questa espressione regolare mi ha aiutato a identificare la base64 nella mia applicazione in rotaie, ho avuto solo un problema, è che riconosce la stringa "errorDescripcion", ho generato un errore, per risolverlo basta convalidare la lunghezza di una stringa.

Questo funziona 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.")

Riepilogo: IsBase64("string here") restituisce true se string hereè codificato Base64 e restituisce false se string hereNON è codificato Base64.

C # Questo sta andando alla grande:

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;
}

Non è possibile distinguere tra stringa e codifica base64, tranne per il fatto che la stringa nel proprio sistema presenta alcune limitazioni o identificazioni specifiche.

Questo frammento può essere utile quando conosci la lunghezza del contenuto originale (ad esempio un checksum). Verifica che la forma codificata abbia la lunghezza corretta.

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() ;
}

Se RegEx non funziona e si conosce lo stile del formato della stringa originale, è possibile invertire la logica, regexing per questo formato.

Ad esempio, lavoro con file xml con codifica base64 e controllo solo se il file contiene markup xml validi. In caso contrario, posso presumere che sia decodificato in base64. Questo non è molto dinamico ma funziona bene per la mia piccola applicazione.

Questo funziona 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)

Prova questo usando una regex menzionata in precedenza:

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");
}

... Possiamo anche fare una semplice validazione come, se ha spazi non può essere Base64:

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");
 }

se durante la decodifica otteniamo una stringa con caratteri ASCII, la stringa non è stata codificata

(RoR) soluzione di rubino:

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

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

Provo a usare questo, sì, questo funziona

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

ma ho aggiunto la condizione per verificare che almeno la fine del personaggio sia =

string.lastIndexOf("=") >= 0