Use packing methods from newly introduced Pack class.

src/Renci.SshNet.Tests/Classes/Sftp/SftpSessionTest_Connected_RequestRead.cs

@@ -118,9 +118,9 @@ namespace Renci.SshNet.Tests.Classes.Sftp
                 var nameBytes = encoding.GetBytes(name);
                 var attributesBytes = SftpFileAttributes.Empty.GetBytes();
 
-                namesAndAttributes.AddRange((((uint) nameBytes.Length).GetBytes())); // filename length
+                namesAndAttributes.AddRange(Pack.UInt32ToBigEndian((uint) nameBytes.Length)); // filename length
                 namesAndAttributes.AddRange(nameBytes); // filename
-                namesAndAttributes.AddRange(((uint) 0).GetBytes()); // longname length
+                namesAndAttributes.AddRange(Pack.UInt32ToBigEndian(0U)); // longname length
                 namesAndAttributes.AddRange(attributesBytes); // attributes
             }
 

src/Renci.SshNet.Tests/Classes/Sftp/SftpSessionTest_Connected_RequestStatVfs.cs

@@ -111,9 +111,9 @@ namespace Renci.SshNet.Tests.Classes.Sftp
                 var nameBytes = encoding.GetBytes(name);
                 var attributesBytes = SftpFileAttributes.Empty.GetBytes();
 
-                namesAndAttributes.AddRange((((uint) nameBytes.Length).GetBytes())); // filename length
+                namesAndAttributes.AddRange(Pack.UInt32ToBigEndian((uint) nameBytes.Length)); // filename length
                 namesAndAttributes.AddRange(nameBytes); // filename
-                namesAndAttributes.AddRange(((uint) 0).GetBytes()); // longname length
+                namesAndAttributes.AddRange(Pack.UInt32ToBigEndian(0U)); // longname length
                 namesAndAttributes.AddRange(attributesBytes); // attributes
             }
 

src/Renci.SshNet/Common/DerData.cs

@@ -157,7 +157,7 @@ namespace Renci.SshNet.Common
         /// <param name="data">UInt32 data to write.</param>
         public void Write(uint data)
         {
-            var bytes = data.GetBytes();
+            var bytes = Pack.UInt32ToBigEndian(data);
             _data.Add(Integer);
             var length = GetLength(bytes.Length);
             WriteBytes(length);

src/Renci.SshNet/Common/Extensions.cs

@@ -111,70 +111,6 @@ namespace Renci.SshNet
             return Activator.CreateInstance(type) as T;
         }
 
-        /// <summary>
-        /// Returns the specified 16-bit unsigned integer value as an array of bytes.
-        /// </summary>
-        /// <param name="value">The number to convert.</param>
-        /// <returns>An array of bytes with length 2.</returns>
-        internal static byte[] GetBytes(this ushort value)
-        {
-            return new[] {(byte) (value >> 8), (byte) (value & 0xFF)};
-        }
-
-        /// <summary>
-        /// Returns the specified 32-bit unsigned integer value as an array of bytes.
-        /// </summary>
-        /// <param name="value">The number to convert.</param>
-        /// <returns>An array of bytes with length 4.</returns>
-        internal static byte[] GetBytes(this uint value)
-        {
-            var buffer = new byte[4];
-            value.Write(buffer, 0);
-            return buffer;
-        }
-
-        /// <summary>
-        /// Returns the specified 32-bit unsigned integer value as an array of bytes.
-        /// </summary>
-        /// <param name="value">The number to convert.</param>
-        /// <param name="buffer">The array of bytes to write <paramref name="value"/> to.</param>
-        /// <param name="offset">The zero-based offset in <paramref name="buffer"/> at which to begin writing.</param>
-        internal static void Write(this uint value, byte[] buffer, int offset)
-        {
-            buffer[offset++] = (byte) (value >> 24);
-            buffer[offset++] = (byte) (value >> 16);
-            buffer[offset++] = (byte)(value >> 8);
-            buffer[offset] = (byte) (value & 0xFF);
-        }
-
-        /// <summary>
-        /// Returns the specified 64-bit unsigned integer value as an array of bytes.
-        /// </summary>
-        /// <param name="value">The number to convert.</param>
-        /// <returns>An array of bytes with length 8.</returns>
-        internal static byte[] GetBytes(this ulong value)
-        {
-            return new[]
-                {
-                    (byte) (value >> 56), (byte) (value >> 48), (byte) (value >> 40), (byte) (value >> 32),
-                    (byte) (value >> 24), (byte) (value >> 16), (byte) (value >> 8), (byte) (value & 0xFF)
-                };
-        }
-
-        /// <summary>
-        /// Returns the specified 64-bit signed integer value as an array of bytes.
-        /// </summary>
-        /// <param name="value">The number to convert.</param>
-        /// <returns>An array of bytes with length 8.</returns>
-        internal static byte[] GetBytes(this long value)
-        {
-            return new[]
-                {
-                    (byte) (value >> 56), (byte) (value >> 48), (byte) (value >> 40), (byte) (value >> 32),
-                    (byte) (value >> 24), (byte) (value >> 16), (byte) (value >> 8), (byte) (value & 0xFF)
-                };
-        }
-
         internal static void ValidatePort(this uint value, string argument)
         {
             if (value > IPEndPoint.MaxPort)

src/Renci.SshNet/Common/SshDataStream.cs

@@ -62,7 +62,7 @@ namespace Renci.SshNet.Common
         /// <param name="value"><see cref="uint"/> data to write.</param>
         public void Write(uint value)
         {
-            var bytes = value.GetBytes();
+            var bytes = Pack.UInt32ToBigEndian(value);
             Write(bytes, 0, bytes.Length);
         }
 
@@ -72,7 +72,7 @@ namespace Renci.SshNet.Common
         /// <param name="value"><see cref="ulong"/> data to write.</param>
         public void Write(ulong value)
         {
-            var bytes = value.GetBytes();
+            var bytes = Pack.UInt64ToBigEndian(value);
             Write(bytes, 0, bytes.Length);
         }
 
@@ -183,7 +183,7 @@ namespace Renci.SshNet.Common
         public uint ReadUInt32()
         {
             var data = ReadBytes(4);
-            return (uint) (data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]);
+            return Pack.BigEndianToUInt32(data);
         }
 
         /// <summary>
