Comment réaliser un encodage sécurisé d'URL Base64 en C #?

Je souhaite obtenir un encodage sécurisé d'URL Base64 en C #. En Java, nous avons la Codecbibliothèque commune qui me donne une chaîne codée URL sécurisée. Comment puis-je réaliser la même chose en utilisant C #?

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

Le code ci-dessus le convertit en Base64, mais il complète ==. Existe-t-il un moyen d'obtenir un encodage sécurisé des URL?

Il est courant d' échanger simplement l'alphabet pour une utilisation dans les URL, de sorte qu'aucun% -encoding n'est nécessaire; seuls 3 des 65 caractères sont problématiques - +, /et =. les remplacements les plus courants sont -à la place +et _à la place de /. Quant au rembourrage: il suffit de le retirer (le =); vous pouvez déduire la quantité de rembourrage nécessaire. À l'autre extrémité: inversez simplement le processus:

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

avec:

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

et inverser:

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 question intéressante, cependant, est: est-ce la même approche que la "bibliothèque de codecs communs" utilise? Ce serait certainement une première chose raisonnable à tester - c'est une approche assez courante.

Vous pouvez utiliser la classe Base64UrlEncoderde l'espace de noms 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!");

Une autre option, si vous utilisez ASP.NET Core, serait d'utiliser Microsoft.AspNetCore.WebUtilities.WebEncoders.Base64UrlEncode .

Si vous n'utilisez pas ASP.NET Core, la WebEncoderssource est disponible sous la licence Apache 2.0 .

Sur la base des réponses ici avec quelques améliorations de performances, nous avons publié une implémentation base64 sécurisée pour les URL très facile à utiliser dans NuGet avec le code source disponible sur GitHub (licence MIT).

L'utilisation est aussi simple que

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

Pour obtenir un encodage de type base64 sécurisé pour les URL, mais pas "base64url" selon RFC4648, utilisez System.Web.HttpServerUtility.UrlTokenEncode(bytes)pour encoder et System.Web.HttpServerUtility.UrlTokenDecode(bytes)pour décoder.

Solution la plus simple: (sans rembourrage)

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
  }

Le mérite revient à: Tholle

Voici une autre méthode pour décoder une url-safe base64 qui a été encodée de la même manière avec Marc. Je ne comprends juste pas pourquoi4-length%4 travaillé (c'est le cas).

Comme suit, seules les longueurs en bits de l'origine sont des multiples communs de 6 et 8, base64 n'ajoute pas "=" au résultat.

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

Nous pouvons donc le faire à l'inverse, si la longueur en bits du résultat ne peut pas être divisible par 8, elle a été ajoutée:

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

Utilisation du moteur cryptographique Microsoft dans UWP.

uint length = 32;

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

return base64Str;

La réponse de Karanvir Kang est bonne et j'ai voté pour. Cependant, il laisse un caractère impair à la fin de la chaîne (indiquant le nombre de caractères de remplissage supprimés). Voici ma solution.

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