Misc addendum to CORE-14271 (#1529)
[reactos.git] / drivers / filesystems / udfs / secursup.cpp
1 ////////////////////////////////////////////////////////////////////
2 // Copyright (C) Alexander Telyatnikov, Ivan Keliukh, Yegor Anchishkin, SKIF Software, 1999-2013. Kiev, Ukraine
3 // All rights reserved
4 // This file was released under the GPLv2 on June 2015.
5 ////////////////////////////////////////////////////////////////////
6 /*************************************************************************
7 *
8 * File: SecurSup.cpp
9 *
10 * Module: UDF File System Driver (Kernel mode execution only)
11 *
12 * Description:
13 * Contains code to handle the "Get/Set Security" dispatch entry points.
14 *
15 *************************************************************************/
16
17 #include "udffs.h"
18
19 // define the file specific bug-check id
20 #define UDF_BUG_CHECK_ID UDF_FILE_SECURITY
21
22 #ifdef UDF_ENABLE_SECURITY
23
24 NTSTATUS UDFConvertToSelfRelative(
25 IN OUT PSECURITY_DESCRIPTOR* SecurityDesc);
26
27 /*UCHAR FullControlSD[] = {
28 0x01, 0x00, 0x04, 0x80, 0x4c, 0x00, 0x00, 0x00,
29 0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
30 0x14, 0x00, 0x00, 0x00, 0x02, 0x00, 0x38, 0x00,
31 0x02, 0x00, 0x00, 0x00, 0x00, 0x09, 0x18, 0x00,
32 0x00, 0x00, 0x00, 0x10, 0x01, 0x01, 0x00, 0x00,
33 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
34 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x18, 0x00,
35 0xff, 0x01, 0x1f, 0x00, 0x01, 0x01, 0x00, 0x00,
36 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
37 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00,
38 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
39 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
40 0x00, 0x00, 0x00, 0x00
41 };*/
42
43 /*************************************************************************
44 *
45 * Function: UDFGetSecurity()
46 *
47 * Description:
48 *
49 * Expected Interrupt Level (for execution) :
50 *
51 * IRQL_PASSIVE_LEVEL
52 *
53 * Return Value: Irrelevant.
54 *
55 *************************************************************************/
56 NTSTATUS
57 UDFGetSecurity(
58 IN PDEVICE_OBJECT DeviceObject, // the logical volume device object
59 IN PIRP Irp) // I/O Request Packet
60 {
61 NTSTATUS RC = STATUS_SUCCESS;
62 PtrUDFIrpContext PtrIrpContext = NULL;
63 BOOLEAN AreWeTopLevel = FALSE;
64
65 UDFPrint(("UDFGetSecurity\n"));
66 // BrutePoint();
67
68 FsRtlEnterFileSystem();
69 ASSERT(DeviceObject);
70 ASSERT(Irp);
71
72 // set the top level context
73 AreWeTopLevel = UDFIsIrpTopLevel(Irp);
74 ASSERT(!UDFIsFSDevObj(DeviceObject));
75 // Call the common Lock Control routine, with blocking allowed if
76 // synchronous
77 _SEH2_TRY {
78
79 // get an IRP context structure and issue the request
80 PtrIrpContext = UDFAllocateIrpContext(Irp, DeviceObject);
81 if(PtrIrpContext) {
82 RC = UDFCommonGetSecurity(PtrIrpContext, Irp);
83 } else {
84 RC = STATUS_INSUFFICIENT_RESOURCES;
85 Irp->IoStatus.Status = RC;
86 Irp->IoStatus.Information = 0;
87 // complete the IRP
88 IoCompleteRequest(Irp, IO_DISK_INCREMENT);
89 }
90
91 } __except (UDFExceptionFilter(PtrIrpContext, GetExceptionInformation())) {
92
93 RC = UDFExceptionHandler(PtrIrpContext, Irp);
94
95 UDFLogEvent(UDF_ERROR_INTERNAL_ERROR, RC);
96 }
97
98 if (AreWeTopLevel) {
99 IoSetTopLevelIrp(NULL);
100 }
101
102 FsRtlExitFileSystem();
103
104 return(RC);
105 } // end UDFGetSecurity()
106
107
108 /*************************************************************************
109 *
110 * Function: UDFCommonGetSecurity()
111 *
112 * Description:
113 * This is the common routine for getting Security (ACL) called
114 * by both the fsd and fsp threads
115 *
116 * Expected Interrupt Level (for execution) :
117 *
118 * IRQL_PASSIVE_LEVEL
119 *
120 * Return Value: Irrelevant
121 *
122 *************************************************************************/
123 NTSTATUS
124 UDFCommonGetSecurity(
125 IN PtrUDFIrpContext PtrIrpContext,
126 IN PIRP Irp)
127 {
128 NTSTATUS RC = STATUS_SUCCESS;
129 PIO_STACK_LOCATION IrpSp = NULL;
130 BOOLEAN PostRequest = FALSE;
131 BOOLEAN CanWait = FALSE;
132 PtrUDFNTRequiredFCB NtReqFcb = NULL;
133 BOOLEAN AcquiredFCB = FALSE;
134 PFILE_OBJECT FileObject = NULL;
135 PtrUDFFCB Fcb = NULL;
136 PtrUDFCCB Ccb = NULL;
137 PVOID PtrSystemBuffer = NULL;
138 ULONG BufferLength = 0;
139
140 UDFPrint(("UDFCommonGetSecurity\n"));
141
142 _SEH2_TRY {
143
144 // First, get a pointer to the current I/O stack location.
145 IrpSp = IoGetCurrentIrpStackLocation(Irp);
146 ASSERT(IrpSp);
147
148 FileObject = IrpSp->FileObject;
149 ASSERT(FileObject);
150
151 // Get the FCB and CCB pointers.
152 Ccb = (PtrUDFCCB)(FileObject->FsContext2);
153 ASSERT(Ccb);
154 Fcb = Ccb->Fcb;
155 ASSERT(Fcb);
156
157 /* if(!Fcb->Vcb->ReadSecurity)
158 try_return(RC = STATUS_NOT_IMPLEMENTED);*/
159
160 NtReqFcb = Fcb->NTRequiredFCB;
161 CanWait = ((PtrIrpContext->IrpContextFlags & UDF_IRP_CONTEXT_CAN_BLOCK) ? TRUE : FALSE);
162
163 // Acquire the FCB resource shared
164 UDF_CHECK_PAGING_IO_RESOURCE(NtReqFcb);
165 if (!UDFAcquireResourceExclusive(&(NtReqFcb->MainResource), CanWait)) {
166 // if (!UDFAcquireResourceShared(&(NtReqFcb->MainResource), CanWait)) {
167 PostRequest = TRUE;
168 try_return(RC = STATUS_PENDING);
169 }
170 AcquiredFCB = TRUE;
171
172 PtrSystemBuffer = UDFGetCallersBuffer(PtrIrpContext, Irp);
173 if(!PtrSystemBuffer)
174 try_return(RC = STATUS_INVALID_USER_BUFFER);
175 BufferLength = IrpSp->Parameters.QuerySecurity.Length;
176
177 if(!NtReqFcb->SecurityDesc) {
178 RC = UDFAssignAcl(Fcb->Vcb, FileObject, Fcb, NtReqFcb);
179 if(!NT_SUCCESS(RC))
180 try_return(RC);
181 }
182
183 _SEH2_TRY {
184 RC = SeQuerySecurityDescriptorInfo(&(IrpSp->Parameters.QuerySecurity.SecurityInformation),
185 (PSECURITY_DESCRIPTOR)PtrSystemBuffer,
186 &BufferLength,
187 &(NtReqFcb->SecurityDesc) );
188 } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
189 RC = STATUS_BUFFER_TOO_SMALL;
190 }
191
192 try_exit: NOTHING;
193
194 } _SEH2_FINALLY {
195
196 // Release the FCB resources if acquired.
197 if (AcquiredFCB) {
198 UDF_CHECK_PAGING_IO_RESOURCE(NtReqFcb);
199 UDFReleaseResource(&(NtReqFcb->MainResource));
200 AcquiredFCB = FALSE;
201 }
202
203 if (PostRequest) {
204 // Perform appropriate post related processing here
205 RC = UDFPostRequest(PtrIrpContext, Irp);
206 } else
207 if(!AbnormalTermination()) {
208 Irp->IoStatus.Status = RC;
209 Irp->IoStatus.Information = BufferLength;
210 // Free up the Irp Context
211 UDFReleaseIrpContext(PtrIrpContext);
212 // complete the IRP
213 IoCompleteRequest(Irp, IO_DISK_INCREMENT);
214 }
215
216 } // end of "__finally" processing
217
218 return(RC);
219 }
220
221 #ifndef UDF_READ_ONLY_BUILD
222 /*************************************************************************
223 *
224 * Function: UDFSetSecurity()
225 *
226 * Description:
227 *
228 * Expected Interrupt Level (for execution) :
229 *
230 * IRQL_PASSIVE_LEVEL
231 *
232 * Return Value: Irrelevant.
233 *
234 *************************************************************************/
235 NTSTATUS
236 UDFSetSecurity(
237 IN PDEVICE_OBJECT DeviceObject, // the logical volume device object
238 IN PIRP Irp) // I/O Request Packet
239 {
240 NTSTATUS RC = STATUS_SUCCESS;
241 PtrUDFIrpContext PtrIrpContext = NULL;
242 BOOLEAN AreWeTopLevel = FALSE;
243
244 UDFPrint(("UDFSetSecurity\n"));
245 // BrutePoint();
246
247 FsRtlEnterFileSystem();
248 ASSERT(DeviceObject);
249 ASSERT(Irp);
250
251 // set the top level context
252 AreWeTopLevel = UDFIsIrpTopLevel(Irp);
253 // Call the common Lock Control routine, with blocking allowed if
254 // synchronous
255 _SEH2_TRY {
256
257 // get an IRP context structure and issue the request
258 PtrIrpContext = UDFAllocateIrpContext(Irp, DeviceObject);
259 if(PtrIrpContext) {
260 RC = UDFCommonSetSecurity(PtrIrpContext, Irp);
261 } else {
262 RC = STATUS_INSUFFICIENT_RESOURCES;
263 Irp->IoStatus.Status = RC;
264 Irp->IoStatus.Information = 0;
265 // complete the IRP
266 IoCompleteRequest(Irp, IO_DISK_INCREMENT);
267 }
268
269 } __except (UDFExceptionFilter(PtrIrpContext, GetExceptionInformation())) {
270
271 RC = UDFExceptionHandler(PtrIrpContext, Irp);
272
273 UDFLogEvent(UDF_ERROR_INTERNAL_ERROR, RC);
274 }
275
276 if (AreWeTopLevel) {
277 IoSetTopLevelIrp(NULL);
278 }
279
280 FsRtlExitFileSystem();
281
282 return(RC);
283 } // end UDFSetSecurity()
284
285
286 /*************************************************************************
287 *
288 * Function: UDFCommonSetSecurity()
289 *
290 * Description:
291 * This is the common routine for getting Security (ACL) called
292 * by both the fsd and fsp threads
293 *
294 * Expected Interrupt Level (for execution) :
295 *
296 * IRQL_PASSIVE_LEVEL
297 *
298 * Return Value: Irrelevant
299 *
300 *************************************************************************/
301 NTSTATUS
302 UDFCommonSetSecurity(
303 IN PtrUDFIrpContext PtrIrpContext,
304 IN PIRP Irp)
305 {
306 NTSTATUS RC = STATUS_SUCCESS;
307 PIO_STACK_LOCATION IrpSp = NULL;
308 BOOLEAN PostRequest = FALSE;
309 BOOLEAN CanWait = FALSE;
310 PtrUDFNTRequiredFCB NtReqFcb = NULL;
311 BOOLEAN AcquiredFCB = FALSE;
312 PFILE_OBJECT FileObject = NULL;
313 PtrUDFFCB Fcb = NULL;
314 PtrUDFCCB Ccb = NULL;
315 ACCESS_MASK DesiredAccess = 0;
316
317 UDFPrint(("UDFCommonSetSecurity\n"));
318
319 _SEH2_TRY {
320
321 // First, get a pointer to the current I/O stack location.
322 IrpSp = IoGetCurrentIrpStackLocation(Irp);
323 ASSERT(IrpSp);
324
325 FileObject = IrpSp->FileObject;
326 ASSERT(FileObject);
327
328 // Get the FCB and CCB pointers.
329 Ccb = (PtrUDFCCB)(FileObject->FsContext2);
330 ASSERT(Ccb);
331 Fcb = Ccb->Fcb;
332 ASSERT(Fcb);
333
334 if(!Fcb->Vcb->WriteSecurity)
335 try_return(RC = STATUS_NOT_IMPLEMENTED);
336
337 NtReqFcb = Fcb->NTRequiredFCB;
338 CanWait = ((PtrIrpContext->IrpContextFlags & UDF_IRP_CONTEXT_CAN_BLOCK) ? TRUE : FALSE);
339
340 // Acquire the FCB resource exclusive
341 UDF_CHECK_PAGING_IO_RESOURCE(NtReqFcb);
342 if (!UDFAcquireResourceExclusive(&(NtReqFcb->MainResource), CanWait)) {
343 PostRequest = TRUE;
344 try_return(RC = STATUS_PENDING);
345 }
346 AcquiredFCB = TRUE;
347
348 //OWNER_SECURITY_INFORMATION
349 if(IrpSp->Parameters.SetSecurity.SecurityInformation & OWNER_SECURITY_INFORMATION)
350 DesiredAccess |= WRITE_OWNER;
351 //GROUP_SECURITY_INFORMATION
352 if(IrpSp->Parameters.SetSecurity.SecurityInformation & GROUP_SECURITY_INFORMATION)
353 DesiredAccess |= WRITE_OWNER;
354 //DACL_SECURITY_INFORMATION
355 if(IrpSp->Parameters.SetSecurity.SecurityInformation & DACL_SECURITY_INFORMATION)
356 DesiredAccess |= WRITE_DAC;
357 //SACL_SECURITY_INFORMATION
358 if(IrpSp->Parameters.SetSecurity.SecurityInformation & SACL_SECURITY_INFORMATION)
359 DesiredAccess |= ACCESS_SYSTEM_SECURITY;
360
361 _SEH2_TRY {
362 UDFConvertToSelfRelative(&(NtReqFcb->SecurityDesc));
363
364 KdDump(NtReqFcb->SecurityDesc, RtlLengthSecurityDescriptor(NtReqFcb->SecurityDesc));
365 UDFPrint(("\n"));
366
367 RC = SeSetSecurityDescriptorInfo(/*FileObject*/ NULL,
368 &(IrpSp->Parameters.SetSecurity.SecurityInformation),
369 IrpSp->Parameters.SetSecurity.SecurityDescriptor,
370 &(NtReqFcb->SecurityDesc),
371 NonPagedPool,
372 IoGetFileObjectGenericMapping() );
373
374 KdDump(NtReqFcb->SecurityDesc, RtlLengthSecurityDescriptor(NtReqFcb->SecurityDesc));
375
376 } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
377 RC = STATUS_INVALID_PARAMETER;
378 }
379 if(NT_SUCCESS(RC)) {
380 NtReqFcb->NtReqFCBFlags |= UDF_NTREQ_FCB_SD_MODIFIED;
381
382 UDFNotifyFullReportChange( Fcb->Vcb, Fcb->FileInfo,
383 FILE_NOTIFY_CHANGE_SECURITY,
384 FILE_ACTION_MODIFIED);
385 }
386
387 try_exit: NOTHING;
388
389 } _SEH2_FINALLY {
390
391 // Release the FCB resources if acquired.
392 if (AcquiredFCB) {
393 UDF_CHECK_PAGING_IO_RESOURCE(NtReqFcb);
394 UDFReleaseResource(&(NtReqFcb->MainResource));
395 AcquiredFCB = FALSE;
396 }
397
398 if (PostRequest) {
399 // Perform appropriate post related processing here
400 RC = UDFPostRequest(PtrIrpContext, Irp);
401 } else
402 if(!AbnormalTermination()) {
403 Irp->IoStatus.Status = RC;
404 Irp->IoStatus.Information = 0;
405 // Free up the Irp Context
406 UDFReleaseIrpContext(PtrIrpContext);
407 // complete the IRP
408 IoCompleteRequest(Irp, IO_DISK_INCREMENT);
409 }
410
411 } // end of "__finally" processing
412
413 return(RC);
414 } // ens UDFCommonSetSecurity()
415
416 #endif //UDF_READ_ONLY_BUILD
417 #endif //UDF_ENABLE_SECURITY
418
419 NTSTATUS
420 UDFReadSecurity(
421 IN PVCB Vcb,
422 IN PtrUDFFCB Fcb,
423 IN PSECURITY_DESCRIPTOR* SecurityDesc
424 )
425 {
426 #ifdef UDF_ENABLE_SECURITY
427 PUDF_FILE_INFO FileInfo = NULL;
428 PUDF_FILE_INFO SDirInfo = NULL;
429 PUDF_FILE_INFO AclInfo = NULL;
430 NTSTATUS RC;
431 ULONG NumberBytesRead;
432 PERESOURCE Res1 = NULL;
433
434 UDFPrint(("UDFReadSecurity\n"));
435
436 _SEH2_TRY {
437
438 FileInfo = Fcb->FileInfo;
439 ASSERT(FileInfo);
440 if(!FileInfo) {
441 UDFPrint((" Volume Security\n"));
442 try_return(RC = STATUS_NO_SECURITY_ON_OBJECT);
443 }
444 if(Vcb->VCBFlags & UDF_VCB_FLAGS_RAW_DISK) {
445 UDFPrint((" No Security on blank volume\n"));
446 try_return(RC = STATUS_NO_SECURITY_ON_OBJECT);
447 }
448
449 // Open Stream Directory
450 RC = UDFOpenStreamDir__(Vcb, FileInfo, &SDirInfo);
451
452 if(RC == STATUS_NOT_FOUND)
453 try_return(RC = STATUS_NO_SECURITY_ON_OBJECT);
454 if(!NT_SUCCESS(RC)) {
455 if(UDFCleanUpFile__(Vcb, SDirInfo)) {
456 if(SDirInfo) MyFreePool__(SDirInfo);
457 }
458 SDirInfo = NULL;
459 try_return(RC);
460 }
461 // Acquire SDir exclusively if Fcb present
462 if(SDirInfo->Fcb) {
463 BrutePoint();
464 UDF_CHECK_PAGING_IO_RESOURCE(SDirInfo->Fcb->NTRequiredFCB);
465 UDFAcquireResourceExclusive(Res1 = &(SDirInfo->Fcb->NTRequiredFCB->MainResource),TRUE);
466 }
467
468 // Open Acl Stream
469 RC = UDFOpenFile__(Vcb,
470 FALSE,TRUE,&(UDFGlobalData.AclName),
471 SDirInfo,&AclInfo,NULL);
472 if(RC == STATUS_OBJECT_NAME_NOT_FOUND)
473 try_return(RC = STATUS_NO_SECURITY_ON_OBJECT);
474 if(!NT_SUCCESS(RC)) {
475 if(UDFCleanUpFile__(Vcb, AclInfo)) {
476 if(AclInfo) MyFreePool__(AclInfo);
477 }
478 AclInfo = NULL;
479 try_return(RC);
480 }
481
482 NumberBytesRead = (ULONG)UDFGetFileSize(AclInfo);
483 (*SecurityDesc) = DbgAllocatePool(NonPagedPool, NumberBytesRead);
484 if(!(*SecurityDesc))
485 try_return(RC = STATUS_INSUFFICIENT_RESOURCES);
486 RC = UDFReadFile__(Vcb, AclInfo, 0, NumberBytesRead,
487 FALSE, (PCHAR)(*SecurityDesc), &NumberBytesRead);
488 if(!NT_SUCCESS(RC))
489 try_return(RC);
490
491 RC = RtlValidSecurityDescriptor(*SecurityDesc);
492
493 try_exit: NOTHING;
494
495 } _SEH2_FINALLY {
496
497 if(AclInfo) {
498 UDFCloseFile__(Vcb, AclInfo);
499 if(UDFCleanUpFile__(Vcb, AclInfo))
500 MyFreePool__(AclInfo);
501 }
502
503 if(SDirInfo) {
504 UDFCloseFile__(Vcb, SDirInfo);
505 if(UDFCleanUpFile__(Vcb, SDirInfo))
506 MyFreePool__(SDirInfo);
507 }
508
509 if(!NT_SUCCESS(RC) && (*SecurityDesc)) {
510 DbgFreePool(*SecurityDesc);
511 (*SecurityDesc) = NULL;
512 }
513 if(Res1)
514 UDFReleaseResource(Res1);
515 }
516
517 return RC;
518 #else
519 return STATUS_NO_SECURITY_ON_OBJECT;
520 #endif //UDF_ENABLE_SECURITY
521
522 } // end UDFReadSecurity()
523
524 #ifdef UDF_ENABLE_SECURITY
525 NTSTATUS
526 UDFConvertToSelfRelative(
527 IN OUT PSECURITY_DESCRIPTOR* SecurityDesc
528 )
529 {
530 NTSTATUS RC;
531 SECURITY_INFORMATION SecurityInformation;
532 PSECURITY_DESCRIPTOR NewSD;
533 ULONG Len;
534
535 UDFPrint((" UDFConvertToSelfRelative\n"));
536
537 if(!(*SecurityDesc))
538 return STATUS_NO_SECURITY_ON_OBJECT;
539
540 SecurityInformation = FULL_SECURITY_INFORMATION;
541 Len = RtlLengthSecurityDescriptor(*SecurityDesc);
542 ASSERT(Len <= 1024);
543 NewSD = (PSECURITY_DESCRIPTOR)DbgAllocatePool(NonPagedPool, Len);
544 if(!NewSD)
545 return STATUS_INSUFFICIENT_RESOURCES;
546 _SEH2_TRY {
547 RC = SeQuerySecurityDescriptorInfo(&SecurityInformation, NewSD, &Len, SecurityDesc);
548 } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
549 RC = STATUS_INSUFFICIENT_RESOURCES;
550 }
551
552 if(NT_SUCCESS(RC)) {
553 DbgFreePool(*SecurityDesc);
554 *SecurityDesc = NewSD;
555 } else {
556 DbgFreePool(NewSD);
557 }
558 return RC;
559 } // end UDFConvertToSelfRelative()
560
561 NTSTATUS
562 UDFInheritAcl(
563 IN PVCB Vcb,
564 IN PSECURITY_DESCRIPTOR* ParentSecurityDesc,
565 IN OUT PSECURITY_DESCRIPTOR* SecurityDesc
566 )
567 {
568 NTSTATUS RC;
569 SECURITY_INFORMATION SecurityInformation;
570 ULONG Len;
571
572 UDFPrint((" UDFInheritAcl\n"));
573
574 if(!(*ParentSecurityDesc)) {
575 *SecurityDesc = NULL;
576 return STATUS_SUCCESS;
577 }
578
579 SecurityInformation = FULL_SECURITY_INFORMATION;
580 Len = RtlLengthSecurityDescriptor(*ParentSecurityDesc);
581 *SecurityDesc = (PSECURITY_DESCRIPTOR)DbgAllocatePool(NonPagedPool, Len);
582 if(!(*SecurityDesc))
583 return STATUS_INSUFFICIENT_RESOURCES;
584 _SEH2_TRY {
585 RC = SeQuerySecurityDescriptorInfo(&SecurityInformation, *SecurityDesc, &Len, ParentSecurityDesc);
586 } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
587 RC = STATUS_INSUFFICIENT_RESOURCES;
588 }
589
590 if(!NT_SUCCESS(RC)) {
591 DbgFreePool(*SecurityDesc);
592 *SecurityDesc = NULL;
593 }
594 return RC;
595 } // end UDFInheritAcl()
596
597 NTSTATUS
598 UDFBuildEmptyAcl(
599 IN PVCB Vcb,
600 IN PSECURITY_DESCRIPTOR* SecurityDesc
601 )
602 {
603 NTSTATUS RC;
604 ULONG Len = 2 * (sizeof(ACL) + sizeof(ACCESS_ALLOWED_ACE) + sizeof(ULONG)*4 /*RtlLengthSid(SeExports->SeWorldSid)*/);
605
606 UDFPrint((" UDFBuildEmptyAcl\n"));
607 // Create Security Descriptor
608 (*SecurityDesc) = (PSECURITY_DESCRIPTOR)DbgAllocatePool(NonPagedPool,
609 sizeof(SECURITY_DESCRIPTOR) + Len);
610 if(!(*SecurityDesc))
611 return STATUS_INSUFFICIENT_RESOURCES;
612
613 RC = RtlCreateSecurityDescriptor(*SecurityDesc, SECURITY_DESCRIPTOR_REVISION);
614
615 if(!NT_SUCCESS(RC)) {
616 DbgFreePool(*SecurityDesc);
617 *((PULONG)SecurityDesc) = NULL;
618 }
619 return RC;
620 } // end UDFBuildEmptyAcl()
621
622 NTSTATUS
623 UDFBuildFullControlAcl(
624 IN PVCB Vcb,
625 IN PSECURITY_DESCRIPTOR* SecurityDesc
626 )
627 {
628 NTSTATUS RC;
629 PACL Acl;
630 ULONG Len = sizeof(ACL) + 2*(sizeof(ACCESS_ALLOWED_ACE) + sizeof(ULONG)*4 /*- sizeof(ULONG)*/ /*+ RtlLengthSid(SeExports->SeWorldSid)*/);
631
632 UDFPrint((" UDFBuildFullControlAcl\n"));
633 // Create Security Descriptor
634 RC = UDFBuildEmptyAcl(Vcb, SecurityDesc);
635 if(!NT_SUCCESS(RC))
636 return RC;
637
638 // Set Owner
639 RC = RtlSetOwnerSecurityDescriptor(*SecurityDesc, SeExports->SeWorldSid, FALSE);
640 if(!NT_SUCCESS(RC)) {
641 DbgFreePool(*SecurityDesc);
642 *((PULONG)SecurityDesc) = NULL;
643 return RC;
644 }
645
646 // Set Group
647 RC = RtlSetGroupSecurityDescriptor(*SecurityDesc, SeExports->SeWorldSid, FALSE);
648 if(!NT_SUCCESS(RC)) {
649 DbgFreePool(*SecurityDesc);
650 *((PULONG)SecurityDesc) = NULL;
651 return RC;
652 }
653
654 // Create empty Acl
655 Acl = (PACL)DbgAllocatePool(NonPagedPool, Len);
656 if(!Acl) {
657 DbgFreePool(*SecurityDesc);
658 *((PULONG)SecurityDesc) = NULL;
659 return RC;
660 }
661 RtlZeroMemory(Acl, Len);
662
663 RC = RtlCreateAcl(Acl, Len, ACL_REVISION);
664 if(!NT_SUCCESS(RC)) {
665 DbgFreePool(Acl);
666 DbgFreePool(*SecurityDesc);
667 *((PULONG)SecurityDesc) = NULL;
668 return RC;
669 }
670
671 // Add (All)(All) access for Everyone
672 /* RC = RtlAddAccessAllowedAce(Acl, ACL_REVISION,
673 GENERIC_ALL,
674 SeExports->SeWorldSid);*/
675
676 RC = RtlAddAccessAllowedAce(Acl, ACL_REVISION,
677 FILE_ALL_ACCESS,
678 SeExports->SeWorldSid);
679
680 if(!NT_SUCCESS(RC)) {
681 DbgFreePool(Acl);
682 DbgFreePool(*SecurityDesc);
683 *((PULONG)SecurityDesc) = NULL;
684 return RC;
685 }
686
687 // Add Acl to Security Descriptor
688 RC = RtlSetDaclSecurityDescriptor(*SecurityDesc, TRUE, Acl, FALSE);
689 if(!NT_SUCCESS(RC)) {
690 DbgFreePool(Acl);
691 DbgFreePool(*SecurityDesc);
692 *((PULONG)SecurityDesc) = NULL;
693 return RC;
694 }
695
696 RC = UDFConvertToSelfRelative(SecurityDesc);
697
698 DbgFreePool(Acl);
699
700 return RC;
701 } // end UDFBuildFullControlAcl()
702
703 #endif // UDF_ENABLE_SECURITY
704
705 NTSTATUS
706 UDFAssignAcl(
707 IN PVCB Vcb,
708 IN PFILE_OBJECT FileObject, // OPTIONAL
709 IN PtrUDFFCB Fcb,
710 IN PtrUDFNTRequiredFCB NtReqFcb
711 )
712 {
713 NTSTATUS RC = STATUS_SUCCESS;
714 #ifdef UDF_ENABLE_SECURITY
715 // SECURITY_INFORMATION SecurityInformation;
716
717 // UDFPrint((" UDFAssignAcl\n"));
718 if(!NtReqFcb->SecurityDesc) {
719
720 PSECURITY_DESCRIPTOR ExplicitSecurity = NULL;
721
722 if(UDFIsAStreamDir(Fcb->FileInfo) || UDFIsAStream(Fcb->FileInfo)) {
723 // Stream/SDir security
724 NtReqFcb->SecurityDesc = Fcb->FileInfo->ParentFile->Dloc->CommonFcb->SecurityDesc;
725 return STATUS_SUCCESS;
726 } else
727 if(!Fcb->FileInfo) {
728 // Volume security
729 if(Vcb->RootDirFCB &&
730 Vcb->RootDirFCB->FileInfo &&
731 Vcb->RootDirFCB->FileInfo->Dloc &&
732 Vcb->RootDirFCB->FileInfo->Dloc->CommonFcb) {
733 RC = UDFInheritAcl(Vcb, &(Vcb->RootDirFCB->FileInfo->Dloc->CommonFcb->SecurityDesc), &ExplicitSecurity);
734 } else {
735 NtReqFcb->SecurityDesc = NULL;
736 RC = STATUS_NO_SECURITY_ON_OBJECT;
737 }
738 return RC;
739 }
740
741 RC = UDFReadSecurity(Vcb, Fcb, &ExplicitSecurity);
742 if(RC == STATUS_NO_SECURITY_ON_OBJECT) {
743 if(!Fcb->FileInfo->ParentFile) {
744 RC = UDFBuildFullControlAcl(Vcb, &ExplicitSecurity);
745 } else {
746 RC = UDFInheritAcl(Vcb, &(Fcb->FileInfo->ParentFile->Dloc->CommonFcb->SecurityDesc), &ExplicitSecurity);
747 }
748 /* if(NT_SUCCESS(RC)) {
749 NtReqFcb->NtReqFCBFlags |= UDF_NTREQ_FCB_SD_MODIFIED;
750 }*/
751 }
752 if(NT_SUCCESS(RC)) {
753
754 // SecurityInformation = FULL_SECURITY_INFORMATION;
755 NtReqFcb->SecurityDesc = ExplicitSecurity;
756
757 /* RC = SeSetSecurityDescriptorInfo(FileObject,
758 &SecurityInformation,
759 ExplicitSecurity,
760 &(NtReqFcb->SecurityDesc),
761 NonPagedPool,
762 IoGetFileObjectGenericMapping() );*/
763
764 }
765 }
766 #endif //UDF_ENABLE_SECURITY
767 return RC;
768 } // end UDFAssignAcl()
769
770
771 VOID
772 UDFDeassignAcl(
773 IN PtrUDFNTRequiredFCB NtReqFcb,
774 IN BOOLEAN AutoInherited
775 )
776 {
777 #ifdef UDF_ENABLE_SECURITY
778 // NTSTATUS RC = STATUS_SUCCESS;
779
780 // UDFPrint((" UDFDeassignAcl\n"));
781 if(!NtReqFcb->SecurityDesc)
782 return;
783
784 if(AutoInherited) {
785 NtReqFcb->SecurityDesc = NULL;
786 return;
787 }
788
789 SeDeassignSecurity(&(NtReqFcb->SecurityDesc));
790 NtReqFcb->SecurityDesc = NULL; // HA BCRK CLU4
791 #endif //UDF_ENABLE_SECURITY
792 return;
793 } // end UDFDeassignAcl()
794
795 NTSTATUS
796 UDFWriteSecurity(
797 IN PVCB Vcb,
798 IN PtrUDFFCB Fcb,
799 IN PSECURITY_DESCRIPTOR* SecurityDesc
800 )
801 {
802 #ifdef UDF_ENABLE_SECURITY
803 PUDF_FILE_INFO FileInfo = NULL;
804 PUDF_FILE_INFO SDirInfo = NULL;
805 PUDF_FILE_INFO AclInfo = NULL;
806 PERESOURCE Res1 = NULL;
807 NTSTATUS RC;
808 ULONG NumberBytesRead;
809
810 // UDFPrint(("UDFWriteSecurity\n"));
811
812 #if !defined(UDF_READ_ONLY_BUILD)
813
814 if(!Vcb->WriteSecurity ||
815 (Vcb->VCBFlags & (UDF_VCB_FLAGS_VOLUME_READ_ONLY |
816 UDF_VCB_FLAGS_MEDIA_READ_ONLY)))
817
818 #endif //!defined(UDF_READ_ONLY_BUILD)
819
820 return STATUS_SUCCESS;
821
822 #if !defined(UDF_READ_ONLY_BUILD)
823
824 _SEH2_TRY {
825
826 FileInfo = Fcb->FileInfo;
827 ASSERT(FileInfo);
828 if(!FileInfo) {
829 UDFPrint((" Volume Security\n"));
830 try_return(RC = STATUS_SUCCESS);
831 }
832
833 if(!(Fcb->NTRequiredFCB->NtReqFCBFlags & UDF_NTREQ_FCB_SD_MODIFIED))
834 try_return(RC = STATUS_SUCCESS);
835
836 // Open Stream Directory
837 RC = UDFOpenStreamDir__(Vcb, FileInfo, &SDirInfo);
838
839 if(RC == STATUS_NOT_FOUND) {
840 RC = UDFCreateStreamDir__(Vcb, FileInfo, &SDirInfo);
841 }
842 if(!NT_SUCCESS(RC)) {
843 if(UDFCleanUpFile__(Vcb, SDirInfo)) {
844 if(SDirInfo) MyFreePool__(SDirInfo);
845 }
846 SDirInfo = NULL;
847 try_return(RC);
848 }
849 // Acquire SDir exclusively if Fcb present
850 if(SDirInfo->Fcb) {
851 BrutePoint();
852 UDF_CHECK_PAGING_IO_RESOURCE(SDirInfo->Fcb->NTRequiredFCB);
853 UDFAcquireResourceExclusive(Res1 = &(SDirInfo->Fcb->NTRequiredFCB->MainResource),TRUE);
854 }
855
856 // Open Acl Stream
857 RC = UDFOpenFile__(Vcb,
858 FALSE,TRUE,&(UDFGlobalData.AclName),
859 SDirInfo,&AclInfo,NULL);
860 if(RC == STATUS_OBJECT_NAME_NOT_FOUND) {
861 RC = UDFCreateFile__(Vcb, FALSE, &(UDFGlobalData.AclName),
862 0, 0, FALSE, FALSE, SDirInfo, &AclInfo);
863 }
864 if(!NT_SUCCESS(RC)) {
865 if(UDFCleanUpFile__(Vcb, AclInfo)) {
866 if(AclInfo) MyFreePool__(AclInfo);
867 }
868 AclInfo = NULL;
869 try_return(RC);
870 }
871
872 if(!(*SecurityDesc)) {
873 UDFFlushFile__(Vcb, AclInfo);
874 RC = UDFUnlinkFile__(Vcb, AclInfo, TRUE);
875 try_return(RC);
876 }
877 NumberBytesRead = RtlLengthSecurityDescriptor(*SecurityDesc);
878
879 RC = UDFWriteFile__(Vcb, AclInfo, 0, NumberBytesRead,
880 FALSE, (PCHAR)(*SecurityDesc), &NumberBytesRead);
881 if(!NT_SUCCESS(RC))
882 try_return(RC);
883
884 Fcb->NTRequiredFCB->NtReqFCBFlags &= ~UDF_NTREQ_FCB_SD_MODIFIED;
885
886 try_exit: NOTHING;
887
888 } _SEH2_FINALLY {
889
890 if(AclInfo) {
891 UDFCloseFile__(Vcb, AclInfo);
892 if(UDFCleanUpFile__(Vcb, AclInfo))
893 MyFreePool__(AclInfo);
894 }
895
896 if(SDirInfo) {
897 UDFCloseFile__(Vcb, SDirInfo);
898 if(UDFCleanUpFile__(Vcb, SDirInfo))
899 MyFreePool__(SDirInfo);
900 }
901 if(Res1)
902 UDFReleaseResource(Res1);
903 }
904
905 return RC;
906
907 #endif //!defined(UDF_READ_ONLY_BUILD)
908 #endif //UDF_ENABLE_SECURITY
909
910 return STATUS_SUCCESS;
911
912 } // end UDFWriteSecurity()
913
914 PSECURITY_DESCRIPTOR
915 UDFLookUpAcl(
916 IN PVCB Vcb,
917 PFILE_OBJECT FileObject, // OPTIONAL
918 IN PtrUDFFCB Fcb
919 )
920 {
921 UDFAssignAcl(Vcb, FileObject, Fcb, Fcb->NTRequiredFCB);
922 return (Fcb->NTRequiredFCB->SecurityDesc);
923 } // end UDFLookUpAcl()
924
925
926 NTSTATUS
927 UDFCheckAccessRights(
928 PFILE_OBJECT FileObject, // OPTIONAL
929 PACCESS_STATE AccessState,
930 PtrUDFFCB Fcb,
931 PtrUDFCCB Ccb, // OPTIONAL
932 ACCESS_MASK DesiredAccess,
933 USHORT ShareAccess
934 )
935 {
936 NTSTATUS RC;
937 BOOLEAN ROCheck = FALSE;
938 #ifdef UDF_ENABLE_SECURITY
939 BOOLEAN SecurityCheck;
940 PSECURITY_DESCRIPTOR SecDesc;
941 SECURITY_SUBJECT_CONTEXT SubjectContext;
942 ACCESS_MASK LocalAccessMask;
943 #endif //UDF_ENABLE_SECURITY
944
945 // Check attr compatibility
946 ASSERT(Fcb);
947 ASSERT(Fcb->Vcb);
948 #ifdef UDF_READ_ONLY_BUILD
949 goto treat_as_ro;
950 #endif //UDF_READ_ONLY_BUILD
951
952 if(Fcb->FCBFlags & UDF_FCB_READ_ONLY) {
953 ROCheck = TRUE;
954 } else
955 if((Fcb->Vcb->origIntegrityType == INTEGRITY_TYPE_OPEN) &&
956 Ccb && !(Ccb->CCBFlags & UDF_CCB_VOLUME_OPEN) &&
957 (Fcb->Vcb->CompatFlags & UDF_VCB_IC_DIRTY_RO)) {
958 AdPrint(("force R/O on dirty\n"));
959 ROCheck = TRUE;
960 }
961 if(ROCheck) {
962 #ifdef UDF_READ_ONLY_BUILD
963 treat_as_ro:
964 #endif //UDF_READ_ONLY_BUILD
965 ACCESS_MASK DesiredAccessMask = 0;
966
967 if(Fcb->Vcb->CompatFlags & UDF_VCB_IC_WRITE_IN_RO_DIR) {
968 if(Fcb->FCBFlags & UDF_FCB_DIRECTORY) {
969 DesiredAccessMask = (FILE_WRITE_EA |
970 DELETE);
971 } else {
972 DesiredAccessMask = (FILE_WRITE_DATA |
973 FILE_APPEND_DATA |
974 FILE_WRITE_EA |
975 DELETE);
976 }
977 } else {
978 DesiredAccessMask = (FILE_WRITE_DATA |
979 FILE_APPEND_DATA |
980 FILE_WRITE_EA |
981 FILE_DELETE_CHILD |
982 FILE_ADD_SUBDIRECTORY |
983 FILE_ADD_FILE |
984 DELETE);
985 }
986 if(DesiredAccess & DesiredAccessMask)
987 return STATUS_ACCESS_DENIED;
988 }
989 #ifdef UDF_ENABLE_SECURITY
990 // Check Security
991 // NOTE: we should not perform security check if an empty DesiredAccess
992 // was specified. AFAIU, SeAccessCheck() will return FALSE in this case.
993 SecDesc = UDFLookUpAcl(Fcb->Vcb, FileObject, Fcb);
994 if(SecDesc && DesiredAccess) {
995 SeCaptureSubjectContext(&SubjectContext);
996 SecurityCheck =
997 SeAccessCheck(SecDesc,
998 &SubjectContext,
999 FALSE,
1000 DesiredAccess,
1001 Ccb ? Ccb->PreviouslyGrantedAccess : 0,
1002 NULL,
1003 IoGetFileObjectGenericMapping(),
1004 UserMode,
1005 Ccb ? &(Ccb->PreviouslyGrantedAccess) : &LocalAccessMask,
1006 &RC);
1007 SeReleaseSubjectContext(&SubjectContext);
1008
1009 if(!SecurityCheck) {
1010 return RC;
1011 } else
1012 #endif //UDF_ENABLE_SECURITY
1013 if(DesiredAccess & ACCESS_SYSTEM_SECURITY) {
1014 if (!SeSinglePrivilegeCheck(SeExports->SeSecurityPrivilege, UserMode))
1015 return STATUS_ACCESS_DENIED;
1016 Ccb->PreviouslyGrantedAccess |= ACCESS_SYSTEM_SECURITY;
1017 }
1018 #ifdef UDF_ENABLE_SECURITY
1019 }
1020 #endif //UDF_ENABLE_SECURITY
1021 if(FileObject) {
1022 if (Fcb->OpenHandleCount) {
1023 // The FCB is currently in use by some thread.
1024 // We must check whether the requested access/share access
1025 // conflicts with the existing open operations.
1026 RC = IoCheckShareAccess(DesiredAccess, ShareAccess, FileObject,
1027 &(Fcb->NTRequiredFCB->FCBShareAccess), TRUE);
1028 #ifndef UDF_ENABLE_SECURITY
1029 if(Ccb)
1030 Ccb->PreviouslyGrantedAccess |= DesiredAccess;
1031 IoUpdateShareAccess(FileObject, &(Fcb->NTRequiredFCB->FCBShareAccess));
1032 #endif //UDF_ENABLE_SECURITY
1033 } else {
1034 IoSetShareAccess(DesiredAccess, ShareAccess, FileObject, &(Fcb->NTRequiredFCB->FCBShareAccess));
1035 #ifndef UDF_ENABLE_SECURITY
1036 if(Ccb)
1037 Ccb->PreviouslyGrantedAccess = DesiredAccess;
1038 #endif //UDF_ENABLE_SECURITY
1039 RC = STATUS_SUCCESS;
1040 }
1041 } else {
1042 // we get here if given file was opened for internal purposes
1043 RC = STATUS_SUCCESS;
1044 }
1045 return RC;
1046 } // end UDFCheckAccessRights()
1047
1048 NTSTATUS
1049 UDFSetAccessRights(
1050 PFILE_OBJECT FileObject,
1051 PACCESS_STATE AccessState,
1052 PtrUDFFCB Fcb,
1053 PtrUDFCCB Ccb,
1054 ACCESS_MASK DesiredAccess,
1055 USHORT ShareAccess
1056 )
1057 {
1058 #ifndef UDF_ENABLE_SECURITY
1059 ASSERT(Ccb);
1060 ASSERT(Fcb->FileInfo);
1061
1062 return UDFCheckAccessRights(FileObject, AccessState, Fcb, Ccb, DesiredAccess, ShareAccess);
1063
1064 #else //UDF_ENABLE_SECURITY
1065
1066 NTSTATUS RC;
1067 // Set Security on Object
1068 PSECURITY_DESCRIPTOR SecDesc;
1069 SECURITY_SUBJECT_CONTEXT SubjectContext;
1070 BOOLEAN AutoInherit;
1071
1072 ASSERT(Ccb);
1073 ASSERT(Fcb->FileInfo);
1074
1075 SecDesc = UDFLookUpAcl(Fcb->Vcb, FileObject, Fcb);
1076 AutoInherit = UDFIsAStreamDir(Fcb->FileInfo) || UDFIsAStream(Fcb->FileInfo);
1077
1078 if(SecDesc && !AutoInherit) {
1079 // Get caller's User/Primary Group info
1080 SeCaptureSubjectContext(&SubjectContext);
1081 RC = SeAssignSecurity(
1082 Fcb->FileInfo->ParentFile->Dloc->CommonFcb->SecurityDesc,
1083 // NULL,
1084 AccessState->SecurityDescriptor,
1085 &(Fcb->NTRequiredFCB->SecurityDesc),
1086 UDFIsADirectory(Fcb->FileInfo),
1087 &SubjectContext,
1088 IoGetFileObjectGenericMapping(),
1089 NonPagedPool);
1090 SeReleaseSubjectContext(&SubjectContext);
1091 UDFConvertToSelfRelative(&(Fcb->NTRequiredFCB->SecurityDesc));
1092
1093 if(!NT_SUCCESS(RC)) {
1094 Clean_Up_SD:
1095 UDFDeassignAcl(Fcb->NTRequiredFCB, AutoInherit);
1096 return RC;
1097 }
1098 }
1099
1100 RC = UDFCheckAccessRights(FileObject, AccessState, Fcb, Ccb, DesiredAccess, ShareAccess);
1101 if(!NT_SUCCESS(RC))
1102 goto Clean_Up_SD;
1103 return RC;
1104
1105 #endif //UDF_ENABLE_SECURITY
1106
1107 } // end UDFSetAccessRights()
1108