Convertir des.FromBase64String retourne unicode parfois, ou UTF-8

Parfois, le tableau d'octets b64 est UTF-8, et d'autres fois UTF-16. Je lis en ligne que C# les chaînes sont toujours UTF-16, mais ce n'est pas le cas pour moi ici. Pourquoi est-ce qui se passe, et comment puis-je résoudre ce problème? J'ai une méthode simple pour la conversion d'une chaîne base64 normale à la chaîne:

public static string FromBase64(this string input)
{
    String corrected = new string(input.ToCharArray());
    byte[] b64 = Convert.FromBase64String(corrected);
    if (b64[1] == 0)
    {
        return System.Text.Encoding.Unicode.GetString(b64);
    }
    else
    {
        return System.Text.Encoding.UTF8.GetString(b64);
    }

}

La même chose se passe pour ma base 64 encodeur:

public static string ToBase64(this string input)
{
    String b64 = Convert.ToBase64String(input.GetBytes());
    return b64;
}

public static byte[] GetBytes(this string str)
{
    byte[] bytes = new byte[str.Length * sizeof(char)];
    System.Buffer.BlockCopy(str.ToCharArray(), 0, bytes, 0, bytes.Length);
    return bytes;
}

Exemple:
Sur mon ordinateur, "cABhAHMAcwB3AG8AcgBkADEA" décode:

'p',''p','\0','a','\0','s','\0','s','\0','w','\0','o','\0','r','\0','d','\0','1','\0'
','a',''p','\0','a','\0','s','\0','s','\0','w','\0','o','\0','r','\0','d','\0','1','\0'
','s',''p','\0','a','\0','s','\0','s','\0','w','\0','o','\0','r','\0','d','\0','1','\0'
','s',''p','\0','a','\0','s','\0','s','\0','w','\0','o','\0','r','\0','d','\0','1','\0'
','w',''p','\0','a','\0','s','\0','s','\0','w','\0','o','\0','r','\0','d','\0','1','\0'
','o',''p','\0','a','\0','s','\0','s','\0','w','\0','o','\0','r','\0','d','\0','1','\0'
','r',''p','\0','a','\0','s','\0','s','\0','w','\0','o','\0','r','\0','d','\0','1','\0'
','d',''p','\0','a','\0','s','\0','s','\0','w','\0','o','\0','r','\0','d','\0','1','\0'
','1',''p','\0','a','\0','s','\0','s','\0','w','\0','o','\0','r','\0','d','\0','1','\0'
'

Mais sur mes collègues de l'ordinateur c'est:

'p','a','s','s','w','o','r','d','1'

Edit:

Je sais que la chaîne que je vient de créer une zone de texte, et que le fichier où je suis d'économie qu'il va toujours être en UTF-8, donc tout est pour le pointage de l'Convertir méthode la cause de mes codage switch.

Mise à jour:

Après creuser plus loin, il semble que mon collègue avait un pas très important a commenté dans sa version du code, celui qui enregistre la valeur lue à partir du fichier de la table de hachage. La valeur par défaut j'ai utilisé est UTF-8 base64 valeur, donc je vais corriger le défaut, à un utf-16 valeur, alors je peux nettoyer le code en supprimant tout UTF8 références.

Aussi, j'avais été naïvement à l'aide de l'UTF-8 est un encodage base64 j'avais récupéré à partir d'un site web, ne réalisant pas ce qui m'attendait. Le plus drôle, c'est que je n'aurais jamais trouvé que fait, si mon collègue n'avait pas commenté la ligne qui enregistre les valeurs dans le fichier.

Version finale du code:

public static string FromBase64(this string input)
{
    byte[] b64 = Convert.FromBase64String(input);
    return System.Text.Encoding.Unicode.GetString(b64);
}

public static string ToBase64(this string input)
{
    String b64 = Convert.ToBase64String(input.GetBytes());
    return b64;
}

public static byte[] GetBytes(this string str)
{
    return System.Text.Encoding.Unicode.GetBytes(str);
}

Qu'est-ce que String corrected = new string(input.ToCharArray()); censé faire? Il ne fait aucun sens.
C'était une tentative pour obtenir la sortie à jouer très bien. J'ai pensé qu'il n'aurait aucun effet sur la sortie, et il n'a pas, je n'ai tout simplement pas l'enlever avant de poster la question.

OriginalL'auteur david.tanner | 2014-01-21

base64 c#encoding unicode utf-8

8

Tout d'abord, je tiens à démystifier le titre de la question:

Convert.FromBase64String() retourne Unicode parfois, ou UTF-8

Qui n'est pas le cas. Donner alors même entrée, valable encodées en base64 texte, Convert.FromBase64String() retourne toujours le même résultat.

Déplaçant sur, vous ne pouvez pas déterminer définitivement, juste par l'examen de la charge utile, le codage utilisé pour une chaîne de caractères. Vous tentez de le faire avec
```
if (b64[1] == 0)
    //encoding must be UTF-16
```
Ce n'est pas le cas. L'écrasante majorité de caractère UTF-16 éléments de l'échec du test. Il n'a pas d'importance comment vous essayez d'écrire ce test, il est voué à l'échec. Et c'est parce qu'il existe des tableaux d'octets qui sont bien définis, les chaînes lorsqu'ils sont interprétés comme des codages différents. En d'autres termes, il est possible, par exemple, de construire des tableaux d'octets qui sont valides au moment considéré, soit comme l'UTF-8 ou UTF-16.

