Comment préparer correctement une requête SAML de redirection HTTP en utilisant C #

J'ai besoin de créer un SP lancé SAML 2.0 Authentification de la transaction à l'aide de HTTP de Redirection de Liaison de la méthode. Il s'avère que c'est assez facile. Juste obtenir de l'IdP, d'URI et de concaténer une seule chaîne de la requête param SAMLRequest. Le param est un bloc codé en xml qui décrit la requête SAML. So far So good.

Le problème vient lors de la conversion de la SAML dans la chaîne de requête param. Je crois que ce processus de préparation doit être:

Construire un SAML chaîne
Compresser cette chaîne
Base64 encode la chaîne
UrlEncode la chaîne.

La Requête SAML

<samlp:AuthnRequest
    xmlns:samlp="urn:oasis:names:tc:SAML:2.0:protocol"
    xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion"
    ID="{0}"
    Version="2.0"
    AssertionConsumerServiceIndex="0"
    AttributeConsumingServiceIndex="0">
    <saml:Issuer>URN:xx-xx-xx</saml:Issuer>
    <samlp:NameIDPolicy
        AllowCreate="true"
        Format="urn:oasis:names:tc:SAML:2.0:nameid-format:transient"/>
</samlp:AuthnRequest>

Le Code

private string GetSAMLHttpRedirectUri(string idpUri)
{
    var saml = string.Format(SAMLRequest, Guid.NewGuid());
    var bytes = Encoding.UTF8.GetBytes(saml);
    using (var output = new MemoryStream())
    {
        using (var zip = new DeflaterOutputStream(output))
        {
            zip.Write(bytes, 0, bytes.Length);
        }
        var base64 = Convert.ToBase64String(output.ToArray());
        var urlEncode = HttpUtility.UrlEncode(base64);
        return string.Concat(idpUri, "?SAMLRequest=", urlEncode);
    }
}

Je soupçonne que la compression est en quelque sorte à blâmer. Je suis l'aide de la DeflaterOutputStream classe de SharpZipLib qui est censé mettre en œuvre une norme de l'industrie dégonfler-algorithme alors peut-être il y a certains paramètres ici, j'ai tort?

