iOS OpenUDID源码解析

已于 2023-05-16 13:18:32 修改
阅读量1.2k 收藏 2
点赞数
分类专栏： IOS 应用 文章标签： ios OpenUDID
于 2022-01-17 10:29:00 首次发布
原文链接：https://www.jianshu.com/p/69a526f72639
版权

在iOS的生态中，有我们所熟知的IDFA，IDFV，UDID，UUID。

简直能把人整晕。但是他们含义不同，应用场景不同。

为了能在我们的业务中更好的标识一个唯一设备，我们引入OpenUDID类库。

而在介绍这个库之前，我们先来看看，上面说的这几个编码到底有哪里不同，以及如何应用。

一、IDFA

IDFA是一串16进制的32位串。全称是Identifier For Advertising

设计目的是，标识用户设备，用于提供给各个APP之间跟踪广告所用。

例如，你在淘宝里搜索了某个商品之后，你在用浏览器去浏览网页的时候，那个网页的广告就会给你展示相应的那个商品的广告。

IDFA具有以下特性：

  • IDFA和设备绑定。所有应用在统一设备上获取的都是一样的
  • iOS10之后，用户可以在设置中关闭限制APP获取
  • 可以被更改，更改的时机为：
    • 设置程序 -> 通用 -> 还原 -> 还原位置与隐私
    • 设置程序-> 通用 -> 关于本机 -> 广告 -> 还原广告标示符

因此，IDFA可以作为一台设备的唯一标识符。但是会有风险被重试，或者被限制获取。

二、IDFV

和IDFA非常类似，是一串16进制的32位串。全称是Identifier For Vendor。

但是不同的是，不仅和设备相关，也和APP提供商相关。

因此，具有以下特性：

  • IDFV同时和设备，以及APP的提供商相关。一台设备上，同一个APP提供商的IDFV是一样的。

因此，如果将此台设备上，所有这个APP提供商的APP都删除了，则下一次重新安装此提供商APP时，获取的IDFV会变化。

例如，Dailyyoga和每日瑜伽获取的IDFV相同，但是把他们两个都删除了，下次重新安装后，IDFV会变化。

所以，IDFV，一般可以用于同一个厂家不同APP之间的在本地的数据互通。

三、UDID

是 iOS 设备的一个唯一识别码，每台 iOS 设备都有一个独一无二的编码，全称是Unique Device Identifier。由40位16进制数组成的字符串。

但是在iOS5以后，已经被苹果禁止通过代码获取了。

目前还有三种方式可以看到UDID:

  1. 使用iTunes，将手机连接电脑
    在这里插入图片描述
  2. 使用XCode->Device，将手机连接电脑
    在这里插入图片描述
  3. 使用企业级的MDM，制作描述文件，然后搭配网页展示获取UDID。但是只能在Safari中实现。

目前蒲公英就是这么做的。可以参考蒲公英的获取UDID的地址：https://www.pgyer.com/udid

具体实现方案，可以参考这里：http://www.skyfox.org/safari-ios-device-udid.html

因此，苹果为了防止厂家滥用，对于客户端来说，目前已经失去了获取UDID的能力。

四、UUID

UUID 是 通用唯一识别码（Universally Unique Identifier）的缩写，是一种软件建构的标准，是国际标准化组织（ISO）提出了一个概念。

它是一个32位的十六进制序列。

其设计目的是，让分布式系统中的所有元素，都能有唯一的辨识信息，而不需要通过中央控制端来做辨识信息的指定。

目前几乎所有系统，windows，Linux，macOS，都已经接入此标准。

UUID是基于当前时间、计数器（counter）和硬件标识（通常为无线网卡的MAC地址）等数据计算生成的。因此，每次重新获取的时候，都不一样，可以在此时此地标识唯一的一台设备。

五、OpenUDID —— 我们使用的识别标识库

