jellyfin/Emby.Common.Implementations/IO/SharpCifs/Ntlmssp/NtlmMessage.cs

// This code is derived from jcifs smb client library <jcifs at samba dot org>
// Ported by J. Arturo <webmaster at komodosoft dot net>
//  
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// 
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
// 
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
using System;

namespace SharpCifs.Ntlmssp
{
	/// <summary>Abstract superclass for all NTLMSSP messages.</summary>
	/// <remarks>Abstract superclass for all NTLMSSP messages.</remarks>
	public abstract class NtlmMessage : NtlmFlags
	{
		/// <summary>The NTLMSSP "preamble".</summary>
		/// <remarks>The NTLMSSP "preamble".</remarks>
		protected internal static readonly byte[] NtlmsspSignature = { unchecked(
			(byte)('N')), unchecked((byte)('T')), unchecked((byte)('L')), 
			unchecked((byte)('M')), unchecked((byte)('S')), unchecked((byte
			    )('S')), unchecked((byte)('P')), unchecked(0) };

		private static readonly string OemEncoding = Config.DefaultOemEncoding;

		protected internal static readonly string UniEncoding = "UTF-16LE";

		private int _flags;

		/// <summary>Returns the flags currently in use for this message.</summary>
		/// <remarks>Returns the flags currently in use for this message.</remarks>
		/// <returns>
		/// An <code>int</code> containing the flags in use for this
		/// message.
		/// </returns>
		public virtual int GetFlags()
		{
			return _flags;
		}

		/// <summary>Sets the flags for this message.</summary>
		/// <remarks>Sets the flags for this message.</remarks>
		/// <param name="flags">The flags for this message.</param>
		public virtual void SetFlags(int flags)
		{
			this._flags = flags;
		}

		/// <summary>Returns the status of the specified flag.</summary>
		/// <remarks>Returns the status of the specified flag.</remarks>
		/// <param name="flag">The flag to test (i.e., <code>NTLMSSP_NEGOTIATE_OEM</code>).</param>
		/// <returns>A <code>boolean</code> indicating whether the flag is set.</returns>
		public virtual bool GetFlag(int flag)
		{
			return (GetFlags() & flag) != 0;
		}

		/// <summary>Sets or clears the specified flag.</summary>
		/// <remarks>Sets or clears the specified flag.</remarks>
		/// <param name="flag">
		/// The flag to set/clear (i.e.,
		/// <code>NTLMSSP_NEGOTIATE_OEM</code>).
		/// </param>
		/// <param name="value">
		/// Indicates whether to set (<code>true</code>) or
		/// clear (<code>false</code>) the specified flag.
		/// </param>
		public virtual void SetFlag(int flag, bool value)
		{
			SetFlags(value ? (GetFlags() | flag) : (GetFlags() & (unchecked((int)(0xffffffff)
				) ^ flag)));
		}

		internal static int ReadULong(byte[] src, int index)
		{
			return (src[index] & unchecked(0xff)) | ((src[index + 1] & unchecked(0xff)) << 8) | ((src[index + 2] & unchecked(0xff)) << 16) | ((src[index
				 + 3] & unchecked(0xff)) << 24);
		}

		internal static int ReadUShort(byte[] src, int index)
		{
			return (src[index] & unchecked(0xff)) | ((src[index + 1] & unchecked(0xff)) << 8);
		}

		internal static byte[] ReadSecurityBuffer(byte[] src, int index)
		{
			int length = ReadUShort(src, index);
			int offset = ReadULong(src, index + 4);
			byte[] buffer = new byte[length];
			Array.Copy(src, offset, buffer, 0, length);
			return buffer;
		}

		internal static void WriteULong(byte[] dest, int offset, int value)
		{
			dest[offset] = unchecked((byte)(value & unchecked(0xff)));
			dest[offset + 1] = unchecked((byte)(value >> 8 & unchecked(0xff)));
			dest[offset + 2] = unchecked((byte)(value >> 16 & unchecked(0xff)));
			dest[offset + 3] = unchecked((byte)(value >> 24 & unchecked(0xff)));
		}

		internal static void WriteUShort(byte[] dest, int offset, int value)
		{
			dest[offset] = unchecked((byte)(value & unchecked(0xff)));
            dest[offset + 1] = unchecked((byte)(value >> 8 & unchecked(0xff)));
		}

		internal static void WriteSecurityBuffer(byte[] dest, int offset, int bodyOffset, 
			byte[] src)
		{
			int length = (src != null) ? src.Length : 0;
			if (length == 0)
			{
				return;
			}
			WriteUShort(dest, offset, length);
			WriteUShort(dest, offset + 2, length);
			WriteULong(dest, offset + 4, bodyOffset);
			Array.Copy(src, 0, dest, bodyOffset, length);
		}

		internal static string GetOemEncoding()
		{
			return OemEncoding;
		}

		/// <summary>Returns the raw byte representation of this message.</summary>
		/// <remarks>Returns the raw byte representation of this message.</remarks>
		/// <returns>A <code>byte[]</code> containing the raw message material.</returns>
		public abstract byte[] ToByteArray();
	}
}