Changed how internal structures are created for handling SecureBuffers.

SecureBuffer/SecureBuffer.cs

@@ -8,7 +8,7 @@ using System.Threading.Tasks;
 namespace NSspi.Contexts
 {
     [StructLayout( LayoutKind.Sequential )]
-    public unsafe struct SecureBuffer
+    public unsafe struct SecureBufferInternal
     {
         public int Count;
 
@@ -17,4 +17,20 @@ namespace NSspi.Contexts
         // A pointer to a byte[]
         public IntPtr Buffer;
     }
+
+    public class SecureBuffer
+    {
+        public SecureBuffer( byte[] buffer, BufferType type )
+        {
+            this.Buffer = buffer;
+            this.Type = type;
+            this.Length = this.Buffer.Length;
+        }
+
+        public BufferType Type { get; set; }
+
+        public byte[] Buffer { get; set; }
+
+        public int Length { get; internal set; }
+    }
 }

SecureBuffer/SecureBufferAdapter.cs

@@ -0,0 +1,108 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NSspi.Contexts
+{
+    public class SecureBufferAdapter : IDisposable
+    {
+        private bool disposed;
+
+        private IList<SecureBuffer> buffers;
+
+        private GCHandle descriptorHandle;
+
+        private GCHandle[] bufferHandles;
+
+        private SecureBufferDescInternal descriptor;
+        private SecureBufferInternal[] bufferCarrier;
+        private GCHandle bufferCarrierHandle;
+
+        public SecureBufferAdapter( SecureBuffer buffer )
+            : this( new[] { buffer } )
+        {
+
+        }
+
+        //[ReliabilityContract( Consistency.MayCorruptAppDomain, Cer.None)]
+        public SecureBufferAdapter( IList<SecureBuffer> buffers )
+        {
+            this.buffers = buffers;
+
+            this.disposed = false;
+
+            this.bufferHandles = new GCHandle[this.buffers.Count];
+            this.bufferCarrier = new SecureBufferInternal[this.buffers.Count];
+
+            for ( int i = 0; i < this.buffers.Count; i++ )
+            {
+                this.bufferHandles[i] = GCHandle.Alloc( this.buffers[i].Buffer, GCHandleType.Pinned );
+
+                this.bufferCarrier[i] = new SecureBufferInternal();
+                this.bufferCarrier[i].Type = this.buffers[i].Type;
+                this.bufferCarrier[i].Count = this.buffers[i].Buffer.Length;
+                this.bufferCarrier[i].Buffer = bufferHandles[i].AddrOfPinnedObject();
+            }
+
+            this.bufferCarrierHandle = GCHandle.Alloc( bufferCarrier, GCHandleType.Pinned );
+
+            this.descriptor = new SecureBufferDescInternal();
+            this.descriptor.Version = SecureBufferDescInternal.ApiVersion;
+            this.descriptor.NumBuffers = this.buffers.Count;
+            this.descriptor.Buffers = bufferCarrierHandle.AddrOfPinnedObject();
+
+            this.descriptorHandle = GCHandle.Alloc( descriptor, GCHandleType.Pinned );
+        }
+
+        ~SecureBufferAdapter()
+        {
+            Dispose( false );
+        }
+
+        public IntPtr Handle
+        {
+            get
+            {
+                if ( this.disposed )
+                {
+                    throw new ObjectDisposedException( "Cannot use SecureBufferListHandle after it has been disposed" );
+                }
+
+                return this.descriptorHandle.AddrOfPinnedObject();
+            }
+        }
+
+        public void Dispose()
+        {
+            this.Dispose( true );
+            GC.SuppressFinalize( this );
+        }
+
+        protected virtual void Dispose( bool disposing )
+        {
+            if ( this.disposed == true ) { return; }
+
+            if ( disposing )
+            {
+                for ( int i = 0; i < this.buffers.Count; i++ )
+                {
+                    this.buffers[i].Length = this.bufferCarrier[i].Count;
+                }
+            }
+
+            for ( int i = 0; i < this.bufferHandles.Length; i++ )
+            {
+                this.bufferHandles[i].Free();
+            }
+
+            this.bufferCarrierHandle.Free();
+            this.descriptorHandle.Free();
+
+            this.disposed = true;
+        }
+
+    }
+}

SecureBuffer/SecureBufferDesc.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.ConstrainedExecution;
 using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading.Tasks;
@@ -8,7 +9,7 @@ using System.Threading.Tasks;
 namespace NSspi.Contexts
 {
     [StructLayout( LayoutKind.Sequential)]
-    public unsafe struct SecureBufferDesc
+    public struct SecureBufferDescInternal
     {
         public int Version;
         public int NumBuffers;
@@ -18,6 +19,4 @@ namespace NSspi.Contexts
 
         public const int ApiVersion = 0;
     }
-
-
 }