src/WINNT/afsrdr/kernel/lib/AFSSecurity.cpp

   1 /*
   2  * Copyright (c) 2008, 2009, 2010, 2011 Kernel Drivers, LLC.
   3  * Copyright (c) 2009, 2010, 2011 Your File System, Inc.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * - Redistributions of source code must retain the above copyright notice,
  11  *   this list of conditions and the following disclaimer.
  12  * - Redistributions in binary form must reproduce the above copyright
  13  *   notice,
  14  *   this list of conditions and the following disclaimer in the
  15  *   documentation
  16  *   and/or other materials provided with the distribution.
  17  * - Neither the names of Kernel Drivers, LLC and Your File System, Inc.
  18  *   nor the names of their contributors may be used to endorse or promote
  19  *   products derived from this software without specific prior written
  20  *   permission from Kernel Drivers, LLC and Your File System, Inc.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  23  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  24  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  25  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
  26  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  27  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  28  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  29  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  30  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  31  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  32  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33  */
  34
  35 //
  36 // File: AFSSecurity.cpp
  37 //
  38
  39 #include "AFSCommon.h"
  40
  41 NTSTATUS
  42 AFSSetSecurity( IN PDEVICE_OBJECT LibDeviceObject,
  43                 IN PIRP Irp)
  44 {
  45
  46     UNREFERENCED_PARAMETER(LibDeviceObject);
  47     NTSTATUS ntStatus = STATUS_SUCCESS;
  48     IO_STACK_LOCATION *pIrpSp;
  49
  50     pIrpSp = IoGetCurrentIrpStackLocation( Irp);
  51
  52     __try
  53     {
  54
  55         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
  56                       AFS_TRACE_LEVEL_ERROR,
  57                       "AFSSetSecurity Entry for FO %p\n",
  58                       pIrpSp->FileObject);
  59
  60         AFSCompleteRequest( Irp,
  61                             ntStatus);
  62     }
  63     __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
  64     {
  65
  66         AFSDbgLogMsg( 0,
  67                       0,
  68                       "EXCEPTION - AFSSetSecurity\n");
  69
  70         AFSDumpTraceFilesFnc();
  71     }
  72
  73     return ntStatus;
  74 }
  75
  76 NTSTATUS
  77 AFSQuerySecurity( IN PDEVICE_OBJECT LibDeviceObject,
  78                   IN PIRP Irp)
  79 {
  80
  81     UNREFERENCED_PARAMETER(LibDeviceObject);
  82     NTSTATUS ntStatus = STATUS_SUCCESS;
  83     PIO_STACK_LOCATION pIrpSp;
  84     PMDL pUserBufferMdl = NULL;
  85     void *pLockedUserBuffer = NULL;
  86     ULONG ulSDLength = 0;
  87     SECURITY_INFORMATION SecurityInformation;
  88     PFILE_OBJECT pFileObject;
  89     AFSFcb *pFcb = NULL;
  90     AFSCcb *pCcb = NULL;
  91
  92     __try
  93     {
  94
  95         pIrpSp = IoGetCurrentIrpStackLocation( Irp);
  96
  97         SecurityInformation = pIrpSp->Parameters.QuerySecurity.SecurityInformation;
  98
  99         pFileObject = pIrpSp->FileObject;
 100
 101         pFcb = (AFSFcb *)pFileObject->FsContext;
 102
 103         pCcb = (AFSCcb *)pFileObject->FsContext2;
 104
 105         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 106                       AFS_TRACE_LEVEL_VERBOSE,
 107                       "AFSQuerySecurity (%p) Entry for FO %p SI %08lX\n",
 108                       Irp,
 109                       pFileObject,
 110                       SecurityInformation);
 111
 112         if( pFcb == NULL)
 113         {
 114
 115             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 116                           AFS_TRACE_LEVEL_ERROR,
 117                           "AFSQuerySecurity Attempted access (%p) when pFcb == NULL\n",
 118                           Irp);
 119
 120             try_return( ntStatus = STATUS_INVALID_DEVICE_REQUEST);
 121         }
 122
 123         if ( SecurityInformation & SACL_SECURITY_INFORMATION)
 124         {
 125
 126             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 127                           AFS_TRACE_LEVEL_ERROR,
 128                           "AFSQuerySecurity Attempted access (%p) SACL\n",
 129                           Irp);
 130
 131             try_return( ntStatus = STATUS_ACCESS_DENIED);
 132         }
 133
 134         if( AFSDefaultSD == NULL)
 135         {
 136
 137             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 138                           AFS_TRACE_LEVEL_ERROR,
 139                           "AFSQuerySecurity No default SD allocated\n");
 140
 141             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 142         }
 143
 144         ulSDLength = RtlLengthSecurityDescriptor( AFSDefaultSD);
 145
 146         if( pIrpSp->Parameters.QuerySecurity.Length < ulSDLength ||
 147             Irp->UserBuffer == NULL)
 148         {
 149
 150             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 151                           AFS_TRACE_LEVEL_VERBOSE,
 152                           "AFSQuerySecurity Buffer too small\n");
 153
 154             Irp->IoStatus.Information = (ULONG_PTR)ulSDLength;
 155
 156             try_return( ntStatus = STATUS_BUFFER_OVERFLOW);
 157         }
 158
 159         pLockedUserBuffer = AFSLockUserBuffer( Irp->UserBuffer,
 160                                                pIrpSp->Parameters.QuerySecurity.Length,
 161                                                &pUserBufferMdl);
 162
 163         if( pLockedUserBuffer == NULL)
 164         {
 165
 166             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 167                           AFS_TRACE_LEVEL_ERROR,
 168                           "AFSQuerySecurity Failed to lock user buffer\n");
 169
 170             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 171         }
 172
 173         RtlCopyMemory( pLockedUserBuffer,
 174                        AFSDefaultSD,
 175                        ulSDLength);
 176
 177         Irp->IoStatus.Information = (ULONG_PTR)ulSDLength;
 178
 179 try_exit:
 180
 181         if( pUserBufferMdl != NULL)
 182         {
 183             MmUnlockPages( pUserBufferMdl);
 184             IoFreeMdl( pUserBufferMdl);
 185         }
 186     }
 187     __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
 188     {
 189
 190         AFSDbgLogMsg( 0,
 191                       0,
 192                       "EXCEPTION - AFSQuerySecurity\n");
 193
 194         AFSDumpTraceFilesFnc();
 195     }
 196
 197     AFSCompleteRequest( Irp,
 198                         ntStatus);
 199
 200     return ntStatus;
 201 }