UUID目前是比较通用的，在OC中可以通过NSUUID来获取。根据其获取方式，可以知道每次获取都会不同，实际验证也如此。OpenUDID实际也是基于UUID来实现的。

但是我们想要是，一旦我的APP在这台机器上安装上了，无论以后怎么折腾，都获取的是统一个。那么，我们应该如何做呢？

此时，OpenUUID给了我们一个解决策略。（虽然这个库已经很多年没更新过了，API基于系统底层，所以相对稳定。并且我们的APP使用了很长时间，也没有办法替换）

由于DeviceID对于我们的重要性，我们还是有必要仔细阅读一下此库的源码，来弄清楚我们DeviceID的前世今生。接下来，我们一起来看看。

我们首先用流程图来表示一下，OpenUDID的核心功能，以及其数据流向：

在这里插入图片描述

  1. OpenUDID中所获取的UDID是使用32位UUID进行了40位的补全而来，它的本质就是一个UUID，是可变的
  2. 为了使其不可变，OpenUDID将此值分别存储在了三个地方
    1. 内存变量 — — 在不退出APP时，可以从内存中直接获取之前的ID
    2. NSUserDefault — — 在不删除APP时，每次打开APP，可以在NSUserDefault中获取到之前生成的ID
    3. UIPasteboard — — 删除了APP后，在同一设备上重新安装APP，依然可以获取到之前已经生成的ID
  3. 不可变是我们要的常态，那么我们需要着重关心的是，这个ID什么时候会变化
    由于最终是存在UIPasteboard的不同域中，而iOS不允许用户主动清理剪贴板，所以变化的时机有以下几个：
    1. 用户抹掉手机中所有数据，出厂还原为一个新手机
    2. 有其他APP，使用API强制清除所有剪贴板（待确认可实施性，但是不排除有这个可能）
    3. 由于OpenUDID是开源，不排除极端情况，有其他恶意APP清除OpenUDID使用的剪贴板域

综上，OpenUDID由于聪明地使用了剪贴板做数据持久化以及共享。所以可以保证只要设备上有APP使用了OpenUDID，就可以生成一个唯一识别码，除非以上情况，此识别码将可以一直持续使用，因此，可靠性很高。

对于我们的业务来说，部分功能使用了DeviceID（即我们通过OpenUDID获取给服务器的ID）进行设备识别的模块，例如，即使用户删除APP，再次安装时，也要在登录页面弹出上次他在这台设备上最后一次登录的账号的功能，可以大胆放心的使用此ID作为识别码。

最后，放上OpenUDID源码。有表述不清或者不对的地方，还请提出质疑。

Let’s think!

//
//  OpenUDID.m
//  openudid
//
//  initiated by Yann Lechelle (cofounder @Appsfire) on 8/28/11.
//  Copyright 2011 OpenUDID.org
//
//  Initiators/root branches
//      iOS code: https://github.com/ylechelle/OpenUDID
//      Android code: https://github.com/vieux/OpenUDID
//
//  Contributors:
//      https://github.com/ylechelle/OpenUDID/contributors
//

/*
 http://en.wikipedia.org/wiki/Zlib_License
 
 This software is provided 'as-is', without any express or implied
 warranty. In no event will the authors be held liable for any damages
 arising from the use of this software.
 
 Permission is granted to anyone to use this software for any purpose,
 including commercial applications, and to alter it and redistribute it
 freely, subject to the following restrictions:
 
 1. The origin of this software must not be misrepresented; you must not
 claim that you wrote the original software. If you use this software
 in a product, an acknowledgment in the product documentation would be
 appreciated but is not required.
 
 2. Altered source versions must be plainly marked as such, and must not be
 misrepresented as being the original software.
 
 3. This notice may not be removed or altered from any source
 distribution.
*/

#if __has_feature(objc_arc)
#error This file uses the classic non-ARC retain/release model; hints below... 
    // to selectively compile this file as non-ARC, do as follows:
    // https://img.skitch.com/20120411-bcku69k1uw528cwh9frh5px8ya.png
