base/ios/device_util.mm

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/ios/device_util.h"
   6
   7 #include <CommonCrypto/CommonDigest.h>
   8 #import <UIKit/UIKit.h>
   9
  10 #include <ifaddrs.h>
  11 #include <net/if_dl.h>
  12 #include <string.h>
  13 #include <sys/socket.h>
  14 #include <sys/sysctl.h>
  15
  16 #include "base/logging.h"
  17 #include "base/mac/scoped_cftyperef.h"
  18 #include "base/memory/scoped_ptr.h"
  19 #include "base/strings/string_util.h"
  20 #include "base/strings/stringprintf.h"
  21 #include "base/strings/sys_string_conversions.h"
  22
  23 namespace {
  24
  25 // Client ID key in the user preferences.
  26 NSString* const kLegacyClientIdPreferenceKey = @"ChromiumClientID";
  27 NSString* const kClientIdPreferenceKey = @"ChromeClientID";
  28 // Current hardware type. This is used to detect that a device has been backed
  29 // up and restored to another device, and allows regenerating a new device id.
  30 NSString* const kHardwareTypePreferenceKey = @"ClientIDGenerationHardwareType";
  31 // Default salt for device ids.
  32 const char kDefaultSalt[] = "Salt";
  33 // Zero UUID returned on buggy iOS devices.
  34 NSString* const kZeroUUID = @"00000000-0000-0000-0000-000000000000";
  35
  36 NSString* GenerateClientId() {
  37   NSUserDefaults* defaults = [NSUserDefaults standardUserDefaults];
  38
  39   // Try to migrate from legacy client id.
  40   NSString* client_id = [defaults stringForKey:kLegacyClientIdPreferenceKey];
  41
  42   // Some iOS6 devices return a buggy identifierForVendor:
  43   // http://openradar.appspot.com/12377282. If this is the case, revert to
  44   // generating a new one.
  45   if (!client_id || [client_id isEqualToString:kZeroUUID]) {
  46     client_id = [[[UIDevice currentDevice] identifierForVendor] UUIDString];
  47     if ([client_id isEqualToString:kZeroUUID])
  48       client_id = base::SysUTF8ToNSString(ios::device_util::GetRandomId());
  49   }
  50   return client_id;
  51 }
  52
  53 }  // namespace
  54
  55 namespace ios {
  56 namespace device_util {
  57
  58 std::string GetPlatform() {
  59   std::string platform;
  60   size_t size = 0;
  61   sysctlbyname("hw.machine", NULL, &size, NULL, 0);
  62   sysctlbyname("hw.machine", WriteInto(&platform, size), &size, NULL, 0);
  63   return platform;
  64 }
  65
  66 bool RamIsAtLeast512Mb() {
  67   // 512MB devices report anywhere from 502-504 MB, use 450 MB just to be safe.
  68   return RamIsAtLeast(450);
  69 }
  70
  71 bool RamIsAtLeast1024Mb() {
  72   // 1GB devices report anywhere from 975-999 MB, use 900 MB just to be safe.
  73   return RamIsAtLeast(900);
  74 }
  75
  76 bool RamIsAtLeast(uint64_t ram_in_mb) {
  77   uint64_t memory_size = 0;
  78   size_t size = sizeof(memory_size);
  79   if (sysctlbyname("hw.memsize", &memory_size, &size, NULL, 0) == 0) {
  80     // Anything >= 500M, call high ram.
  81     return memory_size >= ram_in_mb * 1024 * 1024;
  82   }
  83   return false;
  84 }
  85
  86 bool IsSingleCoreDevice() {
  87   uint64_t cpu_number = 0;
  88   size_t sizes = sizeof(cpu_number);
  89   sysctlbyname("hw.physicalcpu", &cpu_number, &sizes, NULL, 0);
  90   return cpu_number == 1;
  91 }
  92
  93 std::string GetMacAddress(const std::string& interface_name) {
  94   std::string mac_string;
  95   struct ifaddrs* addresses;
  96   if (getifaddrs(&addresses) == 0) {
  97     for (struct ifaddrs* address = addresses; address;
  98          address = address->ifa_next) {
  99       if ((address->ifa_addr->sa_family == AF_LINK) &&
 100           strcmp(interface_name.c_str(), address->ifa_name) == 0) {
 101         const struct sockaddr_dl* found_address_struct =
 102             reinterpret_cast<const struct sockaddr_dl*>(address->ifa_addr);
 103
 104         // |found_address_struct->sdl_data| contains the interface name followed
 105         // by the interface address. The address part can be accessed based on
 106         // the length of the name, that is, |found_address_struct->sdl_nlen|.
 107         const unsigned char* found_address =
 108             reinterpret_cast<const unsigned char*>(
 109                 &found_address_struct->sdl_data[
 110                     found_address_struct->sdl_nlen]);
 111
 112         int found_address_length = found_address_struct->sdl_alen;
 113         for (int i = 0; i < found_address_length; ++i) {
 114           if (i != 0)
 115             mac_string.push_back(':');
 116           base::StringAppendF(&mac_string, "%02X", found_address[i]);
 117         }
 118         break;
 119       }
 120     }
 121     freeifaddrs(addresses);
 122   }
 123   return mac_string;
 124 }
 125
 126 std::string GetRandomId() {
 127   base::ScopedCFTypeRef<CFUUIDRef> uuid_object(
 128       CFUUIDCreate(kCFAllocatorDefault));
 129   base::ScopedCFTypeRef<CFStringRef> uuid_string(
 130       CFUUIDCreateString(kCFAllocatorDefault, uuid_object));
 131   return base::SysCFStringRefToUTF8(uuid_string);
 132 }
 133
 134 std::string GetDeviceIdentifier(const char* salt) {
 135   NSUserDefaults* defaults = [NSUserDefaults standardUserDefaults];
 136
 137   NSString* last_seen_hardware =
 138       [defaults stringForKey:kHardwareTypePreferenceKey];
 139   NSString* current_hardware = base::SysUTF8ToNSString(GetPlatform());
 140   if (!last_seen_hardware) {
 141     last_seen_hardware = current_hardware;
 142     [defaults setObject:current_hardware forKey:kHardwareTypePreferenceKey];
 143     [defaults synchronize];
 144   }
 145
 146   NSString* client_id = [defaults stringForKey:kClientIdPreferenceKey];
 147
 148   if (!client_id || ![last_seen_hardware isEqualToString:current_hardware]) {
 149     client_id = GenerateClientId();
 150     [defaults setObject:client_id forKey:kClientIdPreferenceKey];
 151     [defaults setObject:current_hardware forKey:kHardwareTypePreferenceKey];
 152     [defaults synchronize];
 153   }
 154
 155   return GetSaltedString(base::SysNSStringToUTF8(client_id),
 156                          salt ? salt : kDefaultSalt);
 157 }
 158
 159 std::string GetSaltedString(const std::string& in_string,
 160                             const std::string& salt) {
 161   DCHECK(salt.length());
 162   NSData* hash_data = [base::SysUTF8ToNSString(in_string + salt)
 163       dataUsingEncoding:NSUTF8StringEncoding];
 164
 165   unsigned char hash[CC_SHA256_DIGEST_LENGTH];
 166   CC_SHA256([hash_data bytes], [hash_data length], hash);
 167   CFUUIDBytes* uuid_bytes = reinterpret_cast<CFUUIDBytes*>(hash);
 168
 169   base::ScopedCFTypeRef<CFUUIDRef> uuid_object(
 170       CFUUIDCreateFromUUIDBytes(kCFAllocatorDefault, *uuid_bytes));
 171   base::ScopedCFTypeRef<CFStringRef> device_id(
 172       CFUUIDCreateString(kCFAllocatorDefault, uuid_object));
 173   return base::SysCFStringRefToUTF8(device_id);
 174 }
 175
 176 }  // namespace device_util
 177 }  // namespace ios