Como verificar se uma string é codificada em Base64 ou não

Quero decodificar uma string codificada em Base64 e armazená-la no meu banco de dados. Se a entrada não estiver codificada em Base64, preciso gerar um erro.

Como posso verificar se uma string é codificada em Base64?

Você pode usar a seguinte expressão regular para verificar se uma sequência está codificada em base64 ou não:

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

Na codificação base64, o conjunto de caracteres é [A-Z, a-z, 0-9, and + /]. Se o comprimento restante for menor que 4, a sequência será preenchida com '='caracteres.

^([A-Za-z0-9+/]{4})* significa que a sequência começa com 0 ou mais grupos base64.

([A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)$significa que as extremidades da corda em uma de três formas: [A-Za-z0-9+/]{4}, [A-Za-z0-9+/]{3}=ou [A-Za-z0-9+/]{2}==.

Se você estiver usando Java, poderá usar a biblioteca commons-codec

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

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

Bem, você pode:

• Verifique se o comprimento é múltiplo de 4 caracteres
• Verifique se todos os caracteres estão no conjunto AZ, az, 0-9, +, /, exceto pelo preenchimento no final, que é 0, 1 ou 2 '=' caracteres

Se você está esperando que vai ser base64, então provavelmente você pode simplesmente usar qualquer biblioteca está disponível em sua plataforma para tentar decodificá-lo para um array de bytes, lançando uma exceção se não é de base válido 64. Isso depende de sua plataforma, claro.

No Java 8, você pode simplesmente usar java.util.Base64 para tentar decodificar a sequência:

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

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

Tente assim para 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"; 
}

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

Verifique se o comprimento da sequência é múltiplo de 4. Posteriormente, use esse regex para garantir que todos os caracteres na sequência sejam caracteres base64.

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

Se a biblioteca que você usa adicionar uma nova linha como uma maneira de observar a regra de 76 caracteres máximos por linha, substitua-as por cadeias vazias.

Existem muitas variantes do Base64 , portanto, considere apenas determinar se sua sequência se assemelha à variação que você espera manipular. Como tal, pode ser necessário ajustar a regex abaixo com respeito aos caracteres de índice e enchimento (isto é +, /, =).

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?

Tente o seguinte:

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

É impossível verificar se uma sequência é codificada em base64 ou não. Só é possível validar se essa sequência possui um formato de sequência codificada em base64, o que significa que poderia ser uma sequência produzida pela codificação base64 (para verificar se a sequência pode ser validada em um regexp ou se uma biblioteca pode ser usada, muitos outras respostas a essa pergunta fornecem boas maneiras de verificar isso, para não entrar em detalhes).

Por exemplo, string flowé uma string codificada em base64 válida. Mas é impossível saber se é apenas uma sequência simples, uma palavra em inglês flowou se é uma sequência codificada de base 64~Z0

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

essa expressão regular me ajudou a identificar a base64 na minha aplicação em trilhos, só tive um problema, é que reconhece a string "errorDescripcion", gere um erro, para resolvê-la apenas valida o comprimento de uma string.

Isso funciona em 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.")

Resumo: IsBase64("string here") retorna true se string herefor codificado em Base64 e retorna false se string herenão foi codificado em Base64.

C # Isso está executando muito bem:

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

Não há como distinguir a string e a base64, exceto que a string no seu sistema possui alguma limitação ou identificação específica.

Este trecho pode ser útil quando você souber o tamanho do conteúdo original (por exemplo, uma soma de verificação). Ele verifica se o formulário codificado tem o comprimento correto.

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 o RegEx não funcionar e você souber o estilo de formato da sequência original, poderá inverter a lógica regexando para esse formato.

Por exemplo, eu trabalho com arquivos xml codificados em base64 e apenas verifico se o arquivo contém uma marcação xml válida. Se não, posso assumir, que é decodificado em base64. Isso não é muito dinâmico, mas funciona bem para meu pequeno aplicativo.

Isso funciona em Python:

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

Tente isso usando um regex mencionado anteriormente:

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

... Também podemos fazer uma validação simples como, se tiver espaços, não poderá ser 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 ao decodificar obtemos uma sequência com caracteres ASCII, a sequência não foi codificada

Solução de rubi (RoR):

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

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

Eu tento usar isso, sim este está funcionando

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

mas eu adicionei a condição de verificar pelo menos o final do caractere é =

string.lastIndexOf("=") >= 0