From 51750a03b0ac4d25db019a9d1a665d242023211e Mon Sep 17 00:00:00 2001 From: imSp4rky Date: Wed, 22 Jul 2026 09:18:14 -0600 Subject: [PATCH] feat(drm): add PlayReady HRESULT decoder Maps DRM_E_/DRM_S_ result codes to symbol + description so services can turn raw license HRESULTs (e.g. 0x8004C065) into readable errors. --- unshackle/core/drm/playready_errors.py | 865 +++++++++++++++++++++++++ 1 file changed, 865 insertions(+) create mode 100644 unshackle/core/drm/playready_errors.py diff --git a/unshackle/core/drm/playready_errors.py b/unshackle/core/drm/playready_errors.py new file mode 100644 index 00000000..0560eaed --- /dev/null +++ b/unshackle/core/drm/playready_errors.py @@ -0,0 +1,865 @@ +# Generated from PlayReady drmresults.h (DRM_E_/DRM_S_ result codes). + +from __future__ import annotations + +# {unsigned_hresult: (symbol, description)} +ERRORS: dict[int, tuple[str, str]] = { + 0x00000001: ("DRM_S_FALSE", "Operation was successful, but returned a FALSE test condition."), + 0x00000002: ("DRM_S_MORE_DATA", "Operation was successful, but more data is available."), + 0x0004C300: ("DRM_S_TEST_SKIP_FILE", "Skip processing this file, not an eror."), + 0x0004C301: ("DRM_S_TEST_CONVERTED_FILE", "The file was converted to a PlayReady file during the action."), + 0x80000002: ("DRM_E_OUTOFMEMORY", "Insufficient resources exist to complete the request."), + 0x80004001: ("DRM_E_NOTIMPL", "The requested operation is not implemented."), + 0x80004005: ("DRM_E_FAIL", "The requested operation failed."), + 0x80004006: ("DRM_E_HLOS_TAMPERED", "HLOS tampered."), + 0x80004007: ("DRM_E_OPL_BLOCKED", "OPL blocked."), + 0x80004008: ("DRM_E_LOAD_IMG", "Failed on loading playready image."), + 0x80004009: ("DRM_E_VER_MISMATCH", "Version mismatch between HLOS and TZ."), + 0x8000400A: ("DRM_E_SET_BANDWIDTH", "Failed on setting bandwidth."), + 0x8000400B: ("DRM_E_OUT_OF_BOUND", "Out of bound."), + 0x8000400C: ( + "DRM_E_PLAY_ENABLER_BLOCKED", + "WFD is blocked as play enabler object for HDCP doesn't exist in license", + ), + 0x8000400E: ("DRM_E_HDMI_READ_FAIL", "Failed to read HDMI Status"), + 0x80030002: ("DRM_E_FILENOTFOUND", "A requested file could not be found."), + 0x8003006E: ("DRM_E_FILEOPEN", "A request failed due to a file being open."), + 0x80040E80: ("DRM_E_VERIFICATION_FAILURE", "Validation of a Longhorn certificate failed."), + 0x80040E82: ("DRM_E_RSA_SIGNATURE_ERROR", "Error in RSA(PSS) signature."), + 0x80040E86: ("DRM_E_BAD_RSA_EXPONENT", "An incorrect RSA exponent was supplied for a public key."), + 0x80040E87: ("DRM_E_P256_CONVERSION_FAILURE", "An error occurred while converting between P256 types."), + 0x80040E88: ("DRM_E_P256_PKCRYPTO_FAILURE", "An error occurred in an asymmetric P256 cryptographic operation."), + 0x80040E89: ( + "DRM_E_P256_PLAINTEXT_MAPPING_FAILURE", + "An error occurred while attempting to map a plaintext array to a EC Point: There is no conversion for this byte array to a EC Point.", + ), + 0x80040E8A: ( + "DRM_E_P256_INVALID_SIGNATURE", + "The ECDSA signature to be verified was not a valid signature format.", + ), + 0x80040E8B: ( + "DRM_E_P256_ECDSA_VERIFICATION_ERROR", + "The ECDSA verification algorithm encountered an unknown error.", + ), + 0x80040E8C: ("DRM_E_P256_ECDSA_SIGNING_ERROR", "The ECDSA signature algorithm encountered an unknown error."), + 0x80040E8D: ( + "DRM_E_P256_HMAC_KEYGEN_FAILURE", + "Could not generate a valid HMAC key under constraint where CK || HMACK is a valid x coord on the EC (P256).", + ), + 0x80041100: ("DRM_E_CH_BASECODE", ""), + 0x80041103: ("DRM_E_CH_VERSION_MISSING", "Missing content header version."), + 0x80041104: ("DRM_E_CH_KID_MISSING", "Missing KID attribute in content header."), + 0x80041105: ("DRM_E_CH_LAINFO_MISSING", "Missing LAINFO attribute in content header."), + 0x80041106: ("DRM_E_CH_CHECKSUM_MISSING", "Missing content header checksum."), + 0x80041107: ("DRM_E_CH_ATTR_MISSING", "Missing content header attribute."), + 0x80041108: ("DRM_E_CH_INVALID_HEADER", "Invalid content header."), + 0x80041109: ("DRM_E_CH_INVALID_CHECKSUM", "Invalid checksum in the header."), + 0x8004110A: ("DRM_E_CH_UNABLE_TO_VERIFY", "Unable to verify signature of content header."), + 0x8004110B: ("DRM_E_CH_UNSUPPORTED_VERSION", "Unsupported content header version."), + 0x8004110C: ("DRM_E_CH_UNSUPPORTED_HASH_ALGORITHM", "Unsupported hash algorithm."), + 0x8004110D: ("DRM_E_CH_UNSUPPORTED_SIGN_ALGORITHM", "Unsupported signature algorithm."), + 0x8004110E: ("DRM_E_CH_BAD_KEY", "Invalid key."), + 0x8004110F: ("DRM_E_CH_INCOMPATIBLE_HEADER_TYPE", "Incompatible content header type."), + 0x80041110: ("DRM_E_HEADER_ALREADY_SET", "Content header type is already set. Reinitialize is required."), + 0x80041113: ("DRM_E_CH_NOT_SIGNED", "The header was not signed."), + 0x80041116: ("DRM_E_CH_UNKNOWN_ERROR", "Unknown Error."), + 0x80048000: ("DRM_E_LEGACY_BASECODE", ""), + 0x80048007: ("DRM_E_LIC_KEY_DECODE_FAILURE", "Key decode failure."), + 0x80048008: ("DRM_E_LIC_SIGNATURE_FAILURE", "License signature failure."), + 0x80048013: ("DRM_E_LIC_KEY_AND_CERT_MISMATCH", "Key and cert mismatch."), + 0x80048014: ("DRM_E_KEY_MISMATCH", "A public/private keypair is mismatched."), + 0x800480CF: ("DRM_E_INVALID_SIGNATURE", "License signature failure."), + 0x800480D0: ("DRM_E_SYNC_ENTRYNOTFOUND", "An entry was not found in the sync store."), + 0x800480D1: ("DRM_E_STACKTOOSMALL", "The stack supplied to the DRM API was too small."), + 0x800480D2: ( + "DRM_E_CIPHER_NOTINITIALIZED", + "The DRM Cipher routines were not correctly initialized before calling encryption/decryption routines.", + ), + 0x800480D3: ( + "DRM_E_DECRYPT_NOTINITIALIZED", + "The DRM decrypt routines were not correctly initialized before trying to decrypt data.", + ), + 0x800480D4: ( + "DRM_E_SECURESTORE_LOCKNOTOBTAINED", + "Before reading or writing data to securestore in raw mode, first the lock must be obtained using DRM_SST_OpenData.", + ), + 0x800480D5: ("DRM_E_PKCRYPTO_FAILURE", "An error occurred in an asymmetric cryptographic operation."), + 0x800480D6: ("DRM_E_INVALID_DSTSLOTSIZE", "Invalid DST slot size is specified."), + 0x8004A000: ("DRM_E_DEVICE_NOT_REGISTERED", "The DEVICEID does not exist in the device store"), + 0x8004A001: ( + "DRM_E_TOO_MANY_INCLUSION_GUIDS", + "The license contained more than DRM_MAX_INCLUSION_GUIDS entries in its inclusion list", + ), + 0x8004A002: ("DRM_E_REVOCATION_GUID_NOT_RECOGNIZED", "The revocation list type GUID was not recognized"), + 0x8004A003: ("DRM_E_LIC_CHAIN_TOO_DEEP", "The license chained deeper than this implementation can handle"), + 0x8004A004: ( + "DRM_E_DEVICE_SECURITY_LEVEL_TOO_LOW", + "The security level of the remote device is too low to receive the license", + ), + 0x8004A005: ("DRM_E_DST_BLOCK_CACHE_CORRUPT", "The block header cache returned invalid data"), + 0x8004A006: ("DRM_E_CONTRACT_FAILED", "The error code returned by the API is not present in the contract"), + 0x8004A007: ("DRM_E_DST_BLOCK_CACHE_MISS", "The block header cache didn't contain the requested block header"), + 0x8004A013: ("DRM_E_INVALID_METERRESPONSE_SIGNATURE", "Invalid signature in meter response"), + 0x8004A014: ("DRM_E_INVALID_LICENSE_REVOCATION_LIST_SIGNATURE", "Invalid signature in license revocation list."), + 0x8004A015: ("DRM_E_INVALID_METERCERT_SIGNATURE", "Invalid signature in metering certificate"), + 0x8004A016: ("DRM_E_METERSTORE_DATA_NOT_FOUND", "Metering data slot not found due to bad data in response file"), + 0x8004A017: ("DRM_E_NO_LICENSES_TO_SYNC", "No more licenses to sync"), + 0x8004A018: ( + "DRM_E_INVALID_REVOCATION_LIST", + "The revocation list version does not match the current revocation version", + ), + 0x8004A019: ("DRM_E_ENVELOPE_CORRUPT", "The envelope archive or file is corrupt"), + 0x8004A01A: ( + "DRM_E_ENVELOPE_FILE_NOT_COMPATIBLE", + "The envelope file is not compatible with this version of the porting kit", + ), + 0x8004A01B: ( + "DRM_E_EXTENDED_RESTRICTION_NOT_UNDERSTOOD", + "An extensible restriction was not understood by the app, and is mark as being required", + ), + 0x8004A01C: ("DRM_E_INVALID_SLK", "An ILA SLK (symmetric session key) was found, but did not contain valid data"), + 0x8004A01D: ( + "DRM_E_DEVCERT_MODEL_MISMATCH", + "The model string in the certificate does not match the model of the device and so the cert must be re-generated.", + ), + 0x8004C001: ("DRM_E_DEVICENOTINIT", "This device has not been initialized against a DRM init service"), + 0x8004C002: ("DRM_E_DRMNOTINIT", "The app has not call DRM_Init properly"), + 0x8004C003: ("DRM_E_INVALIDRIGHT", "A right in the license in invalid"), + 0x8004C004: ( + "DRM_E_INCOMPATABLELICENSESIZE", + "The size of the license is incompatable. DRM doesn't understand this license", + ), + 0x8004C005: ( + "DRM_E_INVALIDLICENSEFLAGS", + "The flags in the license are invalid. DRM either doesn't understand them or they are conflicting", + ), + 0x8004C006: ("DRM_E_INVALIDLICENSE", "The license is invalid"), + 0x8004C007: ("DRM_E_CONDITIONFAIL", "A condition in the license failed to pass"), + 0x8004C008: ("DRM_E_CONDITIONNOTSUPPORTED", "A condition in the license is not supported by this verison of DRM"), + 0x8004C009: ( + "DRM_E_LICENSEEXPIRED", + "The license has expired either by depleting a play count or via an end time.", + ), + 0x8004C00A: ("DRM_E_LICENSENOTYETVALID", "The license start time had not come to pass yet."), + 0x8004C00B: ("DRM_E_RIGHTSNOTAVAILABLE", "The rights the app has requested are not available in the license"), + 0x8004C00C: ("DRM_E_LICENSEMISMATCH", "The license content id/ sku id doesn't match that requested by the app"), + 0x8004C00D: ("DRM_E_WRONGTOKENTYPE", "The token parameter was of an incompatible type."), + 0x8004C00E: ("DRM_E_NORIGHTSREQUESTED", "The app has not requested any rights before trying to bind"), + 0x8004C00F: ( + "DRM_E_LICENSENOTBOUND", + "A license has not been bound to. Decrypt can not happen without a successful bind call", + ), + 0x8004C010: ("DRM_E_HASHMISMATCH", "A Keyed Hash check failed."), + 0x8004C011: ("DRM_E_INVALIDTIME", "A time structure is invalid."), + 0x8004C012: ("DRM_E_LICENSESTORENOTFOUND", "The external license store was not found."), + 0x8004C013: ("DRM_E_LICENSENOTFOUND", "A license was not found in the license store."), + 0x8004C014: ( + "DRM_E_LICENSEVERSIONNOTSUPPORTED", + "The DRM license version is not supported by the DRM version on the device.", + ), + 0x8004C015: ("DRM_E_INVALIDBINDID", "The bind id is invalid."), + 0x8004C016: ( + "DRM_E_UNSUPPORTEDALGORITHM", + "The encryption algorithm required for this operation is not supported.", + ), + 0x8004C017: ("DRM_E_ALGORITHMNOTSET", "The encryption algorithm required for this operation is not supported."), + 0x8004C018: ( + "DRM_E_LICENSESERVERNEEDSKEY", + "The license server needs a version of the device bind key from the init service.", + ), + 0x8004C019: ( + "DRM_E_INVALIDLICENSESTORE", + "The license store version number is incorrect, or the store is invalid in some other way.", + ), + 0x8004C01A: ("DRM_E_FILEREADERROR", "There was an error reading a file."), + 0x8004C01B: ("DRM_E_FILEWRITEERROR", "There was an error writing a file."), + 0x8004C01C: ( + "DRM_E_CLIENTTIMEINVALID", + "The time/clock on the device is not in sync with the license server within tolerance.", + ), + 0x8004C01D: ("DRM_E_DSTSTOREFULL", "The data store is full."), + 0x8004C01E: ("DRM_E_NOXMLOPENTAG", "XML open tag not found"), + 0x8004C01F: ("DRM_E_NOXMLCLOSETAG", "XML close tag not found"), + 0x8004C020: ("DRM_E_INVALIDXMLTAG", "Invalid XML tag"), + 0x8004C021: ("DRM_E_NOXMLCDATA", "No XML CDATA found"), + 0x8004C022: ("DRM_E_DSTNAMESPACEFULL", "No more room for DST Namespace"), + 0x8004C023: ("DRM_E_DSTNAMESPACENOTFOUND", "No DST Namespace found"), + 0x8004C024: ("DRM_E_DSTSLOTNOTFOUND", "DST Dataslot not found"), + 0x8004C025: ("DRM_E_DSTSLOTEXIST", "DST Dataslot already exists"), + 0x8004C026: ("DRM_E_DSTCORRUPTED", "The data store is corrupted"), + 0x8004C027: ("DRM_E_DSTSEEKERROR", "There was an error attempting to seek in the Data Store"), + 0x8004C028: ("DRM_E_DSTNAMESPACEINUSE", "No DST Namespace in use"), + 0x8004C029: ( + "DRM_E_INVALID_SECURESTORE_PASSWORD", + "The password used to open the secure store key was not able to validate the secure store hash.", + ), + 0x8004C02A: ("DRM_E_SECURESTORE_CORRUPT", "The secure store is corrupt"), + 0x8004C02B: ("DRM_E_SECURESTORE_FULL", "The current secure store key is full. No more data can be added."), + 0x8004C02C: ("DRM_E_NOACTIONINLICENSEREQUEST", "No action(s) added for license request"), + 0x8004C02D: ("DRM_E_DUPLICATEDHEADERATTRIBUTE", "Duplicated attribute in Header"), + 0x8004C02E: ("DRM_E_NOKIDINHEADER", "No KID attribute in Header"), + 0x8004C02F: ("DRM_E_NOLAINFOINHEADER", "No LAINFO attribute in Header"), + 0x8004C030: ("DRM_E_NOCHECKSUMINHEADER", "No Checksum attribute in Header"), + 0x8004C031: ("DRM_E_DSTBLOCKMISMATCH", "DST block mismatch"), + 0x8004C032: ("DRM_E_BACKUP_EXISTS", "Backup file already exist."), + 0x8004C033: ("DRM_E_LICENSE_TOOLONG", "License size is too long"), + 0x8004C034: ("DRM_E_DSTEXISTS", "A DST already exists in the specified location"), + 0x8004C035: ("DRM_E_INVALIDDEVICECERTIFICATE", "The device certificate is invalid."), + 0x8004C036: ("DRM_E_DSTLOCKFAILED", "Locking a segment of the DST failed."), + 0x8004C037: ("DRM_E_FILESEEKERROR", "File Seek Error"), + 0x8004C038: ("DRM_E_DSTNOTLOCKEDEXCLUSIVE", "Existing lock is not exclusive"), + 0x8004C039: ("DRM_E_DSTEXCLUSIVELOCKONLY", "Only exclusive lock is accepted"), + 0x8004C03A: ("DRM_E_DSTRESERVEDKEYDETECTED", "DST reserved key value detected in UniqueKey"), + 0x8004C03B: ("DRM_E_V1_NOT_SUPPORTED", "V1 Lic Acquisition is not supported"), + 0x8004C03C: ("DRM_E_HEADER_NOT_SET", "Content header is not set"), + 0x8004C03D: ("DRM_E_NEEDDEVCERTINDIV", "The device certificate is template. It need Devcert Indiv"), + 0x8004C03E: ("DRM_E_MACHINEIDMISMATCH", "The device has Machine Id different from that in devcert."), + 0x8004C03F: ("DRM_E_CLK_INVALID_RESPONSE", "The secure clock response is invalid."), + 0x8004C040: ("DRM_E_CLK_INVALID_DATE", "The secure clock response is invalid."), + 0x8004C041: ("DRM_E_CLK_UNSUPPORTED_VALUE", "The secure clock response has unsupported value."), + 0x8004C042: ("DRM_E_INVALIDDEVICECERTIFICATETEMPLATE", "The device certificate is invalid."), + 0x8004C043: ("DRM_E_DEVCERTEXCEEDSIZELIMIT", "The device certificate exceeds max size"), + 0x8004C044: ("DRM_E_DEVCERTTEMPLATEEXCEEDSSIZELIMIT", "The device certificate template exceeds max size"), + 0x8004C045: ("DRM_E_DEVCERTREADERROR", "Can't get the device certificate"), + 0x8004C046: ("DRM_E_DEVCERTWRITEERROR", "Can't store the device certificate"), + 0x8004C047: ("DRM_E_PRIVKEYREADERROR", "Can't get device private key"), + 0x8004C048: ("DRM_E_PRIVKEYWRITEERROR", "Can't store device private key"), + 0x8004C049: ("DRM_E_DEVCERTTEMPLATEREADERROR", "Can't get the device certificate template"), + 0x8004C04A: ("DRM_E_CLK_NOT_SUPPORTED", "The secure clock is not supported."), + 0x8004C04B: ("DRM_E_DEVCERTINDIV_NOT_SUPPORTED", "The Devcert Indiv is not supported."), + 0x8004C04C: ("DRM_E_METERING_NOT_SUPPORTED", "The Metering is not supported."), + 0x8004C04D: ("DRM_E_CLK_RESETSTATEREADERROR", "Can not read Secure clock Reset State."), + 0x8004C04E: ("DRM_E_CLK_RESETSTATEWRITEERROR", "Can not write Secure clock Reset State."), + 0x8004C04F: ("DRM_E_XMLNOTFOUND", "a required XML tag was not found"), + 0x8004C050: ("DRM_E_METERING_WRONG_TID", "wrong TID sent on metering response"), + 0x8004C051: ("DRM_E_METERING_INVALID_COMMAND", "wrong command sent on metering response"), + 0x8004C052: ("DRM_E_METERING_STORE_CORRUPT", "The metering store is corrupt"), + 0x8004C053: ("DRM_E_CERTIFICATE_REVOKED", "A certificate given to DRM was revoked."), + 0x8004C054: ("DRM_E_CRYPTO_FAILED", "A cryptographic operation failed."), + 0x8004C055: ("DRM_E_STACK_CORRUPT", "The stack allocator context is corrupt. Likely a buffer overrun problem."), + 0x8004C056: ("DRM_E_UNKNOWN_BINDING_KEY", "A matching binding key could not be found for the license."), + 0x8004C057: ("DRM_E_V1_LICENSE_CHAIN_NOT_SUPPORTED", "License chaining with V1 content is not supported."), + 0x8004C058: ("DRM_E_WRONG_TOKEN_TYPE", "The wrong type of token was used."), + 0x8004C059: ( + "DRM_E_POLICY_METERING_DISABLED", + "Metering code was called but metering is disabled by group or user policy", + ), + 0x8004C05A: ("DRM_E_POLICY_ONLINE_DISABLED", "online communication is disabled by group policy"), + 0x8004C05B: ("DRM_E_CLK_NOT_SET", "License may be there but can not be used as secure clock not set."), + 0x8004C05C: ( + "DRM_E_NO_CLK_SUPPORTED", + "This device does not support any Clock. So time bound licenses can not be played", + ), + 0x8004C05D: ("DRM_E_NO_URL", "Can not find URL info."), + 0x8004C05E: ("DRM_E_UNKNOWN_DEVICE_PROPERTY", "Unknown device property."), + 0x8004C05F: ( + "DRM_E_METERING_MID_MISMATCH", + "The metering ID is not same in Metering Cert and metering response data", + ), + 0x8004C060: ( + "DRM_E_METERING_RESPONSE_DECRYPT_FAILED", + "The encrypted section of metering response can not be decrypted", + ), + 0x8004C063: ("DRM_E_RIV_TOO_SMALL", "RIV on the machine is too small."), + 0x8004C064: ("DRM_E_STACK_ALREADY_INITIALIZED", "DRM_STK_Init called for initialized stack"), + 0x8004C065: ("DRM_E_DEVCERT_REVOKED", "The device certificate given to DRM is revoked."), + 0x8004C066: ("DRM_E_OEM_RSA_DECRYPTION_ERROR", "Error in OEM RSA Decryption."), + 0x8004C067: ("DRM_E_INVALID_DEVSTORE_ATTRIBUTE", "Invalid device attributes in the device store"), + 0x8004C068: ("DRM_E_INVALID_DEVSTORE_ENTRY", "The device store data entry is corrupted"), + 0x8004C069: ("DRM_E_OEM_RSA_ENCRYPTION_ERROR", "Error in OEM RSA Encryption process"), + 0x8004C06A: ("DRM_E_DSTNAMESPACEEXIST", "The DST Namespace already exists."), + 0x8004C06B: ("DRM_E_PERF_SCOPING_ERROR", "Error in performance scope context"), + 0x8004C06C: ("DRM_E_PRECISION_ARITHMETIC_FAIL", "Operation involving multiple precision arithmetic fails"), + 0x8004C06D: ("DRM_E_OEM_RSA_INVALID_PRIVATE_KEY", "Invalid private key."), + 0x8004C06E: ( + "DRM_E_NO_OPL_CALLBACK", + "There is no callback function to process the output restrictions specified in the license", + ), + 0x8004C06F: ("DRM_E_INVALID_PLAYREADY_OBJECT", "Structure of PlayReady object is invalid"), + 0x8004C070: ("DRM_E_DUPLICATE_LICENSE", "There is already a license in the store with the same KID & LID"), + 0x8004C071: ( + "DRM_E_REVOCATION_NOT_SUPPORTED", + "Device does not support revocation, while revocation data was placed into license policy structure.", + ), + 0x8004C072: ("DRM_E_RECORD_NOT_FOUND", "Record with requested type was not found in PlayReady object."), + 0x8004C073: ("DRM_E_BUFFER_BOUNDS_EXCEEDED", "An array is being referenced outside of it's bounds."), + 0x8004C074: ("DRM_E_INVALID_BASE64", "An input string contains invalid Base64 characters."), + 0x8004C075: ("DRM_E_PROTOCOL_VERSION_NOT_SUPPORTED", "The protocol version is not supported."), + 0x8004C076: ( + "DRM_E_INVALID_LICENSE_RESPONSE_SIGNATURE", + "Cannot verify license acquisition's response because signature is invalid.", + ), + 0x8004C077: ( + "DRM_E_INVALID_LICENSE_RESPONSE_RESPONSEID", + "Cannot verify license acquisition's response because response ID is invalid.", + ), + 0x8004C078: ( + "DRM_E_LICENSE_RESPONSE_SIGNATURE_MISSING", + "Cannot verify license acquisition's response because either response ID, license nonce or signature is missing.", + ), + 0x8004C079: ( + "DRM_E_INVALID_DOMAIN_JOIN_RESPONSE_SIGNATURE", + "Cannot verify domain join response because signature is invalid.", + ), + 0x8004C07A: ( + "DRM_E_DOMAIN_JOIN_RESPONSE_SIGNATURE_MISSING", + "Cannot verify domain join response because either signing certificate chain or signature is missing.", + ), + 0x8004C07B: ("DRM_E_ACTIVATION_REQUIRED", "The device must be activated before initialization can succeed."), + 0x8004C07C: ("DRM_E_ACTIVATION_INTERNAL_ERROR", "A server error occurred during device activation."), + 0x8004C07D: ( + "DRM_E_ACTIVATION_GROUP_CERT_REVOKED_ERROR", + "The activation group cert has been revoked and the application must be updated with a new client lib.", + ), + 0x8004C07E: ( + "DRM_E_ACTIVATION_NEW_CLIENT_LIB_REQUIRED_ERROR", + "The client lib used by the application is not supported and must be updated.", + ), + 0x8004C07F: ("DRM_E_ACTIVATION_BAD_REQUEST", "The activation request is invalid"), + 0x8004C080: ("DRM_E_FILEIO_ERROR", "Encountered a system error during file I/O."), + 0x8004C081: ("DRM_E_DISKSPACE_ERROR", "Out of disk space for storing playready files."), + 0x8004C082: ( + "DRM_E_UPLINKLICENSENOTFOUND", + "A license was found in the license store but no license was found for its uplink ID.", + ), + 0x8004C0A0: ("DRM_E_LRB_NOLGPUBKEY", "LRB does not contain a valid LGPUBKEY."), + 0x8004C0A1: ("DRM_E_LRB_INVALIDSIGNATURE", "Signature inside LRB is invalid."), + 0x8004C0A2: ("DRM_E_LRB_LGPUBKEY_MISMATCH", "LRB is signed with a pubkey different from LGPUBKEY"), + 0x8004C0A3: ("DRM_E_LRB_INVALIDLICENSEDATA", "LRB is signed with a pubkey different from LGPUBKEY"), + 0x8004C0C0: ("DRM_E_LICEVAL_LICENSE_NOT_SUPPLIED", "License not supplied in the liceval context"), + 0x8004C0C1: ("DRM_E_LICEVAL_KID_MISMATCH", "Mismatch between KID from header and the one inside license"), + 0x8004C0C2: ("DRM_E_LICEVAL_LICENSE_REVOKED", "License for this content has been revoked"), + 0x8004C0C3: ("DRM_E_LICEVAL_UPDATE_FAILURE", "Failed to update content revocation"), + 0x8004C0C4: ("DRM_E_LICEVAL_REQUIRED_REVOCATION_LIST_NOT_AVAILABLE", "Failed to update content revocation"), + 0x8004C0E0: ("DRM_E_XMR_OBJECT_ALREADY_EXISTS", "XMR builder context already has this object."), + 0x8004C0E1: ("DRM_E_XMR_OBJECT_NOTFOUND", "XMR object was not found."), + 0x8004C0E2: ("DRM_E_XMR_REQUIRED_OBJECT_MISSING", "XMR license doesn't have one or more required objects."), + 0x8004C0E3: ("DRM_E_XMR_INVALID_UNKNOWN_OBJECT", "Invalid unknown object"), + 0x8004C0E4: ("DRM_E_XMR_LICENSE_BINDABLE", "XMR license does not contain the Cannot Bind right"), + 0x8004C0E5: ("DRM_E_XMR_LICENSE_NOT_BINDABLE", "XMR license cannot be bound to because of the Cannot Bind right"), + 0x8004C0E6: ( + "DRM_E_XMR_UNSUPPORTED_XMR_VERSION", + "The version of XMR license is not supported for the current action", + ), + 0x8004C100: ( + "DRM_E_NOT_CRL_BLOB", + "CRL blob provided for parsing does not start with CBLB. It means file is not CRL blob at all.", + ), + 0x8004C101: ( + "DRM_E_BAD_CRL_BLOB", + "The file is structured as CRL blob, but there is some error in file structure or one of CRLs inside is invalid.", + ), + 0x8004C200: ("DRM_E_INVALID_DEVCERT_ATTRIBUTE", "The attributes in the Device certificate are invalid"), + 0x8004C300: ("DRM_E_TEST_PKCRYPTO_FAILURE", "Error in PK encryption/decryption crypto test cases."), + 0x8004C301: ("DRM_E_TEST_PKSIGN_VERIFY_ERROR", "Digital signature verification failed."), + 0x8004C302: ("DRM_E_TEST_ENCRYPT_ERROR", "Error in encryption of cipher text."), + 0x8004C303: ("DRM_E_TEST_RC4KEY_FAILED", "RC4 key failed during crypto operations."), + 0x8004C304: ("DRM_E_TEST_DECRYPT_ERROR", "Error in cipher text decryption."), + 0x8004C305: ("DRM_E_TEST_DESKEY_FAILED", "Decrypted data not equal to original data in a DES operation."), + 0x8004C306: ("DRM_E_TEST_CBC_INVERSEMAC_FAILURE", "Decrypted data not equal to original in Inverse MAC operation."), + 0x8004C307: ("DRM_E_TEST_HMAC_FAILURE", "Error in hashed data in HMAC operation."), + 0x8004C308: ("DRM_E_TEST_INVALIDARG", "Error in the number of arguments or argument data in Test files."), + 0x8004C30A: ( + "DRM_E_TEST_DEVICE_PRIVATE_KEY_INCORRECTLY_STORED", + "DRMManager context should not contain the device private key.", + ), + 0x8004C30B: ("DRM_E_TEST_DRMMANAGER_CONTEXT_NULL", "DRMManager context is NULL."), + 0x8004C30C: ("DRM_E_TEST_UNEXPECTED_REVINFO_RESULT", "Revocation cache result was not as expected."), + 0x8004C30D: ("DRM_E_TEST_RIV_MISMATCH", "Revocation Info Version(RIV) mismatch."), + 0x8004C310: ("DRM_E_TEST_URL_ERROR", "There is an error in the URL from the challenge generated."), + 0x8004C311: ( + "DRM_E_TEST_MID_MISMATCH", + "The MIDs returned from the DRM_MANAGER_CONTEXT does not match the test input.", + ), + 0x8004C312: ( + "DRM_E_TEST_METER_CERTIFICATE_MISMATCH", + "The input data does not match with the Metering certificate returned from the license.", + ), + 0x8004C313: ( + "DRM_E_TEST_LICENSE_STATE_MISMATCH", + "The input data and license state returned from the license do not match.", + ), + 0x8004C316: ( + "DRM_E_TEST_SOURCE_ID_MISMATCH", + "The input data and license state returned from the license do not match.", + ), + 0x8004C317: ( + "DRM_E_TEST_UNEXPECTED_LICENSE_COUNT", + "The input data and the number of license from the KID do not match.", + ), + 0x8004C318: ("DRM_E_TEST_UNEXPECTED_DEVICE_PROPERTY", "Unknown device property."), + 0x8004C319: ("DRM_E_TEST_DRMMANAGER_MISALIGNED_BYTES", "Error due to misalignment of bytes."), + 0x8004C31A: ( + "DRM_E_TEST_LICENSE_RESPONSE_ERROR", + "The license response callbacks did not provide the expected data.", + ), + 0x8004C31B: ( + "DRM_E_TEST_OPL_MISMATCH", + "The minimum levels of the compressed/uncompressed Digital and Analog Video do not match the OPL.", + ), + 0x8004C31C: ("DRM_E_TEST_INVALID_OPL_CALLBACK", "The callback type supplied is not valid."), + 0x8004C31D: ("DRM_E_TEST_INCOMPLETE", "The test function failed to complete."), + 0x8004C31E: ( + "DRM_E_TEST_UNEXPECTED_OUTPUT", + "The output of the function being tested does not match the expected output.", + ), + 0x8004C31F: ( + "DRM_E_TEST_DLA_NO_CONTENT_HEADER", + "Content Header Information was not retrieved correctly in DLA Sync Tests.", + ), + 0x8004C320: ( + "DRM_E_TEST_DLA_CONTENT_HEADER_FOUND", + "Content Header Information was found when it should not have been in DLA Sync Tests.", + ), + 0x8004C321: ("DRM_E_TEST_SYNC_LSD_INCORRECT", "DRM_SNC_GetSyncStoreEntry returned incorrect License State Data."), + 0x8004C322: ("DRM_E_TEST_TOO_SLOW", "The performance test failed because DRM took longer than its maximum time."), + 0x8004C323: ( + "DRM_E_TEST_LICENSESTORE_NOT_OPEN", + "The License Store contexts in the App Manager context are not open.", + ), + 0x8004C324: ("DRM_E_TEST_DEVICE_NOT_INITED", "The device instance has not been initialized prior to use."), + 0x8004C325: ( + "DRM_E_TEST_VARIABLE_NOT_SET", + "A global variable needed for test execution has not been set correctly.", + ), + 0x8004C326: ("DRM_E_TEST_NOMORE", "The same as DRM_E_NOMORE, only explicitly used in test code."), + 0x8004C327: ("DRM_E_TEST_FILE_LOAD_ERROR", "There was an error loading a test data file."), + 0x8004C328: ("DRM_E_TEST_LICENSE_ACQ_FAILED", "The attempt to acquire a license failed."), + 0x8004C329: ( + "DRM_E_TEST_UNSUPPORTED_FILE_FORMAT", + "A file format is being used which is not supported by the test function.", + ), + 0x8004C32A: ("DRM_E_TEST_PARSING_ERROR", "There was an error parsing input parameter."), + 0x8004C32B: ("DRM_E_TEST_NOTIMPL", "The specified test API is not implemented."), + 0x8004C32C: ( + "DRM_E_TEST_VARIABLE_NOTFOUND", + "The specified test varaible was not found in the shared variable table.", + ), + 0x8004C32D: ("DRM_E_TEST_VARIABLE_LISTFULL", "The shared test variable table is full."), + 0x8004C32E: ("DRM_E_TEST_UNEXPECTED_CONTENT_PROPERTY", "Unknown content property."), + 0x8004C32F: ("DRM_E_TEST_PRO_HEADER_NOT_SET", "PlayReady Object Header not set."), + 0x8004C330: ("DRM_E_TEST_NON_PRO_HEADER_TYPE", "Incompatible header - PlayReady Object Header expected."), + 0x8004C331: ("DRM_E_TEST_INVALID_DEVICE_WRAPPER", "The Device Simulator Device Wrapper is not valid."), + 0x8004C332: ("DRM_E_TEST_INVALID_WMDM_WRAPPER", "The Device Simulator WMDM Wrapper is not valid."), + 0x8004C333: ("DRM_E_TEST_INVALID_WPD_WRAPPER", "The Device Simulator WPD Wrapper is not valid."), + 0x8004C334: ("DRM_E_TEST_INVALID_FILE", "The data file given was invalid."), + 0x8004C335: ("DRM_E_TEST_PROPERTY_NOT_FOUND", "The object did not have the property which was queried."), + 0x8004C336: ("DRM_E_TEST_METERING_DATA_INCORRECT", "The metering data reported is incorrect."), + 0x8004C337: ( + "DRM_E_TEST_FILE_ALREADY_OPEN", + "The handle variable for a test file is not NULL. This indicates that a file was opened and not closed properly.", + ), + 0x8004C338: ( + "DRM_E_TEST_FILE_NOT_OPEN", + "The handle variable for a test file is NULL. This indicates that a file was not opened.", + ), + 0x8004C339: ( + "DRM_E_TEST_PICT_COLUMN_TOO_WIDE", + "The PICT input file contains a column which is too wide for the test parser to handle.", + ), + 0x8004C33A: ( + "DRM_E_TEST_PICT_COLUMN_MISMATCH", + "The PICT input file contains a row which doesn't have the same number of columns as the header row.", + ), + 0x8004C33B: ("DRM_E_TEST_TUX_TEST_SKIPPED", "TUX cannot find the speficied test case in target dll. Test Skipped."), + 0x8004C33C: ("DRM_E_TEST_KEYFILE_VERIFICATION_FAILURE", "Verification of the Keyfile context failed."), + 0x8004C33D: ("DRM_E_TEST_DATA_VERIFICATION_FAILURE", "Data does not match expected value and failed verification."), + 0x8004C33E: ("DRM_E_TEST_NET_FAIL", "The Test failed to perform Network I/O."), + 0x8004C3E8: ( + "DRM_E_LOGICERR", + "DRM code has a logic error in it. This result should never be returned. There is an unhandled code path if it is returned.", + ), + 0x8004C3E9: ("DRM_E_INVALIDREVINFO", "The device certificate is invalid."), + 0x8004C3EA: ("DRM_E_SYNCLISTNOTSUPPORTED", "The device does not support synclist."), + 0x8004C3EB: ("DRM_E_REVOCATION_BUFFERTOOSMALL", "The revocation buffer is too small."), + 0x8004C3EC: ( + "DRM_E_DEVICE_ALREADY_REGISTERED", + "There exists already a device in the device store with the same DEVICEID that was given.", + ), + 0x8004C3ED: ("DRM_E_DST_NOT_COMPATIBLE", "The data store version is incompatible with this version of DRM."), + 0x8004C3F0: ("DRM_E_RSA_DECRYPTION_ERROR", "The data block/Encoded message used in OAEP decoding is incorrect."), + 0x8004C3F1: ("DRM_E_OEM_RSA_MESSAGE_TOO_BIG", "The base message buffer is larger than the given modulus."), + 0x8004C3F2: ("DRM_E_METERCERTNOTFOUND", "The metering certificate was not found in the store."), + 0x8004C3F3: ("DRM_E_MODULAR_ARITHMETIC_FAILURE", "A failure occurred in bignum modular arithmetic."), + 0x8004C3F4: ("DRM_E_FEATURE_NOT_SUPPORTED", "The feature is not supported in this release."), + 0x8004C3F5: ("DRM_E_REVOCATION_INVALID_PACKAGE", "The revocation package is invalid"), + 0x8004C3F6: ("DRM_E_HWID_ERROR", "Failed to get the hardware ID."), + 0x8004C500: ("DRM_E_DOMAIN_INVALID_GUID", "Not a correct GUID."), + 0x8004C501: ("DRM_E_DOMAIN_INVALID_CUSTOM_DATA_TYPE", "Not a valid custom data type."), + 0x8004C502: ("DRM_E_DOMAIN_STORE_ADD_DATA", "Failed to add data into the domain store."), + 0x8004C503: ("DRM_E_DOMAIN_STORE_GET_DATA", "Failed to retrieve data from the domain store."), + 0x8004C504: ("DRM_E_DOMAIN_STORE_DELETE_DATA", "Failed to delete data from the domain store."), + 0x8004C505: ("DRM_E_DOMAIN_STORE_OPEN_STORE", "Failed to open the domain store."), + 0x8004C506: ("DRM_E_DOMAIN_STORE_CLOSE_STORE", "Failed to close the domain store."), + 0x8004C507: ("DRM_E_DOMAIN_BIND_LICENSE", "Failed to bind to the domain license."), + 0x8004C508: ("DRM_E_DOMAIN_INVALID_CUSTOM_DATA", "Not a valid custom data."), + 0x8004C509: ("DRM_E_DOMAIN_NOT_FOUND", "No domain information is found."), + 0x8004C50A: ( + "DRM_E_DOMAIN_INVALID_DOMKEYXMR_DATA", + "The domain join response contains invalid domain privkey XMR data.", + ), + 0x8004C50B: ( + "DRM_E_DOMAIN_STORE_INVALID_KEY_RECORD", + "Invalid format of domain private key record read from the domain store.", + ), + 0x8004C580: ( + "DRM_E_DEVICE_DOMAIN_JOIN_REQUIRED", + "This error code communicates to the application that the device is not a member of a domain. The app can uses this error code in turn to decide whether it needs to join the domain or not", + ), + 0x8004C600: ("DRM_E_SERVER_INTERNAL_ERROR", "An internal server error occurred."), + 0x8004C601: ("DRM_E_SERVER_INVALID_MESSAGE", "The message sent to the server was invalid."), + 0x8004C602: ("DRM_E_SERVER_DEVICE_LIMIT_REACHED", "The device limit for the domain has been reached."), + 0x8004C603: ("DRM_E_SERVER_INDIV_REQUIRED", "Individualization of the client is required."), + 0x8004C604: ("DRM_E_SERVER_SERVICE_SPECIFIC", "An error specific to the service has occurred."), + 0x8004C605: ("DRM_E_SERVER_DOMAIN_REQUIRED", "A Domain certificate is required."), + 0x8004C606: ("DRM_E_SERVER_RENEW_DOMAIN", "The Domain certificate needs to be renewed."), + 0x8004C607: ("DRM_E_SERVER_UNKNOWN_METERINGID", "The metering identifier is unknown."), + 0x8004C608: ("DRM_E_SERVER_COMPUTER_LIMIT_REACHED", "The computer limit for the domain has been reached."), + 0x8004C609: ( + "DRM_E_SERVER_PROTOCOL_FALLBACK", + "The client should fallback to the V2 license acquisition protocol.", + ), + 0x8004C60A: ( + "DRM_E_SERVER_NOT_A_MEMBER", + "The client was removed from the domain in an offline fashion and thus still has a domain cert, but not a valid domain membership.", + ), + 0x8004C60B: ( + "DRM_E_SERVER_PROTOCOL_VERSION_MISMATCH", + "The protocol version specified was not supported by the server.", + ), + 0x8004C60C: ("DRM_E_SERVER_UNKNOWN_ACCOUNTID", "The account identifier is unknown."), + 0x8004C60D: ("DRM_E_SERVER_PROTOCOL_REDIRECT", "The protocol has a redirect."), + 0x8004C610: ("DRM_E_SERVER_UNKNOWN_TRANSACTIONID", "The transaction identifier is unknown."), + 0x8004C611: ("DRM_E_SERVER_INVALID_LICENSEID", "The license identifier is invalid."), + 0x8004C612: ( + "DRM_E_SERVER_MAXIMUM_LICENSEID_EXCEEDED", + "The maximum number of license identifiers in the request was exceeded.", + ), + 0x8004C700: ("DRM_E_LICACQ_TOO_MANY_LICENSES", "There are too many licenses in the license response."), + 0x8004C701: ( + "DRM_E_LICACQ_ACK_TRANSACTIONID_TOO_BIG", + "The Transaction ID specified by the server exceeds the allocated buffer.", + ), + 0x8004C702: ( + "DRM_E_LICACQ_ACK_MESSAGE_NOT_CREATED", + "The license acquisition acknowledgement message could not be created.", + ), + 0x8004C780: ("DRM_E_INITIATORS_UNKNOWN_TYPE", "The initiator type is unknown."), + 0x8004C781: ("DRM_E_INITIATORS_INVALID_SERVICEID", "The service ID data is not valid."), + 0x8004C782: ("DRM_E_INITIATORS_INVALID_ACCOUNTID", "The account ID data is not valid."), + 0x8004C783: ("DRM_E_INITIATORS_INVALID_MID", "The account ID data is not valid."), + 0x8004C784: ("DRM_E_INITIATORS_MISSING_DC_URL", "Domain Controller URL is missing."), + 0x8004C785: ("DRM_E_INITIATORS_MISSING_CONTENT_HEADER", "Content header is missing."), + 0x8004C786: ( + "DRM_E_INITIATORS_MISSING_LAURL_IN_CONTENT_HEADER", + "Missing license acquisition URL in content header.", + ), + 0x8004C787: ("DRM_E_INITIATORS_MISSING_METERCERT_URL", "Meter certificate server URL is missing."), + 0x8004C800: ("DRM_E_BCERT_INVALID_SIGNATURE_TYPE", "An invalid signature type was encountered"), + 0x8004C801: ( + "DRM_E_BCERT_CHAIN_TOO_DEEP", + "There are, or there would be, too many certificates in the certificate chain", + ), + 0x8004C802: ("DRM_E_BCERT_INVALID_CERT_TYPE", "An invalid certificate type was encountered"), + 0x8004C803: ("DRM_E_BCERT_INVALID_FEATURE", "An invalid feature entry was encountered"), + 0x8004C804: ("DRM_E_BCERT_INVALID_KEY_USAGE", "An invalid public key usage was encountered"), + 0x8004C805: ("DRM_E_BCERT_INVALID_SECURITY_VERSION", "An invalid Indiv Box security version was encountered"), + 0x8004C806: ("DRM_E_BCERT_INVALID_KEY_TYPE", "An invalid public key type was encountered"), + 0x8004C807: ("DRM_E_BCERT_INVALID_KEY_LENGTH", "An invalid public key length was encountered"), + 0x8004C808: ("DRM_E_BCERT_INVALID_MAX_LICENSE_SIZE", "An invalid maximum license size value was encountered"), + 0x8004C809: ("DRM_E_BCERT_INVALID_MAX_HEADER_SIZE", "An invalid maximum license header size value was encountered"), + 0x8004C80A: ( + "DRM_E_BCERT_INVALID_MAX_LICENSE_CHAIN_DEPTH", + "An invalid maximum license chain depth was encountered", + ), + 0x8004C80B: ("DRM_E_BCERT_INVALID_SECURITY_LEVEL", "An invalid security level was encountered"), + 0x8004C80C: ( + "DRM_E_BCERT_PRIVATE_KEY_NOT_SPECIFIED", + "A private key for signing the certificate was not provided to the builder", + ), + 0x8004C80D: ("DRM_E_BCERT_ISSUER_KEY_NOT_SPECIFIED", "An issuer key was not provided to the builder"), + 0x8004C80E: ("DRM_E_BCERT_ACCOUNT_ID_NOT_SPECIFIED", "An account ID was not provided to the builder"), + 0x8004C80F: ("DRM_E_BCERT_SERVICE_ID_NOT_SPECIFIED", "A service provider ID was not provided to the builder"), + 0x8004C810: ("DRM_E_BCERT_CLIENT_ID_NOT_SPECIFIED", "A client ID was not provided to the builder"), + 0x8004C811: ("DRM_E_BCERT_DOMAIN_URL_NOT_SPECIFIED", "A domain URL was not provided to the builder"), + 0x8004C812: ("DRM_E_BCERT_DOMAIN_URL_TOO_LONG", "The domain URL contains too many ASCII characters"), + 0x8004C813: ("DRM_E_BCERT_HARDWARE_ID_NOT_SPECIFIED", "A hardware ID was not provided to the builder"), + 0x8004C814: ("DRM_E_BCERT_HARDWARE_ID_TOO_LONG", "A hardware ID is longer than the maximum supported bytes"), + 0x8004C815: ("DRM_E_BCERT_SERIAL_NUM_NOT_SPECIFIED", "A device serial number was not provided to the builder"), + 0x8004C816: ("DRM_E_BCERT_CERT_ID_NOT_SPECIFIED", "A certificate ID was not provided to the builder"), + 0x8004C817: ( + "DRM_E_BCERT_PUBLIC_KEY_NOT_SPECIFIED", + "A public key for the certificate was not provided to the builder or not found by the parser", + ), + 0x8004C818: ( + "DRM_E_BCERT_KEY_USAGES_NOT_SPECIFIED", + "The public key usage information was not provided to the builder or not found by the parser", + ), + 0x8004C819: ("DRM_E_BCERT_STRING_NOT_NULL_TERMINATED", "Data string is not null-teminated"), + 0x8004C81A: ("DRM_E_BCERT_OBJECTHEADER_LEN_TOO_BIG", "Object length in object header is too big"), + 0x8004C81B: ("DRM_E_BCERT_INVALID_ISSUERKEY_LENGTH", "IssuerKey Length value is invalid"), + 0x8004C81C: ("DRM_E_BCERT_BASICINFO_CERT_EXPIRED", "Certificate is expired"), + 0x8004C81D: ("DRM_E_BCERT_UNEXPECTED_OBJECT_HEADER", "Object header has unexpected values"), + 0x8004C81E: ( + "DRM_E_BCERT_ISSUERKEY_KEYINFO_MISMATCH", + "The cert's Issuer Key does not match key info in the next cert", + ), + 0x8004C81F: ("DRM_E_BCERT_INVALID_MAX_KEY_USAGES", "Number of key usage entries is invalid"), + 0x8004C820: ("DRM_E_BCERT_INVALID_MAX_FEATURES", "Number of features is invalid"), + 0x8004C821: ("DRM_E_BCERT_INVALID_CHAIN_HEADER_TAG", "Cert chain header tag is invalid"), + 0x8004C822: ("DRM_E_BCERT_INVALID_CHAIN_VERSION", "Cert chain version is invalid"), + 0x8004C823: ("DRM_E_BCERT_INVALID_CHAIN_LENGTH", "Cert chain length value is invalid"), + 0x8004C824: ("DRM_E_BCERT_INVALID_CERT_HEADER_TAG", "Cert header tag is invalid"), + 0x8004C825: ("DRM_E_BCERT_INVALID_CERT_VERSION", "Cert version is invalid"), + 0x8004C826: ("DRM_E_BCERT_INVALID_CERT_LENGTH", "Cert length value is invalid"), + 0x8004C827: ("DRM_E_BCERT_INVALID_SIGNEDCERT_LENGTH", "Length of signed portion of certificate is invalid"), + 0x8004C828: ("DRM_E_BCERT_INVALID_PLATFORM_IDENTIFIER", "An invalid Platform Identifier was specified"), + 0x8004C829: ("DRM_E_BCERT_INVALID_NUMBER_EXTDATARECORDS", "An invalid number of extended data records"), + 0x8004C82A: ("DRM_E_BCERT_INVALID_EXTDATARECORD", "An invalid extended data record"), + 0x8004C82B: ("DRM_E_BCERT_EXTDATA_LENGTH_MUST_PRESENT", "Extended data record length must be present."), + 0x8004C82C: ("DRM_E_BCERT_EXTDATA_PRIVKEY_MUST_PRESENT", "Extended data record length must be present."), + 0x8004C82D: ( + "DRM_E_BCERT_INVALID_EXTDATA_LENGTH", + "Calculated and written extended data object lengths do not match.", + ), + 0x8004C82E: ( + "DRM_E_BCERT_EXTDATA_IS_NOT_PROVIDED", + "Extended data is not provided, the cert builder cannot write it.", + ), + 0x8004C82F: ( + "DRM_E_BCERT_HWIDINFO_IS_MISSING", + "The PC certificate is correct but is not ready to use because has no HWID information", + ), + 0x8004C830: ( + "DRM_E_BCERT_INVALID_EXTDATA_SIGNED_LENGTH", + "Length of signed portion of extended data info is invalid", + ), + 0x8004C831: ("DRM_E_BCERT_INVALID_EXTDATA_RECORD_TYPE", "Extended data record type is invalid"), + 0x8004C832: ( + "DRM_E_BCERT_EXTDATAFLAG_CERT_TYPE_MISMATCH", + "Certificate of this type cannot have extended data flag set", + ), + 0x8004C833: ("DRM_E_BCERT_METERING_ID_NOT_SPECIFIED", "An metering ID was not provided to the builder"), + 0x8004C834: ("DRM_E_BCERT_METERING_URL_NOT_SPECIFIED", "A metering URL was not provided to the builder"), + 0x8004C835: ("DRM_E_BCERT_METERING_URL_TOO_LONG", "The metering URL contains too many ASCII characters"), + 0x8004C836: ("DRM_E_BCERT_VERIFICATION_ERRORS", "Verification errors are found while parsing cert chain"), + 0x8004C837: ("DRM_E_BCERT_REQUIRED_KEYUSAGE_MISSING", "Required key usage is missing"), + 0x8004C838: ( + "DRM_E_BCERT_NO_PUBKEY_WITH_REQUESTED_KEYUSAGE", + "The certificate does not contain a public key with the requested key usage", + ), + 0x8004C839: ("DRM_E_BCERT_MANUFACTURER_STRING_TOO_LONG", "The manufacturer string is too long"), + 0x8004C83A: ("DRM_E_BCERT_TOO_MANY_PUBLIC_KEYS", "There are too many public keys in the certificate"), + 0x8004C83B: ("DRM_E_BCERT_OBJECTHEADER_LEN_TOO_SMALL", "Object length in object header is too small"), + 0x8004C83C: ( + "DRM_E_BCERT_INVALID_WARNING_DAYS", + "An invalid server certificate expiration warning days. Warning days must be greater than zero.", + ), + 0x8004C900: ("DRM_E_XMLSIG_ECDSA_VERIFY_FAILURE", "Error in ECDSA signature verification."), + 0x8004C901: ("DRM_E_XMLSIG_SHA_VERIFY_FAILURE", "Error in SHA verification."), + 0x8004C902: ("DRM_E_XMLSIG_FORMAT", "The format of XML signature or encryption segment is incorrect."), + 0x8004C903: ("DRM_E_XMLSIG_PUBLIC_KEY_ID", "Invalud pre-shared public key ID."), + 0x8004C904: ("DRM_E_XMLSIG_INVALID_KEY_FORMAT", "Invalid type of public/private key format."), + 0x8004C905: ("DRM_E_XMLSIG_SHA_HASH_SIZE", "Size of hash is unexpected."), + 0x8004C906: ("DRM_E_XMLSIG_ECDSA_SIGNATURE_SIZE", "Size of ECDSA signature is unexpected."), + 0x8004CA00: ("DRM_E_UTF_UNEXPECTED_END", "Unexpected end of data in the middle of multibyte character."), + 0x8004CA01: ("DRM_E_UTF_INVALID_CODE", "UTF character maps into a code with invalid value."), + 0x8004CB00: ("DRM_E_SOAPXML_INVALID_STATUS_CODE", "Status code contained in the server error response is invalid."), + 0x8004CB01: ("DRM_E_SOAPXML_XML_FORMAT", "Cannot parse out expected XML node."), + 0x8004CB02: ("DRM_E_SOAPXML_WRONG_MESSAGE_TYPE", "The message type associated with the soap message is wrong."), + 0x8004CB03: ("DRM_E_SOAPXML_SIGNATURE_MISSING", "The message did not have a signature and needed one"), + 0x8004CB04: ( + "DRM_E_SOAPXML_PROTOCOL_NOT_SUPPORTED", + "The requested protocol is not supported by the DRM SOAP parser.", + ), + 0x8004CB05: ("DRM_E_SOAPXML_DATA_NOT_FOUND", "The requested data is not found in the response."), + 0x8004CC00: ( + "DRM_E_CRYPTO_PUBLIC_KEY_NOT_MATCH", + "The public key associated with an encrypted domain private from the server does not match any public key on the device.", + ), + 0x8004CC01: ( + "DRM_E_UNABLE_TO_RESOLVE_LOCATION_TREE", + "Unable to derive the key. Maybe due to blackout or no rights to the service, etc.", + ), + 0x8004CD00: ("DRM_E_SECURE_TRACE_BAD_GLOBAL_DATA_POINTER", "The secure trace global data pointer is NULL"), + 0x8004CD01: ("DRM_E_SECURE_TRACE_INVALID_GLOBAL_DATA", "The secure trace global data structure is invalid"), + 0x8004CD02: ("DRM_E_SECURE_TRACE_FORMATTING_ERROR", "An error occured in formatting the trace message"), + 0x8004CD03: ("DRM_E_SECURE_TRACE_BAD_SCHEME_DATA_POINTER", "A secure trace scheme data pointer is NULL"), + 0x8004CD04: ( + "DRM_E_SECURE_TRACE_BAD_PER_THREAD_AES_DATA_POINTER", + "The secure trace per thread AES data pointer is NULL", + ), + 0x8004CD05: ( + "DRM_E_SECURE_TRACE_BAD_PER_THREAD_AES_BUFFER_POINTER", + "A secure trace per thread AES buffer pointer is NULL", + ), + 0x8004CD06: ("DRM_E_SECURE_TRACE_AES_INSUFFICIENT_BUFFER", "There is no space left in the secure trace AES buffer"), + 0x8004CD07: ("DRM_E_SECURE_TRACE_VERSION_MISMATCH", "All drm dlls do not agree on the same secure trace version"), + 0x8004CD08: ("DRM_E_SECURE_TRACE_UNEXPECTED_ERROR", "An expected error was encountered in secure tracing system"), + 0x8004CE00: ("DRM_E_ND_MUST_REVALIDATE", "The client must be revalidated before executing the intended operation."), + 0x8004CE01: ("DRM_E_ND_INVALID_MESSAGE", "A received message is garbled."), + 0x8004CE02: ("DRM_E_ND_INVALID_MESSAGE_TYPE", "A received message contains an invalid message type."), + 0x8004CE03: ("DRM_E_ND_INVALID_MESSAGE_VERSION", "A received message contains an invalid message version."), + 0x8004CE04: ("DRM_E_ND_INVALID_SESSION", "The requested session is invalid."), + 0x8004CE05: ( + "DRM_E_ND_MEDIA_SESSION_LIMIT_REACHED", + "A new session cannot be opened because the maximum number of sessions has already been opened.", + ), + 0x8004CE06: ( + "DRM_E_ND_UNABLE_TO_VERIFY_PROXIMITY", + "The proximity detection procedure could not confirm that the receiver is near the transmitter in the network.", + ), + 0x8004CE07: ( + "DRM_E_ND_INVALID_PROXIMITY_RESPONSE", + "The response to the proximity detection challenge is invalid.", + ), + 0x8004CE08: ( + "DRM_E_ND_DEVICE_LIMIT_REACHED", + "The maximum number of devices in use has been reached. Unable to open additional devices.", + ), + 0x8004CE09: ("DRM_E_ND_BAD_REQUEST", "The message format is invalid."), + 0x8004CE0A: ("DRM_E_ND_FAILED_SEEK", "It is not possible to seek to the specified mark-in point."), + 0x8004CE0B: ( + "DRM_E_ND_INVALID_CONTEXT", + "Manager context or at least one of it's children is missing (or corrupt).", + ), + 0x8004CF00: ("DRM_E_ASF_BAD_ASF_HEADER", "The ASF file has a bad ASF header."), + 0x8004CF01: ("DRM_E_ASF_BAD_PACKET_HEADER", "The ASF file has a bad packet header."), + 0x8004CF02: ("DRM_E_ASF_BAD_PAYLOAD_HEADER", "The ASF file has a bad payload header."), + 0x8004CF03: ("DRM_E_ASF_BAD_DATA_HEADER", "The ASF file has a bad data header."), + 0x8004CF04: ( + "DRM_E_ASF_INVALID_OPERATION", + "The intended operation is invalid given the current processing state of the ASF file.", + ), + 0x8004CF05: ( + "DRM_E_ASF_AES_PAYLOAD_FOUND", + "ND payload extension system found; the file may be encrypted with AES already.", + ), + 0x8004CF06: ( + "DRM_E_ASF_EXTENDED_STREAM_PROPERTIES_OBJ_NOT_FOUND", + "Extended stream properties object is not found; the file may be in non-supported outdated format.", + ), + 0x8004CF20: ("DRM_E_ASF_INVALID_DATA", "The packet is overstuffed with data."), + 0x8004CF21: ( + "DRM_E_ASF_TOO_MANY_PAYLOADS", + "The number of payloads in the packet is greater than the maximum allowed.", + ), + 0x8004CF22: ("DRM_E_ASF_BANDWIDTH_OVERRUN", "An object is overflowing the leaky bucket."), + 0x8004CF23: ( + "DRM_E_ASF_INVALID_STREAM_NUMBER", + "The stream number is invalid; it is either zero, greater than the maximum value allowed, or has no associated data.", + ), + 0x8004CF24: ( + "DRM_E_ASF_LATE_SAMPLE", + "A sample was encountered with a presentation time outside of the mux's send window.", + ), + 0x8004CF25: ("DRM_E_ASF_NOT_ACCEPTING", "The sample does not fit in the remaining payload space."), + 0x8004CF26: ("DRM_E_ASF_UNEXPECTED", "An unexpected error occurred."), + 0x8004D000: ("DRM_E_NONCE_STORE_TOKEN_NOT_FOUND", "The matching nonce store token is not found."), + 0x8004D001: ("DRM_E_NONCE_STORE_OPEN_STORE", "Fail to open nonce store."), + 0x8004D002: ("DRM_E_NONCE_STORE_CLOSE_STORE", "Fail to close nonce store."), + 0x8004D003: ("DRM_E_NONCE_STORE_ADD_LICENSE", "There is already a license associated with the nonce store token."), + 0x8004D100: ("DRM_E_LICGEN_POLICY_NOT_SUPPORTED", "The license generation policy combination is not supported."), + 0x8004D200: ("DRM_E_POLICYSTATE_NOT_FOUND", "The policy state is not found in the secure store."), + 0x8004D201: ( + "DRM_E_POLICYSTATE_CORRUPTED", + "The policy state is not stored as a valid internal format in the secure store.", + ), + 0x8004D300: ("DRM_E_MOVE_DENIED", "The requested move operation was denied by the service."), + 0x8004D301: ("DRM_E_INVALID_MOVE_RESPONSE", "The move response was incorrectly formed."), + 0x8004D302: ("DRM_E_MOVE_NONCE_MISMATCH", "The nonce in the repsonse did not match the expected value."), + 0x8004D303: ("DRM_E_MOVE_TXID_MISMATCH", "The transaction id in the repsonse did not match the expected value."), + 0x8004D304: ("DRM_E_MOVE_STORE_OPEN_STORE", "Failed to open the move store."), + 0x8004D305: ("DRM_E_MOVE_STORE_CLOSE_STORE", "Failed to close the move store."), + 0x8004D306: ("DRM_E_MOVE_STORE_ADD_DATA", "Failed to add data into the move store."), + 0x8004D307: ("DRM_E_MOVE_STORE_GET_DATA", "Failed to retrieve data from the move store."), + 0x8004D308: ("DRM_E_MOVE_FORMAT_INVALID", "The format of a move page or index is invalid."), + 0x8004D309: ("DRM_E_MOVE_SIGNATURE_INVALID", "The signature of a move index is invalid."), + 0x8004D30A: ("DRM_E_COPY_DENIED", "The requested copy operation was denied by the service."), + 0x8004D400: ("DRM_E_XB_OBJECT_NOTFOUND", "The extensible binary object was not found."), + 0x8004D401: ("DRM_E_XB_INVALID_OBJECT", "The extensible binary object format was invalid."), + 0x8004D402: ( + "DRM_E_XB_OBJECT_ALREADY_EXISTS", + "A single instance extensible binary object was encountered more than once.", + ), + 0x8004D403: ( + "DRM_E_XB_REQUIRED_OBJECT_MISSING", + "A required extensible binary object was not found during building.", + ), + 0x8004D404: ( + "DRM_E_XB_UNKNOWN_ELEMENT_TYPE", + "An extensible binary object description contained an element of an unknown type.", + ), + 0x8004D500: ("DRM_E_KEYFILE_INVALID_PLATFORM", "The keyfile does not support the current platform."), + 0x8004D501: ("DRM_E_KEYFILE_TOO_LARGE", "The keyfile is larger than the maximum supported size."), + 0x8004D502: ("DRM_E_KEYFILE_PRIVATE_KEY_NOT_FOUND", "The private key requested was not found in the keyfile."), + 0x8004D503: ( + "DRM_E_KEYFILE_CERTIFICATE_CHAIN_NOT_FOUND", + "The certificate chain requested was not found in the keyfile.", + ), + 0x8004D504: ("DRM_E_KEYFILE_KEY_NOT_FOUND", "The AES Key ID was not found in the keyfile."), + 0x8004D505: ("DRM_E_KEYFILE_UNKNOWN_DECRYPTION_METHOD", "Unknown keyfile decryption method."), + 0x8004D506: ("DRM_E_KEYFILE_INVALID_SIGNATURE", "The keyfile signature was not valid."), + 0x8004D507: ( + "DRM_E_KEYFILE_INTERNAL_DECRYPTION_BUFFER_TOO_SMALL", + "The internal decryption buffer is too small to hold the encrypted key from the keyfile.", + ), + 0x8004D508: ("DRM_E_KEYFILE_PLATFORMID_MISMATCH", "Platform ID in the certificate does not match expected value."), + 0x8004D509: ( + "DRM_E_KEYFILE_CERTIFICATE_ISSUER_KEY_MISMATCH", + "Issuer key of the device certificate does not match public key of the model certificate.", + ), + 0x8004D50A: ( + "DRM_E_KEYFILE_ROBUSTNESSVERSION_MISMATCH", + "Robustness version in the certificate does not match expected value.", + ), + 0x8004D50B: ( + "DRM_E_KEYFILE_FILE_NOT_CLOSED", + "The KeyFile Close function was not called before trying to unintialize the KeyFile context.", + ), + 0x8004D50C: ("DRM_E_KEYFILE_NOT_INITED", "The KeyFile Context was not initialized before trying to use it."), + 0x8004D50D: ("DRM_E_KEYFILE_FORMAT_INVALID", "The format of the KeyFile was invalid."), + 0x8004D50E: ( + "DRM_E_KEYFILE_UPDATE_NOT_ALLOWED", + "The keyfile of the device is read only, and updates are not permitted.", + ), + 0x8004DFFC: ("DRM_E_OEM_CONSTRAINT_1_FAIL", "Failed while OEM CONSTRAINT-1 check"), + 0x8004DFFD: ("DRM_E_OEM_CONSTRAINT_2_FAIL", "Failed while OEM CONSTRAINT-2 check"), + 0x8004DFFE: ("DRM_E_OEM_CONSTRAINT_3_FAIL", "Failed while OEM CONSTRAINT-3 check"), + 0x8004DFFF: ("DRM_E_HDCP_NON_SECURE", "Attempt to play back through insecure HDMI output path"), + 0x80070002: ("DRM_E_WIN32_FILE_NOT_FOUND", "The system cannot find the file specified."), + 0x80070012: ("DRM_E_WIN32_NO_MORE_FILES", "There are no more files."), + 0x80070057: ("DRM_E_INVALIDARG", "The parameter is incorrect."), + 0x8007007A: ("DRM_E_BUFFERTOOSMALL", "The data area passed to a function is too small."), + 0x80070103: ("DRM_E_NOMORE", "No more data is available."), + 0x80070216: ("DRM_E_ARITHMETIC_OVERFLOW", "Arithmetic result exceeded maximum value."), + 0x80070490: ("DRM_E_NOT_FOUND", "Element not found."), + 0x80070667: ("DRM_E_INVALID_COMMAND_LINE", "Invalid command line argument."), + 0xC00D2712: ("DRM_E_FAILED_TO_STORE_LICENSE", "License storage is not working."), + 0xC00D272F: ("DRM_E_PARAMETERS_MISMATCHED", "A problem has occurred in the Digital Rights Management component."), + 0xC00D275F: ("DRM_E_NOT_ALL_STORED", "Some of the licenses could not be stored."), +} + + +def describe(code: int) -> str | None: + """Human string for a PlayReady/DRM HRESULT, or None if unknown. + + Accepts signed or unsigned 32-bit ints (license servers often return the + signed form, e.g. -2147172251 == 0x8004C065). + """ + if code is None: + return None + key = code & 0xFFFFFFFF + entry = ERRORS.get(key) + if entry is None: + return None + name, text = entry + return f"{name} (0x{key:08X}){f': {text}' if text else ''}" + + +if __name__ == "__main__": + # ponytail: one check, signed and unsigned forms resolve to the same entry + assert describe(0x8004C065) == describe(-2147172251) + assert "DEVCERT_REVOKED" in describe(-2147172251) + assert describe(-1021) is None # non-DRM_E service code + print("ok")