Eine vollständige Lösung zur LOKALEN Validierung von In-App-Quittungen und Bündelung von Belegen auf iOS 7

Hier ist eine Anleitung, wie ich das Problem gelöst in meiner in-app-Kauf der Bibliothek RMStore. Ich werde erklären, wie Sie überprüfen, eine Transaktion, die gehört die überprüfung der gesamten Empfang.

Auf einen Blick

Bekommen Sie die Quittung, und überprüfen Sie die Transaktion. Wenn dies nicht funktioniert, aktualisieren Sie den Eingang und versuchen Sie es erneut. Dies macht die überprüfung der asynchronen wie erfrischend, der Eingang ist asynchron.

Vom RMStoreAppReceiptVerifier:

RMAppReceipt *receipt = [RMAppReceipt bundleReceipt];
const BOOL verified = [self verifyTransaction:transaction inReceipt:receipt success:successBlock failure:nil]; //failureBlock is nil intentionally. See below.
if (verified) return;

//Apple recommends to refresh the receipt if validation fails on iOS
[[RMStore defaultStore] refreshReceiptOnSuccess:^{
    RMAppReceipt *receipt = [RMAppReceipt bundleReceipt];
    [self verifyTransaction:transaction inReceipt:receipt success:successBlock failure:failureBlock];
} failure:^(NSError *error) {
    [self failWithBlock:failureBlock error:error];
}];

Immer den Empfang der Daten

Eingang ist in [[NSBundle mainBundle] appStoreReceiptURL] und ist eigentlich ein PCKS7 container. Ich sauge auf die Kryptographie, so habe ich OpenSSL zum öffnen dieser container. Andere scheinbar haben es getan, rein mit system-frameworks.

Hinzufügen von OpenSSL zu Ihrem Projekt ist nicht trivial. Die RMStore wiki sollte helfen.

Wenn Sie sich entscheiden, verwenden Sie OpenSSL, um öffnen Sie die PKCS7-container, könnte der code wie folgt Aussehen. Von RMAppReceipt:

+ (NSData*)dataFromPKCS7Path:(NSString*)path
{
    const char *cpath = [[path stringByStandardizingPath] fileSystemRepresentation];
    FILE *fp = fopen(cpath, "rb");
    if (!fp) return nil;

    PKCS7 *p7 = d2i_PKCS7_fp(fp, NULL);
    fclose(fp);

    if (!p7) return nil;

    NSData *data;
    NSURL *certificateURL = [[NSBundle mainBundle] URLForResource:@"AppleIncRootCertificate" withExtension:@"cer"];
    NSData *certificateData = [NSData dataWithContentsOfURL:certificateURL];
    if ([self verifyPKCS7:p7 withCertificateData:certificateData])
    {
        struct pkcs7_st *contents = p7->d.sign->contents;
        if (PKCS7_type_is_data(contents))
        {
            ASN1_OCTET_STRING *octets = contents->d.data;
            data = [NSData dataWithBytes:octets->data length:octets->length];
        }
    }
    PKCS7_free(p7);
    return data;
}

Bekommen wir in die details der überprüfung später.

Immer die Quittung Felder

Eingang ist ausgedrückt im ASN1-format. Es enthält Allgemeine Informationen, einige Felder, die für die Zwecke der überprüfung (wir kommen später) und spezifische Informationen der jeweiligen in-app-Kauf.

Wieder, OpenSSL kommt zur Rettung, wenn es um das Lesen ASN1. Von RMAppReceipt, mit ein paar helper Methoden:

NSMutableArray *purchases = [NSMutableArray array];
[RMAppReceipt enumerateASN1Attributes:asn1Data.bytes length:asn1Data.length usingBlock:^(NSData *data, int type) {
    const uint8_t *s = data.bytes;
    const NSUInteger length = data.length;
    switch (type)
    {
        case RMAppReceiptASN1TypeBundleIdentifier:
            _bundleIdentifierData = data;
            _bundleIdentifier = RMASN1ReadUTF8String(&s, length);
            break;
        case RMAppReceiptASN1TypeAppVersion:
            _appVersion = RMASN1ReadUTF8String(&s, length);
            break;
        case RMAppReceiptASN1TypeOpaqueValue:
            _opaqueValue = data;
            break;
        case RMAppReceiptASN1TypeHash:
            _hash = data;
            break;
        case RMAppReceiptASN1TypeInAppPurchaseReceipt:
        {
            RMAppReceiptIAP *purchase = [[RMAppReceiptIAP alloc] initWithASN1Data:data];
            [purchases addObject:purchase];
            break;
        }
        case RMAppReceiptASN1TypeOriginalAppVersion:
            _originalAppVersion = RMASN1ReadUTF8String(&s, length);
            break;
        case RMAppReceiptASN1TypeExpirationDate:
        {
            NSString *string = RMASN1ReadIA5SString(&s, length);
            _expirationDate = [RMAppReceipt formatRFC3339String:string];
            break;
        }
    }
}];
_inAppPurchases = purchases;