#endif

#import "OpenUDID.h"
#import <CommonCrypto/CommonDigest.h> // Need to import for CC_MD5 access
#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
#import <UIKit/UIPasteboard.h>
#import <UIKit/UIKit.h>
#else
#import <AppKit/NSPasteboard.h>
#endif

#define OpenUDIDLog(fmt, ...)
//#define OpenUDIDLog(fmt, ...) NSLog((@"%s [Line %d] " fmt), __PRETTY_FUNCTION__, __LINE__, ##__VA_ARGS__);
//#define OpenUDIDLog(fmt, ...) NSLog((@"[Line %d] " fmt), __LINE__, ##__VA_ARGS__);

static NSString * kOpenUDIDSessionCache = nil;
static NSString * const kOpenUDIDKey = @"OpenUDID";
static NSString * const kOpenUDIDSlotKey = @"OpenUDID_slot";
static NSString * const kOpenUDIDAppUIDKey = @"OpenUDID_appUID";
static NSString * const kOpenUDIDTSKey = @"OpenUDID_createdTS";
static NSString * const kOpenUDIDOOTSKey = @"OpenUDID_optOutTS";
static NSString * const kOpenUDIDDomain = @"org.OpenUDID";
static NSString * const kOpenUDIDSlotPBPrefix = @"org.OpenUDID.slot.";
static int const kOpenUDIDRedundancySlots = 100;

@interface OpenUDID (Private)
+ (void) _setDict:(id)dict forPasteboard:(id)pboard;
+ (NSMutableDictionary*) _getDictFromPasteboard:(id)pboard;
+ (NSString*) _generateFreshOpenUDID;
@end

@implementation OpenUDID

// Archive a NSDictionary inside a pasteboard of a given type
// Convenience method to support iOS & Mac OS X
//
+ (void) _setDict:(id)dict forPasteboard:(id)pboard {
#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR		
    [pboard setData:[NSKeyedArchiver archivedDataWithRootObject:dict] forPasteboardType:kOpenUDIDDomain];
#else
    [pboard setData:[NSKeyedArchiver archivedDataWithRootObject:dict] forType:kOpenUDIDDomain];
#endif
}

// Retrieve an NSDictionary from a pasteboard of a given type
// Convenience method to support iOS & Mac OS X
//
+ (NSMutableDictionary*) _getDictFromPasteboard:(id)pboard {
#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR	
    id item = [pboard dataForPasteboardType:kOpenUDIDDomain];
#else
	id item = [pboard dataForType:kOpenUDIDDomain];
#endif	
    if (item) {
        @try{
            item = [NSKeyedUnarchiver unarchiveObjectWithData:item];
        } @catch(NSException* e) {
            OpenUDIDLog(@"Unable to unarchive item %@ on pasteboard!", [pboard name]);
            item = nil;
        }
    }
    
    // return an instance of a MutableDictionary 
    return [NSMutableDictionary dictionaryWithDictionary:(item == nil || [item isKindOfClass:[NSDictionary class]]) ? item : nil];
}

