1  /*
  2   * Copyright (c) 2006-2010,2012-2014 Apple Inc. All Rights Reserved.
  3   *
  4   * @APPLE_LICENSE_HEADER_START@
  5   * 
  6   * This file contains Original Code and/or Modifications of Original Code
  7   * as defined in and that are subject to the Apple Public Source License
  8   * Version 2.0 (the 'License'). You may not use this file except in
  9   * compliance with the License. Please obtain a copy of the License at
 10   * http://www.opensource.apple.com/apsl/ and read it before using this
 11   * file.
 12   * 
 13   * The Original Code and all software distributed under the License are
 14   * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 15   * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 16   * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 17   * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 18   * Please see the License for the specific language governing rights and
 19   * limitations under the License.
 20   * 
 21   * @APPLE_LICENSE_HEADER_END@
 22   */
 23  
 24  
 25  /*
 26   * debugging.c - non-trivial debug support
 27   */
 28  #include "utilities/debugging.h"
 29  #include "utilities/debugging_test.h"
 30  #include "utilities/SecCFWrappers.h"
 31  #include "utilities/SecFileLocations.h"
 32  #include <CoreFoundation/CFSet.h>
 33  #include <CoreFoundation/CFString.h>
 34  #include <CoreFoundation/CFPreferences.h>
 35  
 36  #include <dispatch/dispatch.h>
 37  
 38  #include <stdarg.h>
 39  #include <stdlib.h>
 40  #include <stdio.h>
 41  #include <string.h>
 42  #include <pthread.h>
 43  #include <asl.h>
 44  #include <os/trace.h>
 45  #include <os/log_private.h>
 46  #include <sqlite3.h>
 47  #include <os/lock_private.h>
 48  
 49  const char *api_trace = "api_trace";
 50  
 51  
 52  const CFStringRef kStringNegate = CFSTR("-");
 53  const CFStringRef kStringAll = CFSTR("all");
 54  
 55  const CFStringRef kAPIScope = CFSTR("api");
 56  
 57  static CFMutableArrayRef sLogSettings = NULL; /* Either sets or dictionaries of level => set. */
 58  
 59  static dispatch_queue_t GetDispatchControlQueue(void) {
 60      static dispatch_queue_t sLoggingScopeControlQueue;
 61      static dispatch_once_t onceToken;
 62      dispatch_once(&onceToken, ^{
 63          sLoggingScopeControlQueue = dispatch_queue_create("security scope control", DISPATCH_QUEUE_CONCURRENT);
 64      });
 65      return sLoggingScopeControlQueue;
 66  }
 67  
 68  static void with_scopes_read(dispatch_block_t action) {
 69      dispatch_sync(GetDispatchControlQueue(), action);
 70  }
 71  
 72  static void with_scopes_write(dispatch_block_t action) {
 73      dispatch_barrier_sync(GetDispatchControlQueue(), action);
 74  }
 75  
 76  bool IsScopeActive(int level, CFStringRef scope)
 77  {
 78      if (scope == NULL)
 79          return true;
 80  
 81      CFNumberRef level_number = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &level);
 82  
 83      __block bool isActive = false;
 84      with_scopes_read(^{
 85          if (sLogSettings) {
 86              CFArrayForEach(sLogSettings, ^(const void *value) {
 87                  CFSetRef setToCheck = NULL;
 88  
 89                  if (isSet(value)) {
 90                      setToCheck = (CFSetRef) value;
 91                  } else if (isDictionary(value)) {
 92                      CFDictionaryRef levels = (CFDictionaryRef) value;
 93  
 94                      setToCheck = CFDictionaryGetValue(levels, level_number);
 95  
 96                      if (!isSet(setToCheck))
 97                          setToCheck = NULL;
 98                  }
 99  
100                  if (setToCheck != NULL && !isActive) {
101                      bool negated = CFSetContainsValue(setToCheck, kStringNegate);
102                      bool inSet = CFSetContainsValue(setToCheck, scope);
103  
104                      isActive = negated ^ inSet;
105                  }
106              });
107          }
108      });
109  
110      CFReleaseNull(level_number);
111  
112      return isActive;
113  }
114  
115  bool IsScopeActiveC(int level, const char *scope)
116  {
117      CFStringRef scopeString = CFStringCreateWithBytes(kCFAllocatorDefault, (const uint8_t*)scope, strlen(scope), kCFStringEncodingUTF8, false);
118      bool isActive = IsScopeActive(level, scopeString);
119      CFReleaseNull(scopeString);
120  
121      return isActive;
122  }
123  
124  
125  static CFMutableSetRef CopyScopesFromScopeList(CFStringRef scopes) {
126      CFMutableSetRef resultSet = CFSetCreateMutableForCFTypes(kCFAllocatorDefault);
127  
128      CFStringRef allocated_scope_list = NULL;
129      CFStringRef clean_scope_list = scopes;
130      bool add_negate = false;
131  
132      if (CFStringHasPrefix(scopes, kStringNegate)) {
133          allocated_scope_list = CFStringCreateWithSubstring(kCFAllocatorDefault, scopes, CFRangeMake(CFStringGetLength(kStringNegate), CFStringGetLength(scopes) - 1));
134          clean_scope_list = allocated_scope_list;
135          add_negate = true;
136      }
137  
138      CFArrayRef commaArray = CFStringCreateArrayBySeparatingStrings(kCFAllocatorDefault, clean_scope_list, CFSTR(","));
139  
140      if (commaArray) {
141          CFArrayForEach(commaArray, ^(const void *value) {
142              if (isString(value)) {
143                  CFMutableStringRef copy = CFStringCreateMutableCopy(kCFAllocatorDefault, 0, (CFStringRef) value);
144                  CFStringTrimWhitespace(copy);
145                  CFSetSetValue(resultSet, copy);
146                  CFReleaseNull(copy);
147              }
148          });
149      }
150  
151      CFSetRemoveValue(resultSet, CFSTR("none"));
152      CFSetRemoveValue(resultSet, CFSTR(""));
153  
154      if (CFSetContainsValue(resultSet, CFSTR("all"))) {
155          CFSetRemoveAllValues(resultSet);
156          add_negate = !add_negate;
157      }
158  
159      if (add_negate)
160          CFSetSetValue(resultSet, kStringNegate);
161  
162      CFReleaseNull(commaArray);
163      CFReleaseNull(allocated_scope_list);
164  
165      return resultSet;
166  }
167  
168  static CFMutableArrayRef CFArrayCreateMutableForCFTypesFilledWithCFNull(CFAllocatorRef allocator, CFIndex capacity) {
169      CFMutableArrayRef result = CFArrayCreateMutableForCFTypesWithCapacity(kCFAllocatorDefault, kScopeIDMax);
170  
171      for(int count = 0; count <= capacity; ++count)
172          CFArrayAppendValue(result, kCFNull);
173  
174      return result;
175  }
176  
177  static bool CFArrayIsAll(CFArrayRef array, const void *value)
178  {
179      return CFArrayGetCountOfValue(array, CFRangeMake(0, CFArrayGetCount(array)), value) == CFArrayGetCount(array);
180  }
181  
182  static void SetNthScopeSet(int nth, CFTypeRef collection)
183  {
184      with_scopes_write(^{
185          if (sLogSettings == NULL) {
186              sLogSettings = CFArrayCreateMutableForCFTypesFilledWithCFNull(kCFAllocatorDefault, kScopeIDMax);
187          }
188  
189          CFArraySetValueAtIndex(sLogSettings, nth, collection);
190  
191          if (CFArrayIsAll(sLogSettings, kCFNull)) {
192              CFReleaseNull(sLogSettings);
193          }
194      });
195  }
196  
197  static int string_to_log_level(CFStringRef string) {
198      if (CFEqual(string, CFSTR(ASL_STRING_EMERG)))
199          return SECLOG_LEVEL_EMERG;
200      else if (CFEqual(string, CFSTR(ASL_STRING_ALERT)))
201          return SECLOG_LEVEL_ALERT;
202      else if (CFEqual(string, CFSTR(ASL_STRING_CRIT)))
203          return SECLOG_LEVEL_CRIT;
204      else if (CFEqual(string, CFSTR(ASL_STRING_ERR)))
205          return SECLOG_LEVEL_ERR;
206      else if (CFEqual(string, CFSTR(ASL_STRING_WARNING)))
207          return SECLOG_LEVEL_WARNING;
208      else if (CFEqual(string, CFSTR(ASL_STRING_NOTICE)))
209          return SECLOG_LEVEL_NOTICE;
210      else if (CFEqual(string, CFSTR(ASL_STRING_INFO)))
211          return SECLOG_LEVEL_INFO;
212      else if (CFEqual(string, CFSTR(ASL_STRING_DEBUG)))
213          return SECLOG_LEVEL_DEBUG;
214      else
215          return -1;
216  }
217  
218  static CFMutableArrayRef CFSetOfCFObjectsCopyValues(CFSetRef setOfCFs)
219  {
220      CFMutableArrayRef result = CFArrayCreateMutableForCFTypes(kCFAllocatorDefault);
221  
222      CFSetForEach(setOfCFs, ^(const void *value) {
223          CFArrayAppendValue(result, value);
224      });
225  
226      return result;
227  }
228  
229  CFPropertyListRef CopyCurrentScopePlist(void)
230  {
231      CFMutableArrayRef result = CFArrayCreateMutableForCFTypes(kCFAllocatorDefault);
232      with_scopes_read(^{
233          CFArrayForEach(sLogSettings, ^(const void *value) {
234              if (isSet(value)) {
235                  CFArrayRef values = CFSetOfCFObjectsCopyValues((CFSetRef) value);
236                  CFArrayAppendValue(result, values);
237                  CFReleaseNull(values);
238              } else if (isDictionary(value)) {
239                  CFMutableDictionaryRef levels = CFDictionaryCreateMutableForCFTypes(kCFAllocatorDefault);
240  
241                  CFDictionaryForEach((CFDictionaryRef) value, ^(const void *key, const void *value) {
242                      if (isSet(value)) {
243                          CFArrayRef values = CFSetOfCFObjectsCopyValues((CFSetRef) value);
244                          CFDictionaryAddValue(levels, key, values);
245                          CFReleaseNull(values);
246                      }
247                  });
248  
249                  CFArrayAppendValue(result, levels);
250              } else {
251                  CFArrayAppendValue(result, kCFNull);
252              }
253          });
254      });
255      return result;
256  }
257  
258  void ApplyScopeDictionaryForID(CFDictionaryRef scopeDictionary, SecDebugScopeID whichID)
259  {
260      CFMutableDictionaryRef dictionary_for_id = CFDictionaryCreateMutableForCFTypes(kCFAllocatorDefault);
261  
262      CFDictionaryForEach(scopeDictionary, ^(const void *key, const void *value) {
263          CFSetRef scope_set = NULL;
264          CFNumberRef key_number = NULL;
265          if (isString(key)) {
266              int level = string_to_log_level((CFStringRef) key);
267  
268              if (level >= 0)
269                  key_number = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &level);
270          } else if (isNumber(key)) {
271              key_number = CFRetainSafe(key);
272          }
273  
274          if (isString(value)) {
275              scope_set = CopyScopesFromScopeList(value);
276          }
277  
278          if (key_number && scope_set)
279              CFDictionaryAddValue(dictionary_for_id, key_number, scope_set);
280  
281          CFReleaseNull(key_number);
282          CFReleaseNull(scope_set);
283      });
284  
285      if (CFDictionaryGetCount(dictionary_for_id) > 0) {
286          SetNthScopeSet(whichID, dictionary_for_id);
287      }
288  
289      CFReleaseNull(dictionary_for_id);
290  }
291  
292  void ApplyScopeListForID(CFStringRef scopeList, SecDebugScopeID whichID)
293  {
294      CFMutableSetRef scopesToUse = CopyScopesFromScopeList(scopeList);
295  
296      SetNthScopeSet(whichID, scopesToUse);
297  
298      CFReleaseNull(scopesToUse);
299  }
300  
301  void ApplyScopeListForIDC(const char *scopeList, SecDebugScopeID whichID) {
302      CFStringRef scope_string = CFStringCreateWithCStringNoCopy(kCFAllocatorDefault, scopeList, kCFStringEncodingUTF8, kCFAllocatorNull);
303  
304      ApplyScopeListForID(scope_string, whichID);
305  
306      CFReleaseNull(scope_string);
307  }
308  
309  #pragma mark - Log Handlers to catch log information
310  
311  
312  /*
313   * Instead of using CFPropertyListReadFromFile we use a
314   * CFPropertyListCreateWithStream directly
315   * here. CFPropertyListReadFromFile() uses
316   * CFURLCopyResourcePropertyForKey() andCF pulls in CoreServices for
317   * CFURLCopyResourcePropertyForKey() and that doesn't work in install
318   * environment.
319   */
320  
321  static CFPropertyListRef
322  CopyPlistFromFile(CFURLRef url)
323  {
324      CFDictionaryRef d = NULL;
325      CFReadStreamRef s = CFReadStreamCreateWithFile(kCFAllocatorDefault, url);
326      if (s && CFReadStreamOpen(s)) {
327  	    d = (CFDictionaryRef)CFPropertyListCreateWithStream(kCFAllocatorDefault, s, 0, kCFPropertyListImmutable, NULL, NULL);
328  	}
329      CFReleaseSafe(s);
330  
331      return d;
332  }
333  
334  static void ApplyScopeByTypeForID(CFPropertyListRef scopes, SecDebugScopeID whichID) {
335      if (isDictionary(scopes)) {
336          ApplyScopeDictionaryForID(scopes, whichID);
337      } else if (isString(scopes)) {
338          ApplyScopeListForID(scopes, whichID);
339      }
340  }
341  
342  static void setup_config_settings() {
343      CFStringRef logFileName;
344  #if TARGET_OS_IPHONE
345      logFileName = CFSTR(".GlobalPreferences.plist");
346  #else
347      logFileName = CFSTR("com.apple.security.logging.plist");
348  #endif
349      CFURLRef prefURL = SecCopyURLForFileInManagedPreferencesDirectory(logFileName);
350      if(prefURL) {
351          CFPropertyListRef plist = CopyPlistFromFile(prefURL);
352          if (plist) {
353              ApplyScopeByTypeForID(CFDictionaryGetValue(plist, CFSTR("SecLogging")), kScopeIDConfig);
354          }
355          CFReleaseSafe(plist);
356      }
357      CFReleaseSafe(prefURL);
358  }
359  
360  static void setup_defaults_settings() {
361      CFPropertyListRef scopes_value = CFPreferencesCopyValue(CFSTR("Logging"), CFSTR("com.apple.security"), kCFPreferencesAnyUser, kCFPreferencesCurrentHost);
362  
363      ApplyScopeByTypeForID(scopes_value, kScopeIDDefaults);
364  
365      CFReleaseSafe(scopes_value);
366  }
367  
368  static void setup_circle_defaults_settings() {
369      CFPropertyListRef scopes_value = CFPreferencesCopyValue(CFSTR("Circle-Logging"), CFSTR("com.apple.security"), kCFPreferencesAnyUser, kCFPreferencesCurrentHost);
370  
371      ApplyScopeByTypeForID(scopes_value, kScopeIDDefaults);
372  
373      CFReleaseSafe(scopes_value);
374  }
375  
376  static void setup_environment_scopes() {
377      const char *cur_scope = getenv("DEBUGSCOPE");
378      if (cur_scope == NULL)
379          cur_scope = "";
380  
381      ApplyScopeListForIDC(cur_scope, kScopeIDEnvironment);
382  }
383  
384  
385  void __security_debug_init(void) {
386      static dispatch_once_t sdOnceToken;
387  
388      dispatch_once(&sdOnceToken, ^{
389          setup_environment_scopes();
390          setup_config_settings();
391          setup_defaults_settings();
392          setup_circle_defaults_settings();
393      });
394  }
395  
396  
397  os_log_t
398  secLogObjForCFScope(CFStringRef scope)
399  {
400      os_log_t retval = OS_LOG_DISABLED;
401      static os_unfair_lock lock = OS_UNFAIR_LOCK_INIT;
402      static CFMutableDictionaryRef scopeMap = NULL;
403  
404      if (scope == NULL) {
405          scope = CFSTR("logging");
406      }
407  
408      os_unfair_lock_lock_with_options(&lock, OS_UNFAIR_LOCK_DATA_SYNCHRONIZATION);
409  
410      if (scopeMap == NULL) {
411          scopeMap = CFDictionaryCreateMutable(kCFAllocatorDefault, 0, &kCFCopyStringDictionaryKeyCallBacks, NULL);
412      }
413  
414      retval = (os_log_t)CFDictionaryGetValue(scopeMap, scope);
415      if (retval == NULL) {
416          CFStringPerformWithCString(scope, ^(const char *scopeStr) {
417              CFDictionaryAddValue(scopeMap, scope, os_log_create("com.apple.securityd", scopeStr));
418          });
419          retval = (os_log_t)CFDictionaryGetValue(scopeMap, scope);
420      }
421  
422      os_unfair_lock_unlock(&lock);
423  
424      return retval;
425  }
426  
427  static bool loggingEnabled = true;
428  static pthread_mutex_t loggingMutex = PTHREAD_MUTEX_INITIALIZER;
429  
430  bool secLogEnabled(void) {
431      bool r = false;
432      pthread_mutex_lock(&loggingMutex);
433      r = loggingEnabled;
434      pthread_mutex_unlock(&loggingMutex);
435      return r;
436  }
437  void secLogDisable(void) {
438      pthread_mutex_lock(&loggingMutex);
439      loggingEnabled = false;
440      pthread_mutex_unlock(&loggingMutex);
441  }
442  
443  void secLogEnable(void) {
444      pthread_mutex_lock(&loggingMutex);
445      loggingEnabled = true;
446      pthread_mutex_unlock(&loggingMutex);
447  }
448  
449  os_log_t secLogObjForScope(const char *scope) {
450      if (!secLogEnabled())
451          return OS_LOG_DISABLED;
452      CFStringRef cfscope = NULL;
453      if(scope) cfscope =  CFStringCreateWithCString(kCFAllocatorDefault, scope, kCFStringEncodingASCII);
454      os_log_t retval = secLogObjForCFScope(cfscope);
455      CFReleaseNull(cfscope);
456      return retval;
457  }
458  
459  
460  
461  CFStringRef SecLogAPICreate(bool apiIn, const char *api, CFStringRef format, ... ) {
462      CFMutableStringRef outStr = CFStringCreateMutable(kCFAllocatorDefault, 0);
463  
464      char *direction = apiIn ? "ENTER" : "RETURN";
465      va_list args;
466      va_start(args, format);
467  
468      CFStringAppend(outStr, CFSTR("SecAPITrace "));
469      CFStringAppendCString(outStr, api, kCFStringEncodingASCII);
470      CFStringAppendCString(outStr, direction, kCFStringEncodingASCII);
471      
472      if (format) {
473          CFStringRef message = CFStringCreateWithFormatAndArguments(kCFAllocatorDefault, NULL, format, args);
474          CFStringAppend(outStr, message);
475          CFReleaseSafe(message);
476      }
477      
478      if (apiIn) {
479          char caller_info[80];
480          snprintf(caller_info, sizeof(caller_info), "C%p F%p", __builtin_return_address(1), __builtin_frame_address(2));
481          CFStringAppend(outStr, CFSTR("CALLER "));
482          CFStringAppendCString(outStr, caller_info, kCFStringEncodingASCII);
483      }
484      va_end(args);
485  
486      return outStr;
487  }