diff --git a/libwvdrmengine/Android.bp b/libwvdrmengine/Android.bp index 6c7ab650..07207d5a 100644 --- a/libwvdrmengine/Android.bp +++ b/libwvdrmengine/Android.bp @@ -89,31 +89,6 @@ common_widevine_service { }, } -cc_defaults { - name: "common_widevine_service-multilib-defaults@1.3", - owner: "widevine", - proprietary: true, - relative_install_path: "hw", - include_dirs: [ - "vendor/widevine/libwvdrmengine/include_hidl", - "vendor/widevine/libwvdrmengine/mediadrm/include_hidl", - "vendor/widevine/libwvdrmengine/oemcrypto/include", - ], - header_libs: ["libstagefright_foundation_headers"], - - shared_libs: [ - "android.hardware.drm@1.0", - "android.hardware.drm@1.1", - "android.hardware.drm@1.2", - "android.hardware.drm@1.3", - "libbase", - "libbinder", - "libhidlbase", - "liblog", - "libutils", - ], -} - cc_defaults { name: "common_widevine_service-multilib-defaults-aidl", owner: "widevine", @@ -136,118 +111,6 @@ cc_defaults { ], } -cc_defaults { - name: "common_widevine_service-multilib-defaults", - defaults: [ - "common_widevine_service-multilib-defaults@1.3", - ], - - shared_libs: [ - "android.hardware.drm@1.4", - "libwvhidl", - ], -} - -// ---------------------------------------------------------------------------- -// Builds android.hardware.drm@1.2-service.widevine -// -cc_binary { - name: "android.hardware.drm@1.2-service.widevine", - defaults: [ - "common_widevine_service-multilib-first", - "common_widevine_service-multilib-defaults", - ], - - srcs: ["src_hidl/service.cpp"], - init_rc: ["src_hidl/android.hardware.drm@1.2-service.widevine.rc"], - vintf_fragments: ["manifest_android.hardware.drm@1.2-service.widevine.xml"], - -} - -// ---------------------------------------------------------------------------- -// Builds android.hardware.drm@1.2-service-lazy.widevine -// -cc_binary { - name: "android.hardware.drm@1.2-service-lazy.widevine", - defaults: [ - "common_widevine_service-multilib-first", - "common_widevine_service-multilib-defaults", - ], - - srcs: ["src_hidl/serviceLazy.cpp"], - overrides: ["android.hardware.drm@1.2-service.widevine"], - init_rc: ["src_hidl/android.hardware.drm@1.2-service-lazy.widevine.rc"], - vintf_fragments: ["manifest_android.hardware.drm@1.2-service.widevine.xml"], - -} - -// ---------------------------------------------------------------------------- -// Builds android.hardware.drm@1.3-service.widevine -// -cc_binary { - name: "android.hardware.drm@1.3-service.widevine", - defaults: [ - "common_widevine_service-multilib-first", - "common_widevine_service-multilib-defaults@1.3", - ], - - srcs: ["src_hidl/service@1.3.cpp"], - shared_libs: ["libwvhidl@1.3"], - init_rc: ["src_hidl/android.hardware.drm@1.3-service.widevine.rc"], - vintf_fragments: ["manifest_android.hardware.drm@1.3-service.widevine.xml"], - -} - -// ---------------------------------------------------------------------------- -// Builds android.hardware.drm@1.3-service-lazy.widevine -// -cc_binary { - name: "android.hardware.drm@1.3-service-lazy.widevine", - defaults: [ - "common_widevine_service-multilib-first", - "common_widevine_service-multilib-defaults", - ], - - srcs: ["src_hidl/serviceLazy.cpp"], - overrides: ["android.hardware.drm@1.3-service.widevine"], - init_rc: ["src_hidl/android.hardware.drm@1.3-service-lazy.widevine.rc"], - vintf_fragments: ["manifest_android.hardware.drm@1.4-service.widevine.xml"], - -} - -// ---------------------------------------------------------------------------- -// Builds android.hardware.drm@1.4-service.widevine -// -cc_binary { - name: "android.hardware.drm@1.4-service.widevine", - defaults: [ - "common_widevine_service-multilib-first", - "common_widevine_service-multilib-defaults", - ], - - srcs: ["src_hidl/service.cpp"], - init_rc: ["src_hidl/android.hardware.drm@1.4-service.widevine.rc"], - vintf_fragments: ["manifest_android.hardware.drm@1.4-service.widevine.xml"], - -} - -// ---------------------------------------------------------------------------- -// Builds android.hardware.drm@1.4-service-lazy.widevine -// -cc_binary { - name: "android.hardware.drm@1.4-service-lazy.widevine", - defaults: [ - "common_widevine_service-multilib-first", - "common_widevine_service-multilib-defaults", - ], - - srcs: ["src_hidl/serviceLazy.cpp"], - overrides: ["android.hardware.drm@1.4-service.widevine"], - init_rc: ["src_hidl/android.hardware.drm@1.4-service-lazy.widevine.rc"], - vintf_fragments: ["manifest_android.hardware.drm@1.4-service.widevine.xml"], - -} - // ---------------------------------------------------------------------------- // Builds android.hardware.drm-service.widevine // @@ -293,64 +156,30 @@ cc_binary { } // ---------------------------------------------------------------------------- -// Builds libcdm_utils.a and libcdm_utils_hidl.a +// Builds libcdm_utils.a // - -cdm_util_src_files = [ - "cdm/core/src/properties.cpp", - "cdm/src/properties_android.cpp", - "cdm/src/timer.cpp", - "cdm/util/src/cdm_random.cpp", - "cdm/util/src/clock.cpp", - "cdm/util/src/error_string_util.cpp", - "cdm/util/src/file_store.cpp", - "cdm/util/src/file_utils.cpp", - "cdm/util/src/log.cpp", - "cdm/util/src/platform.cpp", - "cdm/util/src/rw_lock.cpp", - "cdm/util/src/string_conversions.cpp", - "cdm/util/src/string_format.cpp", -] - -cc_library_static { - - name: "libcdm_utils_hidl", - - proprietary: true, - - include_dirs: [ - "vendor/widevine/libwvdrmengine/cdm/core/include", - "vendor/widevine/libwvdrmengine/cdm/include", - "vendor/widevine/libwvdrmengine/cdm/util/include", - "vendor/widevine/libwvdrmengine/oemcrypto/include", - ], - - header_libs: [ - "libbase_headers", - "libutils_headers", - ], - - shared_libs: [ - "libbinder_ndk", - "libcrypto", - "libhidlbase", - "liblog", - ], - - cflags: [ - "-DIS_HIDL", - ], - - srcs: cdm_util_src_files, - -} - cc_library_static { name: "libcdm_utils", proprietary: true, + srcs: [ + "cdm/core/src/properties.cpp", + "cdm/src/properties_android.cpp", + "cdm/src/timer.cpp", + "cdm/util/src/cdm_random.cpp", + "cdm/util/src/clock.cpp", + "cdm/util/src/error_string_util.cpp", + "cdm/util/src/file_store.cpp", + "cdm/util/src/file_utils.cpp", + "cdm/util/src/log.cpp", + "cdm/util/src/platform.cpp", + "cdm/util/src/rw_lock.cpp", + "cdm/util/src/string_conversions.cpp", + "cdm/util/src/string_format.cpp", + ], + include_dirs: [ "vendor/widevine/libwvdrmengine/cdm/core/include", "vendor/widevine/libwvdrmengine/cdm/include", @@ -366,117 +195,8 @@ cc_library_static { shared_libs: [ "libbinder_ndk", "libcrypto", - "libhidlbase", "liblog", ], - - srcs: cdm_util_src_files, -} - -// ---------------------------------------------------------------------------- -// Builds libwvhidl.so -// -cc_library_shared { - name: "libwvhidl", - - srcs: [ - "src/WVCDMSingleton.cpp", - "src/WVUUID.cpp", - "src_hidl/wv_metrics.cpp", - "src_hidl/WVCreatePluginFactories.cpp", - "src_hidl/WVCryptoFactory.cpp", - "src_hidl/WVDrmFactory.cpp", - ], - - include_dirs: [ - "frameworks/av/include", - "frameworks/native/include", - "vendor/widevine/libwvdrmengine/cdm/core/include", - "vendor/widevine/libwvdrmengine/cdm/metrics/include", - "vendor/widevine/libwvdrmengine/cdm/util/include", - "vendor/widevine/libwvdrmengine/cdm/include", - "vendor/widevine/libwvdrmengine/include", - "vendor/widevine/libwvdrmengine/include_hidl", - "vendor/widevine/libwvdrmengine/mediacrypto/include_hidl", - "vendor/widevine/libwvdrmengine/mediadrm/include_hidl", - "vendor/widevine/libwvdrmengine/oemcrypto/include", - ], - - static_libs: [ - "libcdm", - "libcdm_protos", - "libcdm_utils_hidl", - "libjsmn", - "libwvdrmcryptoplugin_hidl", - "libwvdrmdrmplugin_hidl", - "libwvlevel3", - "libwv_odk", - ], - - shared_libs: [ - "android.hardware.drm@1.0", - "android.hardware.drm@1.1", - "android.hardware.drm@1.2", - "android.hardware.drm@1.3", - "android.hardware.drm@1.4", - "android.hidl.memory@1.0", - "libbase", - "libcrypto", - "libcutils", - "libdl", - "libhidlbase", - "libhidlmemory", - "liblog", - "libprotobuf-cpp-lite", - "libutils", - ], - - header_libs: ["libstagefright_foundation_headers"], - - owner: "widevine", - - proprietary: true, - -} - -cc_prebuilt_library_shared { - name: "libwvhidl@1.3", - target: { - android_arm: { - srcs: ["prebuilts_hidl/arm/libwvhidl@1.3.so"], - }, - android_arm64: { - srcs: ["prebuilts_hidl/arm64/libwvhidl@1.3.so"], - }, - android_x86: { - srcs: ["prebuilts_hidl/x86/libwvhidl@1.3.so"], - }, - android_x86_64: { - srcs: ["prebuilts_hidl/x86_64/libwvhidl@1.3.so"], - }, - }, - - shared_libs: [ - "android.hardware.drm@1.0", - "android.hardware.drm@1.1", - "android.hardware.drm@1.2", - "android.hardware.drm@1.3", - "android.hidl.memory@1.0", - "libbase", - "libcrypto", - "libcutils", - "libdl", - "libhidlbase", - "libhidlmemory", - "liblog", - "libprotobuf-cpp-lite", - "libutils", - ], - - owner: "widevine", - - proprietary: true, - } // ---------------------------------------------------------------------------- diff --git a/libwvdrmengine/build_all_unit_tests.sh b/libwvdrmengine/build_all_unit_tests.sh index 42636f0f..c95b0b4f 100755 --- a/libwvdrmengine/build_all_unit_tests.sh +++ b/libwvdrmengine/build_all_unit_tests.sh @@ -9,12 +9,9 @@ fi # Read arguments in case the user wants to do a multicore build or # copy files to a specific android device by providing a serial number. -# The default build target is for AIDL service, use "-t hidl" to -# build for HIDL service. -WV_UNITTESTS_BUILD_TARGET="" NUM_CORES=1 SERIAL_NUM="" -while getopts "j:s:t:" opt; do +while getopts "j:s:" opt; do case $opt in j) NUM_CORES=$OPTARG @@ -22,9 +19,6 @@ while getopts "j:s:t:" opt; do s) SERIAL_NUM="-s $OPTARG" ;; - t) - WV_UNITTESTS_BUILD_TARGET="WV_UNITTESTS_BUILD_TARGET=$OPTARG" - ;; esac done @@ -81,7 +75,7 @@ WV_UNITTESTS="base64_test \ cd $ANDROID_BUILD_TOP pwd -m -j $NUM_CORES $WV_UNITTESTS $WV_UNITTESTS_BUILD_TARGET +m -j $NUM_CORES $WV_UNITTESTS # Detect the device and check if Verity is going to stop the script from working diff --git a/libwvdrmengine/cdm/core/include/wv_cdm_constants.h b/libwvdrmengine/cdm/core/include/wv_cdm_constants.h index 4aaaaff6..d67313c2 100644 --- a/libwvdrmengine/cdm/core/include/wv_cdm_constants.h +++ b/libwvdrmengine/cdm/core/include/wv_cdm_constants.h @@ -61,11 +61,8 @@ constexpr char ATSC_APP_PACKAGE_NAME[] = "org.atsc"; // Define query keys, values here. // To expose these query items to Android update: // android/mediadrm/src/WVDrmPlugin.cpp -// android/mediadrm/src_hidl/WVDrmPlugin.cpp // Update test QueryStatus and QueryStatusL3 test for all possible outputs: // android/cdm/test/request_license_test.cpp -// Update HIDL debug output: -// android/src_hidl/WVDrmFactory.cpp static const std::string QUERY_KEY_LICENSE_TYPE = "LicenseType"; // "Streaming", "Offline" static const std::string QUERY_KEY_PLAY_ALLOWED = diff --git a/libwvdrmengine/cdm/core/include/wv_cdm_types.h b/libwvdrmengine/cdm/core/include/wv_cdm_types.h index 18d6cf57..14cd4cda 100644 --- a/libwvdrmengine/cdm/core/include/wv_cdm_types.h +++ b/libwvdrmengine/cdm/core/include/wv_cdm_types.h @@ -445,7 +445,6 @@ enum CdmResponseType : int32_t { // Don't forget to add new values to // * core/test/test_printers.cpp. // * android/include/mapErrors-inl.h - // * android/include_hidl/HidlMapErrors-inl.h }; enum CdmKeyStatus : int32_t { diff --git a/libwvdrmengine/cdm/test/coverage-test.mk b/libwvdrmengine/cdm/test/coverage-test.mk index 571c657a..c8e89a16 100644 --- a/libwvdrmengine/cdm/test/coverage-test.mk +++ b/libwvdrmengine/cdm/test/coverage-test.mk @@ -3,15 +3,6 @@ # include $(CLEAR_VARS) -WV_UNITTESTS_BUILD_TARGET?= -ifeq ($(WV_UNITTESTS_BUILD_TARGET), hidl) -HIDL_EXTENSION := _hidl -LIB_BINDER := libhidlbase -else -HIDL_EXTENSION := -LIB_BINDER := libbinder_ndk -endif - LOCAL_LICENSE_CONDITIONS := by_exception_only LOCAL_LICENSE_KINDS := legacy_by_exception_only LOCAL_MODULE := cdm_coverage_test @@ -69,7 +60,7 @@ LOCAL_C_INCLUDES += external/protobuf/src LOCAL_STATIC_LIBRARIES := \ libcdm \ libcdm_protos \ - libcdm_utils$(HIDL_EXTENSION) \ + libcdm_utils \ libjsmn \ libgmock \ libgtest \ @@ -81,7 +72,7 @@ LOCAL_SHARED_LIBRARIES := \ libbase \ libcrypto \ libdl \ - $(LIB_BINDER) \ + libbinder_ndk \ liblog \ libmedia_omx \ libprotobuf-cpp-lite \ diff --git a/libwvdrmengine/cdm/test/integration-test.mk b/libwvdrmengine/cdm/test/integration-test.mk index cd9eb659..f8907a06 100644 --- a/libwvdrmengine/cdm/test/integration-test.mk +++ b/libwvdrmengine/cdm/test/integration-test.mk @@ -6,15 +6,6 @@ $(call assert-not-null,test_name) include $(CLEAR_VARS) -WV_UNITTESTS_BUILD_TARGET?= -ifeq ($(WV_UNITTESTS_BUILD_TARGET), hidl) -HIDL_EXTENSION := _hidl -LIB_BINDER := libhidlbase -else -HIDL_EXTENSION := -LIB_BINDER := libbinder_ndk -endif - LOCAL_MODULE := $(test_name) LOCAL_LICENSE_KINDS := legacy_by_exception_only LOCAL_LICENSE_CONDITIONS := by_exception_only @@ -59,7 +50,7 @@ LOCAL_C_INCLUDES += external/protobuf/src LOCAL_STATIC_LIBRARIES := \ libcdm \ libcdm_protos \ - libcdm_utils$(HIDL_EXTENSION) \ + libcdm_utils \ libjsmn \ libgmock \ libgtest \ @@ -71,7 +62,7 @@ LOCAL_SHARED_LIBRARIES := \ libbase \ libcrypto \ libdl \ - $(LIB_BINDER) \ + libbinder_ndk \ liblog \ libmedia_omx \ libprotobuf-cpp-lite \ diff --git a/libwvdrmengine/cdm/test/unit-test.mk b/libwvdrmengine/cdm/test/unit-test.mk index 084f79df..e3d14a5d 100644 --- a/libwvdrmengine/cdm/test/unit-test.mk +++ b/libwvdrmengine/cdm/test/unit-test.mk @@ -6,15 +6,6 @@ $(call assert-not-null,test_name) include $(CLEAR_VARS) -WV_UNITTESTS_BUILD_TARGET?= -ifeq ($(WV_UNITTESTS_BUILD_TARGET), hidl) -HIDL_EXTENSION := _hidl -LIB_BINDER := libhidlbase -else -HIDL_EXTENSION := -LIB_BINDER := libbinder_ndk -endif - LOCAL_MODULE := $(test_name) LOCAL_LICENSE_KINDS := legacy_by_exception_only LOCAL_LICENSE_CONDITIONS := by_exception_only @@ -52,7 +43,7 @@ LOCAL_C_INCLUDES += external/protobuf/src LOCAL_STATIC_LIBRARIES := \ libcdm \ libcdm_protos \ - libcdm_utils$(HIDL_EXTENSION) \ + libcdm_utils \ libjsmn \ libgmock \ libgtest \ @@ -63,8 +54,7 @@ LOCAL_SHARED_LIBRARIES := \ libbase \ libcrypto \ libdl \ - libhidlbase \ - $(LIB_BINDER) \ + libbinder_ndk \ liblog \ libmedia_omx \ libprotobuf-cpp-lite \ diff --git a/libwvdrmengine/cdm/util/src/log.cpp b/libwvdrmengine/cdm/util/src/log.cpp index c8598bf2..4f09b009 100644 --- a/libwvdrmengine/cdm/util/src/log.cpp +++ b/libwvdrmengine/cdm/util/src/log.cpp @@ -23,11 +23,7 @@ #include "log.h" -#ifdef IS_HIDL -# include -#else // AIDL is the default -# include -#endif +#include #include #include #include @@ -80,12 +76,7 @@ void ClearLoggingUid() { uint32_t GetLoggingUid() { return tl_logging_uid_; } uint32_t GetIpcCallingUid() { -#ifdef IS_HIDL - const auto self = android::hardware::IPCThreadState::selfOrNull(); - return self ? self->getCallingUid() : UNKNOWN_UID; -#else // AIDL is the default return AIBinder_getCallingUid(); -#endif } void InitLogging() {} diff --git a/libwvdrmengine/include_hidl/HidlMapErrors-inl.h b/libwvdrmengine/include_hidl/HidlMapErrors-inl.h deleted file mode 100644 index a6d351d8..00000000 --- a/libwvdrmengine/include_hidl/HidlMapErrors-inl.h +++ /dev/null @@ -1,753 +0,0 @@ -// -// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary -// source code may only be used and distributed under the Widevine License -// Agreement. -// - -#ifndef WV_MAP_ERRORS_H_ -#define WV_MAP_ERRORS_H_ - -#include "media/stagefright/MediaErrors.h" -#include "utils/Errors.h" -#include "wv_cdm_types.h" -#include "HidlTypes.h" -#include "WVErrors.h" - -namespace wvdrm { - -static Status mapCdmResponseType_1_0(wvcdm::CdmResponseType res) { - switch (res) { - case wvcdm::KEY_ADDED: - case wvcdm::KEY_MESSAGE: - case wvcdm::KEY_CANCELED: - // KEY_ADDED, KEY_MESSAGE, and KEY_CANCELLED are all alternative - // success messages for certain CDM methods instead of NO_ERROR. - case wvcdm::NO_ERROR: - return Status::OK; - - case wvcdm::DECRYPT_NOT_READY: - case wvcdm::KEY_NOT_FOUND_IN_SESSION: - case wvcdm::NEED_KEY: - case wvcdm::NO_MATCHING_ENTITLEMENT_KEY: - // TODO(http://b/119690361): there are several NO_CONTENT_* errors. - // that should probably all turn into NO_LICENSE. Here, and below, and - // everywhere. - case wvcdm::NO_CONTENT_KEY_3: - return Status::ERROR_DRM_NO_LICENSE; - - case wvcdm::NEED_PROVISIONING: - return Status::ERROR_DRM_NOT_PROVISIONED; - - case wvcdm::DEVICE_REVOKED: - return Status::ERROR_DRM_DEVICE_REVOKED; - - case wvcdm::INSUFFICIENT_CRYPTO_RESOURCES: - return Status::ERROR_DRM_RESOURCE_BUSY; - - case wvcdm::RELEASE_USAGE_INFO_ERROR: - case wvcdm::RELEASE_USAGE_INFO_FAILED: - case wvcdm::SYSTEM_INVALIDATED_ERROR: - return Status::ERROR_DRM_INVALID_STATE; - - case wvcdm::SESSION_NOT_FOUND_FOR_DECRYPT: - case wvcdm::SESSION_NOT_FOUND_1: - case wvcdm::SESSION_NOT_FOUND_2: - case wvcdm::SESSION_NOT_FOUND_3: - case wvcdm::SESSION_NOT_FOUND_4: - case wvcdm::SESSION_NOT_FOUND_5: - case wvcdm::SESSION_NOT_FOUND_6: - case wvcdm::SESSION_NOT_FOUND_7: - case wvcdm::SESSION_NOT_FOUND_8: - case wvcdm::SESSION_NOT_FOUND_9: - case wvcdm::SESSION_NOT_FOUND_10: - case wvcdm::SESSION_NOT_FOUND_18: - case wvcdm::SESSION_NOT_FOUND_19: - case wvcdm::SESSION_NOT_FOUND_20: - case wvcdm::SESSION_NOT_FOUND_21: - case wvcdm::SESSION_NOT_FOUND_22: - case wvcdm::SESSION_NOT_FOUND_23: - return Status::ERROR_DRM_SESSION_NOT_OPENED; - - case wvcdm::DECRYPT_ERROR: - case wvcdm::SECURE_BUFFER_REQUIRED: - return Status::ERROR_DRM_CANNOT_HANDLE; - - case wvcdm::ANALOG_OUTPUT_ERROR: - case wvcdm::KEY_PROHIBITED_FOR_SECURITY_LEVEL: - case wvcdm::INSUFFICIENT_OUTPUT_PROTECTION: - return Status::ERROR_DRM_INSUFFICIENT_OUTPUT_PROTECTION; - - case wvcdm::KEYSET_ID_NOT_FOUND_4: - return Status::BAD_VALUE; - - // The following cases follow the order in wv_cdm_types.h - // to make it easier to keep track of newly defined errors. - case wvcdm::KEY_ERROR: - case wvcdm::ADD_KEY_ERROR: - case wvcdm::CERT_PROVISIONING_EMPTY_SERVICE_CERTIFICATE: - case wvcdm::CERT_PROVISIONING_GET_KEYBOX_ERROR_1: - case wvcdm::CERT_PROVISIONING_INVALID_CERT_TYPE: - case wvcdm::CERT_PROVISIONING_REQUEST_ERROR_1: - case wvcdm::CERT_PROVISIONING_NONCE_GENERATION_ERROR: - case wvcdm::CERT_PROVISIONING_REQUEST_ERROR_4: - case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_1: - case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_2: - case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_3: - case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_4: - case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_7: - case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_8: - case wvcdm::DEVICE_CERTIFICATE_ERROR_1: - case wvcdm::DEVICE_CERTIFICATE_ERROR_2: - case wvcdm::DEVICE_CERTIFICATE_ERROR_3: - case wvcdm::DEVICE_CERTIFICATE_ERROR_4: - case wvcdm::EMPTY_KEY_DATA_1: - case wvcdm::EMPTY_KEY_DATA_2: - case wvcdm::EMPTY_KEYSET_ID: - case wvcdm::EMPTY_KEYSET_ID_ENG_1: - case wvcdm::EMPTY_KEYSET_ID_ENG_2: - case wvcdm::EMPTY_KEYSET_ID_ENG_3: - case wvcdm::EMPTY_KEYSET_ID_ENG_4: - case wvcdm::EMPTY_LICENSE_RENEWAL: - case wvcdm::EMPTY_LICENSE_RESPONSE_1: - case wvcdm::EMPTY_LICENSE_RESPONSE_2: - case wvcdm::EMPTY_PROVISIONING_CERTIFICATE_1: - case wvcdm::EMPTY_PROVISIONING_RESPONSE: - case wvcdm::EMPTY_SESSION_ID: - case wvcdm::GENERATE_DERIVED_KEYS_ERROR: - case wvcdm::LICENSE_RENEWAL_NONCE_GENERATION_ERROR: - case wvcdm::GENERATE_USAGE_REPORT_ERROR: - case wvcdm::GET_LICENSE_ERROR: - case wvcdm::GET_RELEASED_LICENSE_ERROR: - case wvcdm::GET_USAGE_INFO_ERROR_1: - case wvcdm::GET_USAGE_INFO_ERROR_2: - case wvcdm::GET_USAGE_INFO_ERROR_3: - case wvcdm::GET_USAGE_INFO_ERROR_4: - case wvcdm::INIT_DATA_NOT_FOUND: - case wvcdm::INVALID_DECRYPT_PARAMETERS_ENG_1: - case wvcdm::INVALID_DECRYPT_PARAMETERS_ENG_2: - case wvcdm::INVALID_DECRYPT_PARAMETERS_ENG_3: - case wvcdm::INVALID_DECRYPT_PARAMETERS_ENG_4: - case wvcdm::INVALID_DEVICE_CERTIFICATE_TYPE: - case wvcdm::INVALID_KEY_SYSTEM: - case wvcdm::INVALID_LICENSE_RESPONSE: - case wvcdm::INVALID_LICENSE_TYPE: - case wvcdm::PARAMETER_NULL: - case wvcdm::INVALID_PARAMETERS_LIC_1: - case wvcdm::INVALID_PARAMETERS_LIC_2: - case wvcdm::INVALID_PROVISIONING_PARAMETERS_1: - case wvcdm::INVALID_PROVISIONING_PARAMETERS_2: - case wvcdm::INVALID_PROVISIONING_REQUEST_PARAM_1: - case wvcdm::INVALID_PROVISIONING_REQUEST_PARAM_2: - case wvcdm::INVALID_QUERY_KEY: - case wvcdm::INVALID_SESSION_ID: - case wvcdm::KEY_REQUEST_ERROR_1: - case wvcdm::KEY_SIZE_ERROR_1: - case wvcdm::KEY_SIZE_ERROR_2: - case wvcdm::KEYSET_ID_NOT_FOUND_1: - case wvcdm::KEYSET_ID_NOT_FOUND_2: - case wvcdm::KEYSET_ID_NOT_FOUND_3: - case wvcdm::LICENSE_ID_NOT_FOUND: - case wvcdm::LICENSE_PARSER_INIT_ERROR: - case wvcdm::LICENSE_PARSER_NOT_INITIALIZED_1: - case wvcdm::LICENSE_PARSER_NOT_INITIALIZED_2: - case wvcdm::LICENSE_PARSER_NOT_INITIALIZED_3: - case wvcdm::LICENSE_RESPONSE_NOT_SIGNED: - case wvcdm::LICENSE_RESPONSE_PARSE_ERROR_1: - case wvcdm::LICENSE_RESPONSE_PARSE_ERROR_2: - case wvcdm::LICENSE_RESPONSE_PARSE_ERROR_3: - case wvcdm::LOAD_KEY_ERROR: - case wvcdm::NO_CONTENT_KEY: - case wvcdm::REFRESH_KEYS_ERROR: - case wvcdm::REMOVE_ALL_USAGE_INFO_ERROR_1: - case wvcdm::REMOVE_ALL_USAGE_INFO_ERROR_2: - case wvcdm::RELEASE_KEY_ERROR: - case wvcdm::RELEASE_KEY_REQUEST_ERROR: - case wvcdm::RELEASE_LICENSE_ERROR_1: - case wvcdm::RELEASE_LICENSE_ERROR_2: - case wvcdm::RENEW_KEY_ERROR_1: - case wvcdm::RENEW_KEY_ERROR_2: - case wvcdm::RESTORE_OFFLINE_LICENSE_ERROR_2: - case wvcdm::RESTORE_OFFLINE_LICENSE_ERROR_3: - case wvcdm::NOT_INITIALIZED_ERROR: - case wvcdm::REINIT_ERROR: - case wvcdm::SESSION_KEYS_NOT_FOUND: - case wvcdm::SIGNATURE_NOT_FOUND: - case wvcdm::STORE_LICENSE_ERROR_1: - case wvcdm::STORE_LICENSE_ERROR_2: - case wvcdm::STORE_USAGE_INFO_ERROR: - case wvcdm::UNPROVISION_ERROR_1: - case wvcdm::UNPROVISION_ERROR_2: - case wvcdm::UNPROVISION_ERROR_3: - case wvcdm::UNPROVISION_ERROR_4: - case wvcdm::UNSUPPORTED_INIT_DATA: - case wvcdm::USAGE_INFO_NOT_FOUND: - case wvcdm::PARSE_SERVICE_CERTIFICATE_ERROR: - case wvcdm::CLIENT_ID_GENERATE_RANDOM_ERROR: - case wvcdm::CLIENT_ID_AES_INIT_ERROR: - case wvcdm::CLIENT_ID_AES_ENCRYPT_ERROR: - case wvcdm::CLIENT_ID_RSA_INIT_ERROR: - case wvcdm::CLIENT_ID_RSA_ENCRYPT_ERROR: - case wvcdm::LICENSE_PARSER_NOT_INITIALIZED_4: - case wvcdm::INVALID_PARAMETERS_LIC_3: - case wvcdm::INVALID_PARAMETERS_LIC_4: - case wvcdm::INVALID_PARAMETERS_LIC_6: - case wvcdm::INVALID_PARAMETERS_LIC_7: - case wvcdm::CENC_INIT_DATA_UNAVAILABLE: - case wvcdm::PREPARE_CENC_CONTENT_ID_FAILED: - case wvcdm::WEBM_INIT_DATA_UNAVAILABLE: - case wvcdm::PREPARE_WEBM_CONTENT_ID_FAILED: - case wvcdm::UNSUPPORTED_INIT_DATA_FORMAT: - case wvcdm::LICENSE_REQUEST_NONCE_GENERATION_ERROR: - case wvcdm::LICENSE_REQUEST_SERVICE_CERTIFICATE_GENERATION_ERROR: - case wvcdm::EMPTY_LICENSE_REQUEST: - case wvcdm::DUPLICATE_SESSION_ID_SPECIFIED: - case wvcdm::LICENSE_RENEWAL_PROHIBITED: - case wvcdm::EMPTY_PROVISIONING_CERTIFICATE_2: - case wvcdm::OFFLINE_LICENSE_PROHIBITED: - case wvcdm::STORAGE_PROHIBITED: - case wvcdm::EMPTY_KEYSET_ID_ENG_5: - case wvcdm::SESSION_NOT_FOUND_11: - case wvcdm::LOAD_USAGE_INFO_FILE_ERROR: - case wvcdm::LOAD_USAGE_INFO_MISSING: - case wvcdm::SESSION_FILE_HANDLE_INIT_ERROR: - case wvcdm::INCORRECT_CRYPTO_MODE: - case wvcdm::INVALID_PARAMETERS_ENG_5: - case wvcdm::SESSION_NOT_FOUND_12: - case wvcdm::KEY_NOT_FOUND_1: - case wvcdm::KEY_NOT_FOUND_2: - case wvcdm::KEY_CONFLICT_1: - case wvcdm::SESSION_NOT_FOUND_13: - case wvcdm::SESSION_NOT_FOUND_14: - case wvcdm::SESSION_NOT_FOUND_15: - case wvcdm::SESSION_NOT_FOUND_16: - case wvcdm::KEY_NOT_FOUND_3: - case wvcdm::KEY_NOT_FOUND_4: - case wvcdm::KEY_NOT_FOUND_5: - case wvcdm::KEY_NOT_FOUND_6: - case wvcdm::INVALID_SESSION_1: - case wvcdm::NO_DEVICE_KEY_1: - case wvcdm::NO_CONTENT_KEY_2: - case wvcdm::INVALID_PARAMETERS_ENG_13: - case wvcdm::INVALID_PARAMETERS_ENG_14: - case wvcdm::INVALID_PARAMETERS_ENG_15: - case wvcdm::INVALID_PARAMETERS_ENG_16: - case wvcdm::CLIENT_IDENTIFICATION_TOKEN_ERROR_1: - case wvcdm::UNKNOWN_SELECT_KEY_ERROR_1: - case wvcdm::UNKNOWN_SELECT_KEY_ERROR_2: - case wvcdm::CREATE_USAGE_TABLE_ERROR: - case wvcdm::LOAD_USAGE_HEADER_GENERATION_SKEW: - case wvcdm::LOAD_USAGE_HEADER_SIGNATURE_FAILURE: - case wvcdm::LOAD_USAGE_HEADER_BAD_MAGIC: - case wvcdm::LOAD_USAGE_HEADER_UNKNOWN_ERROR: - case wvcdm::CREATE_USAGE_ENTRY_UNKNOWN_ERROR: - case wvcdm::LOAD_USAGE_ENTRY_GENERATION_SKEW: - case wvcdm::LOAD_USAGE_ENTRY_SIGNATURE_FAILURE: - case wvcdm::LOAD_USAGE_ENTRY_UNKNOWN_ERROR: - case wvcdm::UPDATE_USAGE_ENTRY_UNKNOWN_ERROR: - case wvcdm::SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR: - case wvcdm::MOVE_USAGE_ENTRY_UNKNOWN_ERROR: - case wvcdm::COPY_OLD_USAGE_ENTRY_UNKNOWN_ERROR: - case wvcdm::INVALID_PARAMETERS_ENG_22: - case wvcdm::INVALID_PARAMETERS_ENG_23: - case wvcdm::USAGE_INFORMATION_SUPPORT_FAILED: - case wvcdm::USAGE_SUPPORT_GET_API_FAILED: - case wvcdm::UNEXPECTED_EMPTY_USAGE_ENTRY: - case wvcdm::INVALID_USAGE_ENTRY_NUMBER_MODIFICATION: - case wvcdm::USAGE_INVALID_NEW_ENTRY: - case wvcdm::USAGE_INVALID_PARAMETERS_1: - case wvcdm::USAGE_ENTRY_NUMBER_MISMATCH: - case wvcdm::USAGE_GET_ENTRY_RETRIEVE_INVALID_STORAGE_TYPE: - case wvcdm::USAGE_GET_ENTRY_RETRIEVE_LICENSE_FAILED: - case wvcdm::USAGE_GET_ENTRY_RETRIEVE_USAGE_INFO_FAILED: - case wvcdm::USAGE_STORE_ENTRY_RETRIEVE_INVALID_STORAGE_TYPE: - case wvcdm::USAGE_STORE_ENTRY_RETRIEVE_LICENSE_FAILED: - case wvcdm::USAGE_STORE_ENTRY_RETRIEVE_USAGE_INFO_FAILED: - case wvcdm::USAGE_STORE_LICENSE_FAILED: - case wvcdm::USAGE_STORE_USAGE_INFO_FAILED: - case wvcdm::USAGE_INVALID_LOAD_ENTRY: - case wvcdm::REMOVE_ALL_USAGE_INFO_ERROR_5: - case wvcdm::REMOVE_ALL_USAGE_INFO_ERROR_6: - case wvcdm::REMOVE_ALL_USAGE_INFO_ERROR_7: - case wvcdm::INCORRECT_USAGE_SUPPORT_TYPE_1: - case wvcdm::INCORRECT_USAGE_SUPPORT_TYPE_2: - case wvcdm::NO_USAGE_ENTRIES: - case wvcdm::LIST_LICENSE_ERROR_1: - case wvcdm::LIST_LICENSE_ERROR_2: - case wvcdm::LIST_USAGE_ERROR_1: - case wvcdm::LIST_USAGE_ERROR_2: - case wvcdm::DELETE_USAGE_ERROR_1: - case wvcdm::DELETE_USAGE_ERROR_2: - case wvcdm::DELETE_USAGE_ERROR_3: - case wvcdm::PRIVACY_MODE_ERROR_1: - case wvcdm::PRIVACY_MODE_ERROR_2: - case wvcdm::PRIVACY_MODE_ERROR_3: - case wvcdm::EMPTY_RESPONSE_ERROR_1: - case wvcdm::INVALID_PARAMETERS_ENG_24: - case wvcdm::PARSE_RESPONSE_ERROR_1: - case wvcdm::PARSE_RESPONSE_ERROR_2: - case wvcdm::PARSE_RESPONSE_ERROR_3: - case wvcdm::PARSE_RESPONSE_ERROR_4: - case wvcdm::LOAD_SYSTEM_ID_ERROR: - case wvcdm::REMOVE_USAGE_INFO_ERROR_1: - case wvcdm::REMOVE_USAGE_INFO_ERROR_2: - case wvcdm::REMOVE_USAGE_INFO_ERROR_3: - case wvcdm::NOT_AN_ENTITLEMENT_SESSION: - case wvcdm::LOAD_ENTITLED_CONTENT_KEYS_ERROR: - case wvcdm::GET_PROVISIONING_METHOD_ERROR: - case wvcdm::INVALID_SESSION_2: - case wvcdm::DEVICE_CANNOT_REPROVISION: - case wvcdm::SET_DECRYPT_HASH_ERROR: - case wvcdm::GET_DECRYPT_HASH_ERROR: - case wvcdm::INVALID_DECRYPT_HASH_FORMAT: - case wvcdm::EMPTY_LICENSE_REQUEST_2: - case wvcdm::EMPTY_LICENSE_REQUEST_3: - case wvcdm::EMPTY_LICENSE_RESPONSE_3: - case wvcdm::EMPTY_LICENSE_RESPONSE_4: - case wvcdm::PARSE_REQUEST_ERROR_1: - case wvcdm::PARSE_REQUEST_ERROR_2: - case wvcdm::INVALID_LICENSE_REQUEST_TYPE_1: - case wvcdm::INVALID_LICENSE_REQUEST_TYPE_2: - case wvcdm::LICENSE_RESPONSE_PARSE_ERROR_4: - case wvcdm::LICENSE_RESPONSE_PARSE_ERROR_5: - case wvcdm::INVALID_LICENSE_TYPE_2: - case wvcdm::SIGNATURE_NOT_FOUND_2: - case wvcdm::SESSION_KEYS_NOT_FOUND_2: - case wvcdm::GET_OFFLINE_LICENSE_STATE_ERROR_1: - case wvcdm::GET_OFFLINE_LICENSE_STATE_ERROR_2: - case wvcdm::REMOVE_OFFLINE_LICENSE_ERROR_1: - case wvcdm::REMOVE_OFFLINE_LICENSE_ERROR_2: - case wvcdm::OUTPUT_TOO_LARGE_ERROR: - case wvcdm::SESSION_LOST_STATE_ERROR: - case wvcdm::GENERATE_DERIVED_KEYS_ERROR_2: - case wvcdm::LOAD_DEVICE_RSA_KEY_ERROR: - case wvcdm::NONCE_GENERATION_ERROR: - case wvcdm::GENERATE_SIGNATURE_ERROR: - case wvcdm::UNKNOWN_CLIENT_TOKEN_TYPE: - case wvcdm::DEACTIVATE_USAGE_ENTRY_ERROR: - case wvcdm::SERVICE_CERTIFICATE_PROVIDER_ID_EMPTY: - case wvcdm::OPEN_CRYPTO_SESSION_ERROR: - case wvcdm::LOAD_SRM_ERROR: - case wvcdm::RANDOM_GENERATION_ERROR: - case wvcdm::CRYPTO_SESSION_NOT_INITIALIZED: - case wvcdm::GET_DEVICE_ID_ERROR: - case wvcdm::GET_TOKEN_FROM_OEM_CERT_ERROR: - case wvcdm::CRYPTO_SESSION_NOT_OPEN: - case wvcdm::GET_TOKEN_FROM_KEYBOX_ERROR: - case wvcdm::KEYBOX_TOKEN_TOO_SHORT: - case wvcdm::EXTRACT_SYSTEM_ID_FROM_OEM_CERT_ERROR: - case wvcdm::RSA_SIGNATURE_GENERATION_ERROR: - case wvcdm::GET_HDCP_CAPABILITY_FAILED: - case wvcdm::GET_NUMBER_OF_OPEN_SESSIONS_ERROR: - case wvcdm::GET_MAX_NUMBER_OF_OPEN_SESSIONS_ERROR: - case wvcdm::NOT_IMPLEMENTED_ERROR: - case wvcdm::GET_SRM_VERSION_ERROR: - case wvcdm::REWRAP_DEVICE_RSA_KEY_ERROR: - case wvcdm::INVALID_SRM_LIST: - case wvcdm::USAGE_INVALID_PARAMETERS_2: - case wvcdm::CORE_MESSAGE_NOT_FOUND: - case wvcdm::LOAD_PROVISIONING_ERROR: - case wvcdm::LOAD_LICENSE_ERROR: - case wvcdm::LOAD_RENEWAL_ERROR: - case wvcdm::CANNOT_DECRYPT_ZERO_SAMPLES: - case wvcdm::CANNOT_DECRYPT_ZERO_SUBSAMPLES: - case wvcdm::SAMPLE_AND_SUBSAMPLE_SIZE_MISMATCH: - case wvcdm::INVALID_IV_SIZE: - case wvcdm::LOAD_USAGE_ENTRY_INVALID_SESSION: - case wvcdm::MOVE_USAGE_ENTRY_DESTINATION_IN_USE: - case wvcdm::SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE: - case wvcdm::LICENSE_USAGE_ENTRY_MISSING: - case wvcdm::PROVISIONING_NOT_ALLOWED_FOR_ATSC: - case wvcdm::NO_SRM_VERSION: - case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_9: - case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_10: - case wvcdm::CLIENT_TOKEN_NOT_SET: - case wvcdm::USAGE_ENTRY_ALREADY_LOADED: - case wvcdm::PARSE_OKP_RESPONSE_ERROR: - case wvcdm::OKP_ALREADY_PROVISIONED: - case wvcdm::PROVISIONING_TYPE_IS_NOT_BOOT_CERTIFICATE_CHAIN_ERROR: - case wvcdm::GET_BOOT_CERTIFICATE_CHAIN_ERROR: - case wvcdm::GENERATE_CERTIFICATE_KEY_PAIR_ERROR: - case wvcdm::GENERATE_CERTIFICATE_KEY_PAIR_UNKNOWN_TYPE_ERROR: - case wvcdm::LOAD_OEM_CERTIFICATE_PRIVATE_KEY_ERROR: - case wvcdm::PROVISIONING_4_CRYPTO_SESSION_NOT_OPEN: - case wvcdm::PROVISIONING_4_FILE_SYSTEM_IS_NULL: - case wvcdm::PROVISIONING_4_FAILED_TO_INITIALIZE_DEVICE_FILES: - case wvcdm::PROVISIONING_4_RESPONSE_FAILED_TO_PARSE_MESSAGE: - case wvcdm::PROVISIONING_4_RESPONSE_HAS_ERROR_STATUS: - case wvcdm::PROVISIONING_4_RESPONSE_HAS_NO_CERTIFICATE: - case wvcdm::PROVISIONING_4_NO_PRIVATE_KEY: - case wvcdm::PROVISIONING_4_FAILED_TO_INITIALIZE_DEVICE_FILES_2: - case wvcdm::PROVISIONING_4_FAILED_TO_STORE_OEM_CERTIFICATE: - case wvcdm::PROVISIONING_4_FAILED_TO_STORE_DRM_CERTIFICATE: - case wvcdm::PROVISIONING_4_FAILED_TO_INITIALIZE_DEVICE_FILES_3: - ALOGW("Returns UNKNOWN error for legacy status: %d", res); - return Status::ERROR_DRM_UNKNOWN; - - case wvcdm::UNKNOWN_ERROR: - return Status::ERROR_DRM_UNKNOWN; - } - - // Return here instead of as a default case so that the compiler will warn - // us if we forget to include an enum member in the switch statement. - return Status::ERROR_DRM_UNKNOWN; -} - -static Status_V1_2 mapCdmResponseType_1_2( - wvcdm::CdmResponseType res) { - switch(res) { - case wvcdm::KEY_PROHIBITED_FOR_SECURITY_LEVEL: - return Status_V1_2::ERROR_DRM_INSUFFICIENT_SECURITY; - case wvcdm::OUTPUT_TOO_LARGE_ERROR: - return Status_V1_2::ERROR_DRM_FRAME_TOO_LARGE; - case wvcdm::SESSION_LOST_STATE_ERROR: - return Status_V1_2::ERROR_DRM_SESSION_LOST_STATE; - case wvcdm::LICENSE_REQUEST_NONCE_GENERATION_ERROR: - case wvcdm::LICENSE_RENEWAL_NONCE_GENERATION_ERROR: - case wvcdm::CERT_PROVISIONING_NONCE_GENERATION_ERROR: - case wvcdm::NONCE_GENERATION_ERROR: - // These are likely nonce flood errors - return Status_V1_2::ERROR_DRM_RESOURCE_CONTENTION; - - default: - return static_cast(mapCdmResponseType_1_0(res)); - } -} - -template -static S mapCdmResponseType(wvcdm::CdmResponseType res) { - ::drm::V1_4::Status err = ::drm::V1_4::Status::ERROR_DRM_UNKNOWN; - switch(res) { - case wvcdm::CANNOT_DECRYPT_ZERO_SUBSAMPLES: - err = ::drm::V1_4::Status::CANNOT_DECRYPT_ZERO_SUBSAMPLES; - break; - case wvcdm::CLIENT_ID_AES_ENCRYPT_ERROR: - case wvcdm::CLIENT_ID_AES_INIT_ERROR: - case wvcdm::CLIENT_ID_RSA_ENCRYPT_ERROR: - err = ::drm::V1_4::Status::CRYPTO_LIBRARY_ERROR; - break; - case wvcdm::PROVISIONING_NOT_ALLOWED_FOR_ATSC: - err = ::drm::V1_4::Status::ERROR_DRM_CANNOT_HANDLE; - break; - case wvcdm::CERT_PROVISIONING_REQUEST_ERROR_4: - case wvcdm::CLIENT_IDENTIFICATION_TOKEN_ERROR_1: - case wvcdm::CREATE_USAGE_ENTRY_UNKNOWN_ERROR: - case wvcdm::CREATE_USAGE_TABLE_ERROR: - case wvcdm::DEACTIVATE_USAGE_ENTRY_ERROR: - case wvcdm::EMPTY_LICENSE_RENEWAL: - case wvcdm::EMPTY_LICENSE_REQUEST: - case wvcdm::EXTRACT_SYSTEM_ID_FROM_OEM_CERT_ERROR: - case wvcdm::GENERATE_DERIVED_KEYS_ERROR: - case wvcdm::GENERATE_DERIVED_KEYS_ERROR_2: - case wvcdm::GENERATE_SIGNATURE_ERROR: - case wvcdm::GENERATE_USAGE_REPORT_ERROR: - case wvcdm::GET_DECRYPT_HASH_ERROR: - case wvcdm::GET_DEVICE_ID_ERROR: - case wvcdm::GET_HDCP_CAPABILITY_FAILED: - case wvcdm::GET_MAX_NUMBER_OF_OPEN_SESSIONS_ERROR: - case wvcdm::GET_NUMBER_OF_OPEN_SESSIONS_ERROR: - case wvcdm::GET_PROVISIONING_METHOD_ERROR: - case wvcdm::GET_SRM_VERSION_ERROR: - case wvcdm::GET_TOKEN_FROM_KEYBOX_ERROR: - case wvcdm::GET_TOKEN_FROM_OEM_CERT_ERROR: - case wvcdm::INVALID_DECRYPT_HASH_FORMAT: - case wvcdm::INVALID_SESSION_1: - case wvcdm::INVALID_SESSION_2: - case wvcdm::KEYBOX_TOKEN_TOO_SHORT: - case wvcdm::LOAD_USAGE_ENTRY_UNKNOWN_ERROR: - case wvcdm::LOAD_USAGE_HEADER_UNKNOWN_ERROR: - case wvcdm::MOVE_USAGE_ENTRY_UNKNOWN_ERROR: - case wvcdm::OPEN_CRYPTO_SESSION_ERROR: - case wvcdm::RANDOM_GENERATION_ERROR: - case wvcdm::SET_DECRYPT_HASH_ERROR: - case wvcdm::SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR: - case wvcdm::UNKNOWN_CLIENT_TOKEN_TYPE: - case wvcdm::UNKNOWN_SELECT_KEY_ERROR_1: - case wvcdm::UNKNOWN_SELECT_KEY_ERROR_2: - case wvcdm::UPDATE_USAGE_ENTRY_UNKNOWN_ERROR: - case wvcdm::USAGE_SUPPORT_GET_API_FAILED: - err = ::drm::V1_4::Status::GENERAL_OEM_ERROR; - break; - case wvcdm::CANNOT_DECRYPT_ZERO_SAMPLES: - case wvcdm::CERT_PROVISIONING_REQUEST_ERROR_1: - case wvcdm::CLIENT_TOKEN_NOT_SET: - case wvcdm::CRYPTO_SESSION_NOT_INITIALIZED: - case wvcdm::CRYPTO_SESSION_NOT_OPEN: - case wvcdm::DEVICE_CANNOT_REPROVISION: - case wvcdm::DEVICE_CERTIFICATE_ERROR_1: - case wvcdm::DUPLICATE_SESSION_ID_SPECIFIED: - case wvcdm::EMPTY_KEYSET_ID_ENG_5: - case wvcdm::EMPTY_RESPONSE_ERROR_1: - case wvcdm::EMPTY_SESSION_ID: - case wvcdm::GENERATE_CERTIFICATE_KEY_PAIR_ERROR: - case wvcdm::GENERATE_CERTIFICATE_KEY_PAIR_UNKNOWN_TYPE_ERROR: - case wvcdm::GET_BOOT_CERTIFICATE_CHAIN_ERROR: - case wvcdm::INCORRECT_USAGE_SUPPORT_TYPE_1: - case wvcdm::INCORRECT_USAGE_SUPPORT_TYPE_2: - case wvcdm::INVALID_IV_SIZE: - case wvcdm::INVALID_KEY_SYSTEM: - case wvcdm::INVALID_PARAMETERS_ENG_22: - case wvcdm::INVALID_PARAMETERS_ENG_23: - case wvcdm::INVALID_PARAMETERS_ENG_24: - case wvcdm::INVALID_PARAMETERS_LIC_1: - case wvcdm::INVALID_PARAMETERS_LIC_2: - case wvcdm::INVALID_PARAMETERS_LIC_6: - case wvcdm::INVALID_PARAMETERS_LIC_7: - case wvcdm::INVALID_PROVISIONING_PARAMETERS_1: - case wvcdm::INVALID_PROVISIONING_PARAMETERS_2: - case wvcdm::INVALID_PROVISIONING_REQUEST_PARAM_1: - case wvcdm::INVALID_PROVISIONING_REQUEST_PARAM_2: - case wvcdm::INVALID_SESSION_ID: - case wvcdm::KEYSET_ID_NOT_FOUND_1: - case wvcdm::KEYSET_ID_NOT_FOUND_2: - case wvcdm::KEYSET_ID_NOT_FOUND_3: - case wvcdm::KEY_CONFLICT_1: - case wvcdm::KEY_NOT_FOUND_2: - case wvcdm::KEY_REQUEST_ERROR_1: - case wvcdm::LICENSE_PARSER_NOT_INITIALIZED_1: - case wvcdm::LICENSE_PARSER_NOT_INITIALIZED_2: - case wvcdm::LICENSE_PARSER_NOT_INITIALIZED_3: - case wvcdm::LICENSE_PARSER_NOT_INITIALIZED_4: - case wvcdm::LICENSE_REQUEST_SERVICE_CERTIFICATE_GENERATION_ERROR: - case wvcdm::LICENSE_USAGE_ENTRY_MISSING: - case wvcdm::LOAD_ENTITLED_CONTENT_KEYS_ERROR: - case wvcdm::LOAD_OEM_CERTIFICATE_PRIVATE_KEY_ERROR: - case wvcdm::LOAD_USAGE_ENTRY_GENERATION_SKEW: - case wvcdm::LOAD_USAGE_ENTRY_INVALID_SESSION: - case wvcdm::LOAD_USAGE_ENTRY_SIGNATURE_FAILURE: - case wvcdm::LOAD_USAGE_HEADER_BAD_MAGIC: - case wvcdm::LOAD_USAGE_HEADER_GENERATION_SKEW: - case wvcdm::LOAD_USAGE_HEADER_SIGNATURE_FAILURE: - case wvcdm::LOAD_USAGE_INFO_MISSING: - case wvcdm::MOVE_USAGE_ENTRY_DESTINATION_IN_USE: - case wvcdm::NOT_IMPLEMENTED_ERROR: - case wvcdm::NOT_INITIALIZED_ERROR: - case wvcdm::NO_SRM_VERSION: - case wvcdm::NO_USAGE_ENTRIES: - case wvcdm::PARAMETER_NULL: - case wvcdm::PREPARE_CENC_CONTENT_ID_FAILED: - case wvcdm::PREPARE_WEBM_CONTENT_ID_FAILED: - case wvcdm::PROVISIONING_4_CRYPTO_SESSION_NOT_OPEN: - case wvcdm::PROVISIONING_4_FAILED_TO_INITIALIZE_DEVICE_FILES: - case wvcdm::PROVISIONING_4_FILE_SYSTEM_IS_NULL: - case wvcdm::PROVISIONING_4_NO_PRIVATE_KEY: - case wvcdm::PROVISIONING_TYPE_IS_NOT_BOOT_CERTIFICATE_CHAIN_ERROR: - case wvcdm::REINIT_ERROR: - case wvcdm::REMOVE_OFFLINE_LICENSE_ERROR_2: - case wvcdm::REMOVE_USAGE_INFO_ERROR_3: - case wvcdm::SESSION_NOT_FOUND_11: - case wvcdm::SESSION_NOT_FOUND_12: - case wvcdm::SESSION_NOT_FOUND_13: - case wvcdm::SESSION_NOT_FOUND_14: - case wvcdm::SESSION_NOT_FOUND_15: - case wvcdm::SESSION_NOT_FOUND_16: - case wvcdm::SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE: - case wvcdm::STORAGE_PROHIBITED: - case wvcdm::STORE_LICENSE_ERROR_2: - case wvcdm::USAGE_ENTRY_NUMBER_MISMATCH: - case wvcdm::USAGE_GET_ENTRY_RETRIEVE_INVALID_STORAGE_TYPE: - case wvcdm::USAGE_INFORMATION_SUPPORT_FAILED: - case wvcdm::USAGE_INVALID_LOAD_ENTRY: - case wvcdm::USAGE_INVALID_NEW_ENTRY: - case wvcdm::USAGE_INVALID_PARAMETERS_1: - case wvcdm::USAGE_INVALID_PARAMETERS_2: - case wvcdm::USAGE_STORE_ENTRY_RETRIEVE_INVALID_STORAGE_TYPE: - err = ::drm::V1_4::Status::GENERAL_PLUGIN_ERROR; - break; - case wvcdm::CLIENT_ID_GENERATE_RANDOM_ERROR: - err = ::drm::V1_4::Status::ERROR_DRM_RESOURCE_CONTENTION; - break; - case wvcdm::CENC_INIT_DATA_UNAVAILABLE: - case wvcdm::INIT_DATA_NOT_FOUND: - case wvcdm::INVALID_PARAMETERS_LIC_3: - case wvcdm::INVALID_PARAMETERS_LIC_4: - case wvcdm::UNSUPPORTED_INIT_DATA: - case wvcdm::UNSUPPORTED_INIT_DATA_FORMAT: - case wvcdm::WEBM_INIT_DATA_UNAVAILABLE: - err = ::drm::V1_4::Status::INIT_DATA_INVALID; - break; - case wvcdm::EMPTY_KEYSET_ID: - case wvcdm::EMPTY_KEYSET_ID_ENG_1: - case wvcdm::EMPTY_KEYSET_ID_ENG_2: - case wvcdm::EMPTY_KEYSET_ID_ENG_3: - case wvcdm::EMPTY_KEYSET_ID_ENG_4: - case wvcdm::EMPTY_LICENSE_RESPONSE_1: - case wvcdm::EMPTY_LICENSE_RESPONSE_2: - case wvcdm::EMPTY_PROVISIONING_RESPONSE: - case wvcdm::INVALID_PARAMETERS_ENG_13: - case wvcdm::INVALID_PARAMETERS_ENG_14: - case wvcdm::INVALID_PARAMETERS_ENG_15: - case wvcdm::INVALID_PARAMETERS_ENG_16: - case wvcdm::INVALID_QUERY_KEY: - case wvcdm::KEY_NOT_FOUND_1: - case wvcdm::SAMPLE_AND_SUBSAMPLE_SIZE_MISMATCH: - err = ::drm::V1_4::Status::BAD_VALUE; - break; - case wvcdm::KEY_NOT_FOUND_3: - case wvcdm::KEY_NOT_FOUND_4: - case wvcdm::KEY_NOT_FOUND_5: - case wvcdm::KEY_NOT_FOUND_6: - err = ::drm::V1_4::Status::KEY_NOT_LOADED; - break; - case wvcdm::ADD_KEY_ERROR: - case wvcdm::CORE_MESSAGE_NOT_FOUND: - case wvcdm::EMPTY_KEY_DATA_1: - case wvcdm::EMPTY_KEY_DATA_2: - case wvcdm::INVALID_LICENSE_RESPONSE: - case wvcdm::INVALID_LICENSE_TYPE: - case wvcdm::INVALID_SRM_LIST: - case wvcdm::KEY_SIZE_ERROR_1: - case wvcdm::KEY_SIZE_ERROR_2: - case wvcdm::LICENSE_ID_NOT_FOUND: - case wvcdm::LICENSE_RESPONSE_NOT_SIGNED: - case wvcdm::LICENSE_RESPONSE_PARSE_ERROR_1: - case wvcdm::LICENSE_RESPONSE_PARSE_ERROR_2: - case wvcdm::LICENSE_RESPONSE_PARSE_ERROR_3: - case wvcdm::LICENSE_RESPONSE_PARSE_ERROR_4: - case wvcdm::LICENSE_RESPONSE_PARSE_ERROR_5: - case wvcdm::LOAD_KEY_ERROR: - case wvcdm::LOAD_LICENSE_ERROR: - case wvcdm::LOAD_RENEWAL_ERROR: - case wvcdm::LOAD_SRM_ERROR: - case wvcdm::NOT_AN_ENTITLEMENT_SESSION: - case wvcdm::NO_CONTENT_KEY: - case wvcdm::NO_CONTENT_KEY_2: - case wvcdm::NO_DEVICE_KEY_1: - case wvcdm::PROVISIONING_4_RESPONSE_FAILED_TO_PARSE_MESSAGE: - case wvcdm::REFRESH_KEYS_ERROR: - case wvcdm::SESSION_KEYS_NOT_FOUND: - case wvcdm::SIGNATURE_NOT_FOUND: - err = ::drm::V1_4::Status::LICENSE_PARSE_ERROR; - break; - case wvcdm::LICENSE_RENEWAL_PROHIBITED: - case wvcdm::OFFLINE_LICENSE_PROHIBITED: - err = ::drm::V1_4::Status::LICENSE_POLICY_ERROR; - break; - case wvcdm::PARSE_REQUEST_ERROR_2: - case wvcdm::RELEASE_LICENSE_ERROR_1: - case wvcdm::SESSION_KEYS_NOT_FOUND_2: - err = ::drm::V1_4::Status::LICENSE_RELEASE_ERROR; - break; - case wvcdm::KEY_ERROR: - case wvcdm::RELEASE_KEY_ERROR: - case wvcdm::RENEW_KEY_ERROR_1: - err = ::drm::V1_4::Status::LICENSE_REQUEST_REJECTED; - break; - case wvcdm::EMPTY_LICENSE_REQUEST_2: - case wvcdm::EMPTY_LICENSE_REQUEST_3: - case wvcdm::EMPTY_LICENSE_RESPONSE_3: - case wvcdm::EMPTY_LICENSE_RESPONSE_4: - case wvcdm::INVALID_LICENSE_REQUEST_TYPE_1: - case wvcdm::INVALID_LICENSE_REQUEST_TYPE_2: - case wvcdm::INVALID_LICENSE_TYPE_2: - case wvcdm::PARSE_REQUEST_ERROR_1: - case wvcdm::RESTORE_OFFLINE_LICENSE_ERROR_2: - case wvcdm::SIGNATURE_NOT_FOUND_2: - err = ::drm::V1_4::Status::LICENSE_RESTORE_ERROR; - break; - case wvcdm::GET_RELEASED_LICENSE_ERROR: - case wvcdm::RESTORE_OFFLINE_LICENSE_ERROR_3: - case wvcdm::USAGE_ENTRY_ALREADY_LOADED: - err = ::drm::V1_4::Status::LICENSE_STATE_ERROR; - break; - case wvcdm::DEVICE_CERTIFICATE_ERROR_2: - case wvcdm::DEVICE_CERTIFICATE_ERROR_3: - case wvcdm::DEVICE_CERTIFICATE_ERROR_4: - case wvcdm::LICENSE_PARSER_INIT_ERROR: - case wvcdm::PARSE_RESPONSE_ERROR_1: - case wvcdm::PARSE_RESPONSE_ERROR_2: - case wvcdm::PARSE_RESPONSE_ERROR_3: - case wvcdm::PARSE_RESPONSE_ERROR_4: - err = ::drm::V1_4::Status::MALFORMED_CERTIFICATE; - break; - case wvcdm::INVALID_DECRYPT_PARAMETERS_ENG_2: - case wvcdm::INVALID_DECRYPT_PARAMETERS_ENG_4: - err = ::drm::V1_4::Status::MEDIA_FRAMEWORK_ERROR; - break; - case wvcdm::PRIVACY_MODE_ERROR_1: - case wvcdm::PRIVACY_MODE_ERROR_2: - case wvcdm::PRIVACY_MODE_ERROR_3: - err = ::drm::V1_4::Status::MISSING_CERTIFICATE; - break; - case wvcdm::LOAD_DEVICE_RSA_KEY_ERROR: - err = ::drm::V1_4::Status::PROVISIONING_CERTIFICATE_ERROR; - break; - case wvcdm::CERT_PROVISIONING_EMPTY_SERVICE_CERTIFICATE: - case wvcdm::PROVISIONING_4_RESPONSE_HAS_NO_CERTIFICATE: - case wvcdm::SERVICE_CERTIFICATE_PROVIDER_ID_EMPTY: - err = ::drm::V1_4::Status::PROVISIONING_CONFIGURATION_ERROR; - break; - case wvcdm::CERT_PROVISIONING_INVALID_CERT_TYPE: - case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_1: - case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_2: - case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_3: - case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_4: - case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_9: - case wvcdm::LOAD_PROVISIONING_ERROR: - err = ::drm::V1_4::Status::PROVISIONING_PARSE_ERROR; - break; - case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_10: - case wvcdm::PROVISIONING_4_RESPONSE_HAS_ERROR_STATUS: - err = ::drm::V1_4::Status::PROVISIONING_REQUEST_REJECTED; - break; - case wvcdm::EMPTY_PROVISIONING_CERTIFICATE_1: - case wvcdm::EMPTY_PROVISIONING_CERTIFICATE_2: - err = ::drm::V1_4::Status::RETRYABLE_PROVISIONING_ERROR; - break; - case wvcdm::RELEASE_LICENSE_ERROR_2: - err = ::drm::V1_4::Status::SECURE_STOP_RELEASE_ERROR; - break; - case wvcdm::GET_LICENSE_ERROR: - case wvcdm::GET_OFFLINE_LICENSE_STATE_ERROR_1: - case wvcdm::GET_OFFLINE_LICENSE_STATE_ERROR_2: - case wvcdm::GET_USAGE_INFO_ERROR_1: - case wvcdm::GET_USAGE_INFO_ERROR_2: - case wvcdm::GET_USAGE_INFO_ERROR_3: - case wvcdm::GET_USAGE_INFO_ERROR_4: - case wvcdm::LIST_LICENSE_ERROR_1: - case wvcdm::LIST_LICENSE_ERROR_2: - case wvcdm::LIST_USAGE_ERROR_1: - case wvcdm::LIST_USAGE_ERROR_2: - case wvcdm::LOAD_USAGE_INFO_FILE_ERROR: - case wvcdm::REMOVE_OFFLINE_LICENSE_ERROR_1: - case wvcdm::REMOVE_USAGE_INFO_ERROR_2: - case wvcdm::SESSION_FILE_HANDLE_INIT_ERROR: - case wvcdm::UNPROVISION_ERROR_1: - case wvcdm::USAGE_GET_ENTRY_RETRIEVE_LICENSE_FAILED: - case wvcdm::USAGE_GET_ENTRY_RETRIEVE_USAGE_INFO_FAILED: - case wvcdm::USAGE_INFO_NOT_FOUND: - case wvcdm::USAGE_STORE_ENTRY_RETRIEVE_LICENSE_FAILED: - case wvcdm::USAGE_STORE_ENTRY_RETRIEVE_USAGE_INFO_FAILED: - err = ::drm::V1_4::Status::STORAGE_READ_FAILURE; - break; - case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_7: - case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_8: - case wvcdm::DELETE_USAGE_ERROR_1: - case wvcdm::DELETE_USAGE_ERROR_2: - case wvcdm::PROVISIONING_4_FAILED_TO_INITIALIZE_DEVICE_FILES_2: - case wvcdm::PROVISIONING_4_FAILED_TO_STORE_DRM_CERTIFICATE: - case wvcdm::PROVISIONING_4_FAILED_TO_STORE_OEM_CERTIFICATE: - case wvcdm::RELEASE_KEY_REQUEST_ERROR: - case wvcdm::REMOVE_ALL_USAGE_INFO_ERROR_5: - case wvcdm::REMOVE_USAGE_INFO_ERROR_1: - case wvcdm::RENEW_KEY_ERROR_2: - case wvcdm::STORE_LICENSE_ERROR_1: - case wvcdm::STORE_USAGE_INFO_ERROR: - case wvcdm::UNPROVISION_ERROR_2: - case wvcdm::UNPROVISION_ERROR_3: - case wvcdm::USAGE_STORE_LICENSE_FAILED: - case wvcdm::USAGE_STORE_USAGE_INFO_FAILED: - err = ::drm::V1_4::Status::STORAGE_WRITE_FAILURE; - break; - default: - return static_cast(mapCdmResponseType_1_2(res)); - } - return static_cast(err); -} - -static inline bool isCdmResponseTypeSuccess(wvcdm::CdmResponseType res) { - return mapCdmResponseType(res) == Status::OK; -} - -} // namespace wvdrm - -#endif // WV_MAP_ERRORS_H_ diff --git a/libwvdrmengine/include_hidl/HidlTypes.h b/libwvdrmengine/include_hidl/HidlTypes.h deleted file mode 100644 index 62ce8c5d..00000000 --- a/libwvdrmengine/include_hidl/HidlTypes.h +++ /dev/null @@ -1,66 +0,0 @@ -// -// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary -// source code may only be used and distributed under the Widevine License -// Agreement. -// - -#ifndef HIDL_TYPES_H_ -#define HIDL_TYPES_H_ - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -using ::android::hardware::configureRpcThreadpool; -using ::android::hardware::hidl_array; -using ::android::hardware::hidl_handle; -using ::android::hardware::hidl_memory; -using ::android::hardware::hidl_string; -using ::android::hardware::hidl_vec; -using ::android::hardware::joinRpcThreadpool; -using ::android::hardware::Return; -using ::android::hardware::Void; -using ::android::sp; - -namespace drm = ::android::hardware::drm; -using drm::V1_0::BufferType; -using drm::V1_0::DestinationBuffer; -using drm::V1_0::EventType; -using drm::V1_0::IDrmPluginListener; -using drm::V1_0::KeyRequestType; -using drm::V1_0::KeyStatus; -using drm::V1_0::KeyStatusType; -using drm::V1_0::KeyType; -using drm::V1_0::KeyValue; -using drm::V1_0::Mode; -using drm::V1_0::Pattern; -using drm::V1_0::SecureStop; -using drm::V1_0::SecureStopId; -using drm::V1_0::SharedBuffer; -using drm::V1_0::Status; -using drm::V1_0::SubSample; -using drm::V1_1::DrmMetricGroup; -using drm::V1_1::HdcpLevel; -using drm::V1_1::SecureStopRelease; -using drm::V1_1::SecurityLevel; -using drm::V1_2::ICryptoPlugin; -using drm::V1_2::IDrmPlugin; -using drm::V1_2::KeySetId; -using drm::V1_2::OfflineLicenseState; -using drm::V1_3::ICryptoFactory; -using drm::V1_3::IDrmFactory; - -typedef drm::V1_1::KeyRequestType KeyRequestType_V1_1; -typedef drm::V1_2::KeyStatus KeyStatus_V1_2; -typedef drm::V1_2::KeyStatusType KeyStatusType_V1_2; -typedef drm::V1_2::IDrmPluginListener IDrmPluginListener_V1_2; -typedef drm::V1_2::Status Status_V1_2; -typedef drm::V1_2::HdcpLevel HdcpLevel_V1_2; - -#endif diff --git a/libwvdrmengine/include_hidl/HidlWVCreatePluginFactories.h b/libwvdrmengine/include_hidl/HidlWVCreatePluginFactories.h deleted file mode 100644 index b358d2b4..00000000 --- a/libwvdrmengine/include_hidl/HidlWVCreatePluginFactories.h +++ /dev/null @@ -1,28 +0,0 @@ -// -// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary -// source code may only be used and distributed under the Widevine License -// Agreement. -// - -#ifndef WV_CREATE_PLUGIN_FACTORIES_H_ -#define WV_CREATE_PLUGIN_FACTORIES_H_ - -#include "HidlTypes.h" - -namespace wvdrm { -namespace hardware { -namespace drm { -namespace V1_4 { -namespace widevine { - -extern "C" { - ::drm::V1_4::IDrmFactory* createDrmFactory(); - ::drm::V1_4::ICryptoFactory* createCryptoFactory(); -} - -} // namespace widevine -} // namespace V1_4 -} // namespace drm -} // namespace hardware -} // namespace wvdrm -#endif // WV_CREATE_PLUGIN_FACTORIES_H_ diff --git a/libwvdrmengine/include_hidl/HidlWVDrmFactory.h b/libwvdrmengine/include_hidl/HidlWVDrmFactory.h deleted file mode 100644 index 88e542d8..00000000 --- a/libwvdrmengine/include_hidl/HidlWVDrmFactory.h +++ /dev/null @@ -1,68 +0,0 @@ -// -// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary -// source code may only be used and distributed under the Widevine License -// Agreement. -// - -#ifndef WV_DRM_FACTORY_H_ -#define WV_DRM_FACTORY_H_ - -#include "HidlTypes.h" -#include "HidlWVTypes.h" -#include "WVGenericCryptoInterface.h" - -namespace wvdrm { -namespace hardware { -namespace drm { -namespace V1_4 { -namespace widevine { - -using ::android::hardware::hidl_handle; -using ::android::hardware::hidl_vec; - -struct WVDrmFactory : public ::drm::V1_4::IDrmFactory { - WVDrmFactory() {} - virtual ~WVDrmFactory() {} - - Return isCryptoSchemeSupported( - const hidl_array& uuid) override; - - Return isCryptoSchemeSupported_1_2(const hidl_array& uuid, - const hidl_string& mimeType, - SecurityLevel level) override; - - Return isContentTypeSupported(const hidl_string& mimeType) override; - - Return createPlugin(const hidl_array& uuid, - const hidl_string& appPackageName, - createPlugin_cb _hidl_cb) override; - - Return getSupportedCryptoSchemes( - getSupportedCryptoSchemes_cb _hidl_cb) override; - - Return debug(const hidl_handle& fd, const hidl_vec& args); - - private: - WVDRM_DISALLOW_COPY_AND_ASSIGN(WVDrmFactory); - - static WVGenericCryptoInterface sOemCryptoInterface; - - static bool areSpoidsEnabled(); - static bool isBlankAppPackageNameAllowed(); - static int32_t firstApiLevel(); - static std::string stringToHex(const std::string& input); - static void printCdmMetrics(FILE* out); - static void printCdmProperties(FILE* out); - - friend class WVDrmFactoryTestPeer; -}; - -extern "C" IDrmFactory* HIDL_FETCH_IDrmFactory(const char* name); - -} // namespace widevine -} // namespace V1_4 -} // namespace drm -} // namespace hardware -} // namespace wvdrm - -#endif // WV_DRM_FACTORY_H_ diff --git a/libwvdrmengine/include_hidl/HidlWVTypes.h b/libwvdrmengine/include_hidl/HidlWVTypes.h deleted file mode 100644 index c3cb5167..00000000 --- a/libwvdrmengine/include_hidl/HidlWVTypes.h +++ /dev/null @@ -1,22 +0,0 @@ -// -// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary -// source code may only be used and distributed under the Widevine License -// Agreement. -// - -#ifndef WV_TYPES_H_ -#define WV_TYPES_H_ - -namespace wvdrm { - -#define WVDRM_DISALLOW_COPY_AND_ASSIGN(TypeName) \ - TypeName(const TypeName&) = delete; \ - void operator=(const TypeName&) = delete; - -#define WVDRM_DISALLOW_COPY_AND_ASSIGN_AND_NEW(TypeName) \ - TypeName() = delete; \ - TypeName(const TypeName&) = delete; \ - void operator=(const TypeName&) = delete; - -} // namespace wvdrm -#endif // WV_TYPES_H_ diff --git a/libwvdrmengine/include_hidl/TypeConvert.h b/libwvdrmengine/include_hidl/TypeConvert.h deleted file mode 100644 index 7d3fd659..00000000 --- a/libwvdrmengine/include_hidl/TypeConvert.h +++ /dev/null @@ -1,119 +0,0 @@ -/* - * Copyright (C) 2017 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef WVDRM_ANDROID_HARDWARE_DRM_V1_1_TYPECONVERT -#define WVDRM_ANDROID_HARDWARE_DRM_V1_1_TYPECONVERT - -#include - -#include "HidlTypes.h" -#include "log.h" -#include "media/stagefright/MediaErrors.h" -#include "utils/Errors.h" - -namespace android { -namespace hardware { -namespace drm { -namespace V1_2 { -namespace widevine { - -inline ::drm::V1_4::LogPriority toHidlPriority(wvutil::LogPriority p) { - switch (p) { - case wvutil::LogPriority::CDM_LOG_ERROR: - return ::drm::V1_4::LogPriority::ERROR; - case wvutil::LogPriority::CDM_LOG_WARN: - return ::drm::V1_4::LogPriority::WARN; - case wvutil::LogPriority::CDM_LOG_INFO: - return ::drm::V1_4::LogPriority::INFO; - case wvutil::LogPriority::CDM_LOG_DEBUG: - return ::drm::V1_4::LogPriority::DEBUG; - case wvutil::LogPriority::CDM_LOG_VERBOSE: - return ::drm::V1_4::LogPriority::VERBOSE; - default: - return ::drm::V1_4::LogPriority::UNKNOWN; - } - return ::drm::V1_4::LogPriority::UNKNOWN; -} - -template -hidl_vec toHidlVec(const std::vector &vec); - -template<> -inline hidl_vec<::drm::V1_4::LogMessage> toHidlVec(const std::vector &vec) { - uint32_t uid = wvutil::GetIpcCallingUid(); - std::vector<::drm::V1_4::LogMessage> vec2; - for (auto msg : vec) { - if (uid == msg.uid_) { - vec2.push_back({ - msg.time_ms_, - toHidlPriority(msg.priority_), - msg.message_, - }); - } - } - - return hidl_vec<::drm::V1_4::LogMessage>(vec2); -} - -template -const hidl_vec toHidlVec(const std::vector &vec) { - hidl_vec hVec; - hVec.setToExternal(const_cast(vec.data()), vec.size()); - return hVec; -} - -template -hidl_vec toHidlVec(std::vector &vec) { - hidl_vec hVec; - hVec.setToExternal(vec.data(), vec.size()); - return hVec; -} - -template -const std::vector toVector(const hidl_vec &hVec) { - std::vector vec; - vec.assign(hVec.data(), hVec.data() + hVec.size()); - return *const_cast *>(&vec); -} - -template -std::vector toVector(hidl_vec &hVec) { - std::vector vec; - vec.assign(hVec.data(), hVec.data() + hVec.size()); - return vec; -} - -template -const std::vector toVector(const hidl_array &hArray) { - std::vector vec; - vec.assign(hArray.data(), hArray.data() + hArray.size()); - return vec; -} - -template -std::vector toVector(hidl_array &hArray) { - std::vector vec; - vec.assign(hArray.data(), hArray.data() + hArray.size()); - return vec; -} - -} // namespace widevine -} // namespace V1_2 -} // namespace drm -} // namespace hardware -} // namespace android - -#endif // WVDRM_ANDROID_HARDWARE_DRM_V1_0_TYPECONVERT diff --git a/libwvdrmengine/include_hidl/WVCryptoFactory.h b/libwvdrmengine/include_hidl/WVCryptoFactory.h deleted file mode 100644 index 7a9f925c..00000000 --- a/libwvdrmengine/include_hidl/WVCryptoFactory.h +++ /dev/null @@ -1,42 +0,0 @@ -// -// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary -// source code may only be used and distributed under the Widevine License -// Agreement. -// - -#ifndef WV_CRYPTO_FACTORY_H_ -#define WV_CRYPTO_FACTORY_H_ - -#include "HidlTypes.h" -#include "HidlWVTypes.h" - -namespace wvdrm { -namespace hardware { -namespace drm { -namespace V1_4 { -namespace widevine { - -struct WVCryptoFactory : public ::drm::V1_4::ICryptoFactory { - public: - WVCryptoFactory() {} - virtual ~WVCryptoFactory() {} - - Return isCryptoSchemeSupported(const hidl_array& uuid) - override; - - Return createPlugin( - const hidl_array& uuid, - const hidl_vec& initData, - createPlugin_cb _hidl_cb) override; - - private: - WVDRM_DISALLOW_COPY_AND_ASSIGN(WVCryptoFactory); -}; - -} // namespace widevine -} // namespace V1_4 -} // namespace drm -} // namespace hardware -} // namespace wvdrm - -#endif // WV_CRYPTO_FACTORY_H_ diff --git a/libwvdrmengine/manifest_android.hardware.drm@1.2-service.widevine.xml b/libwvdrmengine/manifest_android.hardware.drm@1.2-service.widevine.xml deleted file mode 100644 index 85cd44cf..00000000 --- a/libwvdrmengine/manifest_android.hardware.drm@1.2-service.widevine.xml +++ /dev/null @@ -1,23 +0,0 @@ - - - - - android.hardware.drm - hwbinder - @1.2::ICryptoFactory/widevine - @1.2::IDrmFactory/widevine - - diff --git a/libwvdrmengine/manifest_android.hardware.drm@1.3-service.widevine.xml b/libwvdrmengine/manifest_android.hardware.drm@1.3-service.widevine.xml deleted file mode 100644 index f6f2d885..00000000 --- a/libwvdrmengine/manifest_android.hardware.drm@1.3-service.widevine.xml +++ /dev/null @@ -1,23 +0,0 @@ - - - - - android.hardware.drm - hwbinder - @1.3::ICryptoFactory/widevine - @1.3::IDrmFactory/widevine - - diff --git a/libwvdrmengine/manifest_android.hardware.drm@1.4-service.widevine.xml b/libwvdrmengine/manifest_android.hardware.drm@1.4-service.widevine.xml deleted file mode 100644 index 78618dca..00000000 --- a/libwvdrmengine/manifest_android.hardware.drm@1.4-service.widevine.xml +++ /dev/null @@ -1,23 +0,0 @@ - - - - - android.hardware.drm - hwbinder - @1.4::ICryptoFactory/widevine - @1.4::IDrmFactory/widevine - - diff --git a/libwvdrmengine/mediacrypto/Android.bp b/libwvdrmengine/mediacrypto/Android.bp index 3c288463..84540abd 100644 --- a/libwvdrmengine/mediacrypto/Android.bp +++ b/libwvdrmengine/mediacrypto/Android.bp @@ -22,50 +22,6 @@ package { default_applicable_licenses: ["vendor_widevine_license"], } -// Builds libwvdrmcryptoplugin_hidl -// -cc_library_static { - name: "libwvdrmcryptoplugin_hidl", - - srcs: ["src_hidl/WVCryptoPlugin.cpp"], - - include_dirs: [ - "frameworks/av/include", - "frameworks/native/include", - "vendor/widevine/libwvdrmengine/cdm/core/include", - "vendor/widevine/libwvdrmengine/cdm/include", - "vendor/widevine/libwvdrmengine/cdm/metrics/include", - "vendor/widevine/libwvdrmengine/cdm/util/include", - "vendor/widevine/libwvdrmengine/include", - "vendor/widevine/libwvdrmengine/include_hidl", - "vendor/widevine/libwvdrmengine/mediacrypto/include_hidl", - "vendor/widevine/libwvdrmengine/oemcrypto/include", - ], - - header_libs: [ - "libstagefright_headers", - "libutils_headers", - ], - - static_libs: ["libcdm_protos"], - - shared_libs: [ - "android.hardware.drm@1.0", - "android.hardware.drm@1.1", - "android.hardware.drm@1.2", - "android.hardware.drm@1.3", - "android.hardware.drm@1.4", - "android.hidl.memory@1.0", - "libcrypto", - "libhidlmemory", - "liblog", - ], - - cflags: ["-Wthread-safety"], - - proprietary: true, -} - // Builds libwvdrmcryptoplugin_aidl // cc_library_static { diff --git a/libwvdrmengine/mediacrypto/include_hidl/WVCryptoPlugin.h b/libwvdrmengine/mediacrypto/include_hidl/WVCryptoPlugin.h deleted file mode 100644 index 5428d2e3..00000000 --- a/libwvdrmengine/mediacrypto/include_hidl/WVCryptoPlugin.h +++ /dev/null @@ -1,97 +0,0 @@ -// -// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary -// source code may only be used and distributed under the Widevine License -// Agreement. -// - -#ifndef WV_CRYPTO_PLUGIN_H_ -#define WV_CRYPTO_PLUGIN_H_ - -#include -#include - -#include - -#include "HidlTypes.h" -#include "HidlWVTypes.h" -#include "log.h" -#include "wv_content_decryption_module.h" - -namespace wvdrm { -namespace hardware { -namespace drm { -namespace V1_4 { -namespace widevine { - -using ::android::hidl::memory::V1_0::IMemory; - -struct WVCryptoPlugin : public ::drm::V1_4::ICryptoPlugin { - WVCryptoPlugin(const void* data, size_t size, - const sp& cdm); - virtual ~WVCryptoPlugin(); - - Return requiresSecureDecoderComponent(const hidl_string& mime) - override; - - Return notifyResolution(uint32_t width, uint32_t height) override; - - Return setMediaDrmSession(const hidl_vec& sessionId) - override; - - Return setSharedBufferBase(const hidl_memory& base, - uint32_t bufferId) override; - - Return decrypt( - bool secure, - const hidl_array& keyId, - const hidl_array& iv, - Mode mode, - const Pattern& pattern, - const hidl_vec& subSamples, - const SharedBuffer& source, - uint64_t offset, - const DestinationBuffer& destination, - decrypt_cb _hidl_cb) override; - - Return decrypt_1_2( - bool secure, - const hidl_array& keyId, - const hidl_array& iv, - Mode mode, - const Pattern& pattern, - const hidl_vec& subSamples, - const SharedBuffer& source, - uint64_t offset, - const DestinationBuffer& destination, - decrypt_1_2_cb _hidl_cb) override NO_THREAD_SAFETY_ANALYSIS; // use unique_lock - - Return getLogMessages( - getLogMessages_cb _hidl_cb) override; - - private: - WVDRM_DISALLOW_COPY_AND_ASSIGN_AND_NEW(WVCryptoPlugin); - - // List this field first so it is destructed last; ensure logging uid - // is cleared right before plugin is destructed. - wvutil::LoggingUidSetter mLoggingUidSetter; - - wvcdm::CdmSessionId mSessionId; - std::map > mSharedBufferMap GUARDED_BY(mSharedBufferLock); - - sp const mCDM; - uint32_t mUserId; - - Status_V1_2 attemptDecrypt( - const wvcdm::CdmDecryptionParametersV16& params, - bool haveEncryptedSubsamples, std::string* errorDetailMsg); - - std::mutex mSharedBufferLock; -}; - -} // namespace widevine -} // namespace V1_4 -} // namespace drm -} // namespace hardware -} // namespace wvdrm - -#endif // WV_CRYPTO_PLUGIN_H_ diff --git a/libwvdrmengine/mediacrypto/src_hidl/WVCryptoPlugin.cpp b/libwvdrmengine/mediacrypto/src_hidl/WVCryptoPlugin.cpp deleted file mode 100644 index 31e2b532..00000000 --- a/libwvdrmengine/mediacrypto/src_hidl/WVCryptoPlugin.cpp +++ /dev/null @@ -1,372 +0,0 @@ -// -// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary -// source code may only be used and distributed under the Widevine License -// Agreement. -// - -//#define LOG_NDEBUG 0 -#define LOG_TAG "WVCdm" -#include - -#include "WVCryptoPlugin.h" - -#include -#include -#include - -#include "HidlMapErrors-inl.h" -#include "HidlTypes.h" -#include "log.h" -#include "OEMCryptoCENC.h" -#include "openssl/sha.h" -#include "TypeConvert.h" -#include "wv_cdm_constants.h" -#include "WVErrors.h" - -namespace { - -inline Status toStatus_1_0(Status_V1_2 status) { - switch (status) { - case Status_V1_2::ERROR_DRM_INSUFFICIENT_SECURITY: - case Status_V1_2::ERROR_DRM_FRAME_TOO_LARGE: - case Status_V1_2::ERROR_DRM_SESSION_LOST_STATE: - return Status::ERROR_DRM_UNKNOWN; - default: - return static_cast(status); - } -} - -} // namespace - -namespace wvdrm { -namespace hardware { -namespace drm { -namespace V1_4 { -namespace widevine { - -using android::hardware::drm::V1_2::widevine::toHidlVec; -using android::hardware::drm::V1_2::widevine::toVector; -using wvcdm::CdmDecryptionParametersV16; -using wvcdm::CdmDecryptionSample; -using wvcdm::CdmDecryptionSubsample; -using wvcdm::CdmQueryMap; -using wvcdm::CdmResponseType; -using wvcdm::CdmSessionId; -using wvcdm::KeyId; -using wvcdm::WvContentDecryptionModule; - -WVCryptoPlugin::WVCryptoPlugin(const void* data, size_t size, - const sp& cdm) - : mCDM(cdm), - mUserId(wvutil::UNKNOWN_UID) { - if (data != NULL) { - mSessionId.assign(static_cast(data), size); - } - if (!mCDM->IsOpenSession(mSessionId)) { - mSessionId.clear(); - } else { - mCDM->GetSessionUserId(mSessionId, &mUserId); - } -} - -WVCryptoPlugin::~WVCryptoPlugin() { - if (wvutil::UNKNOWN_UID != mUserId) { - wvutil::SetLoggingUid(mUserId); - } -} - -Return WVCryptoPlugin::requiresSecureDecoderComponent( - const hidl_string& mime) { - if (!strncasecmp(mime.c_str(), "video/", 6)) { - // Type is video, so query CDM to see if we require a secure decoder. - CdmQueryMap status; - - CdmResponseType res = mCDM->QuerySessionStatus(mSessionId, &status); - - if (!isCdmResponseTypeSuccess(res)) { - ALOGE("Error querying CDM status: %u", res); - return false; - } - - return status[wvcdm::QUERY_KEY_SECURITY_LEVEL] == - wvcdm::QUERY_VALUE_SECURITY_LEVEL_L1; - } else { - // Type is not video, so never require a secure decoder. - return false; - } -} - -Return WVCryptoPlugin::notifyResolution( - uint32_t width, uint32_t height) { - mCDM->NotifyResolution(mSessionId, width, height); - return Void(); -} - -Return WVCryptoPlugin::setMediaDrmSession( - const hidl_vec& sessionId) { - if (sessionId.size() == 0) { - return Status::BAD_VALUE; - } - const std::vector sId = toVector(sessionId); - CdmSessionId cdmSessionId(sId.begin(), sId.end()); - if (!mCDM->IsOpenSession(cdmSessionId)) { - return Status::ERROR_DRM_SESSION_NOT_OPENED; - } else { - mSessionId = cdmSessionId; - return Status::OK; - } -} - -Return WVCryptoPlugin::setSharedBufferBase( - const hidl_memory& base, uint32_t bufferId) { - sp hidlMemory = mapMemory(base); - - std::lock_guard shared_buffer_lock(mSharedBufferLock); - - // allow mapMemory to return nullptr - mSharedBufferMap[bufferId] = hidlMemory; - return Void(); -} - -Return WVCryptoPlugin::decrypt( - bool secure, - const hidl_array& keyId, - const hidl_array& iv, - Mode mode, - const Pattern& pattern, - const hidl_vec& subSamples, - const SharedBuffer& source, - uint64_t offset, - const DestinationBuffer& destination, - decrypt_cb _hidl_cb) { - - Status status = Status::ERROR_DRM_UNKNOWN; - hidl_string detailedError; - uint32_t bytesWritten = 0; - - Return hResult = decrypt_1_2( - secure, keyId, iv, mode, pattern, subSamples, source, offset, destination, - [&](Status_V1_2 hStatus, uint32_t hBytesWritten, hidl_string hDetailedError) { - status = toStatus_1_0(hStatus); - if (status == Status::OK) { - bytesWritten = hBytesWritten; - detailedError = hDetailedError; - } - } - ); - - status = hResult.isOk() ? status : Status::ERROR_DRM_CANNOT_HANDLE; - _hidl_cb(status, bytesWritten, detailedError); - return Void(); -} - -Return WVCryptoPlugin::decrypt_1_2( - bool secure, - const hidl_array& keyId, - const hidl_array& iv, - Mode mode, - const Pattern& pattern, - const hidl_vec& subSamples, - const SharedBuffer& source, - uint64_t offset, - const DestinationBuffer& destination, - decrypt_1_2_cb _hidl_cb) { - std::unique_lock lock(mSharedBufferLock); - if (mSharedBufferMap.find(source.bufferId) == mSharedBufferMap.end()) { - _hidl_cb(Status_V1_2::ERROR_DRM_CANNOT_HANDLE, 0, - "source decrypt buffer base not set"); - return Void(); - } - - if (destination.type == BufferType::SHARED_MEMORY) { - const SharedBuffer& dest = destination.nonsecureMemory; - if (mSharedBufferMap.find(dest.bufferId) == mSharedBufferMap.end()) { - _hidl_cb(Status_V1_2::ERROR_DRM_CANNOT_HANDLE, 0, - "destination decrypt buffer base not set"); - return Void(); - } - } - - if (mode != Mode::UNENCRYPTED && - mode != Mode::AES_CTR && - mode != Mode::AES_CBC) { - _hidl_cb(Status_V1_2::BAD_VALUE, 0, - "The requested encryption mode is not supported by Widevine CDM."); - return Void(); - } else if (mode == Mode::AES_CTR && - (pattern.encryptBlocks != 0 || pattern.skipBlocks != 0)) { - _hidl_cb(Status_V1_2::BAD_VALUE, 0, - "The 'cens' schema is not supported by Widevine CDM."); - return Void(); - } - - // Convert parameters to the form the CDM wishes to consume them in. - const KeyId cryptoKey( - reinterpret_cast(keyId.data()), wvcdm::KEY_ID_SIZE); - std::vector ivVector(iv.data(), iv.data() + wvcdm::KEY_IV_SIZE); - - std::string errorDetailMsg; - sp sourceBase = mSharedBufferMap[source.bufferId]; - if (sourceBase == nullptr) { - _hidl_cb(Status_V1_2::ERROR_DRM_CANNOT_HANDLE, 0, "source is a nullptr"); - return Void(); - } - - size_t totalSrcSize = 0; - if (__builtin_add_overflow(source.offset, offset, &totalSrcSize) || - __builtin_add_overflow(totalSrcSize, source.size, &totalSrcSize) || - totalSrcSize > sourceBase->getSize()) { - android_errorWriteLog(0x534e4554, "176496160"); - _hidl_cb(Status_V1_2::ERROR_DRM_CANNOT_HANDLE, 0, "invalid buffer size"); - return Void(); - } - - uint8_t *base = static_cast - (static_cast(sourceBase->getPointer())); - uint8_t* srcPtr = static_cast(base + source.offset + offset); - void* destPtr = NULL; - if (destination.type == BufferType::SHARED_MEMORY) { - const SharedBuffer& destBuffer = destination.nonsecureMemory; - sp destBase = mSharedBufferMap[destBuffer.bufferId]; - if (destBase == nullptr) { - _hidl_cb(Status_V1_2::ERROR_DRM_CANNOT_HANDLE, 0, "destination is a nullptr"); - return Void(); - } - - size_t totalDstSize = 0; - if (__builtin_add_overflow(destBuffer.offset, destBuffer.size, &totalDstSize) || - totalDstSize > destBase->getSize()) { - android_errorWriteLog(0x534e4554, "176444622"); - _hidl_cb(Status_V1_2::ERROR_DRM_FRAME_TOO_LARGE, 0, "invalid buffer size"); - return Void(); - } - destPtr = static_cast(base + destination.nonsecureMemory.offset); - } else if (destination.type == BufferType::NATIVE_HANDLE) { - native_handle_t *handle = const_cast( - destination.secureMemory.getNativeHandle()); - destPtr = static_cast(handle); - } - - // release mSharedBufferLock - lock.unlock(); - - // Set up the decrypt params - CdmDecryptionParametersV16 params; - params.key_id = cryptoKey; - params.is_secure = secure; - if (mode == Mode::AES_CTR) { - params.cipher_mode = wvcdm::kCipherModeCtr; - } else if (mode == Mode::AES_CBC) { - params.cipher_mode = wvcdm::kCipherModeCbc; - } - params.pattern.encrypt_blocks = pattern.encryptBlocks; - params.pattern.skip_blocks = pattern.skipBlocks; - - // Set up the sample - // Android's API only supports one at a time - params.samples.emplace_back(); - CdmDecryptionSample& sample = params.samples.back(); - sample.encrypt_buffer = srcPtr; - sample.decrypt_buffer = destPtr; - sample.decrypt_buffer_offset = 0; - sample.iv = ivVector; - - // Set up the subsamples - // We abuse std::transform() here to also do some side-effects: Tallying the - // total size of the sample and checking if any of the data is protected. - size_t totalSize = 0; - bool hasProtectedData = false; - sample.subsamples.reserve(subSamples.size()); - std::transform(subSamples.data(), subSamples.data() + subSamples.size(), - std::back_inserter(sample.subsamples), - [&](const SubSample& subSample) -> CdmDecryptionSubsample { - totalSize += - subSample.numBytesOfClearData + subSample.numBytesOfEncryptedData; - hasProtectedData |= subSample.numBytesOfEncryptedData > 0; - return CdmDecryptionSubsample(subSample.numBytesOfClearData, - subSample.numBytesOfEncryptedData); - }); - - sample.encrypt_buffer_length = totalSize; - sample.decrypt_buffer_size = totalSize; - - if (mode == Mode::UNENCRYPTED && hasProtectedData) { - _hidl_cb(Status_V1_2::ERROR_DRM_CANNOT_HANDLE, 0, - "Protected ranges found in allegedly clear data."); - return Void(); - } - - // Decrypt - Status_V1_2 res = attemptDecrypt(params, hasProtectedData, &errorDetailMsg); - if (res != Status_V1_2::OK) { - _hidl_cb(res, 0, errorDetailMsg.c_str()); - return Void(); - } - - _hidl_cb(Status_V1_2::OK, totalSize, errorDetailMsg.c_str()); - return Void(); -} - -Status_V1_2 WVCryptoPlugin::attemptDecrypt( - const CdmDecryptionParametersV16& params, bool hasProtectedData, - std::string* errorDetailMsg) { - CdmResponseType res = mCDM->DecryptV16(mSessionId, hasProtectedData, - params); - - if (isCdmResponseTypeSuccess(res)) { - return Status_V1_2::OK; - } else { - ALOGE("Decrypt error in session %s during a sample %s protected data: %d", - mSessionId.c_str(), - hasProtectedData ? "with" : "without", - res); - switch (res) { - case wvcdm::INSUFFICIENT_CRYPTO_RESOURCES: - errorDetailMsg->assign( - "Error decrypting data: insufficient crypto resources"); - break; - case wvcdm::NEED_KEY: - case wvcdm::KEY_NOT_FOUND_IN_SESSION: - errorDetailMsg->assign( - "Error decrypting data: requested key has not been loaded"); - break; - case wvcdm::DECRYPT_NOT_READY: - errorDetailMsg->assign( - "Error decrypting data: license validity period is in the future"); - break; - case wvcdm::SESSION_NOT_FOUND_FOR_DECRYPT: - errorDetailMsg->assign( - "Error decrypting data: session not found, possibly reclaimed"); - break; - case wvcdm::DECRYPT_ERROR: - errorDetailMsg->assign( - "Error decrypting data: unspecified error"); - break; - case wvcdm::INSUFFICIENT_OUTPUT_PROTECTION: - case wvcdm::ANALOG_OUTPUT_ERROR: - errorDetailMsg->assign( - "Error decrypting data: insufficient output protection"); - break; - case wvcdm::KEY_PROHIBITED_FOR_SECURITY_LEVEL: - errorDetailMsg->assign( - "Error decrypting data: key prohibited for security level"); - break; - default: - break; - } - - return mapCdmResponseType(res); - } -} - -Return WVCryptoPlugin::getLogMessages(getLogMessages_cb _hidl_cb) { - const std::vector &logs(wvutil::g_logbuf.getLogs()); - _hidl_cb(::drm::V1_4::Status::OK, toHidlVec<::drm::V1_4::LogMessage>(logs)); - return Void(); -} - -} // namespace widevine -} // namespace V1_4 -} // namespace drm -} // namespace hardware -} // namespace wvdrm diff --git a/libwvdrmengine/mediacrypto/test/Android.mk b/libwvdrmengine/mediacrypto/test/Android.mk index fab60ef8..614055b0 100644 --- a/libwvdrmengine/mediacrypto/test/Android.mk +++ b/libwvdrmengine/mediacrypto/test/Android.mk @@ -4,56 +4,7 @@ LOCAL_PATH := $(call my-dir) # include $(CLEAR_VARS) -WV_UNITTESTS_BUILD_TARGET?= -ifeq ($(WV_UNITTESTS_BUILD_TARGET), hidl) - -LOCAL_SRC_FILES := \ - hidl/WVCryptoPlugin_test.cpp \ - -LOCAL_C_INCLUDES := \ - frameworks/av/include \ - frameworks/native/include \ - vendor/widevine/libwvdrmengine/cdm/core/include \ - vendor/widevine/libwvdrmengine/cdm/include \ - vendor/widevine/libwvdrmengine/cdm/metrics/include \ - vendor/widevine/libwvdrmengine/cdm/util/include \ - vendor/widevine/libwvdrmengine/include_hidl \ - vendor/widevine/libwvdrmengine/mediacrypto/include_hidl \ - vendor/widevine/libwvdrmengine/oemcrypto/include \ - -LOCAL_STATIC_LIBRARIES := \ - libcdm \ - libcdm_protos \ - libcdm_utils_hidl \ - libjsmn \ - libgmock \ - libgmock_main \ - libgtest \ - libwvlevel3 \ - libwvdrmcryptoplugin_hidl \ - libwv_odk \ - -LOCAL_SHARED_LIBRARIES := \ - android.hardware.drm@1.0 \ - android.hardware.drm@1.1 \ - android.hardware.drm@1.2 \ - android.hardware.drm@1.3 \ - android.hardware.drm@1.4 \ - android.hidl.memory@1.0 \ - libbase \ - libbinder \ - libcrypto \ - libcutils \ - libdl \ - libhidlbase \ - libhidlmemory \ - liblog \ - libprotobuf-cpp-lite \ - libutils \ - # build unit tests for Aidl -else - LOCAL_SRC_FILES := \ WVCryptoPlugin_hal_test.cpp \ @@ -92,9 +43,6 @@ LOCAL_SHARED_LIBRARIES := \ libprotobuf-cpp-lite \ libutils \ -# endif $(WV_UNITTESTS_BUILD_TARGET) -endif - LOCAL_HEADER_LIBRARIES := \ libstagefright_headers \ diff --git a/libwvdrmengine/mediacrypto/test/hidl/WVCryptoPlugin_test.cpp b/libwvdrmengine/mediacrypto/test/hidl/WVCryptoPlugin_test.cpp deleted file mode 100644 index 15a048f4..00000000 --- a/libwvdrmengine/mediacrypto/test/hidl/WVCryptoPlugin_test.cpp +++ /dev/null @@ -1,643 +0,0 @@ -// -// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary -// source code may only be used and distributed under the Widevine License -// Agreement. -// - -//#define LOG_NDEBUG 0 -#define LOG_TAG "WVCryptoPluginTest" -#include - -#include -#include -#include -#include - -#include -#include -#include - -#include "gmock/gmock.h" -#include "gtest/gtest.h" -#include "wv_cdm_constants.h" -#include "wv_cdm_types.h" -#include "wv_content_decryption_module.h" -#include "HidlTypes.h" -#include "OEMCryptoCENC.h" -#include "TypeConvert.h" -#include "WVCryptoPlugin.h" - -namespace wvdrm { -namespace hardware { -namespace drm { -namespace V1_4 { -namespace widevine { - -using ::android::MemoryDealer; - -using ::testing::_; -using ::testing::DefaultValue; -using ::testing::DoAll; -using ::testing::ElementsAreArray; -using ::testing::Field; -using ::testing::InSequence; -using ::testing::Matcher; -using ::testing::SetArgPointee; -using ::testing::StrictMock; -using ::testing::Test; -using ::testing::Truly; -using ::testing::Value; -using ::testing::internal::ElementsAreArrayMatcher; - -using wvcdm::kCipherModeCtr; -using wvcdm::kCipherModeCbc; -using wvcdm::CdmCipherMode; -using wvcdm::CdmDecryptionParametersV16; -using wvcdm::CdmDecryptionSample; -using wvcdm::CdmDecryptionSubsample; -using wvcdm::CdmQueryMap; -using wvcdm::CdmResponseType; -using wvcdm::CdmSessionId; -using wvcdm::KeyId; -using wvcdm::KEY_ID_SIZE; -using wvcdm::KEY_IV_SIZE; -using wvcdm::QUERY_KEY_SECURITY_LEVEL; -using wvcdm::QUERY_VALUE_SECURITY_LEVEL_L1; -using wvcdm::QUERY_VALUE_SECURITY_LEVEL_L3; - -class MockCDM : public wvcdm::WvContentDecryptionModule { - public: - MOCK_METHOD(bool, IsOpenSession, (const CdmSessionId&), (override)); - - MOCK_METHOD(CdmResponseType, DecryptV16, (const CdmSessionId&, bool, - const CdmDecryptionParametersV16&), (override)); - - MOCK_METHOD(CdmResponseType, QuerySessionStatus, (const CdmSessionId&, - CdmQueryMap*), (override)); -}; - -class WVCryptoPluginTest : public Test { - protected: - static const uint32_t kSessionIdSize = 16; - uint8_t* pDest = nullptr; - uint8_t* pSrc = nullptr; - uint8_t sessionId[kSessionIdSize]; - uint32_t nextBufferId = 0; - std::map heapBases; - - virtual void SetUp() { - FILE* fp = fopen("/dev/urandom", "r"); - fread(sessionId, sizeof(uint8_t), kSessionIdSize, fp); - fclose(fp); - - // Set default CdmResponseType value for gMock - DefaultValue::Set(wvcdm::NO_ERROR); - heapBases.clear(); - } - - void setHeapBase(WVCryptoPlugin& plugin, - const sp& heap) { - ASSERT_NE(heap, nullptr); - - void* heapBase = heap->getBase(); - ASSERT_NE(heapBase, nullptr); - - native_handle_t* nativeHandle = native_handle_create(1, 0); - ASSERT_NE(nativeHandle, nullptr); - - nativeHandle->data[0] = heap->getHeapID(); - - auto hidlHandle = hidl_handle(nativeHandle); - auto hidlMemory = hidl_memory("ashmem", hidlHandle, heap->getSize()); - heapBases.insert( - std::pair(heapBase, nextBufferId)); - Return hResult = - plugin.setSharedBufferBase(hidlMemory, nextBufferId++); - - ALOGE_IF(!hResult.isOk(), "setHeapBase failed setSharedBufferBase"); - } - - void toSharedBuffer(WVCryptoPlugin& plugin, - const sp& memory, - SharedBuffer* buffer) { - ssize_t offset; - size_t size; - - ASSERT_NE(memory, nullptr); - ASSERT_NE(buffer, nullptr); - - sp heap = memory->getMemory(&offset, &size); - ASSERT_NE(heap, nullptr); - - setHeapBase(plugin, heap); - buffer->bufferId = heapBases[heap->getBase()]; - buffer->offset = offset >= 0 ? offset : 0; - buffer->size = size; - } -}; - -TEST_F(WVCryptoPluginTest, CorrectlyReportsSecureBuffers) { - android::sp> cdm = new StrictMock(); - - CdmQueryMap l1Map; - l1Map[QUERY_KEY_SECURITY_LEVEL] = QUERY_VALUE_SECURITY_LEVEL_L1; - CdmQueryMap l3Map; - l3Map[QUERY_KEY_SECURITY_LEVEL] = QUERY_VALUE_SECURITY_LEVEL_L3; - - // Provide the expected behavior for IsOpenSession - EXPECT_CALL(*cdm, IsOpenSession(_)) - .WillRepeatedly(testing::Return(true)); - - // Specify the expected calls to QuerySessionStatus - EXPECT_CALL(*cdm, QuerySessionStatus(_, _)) - .WillOnce(DoAll(SetArgPointee<1>(l1Map), - testing::Return(wvcdm::NO_ERROR))) - .WillOnce(DoAll(SetArgPointee<1>(l3Map), - testing::Return(wvcdm::NO_ERROR))); - - WVCryptoPlugin plugin(sessionId, kSessionIdSize, cdm.get()); - - EXPECT_TRUE(plugin.requiresSecureDecoderComponent("video/mp4")) << - "WVCryptoPlugin incorrectly allows an insecure video decoder on L1"; - EXPECT_FALSE(plugin.requiresSecureDecoderComponent("video/mp4")) << - "WVCryptoPlugin incorrectly expects a secure video decoder on L3"; - EXPECT_FALSE(plugin.requiresSecureDecoderComponent("audio/aac")) << - "WVCryptoPlugin incorrectly expects a secure audio decoder"; -} - -// TODO(b/28295739): -// Add New MediaCrypto Unit Tests for CBC & Pattern Mode in cdmPatternDesc. - -// Predicate that validates that the fields of a passed-in -// CdmDecryptionParametersV16 match the values it was given at construction -// time. -// -// This could be done with a huge pile of gMock matchers, but it is ugly and -// unmaintainable, particularly once you get into validating the subsamples. The -// logic here is complex enough to warrant a custom matcher for this one test. -class CDPMatcher { - public: - // TODO(b/35259313): Uncomment the removed parameters once the matcher can - // convert them from HIDL accesses to physical addresses. - CDPMatcher(const uint8_t* keyId, bool isSecure, Mode cipherMode, - const Pattern& pattern, - const uint8_t* /* input */, size_t inputLength, - const uint8_t* /* output */, size_t outputLength, const uint8_t* iv, - const SubSample* subsamples, size_t subsamplesLength) - : mKeyId(keyId, keyId + KEY_ID_SIZE), mIsSecure(isSecure), - mCipherMode(cipherMode), mPattern(pattern), /* mInput(input), */ - mInputLength(inputLength), /* mOutput(output), */ - mOutputLength(outputLength), mIv(iv, iv + KEY_IV_SIZE), - mSubsamples(subsamples, subsamples + subsamplesLength) {} - - bool operator()(const CdmDecryptionParametersV16& params) const { - if (mCipherMode == Mode::AES_CTR && - params.cipher_mode != kCipherModeCtr) { - return false; - } else if (mCipherMode == Mode::AES_CBC && - params.cipher_mode != kCipherModeCbc) { - return false; - } - - if (params.key_id != mKeyId || - params.is_secure != mIsSecure || - params.pattern.encrypt_blocks != mPattern.encryptBlocks || - params.pattern.skip_blocks != mPattern.skipBlocks || - params.samples.size() != 1) { - return false; - } - - const CdmDecryptionSample& sample = params.samples[0]; - if (// TODO(b/35259313): Convert from a HIDL access to a physical address. - // sample.encrypt_buffer != mInput || - sample.encrypt_buffer_length != mInputLength || - // TODO(b/35259313): Convert from a HIDL access to a physical address. - // sample.decrypt_buffer != mOutput || - sample.decrypt_buffer_size != mOutputLength || - sample.decrypt_buffer_offset != 0 || - sample.iv != mIv || - sample.subsamples.size() != mSubsamples.size()) { - return false; - } - - for (size_t i = 0; i < mSubsamples.size(); ++i) { - const SubSample& androidSubsample = mSubsamples[i]; - const CdmDecryptionSubsample& cdmSubsample = sample.subsamples[i]; - - if (cdmSubsample.clear_bytes != androidSubsample.numBytesOfClearData || - cdmSubsample.protected_bytes != androidSubsample.numBytesOfEncryptedData) { - return false; - } - } - - return true; - } - - private: - const KeyId mKeyId; - const bool mIsSecure; - const Mode mCipherMode; - const Pattern mPattern; - // TODO(b/35259313): Uncomment this field once the matcher can convert this - // from a HIDL access to a physical address. - // const uint8_t* const mInput; - const size_t mInputLength; - // TODO(b/35259313): Uncomment this field once the matcher can convert this - // from a HIDL access to a physical address. - // const uint8_t* const mOutput; - const size_t mOutputLength; - const std::vector mIv; - const std::vector mSubsamples; -}; - -TEST_F(WVCryptoPluginTest, AttemptsToDecrypt) { - android::sp> cdm = new StrictMock(); - - constexpr size_t kSubSampleCount = 6; - SubSample subSamples[kSubSampleCount]; - memset(subSamples, 0, sizeof(subSamples)); - subSamples[0].numBytesOfEncryptedData = 16; - subSamples[1].numBytesOfClearData = 16; - subSamples[1].numBytesOfEncryptedData = 16; - subSamples[2].numBytesOfEncryptedData = 8; - subSamples[3].numBytesOfClearData = 29; - subSamples[3].numBytesOfEncryptedData = 24; - subSamples[4].numBytesOfEncryptedData = 60; - subSamples[5].numBytesOfEncryptedData = 16; - - std::vector subSamplesVector( - subSamples, subSamples + sizeof(subSamples) / sizeof(subSamples[0])); - auto hSubSamples = hidl_vec(subSamplesVector); - - uint8_t keyId[KEY_ID_SIZE]; - uint8_t iv[KEY_IV_SIZE]; - - static const size_t kDataSize = 185; - uint8_t inputData[kDataSize]; - - FILE* fp = fopen("/dev/urandom", "r"); - fread(keyId, sizeof(uint8_t), KEY_ID_SIZE, fp); - fread(iv, sizeof(uint8_t), KEY_IV_SIZE, fp); - fread(inputData, sizeof(uint8_t), kDataSize, fp); - fclose(fp); - - sp memDealer = new MemoryDealer( - kDataSize * 2, "WVCryptoPlugin_test"); - sp source = memDealer->allocate(kDataSize); - ASSERT_NE(source, nullptr); - pSrc = static_cast( - static_cast(source->unsecurePointer())); - ASSERT_NE(pSrc, nullptr); - memcpy(pSrc, inputData, source->size()); - - sp destination = memDealer->allocate(kDataSize); - ASSERT_NE(destination, nullptr); - pDest = static_cast( - static_cast(destination->unsecurePointer())); - ASSERT_NE(pDest, nullptr); - - Pattern noPattern = { 0, 0 }; - - // Provide the expected behavior for IsOpenSession - EXPECT_CALL(*cdm, IsOpenSession(_)) - .WillRepeatedly(testing::Return(true)); - - // Specify the expected calls to Decrypt - CDPMatcher paramsMatcher(keyId, false, Mode::AES_CTR, noPattern, pSrc, - kDataSize, pDest, kDataSize, iv, subSamples, - kSubSampleCount); - - EXPECT_CALL(*cdm, DecryptV16(ElementsAreArray(sessionId, kSessionIdSize), - true, - Truly(paramsMatcher))) - .Times(1); - - WVCryptoPlugin plugin(sessionId, kSessionIdSize, cdm.get()); - - uint32_t bytesWritten = 0; - std::string errorDetailMessage; - DestinationBuffer hDestination; - hDestination.type = BufferType::SHARED_MEMORY; - toSharedBuffer(plugin, destination, &hDestination.nonsecureMemory); - - SharedBuffer sourceBuffer; - toSharedBuffer(plugin, source, &sourceBuffer); - - plugin.decrypt( - false, hidl_array(keyId), hidl_array(iv), - Mode::AES_CTR, noPattern, hSubSamples, sourceBuffer, 0, hDestination, - [&](Status status, uint32_t hBytesWritten, hidl_string hDetailedError) { - EXPECT_EQ(status, Status::OK); - - bytesWritten = hBytesWritten; - errorDetailMessage.assign(hDetailedError.c_str()); - }); - - EXPECT_EQ(kDataSize, bytesWritten) << - "WVCryptoPlugin decrypted the wrong number of bytes"; - EXPECT_EQ(0u, errorDetailMessage.size()) << - "WVCryptoPlugin reported a detailed error message."; -} - -TEST_F(WVCryptoPluginTest, RejectsCens) { - android::sp> cdm = new StrictMock(); - - constexpr size_t kSubSampleCount = 2; - SubSample subSamples[kSubSampleCount]; - memset(subSamples, 0, sizeof(subSamples)); - subSamples[0].numBytesOfEncryptedData = 16; - subSamples[1].numBytesOfClearData = 16; - subSamples[1].numBytesOfEncryptedData = 16; - - std::vector subSamplesVector( - subSamples, subSamples + sizeof(subSamples) / sizeof(subSamples[0])); - auto hSubSamples = hidl_vec(subSamplesVector); - - uint8_t keyId[KEY_ID_SIZE]; - uint8_t iv[KEY_IV_SIZE]; - - static const size_t kDataSize = 48; - uint8_t inputData[kDataSize]; - - FILE* fp = fopen("/dev/urandom", "r"); - fread(keyId, sizeof(uint8_t), KEY_ID_SIZE, fp); - fread(iv, sizeof(uint8_t), KEY_IV_SIZE, fp); - fread(inputData, sizeof(uint8_t), kDataSize, fp); - fclose(fp); - - sp memDealer = new MemoryDealer( - kDataSize * 2, "WVCryptoPlugin_test"); - sp source = memDealer->allocate(kDataSize); - ASSERT_NE(source, nullptr); - pSrc = static_cast( - static_cast(source->unsecurePointer())); - ASSERT_NE(pSrc, nullptr); - memcpy(pSrc, inputData, source->size()); - - sp destination = memDealer->allocate(kDataSize); - ASSERT_NE(destination, nullptr); - pDest = static_cast( - static_cast(destination->unsecurePointer())); - ASSERT_NE(pDest, nullptr); - - Pattern recommendedPattern = { 1, 9 }; - - // Provide the expected behavior for IsOpenSession - EXPECT_CALL(*cdm, IsOpenSession(_)) - .WillRepeatedly(testing::Return(true)); - - // Refuse calls to Decrypt - EXPECT_CALL(*cdm, DecryptV16(_, _, _)) - .Times(0); - - WVCryptoPlugin plugin(sessionId, kSessionIdSize, cdm.get()); - - DestinationBuffer hDestination; - hDestination.type = BufferType::SHARED_MEMORY; - toSharedBuffer(plugin, destination, &hDestination.nonsecureMemory); - - SharedBuffer sourceBuffer; - toSharedBuffer(plugin, source, &sourceBuffer); - - plugin.decrypt( - false, hidl_array(keyId), hidl_array(iv), - Mode::AES_CTR, recommendedPattern, hSubSamples, sourceBuffer, 0, - hDestination, - [&](Status status, uint32_t bytesWritten, - hidl_string /* errorDetailMessage */) { - EXPECT_EQ(status, Status::BAD_VALUE); - EXPECT_EQ(bytesWritten, 0); - }); -} - -TEST_F(WVCryptoPluginTest, CommunicatesSecureBufferRequest) { - android::sp> cdm = new StrictMock(); - - uint8_t keyId[KEY_ID_SIZE]; - uint8_t iv[KEY_IV_SIZE]; - - static const size_t kDataSize = 32; - uint8_t in[kDataSize]; - - FILE* fp = fopen("/dev/urandom", "r"); - fread(keyId, sizeof(uint8_t), KEY_ID_SIZE, fp); - fread(iv, sizeof(uint8_t), KEY_IV_SIZE, fp); - fread(in, sizeof(uint8_t), kDataSize, fp); - fclose(fp); - - SubSample subSample; - subSample.numBytesOfClearData = 16; - subSample.numBytesOfEncryptedData = 16; - std::vector subSampleVector; - subSampleVector.push_back(subSample); - auto hSubSamples = hidl_vec(subSampleVector); - - // Provide the expected behavior for IsOpenSession - EXPECT_CALL(*cdm, IsOpenSession(_)) - .WillRepeatedly(testing::Return(true)); - - // Specify the expected calls to Decrypt - { - InSequence calls; - - typedef CdmDecryptionParametersV16 CDP; - - EXPECT_CALL(*cdm, DecryptV16(_, _, Field(&CDP::is_secure, false))) - .Times(1); - - EXPECT_CALL(*cdm, DecryptV16(_, _, Field(&CDP::is_secure, true))) - .Times(1); - } - - sp memDealer = new MemoryDealer( - kDataSize * 2, "WVCryptoPlugin_test"); - sp source = memDealer->allocate(kDataSize); - ASSERT_NE(source, nullptr); - pSrc = static_cast( - static_cast(source->unsecurePointer())); - ASSERT_NE(pSrc, nullptr); - memcpy(pSrc, in, source->size()); - - sp destination = memDealer->allocate(kDataSize); - ASSERT_NE(destination, nullptr); - pDest = static_cast( - static_cast(destination->unsecurePointer())); - ASSERT_NE(pDest, nullptr); - - WVCryptoPlugin plugin(sessionId, kSessionIdSize, cdm.get()); - - uint32_t bytesWritten = 0; - std::string errorDetailMessage; - DestinationBuffer hDestination; - hDestination.type = BufferType::SHARED_MEMORY; - toSharedBuffer(plugin, destination, &hDestination.nonsecureMemory); - Pattern noPattern = { 0, 0 }; - - SharedBuffer sourceBuffer; - toSharedBuffer(plugin, source, &sourceBuffer); - - plugin.decrypt( - false, hidl_array(keyId), hidl_array(iv), - Mode::AES_CTR, noPattern, hSubSamples, sourceBuffer, 0, hDestination, - [&](Status status, uint32_t hBytesWritten, hidl_string hDetailedError) { - EXPECT_EQ(status, Status::OK); - - bytesWritten = hBytesWritten; - errorDetailMessage.assign(hDetailedError.c_str()); - }); - - EXPECT_EQ(0u, errorDetailMessage.size()) << - "WVCryptoPlugin reported a detailed error message."; - - plugin.decrypt( - true, hidl_array(keyId), hidl_array(iv), - Mode::AES_CTR, noPattern, hSubSamples, sourceBuffer, 0, hDestination, - [&](Status status, uint32_t hBytesWritten, hidl_string hDetailedError) { - EXPECT_EQ(status, Status::OK); - - bytesWritten = hBytesWritten; - errorDetailMessage.assign(hDetailedError.c_str()); - }); - - EXPECT_EQ(0u, errorDetailMessage.size()) << - "WVCryptoPlugin reported a detailed error message."; -} - -TEST_F(WVCryptoPluginTest, AllowsSessionIdChanges) { - android::sp> cdm = new StrictMock(); - - uint8_t keyId[KEY_ID_SIZE]; - uint8_t iv[KEY_IV_SIZE]; - uint8_t sessionId2[kSessionIdSize]; - - static const size_t kDataSize = 32; - uint8_t in[kDataSize]; - - FILE* fp = fopen("/dev/urandom", "r"); - fread(keyId, sizeof(uint8_t), KEY_ID_SIZE, fp); - fread(iv, sizeof(uint8_t), KEY_IV_SIZE, fp); - fread(sessionId2, sizeof(uint8_t), kSessionIdSize, fp); - fread(in, sizeof(uint8_t), kDataSize, fp); - fclose(fp); - - SubSample subSample; - subSample.numBytesOfClearData = 16; - subSample.numBytesOfEncryptedData = 16; - std::vector subSampleVector; - subSampleVector.push_back(subSample); - auto hSubSamples = hidl_vec(subSampleVector); - - std::vector sessionIdVector(sessionId, sessionId + kSessionIdSize); - std::vector sessionId2Vector(sessionId2, - sessionId2 + kSessionIdSize); - - // Provide the expected behavior for IsOpenSession - EXPECT_CALL(*cdm, IsOpenSession(_)) - .WillRepeatedly(testing::Return(true)); - - // Specify the expected calls to Decrypt - { - InSequence calls; - - EXPECT_CALL(*cdm, - DecryptV16(ElementsAreArray(sessionId, kSessionIdSize), _, _)) - .Times(1); - - EXPECT_CALL(*cdm, - DecryptV16(ElementsAreArray(sessionId2, kSessionIdSize), _, _)) - .Times(1); - } - - sp memDealer = new MemoryDealer( - kDataSize * 2, "WVCryptoPlugin_test"); - sp source = memDealer->allocate(kDataSize); - ASSERT_NE(source, nullptr); - pSrc = static_cast( - static_cast(source->unsecurePointer())); - ASSERT_NE(pSrc, nullptr); - memcpy(pSrc, in, source->size()); - - sp destination = memDealer->allocate(kDataSize); - ASSERT_NE(destination, nullptr); - pDest = static_cast( - static_cast(destination->unsecurePointer())); - ASSERT_NE(pDest, nullptr); - - uint8_t blank[1]; // Some compilers will not accept 0. - WVCryptoPlugin plugin(blank, 0, cdm.get()); - - uint32_t bytesWritten = 0; - std::string errorDetailMessage; - DestinationBuffer hDestination; - hDestination.type = BufferType::SHARED_MEMORY; - toSharedBuffer(plugin, destination, &hDestination.nonsecureMemory); - Pattern noPattern = { 0, 0 }; - - SharedBuffer sourceBuffer; - toSharedBuffer(plugin, source, &sourceBuffer); - - Status status = plugin.setMediaDrmSession(sessionIdVector); - EXPECT_EQ(status, Status::OK); - - plugin.decrypt( - false, hidl_array(keyId), hidl_array(iv), - Mode::AES_CTR, noPattern, hSubSamples, sourceBuffer, 0, hDestination, - [&](Status status, uint32_t hBytesWritten, hidl_string hDetailedError) { - EXPECT_EQ(status, Status::OK); - - bytesWritten = hBytesWritten; - errorDetailMessage.assign(hDetailedError.c_str()); - }); - - EXPECT_EQ(0u, errorDetailMessage.size()) << - "WVCryptoPlugin reported a detailed error message."; - - status = plugin.setMediaDrmSession(sessionId2Vector); - EXPECT_EQ(status, Status::OK); - - plugin.decrypt( - false, hidl_array(keyId), hidl_array(iv), - Mode::AES_CTR, noPattern, hSubSamples, sourceBuffer, 0, hDestination, - [&](Status status, uint32_t hBytesWritten, hidl_string hDetailedError) { - EXPECT_EQ(status, Status::OK); - - bytesWritten = hBytesWritten; - errorDetailMessage.assign(hDetailedError.c_str()); - }); - - EXPECT_EQ(0u, errorDetailMessage.size()) << - "WVCryptoPlugin reported a detailed error message."; -} - -TEST_F(WVCryptoPluginTest, DisallowsUnopenedSessionIdChanges) { - android::sp> cdm = new StrictMock(); - - uint8_t blank[1]; // Some compilers will not accept 0. - std::vector sessionIdVector(sessionId, sessionId + kSessionIdSize); - - // Specify the expected calls to IsOpenSession - { - InSequence calls; - - EXPECT_CALL(*cdm, IsOpenSession(ElementsAreArray(blank, 0))) - .WillOnce(testing::Return(false)); - - EXPECT_CALL(*cdm, IsOpenSession(ElementsAreArray(sessionId, kSessionIdSize))) - .WillOnce(testing::Return(false)) - .WillOnce(testing::Return(true)); - } - - WVCryptoPlugin plugin(blank, 0, cdm.get()); - - Status status = plugin.setMediaDrmSession(sessionIdVector); - EXPECT_EQ(status, Status::ERROR_DRM_SESSION_NOT_OPENED); - - status = plugin.setMediaDrmSession(sessionIdVector); - EXPECT_EQ(status, Status::OK); -} - -} // namespace widevine -} // namespace V1_4 -} // namespace drm -} // namespace hardware -} // namespace wvdrm diff --git a/libwvdrmengine/mediadrm/Android.bp b/libwvdrmengine/mediadrm/Android.bp index ef9664dd..9952518e 100644 --- a/libwvdrmengine/mediadrm/Android.bp +++ b/libwvdrmengine/mediadrm/Android.bp @@ -22,52 +22,6 @@ package { default_applicable_licenses: ["vendor_widevine_license"], } -// Builds libwvdrmdrmplugin_hidl -// -cc_library_static { - name: "libwvdrmdrmplugin_hidl", - - srcs: [ - "src_hidl/WVDrmPlugin.cpp", - "src_hidl/WVGenericCryptoInterface.cpp", - "src_hidl/hidl_metrics_adapter.cpp", - ], - - include_dirs: [ - "frameworks/av/include", - "frameworks/native/include", - "vendor/widevine/libwvdrmengine/cdm/core/include", - "vendor/widevine/libwvdrmengine/cdm/include", - "vendor/widevine/libwvdrmengine/cdm/metrics/include", - "vendor/widevine/libwvdrmengine/cdm/util/include", - "vendor/widevine/libwvdrmengine/include_hidl", - "vendor/widevine/libwvdrmengine/include", - "vendor/widevine/libwvdrmengine/mediadrm/include_hidl", - "vendor/widevine/libwvdrmengine/oemcrypto/include", - ], - - header_libs: [ - "libstagefright_headers", - "libstagefright_foundation_headers", - "libutils_headers", - ], - - static_libs: ["libcdm_protos"], - - shared_libs: [ - "android.hardware.drm@1.0", - "android.hardware.drm@1.1", - "android.hardware.drm@1.2", - "android.hardware.drm@1.3", - "android.hardware.drm@1.4", - "android.hidl.memory@1.0", - "libcrypto", - "liblog", - ], - - proprietary: true, -} - // Builds libwvdrmdrmplugin_aidl // cc_library_static { diff --git a/libwvdrmengine/mediadrm/include/WVDrmPlugin.h b/libwvdrmengine/mediadrm/include/WVDrmPlugin.h index 5ace6611..c5fddb08 100644 --- a/libwvdrmengine/mediadrm/include/WVDrmPlugin.h +++ b/libwvdrmengine/mediadrm/include/WVDrmPlugin.h @@ -175,7 +175,7 @@ class WVDrmPlugin : public ::aidl::android::hardware::drm::BnDrmPlugin, const std::vector& in_signature, bool* _aidl_return) override; - // The following methods do not use hidl interface, it is used internally. + // The following methods do not use HAL interface, it is used internally. virtual Status unprovisionDevice(); virtual void OnSessionRenewalNeeded(const CdmSessionId& cdmSessionId); diff --git a/libwvdrmengine/mediadrm/include_hidl/WVDrmPlugin.h b/libwvdrmengine/mediadrm/include_hidl/WVDrmPlugin.h deleted file mode 100644 index 5709960d..00000000 --- a/libwvdrmengine/mediadrm/include_hidl/WVDrmPlugin.h +++ /dev/null @@ -1,510 +0,0 @@ -// -// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary -// source code may only be used and distributed under the Widevine License -// Agreement. -// - -#ifndef WV_DRM_PLUGIN_H_ -#define WV_DRM_PLUGIN_H_ - -#include - -#include -#include - -#include "HidlTypes.h" -#include "HidlWVTypes.h" -#include "OEMCryptoCENC.h" -#include "WVGenericCryptoInterface.h" -#include "cdm_client_property_set.h" -#include "cdm_identifier.h" -#include "log.h" -#include "wv_cdm_event_listener.h" -#include "wv_content_decryption_module.h" - -namespace wvdrm { -namespace hardware { -namespace drm { -namespace V1_4 { -namespace widevine { - -using android::Mutex; -using std::map; -using wvcdm::CdmIdentifier; -using wvcdm::CdmKeyStatusMap; -using wvcdm::CdmResponseType; -using wvcdm::CdmSessionId; -using wvcdm::WvContentDecryptionModule; - -const OEMCrypto_Algorithm kInvalidCryptoAlgorithm = - static_cast(-1); - -struct WVDrmPlugin : public ::drm::V1_4::IDrmPlugin, - IDrmPluginListener, - wvcdm::WvCdmEventListener { - WVDrmPlugin(const sp& cdm, - const std::string& appPackageName, - WVGenericCryptoInterface* crypto, bool useSpoid); - - virtual ~WVDrmPlugin(); - - void Close(); - - Return openSession(openSession_cb _hidl_cb) override; - - Return openSession_1_1(SecurityLevel securityLevel, - openSession_1_1_cb _hidl_cb) override; - - Return closeSession(const hidl_vec& sessionId) override; - - Return getKeyRequest(const hidl_vec& scope, - const hidl_vec& initData, - const hidl_string& mimeType, KeyType keyType, - const hidl_vec& optionalParameters, - getKeyRequest_cb _hidl_cb) override; - - Return getKeyRequest_1_1(const hidl_vec& scope, - const hidl_vec& initData, - const hidl_string& mimeType, KeyType keyType, - const hidl_vec& optionalParameters, - getKeyRequest_1_1_cb _hidl_cb) override; - - Return getKeyRequest_1_2(const hidl_vec& scope, - const hidl_vec& initData, - const hidl_string& mimeType, KeyType keyType, - const hidl_vec& optionalParameters, - getKeyRequest_1_2_cb _hidl_cb) override; - - Return provideKeyResponse(const hidl_vec& scope, - const hidl_vec& response, - provideKeyResponse_cb _hidl_cb) override; - - Return removeKeys(const hidl_vec& sessionId) override; - - Return restoreKeys(const hidl_vec& sessionId, - const hidl_vec& keySetId) override; - - Return queryKeyStatus(const hidl_vec& sessionId, - queryKeyStatus_cb _hidl_cb) override; - - Return getProvisionRequest(const hidl_string& certificateType, - const hidl_string& certificateAuthority, - getProvisionRequest_cb _hidl_cb) override; - - Return getProvisionRequest_1_2( - const hidl_string& certificateType, - const hidl_string& certificateAuthority, - getProvisionRequest_1_2_cb _hidl_cb) override; - - Return provideProvisionResponse( - const hidl_vec& response, - provideProvisionResponse_cb _hidl_cb) override; - - Return getSecureStops(getSecureStops_cb _hidl_cb) override; - - Return getSecureStop(const hidl_vec& secureStopId, - getSecureStop_cb _hidl_cb) override; - - Return releaseAllSecureStops() override; - - Return releaseSecureStop( - const hidl_vec& secureStopId) override; - - Return getMetrics(getMetrics_cb _hidl_cb); - - Return getSecureStopIds(getSecureStopIds_cb _hidl_cb) override; - - Return releaseSecureStops( - const SecureStopRelease& ssRelease) override; - - Return removeSecureStop( - const hidl_vec& secureStopId) override; - - Return removeAllSecureStops() override; - - Return getHdcpLevels(getHdcpLevels_cb _hidl_cb) override; - Return getHdcpLevels_1_2(getHdcpLevels_1_2_cb _hidl_cb) override; - - Return getNumberOfSessions(getNumberOfSessions_cb _hidl_cb) override; - - Return getSecurityLevel(const hidl_vec& sessionId, - getSecurityLevel_cb _hidl_cb) override; - - Return getOfflineLicenseKeySetIds( - getOfflineLicenseKeySetIds_cb _hidl_cb) override; - - Return removeOfflineLicense(const KeySetId& keySetId) override; - - Return getOfflineLicenseState( - const KeySetId& keySetId, getOfflineLicenseState_cb _hidl_cb) override; - - Return getPropertyString(const hidl_string& propertyName, - getPropertyString_cb _hidl_cb) override; - - Return getPropertyByteArray(const hidl_string& propertyName, - getPropertyByteArray_cb _hidl_cb) override; - - Return setPropertyString(const hidl_string& propertyName, - const hidl_string& value) override; - - Return setPropertyByteArray(const hidl_string& propertyName, - const hidl_vec& value) override; - - Return setCipherAlgorithm(const hidl_vec& sessionId, - const hidl_string& algorithm) override; - - Return setMacAlgorithm(const hidl_vec& sessionId, - const hidl_string& algorithm) override; - - Return encrypt(const hidl_vec& sessionId, - const hidl_vec& keyId, - const hidl_vec& input, - const hidl_vec& iv, - encrypt_cb _hidl_cb) override; - - Return decrypt(const hidl_vec& sessionId, - const hidl_vec& keyId, - const hidl_vec& input, - const hidl_vec& iv, - decrypt_cb _hidl_cb) override; - - Return sign(const hidl_vec& sessionId, - const hidl_vec& keyId, - const hidl_vec& message, - sign_cb _hidl_cb) override; - - Return verify(const hidl_vec& sessionId, - const hidl_vec& keyId, - const hidl_vec& message, - const hidl_vec& signature, - verify_cb _hidl_cb) override; - - Return signRSA(const hidl_vec& sessionId, - const hidl_string& algorithm, - const hidl_vec& message, - const hidl_vec& wrappedkey, - signRSA_cb _hidl_cb) override; - - Return setListener(const sp& listener) override; - - Return sendEvent(EventType eventType, - const hidl_vec& sessionId, - const hidl_vec& data) override; - - Return sendExpirationUpdate(const hidl_vec& sessionId, - int64_t expiryTimeInMS) override; - - Return sendKeysChange(const hidl_vec& sessionId, - const hidl_vec& keyStatusList, - bool hasNewUsableKey) override; - - Return sendKeysChange_1_2(const hidl_vec& sessionId, - const hidl_vec& keyStatusList, - bool hasNewUsableKey) override; - - Return sendSessionLostState( - const hidl_vec& sessionId) override; - - Return getLogMessages(getLogMessages_cb _hidl_cb) override; - - Return requiresSecureDecoder(const hidl_string& mime, - SecurityLevel level) override; - - Return requiresSecureDecoderDefault(const hidl_string& mime) override; - - Return<::drm::V1_0::Status> setPlaybackId( - const hidl_vec& sessionId, - const hidl_string& playbackId) override; - - // The following methods do not use hidl interface, it is used internally. - virtual Status unprovisionDevice(); - - virtual void OnSessionRenewalNeeded(const CdmSessionId& cdmSessionId); - - template - void _sendKeysChange(const hidl_vec& sessionId, - const hidl_vec& keyStatusList, bool hasNewUsableKey); - - template - void _OnSessionKeysChange(const CdmSessionId&, const CdmKeyStatusMap&, - bool hasNewUsableKey); - - virtual void OnSessionKeysChange(const CdmSessionId& cdmSessionId, - const CdmKeyStatusMap& cdmKeysStatus, - bool hasNewUsableKey); - - virtual void OnExpirationUpdate(const CdmSessionId& cdmSessionId, - int64_t newExpiryTimeSeconds); - - virtual void OnSessionLostState(const CdmSessionId& cdmSessionId); - - private: - WVDRM_DISALLOW_COPY_AND_ASSIGN_AND_NEW(WVDrmPlugin); - - // List this field first so it is destructed last; ensure logging uid - // is cleared right before plugin is destructed. - wvutil::LoggingUidSetter mLoggingUidSetter; - - struct CryptoSession { - public: - CryptoSession() - : mOecSessionId(-1), - mCipherAlgorithm(kInvalidCryptoAlgorithm), - mMacAlgorithm(kInvalidCryptoAlgorithm) {} - - CryptoSession(OEMCrypto_SESSION sessionId) - : mOecSessionId(sessionId), - mCipherAlgorithm(kInvalidCryptoAlgorithm), - mMacAlgorithm(kInvalidCryptoAlgorithm) {} - - OEMCrypto_SESSION oecSessionId() const { return mOecSessionId; } - - OEMCrypto_Algorithm cipherAlgorithm() const { return mCipherAlgorithm; } - - void setCipherAlgorithm(OEMCrypto_Algorithm newAlgorithm) { - mCipherAlgorithm = newAlgorithm; - } - - OEMCrypto_Algorithm macAlgorithm() const { return mMacAlgorithm; } - - void setMacAlgorithm(OEMCrypto_Algorithm newAlgorithm) { - mMacAlgorithm = newAlgorithm; - } - - private: - OEMCrypto_SESSION mOecSessionId; - OEMCrypto_Algorithm mCipherAlgorithm; - OEMCrypto_Algorithm mMacAlgorithm; - }; - - class WVClientPropertySet : public wvcdm::CdmClientPropertySet { - public: - WVClientPropertySet() - : mUsePrivacyMode(false), - mShareKeys(false), - mSessionSharingId(0), - mUseAtscMode(false) {} - - virtual ~WVClientPropertySet() {} - - virtual const std::string& security_level() const { return mSecurityLevel; } - - void set_security_level(const std::string& securityLevel) { - mSecurityLevel = securityLevel; - } - - virtual bool use_privacy_mode() const { return mUsePrivacyMode; } - - void set_use_privacy_mode(bool usePrivacyMode) { - mUsePrivacyMode = usePrivacyMode; - } - - virtual const std::string& service_certificate() const { - return mServiceCertificate; - } - - virtual void set_service_certificate( - const std::string& serviceCertificate) { - mServiceCertificate = serviceCertificate; - } - - virtual const std::string& device_provisioning_service_certificate() const { - // Android does not support service certificates for provisioning. - return mEmptyString; - } - - virtual void set_device_provisioning_service_certificate( - const std::string&) { - // Ignore. Android does not support service certificates for provisioning - // TODO(b/69562876): Android SHOULD support service cert for provisioning - } - - virtual bool is_session_sharing_enabled() const { return mShareKeys; } - - void set_is_session_sharing_enabled(bool shareKeys) { - mShareKeys = shareKeys; - } - - virtual uint32_t session_sharing_id() const { return mSessionSharingId; } - - virtual void set_session_sharing_id(uint32_t id) { mSessionSharingId = id; } - - virtual const std::string& app_id() const { return mAppId; } - - void set_app_id(const std::string& appId) { mAppId = appId; } - - virtual bool use_atsc_mode() const { return mUseAtscMode; } - - void set_use_atsc_mode(bool useAtscMode) { mUseAtscMode = useAtscMode; } - - private: - DISALLOW_EVIL_CONSTRUCTORS(WVClientPropertySet); - - std::string mSecurityLevel; - bool mUsePrivacyMode; - std::string mServiceCertificate; - bool mShareKeys; - uint32_t mSessionSharingId; - std::string mAppId; - bool mUseAtscMode; - const std::string mEmptyString; - } mPropertySet; - - class CdmIdentifierBuilder { - public: - CdmIdentifierBuilder(bool useSpoid, const WVDrmPlugin& parent, - const std::string& appPackageName); - - // Fills in the passed-in struct with the CDM Identifier for the current - // combination of Origin, Application, and Device. This is needed by some - // calls into the CDM in order to identify which CDM instance should receive - // the call. Calling this will seal the CDM Identifier Builder, thus making - // it an error to change the origin. - Status getCdmIdentifier(CdmIdentifier* identifier); - - // Gets the application-safe device-unique ID. On non-SPOID devices, this is - // the device-unique ID from OEMCrypto. On SPOID devices, this is the SPOID. - // On SPOID devices, calling this will seal the CDM Identifier Builder, thus - // making it an error to change the origin. - Status getDeviceUniqueId(std::string* id); - Status getProvisioningUniqueId(std::string* id); - - const std::string& origin() const { return mCdmIdentifier.origin; } - bool set_origin(const std::string& id); - - // This sets the app package name to allow apps to access ATSC licenses - bool set_use_atsc_mode(bool enable); - - // Indicates whether the builder can still be modified. This returns false - // until a call to getCdmIdentifier. - bool is_sealed() { return mIsIdentifierSealed; } - - uint32_t user_id() const { return mCdmIdentifier.user_id; } - - private: - WVDRM_DISALLOW_COPY_AND_ASSIGN(CdmIdentifierBuilder); - - CdmIdentifier mCdmIdentifier; - bool mIsIdentifierSealed; - - bool mUseSpoid; - std::string mAppPackageName; - const WVDrmPlugin& mParent; - - Status calculateSpoid(); - Status calculateSpoid(const std::string& deviceID, std::string* spoid); - - // Gets the device-unique ID from OEMCrypto. This must be private, since - // this value must not be exposed to applications on SPOID devices. Code - // outside this class should use getDeviceUniqueId() to get the - // application-safe device-unique ID. - Status getOemcryptoDeviceId(std::string* id); - Status getOemcryptoDeviceId(wvcdm::RequestedSecurityLevel securityLevel, - std::string* id); - - // The unique identifier is meant to ensure that two clients with the - // same spoid, origin and app package name still get different cdm engine - // instances. This is a stepping stone to simplifying the implementation. - // Note that we do not have a lock or mutex around this object. We assume - // that locking is handled external to this object. - uint32_t getNextUniqueId(); - } mCdmIdentifierBuilder; - - // Properly close plugins on SIGTERM then exit - class Terminator { - public: - static void Register(WVDrmPlugin* plugin) { instance().DoRegister(plugin); } - static void Forget(WVDrmPlugin* plugin) { instance().DoForget(plugin); } - static void Terminate(int /*signal*/) { instance().DoTerminate(); } - - private: - WVDRM_DISALLOW_COPY_AND_ASSIGN(Terminator); - - Terminator() { signal(SIGTERM, Terminate); } - - static Terminator& instance() { - static Terminator instance; - return instance; - } - - void DoRegister(WVDrmPlugin* plugin) { - Mutex::Autolock lock(mLock); - mPlugins.push_back(plugin); - } - - void DoForget(WVDrmPlugin* plugin) { - Mutex::Autolock lock(mLock); - mPlugins.remove(plugin); - } - - void DoTerminate() { - Mutex::Autolock lock(mLock); - for_each(mPlugins.begin(), mPlugins.end(), [] (WVDrmPlugin* plugin) { - ALOGI("WVDrmPlugin::Terminating plugin %p", (void*)plugin); - plugin->Close(); - }); - exit(0); - } - - std::list mPlugins; - Mutex mLock; - }; - - sp const mCDM; - WVGenericCryptoInterface* mCrypto; - map mCryptoSessions; - sp mListener; - sp mListenerV1_2; - - std::string mProvisioningServiceCertificate; - - wvcdm::CdmSessionId mDecryptHashSessionId; - - std::string mAppPackageName; - - Status queryProperty(const std::string& property, - std::string& stringValue) const; - - Status queryProperty(wvcdm::RequestedSecurityLevel securityLevel, - const std::string& property, - std::string& stringValue) const; - - Status queryProperty(const std::string& property, - std::vector& vector_value) const; - - bool isProvisioned(wvcdm::CdmSecurityLevel securityLevel, - const std::string& origin, const std::string& spoid, - bool atsc_mode_enabled) const; - - Status mapAndNotifyOfCdmResponseType(const std::vector& sessionId, - CdmResponseType res); - - Status_V1_2 mapAndNotifyOfCdmResponseType_1_2( - const std::vector& sessionId, CdmResponseType res); - - void notifyOfCdmResponseType(const std::vector& sessionId, - CdmResponseType res); - - Status mapAndNotifyOfOEMCryptoResult(const std::vector& sessionId, - OEMCryptoResult res); - - Status mapOEMCryptoResult(OEMCryptoResult res); - - SecurityLevel mapSecurityLevel(const std::string& level); - - wvcdm::RequestedSecurityLevel getRequestedSecurityLevel() const; - - Status openSessionCommon(std::vector& sessionId); - - bool initDataResemblesPSSH(const std::vector& initData); - - Status unprovision(const CdmIdentifier& identifier); -}; - -} // namespace widevine -} // namespace V1_4 -} // namespace drm -} // namespace hardware -} // namespace wvdrm - -#endif // WV_DRM_PLUGIN_H_ diff --git a/libwvdrmengine/mediadrm/include_hidl/WVGenericCryptoInterface.h b/libwvdrmengine/mediadrm/include_hidl/WVGenericCryptoInterface.h deleted file mode 100644 index 989fc991..00000000 --- a/libwvdrmengine/mediadrm/include_hidl/WVGenericCryptoInterface.h +++ /dev/null @@ -1,98 +0,0 @@ -// -// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary -// source code may only be used and distributed under the Widevine License -// Agreement. -// - -#ifndef WV_GENERIC_CRYPTO_INTERFACE_H_ -#define WV_GENERIC_CRYPTO_INTERFACE_H_ - -#include -#include - -#include "OEMCryptoCENC.h" -#include "media/stagefright/foundation/ABase.h" - -namespace wvdrm { - -class WVGenericCryptoInterface { - public: - WVGenericCryptoInterface() {} - virtual ~WVGenericCryptoInterface() {} - - virtual OEMCryptoResult selectKey(const OEMCrypto_SESSION session, - const uint8_t* key_id, - size_t key_id_length) { - return OEMCrypto_SelectKey(session, key_id, key_id_length, - OEMCrypto_CipherMode_CBCS); - } - - virtual OEMCryptoResult encrypt(OEMCrypto_SESSION session, - const uint8_t* in_buffer, - size_t buffer_length, const uint8_t* iv, - OEMCrypto_Algorithm algorithm, - uint8_t* out_buffer) { - return OEMCrypto_Generic_Encrypt(session, in_buffer, buffer_length, iv, - algorithm, out_buffer); - } - - virtual OEMCryptoResult decrypt(OEMCrypto_SESSION session, - const uint8_t* in_buffer, - size_t buffer_length, const uint8_t* iv, - OEMCrypto_Algorithm algorithm, - uint8_t* out_buffer) { - return OEMCrypto_Generic_Decrypt(session, in_buffer, buffer_length, iv, - algorithm, out_buffer); - } - - virtual OEMCryptoResult sign(OEMCrypto_SESSION session, - const uint8_t* in_buffer, size_t buffer_length, - OEMCrypto_Algorithm algorithm, - uint8_t* signature, size_t* signature_length) { - return OEMCrypto_Generic_Sign(session, in_buffer, buffer_length, algorithm, - signature, signature_length); - } - - virtual OEMCryptoResult verify(OEMCrypto_SESSION session, - const uint8_t* in_buffer, size_t buffer_length, - OEMCrypto_Algorithm algorithm, - const uint8_t* signature, - size_t signature_length) { - return OEMCrypto_Generic_Verify(session, in_buffer, buffer_length, - algorithm, signature, signature_length); - } - - virtual OEMCryptoResult signRSA(const uint8_t* wrapped_rsa_key, - size_t wrapped_rsa_key_length, - const uint8_t* message, - size_t message_length, - std::vector& signature, - RSA_Padding_Scheme padding_scheme); - - - virtual OEMCryptoResult loadDeviceRSAKey(OEMCrypto_SESSION session, - const uint8_t* wrapped_rsa_key, - size_t wrapped_rsa_key_length) { - return OEMCrypto_LoadDRMPrivateKey(session, OEMCrypto_RSA_Private_Key, - wrapped_rsa_key, wrapped_rsa_key_length); - } - - virtual OEMCryptoResult generateRSASignature( - OEMCrypto_SESSION session, - const uint8_t* message, - size_t message_length, - uint8_t* signature, - size_t* signature_length, - RSA_Padding_Scheme padding_scheme) { - return OEMCrypto_GenerateRSASignature(session, message, message_length, - signature, signature_length, - padding_scheme); -} - - private: - DISALLOW_EVIL_CONSTRUCTORS(WVGenericCryptoInterface); -}; - -} // namespace wvdrm - -#endif // WV_GENERIC_CRYPTO_INTERFACE_H_ diff --git a/libwvdrmengine/mediadrm/include_hidl/hidl_metrics_adapter.h b/libwvdrmengine/mediadrm/include_hidl/hidl_metrics_adapter.h deleted file mode 100644 index f35b4589..00000000 --- a/libwvdrmengine/mediadrm/include_hidl/hidl_metrics_adapter.h +++ /dev/null @@ -1,113 +0,0 @@ -// -// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary -// source code may only be used and distributed under the Widevine License -// Agreement. -// - -#ifndef CDM_HIDL_METRICS_ADAPTER_H_ -#define CDM_HIDL_METRICS_ADAPTER_H_ - -#include - -#include - -#include "wv_metrics.pb.h" - -namespace wvcdm { - -// Convenience alias. Used only in the declaration of HidlMetricsGroup. -namespace internal { -using DrmMetricGroup = android::hardware::drm::V1_1::DrmMetricGroup; -} // namespace internal - -class HidlMetricsAdapter; - -// This class is used to convert from the metrics.proto format for metrics -// to the format specified in the android.hardware.drm@1.1 DrmMetricGroup -// type. This class converts the common metric types into a single group. -// -// Example: -// drm_metrics::DistributionMetric distribution; -// distribution.set_operation_count(1); -// HidlMetricsGroupBuilder builder; -// builder.AddDistributions("test distribution", { distribution }); -// -// DrmMetricGroup group = builder.Build(); -class HidlMetricsGroupBuilder { - public: - // Adds a group of distributions with the given base name. - void AddDistributions( - const std::string& name, - const google::protobuf::RepeatedPtrField< - drm_metrics::DistributionMetric>& distributions); - - // Adds a group of counter metrics with the given base name. - void AddCounters( - const std::string& name, - const google::protobuf::RepeatedPtrField< - drm_metrics::CounterMetric>& counters); - - // Adds a value metric. - void AddValue(const std::string& name, - const drm_metrics::ValueMetric& value_or_error); - - // Builds the metric group containing all of the previously added metrics. - internal::DrmMetricGroup Build(); - - private: - friend class HidlMetricsAdapter; - std::vector metrics_; - - HidlMetricsGroupBuilder(); - // Adds a distribution with the given name and distribution values. - void AddDistribution(const std::string& name, - const drm_metrics::DistributionMetric& distribution); - // Adds a counter metric - void AddCounter(const std::string& name, - const drm_metrics::CounterMetric& counter); - void AddAttributes( - const drm_metrics::Attributes& attributes_proto, - ::android::hardware::hidl_vec* - attributes); -}; - -// This class handles adding the engine and session metric collections. This -// will generate one DrmMetricGroup for each EngineMetric added and one for -// each SessionMetric added. This class also supports a static utility method to -// convert a WvCdmMetrics proto to a vector of DrmMetricGroup instances. -class HidlMetricsAdapter { - public: - // Utility method to quickly convert a WvCdmMetrics proto to a DrmMetricGroup - // vector. - static void ToHidlMetrics( - const drm_metrics::WvCdmMetrics& proto_metrics, - android::hardware::hidl_vec* hidl_metrics); - - HidlMetricsAdapter(); - ~HidlMetricsAdapter(); - - // Adds the EngineMetrics instance to the Adapter. It will be converted and - // stored. The converted metrics can be fetched via GetHidlGroupVector. - void AddEngineMetrics( - const drm_metrics::WvCdmMetrics::EngineMetrics& proto_metrics); - - // Adds the SessionMetrics instance to the Adapter. It will be converted and - // stored. The converted metrics can be fetched via GetHidlGroupVector. - void AddSessionMetrics( - const drm_metrics::WvCdmMetrics::SessionMetrics& proto_metrics); - - // Returns the converted DrmMetricGroup vector containing all of the - // previously added engine and session metrics collections. - const android::hardware::hidl_vec - GetHidlGroupVector(); - - private: - void AddCryptoMetrics( - const drm_metrics::WvCdmMetrics::CryptoMetrics& proto_metrics, - HidlMetricsGroupBuilder* group_builder); - std::vector group_vector_; -}; - -} // namespace wvcdm - -#endif // CDM_HIDL_METRICS_ADAPTER_H_ diff --git a/libwvdrmengine/mediadrm/src_hidl/WVDrmPlugin.cpp b/libwvdrmengine/mediadrm/src_hidl/WVDrmPlugin.cpp deleted file mode 100644 index 39073f42..00000000 --- a/libwvdrmengine/mediadrm/src_hidl/WVDrmPlugin.cpp +++ /dev/null @@ -1,2364 +0,0 @@ -// -// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary -// source code may only be used and distributed under the Widevine License -// Agreement. -// - -//#define LOG_NDEBUG 0 -#define LOG_TAG "WVCdm" -#include "WVDrmPlugin.h" - -#include -#include -#include - -#include -#include -#include -#include - -#include "HidlMapErrors-inl.h" -#include "HidlTypes.h" -#include "TypeConvert.h" -#include "android-base/macros.h" -#include "hidl_metrics_adapter.h" -#include "log.h" -#include "media/stagefright/MediaErrors.h" -#include "openssl/sha.h" -#include "wv_cdm_constants.h" -#include "wv_metrics.pb.h" - -namespace { - -static const char* const kResetSecurityLevel = ""; -static const char* const kEnable = "enable"; -static const char* const kDisable = "disable"; -static const std::string kPsshTag = "pssh"; -static const char* const kSpecialUnprovisionResponse = "unprovision"; -static const std::string kKeyAppPackageName = "application_name"; -static const std::string kKeyOrigin = "origin"; - -} // namespace - -namespace wvdrm { -namespace hardware { -namespace drm { -namespace V1_4 { -namespace widevine { - -using android::hardware::drm::V1_2::widevine::toHidlVec; -using android::hardware::drm::V1_2::widevine::toVector; -using wvcdm::CdmAppParameterMap; -using wvcdm::CdmCertificateType; -using wvcdm::CdmInitData; -using wvcdm::CdmKeyRequest; -using wvcdm::CdmKeyRequestType; -using wvcdm::CdmKeyResponse; -using wvcdm::CdmKeySetId; -using wvcdm::CdmKeyStatus; -using wvcdm::CdmLicenseType; -using wvcdm::CdmProvisioningRequest; -using wvcdm::CdmProvisioningResponse; -using wvcdm::CdmQueryMap; -using wvcdm::CdmSecureStopId; -using wvcdm::CdmSecurityLevel; -using wvcdm::CdmUsageInfo; -using wvcdm::CdmUsageInfoReleaseMessage; -using wvcdm::kDefaultCdmIdentifier; -using wvcdm::KeyId; - -namespace { - -std::vector StrToVector(const std::string& str) { - std::vector vec(str.begin(), str.end()); - return vec; -} - -KeyRequestType ConvertFromCdmKeyRequestType(CdmKeyRequestType keyRequestType) { - switch (keyRequestType) { - case wvcdm::kKeyRequestTypeInitial: - return KeyRequestType::INITIAL; - case wvcdm::kKeyRequestTypeRenewal: - return KeyRequestType::RENEWAL; - case wvcdm::kKeyRequestTypeRelease: - return KeyRequestType::RELEASE; - default: - return KeyRequestType::UNKNOWN; - } -} - -KeyRequestType_V1_1 ConvertFromCdmKeyRequestType_1_1( - CdmKeyRequestType keyRequestType) { - switch (keyRequestType) { - case wvcdm::kKeyRequestTypeNone: - return KeyRequestType_V1_1::NONE; - case wvcdm::kKeyRequestTypeUpdate: - return KeyRequestType_V1_1::UPDATE; - default: - return static_cast( - ConvertFromCdmKeyRequestType(keyRequestType)); - } -} - -KeyRequestType toKeyRequestType_V1_0(KeyRequestType_V1_1 keyRequestType) { - switch (keyRequestType) { - case KeyRequestType_V1_1::NONE: - case KeyRequestType_V1_1::UPDATE: - return KeyRequestType::UNKNOWN; - default: - return static_cast(keyRequestType); - } -} - -Status toStatus_1_0(Status_V1_2 status) { - switch (status) { - case Status_V1_2::ERROR_DRM_INSUFFICIENT_SECURITY: - case Status_V1_2::ERROR_DRM_FRAME_TOO_LARGE: - case Status_V1_2::ERROR_DRM_SESSION_LOST_STATE: - case Status_V1_2::ERROR_DRM_RESOURCE_CONTENTION: - return Status::ERROR_DRM_UNKNOWN; - default: - return static_cast(status); - } -} - -template -KST ConvertFromCdmKeyStatus(CdmKeyStatus keyStatus); - -template <> -KeyStatusType ConvertFromCdmKeyStatus(CdmKeyStatus keyStatus) { - switch (keyStatus) { - case wvcdm::kKeyStatusUsable: - return KeyStatusType::USABLE; - case wvcdm::kKeyStatusExpired: - return KeyStatusType::EXPIRED; - case wvcdm::kKeyStatusOutputNotAllowed: - return KeyStatusType::OUTPUTNOTALLOWED; - case wvcdm::kKeyStatusPending: - case wvcdm::kKeyStatusUsableInFuture: - return KeyStatusType::STATUSPENDING; - case wvcdm::kKeyStatusInternalError: - default: - return KeyStatusType::INTERNALERROR; - } -} - -template <> -KeyStatusType_V1_2 ConvertFromCdmKeyStatus( - CdmKeyStatus keyStatus) { - switch (keyStatus) { - case wvcdm::kKeyStatusUsableInFuture: - return KeyStatusType_V1_2::USABLEINFUTURE; - default: - return static_cast( - ConvertFromCdmKeyStatus(keyStatus)); - } -} - -HdcpLevel mapHdcpLevel(const std::string& level) { - if (level == wvcdm::QUERY_VALUE_HDCP_V1) - return HdcpLevel::HDCP_V1; - else if (level == wvcdm::QUERY_VALUE_HDCP_V2_0) - return HdcpLevel::HDCP_V2; - else if (level == wvcdm::QUERY_VALUE_HDCP_V2_1) - return HdcpLevel::HDCP_V2_1; - else if (level == wvcdm::QUERY_VALUE_HDCP_V2_2) - return HdcpLevel::HDCP_V2_2; - else if (level == wvcdm::QUERY_VALUE_HDCP_NONE) - return HdcpLevel::HDCP_NONE; - else if (level == wvcdm::QUERY_VALUE_HDCP_NO_DIGITAL_OUTPUT) - return HdcpLevel::HDCP_NO_OUTPUT; - else { - ALOGE("Invalid HDCP level=%s", level.c_str()); - return HdcpLevel::HDCP_NONE; - } -} - -HdcpLevel_V1_2 mapHdcpLevel_1_2(const std::string level) { - if (level == wvcdm::QUERY_VALUE_HDCP_V2_3) { - return HdcpLevel_V1_2::HDCP_V2_3; - } - return static_cast(mapHdcpLevel(level)); -} - -HdcpLevel toHdcpLevel_1_1(HdcpLevel_V1_2 level) { - if (level == HdcpLevel_V1_2::HDCP_V2_3) { - return HdcpLevel::HDCP_NONE; - } - return static_cast(level); -} - -} // namespace - -WVDrmPlugin::WVDrmPlugin(const sp& cdm, - const std::string& appPackageName, - WVGenericCryptoInterface* crypto, bool useSpoid) - : mCdmIdentifierBuilder(useSpoid, *this, appPackageName), - mCDM(cdm), - mCrypto(crypto), - mCryptoSessions(), - mAppPackageName(appPackageName) { - Terminator::Register(this); -} - -WVDrmPlugin::~WVDrmPlugin() { - wvutil::SetLoggingUid(mCdmIdentifierBuilder.user_id()); - Terminator::Forget(this); - Close(); -} - -void WVDrmPlugin::Close() { - typedef map::iterator mapIterator; - for (mapIterator iter = mCryptoSessions.begin(); - iter != mCryptoSessions.end(); ++iter) { - CdmResponseType res = mCDM->CloseSession(iter->first); - if (!isCdmResponseTypeSuccess(res)) { - ALOGE("Failed to close session while destroying WVDrmPlugin"); - } - } - mCryptoSessions.clear(); - if (mCdmIdentifierBuilder.is_sealed()) { - CdmIdentifier identifier; - Status status = mCdmIdentifierBuilder.getCdmIdentifier(&identifier); - if (status != Status::OK) { - ALOGE("Failed to get cdm identifier %d", status); - } else { - status = mapCdmResponseType(mCDM->CloseCdm(identifier)); - if (status != Status::OK) { - ALOGE("Failed to close cdm. status %d", status); - } - } - } -} - -Status WVDrmPlugin::openSessionCommon(std::vector& sessionId) { - Status status = Status::OK; - - CdmIdentifier identifier; - status = mCdmIdentifierBuilder.getCdmIdentifier(&identifier); - if (status != Status::OK) { - return status; - } - - CdmSessionId cdmSessionId; - CdmResponseType res = mCDM->OpenSession("com.widevine", &mPropertySet, - identifier, this, &cdmSessionId); - - if (!isCdmResponseTypeSuccess(res)) { - status = mapAndNotifyOfCdmResponseType(sessionId, res); - return status; - } - - bool success = false; - - // Construct a CryptoSession - CdmQueryMap info; - res = mCDM->QueryOemCryptoSessionId(cdmSessionId, &info); - - if (isCdmResponseTypeSuccess(res) && - info.count(wvcdm::QUERY_KEY_OEMCRYPTO_SESSION_ID)) { - OEMCrypto_SESSION oecSessionId = - std::stoul(info[wvcdm::QUERY_KEY_OEMCRYPTO_SESSION_ID]); - mCryptoSessions[cdmSessionId] = CryptoSession(oecSessionId); - success = true; - } else { - ALOGE("Unable to query key control info."); - } - - if (success) { - // Marshal Session ID - sessionId = StrToVector(cdmSessionId); - return Status::OK; - } else { - mCDM->CloseSession(cdmSessionId); - - if (!isCdmResponseTypeSuccess(res)) { - // We got an error code we can return. - status = mapAndNotifyOfCdmResponseType(sessionId, res); - } else { - // We got a failure that did not give us an error code, such as a failure - // of AttachEventListener() or the key being missing from the map. - ALOGW("Returns UNKNOWN error for legacy status kErrorCDMGeneric"); - status = Status::ERROR_DRM_UNKNOWN; - } - } - - return status; -} - -Return WVDrmPlugin::openSession(openSession_cb _hidl_cb) { - std::vector sessionId; - Status status = openSessionCommon(sessionId); - - _hidl_cb(status, toHidlVec(sessionId)); - return Void(); -} - -SecurityLevel WVDrmPlugin::mapSecurityLevel(const std::string& level) { - SecurityLevel hSecurityLevel = SecurityLevel::UNKNOWN; - - if (wvcdm::QUERY_VALUE_SECURITY_LEVEL_L1 == level) { - hSecurityLevel = SecurityLevel::HW_SECURE_ALL; - } else if (wvcdm::QUERY_VALUE_SECURITY_LEVEL_L2 == level) { - hSecurityLevel = SecurityLevel::HW_SECURE_CRYPTO; - } else if (wvcdm::QUERY_VALUE_SECURITY_LEVEL_L3 == level) { - hSecurityLevel = SecurityLevel::SW_SECURE_CRYPTO; - } // else QUERY_VALUE_SECURITY_LEVEL_UNKNOWN returns Security::UNKNOWN - - return hSecurityLevel; -} - -Return WVDrmPlugin::openSession_1_1(SecurityLevel requestedLevel, - openSession_1_1_cb _hidl_cb) { - std::vector sessionId; - sessionId.clear(); - - if (SecurityLevel::UNKNOWN == requestedLevel) { - _hidl_cb(Status::ERROR_DRM_CANNOT_HANDLE, toHidlVec(sessionId)); - return Void(); - } - - std::string native_security_level; - Status status = - queryProperty(wvcdm::kLevelDefault, wvcdm::QUERY_KEY_SECURITY_LEVEL, - native_security_level); - if (Status::OK != status) { - _hidl_cb(status, toHidlVec(sessionId)); - return Void(); - } - - if (wvcdm::QUERY_VALUE_SECURITY_LEVEL_L3 == native_security_level && - requestedLevel >= SecurityLevel::SW_SECURE_DECODE) { - _hidl_cb(Status::ERROR_DRM_CANNOT_HANDLE, toHidlVec(sessionId)); - return Void(); - } - - std::string wvcdm_security_level = - (SecurityLevel::SW_SECURE_CRYPTO == requestedLevel) - ? wvcdm::QUERY_VALUE_SECURITY_LEVEL_L3 - : wvcdm::QUERY_VALUE_SECURITY_LEVEL_DEFAULT; - - setPropertyString("securityLevel", hidl_string(wvcdm_security_level)); - - status = openSessionCommon(sessionId); - hidl_vec hSessionId = toHidlVec(sessionId); - if (Status::OK == status) { - SecurityLevel currentSecurityLevel = SecurityLevel::UNKNOWN; - Return hResult = getSecurityLevel( - hSessionId, [&](Status gslStatus, SecurityLevel hSecurityLevel) { - currentSecurityLevel = hSecurityLevel; - if (Status::OK != gslStatus || requestedLevel != hSecurityLevel) { - ALOGE("Failed to open session with the requested security level=%d", - requestedLevel); - closeSession(hSessionId); - sessionId.clear(); - } - }); - if (!hResult.isOk() || (requestedLevel != currentSecurityLevel)) { - status = Status::ERROR_DRM_INVALID_STATE; - } - } - _hidl_cb(status, toHidlVec(sessionId)); - return Void(); -} - -Return WVDrmPlugin::closeSession(const hidl_vec& sessionId) { - if (!sessionId.size()) { - return Status::BAD_VALUE; - } - const std::vector sId = toVector(sessionId); - CdmSessionId cdmSessionId(sId.begin(), sId.end()); - CdmResponseType res = mCDM->CloseSession(cdmSessionId); - mCryptoSessions.erase(cdmSessionId); - if (!isCdmResponseTypeSuccess(res)) { - return Status::ERROR_DRM_SESSION_NOT_OPENED; - } - return Status::OK; -} - -Return WVDrmPlugin::getKeyRequest( - const hidl_vec& scope, const hidl_vec& initData, - const hidl_string& mimeType, KeyType keyType, - const hidl_vec& optionalParameters, getKeyRequest_cb _hidl_cb) { - hidl_string defaultUrl; - hidl_vec request; - KeyRequestType requestType = KeyRequestType::UNKNOWN; - Status status = Status::ERROR_DRM_UNKNOWN; - - defaultUrl.clear(); - Return hResult = getKeyRequest_1_1( - scope, initData, mimeType, keyType, optionalParameters, - [&](Status statusCode, const hidl_vec& hRequest, - KeyRequestType_V1_1 hKeyRequestType, const hidl_string& hDefaultUrl) { - defaultUrl = hDefaultUrl; - request = hRequest; - requestType = toKeyRequestType_V1_0(hKeyRequestType); - status = statusCode; - }); - if (!hResult.isOk()) { - status = Status::ERROR_DRM_INVALID_STATE; - } - _hidl_cb(status, request, requestType, defaultUrl); - return Void(); -} - -Return WVDrmPlugin::getKeyRequest_1_1( - const hidl_vec& scope, const hidl_vec& initData, - const hidl_string& mimeType, KeyType keyType, - const hidl_vec& optionalParameters, - getKeyRequest_1_1_cb _hidl_cb) { - hidl_string defaultUrl; - hidl_vec request; - KeyRequestType_V1_1 requestType = KeyRequestType_V1_1::UNKNOWN; - Status status = Status::ERROR_DRM_UNKNOWN; - - defaultUrl.clear(); - Return hResult = getKeyRequest_1_2( - scope, initData, mimeType, keyType, optionalParameters, - [&](Status_V1_2 statusCode, const hidl_vec& hRequest, - KeyRequestType_V1_1 hKeyRequestType, const hidl_string& hDefaultUrl) { - defaultUrl = hDefaultUrl; - request = hRequest; - requestType = hKeyRequestType; - status = toStatus_1_0(statusCode); - }); - if (!hResult.isOk()) { - status = Status::ERROR_DRM_INVALID_STATE; - } - _hidl_cb(status, request, requestType, defaultUrl); - return Void(); -} - -Return WVDrmPlugin::getKeyRequest_1_2( - const hidl_vec& scope, const hidl_vec& initData, - const hidl_string& mimeType, KeyType keyType, - const hidl_vec& optionalParameters, - getKeyRequest_1_2_cb _hidl_cb) { - if (!scope.size()) { - _hidl_cb(Status_V1_2::BAD_VALUE, hidl_vec(), - KeyRequestType_V1_1::UNKNOWN, ""); - return Void(); - } - KeyRequestType_V1_1 requestType = KeyRequestType_V1_1::UNKNOWN; - Status_V1_2 status = Status_V1_2::OK; - std::string defaultUrl; - std::vector request; - const std::vector scopeId = toVector(scope); - - CdmIdentifier identifier; - status = static_cast( - mCdmIdentifierBuilder.getCdmIdentifier(&identifier)); - if (status != Status_V1_2::OK) { - _hidl_cb(status, toHidlVec(request), requestType, defaultUrl.c_str()); - return Void(); - } - - CdmLicenseType cdmLicenseType; - CdmSessionId cdmSessionId; - CdmKeySetId cdmKeySetId; - if (keyType == KeyType::OFFLINE) { - cdmLicenseType = wvcdm::kLicenseTypeOffline; - cdmSessionId.assign(scopeId.begin(), scopeId.end()); - } else if (keyType == KeyType::STREAMING) { - cdmLicenseType = wvcdm::kLicenseTypeStreaming; - cdmSessionId.assign(scopeId.begin(), scopeId.end()); - } else if (keyType == KeyType::RELEASE) { - cdmLicenseType = wvcdm::kLicenseTypeRelease; - cdmKeySetId.assign(scopeId.begin(), scopeId.end()); - } else { - _hidl_cb(Status_V1_2::BAD_VALUE, toHidlVec(request), - KeyRequestType_V1_1::UNKNOWN, defaultUrl.c_str()); - return Void(); - } - - std::string cdmInitDataType = mimeType; - // Provide backwards-compatibility for apps that pass non-EME-compatible MIME - // types. - if (!WvContentDecryptionModule::IsSupported(cdmInitDataType)) { - cdmInitDataType = wvcdm::ISO_BMFF_VIDEO_MIME_TYPE; - } - - CdmInitData processedInitData; - if (initData.size() > 0 && - WvContentDecryptionModule::IsCenc(cdmInitDataType) && - !initDataResemblesPSSH(toVector(initData))) { - // This data was passed in the old format, pre-unwrapped. We need to wrap - // the init data in a new PSSH header. - static const uint8_t psshPrefix[] = { - 0, 0, 0, 0, // Total size - 'p', 's', 's', 'h', // "PSSH" - 0, 0, 0, 0, // Flags - must be zero - 0xED, 0xEF, 0x8B, 0xA9, 0x79, 0xD6, 0x4A, 0xCE, // Widevine UUID - 0xA3, 0xC8, 0x27, 0xDC, 0xD5, 0x1D, 0x21, 0xED, - 0, 0, 0, 0 // Size of initData - }; - processedInitData.assign(reinterpret_cast(psshPrefix), - sizeof(psshPrefix) / sizeof(uint8_t)); - processedInitData.append(reinterpret_cast(initData.data()), - initData.size()); - const size_t kPsshBoxSizeLocation = 0; - const size_t kInitDataSizeLocation = sizeof(psshPrefix) - sizeof(uint32_t); - uint32_t psshBoxSize = htonl(processedInitData.size()); - uint32_t initDataSize = htonl(initData.size()); - memcpy(&processedInitData[kPsshBoxSizeLocation], &psshBoxSize, - sizeof(uint32_t)); - memcpy(&processedInitData[kInitDataSizeLocation], &initDataSize, - sizeof(uint32_t)); - } else { - // For other formats, we can pass the init data through unmodified. - processedInitData.assign(reinterpret_cast(initData.data()), - initData.size()); - } - - CdmAppParameterMap cdmParameters; - for (size_t i = 0; i < optionalParameters.size(); ++i) { - const std::string& key(optionalParameters[i].key); - const std::string& value(optionalParameters[i].value); - - std::string cdmKey(key.c_str(), key.size()); - std::string cdmValue(value.c_str(), value.size()); - - cdmParameters[cdmKey] = cdmValue; - } - - // Inserting additional client ID parameters here, this will appear - // in the license request. - // Note: This will overwrite user parameters of the same key. - cdmParameters[kKeyAppPackageName] = mAppPackageName; - cdmParameters[kKeyOrigin] = mCdmIdentifierBuilder.origin(); - - CdmKeyRequest keyRequest; - CdmResponseType res = mCDM->GenerateKeyRequest( - cdmSessionId, cdmKeySetId, cdmInitDataType, processedInitData, - cdmLicenseType, cdmParameters, &mPropertySet, identifier, &keyRequest); - - requestType = ConvertFromCdmKeyRequestType_1_1(keyRequest.type); - - if (isCdmResponseTypeSuccess(res)) { - defaultUrl.clear(); - defaultUrl.assign(keyRequest.url.data(), keyRequest.url.size()); - - request = StrToVector(keyRequest.message); - } - - if (keyType == KeyType::RELEASE) { - // When releasing keys, we do not have a session ID. - status = mapCdmResponseType(res); - } else { - // For all other requests, we have a session ID. - status = mapAndNotifyOfCdmResponseType_1_2(scopeId, res); - } - _hidl_cb(status, toHidlVec(request), requestType, defaultUrl.c_str()); - return Void(); -} - -Return WVDrmPlugin::provideKeyResponse(const hidl_vec& scope, - const hidl_vec& response, - provideKeyResponse_cb _hidl_cb) { - if (scope.size() == 0 || response.size() == 0) { - _hidl_cb(Status::BAD_VALUE, hidl_vec()); - return Void(); - } - const std::vector resp = toVector(response); - const std::vector scopeId = toVector(scope); - - CdmKeySetId cdmKeySetId; - CdmSessionId cdmSessionId; - CdmKeyResponse cdmResponse(resp.begin(), resp.end()); - - bool isRequest = (memcmp(scopeId.data(), wvcdm::SESSION_ID_PREFIX, - sizeof(wvcdm::SESSION_ID_PREFIX) - 1) == 0); - bool isRelease = (memcmp(scopeId.data(), wvcdm::KEY_SET_ID_PREFIX, - sizeof(wvcdm::KEY_SET_ID_PREFIX) - 1) == 0); - - std::vector keySetId; - - if (isRequest) { - cdmSessionId.assign(scopeId.begin(), scopeId.end()); - } else if (isRelease) { - cdmKeySetId.assign(scopeId.begin(), scopeId.end()); - } else { - _hidl_cb(Status::ERROR_DRM_CANNOT_HANDLE, toHidlVec(keySetId)); - return Void(); - } - - CdmResponseType res = mCDM->AddKey(cdmSessionId, cdmResponse, &cdmKeySetId); - - if (isRequest && isCdmResponseTypeSuccess(res)) { - keySetId = StrToVector(cdmKeySetId); - } - - Status status = Status::OK; - if (isRelease) { - // When releasing keys, we do not have a session ID. - status = mapCdmResponseType(res); - } else { - // For all other requests, we have a session ID. - status = mapAndNotifyOfCdmResponseType(scopeId, res); - // For "NEED_KEY," we still want to send the notifcation, but then we don't - // return the error. This is because "NEED_KEY" from AddKey() is an - // expected behavior when sending a privacy certificate. - if (res == wvcdm::NEED_KEY && mPropertySet.use_privacy_mode()) { - status = Status::OK; - } - } - _hidl_cb(status, toHidlVec(keySetId)); - return Void(); -} - -Return WVDrmPlugin::removeKeys(const hidl_vec& sessionId) { - if (!sessionId.size()) { - return Status::BAD_VALUE; - } - const std::vector sId = toVector(sessionId); - CdmSessionId cdmSessionId(sId.begin(), sId.end()); - - CdmResponseType res = mCDM->RemoveKeys(cdmSessionId); - - return mapAndNotifyOfCdmResponseType(sId, res); -} - -Return WVDrmPlugin::restoreKeys(const hidl_vec& sessionId, - const hidl_vec& keySetId) { - if (!sessionId.size() || !keySetId.size()) { - return Status::BAD_VALUE; - } - const std::vector kId = toVector(keySetId); - const std::vector sId = toVector(sessionId); - CdmSessionId cdmSessionId(sId.begin(), sId.end()); - CdmKeySetId cdmKeySetId(kId.begin(), kId.end()); - - CdmResponseType res = mCDM->RestoreKey(cdmSessionId, cdmKeySetId); - - return mapAndNotifyOfCdmResponseType(sId, res); -} - -Return WVDrmPlugin::queryKeyStatus(const hidl_vec& sessionId, - queryKeyStatus_cb _hidl_cb) { - if (sessionId.size() == 0) { - _hidl_cb(Status::BAD_VALUE, hidl_vec()); - return Void(); - } - const std::vector sId = toVector(sessionId); - CdmSessionId cdmSessionId(sId.begin(), sId.end()); - CdmQueryMap cdmLicenseInfo; - - CdmResponseType res = mCDM->QueryKeyStatus(cdmSessionId, &cdmLicenseInfo); - - std::vector infoMapVec; - if (isCdmResponseTypeSuccess(res)) { - infoMapVec.clear(); - - KeyValue keyValuePair; - for (CdmQueryMap::const_iterator iter = cdmLicenseInfo.begin(); - iter != cdmLicenseInfo.end(); ++iter) { - const std::string& cdmKey = iter->first; - const std::string& cdmValue = iter->second; - keyValuePair.key = std::string(cdmKey.data(), cdmKey.size()); - keyValuePair.value = std::string(cdmValue.data(), cdmValue.size()); - infoMapVec.push_back(keyValuePair); - } - } - - _hidl_cb(mapCdmResponseType(res), toHidlVec(infoMapVec)); - return Void(); -} - -Return WVDrmPlugin::getProvisionRequest( - const hidl_string& certificateType, const hidl_string& certificateAuthority, - getProvisionRequest_cb _hidl_cb) { - Status status = Status::OK; - std::string defaultUrl; - std::vector request; - - Return hResult = getProvisionRequest_1_2( - certificateType, certificateAuthority, - [&](Status_V1_2 statusCode, const hidl_vec& hRequest, - const hidl_string& hDefaultUrl) { - request = hRequest; - status = toStatus_1_0(statusCode); - defaultUrl = hDefaultUrl; - }); - if (!hResult.isOk()) { - status = Status::ERROR_DRM_INVALID_STATE; - } - - _hidl_cb(status, toHidlVec(request), hidl_string(defaultUrl)); - return Void(); -} - -Return WVDrmPlugin::getProvisionRequest_1_2( - const hidl_string& certificateType, const hidl_string& certificateAuthority, - getProvisionRequest_1_2_cb _hidl_cb) { - Status_V1_2 status = Status_V1_2::OK; - std::string defaultUrl; - std::vector request; - - if (mPropertySet.use_atsc_mode()) { - _hidl_cb(mapCdmResponseType( - wvcdm::PROVISIONING_NOT_ALLOWED_FOR_ATSC), - toHidlVec(request), hidl_string(defaultUrl)); - return Void(); - } - - CdmIdentifier identifier; - status = static_cast( - mCdmIdentifierBuilder.getCdmIdentifier(&identifier)); - if (status != Status_V1_2::OK) { - _hidl_cb(status, toHidlVec(request), hidl_string(defaultUrl)); - return Void(); - } - - CdmProvisioningRequest cdmProvisionRequest; - std::string cdmDefaultUrl; - - CdmCertificateType cdmCertType = wvcdm::kCertificateWidevine; - if (certificateType == "X.509") { - cdmCertType = wvcdm::kCertificateX509; - } - - std::string cdmCertAuthority = certificateAuthority; - - CdmResponseType res = mCDM->GetProvisioningRequest( - cdmCertType, cdmCertAuthority, identifier, - mProvisioningServiceCertificate, getRequestedSecurityLevel(), - &cdmProvisionRequest, &cdmDefaultUrl); - if (isCdmResponseTypeSuccess(res)) { - request = StrToVector(cdmProvisionRequest); - defaultUrl.clear(); - defaultUrl.assign(cdmDefaultUrl.data(), cdmDefaultUrl.size()); - } - - _hidl_cb(mapCdmResponseType(res), toHidlVec(request), - hidl_string(defaultUrl)); - return Void(); -} - -Return WVDrmPlugin::provideProvisionResponse( - const hidl_vec& response, provideProvisionResponse_cb _hidl_cb) { - if (!response.size()) { - _hidl_cb(Status::BAD_VALUE, hidl_vec(), hidl_vec()); - return Void(); - } - const std::vector resp = toVector(response); - std::vector certificate; - std::vector wrappedKey; - - CdmIdentifier identifier; - Status status = mCdmIdentifierBuilder.getCdmIdentifier(&identifier); - if (status != Status::OK) { - _hidl_cb(status, toHidlVec(certificate), toHidlVec(wrappedKey)); - } - - CdmProvisioningResponse cdmResponse(resp.begin(), resp.end()); - if (cdmResponse == kSpecialUnprovisionResponse) { - if (identifier.IsEquivalentToDefault()) { - ALOGW("Returns UNKNOWN error for legacy status kErrorNoOriginSpecified"); - _hidl_cb(Status::ERROR_DRM_UNKNOWN, toHidlVec(certificate), - toHidlVec(wrappedKey)); - return Void(); - } - _hidl_cb(unprovision(identifier), toHidlVec(certificate), - toHidlVec(wrappedKey)); - return Void(); - } else { - std::string cdmCertificate; - std::string cdmWrappedKey; - CdmResponseType res = mCDM->HandleProvisioningResponse( - identifier, cdmResponse, getRequestedSecurityLevel(), &cdmCertificate, - &cdmWrappedKey); - if (isCdmResponseTypeSuccess(res)) { - certificate = StrToVector(cdmCertificate); - wrappedKey = StrToVector(cdmWrappedKey); - } - - _hidl_cb(mapCdmResponseType(res), toHidlVec(certificate), - toHidlVec(wrappedKey)); - return Void(); - } -} - -Status WVDrmPlugin::unprovisionDevice() { - return unprovision(kDefaultCdmIdentifier); -} - -Return WVDrmPlugin::getSecureStop(const hidl_vec& secureStopId, - getSecureStop_cb _hidl_cb) { - if (!secureStopId.size()) { - _hidl_cb(Status::BAD_VALUE, SecureStop()); - return Void(); - } - - const std::vector id = toVector(secureStopId); - std::vector cdmStopVec; - SecureStop secureStop; - - CdmIdentifier identifier; - Status status = mCdmIdentifierBuilder.getCdmIdentifier(&identifier); - if (status != Status::OK) { - _hidl_cb(status, secureStop); - return Void(); - } - - CdmUsageInfo cdmUsageInfo; - CdmSecureStopId cdmSsId(id.begin(), id.end()); - CdmResponseType res = mCDM->GetUsageInfo(mPropertySet.app_id(), cdmSsId, - identifier, &cdmUsageInfo); - - if (isCdmResponseTypeSuccess(res)) { - for (CdmUsageInfo::const_iterator iter = cdmUsageInfo.begin(); - iter != cdmUsageInfo.end(); ++iter) { - const std::string& cdmStop = *iter; - cdmStopVec = StrToVector(cdmStop); - } - secureStop.opaqueData = toHidlVec(cdmStopVec); - } - - _hidl_cb(mapCdmResponseType(res), secureStop); - return Void(); -} - -Return WVDrmPlugin::getSecureStops(getSecureStops_cb _hidl_cb) { - std::list> secureStops; - std::vector secureStopsVec; - - CdmIdentifier identifier; - Status status = mCdmIdentifierBuilder.getCdmIdentifier(&identifier); - if (status != Status::OK) { - _hidl_cb(status, toHidlVec(secureStopsVec)); - return Void(); - } - - CdmUsageInfo cdmUsageInfo; - CdmResponseType res = - mCDM->GetUsageInfo(mPropertySet.app_id(), identifier, &cdmUsageInfo); - - if (isCdmResponseTypeSuccess(res)) { - secureStops.clear(); - for (CdmUsageInfo::const_iterator iter = cdmUsageInfo.begin(); - iter != cdmUsageInfo.end(); ++iter) { - const std::string& cdmStop = *iter; - secureStops.push_back(StrToVector(cdmStop)); - } - } - - std::list>::iterator iter = secureStops.begin(); - while (iter != secureStops.end()) { - SecureStop secureStop; - secureStop.opaqueData = toHidlVec(*iter++); - secureStopsVec.push_back(secureStop); - } - - _hidl_cb(mapCdmResponseType(res), toHidlVec(secureStopsVec)); - return Void(); -} - -Return WVDrmPlugin::releaseAllSecureStops() { - return removeAllSecureStops(); -} - -Return WVDrmPlugin::releaseSecureStop( - const hidl_vec& secureStopId) { - if (!secureStopId.size()) { - return Status::BAD_VALUE; - } - - CdmIdentifier identifier; - Status status = mCdmIdentifierBuilder.getCdmIdentifier(&identifier); - if (status != Status::OK) { - return status; - } - - const std::vector ssRelease = toVector(secureStopId); - CdmUsageInfoReleaseMessage cdmMessage(ssRelease.begin(), ssRelease.end()); - CdmResponseType res = mCDM->ReleaseUsageInfo(cdmMessage, identifier); - return mapCdmResponseType(res); -} - -Return WVDrmPlugin::getMetrics(getMetrics_cb _hidl_cb) { - hidl_vec hidl_metrics; - CdmIdentifier identifier; - Status status = mCdmIdentifierBuilder.getCdmIdentifier(&identifier); - if (status != Status::OK) { - _hidl_cb(status, hidl_metrics); - return Void(); - } - - drm_metrics::WvCdmMetrics proto_metrics; - CdmResponseType result = mCDM->GetMetrics(identifier, &proto_metrics); - if (result != wvcdm::NO_ERROR) { - status = mapCdmResponseType(result); - _hidl_cb(status, hidl_metrics); - return Void(); - } - - ::wvcdm::HidlMetricsAdapter adapter; - ::wvcdm::HidlMetricsAdapter::ToHidlMetrics(proto_metrics, &hidl_metrics); - _hidl_cb(Status::OK, hidl_metrics); - return Void(); -} - -Return WVDrmPlugin::getSecureStopIds(getSecureStopIds_cb _hidl_cb) { - std::vector secureStopIds; - - CdmIdentifier identifier; - Status status = mCdmIdentifierBuilder.getCdmIdentifier(&identifier); - if (status != Status::OK) { - _hidl_cb(status, toHidlVec(secureStopIds)); - return Void(); - } - - std::vector ssids; - CdmResponseType res = - mCDM->GetSecureStopIds(mPropertySet.app_id(), identifier, &ssids); - - if (isCdmResponseTypeSuccess(res)) { - for (auto itr = ssids.begin(); itr != ssids.end(); ++itr) { - const CdmSecureStopId& ssid = *itr; - secureStopIds.push_back(StrToVector(ssid)); - } - } - - _hidl_cb(mapCdmResponseType(res), toHidlVec(secureStopIds)); - return Void(); -} - -Return WVDrmPlugin::releaseSecureStops( - const SecureStopRelease& ssRelease) { - if (ssRelease.opaqueData.size() == 0) { - return Status::BAD_VALUE; - } - - CdmIdentifier identifier; - Status status = mCdmIdentifierBuilder.getCdmIdentifier(&identifier); - if (status != Status::OK) { - return status; - } - - const std::vector data = toVector(ssRelease.opaqueData); - CdmUsageInfoReleaseMessage cdmMessage(data.begin(), data.end()); - CdmResponseType res = mCDM->ReleaseUsageInfo(cdmMessage, identifier); - return mapCdmResponseType(res); -} - -Return WVDrmPlugin::removeSecureStop( - const hidl_vec& secureStopId) { - if (!secureStopId.size()) { - return Status::BAD_VALUE; - } - - CdmIdentifier identifier; - Status status = mCdmIdentifierBuilder.getCdmIdentifier(&identifier); - if (status != Status::OK) { - return status; - } - - const std::vector idVec = toVector(secureStopId); - CdmSecureStopId id(idVec.begin(), idVec.end()); - CdmResponseType res = - mCDM->RemoveUsageInfo(mPropertySet.app_id(), identifier, id); - return mapCdmResponseType(res); -} - -Return WVDrmPlugin::removeAllSecureStops() { - CdmIdentifier identifier; - Status status = mCdmIdentifierBuilder.getCdmIdentifier(&identifier); - if (status != Status::OK) { - return status; - } - - CdmResponseType res = - mCDM->RemoveAllUsageInfo(mPropertySet.app_id(), identifier); - return mapCdmResponseType(res); -} - -Return WVDrmPlugin::getHdcpLevels(getHdcpLevels_cb _hidl_cb) { - HdcpLevel connectedLevel = HdcpLevel::HDCP_NONE; - HdcpLevel maxLevel = HdcpLevel::HDCP_NO_OUTPUT; - - Return hResult = getHdcpLevels_1_2([&](Status_V1_2 status, - const HdcpLevel_V1_2& hConnected, - const HdcpLevel_V1_2& hMax) { - if (status == Status_V1_2::OK) { - connectedLevel = toHdcpLevel_1_1(hConnected); - maxLevel = toHdcpLevel_1_1(hMax); - } - }); - - _hidl_cb(Status::OK, connectedLevel, maxLevel); - return Void(); -} - -Return WVDrmPlugin::getHdcpLevels_1_2(getHdcpLevels_1_2_cb _hidl_cb) { - HdcpLevel_V1_2 connectedLevel = HdcpLevel_V1_2::HDCP_NONE; - HdcpLevel_V1_2 maxLevel = HdcpLevel_V1_2::HDCP_NO_OUTPUT; - - std::string level; - Status status = queryProperty(wvcdm::QUERY_KEY_CURRENT_HDCP_LEVEL, level); - if (status == Status::OK) { - connectedLevel = mapHdcpLevel_1_2(level); - } else { - ALOGE("Failed to query current hdcp level."); - _hidl_cb(Status_V1_2::ERROR_DRM_INVALID_STATE, connectedLevel, maxLevel); - return Void(); - } - - status = queryProperty(wvcdm::QUERY_KEY_MAX_HDCP_LEVEL, level); - if (status == Status::OK) { - maxLevel = mapHdcpLevel_1_2(level); - } else { - ALOGE("Failed to query maximum hdcp level."); - _hidl_cb(Status_V1_2::ERROR_DRM_INVALID_STATE, connectedLevel, maxLevel); - return Void(); - } - - _hidl_cb(Status_V1_2::OK, connectedLevel, maxLevel); - return Void(); -} - -Return WVDrmPlugin::getNumberOfSessions(getNumberOfSessions_cb _hidl_cb) { - uint32_t currentSessions = 0; - uint32_t maxSessions = 1; - - std::string value; - Status status = - queryProperty(wvcdm::QUERY_KEY_NUMBER_OF_OPEN_SESSIONS, value); - if (status == Status::OK) { - currentSessions = std::strtoul(value.c_str(), nullptr, 10); - } else { - ALOGE("Failed to query currently opened sessions."); - _hidl_cb(Status::ERROR_DRM_INVALID_STATE, currentSessions, maxSessions); - return Void(); - } - - status = queryProperty(wvcdm::QUERY_KEY_MAX_NUMBER_OF_SESSIONS, value); - if (status == Status::OK) { - maxSessions = std::strtoul(value.c_str(), nullptr, 10); - } else { - ALOGE( - "Failed to query maximum number of sessions that the device can " - "support."); - _hidl_cb(Status::ERROR_DRM_INVALID_STATE, currentSessions, maxSessions); - return Void(); - } - - _hidl_cb(Status::OK, currentSessions, maxSessions); - return Void(); -} - -Return WVDrmPlugin::getSecurityLevel(const hidl_vec& sessionId, - getSecurityLevel_cb _hidl_cb) { - if (sessionId.size() == 0) { - _hidl_cb(Status::BAD_VALUE, SecurityLevel::UNKNOWN); - return Void(); - } - - std::vector sid = toVector(sessionId); - CdmQueryMap info; - SecurityLevel hSecurityLevel = SecurityLevel::UNKNOWN; - - CdmResponseType status = - mCDM->QuerySessionStatus(std::string(sid.begin(), sid.end()), &info); - if (wvcdm::NO_ERROR == status) { - std::string level = info[wvcdm::QUERY_KEY_SECURITY_LEVEL]; - hSecurityLevel = mapSecurityLevel(level); - } else { - ALOGE("Failed to query security level, status=%d", status); - } - - _hidl_cb(mapCdmResponseType(status), hSecurityLevel); - return Void(); -} - -Return WVDrmPlugin::getOfflineLicenseKeySetIds( - getOfflineLicenseKeySetIds_cb _hidl_cb) { - std::vector> keySetIds; - std::vector keySetIdsVec; - - CdmIdentifier identifier; - Status status = mCdmIdentifierBuilder.getCdmIdentifier(&identifier); - if (status != Status::OK) { - _hidl_cb(status, toHidlVec(keySetIdsVec)); - return Void(); - } - - std::vector levels = {wvcdm::kSecurityLevelL1, - wvcdm::kSecurityLevelL3}; - - CdmResponseType res = wvcdm::UNKNOWN_ERROR; - - for (auto level : levels) { - std::vector cdmKeySetIds; - res = mCDM->ListStoredLicenses(level, identifier, &cdmKeySetIds); - - if (isCdmResponseTypeSuccess(res)) { - keySetIds.clear(); - for (auto id : cdmKeySetIds) { - keySetIds.push_back(StrToVector(id)); - } - for (auto id : keySetIds) { - keySetIdsVec.push_back(id); - } - } - } - _hidl_cb(mapCdmResponseType(res), toHidlVec(keySetIdsVec)); - return Void(); -} - -Return WVDrmPlugin::getOfflineLicenseState( - const KeySetId& keySetId, getOfflineLicenseState_cb _hidl_cb) { - OfflineLicenseState licenseState = OfflineLicenseState::UNKNOWN; - - if (!keySetId.size()) { - _hidl_cb(Status::BAD_VALUE, licenseState); - return Void(); - } - - CdmIdentifier identifier; - Status status = mCdmIdentifierBuilder.getCdmIdentifier(&identifier); - if (status != Status::OK) { - _hidl_cb(status, licenseState); - return Void(); - } - - CdmResponseType res = wvcdm::UNKNOWN_ERROR; - CdmKeySetId keySetIdStr(keySetId.begin(), keySetId.end()); - - wvcdm::CdmOfflineLicenseState state = wvcdm::kLicenseStateUnknown; - res = mCDM->GetOfflineLicenseState(keySetIdStr, wvcdm::kSecurityLevelL1, - identifier, &state); - if (!isCdmResponseTypeSuccess(res)) { - // try L3 - res = mCDM->GetOfflineLicenseState(keySetIdStr, wvcdm::kSecurityLevelL3, - identifier, &state); - if (!isCdmResponseTypeSuccess(res)) { - _hidl_cb(Status::BAD_VALUE, licenseState); - return Void(); - } - } - - switch (state) { - case wvcdm::kLicenseStateActive: - licenseState = OfflineLicenseState::USABLE; - break; - case wvcdm::kLicenseStateReleasing: - licenseState = OfflineLicenseState::INACTIVE; - break; - default: - licenseState = OfflineLicenseState::UNKNOWN; - ALOGE("Return unknown offline license state for %s", keySetIdStr.c_str()); - break; - } - - _hidl_cb(mapCdmResponseType(res), licenseState); - return Void(); -} - -Return WVDrmPlugin::removeOfflineLicense(const KeySetId& keySetId) { - if (!keySetId.size()) { - return Status::BAD_VALUE; - } - - CdmIdentifier identifier; - Status status = mCdmIdentifierBuilder.getCdmIdentifier(&identifier); - if (status != Status::OK) { - return status; - } - - CdmResponseType res = wvcdm::UNKNOWN_ERROR; - - res = - mCDM->RemoveOfflineLicense(std::string(keySetId.begin(), keySetId.end()), - wvcdm::kSecurityLevelL1, identifier); - if (!isCdmResponseTypeSuccess(res)) { - CdmResponseType res = mCDM->RemoveOfflineLicense( - std::string(keySetId.begin(), keySetId.end()), wvcdm::kSecurityLevelL3, - identifier); - status = mapCdmResponseType(res); - } - - return status; -} - -Return WVDrmPlugin::getPropertyString(const hidl_string& propertyName, - getPropertyString_cb _hidl_cb) { - Status status = Status::OK; - std::string name(propertyName.c_str()); - std::string value; - - if (name == "vendor") { - value = "Google"; - } else if (name == "version") { - status = queryProperty(wvcdm::QUERY_KEY_WVCDM_VERSION, value); - } else if (name == "description") { - value = "Widevine CDM"; - } else if (name == "algorithms") { - value = "AES/CBC/NoPadding,HmacSHA256"; - } else if (name == "securityLevel") { - std::string requestedLevel = mPropertySet.security_level(); - - if (requestedLevel.length() > 0) { - value = requestedLevel.c_str(); - } else { - status = queryProperty(wvcdm::QUERY_KEY_SECURITY_LEVEL, value); - } - } else if (name == "systemId") { - status = queryProperty(wvcdm::QUERY_KEY_SYSTEM_ID, value); - } else if (name == "privacyMode") { - if (mPropertySet.use_privacy_mode()) { - value = kEnable; - } else { - value = kDisable; - } - } else if (name == "sessionSharing") { - if (mPropertySet.is_session_sharing_enabled()) { - value = kEnable; - } else { - value = kDisable; - } - } else if (name == "hdcpLevel") { - status = queryProperty(wvcdm::QUERY_KEY_CURRENT_HDCP_LEVEL, value); - } else if (name == "maxHdcpLevel") { - status = queryProperty(wvcdm::QUERY_KEY_MAX_HDCP_LEVEL, value); - } else if (name == "usageReportingSupport") { - status = queryProperty(wvcdm::QUERY_KEY_USAGE_SUPPORT, value); - } else if (name == "numberOfOpenSessions") { - status = queryProperty(wvcdm::QUERY_KEY_NUMBER_OF_OPEN_SESSIONS, value); - } else if (name == "maxNumberOfSessions") { - status = queryProperty(wvcdm::QUERY_KEY_MAX_NUMBER_OF_SESSIONS, value); - } else if (name == "oemCryptoApiVersion") { - status = queryProperty(wvcdm::QUERY_KEY_OEMCRYPTO_API_VERSION, value); - } else if (name == "appId") { - value = mPropertySet.app_id().c_str(); - } else if (name == "origin") { - value = mCdmIdentifierBuilder.origin().c_str(); - } else if (name == "CurrentSRMVersion") { - status = queryProperty(wvcdm::QUERY_KEY_CURRENT_SRM_VERSION, value); - } else if (name == "SRMUpdateSupport") { - status = queryProperty(wvcdm::QUERY_KEY_SRM_UPDATE_SUPPORT, value); - } else if (name == "resourceRatingTier") { - status = queryProperty(wvcdm::QUERY_KEY_RESOURCE_RATING_TIER, value); - } else if (name == "oemCryptoBuildInformation") { - status = queryProperty(wvcdm::QUERY_KEY_OEMCRYPTO_BUILD_INFORMATION, value); - } else if (name == "decryptHashSupport") { - status = queryProperty(wvcdm::QUERY_KEY_DECRYPT_HASH_SUPPORT, value); - } else if (name == "decryptHashError") { - status = mapCdmResponseType( - mCDM->GetDecryptHashError(mDecryptHashSessionId, &value)); - } else if (name == "maxUsageEntriesSupported") { - status = queryProperty(wvcdm::QUERY_KEY_MAX_USAGE_TABLE_ENTRIES, value); - } else if (name == "oemCryptoApiMinorVersion") { - status = queryProperty(wvcdm::QUERY_KEY_OEMCRYPTO_API_MINOR_VERSION, value); - } else if (name == "analogOutputCapabilities") { - status = queryProperty(wvcdm::QUERY_KEY_ANALOG_OUTPUT_CAPABILITIES, value); - } else if (name == "canDisableAnalogOutput") { - status = queryProperty(wvcdm::QUERY_KEY_CAN_DISABLE_ANALOG_OUTPUT, value); - } else if (name == "atscMode") { - if (mPropertySet.use_atsc_mode()) { - value = kEnable; - } else { - value = kDisable; - } - } else if (name == "watermarkingSupport") { - status = queryProperty(wvcdm::QUERY_KEY_WATERMARKING_SUPPORT, value); - } else if (name == "productionReady") { - status = queryProperty(wvcdm::QUERY_KEY_PRODUCTION_READY, value); - } else if (name == "provisioningModel") { - status = queryProperty(wvcdm::QUERY_KEY_PROVISIONING_MODEL, value); - } else { - ALOGE("App requested unknown string property %s", name.c_str()); - status = Status::ERROR_DRM_CANNOT_HANDLE; - } - - _hidl_cb(status, value.c_str()); - return Void(); -} - -Return WVDrmPlugin::getPropertyByteArray( - const hidl_string& propertyName, getPropertyByteArray_cb _hidl_cb) { - Status status = Status::OK; - std::string name(propertyName.c_str()); - std::vector value; - - if (name == "deviceUniqueId") { - std::string id; - status = mCdmIdentifierBuilder.getDeviceUniqueId(&id); - if (status == Status::OK) { - value = StrToVector(id); - } - } else if (name == "provisioningUniqueId") { - std::string id; - status = mCdmIdentifierBuilder.getProvisioningUniqueId(&id); - if (status == Status::OK) { - value = StrToVector(id); - } - } else if (name == "serviceCertificate") { - value = StrToVector(mPropertySet.service_certificate()); - } else if (name == "provisioningServiceCertificate") { - value = StrToVector(mProvisioningServiceCertificate); - } else if (name == "metrics") { - drm_metrics::WvCdmMetrics metrics; - // If the cdm identifier is not yet sealed, then there are no metrics - // for that cdm engine. Avoid calling getCdmIdentifier and sealing - // the identifier builder. - if (mCdmIdentifierBuilder.is_sealed()) { - CdmIdentifier identifier; - status = mCdmIdentifierBuilder.getCdmIdentifier(&identifier); - if (status != Status::OK) { - ALOGE("Unexpected error retrieving cdm identifier: %d", status); - } else { - status = mapCdmResponseType(mCDM->GetMetrics(identifier, &metrics)); - } - } - if (status == Status::OK) { - std::string serialized_metrics; - if (!metrics.SerializeToString(&serialized_metrics)) { - status = Status::ERROR_DRM_UNKNOWN; - } else { - value = StrToVector(serialized_metrics); - } - } - } else { - ALOGE("App requested unknown byte array property %s", name.c_str()); - status = Status::ERROR_DRM_CANNOT_HANDLE; - } - - _hidl_cb(status, toHidlVec(value)); - return Void(); -} - -Return WVDrmPlugin::setPropertyString(const hidl_string& propertyName, - const hidl_string& value) { - std::string name(propertyName.c_str()); - std::string _value(value.c_str()); - - if (name == "securityLevel") { - if (mCryptoSessions.size() == 0) { - if (_value == wvcdm::QUERY_VALUE_SECURITY_LEVEL_L3.c_str()) { - mPropertySet.set_security_level(wvcdm::QUERY_VALUE_SECURITY_LEVEL_L3); - } else if (_value == wvcdm::QUERY_VALUE_SECURITY_LEVEL_L1.c_str()) { - // We must be sure we CAN set the security level to L1. - std::string current_security_level; - Status status = - queryProperty(wvcdm::kLevelDefault, wvcdm::QUERY_KEY_SECURITY_LEVEL, - current_security_level); - if (status != Status::OK) { - return status; - } - if (current_security_level != wvcdm::QUERY_VALUE_SECURITY_LEVEL_L1) { - ALOGE("App requested L1 security on a non-L1 device."); - return Status::BAD_VALUE; - } else { - mPropertySet.set_security_level(kResetSecurityLevel); - } - } else if (_value == kResetSecurityLevel || - _value == wvcdm::QUERY_VALUE_SECURITY_LEVEL_DEFAULT) { - mPropertySet.set_security_level(kResetSecurityLevel); - } else { - ALOGE("App requested invalid security level %s", _value.c_str()); - return Status::BAD_VALUE; - } - } else { - ALOGE("App tried to change security level while sessions are open."); - ALOGW("Returns UNKNOWN error for legacy status kErrorSessionIsOpen"); - return Status::ERROR_DRM_UNKNOWN; - } - } else if (name == "privacyMode") { - if (_value == kEnable) { - mPropertySet.set_use_privacy_mode(true); - } else if (_value == kDisable) { - mPropertySet.set_use_privacy_mode(false); - } else { - ALOGE("App requested unknown privacy mode %s", _value.c_str()); - return Status::BAD_VALUE; - } - } else if (name == "sessionSharing") { - if (mCryptoSessions.size() == 0) { - if (_value == kEnable) { - mPropertySet.set_is_session_sharing_enabled(true); - } else if (_value == kDisable) { - mPropertySet.set_is_session_sharing_enabled(false); - } else { - ALOGE("App requested unknown sharing type %s", _value.c_str()); - return Status::BAD_VALUE; - } - } else { - ALOGE("App tried to change key sharing while sessions are open."); - ALOGW("Returns UNKNOWN error for legacy status kErrorSessionIsOpen"); - return Status::ERROR_DRM_UNKNOWN; - } - } else if (name == "appId") { - if (mCryptoSessions.size() == 0) { - mPropertySet.set_app_id(_value.c_str()); - } else { - ALOGE("App tried to set the application id while sessions are opened."); - ALOGW("Returns UNKNOWN error for legacy status kErrorSessionIsOpen"); - return Status::ERROR_DRM_UNKNOWN; - } - } else if (name == "origin") { - if (mCryptoSessions.size() != 0) { - ALOGE("App tried to set the origin while sessions are opened."); - ALOGW("Returns UNKNOWN error for legacy status kErrorSessionIsOpen"); - return Status::ERROR_DRM_UNKNOWN; - } else { - if (!mCdmIdentifierBuilder.set_origin(_value.c_str())) { - return Status::BAD_VALUE; - } - } - } else if (name == "debugIgnoreKeyboxCount") { - std::istringstream ss(_value); - uint32_t count = 0; - ss >> count; - if (ss.fail()) { - ALOGE("Could not parse an integer from '%s'", _value.c_str()); - count = 0; - return Status::BAD_VALUE; - } - CdmResponseType res = mCDM->SetDebugIgnoreKeyboxCount(count); - return mapCdmResponseType(res); - } else if (name == "allowTestKeybox") { - bool allow; - if (_value == kEnable) { - allow = true; - } else if (_value == kDisable) { - allow = false; - } else { - ALOGE("App requested unknown allowTestKeybox %s", _value.c_str()); - return Status::BAD_VALUE; - } - CdmResponseType res = mCDM->SetAllowTestKeybox(allow); - return mapCdmResponseType(res); - } else if (name == "decryptHash") { - wvcdm::CdmSessionId sessionId; - CdmResponseType res = mCDM->SetDecryptHash(_value.c_str(), &sessionId); - - if (wvcdm::NO_ERROR == res) mDecryptHashSessionId = sessionId; - - return mapCdmResponseType(res); - } else if (name == "decryptHashSessionId") { - mDecryptHashSessionId = _value.c_str(); - } else if (name == "atscMode") { - if (_value == kEnable) { - if (!mCdmIdentifierBuilder.set_use_atsc_mode(true)) { - ALOGE("Cdm identifier builder is sealed. Setting ATSC mode prohibited"); - return Status::BAD_VALUE; - } - mPropertySet.set_use_atsc_mode(true); - } else if (_value == kDisable) { - if (!mCdmIdentifierBuilder.set_use_atsc_mode(false)) { - ALOGE("Cdm identifier builder is sealed. Setting ATSC mode prohibited"); - return Status::BAD_VALUE; - } - mPropertySet.set_use_atsc_mode(false); - } else { - ALOGE("App requested unknown ATSC mode %s", _value.c_str()); - return Status::BAD_VALUE; - } - } else if (name == "debugOtaKeyboxFallbackDuration") { - bool success = false; - if (value == "default") { - success = mCDM->SetDefaultOtaKeyboxFallbackDurationRules(); - } else if (value == "fast") { - success = mCDM->SetFastOtaKeyboxFallbackDurationRules(); - } else { - ALOGE("Unknown OTA fallback duration value %s", _value.c_str()); - return Status::BAD_VALUE; - } - if (!success) { - return Status::ERROR_DRM_UNKNOWN; - } - } else { - ALOGE("App set unknown string property %s", name.c_str()); - return Status::ERROR_DRM_CANNOT_HANDLE; - } - - return Status::OK; -} - -Return WVDrmPlugin::setPropertyByteArray( - const hidl_string& propertyName, const hidl_vec& value) { - std::string name(propertyName.c_str()); - std::vector _value = toVector(value); - - if (name == "serviceCertificate") { - std::string cert(_value.begin(), _value.end()); - if (_value.empty() || mCDM->IsValidServiceCertificate(cert)) { - mPropertySet.set_service_certificate(cert); - } else { - return Status::BAD_VALUE; - } - } else if (name == "provisioningServiceCertificate") { - std::string cert(_value.begin(), _value.end()); - if (_value.empty() || mCDM->IsValidServiceCertificate(cert)) { - mProvisioningServiceCertificate = cert; - } else { - return Status::BAD_VALUE; - } - } else { - ALOGE("App set unknown byte array property %s", name.c_str()); - return Status::ERROR_DRM_CANNOT_HANDLE; - } - - return Status::OK; -} - -Return WVDrmPlugin::setCipherAlgorithm( - const hidl_vec& sessionId, const hidl_string& algorithm) { - if (sessionId.size() == 0 || algorithm.size() == 0) { - return Status::BAD_VALUE; - } - std::string algo(algorithm.c_str()); - std::vector sId = toVector(sessionId); - - CdmSessionId cdmSessionId(sId.begin(), sId.end()); - if (!mCryptoSessions.count(cdmSessionId)) { - return Status::ERROR_DRM_SESSION_NOT_OPENED; - } - - CryptoSession& cryptoSession = mCryptoSessions[cdmSessionId]; - - if (algo == "AES/CBC/NoPadding") { - cryptoSession.setCipherAlgorithm(OEMCrypto_AES_CBC_128_NO_PADDING); - } else { - return Status::ERROR_DRM_CANNOT_HANDLE; - } - - return Status::OK; -} - -Return WVDrmPlugin::setMacAlgorithm(const hidl_vec& sessionId, - const hidl_string& algorithm) { - if (sessionId.size() == 0 || algorithm.size() == 0) { - return Status::BAD_VALUE; - } - std::string algo(algorithm.c_str()); - std::vector sId = toVector(sessionId); - - CdmSessionId cdmSessionId(sId.begin(), sId.end()); - if (!mCryptoSessions.count(cdmSessionId)) { - return Status::ERROR_DRM_SESSION_NOT_OPENED; - } - - CryptoSession& cryptoSession = mCryptoSessions[cdmSessionId]; - - if (algo == "HmacSHA256") { - cryptoSession.setMacAlgorithm(OEMCrypto_HMAC_SHA256); - } else { - return Status::ERROR_DRM_CANNOT_HANDLE; - } - - return Status::OK; -} - -Return WVDrmPlugin::encrypt(const hidl_vec& sessionId, - const hidl_vec& keyId, - const hidl_vec& input, - const hidl_vec& iv, - encrypt_cb _hidl_cb) { - const std::vector sId = toVector(sessionId); - std::vector output; - - CdmSessionId cdmSessionId(sId.begin(), sId.end()); - if (!mCryptoSessions.count(cdmSessionId)) { - _hidl_cb(Status::ERROR_DRM_SESSION_NOT_OPENED, toHidlVec(output)); - return Void(); - } - - const CryptoSession& cryptoSession = mCryptoSessions[cdmSessionId]; - - if (cryptoSession.cipherAlgorithm() == kInvalidCryptoAlgorithm) { - ALOGW("Returns UNKNOWN error for legacy status NO_INIT"); - _hidl_cb(Status::ERROR_DRM_UNKNOWN, toHidlVec(output)); - return Void(); - } - - const std::vector _keyId = toVector(keyId); - OEMCryptoResult res = mCrypto->selectKey(cryptoSession.oecSessionId(), - _keyId.data(), _keyId.size()); - - if (res != OEMCrypto_SUCCESS) { - ALOGE("OEMCrypto_SelectKey failed with %u", res); - _hidl_cb(mapAndNotifyOfOEMCryptoResult(sId, res), toHidlVec(output)); - return Void(); - } - - const std::vector _input = toVector(input); - const std::vector _iv = toVector(iv); - output.resize(_input.size()); - - res = mCrypto->encrypt(cryptoSession.oecSessionId(), _input.data(), - _input.size(), _iv.data(), - cryptoSession.cipherAlgorithm(), output.data()); - - if (res == OEMCrypto_SUCCESS) { - _hidl_cb(Status::OK, toHidlVec(output)); - } else { - ALOGE("OEMCrypto_Generic_Encrypt failed with %u", res); - _hidl_cb(mapAndNotifyOfOEMCryptoResult(sId, res), toHidlVec(output)); - } - return Void(); -} - -Return WVDrmPlugin::decrypt(const hidl_vec& sessionId, - const hidl_vec& keyId, - const hidl_vec& input, - const hidl_vec& iv, - decrypt_cb _hidl_cb) { - const std::vector sId = toVector(sessionId); - std::vector output; - - CdmSessionId cdmSessionId(sId.begin(), sId.end()); - if (!mCryptoSessions.count(cdmSessionId)) { - _hidl_cb(Status::ERROR_DRM_SESSION_NOT_OPENED, toHidlVec(output)); - return Void(); - } - - const CryptoSession& cryptoSession = mCryptoSessions[cdmSessionId]; - - if (cryptoSession.cipherAlgorithm() == kInvalidCryptoAlgorithm) { - ALOGW("Returns UNKNOWN error for legacy status NO_INIT"); - _hidl_cb(Status::ERROR_DRM_UNKNOWN, toHidlVec(output)); - return Void(); - } - - const std::vector _keyId = toVector(keyId); - OEMCryptoResult res = mCrypto->selectKey(cryptoSession.oecSessionId(), - _keyId.data(), _keyId.size()); - - if (res != OEMCrypto_SUCCESS) { - ALOGE("OEMCrypto_SelectKey failed with %u", res); - _hidl_cb(mapAndNotifyOfOEMCryptoResult(sId, res), toHidlVec(output)); - return Void(); - } - - const std::vector _input = toVector(input); - const std::vector _iv = toVector(iv); - output.resize(_input.size()); - - res = mCrypto->decrypt(cryptoSession.oecSessionId(), _input.data(), - _input.size(), _iv.data(), - cryptoSession.cipherAlgorithm(), output.data()); - - if (res == OEMCrypto_SUCCESS) { - _hidl_cb(Status::OK, toHidlVec(output)); - } else { - ALOGE("OEMCrypto_Generic_Decrypt failed with %u", res); - _hidl_cb(mapAndNotifyOfOEMCryptoResult(sId, res), toHidlVec(output)); - } - return Void(); -} - -Return WVDrmPlugin::sign(const hidl_vec& sessionId, - const hidl_vec& keyId, - const hidl_vec& message, - sign_cb _hidl_cb) { - const std::vector sId = toVector(sessionId); - std::vector signature; - - CdmSessionId cdmSessionId(sId.begin(), sId.end()); - if (!mCryptoSessions.count(cdmSessionId)) { - _hidl_cb(Status::ERROR_DRM_SESSION_NOT_OPENED, toHidlVec(signature)); - return Void(); - } - - const CryptoSession& cryptoSession = mCryptoSessions[cdmSessionId]; - - if (cryptoSession.macAlgorithm() == kInvalidCryptoAlgorithm) { - ALOGW("Returns UNKNOWN error for legacy status NO_INIT"); - _hidl_cb(Status::ERROR_DRM_UNKNOWN, toHidlVec(signature)); - return Void(); - } - - const std::vector _keyId = toVector(keyId); - OEMCryptoResult res = mCrypto->selectKey(cryptoSession.oecSessionId(), - _keyId.data(), _keyId.size()); - - if (res != OEMCrypto_SUCCESS) { - ALOGE("OEMCrypto_SelectKey failed with %u", res); - _hidl_cb(mapAndNotifyOfOEMCryptoResult(sId, res), toHidlVec(signature)); - return Void(); - } - - size_t signatureSize = 0; - - const std::vector msg = toVector(message); - res = mCrypto->sign(cryptoSession.oecSessionId(), msg.data(), msg.size(), - cryptoSession.macAlgorithm(), NULL, &signatureSize); - - if (res != OEMCrypto_ERROR_SHORT_BUFFER) { - ALOGE( - "OEMCrypto_Generic_Sign failed with %u when requesting signature " - "size", - res); - if (res != OEMCrypto_SUCCESS) { - _hidl_cb(mapAndNotifyOfOEMCryptoResult(sId, res), toHidlVec(signature)); - } else { - _hidl_cb(Status::ERROR_DRM_UNKNOWN, toHidlVec(signature)); - } - return Void(); - } - - signature.resize(signatureSize); - - res = mCrypto->sign(cryptoSession.oecSessionId(), msg.data(), msg.size(), - cryptoSession.macAlgorithm(), signature.data(), - &signatureSize); - - if (res == OEMCrypto_SUCCESS) { - _hidl_cb(Status::OK, toHidlVec(signature)); - } else { - ALOGE("OEMCrypto_Generic_Sign failed with %u", res); - _hidl_cb(mapAndNotifyOfOEMCryptoResult(sId, res), toHidlVec(signature)); - } - return Void(); -} - -Return WVDrmPlugin::verify(const hidl_vec& sessionId, - const hidl_vec& keyId, - const hidl_vec& message, - const hidl_vec& signature, - verify_cb _hidl_cb) { - bool match = false; - const std::vector sId = toVector(sessionId); - - CdmSessionId cdmSessionId(sId.begin(), sId.end()); - if (!mCryptoSessions.count(cdmSessionId)) { - _hidl_cb(Status::ERROR_DRM_SESSION_NOT_OPENED, match); - return Void(); - } - - const CryptoSession& cryptoSession = mCryptoSessions[cdmSessionId]; - - if (cryptoSession.macAlgorithm() == kInvalidCryptoAlgorithm) { - ALOGW("Returns UNKNOWN error for legacy status NO_INIT"); - _hidl_cb(Status::ERROR_DRM_UNKNOWN, match); - return Void(); - } - - const std::vector _keyId = toVector(keyId); - OEMCryptoResult res = mCrypto->selectKey(cryptoSession.oecSessionId(), - _keyId.data(), _keyId.size()); - - if (res != OEMCrypto_SUCCESS) { - ALOGE("OEMCrypto_SelectKey failed with %u", res); - _hidl_cb(mapAndNotifyOfOEMCryptoResult(sId, res), match); - return Void(); - } - - const std::vector _message = toVector(message); - const std::vector _signature = toVector(signature); - res = mCrypto->verify(cryptoSession.oecSessionId(), _message.data(), - _message.size(), cryptoSession.macAlgorithm(), - _signature.data(), _signature.size()); - - if (res == OEMCrypto_SUCCESS) { - match = true; - _hidl_cb(Status::OK, match); - } else if (res == OEMCrypto_ERROR_SIGNATURE_FAILURE) { - match = false; - _hidl_cb(Status::OK, match); - } else { - ALOGE("OEMCrypto_Generic_Verify failed with %u", res); - _hidl_cb(mapAndNotifyOfOEMCryptoResult(sId, res), match); - } - return Void(); -} - -Return WVDrmPlugin::signRSA(const hidl_vec& sessionId, - const hidl_string& algorithm, - const hidl_vec& message, - const hidl_vec& wrappedKey, - signRSA_cb _hidl_cb) { - if (sessionId.size() == 0 || algorithm.size() == 0 || message.size() == 0 || - wrappedKey.size() == 0) { - _hidl_cb(Status::BAD_VALUE, hidl_vec()); - return Void(); - } - - const auto& self = android::hardware::IPCThreadState::self(); - const char* sid = self->getCallingSid(); - if (!sid || - (!strstr(sid, ":mediashell_app:") && !strstr(sid, ":mediadrmserver:") && - !strstr(sid, ":setupwraith_app:"))) { - ALOGE( - "Only mediashell/mediadrmserver/setupwraith_app can call signRSA, " - "but actually: %s", - sid); - _hidl_cb(Status::ERROR_DRM_UNKNOWN, hidl_vec()); - return Void(); - } - - const std::string algo(algorithm.c_str()); - std::vector signature; - - RSA_Padding_Scheme padding_scheme; - if (algo == "RSASSA-PSS-SHA1") { - padding_scheme = kSign_RSASSA_PSS; - } else if (algo == "PKCS1-BlockType1") { - padding_scheme = kSign_PKCS1_Block1; - } else { - ALOGE("Unknown RSA Algorithm %s", algo.c_str()); - _hidl_cb(Status::ERROR_DRM_CANNOT_HANDLE, toHidlVec(signature)); - return Void(); - } - - const std::vector msg = toVector(message); - const std::vector _wrappedKey = toVector(wrappedKey); - OEMCryptoResult res = - mCrypto->signRSA(_wrappedKey.data(), _wrappedKey.size(), msg.data(), - msg.size(), signature, padding_scheme); - - if (res != OEMCrypto_SUCCESS) { - ALOGE("OEMCrypto_GenerateRSASignature failed with %u", res); - _hidl_cb(mapOEMCryptoResult(res), toHidlVec(signature)); - return Void(); - } - - _hidl_cb(Status::OK, toHidlVec(signature)); - return Void(); -} - -Return WVDrmPlugin::setListener(const sp& listener) { - mListener = listener; - mListenerV1_2 = IDrmPluginListener_V1_2::castFrom(listener); - return Void(); -} - -Return WVDrmPlugin::sendEvent(EventType eventType, - const hidl_vec& sessionId, - const hidl_vec& data) { - Return err{}; - if (mListenerV1_2 != NULL) { - err = mListenerV1_2->sendEvent(eventType, sessionId, data); - } else if (mListener != NULL) { - err = mListener->sendEvent(eventType, sessionId, data); - } else { - ALOGE("Null event listener, event not sent"); - } - if (!err.isOk()) { - ALOGW("sendEvent failed %s", err.description().c_str()); - } - return err; -} - -Return WVDrmPlugin::sendExpirationUpdate( - const hidl_vec& sessionId, int64_t expiryTimeInMS) { - Return err{}; - if (mListenerV1_2 != NULL) { - err = mListenerV1_2->sendExpirationUpdate(sessionId, expiryTimeInMS); - } else if (mListener != NULL) { - err = mListener->sendExpirationUpdate(sessionId, expiryTimeInMS); - } else { - ALOGE("Null event listener, event not sent"); - } - if (!err.isOk()) { - ALOGW("sendExpirationUpdate failed %s", err.description().c_str()); - } - return err; -} - -template <> -void WVDrmPlugin::_sendKeysChange(const hidl_vec& sessionId, - const hidl_vec& keyStatusList, - bool hasNewUsableKey) { - auto err = - mListener->sendKeysChange(sessionId, keyStatusList, hasNewUsableKey); - if (!err.isOk()) { - ALOGW("sendKeysChange failed %s", err.description().c_str()); - } -} - -template <> -void WVDrmPlugin::_sendKeysChange(const hidl_vec& sessionId, - const hidl_vec& keyStatusList, - bool hasNewUsableKey) { - auto err = mListenerV1_2->sendKeysChange_1_2(sessionId, keyStatusList, - hasNewUsableKey); - if (!err.isOk()) { - ALOGW("sendKeysChange_1_2 failed %s", err.description().c_str()); - } -} - -Return WVDrmPlugin::sendKeysChange( - const hidl_vec& sessionId, - const hidl_vec& keyStatusList, bool hasNewUsableKey) { - Return err{}; - if (mListenerV1_2 != NULL) { - err = mListenerV1_2->sendKeysChange(sessionId, keyStatusList, - hasNewUsableKey); - } else if (mListener != NULL) { - err = mListener->sendKeysChange(sessionId, keyStatusList, hasNewUsableKey); - } else { - ALOGE("Null event listener, event not sent"); - } - if (!err.isOk()) { - ALOGW("sendKeysChange failed %s", err.description().c_str()); - } - return err; -} - -Return WVDrmPlugin::sendKeysChange_1_2( - const hidl_vec& sessionId, - const hidl_vec& keyStatusList, bool hasNewUsableKey) { - Return err{}; - if (mListenerV1_2 != NULL) { - err = mListenerV1_2->sendKeysChange_1_2(sessionId, keyStatusList, - hasNewUsableKey); - } else { - ALOGE("Null event listener, event not sent"); - } - if (!err.isOk()) { - ALOGW("sendKeysChange_1_2 failed %s", err.description().c_str()); - } - return err; -} - -Return WVDrmPlugin::sendSessionLostState( - const hidl_vec& sessionId) { - Return err{}; - if (mListenerV1_2 != NULL) { - err = mListenerV1_2->sendSessionLostState(sessionId); - } else { - ALOGE("Null event listener, event not sent"); - } - if (!err.isOk()) { - ALOGW("sendSessionLostState failed %s", err.description().c_str()); - } - return err; -} - -Return WVDrmPlugin::getLogMessages(getLogMessages_cb _hidl_cb) { - const std::vector &logs(wvutil::g_logbuf.getLogs()); - _hidl_cb(::drm::V1_4::Status::OK, toHidlVec<::drm::V1_4::LogMessage>(logs)); - return Void(); -} - -Return WVDrmPlugin::requiresSecureDecoder(const hidl_string& mime, - SecurityLevel level) { - if (!strncasecmp(mime.c_str(), "video/", 6)) { - // Type is video, so check level to see if we require a secure decoder. - return level == SecurityLevel::HW_SECURE_ALL || - level == SecurityLevel::HW_SECURE_DECODE; - } else { - // Type is not video, so never require a secure decoder. - return false; - } -} - -Return WVDrmPlugin::requiresSecureDecoderDefault( - const hidl_string& mime) { - if (!strncasecmp(mime.c_str(), "video/", 6)) { - // Type is video, so check level to see if we require a secure decoder. - std::string level(mPropertySet.security_level()); - - if (level == kResetSecurityLevel) { - mCDM->QueryStatus(wvcdm::kLevelDefault, wvcdm::QUERY_KEY_SECURITY_LEVEL, - &level); - } - - return level == wvcdm::QUERY_VALUE_SECURITY_LEVEL_L1; - } else { - // Type is not video, so never require a secure decoder. - return false; - } -} - -Return<::drm::V1_0::Status> WVDrmPlugin::setPlaybackId( - const hidl_vec& sessionId, const hidl_string& playbackId) { - const std::vector sId = toVector(sessionId); - CdmSessionId cdmSessionId(sId.begin(), sId.end()); - std::string cdmPlaybackId = playbackId; - CdmResponseType res = mCDM->SetPlaybackId(cdmSessionId, cdmPlaybackId); - return mapCdmResponseType(res); -} - -void WVDrmPlugin::OnSessionRenewalNeeded(const CdmSessionId& cdmSessionId) { - const std::vector sessionId = StrToVector(cdmSessionId); - const hidl_vec data; // data is ignored - const hidl_vec sid = toHidlVec(sessionId); - sendEvent(EventType::KEY_NEEDED, sid, data); -} - -void WVDrmPlugin::OnSessionKeysChange(const CdmSessionId& cdmSessionId, - const CdmKeyStatusMap& cdmKeysStatus, - bool hasNewUsableKey) { - if (mListenerV1_2 != NULL) { - _OnSessionKeysChange(cdmSessionId, cdmKeysStatus, - hasNewUsableKey); - } else if (mListener != NULL) { - _OnSessionKeysChange(cdmSessionId, cdmKeysStatus, - hasNewUsableKey); - } else { - ALOGE("Null event listener, event not sent"); - } -} - -template -void WVDrmPlugin::_OnSessionKeysChange(const CdmSessionId& cdmSessionId, - const CdmKeyStatusMap& cdmKeysStatus, - bool hasNewUsableKey) { - bool expired = false; - std::vector keyStatusList; - for (CdmKeyStatusMap::const_iterator it = cdmKeysStatus.begin(); - it != cdmKeysStatus.end(); ++it) { - const KeyId& keyId = it->first; - const CdmKeyStatus cdmKeyStatus = it->second; - if (cdmKeyStatus == wvcdm::kKeyStatusExpired) expired = true; - - KS keyStatus; - keyStatus.keyId = toHidlVec(StrToVector(keyId)); - keyStatus.type = - ConvertFromCdmKeyStatus(cdmKeyStatus); - keyStatusList.push_back(keyStatus); - } - - const std::vector sessionId = StrToVector(cdmSessionId); - const hidl_vec data; // data is ignored - const hidl_vec sid = toHidlVec(sessionId); - _sendKeysChange(sid, toHidlVec(keyStatusList), hasNewUsableKey); - // For backward compatibility. - if (expired) { - sendEvent(EventType::KEY_EXPIRED, sid, data); - } -} - -void WVDrmPlugin::OnExpirationUpdate(const CdmSessionId& cdmSessionId, - int64_t newExpiryTimeSeconds) { - const std::vector sessionId = StrToVector(cdmSessionId); - int64_t newExpiryTimeMilliseconds = - newExpiryTimeSeconds == wvcdm::NEVER_EXPIRES - ? newExpiryTimeSeconds - : newExpiryTimeSeconds * 1000; - - sendExpirationUpdate(toHidlVec(sessionId), newExpiryTimeMilliseconds); -} - -void WVDrmPlugin::OnSessionLostState(const CdmSessionId& cdmSessionId) { - const std::vector sessionId = StrToVector(cdmSessionId); - sendSessionLostState(toHidlVec(sessionId)); -} - -Status WVDrmPlugin::queryProperty(const std::string& property, - std::string& stringValue) const { - return queryProperty(getRequestedSecurityLevel(), property, stringValue); -} - -Status WVDrmPlugin::queryProperty(wvcdm::RequestedSecurityLevel securityLevel, - const std::string& property, - std::string& stringValue) const { - CdmResponseType res = - mCDM->QueryStatus(securityLevel, property, &stringValue); - - if (res != wvcdm::NO_ERROR) { - ALOGE("Error querying CDM status: %u", res); - } - return mapCdmResponseType(res); -} - -Status WVDrmPlugin::queryProperty(const std::string& property, - std::vector& vector_value) const { - std::string string_value; - Status status = queryProperty(property, string_value); - if (status != Status::OK) return status; - vector_value = StrToVector(string_value); - return Status::OK; -} - -bool WVDrmPlugin::isProvisioned(wvcdm::CdmSecurityLevel securityLevel, - const std::string& origin, - const std::string& spoid, - bool atsc_mode_enabled) const { - return mCDM->IsProvisioned(securityLevel, origin, spoid, atsc_mode_enabled); -} - -Status WVDrmPlugin::mapAndNotifyOfCdmResponseType( - const std::vector& sessionId, CdmResponseType res) { - notifyOfCdmResponseType(sessionId, res); - return mapCdmResponseType(res); -} - -Status_V1_2 WVDrmPlugin::mapAndNotifyOfCdmResponseType_1_2( - const std::vector& sessionId, CdmResponseType res) { - notifyOfCdmResponseType(sessionId, res); - return mapCdmResponseType(res); -} - -void WVDrmPlugin::notifyOfCdmResponseType(const std::vector& sessionId, - CdmResponseType res) { - const hidl_vec data; // data is ignored - if (res == wvcdm::NEED_PROVISIONING) { - sendEvent(EventType::PROVISION_REQUIRED, toHidlVec(sessionId), data); - } else if (res == wvcdm::NEED_KEY) { - sendEvent(EventType::KEY_NEEDED, toHidlVec(sessionId), data); - } -} - -Status WVDrmPlugin::mapAndNotifyOfOEMCryptoResult( - const std::vector& sessionId, OEMCryptoResult res) { - const hidl_vec data; // data is ignored - if (res == OEMCrypto_ERROR_NO_DEVICE_KEY) { - sendEvent(EventType::PROVISION_REQUIRED, toHidlVec(sessionId), data); - } - return mapOEMCryptoResult(res); -} - -Status WVDrmPlugin::mapOEMCryptoResult(OEMCryptoResult res) { - switch (res) { - case OEMCrypto_SUCCESS: - return Status::OK; - - case OEMCrypto_ERROR_SIGNATURE_FAILURE: - return Status::ERROR_DRM_INVALID_STATE; - - case OEMCrypto_ERROR_NO_DEVICE_KEY: - return Status::ERROR_DRM_NOT_PROVISIONED; - - case OEMCrypto_ERROR_INVALID_SESSION: - return Status::ERROR_DRM_SESSION_NOT_OPENED; - - case OEMCrypto_ERROR_TOO_MANY_SESSIONS: - case OEMCrypto_ERROR_INSUFFICIENT_RESOURCES: - return Status::ERROR_DRM_RESOURCE_BUSY; - - case OEMCrypto_ERROR_NOT_IMPLEMENTED: - return Status::ERROR_DRM_CANNOT_HANDLE; - - case OEMCrypto_ERROR_INVALID_RSA_KEY: - case OEMCrypto_ERROR_SHORT_BUFFER: - case OEMCrypto_ERROR_UNKNOWN_FAILURE: - case OEMCrypto_ERROR_OPEN_SESSION_FAILED: - FALLTHROUGH_INTENDED; /* FALLTHROUGH */ - default: - ALOGW("Returns UNKNOWN error for legacy status: %d", res); - return static_cast(::drm::V1_4::Status::GENERAL_OEM_ERROR); - } -} - -wvcdm::RequestedSecurityLevel WVDrmPlugin::getRequestedSecurityLevel() const { - return mPropertySet.security_level().compare( - wvcdm::QUERY_VALUE_SECURITY_LEVEL_L3) == 0 - ? wvcdm::kLevel3 - : wvcdm::kLevelDefault; -} - -bool WVDrmPlugin::initDataResemblesPSSH(const std::vector& initData) { - const uint8_t* const initDataArray = initData.data(); - - if (sizeof(uint32_t) + kPsshTag.size() > initData.size()) { - // The init data is so small that it couldn't contain a size and PSSH tag. - return false; - } - - // Extract the size field - const uint8_t* const sizeField = &initDataArray[0]; - uint32_t nboSize; - memcpy(&nboSize, sizeField, sizeof(nboSize)); - uint32_t size = ntohl(nboSize); - - if (size > initData.size()) { - return false; - } - - // Extract the ID field - const char* const idField = - reinterpret_cast(&initDataArray[sizeof(nboSize)]); - std::string id(idField, kPsshTag.size()); - return id == kPsshTag; -} - -Status WVDrmPlugin::unprovision(const CdmIdentifier& identifier) { - if (mPropertySet.use_atsc_mode()) - return mapCdmResponseType(wvcdm::PROVISIONING_NOT_ALLOWED_FOR_ATSC); - - CdmResponseType res1 = mCDM->Unprovision(wvcdm::kSecurityLevelL1, identifier); - CdmResponseType res3 = mCDM->Unprovision(wvcdm::kSecurityLevelL3, identifier); - if (!isCdmResponseTypeSuccess(res1)) { - return mapCdmResponseType(res1); - } else { - return mapCdmResponseType(res3); - } -} - -// Implementation for the CdmIdentifierBuilder inner class -WVDrmPlugin::CdmIdentifierBuilder::CdmIdentifierBuilder( - bool useSpoid, const WVDrmPlugin& parent, const std::string& appPackageName) - : mCdmIdentifier(), - mIsIdentifierSealed(false), - mUseSpoid(useSpoid), - mAppPackageName(appPackageName), - mParent(parent) { - mCdmIdentifier.app_package_name = mAppPackageName; - mCdmIdentifier.unique_id = getNextUniqueId(); - mCdmIdentifier.user_id = wvutil::GetIpcCallingUid(); -} - -Status WVDrmPlugin::CdmIdentifierBuilder::getCdmIdentifier( - CdmIdentifier* identifier) { - if (!mIsIdentifierSealed) { - Status res = calculateSpoid(); - if (res != Status::OK) return res; - mIsIdentifierSealed = true; - } - *identifier = mCdmIdentifier; - return Status::OK; -} - -Status WVDrmPlugin::CdmIdentifierBuilder::getDeviceUniqueId(std::string* id) { - if (mUseSpoid) { - CdmIdentifier identifier; - Status res = getCdmIdentifier(&identifier); - if (res != Status::OK) return res; - - *id = identifier.spoid; - return Status::OK; - } else { - return getOemcryptoDeviceId(id); - } -} - -Status WVDrmPlugin::CdmIdentifierBuilder::getProvisioningUniqueId( - std::string* id) { - if (mUseSpoid) { - // To fake a provisioning-unique ID on SPOID devices where we can't expose - // the real provisioning-unique ID, we just use the SPOID and invert all the - // bits. - Status res = getDeviceUniqueId(id); - if (res != Status::OK) return res; - - for (char& c : *id) { - c = ~c; - } - - return Status::OK; - } else { - return mParent.queryProperty(wvcdm::QUERY_KEY_PROVISIONING_ID, *id); - } -} - -bool WVDrmPlugin::CdmIdentifierBuilder::set_origin(const std::string& id) { - if (mIsIdentifierSealed) return false; - mCdmIdentifier.origin = id; - return true; -} - -bool WVDrmPlugin::CdmIdentifierBuilder::set_use_atsc_mode(bool enable) { - if (is_sealed()) return false; - mCdmIdentifier.app_package_name = - enable ? wvcdm::ATSC_APP_PACKAGE_NAME : mAppPackageName; - return true; -} - -Status WVDrmPlugin::CdmIdentifierBuilder::calculateSpoid() { - if (!mUseSpoid) return Status::OK; - - // Calculate SPOID for default security level if appropriate - std::string deviceId; - if (mParent.getRequestedSecurityLevel() == wvcdm::kLevelDefault) { - Status res = getOemcryptoDeviceId(&deviceId); - if (res != Status::OK) return res; - - return calculateSpoid(deviceId, &mCdmIdentifier.spoid); - } - - // If requested security level is L3, possibilities are - // (a) L3 has not been provisioned - // (b) L3 was provisioned with L3 device ID in the CdmIdentifier - // (c) L3 was provisioned (incorrectly) with L1 device ID in the CdmIdentifier - // Check (b) first. Get L3 device ID, calculate SPOID and if provisioned - // with this SPOID, return this SPOID. - // Check (c) next. Get L1 device ID, calculate SPOID and if provisioned - // with this SPOID, return this SPOID. - // On any errors in (c) or not provisioned return L3 SPOID. - Status res = getOemcryptoDeviceId(wvcdm::kLevel3, &deviceId); - if (res != Status::OK) return res; - - std::string spoidL3; - res = calculateSpoid(deviceId, &spoidL3); - if (res != Status::OK) return res; - - bool atsc_mode_enabled = - mCdmIdentifier.app_package_name == wvcdm::ATSC_APP_PACKAGE_NAME; - - if (mParent.isProvisioned(wvcdm::kSecurityLevelL3, origin(), spoidL3, - atsc_mode_enabled)) { - mCdmIdentifier.spoid = spoidL3; - return Status::OK; - } - - // Not provisioned with CdmIdentifier containing SPOID with L3 device ID. - // Try SPOID with L1 device ID. - std::string deviceIdLevelDefault; - res = getOemcryptoDeviceId(wvcdm::kLevelDefault, &deviceIdLevelDefault); - if (res != Status::OK) { - mCdmIdentifier.spoid = spoidL3; - return Status::OK; - } - - // If the L3 and default security level IDs are identical then the - // device does not support L1. - if (deviceId == deviceIdLevelDefault) { - mCdmIdentifier.spoid = spoidL3; - return Status::OK; - } - - std::string spoidLevelDefault; - res = calculateSpoid(deviceIdLevelDefault, &spoidLevelDefault); - if (res != Status::OK) { - mCdmIdentifier.spoid = spoidL3; - return Status::OK; - } - - if (mParent.isProvisioned(wvcdm::kSecurityLevelL1, origin(), - spoidLevelDefault, atsc_mode_enabled)) { - mCdmIdentifier.spoid = spoidLevelDefault; - return Status::OK; - } - - // Not provisioned with CdmIdentifier containing SPOID with L1 or L3 - // device ID. Return L3 SPOID. - mCdmIdentifier.spoid = spoidL3; - return Status::OK; -} - -Status WVDrmPlugin::CdmIdentifierBuilder::calculateSpoid( - const std::string& deviceId, std::string* spoid) { - if (spoid == nullptr) return Status::ERROR_DRM_CANNOT_HANDLE; - - if (!mUseSpoid) { - spoid->clear(); - return Status::OK; - } - - uint8_t hash[SHA256_DIGEST_LENGTH]; - SHA256_CTX ctx; - SHA256_Init(&ctx); - SHA256_Update(&ctx, deviceId.data(), deviceId.length()); - SHA256_Update(&ctx, mAppPackageName.data(), mAppPackageName.length()); - SHA256_Update(&ctx, origin().data(), origin().length()); - SHA256_Final(hash, &ctx); - - *spoid = std::string(reinterpret_cast(hash), SHA256_DIGEST_LENGTH); - return Status::OK; -} - -Status WVDrmPlugin::CdmIdentifierBuilder::getOemcryptoDeviceId( - std::string* id) { - return mParent.queryProperty(wvcdm::QUERY_KEY_DEVICE_ID, *id); -} - -Status WVDrmPlugin::CdmIdentifierBuilder::getOemcryptoDeviceId( - wvcdm::RequestedSecurityLevel securityLevel, std::string* id) { - return mParent.queryProperty(securityLevel, wvcdm::QUERY_KEY_DEVICE_ID, *id); -} - -uint32_t WVDrmPlugin::CdmIdentifierBuilder::getNextUniqueId() { - // Start with 1. 0 is reserved for the default cdm identifier. - static uint32_t unique_id = 1; - return ++unique_id; -} - -} // namespace widevine -} // namespace V1_4 -} // namespace drm -} // namespace hardware -} // namespace wvdrm diff --git a/libwvdrmengine/mediadrm/src_hidl/WVGenericCryptoInterface.cpp b/libwvdrmengine/mediadrm/src_hidl/WVGenericCryptoInterface.cpp deleted file mode 100644 index 9c788fb1..00000000 --- a/libwvdrmengine/mediadrm/src_hidl/WVGenericCryptoInterface.cpp +++ /dev/null @@ -1,50 +0,0 @@ -// -// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary -// source code may only be used and distributed under the Widevine License -// Agreement. -// - -//#define LOG_NDEBUG 0 -#define LOG_TAG "WVCdm" -#include - -#include "WVGenericCryptoInterface.h" - -#include "wv_cdm_constants.h" - -namespace wvdrm { - -using namespace std; -using namespace wvcdm; - -OEMCryptoResult WVGenericCryptoInterface::signRSA(const uint8_t* wrapped_rsa_key, - size_t wrapped_rsa_key_length, - const uint8_t* message, - size_t message_length, - std::vector& signature, - RSA_Padding_Scheme padding_scheme) { - OEMCrypto_SESSION session; - OEMCryptoResult sts = OEMCrypto_OpenSession(&session); - if (sts != OEMCrypto_SUCCESS) return sts; - sts = OEMCrypto_LoadDRMPrivateKey(session, OEMCrypto_RSA_Private_Key, - wrapped_rsa_key, wrapped_rsa_key_length); - if (sts == OEMCrypto_SUCCESS) { - size_t signatureSize = 0; - sts = OEMCrypto_GenerateRSASignature(session, message, message_length, - NULL, &signatureSize, - padding_scheme); - if (sts == OEMCrypto_SUCCESS) { - // Should be short buffer. - sts = OEMCrypto_ERROR_UNKNOWN_FAILURE; - } else if (sts == OEMCrypto_ERROR_SHORT_BUFFER) { - signature.resize(signatureSize); - sts = OEMCrypto_GenerateRSASignature(session, message, message_length, - signature.data(), &signatureSize, - padding_scheme); - } - } - OEMCrypto_CloseSession(session); - return sts; -} - -} // namespace wvdrm diff --git a/libwvdrmengine/mediadrm/src_hidl/hidl_metrics_adapter.cpp b/libwvdrmengine/mediadrm/src_hidl/hidl_metrics_adapter.cpp deleted file mode 100644 index c770a669..00000000 --- a/libwvdrmengine/mediadrm/src_hidl/hidl_metrics_adapter.cpp +++ /dev/null @@ -1,650 +0,0 @@ -// -// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary -// source code may only be used and distributed under the Widevine License -// Agreement. -// - -#include "hidl_metrics_adapter.h" - -#include -#include "wv_metrics.pb.h" - -using android::hardware::hidl_vec; -using android::hardware::drm::V1_1::DrmMetricGroup; -using drm_metrics::CounterMetric; -using drm_metrics::DistributionMetric; -using google::protobuf::RepeatedPtrField; - -namespace wvcdm { - -namespace { - -const char kAttributeErrorCode[] = "error_code"; -const char kAttributeErrorCodeBool[] = "error_code_bool"; -const char kAttributeCdmSecurityLevel[] = "cdm_security_level"; -const char kAttributeSecurityLevel[] = "security_level"; -const char kAttributeLength[] = "length"; -const char kAttributeEncryptionAlgorithm[] = "encryption_algorithm"; -const char kAttributeSigningAlgorithm[] = "signing_algorithm"; -const char kAttributeOemCryptoResult[] = "oem_crypto_result"; -const char kAttributeKeyStatusType[] = "key_status_type"; -const char kAttributeEventType[] = "event_type"; -const char kAttributeKeyRequestType[] = "key_request_type"; -const char kAttributeLicenseType[] = "license_type"; - -template -void SetValue(const T& value, DrmMetricGroup::Attribute* attribute); - -template<> -void SetValue(const int& value, DrmMetricGroup::Attribute* attribute) { - attribute->int64Value = value; -} -template<> -void SetValue(const bool& value, DrmMetricGroup::Attribute* attribute) { - attribute->int64Value = value; -} -template<> -void SetValue(const unsigned int& value, - DrmMetricGroup::Attribute* attribute) { - attribute->int64Value = value; -} -template<> -__attribute__((unused)) -void SetValue(const unsigned long& value, - DrmMetricGroup::Attribute* attribute) { - attribute->int64Value = value; -} -template<> -__attribute__((unused)) -void SetValue(const unsigned long long& value, - DrmMetricGroup::Attribute* attribute) { - attribute->int64Value = value; -} - -template -void AddAttribute( - const std::string& name, DrmMetricGroup::ValueType vt, T value, - std::vector* attribute_vector) { - // Set the default values. - DrmMetricGroup::Attribute attribute = { name, vt, 0, 0, "" }; - SetValue(value, &attribute); - attribute_vector->push_back(attribute); -} - -} // anonymous namespace - -void HidlMetricsGroupBuilder::AddDistributions( - const std::string& name, - const RepeatedPtrField& distributions) { - for (const auto& metric : distributions) { - AddDistribution(name, metric); - } -} - -void HidlMetricsGroupBuilder::AddCounters( - const std::string& name, - const RepeatedPtrField& counters) { - for (const auto& counter : counters) { - AddCounter(name, counter); - } -} - -void HidlMetricsGroupBuilder::AddDistribution( - const std::string& name, const drm_metrics::DistributionMetric& distribution) { - DrmMetricGroup::Metric metric; - metric.name = name; - AddAttributes(distribution.attributes(), &(metric.attributes)); - - DrmMetricGroup::Value mean = { - "mean", DrmMetricGroup::ValueType::DOUBLE_TYPE, - 0, distribution.mean(), "" }; - DrmMetricGroup::Value count = { - "count", DrmMetricGroup::ValueType::INT64_TYPE, - (int64_t) distribution.operation_count(), 0, "" }; - - if (distribution.operation_count() == 1) { - metric.values.resize(2); - metric.values[0] = mean; - metric.values[1] = count; - } else { - DrmMetricGroup::Value min = { - "min", DrmMetricGroup::ValueType::DOUBLE_TYPE, - 0, distribution.min(), "" }; - DrmMetricGroup::Value max = { - "max", DrmMetricGroup::ValueType::DOUBLE_TYPE, - 0, distribution.max(), "" }; - DrmMetricGroup::Value variance { - "variance", DrmMetricGroup::ValueType::DOUBLE_TYPE, - 0, distribution.variance(), "" }; - metric.values.resize(5); - metric.values[0] = mean; - metric.values[1] = count; - metric.values[2] = min; - metric.values[3] = max; - metric.values[4] = variance; - } - metrics_.push_back(metric); -} - -void HidlMetricsGroupBuilder::AddCounter( - const std::string& name, const drm_metrics::CounterMetric& counter) { - DrmMetricGroup::Metric metric; - metric.name = name; - AddAttributes(counter.attributes(), &(metric.attributes)); - - DrmMetricGroup::Value value = { - "count", DrmMetricGroup::ValueType::INT64_TYPE, counter.count(), 0, "" }; - metric.values.resize(1); - metric.values[0] = value; - metrics_.push_back(metric); -} - -void HidlMetricsGroupBuilder::AddValue( - const std::string& name, const drm_metrics::ValueMetric& value_or_error) { - DrmMetricGroup::Metric metric; - DrmMetricGroup::Value value; - - metric.name = name; - if (value_or_error.has_error_code()) { - value = { "error_code", DrmMetricGroup::ValueType::INT64_TYPE, - value_or_error.error_code(), 0, "" }; - } else if (value_or_error.has_int_value()) { - value = { "value", DrmMetricGroup::ValueType::INT64_TYPE, - value_or_error.int_value(), 0, "" }; - } else if (value_or_error.has_double_value()) { - value = { "value", DrmMetricGroup::ValueType::DOUBLE_TYPE, - 0, value_or_error.double_value(), "" }; - } else if (value_or_error.has_string_value()) { - value = { "value", DrmMetricGroup::ValueType::STRING_TYPE, - 0, 0, value_or_error.string_value() }; - } else { - value = { "error", DrmMetricGroup::ValueType::STRING_TYPE, - 0, 0, "Unexpected value type." }; - } - metric.values.resize(1); - metric.values[0] = value; - metrics_.push_back(metric); -} - -void HidlMetricsGroupBuilder::AddAttributes( - const drm_metrics::Attributes& attributes_proto, - hidl_vec* - attributes) { - std::vector - attribute_vector; - if (attributes_proto.has_error_code()) { - AddAttribute( - kAttributeErrorCode, - DrmMetricGroup::ValueType::INT64_TYPE, - attributes_proto.error_code(), &attribute_vector); - } - if (attributes_proto.has_error_code_bool()) { - AddAttribute( - kAttributeErrorCodeBool, - DrmMetricGroup::ValueType::INT64_TYPE, - attributes_proto.error_code_bool(), &attribute_vector); - } - if (attributes_proto.has_cdm_security_level()) { - AddAttribute( - kAttributeCdmSecurityLevel, - DrmMetricGroup::ValueType::INT64_TYPE, - attributes_proto.cdm_security_level(), &attribute_vector); - } - if (attributes_proto.has_security_level()) { - AddAttribute( - kAttributeSecurityLevel, - DrmMetricGroup::ValueType::INT64_TYPE, - attributes_proto.security_level(), &attribute_vector); - } - if (attributes_proto.has_length()) { - AddAttribute( - kAttributeLength, - DrmMetricGroup::ValueType::INT64_TYPE, - attributes_proto.length(), &attribute_vector); - } - if (attributes_proto.has_encryption_algorithm()) { - AddAttribute( - kAttributeEncryptionAlgorithm, - DrmMetricGroup::ValueType::INT64_TYPE, - attributes_proto.encryption_algorithm(), &attribute_vector); - } - if (attributes_proto.has_signing_algorithm()) { - AddAttribute( - kAttributeSigningAlgorithm, - DrmMetricGroup::ValueType::INT64_TYPE, - attributes_proto.signing_algorithm(), &attribute_vector); - } - if (attributes_proto.has_oem_crypto_result()) { - AddAttribute( - kAttributeOemCryptoResult, - DrmMetricGroup::ValueType::INT64_TYPE, - attributes_proto.oem_crypto_result(), &attribute_vector); - } - if (attributes_proto.has_key_status_type()) { - AddAttribute( - kAttributeKeyStatusType, - DrmMetricGroup::ValueType::INT64_TYPE, - attributes_proto.key_status_type(), &attribute_vector); - } - if (attributes_proto.has_event_type()) { - AddAttribute( - kAttributeEventType, - DrmMetricGroup::ValueType::INT64_TYPE, - attributes_proto.event_type(), &attribute_vector); - } - if (attributes_proto.has_key_request_type()) { - AddAttribute( - kAttributeKeyRequestType, - DrmMetricGroup::ValueType::INT64_TYPE, - attributes_proto.key_request_type(), &attribute_vector); - } - if (attributes_proto.has_license_type()) { - AddAttribute( - kAttributeLicenseType, - DrmMetricGroup::ValueType::INT64_TYPE, - attributes_proto.license_type(), &attribute_vector); - } - - *attributes = attribute_vector; -} - -DrmMetricGroup HidlMetricsGroupBuilder::Build() { - DrmMetricGroup metric_group; - metric_group.metrics = metrics_; - return metric_group; -} - -HidlMetricsGroupBuilder::HidlMetricsGroupBuilder() {} - -HidlMetricsAdapter::HidlMetricsAdapter() {} -HidlMetricsAdapter::~HidlMetricsAdapter() {} - -void HidlMetricsAdapter::AddEngineMetrics( - const drm_metrics::WvCdmMetrics::EngineMetrics& proto_metrics) { - HidlMetricsGroupBuilder group_builder; - AddCryptoMetrics(proto_metrics.crypto_metrics(), &group_builder); - - if (proto_metrics.has_oemcrypto_initialization_mode()) { - group_builder.AddValue( - "oemcrypto_initialization_mode", - proto_metrics.oemcrypto_initialization_mode()); - } - if (proto_metrics.has_oemcrypto_l1_api_version()) { - group_builder.AddValue( - "oemcrypto_l1_api_version", - proto_metrics.oemcrypto_l1_api_version()); - } - if (proto_metrics.has_oemcrypto_l1_min_api_version()) { - group_builder.AddValue( - "oemcrypto_l1_min_api_version", - proto_metrics.oemcrypto_l1_min_api_version()); - } - if (proto_metrics.has_app_package_name()) { - group_builder.AddValue( - "app_package_name", - proto_metrics.app_package_name()); - } - group_builder.AddDistributions( - "cdm_engine_add_key_time_us", - proto_metrics.cdm_engine_add_key_time_us()); - if (proto_metrics.has_cdm_engine_cdm_version()) { - group_builder.AddValue( - "cdm_engine_cdm_version", - proto_metrics.cdm_engine_cdm_version()); - } - group_builder.AddCounters( - "cdm_engine_close_session", - proto_metrics.cdm_engine_close_session()); - if (proto_metrics.has_cdm_engine_creation_time_millis()) { - group_builder.AddValue( - "cdm_engine_creation_time_millis", - proto_metrics.cdm_engine_creation_time_millis()); - } - group_builder.AddDistributions( - "cdm_engine_decrypt_time_us", - proto_metrics.cdm_engine_decrypt_time_us()); - group_builder.AddCounters( - "cdm_engine_find_session_for_key", - proto_metrics.cdm_engine_find_session_for_key()); - group_builder.AddDistributions( - "cdm_engine_generate_key_request_time_us", - proto_metrics.cdm_engine_generate_key_request_time_us()); - group_builder.AddDistributions( - "cdm_engine_get_provisioning_request_time_us", - proto_metrics.cdm_engine_get_provisioning_request_time_us()); - group_builder.AddCounters( - "cdm_engine_get_secure_stop_ids", - proto_metrics.cdm_engine_get_secure_stop_ids()); - group_builder.AddDistributions( - "cdm_engine_get_usage_info_time_us", - proto_metrics.cdm_engine_get_usage_info_time_us()); - group_builder.AddDistributions( - "cdm_engine_handle_provisioning_response_time_us", - proto_metrics.cdm_engine_handle_provisioning_response_time_us()); - if (proto_metrics.has_cdm_engine_life_span_ms()) { - group_builder.AddValue( - "cdm_engine_life_span_ms", - proto_metrics.cdm_engine_life_span_ms()); - } - group_builder.AddCounters( - "cdm_engine_open_key_set_session", - proto_metrics.cdm_engine_open_key_set_session()); - group_builder.AddCounters( - "cdm_engine_open_session", - proto_metrics.cdm_engine_open_session()); - group_builder.AddDistributions( - "cdm_engine_query_key_status_time_us", - proto_metrics.cdm_engine_query_key_status_time_us()); - group_builder.AddCounters( - "cdm_engine_release_all_usage_info", - proto_metrics.cdm_engine_release_all_usage_info()); - group_builder.AddCounters( - "cdm_engine_release_usage_info", - proto_metrics.cdm_engine_release_usage_info()); - group_builder.AddCounters( - "cdm_engine_remove_all_usage_info", - proto_metrics.cdm_engine_remove_all_usage_info()); - group_builder.AddCounters( - "cdm_engine_remove_keys", - proto_metrics.cdm_engine_remove_keys()); - group_builder.AddCounters( - "cdm_engine_remove_usage_info", - proto_metrics.cdm_engine_remove_usage_info()); - group_builder.AddDistributions( - "cdm_engine_restore_key_time_us", - proto_metrics.cdm_engine_restore_key_time_us()); - group_builder.AddCounters( - "cdm_engine_unprovision", - proto_metrics.cdm_engine_unprovision()); - if (proto_metrics.has_level3_oemcrypto_initialization_error()) { - group_builder.AddValue( - "level3_oemcrypto_initialization_error", - proto_metrics.level3_oemcrypto_initialization_error()); - } - if (proto_metrics.has_previous_oemcrypto_initialization_failure()) { - group_builder.AddValue( - "previous_oemcrypto_initialization_failure", - proto_metrics.previous_oemcrypto_initialization_failure()); - } - - group_vector_.emplace_back(group_builder.Build()); -} - -void HidlMetricsAdapter::AddSessionMetrics( - const drm_metrics::WvCdmMetrics::SessionMetrics& proto_metrics) { - HidlMetricsGroupBuilder group_builder; - AddCryptoMetrics(proto_metrics.crypto_metrics(), &group_builder); - - if (proto_metrics.has_session_id()) { - group_builder.AddValue( - "session_id", - proto_metrics.session_id()); - } - if (proto_metrics.has_cdm_session_life_span_ms()) { - group_builder.AddValue( - "cdm_session_life_span_ms", - proto_metrics.cdm_session_life_span_ms()); - } - group_builder.AddDistributions( - "cdm_session_renew_key_time_us", - proto_metrics.cdm_session_renew_key_time_us()); - group_builder.AddCounters( - "cdm_session_restore_offline_session", - proto_metrics.cdm_session_restore_offline_session()); - group_builder.AddCounters( - "cdm_session_restore_usage_session", - proto_metrics.cdm_session_restore_usage_session()); - group_builder.AddDistributions( - "cdm_session_license_request_latency_ms", - proto_metrics.cdm_session_license_request_latency_ms()); - if (proto_metrics.has_oemcrypto_build_info()) { - group_builder.AddValue( - "oemcrypto_build_info", - proto_metrics.oemcrypto_build_info()); - } - if (proto_metrics.has_license_sdk_version()) { - group_builder.AddValue( - "license_sdk_version", - proto_metrics.license_sdk_version()); - } - if (proto_metrics.has_license_service_version()) { - group_builder.AddValue( - "license_service_version", - proto_metrics.license_service_version()); - } - if (proto_metrics.has_playback_id()) { - group_builder.AddValue( - "playback_id", - proto_metrics.playback_id()); - } - group_vector_.emplace_back(group_builder.Build()); -} - -void HidlMetricsAdapter::AddCryptoMetrics( - const drm_metrics::WvCdmMetrics::CryptoMetrics& proto_metrics, - HidlMetricsGroupBuilder* group_builder) { - if (proto_metrics.has_crypto_session_security_level()) { - group_builder->AddValue( - "crypto_session_security_level", - proto_metrics.crypto_session_security_level()); - } - group_builder->AddCounters( - "crypto_session_delete_all_usage_reports", - proto_metrics.crypto_session_delete_all_usage_reports()); - group_builder->AddCounters( - "crypto_session_delete_multiple_usage_information", - proto_metrics.crypto_session_delete_multiple_usage_information()); - group_builder->AddDistributions( - "crypto_session_generic_decrypt_time_us", - proto_metrics.crypto_session_generic_decrypt_time_us()); - group_builder->AddDistributions( - "crypto_session_generic_encrypt_time_us", - proto_metrics.crypto_session_generic_encrypt_time_us()); - group_builder->AddDistributions( - "crypto_session_generic_sign_time_us", - proto_metrics.crypto_session_generic_sign_time_us()); - group_builder->AddDistributions( - "crypto_session_generic_verify_time_us", - proto_metrics.crypto_session_generic_verify_time_us()); - group_builder->AddCounters( - "crypto_session_get_device_unique_id", - proto_metrics.crypto_session_get_device_unique_id()); - group_builder->AddCounters( - "crypto_session_get_token", - proto_metrics.crypto_session_get_token()); - if (proto_metrics.has_crypto_session_life_span()) { - group_builder->AddValue("crypto_session_life_span", - proto_metrics.crypto_session_life_span()); - } - group_builder->AddDistributions( - "crypto_session_load_certificate_private_key_time_us", - proto_metrics.crypto_session_load_certificate_private_key_time_us()); - group_builder->AddDistributions( - "crypto_session_open_time_us", - proto_metrics.crypto_session_open_time_us()); - if (proto_metrics.has_crypto_session_system_id()) { - group_builder->AddValue("crypto_session_system_id", - proto_metrics.crypto_session_system_id()); - } - group_builder->AddDistributions( - "crypto_session_update_usage_information_time_us", - proto_metrics.crypto_session_update_usage_information_time_us()); - if (proto_metrics.has_crypto_session_usage_information_support()) { - group_builder->AddValue("crypto_session_usage_information_support", - proto_metrics.crypto_session_usage_information_support()); - } - if (proto_metrics.has_usage_table_header_initial_size()) { - group_builder->AddValue("usage_table_header_initial_size", - proto_metrics.usage_table_header_initial_size()); - } - group_builder->AddCounters( - "usage_table_header_add_entry", - proto_metrics.usage_table_header_add_entry()); - group_builder->AddCounters( - "usage_table_header_delete_entry", - proto_metrics.usage_table_header_delete_entry()); - group_builder->AddDistributions( - "usage_table_header_update_entry_time_us", - proto_metrics.usage_table_header_update_entry_time_us()); - group_builder->AddCounters( - "usage_table_header_load_entry", - proto_metrics.usage_table_header_load_entry()); - if (proto_metrics.has_oemcrypto_api_version()) { - group_builder->AddValue("oemcrypto_api_version", - proto_metrics.oemcrypto_api_version()); - } - group_builder->AddCounters( - "oemcrypto_close_session", - proto_metrics.oemcrypto_close_session()); - group_builder->AddDistributions( - "oemcrypto_copy_buffer_time_us", - proto_metrics.oemcrypto_copy_buffer_time_us()); - if (proto_metrics.has_oemcrypto_current_hdcp_capability()) { - group_builder->AddValue("oemcrypto_current_hdcp_capability", - proto_metrics.oemcrypto_current_hdcp_capability()); - } - group_builder->AddCounters( - "oemcrypto_deactivate_usage_entry", - proto_metrics.oemcrypto_deactivate_usage_entry()); - group_builder->AddDistributions( - "oemcrypto_decrypt_cenc_time_us", - proto_metrics.oemcrypto_decrypt_cenc_time_us()); - group_builder->AddCounters( - "oemcrypto_delete_usage_entry", - proto_metrics.oemcrypto_delete_usage_entry()); - group_builder->AddCounters( - "oemcrypto_delete_usage_table", - proto_metrics.oemcrypto_delete_usage_table()); - group_builder->AddDistributions( - "oemcrypto_derive_keys_from_session_key_time_us", - proto_metrics.oemcrypto_derive_keys_from_session_key_time_us()); - group_builder->AddCounters( - "oemcrypto_force_delete_usage_entry", - proto_metrics.oemcrypto_force_delete_usage_entry()); - group_builder->AddDistributions( - "oemcrypto_generate_derived_keys_time_us", - proto_metrics.oemcrypto_generate_derived_keys_time_us()); - group_builder->AddCounters( - "oemcrypto_generate_nonce", - proto_metrics.oemcrypto_generate_nonce()); - group_builder->AddDistributions( - "oemcrypto_generate_rsa_signature_time_us", - proto_metrics.oemcrypto_generate_rsa_signature_time_us()); - group_builder->AddDistributions( - "oemcrypto_generate_signature_time_us", - proto_metrics.oemcrypto_generate_signature_time_us()); - group_builder->AddDistributions( - "oemcrypto_generic_decrypt_time_us", - proto_metrics.oemcrypto_generic_decrypt_time_us()); - group_builder->AddDistributions( - "oemcrypto_generic_encrypt_time_us", - proto_metrics.oemcrypto_generic_encrypt_time_us()); - group_builder->AddDistributions( - "oemcrypto_generic_sign_time_us", - proto_metrics.oemcrypto_generic_sign_time_us()); - group_builder->AddDistributions( - "oemcrypto_generic_verify_time_us", - proto_metrics.oemcrypto_generic_verify_time_us()); - group_builder->AddCounters( - "oemcrypto_get_device_id", - proto_metrics.oemcrypto_get_device_id()); - group_builder->AddDistributions( - "oemcrypto_get_key_data_time_us", - proto_metrics.oemcrypto_get_key_data_time_us()); - group_builder->AddCounters( - "oemcrypto_get_oem_public_certificate", - proto_metrics.oemcrypto_get_oem_public_certificate()); - group_builder->AddCounters( - "oemcrypto_get_random", - proto_metrics.oemcrypto_get_random()); - group_builder->AddDistributions( - "oemcrypto_initialize_time_us", - proto_metrics.oemcrypto_initialize_time_us()); - if (proto_metrics.has_oemcrypto_is_anti_rollback_hw_present()) { - group_builder->AddValue( - "oemcrypto_is_anti_rollback_hw_present", - proto_metrics.oemcrypto_is_anti_rollback_hw_present()); - } - if (proto_metrics.has_oemcrypto_is_keybox_valid()) { - group_builder->AddValue("oemcrypto_is_keybox_valid", - proto_metrics.oemcrypto_is_keybox_valid()); - } - group_builder->AddDistributions( - "oemcrypto_load_device_drm_key_time_us", - proto_metrics.oemcrypto_load_device_drm_key_time_us()); - group_builder->AddDistributions( - "oemcrypto_load_entitled_keys_time_us", - proto_metrics.oemcrypto_load_entitled_keys_time_us()); - group_builder->AddDistributions( - "oemcrypto_load_keys_time_us", - proto_metrics.oemcrypto_load_keys_time_us()); - if (proto_metrics.has_oemcrypto_max_hdcp_capability()) { - group_builder->AddValue("oemcrypto_max_hdcp_capability", - proto_metrics.oemcrypto_max_hdcp_capability()); - } - if (proto_metrics.has_oemcrypto_max_number_of_sessions()) { - group_builder->AddValue("oemcrypto_max_number_of_sessions", - proto_metrics.oemcrypto_max_number_of_sessions()); - } - if (proto_metrics.has_oemcrypto_number_of_open_sessions()) { - group_builder->AddValue("oemcrypto_number_of_open_sessions", - proto_metrics.oemcrypto_number_of_open_sessions()); - } - if (proto_metrics.has_oemcrypto_provisioning_method()) { - group_builder->AddValue("oemcrypto_provisioning_method", - proto_metrics.oemcrypto_provisioning_method()); - } - group_builder->AddDistributions( - "oemcrypto_refresh_keys_time_us", - proto_metrics.oemcrypto_refresh_keys_time_us()); - group_builder->AddCounters( - "oemcrypto_report_usage", - proto_metrics.oemcrypto_report_usage()); - group_builder->AddDistributions( - "oemcrypto_rewrap_device_rsa_key_time_us", - proto_metrics.oemcrypto_rewrap_device_rsa_key_time_us()); - group_builder->AddDistributions( - "oemcrypto_rewrap_device_rsa_key_30_time_us", - proto_metrics.oemcrypto_rewrap_device_rsa_key_30_time_us()); - if (proto_metrics.has_oemcrypto_security_patch_level()) { - group_builder->AddValue("oemcrypto_security_patch_level", - proto_metrics.oemcrypto_security_patch_level()); - } - group_builder->AddDistributions( - "oemcrypto_select_key_time_us", - proto_metrics.oemcrypto_select_key_time_us()); - if (proto_metrics.has_oemcrypto_usage_table_support()) { - group_builder->AddValue("oemcrypto_usage_table_support", - proto_metrics.oemcrypto_usage_table_support()); - } - group_builder->AddCounters( - "oemcrypto_update_usage_table", - proto_metrics.oemcrypto_update_usage_table()); - group_builder->AddCounters( - "oemcrypto_update_usage_entry", - proto_metrics.oemcrypto_update_usage_entry()); -} - -const android::hardware::hidl_vec< - DrmMetricGroup> -HidlMetricsAdapter::GetHidlGroupVector() { - return group_vector_; -} - -void HidlMetricsAdapter::ToHidlMetrics( - const drm_metrics::WvCdmMetrics& proto_metrics, - hidl_vec* hidl_metrics) { - // Convert the engine level metrics - HidlMetricsAdapter adapter; - - if (proto_metrics.has_engine_metrics()) { - adapter.AddEngineMetrics(proto_metrics.engine_metrics()); - } - for (const auto& session_metrics : proto_metrics.session_metrics()) { - adapter.AddSessionMetrics(session_metrics); - } - - *hidl_metrics = adapter.GetHidlGroupVector(); -} - -} // namespace wvcdm diff --git a/libwvdrmengine/mediadrm/test/Android.mk b/libwvdrmengine/mediadrm/test/Android.mk index 428e652f..45a91b57 100644 --- a/libwvdrmengine/mediadrm/test/Android.mk +++ b/libwvdrmengine/mediadrm/test/Android.mk @@ -5,56 +5,7 @@ LOCAL_PATH := $(call my-dir) # include $(CLEAR_VARS) -WV_UNITTESTS_BUILD_TARGET?= -ifeq ($(WV_UNITTESTS_BUILD_TARGET), hidl) - -LOCAL_SRC_FILES := \ - hidl/WVDrmPlugin_test.cpp \ - -LOCAL_C_INCLUDES := \ - frameworks/av/include \ - frameworks/native/include \ - vendor/widevine/libwvdrmengine/cdm/core/include \ - vendor/widevine/libwvdrmengine/cdm/include \ - vendor/widevine/libwvdrmengine/cdm/metrics/include \ - vendor/widevine/libwvdrmengine/cdm/util/include \ - vendor/widevine/libwvdrmengine/include_hidl \ - vendor/widevine/libwvdrmengine/include \ - vendor/widevine/libwvdrmengine/mediadrm/include_hidl \ - vendor/widevine/libwvdrmengine/oemcrypto/include \ - -LOCAL_STATIC_LIBRARIES := \ - libcdm \ - libcdm_protos \ - libcdm_utils \ - libjsmn \ - libgmock \ - libgmock_main \ - libgtest \ - libwvlevel3 \ - libwvdrmdrmplugin_hidl \ - libwv_odk \ - -LOCAL_SHARED_LIBRARIES := \ - android.hardware.drm@1.0 \ - android.hardware.drm@1.1 \ - android.hardware.drm@1.2 \ - android.hardware.drm@1.3 \ - android.hardware.drm@1.4 \ - android.hidl.memory@1.0 \ - libbinder_ndk \ - libbase \ - libcrypto \ - libdl \ - libhidlbase \ - libhidlmemory \ - liblog \ - libprotobuf-cpp-lite \ - libutils \ - # build unit tests for Aidl -else - LOCAL_SRC_FILES := \ WVDrmPlugin_hal_test.cpp \ @@ -90,8 +41,6 @@ LOCAL_SHARED_LIBRARIES := \ liblog \ libprotobuf-cpp-lite \ libutils \ -# endif $(WV_UNITTESTS_BUILD_TARGET) -endif LOCAL_HEADER_LIBRARIES := \ libstagefright_headers \ @@ -119,53 +68,10 @@ endif include $(BUILD_EXECUTABLE) # ----------------------------------------------------------------------------- -# Builds hidl hal_metrics_adapter_unittest +# Builds hal_metrics_adapter_unittest # include $(CLEAR_VARS) -WV_UNITTESTS_BUILD_TARGET?= -ifeq ($(WV_UNITTESTS_BUILD_TARGET), hidl) - -LOCAL_SRC_FILES := \ - hidl/hidl_metrics_adapter_unittest.cpp \ - -LOCAL_C_INCLUDES := \ - vendor/widevine/libwvdrmengine/cdm/core/include \ - vendor/widevine/libwvdrmengine/cdm/include \ - vendor/widevine/libwvdrmengine/cdm/metrics/include \ - vendor/widevine/libwvdrmengine/cdm/util/include \ - vendor/widevine/libwvdrmengine/include_hidl \ - vendor/widevine/libwvdrmengine/include \ - vendor/widevine/libwvdrmengine/mediadrm/include_hidl \ - vendor/widevine/libwvdrmengine/oemcrypto/include \ - -LOCAL_STATIC_LIBRARIES := \ - libcdm \ - libcdm_protos \ - libcdm_utils \ - libgtest \ - libgtest_main \ - libjsmn \ - libwvdrmdrmplugin_hidl \ - libwvlevel3 \ - libwv_odk \ - -LOCAL_SHARED_LIBRARIES := \ - android.hardware.drm@1.0 \ - android.hardware.drm@1.1 \ - android.hardware.drm@1.2 \ - android.hidl.memory@1.0 \ - libcrypto \ - libhidlbase \ - libhidlmemory \ - liblog \ - libprotobuf-cpp-lite \ - -LOCAL_C_INCLUDES += \ - external/protobuf/src \ - -# build unit tests for Aidl -else LOCAL_SRC_FILES := \ hal_metrics_adapter_unittest.cpp \ @@ -199,9 +105,6 @@ LOCAL_SHARED_LIBRARIES := \ LOCAL_C_INCLUDES += \ external/protobuf/src \ -# endif $(WV_UNITTESTS_BUILD_TARGET) -endif - LOCAL_MODULE := hal_metrics_adapter_unittest LOCAL_LICENSE_KINDS := legacy_by_exception_only LOCAL_LICENSE_CONDITIONS := by_exception_only diff --git a/libwvdrmengine/mediadrm/test/hal_metrics_adapter_unittest.cpp b/libwvdrmengine/mediadrm/test/hal_metrics_adapter_unittest.cpp index a81be10b..af438b33 100644 --- a/libwvdrmengine/mediadrm/test/hal_metrics_adapter_unittest.cpp +++ b/libwvdrmengine/mediadrm/test/hal_metrics_adapter_unittest.cpp @@ -305,7 +305,7 @@ TEST(HalMetricsAdapterTest, AddAllAttrbitues) { {DrmMetricValue::make(59)}}}, {{"count", {DrmMetricValue::make(13)}}}}; - // Confirm that all of the attributes exist in the hidl data. + // Confirm that all of the attributes exist in the HAL data. std::vector metrics; WvMetricsAdapter::ToWvMetrics(metrics_proto, &metrics); EXPECT_TRUE(HasMetric(expected_counter_metric, metrics[0])) diff --git a/libwvdrmengine/mediadrm/test/hidl/WVDrmPlugin_test.cpp b/libwvdrmengine/mediadrm/test/hidl/WVDrmPlugin_test.cpp deleted file mode 100644 index 95215a9c..00000000 --- a/libwvdrmengine/mediadrm/test/hidl/WVDrmPlugin_test.cpp +++ /dev/null @@ -1,3264 +0,0 @@ -// -// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary -// source code may only be used and distributed under the Widevine License -// Agreement. -// -//#define LOG_NDEBUG 0 -#define LOG_TAG "WVDrmPluginTest" -#include "WVDrmPlugin.h" - -#include -#include - -#include -#include -#include -#include - -#include "HidlTypes.h" -#include "TypeConvert.h" -#include "WVErrors.h" -#include "cdm_client_property_set.h" -#include "gmock/gmock.h" -#include "gtest/gtest.h" -#include "media/stagefright/MediaErrors.h" -#include "media/stagefright/foundation/ABase.h" -#include "string_conversions.h" -#include "wv_cdm_constants.h" -#include "wv_cdm_types.h" -#include "wv_content_decryption_module.h" - -namespace wvdrm { -namespace hardware { -namespace drm { -namespace V1_4 { -namespace widevine { - -using android::hardware::drm::V1_2::widevine::toHidlVec; -using ::testing::_; -using ::testing::AllOf; -using ::testing::Args; -using ::testing::AtLeast; -using ::testing::DefaultValue; -using ::testing::DoAll; -using ::testing::ElementsAreArray; -using ::testing::Field; -using ::testing::InSequence; -using ::testing::Invoke; -using ::testing::IsEmpty; -using ::testing::Matcher; -using ::testing::NotNull; -using ::testing::Pointee; -using ::testing::SaveArg; -using ::testing::SetArgPointee; -using ::testing::SetArrayArgument; -using ::testing::StrEq; -using ::testing::StrictMock; -using ::testing::Test; -using ::testing::Values; -using ::testing::WithParamInterface; -using ::testing::internal::ElementsAreArrayMatcher; - -using wvcdm::CdmAppParameterMap; -using wvcdm::CdmCertificateType; -using wvcdm::CdmClientPropertySet; -using wvcdm::CdmIdentifier; -using wvcdm::CdmInitData; -using wvcdm::CdmKeyMessage; -using wvcdm::CdmKeyRequest; -using wvcdm::CdmKeyResponse; -using wvcdm::CdmKeySetId; -using wvcdm::CdmKeySystem; -using wvcdm::CdmLicenseType; -using wvcdm::CdmOfflineLicenseState; -using wvcdm::CdmProvisioningRequest; -using wvcdm::CdmProvisioningResponse; -using wvcdm::CdmQueryMap; -using wvcdm::CdmSecurityLevel; -using wvcdm::EMPTY_ORIGIN; -using wvcdm::kCertificateWidevine; -using wvcdm::KEY_ID_SIZE; -using wvcdm::KEY_IV_SIZE; -using wvcdm::KEY_SET_ID_PREFIX; -using wvcdm::kKeyRequestTypeInitial; -using wvcdm::kKeyRequestTypeRelease; -using wvcdm::kKeyRequestTypeRenewal; -using wvcdm::kLicenseTypeOffline; -using wvcdm::kLicenseTypeRelease; -using wvcdm::kLicenseTypeStreaming; -using wvcdm::kSecurityLevelL1; -using wvcdm::kSecurityLevelL3; -using wvcdm::NEVER_EXPIRES; -using wvcdm::QUERY_KEY_CURRENT_SRM_VERSION; -using wvcdm::QUERY_KEY_DECRYPT_HASH_SUPPORT; -using wvcdm::QUERY_KEY_DEVICE_ID; -using wvcdm::QUERY_KEY_MAX_NUMBER_OF_SESSIONS; -using wvcdm::QUERY_KEY_NUMBER_OF_OPEN_SESSIONS; -using wvcdm::QUERY_KEY_OEMCRYPTO_API_VERSION; -using wvcdm::QUERY_KEY_OEMCRYPTO_BUILD_INFORMATION; -using wvcdm::QUERY_KEY_OEMCRYPTO_SESSION_ID; -using wvcdm::QUERY_KEY_PROVISIONING_ID; -using wvcdm::QUERY_KEY_PROVISIONING_MODEL; -using wvcdm::QUERY_KEY_RESOURCE_RATING_TIER; -using wvcdm::QUERY_KEY_SECURITY_LEVEL; -using wvcdm::QUERY_KEY_SRM_UPDATE_SUPPORT; -using wvcdm::QUERY_KEY_SYSTEM_ID; -using wvcdm::QUERY_KEY_WVCDM_VERSION; -using wvcdm::QUERY_VALUE_SECURITY_LEVEL_L1; -using wvcdm::QUERY_VALUE_SECURITY_LEVEL_L3; -using wvcdm::SESSION_ID_PREFIX; -using wvcdm::WvCdmEventListener; -using wvutil::Base64Encode; - -namespace { -const std::string kEmptyString; -const std::string kOrigin("widevine.com"); -const std::string kAppId("com.unittest.mock.app.id"); -const uint8_t* const kUnprovisionResponse = - reinterpret_cast("unprovision"); -const size_t kUnprovisionResponseSize = 11; -const std::string kDeviceId("0123456789\0ABCDEF", 17); - -// This is a serialized WvCdmMetrics message containing a small amount of -// sample data. This ensures we're able to extract it via a property. -const char kSerializedMetricsHex[] = - "0a580a001a0210072202100d2a02100832182216636f6d2e676f6f676c652e616e64726f69" - "642e676d734208220631342e302e304a06080112020800520610d5f3fad5056a0b1d00fd4c" - "47280132020804a2010608011202080012cb010a0622047369643412b5010a021001520919" - "1d5a643bdfff50405a0b1d00d01945280132021001620d1d00f8e84528013204080020006a" - "0310b739820102100d8a01060801120248009a010310ff01da0106080112024800e2010e1d" - "005243472801320528800248009a020d1d00b016452801320428404800a202060801120248" - "19aa0206080212024800b2020b1d8098f047280132024800ba02021001ca020b1d00101945" - "280132024800e202021004fa02021002a203021000b2030210021a09196891ed7c3f35504" - "0"; - -#define N_ELEM(a) (sizeof(a) / sizeof(a[0])) -} // anonymous namespace - -class MockCDM : public WvContentDecryptionModule { - public: - MOCK_METHOD(CdmResponseType, OpenSession, (const CdmKeySystem&, - CdmClientPropertySet*, - const CdmIdentifier&, - WvCdmEventListener*, - CdmSessionId*), (override)); - - MOCK_METHOD(CdmResponseType, CloseSession, (const CdmSessionId&), (override)); - - MOCK_METHOD(CdmResponseType, GenerateKeyRequest, - (const CdmSessionId&, const CdmKeySetId&, - const std::string&, const CdmInitData&, - const CdmLicenseType, CdmAppParameterMap&, - CdmClientPropertySet*, const CdmIdentifier&, - CdmKeyRequest*), (override)); - - MOCK_METHOD(CdmResponseType, AddKey, (const CdmSessionId&, - const CdmKeyResponse&, - CdmKeySetId*), (override)); - - MOCK_METHOD(CdmResponseType, RemoveKeys, (const CdmSessionId&), (override)); - - MOCK_METHOD(CdmResponseType, RestoreKey, (const CdmSessionId&, - const CdmKeySetId&), (override)); - - MOCK_METHOD(CdmResponseType, QueryStatus, (wvcdm::RequestedSecurityLevel, - const std::string&, - std::string*), (override)); - - MOCK_METHOD(CdmResponseType, QuerySessionStatus, (const CdmSessionId&, - CdmQueryMap*), (override)); - - MOCK_METHOD(CdmResponseType, QueryKeyStatus, (const CdmSessionId&, - CdmQueryMap*), (override)); - - MOCK_METHOD(CdmResponseType, QueryOemCryptoSessionId, (const CdmSessionId&, - CdmQueryMap*), (override)); - - MOCK_METHOD(CdmResponseType, GetProvisioningRequest, (CdmCertificateType, - const std::string&, - const CdmIdentifier&, - const std::string&, - wvcdm::RequestedSecurityLevel, - CdmProvisioningRequest*, - std::string*), (override)); - - MOCK_METHOD(CdmResponseType, HandleProvisioningResponse, - (const CdmIdentifier&, const CdmProvisioningResponse&, - wvcdm::RequestedSecurityLevel, std::string*, std::string*), (override)); - - MOCK_METHOD(CdmResponseType, Unprovision, (CdmSecurityLevel, - const CdmIdentifier&), (override)); - - MOCK_METHOD(bool, IsProvisioned, (CdmSecurityLevel, const std::string&, - const std::string&, bool), (override)); - - MOCK_METHOD(bool, IsValidServiceCertificate, (const std::string&), (override)); - - MOCK_METHOD(CdmResponseType, GetMetrics, (const CdmIdentifier&, - drm_metrics::WvCdmMetrics*), (override)); - - MOCK_METHOD(CdmResponseType, GetDecryptHashError, - (const CdmSessionId&, std::string*), (override)); - - MOCK_METHOD(CdmResponseType, ListStoredLicenses, - (CdmSecurityLevel, - const CdmIdentifier&, - std::vector*), (override)); - - MOCK_METHOD(CdmResponseType, GetOfflineLicenseState, - (const std::string&, - CdmSecurityLevel, - const CdmIdentifier&, - CdmOfflineLicenseState*), (override)); - - MOCK_METHOD(CdmResponseType, RemoveOfflineLicense, - (const std::string&, - CdmSecurityLevel, - const CdmIdentifier&), (override)); -}; - -class MockCrypto : public WVGenericCryptoInterface { - public: - MOCK_METHOD(OEMCryptoResult, selectKey, (const OEMCrypto_SESSION, - const uint8_t*, size_t), (override)); - - MOCK_METHOD(OEMCryptoResult, encrypt, (OEMCrypto_SESSION, const uint8_t*, - size_t, const uint8_t*, - OEMCrypto_Algorithm, uint8_t*), (override)); - - MOCK_METHOD(OEMCryptoResult, decrypt, (OEMCrypto_SESSION, const uint8_t*, - size_t, const uint8_t*, - OEMCrypto_Algorithm, uint8_t*), (override)); - - MOCK_METHOD(OEMCryptoResult, sign, (OEMCrypto_SESSION, const uint8_t*, size_t, - OEMCrypto_Algorithm, uint8_t*, size_t*), (override)); - - MOCK_METHOD(OEMCryptoResult, verify, (OEMCrypto_SESSION, const uint8_t*, - size_t, OEMCrypto_Algorithm, - const uint8_t*, size_t), (override)); - - MOCK_METHOD(OEMCryptoResult, loadDeviceRSAKey, (OEMCrypto_SESSION, - const uint8_t*, size_t), (override)); - - MOCK_METHOD(OEMCryptoResult, generateRSASignature, (OEMCrypto_SESSION, - const uint8_t*, size_t, - uint8_t*, size_t*, - RSA_Padding_Scheme), (override)); -}; - -class MockDrmPluginListener : public IDrmPluginListener_V1_2 { - public: - MOCK_METHOD(Return, sendEvent, (EventType, const hidl_vec&, - const hidl_vec&), (override)); - - MOCK_METHOD(Return, sendExpirationUpdate, - (const hidl_vec&, int64_t), (override)); - - MOCK_METHOD(Return, sendKeysChange, (const hidl_vec&, - const hidl_vec&, bool), (override)); - - MOCK_METHOD(Return, sendSessionLostState, - (const hidl_vec&), (override)); - - MOCK_METHOD(Return, sendKeysChange_1_2, (const hidl_vec&, - const hidl_vec&, bool), (override)); -}; - -template -CdmResponseType setSessionIdOnMap(testing::Unused, CdmQueryMap* map) { - static const char oecId[] = {DIGIT + '0', '\0'}; - (*map)[QUERY_KEY_OEMCRYPTO_SESSION_ID] = oecId; - return wvcdm::NO_ERROR; -} - -MATCHER_P(HasOrigin, origin, "") { return arg.origin == origin; } - -class WVDrmPluginTest : public Test { - protected: - static const uint32_t kKeySetIdSize = 32; - static const uint32_t kSessionIdSize = 16; - uint8_t keySetIdRaw[kKeySetIdSize]; - uint8_t sessionIdRaw[kSessionIdSize]; - std::vector keySetId; - std::vector sessionId; - CdmSessionId cdmSessionId; - - virtual void SetUp() { - // Fill the session ID - FILE* fp = fopen("/dev/urandom", "r"); - fread(sessionIdRaw, sizeof(uint8_t), kSessionIdSize, fp); - - memcpy(sessionIdRaw, SESSION_ID_PREFIX, sizeof(SESSION_ID_PREFIX) - 1); - sessionId.assign(sessionIdRaw, sessionIdRaw + kSessionIdSize); - cdmSessionId.assign(sessionId.begin(), sessionId.end()); - - fread(keySetIdRaw, sizeof(uint8_t), kKeySetIdSize, fp); - fclose(fp); - - memcpy(keySetIdRaw, KEY_SET_ID_PREFIX, sizeof(KEY_SET_ID_PREFIX)); - CdmKeySetId cdmKeySetId(reinterpret_cast(keySetIdRaw), - kKeySetIdSize); - keySetId.assign(keySetIdRaw, keySetIdRaw + kKeySetIdSize); - - // Set default return values for gMock - DefaultValue::Set(wvcdm::NO_ERROR); - DefaultValue::Set(OEMCrypto_SUCCESS); - DefaultValue::Set(true); - } -}; - -struct OriginTestVariant { - // For a test that does not expect any follow-up queries - OriginTestVariant(const std::string& nameValue, - const std::string& originValue, - const std::string& expectedOriginValue) - : name(nameValue), - origin(originValue), - expectedOrigin(expectedOriginValue) {} - - const std::string name; - const std::string origin; - const std::string expectedOrigin; -}; - -void PrintTo(const OriginTestVariant& param, ::std::ostream* os) { - *os << param.name << " Variant"; -} - -class WVDrmPluginOriginTest : public WVDrmPluginTest, - public WithParamInterface {}; - -TEST_F(WVDrmPluginTest, OpensSessions) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - EXPECT_CALL(*cdm, OpenSession(StrEq("com.widevine"), _, - HasOrigin(EMPTY_ORIGIN), _, _)) - .WillOnce(DoAll(SetArgPointee<4>(cdmSessionId), - testing::Return(wvcdm::NO_ERROR))); - - // Provide expected mock behavior - EXPECT_CALL(*cdm, QueryOemCryptoSessionId(cdmSessionId, _)) - .Times(AtLeast(1)) - .WillRepeatedly(Invoke(setSessionIdOnMap<4>)); - - EXPECT_CALL(*cdm, CloseSession(_)).Times(AtLeast(0)); - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - - plugin.openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.clear(); - sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size()); - }); - - EXPECT_THAT(sessionId, ElementsAreArray(sessionIdRaw, kSessionIdSize)); - Status status = plugin.closeSession(toHidlVec(sessionId)); - ASSERT_EQ(Status::OK, status); -} - -TEST_F(WVDrmPluginTest, OpensSessions_1_1) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - const CdmClientPropertySet* propertySet = nullptr; - - // Provide expected mock behavior - EXPECT_CALL(*cdm, QueryStatus(_, QUERY_KEY_SECURITY_LEVEL, _)) - .WillOnce(DoAll(SetArgPointee<2>(QUERY_VALUE_SECURITY_LEVEL_L1), - testing::Return(wvcdm::NO_ERROR))) - .WillOnce(DoAll(SetArgPointee<2>(QUERY_VALUE_SECURITY_LEVEL_L3), - testing::Return(wvcdm::NO_ERROR))); - - CdmQueryMap securityLevelQueryMap; - securityLevelQueryMap[wvcdm::QUERY_KEY_SECURITY_LEVEL] = - wvcdm::QUERY_VALUE_SECURITY_LEVEL_L3; - - EXPECT_CALL(*cdm, QuerySessionStatus(_, NotNull())) - .WillOnce(DoAll(SetArgPointee<1>(securityLevelQueryMap), - testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, OpenSession(_, _, _, _, _)) - .WillRepeatedly(DoAll(SetArgPointee<4>(cdmSessionId), - SaveArg<1>(&propertySet), - testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, QueryOemCryptoSessionId(cdmSessionId, _)) - .WillRepeatedly(Invoke(setSessionIdOnMap<4>)); - - EXPECT_CALL(*cdm, CloseSession(_)).Times(AtLeast(0)); - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - - Status status = - plugin.setPropertyString(hidl_string("securityLevel"), hidl_string("L1")); - ASSERT_EQ(Status::OK, status); - - plugin.openSession_1_1( - android::hardware::drm::V1_1::SecurityLevel::SW_SECURE_CRYPTO, - [&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.clear(); - sessionId.assign(hSessionId.data(), - hSessionId.data() + hSessionId.size()); - }); - - ASSERT_THAT(propertySet, NotNull()); - EXPECT_THAT(sessionId, ElementsAreArray(sessionIdRaw, kSessionIdSize)); - status = plugin.closeSession(toHidlVec(sessionId)); - ASSERT_EQ(Status::OK, status); -} - -TEST_F(WVDrmPluginTest, ClosesSessions) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - EXPECT_CALL(*cdm, CloseSession(cdmSessionId)).Times(1); - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - Status status = plugin.closeSession(toHidlVec(sessionId)); - ASSERT_EQ(Status::OK, status); -} - -TEST_F(WVDrmPluginTest, ClosesSessionWithError) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - EXPECT_CALL(*cdm, CloseSession(cdmSessionId)) - .WillOnce(testing::Return(wvcdm::SESSION_NOT_FOUND_1)); - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - Status status = plugin.closeSession(toHidlVec(sessionId)); - ASSERT_EQ(Status::ERROR_DRM_SESSION_NOT_OPENED, status); -} - -// TODO b/35325611 Fix this disabled test -TEST_F(WVDrmPluginTest, DISABLED_GeneratesKeyRequests) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - static const size_t kInitDataSize = 128; - uint8_t initDataRaw[kInitDataSize]; - static const size_t kRequestSize = 256; - uint8_t requestRaw[kRequestSize]; - static const uint32_t kKeySetIdSize = 32; - uint8_t keySetIdRaw[kKeySetIdSize]; - FILE* fp = fopen("/dev/urandom", "r"); - fread(initDataRaw, sizeof(uint8_t), kInitDataSize, fp); - fread(requestRaw, sizeof(uint8_t), kRequestSize, fp); - fread(keySetIdRaw, sizeof(uint8_t), kKeySetIdSize, fp); - fclose(fp); - - memcpy(keySetIdRaw, KEY_SET_ID_PREFIX, sizeof(KEY_SET_ID_PREFIX) - 1); - CdmKeySetId cdmKeySetId(reinterpret_cast(keySetIdRaw), kKeySetIdSize); - std::vector keySetId; - keySetId.assign(keySetIdRaw, keySetIdRaw + kKeySetIdSize); - - CdmInitData cdmInitData(reinterpret_cast(initDataRaw), kInitDataSize); - std::vector initData; - initData.assign(initDataRaw, initDataRaw + kInitDataSize); - - // clang-format off - static const uint8_t psshPrefix[] = { - 0, 0, 0, 32 + kInitDataSize, // Total size - 'p', 's', 's', 'h', // "PSSH" - 0, 0, 0, 0, // Flags - must be zero - 0xED, 0xEF, 0x8B, 0xA9, 0x79, 0xD6, 0x4A, 0xCE, // Widevine UUID - 0xA3, 0xC8, 0x27, 0xDC, 0xD5, 0x1D, 0x21, 0xED, - 0, 0, 0, kInitDataSize // Size of initData - }; - // clang-format on - static const size_t kPsshPrefixSize = sizeof(psshPrefix); - static const size_t kPsshBoxSize = kPsshPrefixSize + kInitDataSize; - uint8_t psshBoxRaw[kPsshBoxSize]; - memcpy(psshBoxRaw, psshPrefix, kPsshPrefixSize); - memcpy(psshBoxRaw + kPsshPrefixSize, initDataRaw, kInitDataSize); - CdmInitData cdmPsshBox(reinterpret_cast(psshBoxRaw), kPsshBoxSize); - std::vector psshBox; - psshBox.assign(psshBoxRaw, psshBoxRaw + kPsshBoxSize); - - CdmKeyMessage cdmRequest(requestRaw, requestRaw + kRequestSize); - - std::map parameters; - CdmAppParameterMap cdmParameters; - parameters.insert( - std::pair("paddingScheme", "BUBBLE WRAP")); - cdmParameters["paddingScheme"] = "BUBBLE WRAP"; - parameters.insert( - std::pair("favorite-particle", "tetraquark")); - cdmParameters["favorite-particle"] = "tetraquark"; - parameters.insert(std::pair("answer", "6 * 9")); - cdmParameters["answer"] = "6 * 9"; - - std::vector optionalParameters; - KeyValue keyValue; - for (std::map::iterator itr = parameters.begin(); - itr != parameters.end(); ++itr) { - keyValue.key = itr->first; - keyValue.value = itr->second; - optionalParameters.push_back(keyValue); - } - - static const char* kDefaultUrl = "http://google.com/"; - static const char* kIsoBmffMimeType = "cenc"; - static const char* kWebmMimeType = "webm"; - - struct TestSet { - const char* mimeType; - const std::vector& initDataIn; - const CdmInitData& initDataOut; - }; - - // We run the same set of operations on several sets of data, simulating - // different valid calling patterns. - TestSet testSets[] = { - {kIsoBmffMimeType, psshBox, cdmPsshBox}, // ISO-BMFF, EME passing style - {kIsoBmffMimeType, initData, cdmPsshBox}, // ISO-BMFF, old passing style - {kWebmMimeType, initData, cdmInitData} // WebM - }; - size_t testSetCount = N_ELEM(testSets); - - // Set up the expected calls. Per gMock rules, this must be done for all test - // sets prior to testing any of them. - { - InSequence calls; - - for (size_t i = 0; i < testSetCount; ++i) { - const char* mimeType = testSets[i].mimeType; - const CdmInitData& initData = testSets[i].initDataOut; - - CdmKeyRequest initialRequest = {cdmRequest, kKeyRequestTypeInitial, - kDefaultUrl}; - - CdmKeyRequest renewalRequest = {cdmRequest, kKeyRequestTypeRenewal, - kDefaultUrl}; - - CdmKeyRequest releaseRequest = {cdmRequest, kKeyRequestTypeRelease, - kDefaultUrl}; - - EXPECT_CALL(*cdm, - GenerateKeyRequest(cdmSessionId, "", mimeType, initData, - kLicenseTypeOffline, cdmParameters, - NotNull(), HasOrigin(EMPTY_ORIGIN), _)) - .WillOnce(DoAll(SetArgPointee<8>(initialRequest), - testing::Return(wvcdm::KEY_MESSAGE))); - - EXPECT_CALL(*cdm, - GenerateKeyRequest(cdmSessionId, "", mimeType, initData, - kLicenseTypeStreaming, cdmParameters, - NotNull(), HasOrigin(EMPTY_ORIGIN), _)) - .WillOnce(DoAll(SetArgPointee<8>(renewalRequest), - testing::Return(wvcdm::KEY_MESSAGE))); - - EXPECT_CALL(*cdm, - GenerateKeyRequest("", cdmKeySetId, mimeType, initData, - kLicenseTypeRelease, cdmParameters, - NotNull(), HasOrigin(EMPTY_ORIGIN), _)) - - .WillOnce(DoAll(SetArgPointee<8>(releaseRequest), - testing::Return(wvcdm::KEY_MESSAGE))); - } - } - - // Performs the actual tests - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - for (size_t i = 0; i < testSetCount; ++i) { - const std::string mimeType(testSets[i].mimeType); - const std::vector& initData = testSets[i].initDataIn; - - plugin.getKeyRequest( - toHidlVec(sessionId), toHidlVec(initData), hidl_string(mimeType), - KeyType::OFFLINE, toHidlVec(optionalParameters), - [&](Status status, hidl_vec hRequest, - KeyRequestType keyRequestType, hidl_string defaultUrl) { - ASSERT_EQ(Status::OK, status); - - std::vector request(hRequest); - EXPECT_THAT(request, ElementsAreArray(requestRaw, kRequestSize)); - EXPECT_EQ(KeyRequestType::INITIAL, keyRequestType); - EXPECT_STREQ(kDefaultUrl, defaultUrl.c_str()); - }); - - plugin.getKeyRequest( - toHidlVec(sessionId), toHidlVec(initData), hidl_string(mimeType), - KeyType::STREAMING, toHidlVec(optionalParameters), - [&](Status status, hidl_vec hRequest, - KeyRequestType keyRequestType, hidl_string defaultUrl) { - ASSERT_EQ(Status::OK, status); - - std::vector request(hRequest); - EXPECT_THAT(request, ElementsAreArray(requestRaw, kRequestSize)); - EXPECT_EQ(KeyRequestType::RENEWAL, keyRequestType); - EXPECT_STREQ(kDefaultUrl, defaultUrl.c_str()); - }); - - plugin.getKeyRequest( - toHidlVec(sessionId), toHidlVec(initData), hidl_string(mimeType), - KeyType::RELEASE, toHidlVec(optionalParameters), - [&](Status status, hidl_vec hRequest, - KeyRequestType keyRequestType, hidl_string defaultUrl) { - ASSERT_EQ(Status::OK, status); - - std::vector request(hRequest); - EXPECT_THAT(request, ElementsAreArray(requestRaw, kRequestSize)); - EXPECT_EQ(KeyRequestType::RELEASE, keyRequestType); - EXPECT_STREQ(kDefaultUrl, defaultUrl.c_str()); - }); - } -} - -TEST_F(WVDrmPluginTest, AddsKeys) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - static const uint32_t kResponseSize = 256; - uint8_t responseRaw[kResponseSize]; - static const uint32_t kKeySetIdSize = 32; - uint8_t keySetIdRaw[kKeySetIdSize]; - FILE* fp = fopen("/dev/urandom", "r"); - fread(responseRaw, sizeof(uint8_t), kResponseSize, fp); - fread(keySetIdRaw, sizeof(uint8_t), kKeySetIdSize, fp); - fclose(fp); - - std::vector response; - response.assign(responseRaw, responseRaw + kResponseSize); - - memcpy(keySetIdRaw, KEY_SET_ID_PREFIX, sizeof(KEY_SET_ID_PREFIX) - 1); - CdmKeySetId cdmKeySetId(reinterpret_cast(keySetIdRaw), kKeySetIdSize); - - std::vector keySetId; - std::vector emptyKeySetId; - - EXPECT_CALL(*cdm, AddKey(cdmSessionId, - ElementsAreArray(responseRaw, kResponseSize), _)) - .WillOnce(DoAll(SetArgPointee<2>(cdmKeySetId), - testing::Return(wvcdm::KEY_ADDED))); - - EXPECT_CALL(*cdm, AddKey("", ElementsAreArray(responseRaw, kResponseSize), - Pointee(cdmKeySetId))) - .Times(1); - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - - plugin.provideKeyResponse( - toHidlVec(sessionId), toHidlVec(response), - [&](Status status, hidl_vec hKeySetId) { - ASSERT_EQ(Status::OK, status); - - std::vector id(hKeySetId); - keySetId.assign(id.data(), id.data() + id.size()); - ASSERT_THAT(keySetId, ElementsAreArray(keySetIdRaw, kKeySetIdSize)); - }); - - plugin.provideKeyResponse(toHidlVec(keySetId), toHidlVec(response), - [&](Status status, hidl_vec hKeySetId) { - ASSERT_EQ(Status::OK, status); - - EXPECT_EQ(0u, hKeySetId.size()); - }); -} - -TEST_F(WVDrmPluginTest, HandlesPrivacyCertCaseOfAddKey) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - sp> listener = - new StrictMock(); - - const CdmClientPropertySet* propertySet = nullptr; - - // Provide expected behavior in response to OpenSession and store the - // property set - EXPECT_CALL(*cdm, OpenSession(_, _, _, _, _)) - .WillRepeatedly(DoAll(SetArgPointee<4>(cdmSessionId), - SaveArg<1>(&propertySet), - testing::Return(wvcdm::NO_ERROR))); - - // Provide expected behavior when plugin requests session control info - EXPECT_CALL(*cdm, QueryOemCryptoSessionId(cdmSessionId, _)) - .WillRepeatedly(Invoke(setSessionIdOnMap<4>)); - - EXPECT_CALL(*cdm, CloseSession(_)).Times(AtLeast(0)); - - static const uint32_t kResponseSize = 256; - uint8_t responseRaw[kResponseSize]; - FILE* fp = fopen("/dev/urandom", "r"); - fread(responseRaw, sizeof(uint8_t), kResponseSize, fp); - fclose(fp); - - hidl_vec hSessionId; - hSessionId.setToExternal(sessionIdRaw, kSessionIdSize); - hidl_vec hEmptyData; - - EXPECT_CALL(*listener, - sendEvent(EventType::KEY_NEEDED, hSessionId, hEmptyData)) - .Times(1); - - EXPECT_CALL(*cdm, AddKey(_, _, _)) - .WillRepeatedly(testing::Return(wvcdm::NEED_KEY)); - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - - plugin.openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.clear(); - sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size()); - }); - ASSERT_THAT(propertySet, NotNull()); - - plugin.setListener(listener); - - Status status = plugin.setPropertyString(hidl_string("privacyMode"), - hidl_string("enable")); - ASSERT_EQ(Status::OK, status); - EXPECT_TRUE(propertySet->use_privacy_mode()); - - std::vector response; - response.assign(responseRaw, responseRaw + kResponseSize); - std::vector keySetId; - - plugin.provideKeyResponse( - toHidlVec(sessionId), toHidlVec(response), - [&](Status status, hidl_vec /* keySetId */) { - ASSERT_EQ(Status::OK, status); - }); -} - -TEST_F(WVDrmPluginTest, RemovesKeys) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - EXPECT_CALL(*cdm, RemoveKeys(cdmSessionId)).Times(1); - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - Status status = plugin.removeKeys(toHidlVec(sessionId)); - ASSERT_EQ(Status::OK, status); -} - -TEST_F(WVDrmPluginTest, RestoresKeys) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - EXPECT_CALL(*cdm, RestoreKey(cdmSessionId, - ElementsAreArray(keySetIdRaw, kKeySetIdSize))) - .Times(1); - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - Status status = plugin.restoreKeys(toHidlVec(sessionId), toHidlVec(keySetId)); - ASSERT_EQ(Status::OK, status); -} - -TEST_F(WVDrmPluginTest, QueriesKeyStatus) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - std::map expectedLicenseStatus; - CdmQueryMap cdmLicenseStatus; - - expectedLicenseStatus.insert( - std::pair("areTheKeysAllRight", "yes")); - cdmLicenseStatus["areTheKeysAllRight"] = "yes"; - expectedLicenseStatus.insert( - std::pair("isGMockAwesome", "ohhhhhhYeah")); - cdmLicenseStatus["isGMockAwesome"] = "ohhhhhhYeah"; - expectedLicenseStatus.insert( - std::pair("answer", "42")); - cdmLicenseStatus["answer"] = "42"; - - EXPECT_CALL(*cdm, QueryKeyStatus(cdmSessionId, _)) - .WillOnce(DoAll(SetArgPointee<1>(cdmLicenseStatus), - testing::Return(wvcdm::NO_ERROR))); - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - plugin.queryKeyStatus( - toHidlVec(sessionId), - [&](Status status, hidl_vec(hLicenseStatus)) { - ASSERT_EQ(Status::OK, status); - ASSERT_EQ(expectedLicenseStatus.size(), hLicenseStatus.size()); - - KeyValue keyValuePair; - size_t i = 0; - for (std::map::iterator itr = - expectedLicenseStatus.begin(); - itr != expectedLicenseStatus.end(); ++itr) { - keyValuePair.value = hLicenseStatus[i++].value; - EXPECT_EQ(itr->second.c_str(), - std::string(keyValuePair.value.c_str())); - } - }); -} - -TEST_F(WVDrmPluginTest, GetsProvisioningRequests) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - static const uint32_t kRequestSize = 256; - uint8_t requestRaw[kRequestSize]; - FILE* fp = fopen("/dev/urandom", "r"); - fread(requestRaw, sizeof(uint8_t), kRequestSize, fp); - fclose(fp); - - CdmProvisioningRequest cdmRequest(requestRaw, requestRaw + kRequestSize); - - static const char* kDefaultUrl = "http://google.com/"; - - EXPECT_CALL(*cdm, QueryStatus(_, QUERY_KEY_SECURITY_LEVEL, _)) - .WillOnce(DoAll(SetArgPointee<2>(QUERY_VALUE_SECURITY_LEVEL_L1), - testing::Return(wvcdm::NO_ERROR))); - - // The first and the third invocation should be at default security level, - // while the second one should be L3 - EXPECT_CALL(*cdm, GetProvisioningRequest(kCertificateWidevine, IsEmpty(), - HasOrigin(EMPTY_ORIGIN), IsEmpty(), - wvcdm::kLevelDefault, _, _)) - .Times(2) - .WillRepeatedly(DoAll(SetArgPointee<5>(cdmRequest), - SetArgPointee<6>(kDefaultUrl), - testing::Return(wvcdm::NO_ERROR))); - EXPECT_CALL(*cdm, GetProvisioningRequest(kCertificateWidevine, IsEmpty(), - HasOrigin(EMPTY_ORIGIN), IsEmpty(), - wvcdm::kLevel3, _, _)) - .WillOnce(DoAll(SetArgPointee<5>(cdmRequest), - SetArgPointee<6>(kDefaultUrl), - testing::Return(wvcdm::NO_ERROR))); - - // Make 3 provisioning requests at security level default then L3 then L1 - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - plugin.getProvisionRequest( - hidl_string(""), hidl_string(""), - [&](Status status, hidl_vec hRequest, hidl_string defaultUrl) { - ASSERT_EQ(Status::OK, status); - - std::vector request(hRequest); - EXPECT_THAT(request, ElementsAreArray(requestRaw, kRequestSize)); - EXPECT_STREQ(kDefaultUrl, defaultUrl.c_str()); - }); - - // Set L3 security level - Status status = - plugin.setPropertyString(hidl_string("securityLevel"), hidl_string("L3")); - ASSERT_EQ(Status::OK, status); - plugin.getProvisionRequest( - hidl_string(""), hidl_string(""), - [&](Status status, hidl_vec hRequest, hidl_string defaultUrl) { - ASSERT_EQ(Status::OK, status); - - std::vector request(hRequest); - EXPECT_THAT(request, ElementsAreArray(requestRaw, kRequestSize)); - EXPECT_STREQ(kDefaultUrl, defaultUrl.c_str()); - }); - - // Reset security level to L1 - status = - plugin.setPropertyString(hidl_string("securityLevel"), hidl_string("L1")); - ASSERT_EQ(Status::OK, status); - plugin.getProvisionRequest( - hidl_string(""), hidl_string(""), - [&](Status status, hidl_vec hRequest, hidl_string defaultUrl) { - ASSERT_EQ(Status::OK, status); - - std::vector request(hRequest); - EXPECT_THAT(request, ElementsAreArray(requestRaw, kRequestSize)); - EXPECT_STREQ(kDefaultUrl, defaultUrl.c_str()); - }); -} - -TEST_F(WVDrmPluginTest, RejectsAtscProvisioningRequests) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - - Status status = - plugin.setPropertyString(hidl_string("atscMode"), hidl_string("enable")); - ASSERT_EQ(Status::OK, status); - - plugin.getProvisionRequest( - hidl_string(""), hidl_string(""), - [&](Status status, hidl_vec, hidl_string) { - ASSERT_EQ(Status::ERROR_DRM_CANNOT_HANDLE, status); - }); -} - -TEST_F(WVDrmPluginTest, HandlesProvisioningResponses) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - static const uint32_t kResponseSize = 512; - uint8_t responseRaw[kResponseSize]; - FILE* fp = fopen("/dev/urandom", "r"); - fread(responseRaw, sizeof(uint8_t), kResponseSize, fp); - fclose(fp); - - std::vector response; - response.assign(responseRaw, responseRaw + kResponseSize); - - EXPECT_CALL(*cdm, QueryStatus(_, QUERY_KEY_SECURITY_LEVEL, _)) - .WillOnce(DoAll(SetArgPointee<2>(QUERY_VALUE_SECURITY_LEVEL_L1), - testing::Return(wvcdm::NO_ERROR))); - - // The first and the third invocation should be at default security level, - // while the second one should be L3 - EXPECT_CALL(*cdm, HandleProvisioningResponse( - HasOrigin(EMPTY_ORIGIN), - ElementsAreArray(responseRaw, kResponseSize), - wvcdm::kLevelDefault, _, _)) - .Times(2); - EXPECT_CALL(*cdm, HandleProvisioningResponse( - HasOrigin(EMPTY_ORIGIN), - ElementsAreArray(responseRaw, kResponseSize), - wvcdm::kLevel3, _, _)) - .Times(1); - - std::vector cert; - std::vector key; - - // Process 3 provisioning responses at security level default then L3 then L1 - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - plugin.provideProvisionResponse( - toHidlVec(response), - [&](Status status, hidl_vec /* cert */, - hidl_vec /* key */) { ASSERT_EQ(Status::OK, status); }); - - // Set L3 security level - Status status = - plugin.setPropertyString(hidl_string("securityLevel"), hidl_string("L3")); - ASSERT_EQ(Status::OK, status); - - plugin.provideProvisionResponse( - toHidlVec(response), - [&](Status status, hidl_vec /* cert */, - hidl_vec /* key */) { ASSERT_EQ(Status::OK, status); }); - - // Reset security level to L1 - status = - plugin.setPropertyString(hidl_string("securityLevel"), hidl_string("L1")); - plugin.provideProvisionResponse( - toHidlVec(response), - [&](Status status, hidl_vec /* cert */, - hidl_vec /* key */) { ASSERT_EQ(Status::OK, status); }); -} - -TEST_F(WVDrmPluginTest, UnprovisionsDevice) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - EXPECT_CALL(*cdm, Unprovision(kSecurityLevelL1, HasOrigin(EMPTY_ORIGIN))) - .Times(1); - EXPECT_CALL(*cdm, Unprovision(kSecurityLevelL3, HasOrigin(EMPTY_ORIGIN))) - .Times(1); - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - Status res = plugin.unprovisionDevice(); - ASSERT_EQ(Status::OK, res); -} - -TEST_F(WVDrmPluginTest, MuxesUnprovisioningErrors) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - // Tests that both Unprovisions are called even if one fails. Also tests that - // no matter which fails, the function always propagates the error. - EXPECT_CALL(*cdm, Unprovision(kSecurityLevelL1, HasOrigin(EMPTY_ORIGIN))) - .WillOnce(testing::Return(wvcdm::UNKNOWN_ERROR)) - .WillOnce(testing::Return(wvcdm::NO_ERROR)) - .WillOnce(testing::Return(wvcdm::UNKNOWN_ERROR)); - EXPECT_CALL(*cdm, Unprovision(kSecurityLevelL3, HasOrigin(EMPTY_ORIGIN))) - .WillOnce(testing::Return(wvcdm::NO_ERROR)) - .WillOnce(testing::Return(wvcdm::UNKNOWN_ERROR)) - .WillOnce(testing::Return(wvcdm::UNKNOWN_ERROR)); - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - Status res = plugin.unprovisionDevice(); - ASSERT_NE(Status::OK, res); - res = plugin.unprovisionDevice(); - ASSERT_NE(Status::OK, res); - res = plugin.unprovisionDevice(); - ASSERT_NE(Status::OK, res); -} - -TEST_F(WVDrmPluginTest, UnprovisionsOrigin) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - std::vector specialResponse; - specialResponse.assign(kUnprovisionResponse, - kUnprovisionResponse + kUnprovisionResponseSize); - - EXPECT_CALL(*cdm, Unprovision(kSecurityLevelL1, HasOrigin(kOrigin.c_str()))) - .Times(1); - EXPECT_CALL(*cdm, Unprovision(kSecurityLevelL3, HasOrigin(kOrigin.c_str()))) - .Times(1); - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - - Status status = - plugin.setPropertyString(hidl_string("origin"), hidl_string(kOrigin)); - ASSERT_EQ(Status::OK, status); - - plugin.provideProvisionResponse( - toHidlVec(specialResponse), - [&](Status status, hidl_vec /* cert */, - hidl_vec /* key */) { EXPECT_EQ(Status::OK, status); }); -} - -TEST_F(WVDrmPluginTest, UnprovisionsGloballyWithSpoid) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - std::vector specialResponse; - specialResponse.assign(kUnprovisionResponse, - kUnprovisionResponse + kUnprovisionResponseSize); - - EXPECT_CALL(*cdm, QueryStatus(_, QUERY_KEY_DEVICE_ID, _)) - .WillRepeatedly( - DoAll(SetArgPointee<2>(kDeviceId), testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, Unprovision(kSecurityLevelL1, HasOrigin(EMPTY_ORIGIN))) - .Times(1); - EXPECT_CALL(*cdm, Unprovision(kSecurityLevelL3, HasOrigin(EMPTY_ORIGIN))) - .Times(1); - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, true); - plugin.provideProvisionResponse( - toHidlVec(specialResponse), - [&](Status status, hidl_vec /* cert */, - hidl_vec /* key */) { EXPECT_EQ(Status::OK, status); }); -} - -TEST_F(WVDrmPluginTest, WillNotUnprovisionWithoutOriginOrSpoid) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - std::vector specialResponse; - specialResponse.assign(kUnprovisionResponse, - kUnprovisionResponse + kUnprovisionResponseSize); - - EXPECT_CALL(*cdm, Unprovision(_, _)).Times(0); - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - plugin.provideProvisionResponse( - toHidlVec(specialResponse), - [&](Status status, hidl_vec /* cert */, - hidl_vec /* key */) { EXPECT_NE(Status::OK, status); }); -} - -TEST_F(WVDrmPluginTest, MuxesOriginUnprovisioningErrors) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - std::vector specialResponse; - specialResponse.assign(kUnprovisionResponse, - kUnprovisionResponse + kUnprovisionResponseSize); - - // Tests that both Unprovisions are called even if one fails. Also tests that - // no matter which fails, the function always propagates the error. - EXPECT_CALL(*cdm, Unprovision(kSecurityLevelL1, HasOrigin(kOrigin.c_str()))) - .WillOnce(testing::Return(wvcdm::UNKNOWN_ERROR)) - .WillOnce(testing::Return(wvcdm::NO_ERROR)) - .WillOnce(testing::Return(wvcdm::UNKNOWN_ERROR)); - EXPECT_CALL(*cdm, Unprovision(kSecurityLevelL3, HasOrigin(kOrigin.c_str()))) - .WillOnce(testing::Return(wvcdm::NO_ERROR)) - .WillOnce(testing::Return(wvcdm::UNKNOWN_ERROR)) - .WillOnce(testing::Return(wvcdm::UNKNOWN_ERROR)); - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - - Status status = - plugin.setPropertyString(hidl_string("origin"), hidl_string(kOrigin)); - ASSERT_EQ(Status::OK, status); - - plugin.provideProvisionResponse( - toHidlVec(specialResponse), - [&](Status status, hidl_vec /* cert */, - hidl_vec /* key */) { EXPECT_NE(Status::OK, status); }); - - plugin.provideProvisionResponse( - toHidlVec(specialResponse), - [&](Status status, hidl_vec /* cert */, - hidl_vec /* key */) { EXPECT_NE(Status::OK, status); }); - - plugin.provideProvisionResponse( - toHidlVec(specialResponse), - [&](Status status, hidl_vec /* cert */, - hidl_vec /* key */) { EXPECT_NE(Status::OK, status); }); -} - -TEST_F(WVDrmPluginTest, RejectsAtscUnprovisionDeviceRequests) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - - Status status = - plugin.setPropertyString(hidl_string("atscMode"), hidl_string("enable")); - - status = plugin.unprovisionDevice(); - ASSERT_EQ(Status::ERROR_DRM_CANNOT_HANDLE, status); -} - -TEST_F(WVDrmPluginTest, ReturnsExpectedPropertyValues) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - CdmQueryMap l1Map; - l1Map[QUERY_KEY_SECURITY_LEVEL] = QUERY_VALUE_SECURITY_LEVEL_L1; - - CdmQueryMap l3Map; - l3Map[QUERY_KEY_SECURITY_LEVEL] = QUERY_VALUE_SECURITY_LEVEL_L3; - - static const std::string systemId = "The Universe"; - static const std::string provisioningId("Life\0&Everything", 16); - static const std::string openSessions = "42"; - static const std::string maxSessions = "54"; - static const std::string oemCryptoApiVersion = "13"; - static const std::string currentSRMVersion = "1"; - static const std::string cdmVersion = "Infinity Minus 1"; - static const std::string resourceRatingTier = "1"; - static const std::string oemCryptoBuildInformation = "Mostly Harmless"; - static const std::string oemCryptoHashNotSupported = "0"; - static const std::string oemCryptoCrcClearBuffer = "1"; - static const std::string oemCryptoPartnerDefinedHash = "2"; - static const std::string decryptHashErrorBadHashAndFrameNumber = "53, 1"; - static const std::string provisioningModel = "Zaphod Beeblebrox"; - drm_metrics::WvCdmMetrics expected_metrics; - std::string serialized_metrics = wvutil::a2bs_hex(kSerializedMetricsHex); - ASSERT_TRUE(expected_metrics.ParseFromString(serialized_metrics)); - - EXPECT_CALL(*cdm, QueryStatus(_, QUERY_KEY_SECURITY_LEVEL, _)) - .WillOnce(DoAll(SetArgPointee<2>(QUERY_VALUE_SECURITY_LEVEL_L1), - testing::Return(wvcdm::NO_ERROR))) - .WillOnce(DoAll(SetArgPointee<2>(QUERY_VALUE_SECURITY_LEVEL_L3), - testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, QueryStatus(_, QUERY_KEY_DEVICE_ID, _)) - .WillOnce( - DoAll(SetArgPointee<2>(kDeviceId), testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, QueryStatus(_, QUERY_KEY_SYSTEM_ID, _)) - .WillOnce( - DoAll(SetArgPointee<2>(systemId), testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, QueryStatus(_, QUERY_KEY_PROVISIONING_ID, _)) - .WillOnce(DoAll(SetArgPointee<2>(provisioningId), - testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, QueryStatus(_, QUERY_KEY_NUMBER_OF_OPEN_SESSIONS, _)) - .WillOnce(DoAll(SetArgPointee<2>(openSessions), - testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, QueryStatus(_, QUERY_KEY_MAX_NUMBER_OF_SESSIONS, _)) - .WillOnce(DoAll(SetArgPointee<2>(maxSessions), - testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, QueryStatus(_, QUERY_KEY_OEMCRYPTO_API_VERSION, _)) - .WillOnce(DoAll(SetArgPointee<2>(oemCryptoApiVersion), - testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, QueryStatus(_, QUERY_KEY_SRM_UPDATE_SUPPORT, _)) - .WillOnce( - DoAll(SetArgPointee<2>("True"), testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, QueryStatus(_, QUERY_KEY_CURRENT_SRM_VERSION, _)) - .WillOnce(DoAll(SetArgPointee<2>(currentSRMVersion), - testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, QueryStatus(_, QUERY_KEY_WVCDM_VERSION, _)) - .WillOnce(DoAll(SetArgPointee<2>(cdmVersion), - testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, QueryStatus(_, QUERY_KEY_RESOURCE_RATING_TIER, _)) - .WillOnce(DoAll(SetArgPointee<2>(resourceRatingTier), - testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, QueryStatus(_, QUERY_KEY_DECRYPT_HASH_SUPPORT, _)) - .WillOnce(DoAll(SetArgPointee<2>("1"), testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, QueryStatus(_, QUERY_KEY_OEMCRYPTO_BUILD_INFORMATION, _)) - .WillOnce(DoAll(SetArgPointee<2>(oemCryptoBuildInformation), - testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, GetDecryptHashError(_, _)) - .WillOnce(DoAll(SetArgPointee<1>(decryptHashErrorBadHashAndFrameNumber), - testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, QueryStatus(_, QUERY_KEY_PROVISIONING_MODEL, _)) - .WillOnce(DoAll(SetArgPointee<2>(provisioningModel), - testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, GetMetrics(_, _)) - .WillOnce(DoAll(SetArgPointee<1>(expected_metrics), - testing::Return(wvcdm::NO_ERROR))); - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - std::string stringResult; - std::vector vectorResult; - - plugin.getPropertyString(hidl_string("vendor"), - [&](Status status, hidl_string stringResult) { - ASSERT_EQ(Status::OK, status); - EXPECT_STREQ("Google", stringResult.c_str()); - }); - - plugin.getPropertyString( - hidl_string("version"), [&](Status status, hidl_string stringResult) { - ASSERT_EQ(Status::OK, status); - EXPECT_STREQ(cdmVersion.c_str(), stringResult.c_str()); - }); - - plugin.getPropertyString(hidl_string("description"), - [&](Status status, hidl_string stringResult) { - ASSERT_EQ(Status::OK, status); - EXPECT_STREQ("Widevine CDM", stringResult.c_str()); - }); - - plugin.getPropertyString( - hidl_string("algorithms"), [&](Status status, hidl_string stringResult) { - ASSERT_EQ(Status::OK, status); - EXPECT_STREQ("AES/CBC/NoPadding,HmacSHA256", stringResult.c_str()); - }); - - plugin.getPropertyString(hidl_string("securityLevel"), - [&](Status status, hidl_string stringResult) { - ASSERT_EQ(Status::OK, status); - EXPECT_STREQ(QUERY_VALUE_SECURITY_LEVEL_L1.c_str(), - stringResult.c_str()); - }); - - plugin.getPropertyString(hidl_string("securityLevel"), - [&](Status status, hidl_string stringResult) { - ASSERT_EQ(Status::OK, status); - EXPECT_STREQ(QUERY_VALUE_SECURITY_LEVEL_L3.c_str(), - stringResult.c_str()); - }); - - plugin.getPropertyByteArray( - hidl_string("deviceUniqueId"), - [&](Status status, hidl_vec vectorResult) { - ASSERT_EQ(Status::OK, status); - std::vector id(vectorResult); - EXPECT_THAT(id, ElementsAreArray(kDeviceId.data(), kDeviceId.size())); - }); - - plugin.getPropertyString( - hidl_string("systemId"), [&](Status status, hidl_string stringResult) { - ASSERT_EQ(Status::OK, status); - EXPECT_STREQ(systemId.c_str(), stringResult.c_str()); - }); - - plugin.getPropertyByteArray( - hidl_string("provisioningUniqueId"), - [&](Status status, hidl_vec vectorResult) { - ASSERT_EQ(Status::OK, status); - std::vector id(vectorResult); - EXPECT_THAT( - id, ElementsAreArray(provisioningId.data(), provisioningId.size())); - }); - - plugin.getPropertyString(hidl_string("numberOfOpenSessions"), - [&](Status status, hidl_string stringResult) { - ASSERT_EQ(Status::OK, status); - EXPECT_EQ(openSessions, stringResult.c_str()); - }); - - plugin.getPropertyString(hidl_string("maxNumberOfSessions"), - [&](Status status, hidl_string stringResult) { - ASSERT_EQ(Status::OK, status); - EXPECT_EQ(maxSessions, stringResult.c_str()); - }); - - plugin.getPropertyString(hidl_string("oemCryptoApiVersion"), - [&](Status status, hidl_string stringResult) { - ASSERT_EQ(Status::OK, status); - EXPECT_STREQ(oemCryptoApiVersion.c_str(), - stringResult.c_str()); - }); - - plugin.getPropertyString(hidl_string("SRMUpdateSupport"), - [&](Status status, hidl_string stringResult) { - ASSERT_EQ(Status::OK, status); - EXPECT_STREQ("True", stringResult.c_str()); - }); - - plugin.getPropertyString(hidl_string("CurrentSRMVersion"), - [&](Status status, hidl_string stringResult) { - ASSERT_EQ(Status::OK, status); - EXPECT_STREQ(currentSRMVersion.c_str(), - stringResult.c_str()); - }); - - plugin.getPropertyString(hidl_string("resourceRatingTier"), - [&](Status status, hidl_string stringResult) { - ASSERT_EQ(Status::OK, status); - EXPECT_STREQ(resourceRatingTier.c_str(), - stringResult.c_str()); - }); - - plugin.getPropertyString(hidl_string("oemCryptoBuildInformation"), - [&](Status status, hidl_string stringResult) { - ASSERT_EQ(Status::OK, status); - EXPECT_STREQ(oemCryptoBuildInformation.c_str(), - stringResult.c_str()); - }); - - std::stringstream ss; - ss << oemCryptoHashNotSupported << " " << oemCryptoCrcClearBuffer << " " - << oemCryptoPartnerDefinedHash; - std::string validResults = ss.str(); - plugin.getPropertyString(hidl_string("decryptHashSupport"), - [&](Status status, hidl_string stringResult) { - ASSERT_EQ(Status::OK, status); - EXPECT_EQ(oemCryptoCrcClearBuffer, stringResult); - }); - - plugin.getPropertyString(hidl_string("decryptHashError"), - [&](Status status, hidl_string stringResult) { - ASSERT_EQ(Status::OK, status); - EXPECT_EQ(decryptHashErrorBadHashAndFrameNumber, - stringResult); - }); - - plugin.getPropertyString(hidl_string("provisioningModel"), - [&](Status status, hidl_string stringResult) { - ASSERT_EQ(Status::OK, status); - EXPECT_STREQ(provisioningModel.c_str(), - stringResult.c_str()); - }); - - // This call occurs before any open session or other call. This means - // that the cdm identifer is not yet sealed, and metrics return empty - // metrics data. - plugin.getPropertyByteArray( - hidl_string("metrics"), - [&](Status status, hidl_vec vectorResult) { - ASSERT_EQ(Status::OK, status); - std::vector id(vectorResult); - const char empty[] = {}; - EXPECT_THAT(id, ElementsAreArray(empty, sizeof(empty))); - }); - - // Set expectations for the OpenSession call and a CloseSession call. - EXPECT_CALL(*cdm, OpenSession(StrEq("com.widevine"), _, - HasOrigin(EMPTY_ORIGIN), _, _)) - .WillOnce(DoAll(SetArgPointee<4>(cdmSessionId), - testing::Return(wvcdm::NO_ERROR))); - // Provide expected behavior when plugin requests session control info - EXPECT_CALL(*cdm, QueryOemCryptoSessionId(cdmSessionId, _)) - .Times(AtLeast(1)) - .WillRepeatedly(Invoke(setSessionIdOnMap<4>)); - EXPECT_CALL(*cdm, CloseSession(_)).Times(AtLeast(0)); - - // This call causes the cdm identifier to become sealed. - std::vector sessionId; - plugin.openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.clear(); - sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size()); - }); - - // This call occurs after open session. The CDM identifer should be sealed. - // And the call should populate the mock metrics data. - plugin.getPropertyByteArray( - hidl_string("metrics"), - [&](Status status, hidl_vec vectorResult) { - ASSERT_EQ(Status::OK, status); - std::vector id(vectorResult); - EXPECT_THAT(id, ElementsAreArray(serialized_metrics.data(), - serialized_metrics.size())); - }); - - ASSERT_EQ(Status::OK, plugin.closeSession(toHidlVec(sessionId))); -} - -TEST_F(WVDrmPluginTest, DoesNotGetUnknownProperties) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - std::string stringResult; - std::vector vectorResult; - - plugin.getPropertyString(hidl_string("unknownProperty"), - [&](Status status, hidl_string stringResult) { - ASSERT_NE(Status::OK, status); - EXPECT_TRUE(stringResult.empty()); - }); - - plugin.getPropertyByteArray( - hidl_string("unknownProperty"), - [&](Status status, hidl_vec vectorResult) { - ASSERT_NE(Status::OK, status); - EXPECT_EQ(0u, vectorResult.size()); - }); -} - -TEST_F(WVDrmPluginTest, DoesNotSetUnknownProperties) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - static const uint32_t kValueSize = 32; - uint8_t valueRaw[kValueSize]; - FILE* fp = fopen("/dev/urandom", "r"); - fread(valueRaw, sizeof(uint8_t), kValueSize, fp); - fclose(fp); - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - std::vector value; - value.assign(valueRaw, valueRaw + kValueSize); - - Status status = plugin.setPropertyString(hidl_string("unknownProperty"), - hidl_string("ignored")); - ASSERT_NE(Status::OK, status); - - status = plugin.setPropertyByteArray(hidl_string("unknownProperty"), - toHidlVec(value)); - ASSERT_NE(Status::OK, status); -} - -TEST_F(WVDrmPluginTest, CompliesWithSpoidVariability) { - StrictMock crypto; - - const std::string kDeviceIds[] = { - kDeviceId, - kDeviceId + " the Second", - }; - const size_t kDeviceCount = N_ELEM(kDeviceIds); - - const std::string kAppNames[] = { - std::string("com.google.widevine"), - std::string("com.youtube"), - }; - const size_t kAppCount = N_ELEM(kAppNames); - - const std::string kOrigins[] = { - kOrigin, - kOrigin + " but not that one, the other one.", - std::string(/* Intentionally Empty */), - }; - const size_t kOriginCount = N_ELEM(kOrigins); - - const size_t kPluginCount = 2; - - const size_t kPluginsPerCdm = kAppCount * kOriginCount * kPluginCount; - - // We will get kPluginCount SPOIDs for every app package name + device id + - // origin combination. - std::vector spoids[kDeviceCount][kAppCount][kOriginCount] - [kPluginCount]; - - for (size_t deviceIndex = 0; deviceIndex < kDeviceCount; ++deviceIndex) { - const std::string& deviceId = kDeviceIds[deviceIndex]; - - android::sp> cdm = new StrictMock(); - - EXPECT_CALL(*cdm, QueryStatus(_, QUERY_KEY_DEVICE_ID, _)) - .Times(AtLeast(kPluginsPerCdm)) - .WillRepeatedly(DoAll(SetArgPointee<2>(deviceId), - testing::Return(wvcdm::NO_ERROR))); - - for (size_t appIndex = 0; appIndex < kAppCount; ++appIndex) { - const std::string& appPackageName = kAppNames[appIndex]; - - for (size_t originIndex = 0; originIndex < kOriginCount; ++originIndex) { - const std::string& origin = kOrigins[originIndex]; - - for (size_t pluginIndex = 0; pluginIndex < kPluginCount; - ++pluginIndex) { - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, true); - - if (!origin.empty()) { - ASSERT_EQ(Status::OK, - plugin.setPropertyString(hidl_string("origin"), - hidl_string(origin))); - } - - plugin.getPropertyByteArray( - hidl_string("deviceUniqueId"), - [&](Status status, hidl_vec vectorResult) { - ASSERT_EQ(Status::OK, status); - spoids[deviceIndex][appIndex][originIndex][pluginIndex] = - vectorResult; - }); - } - } - } - } - - // This nest of loops makes sure all the SPOIDs we retrieved above are - // identical if their parameters were identical and dissimilar otherwise. - for (size_t deviceIndex = 0; deviceIndex < kDeviceCount; ++deviceIndex) { - for (size_t appIndex = 0; appIndex < kAppCount; ++appIndex) { - for (size_t originIndex = 0; originIndex < kOriginCount; ++originIndex) { - for (size_t pluginIndex = 0; pluginIndex < kPluginCount; - ++pluginIndex) { - const std::vector& firstSpoid = - spoids[deviceIndex][appIndex][originIndex][pluginIndex]; - - for (size_t deviceIndex2 = 0; deviceIndex2 < kDeviceCount; - ++deviceIndex2) { - for (size_t appIndex2 = 0; appIndex2 < kAppCount; ++appIndex2) { - for (size_t originIndex2 = 0; originIndex2 < kOriginCount; - ++originIndex2) { - for (size_t pluginIndex2 = 0; pluginIndex2 < kPluginCount; - ++pluginIndex2) { - const std::vector& secondSpoid = - spoids[deviceIndex2][appIndex2][originIndex2] - [pluginIndex2]; - - if (deviceIndex == deviceIndex2 && appIndex == appIndex2 && - originIndex == originIndex2) { - EXPECT_EQ(firstSpoid, secondSpoid); - } else { - EXPECT_NE(firstSpoid, secondSpoid); - } - } - } - } - } - } - } - } - } -} - -TEST_F(WVDrmPluginTest, ReturnsSameL1Spoid) { - StrictMock crypto; - - std::string kL1DeviceId = kDeviceId + "L1"; - - const std::string kAppPackageName("com.google.widevine"); - constexpr size_t kSpoidQuery = 2; - std::vector spoid[kSpoidQuery]; - - android::sp> cdm = new StrictMock(); - - EXPECT_CALL(*cdm, QueryStatus(wvcdm::kLevelDefault, QUERY_KEY_DEVICE_ID, _)) - .Times(kSpoidQuery) - .WillRepeatedly(DoAll(SetArgPointee<2>(kL1DeviceId), - testing::Return(wvcdm::NO_ERROR))); - - // Provide expected behavior to support session creation - EXPECT_CALL(*cdm, OpenSession(StrEq("com.widevine"), _, _, _, _)) - .Times(kSpoidQuery) - .WillRepeatedly(DoAll(SetArgPointee<4>(cdmSessionId), - testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, QueryOemCryptoSessionId(cdmSessionId, _)) - .Times(kSpoidQuery) - .WillRepeatedly(Invoke(setSessionIdOnMap<4>)); - - EXPECT_CALL(*cdm, CloseSession(_)).Times(kSpoidQuery); - - // Open a session twice with the same security level, app package name and - // origin and make sure the spoids returned are the same - for (int i = 0; i < kSpoidQuery; ++i) { - WVDrmPlugin plugin(cdm.get(), kAppPackageName, &crypto, true); - - plugin.openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.clear(); - sessionId.assign(hSessionId.data(), - hSessionId.data() + hSessionId.size()); - }); - - EXPECT_EQ(Status::OK, plugin.closeSession(toHidlVec(sessionId))); - - plugin.getPropertyByteArray( - hidl_string("deviceUniqueId"), - [&](Status status, hidl_vec vectorResult) { - ASSERT_EQ(Status::OK, status); - spoid[i] = vectorResult; - }); - } - - EXPECT_EQ(spoid[0], spoid[1]); -} - -TEST_F(WVDrmPluginTest, ReturnsL3SpoidsWhenL3ProvisionedUsingL3Spoid) { - StrictMock crypto; - - std::string kL3DeviceId = kDeviceId + "L3"; - - const std::string kAppPackageName("com.google.widevine"); - constexpr size_t kSpoidQuery = 2; - std::vector spoid[kSpoidQuery]; - - android::sp> cdm = new StrictMock(); - - EXPECT_CALL(*cdm, QueryStatus(wvcdm::kLevel3, QUERY_KEY_DEVICE_ID, _)) - .Times(kSpoidQuery) - .WillRepeatedly(DoAll(SetArgPointee<2>(kL3DeviceId), - testing::Return(wvcdm::NO_ERROR))); - - // Provide expected behavior to support session creation - EXPECT_CALL(*cdm, OpenSession(StrEq("com.widevine"), _, _, _, _)) - .Times(kSpoidQuery) - .WillRepeatedly(DoAll(SetArgPointee<4>(cdmSessionId), - testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, QueryOemCryptoSessionId(cdmSessionId, _)) - .Times(kSpoidQuery) - .WillRepeatedly(Invoke(setSessionIdOnMap<4>)); - - EXPECT_CALL(*cdm, IsProvisioned(wvcdm::kSecurityLevelL3, _, _, _)) - .Times(kSpoidQuery) - .WillRepeatedly(testing::Return(true)); - - EXPECT_CALL(*cdm, CloseSession(_)).Times(kSpoidQuery); - - // The device is provisioned at L3 security level. Open a session twice - // and make sure that the spoids returned are the same when the - // session are opened at the same security level(L3), app package name - // and origin - for (size_t i = 0; i < kSpoidQuery; ++i) { - WVDrmPlugin plugin(cdm.get(), kAppPackageName, &crypto, true); - - // Forcing L3 - Status status = plugin.setPropertyString(hidl_string("securityLevel"), - hidl_string("L3")); - ASSERT_EQ(Status::OK, status); - - plugin.openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.clear(); - sessionId.assign(hSessionId.data(), - hSessionId.data() + hSessionId.size()); - }); - - EXPECT_EQ(Status::OK, plugin.closeSession(toHidlVec(sessionId))); - - plugin.getPropertyByteArray( - hidl_string("deviceUniqueId"), - [&](Status status, hidl_vec vectorResult) { - ASSERT_EQ(Status::OK, status); - spoid[i] = vectorResult; - }); - } - - EXPECT_EQ(spoid[0], spoid[1]); -} - -TEST_F(WVDrmPluginTest, ReturnsL3SpoidsWhenL3Unprovisioned) { - StrictMock crypto; - - std::string kL1DeviceId = kDeviceId + "L1"; - std::string kL3DeviceId = kDeviceId + "L3"; - - const std::string kAppPackageName("com.google.widevine"); - constexpr size_t kSpoidQuery = 2; - std::vector spoid[kSpoidQuery]; - - android::sp> cdm = new StrictMock(); - - EXPECT_CALL(*cdm, QueryStatus(wvcdm::kLevelDefault, QUERY_KEY_DEVICE_ID, _)) - .WillOnce(DoAll(SetArgPointee<2>(kL1DeviceId), - testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, QueryStatus(wvcdm::kLevel3, QUERY_KEY_DEVICE_ID, _)) - .Times(kSpoidQuery) - .WillRepeatedly(DoAll(SetArgPointee<2>(kL3DeviceId), - testing::Return(wvcdm::NO_ERROR))); - - // Provide expected behavior to support session creation - EXPECT_CALL(*cdm, OpenSession(StrEq("com.widevine"), _, _, _, _)) - .Times(kSpoidQuery) - .WillOnce(testing::Return(wvcdm::NEED_PROVISIONING)) - .WillOnce(DoAll(SetArgPointee<4>(cdmSessionId), - testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, QueryOemCryptoSessionId(cdmSessionId, _)) - .WillOnce(Invoke(setSessionIdOnMap<4>)); - - EXPECT_CALL(*cdm, IsProvisioned(wvcdm::kSecurityLevelL3, _, _, _)) - .WillOnce(testing::Return(false)) - .WillOnce(testing::Return(true)); - - EXPECT_CALL(*cdm, IsProvisioned(wvcdm::kSecurityLevelL1, _, _, _)) - .WillOnce(testing::Return(false)); - - EXPECT_CALL(*cdm, CloseSession(_)).Times(1); - - // This device is unprovisioned at the L3 security level. An attempt to - // open a session results in an ERROR_DRM_NOT_PROVISIONED error. - // Spoids are computed using device Unique IDs at each security level. - // Since provisioning has not occurred for either spoid, the spoid - // using the L3 device ID is used. - android::sp plugin = - new WVDrmPlugin(cdm.get(), kAppPackageName, &crypto, true); - - // Force L3 - Status status = plugin->setPropertyString(hidl_string("securityLevel"), - hidl_string("L3")); - ASSERT_EQ(Status::OK, status); - - plugin->openSession([&](Status status, hidl_vec) { - ASSERT_EQ(Status::ERROR_DRM_NOT_PROVISIONED, status); - }); - - plugin->getPropertyByteArray( - hidl_string("deviceUniqueId"), - [&](Status status, hidl_vec vectorResult) { - ASSERT_EQ(Status::OK, status); - spoid[0] = vectorResult; - }); - - // Try to open a session again. If provisioning took place, this time the - // attempt will be successful. Retrieve the spoid. This time only - // the device unique ID at the L3 security level will be queried. - // Confirm that it matches the spoid queried earlier. - plugin = new WVDrmPlugin(cdm.get(), kAppPackageName, &crypto, true); - - // Force L3 - status = plugin->setPropertyString(hidl_string("securityLevel"), - hidl_string("L3")); - ASSERT_EQ(Status::OK, status); - - plugin->openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.clear(); - sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size()); - }); - - EXPECT_EQ(Status::OK, plugin->closeSession(toHidlVec(sessionId))); - - plugin->getPropertyByteArray( - hidl_string("deviceUniqueId"), - [&](Status status, hidl_vec vectorResult) { - ASSERT_EQ(Status::OK, status); - spoid[1] = vectorResult; - }); - - EXPECT_EQ(spoid[0], spoid[1]); -} - -TEST_F(WVDrmPluginTest, ReturnsL1SpoidsWhenL3ProvisionedUsingL1Spoid) { - StrictMock crypto; - - std::string kL1DeviceId = kDeviceId + "L1"; - std::string kL3DeviceId = kDeviceId + "L3"; - - const std::string kAppPackageName("com.google.widevine"); - constexpr size_t kSpoidQuery = 2; - std::vector spoidL1; - std::vector spoidL3[kSpoidQuery]; - - // Set expectations for the first plugin instance - android::sp> cdm1 = new StrictMock(); - - EXPECT_CALL(*cdm1, QueryStatus(wvcdm::kLevelDefault, QUERY_KEY_DEVICE_ID, _)) - .WillOnce(DoAll(SetArgPointee<2>(kL1DeviceId), - testing::Return(wvcdm::NO_ERROR))); - - // Provide expected behavior to support session creation - EXPECT_CALL(*cdm1, OpenSession(StrEq("com.widevine"), _, _, _, _)) - .WillOnce(DoAll(SetArgPointee<4>(cdmSessionId), - testing::Return(wvcdm::NO_ERROR))) - .WillOnce(testing::Return(wvcdm::NEED_PROVISIONING)); - - EXPECT_CALL(*cdm1, QueryOemCryptoSessionId(cdmSessionId, _)) - .WillOnce(Invoke(setSessionIdOnMap<4>)); - - EXPECT_CALL(*cdm1, CloseSession(_)); - - // Open a session at L1 security level. The spoid is now computed with - // the L1 device unique ID - android::sp plugin = - new WVDrmPlugin(cdm1.get(), kAppPackageName, &crypto, true); - - plugin->openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.clear(); - sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size()); - }); - - EXPECT_EQ(Status::OK, plugin->closeSession(toHidlVec(sessionId))); - - plugin->getPropertyByteArray( - hidl_string("deviceUniqueId"), - [&](Status status, hidl_vec vectorResult) { - ASSERT_EQ(Status::OK, status); - spoidL1 = vectorResult; - }); - - // Force L3. This should not be allowed since the spoid has been - // computed. We defer correcting this, as this might have an - // impact on apps. L3 is not provisioned so a call to openSession - // returns a ERROR_DRM_NOT_PROVISIONED error. No spoid computation takes - // place. - Status status = plugin->setPropertyString(hidl_string("securityLevel"), - hidl_string("L3")); - ASSERT_EQ(Status::OK, status); - - plugin->openSession([&](Status status, hidl_vec) { - ASSERT_EQ(Status::ERROR_DRM_NOT_PROVISIONED, status); - }); - - plugin->getPropertyByteArray( - hidl_string("deviceUniqueId"), - [&](Status status, hidl_vec vectorResult) { - ASSERT_EQ(Status::OK, status); - spoidL3[0] = vectorResult; - }); - - // Set expectations for the second plugin instance - android::sp> cdm2 = new StrictMock(); - - EXPECT_CALL(*cdm2, QueryStatus(wvcdm::kLevelDefault, QUERY_KEY_DEVICE_ID, _)) - .WillOnce(DoAll(SetArgPointee<2>(kL1DeviceId), - testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm2, QueryStatus(wvcdm::kLevel3, QUERY_KEY_DEVICE_ID, _)) - .WillOnce(DoAll(SetArgPointee<2>(kL3DeviceId), - testing::Return(wvcdm::NO_ERROR))); - - // Provide expected behavior to support session creation - EXPECT_CALL(*cdm2, OpenSession(StrEq("com.widevine"), _, _, _, _)) - .WillOnce(DoAll(SetArgPointee<4>(cdmSessionId), - testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm2, QueryOemCryptoSessionId(cdmSessionId, _)) - .WillOnce(Invoke(setSessionIdOnMap<4>)); - - EXPECT_CALL(*cdm2, IsProvisioned(wvcdm::kSecurityLevelL1, _, _, _)) - .WillOnce(testing::Return(true)); - - EXPECT_CALL(*cdm2, IsProvisioned(wvcdm::kSecurityLevelL3, _, _, _)) - .WillOnce(testing::Return(false)); - - EXPECT_CALL(*cdm2, CloseSession(_)); - - // Try to open a session again. If provisioning took place, this time the - // attempt will be successful. Spoids are computed using device unique IDs - // from both L1 and L3. The device is provisioned for L3 using the spoid with - // L1 but not L3 device unique ID, so the spoid with L1 device unique ID is - // used. - plugin = new WVDrmPlugin(cdm2.get(), kAppPackageName, &crypto, true); - - // Force L3 - status = plugin->setPropertyString(hidl_string("securityLevel"), - hidl_string("L3")); - ASSERT_EQ(Status::OK, status); - - plugin->openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.clear(); - sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size()); - }); - - EXPECT_EQ(Status::OK, plugin->closeSession(toHidlVec(sessionId))); - - plugin->getPropertyByteArray( - hidl_string("deviceUniqueId"), - [&](Status status, hidl_vec vectorResult) { - ASSERT_EQ(Status::OK, status); - spoidL3[1] = vectorResult; - }); - - EXPECT_EQ(spoidL3[0], spoidL3[1]); - EXPECT_EQ(spoidL1, spoidL3[0]); -} - -TEST_F(WVDrmPluginTest, FailsGenericMethodsWithoutAnAlgorithmSet) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - std::vector keyId; - std::vector input; - std::vector iv; - std::vector output; - - // Provide expected behavior to support session creation - EXPECT_CALL(*cdm, OpenSession(StrEq("com.widevine"), _, _, _, _)) - .Times(AtLeast(1)) - .WillRepeatedly(DoAll(SetArgPointee<4>(cdmSessionId), - testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, QueryOemCryptoSessionId(cdmSessionId, _)) - .Times(AtLeast(1)) - .WillRepeatedly(Invoke(setSessionIdOnMap<4>)); - - EXPECT_CALL(*cdm, CloseSession(_)).Times(AtLeast(0)); - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - - plugin.openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.clear(); - sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size()); - }); - - // Note that we do not set the algorithms. This should cause these methods - // to fail. - - plugin.encrypt(toHidlVec(sessionId), toHidlVec(keyId), toHidlVec(input), - toHidlVec(iv), - [&](Status status, hidl_vec /* output */) { - // NO_INIT is converted to Status::ERROR_DRM_UNKNOWN - EXPECT_EQ(Status::ERROR_DRM_UNKNOWN, status); - }); - - plugin.decrypt(toHidlVec(sessionId), toHidlVec(keyId), toHidlVec(input), - toHidlVec(iv), - [&](Status status, hidl_vec /* output */) { - EXPECT_EQ(Status::ERROR_DRM_UNKNOWN, status); - }); - - plugin.sign(toHidlVec(sessionId), toHidlVec(keyId), toHidlVec(input), - [&](Status status, hidl_vec /* signature */) { - EXPECT_EQ(Status::ERROR_DRM_UNKNOWN, status); - }); - - plugin.verify(toHidlVec(sessionId), toHidlVec(keyId), toHidlVec(input), - toHidlVec(output), [&](Status status, bool /* match */) { - EXPECT_EQ(Status::ERROR_DRM_UNKNOWN, status); - }); -} - -MATCHER_P(IsIV, iv, "") { - for (size_t i = 0; i < KEY_IV_SIZE; ++i) { - if (iv[i] != arg[i]) { - return false; - } - } - - return true; -} - -TEST_F(WVDrmPluginTest, CallsGenericEncrypt) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - static const size_t kDataSize = 256; - uint8_t keyIdRaw[KEY_ID_SIZE]; - uint8_t inputRaw[kDataSize]; - uint8_t ivRaw[KEY_IV_SIZE]; - - FILE* fp = fopen("/dev/urandom", "r"); - fread(keyIdRaw, sizeof(uint8_t), KEY_ID_SIZE, fp); - fread(inputRaw, sizeof(uint8_t), kDataSize, fp); - fread(ivRaw, sizeof(uint8_t), KEY_IV_SIZE, fp); - fclose(fp); - - std::vector keyId; - keyId.assign(keyIdRaw, keyIdRaw + KEY_ID_SIZE); - std::vector input; - input.assign(inputRaw, inputRaw + kDataSize); - std::vector iv; - iv.assign(ivRaw, ivRaw + KEY_IV_SIZE); - std::vector output; - - { - InSequence calls; - - EXPECT_CALL(crypto, selectKey(4, _, KEY_ID_SIZE)) - .With(Args<1, 2>(ElementsAreArray(keyIdRaw, KEY_ID_SIZE))) - .Times(1); - - EXPECT_CALL(crypto, encrypt(4, _, kDataSize, IsIV(ivRaw), - OEMCrypto_AES_CBC_128_NO_PADDING, _)) - .With(Args<1, 2>(ElementsAreArray(inputRaw, kDataSize))) - .Times(1); - } - - // Provide expected behavior to support session creation - EXPECT_CALL(*cdm, OpenSession(StrEq("com.widevine"), _, _, _, _)) - .Times(AtLeast(1)) - .WillRepeatedly(DoAll(SetArgPointee<4>(cdmSessionId), - testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, QueryOemCryptoSessionId(cdmSessionId, _)) - .Times(AtLeast(1)) - .WillRepeatedly(Invoke(setSessionIdOnMap<4>)); - - EXPECT_CALL(*cdm, CloseSession(_)).Times(AtLeast(0)); - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - - plugin.openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.clear(); - sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size()); - }); - - Status status = plugin.setCipherAlgorithm(toHidlVec(sessionId), - hidl_string("AES/CBC/NoPadding")); - ASSERT_EQ(Status::OK, status); - - plugin.encrypt(toHidlVec(sessionId), toHidlVec(keyId), toHidlVec(input), - toHidlVec(iv), - [&](Status status, hidl_vec /* output */) { - ASSERT_EQ(Status::OK, status); - }); -} - -TEST_F(WVDrmPluginTest, CallsGenericDecrypt) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - static const size_t kDataSize = 256; - uint8_t keyIdRaw[KEY_ID_SIZE]; - uint8_t inputRaw[kDataSize]; - uint8_t ivRaw[KEY_IV_SIZE]; - - FILE* fp = fopen("/dev/urandom", "r"); - fread(keyIdRaw, sizeof(uint8_t), KEY_ID_SIZE, fp); - fread(inputRaw, sizeof(uint8_t), kDataSize, fp); - fread(ivRaw, sizeof(uint8_t), KEY_IV_SIZE, fp); - fclose(fp); - - std::vector keyId; - keyId.assign(keyIdRaw, keyIdRaw + KEY_ID_SIZE); - std::vector input; - input.assign(inputRaw, inputRaw + kDataSize); - std::vector iv; - iv.assign(ivRaw, ivRaw + KEY_IV_SIZE); - std::vector output; - - { - InSequence calls; - - EXPECT_CALL(crypto, selectKey(4, _, KEY_ID_SIZE)) - .With(Args<1, 2>(ElementsAreArray(keyIdRaw, KEY_ID_SIZE))) - .Times(1); - - EXPECT_CALL(crypto, decrypt(4, _, kDataSize, IsIV(ivRaw), - OEMCrypto_AES_CBC_128_NO_PADDING, _)) - .With(Args<1, 2>(ElementsAreArray(inputRaw, kDataSize))) - .Times(1); - } - - // Provide expected behavior to support session creation - EXPECT_CALL(*cdm, OpenSession(StrEq("com.widevine"), _, _, _, _)) - .Times(AtLeast(1)) - .WillRepeatedly(DoAll(SetArgPointee<4>(cdmSessionId), - testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, QueryOemCryptoSessionId(cdmSessionId, _)) - .Times(AtLeast(1)) - .WillRepeatedly(Invoke(setSessionIdOnMap<4>)); - - EXPECT_CALL(*cdm, CloseSession(_)).Times(AtLeast(0)); - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - - plugin.openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.clear(); - sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size()); - }); - - Status status = plugin.setCipherAlgorithm(toHidlVec(sessionId), - hidl_string("AES/CBC/NoPadding")); - ASSERT_EQ(Status::OK, status); - - plugin.decrypt(toHidlVec(sessionId), toHidlVec(keyId), toHidlVec(input), - toHidlVec(iv), - [&](Status status, hidl_vec /* output */) { - ASSERT_EQ(Status::OK, status); - }); -} - -TEST_F(WVDrmPluginTest, CallsGenericSign) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - static const size_t kDataSize = 256; - uint8_t keyIdRaw[KEY_ID_SIZE]; - uint8_t messageRaw[kDataSize]; - - FILE* fp = fopen("/dev/urandom", "r"); - fread(keyIdRaw, sizeof(uint8_t), KEY_ID_SIZE, fp); - fread(messageRaw, sizeof(uint8_t), kDataSize, fp); - fclose(fp); - - std::vector keyId; - keyId.assign(keyIdRaw, keyIdRaw + KEY_ID_SIZE); - std::vector message; - message.assign(messageRaw, messageRaw + kDataSize); - std::vector signature; - - { - InSequence calls; - - EXPECT_CALL(crypto, selectKey(4, _, KEY_ID_SIZE)) - .With(Args<1, 2>(ElementsAreArray(keyIdRaw, KEY_ID_SIZE))) - .Times(1); - - EXPECT_CALL(crypto, - sign(4, _, kDataSize, OEMCrypto_HMAC_SHA256, _, Pointee(0))) - .With(Args<1, 2>(ElementsAreArray(messageRaw, kDataSize))) - .WillOnce(DoAll(SetArgPointee<5>(64), - testing::Return(OEMCrypto_ERROR_SHORT_BUFFER))); - - EXPECT_CALL(crypto, - sign(4, _, kDataSize, OEMCrypto_HMAC_SHA256, _, Pointee(64))) - .With(Args<1, 2>(ElementsAreArray(messageRaw, kDataSize))) - .Times(1); - } - - // Provide expected behavior to support session creation - EXPECT_CALL(*cdm, OpenSession(StrEq("com.widevine"), _, _, _, _)) - .Times(AtLeast(1)) - .WillRepeatedly(DoAll(SetArgPointee<4>(cdmSessionId), - testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, QueryOemCryptoSessionId(cdmSessionId, _)) - .Times(AtLeast(1)) - .WillRepeatedly(Invoke(setSessionIdOnMap<4>)); - - EXPECT_CALL(*cdm, CloseSession(_)).Times(AtLeast(0)); - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - - plugin.openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.clear(); - sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size()); - }); - - Status status = - plugin.setMacAlgorithm(toHidlVec(sessionId), hidl_string("HmacSHA256")); - ASSERT_EQ(Status::OK, status); - - plugin.sign(toHidlVec(sessionId), toHidlVec(keyId), toHidlVec(message), - [&](Status status, hidl_vec signature) { - ASSERT_EQ(Status::OK, status); - ASSERT_NE(0u, signature.size()); - }); -} - -TEST_F(WVDrmPluginTest, CallsGenericVerify) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - static const size_t kDataSize = 256; - static const size_t kSignatureSize = 16; - uint8_t keyIdRaw[KEY_ID_SIZE]; - uint8_t messageRaw[kDataSize]; - uint8_t signatureRaw[kSignatureSize]; - - FILE* fp = fopen("/dev/urandom", "r"); - fread(keyIdRaw, sizeof(uint8_t), KEY_ID_SIZE, fp); - fread(messageRaw, sizeof(uint8_t), kDataSize, fp); - fread(signatureRaw, sizeof(uint8_t), kSignatureSize, fp); - fclose(fp); - - std::vector keyId; - keyId.assign(keyIdRaw, keyIdRaw + KEY_ID_SIZE); - std::vector message; - message.assign(messageRaw, messageRaw + kDataSize); - std::vector signature; - signature.assign(signatureRaw, signatureRaw + kSignatureSize); - - { - InSequence calls; - - EXPECT_CALL(crypto, selectKey(4, _, KEY_ID_SIZE)) - .With(Args<1, 2>(ElementsAreArray(keyIdRaw, KEY_ID_SIZE))) - .Times(1); - - EXPECT_CALL(crypto, verify(4, _, kDataSize, OEMCrypto_HMAC_SHA256, _, - kSignatureSize)) - .With(AllOf(Args<1, 2>(ElementsAreArray(messageRaw, kDataSize)), - Args<4, 5>(ElementsAreArray(signatureRaw, kSignatureSize)))) - .WillOnce(testing::Return(OEMCrypto_SUCCESS)); - - EXPECT_CALL(crypto, selectKey(4, _, KEY_ID_SIZE)) - .With(Args<1, 2>(ElementsAreArray(keyIdRaw, KEY_ID_SIZE))) - .Times(1); - - EXPECT_CALL(crypto, verify(4, _, kDataSize, OEMCrypto_HMAC_SHA256, _, - kSignatureSize)) - .With(AllOf(Args<1, 2>(ElementsAreArray(messageRaw, kDataSize)), - Args<4, 5>(ElementsAreArray(signatureRaw, kSignatureSize)))) - .WillOnce(testing::Return(OEMCrypto_ERROR_SIGNATURE_FAILURE)); - } - - // Provide expected behavior to support session creation - EXPECT_CALL(*cdm, OpenSession(StrEq("com.widevine"), _, _, _, _)) - .Times(AtLeast(1)) - .WillRepeatedly(DoAll(SetArgPointee<4>(cdmSessionId), - testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, QueryOemCryptoSessionId(cdmSessionId, _)) - .Times(AtLeast(1)) - .WillRepeatedly(Invoke(setSessionIdOnMap<4>)); - - EXPECT_CALL(*cdm, CloseSession(_)).Times(AtLeast(0)); - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - - plugin.openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.clear(); - sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size()); - }); - - Status status = - plugin.setMacAlgorithm(toHidlVec(sessionId), hidl_string("HmacSHA256")); - ASSERT_EQ(Status::OK, status); - - plugin.verify(toHidlVec(sessionId), toHidlVec(keyId), toHidlVec(message), - toHidlVec(signature), [&](Status status, bool match) { - ASSERT_EQ(Status::OK, status); - EXPECT_TRUE(match); - }); - - plugin.verify(toHidlVec(sessionId), toHidlVec(keyId), toHidlVec(message), - toHidlVec(signature), [&](Status status, bool match) { - ASSERT_EQ(Status::OK, status); - EXPECT_FALSE(match); - }); -} - -TEST_F(WVDrmPluginTest, RegistersForEvents) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - // Provide expected behavior to support session creation - EXPECT_CALL(*cdm, OpenSession(StrEq("com.widevine"), _, _, _, _)) - .Times(AtLeast(1)) - .WillRepeatedly(DoAll(SetArgPointee<4>(cdmSessionId), - testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, QueryOemCryptoSessionId(cdmSessionId, _)) - .Times(AtLeast(1)) - .WillRepeatedly(Invoke(setSessionIdOnMap<4>)); - - EXPECT_CALL(*cdm, CloseSession(_)).Times(AtLeast(0)); - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - plugin.openSession([&](Status status, hidl_vec /* hSessionId */) { - ASSERT_EQ(Status::OK, status); - }); -} - -TEST_F(WVDrmPluginTest, UnregistersForAllEventsOnDestruction) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - uint8_t sessionIdRaw1[kSessionIdSize]; - uint8_t sessionIdRaw2[kSessionIdSize]; - FILE* fp = fopen("/dev/urandom", "r"); - fread(sessionIdRaw1, sizeof(uint8_t), kSessionIdSize, fp); - fread(sessionIdRaw2, sizeof(uint8_t), kSessionIdSize, fp); - fclose(fp); - - CdmSessionId cdmSessionId1(sessionIdRaw1, sessionIdRaw1 + kSessionIdSize); - CdmSessionId cdmSessionId2(sessionIdRaw2, sessionIdRaw2 + kSessionIdSize); - - EXPECT_CALL(*cdm, OpenSession(StrEq("com.widevine"), _, _, _, _)) - .WillOnce(DoAll(SetArgPointee<4>(cdmSessionId1), - testing::Return(wvcdm::NO_ERROR))) - .WillOnce(DoAll(SetArgPointee<4>(cdmSessionId2), - testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, QueryOemCryptoSessionId(cdmSessionId1, _)) - .WillOnce(Invoke(setSessionIdOnMap<4>)); - - EXPECT_CALL(*cdm, QueryOemCryptoSessionId(cdmSessionId2, _)) - .WillOnce(Invoke(setSessionIdOnMap<5>)); - - EXPECT_CALL(*cdm, CloseSession(_)).Times(AtLeast(0)); - - { - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - - plugin.openSession([&](Status status, hidl_vec /* hSessionId */) { - ASSERT_EQ(Status::OK, status); - }); - - plugin.openSession([&](Status status, hidl_vec /* hSessionId */) { - ASSERT_EQ(Status::OK, status); - }); - } -} - -// TODO b/35325611 Fix this disabled test -TEST_F(WVDrmPluginTest, DISABLED_MarshalsEvents) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - sp> listener = - new StrictMock(); - - const int64_t kExpiryTimeInSeconds = 123456789012LL; - std::string kKeyId1 = "Testing Key1 Id "; - std::string kKeyId2 = "Testing Key2 Id "; - std::string kKeyId3 = "Testing Key3 Id "; - std::string kKeyId4 = "Testing Key4 Id "; - std::string kKeyId5 = "Testing Key5 Id "; - - { - InSequence calls; - - hidl_vec hEmptyData; - hidl_vec hSessionId; - hSessionId.setToExternal(sessionIdRaw, kSessionIdSize); - - std::vector keyId; - std::vector keyStatusList; - - KeyStatus_V1_2 keyStatus; - keyId.assign(kKeyId1.begin(), kKeyId1.end()); - keyStatus.keyId = toHidlVec(keyId); - keyStatus.type = KeyStatusType_V1_2::EXPIRED; - keyStatusList.push_back(keyStatus); - - hidl_vec hKeyStatusList = toHidlVec(keyStatusList); - EXPECT_CALL(*listener, - sendKeysChange_1_2(hSessionId, hKeyStatusList, false)); - - EXPECT_CALL(*listener, - sendEvent(EventType::KEY_EXPIRED, hSessionId, hEmptyData)); - - EXPECT_CALL(*listener, - sendEvent(EventType::KEY_NEEDED, hSessionId, hEmptyData)); - - // Expiry Time in Java API is in milliseconds. - EXPECT_CALL(*listener, sendExpirationUpdate(hSessionId, NEVER_EXPIRES)); - EXPECT_CALL(*listener, - sendExpirationUpdate(hSessionId, kExpiryTimeInSeconds * 1000)); - - keyStatusList.clear(); - keyId.clear(); - keyId.assign(kKeyId1.begin(), kKeyId1.end()); - keyStatus.type = KeyStatusType_V1_2::USABLE; - keyStatusList.push_back(keyStatus); - keyId.assign(kKeyId2.begin(), kKeyId2.end()); - keyStatus.type = KeyStatusType_V1_2::OUTPUTNOTALLOWED; - keyStatusList.push_back(keyStatus); - keyId.assign(kKeyId3.begin(), kKeyId3.end()); - keyStatus.type = KeyStatusType_V1_2::INTERNALERROR; - keyStatusList.push_back(keyStatus); - keyId.assign(kKeyId4.begin(), kKeyId4.end()); - keyStatus.type = KeyStatusType_V1_2::STATUSPENDING; - keyStatusList.push_back(keyStatus); - keyId.assign(kKeyId5.begin(), kKeyId5.end()); - keyStatus.type = KeyStatusType_V1_2::USABLEINFUTURE; - keyStatusList.push_back(keyStatus); - - hidl_vec hKeyStatusList2 = toHidlVec(keyStatusList); - EXPECT_CALL(*listener, - sendKeysChange_1_2(hSessionId, hKeyStatusList2, false)); - } - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - plugin.setListener(listener); - - CdmKeyStatusMap cdmKeysStatus; - cdmKeysStatus[kKeyId1] = wvcdm::kKeyStatusExpired; - plugin.OnSessionKeysChange(cdmSessionId, cdmKeysStatus, false); - - plugin.OnSessionRenewalNeeded(cdmSessionId); - plugin.OnExpirationUpdate(cdmSessionId, NEVER_EXPIRES); - plugin.OnExpirationUpdate(cdmSessionId, kExpiryTimeInSeconds); - - cdmKeysStatus[kKeyId1] = wvcdm::kKeyStatusUsable; - cdmKeysStatus[kKeyId2] = wvcdm::kKeyStatusOutputNotAllowed; - cdmKeysStatus[kKeyId3] = wvcdm::kKeyStatusInternalError; - cdmKeysStatus[kKeyId4] = wvcdm::kKeyStatusPending; - cdmKeysStatus[kKeyId5] = wvcdm::kKeyStatusUsableInFuture; - plugin.OnSessionKeysChange(cdmSessionId, cdmKeysStatus, true); -} - -// TODO b/35325611 Fix this disabled test -TEST_F(WVDrmPluginTest, DISABLED_GeneratesProvisioningNeededEvent) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - sp> listener = - new StrictMock(); - - hidl_vec hEmptyData; - hidl_vec hSessionId; - hSessionId.setToExternal(sessionIdRaw, kSessionIdSize); - - EXPECT_CALL(*listener, - sendEvent(EventType::PROVISION_REQUIRED, hSessionId, hEmptyData)) - .Times(1); - - EXPECT_CALL(*cdm, OpenSession(StrEq("com.widevine"), _, _, _, _)) - .Times(AtLeast(1)) - .WillRepeatedly(DoAll(SetArgPointee<4>(cdmSessionId), - testing::Return(wvcdm::NEED_PROVISIONING))); - - EXPECT_CALL(*cdm, CloseSession(_)).Times(AtLeast(0)); - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - plugin.setListener(listener); - - plugin.openSession([&](Status status, hidl_vec /* hSessionId */) { - ASSERT_EQ(Status::ERROR_DRM_NOT_PROVISIONED, status); - }); -} - -TEST_F(WVDrmPluginTest, ProvidesExpectedDefaultPropertiesToCdm) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - const CdmClientPropertySet* propertySet = nullptr; - - // Provide expected mock behavior - { - // Provide expected behavior in response to OpenSession and store the - // property set - EXPECT_CALL(*cdm, OpenSession(_, _, _, _, _)) - .WillRepeatedly(DoAll(SetArgPointee<4>(cdmSessionId), - SaveArg<1>(&propertySet), - testing::Return(wvcdm::NO_ERROR))); - - // Provide expected behavior when plugin requests session control info - EXPECT_CALL(*cdm, QueryOemCryptoSessionId(cdmSessionId, _)) - .WillRepeatedly(Invoke(setSessionIdOnMap<4>)); - - EXPECT_CALL(*cdm, CloseSession(_)).Times(AtLeast(0)); - } - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - - plugin.openSession([&](Status status, hidl_vec /* hSessionId */) { - ASSERT_EQ(Status::OK, status); - }); - - ASSERT_THAT(propertySet, NotNull()); - EXPECT_STREQ("", propertySet->security_level().c_str()); - EXPECT_FALSE(propertySet->use_privacy_mode()); - EXPECT_EQ(0u, propertySet->service_certificate().size()); - EXPECT_FALSE(propertySet->is_session_sharing_enabled()); - EXPECT_EQ(0u, propertySet->session_sharing_id()); - EXPECT_STREQ("", propertySet->app_id().c_str()); -} - -TEST_F(WVDrmPluginTest, CanSetAppId) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - const CdmClientPropertySet* propertySet = nullptr; - - // Provide expected mock behavior - { - // Provide expected behavior in response to OpenSession and store the - // property set - EXPECT_CALL(*cdm, OpenSession(_, _, _, _, _)) - .WillRepeatedly(DoAll(SetArgPointee<4>(cdmSessionId), - SaveArg<1>(&propertySet), - testing::Return(wvcdm::NO_ERROR))); - - // Provide expected behavior when plugin queries for the security level - EXPECT_CALL(*cdm, QueryStatus(_, QUERY_KEY_SECURITY_LEVEL, _)) - .WillRepeatedly(DoAll(SetArgPointee<2>(QUERY_VALUE_SECURITY_LEVEL_L3), - testing::Return(wvcdm::NO_ERROR))); - - // Provide expected behavior when plugin requests session control info - EXPECT_CALL(*cdm, QueryOemCryptoSessionId(cdmSessionId, _)) - .WillRepeatedly(Invoke(setSessionIdOnMap<4>)); - - EXPECT_CALL(*cdm, CloseSession(_)).Times(AtLeast(0)); - } - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - - // Test setting an empty string - Status status = - plugin.setPropertyString(hidl_string("appId"), hidl_string("")); - ASSERT_EQ(Status::OK, status); - - // Test setting an application id before a session is opened. - status = plugin.setPropertyString(hidl_string("appId"), hidl_string(kAppId)); - ASSERT_EQ(Status::OK, status); - - plugin.openSession([&](Status status, hidl_vec /* hSessionId */) { - ASSERT_EQ(Status::OK, status); - }); - ASSERT_THAT(propertySet, NotNull()); - - // Verify application id is set correctly. - EXPECT_STREQ(kAppId.c_str(), propertySet->app_id().c_str()); - - // Test setting application id while session is opened, this should fail. - status = plugin.setPropertyString(hidl_string("appId"), hidl_string(kAppId)); - ASSERT_EQ(Status::ERROR_DRM_UNKNOWN, status); -} - -TEST_P(WVDrmPluginOriginTest, CanSetOrigin) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - OriginTestVariant params = GetParam(); - - // Provide expected mock behavior - { - // Provide expected behavior when plugin requests session control info - EXPECT_CALL(*cdm, QueryOemCryptoSessionId(cdmSessionId, _)) - .WillRepeatedly(Invoke(setSessionIdOnMap<4>)); - - // Provide expected behavior when plugin closes a session - EXPECT_CALL(*cdm, CloseSession(_)).Times(AtLeast(0)); - } - - // Note which mock calls we expect - EXPECT_CALL(*cdm, OpenSession(_, _, HasOrigin(params.expectedOrigin), _, _)) - .WillOnce(DoAll(SetArgPointee<4>(cdmSessionId), - testing::Return(wvcdm::NO_ERROR))); - - // Set the properties & run the test - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - - if (!params.origin.empty()) { - ASSERT_EQ(Status::OK, plugin.setPropertyString(hidl_string("origin"), - hidl_string(params.origin))); - } - - plugin.openSession([&](Status status, hidl_vec /* hSessionId */) { - EXPECT_EQ(Status::OK, status); - }); - // Test setting an origin while sessions are opened. This should fail. - EXPECT_NE(Status::OK, plugin.setPropertyString(hidl_string("origin"), - hidl_string(kOrigin))); - EXPECT_EQ(Status::OK, plugin.closeSession(toHidlVec(sessionId))); -} - -INSTANTIATE_TEST_CASE_P( - OriginTests, WVDrmPluginOriginTest, - Values(OriginTestVariant("No Origin", kEmptyString, EMPTY_ORIGIN), - OriginTestVariant("With an Origin", kOrigin, kOrigin.c_str()))); - -TEST_F(WVDrmPluginTest, CanSetSecurityLevel) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - const CdmClientPropertySet* propertySet = nullptr; - - EXPECT_CALL(*cdm, QueryStatus(_, QUERY_KEY_SECURITY_LEVEL, _)) - .WillOnce(DoAll(SetArgPointee<2>(QUERY_VALUE_SECURITY_LEVEL_L3), - testing::Return(wvcdm::NO_ERROR))) - .WillOnce(DoAll(SetArgPointee<2>(QUERY_VALUE_SECURITY_LEVEL_L1), - testing::Return(wvcdm::NO_ERROR))); - - // Provide expected mock behavior - { - // Provide expected behavior in response to OpenSession and store the - // property set - EXPECT_CALL(*cdm, OpenSession(_, _, _, _, _)) - .WillRepeatedly(DoAll(SetArgPointee<4>(cdmSessionId), - SaveArg<1>(&propertySet), - testing::Return(wvcdm::NO_ERROR))); - - // Provide expected behavior when plugin requests session control info - EXPECT_CALL(*cdm, QueryOemCryptoSessionId(cdmSessionId, _)) - .WillRepeatedly(Invoke(setSessionIdOnMap<4>)); - - EXPECT_CALL(*cdm, CloseSession(_)).Times(AtLeast(0)); - } - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - - // Test forcing L3 - Status status = - plugin.setPropertyString(hidl_string("securityLevel"), hidl_string("L3")); - ASSERT_EQ(Status::OK, status); - - plugin.openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.clear(); - sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size()); - }); - ASSERT_THAT(propertySet, NotNull()); - EXPECT_STREQ("L3", propertySet->security_level().c_str()); - status = plugin.closeSession(toHidlVec(sessionId)); - ASSERT_EQ(Status::OK, status); - - // Test returning to L1 on an L3 device (Should Fail) - status = - plugin.setPropertyString(hidl_string("securityLevel"), hidl_string("L1")); - ASSERT_NE(Status::OK, status); - - plugin.openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.clear(); - sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size()); - }); - ASSERT_THAT(propertySet, NotNull()); - EXPECT_STREQ("L3", propertySet->security_level().c_str()); - status = plugin.closeSession(toHidlVec(sessionId)); - ASSERT_EQ(Status::OK, status); - - // Test returning to L1 on an L1 device - status = - plugin.setPropertyString(hidl_string("securityLevel"), hidl_string("L1")); - ASSERT_EQ(Status::OK, status); - - plugin.openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.clear(); - sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size()); - }); - ASSERT_THAT(propertySet, NotNull()); - EXPECT_STREQ("", propertySet->security_level().c_str()); - status = plugin.closeSession(toHidlVec(sessionId)); - ASSERT_EQ(Status::OK, status); - - // Test un-forcing a level (first forcing to L3 so we have something to reset) - status = - plugin.setPropertyString(hidl_string("securityLevel"), hidl_string("L3")); - ASSERT_EQ(Status::OK, status); - - plugin.openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.clear(); - sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size()); - }); - ASSERT_THAT(propertySet, NotNull()); - EXPECT_STREQ("L3", propertySet->security_level().c_str()); - status = plugin.closeSession(toHidlVec(sessionId)); - ASSERT_EQ(Status::OK, status); - - status = - plugin.setPropertyString(hidl_string("securityLevel"), hidl_string("")); - ASSERT_EQ(Status::OK, status); - - plugin.openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.clear(); - sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size()); - }); - ASSERT_THAT(propertySet, NotNull()); - EXPECT_STREQ("", propertySet->security_level().c_str()); - status = plugin.closeSession(toHidlVec(sessionId)); - ASSERT_EQ(Status::OK, status); - - // Test nonsense (Should Fail) - status = plugin.setPropertyString(hidl_string("securityLevel"), - hidl_string("nonsense")); - ASSERT_NE(Status::OK, status); - - plugin.openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.clear(); - sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size()); - }); - ASSERT_THAT(propertySet, NotNull()); - EXPECT_STREQ("", propertySet->security_level().c_str()); - status = plugin.closeSession(toHidlVec(sessionId)); - ASSERT_EQ(Status::OK, status); - - // Test attempting to force a level with a session open (Should Fail) - plugin.openSession([&](Status status, hidl_vec /* hSessionId */) { - ASSERT_EQ(Status::OK, status); - }); - status = - plugin.setPropertyString(hidl_string("securityLevel"), hidl_string("L3")); - ASSERT_NE(Status::OK, status); -} - -TEST_F(WVDrmPluginTest, CanSetPrivacyMode) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - const CdmClientPropertySet* propertySet = nullptr; - - // Provide expected mock behavior - { - // Provide expected behavior in response to OpenSession and store the - // property set - EXPECT_CALL(*cdm, OpenSession(_, _, _, _, _)) - .WillRepeatedly(DoAll(SetArgPointee<4>(cdmSessionId), - SaveArg<1>(&propertySet), - testing::Return(wvcdm::NO_ERROR))); - - // Provide expected behavior when plugin requests session control info - EXPECT_CALL(*cdm, QueryOemCryptoSessionId(cdmSessionId, _)) - .WillRepeatedly(Invoke(setSessionIdOnMap<4>)); - - EXPECT_CALL(*cdm, CloseSession(_)).Times(AtLeast(0)); - } - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - - plugin.openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.clear(); - sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size()); - }); - ASSERT_THAT(propertySet, NotNull()); - - // Test turning on privacy mode - Status status = plugin.setPropertyString(hidl_string("privacyMode"), - hidl_string("enable")); - ASSERT_EQ(Status::OK, status); - EXPECT_TRUE(propertySet->use_privacy_mode()); - - // Test turning off privacy mode - status = plugin.setPropertyString(hidl_string("privacyMode"), - hidl_string("disable")); - ASSERT_EQ(Status::OK, status); - EXPECT_FALSE(propertySet->use_privacy_mode()); - - // Test nonsense (Should Fail) - status = plugin.setPropertyString(hidl_string("privacyMode"), - hidl_string("nonsense")); - ASSERT_NE(Status::OK, status); -} - -TEST_F(WVDrmPluginTest, CanSetServiceCertificate) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - const CdmClientPropertySet* propertySet = nullptr; - - static const size_t kPrivacyCertSize = 256; - uint8_t privacyCertRaw[kPrivacyCertSize]; - - FILE* fp = fopen("/dev/urandom", "r"); - fread(privacyCertRaw, sizeof(uint8_t), kPrivacyCertSize, fp); - fclose(fp); - - std::vector privacyCert; - privacyCert.assign(privacyCertRaw, privacyCertRaw + kPrivacyCertSize); - std::string strPrivacyCert(reinterpret_cast(privacyCertRaw), - kPrivacyCertSize); - std::vector emptyVector; - - // Provide expected mock behavior - { - // Provide expected behavior in response to OpenSession and store the - // property set - EXPECT_CALL(*cdm, OpenSession(_, _, _, _, _)) - .WillRepeatedly(DoAll(SetArgPointee<4>(cdmSessionId), - SaveArg<1>(&propertySet), - testing::Return(wvcdm::NO_ERROR))); - - // Provide expected behavior when plugin requests session control info - EXPECT_CALL(*cdm, QueryOemCryptoSessionId(cdmSessionId, _)) - .WillRepeatedly(Invoke(setSessionIdOnMap<4>)); - - EXPECT_CALL(*cdm, CloseSession(_)).Times(AtLeast(0)); - } - - // Validate that the certificate is validated. Accept it once and reject it - // once. Note that there is no expected call for when the certificate is - // cleared. - EXPECT_CALL(*cdm, IsValidServiceCertificate(strPrivacyCert)) - .WillOnce(testing::Return(true)) - .WillOnce(testing::Return(false)); - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - - plugin.openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.clear(); - sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size()); - }); - ASSERT_THAT(propertySet, NotNull()); - - // Test setting a certificate - Status status = plugin.setPropertyByteArray(hidl_string("serviceCertificate"), - toHidlVec(privacyCert)); - ASSERT_EQ(Status::OK, status); - EXPECT_THAT(propertySet->service_certificate(), - ElementsAreArray(privacyCertRaw, kPrivacyCertSize)); - - // Test clearing a certificate - status = plugin.setPropertyByteArray(hidl_string("serviceCertificate"), - toHidlVec(emptyVector)); - ASSERT_EQ(Status::OK, status); - EXPECT_EQ(0u, propertySet->service_certificate().size()); - - // Test setting a certificate and having it fail - status = plugin.setPropertyByteArray(hidl_string("serviceCertificate"), - toHidlVec(privacyCert)); - ASSERT_NE(Status::OK, status); - EXPECT_EQ(0u, propertySet->service_certificate().size()); -} - -TEST_F(WVDrmPluginTest, CanSetSessionSharing) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - const CdmClientPropertySet* propertySet = nullptr; - - // Provide expected mock behavior - { - // Provide expected behavior in response to OpenSession and store the - // property set - EXPECT_CALL(*cdm, OpenSession(_, _, _, _, _)) - .WillRepeatedly(DoAll(SetArgPointee<4>(cdmSessionId), - SaveArg<1>(&propertySet), - testing::Return(wvcdm::NO_ERROR))); - - // Provide expected behavior when plugin requests session control info - EXPECT_CALL(*cdm, QueryOemCryptoSessionId(cdmSessionId, _)) - .WillRepeatedly(Invoke(setSessionIdOnMap<4>)); - - EXPECT_CALL(*cdm, CloseSession(_)).Times(AtLeast(0)); - } - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - - // Test turning on session sharing - Status status = plugin.setPropertyString(hidl_string("sessionSharing"), - hidl_string("enable")); - ASSERT_EQ(Status::OK, status); - - plugin.openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.clear(); - sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size()); - }); - ASSERT_THAT(propertySet, NotNull()); - EXPECT_TRUE(propertySet->is_session_sharing_enabled()); - status = plugin.closeSession(toHidlVec(sessionId)); - ASSERT_EQ(Status::OK, status); - - // Test turning off session sharing - status = plugin.setPropertyString(hidl_string("sessionSharing"), - hidl_string("disable")); - ASSERT_EQ(Status::OK, status); - - plugin.openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.clear(); - sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size()); - }); - ASSERT_THAT(propertySet, NotNull()); - EXPECT_FALSE(propertySet->is_session_sharing_enabled()); - status = plugin.closeSession(toHidlVec(sessionId)); - ASSERT_EQ(Status::OK, status); - - // Test nonsense (Should Fail) - status = plugin.setPropertyString(hidl_string("sessionSharing"), - hidl_string("nonsense")); - ASSERT_NE(Status::OK, status); - - // Test changing sharing with a session open (Should Fail) - plugin.openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.clear(); - sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size()); - }); - status = plugin.setPropertyString(hidl_string("sessionSharing"), - hidl_string("enable")); - ASSERT_NE(Status::OK, status); - - status = plugin.closeSession(toHidlVec(sessionId)); - ASSERT_EQ(Status::OK, status); -} - -TEST_F(WVDrmPluginTest, AllowsStoringOfSessionSharingId) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - CdmClientPropertySet* propertySet = nullptr; - - uint32_t sharingId; - FILE* fp = fopen("/dev/urandom", "r"); - fread(&sharingId, sizeof(uint32_t), 1, fp); - fclose(fp); - - // Provide expected mock behavior - { - // Provide expected behavior in response to OpenSession and store the - // property set - EXPECT_CALL(*cdm, OpenSession(_, _, _, _, _)) - .WillRepeatedly(DoAll(SetArgPointee<4>(cdmSessionId), - SaveArg<1>(&propertySet), - testing::Return(wvcdm::NO_ERROR))); - - // Provide expected behavior when plugin requests session control info - EXPECT_CALL(*cdm, QueryOemCryptoSessionId(cdmSessionId, _)) - .WillRepeatedly(Invoke(setSessionIdOnMap<4>)); - - EXPECT_CALL(*cdm, CloseSession(_)).Times(AtLeast(0)); - } - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - plugin.openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.clear(); - sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size()); - }); - - ASSERT_THAT(propertySet, NotNull()); - propertySet->set_session_sharing_id(sharingId); - EXPECT_EQ(sharingId, propertySet->session_sharing_id()); -} - -TEST_F(WVDrmPluginTest, CanSetAtscMode) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName = "com.test.package"; - - const CdmClientPropertySet* propertySet = nullptr; - CdmIdentifier cdmIdAtscModeNotSet; - CdmIdentifier cdmIdAtscModeSet; - CdmIdentifier cdmIdAtscModeReset; - - // Provide expected mock behavior - { - // Provide expected behavior in response to OpenSession and store the - // property set - EXPECT_CALL(*cdm, OpenSession(_, _, _, _, _)) - .WillOnce(DoAll( - SetArgPointee<4>(cdmSessionId), SaveArg<1>(&propertySet), - SaveArg<2>(&cdmIdAtscModeNotSet), testing::Return(wvcdm::NO_ERROR))) - .WillOnce(DoAll(SetArgPointee<4>(cdmSessionId), - SaveArg<1>(&propertySet), SaveArg<2>(&cdmIdAtscModeSet), - testing::Return(wvcdm::NO_ERROR))) - .WillOnce(DoAll( - SetArgPointee<4>(cdmSessionId), SaveArg<1>(&propertySet), - SaveArg<2>(&cdmIdAtscModeReset), testing::Return(wvcdm::NO_ERROR))); - - // Provide expected behavior when plugin requests session control info - EXPECT_CALL(*cdm, QueryOemCryptoSessionId(cdmSessionId, _)) - .WillRepeatedly(Invoke(setSessionIdOnMap<4>)); - - EXPECT_CALL(*cdm, CloseSession(_)).Times(AtLeast(0)); - } - - WVDrmPlugin plugin1(cdm.get(), appPackageName, &crypto, false); - - // Verify that ATSC mode is disabled by default - plugin1.openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size()); - }); - ASSERT_THAT(propertySet, NotNull()); - EXPECT_FALSE(propertySet->use_atsc_mode()); - EXPECT_EQ(cdmIdAtscModeNotSet.app_package_name, appPackageName); - Status status = plugin1.closeSession(toHidlVec(sessionId)); - ASSERT_EQ(Status::OK, status); - - // Verify that ATSC mode can be enabled - WVDrmPlugin plugin2(cdm.get(), appPackageName, &crypto, false); - - // Test turning on ATSC mode - status = - plugin2.setPropertyString(hidl_string("atscMode"), hidl_string("enable")); - ASSERT_EQ(Status::OK, status); - - plugin2.openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size()); - }); - ASSERT_THAT(propertySet, NotNull()); - EXPECT_TRUE(propertySet->use_atsc_mode()); - EXPECT_EQ(cdmIdAtscModeSet.app_package_name, wvcdm::ATSC_APP_PACKAGE_NAME); - status = plugin2.closeSession(toHidlVec(sessionId)); - ASSERT_EQ(Status::OK, status); - - // Verify that ATSC mode can be enabled and disabled - WVDrmPlugin plugin3(cdm.get(), appPackageName, &crypto, false); - - // Test turning on ATSC mode - status = - plugin3.setPropertyString(hidl_string("atscMode"), hidl_string("enable")); - ASSERT_EQ(Status::OK, status); - - // Test turning off ATSC mode - status = plugin3.setPropertyString(hidl_string("atscMode"), - hidl_string("disable")); - ASSERT_EQ(Status::OK, status); - - plugin3.openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size()); - }); - ASSERT_THAT(propertySet, NotNull()); - EXPECT_FALSE(propertySet->use_atsc_mode()); - EXPECT_EQ(cdmIdAtscModeReset.app_package_name, appPackageName); - status = plugin3.closeSession(toHidlVec(sessionId)); - ASSERT_EQ(Status::OK, status); - - // Test turning on and off ATSC mode. They should be rejected since the SPOID - // has been calculated - status = - plugin3.setPropertyString(hidl_string("atscMode"), hidl_string("enable")); - ASSERT_NE(Status::OK, status); - - status = plugin3.setPropertyString(hidl_string("atscMode"), - hidl_string("disable")); - ASSERT_NE(Status::OK, status); -} - -TEST_F(WVDrmPluginTest, CanSetDecryptHashProperties) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - // Provide expected mock behavior - { - // Provide expected behavior in response to OpenSession and store the - // property set - EXPECT_CALL(*cdm, OpenSession(_, _, _, _, _)) - .WillRepeatedly(DoAll(SetArgPointee<4>(cdmSessionId), - testing::Return(wvcdm::NO_ERROR))); - - // Provide expected behavior when plugin requests session control info - EXPECT_CALL(*cdm, QueryOemCryptoSessionId(cdmSessionId, _)) - .WillRepeatedly(Invoke(setSessionIdOnMap<4>)); - - EXPECT_CALL(*cdm, CloseSession(_)).Times(AtLeast(0)); - } - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - - hidl_vec hSessionId; - hSessionId.setToExternal(sessionIdRaw, kSessionIdSize); - plugin.openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.clear(); - sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size()); - }); - - // CDM expects the string property value to be in the following format: - // ",," - static const std::string frameNumber = ",1"; - uint32_t hash = 0xbeef; // crc32 hash - const std::vector hashVector( - reinterpret_cast(&hash), - reinterpret_cast(&hash) + sizeof(uint32_t)); - const std::string base64EncodedHash = wvutil::Base64Encode(hashVector); - std::string computedHash(sessionId.begin(), sessionId.end()); - computedHash.append(frameNumber.c_str()); - computedHash.append(base64EncodedHash.c_str()); - Status status = plugin.setPropertyString(hidl_string("decryptHash"), - hidl_string(computedHash)); - ASSERT_NE(Status::OK, status); - - status = plugin.closeSession(toHidlVec(sessionId)); - ASSERT_EQ(Status::OK, status); -} - -TEST_F(WVDrmPluginTest, DoesNotSetDecryptHashProperties) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - // Provide expected mock behavior - { - // Provide expected behavior in response to OpenSession and store the - // property set - EXPECT_CALL(*cdm, OpenSession(_, _, _, _, _)) - .WillRepeatedly(DoAll(SetArgPointee<4>(cdmSessionId), - testing::Return(wvcdm::NO_ERROR))); - - // Provide expected behavior when plugin requests session control info - EXPECT_CALL(*cdm, QueryOemCryptoSessionId(cdmSessionId, _)) - .WillRepeatedly(Invoke(setSessionIdOnMap<4>)); - - EXPECT_CALL(*cdm, CloseSession(_)).Times(AtLeast(0)); - } - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - - hidl_vec hSessionId; - hSessionId.setToExternal(sessionIdRaw, kSessionIdSize); - plugin.openSession([&](Status status, hidl_vec hSessionId) { - ASSERT_EQ(Status::OK, status); - sessionId.clear(); - sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size()); - }); - - // CDM expects the string property value to be in the following format: - // ",," - static const std::string frameNumber = ",1"; - static const std::string hash = ",AZaz0+,/"; - std::string value(sessionId.begin(), sessionId.end()); - value.append(frameNumber.c_str()); - - // Tests for missing token handling - Status status = - plugin.setPropertyString(hidl_string("decryptHash"), hidl_string(value)); - EXPECT_NE(Status::OK, status); - - // Tests for empty token - value.append(","); - status = - plugin.setPropertyString(hidl_string("decryptHash"), hidl_string(value)); - EXPECT_NE(Status::OK, status); - - // Tests for invalid sessionId - value.clear(); - value.append("bad session id"); - value.append(",1"); - value.append(hash.c_str()); - status = - plugin.setPropertyString(hidl_string("decryptHash"), hidl_string(value)); - EXPECT_NE(Status::OK, status); - - // Tests for malformed Base64encode hash, with a "," - std::string computedHash(sessionId.begin(), sessionId.end()); - computedHash.append(frameNumber.c_str()); - computedHash.append(hash.c_str()); - status = plugin.setPropertyString(hidl_string("decryptHash"), - hidl_string(computedHash)); - EXPECT_NE(Status::OK, status); - - status = plugin.closeSession(toHidlVec(sessionId)); - ASSERT_EQ(Status::OK, status); -} - -TEST_F(WVDrmPluginTest, GetOfflineLicenseIds) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - const uint32_t kLicenseCount = 5; - - uint8_t mockIdsRaw[kLicenseCount * 2][kKeySetIdSize]; - FILE* fp = fopen("/dev/urandom", "r"); - for (uint32_t i = 0; i < kLicenseCount * 2; ++i) { - fread(mockIdsRaw[i], sizeof(uint8_t), kKeySetIdSize, fp); - } - fclose(fp); - - std::vector mockIdsL1; - for (uint32_t i = 0; i < kLicenseCount; ++i) { - mockIdsL1.push_back( - std::string(mockIdsRaw[i], mockIdsRaw[i] + kKeySetIdSize)); - } - - std::vector mockIdsL3; - for (uint32_t i = 0; i < kLicenseCount; ++i) { - mockIdsL3.push_back( - std::string(mockIdsRaw[i + 5], mockIdsRaw[i + 5] + kKeySetIdSize)); - } - - EXPECT_CALL(*cdm, - ListStoredLicenses(kSecurityLevelL1, HasOrigin(EMPTY_ORIGIN), _)) - .WillOnce( - DoAll(SetArgPointee<2>(mockIdsL1), testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, - ListStoredLicenses(kSecurityLevelL3, HasOrigin(EMPTY_ORIGIN), _)) - .WillOnce( - DoAll(SetArgPointee<2>(mockIdsL3), testing::Return(wvcdm::NO_ERROR))); - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - - std::vector> offlineIds; - offlineIds.clear(); - plugin.getOfflineLicenseKeySetIds( - [&](Status status, hidl_vec hKeySetIds) { - ASSERT_EQ(Status::OK, status); - - std::vector ids(hKeySetIds); - - for (auto id : ids) { - offlineIds.push_back(id); - } - }); - - size_t index = 0; - for (auto id : offlineIds) { - EXPECT_THAT(id, ElementsAreArray(mockIdsRaw[index++], kKeySetIdSize)); - } - EXPECT_EQ(kLicenseCount * 2, index); -} - -TEST_F(WVDrmPluginTest, GetOfflineLicenseState) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - EXPECT_CALL(*cdm, QueryStatus(_, QUERY_KEY_SECURITY_LEVEL, _)) - .WillRepeatedly(DoAll(SetArgPointee<2>(QUERY_VALUE_SECURITY_LEVEL_L1), - testing::Return(wvcdm::NO_ERROR))); - - EXPECT_CALL(*cdm, GetOfflineLicenseState(_, kSecurityLevelL1, - HasOrigin(EMPTY_ORIGIN), _)) - .WillOnce(DoAll(SetArgPointee<3>(wvcdm::kLicenseStateActive), - testing::Return(wvcdm::NO_ERROR))) - .WillOnce(DoAll(SetArgPointee<3>(wvcdm::kLicenseStateReleasing), - testing::Return(wvcdm::NO_ERROR))) - .WillOnce(DoAll(SetArgPointee<3>(wvcdm::kLicenseStateUnknown), - testing::Return(wvcdm::NO_ERROR))); - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - Status status = - plugin.setPropertyString(hidl_string("securityLevel"), hidl_string("L1")); - ASSERT_EQ(Status::OK, status); - - plugin.getOfflineLicenseState( - toHidlVec(keySetId), - [&](Status status, OfflineLicenseState hLicenseState) { - ASSERT_EQ(Status::OK, status); - ASSERT_EQ(OfflineLicenseState::USABLE, hLicenseState); - }); - - plugin.getOfflineLicenseState( - toHidlVec(keySetId), - [&](Status status, OfflineLicenseState hLicenseState) { - ASSERT_EQ(Status::OK, status); - ASSERT_EQ(OfflineLicenseState::INACTIVE, hLicenseState); - }); - - plugin.getOfflineLicenseState( - toHidlVec(keySetId), - [&](Status status, OfflineLicenseState hLicenseState) { - ASSERT_EQ(Status::OK, status); - ASSERT_EQ(OfflineLicenseState::UNKNOWN, hLicenseState); - }); -} - -TEST_F(WVDrmPluginTest, RemoveOfflineLicense) { - android::sp> cdm = new StrictMock(); - StrictMock crypto; - std::string appPackageName; - - EXPECT_CALL( - *cdm, RemoveOfflineLicense(_, kSecurityLevelL1, HasOrigin(EMPTY_ORIGIN))) - .Times(1); - - WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false); - - Status status = plugin.removeOfflineLicense(toHidlVec(keySetId)); - ASSERT_EQ(Status::OK, status); -} - -} // namespace widevine -} // namespace V1_4 -} // namespace drm -} // namespace hardware -} // namespace wvdrm diff --git a/libwvdrmengine/mediadrm/test/hidl/hidl_metrics_adapter_unittest.cpp b/libwvdrmengine/mediadrm/test/hidl/hidl_metrics_adapter_unittest.cpp deleted file mode 100644 index ef43174c..00000000 --- a/libwvdrmengine/mediadrm/test/hidl/hidl_metrics_adapter_unittest.cpp +++ /dev/null @@ -1,459 +0,0 @@ -// -// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary -// source code may only be used and distributed under the Widevine License -// Agreement. -// - -// This file contains unit tests for the HidlMetricsAdapter. - -#include "hidl_metrics_adapter.h" - -#include -#include -#include - -#include "gtest/gtest.h" -#include "wv_metrics.pb.h" - -using android::hardware::hidl_vec; -using android::hardware::drm::V1_1::DrmMetricGroup; -using drm_metrics::CounterMetric; -using drm_metrics::DistributionMetric; - -namespace { - -template -std::string ToString(const T& attribute_or_value) { - std::ostringstream os; - switch (attribute_or_value.type) { - case DrmMetricGroup::ValueType::DOUBLE_TYPE: - os << "DOUBLE_TYPE. value: " << attribute_or_value.doubleValue; - break; - case DrmMetricGroup::ValueType::INT64_TYPE: - os << "INT64_TYPE. value: " << attribute_or_value.int64Value; - break; - case DrmMetricGroup::ValueType::STRING_TYPE: - os << "STRING_TYPE. value: " << attribute_or_value.stringValue; - break; - default: - os << "UNKNOWN TYPE!!: " << (int64_t) attribute_or_value.type; - break; - } - os << " (" << attribute_or_value.int64Value << "," - << attribute_or_value.doubleValue << ",\"" - << attribute_or_value.stringValue << "\")"; - return os.str(); -} - -std::string ToString(const DrmMetricGroup::Metric& metric) { - std::ostringstream os; - os << "metric: " << metric.name << std::endl; - os << " attributes:" << std::endl; - for (unsigned a = 0; a < metric.attributes.size(); a++) { - os << " " << metric.attributes[a].name << ". " - << ToString(metric.attributes[a]) << std::endl; - } - os << " values:" << std::endl; - for (unsigned v = 0; v < metric.values.size(); v++) { - os << " " << metric.values[v].componentName << ". " - << ToString(metric.values[v]) << std::endl; - } - return os.str(); -} - -std::string ToString(const hidl_vec& metrics_vector) { - std::ostringstream os; - os << "hidl metrics..." << std::endl; - os << "group count: " << metrics_vector.size() << std::endl; - for (unsigned g = 0; g < metrics_vector.size(); g++) { - os << "group " << g << ". metric count: " - << metrics_vector[g].metrics.size() << std::endl; - for (unsigned m = 0; m < metrics_vector[g].metrics.size(); m++) { - const DrmMetricGroup::Metric metric = metrics_vector[g].metrics[m]; - os << ToString(metric); - } - } - return os.str(); -} - -bool HasMetric(const DrmMetricGroup::Metric& expected, - const DrmMetricGroup& actual_metrics) { - DrmMetricGroup::Metric metric; - auto it = std::find(actual_metrics.metrics.begin(), - actual_metrics.metrics.end(), expected); - if (it == actual_metrics.metrics.end()) { - ALOGE("COULDN'T FIND THE METRIC! %s", ToString(expected).c_str()); - for (auto it = actual_metrics.metrics.begin(); - it < actual_metrics.metrics.end(); it++) { - if (expected.name == it->name) { - ALOGE("Names match."); - } - if (expected.attributes == it->attributes) { - ALOGE("attributes match."); - } - if (expected.values == it->values) { - ALOGE("values match."); - } else { - ALOGE("values length match? %zu, %zu", - expected.values.size(), it->values.size()); - if (expected.values.size() == it->values.size()) { - for (unsigned int i = 0; i < expected.values.size(); i++) { - ALOGE("value %u match? %d", i, expected.values[i] == it->values[i]); - if (expected.values[i] != it->values[i]) { - ALOGE("value component mismatch. %u. %s, %s", - i, expected.values[i].componentName.c_str(), - it->values[i].componentName.c_str()); - } - } - } - } - } - } else { - ALOGE("Found metric: %s", ToString(*it).c_str()); - } - return it != actual_metrics.metrics.end(); -} - -} // anonymous namespace - -namespace wvcdm { - -TEST(HidlMetricsAdapterTest, EmptyMetrics) { - drm_metrics::WvCdmMetrics metrics_proto; - hidl_vec hidl_metrics; - - HidlMetricsAdapter::ToHidlMetrics(metrics_proto, &hidl_metrics); - ASSERT_EQ(0U, hidl_metrics.size()) << ToString(hidl_metrics); -} - -// Adds a metric from each type - Value, counter and distribution. -TEST(HidlMetricsAdapterTest, AllMetricTypes) { - drm_metrics::WvCdmMetrics metrics_proto; - - // Value metric - error. - metrics_proto - .mutable_engine_metrics() - ->mutable_crypto_metrics() - ->mutable_crypto_session_security_level() - ->set_error_code(7); - DrmMetricGroup::Metric expected_value_metric_1 = { - "crypto_session_security_level", - {}, - { { "error_code", DrmMetricGroup::ValueType::INT64_TYPE, 7, 0, "" } } - }; - - // Value metric - integer. - metrics_proto - .mutable_engine_metrics() - ->mutable_oemcrypto_initialization_mode() - ->set_int_value(11); - DrmMetricGroup::Metric expected_value_metric_2 = { - "oemcrypto_initialization_mode", - {}, - { { "value", DrmMetricGroup::ValueType::INT64_TYPE, 11, 0, "" } } - }; - - // Value metric - double. - metrics_proto - .mutable_engine_metrics() - ->mutable_cdm_engine_life_span_ms() - ->set_double_value(3.14159); - DrmMetricGroup::Metric expected_value_metric_3 = { - "cdm_engine_life_span_ms", - {}, - { { "value", DrmMetricGroup::ValueType::DOUBLE_TYPE, 0, 3.14159, "" } } - }; - - // Value metric - string. - metrics_proto - .mutable_engine_metrics() - ->mutable_cdm_engine_cdm_version() - ->set_string_value("test"); - DrmMetricGroup::Metric expected_value_metric_4 = { - "cdm_engine_cdm_version", - {}, - { { "value", DrmMetricGroup::ValueType::STRING_TYPE, 0, 0, "test" } } - }; - - // Counter metric - CounterMetric* counter = metrics_proto.mutable_engine_metrics() - ->mutable_crypto_metrics()->add_crypto_session_get_token(); - counter->set_count(13); - counter->mutable_attributes()->set_error_code(17); - DrmMetricGroup::Metric expected_counter_metric_1 = { - "crypto_session_get_token", - { { "error_code", DrmMetricGroup::ValueType::INT64_TYPE, 17, 0, "" } }, - { { "count", DrmMetricGroup::ValueType::INT64_TYPE, 13, 0, "" } } - }; - // Add a second counter. - counter = metrics_proto.mutable_engine_metrics() - ->mutable_crypto_metrics()->add_crypto_session_get_token(); - counter->set_count(19); - counter->mutable_attributes()->set_error_code(23); - DrmMetricGroup::Metric expected_counter_metric_2 = { - "crypto_session_get_token", - { { "error_code", DrmMetricGroup::ValueType::INT64_TYPE, 23, 0, "" } }, - { { "count", DrmMetricGroup::ValueType::INT64_TYPE, 19, 0, "" } } - }; - - // Distribution metric - DistributionMetric* distribution = metrics_proto.mutable_engine_metrics() - ->mutable_crypto_metrics()->add_crypto_session_open_time_us(); - distribution->set_min(1.0); - distribution->set_max(1.2); - distribution->set_mean(1.1); - distribution->set_variance(.01); - distribution->set_operation_count(2); - distribution->mutable_attributes()->set_error_code(0); - DrmMetricGroup::Metric expected_distribution_metric_1 = { - "crypto_session_open_time_us", - { { "error_code", DrmMetricGroup::ValueType::INT64_TYPE, 0, 0, "" } }, - { { "mean", DrmMetricGroup::ValueType::DOUBLE_TYPE, 0, 1.1f, "" }, - { "count", DrmMetricGroup::ValueType::INT64_TYPE, 2, 0, "" }, - { "min", DrmMetricGroup::ValueType::DOUBLE_TYPE, 0, 1.0, "" }, - { "max", DrmMetricGroup::ValueType::DOUBLE_TYPE, 0, 1.2f, "" }, - { "variance", DrmMetricGroup::ValueType::DOUBLE_TYPE, 0, 0.01, "" } } - }; - // Add a second distribution - distribution = metrics_proto.mutable_engine_metrics() - ->mutable_crypto_metrics()->add_crypto_session_open_time_us(); - distribution->set_mean(0.7); - distribution->set_operation_count(1); - distribution->mutable_attributes()->set_error_code(27); - DrmMetricGroup::Metric expected_distribution_metric_2 = { - "crypto_session_open_time_us", - { { "error_code", DrmMetricGroup::ValueType::INT64_TYPE, 27, 0, "" } }, - { { "mean", DrmMetricGroup::ValueType::DOUBLE_TYPE, 0, 0.7f, "" }, - { "count", DrmMetricGroup::ValueType::INT64_TYPE, 1, 0, "" } } - }; - - hidl_vec hidl_metrics; - - HidlMetricsAdapter::ToHidlMetrics(metrics_proto, &hidl_metrics); - ASSERT_EQ(1U, hidl_metrics.size()); - ASSERT_EQ(8U, hidl_metrics[0].metrics.size()) << ToString(hidl_metrics); - - EXPECT_TRUE(HasMetric(expected_value_metric_1, hidl_metrics[0])) - << "Missing value_metric_1. " << ToString(expected_value_metric_1) - << std::endl << "In metrics: " << ToString(hidl_metrics); - EXPECT_TRUE(HasMetric(expected_value_metric_2, hidl_metrics[0])) - << "Missing value_metric_2. " << ToString(expected_value_metric_2) - << std::endl << "In metrics: " << ToString(hidl_metrics); - EXPECT_TRUE(HasMetric(expected_value_metric_3, hidl_metrics[0])) - << "Missing value_metric_3." << ToString(expected_value_metric_3) - << std::endl << "In metrics: " << ToString(hidl_metrics); - EXPECT_TRUE(HasMetric(expected_value_metric_4, hidl_metrics[0])) - << "Missing value_metric_4. " << ToString(expected_value_metric_4) - << std::endl << "In metrics: " << ToString(hidl_metrics); - EXPECT_TRUE(HasMetric(expected_counter_metric_1, hidl_metrics[0])) - << "Missing counter_metric_1. " << ToString(expected_counter_metric_1) - << std::endl << "In metrics: " << ToString(hidl_metrics); - EXPECT_TRUE(HasMetric(expected_counter_metric_2, hidl_metrics[0])) - << "Missing counter_metric_2. " << ToString(expected_counter_metric_2) - << std::endl << "In metrics: " << ToString(hidl_metrics); - EXPECT_TRUE(HasMetric(expected_distribution_metric_1, hidl_metrics[0])) - << "Missing distribution_metric_1. " - << ToString(expected_distribution_metric_1) << std::endl - << "In metrics: " << ToString(hidl_metrics); - EXPECT_TRUE(HasMetric(expected_distribution_metric_2, hidl_metrics[0])) - << "Missing distribution_metric_2. " - << ToString(expected_distribution_metric_2) << std::endl - << "In metrics: " << ToString(hidl_metrics); -} - -// Add a single metric with all attributes to confirm that all attributes -// can be converted. -TEST(HidlMetricsAdapterTest, AddAllAttrbitues) { - // Create a test attribute proto with all attributes set. - drm_metrics::WvCdmMetrics metrics_proto; - CounterMetric* counter = metrics_proto.mutable_engine_metrics() - ->mutable_crypto_metrics()->add_crypto_session_get_token(); - counter->set_count(13); - drm_metrics::Attributes* attributes = counter->mutable_attributes(); - attributes->set_error_code(17); - attributes->set_error_code_bool(true); - attributes->set_cdm_security_level(19); - attributes->set_security_level(23); - attributes->set_length(29); - attributes->set_encryption_algorithm(31); - attributes->set_signing_algorithm(37); - attributes->set_oem_crypto_result(41); - attributes->set_key_status_type(43); - attributes->set_event_type(47); - attributes->set_key_request_type(53); - attributes->set_license_type(59); - - DrmMetricGroup::Metric expected_counter_metric = { - "crypto_session_get_token", - { { "error_code", DrmMetricGroup::ValueType::INT64_TYPE, 17, 0, "" }, - { "error_code_bool", - DrmMetricGroup::ValueType::INT64_TYPE, true, 0, "" }, - { "cdm_security_level", - DrmMetricGroup::ValueType::INT64_TYPE, 19, 0, "" }, - { "security_level", - DrmMetricGroup::ValueType::INT64_TYPE, 23, 0, "" }, - { "length", DrmMetricGroup::ValueType::INT64_TYPE, 29, 0, "" }, - { "encryption_algorithm", - DrmMetricGroup::ValueType::INT64_TYPE, 31, 0, "" }, - { "signing_algorithm", - DrmMetricGroup::ValueType::INT64_TYPE, 37, 0, "" }, - { "oem_crypto_result", - DrmMetricGroup::ValueType::INT64_TYPE, 41, 0, "" }, - { "key_status_type", - DrmMetricGroup::ValueType::INT64_TYPE, 43, 0, "" }, - { "event_type", DrmMetricGroup::ValueType::INT64_TYPE, 47, 0, "" }, - { "key_request_type", - DrmMetricGroup::ValueType::INT64_TYPE, 53, 0, "" }, - { "license_type", - DrmMetricGroup::ValueType::INT64_TYPE, 59, 0, "" } }, - { { "count", DrmMetricGroup::ValueType::INT64_TYPE, 13, 0, "" } } }; - - // Confirm that all of the attributes exist in the hidl data. - hidl_vec hidl_metrics; - HidlMetricsAdapter::ToHidlMetrics(metrics_proto, &hidl_metrics); - EXPECT_TRUE(HasMetric(expected_counter_metric, hidl_metrics[0])) - << "Missing expected_counter_metrc. " - << ToString(expected_counter_metric) << std::endl - << "In metrics: " << ToString(hidl_metrics); -} - -// Add all session and engine metrics to cofirm that all are converted. -// Only check the counts since other tests confirm that metrics are converted -// properly. -TEST(HidlMetricsAdapterTest, EngineAndSessionAllMetrics) { - // Set all CryptoSession metrics. - drm_metrics::WvCdmMetrics::CryptoMetrics crypto_metrics; - crypto_metrics.mutable_crypto_session_security_level()->set_int_value(1); - crypto_metrics.add_crypto_session_delete_all_usage_reports()->set_count(13); - crypto_metrics.add_crypto_session_delete_multiple_usage_information - ()->set_count(13); - crypto_metrics.add_crypto_session_generic_decrypt_time_us()->set_min(1.0f); - crypto_metrics.add_crypto_session_generic_encrypt_time_us()->set_min(1.0f); - crypto_metrics.add_crypto_session_generic_sign_time_us()->set_min(1.0f); - crypto_metrics.add_crypto_session_generic_verify_time_us()->set_min(1.0f); - crypto_metrics.add_crypto_session_get_device_unique_id()->set_count(13); - crypto_metrics.add_crypto_session_get_token()->set_count(13); - crypto_metrics.mutable_crypto_session_life_span()->set_int_value(1); - crypto_metrics.add_crypto_session_load_certificate_private_key_time_us - ()->set_min(1.0f); - crypto_metrics.add_crypto_session_open_time_us()->set_min(1.0f); - crypto_metrics.mutable_crypto_session_system_id()->set_int_value(1); - crypto_metrics.add_crypto_session_update_usage_information_time_us - ()->set_min(1.0f); - crypto_metrics.mutable_crypto_session_usage_information_support - ()->set_int_value(1); - - // Usage Table Metrics - crypto_metrics.mutable_usage_table_header_initial_size()->set_int_value(1); - crypto_metrics.add_usage_table_header_add_entry()->set_count(13); - crypto_metrics.add_usage_table_header_delete_entry()->set_count(13); - crypto_metrics.add_usage_table_header_update_entry_time_us()->set_min(1.0f); - crypto_metrics.add_usage_table_header_load_entry()->set_count(13); - - // OemCrypto metrics. - crypto_metrics.mutable_oemcrypto_api_version()->set_int_value(1); - crypto_metrics.add_oemcrypto_close_session()->set_count(13); - crypto_metrics.add_oemcrypto_copy_buffer_time_us()->set_min(1.0f); - crypto_metrics.mutable_oemcrypto_current_hdcp_capability()->set_int_value(1); - crypto_metrics.add_oemcrypto_deactivate_usage_entry()->set_count(13); - crypto_metrics.add_oemcrypto_decrypt_cenc_time_us()->set_min(1.0f); - crypto_metrics.add_oemcrypto_delete_usage_entry()->set_count(13); - crypto_metrics.add_oemcrypto_delete_usage_table()->set_count(13); - crypto_metrics.add_oemcrypto_derive_keys_from_session_key_time_us - ()->set_min(1.0f); - crypto_metrics.add_oemcrypto_force_delete_usage_entry()->set_count(13); - crypto_metrics.add_oemcrypto_generate_derived_keys_time_us()->set_min(1.0f); - crypto_metrics.add_oemcrypto_generate_nonce()->set_count(13); - crypto_metrics.add_oemcrypto_generate_rsa_signature_time_us()->set_min(1.0f); - crypto_metrics.add_oemcrypto_generate_signature_time_us()->set_min(1.0f); - crypto_metrics.add_oemcrypto_generic_decrypt_time_us()->set_min(1.0f); - crypto_metrics.add_oemcrypto_generic_encrypt_time_us()->set_min(1.0f); - crypto_metrics.add_oemcrypto_generic_sign_time_us()->set_min(1.0f); - crypto_metrics.add_oemcrypto_generic_verify_time_us()->set_min(1.0f); - crypto_metrics.add_oemcrypto_get_device_id()->set_count(13); - crypto_metrics.add_oemcrypto_get_key_data_time_us()->set_min(1.0f); - crypto_metrics.add_oemcrypto_get_oem_public_certificate()->set_count(13); - crypto_metrics.add_oemcrypto_get_random()->set_count(13); - crypto_metrics.add_oemcrypto_initialize_time_us()->set_min(1.0f); - crypto_metrics.mutable_oemcrypto_is_anti_rollback_hw_present - ()->set_int_value(1); - crypto_metrics.mutable_oemcrypto_is_keybox_valid()->set_int_value(1); - crypto_metrics.add_oemcrypto_load_device_drm_key_time_us()->set_min(1.0f); - crypto_metrics.add_oemcrypto_load_entitled_keys_time_us()->set_min(1.0f); - crypto_metrics.add_oemcrypto_load_keys_time_us()->set_min(1.0f); - crypto_metrics.mutable_oemcrypto_max_hdcp_capability()->set_int_value(1); - crypto_metrics.mutable_oemcrypto_max_number_of_sessions()->set_int_value(1); - crypto_metrics.mutable_oemcrypto_number_of_open_sessions()->set_int_value(1); - crypto_metrics.mutable_oemcrypto_provisioning_method()->set_int_value(1); - crypto_metrics.add_oemcrypto_refresh_keys_time_us()->set_min(1.0f); - crypto_metrics.add_oemcrypto_report_usage()->set_count(13); - crypto_metrics.add_oemcrypto_rewrap_device_rsa_key_time_us()->set_min(1.0f); - crypto_metrics.add_oemcrypto_rewrap_device_rsa_key_30_time_us() - ->set_min(1.0f); - crypto_metrics.mutable_oemcrypto_security_patch_level()->set_int_value(1); - crypto_metrics.add_oemcrypto_select_key_time_us()->set_min(1.0f); - crypto_metrics.mutable_oemcrypto_usage_table_support()->set_int_value(1); - crypto_metrics.add_oemcrypto_update_usage_table()->set_count(13); - crypto_metrics.add_oemcrypto_update_usage_entry()->set_count(13); - - drm_metrics::WvCdmMetrics::SessionMetrics session_metrics; - session_metrics.mutable_session_id()->set_string_value("test"); - *(session_metrics.mutable_crypto_metrics()) = crypto_metrics; - session_metrics.mutable_cdm_session_life_span_ms()->set_double_value(1.0f); - session_metrics.add_cdm_session_renew_key_time_us()->set_min(1.0f); - session_metrics.add_cdm_session_restore_offline_session()->set_count(13); - session_metrics.add_cdm_session_restore_usage_session()->set_count(13); - session_metrics.add_cdm_session_license_request_latency_ms()->set_min(1.0); - session_metrics.mutable_oemcrypto_build_info()->set_string_value("test"); - session_metrics.mutable_license_sdk_version()->set_string_value("test sdk"); - session_metrics.mutable_license_service_version()->set_string_value("test service"); - - drm_metrics::WvCdmMetrics::EngineMetrics engine_metrics; - *(engine_metrics.mutable_crypto_metrics()) = crypto_metrics; - // OEMCrypto Initialize Metrics. - engine_metrics.mutable_level3_oemcrypto_initialization_error() - ->set_int_value(1); - engine_metrics.mutable_oemcrypto_initialization_mode()->set_int_value(1); - engine_metrics.mutable_previous_oemcrypto_initialization_failure() - ->set_int_value(1); - engine_metrics.mutable_oemcrypto_l1_api_version()->set_int_value(1); - engine_metrics.mutable_oemcrypto_l1_min_api_version()->set_int_value(1); - // CdmEngine Metrics. - engine_metrics.mutable_app_package_name()->set_int_value(1); - engine_metrics.add_cdm_engine_add_key_time_us()->set_min(1.0f); - engine_metrics.mutable_cdm_engine_cdm_version()->set_int_value(1); - engine_metrics.add_cdm_engine_close_session()->set_count(13); - engine_metrics.mutable_cdm_engine_creation_time_millis()->set_int_value(1); - engine_metrics.add_cdm_engine_decrypt_time_us()->set_min(1.0f); - engine_metrics.add_cdm_engine_find_session_for_key()->set_count(13); - engine_metrics.add_cdm_engine_generate_key_request_time_us()->set_min(1.0f); - engine_metrics.add_cdm_engine_get_provisioning_request_time_us() - ->set_min(1.0f); - engine_metrics.add_cdm_engine_get_secure_stop_ids()->set_count(13); - engine_metrics.add_cdm_engine_get_usage_info_time_us()->set_min(1.0f); - engine_metrics.add_cdm_engine_handle_provisioning_response_time_us() - ->set_min(1.0f); - engine_metrics.mutable_cdm_engine_life_span_ms()->set_int_value(1); - engine_metrics.add_cdm_engine_open_key_set_session()->set_count(13); - engine_metrics.add_cdm_engine_open_session()->set_count(13); - engine_metrics.add_cdm_engine_query_key_status_time_us()->set_min(1.0f); - engine_metrics.add_cdm_engine_release_all_usage_info()->set_count(13); - engine_metrics.add_cdm_engine_release_usage_info()->set_count(13); - engine_metrics.add_cdm_engine_remove_all_usage_info()->set_count(13); - engine_metrics.add_cdm_engine_remove_keys()->set_count(13); - engine_metrics.add_cdm_engine_remove_usage_info()->set_count(13); - engine_metrics.add_cdm_engine_restore_key_time_us()->set_min(1.0f); - engine_metrics.add_cdm_engine_unprovision()->set_count(13); - - drm_metrics::WvCdmMetrics metrics_proto; - *(metrics_proto.add_session_metrics()) = session_metrics; - *(metrics_proto.mutable_engine_metrics()) = engine_metrics; - - hidl_vec hidl_metrics; - HidlMetricsAdapter::ToHidlMetrics(metrics_proto, &hidl_metrics); - ASSERT_EQ(2U, hidl_metrics.size()); - EXPECT_EQ(89U, hidl_metrics[0].metrics.size()) << ToString(hidl_metrics); - EXPECT_EQ(70U, hidl_metrics[1].metrics.size()) << ToString(hidl_metrics); -} - -} // namespace wvcdm diff --git a/libwvdrmengine/oemcrypto/test/GEN_api_lock_file.c b/libwvdrmengine/oemcrypto/test/GEN_api_lock_file.c new file mode 100644 index 00000000..37e577e6 --- /dev/null +++ b/libwvdrmengine/oemcrypto/test/GEN_api_lock_file.c @@ -0,0 +1,306 @@ +// Copyright 2019 Google LLC. All Rights Reserved. This file and proprietary +// source code may only be used and distributed under the Widevine License +// Agreement. +// +// This code is semi-auto-generated, do not edit unless you know what you are +// doing. The script oemcrypto/lock-api-for-release will append to this file. +// +// If this file does not build, then you have modified an OEMCrypto API +// function. Instead, you should rename the old function and give the modified +// function a new oecc number. + +#include "OEMCryptoCENC.h" + +// This initial generation of this file was for v16.4, so older functions will +// not have an accurate version number. + +OEMCryptoResult _oecc84(const uint8_t* sandbox_id, size_t sandbox_id_length); +OEMCryptoResult _oecc01(void); +OEMCryptoResult _oecc02(void); +OEMCryptoResult _oecc09(OEMCrypto_SESSION* session); +OEMCryptoResult _oecc10(OEMCrypto_SESSION session); +OEMCryptoResult _oecc95(OEMCrypto_SESSION session, + const OEMCrypto_SharedMemory* mac_key_context, + size_t mac_key_context_length, + const OEMCrypto_SharedMemory* enc_key_context, + size_t enc_key_context_length); +OEMCryptoResult _oecc21(OEMCrypto_SESSION session, + const uint8_t* derivation_key, + size_t derivation_key_length, + const OEMCrypto_SharedMemory* mac_key_context, + size_t mac_key_context_length, + const OEMCrypto_SharedMemory* enc_key_context, + size_t enc_key_context_length); +OEMCryptoResult _oecc14(OEMCrypto_SESSION session, uint32_t* nonce); +OEMCryptoResult _oecc96(OEMCrypto_SESSION session, uint8_t* message, + size_t message_length, size_t* core_message_size, + uint8_t* signature, size_t* signature_length); +OEMCryptoResult _oecc97(OEMCrypto_SESSION session, uint8_t* message, + size_t message_length, size_t* core_message_size, + uint8_t* signature, size_t* signature_length); +OEMCryptoResult _oecc98(OEMCrypto_SESSION session, uint8_t* message, + size_t message_length, size_t* core_message_size, + uint8_t* signature, size_t* signature_length); +OEMCryptoResult _oecc55(const uint8_t* buffer, size_t buffer_length); +OEMCryptoResult _oecc83( + OEMCrypto_SESSION session, const uint8_t* message, size_t message_length, + const uint8_t* signature, size_t signature_length, + OEMCrypto_Substring enc_mac_keys_iv, OEMCrypto_Substring enc_mac_keys, + size_t key_array_length, const OEMCrypto_KeyObject* key_array, + OEMCrypto_Substring pst, OEMCrypto_Substring srm_restriction_data, + OEMCrypto_LicenseType license_type); +OEMCryptoResult _oecc99(OEMCrypto_SESSION session, const uint8_t* message, + size_t message_length, size_t core_message_length, + const uint8_t* signature, size_t signature_length); +OEMCryptoResult _oecc92( + OEMCrypto_SESSION session, const uint8_t* message, size_t message_length, + size_t key_array_length, + const OEMCrypto_EntitledContentKeyObject_V16* key_array); +OEMCryptoResult _oecc91(OEMCrypto_SESSION session, const uint8_t* message, + size_t message_length, const uint8_t* signature, + size_t signature_length, size_t num_keys, + const OEMCrypto_KeyRefreshObject* key_array); +OEMCryptoResult _oecc101(OEMCrypto_SESSION session, const uint8_t* message, + size_t message_length, size_t core_message_length, + const uint8_t* signature, size_t signature_length); +OEMCryptoResult _oecc41(OEMCrypto_SESSION session, + const uint8_t* content_key_id, + size_t content_key_id_length, + uint8_t* key_control_block, + size_t* key_control_block_length); +OEMCryptoResult _oecc81(OEMCrypto_SESSION session, + const uint8_t* content_key_id, + size_t content_key_id_length, + OEMCryptoCipherMode cipher_mode); +OEMCryptoResult _oecc105( + OEMCrypto_SESSION session, + const OEMCrypto_SampleDescription* samples, // an array of samples. + size_t samples_length, // the number of samples. + const OEMCrypto_CENCEncryptPatternDesc* pattern); +OEMCryptoResult _oecc93(OEMCrypto_SESSION session, + const OEMCrypto_SharedMemory* data_addr, + size_t data_addr_length, + const OEMCrypto_DestBufferDesc* out_buffer_descriptor, + uint8_t subsample_flags); +OEMCryptoResult _oecc24(OEMCrypto_SESSION session, + const OEMCrypto_SharedMemory* in_buffer, + size_t in_buffer_length, const uint8_t* iv, + OEMCrypto_Algorithm algorithm, + OEMCrypto_SharedMemory* out_buffer); +OEMCryptoResult _oecc25(OEMCrypto_SESSION session, + const OEMCrypto_SharedMemory* in_buffer, + size_t in_buffer_length, const uint8_t* iv, + OEMCrypto_Algorithm algorithm, + OEMCrypto_SharedMemory* out_buffer); +OEMCryptoResult _oecc26(OEMCrypto_SESSION session, + const OEMCrypto_SharedMemory* buffer, + size_t buffer_length, OEMCrypto_Algorithm algorithm, + OEMCrypto_SharedMemory* signature, + size_t* signature_length); +OEMCryptoResult _oecc27(OEMCrypto_SESSION session, + const OEMCrypto_SharedMemory* buffer, + size_t buffer_length, OEMCrypto_Algorithm algorithm, + const OEMCrypto_SharedMemory* signature, + size_t signature_length); +OEMCryptoResult _oecc08(const uint8_t* keybox_or_cert, + size_t keybox_or_cert_length, + uint8_t* wrapped_keybox_or_cert, + size_t* wrapped_keybox_or_cert_length, + const uint8_t* transport_key, + size_t transport_key_length); +OEMCryptoResult _oecc03(const uint8_t* keybox_or_cert, + size_t keybox_or_cert_length); +OEMCrypto_ProvisioningMethod _oecc49(void); +OEMCryptoResult _oecc05(void); +OEMCryptoResult _oecc07(uint8_t* device_id, size_t* device_id_length); +OEMCryptoResult _oecc04(uint8_t* key_data, size_t* key_data_length); +OEMCryptoResult _oecc78(const uint8_t* buffer, size_t buffer_length); +OEMCryptoResult _oecc103(OEMCrypto_SESSION session); +OEMCryptoResult _oecc104(uint8_t* public_cert, size_t* public_cert_length); +OEMCryptoResult _oecc06(uint8_t* random_data, size_t random_data_length); +uint32_t _oecc22(void); +uint32_t _oecc108(void); +uint8_t _oecc46(void); +OEMCryptoResult _oecc44(OEMCrypto_HDCP_Capability* current, + OEMCrypto_HDCP_Capability* maximum); +bool _oecc29(void); +size_t _oecc94(void); +bool _oecc39(void); +OEMCryptoResult _oecc38(size_t* count); +OEMCryptoResult _oecc37(size_t* max); +uint32_t _oecc52(void); +bool _oecc53(void); +OEMCryptoResult _oecc54(uint16_t* version); +uint32_t _oecc71(void); +uint32_t _oecc85(void); +OEMCryptoResult _oecc102(OEMCrypto_SESSION session, const uint8_t* message, + size_t message_length, size_t core_message_length, + const uint8_t* signature, size_t signature_length, + uint8_t* wrapped_private_key, + size_t* wrapped_private_key_length); +OEMCryptoResult _oecc107(OEMCrypto_SESSION session, + OEMCrypto_PrivateKeyType key_type, + const uint8_t* wrapped_private_key, + size_t wrapped_private_key_length); +OEMCryptoResult _oecc45(void); +OEMCryptoResult _oecc36(OEMCrypto_SESSION session, const uint8_t* message, + size_t message_length, uint8_t* signature, + size_t* signature_length, + RSA_Padding_Scheme padding_scheme); +OEMCryptoResult _oecc61(uint8_t* header_buffer, size_t* header_buffer_length); +OEMCryptoResult _oecc62(const uint8_t* buffer, size_t buffer_length); +OEMCryptoResult _oecc63(OEMCrypto_SESSION session, + uint32_t* usage_entry_number); +OEMCryptoResult _oecc64(OEMCrypto_SESSION session, uint32_t usage_entry_number, + const uint8_t* buffer, size_t buffer_length); +OEMCryptoResult _oecc65(OEMCrypto_SESSION session, + OEMCrypto_SharedMemory* header_buffer, + size_t* header_buffer_length, + OEMCrypto_SharedMemory* entry_buffer, + size_t* entry_buffer_length); +OEMCryptoResult _oecc66(OEMCrypto_SESSION session, const uint8_t* pst, + size_t pst_length); +OEMCryptoResult _oecc32(OEMCrypto_SESSION session, const uint8_t* pst, + size_t pst_length, uint8_t* buffer, + size_t* buffer_length); +OEMCryptoResult _oecc68(OEMCrypto_SESSION session, uint32_t new_index); +OEMCryptoResult _oecc67(uint32_t new_entry_count, uint8_t* header_buffer, + size_t* header_buffer_length); +OEMCryptoResult _oecc57(void); +uint32_t _oecc86(void); +OEMCryptoResult _oecc88(OEMCrypto_SESSION session, uint32_t frame_number, + const uint8_t* hash, size_t hash_length); +OEMCryptoResult _oecc89(OEMCrypto_SESSION session, + uint32_t* failed_frame_number); +OEMCryptoResult _oecc109(OEMCrypto_SESSION session, size_t buffer_size, + OEMCrypto_DestBufferDesc* output_descriptor, + int* secure_fd); +OEMCryptoResult _oecc110(OEMCrypto_SESSION session, + OEMCrypto_DestBufferDesc* output_descriptor, + int secure_fd); +OEMCryptoResult _oecc115(uint32_t* ree_major, uint32_t* ree_minor, + uint32_t* tee_major, uint32_t* tee_minor); +OEMCryptoResult _oecc113(OEMCrypto_SESSION session, uint8_t* buffer, + size_t* buffer_length, uint32_t use_test_key); +OEMCryptoResult _oecc114(OEMCrypto_SESSION session, const uint8_t* buffer, + size_t buffer_length, uint32_t use_test_key); +OEMCryptoResult _oecc13(OEMCrypto_SESSION session, const uint8_t* message, + size_t message_length, uint8_t* signature, + size_t* signature_length); +OEMCryptoResult _oecc51(OEMCrypto_SESSION session, + const uint32_t* unaligned_nonce, + const uint8_t* encrypted_message_key, + size_t encrypted_message_key_length, + const uint8_t* enc_rsa_key, size_t enc_rsa_key_length, + const uint8_t* enc_rsa_key_iv, uint8_t* wrapped_rsa_key, + size_t* wrapped_rsa_key_length); +OEMCryptoResult _oecc18(OEMCrypto_SESSION session, const uint8_t* message, + size_t message_length, const uint8_t* signature, + size_t signature_length, + const uint32_t* unaligned_nonce, + const uint8_t* enc_rsa_key, size_t enc_rsa_key_length, + const uint8_t* enc_rsa_key_iv, uint8_t* wrapped_rsa_key, + size_t* wrapped_rsa_key_length); +OEMCryptoResult _oecc30(void); +OEMCryptoResult _oecc33(OEMCrypto_SESSION session, const uint8_t* pst, + size_t pst_length, const uint8_t* message, + size_t message_length, const uint8_t* signature, + size_t signature_length); +OEMCryptoResult _oecc43(const uint8_t* pst, size_t pst_length); +OEMCryptoResult _oecc69(OEMCrypto_SESSION session, const uint8_t* pst, + size_t pst_length); +OEMCryptoResult _oecc34(void); +OEMCryptoResult _oecc70(uint64_t time_since_license_received, + uint64_t time_since_first_decrypt, + uint64_t time_since_last_decrypt, + OEMCrypto_Usage_Entry_Status status, + uint8_t* server_mac_key, uint8_t* client_mac_key, + const uint8_t* pst, size_t pst_length); +OEMCryptoResult _oecc12(OEMCrypto_SESSION session, + const uint8_t* mac_key_context, + uint32_t mac_key_context_length, + const uint8_t* enc_key_context, + uint32_t enc_key_context_length); +OEMCryptoResult _oecc48(OEMCrypto_SESSION session, const uint8_t* data_addr, + size_t data_addr_length, bool is_encrypted, + const uint8_t* iv, + size_t block_offset, // used for CTR "cenc" mode only. + OEMCrypto_DestBufferDesc* out_buffer, + const OEMCrypto_CENCEncryptPatternDesc_V15* pattern, + uint8_t subsample_flags); +OEMCryptoResult _oecc50(OEMCrypto_SESSION session, uint8_t* public_cert, + size_t* public_cert_length); +OEMCryptoResult _oecc19(OEMCrypto_SESSION session, + const uint8_t* wrapped_rsa_key, + size_t wrapped_rsa_key_length); + +// OEMCrypto_Idle defined in v17.1 +OEMCryptoResult _oecc123(OEMCrypto_IdleState state, uint32_t os_specific_code); + +// OEMCrypto_Wake defined in v17.1 +OEMCryptoResult _oecc124(void); + +// OEMCrypto_CreateEntitledKeySession defined in v17.1 +OEMCryptoResult _oecc111(OEMCrypto_SESSION oec_session, + OEMCrypto_SESSION* key_session); + +// OEMCrypto_RemoveEntitledKeySession defined in v17.1 +OEMCryptoResult _oecc112(OEMCrypto_SESSION key_session); + +// OEMCrypto_LoadEntitledContentKeys defined in v17.1 +OEMCryptoResult _oecc121(OEMCrypto_SESSION session, const uint8_t* message, + size_t message_length, size_t key_array_length, + const OEMCrypto_EntitledContentKeyObject* key_array); + +// OEMCrypto_BuildInformation defined in v17.1 +OEMCryptoResult _oecc125(char* buffer, size_t* buffer_length); + +// OEMCrypto_SecurityLevel defined in v17.1 +OEMCrypto_Security_Level _oecc126(void); + +// OEMCrypto_GetDTCP2Capability defined in v17.1 +OEMCryptoResult _oecc128(OEMCrypto_DTCP2_Capability* capability); + +// OEMCrypto_ProductionReady defined in v17.1 +OEMCryptoResult _oecc122(void); + +// OEMCrypto_GetWatermarkingSupport defined in v17.1 +OEMCrypto_WatermarkingSupport _oecc129(void); + +// OEMCrypto_ReuseUsageEntry defined in v17.1 +OEMCryptoResult _oecc127(OEMCrypto_SESSION session, + uint32_t usage_entry_number); + +// OEMCrypto_GetBootCertificateChain defined in v17.1 +OEMCryptoResult _oecc116(uint8_t* bcc, size_t* bcc_length, + uint8_t* additional_signature, + size_t* additional_signature_length); + +// OEMCrypto_GenerateCertificateKeyPair defined in v17.1 +OEMCryptoResult _oecc117(OEMCrypto_SESSION session, uint8_t* public_key, + size_t* public_key_length, + uint8_t* public_key_signature, + size_t* public_key_signature_length, + uint8_t* wrapped_private_key, + size_t* wrapped_private_key_length, + OEMCrypto_PrivateKeyType* key_type); + +// OEMCrypto_InstallOemPrivateKey defined in v17.1 +OEMCryptoResult _oecc118(OEMCrypto_SESSION session, + OEMCrypto_PrivateKeyType key_type, + const uint8_t* wrapped_private_key, + size_t wrapped_private_key_length); + +// OEMCrypto_ReassociateEntitledKeySession defined in v17.1 +OEMCryptoResult _oecc119(OEMCrypto_SESSION key_session, + OEMCrypto_SESSION oec_session); + +// OEMCrypto_LoadCasECMKeys defined in v17.1 +OEMCryptoResult _oecc120(OEMCrypto_SESSION session, const uint8_t* message, + size_t message_length, + const OEMCrypto_EntitledContentKeyObject* even_key, + const OEMCrypto_EntitledContentKeyObject* odd_key); + +// OEMCrypto_GetOEMKeyToken defined in v17.2 +OEMCryptoResult _oecc130(OEMCrypto_SESSION key_session, uint8_t* key_token, + size_t* key_token_length); diff --git a/libwvdrmengine/oemcrypto/test/common.mk b/libwvdrmengine/oemcrypto/test/common.mk index 6f8569a7..d20a3e21 100644 --- a/libwvdrmengine/oemcrypto/test/common.mk +++ b/libwvdrmengine/oemcrypto/test/common.mk @@ -1,14 +1,5 @@ LOCAL_PATH:= $(call my-dir) -WV_UNITTESTS_BUILD_TARGET?= -ifeq ($(WV_UNITTESTS_BUILD_TARGET), hidl) -HIDL_EXTENSION := _hidl -LIB_BINDER := libhidlbase -else -HIDL_EXTENSION := -LIB_BINDER := libbinder_ndk -endif - ifeq ($(filter mips mips64, $(TARGET_ARCH)),) # Tests need to be compatible with devices that do not support gnu hash-style LOCAL_LDFLAGS+=-Wl,--hash-style=both @@ -18,6 +9,7 @@ endif LOCAL_CFLAGS += -DTEST_OEMCRYPTO_V15 LOCAL_SRC_FILES:= \ + GEN_api_lock_file.c \ oec_device_features.cpp \ oec_decrypt_fallback_chain.cpp \ oec_key_deriver.cpp \ @@ -50,7 +42,7 @@ LOCAL_STATIC_LIBRARIES := \ libgtest_main \ libwvlevel3 \ libcdm_protos \ - libcdm_utils$(HIDL_EXTENSION) \ + libcdm_utils \ libwv_kdo \ libwv_odk \ @@ -58,7 +50,7 @@ LOCAL_SHARED_LIBRARIES := \ libbase \ libcrypto \ libdl \ - $(LIB_BINDER) \ + libbinder_ndk \ liblog \ libmedia_omx \ libprotobuf-cpp-lite \ diff --git a/libwvdrmengine/prebuilts_hidl/arm/libwvhidl@1.3.so b/libwvdrmengine/prebuilts_hidl/arm/libwvhidl@1.3.so deleted file mode 100644 index d0aa3ef8..00000000 Binary files a/libwvdrmengine/prebuilts_hidl/arm/libwvhidl@1.3.so and /dev/null differ diff --git a/libwvdrmengine/prebuilts_hidl/arm64/libwvhidl@1.3.so b/libwvdrmengine/prebuilts_hidl/arm64/libwvhidl@1.3.so deleted file mode 100644 index 18a96426..00000000 Binary files a/libwvdrmengine/prebuilts_hidl/arm64/libwvhidl@1.3.so and /dev/null differ diff --git a/libwvdrmengine/prebuilts_hidl/x86/libwvhidl@1.3.so b/libwvdrmengine/prebuilts_hidl/x86/libwvhidl@1.3.so deleted file mode 100644 index 3374099c..00000000 Binary files a/libwvdrmengine/prebuilts_hidl/x86/libwvhidl@1.3.so and /dev/null differ diff --git a/libwvdrmengine/prebuilts_hidl/x86_64/libwvhidl@1.3.so b/libwvdrmengine/prebuilts_hidl/x86_64/libwvhidl@1.3.so deleted file mode 100644 index 6b8709ef..00000000 Binary files a/libwvdrmengine/prebuilts_hidl/x86_64/libwvhidl@1.3.so and /dev/null differ diff --git a/libwvdrmengine/run_all_unit_tests.sh b/libwvdrmengine/run_all_unit_tests.sh index 1cd4fe85..b1a22eff 100755 --- a/libwvdrmengine/run_all_unit_tests.sh +++ b/libwvdrmengine/run_all_unit_tests.sh @@ -128,9 +128,3 @@ adb_shell_run timer_unittest adb_shell_run usage_table_header_unittest adb_shell_run value_metric_unittest adb_shell_run wv_cdm_metrics_test - -# Run the Treble test on Treble devices -if adb $SERIAL_NUM shell ls /vendor/lib/libwvhidl.so &> /dev/null || - adb $SERIAL_NUM shell ls /vendor/lib64/libwvhidl.so &> /dev/null; then - adb_shell_run libwvdrmengine_hal_test -fi diff --git a/libwvdrmengine/src_hidl/WVCreatePluginFactories.cpp b/libwvdrmengine/src_hidl/WVCreatePluginFactories.cpp deleted file mode 100644 index 6682a2a5..00000000 --- a/libwvdrmengine/src_hidl/WVCreatePluginFactories.cpp +++ /dev/null @@ -1,33 +0,0 @@ -// -// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary -// source code may only be used and distributed under the Widevine License -// Agreement. -// - -#include "HidlWVCreatePluginFactories.h" - -#include "HidlWVDrmFactory.h" -#include "WVCryptoFactory.h" - -namespace wvdrm { -namespace hardware { -namespace drm { -namespace V1_4 { -namespace widevine { - -extern "C" { - -::drm::V1_4::IDrmFactory* createDrmFactory() { - return new WVDrmFactory(); -} - -::drm::V1_4::ICryptoFactory* createCryptoFactory() { - return new WVCryptoFactory(); -} - -} // extern "C" -} // namespace widevine -} // namespace V1_4 -} // namespace drm -} // namespace hardware -} // namespace wvdrm diff --git a/libwvdrmengine/src_hidl/WVCryptoFactory.cpp b/libwvdrmengine/src_hidl/WVCryptoFactory.cpp deleted file mode 100644 index 0de24b66..00000000 --- a/libwvdrmengine/src_hidl/WVCryptoFactory.cpp +++ /dev/null @@ -1,60 +0,0 @@ -// -// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary -// source code may only be used and distributed under the Widevine License -// Agreement. -// - -//#define LOG_NDEBUG 0 -#define LOG_TAG "WVCdm" -#include -#include - -#include "WVCryptoFactory.h" - -#include "HidlTypes.h" -#include "WVCDMSingleton.h" -#include "WVCryptoPlugin.h" -#include "WVUUID.h" - -namespace wvdrm { -namespace hardware { -namespace drm { -namespace V1_4 { -namespace widevine { - -using wvdrm::hardware::drm::V1_4::widevine::WVCryptoPlugin; - -Return WVCryptoFactory::isCryptoSchemeSupported( - const hidl_array& uuid) { - return isWidevineUUID(uuid.data()); -} - -Return WVCryptoFactory::createPlugin( - const hidl_array& uuid, - const hidl_vec& initData, - createPlugin_cb _hidl_cb) { - - const auto& self = android::hardware::IPCThreadState::self(); - const char* sid = self->getCallingSid(); - sid = sid ? (strstr(sid, "mediadrmserver") ? sid : "app") : "nullptr"; - ALOGI("[%s] calling %s", sid, __PRETTY_FUNCTION__); - - sp plugin; - if (!isCryptoSchemeSupported(uuid.data())) { - ALOGE("Widevine Drm HAL: failed to create crypto plugin, " \ - "invalid crypto scheme"); - _hidl_cb(Status::ERROR_DRM_CANNOT_HANDLE, plugin); - return Void(); - } - - plugin = new WVCryptoPlugin(initData.data(), initData.size(), getCDM()); - android::hardware::setRequestingSid(plugin, true); - _hidl_cb(Status::OK, plugin); - return Void(); -} - -} // namespace widevine -} // namespace V1_4 -} // namespace drm -} // namespace hardware -} // namespace wvdrm diff --git a/libwvdrmengine/src_hidl/WVDrmFactory.cpp b/libwvdrmengine/src_hidl/WVDrmFactory.cpp deleted file mode 100644 index bcabae33..00000000 --- a/libwvdrmengine/src_hidl/WVDrmFactory.cpp +++ /dev/null @@ -1,277 +0,0 @@ -// -// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary -// source code may only be used and distributed under the Widevine License -// Agreement. -// - -//#define LOG_NDEBUG 0 -#define LOG_TAG "WVCdm" -#include "HidlWVDrmFactory.h" - -#include -#include - -#include "HidlTypes.h" -#include "WVCDMSingleton.h" -#include "WVDrmPlugin.h" -#include "WVUUID.h" -#include "android-base/properties.h" -#include "cutils/properties.h" -#include "wv_cdm_constants.h" -#include "wv_content_decryption_module.h" -#include "wv_metrics.h" - -namespace wvdrm { -namespace hardware { -namespace drm { -namespace V1_4 { -namespace widevine { - -using wvdrm::hardware::drm::V1_4::widevine::WVDrmPlugin; - -WVGenericCryptoInterface WVDrmFactory::sOemCryptoInterface; - -Return WVDrmFactory::isCryptoSchemeSupported( - const hidl_array& uuid) { - return isWidevineUUID(uuid.data()); -} - -Return WVDrmFactory::isCryptoSchemeSupported_1_2( - const hidl_array& uuid, const hidl_string& initDataType, - SecurityLevel level) { - if (!isWidevineUUID(uuid.data()) || !isContentTypeSupported(initDataType)) { - return false; - } - - if (wvcdm::WvContentDecryptionModule::IsSecurityLevelSupported( - wvcdm::kSecurityLevelL1)) { - if (wvcdm::WvContentDecryptionModule::IsAudio(initDataType)) { - if (level < SecurityLevel::HW_SECURE_ALL) { - return true; - } - } else { - return true; - } - } - return level <= SecurityLevel::SW_SECURE_DECODE; -} - -Return WVDrmFactory::isContentTypeSupported( - const hidl_string& initDataType) { - return wvcdm::WvContentDecryptionModule::IsSupported(initDataType.c_str()); -} - -Return WVDrmFactory::createPlugin(const hidl_array& uuid, - const hidl_string& appPackageName, - createPlugin_cb _hidl_cb) { - const auto& self = android::hardware::IPCThreadState::self(); - const char* sid = self->getCallingSid(); - sid = sid ? (strstr(sid, "mediadrmserver") ? sid : "app") : "nullptr"; - ALOGI("[%s][%s] calling %s", sid, appPackageName.c_str(), - __PRETTY_FUNCTION__); - - sp plugin; - if (!isCryptoSchemeSupported(uuid.data())) { - ALOGE( - "Widevine Drm HAL: failed to create drm plugin, " - "invalid crypto scheme"); - _hidl_cb(Status::ERROR_DRM_CANNOT_HANDLE, plugin); - return Void(); - } - - if (!isBlankAppPackageNameAllowed() && appPackageName.empty()) { - ALOGE( - "Widevine Drm HAL: Failed to create DRM Plugin, blank App Package " - "Name disallowed."); - _hidl_cb(Status::ERROR_DRM_CANNOT_HANDLE, plugin); - return Void(); - } - - plugin = new WVDrmPlugin(getCDM(), appPackageName.c_str(), - &sOemCryptoInterface, areSpoidsEnabled()); - android::hardware::setRequestingSid(plugin, true); - _hidl_cb(Status::OK, plugin); - return Void(); -} - -bool WVDrmFactory::areSpoidsEnabled() { - return firstApiLevel() >= 26; // Android O -} - -bool WVDrmFactory::isBlankAppPackageNameAllowed() { - return firstApiLevel() < 29; // Android Q -} - -int32_t WVDrmFactory::firstApiLevel() { - // Check what this device's first API level was. - int32_t firstApiLevel = - android::base::GetIntProperty("ro.product.first_api_level", 0); - if (firstApiLevel == 0) { - // First API Level is 0 on factory ROMs, but we can assume the current SDK - // version is the first if it's a factory ROM. - firstApiLevel = - android::base::GetIntProperty("ro.build.version.sdk", 0); - } - return firstApiLevel; -} - -Return WVDrmFactory::getSupportedCryptoSchemes( - getSupportedCryptoSchemes_cb _hidl_cb) { - std::vector> schemes; - for (const auto& scheme : wvdrm::getSupportedCryptoSchemes()) { - schemes.push_back(scheme); - } - _hidl_cb(schemes); - return Void(); -} - -std::string WVDrmFactory::stringToHex(const std::string& input) { - // If input contains punctuations that are not part of - // a valid server url, we need to convert it to hex. - const std::string validChars = "/-._~%:"; - bool toHex = false; - for (const char ch : input) { - if (ispunct(ch) != 0 && validChars.find(ch) == std::string::npos) { - toHex = true; - break; - } - } - if (!toHex) return input; - - static constexpr char hex[] = "0123456789ABCDEF"; - - std::string output; - output.reserve(input.length() * 2); - for (const unsigned char ch : input) { - output.push_back(hex[ch >> 4]); - output.push_back(hex[ch & 15]); - } - return output; -} - -void WVDrmFactory::printCdmMetrics(FILE* out) { - fprintf(out, "\n**** Widevine Cdm Metrics ****\n"); - - // Verify that the version of the library that we linked against is - // compatible with the version of the headers we compiled against. - GOOGLE_PROTOBUF_VERIFY_VERSION; - - sp cdm(getCDM()); - - std::vector metrics; - bool full_list_returned = true; - wvcdm::CdmResponseType result = - cdm->GetMetrics(&metrics, &full_list_returned); - if (metrics.empty()) { - fprintf(out, - "Metrics not available, please retry while streaming a video\n"); - } else if (!full_list_returned) { - fprintf(out, - "Not all metrics are returned due to some GetMetric error, " - "please check logcat for possible GetMetric errors.\n"); - } - if (result == wvcdm::NO_ERROR) { - for (auto& metric : metrics) { - fprintf(out, "*** Metric size=%zu\n", metric.DebugString().size()); - std::string formatted; - wv_metrics::FormatWvCdmMetrics(metric, formatted); - fprintf(out, "%s\n", formatted.c_str()); - } - } else { - fprintf(out, "GetMetrics failed, error=%d\n", result); - } -} - -void WVDrmFactory::printCdmProperties(FILE* out) { - fprintf(out, "\n**** Widevine CDM properties ****\n"); - - sp cdm(getCDM()); - - const bool isLevel1 = - cdm->IsSecurityLevelSupported(wvcdm::CdmSecurityLevel::kSecurityLevelL1); - fprintf(out, "default security level: [%s]\n", isLevel1 ? "L1" : "L3"); - - const std::map cdmProperties = { - {"version- Widevine CDM:", wvcdm::QUERY_KEY_WVCDM_VERSION}, - {"version- current SRM:", wvcdm::QUERY_KEY_CURRENT_SRM_VERSION}, - {"version(major)- OEM Crypto API:", - wvcdm::QUERY_KEY_OEMCRYPTO_API_VERSION}, - {"version(minor)- OEM Crypto API:", - wvcdm::QUERY_KEY_OEMCRYPTO_API_MINOR_VERSION}, - {"id- device:", wvcdm::QUERY_KEY_DEVICE_ID}, - {"id- system:", wvcdm::QUERY_KEY_SYSTEM_ID}, - {"renewal server url:", wvcdm::QUERY_KEY_RENEWAL_SERVER_URL}, - {"hdcp level- max:", wvcdm::QUERY_KEY_MAX_HDCP_LEVEL}, - {"hdcp level- current:", wvcdm::QUERY_KEY_CURRENT_HDCP_LEVEL}, - {"num sessions- max supported:", wvcdm::QUERY_KEY_MAX_NUMBER_OF_SESSIONS}, - {"num sessions- opened:", wvcdm::QUERY_KEY_NUMBER_OF_OPEN_SESSIONS}, - {"resource rating tier:", wvcdm::QUERY_KEY_RESOURCE_RATING_TIER}, - {"support decrypt hash:", wvcdm::QUERY_KEY_DECRYPT_HASH_SUPPORT}, - {"support SRM update:", wvcdm::QUERY_KEY_SRM_UPDATE_SUPPORT}, - {"support usage table:", wvcdm::QUERY_KEY_USAGE_SUPPORT}, - {"max usage table entries:", wvcdm::QUERY_KEY_MAX_USAGE_TABLE_ENTRIES}, - {"OEM Crypto build info:", wvcdm::QUERY_KEY_OEMCRYPTO_BUILD_INFORMATION}, - {"provisioning id:", wvcdm::QUERY_KEY_PROVISIONING_ID}, - {"provisioning model:", wvcdm::QUERY_KEY_PROVISIONING_MODEL}, - {"analog capabilities:", wvcdm::QUERY_KEY_ANALOG_OUTPUT_CAPABILITIES}, - {"can disable analog output:", - wvcdm::QUERY_KEY_CAN_DISABLE_ANALOG_OUTPUT}, - {"watermarking support:", wvcdm::QUERY_KEY_WATERMARKING_SUPPORT}, - {"production ready:", wvcdm::QUERY_KEY_PRODUCTION_READY}, - }; - - std::string value; - for (const auto& property : cdmProperties) { - cdm->QueryStatus(wvcdm::RequestedSecurityLevel::kLevelDefault, - property.second, &value); - std::string outString = stringToHex(value); - fprintf(out, "%s [%s]\n", property.first.c_str(), outString.c_str()); - value.clear(); - } -} - -Return WVDrmFactory::debug(const hidl_handle& fd, - const hidl_vec& args) { - if (fd.getNativeHandle() == nullptr || fd->numFds < 1) { - ALOGE("%s: missing fd for writing", __FUNCTION__); - return Void(); - } - - FILE* out = fdopen(dup(fd->data[0]), "w"); - fprintf(out, "\nDefault to print all info if no arguments are used.\n"); - fprintf(out, "Optional arguments are:\n"); - fprintf(out, "\tm:cdm metrics | p:cdm properties\n"); - fprintf(out, - "Usage: adb shell lshal debug " - "android.hardware.drm@1.3::IDrmFactory/widevine [m|p]\n"); - - bool dumpCdmProperties, dumpCdmMetrics = false; - if (args.size() == 0) { - // default to print all info if no arguments are given - dumpCdmProperties = dumpCdmMetrics = true; - } else { - for (auto& str : args) { - fprintf(out, "args: %s\n", str.c_str()); - std::string option = str.c_str(); - if (option.find('m') != std::string::npos || - option.find('M') != std::string::npos) { - dumpCdmMetrics = true; - } - if (option.find('p') != std::string::npos || - option.find('P') != std::string::npos) { - dumpCdmProperties = true; - } - } - } - if (dumpCdmMetrics) printCdmMetrics(out); - if (dumpCdmProperties) printCdmProperties(out); - fclose(out); - - return Void(); -} - -} // namespace widevine -} // namespace V1_4 -} // namespace drm -} // namespace hardware -} // namespace wvdrm diff --git a/libwvdrmengine/src_hidl/android.hardware.drm@1.2-service-lazy.widevine.rc b/libwvdrmengine/src_hidl/android.hardware.drm@1.2-service-lazy.widevine.rc deleted file mode 100644 index 11f28490..00000000 --- a/libwvdrmengine/src_hidl/android.hardware.drm@1.2-service-lazy.widevine.rc +++ /dev/null @@ -1,26 +0,0 @@ -on property:init.svc.mediadrm=running - mkdir /data/vendor/mediadrm 0770 media mediadrm - start vendor.move_data_sh - -service vendor.move_data_sh /system/bin/move_widevine_data.sh - class late_start - user media - group media mediadrm system - disabled - oneshot - -service vendor.drm-widevine-hal-1-2 /vendor/bin/hw/android.hardware.drm@1.2-service-lazy.widevine - interface android.hardware.drm@1.0::ICryptoFactory widevine - interface android.hardware.drm@1.0::IDrmFactory widevine - interface android.hardware.drm@1.1::ICryptoFactory widevine - interface android.hardware.drm@1.1::IDrmFactory widevine - interface android.hardware.drm@1.2::ICryptoFactory widevine - interface android.hardware.drm@1.2::IDrmFactory widevine - interface android.hidl.base@1.0::IBase widevine - oneshot - disabled - class hal - user media - group media mediadrm drmrpc system - ioprio rt 4 - task_profiles ProcessCapacityHigh diff --git a/libwvdrmengine/src_hidl/android.hardware.drm@1.2-service.widevine.rc b/libwvdrmengine/src_hidl/android.hardware.drm@1.2-service.widevine.rc deleted file mode 100644 index 5016a1b8..00000000 --- a/libwvdrmengine/src_hidl/android.hardware.drm@1.2-service.widevine.rc +++ /dev/null @@ -1,25 +0,0 @@ -on property:init.svc.mediadrm=running - mkdir /data/vendor/mediadrm 0770 media mediadrm - start vendor.move_data_sh - -service vendor.move_data_sh /system/bin/move_widevine_data.sh - class late_start - user media - group media mediadrm system - disabled - oneshot - -service vendor.drm-widevine-hal-1-2 /vendor/bin/hw/android.hardware.drm@1.2-service.widevine - interface android.hardware.drm@1.0::ICryptoFactory widevine - interface android.hardware.drm@1.0::IDrmFactory widevine - interface android.hardware.drm@1.1::ICryptoFactory widevine - interface android.hardware.drm@1.1::IDrmFactory widevine - interface android.hardware.drm@1.2::ICryptoFactory widevine - interface android.hardware.drm@1.2::IDrmFactory widevine - interface android.hidl.base@1.0::IBase widevine - disabled - class hal - user media - group media mediadrm drmrpc system - ioprio rt 4 - task_profiles ProcessCapacityHigh diff --git a/libwvdrmengine/src_hidl/android.hardware.drm@1.3-service-lazy.widevine.rc b/libwvdrmengine/src_hidl/android.hardware.drm@1.3-service-lazy.widevine.rc deleted file mode 100644 index 285dd5e8..00000000 --- a/libwvdrmengine/src_hidl/android.hardware.drm@1.3-service-lazy.widevine.rc +++ /dev/null @@ -1,29 +0,0 @@ -on property:init.svc.mediadrm=running - mkdir /data/vendor/mediadrm 0770 media mediadrm - start vendor.move_data_sh - -service vendor.move_data_sh /system/bin/move_widevine_data.sh - class late_start - user media - group media mediadrm system - disabled - oneshot - -service vendor.drm-widevine-hal-1-3 /vendor/bin/hw/android.hardware.drm@1.3-service-lazy.widevine - interface android.hardware.drm@1.0::ICryptoFactory widevine - interface android.hardware.drm@1.0::IDrmFactory widevine - interface android.hardware.drm@1.1::ICryptoFactory widevine - interface android.hardware.drm@1.1::IDrmFactory widevine - interface android.hardware.drm@1.2::ICryptoFactory widevine - interface android.hardware.drm@1.2::IDrmFactory widevine - interface android.hardware.drm@1.3::ICryptoFactory widevine - interface android.hardware.drm@1.3::IDrmFactory widevine - interface android.hidl.base@1.0::IBase widevine - oneshot - disabled - class hal - user media - group media mediadrm drmrpc system - ioprio rt 4 - task_profiles ProcessCapacityHigh - capabilities SYS_NICE diff --git a/libwvdrmengine/src_hidl/android.hardware.drm@1.3-service.widevine.rc b/libwvdrmengine/src_hidl/android.hardware.drm@1.3-service.widevine.rc deleted file mode 100644 index cb0cb184..00000000 --- a/libwvdrmengine/src_hidl/android.hardware.drm@1.3-service.widevine.rc +++ /dev/null @@ -1,27 +0,0 @@ -on property:init.svc.mediadrm=running - mkdir /data/vendor/mediadrm 0770 media mediadrm - start vendor.move_data_sh - -service vendor.move_data_sh /system/bin/move_widevine_data.sh - class late_start - user media - group media mediadrm system - disabled - oneshot - -service vendor.drm-widevine-hal-1-3 /vendor/bin/hw/android.hardware.drm@1.3-service.widevine - interface android.hardware.drm@1.0::ICryptoFactory widevine - interface android.hardware.drm@1.0::IDrmFactory widevine - interface android.hardware.drm@1.1::ICryptoFactory widevine - interface android.hardware.drm@1.1::IDrmFactory widevine - interface android.hardware.drm@1.2::ICryptoFactory widevine - interface android.hardware.drm@1.2::IDrmFactory widevine - interface android.hardware.drm@1.3::ICryptoFactory widevine - interface android.hardware.drm@1.3::IDrmFactory widevine - interface android.hidl.base@1.0::IBase widevine - class hal - user media - group media mediadrm drmrpc system - ioprio rt 4 - task_profiles ProcessCapacityHigh - capabilities SYS_NICE diff --git a/libwvdrmengine/src_hidl/android.hardware.drm@1.4-service-lazy.widevine.rc b/libwvdrmengine/src_hidl/android.hardware.drm@1.4-service-lazy.widevine.rc deleted file mode 100644 index c1901af7..00000000 --- a/libwvdrmengine/src_hidl/android.hardware.drm@1.4-service-lazy.widevine.rc +++ /dev/null @@ -1,30 +0,0 @@ -on property:init.svc.mediadrm=running - mkdir /data/vendor/mediadrm 0770 media mediadrm - start vendor.move_data_sh - -service vendor.move_data_sh /system/bin/move_widevine_data.sh - class late_start - user media - group media mediadrm system - disabled - oneshot - -service vendor.drm-widevine-hal-1-4 /vendor/bin/hw/android.hardware.drm@1.4-service-lazy.widevine - interface android.hardware.drm@1.0::ICryptoFactory widevine - interface android.hardware.drm@1.0::IDrmFactory widevine - interface android.hardware.drm@1.1::ICryptoFactory widevine - interface android.hardware.drm@1.1::IDrmFactory widevine - interface android.hardware.drm@1.2::ICryptoFactory widevine - interface android.hardware.drm@1.2::IDrmFactory widevine - interface android.hardware.drm@1.3::ICryptoFactory widevine - interface android.hardware.drm@1.3::IDrmFactory widevine - interface android.hardware.drm@1.4::ICryptoFactory widevine - interface android.hardware.drm@1.4::IDrmFactory widevine - interface android.hidl.base@1.0::IBase widevine - oneshot - disabled - class hal - user media - group media mediadrm drmrpc system - ioprio rt 4 - task_profiles ProcessCapacityHigh diff --git a/libwvdrmengine/src_hidl/android.hardware.drm@1.4-service.widevine.rc b/libwvdrmengine/src_hidl/android.hardware.drm@1.4-service.widevine.rc deleted file mode 100644 index 73805d4d..00000000 --- a/libwvdrmengine/src_hidl/android.hardware.drm@1.4-service.widevine.rc +++ /dev/null @@ -1,28 +0,0 @@ -on property:init.svc.mediadrm=running - mkdir /data/vendor/mediadrm 0770 media mediadrm - start vendor.move_data_sh - -service vendor.move_data_sh /system/bin/move_widevine_data.sh - class late_start - user media - group media mediadrm system - disabled - oneshot - -service vendor.drm-widevine-hal-1-4 /vendor/bin/hw/android.hardware.drm@1.4-service.widevine - interface android.hardware.drm@1.0::ICryptoFactory widevine - interface android.hardware.drm@1.0::IDrmFactory widevine - interface android.hardware.drm@1.1::ICryptoFactory widevine - interface android.hardware.drm@1.1::IDrmFactory widevine - interface android.hardware.drm@1.2::ICryptoFactory widevine - interface android.hardware.drm@1.2::IDrmFactory widevine - interface android.hardware.drm@1.3::ICryptoFactory widevine - interface android.hardware.drm@1.3::IDrmFactory widevine - interface android.hardware.drm@1.4::ICryptoFactory widevine - interface android.hardware.drm@1.4::IDrmFactory widevine - interface android.hidl.base@1.0::IBase widevine - class hal - user media - group media mediadrm drmrpc system - ioprio rt 4 - task_profiles ProcessCapacityHigh diff --git a/libwvdrmengine/src_hidl/service.cpp b/libwvdrmengine/src_hidl/service.cpp deleted file mode 100644 index 860d35f7..00000000 --- a/libwvdrmengine/src_hidl/service.cpp +++ /dev/null @@ -1,44 +0,0 @@ -/* - * Copyright 2017 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#define LOG_TAG "WidevineHidlService" - -#include -#include -#include - -#include "HidlWVDrmFactory.h" -#include "WVCryptoFactory.h" - -using wvdrm::hardware::drm::V1_4::widevine::WVCryptoFactory; -using wvdrm::hardware::drm::V1_4::widevine::WVDrmFactory; - -int main(int /* argc */, char** /* argv */) { - sp drmFactory = new WVDrmFactory; - sp cryptoFactory = new WVCryptoFactory; - - configureRpcThreadpool(8, true /* callerWillJoin */); - - android::hardware::setRequestingSid(drmFactory, true); - android::hardware::setRequestingSid(cryptoFactory, true); - - // Setup hwbinder service - CHECK_EQ(drmFactory->registerAsService("widevine"), android::NO_ERROR) - << "Failed to register Widevine Factory HAL"; - CHECK_EQ(cryptoFactory->registerAsService("widevine"), android::NO_ERROR) - << "Failed to register Widevine Crypto HAL"; - - joinRpcThreadpool(); -} diff --git a/libwvdrmengine/src_hidl/service@1.3.cpp b/libwvdrmengine/src_hidl/service@1.3.cpp deleted file mode 100644 index 9dd164b1..00000000 --- a/libwvdrmengine/src_hidl/service@1.3.cpp +++ /dev/null @@ -1,108 +0,0 @@ -/* - * Copyright 2021 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#include "hidl/HidlSupport.h" -#define LOG_TAG "WidevineHidlService" - -#include -#include -#include -#include -#include - -#include "HidlWVTypes.h" - -namespace drm = ::android::hardware::drm; - -namespace wvdrm { -namespace hardware { -namespace drm { -namespace V1_3 { -namespace widevine { - -using ::android::hardware::Return; -using ::android::hardware::hidl_array; -using ::android::hardware::hidl_string; -using ::android::hardware::hidl_vec; -using ::drm::V1_1::SecurityLevel; - -struct WVCryptoFactory : public ::drm::V1_3::ICryptoFactory { - public: - WVCryptoFactory() {} - virtual ~WVCryptoFactory() {} - - Return isCryptoSchemeSupported(const hidl_array& uuid) - override; - - Return createPlugin( - const hidl_array& uuid, - const hidl_vec& initData, - createPlugin_cb _hidl_cb) override; - - private: - WVDRM_DISALLOW_COPY_AND_ASSIGN(WVCryptoFactory); -}; - -struct WVDrmFactory : public ::drm::V1_3::IDrmFactory { - WVDrmFactory() {} - virtual ~WVDrmFactory() {} - - Return isCryptoSchemeSupported( - const hidl_array& uuid) override; - - Return isCryptoSchemeSupported_1_2(const hidl_array& uuid, - const hidl_string& mimeType, - SecurityLevel level) override; - - Return isContentTypeSupported(const hidl_string& mimeType) override; - - Return createPlugin(const hidl_array& uuid, - const hidl_string& appPackageName, - createPlugin_cb _hidl_cb) override; - - Return getSupportedCryptoSchemes( - getSupportedCryptoSchemes_cb _hidl_cb) override; - - private: - WVDRM_DISALLOW_COPY_AND_ASSIGN(WVDrmFactory); -}; - -} // namespace widevine -} // namespace V1_3 -} // namespace drm -} // namespace hardware -} // namespace wvdrm - -int main(int /* argc */, char** /* argv */) { - using ::android::sp; - using ::wvdrm::hardware::drm::V1_3::widevine::WVCryptoFactory; - using ::wvdrm::hardware::drm::V1_3::widevine::WVDrmFactory; - - sp<::drm::V1_3::IDrmFactory> drmFactory = new WVDrmFactory; - sp<::drm::V1_3::ICryptoFactory> cryptoFactory = new WVCryptoFactory; - - android::hardware::configureRpcThreadpool(8, true /* callerWillJoin */); - - android::hardware::setRequestingSid(drmFactory, true); - android::hardware::setRequestingSid(cryptoFactory, true); - - // Setup hwbinder service - CHECK_EQ(drmFactory->registerAsService("widevine"), android::NO_ERROR) - << "Failed to register Widevine Factory HAL"; - CHECK_EQ(cryptoFactory->registerAsService("widevine"), android::NO_ERROR) - << "Failed to register Widevine Crypto HAL"; - - android::hardware::joinRpcThreadpool(); -} diff --git a/libwvdrmengine/src_hidl/serviceLazy.cpp b/libwvdrmengine/src_hidl/serviceLazy.cpp deleted file mode 100644 index ad961976..00000000 --- a/libwvdrmengine/src_hidl/serviceLazy.cpp +++ /dev/null @@ -1,47 +0,0 @@ -/* - * Copyright 2019 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#define LOG_TAG "WidevineHidlService" - -#include -#include -#include -#include - -#include "HidlWVDrmFactory.h" -#include "WVCryptoFactory.h" - -using wvdrm::hardware::drm::V1_4::widevine::WVCryptoFactory; -using wvdrm::hardware::drm::V1_4::widevine::WVDrmFactory; -using android::hardware::LazyServiceRegistrar; - -int main(int /* argc */, char** /* argv */) { - sp drmFactory = new WVDrmFactory; - sp cryptoFactory = new WVCryptoFactory; - - configureRpcThreadpool(8, true /* callerWillJoin */); - - android::hardware::setRequestingSid(drmFactory, true); - android::hardware::setRequestingSid(cryptoFactory, true); - - // Setup hwbinder service - auto serviceRegistrar = LazyServiceRegistrar::getInstance(); - CHECK_EQ(serviceRegistrar.registerService(drmFactory, "widevine"), android::NO_ERROR) - << "Failed to register Widevine Factory HAL"; - CHECK_EQ(serviceRegistrar.registerService(cryptoFactory, "widevine"), android::NO_ERROR) - << "Failed to register Widevine Crypto HAL"; - - joinRpcThreadpool(); -} diff --git a/libwvdrmengine/src_hidl/wv_metrics.cpp b/libwvdrmengine/src_hidl/wv_metrics.cpp deleted file mode 100644 index 62f281d8..00000000 --- a/libwvdrmengine/src_hidl/wv_metrics.cpp +++ /dev/null @@ -1,451 +0,0 @@ -// Copyright 2020 Google LLC. All Rights Reserved. This file and proprietary -// source code may only be used and distributed under the Widevine License -// Agreement. -// -// Format widevine protobuf metrics - -#include "wv_metrics.h" - -#include -#include -#include -#include -#include - -#include "OEMCryptoCENC.h" -#include "wv_cdm_types.h" - -using namespace drm_metrics; -using std::string; -using std::to_string; - -namespace { -const string kIndentPerLine = " "; - -string FormatCdmErrorTranslation(int error_code) { - std::stringstream os; - os << static_cast(error_code); - return " " + os.str(); -} - -string FormatOEMCryptoResult(int oemcrypto_result) { - std::stringstream os; - os << static_cast(oemcrypto_result); - return " " + os.str(); -} - -string FormatOEMCryptoInitializeMode(const ValueMetric& vm) { - std::map translations = { - {0, "USING_IN_APP"}, - {1, "FORCING_L3"}, - {2, "USING_L3_NO_L1_LIBRARY_PATH"}, - {3, "USING_L3_L1_OPEN_FAILED"}, - {4, "USING_L3_L1_LOAD_FAILED"}, - {5, "USING_L3_COULD_NOT_INITIALIZE_L1"}, - {6, "USING_L3_WRONG_L1_VERSION"}, - {7, "USING_L1_WITH_KEYBOX"}, - {8, "USING_L1_WITH_CERTIFICATE"}, - {9, "USING_L1_CERTIFICATE_MIX"}, - {10, "USING_L3_BAD_KEYBOX"}, - {11, "USING_L3_COULD_NOT_OPEN_FACTORY_KEYBOX"}, - {12, "USING_L3_COULD_NOT_INSTALL_KEYBOX"}, - {13, "USING_L1_INSTALLED_KEYBOX"}, - {14, "USING_L3_INVALID_L1"}, - {15, "USING_L1_WITH_PROVISIONING_3_0"}, - {16, "L3_INITIALIZATION_GENERAL_FAILED"}, - {17, "L3_INITIALIZATION_RNG_FAILED"}, - {18, "L3_INITIALIZATION_SAVE_DEVICE_KEYS_FAILED"}, - {19, "L3_INITIALIZATION_READ_DEVICE_KEYS_FAILED"}, - {20, "L3_INITIALIZATION_VERIFY_DEVIE_KEYS_FAILED"}}; - return translations[vm.int_value()]; -} - -string FormatOEMCryptoHdcpCapability(const ValueMetric& vm) { - std::map translations = { - {0, "HDCP_NONE"}, {1, "HDCP_V1"}, {2, "HDCP_V2"}, - {3, "HDCP_V2_1"}, {4, "HDCP_V2_2"}, {5, "HDCP_V2_3"}, - {0xff, "NO_DIGITAL_OUTPUT"}}; - return translations[vm.int_value()]; -} - -string FormatOEMCryptoProvisioningMethod(const ValueMetric& vm) { - std::map translations = {{0, "PROVISIONING_ERROR"}, - {1, "DRM_CERTIFICATE"}, - {2, "KEYBOX"}, - {3, "OEM_CERTIFICATE"}}; - return translations[vm.int_value()]; -} - -string FormatAttributes(const Attributes& attributes) { - string result; - if (attributes.has_error_code()) { - result.append("error_code:"); - result.append(to_string(attributes.error_code())); - result.append(FormatCdmErrorTranslation(attributes.error_code())); - } - if (attributes.has_error_code_bool()) { - if (result.size()) result.append(","); - result.append("success:"); - result.append(attributes.error_code_bool() ? "true" : "false"); - } - if (attributes.has_cdm_security_level()) { - if (result.size()) result.append(","); - result.append("cdm_security_level:"); - result.append(to_string(attributes.cdm_security_level())); - } - if (attributes.has_security_level()) { - if (result.size()) result.append(","); - result.append("security_level:"); - result.append(to_string(attributes.security_level())); - } - if (attributes.has_length()) { - if (result.size()) result.append(","); - result.append("length:"); - result.append(to_string(attributes.length())); - } - if (attributes.has_encryption_algorithm()) { - if (result.size()) result.append(","); - result.append("encryption_algorithm:"); - result.append(to_string(attributes.encryption_algorithm())); - } - if (attributes.has_signing_algorithm()) { - if (result.size()) result.append(","); - result.append("signing_algorithm:"); - result.append(to_string(attributes.signing_algorithm())); - } - if (attributes.has_oem_crypto_result()) { - if (result.size()) result.append(","); - result.append("oemcrypto_result:"); - result.append(to_string(attributes.oem_crypto_result())); - result.append(FormatOEMCryptoResult(attributes.oem_crypto_result())); - } - if (attributes.has_key_status_type()) { - if (result.size()) result.append(","); - result.append("key_status_type:"); - result.append(to_string(attributes.key_status_type())); - } - if (attributes.has_event_type()) { - if (result.size()) result.append(","); - result.append("event_type:"); - result.append(to_string(attributes.event_type())); - } - if (attributes.has_key_request_type()) { - if (result.size()) result.append(","); - result.append("key_request_type:"); - result.append(to_string(attributes.key_request_type())); - } - if (attributes.has_license_type()) { - if (result.size()) result.append(","); - result.append("license_type:"); - result.append(to_string(attributes.license_type())); - } - if (result.size()) { - return string(" {") + result + "}"; - } else { - return ""; - } -} - -string FormatCounterMetric(const CounterMetric& cm) { - string result; - if (cm.has_count()) { - result = string("count=") + to_string(cm.count()); - if (cm.has_attributes()) { - result.append(FormatAttributes(cm.attributes())); - } - } - return result; -} - -string FormatDistributionMetric(const DistributionMetric& dm) { - string result; - if (dm.has_min()) { - std::ostringstream buffer; - buffer << dm.min(); - result = string("min=") + buffer.str(); - } - if (dm.has_max()) { - std::ostringstream buffer; - buffer << dm.max(); - if (result.size()) result.append(" "); - result += string("max=") + buffer.str(); - } - if (dm.has_mean()) { - std::ostringstream buffer; - buffer << dm.mean(); - if (result.size()) result.append(" "); - result += string("mean=") + buffer.str(); - } - if (dm.has_variance()) { - std::ostringstream buffer; - buffer << dm.variance(); - if (result.size()) result.append(" "); - result += string("variance=") + buffer.str(); - } - if (dm.has_operation_count()) { - if (result.size()) result.append(" "); - result += string("count=") + to_string(dm.operation_count()); - } - if (dm.has_attributes()) { - result.append(FormatAttributes(dm.attributes())); - } - return result; -} - -string FormatValueMetric(const ValueMetric& vm) { - string result; - if (vm.has_error_code()) { - result.append("error(" + to_string(vm.error_code())); - result.append(FormatCdmErrorTranslation(vm.error_code())); - result.append(")"); - } - if (vm.has_int_value()) { - result.append(to_string(vm.int_value())); - } - if (vm.has_double_value()) { - std::ostringstream buffer; - buffer << vm.double_value(); - result.append(buffer.str()); - } - if (vm.has_string_value()) { - result.append("\""); - result.append(vm.string_value()); - result.append("\""); - } - return result; -} - -#define FORMAT_REPEATED_DISTRIBUTION(NAME, INDENT) \ - if (metrics.NAME##_size() == 1) { \ - result.append(INDENT + #NAME + ": "); \ - result.append(FormatDistributionMetric(metrics.NAME(0)) + "\n"); \ - } else { \ - for (int i = 0; i < metrics.NAME##_size(); i++) { \ - result.append(INDENT + #NAME "[" + to_string(i) + "]: "); \ - result.append(FormatDistributionMetric(metrics.NAME(i)) + "\n"); \ - } \ - } - -#define FORMAT_REPEATED_COUNTER(NAME, INDENT) \ - if (metrics.NAME##_size() == 1) { \ - result.append(INDENT + #NAME ": "); \ - result.append(FormatCounterMetric(metrics.NAME(0)) + "\n"); \ - } else { \ - for (int i = 0; i < metrics.NAME##_size(); i++) { \ - result.append(INDENT + #NAME "[" + to_string(i) + "]: "); \ - result.append(FormatCounterMetric(metrics.NAME(i)) + "\n"); \ - } \ - } - -#define FORMAT_OPTIONAL_VALUE(NAME, INDENT) \ - if (metrics.has_##NAME()) { \ - result.append(INDENT + #NAME ": " + FormatValueMetric(metrics.NAME()) + \ - "\n"); \ - } - -#define FORMAT_OPTIONAL_INITIALIZATION_MODE(NAME, INDENT) \ - if (metrics.has_##NAME()) { \ - result.append(INDENT + #NAME ": "); \ - result.append(FormatOEMCryptoInitializeMode(metrics.NAME()) + "\n"); \ - } - -#define FORMAT_OPTIONAL_HDCP_CAPABILITY(NAME, INDENT) \ - if (metrics.has_##NAME()) { \ - result.append(INDENT + #NAME ": "); \ - result.append(FormatOEMCryptoHdcpCapability(metrics.NAME()) + "\n"); \ - } - -#define FORMAT_OPTIONAL_PROVISIONING_METHOD(NAME, INDENT) \ - if (metrics.has_##NAME()) { \ - result.append(INDENT + #NAME ": "); \ - result.append(FormatOEMCryptoProvisioningMethod(metrics.NAME()) + "\n"); \ - } - -#define FORMAT_OPTIONAL_CRYPTO_METRICS(NAME, INDENT) \ - if (metrics.has_##NAME()) { \ - FormatCryptoMetrics(metrics.NAME(), INDENT + kIndentPerLine, result); \ - } - -void FormatCryptoMetrics(const WvCdmMetrics_CryptoMetrics metrics, - const string& indent, string& result) { - // Crypto Session Metrics. - FORMAT_OPTIONAL_VALUE(crypto_session_security_level, indent); - FORMAT_REPEATED_COUNTER(crypto_session_delete_all_usage_reports, indent); - FORMAT_REPEATED_COUNTER(crypto_session_delete_multiple_usage_information, - indent); - FORMAT_REPEATED_DISTRIBUTION(crypto_session_generic_decrypt_time_us, indent); - FORMAT_REPEATED_DISTRIBUTION(crypto_session_generic_encrypt_time_us, indent); - FORMAT_REPEATED_DISTRIBUTION(crypto_session_generic_sign_time_us, indent); - FORMAT_REPEATED_DISTRIBUTION(crypto_session_generic_verify_time_us, indent); - FORMAT_REPEATED_COUNTER(crypto_session_get_device_unique_id, indent); - FORMAT_REPEATED_COUNTER(crypto_session_get_token, indent); - FORMAT_OPTIONAL_VALUE(crypto_session_life_span, indent); - FORMAT_REPEATED_DISTRIBUTION( - crypto_session_load_certificate_private_key_time_us, indent); - FORMAT_REPEATED_DISTRIBUTION(crypto_session_open_time_us, indent); - FORMAT_OPTIONAL_VALUE(crypto_session_system_id, indent); - FORMAT_REPEATED_DISTRIBUTION(crypto_session_update_usage_information_time_us, - indent); - FORMAT_OPTIONAL_VALUE(crypto_session_usage_information_support, indent); - - // Usage Table Metrics - FORMAT_OPTIONAL_VALUE(usage_table_header_initial_size, indent); - FORMAT_REPEATED_COUNTER(usage_table_header_add_entry, indent); - FORMAT_REPEATED_COUNTER(usage_table_header_delete_entry, indent); - FORMAT_REPEATED_DISTRIBUTION(usage_table_header_update_entry_time_us, indent); - FORMAT_REPEATED_COUNTER(usage_table_header_load_entry, indent); - - // Usage Table LRU Metrics - FORMAT_OPTIONAL_VALUE(usage_table_header_lru_usage_info_count, indent); - FORMAT_OPTIONAL_VALUE(usage_table_header_lru_offline_license_count, indent); - FORMAT_OPTIONAL_VALUE(usage_table_header_lru_evicted_entry_staleness_s, - indent); - - // |usage_table_header_lru_evicted_entry_type| refers to the enumeration - // CdmUsageEntryStorageType in wv_cdm_types.h. - FORMAT_OPTIONAL_VALUE(usage_table_header_lru_evicted_entry_type, indent); - - // OemCrypto metrics. - FORMAT_OPTIONAL_VALUE(oemcrypto_api_version, indent); - FORMAT_REPEATED_COUNTER(oemcrypto_close_session, indent); - FORMAT_REPEATED_DISTRIBUTION(oemcrypto_copy_buffer_time_us, indent); - FORMAT_OPTIONAL_HDCP_CAPABILITY(oemcrypto_current_hdcp_capability, indent); - FORMAT_REPEATED_COUNTER(oemcrypto_deactivate_usage_entry, indent); - FORMAT_REPEATED_DISTRIBUTION(oemcrypto_decrypt_cenc_time_us, indent); - FORMAT_REPEATED_COUNTER(oemcrypto_delete_usage_entry, indent); - FORMAT_REPEATED_COUNTER(oemcrypto_delete_usage_table, indent); - FORMAT_REPEATED_DISTRIBUTION(oemcrypto_derive_keys_from_session_key_time_us, - indent); - FORMAT_REPEATED_COUNTER(oemcrypto_force_delete_usage_entry, indent); - FORMAT_REPEATED_DISTRIBUTION(oemcrypto_generate_derived_keys_time_us, indent); - FORMAT_REPEATED_COUNTER(oemcrypto_generate_nonce, indent); - FORMAT_REPEATED_DISTRIBUTION(oemcrypto_generate_rsa_signature_time_us, - indent); - FORMAT_REPEATED_DISTRIBUTION(oemcrypto_generate_signature_time_us, indent); - FORMAT_REPEATED_DISTRIBUTION(oemcrypto_generic_decrypt_time_us, indent); - FORMAT_REPEATED_DISTRIBUTION(oemcrypto_generic_encrypt_time_us, indent); - FORMAT_REPEATED_DISTRIBUTION(oemcrypto_generic_sign_time_us, indent); - FORMAT_REPEATED_DISTRIBUTION(oemcrypto_generic_verify_time_us, indent); - FORMAT_REPEATED_COUNTER(oemcrypto_get_device_id, indent); - FORMAT_REPEATED_DISTRIBUTION(oemcrypto_get_key_data_time_us, indent); - FORMAT_REPEATED_COUNTER(oemcrypto_get_oem_public_certificate, indent); - FORMAT_REPEATED_COUNTER(oemcrypto_get_random, indent); - FORMAT_REPEATED_DISTRIBUTION(oemcrypto_initialize_time_us, indent); - FORMAT_OPTIONAL_VALUE(oemcrypto_is_anti_rollback_hw_present, indent); - FORMAT_OPTIONAL_VALUE(oemcrypto_is_keybox_valid, indent); - FORMAT_REPEATED_DISTRIBUTION(oemcrypto_load_device_drm_key_time_us, indent); - FORMAT_REPEATED_DISTRIBUTION(oemcrypto_load_entitled_keys_time_us, indent); - FORMAT_REPEATED_DISTRIBUTION(oemcrypto_load_keys_time_us, indent); - FORMAT_OPTIONAL_HDCP_CAPABILITY(oemcrypto_max_hdcp_capability, indent); - FORMAT_OPTIONAL_VALUE(oemcrypto_max_number_of_sessions, indent); - FORMAT_OPTIONAL_VALUE(oemcrypto_number_of_open_sessions, indent); - FORMAT_OPTIONAL_PROVISIONING_METHOD(oemcrypto_provisioning_method, indent); - FORMAT_REPEATED_DISTRIBUTION(oemcrypto_refresh_keys_time_us, indent); - FORMAT_REPEATED_COUNTER(oemcrypto_report_usage, indent); - FORMAT_REPEATED_DISTRIBUTION(oemcrypto_rewrap_device_rsa_key_time_us, indent); - FORMAT_REPEATED_DISTRIBUTION(oemcrypto_rewrap_device_rsa_key_30_time_us, - indent); - FORMAT_OPTIONAL_VALUE(oemcrypto_security_patch_level, indent); - FORMAT_REPEATED_DISTRIBUTION(oemcrypto_select_key_time_us, indent); - FORMAT_OPTIONAL_VALUE(oemcrypto_usage_table_support, indent); - FORMAT_REPEATED_COUNTER(oemcrypto_update_usage_table, indent); - FORMAT_REPEATED_COUNTER(oemcrypto_update_usage_entry, indent); - FORMAT_REPEATED_COUNTER(oemcrypto_create_usage_table_header, indent); - FORMAT_REPEATED_COUNTER(oemcrypto_load_usage_table_header, indent); - FORMAT_REPEATED_COUNTER(oemcrypto_shrink_usage_table_header, indent); - FORMAT_REPEATED_COUNTER(oemcrypto_create_new_usage_entry, indent); - FORMAT_REPEATED_COUNTER(oemcrypto_load_usage_entry, indent); - FORMAT_REPEATED_COUNTER(oemcrypto_move_entry, indent); - FORMAT_REPEATED_COUNTER(oemcrypto_create_old_usage_entry, indent); - FORMAT_REPEATED_COUNTER(oemcrypto_copy_old_usage_entry, indent); - FORMAT_OPTIONAL_VALUE(oemcrypto_set_sandbox, indent); - FORMAT_REPEATED_COUNTER(oemcrypto_set_decrypt_hash, indent); - FORMAT_OPTIONAL_VALUE(oemcrypto_resource_rating_tier, indent); - - // Oemcrypto V16 metrics below - FORMAT_REPEATED_DISTRIBUTION(oemcrypto_prep_and_sign_license_request_time_us, - indent); - FORMAT_REPEATED_DISTRIBUTION(oemcrypto_prep_and_sign_renewal_request_time_us, - indent); - FORMAT_REPEATED_DISTRIBUTION( - oemcrypto_prep_and_sign_provisioning_request_time_us, indent); - FORMAT_REPEATED_DISTRIBUTION(oemcrypto_load_license_time_us, indent); - FORMAT_REPEATED_DISTRIBUTION(oemcrypto_load_renewal_time_us, indent); - FORMAT_REPEATED_DISTRIBUTION(oemcrypto_load_provisioning_time_us, indent); - FORMAT_OPTIONAL_VALUE(oemcrypto_minor_api_version, indent); - FORMAT_OPTIONAL_VALUE(oemcrypto_maximum_usage_table_header_size, indent); - - // OEMCrypto V17 metrics below. - FORMAT_OPTIONAL_VALUE(oemcrypto_watermarking_support, indent); -} - -void FormatSessionMetrics(const WvCdmMetrics_SessionMetrics& metrics, - const string& indent, string& result) { - FORMAT_OPTIONAL_VALUE(session_id, indent); - FORMAT_OPTIONAL_CRYPTO_METRICS(crypto_metrics, indent); - FORMAT_OPTIONAL_VALUE(cdm_session_life_span_ms, indent); - FORMAT_REPEATED_DISTRIBUTION(cdm_session_renew_key_time_us, indent); - FORMAT_REPEATED_COUNTER(cdm_session_restore_offline_session, indent); - FORMAT_REPEATED_COUNTER(cdm_session_restore_usage_session, indent); - FORMAT_REPEATED_DISTRIBUTION(cdm_session_license_request_latency_ms, indent); - FORMAT_OPTIONAL_VALUE(oemcrypto_build_info, indent); - FORMAT_OPTIONAL_VALUE(license_sdk_version, indent); - FORMAT_OPTIONAL_VALUE(license_service_version, indent); -} - -void FormatEngineMetrics(const WvCdmMetrics_EngineMetrics& metrics, - const string& indent, string& result) { - FORMAT_OPTIONAL_CRYPTO_METRICS(crypto_metrics, indent); - - // OEMCrypto Initialize Metrics. - FORMAT_OPTIONAL_INITIALIZATION_MODE(oemcrypto_initialization_mode, indent); - FORMAT_OPTIONAL_VALUE(oemcrypto_l1_api_version, indent); - FORMAT_OPTIONAL_VALUE(oemcrypto_l1_min_api_version, indent); - FORMAT_OPTIONAL_VALUE(level3_oemcrypto_initialization_error, indent); - FORMAT_OPTIONAL_VALUE(previous_oemcrypto_initialization_failure, indent); - - // CdmEngine Metrics. - FORMAT_OPTIONAL_VALUE(app_package_name, indent); - FORMAT_REPEATED_DISTRIBUTION(cdm_engine_add_key_time_us, indent); - FORMAT_OPTIONAL_VALUE(cdm_engine_cdm_version, indent); - FORMAT_REPEATED_COUNTER(cdm_engine_close_session, indent); - FORMAT_OPTIONAL_VALUE(cdm_engine_creation_time_millis, indent); - FORMAT_REPEATED_DISTRIBUTION(cdm_engine_decrypt_time_us, indent); - FORMAT_REPEATED_COUNTER(cdm_engine_find_session_for_key, indent); - FORMAT_REPEATED_DISTRIBUTION(cdm_engine_generate_key_request_time_us, indent); - FORMAT_REPEATED_DISTRIBUTION(cdm_engine_get_provisioning_request_time_us, - indent); - FORMAT_REPEATED_COUNTER(cdm_engine_get_secure_stop_ids, indent); - FORMAT_REPEATED_DISTRIBUTION(cdm_engine_get_usage_info_time_us, indent); - FORMAT_REPEATED_DISTRIBUTION(cdm_engine_handle_provisioning_response_time_us, - indent); - FORMAT_OPTIONAL_VALUE(cdm_engine_life_span_ms, indent); - FORMAT_REPEATED_COUNTER(cdm_engine_open_key_set_session, indent); - FORMAT_REPEATED_COUNTER(cdm_engine_open_session, indent); - FORMAT_REPEATED_DISTRIBUTION(cdm_engine_query_key_status_time_us, indent); - FORMAT_REPEATED_COUNTER(cdm_engine_release_all_usage_info, indent); - FORMAT_REPEATED_COUNTER(cdm_engine_release_usage_info, indent); - FORMAT_REPEATED_COUNTER(cdm_engine_remove_all_usage_info, indent); - FORMAT_REPEATED_COUNTER(cdm_engine_remove_keys, indent); - FORMAT_REPEATED_COUNTER(cdm_engine_remove_usage_info, indent); - FORMAT_REPEATED_DISTRIBUTION(cdm_engine_restore_key_time_us, indent); - FORMAT_REPEATED_COUNTER(cdm_engine_unprovision, indent); -} -} // anonymous namespace - -namespace wv_metrics { -void FormatWvCdmMetrics(const WvCdmMetrics& metrics, string& result) { - string indent = kIndentPerLine; - string next_indent = indent + kIndentPerLine; - - result.append("engine_metrics\n"); - if (metrics.has_engine_metrics()) { - FormatEngineMetrics(metrics.engine_metrics(), indent, result); - } - result.append("session_metrics\n"); - for (int i = 0; i < metrics.session_metrics_size(); i++) { - result.append(indent + "session[" + to_string(i) + "]\n"); - FormatSessionMetrics(metrics.session_metrics(i), next_indent, result); - } -} -} // namespace wv_metrics diff --git a/libwvdrmengine/test/unit/Android.mk b/libwvdrmengine/test/unit/Android.mk index f0554ed7..cf834d49 100644 --- a/libwvdrmengine/test/unit/Android.mk +++ b/libwvdrmengine/test/unit/Android.mk @@ -5,46 +5,6 @@ LOCAL_PATH:= $(call my-dir) # include $(CLEAR_VARS) -WV_UNITTESTS_BUILD_TARGET?= -ifeq ($(WV_UNITTESTS_BUILD_TARGET), hidl) -LOCAL_SRC_FILES := \ - hidl/WVCreatePluginFactories_test.cpp \ - hidl/WVCryptoFactory_test.cpp \ - hidl/WVDrmFactory_test.cpp \ - -LOCAL_C_INCLUDES := \ - frameworks/av/include \ - frameworks/native/include \ - vendor/widevine/libwvdrmengine/include_hidl \ - vendor/widevine/libwvdrmengine/include \ - vendor/widevine/libwvdrmengine/mediadrm/include_hidl \ - vendor/widevine/libwvdrmengine/oemcrypto/include \ - -LOCAL_STATIC_LIBRARIES := \ - libgtest \ - libgtest_main \ - -LOCAL_SHARED_LIBRARIES := \ - android.hardware.drm@1.0 \ - android.hardware.drm@1.1 \ - android.hardware.drm@1.2 \ - android.hardware.drm@1.3 \ - android.hardware.drm@1.4 \ - libbase \ - libcrypto \ - libdl \ - libhidlbase \ - libhidlmemory \ - liblog \ - libutils \ - libwvhidl \ - -LOCAL_HEADER_LIBRARIES := \ - libstagefright_foundation_headers \ - -# build unit tests for Aidl -else - LOCAL_SRC_FILES := \ WVCreatePluginFactories_hal_test.cpp \ WVCryptoFactory_hal_test.cpp \ @@ -74,9 +34,6 @@ LOCAL_SHARED_LIBRARIES := \ LOCAL_HEADER_LIBRARIES := \ libstagefright_foundation_headers \ -# endif $(WV_UNITTESTS_BUILD_TARGET) -endif - LOCAL_MODULE := libwvdrmengine_hal_test LOCAL_LICENSE_KINDS := legacy_by_exception_only diff --git a/libwvdrmengine/test/unit/WVCreatePluginFactories_test.cpp b/libwvdrmengine/test/unit/WVCreatePluginFactories_test.cpp deleted file mode 100644 index 7f928d82..00000000 --- a/libwvdrmengine/test/unit/WVCreatePluginFactories_test.cpp +++ /dev/null @@ -1,38 +0,0 @@ -// -// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary -// source code may only be used and distributed under the Widevine License -// Agreement. -// - -#include "gtest/gtest.h" -#include "WVCreatePluginFactories.h" - -namespace wvdrm { -namespace hardware { -namespace drm { -namespace V1_4 { -namespace widevine { - -using ::android::sp; - -using namespace android; - -TEST(CreatePluginFactoriesTest, CreatesDrmFactory) { - sp factory(createDrmFactory()); - - EXPECT_NE((IDrmFactory*)NULL, factory.get()) << - "createDrmFactory() returned null"; -} - -TEST(CreatePluginFactoriesTest, CreatesCryptoFactory) { - sp factory(createCryptoFactory()); - - EXPECT_NE((ICryptoFactory*)NULL, factory.get()) << - "createCryptoFactory() returned null"; -} - -} // namespace widevine -} // namespace V1_4 -} // namespace drm -} // namespace hardware -} // namespace wvdrm diff --git a/libwvdrmengine/test/unit/WVCryptoFactory_test.cpp b/libwvdrmengine/test/unit/WVCryptoFactory_test.cpp deleted file mode 100644 index a7782b1e..00000000 --- a/libwvdrmengine/test/unit/WVCryptoFactory_test.cpp +++ /dev/null @@ -1,54 +0,0 @@ -/* - * Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary - * source code may only be used and distributed under the Widevine License - * Agreement. - */ - -#include "gtest/gtest.h" -#include "WVCryptoFactory.h" - -namespace wvdrm { -namespace hardware { -namespace drm { -namespace V1_4 { -namespace widevine { - -using ::android::sp; - -const uint8_t kWidevineUUID[16] = { - 0xED,0xEF,0x8B,0xA9,0x79,0xD6,0x4A,0xCE, - 0xA3,0xC8,0x27,0xDC,0xD5,0x1D,0x21,0xED -}; - -const uint8_t kOldNetflixWidevineUUID[16] = { - 0x29,0x70,0x1F,0xE4,0x3C,0xC7,0x4A,0x34, - 0x8C,0x5B,0xAE,0x90,0xC7,0x43,0x9A,0x47 -}; - -const uint8_t kUnknownUUID[16] = { - 0x6A,0x7F,0xAA,0xB0,0x83,0xC7,0x9E,0x20, - 0x08,0xBC,0xEF,0x32,0x34,0x1A,0x9A,0x26 -}; - -TEST(WVCryptoFactoryTest, SupportsSupportedCryptoSchemes) { - sp factory(new WVCryptoFactory()); - - EXPECT_TRUE(factory->isCryptoSchemeSupported(kWidevineUUID)) << - "WVPluginFactory does not support Widevine's UUID"; - - EXPECT_TRUE(factory->isCryptoSchemeSupported(kOldNetflixWidevineUUID)) << - "WVPluginFactory does not support the old Netflix Widevine UUID"; -} - -TEST(WVCryptoFactoryTest, DoesNotSupportUnsupportedCryptoSchemes) { - sp factory(new WVCryptoFactory()); - - EXPECT_FALSE(factory->isCryptoSchemeSupported(kUnknownUUID)) << - "WVPluginFactory incorrectly claims to support an unknown UUID"; -} - -} // namespace widevine -} // namespace V1_4 -} // namespace drm -} // namespace hardware -} // namespace wvdrm diff --git a/libwvdrmengine/test/unit/WVDrmFactory_test.cpp b/libwvdrmengine/test/unit/WVDrmFactory_test.cpp deleted file mode 100644 index bd5c8915..00000000 --- a/libwvdrmengine/test/unit/WVDrmFactory_test.cpp +++ /dev/null @@ -1,150 +0,0 @@ -/* - * Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary - * source code may only be used and distributed under the Widevine License - * Agreement. - */ - -#include "android-base/properties.h" -#include "cutils/properties.h" -#include "gtest/gtest.h" -#include "HidlTypes.h" -#include "WVDrmFactory.h" - -namespace wvdrm { -namespace hardware { -namespace drm { -namespace V1_4 { -namespace widevine { - -using namespace android; - -const uint8_t kWidevineUUID[16] = { - 0xED,0xEF,0x8B,0xA9,0x79,0xD6,0x4A,0xCE, - 0xA3,0xC8,0x27,0xDC,0xD5,0x1D,0x21,0xED -}; - -const uint8_t kOldNetflixWidevineUUID[16] = { - 0x29,0x70,0x1F,0xE4,0x3C,0xC7,0x4A,0x34, - 0x8C,0x5B,0xAE,0x90,0xC7,0x43,0x9A,0x47 -}; - -const uint8_t kUnknownUUID[16] = { - 0x6A,0x7F,0xAA,0xB0,0x83,0xC7,0x9E,0x20, - 0x08,0xBC,0xEF,0x32,0x34,0x1A,0x9A,0x26 -}; - -class WVDrmFactoryTestPeer : public WVDrmFactory { - public: - using WVDrmFactory::areSpoidsEnabled; - using WVDrmFactory::isBlankAppPackageNameAllowed; -}; - -TEST(WVDrmFactoryTest, SupportsSupportedCryptoSchemes) { - WVDrmFactory factory; - - EXPECT_TRUE(factory.isCryptoSchemeSupported(kWidevineUUID)) << - "WVPluginFactory does not support Widevine's UUID"; - - EXPECT_TRUE(factory.isCryptoSchemeSupported(kOldNetflixWidevineUUID)) << - "WVPluginFactory does not support the old Netflix Widevine UUID"; -} - -TEST(WVDrmFactoryTest, DoesNotSupportUnsupportedCryptoSchemes) { - WVDrmFactory factory; - - EXPECT_FALSE(factory.isCryptoSchemeSupported(kUnknownUUID)) << - "WVPluginFactory incorrectly claims to support an unknown UUID"; -} - -TEST(WVDrmFactoryTest, SupportsSupportedContainerFormats) { - WVDrmFactory factory; - - EXPECT_TRUE(factory.isContentTypeSupported(hidl_string("video/mp4"))) << - "WVPluginFactory does not support ISO-BMFF video"; - - EXPECT_TRUE(factory.isContentTypeSupported(hidl_string("audio/mp4"))) << - "WVPluginFactory does not support ISO-BMFF audio"; - - EXPECT_TRUE(factory.isContentTypeSupported(hidl_string("video/webm"))) << - "WVPluginFactory does not support WebM video"; - - EXPECT_TRUE(factory.isContentTypeSupported(hidl_string("audio/webm"))) << - "WVPluginFactory does not support WebM audio"; -} - -TEST(WVDrmFactoryTest, DoesNotSupportUnsupportedContainerFormats) { - WVDrmFactory factory; - - // Taken from Encoding.com's list of the most common internet video MIME-types - EXPECT_FALSE(factory.isContentTypeSupported(hidl_string("video/x-matroska"))) << - "WVPluginFactory incorrectly claims to support Matroska"; - - EXPECT_FALSE(factory.isContentTypeSupported(hidl_string("video/x-flv"))) << - "WVPluginFactory incorrectly claims to support Flash Video"; - - EXPECT_FALSE(factory.isContentTypeSupported(hidl_string("application/x-mpegURL"))) << - "WVPluginFactory incorrectly claims to support m3u8 Indexes"; - - EXPECT_FALSE(factory.isContentTypeSupported(hidl_string("video/MP2T"))) << - "WVPluginFactory incorrectly claims to support MPEG-2 TS"; - - EXPECT_FALSE(factory.isContentTypeSupported(hidl_string("video/3gpp"))) << - "WVPluginFactory incorrectly claims to support 3GP Mobile"; - - EXPECT_FALSE(factory.isContentTypeSupported(hidl_string("video/quicktime"))) << - "WVPluginFactory incorrectly claims to support Quicktime"; - - EXPECT_FALSE(factory.isContentTypeSupported(hidl_string("video/x-msvideo"))) << - "WVPluginFactory incorrectly claims to support AVI"; - - EXPECT_FALSE(factory.isContentTypeSupported(hidl_string("video/x-ms-wmv"))) << - "WVPluginFactory incorrectly claims to support WMV"; -} - -TEST(WVDrmFactoryTest, SupportsSupportedCryptoSchemeWithLevel) { - WVDrmFactory factory; - - EXPECT_TRUE(factory.isCryptoSchemeSupported_1_2(kWidevineUUID, hidl_string("video/mp4"), - android::hardware::drm::V1_1::SecurityLevel::SW_SECURE_CRYPTO)) << - "WVPluginFactory does not support Widevine's UUID for video/mp4 and SW_SECURE_CRYPTO"; -} - -TEST(WVDrmFactoryTest, CalculatesSpoidUseCorrectly) { - WVDrmFactoryTestPeer factory; - - int32_t firstApiLevel = - android::base::GetIntProperty("ro.product.first_api_level", 0); - if (firstApiLevel == 0) { - // First API Level is 0 on factory ROMs, but we can assume the current SDK - // version is the first if it's a factory ROM. - firstApiLevel = - android::base::GetIntProperty("ro.build.version.sdk", 0); - } - bool shouldUseSpoids = (firstApiLevel >= 26); // Android O - - EXPECT_EQ(shouldUseSpoids, factory.areSpoidsEnabled()) << - "WVDrmFactory calculated a different SPOID state than expected."; -} - -TEST(WVDrmFactoryTest, CalculatesBlankAppPackageNamePermissibilityCorrectly) { - WVDrmFactoryTestPeer factory; - - int32_t firstApiLevel = - android::base::GetIntProperty("ro.product.first_api_level", 0); - if (firstApiLevel == 0) { - // First API Level is 0 on factory ROMs, but we can assume the current SDK - // version is the first if it's a factory ROM. - firstApiLevel = - android::base::GetIntProperty("ro.build.version.sdk", 0); - } - bool shouldAllow = (firstApiLevel < 29); // Android Q - - EXPECT_EQ(shouldAllow, factory.isBlankAppPackageNameAllowed()) << - "WVDrmFactory calculated a different Blank App Package Name state than expected."; -} - -} // namespace widevine -} // namespace V1_4 -} // namespace drm -} // namespace hardware -} // namespace wvdrm diff --git a/libwvdrmengine/test/unit/hidl/WVCreatePluginFactories_test.cpp b/libwvdrmengine/test/unit/hidl/WVCreatePluginFactories_test.cpp deleted file mode 100644 index 7f928d82..00000000 --- a/libwvdrmengine/test/unit/hidl/WVCreatePluginFactories_test.cpp +++ /dev/null @@ -1,38 +0,0 @@ -// -// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary -// source code may only be used and distributed under the Widevine License -// Agreement. -// - -#include "gtest/gtest.h" -#include "WVCreatePluginFactories.h" - -namespace wvdrm { -namespace hardware { -namespace drm { -namespace V1_4 { -namespace widevine { - -using ::android::sp; - -using namespace android; - -TEST(CreatePluginFactoriesTest, CreatesDrmFactory) { - sp factory(createDrmFactory()); - - EXPECT_NE((IDrmFactory*)NULL, factory.get()) << - "createDrmFactory() returned null"; -} - -TEST(CreatePluginFactoriesTest, CreatesCryptoFactory) { - sp factory(createCryptoFactory()); - - EXPECT_NE((ICryptoFactory*)NULL, factory.get()) << - "createCryptoFactory() returned null"; -} - -} // namespace widevine -} // namespace V1_4 -} // namespace drm -} // namespace hardware -} // namespace wvdrm diff --git a/libwvdrmengine/test/unit/hidl/WVCryptoFactory_test.cpp b/libwvdrmengine/test/unit/hidl/WVCryptoFactory_test.cpp deleted file mode 100644 index a7782b1e..00000000 --- a/libwvdrmengine/test/unit/hidl/WVCryptoFactory_test.cpp +++ /dev/null @@ -1,54 +0,0 @@ -/* - * Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary - * source code may only be used and distributed under the Widevine License - * Agreement. - */ - -#include "gtest/gtest.h" -#include "WVCryptoFactory.h" - -namespace wvdrm { -namespace hardware { -namespace drm { -namespace V1_4 { -namespace widevine { - -using ::android::sp; - -const uint8_t kWidevineUUID[16] = { - 0xED,0xEF,0x8B,0xA9,0x79,0xD6,0x4A,0xCE, - 0xA3,0xC8,0x27,0xDC,0xD5,0x1D,0x21,0xED -}; - -const uint8_t kOldNetflixWidevineUUID[16] = { - 0x29,0x70,0x1F,0xE4,0x3C,0xC7,0x4A,0x34, - 0x8C,0x5B,0xAE,0x90,0xC7,0x43,0x9A,0x47 -}; - -const uint8_t kUnknownUUID[16] = { - 0x6A,0x7F,0xAA,0xB0,0x83,0xC7,0x9E,0x20, - 0x08,0xBC,0xEF,0x32,0x34,0x1A,0x9A,0x26 -}; - -TEST(WVCryptoFactoryTest, SupportsSupportedCryptoSchemes) { - sp factory(new WVCryptoFactory()); - - EXPECT_TRUE(factory->isCryptoSchemeSupported(kWidevineUUID)) << - "WVPluginFactory does not support Widevine's UUID"; - - EXPECT_TRUE(factory->isCryptoSchemeSupported(kOldNetflixWidevineUUID)) << - "WVPluginFactory does not support the old Netflix Widevine UUID"; -} - -TEST(WVCryptoFactoryTest, DoesNotSupportUnsupportedCryptoSchemes) { - sp factory(new WVCryptoFactory()); - - EXPECT_FALSE(factory->isCryptoSchemeSupported(kUnknownUUID)) << - "WVPluginFactory incorrectly claims to support an unknown UUID"; -} - -} // namespace widevine -} // namespace V1_4 -} // namespace drm -} // namespace hardware -} // namespace wvdrm diff --git a/libwvdrmengine/test/unit/hidl/WVDrmFactory_test.cpp b/libwvdrmengine/test/unit/hidl/WVDrmFactory_test.cpp deleted file mode 100644 index bd5c8915..00000000 --- a/libwvdrmengine/test/unit/hidl/WVDrmFactory_test.cpp +++ /dev/null @@ -1,150 +0,0 @@ -/* - * Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary - * source code may only be used and distributed under the Widevine License - * Agreement. - */ - -#include "android-base/properties.h" -#include "cutils/properties.h" -#include "gtest/gtest.h" -#include "HidlTypes.h" -#include "WVDrmFactory.h" - -namespace wvdrm { -namespace hardware { -namespace drm { -namespace V1_4 { -namespace widevine { - -using namespace android; - -const uint8_t kWidevineUUID[16] = { - 0xED,0xEF,0x8B,0xA9,0x79,0xD6,0x4A,0xCE, - 0xA3,0xC8,0x27,0xDC,0xD5,0x1D,0x21,0xED -}; - -const uint8_t kOldNetflixWidevineUUID[16] = { - 0x29,0x70,0x1F,0xE4,0x3C,0xC7,0x4A,0x34, - 0x8C,0x5B,0xAE,0x90,0xC7,0x43,0x9A,0x47 -}; - -const uint8_t kUnknownUUID[16] = { - 0x6A,0x7F,0xAA,0xB0,0x83,0xC7,0x9E,0x20, - 0x08,0xBC,0xEF,0x32,0x34,0x1A,0x9A,0x26 -}; - -class WVDrmFactoryTestPeer : public WVDrmFactory { - public: - using WVDrmFactory::areSpoidsEnabled; - using WVDrmFactory::isBlankAppPackageNameAllowed; -}; - -TEST(WVDrmFactoryTest, SupportsSupportedCryptoSchemes) { - WVDrmFactory factory; - - EXPECT_TRUE(factory.isCryptoSchemeSupported(kWidevineUUID)) << - "WVPluginFactory does not support Widevine's UUID"; - - EXPECT_TRUE(factory.isCryptoSchemeSupported(kOldNetflixWidevineUUID)) << - "WVPluginFactory does not support the old Netflix Widevine UUID"; -} - -TEST(WVDrmFactoryTest, DoesNotSupportUnsupportedCryptoSchemes) { - WVDrmFactory factory; - - EXPECT_FALSE(factory.isCryptoSchemeSupported(kUnknownUUID)) << - "WVPluginFactory incorrectly claims to support an unknown UUID"; -} - -TEST(WVDrmFactoryTest, SupportsSupportedContainerFormats) { - WVDrmFactory factory; - - EXPECT_TRUE(factory.isContentTypeSupported(hidl_string("video/mp4"))) << - "WVPluginFactory does not support ISO-BMFF video"; - - EXPECT_TRUE(factory.isContentTypeSupported(hidl_string("audio/mp4"))) << - "WVPluginFactory does not support ISO-BMFF audio"; - - EXPECT_TRUE(factory.isContentTypeSupported(hidl_string("video/webm"))) << - "WVPluginFactory does not support WebM video"; - - EXPECT_TRUE(factory.isContentTypeSupported(hidl_string("audio/webm"))) << - "WVPluginFactory does not support WebM audio"; -} - -TEST(WVDrmFactoryTest, DoesNotSupportUnsupportedContainerFormats) { - WVDrmFactory factory; - - // Taken from Encoding.com's list of the most common internet video MIME-types - EXPECT_FALSE(factory.isContentTypeSupported(hidl_string("video/x-matroska"))) << - "WVPluginFactory incorrectly claims to support Matroska"; - - EXPECT_FALSE(factory.isContentTypeSupported(hidl_string("video/x-flv"))) << - "WVPluginFactory incorrectly claims to support Flash Video"; - - EXPECT_FALSE(factory.isContentTypeSupported(hidl_string("application/x-mpegURL"))) << - "WVPluginFactory incorrectly claims to support m3u8 Indexes"; - - EXPECT_FALSE(factory.isContentTypeSupported(hidl_string("video/MP2T"))) << - "WVPluginFactory incorrectly claims to support MPEG-2 TS"; - - EXPECT_FALSE(factory.isContentTypeSupported(hidl_string("video/3gpp"))) << - "WVPluginFactory incorrectly claims to support 3GP Mobile"; - - EXPECT_FALSE(factory.isContentTypeSupported(hidl_string("video/quicktime"))) << - "WVPluginFactory incorrectly claims to support Quicktime"; - - EXPECT_FALSE(factory.isContentTypeSupported(hidl_string("video/x-msvideo"))) << - "WVPluginFactory incorrectly claims to support AVI"; - - EXPECT_FALSE(factory.isContentTypeSupported(hidl_string("video/x-ms-wmv"))) << - "WVPluginFactory incorrectly claims to support WMV"; -} - -TEST(WVDrmFactoryTest, SupportsSupportedCryptoSchemeWithLevel) { - WVDrmFactory factory; - - EXPECT_TRUE(factory.isCryptoSchemeSupported_1_2(kWidevineUUID, hidl_string("video/mp4"), - android::hardware::drm::V1_1::SecurityLevel::SW_SECURE_CRYPTO)) << - "WVPluginFactory does not support Widevine's UUID for video/mp4 and SW_SECURE_CRYPTO"; -} - -TEST(WVDrmFactoryTest, CalculatesSpoidUseCorrectly) { - WVDrmFactoryTestPeer factory; - - int32_t firstApiLevel = - android::base::GetIntProperty("ro.product.first_api_level", 0); - if (firstApiLevel == 0) { - // First API Level is 0 on factory ROMs, but we can assume the current SDK - // version is the first if it's a factory ROM. - firstApiLevel = - android::base::GetIntProperty("ro.build.version.sdk", 0); - } - bool shouldUseSpoids = (firstApiLevel >= 26); // Android O - - EXPECT_EQ(shouldUseSpoids, factory.areSpoidsEnabled()) << - "WVDrmFactory calculated a different SPOID state than expected."; -} - -TEST(WVDrmFactoryTest, CalculatesBlankAppPackageNamePermissibilityCorrectly) { - WVDrmFactoryTestPeer factory; - - int32_t firstApiLevel = - android::base::GetIntProperty("ro.product.first_api_level", 0); - if (firstApiLevel == 0) { - // First API Level is 0 on factory ROMs, but we can assume the current SDK - // version is the first if it's a factory ROM. - firstApiLevel = - android::base::GetIntProperty("ro.build.version.sdk", 0); - } - bool shouldAllow = (firstApiLevel < 29); // Android Q - - EXPECT_EQ(shouldAllow, factory.isBlankAppPackageNameAllowed()) << - "WVDrmFactory calculated a different Blank App Package Name state than expected."; -} - -} // namespace widevine -} // namespace V1_4 -} // namespace drm -} // namespace hardware -} // namespace wvdrm diff --git a/libwvdrmengine/tools/metrics_dump/Android.bp b/libwvdrmengine/tools/metrics_dump/Android.bp index 9dbdb221..dd159686 100644 --- a/libwvdrmengine/tools/metrics_dump/Android.bp +++ b/libwvdrmengine/tools/metrics_dump/Android.bp @@ -45,7 +45,7 @@ cc_binary_host { "vendor/widevine/libwvdrmengine/cdm/core/include", "vendor/widevine/libwvdrmengine/cdm/core/test", "vendor/widevine/libwvdrmengine/cdm/metrics/include", - "vendor/widevine/libwvdrmengine/include_hidl", + "vendor/widevine/libwvdrmengine/include", "vendor/widevine/libwvdrmengine/oemcrypto/include", "vendor/widevine/libwvdrmengine/tools/metrics_dump/include", ], diff --git a/libwvdrmengine/vts/vendor_module/Android.bp b/libwvdrmengine/vts/vendor_module/Android.bp index 9610dfe6..6df4c598 100644 --- a/libwvdrmengine/vts/vendor_module/Android.bp +++ b/libwvdrmengine/vts/vendor_module/Android.bp @@ -38,7 +38,6 @@ cc_library_shared { "vendor/widevine/libwvdrmengine/cdm/core/include", "vendor/widevine/libwvdrmengine/cdm/core/test", "vendor/widevine/libwvdrmengine/cdm/util/include", - "system/libhidl/base/include", "system/libbase/include", "system/libvintf/include", ],