Immer die in-app-Käufe

Jedem in-app-Kauf ist auch im ASN1. Analyse es ist sehr ähnlich wie das Parsen der Allgemeinen Erhalt von Informationen.

Vom RMAppReceipt, mit der gleichen Hilfsmethoden:

[RMAppReceipt enumerateASN1Attributes:asn1Data.bytes length:asn1Data.length usingBlock:^(NSData *data, int type) {
    const uint8_t *p = data.bytes;
    const NSUInteger length = data.length;
    switch (type)
    {
        case RMAppReceiptASN1TypeQuantity:
            _quantity = RMASN1ReadInteger(&p, length);
            break;
        case RMAppReceiptASN1TypeProductIdentifier:
            _productIdentifier = RMASN1ReadUTF8String(&p, length);
            break;
        case RMAppReceiptASN1TypeTransactionIdentifier:
            _transactionIdentifier = RMASN1ReadUTF8String(&p, length);
            break;
        case RMAppReceiptASN1TypePurchaseDate:
        {
            NSString *string = RMASN1ReadIA5SString(&p, length);
            _purchaseDate = [RMAppReceipt formatRFC3339String:string];
            break;
        }
        case RMAppReceiptASN1TypeOriginalTransactionIdentifier:
            _originalTransactionIdentifier = RMASN1ReadUTF8String(&p, length);
            break;
        case RMAppReceiptASN1TypeOriginalPurchaseDate:
        {
            NSString *string = RMASN1ReadIA5SString(&p, length);
            _originalPurchaseDate = [RMAppReceipt formatRFC3339String:string];
            break;
        }
        case RMAppReceiptASN1TypeSubscriptionExpirationDate:
        {
            NSString *string = RMASN1ReadIA5SString(&p, length);
            _subscriptionExpirationDate = [RMAppReceipt formatRFC3339String:string];
            break;
        }
        case RMAppReceiptASN1TypeWebOrderLineItemID:
            _webOrderLineItemID = RMASN1ReadInteger(&p, length);
            break;
        case RMAppReceiptASN1TypeCancellationDate:
        {
            NSString *string = RMASN1ReadIA5SString(&p, length);
            _cancellationDate = [RMAppReceipt formatRFC3339String:string];
            break;
        }
    }
}]; 

Es sollte beachtet werden, dass bestimmte in-app-Käufe, wie Verbrauchsmaterialien und nicht-erneuerbaren Abonnements, erscheint nur einmal in den Eingang. Sie sollten überprüfen, diese direkt nach dem Kauf (mal wieder, RMStore hilft Ihnen dabei).

Überprüfung auf einen Blick

Wir haben jetzt alle Felder der Eingang und alle Ihre in-app-Käufe. Zuerst überprüfen wir die Quittung, und dann prüfen wir einfach, ob der Eingang enthält das Produkt der Transaktion.

Unten ist die Methode, die wir riefen wieder am Anfang. Von RMStoreAppReceiptVerificator:

- (BOOL)verifyTransaction:(SKPaymentTransaction*)transaction
                inReceipt:(RMAppReceipt*)receipt
                           success:(void (^)())successBlock
                           failure:(void (^)(NSError *error))failureBlock
{
    const BOOL receiptVerified = [self verifyAppReceipt:receipt];
    if (!receiptVerified)
    {
        [self failWithBlock:failureBlock message:NSLocalizedString(@"The app receipt failed verification", @"")];
        return NO;
    }
    SKPayment *payment = transaction.payment;
    const BOOL transactionVerified = [receipt containsInAppPurchaseOfProductIdentifier:payment.productIdentifier];
    if (!transactionVerified)
    {
        [self failWithBlock:failureBlock message:NSLocalizedString(@"The app receipt doest not contain the given product", @"")];
        return NO;
    }
    if (successBlock)
    {
        successBlock();
    }
    return YES;
}

Überprüfung der Empfang

Überprüfen der Quittung hinausläuft:

1. Prüfen, ob der Empfang gültig ist PKCS7-und ASN1. Wir haben dies getan, implizit schon.
2. Überprüfung, ob der Eingang wird von Apple signiert. Dies wurde vor der Analyse der Erhalt-und werden weiter unten detailliert beschrieben.
3. Zu prüfen, dass der bundle-Bezeichner enthalten in der Quittung entspricht Ihren bundle identifier. Sollten Sie fest Ihren bundle identifier ein, wie es scheint nicht sehr schwierig zu sein, ändern Sie Ihre app-bundle und einige andere Eingang.
4. Überprüfung, dass die app-version enthalten, in der Quittung entspricht Ihre app-version-id. Sie sollten fest die app-version, für den gleichen Gründen, die oben angegeben ist.
5. Überprüfen Sie die Eingangs-hash, um sicherzustellen, dass der Eingang entsprechen dem aktuellen Gerät.

