¿Cómo lograr la codificación segura de URL Base64 en C #?

Quiero lograr una codificación segura de URL Base64 en C #. En Java, tenemos la Codecbiblioteca común que me da una cadena codificada segura para URL. ¿Cómo puedo lograr lo mismo usando C #?

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

El código anterior lo convierte a Base64, pero rellena ==. ¿Hay alguna forma de lograr una codificación segura de URL?

Es común simplemente intercambiar el alfabeto para usarlo en las URL, por lo que no es necesaria la codificación%; sólo 3 de los 65 caracteres son problemáticos - +, /y =. los reemplazos más comunes están -en lugar de +y _en lugar de /. En cuanto al acolchado: simplemente quítelo (el =); puede inferir la cantidad de relleno necesaria. En el otro extremo: simplemente invierta el proceso:

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

con:

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

y para revertir:

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

Sin embargo, la pregunta interesante es: ¿ es este el mismo enfoque que utiliza la "biblioteca de códecs común"? Sin duda, sería una primera cosa razonable para probar; este es un enfoque bastante común.

Puede usar la clase Base64UrlEncoderdel espacio de nombres 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!");

Otra opción, si está utilizando ASP.NET Core, sería utilizar Microsoft.AspNetCore.WebUtilities.WebEncoders.Base64UrlEncode.

Si no está utilizando ASP.NET Core, la WebEncodersfuente está disponible bajo la licencia Apache 2.0 .

Basándonos en las respuestas aquí con algunas mejoras de rendimiento, hemos publicado una implementación de base64 segura para URL muy fácil de usar para NuGet con el código fuente disponible en GitHub (con licencia MIT).

El uso es tan fácil como

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

Para obtener una codificación tipo base64 segura para URL, pero no "base64url" según RFC4648, utilice System.Web.HttpServerUtility.UrlTokenEncode(bytes)para codificar y System.Web.HttpServerUtility.UrlTokenDecode(bytes)decodificar.

Solución más simple: (sin relleno)

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
  }

El crédito es para: Tholle

Aquí hay otro método para decodificar una base64 segura para URL que se codificó de la misma manera con Marc. Simplemente no entiendo por qué 4-length%4funcionó (lo hace).

De la siguiente manera, solo la longitud de bits del origen es un múltiplo común de 6 y 8, base64 no agrega "=" al resultado.

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

Entonces podemos hacerlo a la inversa, si la longitud de bits del resultado no puede ser divisible por 8, se ha agregado:

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

Usando el motor criptográfico de Microsoft en UWP.

uint length = 32;

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

return base64Str;

La respuesta de Karanvir Kang es buena y yo voté a favor. Sin embargo, deja un carácter impar al final de la cadena (que indica el número de caracteres de relleno eliminados). Aquí está mi solución.

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