// Private method to create and return a new OpenUDID
// Theoretically, this function is called once ever per application when calling [OpenUDID value] for the first time.
// After that, the caching/pasteboard/redundancy mechanism inside [OpenUDID value] returns a persistent and cross application OpenUDID
//
+ (NSString*) _generateFreshOpenUDID {
    
    NSString* _openUDID = nil;
    
    // August 2011: One day, this may no longer be allowed in iOS. When that is, just comment this line out.
    // March 25th 2012: this day has come, let's remove this "outlawed" call... 
#if TARGET_OS_IPHONE	
//    if([UIDevice instancesRespondToSelector:@selector(uniqueIdentifier)]){
//        _openUDID = [[UIDevice currentDevice] uniqueIdentifier];
//    }
#endif
    // Next we try to use an alternative method which uses the host name, process ID, and a time stamp
    // We then hash it with md5 to get 32 bytes, and then add 4 extra random bytes
    // Collision is possible of course, but unlikely and suitable for most industry needs (e.g.. aggregate tracking)
    //
    if (_openUDID==nil) {
        unsigned char result[16];
        const char *cStr = [[[NSProcessInfo processInfo] globallyUniqueString] UTF8String];
        CC_MD5( cStr, strlen(cStr), result );
        _openUDID = [NSString stringWithFormat:
                @"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%08x",
                result[0], result[1], result[2], result[3], 
                result[4], result[5], result[6], result[7],
                result[8], result[9], result[10], result[11],
                result[12], result[13], result[14], result[15],
                arc4random() % 4294967295];  
    }
    
    // Call to other developers in the Open Source community:
    //
    // feel free to suggest better or alternative "UDID" generation code above.
    // NOTE that the goal is NOT to find a better hash method, but rather, find a decentralized (i.e. not web-based)
    // 160 bits / 20 bytes random string generator with the fewest possible collisions.
    // 

    return _openUDID;
}


// Main public method that returns the OpenUDID
// This method will generate and store the OpenUDID if it doesn't exist, typically the first time it is called
// It will return the null udid (forty zeros) if the user has somehow opted this app out (this is subject to 3rd party implementation)
// Otherwise, it will register the current app and return the OpenUDID
//
+ (NSString*) value {
    return [OpenUDID valueWithError:nil];
}