Die 5 Schritte im code auf einem hohen Niveau, von RMStoreAppReceiptVerificator:

- (BOOL)verifyAppReceipt:(RMAppReceipt*)receipt
{
    //Steps 1 & 2 were done while parsing the receipt
    if (!receipt) return NO;   

    //Step 3
    if (![receipt.bundleIdentifier isEqualToString:self.bundleIdentifier]) return NO;

    //Step 4        
    if (![receipt.appVersion isEqualToString:self.bundleVersion]) return NO;

    //Step 5        
    if (![receipt verifyReceiptHash]) return NO;

    return YES;
}

Let ' s drill-down in die Schritte 2 und 5.

Überprüfen der Erhalt Signatur

Zurück, wenn wir die Daten extrahiert, wir blickten über den Eingang Verifizierung der Signatur. Der Empfang ist unterzeichnet mit der Apple Inc. Root-Zertifikat, welches heruntergeladen werden kann Apple Root-Zertifizierungsstelle. Der folgende code nimmt die PKCS7-container und das root-Zertifikat als Daten und überprüft, ob Sie übereinstimmen:

+ (BOOL)verifyPKCS7:(PKCS7*)container withCertificateData:(NSData*)certificateData
{ //Based on: https://developer.apple.com/library/content/releasenotes/General/ValidateAppStoreReceipt/Chapters/ValidateLocally.html#//apple_ref/doc/uid/TP40010573-CH1-SW17
    static int verified = 1;
    int result = 0;
    OpenSSL_add_all_digests(); //Required for PKCS7_verify to work
    X509_STORE *store = X509_STORE_new();
    if (store)
    {
        const uint8_t *certificateBytes = (uint8_t *)(certificateData.bytes);
        X509 *certificate = d2i_X509(NULL, &certificateBytes, (long)certificateData.length);
        if (certificate)
        {
            X509_STORE_add_cert(store, certificate);

            BIO *payload = BIO_new(BIO_s_mem());
            result = PKCS7_verify(container, NULL, store, NULL, payload, 0);
            BIO_free(payload);

            X509_free(certificate);
        }
    }
    X509_STORE_free(store);
    EVP_cleanup(); //Balances OpenSSL_add_all_digests (), per http://www.openssl.org/docs/crypto/OpenSSL_add_all_algorithms.html

    return result == verified;
}

Dies wurde getan, zurück an den Anfang, vor dem Eingang analysiert.

Überprüfung der Empfang hash

Den hash enthalten in der Quittung ist ein SHA1-Hash der Geräte-id, einige undurchsichtige Wert enthalten in den Erhalt und die bundle-id.

Dies ist, wie Sie prüfen, ob der Erhalt hash auf iOS. Von RMAppReceipt:

- (BOOL)verifyReceiptHash
{
    //TODO: Getting the uuid in Mac is different. See: https://developer.apple.com/library/content/releasenotes/General/ValidateAppStoreReceipt/Chapters/ValidateLocally.html#//apple_ref/doc/uid/TP40010573-CH1-SW5
    NSUUID *uuid = [[UIDevice currentDevice] identifierForVendor];
    unsigned char uuidBytes[16];
    [uuid getUUIDBytes:uuidBytes];

    //Order taken from: https://developer.apple.com/library/content/releasenotes/General/ValidateAppStoreReceipt/Chapters/ValidateLocally.html#//apple_ref/doc/uid/TP40010573-CH1-SW5
    NSMutableData *data = [NSMutableData data];
    [data appendBytes:uuidBytes length:sizeof(uuidBytes)];
    [data appendData:self.opaqueValue];
    [data appendData:self.bundleIdentifierData];

    NSMutableData *expectedHash = [NSMutableData dataWithLength:SHA_DIGEST_LENGTH];
    SHA1(data.bytes, data.length, expectedHash.mutableBytes);

    return [expectedHash isEqualToData:self.hash];
}

- Und das ist der Kern von ihm. Ich könnte hier etwas fehlt, oder dort, so dass ich vielleicht kommen Sie zurück zu diesem post später. In jedem Fall empfehle ich, durchsuchen Sie den vollständigen code für mehr details.

InformationsquelleAutor der Antwort hpique

Hallo Dies ist Swift 3 - version für die Validierung von in-app-Kauf Quittung...

