Come ottenere la codifica sicura dell'URL Base64 in C #?

Voglio ottenere la codifica sicura dell'URL Base64 in C #. In Java, abbiamo la Codeclibreria comune che mi fornisce una stringa codificata sicura per l'URL. Come posso ottenere lo stesso risultato usando C #?

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

Il codice sopra lo converte in Base64, ma si riempie ==. C'è un modo per ottenere la codifica sicura degli URL?

È comune scambiare semplicemente l'alfabeto per l'uso negli URL, in modo che non sia necessaria la codifica%; solo 3 dei 65 caratteri sono problematici - +, /e =. le sostituzioni più comuni sono -al posto di +e _al posto di /. Per quanto riguarda l'imbottitura: basta rimuoverla (la =); puoi dedurre la quantità di imbottitura necessaria. All'altra estremità: basta invertire il processo:

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

con:

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

e per invertire:

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

La domanda interessante, tuttavia, è: è questo lo stesso approccio utilizzato dalla "libreria di codec comuni"? Sarebbe certamente una prima cosa ragionevole da testare: questo è un approccio piuttosto comune.

Puoi usare class Base64UrlEncoderdallo spazio dei nomi 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!");

Un'altra opzione, se stai usando ASP.NET Core, sarebbe usare Microsoft.AspNetCore.WebUtilities.WebEncoders.Base64UrlEncode.

Se non si utilizza ASP.NET Core, l' WebEncodersorigine è disponibile con la licenza Apache 2.0 .

Sulla base delle risposte qui con alcuni miglioramenti delle prestazioni, abbiamo pubblicato un molto facile da usare un'implementazione base64 e sicura per l'URL in NuGet con il codice sorgente disponibile su GitHub (con licenza MIT).

L'utilizzo è facile quanto

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

Per ottenere una codifica simile a base64 sicura per gli URL, ma non "base64url" secondo RFC4648, utilizzare System.Web.HttpServerUtility.UrlTokenEncode(bytes)per codificare e System.Web.HttpServerUtility.UrlTokenDecode(bytes)decodificare.

Soluzione più semplice: (senza imbottitura)

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
  }

Il merito va a: Tholle

Ecco un altro metodo per decodificare un base64 sicuro per l'URL che è stato codificato allo stesso modo con Marc. Semplicemente non capisco perché4-length%4 funzionato (lo fa).

Come segue, solo la lunghezza in bit dell'origine è un multiplo comune di 6 e 8, base64 non aggiunge "=" al risultato.

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
                "=="            "="

Quindi possiamo farlo al contrario, se la lunghezza del bit del risultato non può essere divisibile per 8, è stato aggiunto:

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

Utilizzo del motore crittografico Microsoft in UWP.

uint length = 32;

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

return base64Str;

La risposta di Karanvir Kang è buona e ho votato a favore. Tuttavia, lascia un carattere dispari alla fine della stringa (che indica il numero di caratteri di riempimento rimossi). Ecco la mia soluzione.

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