Как проверить, закодирована ли строка в Base64 или нет

Я хочу декодировать строку в кодировке Base64, а затем сохранить ее в своей базе данных. Если вход не в кодировке Base64, мне нужно выдать ошибку.

Как я могу проверить, закодирована ли строка в Base64?

Вы можете использовать следующее регулярное выражение, чтобы проверить, закодирована ли строка в base64:

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

В кодировке base64 набор символов [A-Z, a-z, 0-9, and + /]. Если длина покоя меньше 4, строка дополняется '='символами.

^([A-Za-z0-9+/]{4})* означает, что строка начинается с 0 или более групп base64.

([A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)$означает , что строка заканчивается в одной из трех форм: [A-Za-z0-9+/]{4}, [A-Za-z0-9+/]{3}=или [A-Za-z0-9+/]{2}==.

Если вы используете Java, вы можете использовать библиотеку commons-codec

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

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

Ну, вы можете:

• Убедитесь, что длина кратна 4 символам
• Убедитесь, что каждый символ находится в наборе AZ, az, 0-9, +, /, за исключением заполнения в конце, которое состоит из 0, 1 или 2 символов '='

Если вы ожидаете, что это будет base64, то вы, вероятно, можете просто использовать любую библиотеку, доступную на вашей платформе, чтобы попытаться декодировать ее в байтовый массив, выдав исключение, если оно не является действительным base 64. Это зависит от вашей платформы, конечно.

Начиная с Java 8, вы можете просто использовать java.util.Base64, чтобы попытаться декодировать строку:

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

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

Попробуйте вот так для 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"; 
}

Используйте это для 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');
}

Проверьте, ЕСЛИ длина строки кратна 4. Aftwerwards использует это регулярное выражение, чтобы убедиться, что все символы в строке являются символами base64.

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

Если используемая вами библиотека добавляет новую строку для наблюдения правила 76 максимальных символов на строку, замените их пустыми строками.

Есть много вариантов Base64 , поэтому рассмотрим только определения , если ваша строка похожа на varient вы ожидаете обрабатывать. Таким образом , вы , возможно , потребуется настроить регулярное выражение ниже по отношению к индексу и заполняющих символов (т.е. +, /, =).

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

Использование:

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

Попробуй это:

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

Невозможно проверить, закодирована ли строка в base64 или нет. Проверка возможна только в том случае, если эта строка имеет формат строки, закодированный в base64, что означает, что она может быть строкой, созданной кодировкой base64 (чтобы убедиться, что строка может быть проверена с помощью регулярного выражения или может использоваться библиотека, многие другие ответы на этот вопрос предоставляют хорошие способы проверить это, поэтому я не буду вдаваться в подробности).

Например, строка flowявляется допустимой строкой в ​​кодировке base64. Но невозможно узнать, является ли это просто простая строка, английское слово flow, или это строка, закодированная в формате 64~Z0

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

это регулярное выражение помогло мне идентифицировать base64 в моем приложении в rails, у меня была только одна проблема, это то, что оно распознает строку «errorDescripcion», я генерирую ошибку, для ее решения просто проверяю длину строки.

Это работает в 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.")

Сводка: IsBase64("string here") возвращает true, если string hereкодируется Base64, и возвращает false, если string hereкод не был Base64.

C # Это отлично работает:

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

Нет способа различить строку и кодировку base64, за исключением того, что строка в вашей системе имеет определенные ограничения или идентификацию.

Этот фрагмент может быть полезен, когда вы знаете длину исходного содержимого (например, контрольной суммы). Он проверяет, что закодированная форма имеет правильную длину.

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 не работает, и вы знаете стиль формата исходной строки, вы можете изменить логику, выполнив регулярное выражение для этого формата.

Например, я работаю с XML-файлами в кодировке Base64 и просто проверяю, содержит ли файл допустимую разметку XML. Если это не так, я могу предположить, что это base64 декодируется. Это не очень динамично, но отлично работает для моего небольшого приложения.

Это работает в Python:

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

Попробуйте это с помощью ранее упомянутого регулярного выражения:

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

... Мы также можем сделать простую проверку, например, если у нее есть пробелы, она не может быть 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");
 }

если при декодировании мы получаем строку с символами ASCII, то строка не была закодирована

(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

Я пытаюсь использовать это, да, это работает

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

но я добавил условие, чтобы проверить хотя бы конец символа =

string.lastIndexOf("=") >= 0