C# TlsContext类代码示例

        /// <exception cref="IOException"></exception>
        public Chacha20Poly1305(TlsContext context)
        {
            if (!TlsUtilities.IsTlsV12(context))
                throw new TlsFatalAlert(AlertDescription.internal_error);

            this.context = context;

            byte[] key_block = TlsUtilities.CalculateKeyBlock(context, 64);

            KeyParameter client_write_key = new KeyParameter(key_block, 0, 32);
            KeyParameter server_write_key = new KeyParameter(key_block, 32, 32);

            this.encryptCipher = new ChaChaEngine(20);
            this.decryptCipher = new ChaChaEngine(20);

            KeyParameter encryptKey, decryptKey;
            if (context.IsServer)
            {
                encryptKey = server_write_key;
                decryptKey = client_write_key;
            }
            else
            {
                encryptKey = client_write_key;
                decryptKey = server_write_key;
            }

            byte[] dummyNonce = new byte[8];

            this.encryptCipher.Init(true, new ParametersWithIV(encryptKey, dummyNonce));
            this.decryptCipher.Init(false, new ParametersWithIV(decryptKey, dummyNonce));
        }

		public TlsServerHello (TlsContext context, TlsBuffer incoming)
			: base (HandshakeType.ServerHello)
		{
			ServerProtocol = (TlsProtocolCode)incoming.ReadInt16 ();

			Read (incoming);
		}

		public static HandshakeMessage ReadMessage (TlsContext context, HandshakeType handshakeType, TlsBuffer incoming)
		{
			HandshakeMessage message;
			switch (handshakeType) {
			case HandshakeType.HelloRequest:
				message = new TlsHelloRequest ();
				break;
			case HandshakeType.ServerHello:
				return new TlsServerHello (context, incoming);
			case HandshakeType.Certificate:
				return new TlsCertificate (incoming);
			case HandshakeType.ServerHelloDone:
				message = new TlsServerHelloDone ();
				break;
			case HandshakeType.Finished:
				return new TlsFinished (incoming);
			case HandshakeType.ClientHello:
				return new TlsClientHello (context, incoming);
			case HandshakeType.ClientKeyExchange:
				return new TlsClientKeyExchange (context, incoming);
			case HandshakeType.CertificateRequest:
				return new TlsCertificateRequest (context.NegotiatedProtocol, incoming);
			case HandshakeType.CertificateVerify:
				return new TlsCertificateVerify (context.NegotiatedProtocol, incoming);
			case HandshakeType.ServerKeyExchange:
				return new TlsServerKeyExchange (context, incoming);
			default:
				throw new TlsException (AlertDescription.UnexpectedMessage, "Unknown server handshake message received: {0}", handshakeType);
			}

			message.Read (incoming);
			return message;
		}

		public TlsClientHello (TlsContext context, TlsBuffer incoming)
			: base (HandshakeType.ClientHello)
		{
			ClientProtocol = (TlsProtocolCode)incoming.ReadInt16 ();

			Read (incoming);
		}

		public DiffieHellmanKeyExchange (TlsContext ctx)
		{
			this.protocol = ctx.NegotiatedProtocol;

			switch (protocol) {
			case TlsProtocolCode.Tls12:
				Signature = new SignatureTls12 (ctx.Session.ServerSignatureAlgorithm);
				break;
			case TlsProtocolCode.Tls10:
				Signature = new SignatureTls10 ();
				break;
			case TlsProtocolCode.Tls11:
				Signature = new SignatureTls11 ();
				break;
			default:
				throw new NotSupportedException ();
			}

			dh = new DiffieHellmanManaged ();
			Y = dh.CreateKeyExchange ();
			var dhparams = dh.ExportParameters (true);
			P = dhparams.P;
			G = dhparams.G;

			using (var buffer = CreateParameterBuffer (ctx.HandshakeParameters))
				Signature.Create (buffer, ctx.Configuration.PrivateKey);
		}

		public override void GenerateClient (TlsContext ctx)
		{
			// Compute pre master secret
			using (var preMasterSecret = ctx.Session.GetSecureRandomBytes (48)) {
				preMasterSecret.Buffer [0] = (byte)((short)ctx.Configuration.RequestedProtocol >> 8);
				preMasterSecret.Buffer [1] = (byte)ctx.Configuration.RequestedProtocol;

				RSA rsa = null;
				// Create a new RSA key
				var serverCertificates = ctx.Session.PendingCrypto.ServerCertificates;
				if (serverCertificates == null || serverCertificates.Count == 0) {
					// FIXME: Should have received ServerKeyExchange message.
					throw new TlsException (AlertDescription.IlegalParameter);
				} else {
					rsa = new RSAManaged (serverCertificates [0].RSA.KeySize);
					rsa.ImportParameters (serverCertificates [0].RSA.ExportParameters (false));
				}

				ComputeMasterSecret (ctx, preMasterSecret);

				// Encrypt premaster_sercret
				var formatter = new RSAPKCS1KeyExchangeFormatter (rsa);
				encryptedPreMasterSecret = formatter.CreateKeyExchange (preMasterSecret.Buffer);
				rsa.Clear ();
			}
		}

        internal static TlsEncryptionCredentials LoadEncryptionCredentials(TlsContext context,
            string[] certResources, string keyResource)
        {
            Certificate certificate = LoadCertificateChain(certResources);
            AsymmetricKeyParameter privateKey = LoadPrivateKeyResource(keyResource);

            return new DefaultTlsEncryptionCredentials(context, certificate, privateKey);
        }

		internal static RenegotiationExtension CreateClient (TlsContext context)
		{
			if (!context.Session.SecureRenegotiation && (context.Configuration.RenegotiationFlags & RenegotiationFlags.SendClientHelloExtension) == 0)
				return null;

			context.HandshakeParameters.RequestedSecureNegotiation = true;
			return new RenegotiationExtension (context.Session.ClientVerifyData);
		}

        internal static TlsSignerCredentials LoadSignerCredentials(TlsContext context, string[] certResources,
            string keyResource, SignatureAndHashAlgorithm signatureAndHashAlgorithm)
        {
            Certificate certificate = LoadCertificateChain(certResources);
            AsymmetricKeyParameter privateKey = LoadPrivateKeyResource(keyResource);

            return new DefaultTlsSignerCredentials(context, certificate, privateKey, signatureAndHashAlgorithm);
        }

        /// <exception cref="IOException"></exception>
        public TlsAeadCipher(TlsContext context, IAeadBlockCipher clientWriteCipher, IAeadBlockCipher serverWriteCipher,
            int cipherKeySize, int macSize)
        {
            if (!TlsUtilities.IsTlsV12(context))
                throw new TlsFatalAlert(AlertDescription.internal_error);

            this.context = context;
            this.macSize = macSize;

            // NOTE: Valid for RFC 5288/6655 ciphers but may need review for other AEAD ciphers
            this.nonce_explicit_length = 8;

            // TODO SecurityParameters.fixed_iv_length
            int fixed_iv_length = 4;

            int key_block_size = (2 * cipherKeySize) + (2 * fixed_iv_length);

            byte[] key_block = TlsUtilities.CalculateKeyBlock(context, key_block_size);

            int offset = 0;

            KeyParameter client_write_key = new KeyParameter(key_block, offset, cipherKeySize);
            offset += cipherKeySize;
            KeyParameter server_write_key = new KeyParameter(key_block, offset, cipherKeySize);
            offset += cipherKeySize;
            byte[] client_write_IV = Arrays.CopyOfRange(key_block, offset, offset + fixed_iv_length);
            offset += fixed_iv_length;
            byte[] server_write_IV = Arrays.CopyOfRange(key_block, offset, offset + fixed_iv_length);
            offset += fixed_iv_length;

            if (offset != key_block_size)
                throw new TlsFatalAlert(AlertDescription.internal_error);

            KeyParameter encryptKey, decryptKey;
            if (context.IsServer)
            {
                this.encryptCipher = serverWriteCipher;
                this.decryptCipher = clientWriteCipher;
                this.encryptImplicitNonce = server_write_IV;
                this.decryptImplicitNonce = client_write_IV;
                encryptKey = server_write_key;
                decryptKey = client_write_key;
            }
            else
            {
                this.encryptCipher = clientWriteCipher;
                this.decryptCipher = serverWriteCipher;
                this.encryptImplicitNonce = client_write_IV;
                this.decryptImplicitNonce = server_write_IV;
                encryptKey = client_write_key;
                decryptKey = server_write_key;
            }

            byte[] dummyNonce = new byte[fixed_iv_length + nonce_explicit_length];

            this.encryptCipher.Init(true, new AeadParameters(encryptKey, 8 * macSize, dummyNonce));
            this.decryptCipher.Init(false, new AeadParameters(decryptKey, 8 * macSize, dummyNonce));
        }

        internal virtual void Init(TlsContext context)
        {
            this.mReadCipher = new TlsNullCipher(context);
            this.mWriteCipher = this.mReadCipher;
            this.mHandshakeHash = new DeferredHash();
            this.mHandshakeHash.Init(context);

            SetPlaintextLimit(DEFAULT_PLAINTEXT_LIMIT);
        }

        public override void Init(TlsContext context)
        {
            base.Init(context);

            if (this.mTlsSigner != null)
            {
                this.mTlsSigner.Init(context);
            }
        }

 /// <exception cref="IOException"></exception>
 public override TlsCipher CreateCipher(TlsContext context, int encryptionAlgorithm, int macAlgorithm)
 {
     switch (encryptionAlgorithm)
     {
     case EncryptionAlgorithm.cls_3DES_EDE_CBC:
         return CreateDesEdeCipher(context, macAlgorithm);
     case EncryptionAlgorithm.AES_128_CBC:
         return CreateAESCipher(context, 16, macAlgorithm);
     case EncryptionAlgorithm.AES_128_CCM:
         // NOTE: Ignores macAlgorithm
         return CreateCipher_Aes_Ccm(context, 16, 16);
     case EncryptionAlgorithm.AES_128_CCM_8:
         // NOTE: Ignores macAlgorithm
         return CreateCipher_Aes_Ccm(context, 16, 8);
     case EncryptionAlgorithm.AES_128_GCM:
         // NOTE: Ignores macAlgorithm
         return CreateCipher_Aes_Gcm(context, 16, 16);
     case EncryptionAlgorithm.AES_128_OCB_TAGLEN96:
         // NOTE: Ignores macAlgorithm
         return CreateCipher_Aes_Ocb(context, 16, 12);
     case EncryptionAlgorithm.AES_256_CBC:
         return CreateAESCipher(context, 32, macAlgorithm);
     case EncryptionAlgorithm.AES_256_CCM:
         // NOTE: Ignores macAlgorithm
         return CreateCipher_Aes_Ccm(context, 32, 16);
     case EncryptionAlgorithm.AES_256_CCM_8:
         // NOTE: Ignores macAlgorithm
         return CreateCipher_Aes_Ccm(context, 32, 8);
     case EncryptionAlgorithm.AES_256_GCM:
         // NOTE: Ignores macAlgorithm
         return CreateCipher_Aes_Gcm(context, 32, 16);
     case EncryptionAlgorithm.AES_256_OCB_TAGLEN96:
         // NOTE: Ignores macAlgorithm
         return CreateCipher_Aes_Ocb(context, 32, 12);
     case EncryptionAlgorithm.CAMELLIA_128_CBC:
         return CreateCamelliaCipher(context, 16, macAlgorithm);
     case EncryptionAlgorithm.CAMELLIA_128_GCM:
         // NOTE: Ignores macAlgorithm
         return CreateCipher_Camellia_Gcm(context, 16, 16);
     case EncryptionAlgorithm.CAMELLIA_256_CBC:
         return CreateCamelliaCipher(context, 32, macAlgorithm);
     case EncryptionAlgorithm.CAMELLIA_256_GCM:
         // NOTE: Ignores macAlgorithm
         return CreateCipher_Camellia_Gcm(context, 32, 16);
     case EncryptionAlgorithm.CHACHA20_POLY1305:
         // NOTE: Ignores macAlgorithm
         return CreateChaCha20Poly1305(context);
     case EncryptionAlgorithm.NULL:
         return CreateNullCipher(context, macAlgorithm);
     case EncryptionAlgorithm.RC4_128:
         return CreateRC4Cipher(context, 16, macAlgorithm);
     case EncryptionAlgorithm.SEED_CBC:
         return CreateSeedCipher(context, macAlgorithm);
     default:
         throw new TlsFatalAlert(AlertDescription.internal_error);
     }
 }

		public override void GenerateClient (TlsContext ctx)
		{
			using (var dh = new DiffieHellmanManaged (P, G, 0)) {
				using (var X = new SecureBuffer (dh.DecryptKeyExchange (Y))) {
					Y = dh.CreateKeyExchange ();
					ComputeMasterSecret (ctx, X);
				}
			}
		}

		public override void GenerateClient (TlsContext context)
		{
			GenerateKeyPair (context, domainParameters, out clientQ, out clientD);
			clientKey = ExternalizeKey (clientQ);

			var agreement = CalculateAgreement (serverQ, clientD);
			using (var preMaster = new SecureBuffer (agreement.ToByteArrayUnsigned ()))
				ComputeMasterSecret (context, preMaster);
		}