Encode() public method

public Encode ( bool unicode ) : byte[]
unicode bool
return byte[]
Beispiel #1
0
        public override byte[] Encode()
        {
            int targetNameOffset = 40;
            int targetInfoOffset = 48;

            byte[] targetName = null;
            int    size       = 40;

            if (TargetName != null)
            {
                var encoding = (Flags & NtlmFlags.NegotiateUnicode) != 0 ? Encoding.Unicode : Encoding.UTF8;

                targetName        = encoding.GetBytes(TargetName);
                targetInfoOffset += targetName.Length;
                size             += targetName.Length;
            }

            if (TargetInfo != null || targetInfo != null)
            {
                if (targetInfo == null)
                {
                    targetInfo = TargetInfo.Encode((Flags & NtlmFlags.NegotiateUnicode) != 0);
                }
                size             += targetInfo.Length + 8;
                targetNameOffset += 8;
            }

            var data = PrepareMessage(size);

            // message length
            short length = (short)data.Length;

            data[16] = (byte)length;
            data[17] = (byte)(length >> 8);

            // flags
            data[20] = (byte)Flags;
            data[21] = (byte)((uint)Flags >> 8);
            data[22] = (byte)((uint)Flags >> 16);
            data[23] = (byte)((uint)Flags >> 24);

            Buffer.BlockCopy(nonce, 0, data, 24, nonce.Length);

            if (targetName != null)
            {
                data[12] = (byte)targetName.Length;
                data[13] = (byte)(targetName.Length >> 8);
                data[14] = (byte)targetName.Length;
                data[15] = (byte)(targetName.Length >> 8);
                data[16] = (byte)targetNameOffset;
                data[17] = (byte)(targetNameOffset >> 8);

                Buffer.BlockCopy(targetName, 0, data, targetNameOffset, targetName.Length);
            }

            if (targetInfo != null)
            {
                data[40] = (byte)targetInfo.Length;
                data[41] = (byte)(targetInfo.Length >> 8);
                data[42] = (byte)targetInfo.Length;
                data[43] = (byte)(targetInfo.Length >> 8);
                data[44] = (byte)targetInfoOffset;
                data[45] = (byte)(targetInfoOffset >> 8);

                Buffer.BlockCopy(targetInfo, 0, data, targetInfoOffset, targetInfo.Length);
            }

            return(data);
        }
		public void TestNtlmTargetInfoEncode ()
		{
			var now = DateTime.Now.Ticks;

			var targetInfo = new TargetInfo {
				DomainName = "DOMAIN",
				ServerName = "SERVER",
				DnsDomainName = "domain.com",
				DnsServerName = "server.domain.com",
				Timestamp = now,
			};

			var encoded = targetInfo.Encode (true);
			var decoded = new TargetInfo (encoded, 0, encoded.Length, true);

			Assert.AreEqual (targetInfo.DnsDomainName, decoded.DnsDomainName, "DnsDomainName does not match.");
			Assert.AreEqual (targetInfo.DnsServerName, decoded.DnsServerName, "DnsServerName does not match.");
			Assert.AreEqual (targetInfo.DomainName, decoded.DomainName, "DomainName does not match.");
			Assert.AreEqual (targetInfo.ServerName, decoded.ServerName, "ServerName does not match.");
			Assert.AreEqual (targetInfo.Timestamp, decoded.Timestamp, "Timestamp does not match.");
		}
Beispiel #3
0
        public override byte[] Encode()
        {
            int targetNameOffset = 40;
            int targetInfoOffset = 48;

            byte[] targetName = null;
            bool   negotiateVersion;
            int    size = 40;

            if (negotiateVersion = (Flags & NtlmFlags.NegotiateVersion) != 0)
            {
                targetNameOffset += 16;
                targetInfoOffset += 16;
                size             += 16;
            }

            if (TargetName != null)
            {
                var encoding = (Flags & NtlmFlags.NegotiateUnicode) != 0 ? Encoding.Unicode : Encoding.UTF8;

                targetName        = encoding.GetBytes(TargetName);
                targetInfoOffset += targetName.Length;
                size             += targetName.Length;
            }

            if (TargetInfo != null || targetInfo != null)
            {
                if (targetInfo == null)
                {
                    targetInfo = TargetInfo.Encode((Flags & NtlmFlags.NegotiateUnicode) != 0);
                }
                size             += targetInfo.Length + 8;
                targetNameOffset += 8;
            }

            var message = PrepareMessage(size);

            // message length
            message[16] = (byte)size;
            message[17] = (byte)(size >> 8);

            // flags
            message[20] = (byte)Flags;
            message[21] = (byte)((uint)Flags >> 8);
            message[22] = (byte)((uint)Flags >> 16);
            message[23] = (byte)((uint)Flags >> 24);

            Buffer.BlockCopy(nonce, 0, message, 24, nonce.Length);

            if (targetName != null)
            {
                message[12] = (byte)targetName.Length;
                message[13] = (byte)(targetName.Length >> 8);
                message[14] = (byte)targetName.Length;
                message[15] = (byte)(targetName.Length >> 8);
                message[16] = (byte)targetNameOffset;
                message[17] = (byte)(targetNameOffset >> 8);

                Buffer.BlockCopy(targetName, 0, message, targetNameOffset, targetName.Length);
            }

            if (targetInfo != null)
            {
                message[40] = (byte)targetInfo.Length;
                message[41] = (byte)(targetInfo.Length >> 8);
                message[42] = (byte)targetInfo.Length;
                message[43] = (byte)(targetInfo.Length >> 8);
                message[44] = (byte)targetInfoOffset;
                message[45] = (byte)(targetInfoOffset >> 8);

                Buffer.BlockCopy(targetInfo, 0, message, targetInfoOffset, targetInfo.Length);
            }

            if (negotiateVersion)
            {
                message[48] = (byte)OSVersion.Major;
                message[49] = (byte)OSVersion.Minor;
                message[50] = (byte)OSVersion.Build;
                message[51] = (byte)(OSVersion.Build >> 8);
                message[52] = 0x00;
                message[53] = 0x00;
                message[54] = 0x00;
                message[55] = 0x0f;
            }

            return(message);
        }