@@ -195,8 +195,7 @@ namespace Renci.SshNet.Common
         public ulong ReadUInt64()
         {
             var data = ReadBytes(8);
-            return ((ulong) data[0] << 56 | (ulong) data[1] << 48 | (ulong) data[2] << 40 | (ulong) data[3] << 32 |
-                    (ulong) data[4] << 24 | (ulong) data[5] << 16 | (ulong) data[6] << 8 | data[7]);
+            return Pack.BigEndianToUInt64(data);
         }
 
         /// <summary>

src/Renci.SshNet/Messages/Message.cs

@@ -94,7 +94,7 @@ namespace Renci.SshNet.Messages
                 sshDataStream.Seek(outboundPacketSequenceSize, SeekOrigin.Begin);
 
                 // add packet data length
-                sshDataStream.Write(packetDataLength.GetBytes(), 0, 4);
+                sshDataStream.Write(packetDataLength);
 
                 //  add packet padding length
                 sshDataStream.WriteByte(paddingLength);
@@ -115,7 +115,7 @@ namespace Renci.SshNet.Messages
                 sshDataStream.Seek(outboundPacketSequenceSize, SeekOrigin.Begin);
 
                 // add packet data length
-                sshDataStream.Write(packetDataLength.GetBytes(), 0, 4);
+                sshDataStream.Write(packetDataLength);
 
                 //  add packet padding length
                 sshDataStream.WriteByte(paddingLength);

src/Renci.SshNet/Security/Cryptography/Cipher.cs

