Có cách nào trong C # để xem một chuỗi có được mã hóa Base 64 không ngoài việc cố gắng chuyển đổi nó và xem có lỗi không? Tôi có mã mã như thế này:

// Convert base64-encoded hash value into a byte array.
byte[] HashBytes = Convert.FromBase64String(Value);

Tôi muốn tránh ngoại lệ "Ký tự không hợp lệ trong chuỗi Base-64" xảy ra nếu giá trị không phải là chuỗi 64 cơ sở hợp lệ. Tôi muốn chỉ kiểm tra và trả về false thay vì xử lý một ngoại lệ vì tôi hy vọng rằng đôi khi giá trị này sẽ không phải là một chuỗi 64 cơ sở. Có cách nào để kiểm tra trước khi sử dụng hàm Convert.FromBase64String không?

Cảm ơn!

Cập nhật:
Cảm ơn tất cả các câu trả lời của bạn. Đây là một phương thức mở rộng mà tất cả bạn có thể sử dụng cho đến nay dường như để đảm bảo chuỗi của bạn sẽ vượt qua Convert.FromBase64String mà không có ngoại lệ. .NET dường như bỏ qua tất cả các dấu cách và dấu cách kết thúc khi chuyển đổi sang cơ sở 64 nên "1234" là hợp lệ và "1234" cũng vậy

public static bool IsBase64String(this string s)
{
    s = s.Trim();
    return (s.Length % 4 == 0) && Regex.IsMatch(s, @"^[a-zA-Z0-9\+/]*={0,3}$", RegexOptions.None);

}

Đối với những người thắc mắc về hiệu suất của kiểm tra so với bắt và ngoại lệ, trong hầu hết các trường hợp đối với cơ sở 64 này, việc kiểm tra sẽ nhanh hơn so với bắt ngoại lệ cho đến khi bạn đạt đến một độ dài nhất định. Chiều dài càng nhỏ càng nhanh

Trong thử nghiệm rất không khoa học của tôi: Trong 10000 lần lặp cho độ dài ký tự 100.000 - 110000, nó nhanh hơn 2,7 lần để thử nghiệm đầu tiên.

Đối với 1000 lần lặp cho các ký tự có độ dài 1 - 16 ký tự cho tổng số 16.000 bài kiểm tra, nó nhanh hơn 10,9 lần.

Tôi chắc chắn có một điểm mà nó trở nên tốt hơn để kiểm tra bằng phương pháp dựa trên ngoại lệ. Tôi chỉ không biết đó là điểm gì.

Thật dễ dàng để nhận ra một chuỗi Base64, vì nó sẽ chỉ bao gồm các ký tự 'A'..'Z', 'a'..'z', '0'..'9', '+', '/'và nó thường được đệm ở cuối với tối đa ba '=', để tạo độ dài gấp bội 4. Nhưng thay vì so sánh các ký tự này, bạn ' d tốt hơn là bỏ qua ngoại lệ, nếu nó xảy ra.

Sử dụng Convert.TryFromBase64String từ C # 7.2

public static bool IsBase64String(string base64)
{
   Span<byte> buffer = new Span<byte>(new byte[base64.Length]);
   return Convert.TryFromBase64String(base64, buffer , out int bytesParsed);
}

Tôi biết bạn nói rằng bạn không muốn bắt một ngoại lệ. Nhưng, vì bắt được một ngoại lệ đáng tin cậy hơn, tôi sẽ tiếp tục và đăng câu trả lời này.

public static bool IsBase64(this string base64String) {
     // Credit: oybek https://stackoverflow.com/users/794764/oybek
     if (string.IsNullOrEmpty(base64String) || base64String.Length % 4 != 0
        || base64String.Contains(" ") || base64String.Contains("\t") || base64String.Contains("\r") || base64String.Contains("\n"))
        return false;

     try{
         Convert.FromBase64String(base64String);
         return true;
     }
     catch(Exception exception){
     // Handle the exception
     }
     return false;
}

Cập nhật: Tôi đã cập nhật điều kiện nhờ vào oybek để cải thiện độ tin cậy hơn nữa.

Tôi tin rằng regex nên là:

    Regex.IsMatch(s, @"^[a-zA-Z0-9\+/]*={0,2}$")

Chỉ khớp một hoặc hai dấu '=', không phải ba.

snên là chuỗi sẽ được kiểm tra. Regexlà một phần của System.Text.RegularExpressionskhông gian tên.

Tại sao không chỉ bắt ngoại lệ, và trả về Sai?

Điều này tránh được chi phí bổ sung trong trường hợp phổ biến.

