Group all packing methods in Pack class, and add corresponding unit tests.

src/Renci.SshNet.Tests/Classes/Common/PackTest.cs

@@ -0,0 +1,186 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Renci.SshNet.Common;
+
+namespace Renci.SshNet.Tests.Classes.Common
+{
+    [TestClass]
+    public class PackTest
+    {
+        [TestMethod]
+        public void BigEndianToUInt16()
+        {
+            Assert.AreEqual(0, Pack.BigEndianToUInt16(new byte[] {0, 0}));
+            Assert.AreEqual(1, Pack.BigEndianToUInt16(new byte[] {0, 1}));
+            Assert.AreEqual(256, Pack.BigEndianToUInt16(new byte[] {1, 0}));
+            Assert.AreEqual(257, Pack.BigEndianToUInt16(new byte[] {1, 1}));
+            Assert.AreEqual(1025, Pack.BigEndianToUInt16(new byte[] {4, 1}));
+            Assert.AreEqual(ushort.MaxValue, Pack.BigEndianToUInt16(new byte[] {255, 255}));
+        }
+
+        [TestMethod]
+        public void BigEndianToUInt32()
+        {
+            Assert.AreEqual(0U, Pack.BigEndianToUInt32(new byte[] {0, 0, 0, 0}));
+            Assert.AreEqual(1U, Pack.BigEndianToUInt32(new byte[] {0, 0, 0, 1}));
+            Assert.AreEqual(256U, Pack.BigEndianToUInt32(new byte[] {0, 0, 1, 0}));
+            Assert.AreEqual(257U, Pack.BigEndianToUInt32(new byte[] {0, 0, 1, 1}));
+            Assert.AreEqual(1025U, Pack.BigEndianToUInt32(new byte[] {0, 0, 4, 1}));
+            Assert.AreEqual(65536U, Pack.BigEndianToUInt32(new byte[] {0, 1, 0, 0}));
+            Assert.AreEqual(133124U, Pack.BigEndianToUInt32(new byte[] {0, 2, 8, 4}));
+            Assert.AreEqual(16777216U, Pack.BigEndianToUInt32(new byte[] {1, 0, 0, 0}));
+            Assert.AreEqual(uint.MaxValue, Pack.BigEndianToUInt32(new byte[] {255, 255, 255, 255}));
+        }
+
+        [TestMethod]
+        public void BigEndianToUInt64()
+        {
+            Assert.AreEqual(0UL, Pack.BigEndianToUInt64(new byte[] {0, 0, 0, 0, 0, 0, 0, 0}));
+            Assert.AreEqual(1UL, Pack.BigEndianToUInt64(new byte[] {0, 0, 0, 0, 0, 0, 0, 1}));
+            Assert.AreEqual(256UL, Pack.BigEndianToUInt64(new byte[] {0, 0, 0, 0, 0, 0, 1, 0}));
+            Assert.AreEqual(257UL, Pack.BigEndianToUInt64(new byte[] {0, 0, 0, 0, 0, 0, 1, 1}));
+            Assert.AreEqual(65536UL, Pack.BigEndianToUInt64(new byte[] {0, 0, 0, 0, 0, 1, 0, 0}));
+            Assert.AreEqual(133124UL, Pack.BigEndianToUInt64(new byte[] {0, 0, 0, 0, 0, 2, 8, 4}));
+            Assert.AreEqual(16777216UL, Pack.BigEndianToUInt64(new byte[] {0, 0, 0, 0, 1, 0, 0, 0}));
+            Assert.AreEqual(4294967296UL, Pack.BigEndianToUInt64(new byte[] {0, 0, 0, 1, 0, 0, 0, 0}));
+            Assert.AreEqual(1099511627776UL, Pack.BigEndianToUInt64(new byte[] {0, 0, 1, 0, 0, 0, 0, 0}));
+            Assert.AreEqual(1099511892096UL, Pack.BigEndianToUInt64(new byte[] {0, 0, 1, 0, 0, 4, 8, 128}));
+            Assert.AreEqual(1099511627776UL * 256, Pack.BigEndianToUInt64(new byte[] {0, 1, 0, 0, 0, 0, 0, 0}));
+            Assert.AreEqual(1099511627776UL * 256 * 256, Pack.BigEndianToUInt64(new byte[] {1, 0, 0, 0, 0, 0, 0, 0}));
+            Assert.AreEqual(ulong.MaxValue, Pack.BigEndianToUInt64(new byte[] {255, 255, 255, 255, 255, 255, 255, 255}));
+        }
+
+        [TestMethod]
+        public void LittleEndianToUInt16()
+        {
+            Assert.AreEqual((ushort) 0, Pack.LittleEndianToUInt16(new byte[] {0, 0}));
+            Assert.AreEqual((ushort) 1, Pack.LittleEndianToUInt16(new byte[] {1, 0}));
+            Assert.AreEqual((ushort) 256, Pack.LittleEndianToUInt16(new byte[] {0, 1}));
+            Assert.AreEqual((ushort) 257, Pack.LittleEndianToUInt16(new byte[] {1, 1}));
+            Assert.AreEqual((ushort) 1025, Pack.LittleEndianToUInt16(new byte[] {1, 4}));
+            Assert.AreEqual(ushort.MaxValue, Pack.LittleEndianToUInt16(new byte[] {255, 255}));
+        }
+
+        [TestMethod]
+        public void LittleEndianToUInt32()
+        {
+            Assert.AreEqual(0U, Pack.LittleEndianToUInt32(new byte[] {0, 0, 0, 0}));
+            Assert.AreEqual(1U, Pack.LittleEndianToUInt32(new byte[] {1, 0, 0, 0}));
+            Assert.AreEqual(256U, Pack.LittleEndianToUInt32(new byte[] {0, 1, 0, 0}));
+            Assert.AreEqual(257U, Pack.LittleEndianToUInt32(new byte[] {1, 1, 0, 0}));
+            Assert.AreEqual(1025U, Pack.LittleEndianToUInt32(new byte[] {1, 4, 0, 0}));
+            Assert.AreEqual(65536U, Pack.LittleEndianToUInt32(new byte[] {0, 0, 1, 0}));
+            Assert.AreEqual(133124U, Pack.LittleEndianToUInt32(new byte[] {4, 8, 2, 0}));
+            Assert.AreEqual(16777216U, Pack.LittleEndianToUInt32(new byte[] {0, 0, 0, 1}));
+            Assert.AreEqual(uint.MaxValue, Pack.LittleEndianToUInt32(new byte[] {255, 255, 255, 255}));
+        }
+
+        [TestMethod]
+        public void LittleEndianToUInt64()
+        {
+            Assert.AreEqual(0UL, Pack.LittleEndianToUInt64(new byte[] {0, 0, 0, 0, 0, 0, 0, 0}));
+            Assert.AreEqual(1UL, Pack.LittleEndianToUInt64(new byte[] {1, 0, 0, 0, 0, 0, 0, 0}));
+            Assert.AreEqual(256UL, Pack.LittleEndianToUInt64(new byte[] {0, 1, 0, 0, 0, 0, 0, 0}));
+            Assert.AreEqual(257UL, Pack.LittleEndianToUInt64(new byte[] {1, 1, 0, 0, 0, 0, 0, 0}));
+            Assert.AreEqual(65536UL, Pack.LittleEndianToUInt64(new byte[] {0, 0, 1, 0, 0, 0, 0, 0}));
+            Assert.AreEqual(133124UL, Pack.LittleEndianToUInt64(new byte[] {4, 8, 2, 0, 0, 0, 0, 0}));
+            Assert.AreEqual(16777216UL, Pack.LittleEndianToUInt64(new byte[] {0, 0, 0, 1, 0, 0, 0, 0}));
+            Assert.AreEqual(4294967296UL, Pack.LittleEndianToUInt64(new byte[] {0, 0, 0, 0, 1, 0, 0, 0}));
+            Assert.AreEqual(1099511627776UL, Pack.LittleEndianToUInt64(new byte[] {0, 0, 0, 0, 0, 1, 0, 0}));
+            Assert.AreEqual(1099511892096UL, Pack.LittleEndianToUInt64(new byte[] {128, 8, 4, 0, 0, 1, 0, 0}));
+            Assert.AreEqual(1099511627776UL * 256, Pack.LittleEndianToUInt64(new byte[] {0, 0, 0, 0, 0, 0, 1, 0}));
+            Assert.AreEqual(1099511627776UL * 256 * 256, Pack.LittleEndianToUInt64(new byte[] {0, 0, 0, 0, 0, 0, 0, 1}));
+            Assert.AreEqual(ulong.MaxValue, Pack.LittleEndianToUInt64(new byte[] {255, 255, 255, 255, 255, 255, 255, 255}));
+        }
+
+        [TestMethod]
+        public void UInt16ToLittleEndian()
+        {
+            AssertEqual(new byte[] {0, 0}, Pack.UInt16ToLittleEndian(0));
+            AssertEqual(new byte[] {1, 0}, Pack.UInt16ToLittleEndian(1));
+            AssertEqual(new byte[] {0, 1}, Pack.UInt16ToLittleEndian(256));
+            AssertEqual(new byte[] {1, 1}, Pack.UInt16ToLittleEndian(257));
+            AssertEqual(new byte[] {1, 4}, Pack.UInt16ToLittleEndian(1025));
+            AssertEqual(new byte[] {255, 255}, Pack.UInt16ToLittleEndian(ushort.MaxValue));
+        }
+
+        [TestMethod]
+        public void UInt32ToLittleEndian()
+        {
+            AssertEqual(new byte[] {0, 0, 0, 0}, Pack.UInt32ToLittleEndian(0));
+            AssertEqual(new byte[] {1, 0, 0, 0}, Pack.UInt32ToLittleEndian(1));
+            AssertEqual(new byte[] {0, 1, 0, 0}, Pack.UInt32ToLittleEndian(256));
+            AssertEqual(new byte[] {1, 1, 0, 0}, Pack.UInt32ToLittleEndian(257));
+            AssertEqual(new byte[] {1, 4, 0, 0}, Pack.UInt32ToLittleEndian(1025));
+            AssertEqual(new byte[] {0, 0, 1, 0}, Pack.UInt32ToLittleEndian(65536));
+            AssertEqual(new byte[] {4, 8, 2, 0}, Pack.UInt32ToLittleEndian(133124));
+            AssertEqual(new byte[] {0, 0, 0, 1}, Pack.UInt32ToLittleEndian(16777216));
+            AssertEqual(new byte[] {255, 255, 255, 255}, Pack.UInt32ToLittleEndian(uint.MaxValue));
+        }
+
+        [TestMethod]
+        public void UInt64ToLittleEndian()
+        {
+            AssertEqual(new byte[] {0, 0, 0, 0, 0, 0, 0, 0}, Pack.UInt64ToLittleEndian(0UL));
+            AssertEqual(new byte[] {1, 0, 0, 0, 0, 0, 0, 0}, Pack.UInt64ToLittleEndian(1UL));
+            AssertEqual(new byte[] {0, 1, 0, 0, 0, 0, 0, 0}, Pack.UInt64ToLittleEndian(256UL));
+            AssertEqual(new byte[] {1, 1, 0, 0, 0, 0, 0, 0}, Pack.UInt64ToLittleEndian(257UL));
+            AssertEqual(new byte[] {0, 0, 1, 0, 0, 0, 0, 0}, Pack.UInt64ToLittleEndian(65536UL));
+            AssertEqual(new byte[] {4, 8, 2, 0, 0, 0, 0, 0}, Pack.UInt64ToLittleEndian(133124UL));
+            AssertEqual(new byte[] {0, 0, 0, 1, 0, 0, 0, 0}, Pack.UInt64ToLittleEndian(16777216UL));
+            AssertEqual(new byte[] {0, 0, 0, 0, 1, 0, 0, 0}, Pack.UInt64ToLittleEndian(4294967296UL));
+            AssertEqual(new byte[] {0, 0, 0, 0, 0, 1, 0, 0}, Pack.UInt64ToLittleEndian(1099511627776UL));
+            AssertEqual(new byte[] {128, 8, 4, 0, 0, 1, 0, 0}, Pack.UInt64ToLittleEndian(1099511892096UL));
+            AssertEqual(new byte[] {0, 0, 0, 0, 0, 0, 1, 0}, Pack.UInt64ToLittleEndian(1099511627776UL * 256));
+            AssertEqual(new byte[] {0, 0, 0, 0, 0, 0, 0, 1}, Pack.UInt64ToLittleEndian(1099511627776UL * 256 * 256));
+            AssertEqual(new byte[] {255, 255, 255, 255, 255, 255, 255, 255}, Pack.UInt64ToLittleEndian(ulong.MaxValue));
+        }
+
+        [TestMethod]
+        public void UInt16ToBigEndian()
+        {
+            AssertEqual(new byte[] {0, 0}, Pack.UInt16ToBigEndian(0));
+            AssertEqual(new byte[] {0, 1}, Pack.UInt16ToBigEndian(1));
+            AssertEqual(new byte[] {1, 0}, Pack.UInt16ToBigEndian(256));
+            AssertEqual(new byte[] {1, 1}, Pack.UInt16ToBigEndian(257));
+            AssertEqual(new byte[] {4, 1}, Pack.UInt16ToBigEndian(1025));
+            AssertEqual(new byte[] {255, 255}, Pack.UInt16ToBigEndian(ushort.MaxValue));
+        }
+
+        [TestMethod]
+        public void UInt32ToBigEndian()
+        {
+            AssertEqual(new byte[] {0, 0, 0, 0}, Pack.UInt32ToBigEndian(0));
+            AssertEqual(new byte[] {0, 0, 0, 1}, Pack.UInt32ToBigEndian(1));
+            AssertEqual(new byte[] {0, 0, 1, 0}, Pack.UInt32ToBigEndian(256));
+            AssertEqual(new byte[] {0, 0, 1, 1}, Pack.UInt32ToBigEndian(257));
+            AssertEqual(new byte[] {0, 0, 4, 1}, Pack.UInt32ToBigEndian(1025));
+            AssertEqual(new byte[] {0, 1, 0, 0}, Pack.UInt32ToBigEndian(65536));
+            AssertEqual(new byte[] {0, 2, 8, 4}, Pack.UInt32ToBigEndian(133124));
+            AssertEqual(new byte[] {1, 0, 0, 0}, Pack.UInt32ToBigEndian(16777216));
+            AssertEqual(new byte[] {255, 255, 255, 255}, Pack.UInt32ToBigEndian(uint.MaxValue));
+        }
+
+        [TestMethod]
+        public void UInt64ToBigEndian()
+        {
+            AssertEqual(new byte[] {0, 0, 0, 0, 0, 0, 0, 0}, Pack.UInt64ToBigEndian(0UL));
+            AssertEqual(new byte[] {0, 0, 0, 0, 0, 0, 0, 1}, Pack.UInt64ToBigEndian(1UL));
+            AssertEqual(new byte[] {0, 0, 0, 0, 0, 0, 1, 0}, Pack.UInt64ToBigEndian(256UL));
+            AssertEqual(new byte[] {0, 0, 0, 0, 0, 0, 1, 1}, Pack.UInt64ToBigEndian(257UL));
+            AssertEqual(new byte[] {0, 0, 0, 0, 0, 1, 0, 0}, Pack.UInt64ToBigEndian(65536UL));
+            AssertEqual(new byte[] {0, 0, 0, 0, 0, 2, 8, 4}, Pack.UInt64ToBigEndian(133124UL));
+            AssertEqual(new byte[] {0, 0, 0, 0, 1, 0, 0, 0}, Pack.UInt64ToBigEndian(16777216UL));
+            AssertEqual(new byte[] {0, 0, 0, 1, 0, 0, 0, 0}, Pack.UInt64ToBigEndian(4294967296UL));
+            AssertEqual(new byte[] {0, 0, 1, 0, 0, 0, 0, 0}, Pack.UInt64ToBigEndian(1099511627776UL));
+            AssertEqual(new byte[] {0, 0, 1, 0, 0, 4, 8, 128}, Pack.UInt64ToBigEndian(1099511892096UL));
+            AssertEqual(new byte[] {0, 1, 0, 0, 0, 0, 0, 0}, Pack.UInt64ToBigEndian(1099511627776UL * 256));
+            AssertEqual(new byte[] {1, 0, 0, 0, 0, 0, 0, 0}, Pack.UInt64ToBigEndian(1099511627776UL * 256 * 256));
+            AssertEqual(new byte[] {255, 255, 255, 255, 255, 255, 255, 255}, Pack.UInt64ToBigEndian(ulong.MaxValue));
+        }
+
+        private static void AssertEqual(byte[] expected, byte[] actual)
+        {
+            Assert.IsTrue(expected.IsEqualTo(actual));
+        }
+    }
+}

