कैसे एक मान्य Base64 एन्कोडेड स्ट्रिंग के लिए जाँच करें

Question

क्या C # में एक तरीका है यह देखने के लिए कि क्या एक स्ट्रिंग बेस 64 एन्कोडेड है इसके अलावा सिर्फ इसे बदलने की कोशिश करें और देखें कि क्या कोई त्रुटि है? मेरे पास कोड कोड इस तरह है:

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

मैं "बेस -64 स्ट्रिंग में अवैध चरित्र" से बचना चाहता हूं जो कि वैल्यू बेस 64 स्ट्रिंग मान्य नहीं होने पर होता है। मैं एक अपवाद को संभालने के बजाय सिर्फ जाँच करना और वापस लौटना चाहता हूं क्योंकि मुझे उम्मीद है कि कभी-कभी यह मान 64 बेस वाला नहीं होगा। क्या Convert.FromBase64String फ़ंक्शन का उपयोग करने से पहले जांचने का कोई तरीका है?

धन्यवाद!

अपडेट:
आपके सभी उत्तरों के लिए धन्यवाद। यहाँ एक विस्तार विधि है जिसका आप सभी उपयोग कर सकते हैं ताकि यह सुनिश्चित हो सके कि आपका तार एक अपवाद के बिना Convert.FromBase64String पास करेगा। .NET 64 के आधार पर परिवर्तित होने पर सभी अनुगामी और समाप्त होने वाले स्थानों की उपेक्षा करता है, इसलिए "1234" वैध है और इसलिए "1234" है

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

}

परीक्षण बनाम कैचिंग और अपवाद के प्रदर्शन के बारे में सोच रहे लोगों के लिए, इस आधार 64 के लिए ज्यादातर मामलों में अपवाद को पकड़ने की तुलना में जांचना तेज है जब तक कि आप एक निश्चित लंबाई तक नहीं पहुंचते। यह लंबाई जितनी तेज होती है

मेरे बहुत ही अवैज्ञानिक परीक्षण में: १०००० पुनरावृत्तियों के लिए चरित्र की लंबाई १,००,००० - ११०००० के लिए पहले परीक्षण करने के लिए यह २. uns गुना तेज़ था।

पात्रों की लंबाई 1 के लिए 1000 पुनरावृत्तियों के लिए - 16,000 परीक्षणों के कुल के लिए 16 वर्ण यह 10.9 गुना तेज था।

मुझे यकीन है कि एक बिंदु है जहां अपवाद आधारित विधि के साथ परीक्षण करना बेहतर है। मुझे नहीं पता कि वह किस बिंदु पर है।

Comments

यह इस बात पर निर्भर करता है कि आप किस तरह से "पूरी तरह" चाहते हैं। आप रेगीक्स का उपयोग करके कुछ पूर्व-सत्यापन का उपयोग कर सकते हैं जैसा कि अन्य ने उत्तर दिया है, लेकिन यह एकमात्र संकेतक नहीं है। बेस 64 एनकोडिंग को =साइन का उपयोग करके कुछ मामलों में पैडिंग की आवश्यकता होती है । यदि पैडिंग गलत है, तो यह एक त्रुटि देगा, भले ही इनपुट एक अभिव्यक्ति से मेल खाता हो।

— vcsjones 16:10 पर

आपकी स्थिति विशेष रूप से बेस 64 स्ट्रिंग्स को संतुष्ट नहीं करती है। स्ट्रिंग पर विचार करें \n\fLE16- आपका तरीका इसके लिए गलत सकारात्मक परिणाम देगा। किसी को पढ़ने के लिए और एक मूर्ख विधि की तलाश में; मैं FormatException को पकड़ने या कल्पना-अनुकूल RegEx का उपयोग करने की सलाह दूंगा, stackoverflow.com/questions/475074/… देखें ।

— नल

यदि ऊपर दिया गया तरीका गलत है, तो मैं स्ट्रिंग को सही लंबाई में कैसे पैड कर सकता हूं?

— पॉल अलेक्जेंडर

मेरा मानना ​​है कि RegEx होना चाहिए@"^[a-zA-Z0-9\+/]*={0,2}$"

— azatar 22