Chỉ vì mục đích hoàn chỉnh, tôi muốn cung cấp một số triển khai. Nói chung, Regex là một cách tiếp cận đắt tiền, đặc biệt nếu chuỗi lớn (xảy ra khi chuyển các tệp lớn). Cách tiếp cận sau đây thử các cách phát hiện nhanh nhất trước tiên.

public static class HelperExtensions {
    // Characters that are used in base64 strings.
    private static Char[] Base64Chars = new[] { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/' };
    /// <summary>
    /// Extension method to test whether the value is a base64 string
    /// </summary>
    /// <param name="value">Value to test</param>
    /// <returns>Boolean value, true if the string is base64, otherwise false</returns>
    public static Boolean IsBase64String(this String value) {

        // The quickest test. If the value is null or is equal to 0 it is not base64
        // Base64 string's length is always divisible by four, i.e. 8, 16, 20 etc. 
        // If it is not you can return false. Quite effective
        // Further, if it meets the above criterias, then test for spaces.
        // If it contains spaces, it is not base64
        if (value == null || value.Length == 0 || value.Length % 4 != 0
            || value.Contains(' ') || value.Contains('\t') || value.Contains('\r') || value.Contains('\n'))
            return false;

        // 98% of all non base64 values are invalidated by this time.
        var index = value.Length - 1;

        // if there is padding step back
        if (value[index] == '=')
            index--;

        // if there are two padding chars step back a second time
        if (value[index] == '=')
            index--;

        // Now traverse over characters
        // You should note that I'm not creating any copy of the existing strings, 
        // assuming that they may be quite large
        for (var i = 0; i <= index; i++) 
            // If any of the character is not from the allowed list
            if (!Base64Chars.Contains(value[i]))
                // return false
                return false;

        // If we got here, then the value is a valid base64 string
        return true;
    }
}

BIÊN TẬP

Theo đề nghị của Sam , bạn cũng có thể thay đổi mã nguồn một chút. Ông cung cấp một cách tiếp cận thực hiện tốt hơn cho bước cuối cùng của các bài kiểm tra. Các thói quen

