So suchen Sie nach einer gültigen Base64-codierten Zeichenfolge

127

Gibt es in C # eine andere Möglichkeit, festzustellen, ob eine Zeichenfolge Base 64-codiert ist, als nur zu versuchen, sie zu konvertieren, und festzustellen, ob ein Fehler vorliegt? Ich habe folgenden Codecode:

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

Ich möchte die Ausnahme "Ungültiges Zeichen in einer Base-64-Zeichenfolge" vermeiden, die auftritt, wenn der Wert keine gültige Base-64-Zeichenfolge ist. Ich möchte nur false überprüfen und zurückgeben, anstatt eine Ausnahme zu behandeln, da ich davon ausgehe, dass dieser Wert manchmal keine Basis-64-Zeichenfolge ist. Gibt es eine Möglichkeit, dies zu überprüfen, bevor Sie die Convert.FromBase64String-Funktion verwenden?

Vielen Dank!

Update:
Danke für all deine Antworten. Hier ist eine Erweiterungsmethode, die Sie alle verwenden können. Sie scheint sicherzustellen, dass Ihre Zeichenfolge ausnahmslos Convert.FromBase64String besteht. .NET scheint beim Konvertieren in Basis 64 alle nachgestellten und endenden Leerzeichen zu ignorieren, sodass "1234" und "1234" gültig sind.

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

}

Für diejenigen, die sich über die Leistung des Testens im Vergleich zu Fang und Ausnahme wundern, ist es in den meisten Fällen für diese Basis-64-Sache schneller zu überprüfen, als die Ausnahme zu fangen, bis Sie eine bestimmte Länge erreicht haben. Je kleiner die Länge, desto schneller

In meinen sehr unwissenschaftlichen Tests: Bei 10000 Iterationen für die Zeichenlänge 100.000 - 110000 war es 2,7-mal schneller, zuerst zu testen.

Bei 1000 Iterationen für Zeichen mit einer Länge von 1 bis 16 Zeichen für insgesamt 16.000 Tests war es 10,9-mal schneller.

Ich bin sicher, dass es einen Punkt gibt, an dem es besser wird, mit der ausnahmebasierten Methode zu testen. Ich weiß nur nicht, an welchem ​​Punkt das ist.

Chris Mullins
quelle
1
Es hängt davon ab, wie "gründlich" die Prüfung sein soll. Sie können einige Vorvalidierungen mit einem regulären Ausdruck verwenden, wie andere geantwortet haben, aber dies ist nicht der einzige Indikator. Die Base64-Codierung erfordert in einigen Fällen das Auffüllen mit dem =Zeichen. Wenn das Auffüllen falsch ist, wird ein Fehler ausgegeben, obwohl die Eingabe mit einem Ausdruck übereinstimmt.
vcsjones
1
Ihre Bedingung erfüllt nicht ausschließlich base64-Zeichenfolgen. Betrachten Sie die Zeichenfolge \n\fLE16- Ihre Methode würde hierfür ein falsches Positiv ergeben. Für alle, die eine narrensichere Methode lesen und suchen; Ich würde empfehlen, die FormatException abzufangen oder eine für die Spezifikation geeignete RegEx zu verwenden, siehe stackoverflow.com/questions/475074/… .
nullable
Wenn die obige Methode false zurückgibt, wie kann ich die Zeichenfolge auf die richtige Länge auffüllen?
Paul Alexander
3
Ich glaube, dass die RegEx sein sollte@"^[a-zA-Z0-9\+/]*={0,2}$"
Azatar
Diese Lösung ist nicht zuverlässig. Es schlägt fehl, wenn Sie 4 gleiche Zeichenfolgen hinzufügen.
Bettimms

Antworten:

49

Es ist ziemlich einfach, eine Base64-Zeichenfolge zu erkennen, da sie nur aus Zeichen besteht 'A'..'Z', 'a'..'z', '0'..'9', '+', '/'und am Ende häufig mit bis zu drei '=' aufgefüllt wird, um die Länge zu einem Vielfachen von 4 zu machen. Aber anstatt diese zu vergleichen, müssen Sie ' d ist besser dran, die Ausnahme zu ignorieren, wenn sie auftritt.

