singrdk/base/Libraries/Ntlm/NtlmMessages.sg

////////////////////////////////////////////////////////////////////////////////
//
//  Microsoft Research Singularity
//
//  Copyright (c) Microsoft Corporation.  All rights reserved.
//
//  File:   NtlmMessages.cs
//
//  Note:
//
//		This file contains structures and enumerated types of the NTLM 
//		authentication protocol.
//
///////////////////////////////////////////////////////////////////////////////

using System;
using System.Runtime.InteropServices;

namespace System.Security.Protocols.Ntlm
{
    class NtlmConstants
    {
#if false
        public static readonly byte[]! MessageSignature = {
            (byte)'N',
            (byte)'T',
            (byte)'L',
            (byte)'M',
            (byte)'S',
            (byte)'S',
            (byte)'P',
            0
        };
#endif
        
        // This is the NTLM message signature, encoded as a little-endian ulong.
        public const ulong MessageSignature64Le = 
			((ulong)'N')
			| (((ulong)'T') << 8)
			| (((ulong)'L') << 0x10)
			| (((ulong)'M') << 0x18)
			| (((ulong)'S') << 0x20)
			| (((ulong)'S') << 0x28)
			| (((ulong)'P') << 0x30)
			/* 0x38 position is zero */;

        public const int HeaderLength = 0x10;

        public const int ChallengeLength = 8;

    }

    public enum NtlmMessageType
    {
        Negotiate = 1,
        Challenge = 2,
        Response = 3,
    }

	/**
		<summary>
			All NTLMSSP messages begin with this header.
		</summary>
	*/
	[StructLayout(LayoutKind.Sequential, Pack=1)]
	pointerfree struct NtlmMessageHeader
	{
		/** <summary>
			This value should always be "NTLMSSP\0", encoded as a little-endian 64-bit ulong.
			NtlmConstants.MessageSignature64Le encodes this value.
			</summary>
		*/
		public ulong Signature;
		
		/** <summary>A value from NtlmMessageType.</summary> */
		public uint MessageType;
	}
	
    /**
		<summary>
			The Negotiate message is the first message in an NTLM exchange.
			The client (supplicant) sends this message to the server, requesting a session
			and indicating what kind of options this client supports.  The OemDomainName
			and OemWorkstationName values can be provided for diagnostics and logging,
			but the server is under no obligation to trust them.
		</summary>
    */
	[StructLayout(LayoutKind.Sequential, Pack=1)]
	pointerfree struct NtlmNegotiateMessage
	{
		public NtlmMessageHeader Header;
		public uint NegotiateFlags;
		public BufferRegion OemDomainName;
		public BufferRegion OemWorkstationName;
		public ulong Version;
	}

    [Flags]
    public enum NtlmNegotiateFlags
    {
        None = 0,

		/** <summary>Text strings are in unicode</summary> */
        NegotiateUnicode = 0x00000001,
        
        /** <summary>Text strings are in OEM</summary> */
        NegotiateOem = 0x00000002,
        
        /** <summary>Server should return its authentication realm</summary> */
        RequestTarget = 0x00000004,

		/** <summary>Request signature capability</summary> */
        NegotiateSign = 0x00000010,
        
        /** <summary>Request confidentiality</summary> */
        NegotiateSeal = 0x00000020,
        
        /** <summary>Use datagram style authentication</summary> */
        NegotiateDatagram = 0x00000040,
        
        /** <summary>Use LM session key for sign/seal</summary> */
        NegotiateLmKey = 0x00000080,

		/** <summary>NetWare authentication</summary> */
        NegotiateNetware = 0x00000100,
        
        /** <summary>NTLM authentication</summary> */
        NegotiateNtlm = 0x00000200,
        
        /** <summary>NT authentication only (no LM)</summary> */
        NegotiateNtOnly = 0x00000400,
        
        /** <summary>NULL Sessions on NT 5.0 and beyond</summary> */
        NegotiateNullSession = 0x00000800,

		/** <summary>Domain Name supplied on negotiate</summary> */
        NegotiateOemDomainSupplied = 0x1000,
        
        /** <summary>Workstation Name supplied on negotiate</summary> */
        NegotiateOemWorkstationSupplied = 0x2000,
        
        /** <summary>Indicates client/server are same machine</summary> */
        NegotiateLocalCall = 0x00004000,
        
        /** <summary>Sign for all security levels</summary> */
        NegotiateAlwaysSign = 0x00008000,
    }

	/**
	<summary>
		<para>
			Describes the header for the NTLM "Challenge" message.  This message is also known as an
			NTLM "Type 3" message.  This message is sent from a server (authenticator) to a client 
			(supplicant).  The server generates a random 8-byte challenge (nonce).
		</para>
	</summary>
	*/
	[StructLayout(LayoutKind.Sequential, Pack=1)]
	pointerfree struct NtlmChallengeMessage
	{
		public NtlmMessageHeader Header;
		
		/**
		<summary>
			The domain name (realm name) of the server.  This value may or may not be present.
			If the NtlmNegotiateFlag.RequestTarget flag is set in the Negotiate message, then 
			the client requests this field, but the server is not obligated to send this value.
		</summary>
		*/
		public BufferRegion TargetName;

		/** <summary>The set of negotiation flags that the server has agreed to.</summary> */
		public uint NegotiateFlags;
		
		/** <summary>The 8-byte challenge, encoded as a 64-bit integer.</summary> */
		public ulong PackedChallenge;
		
		// The contents of the TargetName follow.
	}	


	/**
	<summary>
		<para>
			This structure describes the header for the NTLM "Response" message, also known as the NTLM
			"Type 3" message.  This message is sent from the client (supplicant) to the server (authenticator),
			and is the last message in the exchange.  This message proves that the client has valid credentials.
		</para>
	</summary>
	*/	
	[StructLayout(LayoutKind.Sequential, Pack=1)]
	pointerfree struct NtlmResponseMessage
	{
		public NtlmMessageHeader Header;
		
		/** <summary>Describes the size and location of the LAN Manager response.</summary> */
		public BufferRegion LmChallengeResponse;
		
		/** <summary>Describes the size and location of the NT response.</summary> */
		public BufferRegion NtChallengeResponse;
		
		/** <summary>Describes the size and location of the domain name of the authenticating user.</summary> */
		public BufferRegion DomainName;
		
		/** <summary>Describes the size and location of the username of the authenticating user.</summary> */
		public BufferRegion UserName;
		
		/** <summary>Describes the size and location of the workstation name (computer name) of the client's computer.</summary> */
		public BufferRegion Workstation;		
		
		// The contents of the many BufferRegion fields follow.
	}

	/**
	<summary>
		<para>
			Identifies a region within a buffer.  This structure is compatible with the STRING32 structure
			used by NT, which is used to describe the offset and length of variable-length strings that are
			stored after a fixed-length message header.
		</para>
		
		<para>			
			NTLM uses this structure to describe the size and location variable-length strings in NTLMSSP messages.
		</para>
	</summary>
	*/
	[StructLayout(LayoutKind.Sequential, Pack=1)]
	pointerfree struct BufferRegion
	{
		public ushort Length;				// the length in bytes of the string
		public ushort MaximumLength;		// the maximum number of bytes to write to the buffer (n/a in networking!)
		public ushort Offset;				// offset within the message of this string
		public ushort Reserved;				// always zero
		
		public BufferRegion(ushort length, ushort maximumLength, ushort offset)
		{
			this.Length = length;
			this.MaximumLength = maximumLength;
			this.Offset = offset;
			this.Reserved = 0;
		}
	}
}