@@ -1,6 +1,4 @@
-using System;
-
-namespace Renci.SshNet.Security.Cryptography
+namespace Renci.SshNet.Security.Cryptography
 {
     /// <summary>
     /// Base class for cipher implementation.
@@ -55,217 +53,5 @@ namespace Renci.SshNet.Security.Cryptography
         /// The decrypted data.
         /// </returns>
         public abstract byte[] Decrypt(byte[] input, int offset, int length);
-
-        #region Packing functions
-
-        /// <summary>
-        /// Populates buffer with big endian number representation.
-        /// </summary>
-        /// <param name="number">The number to convert.</param>
-        /// <param name="buffer">The buffer.</param>
-        protected static void UInt32ToBigEndian(uint number, byte[] buffer)
-        {
-            buffer[0] = (byte)(number >> 24);
-            buffer[1] = (byte)(number >> 16);
-            buffer[2] = (byte)(number >> 8);
-            buffer[3] = (byte)(number);
-        }
-
-        /// <summary>
-        /// Populates buffer with big endian number representation.
-        /// </summary>
-        /// <param name="number">The number to convert.</param>
-        /// <param name="buffer">The buffer.</param>
-        /// <param name="offset">The buffer offset.</param>
-        protected static void UInt32ToBigEndian(uint number, byte[] buffer, int offset)
-        {
-            buffer[offset] = (byte)(number >> 24);
-            buffer[offset + 1] = (byte)(number >> 16);
-            buffer[offset + 2] = (byte)(number >> 8);
-            buffer[offset + 3] = (byte)(number);
-        }
-
-        /// <summary>
-        /// Converts big endian bytes into number.
-        /// </summary>
-        /// <param name="buffer">The buffer.</param>
-        /// <returns>Converted <see cref="Int32" />.</returns>
-        protected static uint BigEndianToUInt32(byte[] buffer)
-        {
-            uint n = (uint)buffer[0] << 24;
-            n |= (uint)buffer[1] << 16;
-            n |= (uint)buffer[2] << 8;
-            n |= (uint)buffer[3];
-            return n;
-        }
-
-        /// <summary>
-        /// Converts big endian bytes into number.
-        /// </summary>
-        /// <param name="buffer">The buffer.</param>
-        /// <param name="offset">The buffer offset.</param>
-        /// <returns>Converted <see cref="UInt32" />.</returns>
-        protected static uint BigEndianToUInt32(byte[] buffer, int offset)
-        {
-            uint n = (uint)buffer[offset] << 24;
-            n |= (uint)buffer[offset + 1] << 16;
-            n |= (uint)buffer[offset + 2] << 8;
-            n |= (uint)buffer[offset + 3];
-            return n;
-        }
-
-        /// <summary>
-        /// Converts big endian bytes into number.
-        /// </summary>
-        /// <param name="buffer">The buffer.</param>
-        /// <returns>Converted <see cref="UInt64" />.</returns>
-        protected static ulong BigEndianToUInt64(byte[] buffer)
-        {
-            uint hi = BigEndianToUInt32(buffer);
-            uint lo = BigEndianToUInt32(buffer, 4);
-            return ((ulong)hi << 32) | (ulong)lo;
-        }
-
-        /// <summary>
-        /// Converts big endian bytes into number.
-        /// </summary>
-        /// <param name="buffer">The buffer.</param>
-        /// <param name="offset">The buffer offset.</param>
-        /// <returns>Converted <see cref="UInt64" />.</returns>
-        protected static ulong BigEndianToUInt64(byte[] buffer, int offset)
-        {
-            uint hi = BigEndianToUInt32(buffer, offset);
-            uint lo = BigEndianToUInt32(buffer, offset + 4);
-            return ((ulong)hi << 32) | (ulong)lo;
-        }
-
-        /// <summary>
-        /// Populates buffer with big endian number representation.
-        /// </summary>
-        /// <param name="number">The number to convert.</param>
-        /// <param name="buffer">The buffer.</param>
-        protected static void UInt64ToBigEndian(ulong number, byte[] buffer)
-        {
-            UInt32ToBigEndian((uint)(number >> 32), buffer);
-            UInt32ToBigEndian((uint)(number), buffer, 4);
-        }
-
-        /// <summary>
-        /// Populates buffer with big endian number representation.
-        /// </summary>
-        /// <param name="number">The number to convert.</param>
-        /// <param name="buffer">The buffer.</param>
-        /// <param name="offset">The buffer offset.</param>
-        protected static void UInt64ToBigEndian(ulong number, byte[] buffer, int offset)
-        {
-            UInt32ToBigEndian((uint)(number >> 32), buffer, offset);
-            UInt32ToBigEndian((uint)(number), buffer, offset + 4);
-        }
-
-        /// <summary>
-        /// Populates buffer with little endian number representation.
-        /// </summary>
-        /// <param name="number">The number to convert.</param>
-        /// <param name="buffer">The buffer.</param>
-        protected static void UInt32ToLittleEndian(uint number, byte[] buffer)
-        {
-            buffer[0] = (byte)(number);
-            buffer[1] = (byte)(number >> 8);
-            buffer[2] = (byte)(number >> 16);
-            buffer[3] = (byte)(number >> 24);
-        }
-
-        /// <summary>
-        /// Populates buffer with little endian number representation.
-        /// </summary>
-        /// <param name="number">The number to convert.</param>
-        /// <param name="buffer">The buffer.</param>
-        /// <param name="offset">The buffer offset.</param>
-        protected static void UInt32ToLittleEndian(uint number, byte[] buffer, int offset)
-        {
-            buffer[offset] = (byte)(number);
-            buffer[offset + 1] = (byte)(number >> 8);
-            buffer[offset + 2] = (byte)(number >> 16);
-            buffer[offset + 3] = (byte)(number >> 24);
-        }
-
-        /// <summary>
-        /// Converts little endian bytes into number.
-        /// </summary>
-        /// <param name="buffer">The buffer.</param>
-        /// <returns>Converted <see cref="UInt32" />.</returns>
-        protected static uint LittleEndianToUInt32(byte[] buffer)
-        {
-            uint n = (uint)buffer[0];
-            n |= (uint)buffer[1] << 8;
-            n |= (uint)buffer[2] << 16;
-            n |= (uint)buffer[3] << 24;
-            return n;
-        }
-
-        /// <summary>
-        /// Converts little endian bytes into number.
-        /// </summary>
-        /// <param name="buffer">The buffer.</param>
-        /// <param name="offset">The buffer offset.</param>
-        /// <returns>Converted <see cref="Int32" />.</returns>
-        protected static uint LittleEndianToUInt32(byte[] buffer, int offset)
-        {
-            uint n = (uint)buffer[offset];
-            n |= (uint)buffer[offset + 1] << 8;
-            n |= (uint)buffer[offset + 2] << 16;
-            n |= (uint)buffer[offset + 3] << 24;
-            return n;
-        }
-
-        /// <summary>
-        /// Converts little endian bytes into number.
-        /// </summary>
-        /// <param name="buffer">The buffer.</param>
-        /// <returns>Converted <see cref="UInt64" />.</returns>
-        protected static ulong LittleEndianToUInt64(byte[] buffer)
-        {
-            uint lo = LittleEndianToUInt32(buffer);
-            uint hi = LittleEndianToUInt32(buffer, 4);
-            return ((ulong)hi << 32) | (ulong)lo;
-        }
-
-        /// <summary>
-        /// Converts little endian bytes into number.
-        /// </summary>
-        /// <param name="buffer">The buffer.</param>
-        /// <param name="offset">The buffer offset.</param>
-        /// <returns>Converted <see cref="UInt64" />.</returns>
-        protected static ulong LittleEndianToUInt64(byte[] buffer, int offset)
-        {
-            uint lo = LittleEndianToUInt32(buffer, offset);
-            uint hi = LittleEndianToUInt32(buffer, offset + 4);
-            return ((ulong)hi << 32) | (ulong)lo;
-        }
-
-        /// <summary>
-        /// Populates buffer with little endian number representation.
-        /// </summary>
-        /// <param name="number">The number to convert.</param>
-        /// <param name="buffer">The buffer.</param>
-        protected static void UInt64ToLittleEndian(ulong number, byte[] buffer)
-        {
-            UInt32ToLittleEndian((uint)(number), buffer);
-            UInt32ToLittleEndian((uint)(number >> 32), buffer, 4);
-        }
-
-        /// <summary>
-        /// Populates buffer with little endian number representation.
-        /// </summary>
-        /// <param name="number">The number to convert.</param>
-        /// <param name="buffer">The buffer.</param>
-        /// <param name="offset">The buffer offset.</param>
-        protected static void UInt64ToLittleEndian(ulong number, byte[] buffer, int offset)
-        {
-            UInt32ToLittleEndian((uint)(number), buffer, offset);
-            UInt32ToLittleEndian((uint)(number >> 32), buffer, offset + 4);
-        }
-
-        #endregion
     }
 }