+ (NSString*) valueWithError:(NSError **)error {

    if (kOpenUDIDSessionCache!=nil) {
        if (error!=nil)
            *error = [NSError errorWithDomain:kOpenUDIDDomain
                                         code:kOpenUDIDErrorNone
                                     userInfo:[NSDictionary dictionaryWithObjectsAndKeys:@"OpenUDID in cache from first call",@"description", nil]];
        return kOpenUDIDSessionCache;
    }
    
  	NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
    
    // The AppUID will uniquely identify this app within the pastebins
    //
    NSString * appUID = (NSString *) [defaults objectForKey:kOpenUDIDAppUIDKey];
    if(appUID == nil)
    {
      // generate a new uuid and store it in user defaults
      CFUUIDRef uuid = CFUUIDCreate(NULL);
      appUID = (NSString *) CFUUIDCreateString(NULL, uuid);
      CFRelease(uuid);
    }
  
    NSString* openUDID = nil;
    NSString* myRedundancySlotPBid = nil;
    NSDate* optedOutDate = nil;
    BOOL optedOut = NO;
    BOOL saveLocalDictToDefaults = NO;
    BOOL isCompromised = NO;
    
    // Do we have a local copy of the OpenUDID dictionary?
    // This local copy contains a copy of the openUDID, myRedundancySlotPBid (and unused in this block, the local bundleid, and the timestamp)
    //
    id localDict = [defaults objectForKey:kOpenUDIDKey];
    if ([localDict isKindOfClass:[NSDictionary class]]) {
        localDict = [NSMutableDictionary dictionaryWithDictionary:localDict]; // we might need to set/overwrite the redundancy slot
        openUDID = [localDict objectForKey:kOpenUDIDKey];
        myRedundancySlotPBid = [localDict objectForKey:kOpenUDIDSlotKey];
        optedOutDate = [localDict objectForKey:kOpenUDIDOOTSKey];
        optedOut = optedOutDate!=nil;
        OpenUDIDLog(@"localDict = %@",localDict);
    }
    
    // Here we go through a sequence of slots, each of which being a UIPasteboard created by each participating app
    // The idea behind this is to both multiple and redundant representations of OpenUDIDs, as well as serve as placeholder for potential opt-out
    //
    NSString* availableSlotPBid = nil;
    NSMutableDictionary* frequencyDict = [NSMutableDictionary dictionaryWithCapacity:kOpenUDIDRedundancySlots];
    for (int n=0; n<kOpenUDIDRedundancySlots; n++) {
        NSString* slotPBid = [NSString stringWithFormat:@"%@%d",kOpenUDIDSlotPBPrefix,n];
#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
        UIPasteboard* slotPB = [UIPasteboard pasteboardWithName:slotPBid create:NO];
#else
        NSPasteboard* slotPB = [NSPasteboard pasteboardWithName:slotPBid];
#endif
        OpenUDIDLog(@"SlotPB name = %@",slotPBid);
        if (slotPB==nil) {
            // assign availableSlotPBid to be the first one available
            if (availableSlotPBid==nil) availableSlotPBid = slotPBid;
        } else {
            NSDictionary* dict = [OpenUDID _getDictFromPasteboard:slotPB];
            NSString* oudid = [dict objectForKey:kOpenUDIDKey];
            OpenUDIDLog(@"SlotPB dict = %@",dict);
            if (oudid==nil) {
                // availableSlotPBid could inside a non null slot where no oudid can be found
                if (availableSlotPBid==nil) availableSlotPBid = slotPBid;
            } else {
                // increment the frequency of this oudid key
                int count = [[frequencyDict valueForKey:oudid] intValue];
                [frequencyDict setObject:[NSNumber numberWithInt:++count] forKey:oudid];
            }
            // if we have a match with the app unique id,
            // then let's look if the external UIPasteboard representation marks this app as OptedOut
            NSString* gid = [dict objectForKey:kOpenUDIDAppUIDKey];
            if (gid!=nil && [gid isEqualToString:appUID]) {
                myRedundancySlotPBid = slotPBid;
                // the local dictionary is prime on the opt-out subject, so ignore if already opted-out locally
                if (optedOut) {
                    optedOutDate = [dict objectForKey:kOpenUDIDOOTSKey];
                    optedOut = optedOutDate!=nil;   
                }
            }
        }
    }
    
    // sort the Frequency dict with highest occurence count of the same OpenUDID (redundancy, failsafe)
    // highest is last in the list
    //
    NSArray* arrayOfUDIDs = [frequencyDict keysSortedByValueUsingSelector:@selector(compare:)];
    NSString* mostReliableOpenUDID = (arrayOfUDIDs!=nil && [arrayOfUDIDs count]>0)? [arrayOfUDIDs lastObject] : nil;
    OpenUDIDLog(@"Freq Dict = %@\nMost reliable %@",frequencyDict,mostReliableOpenUDID);
        
    // if openUDID was not retrieved from the local preferences, then let's try to get it from the frequency dictionary above
    //
    if (openUDID==nil) {        
        if (mostReliableOpenUDID==nil) {
            // this is the case where this app instance is likely to be the first one to use OpenUDID on this device
            // we create the OpenUDID, legacy or semi-random (i.e. most certainly unique)
            //
            openUDID = [OpenUDID _generateFreshOpenUDID];
        } else {
            // or we leverage the OpenUDID shared by other apps that have already gone through the process
            // 
            openUDID = mostReliableOpenUDID;
        }
        // then we create a local representation
        //
        if (localDict==nil) { 
            localDict = [NSMutableDictionary dictionaryWithCapacity:4];
            [localDict setObject:openUDID forKey:kOpenUDIDKey];
            [localDict setObject:appUID forKey:kOpenUDIDAppUIDKey];
            [localDict setObject:[NSDate date] forKey:kOpenUDIDTSKey];
            if (optedOut) [localDict setObject:optedOutDate forKey:kOpenUDIDTSKey];
            saveLocalDictToDefaults = YES;
        }
    }
    else {
        // Sanity/tampering check
        //
        if (mostReliableOpenUDID!=nil && ![mostReliableOpenUDID isEqualToString:openUDID])
            isCompromised = YES;
    }
    
    // Here we store in the available PB slot, if applicable
    //
    OpenUDIDLog(@"Available Slot %@ Existing Slot %@",availableSlotPBid,myRedundancySlotPBid);
    if (availableSlotPBid!=nil && (myRedundancySlotPBid==nil || [availableSlotPBid isEqualToString:myRedundancySlotPBid])) {
#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
        UIPasteboard* slotPB = [UIPasteboard pasteboardWithName:availableSlotPBid create:YES];
        [slotPB setPersistent:YES];
#else
        NSPasteboard* slotPB = [NSPasteboard pasteboardWithName:availableSlotPBid];
#endif
        
        // save slotPBid to the defaults, and remember to save later
        //
        if (localDict) {
            [localDict setObject:availableSlotPBid forKey:kOpenUDIDSlotKey];
            saveLocalDictToDefaults = YES;
        }
        
        // Save the local dictionary to the corresponding UIPasteboard slot
        //
        if (openUDID && localDict)
            [OpenUDID _setDict:localDict forPasteboard:slotPB];
    }

    // Save the dictionary locally if applicable
    //
    if (localDict && saveLocalDictToDefaults)
        [defaults setObject:localDict forKey:kOpenUDIDKey];

    // If the UIPasteboard external representation marks this app as opted-out, then to respect privacy, we return the ZERO OpenUDID, a sequence of 40 zeros...
    // This is a *new* case that developers have to deal with. Unlikely, statistically low, but still.
    // To circumvent this and maintain good tracking (conversion ratios, etc.), developers are invited to calculate how many of their users have opted-out from the full set of users.
    // This ratio will let them extrapolate convertion ratios more accurately.
    //
    if (optedOut) {
        if (error!=nil) *error = [NSError errorWithDomain:kOpenUDIDDomain
                                                     code:kOpenUDIDErrorOptedOut
                                                 userInfo:[NSDictionary dictionaryWithObjectsAndKeys:[NSString stringWithFormat:@"Application with unique id %@ is opted-out from OpenUDID as of %@",appUID,optedOutDate],@"description", nil]];
            
        kOpenUDIDSessionCache = [[NSString stringWithFormat:@"%040x",0] retain];
        return kOpenUDIDSessionCache;
    }

    // return the well earned openUDID!
    //
    if (error!=nil) {
        if (isCompromised)
            *error = [NSError errorWithDomain:kOpenUDIDDomain
                                         code:kOpenUDIDErrorCompromised
                                     userInfo:[NSDictionary dictionaryWithObjectsAndKeys:@"Found a discrepancy between stored OpenUDID (reliable) and redundant copies; one of the apps on the device is most likely corrupting the OpenUDID protocol",@"description", nil]];
        else
            *error = [NSError errorWithDomain:kOpenUDIDDomain
                                         code:kOpenUDIDErrorNone
                                     userInfo:[NSDictionary dictionaryWithObjectsAndKeys:@"OpenUDID succesfully retrieved",@"description", nil]];
    }
    kOpenUDIDSessionCache = [openUDID retain];
    return kOpenUDIDSessionCache;
}

