Comment vérifier si une chaîne est encodée en base64 ou non

Si vous utilisez Java, vous pouvez réellement utiliser communes-codec bibliothèque

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

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

Eh Bien, vous pouvez:

• Vérifier que la longueur est un multiple de 4 caractères
• Vérifiez que chaque caractère est dans L'ensemble A-Z, a-z, 0-9,+, / sauf pour le remplissage à la fin qui est 0, 1 ou 2 '=' caractères

Si vous vous attendez à ce que soit base64, alors vous pouvez probablement utiliser n'importe quelle bibliothèque disponible sur votre plate-forme pouressayer de le décoder en un tableau d'octets, en lançant une exception si elle n'est pas valide base 64. Cela dépend de votre plate-forme, bien sûr.

Essayez comme ceci pour 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"; 
}

Vérifiez SI la longueur de la chaîne est un multiple de 4. Aftwerwards utilise cette expression rationnelle pour s'assurer que tous les caractères dans la chaîne sont des caractères base64.

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

Si la bibliothèque que vous utilisez ajoute une nouvelle ligne pour observer la règle 76 caractères maximum par ligne, remplacez-les par des chaînes vides.

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

Depuis Java 8, Vous pouvez simplement utiliser java.util.Base64 pour essayer de décoder la chaîne:

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

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

Il existe de nombreuses variantes de Base64 , alors pensez simplement à déterminer si votre chaîne ressemble à la variable que vous attendez de gérer. En tant que tel, vous devrez peut-être ajuster l'expression rationnelle ci-dessous par rapport aux caractères d'index et de remplissage (c'est-à-dire +, /, =).

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

Utilisation:

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

C# Cela fonctionne très bien:

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

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

Cette expression régulière m'a aidé à identifier le base64 dans mon application dans rails, je n'ai eu qu'un seul problème, c'est qu'il reconnaît la chaîne "errorDescripcion", je génère une erreur, pour le résoudre juste valider le long de la chaîne.

Cet extrait peut être utile lorsque vous connaissez la longueur du contenu original (par exemple une somme de contrôle). Il vérifie que la forme codée a la bonne longueur.

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

Si L'expression rationnelle ne fonctionne pas et que vous connaissez le style de format de la chaîne d'origine, vous pouvez inverser la logique en effectuant une expression rationnelle pour ce format.

Par exemple, je travaille avec des fichiers xml codés en base64 et vérifie simplement si le fichier contient un balisage xml valide. Si ce n'est pas le cas, je peux supposer qu'il est décodé en base64. Ce n'est pas très dynamique mais qui fonctionne bien pour ma petite demande.

Essayez ceci:

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

Cela fonctionne en Python:

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

Essayez ceci en utilisant une expression rationnelle mentionnée précédemment:

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

...Nous pouvons également faire une validation simple comme, si elle a des espaces, elle ne peut pas être 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");
 }

Il N'y a aucun moyen de séparer la chaîne et l'encodage base64, sauf que la chaîne de votre système a une limitation ou une identification spécifique.