Jak osiągnąć bezpieczne kodowanie adresu URL Base64 w C #?

Chcę osiągnąć bezpieczne kodowanie adresu URL Base64 w C #. W Javie mamy wspólną Codecbibliotekę, która daje mi bezpieczny zakodowany łańcuch. Jak mogę osiągnąć to samo za pomocą C #?

byte[] toEncodeAsBytes = System.Text.ASCIIEncoding.ASCII.GetBytes("StringToEncode");
string returnValue = System.Convert.ToBase64String(toEncodeAsBytes);

Powyższy kod konwertuje go na Base64, ale wypełnia ==. Czy istnieje sposób na zapewnienie bezpiecznego kodowania adresów URL?

Zwykle po prostu zamienia się alfabet na potrzeby adresów URL, dzięki czemu nie jest konieczne kodowanie%; tylko 3 z 65 znaków są problematyczne - +, /i =. Najczęstszym zamienniki są -na miejscu +i _na miejscu /. Co do wyściółki: wystarczy ją usunąć (the =); można wywnioskować ilość potrzebnej wyściółki. Z drugiej strony: po prostu odwróć proces:

string returnValue = System.Convert.ToBase64String(toEncodeAsBytes)
        .TrimEnd(padding).Replace('+', '-').Replace('/', '_');

z:

static readonly char[] padding = { '=' };

i odwrócić:

string incoming = returnValue
    .Replace('_', '/').Replace('-', '+');
switch(returnValue.Length % 4) {
    case 2: incoming += "=="; break;
    case 3: incoming += "="; break;
}
byte[] bytes = Convert.FromBase64String(incoming);
string originalText = Encoding.ASCII.GetString(bytes);

Jednak interesujące pytanie brzmi: czy jest to to samo podejście, którego używa „biblioteka wspólnych kodeków”? Z pewnością rozsądnie byłoby najpierw przetestować - to dość powszechne podejście.

Możesz użyć klasy Base64UrlEncoderz przestrzeni nazw Microsoft.IdentityModel.Tokens.

const string StringToEncode = "He=llo+Wo/rld";

var encodedStr = Base64UrlEncoder.Encode(StringToEncode);
var decodedStr = Base64UrlEncoder.Decode(encodedStr);

if (decodedStr == StringToEncode)
    Console.WriteLine("It works!");
else
    Console.WriteLine("Dangit!");

Inną opcją, jeśli używasz ASP.NET Core, byłoby użycie Microsoft.AspNetCore.WebUtilities.WebEncoders.Base64UrlEncode.

Jeśli nie używasz ASP.NET Core źródłowy jest dostępny pod Apache 2.0 License .WebEncoders

Opierając się na odpowiedziach tutaj z pewnymi ulepszeniami wydajności, opublikowaliśmy bardzo łatwą w użyciu implementację base64 z bezpiecznym adresem URL w NuGet z kodem źródłowym dostępnym w GitHub (na licencji MIT).

Użycie jest tak proste, jak

var bytes = Encoding.UTF8.GetBytes("Foo");
var encoded = UrlBase64.Encode(bytes);
var decoded = UrlBase64.Decode(encoded);

Aby uzyskać bezpieczne kodowanie w formacie base64, ale nie „base64url” zgodnie z RFC4648, użyj System.Web.HttpServerUtility.UrlTokenEncode(bytes)do kodowania i System.Web.HttpServerUtility.UrlTokenDecode(bytes)dekodowania.

Najprostsze rozwiązanie: (bez wypełnienia)

private static string Base64UrlEncode(string input) {
    var inputBytes = System.Text.Encoding.UTF8.GetBytes(input);
    // Special "url-safe" base64 encode.
    return Convert.ToBase64String(inputBytes)
      .Replace('+', '-') // replace URL unsafe characters with safe ones
      .Replace('/', '_') // replace URL unsafe characters with safe ones
      .Replace("=", ""); // no padding
  }

Kredyt trafia do: Tholle

Oto inna metoda dekodowania bezpiecznego adresu URL base64, który został zakodowany w ten sam sposób z Markiem. Po prostu nie rozumiem, dlaczego4-length%4 zadziałało (działa).

Jak poniżej, tylko długość bitu początku jest wspólną wielokrotnością 6 i 8, base64 nie dodaje „=” do wyniku.

1 2 3 4 5 6 7 8|1 2 3 4 5 6 7 8|1 2 3 4 5 6 7 8 
1 2 3 4 5 6|1 2 3 4 5 6|1 2 3 4 5 6|1 2 3 4 5 6
                "=="            "="

Możemy więc zrobić to na odwrót, jeśli długość bitu wyniku nie może być podzielna przez 8, została dodana:

base64String = base64String.Replace("-", "+").Replace("_", "/");
var base64 = Encoding.ASCII.GetBytes(base64String);
var padding = base64.Length * 3 % 4;//(base64.Length*6 % 8)/2
if (padding != 0)
{
    base64String = base64String.PadRight(base64String.Length + padding, '=');
}
return Convert.FromBase64String(base64String);

Korzystanie z aparatu kryptograficznego firmy Microsoft na platformie UWP.

uint length = 32;

IBuffer buffer = CryptographicBuffer.GenerateRandom(length);
string base64Str = CryptographicBuffer.EncodeToBase64String(buffer)
                   // ensure url safe
                   .TrimEnd('=').Replace('+', '-').Replace('/', '_');

return base64Str;

Odpowiedź Karanvira Kanga jest dobra i głosowałem za nią. Jednak na końcu ciągu pozostawia nieparzysty znak (wskazujący liczbę usuniętych znaków wypełniających). Oto moje rozwiązanie.

var bytesToEncode = System.Text.Encoding.UTF8.GetBytes("StringToEncode"); 
var bytesEncodedPadded = HttpServerUtility.UrlTokenEncode(bytesToEncode);
var objectIdBase64 = bytesEncodedPadded.Substring(0, bytesEncodedPadded.Length - 1);