Anirudh Ramanathan
quelle
1
Ich denke, Sie sind auf dem richtigen Weg. Ich habe einige Tests durchgeführt und es scheint, dass es ein Vielfaches von 4 statt 3 ist.
Chris Mullins
1
Für eine erfolgreiche Codierung muss die Länge zum Zeitpunkt der Codierung ein Vielfaches von 3 sein! Tut mir leid ... und ja, Sie haben Recht ... Die codierte Zeichenfolge hat eine Länge, die ein Vielfaches von 4 ist. Deshalb würden wir bis zu 3 '=' auffüllen.
Anirudh Ramanathan
4
Als richtig markiert, weil Sie als Erster das Vielfache erwähnt haben. Ich habe meine Frage mit einer Implementierung der Lösung aktualisiert. Lassen Sie mich wissen, wenn Sie Probleme damit sehen.
Chris Mullins
47

Verwenden Sie Convert.TryFromBase64String aus 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);
}
Tomas Kubes
quelle
1
Ich wusste nicht, dass das eine Sache ist. Ich denke, dies sollte die neue Antwort sein, wenn Sie c # 7.2
Chris Mullins
4
Funktioniert nur in .NET Core 2.1+ oder .NET Standard 2.1+
Cyrus
C # ist ein Compiler und TryFromBase64String ist die API von .NET Framework :)
user960567
Dies gibt false für nicht aufgefüllte Zeichenfolgen zurück. Hier ist ein Fix : Convert.TryFromBase64String(base64.PadRight(base64.Length / 4 * 4 + (base64.Length % 4 == 0 ? 0 : 4), '='), new Span<byte>(new byte[base64.Length]), out _). Danke dir.
rvnlord vor
44

Ich weiß, dass Sie gesagt haben, Sie wollten keine Ausnahme machen. Da das Abfangen einer Ausnahme zuverlässiger ist, werde ich diese Antwort veröffentlichen.

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

Update: Ich habe den Zustand dank oybek aktualisiert , um die Zuverlässigkeit weiter zu verbessern.

Harsimranb
quelle
1
base64String.ContainsMehrfaches Aufrufen kann zu einer schlechten Leistung führen, wenn base64Stringes sich um eine große Zeichenfolge handelt.
NucS
@NucS Sie haben Recht, wir können hier einen kompilierten regulären Ausdruck verwenden.
Harsimranb
1
Sie können überprüfen base64String== null || base64String.Length == 0mitstring.IsNullOrEmpty(base64String)
Daniël Tulp
Beachten Sie, dass ein Base64 ohne Probleme Leerzeichen (z. B. Zeilenumbrüche) enthalten kann. Sie werden vom Parser ignoriert.
Timothy
2
Da wir jetzt Zugriff auf den .NET-Quellcode haben, können wir sehen, dass die FromBase64String () -Funktion all diese Überprüfungen durchführt. referencesource.microsoft.com/#mscorlib/system/… Wenn es sich um eine gültige base64-Zeichenfolge handelt, überprüfen Sie sie zweimal. Es ist vielleicht chepaer, nur die Ausnahme zu versuchen / zu fangen.
Iheartcsharp
16

Ich glaube, der reguläre Ausdruck sollte sein:

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

Nur ein oder zwei nachfolgende '=' Zeichen, nicht drei.

ssollte die Zeichenfolge sein, die überprüft wird. Regexist Teil des System.Text.RegularExpressionsNamespace.

jazzdev
quelle
1
prüft nicht, ob die Stringlänge mod von 4 = 0 ist
calingasan
7

Warum nicht einfach die Ausnahme abfangen und False zurückgeben?

Dies vermeidet im allgemeinen Fall zusätzlichen Aufwand.

Tyler Eaves
quelle
1
Dies ist ein ungewöhnlicher Fall, bei dem ich denke, dass der Wert eher nicht Basis 64 ist, daher würde ich den Overhead der Ausnahme lieber vermeiden. Es ist viel schneller zu überprüfen. Ich versuche, ein altes System, das ich von Klartextkennwörtern geerbt habe, in Hash-Werte umzuwandeln.
Chris Mullins
2
Reguläre Ausdrücke sind niemals schneller als das, was Tyler vorschlägt.
Vincent Koeman
Siehe den Kommentar am Ende meines Beitrags. Ich denke, abhängig von der Länge der Zeichenfolgen, mit denen Sie arbeiten, kann es schneller sein, zuerst zu testen, insbesondere für kleine Zeichenfolgen wie Hash-Passwörter. Die Zeichenfolge muss ein Vielfaches von 4 sein, um überhaupt zum regulären Ausdruck zu gelangen, und dann ist der reguläre Ausdruck bei einer kleinen Zeichenfolge schneller als bei einer sehr großen Zeichenfolge.
Chris Mullins
2
In einer perfekten Welt sollte man keinen Code schreiben, dessen Geschäftslogik entworfen ist oder von dem bekannt ist, dass er Ausnahmen auslöst. Der Ausnahme-Try / Catch-Block ist zu teuer, um als Entscheidungsblock verwendet zu werden.
Ismail Hawayel
7

