From f3736aa6b419a0a0db822747ff2c14ac279058dc Mon Sep 17 00:00:00 2001 From: 0z5a Date: Sun, 15 Nov 2026 00:55:43 +0100 Subject: [PATCH] Check ASN.1 element types when extracting a transaction id from an app receipt extract_transaction_id_from_app_receipt discarded the ASN.1 tags of the receipt payload, the in-app array and the transaction id, so a malformed receipt could return an int or bytes transaction id, or None when the in-app container was not a SET. Require a SET for the payload and the in-app array and a UTF8String for the transaction id, as the Java and Node libraries do, and raise ValueError otherwise. --- appstoreserverlibrary/receipt_utility.py | 12 ++-- tests/test_receipt_utility.py | 75 ++++++++++++++++++++++++ 2 files changed, 82 insertions(+), 5 deletions(-) diff --git a/appstoreserverlibrary/receipt_utility.py b/appstoreserverlibrary/receipt_utility.py index 5e2c31a2..0a813570 100644 --- a/appstoreserverlibrary/receipt_utility.py +++ b/appstoreserverlibrary/receipt_utility.py @@ -12,10 +12,12 @@ ORIGINAL_TRANSACTION_IDENTIFIER = 1705 class ReceiptUtility: - def _decode_octet_string(self, octet_string: bytes): + def _decode_octet_string(self, octet_string: bytes, expected_type: Optional[asn1.Numbers] = None): decoder = asn1.Decoder() decoder.start(octet_string) - _, value = decoder.read() + tag, value = decoder.read() + if expected_type is not None and (tag.cls != asn1.Classes.Universal or tag.nr != expected_type): + raise ValueError() return value def extract_transaction_id_from_app_receipt(self, app_receipt: str) -> Optional[str]: @@ -33,15 +35,15 @@ def extract_transaction_id_from_app_receipt(self, app_receipt: str) -> Optional[ raise ValueError() inner_value = val[1][0][2][1][0] # Xcode uses nested OctetStrings, we extract the inner string in this case - value = self._decode_octet_string(inner_value) + value = self._decode_octet_string(inner_value, asn1.Numbers.Set) # We are in the top-level sequence, work our way to the array of in-apps for inner_value in value: if inner_value[0] == IN_APP_ARRAY: - array_values = self._decode_octet_string(inner_value[2]) + array_values = self._decode_octet_string(inner_value[2], asn1.Numbers.Set) # In-app array for array_value in array_values: if array_value[0] == TRANSACTION_IDENTIFIER or array_value[0] == ORIGINAL_TRANSACTION_IDENTIFIER: - return self._decode_octet_string(array_value[2]) + return self._decode_octet_string(array_value[2], asn1.Numbers.UTF8String) return None except Exception as e: raise ValueError(e) diff --git a/tests/test_receipt_utility.py b/tests/test_receipt_utility.py index 2d585383..17a46391 100644 --- a/tests/test_receipt_utility.py +++ b/tests/test_receipt_utility.py @@ -12,6 +12,48 @@ APP_RECEIPT_EXPECTED_TRANSACTION_ID = "0" TRANSACTION_RECEIPT_EXPECTED_TRANSACTION_ID = "33993399" +def _encode_attribute(encoder: asn1.Encoder, attribute_type: int, value: bytes): + encoder.enter(asn1.Numbers.Sequence) + encoder.write(attribute_type, asn1.Numbers.Integer) + encoder.write(1, asn1.Numbers.Integer) + encoder.write(value, asn1.Numbers.OctetString) + encoder.leave() + +def _encode_value(value, value_type: asn1.Numbers) -> bytes: + encoder = asn1.Encoder() + encoder.start() + encoder.write(value, value_type) + return encoder.output() + +def _encode_attributes(attribute_type: int, value: bytes, container_type: asn1.Numbers = asn1.Numbers.Set) -> bytes: + encoder = asn1.Encoder() + encoder.start() + encoder.enter(container_type) + _encode_attribute(encoder, attribute_type, value) + encoder.leave() + return encoder.output() + +def _create_app_receipt(payload: bytes) -> str: + encoder = asn1.Encoder() + encoder.start() + encoder.enter(asn1.Numbers.Sequence) + encoder.write("1.2.840.113549.1.7.2", asn1.Numbers.ObjectIdentifier) + encoder.enter(0, asn1.Classes.Context) + encoder.enter(asn1.Numbers.Sequence) + encoder.write(1, asn1.Numbers.Integer) + encoder.enter(asn1.Numbers.Set) + encoder.leave() + encoder.enter(asn1.Numbers.Sequence) + encoder.write("1.2.840.113549.1.7.1", asn1.Numbers.ObjectIdentifier) + encoder.enter(0, asn1.Classes.Context) + encoder.write(payload, asn1.Numbers.OctetString) + encoder.leave() + encoder.leave() + encoder.leave() + encoder.leave() + encoder.leave() + return base64.b64encode(encoder.output()).decode('utf-8') + class ReceiptUtilityTest(unittest.TestCase): def test_xcode_app_receipt_extraction_with_no_transactions(self): receipt = read_data_from_file("tests/resources/xcode/xcode-app-receipt-empty") @@ -134,3 +176,36 @@ def test_transaction_receipt_extraction_without_transaction_id(self): extracted_transaction_id = receipt_util.extract_transaction_id_from_transaction_receipt(receipt) self.assertIsNone(extracted_transaction_id) + + def test_app_receipt_extraction_with_utf8_string_transaction_id(self): + receipt = _create_app_receipt(_encode_attributes(17, _encode_attributes(1703, _encode_value("2000000000000001", asn1.Numbers.UTF8String)))) + + receipt_util = ReceiptUtility() + + extracted_transaction_id = receipt_util.extract_transaction_id_from_app_receipt(receipt) + + self.assertEqual("2000000000000001", extracted_transaction_id) + + def test_app_receipt_extraction_with_transaction_id_that_is_not_a_utf8_string(self): + receipt_util = ReceiptUtility() + + for value, value_type in [(2000000000000001, asn1.Numbers.Integer), (b'2000000000000001', asn1.Numbers.OctetString), ("2000000000000001", asn1.Numbers.IA5String)]: + receipt = _create_app_receipt(_encode_attributes(17, _encode_attributes(1703, _encode_value(value, value_type)))) + with self.subTest(value_type=value_type), self.assertRaises(ValueError): + receipt_util.extract_transaction_id_from_app_receipt(receipt) + + def test_app_receipt_extraction_with_in_app_purchase_receipt_that_is_not_a_set(self): + receipt = _create_app_receipt(_encode_attributes(17, _encode_value("not a set", asn1.Numbers.UTF8String))) + + receipt_util = ReceiptUtility() + + with self.assertRaises(ValueError): + receipt_util.extract_transaction_id_from_app_receipt(receipt) + + def test_app_receipt_extraction_with_payload_that_is_not_a_set(self): + receipt = _create_app_receipt(_encode_attributes(17, _encode_attributes(1703, _encode_value("2000000000000001", asn1.Numbers.UTF8String)), asn1.Numbers.Sequence)) + + receipt_util = ReceiptUtility() + + with self.assertRaises(ValueError): + receipt_util.extract_transaction_id_from_app_receipt(receipt)