diff --git a/src/Renci.SshNet/ConnectionInfo.cs b/src/Renci.SshNet/ConnectionInfo.cs
index af8e1ca5c..4d6346bbf 100644
--- a/src/Renci.SshNet/ConnectionInfo.cs
+++ b/src/Renci.SshNet/ConnectionInfo.cs
@@ -7,6 +7,10 @@
 using Renci.SshNet.Messages.Connection;
 using Renci.SshNet.Common;
 using Renci.SshNet.Messages.Authentication;
+#if NETCOREAPP3_0 || NETSTANDARD2_1
+using Renci.SshNet.Security.Cryptography;
+using Renci.SshNet.Security.Cryptography.Ciphers.Paddings;
+#endif
 using Renci.SshNet.Security.Cryptography.Ciphers.Modes;
 using Renci.SshNet.Security.Cryptography.Ciphers;
 
@@ -361,6 +365,9 @@ public ConnectionInfo(string host, int port, string username, ProxyTypes proxyTy
                     ////{"rijndael-cbc@lysator.liu.se", typeof(...)},                
                     {"aes128-ctr", new CipherInfo(128, (key, iv) => new AesCipher(key, new CtrCipherMode(iv), null))},
                     {"aes192-ctr", new CipherInfo(192, (key, iv) => new AesCipher(key, new CtrCipherMode(iv), null))},
+#if NETCOREAPP3_0 || NETSTANDARD2_1
+                    {"aes128-gcm@openssh.com", new CipherInfo(128, (key, iv) => new AEADCipher(key, iv, 16, null, new AEADPadding()))},
+#endif
                 };
 
             HmacAlgorithms = new Dictionary<string, HashInfo>
diff --git a/src/Renci.SshNet/Properties/CommonAssemblyInfo.cs b/src/Renci.SshNet/Properties/CommonAssemblyInfo.cs
index 0425d1fba..0883060cc 100644
--- a/src/Renci.SshNet/Properties/CommonAssemblyInfo.cs
+++ b/src/Renci.SshNet/Properties/CommonAssemblyInfo.cs
@@ -5,13 +5,13 @@
 [assembly: AssemblyDescription("SSH.NET is a Secure Shell (SSH) library for .NET, optimized for parallelism.")]
 [assembly: AssemblyCompany("Renci")]
 [assembly: AssemblyProduct("SSH.NET")]
