1  /*
  2   * Copyright (c) 2018 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  #import "SecCoreAnalytics.h"
 25  #import <CoreAnalytics/CoreAnalytics.h>
 26  #import <SoftLinking/SoftLinking.h>
 27  #import <Availability.h>
 28  #import <sys/sysctl.h>
 29  
 30  NSString* const SecCoreAnalyticsValue = @"value";
 31  
 32  
 33  void SecCoreAnalyticsSendValue(CFStringRef _Nonnull eventName, int64_t value)
 34  {
 35      [SecCoreAnalytics sendEvent:(__bridge NSString*)eventName
 36                            event:@{
 37                                SecCoreAnalyticsValue: [NSNumber numberWithLong:value],
 38                            }];
 39  }
 40  
 41  void SecCoreAnalyticsSendKernEntropyHealth()
 42  {
 43      size_t sz_int = sizeof(int);
 44      size_t sz_uint = sizeof(unsigned int);
 45      size_t sz_tv = sizeof(struct timeval);
 46  
 47      int startup_done;
 48      unsigned int adaptive_proportion_failure_count = 0;
 49      unsigned int adaptive_proportion_max_observation_count = 0;
 50      unsigned int adaptive_proportion_reset_count = 0;
 51      unsigned int repetition_failure_count = 0;
 52      unsigned int repetition_max_observation_count = 0;
 53      unsigned int repetition_reset_count = 0;
 54  
 55      int rv = sysctlbyname("kern.entropy.health.startup_done", &startup_done, &sz_int, NULL, 0);
 56      rv |= sysctlbyname("kern.entropy.health.adaptive_proportion_test.failure_count", &adaptive_proportion_failure_count, &sz_uint, NULL, 0);
 57      rv |= sysctlbyname("kern.entropy.health.adaptive_proportion_test.max_observation_count", &adaptive_proportion_max_observation_count, &sz_uint, NULL, 0);
 58      rv |= sysctlbyname("kern.entropy.health.adaptive_proportion_test.reset_count", &adaptive_proportion_reset_count, &sz_uint, NULL, 0);
 59      rv |= sysctlbyname("kern.entropy.health.repetition_count_test.failure_count", &repetition_failure_count, &sz_uint, NULL, 0);
 60      rv |= sysctlbyname("kern.entropy.health.repetition_count_test.max_observation_count", &repetition_max_observation_count, &sz_uint, NULL, 0);
 61      rv |= sysctlbyname("kern.entropy.health.repetition_count_test.reset_count", &repetition_reset_count, &sz_uint, NULL, 0);
 62  
 63      // Round up to next power of two.
 64      if (adaptive_proportion_reset_count > 0) {
 65          adaptive_proportion_reset_count =
 66              1U << (sizeof(unsigned int) * 8 - __builtin_clz(adaptive_proportion_reset_count));
 67      }
 68  
 69      // Round up to next power of two.
 70      if (repetition_reset_count > 0) {
 71          repetition_reset_count =
 72              1U << (sizeof(unsigned int) * 8 - __builtin_clz(repetition_reset_count));
 73      }
 74  
 75      // Default to not submitting uptime, except on failure.
 76      int uptime = -1;
 77  
 78      if (adaptive_proportion_failure_count > 0 || repetition_failure_count > 0) {
 79          time_t now;
 80          time(&now);
 81  
 82          struct timeval boottime;
 83          int mib[2] = { CTL_KERN, KERN_BOOTTIME };
 84          rv |= sysctl(mib, 2, &boottime, &sz_tv, NULL, 0);
 85  
 86          // Submit uptime in minutes.
 87          uptime = (int)((now - boottime.tv_sec) / 60);
 88      }
 89  
 90      if (rv) {
 91          return;
 92      }
 93  
 94      [SecCoreAnalytics sendEventLazy:@"com.apple.kern.entropyHealth" builder:^NSDictionary<NSString *,NSObject *> * _Nonnull{
 95          return @{
 96              @"uptime" : @(uptime),
 97              @"startup_done" : @(startup_done),
 98              @"adaptive_proportion_failure_count" : @(adaptive_proportion_failure_count),
 99              @"adaptive_proportion_max_observation_count" : @(adaptive_proportion_max_observation_count),
100              @"adaptive_proportion_reset_count" : @(adaptive_proportion_reset_count),
101              @"repetition_failure_count" : @(repetition_failure_count),
102              @"repetition_max_observation_count" : @(repetition_max_observation_count),
103              @"repetition_reset_count" : @(repetition_reset_count)
104          };
105      }];
106  }
107  
108  @implementation SecCoreAnalytics
109  
110  SOFT_LINK_OPTIONAL_FRAMEWORK(PrivateFrameworks, CoreAnalytics);
111  
112  SOFT_LINK_FUNCTION(CoreAnalytics, AnalyticsSendEvent, soft_AnalyticsSendEvent, \
113      void, (NSString* eventName, NSDictionary<NSString*,NSObject*>* eventPayload),(eventName, eventPayload));
114  SOFT_LINK_FUNCTION(CoreAnalytics, AnalyticsSendEventLazy, soft_AnalyticsSendEventLazy, \
115      void, (NSString* eventName, NSDictionary<NSString*,NSObject*>* (^eventPayloadBuilder)(void)),(eventName, eventPayloadBuilder));
116  
117  + (void)sendEvent:(NSString*) eventName event:(NSDictionary<NSString*,NSObject*>*)event
118  {
119      if (isCoreAnalyticsAvailable()) {
120          soft_AnalyticsSendEvent(eventName, event);
121      }
122  }
123  
124  + (void)sendEventLazy:(NSString*) eventName builder:(NSDictionary<NSString*,NSObject*>* (^)(void))builder
125  {
126      if (isCoreAnalyticsAvailable()) {
127          soft_AnalyticsSendEventLazy(eventName, builder);
128      }
129  }
130  
131  @end