De l'encodage du fichier de sortie peut être testé à l'aide de cette Grâce à saml2!.0 Débogueur (utile en ligne de l'outil de conversion). Quand je décode ma sortie à l'aide de cet outil, il vient en tant que non-sens.

La question est donc: savez-vous comment convertir un SAML chaîne dans le correctement dégonflé et codé SAMLRequest requête param?

Merci

EDIT 1

La accepté de répondre ci-dessous donne la réponse au problème. Ici est la version finale du code tel que modifié par tous les commentaires et réponses.

Encoder SAMLRequest - Code De Travail

private string GenerateSAMLRequestParam()
{
    var saml = string.Format(SAMLRequest, Guid.NewGuid());
    var bytes = Encoding.UTF8.GetBytes(saml);
    using (var output = new MemoryStream())
    {
        using (var zip = new DeflateStream(output, CompressionMode.Compress))
        {
            zip.Write(bytes, 0, bytes.Length);
        }
        var base64 = Convert.ToBase64String(output.ToArray());
        return HttpUtility.UrlEncode(base64);
    }
}

La SAMLRequest variable contient le SAML indiqué en haut de cette question.

Décoder SAMLResponse - Code De Travail

private string DecodeSAMLResponse(string response)
{
    var utf8 = Encoding.UTF8;
    var bytes = utf8.GetBytes(response);
    using (var output = new MemoryStream())
    {
        using (new DeflateStream(output, CompressionMode.Decompress))
        {
            output.Write(bytes, 0, bytes.Length);
        }
        var base64 = utf8.GetString(output.ToArray());
        return utf8.GetString(Convert.FromBase64String(base64));
    }
}

source d'informationauteur biofractal

c#saml-2.0 sharpziplib

Je viens de lancer le code suivant avec votre exemple SAML:

        var saml = string.Format(sample, Guid.NewGuid());
        var bytes = Encoding.UTF8.GetBytes(saml);

        string middle;
        using (var output = new MemoryStream())
        {
            using (var zip = new DeflaterOutputStream(output))
                zip.Write(bytes, 0, bytes.Length);

            middle = Convert.ToBase64String(output.ToArray());
        }

        string decoded;
        using (var input = new MemoryStream(Convert.FromBase64String(middle)))
        using (var unzip = new InflaterInputStream(input))
        using (var reader = new StreamReader(unzip, Encoding.UTF8))
            decoded = reader.ReadToEnd();

        bool test = decoded == saml;

La variable test est true. Cela signifie que le zip/base64/unbase64/décompressez aller-retour s'exécute correctement. L'erreur doit se produire plus tard. Peut-être que le URLEncoder les détruit? Pourriez-vous essayer similaire urlencode/décodage de test? Aussi, vérifier combien de temps le résultat est. Il peut être possible que l'URL est tronquée en raison de sa longueur.

(edit: j'ai ajouté un StreamReader au lieu de la lecture de tableaux. Plus tôt mon échantillon utilisé octets.Longueur de préparer le tampon et qui pourrait endommager le test. Maintenant, la lecture n'utilise que les informations du flux compressé)

edit:

        var saml = string.Format(sample, Guid.NewGuid());
        var bytes = Encoding.UTF8.GetBytes(saml);

        string middle;
        using (var output = new MemoryStream())
        {
            using (var zip = new DeflateStream(output, CompressionMode.Compress))
                zip.Write(bytes, 0, bytes.Length);

            middle = Convert.ToBase64String(output.ToArray());
        }

        //MIDDLE is the thing that should be now UrlEncode'd

        string decoded;
        using (var input = new MemoryStream(Convert.FromBase64String(middle)))
        using (var unzip = new DeflateStream(input, CompressionMode.Decompress))
        using (var reader = new StreamReader(unzip, Encoding.UTF8))
            decoded = reader.ReadToEnd();

        bool test = decoded == saml;

ce code génère un middle variable, qui une fois n'est UrlEncoded, passe à travers le débogueur correctement. DeflateStream provient de la norme .Net System.IO.Compression espace de noms. Je n'ai pas la moindre idée de pourquoi le SharpZip de Dégonfler n'est pas acceptée par le "debugger" du site. Il est indéniable que la compression des œuvres, qu'il parvient à décompresser les données correctement.. il a juste à être une différence dans les algorithmes, mais je ne peux pas dire quelle est la différence entre cette dégonfler et qui se dégonfler, oh pinaise.

La question dans la partie supérieure contient un "Décoder SAMLResponse - Code de Travail", mais que le code semble brisé. Après avoir essayé quelques choses, j'ai découvert que c'était d'essayer de lire et d'écrire sur le même flux en même temps. J'ai retravaillé par la séparation de la lire et d'écrire des ruisseaux et voici ma solution (je suis en fournissant la demande de la section pour plus de commodité et de clarté):

Encoder Authentification SAML Demande:

public static string EncodeSamlAuthnRequest(this string authnRequest) {
    var bytes = Encoding.UTF8.GetBytes(authnRequest);
    using (var output = new MemoryStream()) {
      using (var zip = new DeflateStream(output, CompressionMode.Compress)) {
        zip.Write(bytes, 0, bytes.Length);
      }
      var base64 = Convert.ToBase64String(output.ToArray());
      return HttpUtility.UrlEncode(base64);
    }
  }

Décoder l'Authentification SAML Réponse:

public static string DecodeSamlAuthnRequest(this string encodedAuthnRequest) {
  var utf8 = Encoding.UTF8;
  var bytes = Convert.FromBase64String(HttpUtility.UrlDecode(encodedAuthnRequest));
  using (var output = new MemoryStream()) {
    using (var input = new MemoryStream(bytes)) {
      using (var unzip = new DeflateStream(input, CompressionMode.Decompress)) {
        unzip.CopyTo(output, bytes.Length);
        unzip.Close();
      }
      return utf8.GetString(output.ToArray());
    }
  }
}

Vous devez vous connecter pour publier un commentaire.