src/Renci.SshNet/Security/Cryptography/Ciphers/BlowfishCipher.cs

@@ -1,4 +1,5 @@
 using System;
+using Renci.SshNet.Common;
 
 namespace Renci.SshNet.Security.Cryptography.Ciphers
 {
@@ -349,8 +350,8 @@ namespace Renci.SshNet.Security.Cryptography.Ciphers
             if (inputCount != BlockSize)
                 throw new ArgumentException("inputCount");
 
-            uint xl = BigEndianToUInt32(inputBuffer, inputOffset);
-            uint xr = BigEndianToUInt32(inputBuffer, inputOffset + 4);
+            uint xl = Pack.BigEndianToUInt32(inputBuffer, inputOffset);
+            uint xr = Pack.BigEndianToUInt32(inputBuffer, inputOffset + 4);
 
             xl ^= _p[0];
 
@@ -362,8 +363,8 @@ namespace Renci.SshNet.Security.Cryptography.Ciphers
 
             xr ^= _p[Rounds + 1];
 
-            UInt32ToBigEndian(xr, outputBuffer, outputOffset);
-            UInt32ToBigEndian(xl, outputBuffer, outputOffset + 4);
+            Pack.UInt32ToBigEndian(xr, outputBuffer, outputOffset);
+            Pack.UInt32ToBigEndian(xl, outputBuffer, outputOffset + 4);
 
             return BlockSize;
         }
@@ -384,12 +385,12 @@ namespace Renci.SshNet.Security.Cryptography.Ciphers
             if (inputCount != BlockSize)
                 throw new ArgumentException("inputCount");
 
-            uint xl = BigEndianToUInt32(inputBuffer, inputOffset);
-            uint xr = BigEndianToUInt32(inputBuffer, inputOffset + 4);
+            var xl = Pack.BigEndianToUInt32(inputBuffer, inputOffset);
+            var xr = Pack.BigEndianToUInt32(inputBuffer, inputOffset + 4);
 
             xl ^= _p[Rounds + 1];
 