Call receiptValidation() Funktion von Ihrem AppDelegate oder von wo Sie wollen.

    func receiptValidation() {
    if let appStoreReceiptURL = Bundle.main.appStoreReceiptURL,
        FileManager.default.fileExists(atPath: appStoreReceiptURL.path) {
        do {
            let receiptData = try Data(contentsOf: appStoreReceiptURL, options: .alwaysMapped)
            let receiptString = receiptData.base64EncodedString(options: [])
            let dict = ["receipt-data" : receiptString, "password" : "**************************"] as [String : Any]
            do {
                let jsonData = try JSONSerialization.data(withJSONObject: dict, options: .prettyPrinted)
                //This Url for original Account
                //let url : String = "https://buy.itunes.apple.com/verifyReceipt"
                //This Url for Sandbox Testing Account 
                let url : String = "https://sandbox.itunes.apple.com/verifyReceipt"
                if let sandboxURL = Foundation.URL(string:url) {
                    var request = URLRequest(url: sandboxURL)
                    request.httpMethod = "POST"
                    request.httpBody = jsonData
                    let session = URLSession(configuration: URLSessionConfiguration.default)
                    let task = session.dataTask(with: request) { data, response, error in
                        if let receivedData = data,
                            let httpResponse = response as? HTTPURLResponse,
                            error == nil,
                            httpResponse.statusCode == 200 {
                            do {
                                if let jsonResponse = try JSONSerialization.jsonObject(with: receivedData, options: JSONSerialization.ReadingOptions.mutableContainers) as? Dictionary<String, AnyObject> {
                                    if let expirationDate: NSDate = self.expirationDateFromResponse(jsonResponse: jsonResponse as NSDictionary) {
                                        let currentDate = self.getCurrentLocalDateApp()
                                        if currentDate > expirationDate as Date {
                                            self.downgrade("1")
                                        }else{

                                        }
                                    }

                                } else {
                                }
                            }
                            catch {
                            }
                        }else {
                            print("Error=\(String(describing: error))")
                        }
                    }
                    task.resume()
                } else {
                }
            }
            catch {
            }
        }
        catch {
        }
    }
}

Nun haben Wir eine weitere Funktion ein Datum aus dem Eingang expirationDateFromResponse(). Diese Funktion würde in dem gleichen controller oder in der AppDelegate

func expirationDateFromResponse(jsonResponse: NSDictionary) -> NSDate? {
    if let receiptInfo: NSArray = jsonResponse["latest_receipt_info"] as? NSArray {
        let lastReceipt = receiptInfo.lastObject as! NSDictionary
        let formatter = DateFormatter()
        formatter.dateFormat = "yyyy-MM-dd HH:mm:ss VV"
        let expirationDate: NSDate = formatter.date(from: lastReceipt["expires_date"] as! String) as NSDate!
        formatter.dateStyle = .medium
        let stringOutput = formatter.string(from: expirationDate as Date)
        formatter.dateFormat = "yyyy-MM-dd HH:mm:ss"
        let date = formatter.string(from: expirationDate as Date)
        print("Date=\(date)")
        self.iosNextBillingDateEntry(date)
        UserDefaults.standard.set(stringOutput, forKey: "PLAN_EXP_DATE")
        return expirationDate

    } else {
        return nil

    }
}

Nun haben wir noch eine Funktion für das abrufen lokale Datum und Zeit, wenn es ist erforderlich für Sie.

func getCurrentLocalDateApp()-> Date {
    var now = Date()
    var nowComponents = DateComponents()
    let calendar = Calendar.current
    nowComponents.year = (Calendar.current as NSCalendar).component(NSCalendar.Unit.year, from: now)
    nowComponents.month = (Calendar.current as NSCalendar).component(NSCalendar.Unit.month, from: now)
    nowComponents.day = (Calendar.current as NSCalendar).component(NSCalendar.Unit.day, from: now)
    nowComponents.hour = (Calendar.current as NSCalendar).component(NSCalendar.Unit.hour, from: now)
    nowComponents.minute = (Calendar.current as NSCalendar).component(NSCalendar.Unit.minute, from: now)
    nowComponents.second = (Calendar.current as NSCalendar).component(NSCalendar.Unit.second, from: now)
    nowComponents.timeZone = TimeZone(abbreviation: "VV")
    now = calendar.date(from: nowComponents)!
    return now
}

Den Passwort erhalten Sie aus dem apple-store. https://developer.apple.com öffnen Sie diesen link, klicken Sie auf

• Account tab
• Do Sign in
• Open iTune Connect
• Open My App
• Open Feature Tab
• Open In App Purchase
• Click at the right side on 'View Shared Secret'
• At the bottom you will get a secrete key

Kopieren Sie diesen Schlüssel und fügen Sie in das Feld Kennwort ein.

Hoffen, dass dies für jeden auf, der will, dass in der swift-version.

InformationsquelleAutor der Antwort APK APPS