Exemplo n.º 1
0
        /// <summary>
        /// Computes the client response containing the client's public key and
        /// evidence.
        /// </summary>
        /// <param name="challenge">The challenge containing the protocol elements
        /// received from the server in response to the initial client
        /// response.</param>
        /// <returns>An array of bytes containing the client's challenge
        /// response.</returns>
        /// <exception cref="SaslException">Thrown if the server specified any
        /// mandatory options which are not supported.</exception>
        private byte[] ComputeFinalResponse(byte[] challenge)
        {
            ServerMessage1 m = ServerMessage1.Deserialize(challenge);

            // We don't support integrity protection or confidentiality.
            if (!String.IsNullOrEmpty(m.Options["mandatory"]))
            {
                throw new SaslException("Mandatory options are not supported.");
            }
            // Set up the message digest algorithm.
            var mda = SelectHashAlgorithm(m.Options["mda"]);

            HashAlgorithm = Activator.CreateInstance(mda.Item2) as HashAlgorithm;

            // Compute public and private key.
            PublicKey = Helper.ComputeClientPublicKey(m.Generator,
                                                      m.SafePrimeModulus, PrivateKey);
            // Compute the shared key and client evidence.
            SharedKey = Helper.ComputeSharedKey(m.Salt, Username, Password,
                                                PublicKey, m.PublicKey, PrivateKey, m.Generator, m.SafePrimeModulus,
                                                HashAlgorithm);
            ClientProof = Helper.ComputeClientProof(m.SafePrimeModulus,
                                                    m.Generator, Username, m.Salt, PublicKey, m.PublicKey, SharedKey,
                                                    AuthId, m.RawOptions, HashAlgorithm);

            ClientMessage2 response = new ClientMessage2(PublicKey, ClientProof);

            // Let the server know which hash algorithm we are using.
            response.Options["mda"] = mda.Item1;
            // Remember the raw options string because we'll need it again
            // when verifying the server signature.
            Options = response.BuildOptionsString();

            return(response.Serialize());
        }
Exemplo n.º 2
0
        public void DeserializeServerFirstMessage()
        {
            ServerMessage1 m = ServerMessage1.Deserialize(serverMessage1);
            BigInteger     expectedGenerator = new BigInteger(2),
                           expectedModulus   = BigInteger.Parse(expectedSafePrimeModulus,
                                                                    NumberStyles.HexNumber),
                           _expectedPublicKey = BigInteger.Parse(expectedPublicKey,
                                                                 NumberStyles.HexNumber);

            Assert.AreEqual <BigInteger>(expectedGenerator, m.Generator.Value);
            Assert.AreEqual <BigInteger>(expectedModulus, m.SafePrimeModulus.Value);
            Assert.AreEqual <BigInteger>(_expectedPublicKey, m.PublicKey.Value);
            Assert.IsTrue(m.Salt.SequenceEqual(expectedSalt));
            Assert.AreEqual <string>(expectedOptions, m.RawOptions);

            Assert.AreEqual <int>(expectedParsedOptions.Count, m.Options.Count);
            foreach (KeyValuePair <string, string> pair in expectedParsedOptions)
            {
                Assert.AreEqual <string>(pair.Value, m.Options[pair.Key]);
            }
        }