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