-[assembly: AssemblyCopyright("Copyright � Renci 2010-2017")]
+[assembly: AssemblyCopyright("Copyright � Renci 2010-2021")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 
-[assembly: AssemblyVersion("2017.0.0")]
-[assembly: AssemblyFileVersion("2017.0.0")]
-[assembly: AssemblyInformationalVersion("2017.0.0-beta1")]
+[assembly: AssemblyVersion("2020.0.1")]
+[assembly: AssemblyFileVersion("2020.0.1")]
+[assembly: AssemblyInformationalVersion("2020.0.1")]
 [assembly: CLSCompliant(false)]
 
 // Setting ComVisible to false makes the types in this assembly not visible 
diff --git a/src/Renci.SshNet/Renci.SshNet.csproj b/src/Renci.SshNet/Renci.SshNet.csproj
index 124ce9d4b..979e31032 100644
--- a/src/Renci.SshNet/Renci.SshNet.csproj
+++ b/src/Renci.SshNet/Renci.SshNet.csproj
@@ -7,7 +7,9 @@
     <AssemblyOriginatorKeyFile>../Renci.SshNet.snk</AssemblyOriginatorKeyFile>
     <LangVersion>5</LangVersion>
     <SignAssembly>true</SignAssembly>
-    <TargetFrameworks>net35;net40;netstandard1.3;netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>net35;net40;netstandard1.3;netstandard2.0;netstandard2.1</TargetFrameworks>
+    <OutputType>Library</OutputType>
+    <AutoGenerateBindingRedirects>false</AutoGenerateBindingRedirects>
   </PropertyGroup>
 
   <!--
@@ -28,7 +30,7 @@
     <PackageReference Include="System.Xml.XPath.XmlDocument" Version="4.3.0" />
   </ItemGroup>
 
-  <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' or '$(TargetFramework)' == 'netstandard2.1' ">
+  <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.1' or '$(TargetFramework)' == 'netstandard2.0' ">
     <PackageReference Include="SshNet.Security.Cryptography" Version="[1.3.0]" />
   </ItemGroup>
 
@@ -41,7 +43,10 @@
   <PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard1.3' ">
     <DefineConstants>FEATURE_STRINGBUILDER_CLEAR;FEATURE_HASHALGORITHM_DISPOSE;FEATURE_ENCODING_ASCII;FEATURE_DIAGNOSTICS_TRACESOURCE;FEATURE_DIRECTORYINFO_ENUMERATEFILES;FEATURE_MEMORYSTREAM_TRYGETBUFFER;FEATURE_REFLECTION_TYPEINFO;FEATURE_RNG_CREATE;FEATURE_SOCKET_TAP;FEATURE_SOCKET_EAP;FEATURE_SOCKET_SYNC;FEATURE_SOCKET_SELECT;FEATURE_SOCKET_POLL;FEATURE_SOCKET_DISPOSE;FEATURE_DNS_TAP;FEATURE_STREAM_TAP;FEATURE_THREAD_COUNTDOWNEVENT;FEATURE_THREAD_TAP;FEATURE_THREAD_THREADPOOL;FEATURE_THREAD_SLEEP;FEATURE_WAITHANDLE_DISPOSE;FEATURE_HASH_MD5;FEATURE_HASH_SHA1_CREATE;FEATURE_HASH_SHA256_CREATE;FEATURE_HASH_SHA384_CREATE;FEATURE_HASH_SHA512_CREATE;FEATURE_HMAC_MD5;FEATURE_HMAC_SHA1;FEATURE_HMAC_SHA256;FEATURE_HMAC_SHA384;FEATURE_HMAC_SHA512</DefineConstants>
   </PropertyGroup>
-  <PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' or '$(TargetFramework)' == 'netstandard2.1' ">
+  <PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' ">
     <DefineConstants>FEATURE_STRINGBUILDER_CLEAR;FEATURE_HASHALGORITHM_DISPOSE;FEATURE_ENCODING_ASCII;FEATURE_DIAGNOSTICS_TRACESOURCE;FEATURE_DIRECTORYINFO_ENUMERATEFILES;FEATURE_MEMORYSTREAM_GETBUFFER;FEATURE_MEMORYSTREAM_TRYGETBUFFER;FEATURE_RNG_CREATE;FEATURE_SOCKET_TAP;FEATURE_SOCKET_APM;FEATURE_SOCKET_EAP;FEATURE_SOCKET_SYNC;FEATURE_SOCKET_SELECT;FEATURE_SOCKET_POLL;FEATURE_SOCKET_DISPOSE;FEATURE_DNS_SYNC;FEATURE_DNS_APM;FEATURE_DNS_TAP;FEATURE_STREAM_APM;FEATURE_STREAM_TAP;FEATURE_THREAD_COUNTDOWNEVENT;FEATURE_THREAD_TAP;FEATURE_THREAD_THREADPOOL;FEATURE_THREAD_SLEEP;FEATURE_WAITHANDLE_DISPOSE;FEATURE_HASH_MD5;FEATURE_HASH_SHA1_CREATE;FEATURE_HASH_SHA256_CREATE;FEATURE_HASH_SHA384_CREATE;FEATURE_HASH_SHA512_CREATE;FEATURE_HMAC_MD5;FEATURE_HMAC_SHA1;FEATURE_HMAC_SHA256;FEATURE_HMAC_SHA384;FEATURE_HMAC_SHA512;FEATURE_ECDSA</DefineConstants>
   </PropertyGroup>
+  <PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard2.1' ">
+    <DefineConstants>DEBUG_AESGCM;FEATURE_STRINGBUILDER_CLEAR;FEATURE_HASHALGORITHM_DISPOSE;FEATURE_ENCODING_ASCII;FEATURE_DIAGNOSTICS_TRACESOURCE;FEATURE_DIRECTORYINFO_ENUMERATEFILES;FEATURE_MEMORYSTREAM_GETBUFFER;FEATURE_MEMORYSTREAM_TRYGETBUFFER;FEATURE_RNG_CREATE;FEATURE_SOCKET_TAP;FEATURE_SOCKET_APM;FEATURE_SOCKET_EAP;FEATURE_SOCKET_SYNC;FEATURE_SOCKET_SELECT;FEATURE_SOCKET_POLL;FEATURE_SOCKET_DISPOSE;FEATURE_DNS_SYNC;FEATURE_DNS_APM;FEATURE_DNS_TAP;FEATURE_STREAM_APM;FEATURE_STREAM_TAP;FEATURE_THREAD_COUNTDOWNEVENT;FEATURE_THREAD_TAP;FEATURE_THREAD_THREADPOOL;FEATURE_THREAD_SLEEP;FEATURE_WAITHANDLE_DISPOSE;FEATURE_HASH_MD5;FEATURE_HASH_SHA1_CREATE;FEATURE_HASH_SHA256_CREATE;FEATURE_HASH_SHA384_CREATE;FEATURE_HASH_SHA512_CREATE;FEATURE_HMAC_MD5;FEATURE_HMAC_SHA1;FEATURE_HMAC_SHA256;FEATURE_HMAC_SHA384;FEATURE_HMAC_SHA512;FEATURE_ECDSA</DefineConstants>
+  </PropertyGroup>
 </Project>
diff --git a/src/Renci.SshNet/Security/Cryptography/Cipher.cs b/src/Renci.SshNet/Security/Cryptography/Cipher.cs
index e624bbba3..1b53f8fc3 100644
--- a/src/Renci.SshNet/Security/Cryptography/Cipher.cs
+++ b/src/Renci.SshNet/Security/Cryptography/Cipher.cs
@@ -1,4 +1,6 @@
-namespace Renci.SshNet.Security.Cryptography
+using System.Security.Cryptography;
+
+namespace Renci.SshNet.Security.Cryptography
 {
     /// <summary>
     /// Base class for cipher implementation.
@@ -13,6 +15,41 @@ public abstract class Cipher
         /// </value>
         public abstract byte MinimumSize { get; }
 
+        /// <summary>
+        /// AEAD Mode or not
+        /// </summary>
+        /// <value>
+        /// AEAD Mode is set to false by default.
+        /// </value>
+        public virtual bool isAEAD
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Server mac length based on the chosen hash algorithm
+        /// </summary>
+        /// <param name="_serverMac">The mac algorithm to use.</param>
+        /// <returns>The server mac length.</returns>
+        public virtual int serverMacLength(HashAlgorithm _serverMac)
+        {
+            return (_serverMac != null ? _serverMac.HashSize/8 : 0);
+        }
+
+        /// <summary>
+        /// Find the right offset for decrypt based on chosen cipher suite
+        /// </summary>
+        /// <param name="blockSz">The default block size</param>
+        /// <param name="inboundPacketSequenceLength">The inbound packet sequence length.</param>
+        /// <returns>The default offset value used for the decrypt function, which is inboundPacketSequenceLength + blockSz</returns>
+        public virtual int decryptOffset(int inboundPacketSequenceLength, int blockSz)
+        {
+            return inboundPacketSequenceLength + blockSz;
+        }
+
         /// <summary>
         /// Encrypts the specified input.
         /// </summary>
diff --git a/src/Renci.SshNet/Security/Cryptography/Ciphers/AEADCipher.cs b/src/Renci.SshNet/Security/Cryptography/Ciphers/AEADCipher.cs
new file mode 100644
index 000000000..0c9f17847
--- /dev/null
+++ b/src/Renci.SshNet/Security/Cryptography/Ciphers/AEADCipher.cs
@@ -0,0 +1,423 @@
+#if NETCOREAPP3_0 || NETSTANDARD2_1
+using System;
+using System.Text;
+using System.Collections.Generic;
+using System.Security.Cryptography;
+using Renci.SshNet.Security.Cryptography.Ciphers;
+
+namespace Renci.SshNet.Security.Cryptography.Ciphers
+{
+    /// <summary>
+    /// AEAD cipher implementation.
+    /// </summary>
+    public sealed class AEADCipher : BlockCipher
+    {
+        private readonly CipherPadding _padding;
+
+        /// <summary>
+        /// Instance for AesGcm Class
+        /// </summary>
+        private AesGcm cipher;
+
+        /// <summary>
+        /// The size of the block in bytes.
+        /// AES128-GCM: 16 bytes
+        /// AES192-GCM: 24 bytes
+        /// AES256-GCM: 32 bytes
+        /// </summary>
+        private readonly byte _blockSize;
+
+        /// <summary>
+        /// The key stream for AES-GCM Encrypt and Decrypt.
+        /// </summary>
+        private readonly byte[] _key;
+
+        /// <summary>
+        /// The IV for AES-GCM Encrypt and Decrypt.
+        /// </summary>
+        private byte[] _iv;
+
+        /// <summary>
+        /// The IV length for AES-GCM.
+        /// Length sz is basd on [RFC5647] Section 7.1 .Auguest 2009
+        /// </summary>
+        private readonly int NONCE_BYTES = 12;
+
+        /// <summary>
+        /// Packet Length Field 4 bytes for AES GCM which is Additional Authenticated Data (AAD) in plain text.
+        /// Based on [RFC5647] Section 7.2 .Auguest 2009
+        /// </summary>
+        private readonly int PACKET_LENGTH_FIELD_SZ = 4;
+
+        /// <summary>
+        /// The size of the tag based on [RFC5647] Section 6.3 .Auguest 2009
+        /// Both AEAD_AES_128_GCM and AEAD_AES_256_GCM produce a 16-octet Authentication Tag
+        /// AEAD_AES_192_GCM can also use 16 bytes of the tag size based on NIST Special Publication 800-38D .page 8
+        /// </summary>
+        private readonly int TAG_SIZE = 16;
+
+        /// <summary>
+        /// Find the right offset for AEAD cipher decryption.
+        /// </summary>
+        /// <param name="blockSz">The block cipher size of AEAD Cipher.</param>
+        /// <param name="inboundPacketSequenceLength">The inbound packet sequence length.</param>
+        /// <returns>The decrypt offset used for the decrypt function of AEAD cipher is
+        /// inboundPacketSequenceLength + PACKET_LENGTH_FIELD_SZ</returns>
+        public override int decryptOffset(int inboundPacketSequenceLength, int blockSz)
+        {
+            return inboundPacketSequenceLength + PACKET_LENGTH_FIELD_SZ;
+        }
+
+        /// <summary>
+        /// AEAD Mode server mac length is the tag size based on [RFC5647] Section 6.3 .Auguest 2009
+        /// Both AEAD_AES_128_GCM and AEAD_AES_256_GCM produce a 16-octet Authentication Tag
+        /// AEAD_AES_192_GCM can also use 16 bytes of the tag size based on NIST Special Publication 800-38D .page 8
+        /// </summary>
+        /// <returns>The tag length for AEAD AES-GCM.</returns>
+        public override int serverMacLength(HashAlgorithm _serverMac)
+        {
+            return TAG_SIZE;
+        }
+
+        /// <summary>
+        /// AEAD Mode Flag
+        /// </summary>
+        /// <value>
+        /// AEAD Mode is set to true if it's AEAD AES-GCM Operation.
+        /// </value>
+        public override bool isAEAD
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AEADCipher"/> class.
+        /// </summary>
+        /// <param name="key">The key for encryption decryption during AES-GCM.</param>
+        /// <param name="iv">The iv as known as nonce during AES-GCM.</param>
+        /// <param name="blockSize">The size of the block cipher.</param>
+        /// <param name="mode">The mode is set to null for AEAD AES-GCM.</param>
+        /// <param name="padding">The padding class for AEAD AES-GCM.</param>
+        /// <exception cref="ArgumentNullException"><paramref name="key"/> is <c>null</c>.</exception>
+        /// <exception cref="ArgumentException">Keysize is not valid for this algorithm.</exception>
+        public AEADCipher(byte[] key, byte[] iv, byte blockSize, CipherMode mode, CipherPadding padding)
+            : base(key, blockSize, mode, padding)
+        {
+            _blockSize = blockSize;
+            _padding = padding;
+
+            // Get the IV length of bytes for AES-GCM (12 bytes) from initial IV.
+            // Length sz is basd on [RFC5647] Section 7.1 .Auguest 2009
+            _iv = new byte[NONCE_BYTES];
+            Array.Copy(iv, 0, _iv, 0, NONCE_BYTES);
+
+            _key = new byte[key.Length];
+            _key = key;
+
+            // Key Size Check for AES-GCM
+            // AES128-GCM: 16 bytes [RFC5116] Section 5.2 .January 2008
+            // AES192-GCM: 24 bytes [RFC5084] Section 1.3 .November 2007
+            // AES256-GCM: 32 bytes [RFC5116] Section 5.3 .January 2008
+            if (!(_key.Length == 16 || _key.Length == 24 || _key.Length == 32))
+                throw new ArgumentException(string.Format("KeySize '{0}' is not valid for this algorithm.", _key.Length));
+
+            cipher = new AesGcm(_key);
+
+            // If cipher is null throw exception
+            if (cipher == null)
+                throw new ArgumentException(string.Format("Invalid AES-GCM Class Cipher."));
+        }
+#if DEBUG_AESGCM
+
+        /// <summary>
+        /// GetHexStringFrom.
+        /// </summary>
+        /// <returns>String.</returns>
+        public static string GetHexStringFrom(byte[] byteArray)
+        {
+            return  BitConverter.ToString(byteArray); //To convert the whole array
+        }
+
+#endif
+
+        /// <summary>
+        /// AEAD AES-GCM Encrypt Function
+        /// </summary>
+        /// <param name="inputBuffer">The input data which contains packet length field (Additional Authenticated Data)
+        /// and the plain text.
+        /// </param>
+        /// <returns>
+        /// The number of bytes encrypted.
+        /// </returns>
+        // Structure of the inputBuffer:
+        // |------4 bytes------||-------------------Plain Text--------------------|
+        // [packet length field][padding length field sz][payload][random paddings]
+        private byte[] GcmEncrypt(byte[] inputBuffer)
+        {
+            if (inputBuffer.Length - PACKET_LENGTH_FIELD_SZ < _blockSize)
+                throw new ArgumentException("Invalid input buffer");
+
+            var tag = new byte[TAG_SIZE];
+            var cipherText = new byte[inputBuffer.Length - PACKET_LENGTH_FIELD_SZ];
+
+            var associatedData = new ReadOnlySpan<byte>(inputBuffer, 0, PACKET_LENGTH_FIELD_SZ);
+            var plainText = new ReadOnlySpan<byte>(inputBuffer, PACKET_LENGTH_FIELD_SZ, cipherText.Length);
+
+#if DEBUG_AESGCM
+
+            string var_iv = GetHexStringFrom(_iv);
+            string var_key = GetHexStringFrom(_key);
+            string var_pt = GetHexStringFrom(plainText.ToArray());
+            string var_aad = GetHexStringFrom(associatedData.ToArray());
+
+            Console.WriteLine("[DEBUG] In GcmEncrypt()");
+            Console.WriteLine("[DEBUG] Encrypt Length: {0}", inputBuffer.Length - PACKET_LENGTH_FIELD_SZ);
+            Console.WriteLine("[DEBUG] IV: {0}", var_iv);
+            Console.WriteLine("[DEBUG] Key: {0}", var_key);
+            Console.WriteLine("[DEBUG] PT before Encrypt: {0}", var_pt);
+            Console.WriteLine("[DEBUG] AAD before Encrypt: {0}", var_aad);
+
+#endif //DEBUG_AESGCM
+            // AES-GCM Encrypt Function
+            cipher.Encrypt(_iv, plainText, cipherText, tag, associatedData);
+
+            // Reallocate the original buffer by the length of tag size
+            Array.Resize(ref inputBuffer, inputBuffer.Length + TAG_SIZE);
+
+            // Add cipher text into reallocated input buffer
+            Array.Copy(cipherText, 0, inputBuffer, associatedData.Length, cipherText.Length);
+
+            // Add cipher text into reallocated input buffer
+            Array.Copy(tag, 0, inputBuffer, associatedData.Length + cipherText.Length, TAG_SIZE);
+
+            int j = _iv.Length;
+
+            // Increment the counter after each operation
+            while (--j >= 0 && ++_iv[j] == 0)
+                ;
+
+            return inputBuffer;
+        }
+
+        /// <summary>
+        /// AEAD AES-GCM Decrypt Function
+        /// </summary>
+        /// <param name="inputBuffer">The input data that contains inbound packet sequence length, packet length, cipher text(CT)
+        /// and authenticated tag(AT).</param>
+        /// <param name="inputOffset">The offset into the input byte array from which to begin using data.</param>
+        /// <returns>Plain text.</returns>
+        // Structure of the inputBuffer:
+        // |4 bytes(offset)-||------4 bytes------||------------------Cipher Text--------------------||-------TAG-------|
+        // [inbound sequence][packet length field][padding length field sz][payload][random paddings][Authenticated TAG]
+        private byte[] GcmDecrypt(byte[] inputBuffer, int inputOffset)
+        {
+            if (inputBuffer.Length - inputOffset < _blockSize)
+                throw new ArgumentException("Invalid input buffer");
+
+            var plainText = new byte[inputBuffer.Length - inputOffset - PACKET_LENGTH_FIELD_SZ - TAG_SIZE];
+
+            // Parse out the Additional Authenticated Data from input buffer
+            var associatedData = new ReadOnlySpan<byte>(inputBuffer, inputOffset, PACKET_LENGTH_FIELD_SZ);
+
+            // Parse out the cipher text from input buffer
+            var cipherText = new ReadOnlySpan<byte>(inputBuffer, inputOffset + PACKET_LENGTH_FIELD_SZ, plainText.Length);
+
+            // Parse out the Authenticated Tag from input buffer
+            var tag = new ReadOnlySpan<byte>(inputBuffer, inputOffset + PACKET_LENGTH_FIELD_SZ + plainText.Length, TAG_SIZE);
+#if DEBUG_AESGCM
+
+            string var_iv = GetHexStringFrom(_iv);
+            string var_key = GetHexStringFrom(_key);
+            string var_ct = GetHexStringFrom(cipherText.ToArray());
+            string var_tag = GetHexStringFrom(tag.ToArray());
+            string var_aad = GetHexStringFrom(associatedData.ToArray());
+
+            Console.WriteLine("[DEBUG] In GcmDecrypt()");
+            Console.WriteLine("[DEBUG] IV: {0}", var_iv);
+            Console.WriteLine("[DEBUG] Key: {0}", var_key);
+            Console.WriteLine("[DEBUG] AAD before decrypt: {0}", var_aad);
+            Console.WriteLine("[DEBUG] CT before decrypt: {0}", var_ct);
+            Console.WriteLine("[DEBUG] TAG before decrypt: {0}", var_tag );
+
+#endif //DEBUG_AESGCM
+
+            cipher.Decrypt(_iv, cipherText, tag, plainText, associatedData);
+
+            // Reallocate the original buffer to only contain plain text
+            Array.Resize(ref inputBuffer, plainText.Length);
+
+            // Add plain text into reallocated input buffer
+            Array.Copy(plainText, 0, inputBuffer, 0, plainText.Length);
+
+            int j = _iv.Length;
+
+            while (--j >= 0 && ++_iv[j] == 0)
+                ;
+
+            return inputBuffer;
+        }
+
+        /// <summary>
+        /// Encrypts the specified data.
+        /// </summary>
+        /// <param name="data">The input data which contains outbound sequence length, packet length field and plain text.</param>
+        /// <param name="offset">The offset (the outbound sequence length) into the input byte array from
+        /// which to begin using data.</param>
+        /// <param name="length">The total length of the input data which contains packet length field and plain text<paramref name="data"/>.</param>
+        /// <returns>Encrypted data</returns>
+        // Structure of the data:
+        // |-4 bytes(offset)-||------4 bytes------||-------------------Plain Text--------------------|
+        // [outbound sequence][packet field length][padding length field sz][payload][random paddings]
+        public override byte[] Encrypt(byte[] data, int offset, int length)
+        {
+            // Length minus packet field length should be PT which needs to be multiplication of 16 in AEAD AES-GCM
+            // Based on [RFC5647] Section 7.2 .Auguest 2009
+            if ((length - PACKET_LENGTH_FIELD_SZ) % _blockSize > 0)
+            {
+                if (_padding == null)
+                {
+                    throw new ArgumentException("Padding Should Not Be Null for AEAD AES GCM Encrypt");
+                }
+
+                // Get the number of paddings need to be added
+                var paddingLength = _blockSize - ((length - PACKET_LENGTH_FIELD_SZ) % _blockSize);
+
+                data = _padding.Pad(data, offset, length, paddingLength);
+
+                // dataLength is the sum of outbound sequence length, updated packet length field and updated plain text
+                var dataLength = data.Length;
+
+                // Convert into an array for GCM Encrypt
+                data = new ReadOnlySpan<byte>(data, offset, dataLength - offset).ToArray();
+
+                // Structure of updated data buffer before invoke GcmEncrypt():
+                // |----------4 bytes----------||----------------------------------------Plain Text-------------------------------------------|
+                // [updated packet length field][updated padding length field sz][payload][random paddings + paddingDataLength of random bytes]
+                // output = PakcetLength Field Length(Additional Authenticated Data) + Cipher Text + Authenticated Tag
+                // Basd on [RFC5647] Section 7.2 .Auguest 2009
+                var output = GcmEncrypt(data);
+
+                if (output.Length != dataLength - offset + TAG_SIZE)
+                {
+                    throw new ArgumentException("Ecryption Failed for AES-GCM");
+                }
+#if DEBUG_AESGCM
+
+                string output_buffer = GetHexStringFrom(output);
+                Console.WriteLine("[DEBUG] In AEADBlockCipher Encrypt()");
+                Console.WriteLine("[DEBUG] Output Payload Length After Encryption: {0} ", output.Length);
+                Console.WriteLine("[DEBUG] Output Payload After Encryption");
+                Console.WriteLine("[DEBUG] {0}", output_buffer);
+
+#endif
+                return output;
+            }
+
+            throw new ArgumentException("Shouldn't Reach Here for AEAD AES GCM as Padding is Always Needed. ");
+        }
+
+        /// <summary>
+        /// For AEAD AES GCM since there is no first block decryption, this function will return what have been received
+        /// </summary>
+        /// <param name="data">The first block of data that contains 4 bytes of packet length field and 12 bytes of cipher text(CT).</param>
+        /// <returns>The first block of data that contains 4 bytes of packet length field and 12 bytes of cipher text(CT).</returns>
+        public override byte[] Decrypt(byte[] data)
+        {
+            return data;
+        }
+
+        /// <summary>
+        /// Decrypts the specified data.
+        /// </summary>
+        /// <param name="data">The packet data that contains inbound packet sequence length, packet length field(AAD), cipher text(CT)
+        /// and authenticated tag(AT).</param>
+        /// <param name="offset">The offset into the input byte array from which to begin using data.</param>
+        /// <param name="length">The length of cipher text that is a multiplication of 16 <paramref name="data"/>.</param>
+        /// <returns>Decrypted plain text</returns>
+        // Structure of the inputBuffer:
+        // |4 bytes(offset)-||------4 bytes------||------------------Cipher Text--------------------||-------TAG-------|
+        // [inbound sequence][packet length field][padding length field sz][payload][random paddings][Authenticated TAG]
+        public override byte[] Decrypt(byte[] data, int offset, int length)
+        {
+            // Since when invoke decrypt() in session.cs the offset is PACKET_LENGTH_FIELD_SZ + inboundPacketSequenceLength
+            // For AEAD AES-GCM, the offset should be inboundPacketSequenceLength so we need to substract PACKET_LENGTH_FIELD_SZ
+            offset -= PACKET_LENGTH_FIELD_SZ;
+
+            if (length % _blockSize > 0)
+            {
+                // Shouldn't reach here for AEAD AES-GCM since the length is always a multiplication of 16
+                // Still keep the padding utility
+
+                if (_padding == null)
+                {
+                    throw new ArgumentException("Padding is NULL");
+                }
+
+                var paddingLength = _blockSize - (length % _blockSize);
+
+                // length equals to cipher text length, thus need to add packet field length back before invoke the padding function
+                data = _padding.Pad(data, offset, length + PACKET_LENGTH_FIELD_SZ, paddingLength);
+
+                length = data.Length;
+            }
+
+            var output = GcmDecrypt(data, offset);
+
+            if (output.Length != length)
+            {
+                throw new ArgumentException("Ecryption Failed for AEAD AES-GCM");
+            }
+#if DEBUG_AESGCM
+
+            string output_buffer = GetHexStringFrom(output);
+            Console.WriteLine("[DEBUG] AEAD BlockCipher Decrypt()");
+            Console.WriteLine("[DEBUG] Output Payload Length After Decryption: {0} ", output.Length);
+            Console.WriteLine("[DEBUG] Output Payload After Decryption");
+            Console.WriteLine("[DEBUG] {0}", output_buffer);
+
+#endif //DEBUG_AESGCM
+
+            return output;
+        }
+
+        /// <summary>
+        /// Encrypts the specified region of the input byte array and copies the encrypted data to the specified region of the output byte array.
+        /// </summary>
+        /// <param name="inputBuffer">The input data to encrypt.</param>
+        /// <param name="inputOffset">The offset into the input byte array from which to begin using data.</param>
+        /// <param name="inputCount">The number of bytes in the input byte array to use as data.</param>
+        /// <param name="outputBuffer">The output to which to write encrypted data.</param>
+        /// <param name="outputOffset">The offset into the output byte array from which to begin writing data.</param>
+        /// <returns>
+        /// The number of bytes encrypted.
+        /// </returns>
+        /// <exception cref="ArgumentNullException"><paramref name="inputBuffer"/> or <paramref name="outputBuffer"/> is <c>null</c>.</exception>
+        /// <exception cref="IndexOutOfRangeException"><paramref name="inputBuffer"/> or <paramref name="outputBuffer"/> is too short.</exception>
+        public override int EncryptBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset)
+        {
+            throw new ArgumentException("Invalid function call");
+        }
+
+        /// <summary>
+        /// Decrypts the specified region of the input byte array and copies the decrypted data to the specified region of the output byte array.
+        /// </summary>
+        /// <param name="inputBuffer">The input data to decrypt.</param>
+        /// <param name="inputOffset">The offset into the input byte array from which to begin using data.</param>
+        /// <param name="inputCount">The number of bytes in the input byte array to use as data.</param>
+        /// <param name="outputBuffer">The output to which to write decrypted data.</param>
+        /// <param name="outputOffset">The offset into the output byte array from which to begin writing data.</param>
+        /// <returns>
+        /// The number of bytes decrypted.
+        /// </returns>
+        /// <exception cref="ArgumentNullException"><paramref name="inputBuffer"/> or <paramref name="outputBuffer"/> is <c>null</c>.</exception>
+        /// <exception cref="IndexOutOfRangeException"><paramref name="inputBuffer"/> or <paramref name="outputBuffer"/> is too short.</exception>
+        public override int DecryptBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset)
+        {
+            throw new ArgumentException("Invalid function call");
+        }
+    }
+}
+#endif
diff --git a/src/Renci.SshNet/Security/Cryptography/Ciphers/Paddings/AEADPadding.cs b/src/Renci.SshNet/Security/Cryptography/Ciphers/Paddings/AEADPadding.cs
new file mode 100644
index 000000000..6826ec7aa
--- /dev/null
+++ b/src/Renci.SshNet/Security/Cryptography/Ciphers/Paddings/AEADPadding.cs
@@ -0,0 +1,101 @@
+#if NETCOREAPP3_0 || NETSTANDARD2_1
+using System;
+using System.Text;
+using Renci.SshNet.Common;
+using Renci.SshNet.Abstractions;
+
+namespace Renci.SshNet.Security.Cryptography.Ciphers.Paddings
+{
+    /// <summary>
+    /// Implements AEAD cipher padding
+    /// </summary>
+    public class AEADPadding : CipherPadding
+    {
+        /// <summary>
+        /// Packet Length Field 4 bytes for AES GCM which is AAD as well.
+        /// Based on [RFC5647] Section 7.2 .Auguest 2009
+        /// </summary>
+        private readonly int PAD_LENGTH_FIELD_SZ = 1;
+
+        /// <summary>
+        /// Packet Length Field 4 bytes for AES GCM which is AAD as well.
+        /// Based on [RFC5647] Section 7.2 .Auguest 2009
+        /// </summary>
+        private readonly int PACKET_LENGTH_FIELD_SZ = 4;
+
+        /// <summary>
+        /// Pads the specified input to match the block size.
+        /// </summary>
+        /// <param name="blockSize">The size of the block cipher for AEAD AES-GCM.</param>
+        /// <param name="input">The input buffer which contains inbound sequence length, packet length field and Cipher Text.</param>
+        /// <param name="offset">The offset into the input data array from which to begin using data..</param>
+        /// <param name="length">The number of bytes in <paramref name="input"/> to take into account.</param>
+        /// <returns>
+        /// The padded data array.
+        /// </returns>
+        public override byte[] Pad(int blockSize, byte[] input, int offset, int length)
+        {
+            throw new ArgumentException("Not Implemented");
+        }
+
+        /// <summary>
+        /// Pads the specified input with a given number of bytes.
+        /// </summary>
+        /// <param name="input">The packet Data which contains outbound/inbound sequence length, packet length field and plain text PT .</param>
+        /// <param name="offset">The offset into the input data array from which to begin using data.</param>
+        /// <param name="length">The number of bytes in <paramref name="input"/> to take into account
+        /// which is input buffer data - outbound/inbound sequence length.</param>
+        /// <param name="paddingDataLength">The number of padding bytes need to add to <paramref name="input"/>.</param>
+        /// <returns>
+        /// The padded data array.
+        /// </returns>
+        // Structure of the data:
+        // |-----4 bytes(offset)-----||-----4 bytes-------|-------------------Plain Text--------------------|
+        // [outbound/inbound sequence][packet length field][padding length field sz][payload][random paddings]
+        // After re construct the new output buffer will be:
+        // |----------4 bytes----------||----------------------------------------Plain Text-------------------------------------------|
+        // [updated packet length field][updated padding length field sz][payload][random paddings + paddingDataLength of random bytes]
+        public override byte[] Pad(byte[] input, int offset, int length, int paddingDataLength)
+        {
+            // Generate the compensated padding bytes
+            var paddingBytes = new byte[paddingDataLength];
+            CryptoAbstraction.GenerateRandom(paddingBytes);
+
+            // Find Old padding byte length then convert to int type
+            var padding_field = Buffer.GetByte(input, offset + PACKET_LENGTH_FIELD_SZ);
+            int padding_field_length = Convert.ToInt32(padding_field);
+
+            // New padding length byte
+            var _paddingSz = padding_field_length + paddingDataLength;
+
+            padding_field = Convert.ToByte(_paddingSz);
+
+            // Extract old packet length field
+            var packetlength_field = new ReadOnlySpan<byte>(input, offset, PACKET_LENGTH_FIELD_SZ).ToArray();
+            var packetlength_field_int32 = Pack.BigEndianToUInt32(packetlength_field, 0);
+
+            // Calculate the msg payload length
+            var messageLength = packetlength_field_int32 - PAD_LENGTH_FIELD_SZ - padding_field_length;
+
+            // New packet length field
+            packetlength_field_int32 = packetlength_field_int32 + (uint)paddingDataLength;
+            Pack.UInt32ToBigEndian(packetlength_field_int32, packetlength_field);
+
+            // Only update packet length field, padding length byte and new padding bytes from the original data buffer
+            // Based on [RFC5647] Section 7.2
+            Array.Resize(ref input, offset + length + paddingDataLength);
+
+            //Update the packet length field from original array
+            Array.Copy(packetlength_field, 0, input, offset, PACKET_LENGTH_FIELD_SZ);
+
+            //Update the padding length field from original array
+            Buffer.SetByte(input, offset + PACKET_LENGTH_FIELD_SZ, padding_field);
+
+            //Update the padding bytes from original array
+            Array.Copy(paddingBytes, 0, input, offset + PACKET_LENGTH_FIELD_SZ + PAD_LENGTH_FIELD_SZ + (int)messageLength + (int)padding_field_length, paddingDataLength);
+
+            return input;
+        }
+    }
+}
+#endif
\ No newline at end of file
diff --git a/src/Renci.SshNet/Security/Cryptography/EcdsaDigitalSignature.cs b/src/Renci.SshNet/Security/Cryptography/EcdsaDigitalSignature.cs
index 38d60966e..256cd746a 100644
--- a/src/Renci.SshNet/Security/Cryptography/EcdsaDigitalSignature.cs
+++ b/src/Renci.SshNet/Security/Cryptography/EcdsaDigitalSignature.cs
@@ -39,7 +39,7 @@ public override bool Verify(byte[] input, byte[] signature)
             // for 521 sig_size is 132
             var sig_size = _key.KeyLength == 521 ? 132 : _key.KeyLength / 4;
             var ssh_data = new SshDataSignature(signature, sig_size);
