[EME][Mac] SecureStop left on disk in Private Browsing mode.
[WebKit-https.git] / Source / WebCore / platform / graphics / avfoundation / objc / CDMSessionAVContentKeySession.mm
1 /*
2  * Copyright (C) 2015 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #import "config.h"
27 #import "CDMSessionAVContentKeySession.h"
28
29 #if ENABLE(LEGACY_ENCRYPTED_MEDIA) && ENABLE(MEDIA_SOURCE)
30
31 #import "CDMPrivateMediaSourceAVFObjC.h"
32 #import "FileSystem.h"
33 #import "LegacyCDM.h"
34 #import "Logging.h"
35 #import "MediaPlayer.h"
36 #import "SourceBufferPrivateAVFObjC.h"
37 #import "WebCoreNSErrorExtras.h"
38 #import <AVFoundation/AVError.h>
39 #import <CoreMedia/CMBase.h>
40 #import <objc/objc-runtime.h>
41 #import <runtime/TypedArrayInlines.h>
42 #import <wtf/SoftLinking.h>
43
44 SOFT_LINK_FRAMEWORK_OPTIONAL(AVFoundation)
45 SOFT_LINK_CLASS(AVFoundation, AVStreamDataParser);
46 SOFT_LINK_CLASS_OPTIONAL(AVFoundation, AVContentKeySession);
47 SOFT_LINK_CONSTANT_MAY_FAIL(AVFoundation, AVContentKeyRequestProtocolVersionsKey, NSString *)
48 SOFT_LINK_CONSTANT_MAY_FAIL(AVFoundation, AVContentKeySystemFairPlayStreaming, NSString *)
49
50 typedef NSString *AVContentKeySystem;
51
52 @interface AVContentKeySession : NSObject
53 + (instancetype)contentKeySessionWithKeySystem:(AVContentKeySystem)keySystem;
54 - (instancetype)initWithStorageDirectoryAtURL:(NSURL *)storageURL;
55 @property (assign) id delegate;
56 - (void)addStreamDataParser:(AVStreamDataParser *)streamDataParser;
57 - (void)removeStreamDataParser:(AVStreamDataParser *)streamDataParser;
58 @property (readonly) NSArray *streamDataParsers;
59 - (void)expire;
60 @property (readonly) NSData *contentProtectionSessionIdentifier;
61 - (void)processContentKeyRequestInitializationData:(NSData *)initializationData options:(NSDictionary *)options;
62 + (NSArray *)pendingExpiredSessionReportsWithAppIdentifier:(NSData *)appIdentifier storageDirectoryAtURL:(NSURL *)storageURL;
63 + (void)removePendingExpiredSessionReports:(NSArray *)expiredSessionReports withAppIdentifier:(NSData *)appIdentifier storageDirectoryAtURL:(NSURL *)storageURL;
64 @end
65
66 typedef NS_ENUM(NSInteger, AVContentKeyRequestStatus) {
67     AVContentKeySessionStatusNoKey,
68     AVContentKeySessionStatusRequestingKey,
69     AVContentKeySessionStatusKeyPresent,
70     AVContentKeySessionStatusExpired,
71     AVContentKeySessionStatusFailed
72 };
73
74 @interface AVContentKeyRequest : NSObject
75 @property (readonly) AVContentKeyRequestStatus status;
76 @property (readonly) NSError *error;
77 @property (readonly) NSData *initializationData;
78 - (NSData *)contentKeyRequestDataForApp:(NSData *)appIdentifier contentIdentifier:(NSData *)contentIdentifier options:(NSDictionary *)options error:(NSError **)outError;
79 - (void)processContentKeyResponseData:(NSData *)contentKeyResponseData;
80 - (void)processContentKeyResponseError:(NSError *)error;
81 - (void)renewExpiringContentKeyResponseData;
82 @end
83
84 @interface WebCDMSessionAVContentKeySessionDelegate : NSObject {
85     WebCore::CDMSessionAVContentKeySession *m_parent;
86 }
87 - (void)invalidate;
88 @end
89
90 @implementation WebCDMSessionAVContentKeySessionDelegate
91 - (id)initWithParent:(WebCore::CDMSessionAVContentKeySession *)parent
92 {
93     if ((self = [super init]))
94         m_parent = parent;
95     return self;
96 }
97
98
99 - (void)invalidate
100 {
101     m_parent = nullptr;
102 }
103
104 - (void)contentKeySession:(AVContentKeySession *)session didProvideContentKeyRequest:(AVContentKeyRequest *)keyRequest
105 {
106     UNUSED_PARAM(session);
107
108     if (m_parent)
109         m_parent->didProvideContentKeyRequest(keyRequest);
110 }
111
112 - (void)contentKeySessionContentProtectionSessionIdentifierDidChange:(AVContentKeySession *)session
113 {
114     if (!m_parent)
115         return;
116
117     NSData* identifier = [session contentProtectionSessionIdentifier];
118     RetainPtr<NSString> sessionIdentifierString = identifier ? adoptNS([[NSString alloc] initWithData:identifier encoding:NSUTF8StringEncoding]) : nil;
119     m_parent->setSessionId(sessionIdentifierString.get());
120 }
121 @end
122
123 static const NSString *PlaybackSessionIdKey = @"PlaybackSessionID";
124
125 namespace WebCore {
126
127 CDMSessionAVContentKeySession::CDMSessionAVContentKeySession(const Vector<int>& protocolVersions, CDMPrivateMediaSourceAVFObjC& cdm, CDMSessionClient* client)
128     : CDMSessionMediaSourceAVFObjC(cdm, client)
129     , m_contentKeySessionDelegate(adoptNS([[WebCDMSessionAVContentKeySessionDelegate alloc] initWithParent:this]))
130     , m_protocolVersions(protocolVersions)
131     , m_mode(Normal)
132 {
133 }
134
135 CDMSessionAVContentKeySession::~CDMSessionAVContentKeySession()
136 {
137     [m_contentKeySessionDelegate invalidate];
138
139     for (auto& sourceBuffer : m_sourceBuffers)
140         removeParser(sourceBuffer->parser());
141 }
142
143 bool CDMSessionAVContentKeySession::isAvailable()
144 {
145     return getAVContentKeySessionClass();
146 }
147
148 RefPtr<Uint8Array> CDMSessionAVContentKeySession::generateKeyRequest(const String& mimeType, Uint8Array* initData, String& destinationURL, unsigned short& errorCode, uint32_t& systemCode)
149 {
150     UNUSED_PARAM(mimeType);
151     UNUSED_PARAM(destinationURL);
152     ASSERT(initData);
153
154     LOG(Media, "CDMSessionAVContentKeySession::generateKeyRequest(%p)", this);
155
156     errorCode = MediaPlayer::NoError;
157     systemCode = 0;
158
159     m_initData = initData;
160
161     if (equalLettersIgnoringASCIICase(mimeType, "keyrelease")) {
162         m_mode = KeyRelease;
163         return generateKeyReleaseMessage(errorCode, systemCode);
164     }
165
166     if (!m_certificate) {
167         String certificateString(ASCIILiteral("certificate"));
168         RefPtr<Uint8Array> array = Uint8Array::create(certificateString.length());
169         for (unsigned i = 0, length = certificateString.length(); i < length; ++i)
170             array->set(i, certificateString[i]);
171         return array;
172     }
173
174     if (!m_keyRequest) {
175         NSData* nsInitData = [NSData dataWithBytes:m_initData->data() length:m_initData->length()];
176         [contentKeySession() processContentKeyRequestInitializationData:nsInitData options:nil];
177     }
178
179     return nullptr;
180 }
181
182 void CDMSessionAVContentKeySession::releaseKeys()
183 {
184     if (hasContentKeySession()) {
185         m_stopped = true;
186         for (auto& sourceBuffer : m_sourceBuffers)
187             sourceBuffer->flush();
188
189         LOG(Media, "CDMSessionAVContentKeySession::releaseKeys(%p) - expiring stream session", this);
190         [contentKeySession() expire];
191
192         if (!m_certificate)
193             return;
194
195         if (![getAVContentKeySessionClass() respondsToSelector:@selector(pendingExpiredSessionReportsWithAppIdentifier:storageDirectoryAtURL:)])
196             return;
197
198         auto storagePath = this->storagePath();
199         if (storagePath.isEmpty())
200             return;
201
202         RetainPtr<NSData> certificateData = adoptNS([[NSData alloc] initWithBytes:m_certificate->data() length:m_certificate->length()]);
203         NSArray* expiredSessions = [getAVContentKeySessionClass() pendingExpiredSessionReportsWithAppIdentifier:certificateData.get() storageDirectoryAtURL:[NSURL fileURLWithPath:storagePath]];
204         for (NSData* expiredSessionData in expiredSessions) {
205             NSDictionary *expiredSession = [NSPropertyListSerialization propertyListWithData:expiredSessionData options:kCFPropertyListImmutable format:nullptr error:nullptr];
206             NSString *playbackSessionIdValue = (NSString *)[expiredSession objectForKey:PlaybackSessionIdKey];
207             if (![playbackSessionIdValue isKindOfClass:[NSString class]])
208                 continue;
209
210             if (m_sessionId == String(playbackSessionIdValue)) {
211                 LOG(Media, "CDMSessionAVContentKeySession::releaseKeys(%p) - found session, sending expiration message");
212                 m_expiredSession = expiredSessionData;
213                 m_client->sendMessage(Uint8Array::create(static_cast<const uint8_t*>([m_expiredSession bytes]), [m_expiredSession length]).get(), emptyString());
214                 break;
215             }
216         }
217     }
218 }
219
220 static bool isEqual(Uint8Array* data, const char* literal)
221 {
222     ASSERT(data);
223     ASSERT(literal);
224     unsigned length = data->length();
225
226     for (unsigned i = 0; i < length; ++i) {
227         if (!literal[i])
228             return false;
229
230         if (data->item(i) != static_cast<uint8_t>(literal[i]))
231             return false;
232     }
233     return !literal[length];
234 }
235
236 bool CDMSessionAVContentKeySession::update(Uint8Array* key, RefPtr<Uint8Array>& nextMessage, unsigned short& errorCode, uint32_t& systemCode)
237 {
238     UNUSED_PARAM(nextMessage);
239
240     bool shouldGenerateKeyRequest = !m_certificate || isEqual(key, "renew");
241     if (!m_certificate) {
242         LOG(Media, "CDMSessionAVContentKeySession::update(%p) - certificate data", this);
243
244         m_certificate = key;
245     }
246
247     if (isEqual(key, "acknowledged")) {
248         LOG(Media, "CDMSessionAVContentKeySession::update(%p) - acknowleding secure stop message", this);
249
250         String storagePath = this->storagePath();
251         if (!m_expiredSession || storagePath.isEmpty()) {
252             errorCode = MediaPlayer::InvalidPlayerState;
253             return false;
254         }
255
256         RetainPtr<NSData> certificateData = adoptNS([[NSData alloc] initWithBytes:m_certificate->data() length:m_certificate->length()]);
257
258         if ([getAVContentKeySessionClass() respondsToSelector:@selector(removePendingExpiredSessionReports:withAppIdentifier:storageDirectoryAtURL:)])
259             [getAVContentKeySessionClass() removePendingExpiredSessionReports:@[m_expiredSession.get()] withAppIdentifier:certificateData.get() storageDirectoryAtURL:[NSURL fileURLWithPath:storagePath]];
260         m_expiredSession = nullptr;
261         return true;
262     }
263
264     if (m_mode == KeyRelease)
265         return false;
266
267     if (!m_keyRequest) {
268         NSData* nsInitData = [NSData dataWithBytes:m_initData->data() length:m_initData->length()];
269         [contentKeySession() processContentKeyRequestInitializationData:nsInitData options:nil];
270     }
271
272     if (shouldGenerateKeyRequest) {
273         ASSERT(m_keyRequest);
274         RetainPtr<NSData> certificateData = adoptNS([[NSData alloc] initWithBytes:m_certificate->data() length:m_certificate->length()]);
275
276         RetainPtr<NSDictionary> options;
277         if (!m_protocolVersions.isEmpty() && canLoadAVContentKeyRequestProtocolVersionsKey()) {
278             RetainPtr<NSMutableArray> protocolVersionsOption = adoptNS([[NSMutableArray alloc] init]);
279             for (auto& version : m_protocolVersions) {
280                 if (!version)
281                     continue;
282                 [protocolVersionsOption addObject:@(version)];
283             }
284
285             options = @{ getAVContentKeyRequestProtocolVersionsKey(): protocolVersionsOption.get() };
286         }
287
288         errorCode = MediaPlayer::NoError;
289         systemCode = 0;
290         NSError* error = nil;
291         NSData* requestData = [m_keyRequest contentKeyRequestDataForApp:certificateData.get() contentIdentifier:nil options:options.get() error:&error];
292         if (error) {
293             errorCode = CDM::DomainError;
294             systemCode = mediaKeyErrorSystemCode(error);
295             return false;
296         }
297
298         nextMessage = Uint8Array::create(static_cast<const uint8_t*>([requestData bytes]), [requestData length]);
299         return false;
300     }
301
302     LOG(Media, "CDMSessionAVContentKeySession::update(%p) - key data", this);
303     errorCode = MediaPlayer::NoError;
304     systemCode = 0;
305     RetainPtr<NSData> keyData = adoptNS([[NSData alloc] initWithBytes:key->data() length:key->length()]);
306     [m_keyRequest processContentKeyResponseData:keyData.get()];
307
308     return true;
309 }
310
311 void CDMSessionAVContentKeySession::addParser(AVStreamDataParser* parser)
312 {
313     [contentKeySession() addStreamDataParser:parser];
314 }
315
316 void CDMSessionAVContentKeySession::removeParser(AVStreamDataParser* parser)
317 {
318     [contentKeySession() removeStreamDataParser:parser];
319 }
320
321 RefPtr<Uint8Array> CDMSessionAVContentKeySession::generateKeyReleaseMessage(unsigned short& errorCode, uint32_t& systemCode)
322 {
323     ASSERT(m_mode == KeyRelease);
324     m_certificate = m_initData;
325     RetainPtr<NSData> certificateData = adoptNS([[NSData alloc] initWithBytes:m_certificate->data() length:m_certificate->length()]);
326
327     String storagePath = this->storagePath();
328     if (storagePath.isEmpty() || ![getAVContentKeySessionClass() respondsToSelector:@selector(pendingExpiredSessionReportsWithAppIdentifier:storageDirectoryAtURL:)]) {
329         errorCode = MediaPlayer::KeySystemNotSupported;
330         systemCode = '!mor';
331         return nullptr;
332     }
333
334     NSArray* expiredSessions = [getAVContentKeySessionClass() pendingExpiredSessionReportsWithAppIdentifier:certificateData.get() storageDirectoryAtURL:[NSURL fileURLWithPath:storagePath]];
335     if (![expiredSessions count]) {
336         LOG(Media, "CDMSessionAVContentKeySession::generateKeyReleaseMessage(%p) - no expired sessions found", this);
337
338         errorCode = MediaPlayer::KeySystemNotSupported;
339         systemCode = '!mor';
340         return nullptr;
341     }
342
343     LOG(Media, "CDMSessionAVContentKeySession::generateKeyReleaseMessage(%p) - found %d expired sessions", this, [expiredSessions count]);
344
345     errorCode = 0;
346     systemCode = 0;
347     m_expiredSession = [expiredSessions firstObject];
348     return Uint8Array::create(static_cast<const uint8_t*>([m_expiredSession bytes]), [m_expiredSession length]);
349 }
350
351 void CDMSessionAVContentKeySession::didProvideContentKeyRequest(AVContentKeyRequest *keyRequest)
352 {
353     m_keyRequest = keyRequest;
354 }
355
356 AVContentKeySession* CDMSessionAVContentKeySession::contentKeySession()
357 {
358     if (m_contentKeySession)
359         return m_contentKeySession.get();
360
361     String storagePath = this->storagePath();
362     if (storagePath.isEmpty()) {
363         if (![getAVContentKeySessionClass() respondsToSelector:@selector(contentKeySessionWithKeySystem:)] || !canLoadAVContentKeySystemFairPlayStreaming())
364             return nil;
365
366         m_contentKeySession = [getAVContentKeySessionClass() contentKeySessionWithKeySystem:getAVContentKeySystemFairPlayStreaming()];
367     } else {
368         String storageDirectory = directoryName(storagePath);
369
370         if (!fileExists(storageDirectory)) {
371             if (!makeAllDirectories(storageDirectory))
372                 return nil;
373         }
374
375         m_contentKeySession = adoptNS([allocAVContentKeySessionInstance() initWithStorageDirectoryAtURL:[NSURL fileURLWithPath:storagePath]]);
376     }
377
378     m_contentKeySession.get().delegate = m_contentKeySessionDelegate.get();
379     return m_contentKeySession.get();
380 }
381
382 }
383
384 #endif