Der Vollständigkeit halber möchte ich eine Implementierung bereitstellen. Im Allgemeinen ist Regex ein teurer Ansatz, insbesondere wenn die Zeichenfolge groß ist (was beim Übertragen großer Dateien der Fall ist). Der folgende Ansatz versucht zuerst die schnellsten Erkennungsmethoden.

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

BEARBEITEN

Wie von Sam vorgeschlagen , können Sie den Quellcode auch geringfügig ändern. Er bietet einen leistungsfähigeren Ansatz für den letzten Testschritt. Die Routine

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

kann verwendet werden, um die if (!Base64Chars.Contains(value[i]))Linie durch zu ersetzenif (IsInvalid(value[i]))

Der vollständige Quellcode mit Verbesserungen von Sam sieht folgendermaßen aus (Kommentare wurden aus Gründen der Übersichtlichkeit entfernt).

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;
    }
}
Oybek
quelle
4

Die Antwort muss von der Verwendung der Zeichenfolge abhängen. Es gibt viele Zeichenfolgen, die gemäß der von mehreren Postern vorgeschlagenen Syntax "valid base64" sein können, die jedoch ausnahmslos "korrekt" in Junk dekodieren können. Beispiel: Die 8-Zeichen-Zeichenfolge Portlandist gültig Base64. Was ist der Grund dafür, dass dies eine gültige Base64 ist? Ich denke, irgendwann möchten Sie wissen, dass diese Zeichenfolge Base64-decodiert sein sollte oder nicht.

In meinem Fall habe ich Oracle-Verbindungszeichenfolgen, die möglicherweise im Klartext vorliegen:

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

oder in base64 wie

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

Ich muss nur nach einem Semikolon suchen, da dies beweist, dass es sich NICHT um base64 handelt, was natürlich schneller ist als jede der oben genannten Methoden.

Roland
quelle
Stimmen Sie zu, Fallspezifikationen erfordern auch bestimmte zusätzliche schnelle Überprüfungen. Genau wie Klartext-Verbindungszeichenfolge gegen Base64-codiert.
Oybek
2

Knibb Hohe Fußballregeln!

Dies sollte relativ schnell und genau sein, aber ich gebe zu, dass ich es nicht gründlich getestet habe, nur ein paar.

Es vermeidet teure Ausnahmen, Regex und das Durchlaufen eines Zeichensatzes, stattdessen werden ASCII-Bereiche zur Validierung verwendet.

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;
    }
Jason K.
quelle
2
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;
            }
        }
user3181503
quelle
warum Sie zuerst versuchen zu konvertieren, dann andere Dinge zu kontrollieren
Snr
@ Snr du hast recht. Ich denke, das muss er ändern: if (value.EndsWith ("=")) {value = value.Trim (); int mod4 = value.Length% 4; if (mod4! = 0) {return false; } Convert.FromBase64String (Wert); return true; } else {return false; }
Wajid Khan
2

Ich werde dies verwenden, damit ich die Konvertierungsmethode nicht erneut aufrufen muss

   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;
    }
Yaseer Arafat
quelle
2

Dekodieren Sie das Ergebnis, codieren Sie es neu und vergleichen Sie es mit der ursprünglichen Zeichenfolge

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;
}
PKOS
quelle
1

Imho ist das nicht wirklich möglich. Alle veröffentlichten Lösungen schlagen für Zeichenfolgen wie "Test" usw. fehl . Wenn sie durch 4 geteilt werden können, nicht null oder leer sind und wenn sie ein gültiges base64-Zeichen sind, bestehen sie alle Tests. Das können viele Saiten sein ...

Es gibt also keine wirkliche Lösung, außer zu wissen, dass dies eine Base 64-codierte Zeichenfolge ist . Was ich mir ausgedacht habe, ist Folgendes:

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

Ich erwarte, dass der dekodierte String mit einer bestimmten Struktur beginnt, also überprüfe ich das.