    private static Boolean IsInvalid(char value) {
        var intValue = (Int32)value;

        // 1 - 9
        if (intValue >= 48 && intValue <= 57) 
            return false;

        // A - Z
        if (intValue >= 65 && intValue <= 90) 
            return false;

        // a - z
        if (intValue >= 97 && intValue <= 122) 
            return false;

        // + or /
        return intValue != 43 && intValue != 47;
    } 

có thể được sử dụng để thay thế if (!Base64Chars.Contains(value[i]))dòng vớiif (IsInvalid(value[i]))

Mã nguồn hoàn chỉnh với các cải tiến từ Sam sẽ trông như thế này (đã xóa các nhận xét cho rõ ràng)

public static class HelperExtensions {
    public static Boolean IsBase64String(this String value) {
        if (value == null || value.Length == 0 || value.Length % 4 != 0
            || value.Contains(' ') || value.Contains('\t') || value.Contains('\r') || value.Contains('\n'))
            return false;
        var index = value.Length - 1;
        if (value[index] == '=')
            index--;
        if (value[index] == '=')
            index--;
        for (var i = 0; i <= index; i++)
            if (IsInvalid(value[i]))
                return false;
        return true;
    }
    // Make it private as there is the name makes no sense for an outside caller
    private static Boolean IsInvalid(char value) {
        var intValue = (Int32)value;
        if (intValue >= 48 && intValue <= 57)
            return false;
        if (intValue >= 65 && intValue <= 90)
            return false;
        if (intValue >= 97 && intValue <= 122)
            return false;
        return intValue != 43 && intValue != 47;
    }
}

Câu trả lời phải phụ thuộc vào cách sử dụng chuỗi. Có nhiều chuỗi có thể là "cơ sở hợp lệ64" theo cú pháp được đề xuất bởi một số áp phích, nhưng điều đó có thể "giải mã" chính xác, không có ngoại lệ, thành rác. Ví dụ: chuỗi 8char Portlandlà Base64 hợp lệ. Điểm nói rằng đây là Base64 hợp lệ là gì? Tôi đoán rằng tại một số điểm bạn muốn biết rằng chuỗi này nên hoặc không nên được giải mã Base64.

Trong trường hợp của tôi, tôi có các chuỗi kết nối Oracle có thể ở dạng văn bản đơn giản như:

Data source=mydb/DBNAME;User Id=Roland;Password=.....`

hoặc trong cơ sở 64 như

VXNlciBJZD1sa.....................................==

Tôi chỉ phải kiểm tra sự hiện diện của dấu chấm phẩy, bởi vì điều đó chứng tỏ rằng nó KHÔNG phải là cơ sở64, tất nhiên là nhanh hơn bất kỳ phương pháp nào ở trên.

Quy tắc bóng đá cao Knibb!

Điều này sẽ tương đối nhanh và chính xác nhưng tôi thừa nhận tôi đã không đưa nó qua một bài kiểm tra kỹ lưỡng, chỉ một vài.

Nó tránh các trường hợp ngoại lệ đắt tiền, regex và cũng tránh việc lặp qua một bộ ký tự, thay vào đó sử dụng phạm vi ascii để xác thực.

public static bool IsBase64String(string s)
    {
        s = s.Trim();
        int mod4 = s.Length % 4;
        if(mod4!=0){
            return false;
        }
        int i=0;
        bool checkPadding = false;
        int paddingCount = 1;//only applies when the first is encountered.
        for(i=0;i<s.Length;i++){
            char c = s[i];
            if (checkPadding)
            {
                if (c != '=')
                {
                    return false;
                }
                paddingCount++;
                if (paddingCount > 3)
                {
                    return false;
                }
                continue;
            }
            if(c>='A' && c<='z' || c>='0' && c<='9'){
                continue;
            }
            switch(c){ 
              case '+':
              case '/':
                 continue;
              case '=': 
                 checkPadding = true;
                 continue;
            }
            return false;
        }
        //if here
        //, length was correct
        //, there were no invalid characters
        //, padding was correct
        return true;
    }

public static bool IsBase64String1(string value)
        {
            if (string.IsNullOrEmpty(value))
            {
                return false;
            }
            try
            {
                Convert.FromBase64String(value);
                if (value.EndsWith("="))
                {
                    value = value.Trim();
                    int mod4 = value.Length % 4;
                    if (mod4 != 0)
                    {
                        return false;
                    }
                    return true;
                }
                else
                {

                    return false;
                }
            }
            catch (FormatException)
            {
                return false;
            }
        }

Tôi sẽ sử dụng như thế này để tôi không cần phải gọi lại phương thức convert

   public static bool IsBase64(this string base64String,out byte[] bytes)
    {
        bytes = null;
        // Credit: oybek http://stackoverflow.com/users/794764/oybek
        if (string.IsNullOrEmpty(base64String) || base64String.Length % 4 != 0
           || base64String.Contains(" ") || base64String.Contains("\t") || base64String.Contains("\r") || base64String.Contains("\n"))
            return false;

        try
        {
             bytes=Convert.FromBase64String(base64String);
            return true;
        }
        catch (Exception)
        {
            // Handle the exception
        }

        return false;
    }

Giải mã, mã hóa lại và so sánh kết quả với chuỗi gốc

public static Boolean IsBase64(this String str)
{
    if ((str.Length % 4) != 0)
    {
        return false;
    }

    //decode - encode and compare
    try
    {
        string decoded = System.Text.Encoding.UTF8.GetString(System.Convert.FromBase64String(str));
        string encoded = System.Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(decoded));
        if (str.Equals(encoded, StringComparison.InvariantCultureIgnoreCase))
        {
            return true;
        }
    }
    catch { }
    return false;
}

Imho điều này là không thực sự có thể. Tất cả các giải pháp được đăng đều thất bại đối với các chuỗi như "thử nghiệm" , v.v. Nếu chúng có thể được chia thành 4, không rỗng hoặc trống và nếu chúng là ký tự base64 hợp lệ, chúng sẽ vượt qua tất cả các bài kiểm tra. Đó có thể là nhiều chuỗi ...

Vì vậy, không có giải pháp thực sự nào ngoài việc biết rằng đây là một chuỗi mã hóa cơ sở 64 . Những gì tôi nghĩ ra là đây:

if (base64DecodedString.StartsWith("<xml>")
{
    // This was really a base64 encoded string I was expecting. Yippie!
}
else
{
    // This is gibberish.
}

Tôi hy vọng rằng chuỗi giải mã bắt đầu với một cấu trúc nhất định, vì vậy tôi kiểm tra điều đó.

Chắc chắn rồi. Chỉ cần chắc chắn rằng mỗi nhân vật nằm trong a-z, A-Z, 0-9, /, hay +, và chuỗi kết thúc bằng ==. (Ít nhất, đó là cách triển khai Base64 phổ biến nhất. Bạn có thể tìm thấy một số triển khai sử dụng các ký tự khác với /hoặc +cho hai ký tự cuối cùng.)

Có, vì Base64 mã hóa dữ liệu nhị phân thành các chuỗi ASCII bằng cách sử dụng một bộ ký tự giới hạn, bạn chỉ cần kiểm tra nó bằng biểu thức chính quy này:

/ ^ [A-Za-z0-9 \ = \ + \ / \ s \ n] + $ / s

sẽ đảm bảo chuỗi chỉ chứa AZ, az, 0-9, '+', '/', '=' và khoảng trắng.

Tôi sẽ đề nghị tạo một regex để thực hiện công việc. Bạn sẽ phải kiểm tra một cái gì đó như thế này: [a-zA-Z0-9 + / =] Bạn cũng sẽ phải kiểm tra độ dài của chuỗi. Tôi không chắc chắn về điều này, nhưng tôi khá chắc chắn nếu một cái gì đó được cắt bớt (trừ phần đệm "=") nó sẽ nổ tung.

Hoặc tốt hơn là kiểm tra câu hỏi stackoverflow này

Tôi vừa có một yêu cầu rất giống nhau khi tôi cho phép người dùng thực hiện một số thao tác hình ảnh trong một <canvas>phần tử và sau đó gửi hình ảnh kết quả được truy xuất .toDataURL()tới phần phụ trợ. Tôi muốn thực hiện một số xác thực máy chủ trước khi lưu hình ảnh và đã triển khai ValidationAttributesử dụng một số mã từ các câu trả lời khác:

[AttributeUsage(AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
public class Bae64PngImageAttribute : ValidationAttribute
{
    public override bool IsValid(object value)
    {
        if (value == null || string.IsNullOrWhiteSpace(value as string))
            return true; // not concerned with whether or not this field is required
        var base64string = (value as string).Trim();

        // we are expecting a URL type string
        if (!base64string.StartsWith("data:image/png;base64,"))
            return false;

        base64string = base64string.Substring("data:image/png;base64,".Length);

        // match length and regular expression
        if (base64string.Length % 4 != 0 || !Regex.IsMatch(base64string, @"^[a-zA-Z0-9\+/]*={0,3}$", RegexOptions.None))
            return false;

        // finally, try to convert it to a byte array and catch exceptions
        try
        {
            byte[] converted = Convert.FromBase64String(base64string);
            return true;
        }
        catch(Exception)
        {
            return false;
        }
    }
}

Như bạn có thể thấy tôi đang mong đợi một chuỗi loại hình ảnh / png, đó là mặc định được trả về <canvas>khi sử dụng .toDataURL().

Kiểm tra Base64 hoặc chuỗi bình thường

công khai bool IsBase64Encoding (Chuỗi str)

{

try

{
    // If no exception is caught, then it is possibly a base64 encoded string
    byte[] data = Convert.FromBase64String(str);
    // The part that checks if the string was properly padded to the
    // correct length was borrowed from d@anish's solution
    return (str.Replace(" ","").Length % 4 == 0);
}
catch
{
    // If exception is caught, then it is not a base64 encoded string
   return false;
}

}

Tất cả các câu trả lời đã được tiêu hóa thành 1 chức năng đảm bảo 100% rằng kết quả của nó sẽ chính xác.

1) Sử dụng chức năng như dưới đây:

    string encoded = "WW91ckJhc2U2NHN0cmluZw==";
    msgbox("Is string base64=" + IsBase64(encoded));

2) Dưới đây là chức năng:

  public bool IsBase64(string base64String)
    {
        try
        {
            if (!base64String.Length < 1)
            {
                if (!base64String.Equals(Convert.ToBase64String(Encoding.UTF8.GetBytes(Encoding.UTF8.GetString(Convert.FromBase64String(base64String)))), StringComparison.InvariantCultureIgnoreCase) & !System.Text.RegularExpressions.Regex.IsMatch(base64String, @"^[a-zA-Z0-9\+/]*={0,2}$"))
                {
                    return false;
                    return;
                }
                if ((base64String.Length % 4) != 0 || string.IsNullOrEmpty(base64String) || base64String.Length % 4 != 0 || base64String.Contains(" ") || base64String.Contains(Constants.vbTab) || base64String.Contains(Constants.vbCr) || base64String.Contains(Constants.vbLf))
                {
                    return false;
                    return;
                }
            }
            else
            {
                return false;
                return;
            }

            return true;
            return;
        }
        catch (FormatException ex)
        {
            return false;
            return;
        }
    }

Tôi thích ý tưởng kiểm tra biểu thức chính quy. Biểu thức chính quy có thể nhanh và tiết kiệm chi phí mã hóa đôi khi. các yêu cầu ban đầu, đã có một bản cập nhật đã làm điều này. Mặc dù vậy, tôi thấy rằng tôi không bao giờ có thể cho rằng các chuỗi sẽ không có giá trị. Tôi sẽ mở rộng chức năng Tiện ích mở rộng để kiểm tra chuỗi nguồn cho null hoặc chỉ các ký tự khoảng trắng.

    public static bool IsBase64String(this string s)
    {
        if (string.IsNullOrWhiteSpace(s))
            return false;

        s = s.Trim();
        return (s.Length % 4 == 0) && Regex.IsMatch(s, @"^[a-zA-Z0-9\+/]*={0,3}$", RegexOptions.None);

    }