frombase64 - secret base64 encoded




Como verificar se uma string é codificada em base64 ou não (12)

Eu quero decodificar uma seqüência codificada de base64 e, em seguida, armazená-lo no meu banco de dados. Se a entrada não for codificada em base64, preciso lançar um erro. Como posso verificar se a string foi base64 encriped?


É impossível verificar se uma string é codificada em base64 ou não. Só é possível validar se essa string é de um formato de string codificado em base64, o que significaria que poderia ser uma string produzida por codificação base64 (para verificar se string pode ser validada em relação a um regexp ou uma biblioteca pode ser usada, muitos outras respostas a essa pergunta fornecem boas maneiras de verificar isso, então não vou entrar em detalhes).

Por exemplo, o flow strings é uma string codificada base64 válida. Mas é impossível saber se é apenas uma string simples, um flow palavras em inglês ou se é uma string codificada na base 64 ~Z0


A partir do Java 8, você pode simplesmente usar java.util.Base64 para tentar decodificar a string:

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

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

Este trecho pode ser útil quando você sabe a duração do conteúdo original (por exemplo, uma soma de verificação). Ele verifica se o formato codificado tem o tamanho 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() ;
}

Existem muitas variantes de Base64 , então considere apenas determinar se sua string se parece com a variante que você espera manipular. Como tal, você pode precisar ajustar o regex abaixo com relação ao índice e caracteres de preenchimento (ou seja, + , / , = ).

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?

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 a string here for codificada em Base64 e retorna false se a string here NÃO tiver codificação Base64.


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


Se você estiver usando Java, você pode realmente usar commons-codec biblioteca commons-codec

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

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

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

Tente isto:

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

Verifique se IF o tamanho da string é um múltiplo de 4. Aftwerwards use esta regex para se certificar de que todos os caracteres na string são caracteres base64.

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

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


C # Isso está indo 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;
}

/^([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 o base64 na minha aplicação em rails, só tive um problema, é que ele reconhece a string "errorDescripcion", gerei um erro, para resolvê-lo basta validar o tamanho de uma string.