Jak sprawdzić, czy łańcuch jest zakodowany w standardzie Base64, czy nie

Chcę zdekodować ciąg zakodowany w standardzie Base64, a następnie zapisać go w mojej bazie danych. Jeśli dane wejściowe nie są zakodowane w standardzie Base64, muszę zgłosić błąd.

Jak mogę sprawdzić, czy ciąg znaków jest zakodowany w standardzie Base64?

Możesz użyć następującego wyrażenia regularnego, aby sprawdzić, czy łańcuch jest zakodowany w standardzie base64:

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

W kodowaniu base64 zestaw znaków to [A-Z, a-z, 0-9, and + /]. Jeśli długość reszty jest mniejsza niż 4, ciąg znaków jest uzupełniany '='znakami.

^([A-Za-z0-9+/]{4})* oznacza, że ​​ciąg zaczyna się od 0 lub więcej grup base64.

([A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)$Oznacza końce ciągów w jednej z trzech postaci: [A-Za-z0-9+/]{4}, [A-Za-z0-9+/]{3}=lub [A-Za-z0-9+/]{2}==.

Jeśli używasz Javy, możesz faktycznie użyć biblioteki kodeków commons

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

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

Cóż, możesz:

• Sprawdź, czy długość jest wielokrotnością 4 znaków
• Sprawdź, czy każdy znak znajduje się w zbiorze AZ, az, 0-9, +, /, z wyjątkiem wypełniania na końcu, które zawiera 0, 1 lub 2 znaki „=”

Jeśli spodziewasz się, że będzie to base64, prawdopodobnie możesz po prostu użyć biblioteki dostępnej na platformie, aby spróbować ją zdekodować do tablicy bajtów, zgłaszając wyjątek, jeśli nie jest to poprawna baza 64. To zależy od twojej platformy, oczywiście.

Począwszy od Java 8, możesz po prostu użyć java.util.Base64, aby spróbować zdekodować ciąg:

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

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

Spróbuj tego w 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"; 
}

Użyj tego dla 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');
}

Sprawdź, czy JEŻELI długość łańcucha jest wielokrotnością 4. Po drugiej stronie tego wyrażenia regularnego upewnij się, że wszystkie znaki w łańcuchu są znakami base64.

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

Jeśli używana biblioteka dodaje nowy wiersz jako sposób na przestrzeganie 76 maksymalnych znaków w linii, zastąp je pustymi łańcuchami.

Istnieje wiele wariantów Base64 , więc zastanów się nad ustaleniem, czy Twój ciąg znaków przypomina zmienną, którą spodziewasz się obsłużyć. Jako taka, może być konieczne, aby dostosować regex poniżej w odniesieniu do indeksu i wypełnienie znaków (czyli +, /, =).

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

Stosowanie:

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

Spróbuj tego:

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

Nie można sprawdzić, czy łańcuch jest zakodowany w standardzie base64, czy nie. Sprawdzanie poprawności jest możliwe tylko wtedy, gdy ten ciąg ma format łańcucha zakodowany w standardzie base64, co oznaczałoby, że może to być ciąg utworzony przez kodowanie base64 (aby sprawdzić, czy łańcuch może być sprawdzony pod kątem wyrażenia regularnego lub można użyć biblioteki, wiele inne odpowiedzi na to pytanie zapewniają dobre sposoby na sprawdzenie tego, więc nie będę wchodził w szczegóły).

Na przykład ciąg flowjest prawidłowym ciągiem zakodowanym w standardzie base64. Nie można jednak ustalić, czy jest to zwykły ciąg, angielskie słowo flow, czy też ciąg znaków zakodowany w podstawie 64~Z0

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

to wyrażenie regularne pomogło mi zidentyfikować base64 w mojej aplikacji w szynach, miałem tylko jeden problem, to znaczy, że rozpoznaje ciąg „errorDescripcion”, generuję błąd, aby go rozwiązać, po prostu zweryfikuj długość łańcucha.

Działa to w Pythonie:

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.")

Podsumowanie: IsBase64("string here") zwraca true, jeśli string herejest zakodowany w standardzie Base64, i zwraca false, jeśli string hereNIE został zakodowany w standardzie Base64.

C # To działa świetnie:

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

Nie ma sposobu na odróżnienie łańcucha i kodowania base64, z wyjątkiem tego, że łańcuch w twoim systemie ma określone ograniczenia lub identyfikację.

Ten fragment kodu może być przydatny, gdy znasz długość oryginalnej treści (np. Suma kontrolna). Sprawdza, czy zakodowana forma ma prawidłową długość.

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

Jeśli RegEx nie działa i znasz styl formatu oryginalnego łańcucha, możesz odwrócić logikę, wyrażając wyrażenie regularne dla tego formatu.

Na przykład pracuję z plikami XML zakodowanymi w standardzie base64 i po prostu sprawdzam, czy plik zawiera prawidłowe znaczniki xml. Jeśli nie, mogę założyć, że jest dekodowany w standardzie base64. Nie jest to zbyt dynamiczne, ale działa dobrze w mojej małej aplikacji.

Działa to w Pythonie:

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

Wypróbuj to, używając wcześniej wspomnianego wyrażenia regularnego:

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

... Możemy również dokonać prostej weryfikacji, np. Jeśli ma spacje, to nie może być 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");
 }

jeśli podczas dekodowania otrzymamy ciąg ze znakami ASCII, to nie zostanie on zakodowany

(RoR) rozwiązanie rubinowe:

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

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

Próbuję tego użyć, tak, to działa

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

ale dodałem pod warunkiem, że przynajmniej koniec znaku to =

string.lastIndexOf("=") >= 0