summaryrefslogtreecommitdiffstats
path: root/media/wmf-clearkey/WMFClearKeyCDM.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /media/wmf-clearkey/WMFClearKeyCDM.cpp
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'media/wmf-clearkey/WMFClearKeyCDM.cpp')
-rw-r--r--media/wmf-clearkey/WMFClearKeyCDM.cpp371
1 files changed, 371 insertions, 0 deletions
diff --git a/media/wmf-clearkey/WMFClearKeyCDM.cpp b/media/wmf-clearkey/WMFClearKeyCDM.cpp
new file mode 100644
index 0000000000..b782aec5da
--- /dev/null
+++ b/media/wmf-clearkey/WMFClearKeyCDM.cpp
@@ -0,0 +1,371 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "WMFClearKeyCDM.h"
+
+#include <Mferror.h>
+#include <mfapi.h>
+#include <oleauto.h>
+#include <optional>
+#include <windows.h>
+#include <windows.media.h>
+
+#include "WMFClearKeyTrustedInput.h"
+#include "WMFClearKeySession.h"
+#include "WMFDecryptedBlock.h"
+#include "WMFPMPServer.h"
+
+using Microsoft::WRL::ComPtr;
+using Microsoft::WRL::MakeAndInitialize;
+
+static HRESULT AddPropertyToSet(
+ ABI::Windows::Foundation::Collections::IPropertySet* aPropertySet,
+ LPCWSTR aName, IInspectable* aInspectable) {
+ boolean replaced = false;
+ ComPtr<ABI::Windows::Foundation::Collections::IMap<HSTRING, IInspectable*>>
+ map;
+ RETURN_IF_FAILED(aPropertySet->QueryInterface(IID_PPV_ARGS(&map)));
+ RETURN_IF_FAILED(
+ map->Insert(Microsoft::WRL::Wrappers::HStringReference(aName).Get(),
+ aInspectable, &replaced));
+ return S_OK;
+}
+
+static HRESULT AddStringToPropertySet(
+ ABI::Windows::Foundation::Collections::IPropertySet* aPropertySet,
+ LPCWSTR aName, LPCWSTR aString) {
+ ComPtr<ABI::Windows::Foundation::IPropertyValue> propertyValue;
+ ComPtr<ABI::Windows::Foundation::IPropertyValueStatics> propertyValueStatics;
+ RETURN_IF_FAILED(ABI::Windows::Foundation::GetActivationFactory(
+ Microsoft::WRL::Wrappers::HStringReference(
+ RuntimeClass_Windows_Foundation_PropertyValue)
+ .Get(),
+ &propertyValueStatics));
+ RETURN_IF_FAILED(propertyValueStatics->CreateString(
+ Microsoft::WRL::Wrappers::HStringReference(aString).Get(),
+ &propertyValue));
+ RETURN_IF_FAILED(AddPropertyToSet(aPropertySet, aName, propertyValue.Get()));
+ return S_OK;
+}
+
+static HRESULT AddBoolToPropertySet(
+ ABI::Windows::Foundation::Collections::IPropertySet* aPropertySet,
+ LPCWSTR aName, BOOL aValue) {
+ ComPtr<ABI::Windows::Foundation::IPropertyValue> propertyValue;
+ ComPtr<ABI::Windows::Foundation::IPropertyValueStatics> propertyValueStatics;
+ RETURN_IF_FAILED(ABI::Windows::Foundation::GetActivationFactory(
+ Microsoft::WRL::Wrappers::HStringReference(
+ RuntimeClass_Windows_Foundation_PropertyValue)
+ .Get(),
+ &propertyValueStatics));
+ RETURN_IF_FAILED(
+ propertyValueStatics->CreateBoolean(!!aValue, &propertyValue));
+ RETURN_IF_FAILED(AddPropertyToSet(aPropertySet, aName, propertyValue.Get()));
+ return S_OK;
+}
+
+MF_MEDIAKEYSESSION_MESSAGETYPE ToMFMessageType(cdm::MessageType aMessageType) {
+ switch (aMessageType) {
+ case cdm::MessageType::kLicenseRequest:
+ return MF_MEDIAKEYSESSION_MESSAGETYPE_LICENSE_REQUEST;
+ case cdm::MessageType::kLicenseRenewal:
+ return MF_MEDIAKEYSESSION_MESSAGETYPE_LICENSE_RENEWAL;
+ case cdm::MessageType::kLicenseRelease:
+ return MF_MEDIAKEYSESSION_MESSAGETYPE_LICENSE_RELEASE;
+ case cdm::MessageType::kIndividualizationRequest:
+ return MF_MEDIAKEYSESSION_MESSAGETYPE_INDIVIDUALIZATION_REQUEST;
+ }
+}
+
+namespace mozilla {
+
+HRESULT WMFClearKeyCDM::RuntimeClassInitialize(IPropertyStore* aProperties) {
+ ENTRY_LOG();
+ // A workaround in order to create an in-process PMP server regardless of the
+ // system's HWDRM capability. As accoriding to Microsoft, only PlayReady is
+ // supported for the in-process PMP so we pretend ourselves as a PlayReady
+ // CDM for the PMP server.
+ ComPtr<ABI::Windows::Foundation::Collections::IPropertySet> propertyPmp;
+ RETURN_IF_FAILED(Windows::Foundation::ActivateInstance(
+ Microsoft::WRL::Wrappers::HStringReference(
+ RuntimeClass_Windows_Foundation_Collections_PropertySet)
+ .Get(),
+ &propertyPmp));
+ RETURN_IF_FAILED(AddStringToPropertySet(
+ propertyPmp.Get(), L"Windows.Media.Protection.MediaProtectionSystemId",
+ PLAYREADY_GUID_MEDIA_PROTECTION_SYSTEM_ID_STRING));
+ RETURN_IF_FAILED(AddBoolToPropertySet(
+ propertyPmp.Get(), L"Windows.Media.Protection.UseHardwareProtectionLayer",
+ TRUE));
+ RETURN_IF_FAILED((MakeAndInitialize<
+ WMFPMPServer,
+ ABI::Windows::Media::Protection::IMediaProtectionPMPServer>(
+ &mPMPServer, propertyPmp.Get())));
+
+ mSessionManager = new SessionManagerWrapper(this);
+ return S_OK;
+}
+
+WMFClearKeyCDM::~WMFClearKeyCDM() { ENTRY_LOG(); }
+
+STDMETHODIMP WMFClearKeyCDM::SetContentEnabler(
+ IMFContentEnabler* aContentEnabler, IMFAsyncResult* aResult) {
+ ENTRY_LOG();
+ if (!aContentEnabler || !aResult) {
+ return E_INVALIDARG;
+ }
+ // Invoke the callback immediately but will determine whether the keyid exists
+ // or not in the decryptor's ProcessOutput().
+ RETURN_IF_FAILED(MFInvokeCallback(aResult));
+ return S_OK;
+}
+
+STDMETHODIMP WMFClearKeyCDM::SetPMPHostApp(IMFPMPHostApp* aPmpHostApp) {
+ ENTRY_LOG();
+ // Simply return S_OK and ignore IMFPMPHostApp, which is only used for the
+ // out-of-process PMP.
+ return S_OK;
+}
+
+STDMETHODIMP WMFClearKeyCDM::CreateSession(
+ MF_MEDIAKEYSESSION_TYPE aSessionType,
+ IMFContentDecryptionModuleSessionCallbacks* aCallbacks,
+ IMFContentDecryptionModuleSession** aSession) {
+ ENTRY_LOG();
+ RETURN_IF_FAILED(
+ (MakeAndInitialize<WMFClearKeySession, IMFContentDecryptionModuleSession>(
+ aSession, aSessionType, aCallbacks, mSessionManager)));
+ return S_OK;
+}
+
+STDMETHODIMP WMFClearKeyCDM::CreateTrustedInput(
+ const BYTE* aContentInitData, DWORD aContentInitDataSize,
+ IMFTrustedInput** aTrustedInput) {
+ ENTRY_LOG();
+ ComPtr<IMFTrustedInput> trustedInput;
+ RETURN_IF_FAILED((MakeAndInitialize<WMFClearKeyTrustedInput, IMFTrustedInput>(
+ &trustedInput, mSessionManager)));
+ *aTrustedInput = trustedInput.Detach();
+ return S_OK;
+}
+
+STDMETHODIMP WMFClearKeyCDM::GetProtectionSystemIds(GUID** aSystemIds,
+ DWORD* aCount) {
+ ENTRY_LOG();
+ GUID* systemId = static_cast<GUID*>(CoTaskMemAlloc(sizeof(GUID)));
+ if (!systemId) {
+ return E_OUTOFMEMORY;
+ }
+ *systemId = CLEARKEY_GUID_CLEARKEY_PROTECTION_SYSTEM_ID;
+ *aSystemIds = systemId;
+ *aCount = 1;
+ return S_OK;
+}
+
+STDMETHODIMP WMFClearKeyCDM::GetService(REFGUID aGuidService, REFIID aRiid,
+ LPVOID* aPpvObject) {
+ ENTRY_LOG();
+ if (MF_CONTENTDECRYPTIONMODULE_SERVICE != aGuidService) {
+ ENTRY_LOG_ARGS("unsupported guid!");
+ return MF_E_UNSUPPORTED_SERVICE;
+ }
+ if (!mPMPServer) {
+ ENTRY_LOG_ARGS("no PMP server!");
+ return MF_INVALID_STATE_ERR;
+ }
+ if (aRiid == ABI::Windows::Media::Protection::IID_IMediaProtectionPMPServer) {
+ RETURN_IF_FAILED(mPMPServer.CopyTo(aRiid, aPpvObject));
+ } else {
+ ComPtr<IMFGetService> getService;
+ RETURN_IF_FAILED(mPMPServer.As(&getService));
+ RETURN_IF_FAILED(getService->GetService(MF_PMP_SERVICE, aRiid, aPpvObject));
+ }
+ return S_OK;
+}
+
+STDMETHODIMP WMFClearKeyCDM::GetSuspendNotify(IMFCdmSuspendNotify** aNotify) {
+ NOT_IMPLEMENTED();
+ return E_NOTIMPL;
+}
+
+STDMETHODIMP WMFClearKeyCDM::SetServerCertificate(const BYTE* aCertificate,
+ DWORD aCertificateSize) {
+ NOT_IMPLEMENTED();
+ return E_NOTIMPL;
+}
+
+STDMETHODIMP WMFClearKeyCDM::Shutdown() {
+ ENTRY_LOG();
+ mSessionManager->Shutdown();
+ return S_OK;
+}
+
+STDMETHODIMP WMFClearKeyCDM::GetShutdownStatus(MFSHUTDOWN_STATUS* aStatus) {
+ ENTRY_LOG();
+ // https://learn.microsoft.com/en-us/windows/win32/api/mfidl/nf-mfidl-imfshutdown-getshutdownstatus#return-value
+ if (mSessionManager->IsShutdown()) {
+ return MF_E_INVALIDREQUEST;
+ }
+ return S_OK;
+}
+
+// SessionManagerWrapper
+
+SessionManagerWrapper::SessionManagerWrapper(WMFClearKeyCDM* aCDM)
+ : mOwnerCDM(aCDM), mSessionManager(new ClearKeySessionManager(this)) {
+ // For testing, we don't care about these.
+ mSessionManager->Init(false /* aDistinctiveIdentifierAllowed */,
+ false /* aPersistentStateAllowed*/);
+}
+
+SessionManagerWrapper::~SessionManagerWrapper() { ENTRY_LOG(); }
+
+// Callback methods
+void SessionManagerWrapper::OnResolveNewSessionPromise(
+ uint32_t aPromiseId, const char* aSessionId, uint32_t aSessionIdSize) {
+ if (auto rv = mActiveSyncResultChecker.find(aPromiseId);
+ rv != mActiveSyncResultChecker.end()) {
+ LOG("Generated request (promise-id=%u, sessionId=%s)", aPromiseId,
+ aSessionId);
+ rv->second->SetResultConstChar(aSessionId);
+ std::string sessionId{aSessionId};
+ MOZ_ASSERT(mSessions.find(sessionId) == mSessions.end());
+ mSessions[sessionId] = rv->second->GetKeySession();
+ }
+}
+
+void SessionManagerWrapper::OnResolvePromise(uint32_t aPromiseId) {
+ if (auto rv = mActiveSyncResultChecker.find(aPromiseId);
+ rv != mActiveSyncResultChecker.end()) {
+ LOG("Resolved promise (promise-id=%u)", aPromiseId);
+ rv->second->SetResultBool(true);
+ }
+}
+
+void SessionManagerWrapper::OnRejectPromise(uint32_t aPromiseId,
+ cdm::Exception aException,
+ uint32_t aSystemCode,
+ const char* aErrorMessage,
+ uint32_t aErrorMessageSize) {
+ if (auto rv = mActiveSyncResultChecker.find(aPromiseId);
+ rv != mActiveSyncResultChecker.end()) {
+ LOG("Rejected promise (promise-id=%u)", aPromiseId);
+ rv->second->SetResultBool(false);
+ }
+}
+
+HRESULT SessionManagerWrapper::GenerateRequest(cdm::InitDataType aInitDataType,
+ const BYTE* aInitData,
+ DWORD aInitDataSize,
+ cdm::SessionType aSessionType,
+ WMFClearKeySession* aSession,
+ std::string& aSessionIdOut) {
+ ENTRY_LOG();
+ MOZ_DIAGNOSTIC_ASSERT(aSessionType == cdm::SessionType::kTemporary);
+ SyncResultChecker checker(*this, aSession);
+ mSessionManager->CreateSession(checker.GetPromiseId(), aInitDataType,
+ aInitData, aInitDataSize, aSessionType);
+ auto* rv = std::get_if<const char*>(&checker.GetResult());
+ if (!rv) {
+ LOG("Failed to generate request, no session Id!");
+ return E_FAIL;
+ }
+ aSessionIdOut = std::string(*rv);
+ return S_OK;
+}
+
+HRESULT SessionManagerWrapper::UpdateSession(const std::string& aSessionId,
+ const BYTE* aResponse,
+ DWORD aResponseSize) {
+ ENTRY_LOG();
+ SyncResultChecker checker(*this);
+ mSessionManager->UpdateSession(checker.GetPromiseId(), aSessionId.c_str(),
+ aSessionId.size(), aResponse, aResponseSize);
+ auto* rv = std::get_if<bool>(&checker.GetResult());
+ return rv && *rv ? S_OK : E_FAIL;
+}
+
+HRESULT SessionManagerWrapper::CloseSession(const std::string& aSessionId) {
+ ENTRY_LOG();
+ SyncResultChecker checker(*this);
+ mSessionManager->CloseSession(checker.GetPromiseId(), aSessionId.c_str(),
+ aSessionId.size());
+ auto* rv = std::get_if<bool>(&checker.GetResult());
+ return rv && *rv ? S_OK : E_FAIL;
+}
+
+HRESULT SessionManagerWrapper::RemoveSession(const std::string& aSessionId) {
+ ENTRY_LOG();
+ SyncResultChecker checker(*this);
+ MOZ_ASSERT(mSessions.find(aSessionId) != mSessions.end());
+ mSessions.erase(aSessionId);
+ mSessionManager->RemoveSession(checker.GetPromiseId(), aSessionId.c_str(),
+ aSessionId.size());
+ auto* rv = std::get_if<bool>(&checker.GetResult());
+ return rv && *rv ? S_OK : E_FAIL;
+}
+
+HRESULT SessionManagerWrapper::Decrypt(const cdm::InputBuffer_2& aBuffer,
+ cdm::DecryptedBlock* aDecryptedBlock) {
+ ENTRY_LOG();
+ // From MF thread pool.
+ std::lock_guard<std::mutex> lock(mMutex);
+ if (mIsShutdown) {
+ return MF_E_SHUTDOWN;
+ }
+ auto rv = mSessionManager->Decrypt(aBuffer, aDecryptedBlock);
+ return rv == cdm::kSuccess ? S_OK : E_FAIL;
+}
+
+void SessionManagerWrapper::OnSessionMessage(const char* aSessionId,
+ uint32_t aSessionIdSize,
+ cdm::MessageType aMessageType,
+ const char* aMessage,
+ uint32_t aMessageSize) {
+ ENTRY_LOG_ARGS("sessionId=%s, sz=%u", aSessionId, aSessionIdSize);
+ std::string sessionId(aSessionId);
+ MOZ_ASSERT(mSessions.find(sessionId) != mSessions.end());
+ mSessions[sessionId]->OnKeyMessage(ToMFMessageType(aMessageType),
+ reinterpret_cast<const BYTE*>(aMessage),
+ aMessageSize);
+}
+
+void SessionManagerWrapper::OnSessionKeysChange(
+ const char* aSessionId, uint32_t aSessionIdSize,
+ bool aHasAdditionalUsableKey, const cdm::KeyInformation* aKeysInfo,
+ uint32_t aKeysInfoCount) {
+ ENTRY_LOG_ARGS("sessionId=%s, sz=%u", aSessionId, aSessionIdSize);
+ std::string sessionId(aSessionId);
+ MOZ_ASSERT(mSessions.find(sessionId) != mSessions.end());
+ mSessions[sessionId]->OnKeyStatusChanged(aKeysInfo, aKeysInfoCount);
+}
+
+// `ClearKeySessionManager::Decrypt` will call this method to allocate buffer
+// for decryted data.
+cdm::Buffer* SessionManagerWrapper::Allocate(uint32_t aCapacity) {
+ ENTRY_LOG_ARGS("capacity=%u", aCapacity);
+ return new WMFDecryptedBuffer(aCapacity);
+}
+
+void SessionManagerWrapper::Shutdown() {
+ ENTRY_LOG();
+ std::lock_guard<std::mutex> lock(mMutex);
+ if (mIsShutdown) {
+ return;
+ }
+ mOwnerCDM = nullptr;
+ for (const auto& session : mSessions) {
+ session.second->Shutdown();
+ }
+ mSessions.clear();
+ mSessionManager = nullptr;
+ mIsShutdown = true;
+}
+
+bool SessionManagerWrapper::IsShutdown() {
+ std::lock_guard<std::mutex> lock(mMutex);
+ return mIsShutdown;
+}
+
+} // namespace mozilla