Native shims for libheimntlm

src/Common/src/Interop/Linux/System.Net.Security.Native/Interop.HeimdalNtlm.cs

@@ -0,0 +1,42 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Runtime.InteropServices;
+using Microsoft.Win32.SafeHandles;
+
+internal static partial class Interop
+{
+    internal static class HeimdalNtlm
+    {
+        internal static byte[] CreateNegotiateMessage(uint flags)
+        {
+            SafeNtlmBufferHandle data;
+            int dataLen;
+            int status = NetSecurity.HeimNtlmEncodeType1(flags, out data, out dataLen);
+            NetSecurity.HeimdalNtlmException.AssertOrThrowIfError("HeimNtlmEncodeType1 failed", status);
+            using (data)
+            {
+                return data.ToByteArray(dataLen,0);
+            }
+        }
+
+        internal static byte[] CreateAuthenticateMessage(uint flags, string username, string password, string domain,
+                                                         byte[] type2Data, int offset, int count, out byte[] sessionKey)
+        {
+            using (SafeNtlmType3Handle challengeMessage = new SafeNtlmType3Handle(type2Data, offset, count))
+            {
+                return  challengeMessage.GetResponse(flags, username, password, domain, out sessionKey);
+            }
+        }
+
+        internal static void CreateKeys(byte[] sessionKey, out SafeNtlmKeyHandle serverSignKey, out SafeNtlmKeyHandle serverSealKey, out SafeNtlmKeyHandle clientSignKey, out SafeNtlmKeyHandle clientSealKey)
+        {
+            serverSignKey = new SafeNtlmKeyHandle(sessionKey, false, false);
+            serverSealKey = new SafeNtlmKeyHandle(sessionKey, false, true);
+            clientSignKey = new SafeNtlmKeyHandle(sessionKey, true, false);
+            clientSealKey = new SafeNtlmKeyHandle(sessionKey, true, true);
+        }
+    }
+}
+

src/Common/src/Interop/Linux/System.Net.Security.Native/Interop.HeimdalNtlmException.cs

@@ -0,0 +1,36 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class NetSecurity
+    {
+        internal sealed class HeimdalNtlmException : Exception
+        {
+            public HeimdalNtlmException(string message) : base(message)
+            {
+            }
+
+            public HeimdalNtlmException(int error)
+                : base(SR.Format(SR.net_generic_heimntlm_operation_failed, error))
+            {
+                HResult = error;
+            }
+
+            public static void AssertOrThrowIfError(string message, int error)
+            {
+                if (error != 0)
+                {
+                    var ex = new HeimdalNtlmException(error);
+                    Debug.Fail(message + ": " + ex);
+                    throw ex;
+                }
+            }
+        }
+    }
+}
+

src/Common/src/Interop/Linux/System.Net.Security.Native/Interop.Ntlm.cs