-#if NETSTANDARD2_0
+#if NETSTANDARD2_0 || NETSTANDARD2_1
             return _key.Ecdsa.VerifyData(input, ssh_data.Signature, _key.HashAlgorithm);
 #else
             var ecdsa = (ECDsaCng)_key.Ecdsa;
@@ -57,7 +57,7 @@ public override bool Verify(byte[] input, byte[] signature)
         /// </returns>
         public override byte[] Sign(byte[] input)
         {
-#if NETSTANDARD2_0
+#if NETSTANDARD2_0 || NETSTANDARD2_1
             var signed = _key.Ecdsa.SignData(input, _key.HashAlgorithm);
 #else
             var ecdsa = (ECDsaCng)_key.Ecdsa;
diff --git a/src/Renci.SshNet/Security/Cryptography/EcdsaKey.cs b/src/Renci.SshNet/Security/Cryptography/EcdsaKey.cs
index 58861f020..816259cfe 100644
--- a/src/Renci.SshNet/Security/Cryptography/EcdsaKey.cs
+++ b/src/Renci.SshNet/Security/Cryptography/EcdsaKey.cs
@@ -18,7 +18,7 @@ public class EcdsaKey : Key, IDisposable
         internal const string ECDSA_P384_OID_VALUE = "1.3.132.0.34"; // Also called nistP384 or secP384r1
         internal const string ECDSA_P521_OID_VALUE = "1.3.132.0.35"; // Also called nistP521or secP521r1
 
-#if !NETSTANDARD2_0
+#if !NETSTANDARD2_0 && !NETSTANDARD2_1
         internal enum KeyBlobMagicNumber : int
         {
             BCRYPT_ECDSA_PUBLIC_P256_MAGIC = 0x31534345,
@@ -57,7 +57,7 @@ public override string ToString()
             return string.Format("ecdsa-sha2-nistp{0}", KeyLength);
         }
 
-#if NETSTANDARD2_0
+#if NETSTANDARD2_0 || NETSTANDARD2_1
         /// <summary>
         /// Gets the HashAlgorithm to use
         /// </summary>
@@ -144,7 +144,7 @@ public override BigInteger[] Public
                 byte[] curve;
                 byte[] qx;
                 byte[] qy;
-#if NETSTANDARD2_0
+#if NETSTANDARD2_0 || NETSTANDARD2_1
                 var parameter = Ecdsa.ExportParameters(false);
                 qx = parameter.Q.X;
                 qy = parameter.Q.Y;
@@ -278,7 +278,7 @@ public EcdsaKey(byte[] data)
 
         private void Import(string curve_oid, byte[] publickey, byte[] privatekey)
         {
-#if NETSTANDARD2_0
+#if NETSTANDARD2_0 || NETSTANDARD2_1
             var curve = ECCurve.CreateFromValue(curve_oid);
             var parameter = new ECParameters
             {
diff --git a/src/Renci.SshNet/Session.cs b/src/Renci.SshNet/Session.cs
index 0748b8dac..3717d8e73 100644
--- a/src/Renci.SshNet/Session.cs
+++ b/src/Renci.SshNet/Session.cs
@@ -196,7 +196,18 @@ public class Session : ISession
         /// while performing a given operation or set of operations on <see cref="_socket"/>.
         /// </remarks>
         private readonly object _socketDisposeLock = new object();
+#if DEBUG_AESGCM
 
+        /// <summary>
+        /// GetHexStringFrom.
+        /// </summary>
+        /// <returns>String.</returns>
+        public static string GetHexStringFrom(byte[] byteArray)
+        {
+            return  BitConverter.ToString(byteArray); //To convert the whole array
+        }
+
+#endif
         /// <summary>
         /// Gets the session semaphore that controls session channels.
         /// </summary>
@@ -912,7 +923,12 @@ internal void SendMessage(Message message)
                 byte[] hash = null;
                 var packetDataOffset = 4; // first four bytes are reserved for outbound packet sequence
 
-                if (_clientMac != null)
+                if(_clientCipher != null &&  _clientCipher.isAEAD)
+                {
+                    // write outbound packet sequence to start of packet data when it's AEAD AES-GCM
+                    Pack.UInt32ToBigEndian(_outboundPacketSequence, packetData);
+                }
+                else if (_clientMac != null)
                 {
                     // write outbound packet sequence to start of packet data
                     Pack.UInt32ToBigEndian(_outboundPacketSequence, packetData);
@@ -923,8 +939,26 @@ internal void SendMessage(Message message)
                 // Encrypt packet data
                 if (_clientCipher != null)
                 {
+#if DEBUG_AESGCM
+
+                    string var_pt = GetHexStringFrom(packetData);
+                    Console.WriteLine("[DEBUG] [Sender] [1.0] Before Encrypt");
+                    Console.WriteLine("[DEBUG] Packetdata Length (Minus 8 Should Always Be Mutiplication of 16): {0}", packetData.Length);
+                    Console.WriteLine("[DEBUG] Packetdata Payload");
+                    Console.WriteLine("[DEBUG] {0}", var_pt);
+
+#endif
                     packetData = _clientCipher.Encrypt(packetData, packetDataOffset, (packetData.Length - packetDataOffset));
                     packetDataOffset = 0;
+#if DEBUG_AESGCM
+
+                    string var_ct = GetHexStringFrom(packetData);
+                    Console.WriteLine("[DEBUG] [Sender] [1.1] After Encryption");
+                    Console.WriteLine("[DEBUG] Packetdata Length (Minus 4 Should Always Be Mutiplication of 16): {0}", packetData.Length);
+                    Console.WriteLine("[DEBUG] Packetdata Payload");
+                    Console.WriteLine("[DEBUG] {0}", var_ct);
+
+#endif
                 }
 
                 if (packetData.Length > MaximumSshPacketSize)
@@ -952,6 +986,11 @@ internal void SendMessage(Message message)
                 // the server will use it to verify the data integrity, and as such the order in
                 // which messages are sent must follow the outbound packet sequence number
                 _outboundPacketSequence++;
+#if DEBUG_AESGCM
+
+                Console.WriteLine("[DEBUG] [Sender] [1.2] outboundPacketSequence: [{0}]", _outboundPacketSequence);
+
+#endif
             }
         }
 
@@ -1057,7 +1096,21 @@ private Message ReceiveMessage(Socket socket)
 
                 if (_serverCipher != null)
                 {
+#if DEBUG_AESGCM
+
+                    Console.WriteLine("[DEBUG] [Receiver] [0.0] start from receive message which needs to be decrypted first");
+
+#endif
                     firstBlock = _serverCipher.Decrypt(firstBlock);
+
+                    // If it's AEAD AES-GCM set the serverMacLength to the tag size
+                    // Otherwise use default mac size
+                    serverMacLength = _serverCipher.serverMacLength(_serverMac);
+#if DEBUG_AESGCM
+                    Console.WriteLine("[DEBUG] [Receiver] [1.0] Before Decrypt");
+                    Console.WriteLine("[DEBUG] [Receiver] [1.0] serverMacLength: {0}", serverMacLength);
+
+#endif
                 }
 
                 packetLength = Pack.BigEndianToUInt32(firstBlock);
@@ -1100,16 +1153,41 @@ private Message ReceiveMessage(Socket socket)
 
             if (_serverCipher != null)
             {
-                var numberOfBytesToDecrypt = data.Length - (blockSize + inboundPacketSequenceLength + serverMacLength);
+                // Caculate the size of plain text buffer for the decryption
+                var numberOfBytesToDecrypt = data.Length - (_serverCipher.decryptOffset(inboundPacketSequenceLength, blockSize) + _serverCipher.serverMacLength(_serverMac));
                 if (numberOfBytesToDecrypt > 0)
                 {
-                    var decryptedData = _serverCipher.Decrypt(data, blockSize + inboundPacketSequenceLength, numberOfBytesToDecrypt);
-                    Buffer.BlockCopy(decryptedData, 0, data, blockSize + inboundPacketSequenceLength, decryptedData.Length);
+#if DEBUG_AESGCM
+
+                    string var_data = GetHexStringFrom(data);
+                    Console.WriteLine("[DEBUG] [Receiver] [1.1] Before Decrypt Total Data Length {0}", data.Length);
+                    Console.WriteLine("[DEBUG] [Receiver] [1.1] Before Decrypt");
+                    Console.WriteLine("[DEBUG] [Receiver] [1.1] Data Payload");
+                    Console.WriteLine("[DEBUG] {0}", var_data);
+
+#endif
+                    var decryptedData = _serverCipher.Decrypt(data, _serverCipher.decryptOffset(inboundPacketSequenceLength, blockSize), numberOfBytesToDecrypt);
+
+                    // dst offset should return the right offset based on what cipher suite is choosen
+                    Buffer.BlockCopy(decryptedData, 0, data, _serverCipher.decryptOffset(inboundPacketSequenceLength, blockSize), decryptedData.Length);
+#if DEBUG_AESGCM
+
+                    string var_data_pt = GetHexStringFrom(data);
+                    Console.WriteLine("[DEBUG] [Receiver] [1.2] After Decrypt");
+                    Console.WriteLine("[DEBUG] [Receiver] [1.2] Plain Text Payload");
+                    Console.WriteLine("[DEBUG] {0}", var_data_pt);
+
+#endif
                 }
             }
 
             var paddingLength = data[inboundPacketSequenceLength + packetLengthFieldLength];
-            var messagePayloadLength = (int) packetLength - paddingLength - paddingLengthFieldLength;
+#if DEBUG_AESGCM
+
+            Console.WriteLine("[DEBUG] [Receiver] [1.3] After Decrypt data paddingLength is: {0}", paddingLength);
+
+#endif
+            var messagePayloadLength = (int)packetLength - paddingLength - paddingLengthFieldLength;
             var messagePayloadOffset = inboundPacketSequenceLength + packetLengthFieldLength + paddingLengthFieldLength;
 
             // validate message against MAC
@@ -1138,6 +1216,12 @@ private Message ReceiveMessage(Socket socket)
 
             _inboundPacketSequence++;
 
+#if DEBUG_AESGCM
+
+            Console.WriteLine("[DEBUG] [Receiver] [1.4] Before Load the Message");
+            Console.WriteLine("[DEBUG] [Receiver] [1.4] inboundPacketSequence is: [{0}]", _inboundPacketSequence);
+
+#endif
             return LoadMessage(data, messagePayloadOffset, messagePayloadLength);
         }
 
@@ -1323,10 +1407,19 @@ internal void OnNewKeysReceived(NewKeysMessage message)
             //  Update negotiated algorithms
             _serverCipher = _keyExchange.CreateServerCipher();
             _clientCipher = _keyExchange.CreateClientCipher();
-            _serverMac = _keyExchange.CreateServerHash();
-            _clientMac = _keyExchange.CreateClientHash();
-            _clientCompression = _keyExchange.CreateCompressor();
-            _serverDecompression = _keyExchange.CreateDecompressor();
+
+            if (_clientCipher.isAEAD && _serverCipher.isAEAD)
+            {
+                _clientCompression = null;
+                _serverDecompression = null;
+            }
+            else
+            {
+                _serverMac = _keyExchange.CreateServerHash();
+                _clientMac = _keyExchange.CreateClientHash();
+                _clientCompression = _keyExchange.CreateCompressor();
+                _serverDecompression = _keyExchange.CreateDecompressor();
+            }
 
             //  Dispose of old KeyExchange object as it is no longer needed.
             if (_keyExchange != null)
@@ -1624,6 +1717,11 @@ private Message LoadMessage(byte[] data, int offset, int count)
         {
             var messageType = data[offset];
 
+#if DEBUG_AESGCM
+
+            Console.WriteLine("[DEBUG] [Receiver] [1.5] LoadMessage messageType: {0}", messageType);
+
+#endif
             var message = _sshMessageFactory.Create(messageType);
             message.Load(data, offset + 1, count - 1);