testen
quelle
0

Sicher. So stellen Sie sicher , dass jedes Zeichen in a-z, A-Z, 0-9, /, oder +, und die Schnurenden mit ==. (Zumindest ist das die häufigste Base64 - Implementierung. Sie könnten einige Implementierungen , dass die Verwendung Zeichen anders finden /oder +für die letzten zwei Zeichen ein .)


quelle
Wenn ich verstanden habe, hängen die Endzeichen von der endgültigen Länge des codierten Textes ab. Wenn der codierte Text also nicht die Länge% 4 hat, ist '=' enthalten.
Rafael Diego Nicoletti
0

Ja, da Base64 Binärdaten mit einem begrenzten Zeichensatz in ASCII-Zeichenfolgen codiert, können Sie dies einfach mit diesem regulären Ausdruck überprüfen:

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

Dadurch wird sichergestellt, dass die Zeichenfolge nur AZ, az, 0-9, '+', '/', '=' und Leerzeichen enthält.

Rob Raisch
quelle
Das ist nicht immer eine sichere Art zu sagen. Base64 füllt das =Zeichen am Ende mit dem Zeichen am Ende auf. Wenn diese Auffüllung ungültig ist, handelt es sich nicht um eine korrekte Base64-Codierung, obwohl sie mit Ihrer Regex übereinstimmt. Sie können dies demonstrieren =, indem Sie eine 64-Zeichenfolge mit 1 oder 2 am Ende suchen , diese entfernen und versuchen, sie zu dekodieren.
vcsjones
Ich glaube, das OP hat darum gebeten, nach illegalen Charakteren zu suchen, nicht wenn es sich bei der str um legale Base64 handelt. In letzterem Fall sind Sie korrekt, obwohl Auffüllfehler in Base64 mit Ausnahmen leichter abzufangen sind.
Rob Raisch
Nicht wahr, zumindest ignoriert die .Net-Version des Base64-Parsers das Auffüllen vollständig.
Jay
0

Ich würde vorschlagen, einen regulären Ausdruck zu erstellen, um die Arbeit zu erledigen. Sie müssen Folgendes überprüfen: [a-zA-Z0-9 + / =] Sie müssen auch die Länge der Zeichenfolge überprüfen. Ich bin mir nicht sicher, aber ich bin mir ziemlich sicher, dass etwas, das beschnitten wird (außer der Polsterung "="), explodieren würde.

Oder besser noch diese Frage zum Stapelüberlauf

Jay
quelle
0

Ich hatte gerade eine sehr ähnliche Anforderung, bei der ich den Benutzer einige Bildmanipulationen in einem <canvas>Element durchführen und dann das resultierende Bild, das mit abgerufen wurde, .toDataURL()an das Backend senden kann . Ich wollte vor dem Speichern des Images eine Serverüberprüfung durchführen und habe einen ValidationAttributeTeil des Codes aus anderen Antworten implementiert :

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

Wie Sie sehen können, erwarte ich eine Zeichenfolge vom Typ image / png. Dies ist die Standardeinstellung, die <canvas>bei der Verwendung zurückgegeben wird .toDataURL().

Germankiwi
quelle
0

Überprüfen Sie Base64 oder eine normale Zeichenfolge

public bool IsBase64Encoded (String 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;
}

}}

Navdeep Kapil
quelle
0

Alle Antworten wurden in eine Funktion zusammengefasst, die zu 100% sicherstellt, dass die Ergebnisse korrekt sind.


1) Verwenden Sie die folgende Funktion:

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

2) Unten ist die Funktion:

  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;
        }
    }
Muhammad Ali
quelle
-1

Ich mag die Idee einer Prüfung auf reguläre Ausdrücke. Reguläre Ausdrücke können schnell sein und zeitweise den Codierungsaufwand sparen. Die ursprüngliche Anfrage hatte ein Update, das genau dies tat. Ich finde jedoch, dass ich niemals davon ausgehen kann, dass die Zeichenfolgen nicht null sind. Ich würde die Erweiterungsfunktion erweitern, um die Quellzeichenfolge auf Null- oder Nur-Leerzeichen-Zeichen zu überprüfen.

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

    }
Joseph
quelle
Dies schlägt fehl. Versuchen Sie, eine Zeichenfolge mit 4 Zeichen zu übergeben, die mit 'aaaa' identisch ist.
Bettimms