-            for (int i = Rounds; i > 0; i -= 2)
+            for (var i = Rounds; i > 0; i -= 2)
             {
                 xr ^= F(xl) ^ _p[i];
                 xl ^= F(xr) ^ _p[i - 1];
@@ -397,8 +398,8 @@ namespace Renci.SshNet.Security.Cryptography.Ciphers
 
             xr ^= _p[0];
 
-            UInt32ToBigEndian(xr, outputBuffer, outputOffset);
-            UInt32ToBigEndian(xl, outputBuffer, outputOffset + 4);
+            Pack.UInt32ToBigEndian(xr, outputBuffer, outputOffset);
+            Pack.UInt32ToBigEndian(xl, outputBuffer, outputOffset + 4);
 
             return BlockSize;
         }

src/Renci.SshNet/Security/Cryptography/Ciphers/CastCipher.cs

@@ -1,4 +1,5 @@
 using System;
+using Renci.SshNet.Common;
 
 namespace Renci.SshNet.Security.Cryptography.Ciphers
 {
@@ -59,15 +60,15 @@ namespace Renci.SshNet.Security.Cryptography.Ciphers
             // batch the units up into a 32 bit chunk and go for it
             // the array is in bytes, the increment is 8x8 bits = 64
 
-            uint L0 = BigEndianToUInt32(inputBuffer, inputOffset);
-            uint R0 = BigEndianToUInt32(inputBuffer, inputOffset + 4);
+            var L0 = Pack.BigEndianToUInt32(inputBuffer, inputOffset);
+            var R0 = Pack.BigEndianToUInt32(inputBuffer, inputOffset + 4);
 
-            uint[] result = new uint[2];
+            var result = new uint[2];
             CastEncipher(L0, R0, result);
 
             // now stuff them into the destination block
-            UInt32ToBigEndian(result[0], outputBuffer, outputOffset);
-            UInt32ToBigEndian(result[1], outputBuffer, outputOffset + 4);
+            Pack.UInt32ToBigEndian(result[0], outputBuffer, outputOffset);
+            Pack.UInt32ToBigEndian(result[1], outputBuffer, outputOffset + 4);
 
             return BlockSize;
         }
@@ -88,15 +89,15 @@ namespace Renci.SshNet.Security.Cryptography.Ciphers
             // process the input block
             // batch the units up into a 32 bit chunk and go for it
             // the array is in bytes, the increment is 8x8 bits = 64
-            uint L16 = BigEndianToUInt32(inputBuffer, inputOffset);
-            uint R16 = BigEndianToUInt32(inputBuffer, inputOffset + 4);
+            var L16 = Pack.BigEndianToUInt32(inputBuffer, inputOffset);
+            var R16 = Pack.BigEndianToUInt32(inputBuffer, inputOffset + 4);
 
-            uint[] result = new uint[2];
+            var result = new uint[2];
             CastDecipher(L16, R16, result);
 
             // now stuff them into the destination block
-            UInt32ToBigEndian(result[0], outputBuffer, outputOffset);
-            UInt32ToBigEndian(result[1], outputBuffer, outputOffset + 4);
+            Pack.UInt32ToBigEndian(result[0], outputBuffer, outputOffset);
+            Pack.UInt32ToBigEndian(result[1], outputBuffer, outputOffset + 4);
 
             return BlockSize;
         }

src/Renci.SshNet/Security/Cryptography/Ciphers/DesCipher.cs

@@ -1,4 +1,5 @@
 using System;
