mirror of
https://github.com/unshackle-dl/unshackle.git
synced 2026-11-14 13:05:09 +00:00
imSp4rky
51750a03b0
Maps DRM_E_/DRM_S_ result codes to symbol + description so services can turn raw license HRESULTs (e.g. 0x8004C065) into readable errors.
866 lines
54 KiB
Python
866 lines
54 KiB
Python
# 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")
|