public void ReadEncryptedApplicationData_TLS_AES_128_GCM_SHA256_ResultIsExpected()
        {
            //Arrange
            var messageData                   = GetEncryptedApplicationData();
            var cerificateData                = GetCertificateData();
            var signatureData                 = GetSignatureData();
            var verifyData                    = GetVerifyData();
            var encryptionData                = GetEncryptionData();
            var parsedCertificateEntries      = new List <CertificateEntry>();
            var parsedSignatureData           = new Memory <byte>();
            var parsedCertificateVerifyScheme = new SignatureScheme();
            var parsedVerifyData              = new Memory <byte>();

            using var aead = Cipher.TLS_AES_128_GCM_SHA256.CreateAead(Utils.ParseHexString(encryptionData.Iv), Utils.ParseHexString(encryptionData.Key));

            //Act
            var cursor = new MemoryCursor(Utils.ParseHexString(messageData));
            var result = TlsRecord.TryParseEncrypted(cursor, aead, encryptionData.SeqNum, out var record);

            using (record.Payload.SetCursor(cursor))
            {
                result &= EncryptedExtensions.TrySlice(cursor);

                result &= Certificate.TryParse(cursor, out var certificate);
                foreach (var entry in certificate.Payload.GetCertificateEntryReader(cursor))
                {
                    parsedCertificateEntries.Add(entry);
                }

                result &= CertificateVerify.TryParse(cursor, out var certificateVerify);
                parsedSignatureData           = certificateVerify.Signature.Read(cursor);
                parsedCertificateVerifyScheme = certificateVerify.Scheme;

                result          &= Finished.TryParse(cursor, out var parsedVerifyDataBuffer);
                parsedVerifyData = parsedVerifyDataBuffer.Read(cursor);

                result &= cursor.IsEnd();
            }

            result &= cursor.IsEnd();

            //Assert
            Assert.True(result);
            Assert.Equal(RecordType.Handshake, record.Type);
            Assert.Equal(ProtocolVersion.Tls12, record.ProtocolVersion);
            var certificateEntry = Assert.Single(parsedCertificateEntries);

            Assert.Equal(cerificateData, Utils.ToHexString(certificateEntry.Data.Read(cursor).ToArray()), true);
            Assert.Equal(signatureData, Utils.ToHexString(parsedSignatureData.ToArray()), true);
            Assert.Equal(SignatureScheme.RSA_PSS_RSAE_SHA256, parsedCertificateVerifyScheme);
            Assert.Equal(verifyData, Utils.ToHexString(parsedVerifyData.ToArray()), true);
        }
        public void WriteEncryptedApplicationData_TLS_AES_128_GCM_SHA256_ResultIsExpected()
        {
            //Arrange
            var expectedData   = GetEncryptedApplicationData();
            var cerificateData = GetCertificateData();
            var signatureData  = GetSignatureData();
            var verifyData     = GetVerifyData();
            var encryptionData = GetEncryptionData();
            var buffer         = new byte[TlsBuffer.MaxRecordSize];

            using var aead = Cipher.TLS_AES_128_GCM_SHA256.CreateAead(Utils.ParseHexString(encryptionData.Iv), Utils.ParseHexString(encryptionData.Key));

            //Act
            var cursor = new MemoryCursor(buffer);

            using (TlsRecord.StartEncryptedWriting(cursor, RecordType.Handshake, aead, encryptionData.SeqNum))
            {
                EncryptedExtensions.WriteEmpty(cursor);

                using (Certificate.StartWriting(cursor))
                {
                    CertificateEntry.Write(Utils.ParseHexString(cerificateData), cursor);
                }

                using (CertificateVerify.StartWriting(cursor, SignatureScheme.RSA_PSS_RSAE_SHA256))
                {
                    Utils.ParseHexString(signatureData).CopyTo(cursor);
                }

                using (Finished.StartWriting(cursor))
                {
                    Utils.ParseHexString(verifyData).CopyTo(cursor);
                }
            }

            //Assert
            Assert.Equal(expectedData, Utils.ToHexString(cursor.PeekStart().ToArray()), true);
        }