+using Renci.SshNet.Common;
 
 namespace Renci.SshNet.Security.Cryptography.Ciphers
 {
@@ -13,44 +14,45 @@ namespace Renci.SshNet.Security.Cryptography.Ciphers
 
         #region Static tables
 
-        private static readonly short[] bytebit = {128, 64, 32, 16, 8, 4, 2, 1};
+        private static readonly short[] Bytebit = {128, 64, 32, 16, 8, 4, 2, 1};
 
-        private static readonly int[] bigbyte =
+        private static readonly int[] Bigbyte =
         {
-            0x800000,   0x400000,   0x200000,   0x100000,
-            0x80000,    0x40000,    0x20000,    0x10000,
-            0x8000,     0x4000,     0x2000,     0x1000,
-            0x800,      0x400,      0x200,      0x100,
-            0x80,       0x40,       0x20,       0x10,
-            0x8,        0x4,        0x2,        0x1
+            0x800000, 0x400000, 0x200000, 0x100000,
+            0x080000, 0x040000, 0x020000, 0x010000,
+            0x008000, 0x004000, 0x002000, 0x001000,
+            0x000800, 0x000400, 0x000200, 0x000100,
+            0x000080, 0x000040, 0x000020, 0x000010,
+            0x000008, 0x000004, 0x000002, 0x000001
         };
 
         /*
          * Use the key schedule specified in the Standard (ANSI X3.92-1981).
          */
-        private static readonly byte[] pc1 =
+
+        private static readonly byte[] Pc1 =
         {
-            56, 48, 40, 32, 24, 16,  8,   0, 57, 49, 41, 33, 25, 17,
-            9,  1, 58, 50, 42, 34, 26,  18, 10,  2, 59, 51, 43, 35,
-            62, 54, 46, 38, 30, 22, 14,   6, 61, 53, 45, 37, 29, 21,
-            13,  5, 60, 52, 44, 36, 28,  20, 12,  4, 27, 19, 11,  3
+            56, 48, 40, 32, 24, 16, 8, 0, 57, 49, 41, 33, 25, 17,
+            9, 1, 58, 50, 42, 34, 26, 18, 10, 2, 59, 51, 43, 35,
+            62, 54, 46, 38, 30, 22, 14, 6, 61, 53, 45, 37, 29, 21,
+            13, 5, 60, 52, 44, 36, 28, 20, 12, 4, 27, 19, 11, 3
         };
 
-        private static readonly byte[] totrot =
+        private static readonly byte[] Totrot =
         {
             1, 2, 4, 6, 8, 10, 12, 14,
             15, 17, 19, 21, 23, 25, 27, 28
         };
 
-        private static readonly byte[] pc2 =
+        private static readonly byte[] Pc2 =
         {
-            13, 16, 10, 23,  0,  4,  2, 27, 14,  5, 20,  9,
-            22, 18, 11,  3, 25,  7, 15,  6, 26, 19, 12,  1,
+            13, 16, 10, 23, 0, 4, 2, 27, 14, 5, 20, 9,
+            22, 18, 11, 3, 25, 7, 15, 6, 26, 19, 12, 1,
             40, 51, 30, 36, 46, 54, 29, 39, 50, 44, 32, 47,
             43, 48, 38, 55, 33, 52, 45, 41, 49, 35, 28, 31
         };
 
-        private static readonly uint[] SP1 =
+        private static readonly uint[] Sp1 =
         {
             0x01010400, 0x00000000, 0x00010000, 0x01010404,
             0x01010004, 0x00010404, 0x00000004, 0x00010000,
@@ -70,7 +72,7 @@ namespace Renci.SshNet.Security.Cryptography.Ciphers
             0x00010004, 0x00010400, 0x00000000, 0x01010004
         };
 
-        private static readonly uint[] SP2 =
+        private static readonly uint[] Sp2 =
         {
             0x80108020, 0x80008000, 0x00008000, 0x00108020,
             0x00100000, 0x00000020, 0x80100020, 0x80008020,
@@ -90,7 +92,7 @@ namespace Renci.SshNet.Security.Cryptography.Ciphers
             0x80000000, 0x80100020, 0x80108020, 0x00108000
         };
 
-        private static readonly uint[] SP3 =
+        private static readonly uint[] Sp3 =
         {
             0x00000208, 0x08020200, 0x00000000, 0x08020008,
             0x08000200, 0x00000000, 0x00020208, 0x08000200,
@@ -110,7 +112,7 @@ namespace Renci.SshNet.Security.Cryptography.Ciphers
             0x00020208, 0x00000008, 0x08020008, 0x00020200
         };
 
-        private static readonly uint[] SP4 =
+        private static readonly uint[] Sp4 =
         {
             0x00802001, 0x00002081, 0x00002081, 0x00000080,
             0x00802080, 0x00800081, 0x00800001, 0x00002001,
@@ -130,7 +132,7 @@ namespace Renci.SshNet.Security.Cryptography.Ciphers
             0x00000080, 0x00800000, 0x00002000, 0x00802080
         };
 
-        private static readonly uint[] SP5 =
+        private static readonly uint[] Sp5 =
         {
             0x00000100, 0x02080100, 0x02080000, 0x42000100,
             0x00080000, 0x00000100, 0x40000000, 0x02080000,
@@ -150,7 +152,7 @@ namespace Renci.SshNet.Security.Cryptography.Ciphers
             0x00000000, 0x40080000, 0x02080100, 0x40000100
         };
 
-        private static readonly uint[] SP6 =
+        private static readonly uint[] Sp6 =
         {
             0x20000010, 0x20400000, 0x00004000, 0x20404010,
             0x20400000, 0x00000010, 0x20404010, 0x00400000,
@@ -170,7 +172,7 @@ namespace Renci.SshNet.Security.Cryptography.Ciphers
             0x20404000, 0x20000000, 0x00400010, 0x20004010
         };
 
-        private static readonly uint[] SP7 =
+        private static readonly uint[] Sp7 =
         {
             0x00200000, 0x04200002, 0x04000802, 0x00000000,
             0x00000800, 0x04000802, 0x00200802, 0x04200800,
@@ -190,7 +192,7 @@ namespace Renci.SshNet.Security.Cryptography.Ciphers
             0x04000002, 0x04000800, 0x00000800, 0x00200002
         };
 
-        private static readonly uint[] SP8 =
+        private static readonly uint[] Sp8 =
         {
             0x10001040, 0x00001000, 0x00040000, 0x10041040,
             0x10000000, 0x10001040, 0x00000040, 0x10000000,
@@ -298,9 +300,9 @@ namespace Renci.SshNet.Security.Cryptography.Ciphers
 
             for (int j = 0; j < 56; j++)
             {
-                int l = pc1[j];
+                int l = Pc1[j];
 
-                pc1m[j] = ((key[(uint)l >> 3] & bytebit[l & 07]) != 0);
+                pc1m[j] = ((key[(uint)l >> 3] & Bytebit[l & 07]) != 0);
             }
 
             for (int i = 0; i < 16; i++)
@@ -321,7 +323,7 @@ namespace Renci.SshNet.Security.Cryptography.Ciphers
 
                 for (int j = 0; j < 28; j++)
                 {
-                    l = j + totrot[i];
+                    l = j + Totrot[i];
                     if (l < 28)
                     {
                         pcr[j] = pc1m[l];
@@ -334,7 +336,7 @@ namespace Renci.SshNet.Security.Cryptography.Ciphers
 
                 for (int j = 28; j < 56; j++)
                 {
-                    l = j + totrot[i];
+                    l = j + Totrot[i];
                     if (l < 56)
                     {
                         pcr[j] = pc1m[l];
@@ -347,14 +349,14 @@ namespace Renci.SshNet.Security.Cryptography.Ciphers
 
                 for (int j = 0; j < 24; j++)
                 {
-                    if (pcr[pc2[j]])
+                    if (pcr[Pc2[j]])
                     {
-                        newKey[m] |= bigbyte[j];
+                        newKey[m] |= Bigbyte[j];
                     }
 
-                    if (pcr[pc2[j + 24]])
+                    if (pcr[Pc2[j + 24]])
                     {
-                        newKey[n] |= bigbyte[j];
+                        newKey[n] |= Bigbyte[j];
                     }
                 }
             }
@@ -367,15 +369,15 @@ namespace Renci.SshNet.Security.Cryptography.Ciphers
                 var i1 = newKey[i];
                 var i2 = newKey[i + 1];
 
-                newKey[i] = (int)((uint)((i1 & 0x00fc0000) << 6) |
-                                    (uint)((i1 & 0x00000fc0) << 10) |
-                                    ((uint)(i2 & 0x00fc0000) >> 10) |
-                                    ((uint)(i2 & 0x00000fc0) >> 6));
+                newKey[i] = (int) ((uint) ((i1 & 0x00fc0000) << 6) |
+                                   (uint) ((i1 & 0x00000fc0) << 10) |
+                                   ((uint) (i2 & 0x00fc0000) >> 10) |
+                                   ((uint) (i2 & 0x00000fc0) >> 6));
 
-                newKey[i + 1] = (int)((uint)((i1 & 0x0003f000) << 12) |
-                                      (uint)((i1 & 0x0000003f) << 16) |
-                                      ((uint)(i2 & 0x0003f000) >> 4) |
-                                       (uint)(i2 & 0x0000003f));
+                newKey[i + 1] = (int) ((uint) ((i1 & 0x0003f000) << 12) |
+                                       (uint) ((i1 & 0x0000003f) << 16) |
+                                       ((uint) (i2 & 0x0003f000) >> 4) |
+                                       (uint) (i2 & 0x0000003f));
             }
 
             return newKey;
@@ -402,8 +404,8 @@ namespace Renci.SshNet.Security.Cryptography.Ciphers
         /// <param name="outOff">The out off.</param>
         protected static void DesFunc(int[] wKey, byte[] input, int inOff, byte[] outBytes, int outOff)
         {
-            uint left = BigEndianToUInt32(input, inOff);
-            uint right = BigEndianToUInt32(input, inOff + 4);
+            var left = Pack.BigEndianToUInt32(input, inOff);
+            var right = Pack.BigEndianToUInt32(input, inOff + 4);
 
             var work = ((left >> 4) ^ right) & 0x0f0f0f0f;
             right ^= work;
@@ -423,31 +425,31 @@ namespace Renci.SshNet.Security.Cryptography.Ciphers
             right ^= work;
             left = (left << 1) | (left >> 31);
 
-            for (int round = 0; round < 8; round++)
+            for (var round = 0; round < 8; round++)
             {
                 work = (right << 28) | (right >> 4);
                 work ^= (uint)wKey[round * 4 + 0];
-                var fval = SP7[work & 0x3f];
-                fval |= SP5[(work >> 8) & 0x3f];
-                fval |= SP3[(work >> 16) & 0x3f];
-                fval |= SP1[(work >> 24) & 0x3f];
-                work = right ^ (uint)wKey[round * 4 + 1];
-                fval |= SP8[work & 0x3f];
-                fval |= SP6[(work >> 8) & 0x3f];
-                fval |= SP4[(work >> 16) & 0x3f];
-                fval |= SP2[(work >> 24) & 0x3f];
+                var fval = Sp7[work & 0x3f];
+                fval |= Sp5[(work >> 8) & 0x3f];
+                fval |= Sp3[(work >> 16) & 0x3f];
+                fval |= Sp1[(work >> 24) & 0x3f];
+                work = right ^ (uint) wKey[round * 4 + 1];
+                fval |= Sp8[work & 0x3f];
+                fval |= Sp6[(work >> 8) & 0x3f];
+                fval |= Sp4[(work >> 16) & 0x3f];
+                fval |= Sp2[(work >> 24) & 0x3f];
                 left ^= fval;
                 work = (left << 28) | (left >> 4);
                 work ^= (uint)wKey[round * 4 + 2];
-                fval = SP7[work & 0x3f];
-                fval |= SP5[(work >> 8) & 0x3f];
-                fval |= SP3[(work >> 16) & 0x3f];
-                fval |= SP1[(work >> 24) & 0x3f];
+                fval = Sp7[work & 0x3f];
+                fval |= Sp5[(work >> 8) & 0x3f];
+                fval |= Sp3[(work >> 16) & 0x3f];
+                fval |= Sp1[(work >> 24) & 0x3f];
                 work = left ^ (uint)wKey[round * 4 + 3];
-                fval |= SP8[work & 0x3f];
-                fval |= SP6[(work >> 8) & 0x3f];
-                fval |= SP4[(work >> 16) & 0x3f];
-                fval |= SP2[(work >> 24) & 0x3f];
+                fval |= Sp8[work & 0x3f];
+                fval |= Sp6[(work >> 8) & 0x3f];
+                fval |= Sp4[(work >> 16) & 0x3f];
+                fval |= Sp2[(work >> 24) & 0x3f];
                 right ^= fval;
             }
 
@@ -469,8 +471,8 @@ namespace Renci.SshNet.Security.Cryptography.Ciphers
             left ^= work;
             right ^= (work << 4);
 
-            UInt32ToBigEndian(right, outBytes, outOff);
-            UInt32ToBigEndian(left, outBytes, outOff + 4);
+            Pack.UInt32ToBigEndian(right, outBytes, outOff);
+            Pack.UInt32ToBigEndian(left, outBytes, outOff + 4);
         }
     }
 }

src/Renci.SshNet/Security/KeyExchangeDiffieHellman.cs

@@ -65,7 +65,7 @@ namespace Renci.SshNet.Security
         {
             var exchangeHash = CalculateHash();
 
-            var length = (uint) (_hostKey[0] << 24 | _hostKey[1] << 16 | _hostKey[2] << 8 | _hostKey[3]);
+            var length = Pack.BigEndianToUInt32(_hostKey);
             var algorithmName = Encoding.UTF8.GetString(_hostKey, 4, (int)length);
             var key = Session.ConnectionInfo.HostKeyAlgorithms[algorithmName](_hostKey);
 

src/Renci.SshNet/Session.cs

@@ -858,7 +858,7 @@ namespace Renci.SshNet
                 if (_clientMac != null)
                 {
                     // write outbound packet sequence to start of packet data
-                    _outboundPacketSequence.Write(packetData, 0);
+                    Pack.UInt32ToBigEndian(_outboundPacketSequence, packetData);
                     //  calculate packet hash
                     hash = _clientMac.ComputeHash(packetData);
                 }
@@ -1003,7 +1003,7 @@ namespace Renci.SshNet
                     firstBlock = _serverCipher.Decrypt(firstBlock);
                 }
 
-                packetLength = (uint) (firstBlock[0] << 24 | firstBlock[1] << 16 | firstBlock[2] << 8 | firstBlock[3]);
+                packetLength = Pack.BigEndianToUInt32(firstBlock);
 
                 // Test packet minimum and maximum boundaries
                 if (packetLength < Math.Max((byte) 16, blockSize) - 4 || packetLength > MaximumSshPacketSize - 4)
@@ -1027,7 +1027,7 @@ namespace Renci.SshNet
                 // byte[] for the purpose of calculating the client hash. Room for the server MAC is foreseen
                 // to read the packet including server MAC in a single pass (except for the initial block).
                 data = new byte[bytesToRead + blockSize + inboundPacketSequenceLength];
-                _inboundPacketSequence.Write(data, 0);
+                Pack.UInt32ToBigEndian(_inboundPacketSequence, data);
                 Buffer.BlockCopy(firstBlock, 0, data, inboundPacketSequenceLength, firstBlock.Length);
 
                 if (bytesToRead > 0)