mDNSMacOSX/PreferencePane/PrivilegedOperations.c

   1 /*
   2     File: PrivilegedOperations.c
   3
   4     Abstract: Interface to "ddnswriteconfig" setuid root tool.
   5
   6     Copyright: (c) Copyright 2005 Apple Computer, Inc. All rights reserved.
   7
   8     Disclaimer: IMPORTANT: This Apple software is supplied to you by Apple Computer, Inc.
   9     ("Apple") in consideration of your agreement to the following terms, and your
  10     use, installation, modification or redistribution of this Apple software
  11     constitutes acceptance of these terms.  If you do not agree with these terms,
  12     please do not use, install, modify or redistribute this Apple software.
  13
  14     In consideration of your agreement to abide by the following terms, and subject
  15     to these terms, Apple grants you a personal, non-exclusive license, under Apple's
  16     copyrights in this original Apple software (the "Apple Software"), to use,
  17     reproduce, modify and redistribute the Apple Software, with or without
  18     modifications, in source and/or binary forms; provided that if you redistribute
  19     the Apple Software in its entirety and without modifications, you must retain
  20     this notice and the following text and disclaimers in all such redistributions of
  21     the Apple Software.  Neither the name, trademarks, service marks or logos of
  22     Apple Computer, Inc. may be used to endorse or promote products derived from the
  23     Apple Software without specific prior written permission from Apple.  Except as
  24     expressly stated in this notice, no other rights or licenses, express or implied,
  25     are granted by Apple herein, including but not limited to any patent rights that
  26     may be infringed by your derivative works or by other works in which the Apple
  27     Software may be incorporated.
  28
  29     The Apple Software is provided by Apple on an "AS IS" basis.  APPLE MAKES NO
  30     WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED
  31     WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  32     PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE OR IN
  33     COMBINATION WITH YOUR PRODUCTS.
  34
  35     IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR
  36     CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  37     GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38     ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION
  39     OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, TORT
  40     (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN
  41     ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  42
  43     Change History (most recent first):
  44
  45 $Log: PrivilegedOperations.c,v $
  46 Revision 1.9  2008/06/26 17:34:18  mkrochma
  47 <rdar://problem/6030630> Pref pane destroying shared "system.preferences" authorization right
  48
  49 Revision 1.8  2007/11/30 23:42:33  cheshire
  50 Fixed compile warning: declaration of 'status' shadows a previous local
  51
  52 Revision 1.7  2007/02/09 00:39:06  cheshire
  53 Fix compile warnings
  54
  55 Revision 1.6  2006/08/14 23:15:47  cheshire
  56 Tidy up Change History comment
  57
  58 Revision 1.5  2006/06/10 02:07:11  mkrochma
  59 Whoa.  Make sure code compiles before checking it in.
  60
  61 Revision 1.4  2006/05/27 02:32:38  mkrochma
  62 Wait for installer script to exit before returning result
  63
  64 Revision 1.3  2005/06/04 04:50:00  cheshire
  65 <rdar://problem/4138070> ddnswriteconfig (Bonjour PreferencePane) vulnerability
  66 Use installtool instead of requiring ddnswriteconfig to self-install
  67
  68 Revision 1.2  2005/02/10 22:35:20  cheshire
  69 <rdar://problem/3727944> Update name
  70
  71 Revision 1.1  2005/02/05 01:59:19  cheshire
  72 Add Preference Pane to facilitate testing of DDNS & wide-area features
  73
  74 */
  75
  76 #include "PrivilegedOperations.h"
  77 #include "ConfigurationAuthority.h"
  78 #include <CoreFoundation/CoreFoundation.h>
  79 #include <SystemConfiguration/SystemConfiguration.h>
  80 #include <stdio.h>
  81 #include <stdint.h>
  82 #include <stdlib.h>
  83 #include <unistd.h>
  84 #include <sys/wait.h>
  85 #include <AssertMacros.h>
  86 #include <Security/Security.h>
  87
  88 Boolean gToolApproved = false;
  89
  90 static pid_t    execTool(const char *args[])
  91 // fork/exec and return new pid
  92 {
  93         pid_t   child;
  94
  95         child = vfork();
  96         if (child == 0)
  97         {
  98                 execv(args[0], (char *const *)args);
  99 printf("exec of %s failed; errno = %d\n", args[0], errno);
 100                 _exit(-1);              // exec failed
 101         }
 102         else
 103                 return child;
 104 }
 105
 106 OSStatus EnsureToolInstalled(void)
 107 // Make sure that the tool is installed in the right place, with the right privs, and the right version.
 108 {
 109         CFURLRef                bundleURL;
 110         pid_t                   toolPID;
 111         int                             status;
 112         OSStatus                err = noErr;
 113         const char              *args[] = { kToolPath, "0", "V", NULL };
 114         char                    toolSourcePath[PATH_MAX] = {};
 115         char                    toolInstallerPath[PATH_MAX] = {};
 116
 117         if (gToolApproved)
 118                 return noErr;
 119
 120         // Check version of installed tool
 121         toolPID = execTool(args);
 122         if (toolPID > 0)
 123         {
 124                 waitpid(toolPID, &status, 0);
 125                 if (WIFEXITED(status) && WEXITSTATUS(status) == PRIV_OP_TOOL_VERS)
 126                         return noErr;
 127         }
 128
 129         // Locate our in-bundle copy of privop tool
 130         bundleURL = CFBundleCopyBundleURL(CFBundleGetBundleWithIdentifier(CFSTR("com.apple.preference.bonjour")) );
 131         if (bundleURL != NULL)
 132         {
 133                 CFURLGetFileSystemRepresentation(bundleURL, false, (UInt8*) toolSourcePath, sizeof toolSourcePath);
 134                 if (strlcat(toolSourcePath,    "/Contents/Resources/" kToolName,      sizeof toolSourcePath   ) >= sizeof toolSourcePath   ) return(-1);
 135                 CFURLGetFileSystemRepresentation(bundleURL, false, (UInt8*) toolInstallerPath, sizeof toolInstallerPath);
 136                 if (strlcat(toolInstallerPath, "/Contents/Resources/" kToolInstaller, sizeof toolInstallerPath) >= sizeof toolInstallerPath) return(-1);
 137         }
 138         else
 139                 return coreFoundationUnknownErr;
 140
 141         // Obtain authorization and run in-bundle copy as root to install it
 142         {
 143                 AuthorizationItem               aewpRight = { kAuthorizationRightExecute, strlen(toolInstallerPath), toolInstallerPath, 0 };
 144                 AuthorizationItemSet    rights = { 1, &aewpRight };
 145                 AuthorizationRef                authRef;
 146
 147                 err = AuthorizationCreate(&rights, (AuthorizationEnvironment*) NULL,
 148                                         kAuthorizationFlagInteractionAllowed | kAuthorizationFlagExtendRights |
 149                                         kAuthorizationFlagPreAuthorize, &authRef);
 150                 if (err == noErr)
 151                 {
 152                         char *installerargs[] = { toolSourcePath, NULL };
 153                         err = AuthorizationExecuteWithPrivileges(authRef, toolInstallerPath, 0, installerargs, (FILE**) NULL);
 154                         if (err == noErr) {
 155                                 int pid = wait(&status);
 156                                 if (pid > 0 && WIFEXITED(status)) {
 157                                         err = WEXITSTATUS(status);
 158                                         if (err == noErr) {
 159                                                 gToolApproved = true;
 160                                         }
 161                                 } else {
 162                                         err = -1;
 163                                 }
 164                         }
 165                         (void) AuthorizationFree(authRef, kAuthorizationFlagDefaults);
 166                 }
 167         }
 168
 169         return err;
 170 }
 171
 172
 173 static OSStatus ExecWithCmdAndParam(const char *subCmd, CFDataRef paramData)
 174 // Execute our privop tool with the supplied subCmd and parameter
 175 {
 176         OSStatus                                err = noErr;
 177         int                                             commFD, dataLen;
 178         u_int32_t                               len;
 179         pid_t                                   child;
 180         char                                    fileNum[16];
 181         UInt8                                   *buff;
 182         const char                              *args[] = { kToolPath, NULL, "A", NULL, NULL };
 183         AuthorizationExternalForm       authExt;
 184
 185         err = ExternalizeAuthority(&authExt);
 186         require_noerr(err, AuthFailed);
 187
 188         dataLen = CFDataGetLength(paramData);
 189         buff = (UInt8*) malloc(dataLen * sizeof(UInt8));
 190         require_action(buff != NULL, AllocBuffFailed, err=memFullErr;);
 191         {
 192                 CFRange all = { 0, dataLen };
 193                 CFDataGetBytes(paramData, all, buff);
 194         }
 195
 196         commFD = fileno(tmpfile());
 197         sprintf(fileNum, "%d", commFD);
 198         args[1] = fileNum;
 199         args[3] = subCmd;
 200
 201         // write authority to pipe
 202         len = 0;        // tag, unused
 203         write(commFD, &len, sizeof len);
 204         len = sizeof authExt;   // len
 205         write(commFD, &len, sizeof len);
 206         write(commFD, &authExt, len);
 207
 208         // write parameter to pipe
 209         len = 0;        // tag, unused
 210         write(commFD, &len, sizeof len);
 211         len = dataLen;  // len
 212         write(commFD, &len, sizeof len);
 213         write(commFD, buff, len);
 214
 215         child = execTool(args);
 216         if (child > 0) {
 217                 int     status;
 218                 waitpid(child, &status, 0);
 219                 if (WIFEXITED(status))
 220                         err = WEXITSTATUS(status);
 221                 //fprintf(stderr, "child exited; status = %d (%ld)\n", status, err);
 222         }
 223
 224         close(commFD);
 225
 226         free(buff);
 227 AllocBuffFailed:
 228 AuthFailed:
 229         return err;
 230 }
 231
 232 OSStatus
 233 WriteBrowseDomain(CFDataRef domainArrayData)
 234 {
 235         if (!CurrentlyAuthorized())
 236                 return authFailErr;
 237         return ExecWithCmdAndParam("Wb", domainArrayData);
 238 }
 239
 240 OSStatus
 241 WriteRegistrationDomain(CFDataRef domainArrayData)
 242 {
 243         if (!CurrentlyAuthorized())
 244                 return authFailErr;
 245         return ExecWithCmdAndParam("Wd", domainArrayData);
 246 }
 247
 248 OSStatus
 249 WriteHostname(CFDataRef domainArrayData)
 250 {
 251         if (!CurrentlyAuthorized())
 252                 return authFailErr;
 253         return ExecWithCmdAndParam("Wh", domainArrayData);
 254 }
 255
 256 OSStatus
 257 SetKeyForDomain(CFDataRef secretData)
 258 {
 259         if (!CurrentlyAuthorized())
 260                 return authFailErr;
 261         return ExecWithCmdAndParam("Wk", secretData);
 262 }