@@ -0,0 +1,78 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Security.Cryptography;
+using System.Text;
+using Microsoft.Win32.SafeHandles;
+
+internal static partial class Interop
+{
+    internal static partial class NetSecurity
+    {
+        // The following constant is used in calculation of NTOWF2
+        // ref: https://msdn.microsoft.com/en-us/library/cc236700.aspx
+        public const int MD5DigestLength = 16;
+        [DllImport(Interop.Libraries.NetSecurityNative, EntryPoint="NetSecurity_HeimNtlmFreeBuf")]
+        internal static extern int HeimNtlmFreeBuf(IntPtr bufferHandle);
+
+        [DllImport(Interop.Libraries.NetSecurityNative, EntryPoint="NetSecurity_ExtractNtlmBuffer")]
+        internal static extern int ExtractNtlmBuffer(SafeNtlmBufferHandle data, byte[] buffer, int capacity, int offset);
+
+        [DllImport(Interop.Libraries.NetSecurityNative, EntryPoint="NetSecurity_HeimNtlmEncodeType1")]
+        internal static extern int HeimNtlmEncodeType1(uint flags, out SafeNtlmBufferHandle data, out int length);
+
+        [DllImport(Interop.Libraries.NetSecurityNative, EntryPoint="NetSecurity_HeimNtlmDecodeType2")]
+        internal static extern int HeimNtlmDecodeType2(byte[] data, int offset, int count, out SafeNtlmType2Handle type2Handle);
+
+        [DllImport(Interop.Libraries.NetSecurityNative, EntryPoint="NetSecurity_HeimNtlmFreeType2")]
+        internal static extern int HeimNtlmFreeType2(IntPtr type2Handle);
+
+        [DllImport(Interop.Libraries.NetSecurityNative, EntryPoint="NetSecurity_HeimNtlmNtKey", CharSet = CharSet.Ansi)]
+        internal static extern int HeimNtlmNtKey(string password, out SafeNtlmBufferHandle key, out int length);
+
+        [DllImport(Interop.Libraries.NetSecurityNative, EntryPoint="NetSecurity_HeimNtlmCalculateResponse", CharSet = CharSet.Ansi)]
+        internal static extern int HeimNtlmCalculateResponse(
+            bool isLM,
+            SafeNtlmBufferHandle key,
+            SafeNtlmType2Handle type2Handle,
+            string username,
+            string target,
+            byte[] baseSessionKey,
+            int baseSessionKeyLen,
+            out SafeNtlmBufferHandle answer,
+            out int ansLength);
+
+        [DllImport(Interop.Libraries.NetSecurityNative, EntryPoint="NetSecurity_CreateType3Message", CharSet = CharSet.Ansi)]
+        internal static extern int CreateType3Message(
+            SafeNtlmBufferHandle key,
+            SafeNtlmType2Handle type2Handle,
+            string username,
+            string domain,
+            uint flags,
+            SafeNtlmBufferHandle lmResponse,
+            SafeNtlmBufferHandle ntlmResponse,
+            byte [] baseSessionKey,
+            int baseSessionKeyLen,
+            out SafeNtlmBufferHandle sessionKey,
+            out int sessionKeyLen,
+            out SafeNtlmBufferHandle data,
+            out int dataLen
+            );
+
+        internal partial class NtlmFlags
+        {
+            internal const uint NTLMSSP_NEGOTIATE_UNICODE = 0x1;
+            internal const uint NTLMSSP_REQUEST_TARGET = 0x4;
+            internal const uint NTLMSSP_NEGOTIATE_SIGN = 0x10;
+            internal const uint NTLMSSP_NEGOTIATE_SEAL = 0x20;
+            internal const uint NTLMSSP_NEGOTIATE_NTLM = 0x200;
+            internal const uint NTLMSSP_NEGOTIATE_ALWAYS_SIGN = 0x8000;
+            internal const uint NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY = 0x80000;
+            internal const uint NTLMSSP_NEGOTIATE_128 = 0x20000000;
+            internal const uint NTLMSSP_NEGOTIATE_KEY_EXCH = 0x40000000;
+        }
+    }
+}

src/Common/src/Interop/Unix/Interop.Libraries.cs

@@ -8,6 +8,7 @@ private static partial class Libraries
         // Shims
         internal const string SystemNative = "System.Native";
         internal const string HttpNative = "System.Net.Http.Native";
+        internal const string NetSecurityNative = "System.Net.Security.Native";
         internal const string CryptoNative = "System.Security.Cryptography.Native";
         internal const string GlobalizationNative = "System.Globalization.Native";
         internal const string CompressionNative = "System.IO.Compression.Native";

src/Common/src/Interop/Unix/System.Security.Cryptography.Native/Interop.EVP.Cipher.cs

@@ -66,5 +66,16 @@ internal static extern unsafe bool EvpCipherFinalEx(
 
         [DllImport(Libraries.CryptoNative, EntryPoint = "CryptoNative_EvpDes3Cbc")]
         internal static extern IntPtr EvpDes3Cbc();
+
+        [DllImport(Interop.Libraries.CryptoNative, EntryPoint = "CryptoNative_EvpRc4")]
+        internal static extern IntPtr EvpRc4();
+
+        [DllImport(Interop.Libraries.CryptoNative, EntryPoint = "CryptoNative_EvpCipher")]
+        internal static unsafe extern int EvpCipher(
+            SafeEvpCipherCtxHandle ctx,
+            byte[] output,
+            byte* input,
+            int inl);
+
     }
 }