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

Je souhaite décoder une chaîne encodée en Base64, puis la stocker dans ma base de données. Si l'entrée n'est pas encodée en Base64, je dois lancer une erreur.

Comment puis-je vérifier si une chaîne est encodée en Base64?

Vous pouvez utiliser l'expression régulière suivante pour vérifier si une chaîne est encodée en base64 ou non:

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

Dans le codage base64, le jeu de caractères est [A-Z, a-z, 0-9, and + /]. Si la longueur restante est inférieure à 4, la chaîne est complétée avec des '='caractères.

^([A-Za-z0-9+/]{4})* signifie que la chaîne commence par 0 ou plusieurs groupes base64.

([A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)$signifie que les extrémités de chaîne dans l' une des trois formes suivantes : [A-Za-z0-9+/]{4}, [A-Za-z0-9+/]{3}=ou [A-Za-z0-9+/]{2}==.

Si vous utilisez Java, vous pouvez en fait utiliser la bibliothèque commons-codec

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

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

Bien, vous pouvez:

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

Si vous attendez que ce sera être base64, vous pouvez probablement utiliser la bibliothèque qui est disponible sur votre plate - forme pour essayer de le décoder à un tableau d'octets, lancer une exception si ce n'est pas la base valide 64. Cela dépend de votre plate - forme, bien sûr.

À partir de 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.
}

Essayez comme ça 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"; 
}

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

Vérifiez SI la longueur de la chaîne est un multiple de 4. Aftwerwards utiliser cette regex pour vous assurer que tous les caractères de la chaîne sont base64 caractères.

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

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

Il existe de nombreuses variantes de Base64 , pensez donc simplement à déterminer si votre chaîne ressemble à la variante que vous prévoyez de gérer. A ce titre, vous devrez peut - être régler le regex ci - dessous par rapport aux caractères d'index et remplissage (c. -à +, /, =).

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

Usage:

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

Essaye ça:

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

Il est impossible de vérifier si une chaîne est encodée en base64 ou non. Il n'est possible de valider que si cette chaîne est d'un format de chaîne encodé en base64, ce qui signifierait qu'il pourrait s'agir d'une chaîne produite par encodage en base64 (pour vérifier que, la chaîne pourrait être validée par rapport à une expression rationnelle ou une bibliothèque pourrait être utilisée, beaucoup d'autres réponses à cette question fournissent de bons moyens de vérifier cela, donc je n'entrerai pas dans les détails).

Par exemple, string flowest une chaîne codée en base64 valide. Mais il est impossible de savoir s'il s'agit d'une simple chaîne, d'un mot anglais flowou d'une chaîne encodée en base 64~Z0

/^([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 la base64 dans mon application dans les rails, je n'ai eu qu'un seul problème, c'est qu'elle reconnaît la chaîne "errorDescripcion", je génère une erreur, pour la résoudre il suffit de valider la longueur d'une chaîne.

Cela fonctionne en 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.")

Résumé: IsBase64("string here") renvoie true si string hereest encodé en Base64, et il renvoie false si string heren'est PAS encodé en 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;
}

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

Cet extrait de code peut être utile lorsque vous connaissez la longueur du contenu original (par exemple une somme de contrôle). Il vérifie que le formulaire codé 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 le RegEx ne fonctionne pas et que vous connaissez le style de format de la chaîne d'origine, vous pouvez inverser la logique, par regexing pour ce format.

Par exemple, je travaille avec des fichiers xml encodés en base64 et je 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 fonctionne bien pour ma petite application.

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 régulière 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");
}

... On peut aussi faire une simple validation comme, s'il y a des espaces ça 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");
 }

si lors du décodage nous obtenons une chaîne avec des caractères ASCII, alors la chaîne n'a pas été encodée

(RoR) solution de rubis:

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

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

J'essaye d'utiliser ça, oui celui-ci ça marche

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

mais j'ai ajouté à la condition de vérifier au moins la fin du caractère est =

string.lastIndexOf("=") >= 0