| /* |
| * Copyright (c) 2004, 2007, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| #include <stdio.h> |
| #include <windows.h> |
| #include <malloc.h> |
| #include <string.h> |
| |
| /* |
| * Simple Windows utility to remove all non-owner access to a given |
| * file - suitable for NT/2000/XP only. |
| */ |
| |
| |
| /* |
| * Access mask to represent any file access |
| */ |
| #define ANY_ACCESS (FILE_GENERIC_READ | FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE) |
| |
| |
| /* |
| * Print error message to stderr |
| */ |
| static void printLastError(const char* msg) { |
| int len; |
| char buf[128]; |
| DWORD errval; |
| |
| buf[0] = '\0'; |
| len = sizeof(buf); |
| |
| errval = GetLastError(); |
| if (errval != 0) { |
| int n = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS, |
| NULL, errval, |
| 0, buf, len, NULL); |
| if (n > 3) { |
| /* Drop final '.', CR, LF */ |
| if (buf[n - 1] == '\n') n--; |
| if (buf[n - 1] == '\r') n--; |
| if (buf[n - 1] == '.') n--; |
| buf[n] = '\0'; |
| } |
| } |
| |
| if (strlen(buf) > 0) { |
| fprintf(stderr, "revokeall %s: %s\n", msg, buf); |
| } else { |
| fprintf(stderr, "revokeall %s\n", msg); |
| } |
| } |
| |
| |
| |
| /* |
| * Return a string that includes all the components of a given SID. |
| * See here for a description of the SID components :- |
| * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/security/security/sid_components.asp |
| */ |
| static char *getTextualSid(SID* sid) { |
| SID_IDENTIFIER_AUTHORITY* sia; |
| DWORD i, count; |
| DWORD len; |
| char* name; |
| |
| /* |
| * Get the identifier authority and the number of sub-authorities |
| */ |
| sia = GetSidIdentifierAuthority(sid); |
| count = *GetSidSubAuthorityCount(sid); |
| |
| /* |
| * Allocate buffer for the string - buffer is :- |
| * S-SID_REVISION- + identifierAuthority- + subauthorities- + NULL |
| */ |
| len=(15 + 12 + (12 * count) + 1) * sizeof(char); |
| name = (char*)malloc(len); |
| if (name == NULL) { |
| return NULL; |
| } |
| |
| // S-SID_REVISION |
| sprintf(name, "S-%lu-", SID_REVISION ); |
| |
| // Identifier authority |
| if ((sia->Value[0] != 0) || (sia->Value[1] != 0)) |
| { |
| sprintf(name + strlen(name), "0x%02hx%02hx%02hx%02hx%02hx%02hx", |
| (USHORT)sia->Value[0], |
| (USHORT)sia->Value[1], |
| (USHORT)sia->Value[2], |
| (USHORT)sia->Value[3], |
| (USHORT)sia->Value[4], |
| (USHORT)sia->Value[5]); |
| } |
| else |
| { |
| sprintf(name + strlen(name), "%lu", |
| (ULONG)(sia->Value[5] ) + |
| (ULONG)(sia->Value[4] << 8) + |
| (ULONG)(sia->Value[3] << 16) + |
| (ULONG)(sia->Value[2] << 24) ); |
| } |
| |
| // finally, the sub-authorities |
| for (i=0 ; i<count; i++) { |
| sprintf(name + strlen(name), "-%lu", |
| *GetSidSubAuthority(sid, i) ); |
| } |
| |
| return name; |
| } |
| |
| /* |
| * Returns a string to represent the given security identifier (SID). |
| * If the account is known to the local computer then the account |
| * domain is returned. The format will be \\name or domain\\name depending |
| * on if the computer belongs to a domain. |
| * If the account name is not known then the textual representation of |
| * SID is returned -- eg: S-1-5-21-2818032319-470147023-1036452850-13037. |
| */ |
| static char *getSIDString(SID* sid) { |
| char domain[255]; |
| char name[255]; |
| DWORD domainLen = sizeof(domain); |
| DWORD nameLen = sizeof(name); |
| SID_NAME_USE use; |
| |
| if(!IsValidSid(sid)) { |
| return strdup("<Invalid SID>"); |
| } |
| |
| if (LookupAccountSid(NULL, sid, name, &nameLen, domain, &domainLen, &use)) { |
| int len = strlen(name) + strlen(domain) + 3; |
| char* s = (char*)malloc(len); |
| if (s != NULL) { |
| strcpy(s, domain); |
| strcat(s, "\\\\"); |
| strcat(s, name); |
| } |
| return s; |
| } else { |
| return getTextualSid(sid); |
| } |
| } |
| |
| |
| |
| /* |
| * Returns 1 if the specified file is on a file system that supports |
| * persistent ACLs (On NTFS file systems returns true, on FAT32 file systems |
| * returns false), otherwise 0. Returns -1 if error. |
| */ |
| static int isSecuritySupported(const char* path) { |
| char* root; |
| char* p; |
| BOOL res; |
| DWORD dwMaxComponentLength; |
| DWORD dwFlags; |
| char fsName[128]; |
| DWORD fsNameLength; |
| |
| /* |
| * Get root directory. For UNCs the slash after the share name is required. |
| */ |
| root = strdup(path); |
| if (*root == '\\') { |
| /* |
| * \\server\share\file ==> \\server\share\ |
| */ |
| int slashskip = 3; |
| p = root; |
| while ((*p == '\\') && (slashskip > 0)) { |
| char* p2; |
| p++; |
| p2 = strchr(p, '\\'); |
| if ((p2 == NULL) || (*p2 != '\\')) { |
| free(root); |
| fprintf(stderr, "Malformed UNC"); |
| return -1; |
| } |
| p = p2; |
| slashskip--; |
| } |
| if (slashskip != 0) { |
| free(root); |
| fprintf(stderr, "Malformed UNC"); |
| return -1; |
| } |
| p++; |
| *p = '\0'; |
| |
| } else { |
| p = strchr(root, '\\'); |
| |
| /* |
| * Relative path so use current directory |
| */ |
| if (p == NULL) { |
| free(root); |
| root = malloc(255); |
| if (GetCurrentDirectory(255, root) == 0) { |
| printLastError("GetCurrentDirectory failed"); |
| return -1; |
| } |
| p = strchr(root, '\\'); |
| if (p == NULL) { |
| fprintf(stderr, "GetCurrentDirectory doesn't include drive letter!!!!\n"); |
| return -1; |
| } |
| } |
| p++; |
| *p = '\0'; |
| } |
| |
| /* |
| * Get the volume information - this gives us the file system file and |
| * also tells us if the file system supports persistent ACLs. |
| */ |
| fsNameLength = sizeof(fsName)-1; |
| res = GetVolumeInformation(root, |
| NULL, // address of name of the volume, can be NULL |
| 0, // length of volume name |
| NULL, // address of volume serial number, can be NULL |
| &dwMaxComponentLength, |
| &dwFlags, |
| fsName, |
| fsNameLength); |
| if (res == 0) { |
| printLastError("GetVolumeInformation failed"); |
| free(root); |
| return -1; |
| } |
| |
| free(root); |
| return (dwFlags & FS_PERSISTENT_ACLS) ? 1 : 0; |
| } |
| |
| |
| /* |
| * Returns the security descriptor for a file. |
| */ |
| static SECURITY_DESCRIPTOR* getFileSecurityDescriptor(const char* path) { |
| SECURITY_DESCRIPTOR* sd; |
| DWORD len = 0; |
| SECURITY_INFORMATION info = |
| OWNER_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION; |
| |
| GetFileSecurity(path, info , 0, 0, &len); |
| if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) { |
| printLastError("GetFileSecurity failed"); |
| return NULL; |
| } |
| sd = (SECURITY_DESCRIPTOR *)malloc(len); |
| if (sd == NULL) { |
| fprintf(stderr, "Out of memory"); |
| } else { |
| if (!GetFileSecurity(path, info, sd, len, &len)) { |
| printLastError("GetFileSecurity failed"); |
| free(sd); |
| return NULL; |
| } |
| } |
| return sd; |
| } |
| |
| |
| /* |
| * Revoke all access to the specific file |
| */ |
| static int revokeAll(const char* path) { |
| SECURITY_DESCRIPTOR* sd; |
| SID* owner; |
| ACL *acl; |
| BOOL defaulted, present; |
| ACL_SIZE_INFORMATION acl_size_info; |
| DWORD i, count; |
| char* str; |
| |
| /* |
| * Get security descriptor for file; From security descriptor get the |
| * owner SID, and the DACL. |
| */ |
| sd = getFileSecurityDescriptor(path); |
| if (sd == NULL) { |
| return -1; /* error already reported */ |
| } |
| if (!GetSecurityDescriptorOwner(sd, &owner, &defaulted)) { |
| printLastError("GetSecurityDescriptorOwner failed"); |
| return -1; |
| } |
| str = getSIDString(owner); |
| if (str != NULL) { |
| printf("owner: %s\n", str); |
| free(str); |
| } |
| if (!GetSecurityDescriptorDacl(sd, &present, &acl, &defaulted)) { |
| printLastError("GetSecurityDescriptorDacl failed"); |
| return -1; |
| } |
| if (!present) { |
| fprintf(stderr, "Security descriptor does not contain a DACL"); |
| return -1; |
| } |
| |
| /* |
| * If DACL is NULL there is no access to the file - we are done |
| */ |
| if (acl == NULL) { |
| return 1; |
| } |
| |
| /* |
| * Iterate over the ACEs. For each "allow" type check that the SID |
| * matches the owner - if not we remove the ACE from the ACL |
| */ |
| if (!GetAclInformation(acl, (void *) &acl_size_info, sizeof(acl_size_info), |
| AclSizeInformation)) { |
| printLastError("GetAclInformation failed"); |
| return -1; |
| } |
| count = acl_size_info.AceCount; |
| i = 0; |
| while (count > 0) { |
| void* ace; |
| ACCESS_ALLOWED_ACE *access; |
| SID* sid; |
| BOOL deleted; |
| |
| if (!GetAce(acl, i, &ace)) { |
| printLastError("GetAce failed"); |
| return -1; |
| } |
| if (((ACCESS_ALLOWED_ACE *)ace)->Header.AceType != ACCESS_ALLOWED_ACE_TYPE) { |
| continue; |
| } |
| access = (ACCESS_ALLOWED_ACE *)ace; |
| sid = (SID *) &access->SidStart; |
| |
| |
| deleted = FALSE; |
| if (!EqualSid(owner, sid)) { |
| /* |
| * If the ACE allows any access then the file then we |
| * delete it. |
| */ |
| if (access->Mask & ANY_ACCESS) { |
| str = getSIDString(sid); |
| if (str != NULL) { |
| printf("remove ALLOW %s\n", str); |
| free(str); |
| } |
| if (DeleteAce(acl, i) == 0) { |
| printLastError("DeleteAce failed"); |
| return -1; |
| } |
| deleted = TRUE; |
| } |
| } |
| |
| if (!deleted) { |
| str = getSIDString(sid); |
| if (str != NULL) { |
| printf("ALLOW %s (access mask=%x)\n", str, access->Mask); |
| free(str); |
| } |
| |
| /* onto the next ACE */ |
| i++; |
| } |
| count--; |
| } |
| |
| /* |
| * No changes - only owner has access |
| */ |
| if (i == acl_size_info.AceCount) { |
| printf("No changes.\n"); |
| return 1; |
| } |
| |
| /* |
| * Create security descriptor and set its DACL to the version |
| * that we just edited |
| */ |
| if (!InitializeSecurityDescriptor(sd, SECURITY_DESCRIPTOR_REVISION)) { |
| printLastError("InitializeSecurityDescriptor failed"); |
| return -1; |
| } |
| if (!SetSecurityDescriptorDacl(sd, present, acl, defaulted)) { |
| printLastError("SetSecurityDescriptorDacl failed"); |
| return -1; |
| } |
| if (!SetFileSecurity(path, DACL_SECURITY_INFORMATION, sd)) { |
| printLastError("SetFileSecurity failed"); |
| return -1; |
| } |
| |
| printf("File updated.\n"); |
| |
| return 1; |
| } |
| |
| /* |
| * Convert slashes in the pathname to backslashes if needed. |
| */ |
| static char* convert_path(const char* p) { |
| int i = 0; |
| char* path = strdup(p); |
| while (p[i] != '\0') { |
| if (p[i] == '/') { |
| path[i] = '\\'; |
| } |
| i++; |
| } |
| return path; |
| } |
| |
| /* |
| * Usage: revokeall file |
| */ |
| int main( int argc, char *argv[]) |
| { |
| int rc; |
| const char* path; |
| |
| if (argc != 2) { |
| fprintf(stderr, "Usage: %s file\n", argv[0]); |
| return -1; |
| } |
| path = convert_path(argv[1]); |
| printf("Revoking all non-owner access to %s\n", path); |
| rc = isSecuritySupported(path); |
| if (rc != 1) { |
| if (rc == 0) { |
| printf("File security not supported on this file system\n"); |
| } |
| return rc; |
| } else { |
| return revokeAll(path); |
| } |
| } |