+ (void) setOptOut:(BOOL)optOutValue {

    // init call
    [OpenUDID value];
    
    NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];

    // load the dictionary from local cache or create one
    id dict = [defaults objectForKey:kOpenUDIDKey];
    if ([dict isKindOfClass:[NSDictionary class]]) {
        dict = [NSMutableDictionary dictionaryWithDictionary:dict];
    } else {
        dict = [NSMutableDictionary dictionaryWithCapacity:2];
    }

    // set the opt-out date or remove key, according to parameter
    if (optOutValue)
        [dict setObject:[NSDate date] forKey:kOpenUDIDOOTSKey];
    else
        [dict removeObjectForKey:kOpenUDIDOOTSKey];

  	// store the dictionary locally
    [defaults setObject:dict forKey:kOpenUDIDKey];
    
    OpenUDIDLog(@"Local dict after opt-out = %@",dict);
    
    // reset memory cache 
    kOpenUDIDSessionCache = nil;
    
}

@end
假装你是大灰狼
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
swift获取openuuid_iOS获取设备唯一标识：UDID、IDFA、IDFV、OpenIDFA、SimulateIDFA等.
weixin_36429702的博客
12-24 1947
1. UDIDUDID全称是Unique Device Identifier，顾名思义，它就是苹果iOS设备的唯一标识码，它由40个字符的字母和数字组成。在很多需要限制一台设备一个张红的应用中经常会用到。哎iOS5中可以获取到设备的UDID，iOS7中已经完全禁用了它。iOS7之前的使用app如果在iOS7以上的设备运行，它不会反悔设备的UDID，而是会返回一串字符串，以FFFFF开头，跟着一串十...
iOS获取OpenUUID
标哥
06-03 4967
#pragma mark - 获取MAC地址 + (NSString *)obtainMacAddress { int mib[6]; size_t len; char *buf; unsigned char *ptr; struct
OpenUDID(iPhone源代码)
03-18
来源：Licence：Zlib平台：iOS设备：iPhone / iPad作者：Yann Lechelle     给每台iOS设备（iPhone/itouch/iPad）赋予一个永久、统一并且唯一的UDID（Unique Device IDentifier）。给每台设备提供唯一的UUID，经常用于一些app分析工具。在你需要分析用户的一些app使用情况的时候，你必须得统计每一个不同的用户（对应不同的app安装设备），这时候，就必须用到UDID。补仓一下，因为使用这个代码能够十分方便应用到自己的app中（NSString* openUDID = [OpenUDID value];），所以并不
ios 获取 OpenUDID
09-24 8683
原文地址:点击打开链接 2、OpenUDID测试结果分析 1）优点： a、没有用到MAC地址。MAC地址跟UDID一样，存在隐私问题。不能保证以后不会禁用MAC地址。 b、不同设备能够获取各自唯一的识别码，保证了唯一性，可以用于以往UDID的相关用途。 c、从代码分析OpenUDID的获取，识别码获取方便并且保存谨慎 OpenUDID生成唯一识别码的代码：
OpenUDID - 开源的设备唯一标识符解决方案
最新发布
gitblog_00060的博客
03-14 412
OpenUDID - 开源的设备唯一标识符解决方案 OpenUDID 是一个开源的、跨平台的设备唯一标识符（UDID）解决方案。它旨在为 iOS、Android 和其他移动平台提供一个可靠的、可移植的设备标识符，帮助开发者在没有 Apple 官方 UDID 的情况下，仍然能够实现类似的功能。 什么是 OpenUDID？ OpenUDID 是一个基于客户端-服务器模型的 UDID 解决方案。它通过生...
开源框架OpenUDID源码和伪源码分析
qq_15509071的博客
03-03 1889
void * +[UTDevice utdid](void * self, void * _cmd) { var_-96 = 0x0; var_-88 = &var_-96; var_-176 = &var_-56; var_-184 = [UTDIDOpenUDID value]; *var_-176 = [var_-184 ret...
AppsFire推出UDID开源替代品OpenUDID
我用CV我自豪。
07-27 1114
AppsFire推出UDID开源替代品OpenUDID 发布者：LUPA开源社区 　日期： 2011-09-07 08:40:53　浏览次数：12　(共有0条评论) 查看评论 | 我要评论    《移动新发现》日前报道，移动应用销售平台Appsfire目前推出OpenUDID，来应对苹果禁止开发商在iOS设备上使用UDI
【ios游戏开发】之UDID和OpenUDID扫盲
20386053
10-14 306
最近看友盟的SDK更新日志： Apple公司于2013年5月1日开始，拒绝采集UDID的App上架App Store。 为适应Apple公司的这一政策，2013年4月23日之后，友盟统计分析iOS平台的SDK只提供OpenUDID版本。 OpenUDID版本SDK使用OpenUDID为统计标准，兼有mac地址的统计。同时，我们已经上线服务器端解决方案，避免大家在将SDK从UDID版本切换到O...
iOS各种设备识别码IDFA、UDID、UUID、MAC、OpenUDID、IDFV
热门推荐
u013712343的博客
09-24 2万+
今天在app服务端接口文档中看到2个接口名称，是和idfa相关的，就搜索了解了一下，顺便梳理了ios各种设备识别码。 *IDFA英文全称Identifier+for+Advertising，即广告标示符，目前是苹果生态内广告交易的主要标示符，一般和广告商交易一个用户后，广告商会提供用户的idfa作为凭证。主流广告平台腾讯广点通，新浪粉丝通都是基于idfa。 *ios中路径：设置-->>隐私-->>广告-->>还原广告标识符； 每次切换开关按钮和点击...
关于OPENUDID
碧水蓝天
01-20 3549
dg 下面是一步一步执行的结果，IOS8.1.1上面 540b7c0015362c49a710e25ea2597c1f6cb698b7 reinstall 540b7c0015362c49a710e25ea2597c1f6cb698b7 restart reinstall 540b7c0015362c49a710e25ea2597c1f6cb698b7 还原位置和隐私 54
UDID开源解决方案 OpenUDID.zip
09-17
UDID开源解决方案 OpenUDID ,因为涉嫌危害消费者的隐私问题，苹果公司决定停止使用原有的UDID系统，移动应用软件开发者们正在竞相寻...
ios UDID替换方案--真正可行的。OpenUDID
08-06
NULL 博文链接：https://zhangmingwei.iteye.com/blog/2090563
iOS 获取openudid
09-24
iOS 获取openudid iOS 获取openudid
OpenUDID测试Demo
05-15
关于OpenUDID的测试分析Demo，详见：http://blog.csdn.net/wwmusic/article/details/8929611
利用网卡地址和OpenUDID，实现获取设备唯一标识的一种方案
05-23
网卡地址（<iOS7的系统） 通过Unix级别的API去获取Wifi的网卡地址 该方法属于UDID替代方案中最为准确的一种 因为网卡地址不会因为刷机 还原设备而发生改变 故追求唯一性的厂商多选择此种方案 在iOS7之后 应用已经无法获取网卡地址 该方案在iOS7中也已经被废弃 所以可用于iOS7以前的系统 OpenUDID > iOS7的系统 开源的一个UDID替代方案 原理是利用应用间的剪贴板共享和本地一些必要的缓存信息 让多个应用间共享一个UUID OpenUDID在官方废弃UDID接口之后 受到广泛的欢迎 可以说是现在大多数应用的UDID替代方法 OpenUDID在刷机 还原设备后就会产生新的UDID 事实上 由于剪贴板的特殊性 如果所有使用了OpenUDID的应用被全部卸载之后 再次安装的应用取到的OpenUDID将会是一个全新的值 ">网卡地址（<iOS7的系统） 通过Unix级别的API去获取Wifi的网卡地址 该方法属于UDID替代方案中最为准确的一种 因为网卡地址不会因为刷机 还原设备而发生改变 故追求唯一性的厂商多选择此种方案 在iOS7之后 应用已经无 [更多]
IOS OpenUDID
07-02
IOS获取UDID的替代方案，openUDID源码。
苹果手机UDID的获取
11-16
苹果手机UDID的获取 苹果手机UDID的获取 苹果手机UDID的获取
ProPLUG OpenUDID - iOS Unique Identifier Replacement UDID.rar
11-14
ProPLUG OpenUDID - iOS Unique Identifier Replacement UDID.rar
python获取抖音用户关注列表源码
06-06
openudid=6852c5f94e0edf6a0d5d9dce3fe2d3e2daaa8c61; _ga=GA1.2.1716780489.1593471742; _gid=GA1.2.1482732034.1593471742; _gat_gtag_UA_134238740_1=1; passport_csrf_token_default=07b9bf7c0f4c5c5c7b8a9c1f3...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值