यह समाधान विश्वसनीय नहीं है। यदि आप 4 समान वर्ण स्ट्रिंग जोड़ते हैं तो यह विफल हो जाता है।

— बेट्टीम्स

Answer 1

एक बेस 64 स्ट्रिंग को पहचानना बहुत आसान है, क्योंकि यह केवल पात्रों से बना होगा 'A'..'Z', 'a'..'z', '0'..'9', '+', '/'और यह अक्सर तीन '=' तक की लंबाई के साथ अंत में गद्देदार होता है, जिससे लंबाई 4 से अधिक हो जाती है। लेकिन इनकी तुलना करने के बजाय, आप ' घ अपवाद को अनदेखा करने से बेहतर है, अगर ऐसा होता है।

Comments

मुझे लगता है कि तुम सही रास्ते पर हो। मैंने कुछ परीक्षण किया और ऐसा लगता है कि यह 3 के बजाय 4 का गुणक है।

— क्रिस मुलिंस

सफल एन्कोडिंग के लिए एन्कोडिंग के समय इसकी लंबाई 3 से अधिक होनी चाहिए! उस के बारे में क्षमा करें ... और हाँ, आप सही हैं ... एन्कोडेड स्ट्रिंग की लंबाई है जो कि 4. की एक बहु है। यही कारण है कि हम 3 '=' तक पैड करेंगे।

— अनिरुद्ध रामनाथन

चिह्नित सही है क्योंकि आप पहली बार कई चीजों का उल्लेख कर रहे थे। मैंने अपने प्रश्न को समाधान के कार्यान्वयन के साथ अद्यतन किया है मुझे बताएं कि क्या आपको इसके साथ कोई समस्या दिखाई देती है।

— क्रिस मुलिंस

Answer 2

C # 7.2 से Convert.TryFromBase64String का उपयोग करें

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

Comments

मुझे नहीं पता था कि यह एक चीज़ है। मुझे लगता है कि यह नया उत्तर होना चाहिए, यदि c # 7.2 का उपयोग किया जाए

— क्रिस मुलिंस

केवल .NET Core 2.1+ या .NET Standard 2.1+

— साइरस

C # एक कंपाइलर है और TryFromBase64String .NET फ्रेमवर्क का एपीआई है :)

— user960567

यह गैर-पेड स्ट्रिंग्स के लिए गलत वापस आ जाएगा, यहां एक तय है Convert.TryFromBase64String(base64.PadRight(base64.Length / 4 * 4 + (base64.Length % 4 == 0 ? 0 : 4), '='), new Span<byte>(new byte[base64.Length]), out _):। धन्यवाद।

— २३:२३ पर रवानलॉर्ड २

Answer 3

मुझे पता है कि आपने कहा था कि आप एक अपवाद नहीं पकड़ना चाहते। लेकिन, क्योंकि अपवाद को पकड़ना अधिक विश्वसनीय है, मैं आगे जाऊंगा और इस उत्तर को पोस्ट करूंगा।

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

अपडेट: मैंने विश्वसनीयता को और बेहतर बनाने के लिए oybek का धन्यवाद किया है ।

Comments

base64String.Containsकई बार कॉल करने पर खराब प्रदर्शन के base64Stringकारण बड़ी स्ट्रिंग हो सकती है।

— NucS

@ आप सही हैं, हम यहां एक संकलित रेगेक्स का उपयोग कर सकते हैं।

— हरसिमरनब

आप के base64String== null || base64String.Length == 0साथ की जाँच कर सकते हैंstring.IsNullOrEmpty(base64String)

— Daniël Tulp

ध्यान दें कि बेस 64 में बिना इश्यू के व्हाट्सएप (जैसे लाइन ब्रेक) हो सकते हैं। वे पार्सर द्वारा नजरअंदाज कर रहे हैं।

— तीमुथियुस

चूंकि हमारे पास .NET स्रोत कोड तक पहुंच है, अब हम FromBase64String () फ़ंक्शन को इन सभी जांचों को देख सकते हैं। referenceource.microsoft.com/#mscorlib/system/… यदि यह एक वैध आधार 64 स्ट्रिंग है तो आप इसे दो बार जांच रहे हैं। यह सिर्फ अपवाद की कोशिश / पकड़ने के लिए खुश हो सकता है।

