web-dev-qa-db-fra.com

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

Je veux 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, j'ai besoin d'une erreur. Comment puis-je vérifier si la chaîne a été codée en base64?

base64
153
loganathan

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

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

En codage base64, le jeu de caractères est [A-Z, a-z, 0-9, and + /]. Si la longueur au repos 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 la chaîne se termine sous l’une des trois formes suivantes: [A-Za-z0-9+/]{4}, [A-Za-z0-9+/]{3}= ou [A-Za-z0-9+/]{2}==.

194
xuanyuanzhiyuan

Si vous utilisez Java, vous pouvez réellement utiliser commons-codec library

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

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

Bien, vous pouvez:

  • Vérifiez que la longueur est un multiple de 4 caractères
  • Vérifiez que tous les caractères sont dans le jeu 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 soit base64, vous pouvez probablement utiliser la bibliothèque disponible sur votre plate-forme pour essayer de le décoder en un tableau d'octets, en lançant une exception si elle n'est pas valide 64. Cela dépend de votre plate-forme, bien sûr.

39
Jon Skeet

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"; 
}
11
Suneel Kumar

A 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.
}
5
Philippe

Vérifiez si SI la longueur de la chaîne est un multiple de 4. A l'aide de cette expression rationnelle, assurez-vous que tous les caractères de 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 pouvoir observer la règle des 76 caractères maximum par ligne, remplacez-la par des chaînes vides.

4
Yaw Boakye

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

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?
4
user664833
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');
}
4
Deepak Sisodiya
/^([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'avais qu'un problème, c'est qu'il reconnaît la chaîne "errorDescripcion", je génère une erreur, pour le résoudre, il suffit de valider la longueur d'une chaîne.

1
Onironauta

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;
}
1
Veni Souto

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 en utilisant une expression régulière 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.

0
Jankapunkt

Il est impossible de vérifier si une chaîne est codée en base64 ou non. Il n’est possible de valider que si cette chaîne est au format chaîne encodé en base64, ce qui voudrait dire qu’il s’agirait d’une chaîne produite par encodage en base64 d’autres réponses à cette question fournissent de bons moyens de vérifier cela, aussi je n’entrerai pas dans les détails). 

Par exemple, chaîne flow est 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 flow, ou s’il s’agit d’une chaîne encodée en base 64 ~Z0

0
Adomas

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)
0
bcarroll

Il n’existe aucun moyen de distinguer les chaînes et les codages en base64, sauf que la chaîne de votre système a une limitation ou une identification spécifique.

0
pinxue

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") renvoietruesi string here est codé en Base64, et il renvoiefalsesi string here n'était PAS codé en Base64.

0
gave

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

Cet extrait peut être utile lorsque vous connaissez la longueur du contenu d'origine (par exemple, une somme de contrôle). Il vérifie que la forme encodé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() ;
}
0
Laurent Caillette