Donc, vous devez savoir a priori si la charge utile est codé en UTF-16, UTF-8 ou en effet un autre encodage.

La solution sera de garder une trace de l'origine de l'encodage, avant le codage base64. Passer cette information ainsi que la encodées en base64 de la charge utile. Puis, quand vous décoder, vous pouvez déterminer qui Encoding à utiliser pour décoder en une chaîne de caractères.

Il me semble très bien que vos chaînes sont tous issus de l'UTF-16 .net des chaînes de caractères. Dans ce cas, vous n'aurez pas des chaînes UTF-8 jamais, et doit toujours décoder avec UTF-16. Qu'est que vous utilisez Encoding.Unicode.GetString().

Aussi, le GetBytes méthode dans votre code est mauvais. Il doit être:
```
public static byte[] GetBytes(this string str)
{
    return Encoding.Unicode.GetBytes(str);
}
```
Autre bizarrerie:
```
String corrected = new string(input.ToCharArray());
```
C'est un no-op.

Enfin, il est fort probable que votre texte sera plus compact lorsqu'il est codé en UTF-8. Alors peut-être vous devriez envisager de le faire qu'avant l'application de l'encodage base64.

Au sujet de votre mise à jour, ce que vous dites est inexact. Ce code:
```
string str = Encoding.Unicode.GetString(
    Convert.FromBase64String("cABhAHMAcwB3AG8AcgBkADEA"));
```
attribue password1 à str où il est exécuté.

Les cordes sont à l'intérieur d'abord, sauf quand je les enregistrer dans un fichier, ou de les lire. Donc je ne comprends pas pourquoi je reçois un codage différent d'une machine à une autre.
Vous devez savoir d'avance quel est l'encodage. Vous ne pouvez pas déterminer à partir de la charge utile. L'ensemble de la prémisse de votre code est erroné.
Si la chaîne est toujours unicode, comment se fait il n'est pas sur d'autres portables qui exécutent le même code? J'ai dû ajouter de l'UTF8 décoder pour cette raison.
.net de chaîne est toujours UTF-16. Avez-vous contester ce fait?
C'est ce que j'essaie de comprendre. Est-ce la chaîne de venir en changeant de format, ou tout simplement les résultats de la Convertir.FromBase64String() méthode qui est me gâcher. Voir mon exemple supplémentaire pour les résultats que j'obtiens.

OriginalL'auteur David Heffernan

Essayer de réviser le code pour le rendre un peu plus lisible et précis. Comme mentionné dans mon commentaire et David hefferman nous a ensuite la réponse que vous essayez de faire les choses qui soit:

A) ne rien faire

B) démontrer logique défectueuse

Suivants du code basé sur le vôtre fonctionne très bien:

class Program
{
    static void Main(string[] args)
    {
        string original = "password1";
        string encoded = original.ToBase64();
        string decoded = encoded.FromBase64();
        Console.WriteLine("Original: {0}", original);
        Console.WriteLine("Encoded: {0}", encoded);
        Console.WriteLine("Decoded: {0}", decoded);
    }
}

public static class Extensions
{
    public static string FromBase64(this string input)
    {
        return System.Text.Encoding.Unicode.GetString(Convert.FromBase64String(input));
    }

    public static string ToBase64(this string input)
    {
        return Convert.ToBase64String(input.GetBytes());
    }

    public static byte[] GetBytes(this string str)
    {
        return System.Text.Encoding.Unicode.GetBytes(str);
    }
}

OriginalL'auteur McAden

-1

Ce que vous faites n'est pas différent de l'encodage de données dans les deux ou ASCII, EBCDIC, d'essayer de comprendre ce qui a été utilisé au cours de la décoder. Comme vous l'avez déjà découvert, cela ne va pas très bien fonctionner.

La seule façon d'obtenir que cela fonctionne correctement est d'avoir un unique format d'encodage utilisé par tous les participants. C'est un concept fondamental de la communication.

Choisir un encodage - disons en UTF-8 et de l'utiliser pour toutes les transformations entre String et byte[]. Cela permettra d'assurer que vous avez une connaissance précise du format de la charge utile et la façon de traiter avec elle, comme David Tanner a dit.

Voici le formulaire de base:
```
public static string ToBase64(this string self)
{
    byte[] bytes = Encoding.UTF8.GetBytes(self);
    return Convert.ToBase64String(bytes);   
}

public static string FromBase64(this string self)
{
    byte[] bytes = Convert.FromBase64String(self);
    return Encoding.UTF8.GetString(bytes);
}
```
Quel qu'en soit quelque chose d'étrange qui se passe entre vos ordinateurs, ce code va produire les mêmes chaînes codées.

OriginalL'auteur Corey

Vous devez vous connecter pour publier un commentaire.