— Ieartcsharp

Answer 4

मेरा मानना ​​है कि रेगेक्स होना चाहिए:

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

केवल एक या दो अनुगामी '=' संकेतों से मेल खाते हैं, तीन नहीं।

sवह स्ट्रिंग होनी चाहिए जिसे जांचा जाएगा। नाम स्थान Regexका हिस्सा है System.Text.RegularExpressions।

Comments

यह जाँच नहीं करता है कि क्या स्ट्रिंग की लंबाई 4 = 0 है

— कैलिंगासन

Answer 5

सिर्फ अपवाद को क्यों नहीं पकड़ा, और झूठी वापसी की?

यह आम मामले में अतिरिक्त ओवरहेड से बचा जाता है।

Comments

यह एक असामान्य मामला है जो मुझे लगता है कि मैं मूल्य का उपयोग करने जा रहा हूं, आधार 64 नहीं होने की अधिक संभावना है इसलिए मैं अपवाद के ओवरहेड से बचना चाहूंगा। इससे पहले जांच करना बहुत तेज है। मैं एक पुराने सिस्टम को बदलने की कोशिश कर रहा हूं जो मुझे स्पष्ट पाठ पासवर्ड से हैशेड मानों में विरासत में मिला है।

— क्रिस मुलिंस

टायलर जो सुझाव दे रहा है, उससे नियमित अभिव्यक्ति कभी तेज नहीं होती है।

— विंसेंट कोमैन

मेरी पोस्ट के नीचे टिप्पणी देखें। मुझे लगता है कि आप जिस स्ट्रिंग्स के साथ काम कर रहे हैं उसकी लंबाई के आधार पर, पहले परीक्षण करना तेज़ हो सकता है, खासकर हैशेड पासवर्ड जैसे छोटे स्ट्रिंग्स के लिए। Regex पर पहुंचने के लिए स्ट्रिंग को 4 से अधिक होना चाहिए, और फिर एक छोटे स्ट्रिंग पर regex बहुत बड़े स्ट्रिंग की तुलना में तेज़ होता है।

— क्रिस मुलिंस

एक आदर्श दुनिया में, किसी को कोड नहीं लिखना चाहिए जिसका व्यावसायिक तर्क डिज़ाइन किया गया है या अपवाद फेंकने के लिए जाना जाता है। एक्सेप्शन ट्राई / कैच ब्लॉक एक निर्णय ब्लॉक के रूप में इस्तेमाल किया जाना बहुत महंगा है।

— इस्माइल हैवेल

Answer 6

बस पूर्णता के लिए मैं कुछ कार्यान्वयन प्रदान करना चाहता हूं। आम तौर पर रेगेक्स बोलना एक महंगा दृष्टिकोण है, खासकर अगर स्ट्रिंग बड़ी है (जो बड़ी फ़ाइलों को स्थानांतरित करते समय होती है)। निम्नलिखित दृष्टिकोण पहले पता लगाने के सबसे तेज़ तरीकों की कोशिश करता है।

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

संपादित करें

जैसा कि सैम द्वारा सुझाया गया है , आप स्रोत कोड को थोड़ा बदल भी सकते हैं। वह परीक्षणों के अंतिम चरण के लिए एक बेहतर प्रदर्शन दृष्टिकोण प्रदान करता है। दिनचर्या

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

प्रतिस्थापित करने के लिए इस्तेमाल किया जा सकता है if (!Base64Chars.Contains(value[i])) साथ लाइनif (IsInvalid(value[i]))

सैम से एन्हांसमेंट के साथ पूर्ण स्रोत कोड इस तरह दिखाई देगा (स्पष्टता के लिए टिप्पणियां हटा दी गईं)

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

Answer 7

उत्तर स्ट्रिंग के उपयोग पर निर्भर होना चाहिए। ऐसे कई तार हैं जो कई पोस्टरों द्वारा सुझाए गए वाक्यविन्यास के अनुसार "मान्य आधार 64" हो सकते हैं, लेकिन वह बिना किसी अपवाद के "सही" डिकोड कर सकता है, कबाड़ के लिए। उदाहरण: 8char स्ट्रिंग Portlandमान्य Base64 है। यह बताने का क्या मतलब है कि यह वैध 6464 है? मुझे लगता है कि कुछ बिंदु पर आप यह जानना चाहेंगे कि इस स्ट्रिंग को बेस 64 डिकोड किया जाना चाहिए या नहीं होना चाहिए।