src/Renci.SshNet.Tests/Renci.SshNet.Tests.csproj

@@ -148,6 +148,7 @@
     <Compile Include="Classes\Common\ExtensionsTest_Take_Count.cs" />
     <Compile Include="Classes\Common\ExtensionsTest_Take_OffsetAndCount.cs" />
     <Compile Include="Classes\Common\ExtensionsTest_TrimLeadingZeros.cs" />
+    <Compile Include="Classes\Common\PackTest.cs" />
     <Compile Include="Classes\ConnectionInfoTest_Authenticate_Failure.cs" />
     <Compile Include="Classes\ConnectionInfoTest_Authenticate_Success.cs" />
     <Compile Include="Classes\ForwardedPortDynamicTest_Dispose_PortStarted_ChannelBound.cs" />

src/Renci.SshNet/Common/Pack.cs

@@ -0,0 +1,266 @@
+namespace Renci.SshNet.Common
+{
+    /// <summary>
+    /// Provides convenience methods for conversion to and from both Big Endian and Little Endian.
+    /// </summary>
+    internal static class Pack
+    {
+        /// <summary>
+        /// Converts little endian bytes into number.
+        /// </summary>
+        /// <param name="buffer">The buffer.</param>
+        /// <returns>Converted <see cref="ushort" />.</returns>
+        internal static ushort LittleEndianToUInt16(byte[] buffer)
+        {
+            ushort n = buffer[0];
+            n |= (ushort) (buffer[1] << 8);
+            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="uint" />.</returns>
+        internal static uint LittleEndianToUInt32(byte[] buffer, int offset)
+        {
+            uint n = 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="uint" />.</returns>
+        internal static uint LittleEndianToUInt32(byte[] buffer)
+        {
+            uint n = 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>
+        /// <returns>Converted <see cref="ulong" />.</returns>
+        internal static ulong LittleEndianToUInt64(byte[] buffer)
+        {
+            ulong n = buffer[0];
+            n |= (ulong) buffer[1] << 8;
+            n |= (ulong) buffer[2] << 16;
+            n |= (ulong) buffer[3] << 24;
+            n |= (ulong) buffer[4] << 32;
+            n |= (ulong) buffer[5] << 40;
+            n |= (ulong) buffer[6] << 48;
+            n |= (ulong) buffer[7] << 56;
+            return n;
+        }
+
+        /// <summary>
+        /// Populates buffer with little endian number representation.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        internal static byte[] UInt16ToLittleEndian(ushort value)
+        {
+            var buffer = new byte[2];
+            UInt16ToLittleEndian(value, buffer);
+            return buffer;
+        }
+
+        /// <summary>
+        /// Populates buffer with little endian number representation.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        /// <param name="buffer">The buffer.</param>
+        internal static void UInt16ToLittleEndian(ushort value, byte[] buffer)
+        {
+            buffer[0] = (byte) (value & 0x00FF);
+            buffer[1] = (byte) ((value & 0xFF00) >> 8);
+        }
+
+        /// <summary>
+        /// Populates buffer with little endian number representation.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        internal static byte[] UInt32ToLittleEndian(uint value)
+        {
+            var buffer = new byte[4];
+            UInt32ToLittleEndian(value, buffer);
+            return buffer;
+        }
+
+        /// <summary>
+        /// Populates buffer with little endian number representation.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        /// <param name="buffer">The buffer.</param>
+        internal static void UInt32ToLittleEndian(uint value, byte[] buffer)
+        {
+            buffer[0] = (byte) (value & 0x000000FF);
+            buffer[1] = (byte) ((value & 0x0000FF00) >> 8);
+            buffer[2] = (byte) ((value & 0x00FF0000) >> 16);
+            buffer[3] = (byte) ((value & 0xFF000000) >> 24);
+        }
+
+        /// <summary>
+        /// Populates buffer with little endian number representation.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        /// <param name="buffer">The buffer.</param>
+        /// <param name="offset">The buffer offset.</param>
+        internal static void UInt32ToLittleEndian(uint value, byte[] buffer, int offset)
+        {
+            buffer[offset] = (byte)(value & 0x000000FF);
+            buffer[offset + 1] = (byte)((value & 0x0000FF00) >> 8);
+            buffer[offset + 2] = (byte)((value & 0x00FF0000) >> 16);
+            buffer[offset + 3] = (byte)((value & 0xFF000000) >> 24);
+        }
+
+        /// <summary>
+        /// Populates buffer with little endian number representation.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        internal static byte[] UInt64ToLittleEndian(ulong value)
+        {
+            var buffer = new byte[8];
+            UInt64ToLittleEndian(value, buffer);
+            return buffer;
+        }
+
+        /// <summary>
+        /// Populates buffer with little endian number representation.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        /// <param name="buffer">The buffer.</param>
+        internal static void UInt64ToLittleEndian(ulong value, byte[] buffer)
+        {
+            buffer[0] = (byte)(value & 0x00000000000000FF);
+            buffer[1] = (byte) ((value & 0x000000000000FF00) >> 8);
+            buffer[2] = (byte) ((value & 0x0000000000FF0000) >> 16);
+            buffer[3] = (byte) ((value & 0x00000000FF000000) >> 24);
+            buffer[4] = (byte) ((value & 0x000000FF00000000) >> 32);
+            buffer[5] = (byte) ((value & 0x0000FF0000000000) >> 40);
+            buffer[6] = (byte) ((value & 0x00FF000000000000) >> 48);
+            buffer[7] = (byte) ((value & 0xFF00000000000000) >> 56);
+        }
+
+        internal static byte[] UInt16ToBigEndian(ushort value)
+        {
+            var buffer = new byte[2];
+            UInt16ToBigEndian(value, buffer);
+            return buffer;
+        }
+
+        internal static void UInt16ToBigEndian(ushort value, byte[] buffer)
+        {
+            buffer[0] = (byte) (value >> 8);
+            buffer[1] = (byte) (value & 0x00FF);
+        }
+
+        internal static void UInt16ToBigEndian(ushort value, byte[] buffer, int offset)
+        {
+            buffer[offset] = (byte) (value >> 8);
+            buffer[offset + 1] = (byte) (value & 0x00FF);
+        }
+
+        internal static void UInt32ToBigEndian(uint value, byte[] buffer)
+        {
+            buffer[0] = (byte) ((value & 0xFF000000) >> 24);
+            buffer[1] = (byte) ((value & 0x00FF0000) >> 16);
+            buffer[2] = (byte) ((value & 0x0000FF00) >> 8);
+            buffer[3] = (byte) (value & 0x000000FF);
+        }
+
+        internal static void UInt32ToBigEndian(uint value, byte[] buffer, int offset)
+        {
+            buffer[offset++] = (byte) ((value & 0xFF000000) >> 24);
+            buffer[offset++] = (byte) ((value & 0x00FF0000) >> 16);
+            buffer[offset++] = (byte) ((value & 0x0000FF00) >> 8);
+            buffer[offset] = (byte) (value & 0x000000FF);
+        }
+
+        internal static byte[] UInt32ToBigEndian(uint value)
+        {
+            var buffer = new byte[4];
+            UInt32ToBigEndian(value, buffer);
+            return buffer;
+        }
+
+        /// <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[] UInt64ToBigEndian(ulong value)
+        {
+            return new[]
+                {
+                    (byte) ((value & 0xFF00000000000000) >> 56),
+                    (byte) ((value & 0x00FF000000000000) >> 48),
+                    (byte) ((value & 0x0000FF0000000000) >> 40),
+                    (byte) ((value & 0x000000FF00000000) >> 32),
+                    (byte) ((value & 0x00000000FF000000) >> 24),
+                    (byte) ((value & 0x0000000000FF0000) >> 16),
+                    (byte) ((value & 0x000000000000FF00) >> 8),
+                    (byte) (value & 0x00000000000000FF)
+                };
+        }
+
+        /// <summary>
+        /// Converts big endian bytes into number.
+        /// </summary>
+        /// <param name="buffer">The buffer.</param>
+        /// <returns>Converted <see cref="ushort" />.</returns>
+        internal static ushort BigEndianToUInt16(byte[] buffer)
+        {
+            return (ushort) (buffer[0] << 8 | buffer[1]);
+        }
+
+        /// <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="uint" />.</returns>
+        internal static uint BigEndianToUInt32(byte[] buffer, int offset)
+        {
+            return (uint) buffer[offset + 0] << 24
+                   | (uint) buffer[offset + 1] << 16
+                   | (uint) buffer[offset + 2] << 8
+                   | buffer[offset + 3];
+        }
+
+        /// <summary>
+        /// Converts big endian bytes into number.
+        /// </summary>
+        /// <param name="buffer">The buffer.</param>
+        /// <returns>Converted <see cref="uint" />.</returns>
+        internal static uint BigEndianToUInt32(byte[] buffer)
+        {
+            return (uint) buffer[0] << 24
+                   | (uint) buffer[1] << 16
+                   | (uint) buffer[2] << 8
+                   | buffer[3];
+        }
+
+        /// <summary>
+        /// Converts big endian bytes into number.
+        /// </summary>
+        /// <param name="buffer">The buffer.</param>
+        /// <returns>Converted <see cref="ulong" />.</returns>
+        internal static ulong BigEndianToUInt64(byte[] buffer)
+        {
+            return (ulong) buffer[0] << 56 | (ulong) buffer[1] << 48 | (ulong) buffer[2] << 40 |
+                   (ulong) buffer[3] << 32 | (ulong) buffer[4] << 24 | (ulong) buffer[5] << 16 |
+                   (ulong) buffer[6] << 8 | buffer[7];
+        }
+    }
+}

src/Renci.SshNet/Renci.SshNet.csproj

@@ -96,6 +96,7 @@
     <Compile Include="Common\ChannelOpenFailedEventArgs.cs" />
     <Compile Include="Common\ChannelRequestEventArgs.cs" />
     <Compile Include="Common\CountdownEvent.cs" />
+    <Compile Include="Common\Pack.cs" />
     <Compile Include="Common\ProxyException.cs">
       <SubType>Code</SubType>
     </Compile>