Bir dizenin Base64 kodlu olup olmadığını kontrol etme

Bir Base64 kodlu dize çözmek, sonra benim veritabanında saklamak istiyorum. Giriş Base64 kodlu değilse, bir hata atmam gerekiyor.

Bir dizenin Base64 kodlu olup olmadığını nasıl kontrol edebilirim?

Bir dizenin base64 kodlu olup olmadığını kontrol etmek için aşağıdaki normal ifadeyi kullanabilirsiniz:

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

Base64 kodlamasında karakter kümesi [A-Z, a-z, 0-9, and + /]. Kalan uzunluk 4'ten azsa, dize '='karakterlerle doldurulur .

^([A-Za-z0-9+/]{4})* dizenin 0 veya daha fazla base64 grubu ile başladığı anlamına gelir.

([A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)$Üç biçimden birini dize uçlarını şu anlama gelir: [A-Za-z0-9+/]{4}, [A-Za-z0-9+/]{3}=veya [A-Za-z0-9+/]{2}==.

Java kullanıyorsanız, aslında commons-codec kitaplığını kullanabilirsiniz

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

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

Peki şunları yapabilirsiniz:

• Uzunluğun 4 karakterin katları olduğunu kontrol edin
• 0, 1 veya 2 '=' karakter olan dolgu hariç, her karakterin AZ, az, 0-9, +, / kümesinde olduğunu kontrol edin

Eğer o bekliyorsanız olacak base64 olmak için bir platform üzerine, o zaman muhtemelen sadece var olan her türlü kütüphane kullanabilirsiniz deneyin bir bayt dizisi bunu okumak için bu platforma göre değişiklik geçerli bir temel 64. değilse bir istisna atma, elbette.

Java 8'den itibaren, dizeyi çözmek ve çözmek için java.util.Base64 komutunu kullanabilirsiniz :

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

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

PHP5 için böyle deneyin

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

PHP7 için kullanın

 //$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');
}

Kontrol edin IF dize ait uzunluk Aftwerwards emin olmak için bu normal ifadeler kullanabilirsiniz 4. katları olan tüm karakterlerin dizede base64 karakterlerdir.

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

Kullandığınız kitaplık, satır başına maksimum 76 karakter kuralını gözlemleme yolu olarak yeni satır ekliyorsa, bunları boş dizelerle değiştirin.

Base64'in birçok çeşidi vardır , bu nedenle dizenizin işlemeyi beklediğiniz değişkene benzediğini belirlemeyi düşünün . Bu nedenle, endeks ve dolgu karakterlerine göre aşağıdaki regex ayarlamanız gerekebilir (örneğin +, /, =).

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

Kullanımı:

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

Bunu dene:

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

Bir dizenin base64 kodlu olup olmadığını kontrol etmek imkansızdır. Bu dizenin base64 kodlu dize biçiminde olup olmadığını doğrulamak mümkündür, bu da base64 kodlaması tarafından üretilen bir dize olabileceği anlamına gelir (dizenin bir regexp ile doğrulanabileceğini veya bir kütüphanenin kullanılabileceğini kontrol etmek için, birçok Bu sorunun diğer cevapları bunu kontrol etmek için iyi yollar sağlar, bu yüzden ayrıntılara girmeyeceğim).

Örneğin, dize flowgeçerli bir base64 kodlu dizedir. Ancak bunun basit bir dize mi, İngilizce bir kelime flowmi yoksa temel 64 kodlu dize mi olduğunu bilmek imkansızdır.~Z0

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

Bu düzenli ifade raylarımda benim uygulama baz64 tanımlamak yardımcı oldu, ben sadece bir sorun vardı, o sadece bir dize uzunluğunu doğrulamak çözmek için "errorDescripcion" dizesini tanır, bir hata üretir.

Bu Python'da çalışır:

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

Özet: IsBase64("string here") döner gerçek ise string hereBase64 ile kodlanmış olduğunu ve döner sahte eğer string hereBase64 kodlu DEĞİLDİ.

C # Bu harika bir performans sergiliyor:

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

Sisteminizdeki dizginin belirli bir sınırlaması veya kimliği olması dışında, dizeyi ve base64 kodlamasını ayırt etmenin bir yolu yoktur.

Bu snippet, orijinal içeriğin uzunluğunu bildiğinizde yararlı olabilir (örn. Bir sağlama toplamı). Kodlanmış formun doğru uzunlukta olup olmadığını kontrol eder.

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

RegEx çalışmazsa ve orijinal dizenin biçim stilini biliyorsanız, bu biçim için normal ifadeyi kullanarak mantığı tersine çevirebilirsiniz.

Örneğin base64 kodlu xml dosyalarıyla çalışıyorum ve dosyanın geçerli xml işaretlemesi içerip içermediğini kontrol ediyorum. Eğer kabul edemezse, base64 kodunun çözülmüş olduğunu varsayabilirim. Bu çok dinamik değil ama benim küçük uygulama için iyi çalışıyor.

Bu Python'da çalışır:

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

Daha önce bahsedilen bir normal ifadeyi kullanarak bunu deneyin:

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

... Uzayları varsa Base64 olamaz gibi basit bir doğrulama da yapabiliriz:

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

kod çözme işlemi sırasında ASCII karakterleri olan bir dize alırsak, dize kodlanmamışsa

(RoR) yakut çözeltisi:

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

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

Bunu kullanmaya çalışıyorum, evet bu çalışıyor

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

ama en azından karakterin sonunun =

string.lastIndexOf("=") >= 0