मेरे मामले में, मेरे पास ओरेकल कनेक्शन स्ट्रिंग्स हैं जो सादे पाठ में हो सकते हैं जैसे:

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

या जैसे base64 में

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

मुझे बस एक अर्धविराम की उपस्थिति की जांच करनी है, क्योंकि यह साबित करता है कि यह बेस 64 नहीं है, जो कि किसी भी उपरोक्त विधि से तेज है।

Comments

सहमत हूँ, मामले की बारीकियों ने कुछ अतिरिक्त फास्ट चेक भी लगाए। बस प्लेनटेक्स्ट कनेक्शनस्ट्रिंग बनाम बेस 64 इनकोडिंग।

— ओयबेक

Answer 8

हाई फुटबॉल नियम!

यह अपेक्षाकृत तेज और सटीक होना चाहिए, लेकिन मैं मानता हूं कि मैंने इसे पूरी तरह से परीक्षण के माध्यम से नहीं रखा, बस कुछ ही।

यह महंगे अपवादों से बचता है, रेगेक्स, और एक वर्ण सेट के माध्यम से लूपिंग से भी बचता है, बजाय सत्यापन के लिए एएससीआई पर्वतमाला का उपयोग करता है।

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

Answer 9

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

Comments

क्यों आप पहली बार अन्य चीजों को नियंत्रित करने की कोशिश करते हैं

— Snr

@ आप सही हैं। मुझे लगता है कि यह वही है जिसे उसे बदलने की आवश्यकता है: अगर (value.EndsWith ("=")) {value = value .rim (); int mod4 = value.Length% 4; if (mod4! = 0) {झूठा वापस; } Convert.FromBase64String (मान); सच लौटना; } और {झूठे वापस; }

— वाजिद खान

Answer 10

मैं इस तरह का उपयोग करेंगे ताकि मुझे कन्वर्ट विधि को फिर से कॉल करने की आवश्यकता न हो

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

Answer 11

डिकोड करें, फिर से एनकोड करें और मूल स्ट्रिंग के परिणाम की तुलना करें

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

Answer 12

वास्तव में यह संभव नहीं है। सभी पोस्ट किए गए समाधान "परीक्षण" और इसी तरह के तार के लिए विफल हो जाते हैं। यदि उन्हें 4 से विभाजित किया जा सकता है, तो वे अशक्त या खाली नहीं हैं, और यदि वे एक वैध आधार 64 वर्ण हैं, तो वे सभी परीक्षण पास करेंगे। यह कई तार हो सकता है ...

तो यह जानने के अलावा कोई वास्तविक समाधान नहीं है कि यह एक आधार 64 एन्कोडेड स्ट्रिंग है । मैं इसके साथ आया हूँ:

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

मुझे उम्मीद है कि डिकोड्ड स्ट्रिंग एक निश्चित संरचना के साथ शुरू होती है, इसलिए मैं उसके लिए जांच करता हूं।

Answer 13

ज़रूर। बस सुनिश्चित करें कि प्रत्येक चरित्र के भीतर है बनाने a-z, A-Z, 0-9, /, या +, और साथ स्ट्रिंग समाप्त हो जाती है ==। (कम से कम, कि सबसे आम Base64 कार्यान्वयन है। आप कुछ कार्यान्वयन से उपयोग पात्रों अंतर नज़र आ सकता /या +पिछले दो पात्रों के लिए।)

Comments

अगर मुझे समझ में आया, तो अंतिम चरण एन्कोडेड पाठ की अंतिम लंबाई पर निर्भर करता है। इसलिए यदि एन्कोडेड पाठ की लंबाई 4% नहीं है, तो '=' शामिल हैं।

— राफेल डिएगो निकोलेट्टी

Answer 14

हां, चूंकि बेस64 ASCII स्ट्रिंग्स में द्विआधारी डेटा को वर्णों के एक सीमित सेट का उपयोग करके एन्कोड करता है, आप बस इसे इस नियमित अभिव्यक्ति के साथ देख सकते हैं:

/ ^ [एक-zA-Z0-9 \ = \ + \ / \ s \ n] + $ / s

जो आश्वस्त करेगा कि स्ट्रिंग में केवल AZ, az, 0-9, '+', '/', '=' और व्हाट्सएप शामिल हैं।

Comments

यह हमेशा बताने का एक निश्चित तरीका नहीं है। बेस 64 =अंत में चरित्र का उपयोग करते हुए आपके लिए कुछ पैडिंग करता है । यदि वह पैडिंग अमान्य है, तो यह एक सही आधार 64 एन्कोडिंग नहीं है, भले ही यह आपके regex से मेल खाता हो। आप =अंत में 1 या 2 के साथ एक बेस 64 स्ट्रिंग ढूंढकर , उन्हें हटाकर और इसे डिकोड करने का प्रयास करके इसे प्रदर्शित कर सकते हैं।

— vcsjones

मेरा मानना ​​है कि ओपी ने गैरकानूनी चरित्रों के लिए फंसाने के लिए कहा था, न कि अगर कानूनी कानूनी आधार था। यदि उत्तरार्द्ध, आप सही हैं, हालांकि Base64 में पैडिंग त्रुटियां अपवादों का उपयोग करके फंसाना आसान है।

— रोब Raisch

सच नहीं है, बेस 64 पार्सर के कम से कम .Net संस्करण पूरी तरह से पैडिंग को नजरअंदाज करते हैं।

— जय

Answer 15

मैं काम करने के लिए एक regex बनाने का सुझाव दूंगा। आपको कुछ इस तरह से जांचना होगा: [a-zA-Z0-9 + / =] आपको स्ट्रिंग की लंबाई भी जांचनी होगी। मुझे इस पर यकीन नहीं है, लेकिन मुझे पूरा यकीन है कि अगर कुछ छंटनी होती है (पैडिंग "=" के अलावा) तो यह और बढ़ जाएगा।

या बेहतर अभी तक इस stackoverflow प्रश्न की जाँच करें

Answer 16

मेरे पास बस एक समान आवश्यकता थी जहां मैं उपयोगकर्ता को किसी <canvas>तत्व में कुछ छवि हेरफेर करने दे रहा हूं और फिर परिणामी छवि .toDataURL()को बैकएंड के साथ पुनः भेज रहा हूं । मैं छवि सहेजने से पहले कुछ सर्वर सत्यापन करना चाहता था और ValidationAttributeअन्य उत्तरों में से कुछ कोड का उपयोग करके कार्यान्वित किया है:

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

जैसा कि आप देख सकते हैं कि मैं एक छवि / पीएनजी टाइप स्ट्रिंग की उम्मीद कर रहा हूं, जो कि <canvas>उपयोग करते समय डिफ़ॉल्ट रूप से वापस आ जाती है .toDataURL()।

Answer 17

बेस 64 या सामान्य स्ट्रिंग की जाँच करें

सार्वजनिक मल IsBase64Encoded (स्ट्रिंग स्ट्रिंग)

{

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

}

Answer 18

सभी उत्तरों को 1 फ़ंक्शन में पचाया गया है जो 100% सुनिश्चित करता है कि इसके परिणाम सटीक होंगे।

1) नीचे के रूप में समारोह का उपयोग करें:

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

2) नीचे समारोह है:

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

Answer 19

मुझे एक रेगुलर एक्सप्रेशन चेक का आइडिया पसंद है। नियमित अभिव्यक्तियाँ तेज़ हो सकती हैं, और कई बार कोडिंग ओवरहेड को बचा सकती हैं। ओरिजिनल इंक्वायरी में एक अपडेट था जिसने यह किया। हालांकि, मुझे लगता है कि मैं कभी नहीं मान सकता कि तार अशक्त नहीं होंगे। मैं अशक्त, या व्हाट्सएप केवल वर्णों के लिए स्रोत स्ट्रिंग की जांच करने के लिए एक्सटेंशन फ़ंक्शन का विस्तार करूंगा।

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

    }

Comments

यह विफल हो जाता है। एक स्ट्रिंग को पास करने की कोशिश करें जिसमें 4 अक्षर हैं जैसे 'आआआ'।

— बेट्टीम्स