5513f3dff5bbcbd3ae95d927751bd1a4a347537d
[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 "LegacyCDM.h"
32 #import "CDMPrivateMediaSourceAVFObjC.h"
33 #import "FileSystem.h"
34 #import "Logging.h"
35 #import "MediaPlayer.h"
36 #import "SoftLinking.h"
37 #import "SourceBufferPrivateAVFObjC.h"
38 #import "WebCoreNSErrorExtras.h"
39 #import <AVFoundation/AVError.h>
40 #import <CoreMedia/CMBase.h>
41 #import <objc/objc-runtime.h>
42 #import <runtime/TypedArrayInlines.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
49 @interface AVContentKeySession : NSObject
50 - (instancetype)initWithStorageDirectoryAtURL:(NSURL *)storageURL;
51 @property (assign) id delegate;
52 - (void)addStreamDataParser:(AVStreamDataParser *)streamDataParser;
53 - (void)removeStreamDataParser:(AVStreamDataParser *)streamDataParser;
54 @property (readonly) NSArray *streamDataParsers;
55 - (void)expire;
56 @property (readonly) NSData *contentProtectionSessionIdentifier;
57 - (void)processContentKeyRequestInitializationData:(NSData *)initializationData options:(NSDictionary *)options;
58 + (NSArray *)pendingExpiredSessionReportsWithAppIdentifier:(NSData *)appIdentifier storageDirectoryAtURL:(NSURL *)storageURL;
59 + (void)removePendingExpiredSessionReports:(NSArray *)expiredSessionReports withAppIdentifier:(NSData *)appIdentifier storageDirectoryAtURL:(NSURL *)storageURL;
60 @end
61
62 typedef NS_ENUM(NSInteger, AVContentKeyRequestStatus) {
63     AVContentKeySessionStatusNoKey,
64     AVContentKeySessionStatusRequestingKey,
65     AVContentKeySessionStatusKeyPresent,
66     AVContentKeySessionStatusExpired,
67     AVContentKeySessionStatusFailed
68 };
69
70 @interface AVContentKeyRequest : NSObject
71 @property (readonly) AVContentKeyRequestStatus status;
72 @property (readonly) NSError *error;
73 @property (readonly) NSData *initializationData;
74 - (NSData *)contentKeyRequestDataForApp:(NSData *)appIdentifier contentIdentifier:(NSData *)contentIdentifier options:(NSDictionary *)options error:(NSError **)outError;
75 - (void)processContentKeyResponseData:(NSData *)contentKeyResponseData;
76 - (void)processContentKeyResponseError:(NSError *)error;
77 - (void)renewExpiringContentKeyResponseData;
78 @end
79
80 @interface WebCDMSessionAVContentKeySessionDelegate : NSObject {
81     WebCore::CDMSessionAVContentKeySession *m_parent;
82 }
83 - (void)invalidate;
84 @end
85
86 @implementation WebCDMSessionAVContentKeySessionDelegate
87 - (id)initWithParent:(WebCore::CDMSessionAVContentKeySession *)parent
88 {
89     if ((self = [super init]))
90         m_parent = parent;
91     return self;
92 }
93
94
95 - (void)invalidate
96 {
97     m_parent = nullptr;
98 }
99
100 - (void)contentKeySession:(AVContentKeySession *)session didProvideContentKeyRequest:(AVContentKeyRequest *)keyRequest
101 {
102     UNUSED_PARAM(session);
103
104     if (m_parent)
105         m_parent->didProvideContentKeyRequest(keyRequest);
106 }
107
108 - (void)contentKeySessionContentProtectionSessionIdentifierDidChange:(AVContentKeySession *)session
109 {
110     if (!m_parent)
111         return;
112
113     NSData* identifier = [session contentProtectionSessionIdentifier];
114     RetainPtr<NSString> sessionIdentifierString = identifier ? adoptNS([[NSString alloc] initWithData:identifier encoding:NSUTF8StringEncoding]) : nil;
115     m_parent->setSessionId(sessionIdentifierString.get());
116 }
117 @end
118
119 static const NSString *PlaybackSessionIdKey = @"PlaybackSessionID";
120
121 namespace WebCore {
122
123 CDMSessionAVContentKeySession::CDMSessionAVContentKeySession(const Vector<int>& protocolVersions, CDMPrivateMediaSourceAVFObjC& cdm, CDMSessionClient* client)
124     : CDMSessionMediaSourceAVFObjC(cdm, client)
125     , m_contentKeySessionDelegate(adoptNS([[WebCDMSessionAVContentKeySessionDelegate alloc] initWithParent:this]))
126     , m_protocolVersions(protocolVersions)
127     , m_mode(Normal)
128 {
129 }
130
131 CDMSessionAVContentKeySession::~CDMSessionAVContentKeySession()
132 {
133     [m_contentKeySessionDelegate invalidate];
134
135     for (auto& sourceBuffer : m_sourceBuffers)
136         removeParser(sourceBuffer->parser());
137 }
138
139 bool CDMSessionAVContentKeySession::isAvailable()
140 {
141     return getAVContentKeySessionClass();
142 }
143
144 RefPtr<Uint8Array> CDMSessionAVContentKeySession::generateKeyRequest(const String& mimeType, Uint8Array* initData, String& destinationURL, unsigned short& errorCode, uint32_t& systemCode)
145 {
146     UNUSED_PARAM(mimeType);
147     UNUSED_PARAM(destinationURL);
148     ASSERT(initData);
149
150     LOG(Media, "CDMSessionAVContentKeySession::generateKeyRequest(%p)", this);
151
152     errorCode = MediaPlayer::NoError;
153     systemCode = 0;
154
155     m_initData = initData;
156
157     if (equalLettersIgnoringASCIICase(mimeType, "keyrelease")) {
158         m_mode = KeyRelease;
159         return generateKeyReleaseMessage(errorCode, systemCode);
160     }
161
162     if (!m_certificate) {
163         String certificateString(ASCIILiteral("certificate"));
164         RefPtr<Uint8Array> array = Uint8Array::create(certificateString.length());
165         for (unsigned i = 0, length = certificateString.length(); i < length; ++i)
166             array->set(i, certificateString[i]);
167         return array;
168     }
169
170     if (!m_keyRequest) {
171         NSData* nsInitData = [NSData dataWithBytes:m_initData->data() length:m_initData->length()];
172         [contentKeySession() processContentKeyRequestInitializationData:nsInitData options:nil];
173     }
174
175     return nullptr;
176 }
177
178 void CDMSessionAVContentKeySession::releaseKeys()
179 {
180     if (hasContentKeySession()) {
181         m_stopped = true;
182         for (auto& sourceBuffer : m_sourceBuffers)
183             sourceBuffer->flush();
184
185         LOG(Media, "CDMSessionAVContentKeySession::releaseKeys(%p) - expiring stream session", this);
186         [contentKeySession() expire];
187
188         if (!m_certificate)
189             return;
190
191         if (![getAVContentKeySessionClass() respondsToSelector:@selector(pendingExpiredSessionReportsWithAppIdentifier:storageDirectoryAtURL:)])
192             return;
193
194         RetainPtr<NSData> certificateData = adoptNS([[NSData alloc] initWithBytes:m_certificate->data() length:m_certificate->length()]);
195         NSArray* expiredSessions = [getAVContentKeySessionClass() pendingExpiredSessionReportsWithAppIdentifier:certificateData.get() storageDirectoryAtURL:[NSURL fileURLWithPath:storagePath()]];
196         for (NSData* expiredSessionData in expiredSessions) {
197             NSDictionary *expiredSession = [NSPropertyListSerialization propertyListWithData:expiredSessionData options:kCFPropertyListImmutable format:nullptr error:nullptr];
198             NSString *playbackSessionIdValue = (NSString *)[expiredSession objectForKey:PlaybackSessionIdKey];
199             if (![playbackSessionIdValue isKindOfClass:[NSString class]])
200                 continue;
201
202             if (m_sessionId == String(playbackSessionIdValue)) {
203                 LOG(Media, "CDMSessionAVContentKeySession::releaseKeys(%p) - found session, sending expiration message");
204                 m_expiredSession = expiredSessionData;
205                 m_client->sendMessage(Uint8Array::create(static_cast<const uint8_t*>([m_expiredSession bytes]), [m_expiredSession length]).get(), emptyString());
206                 break;
207             }
208         }
209     }
210 }
211
212 static bool isEqual(Uint8Array* data, const char* literal)
213 {
214     ASSERT(data);
215     ASSERT(literal);
216     unsigned length = data->length();
217
218     for (unsigned i = 0; i < length; ++i) {
219         if (!literal[i])
220             return false;
221
222         if (data->item(i) != static_cast<uint8_t>(literal[i]))
223             return false;
224     }
225     return !literal[length];
226 }
227
228 bool CDMSessionAVContentKeySession::update(Uint8Array* key, RefPtr<Uint8Array>& nextMessage, unsigned short& errorCode, uint32_t& systemCode)
229 {
230     UNUSED_PARAM(nextMessage);
231
232     bool shouldGenerateKeyRequest = !m_certificate || isEqual(key, "renew");
233     if (!m_certificate) {
234         LOG(Media, "CDMSessionAVContentKeySession::update(%p) - certificate data", this);
235
236         m_certificate = key;
237     }
238
239     if (isEqual(key, "acknowledged")) {
240         LOG(Media, "CDMSessionAVContentKeySession::update(%p) - acknowleding secure stop message", this);
241
242         if (!m_expiredSession) {
243             errorCode = MediaPlayer::InvalidPlayerState;
244             return false;
245         }
246
247         RetainPtr<NSData> certificateData = adoptNS([[NSData alloc] initWithBytes:m_certificate->data() length:m_certificate->length()]);
248
249         if ([getAVContentKeySessionClass() respondsToSelector:@selector(removePendingExpiredSessionReports:withAppIdentifier:storageDirectoryAtURL:)])
250             [getAVContentKeySessionClass() removePendingExpiredSessionReports:@[m_expiredSession.get()] withAppIdentifier:certificateData.get() storageDirectoryAtURL:[NSURL fileURLWithPath:storagePath()]];
251         m_expiredSession = nullptr;
252         return true;
253     }
254
255     if (m_mode == KeyRelease)
256         return false;
257
258     if (!m_keyRequest) {
259         NSData* nsInitData = [NSData dataWithBytes:m_initData->data() length:m_initData->length()];
260         [contentKeySession() processContentKeyRequestInitializationData:nsInitData options:nil];
261     }
262
263     if (shouldGenerateKeyRequest) {
264         ASSERT(m_keyRequest);
265         RetainPtr<NSData> certificateData = adoptNS([[NSData alloc] initWithBytes:m_certificate->data() length:m_certificate->length()]);
266
267         RetainPtr<NSDictionary> options;
268         if (!m_protocolVersions.isEmpty() && canLoadAVContentKeyRequestProtocolVersionsKey()) {
269             RetainPtr<NSMutableArray> protocolVersionsOption = adoptNS([[NSMutableArray alloc] init]);
270             for (auto& version : m_protocolVersions) {
271                 if (!version)
272                     continue;
273                 [protocolVersionsOption addObject:@(version)];
274             }
275
276             options = @{ getAVContentKeyRequestProtocolVersionsKey(): protocolVersionsOption.get() };
277         }
278
279         errorCode = MediaPlayer::NoError;
280         systemCode = 0;
281         NSError* error = nil;
282         NSData* requestData = [m_keyRequest contentKeyRequestDataForApp:certificateData.get() contentIdentifier:nil options:options.get() error:&error];
283         if (error) {
284             errorCode = CDM::DomainError;
285             systemCode = mediaKeyErrorSystemCode(error);
286             return false;
287         }
288
289         nextMessage = Uint8Array::create(static_cast<const uint8_t*>([requestData bytes]), [requestData length]);
290         return false;
291     }
292
293     LOG(Media, "CDMSessionAVContentKeySession::update(%p) - key data", this);
294     errorCode = MediaPlayer::NoError;
295     systemCode = 0;
296     RetainPtr<NSData> keyData = adoptNS([[NSData alloc] initWithBytes:key->data() length:key->length()]);
297     [m_keyRequest processContentKeyResponseData:keyData.get()];
298
299     return true;
300 }
301
302 void CDMSessionAVContentKeySession::addParser(AVStreamDataParser* parser)
303 {
304     [contentKeySession() addStreamDataParser:parser];
305 }
306
307 void CDMSessionAVContentKeySession::removeParser(AVStreamDataParser* parser)
308 {
309     [contentKeySession() removeStreamDataParser:parser];
310 }
311
312 PassRefPtr<Uint8Array> CDMSessionAVContentKeySession::generateKeyReleaseMessage(unsigned short& errorCode, uint32_t& systemCode)
313 {
314     ASSERT(m_mode == KeyRelease);
315     m_certificate = m_initData;
316     RetainPtr<NSData> certificateData = adoptNS([[NSData alloc] initWithBytes:m_certificate->data() length:m_certificate->length()]);
317
318     if (![getAVContentKeySessionClass() respondsToSelector:@selector(pendingExpiredSessionReportsWithAppIdentifier:storageDirectoryAtURL:)]) {
319         errorCode = MediaPlayer::KeySystemNotSupported;
320         systemCode = '!mor';
321         return nullptr;
322     }
323
324     NSArray* expiredSessions = [getAVContentKeySessionClass() pendingExpiredSessionReportsWithAppIdentifier:certificateData.get() storageDirectoryAtURL:[NSURL fileURLWithPath:storagePath()]];
325     if (![expiredSessions count]) {
326         LOG(Media, "CDMSessionAVContentKeySession::generateKeyReleaseMessage(%p) - no expired sessions found", this);
327
328         errorCode = MediaPlayer::KeySystemNotSupported;
329         systemCode = '!mor';
330         return nullptr;
331     }
332
333     LOG(Media, "CDMSessionAVContentKeySession::generateKeyReleaseMessage(%p) - found %d expired sessions", this, [expiredSessions count]);
334
335     errorCode = 0;
336     systemCode = 0;
337     m_expiredSession = [expiredSessions firstObject];
338     return Uint8Array::create(static_cast<const uint8_t*>([m_expiredSession bytes]), [m_expiredSession length]);
339 }
340
341 void CDMSessionAVContentKeySession::didProvideContentKeyRequest(AVContentKeyRequest *keyRequest)
342 {
343     m_keyRequest = keyRequest;
344 }
345
346 AVContentKeySession* CDMSessionAVContentKeySession::contentKeySession()
347 {
348     if (!m_contentKeySession) {
349
350         String storagePath = this->storagePath();
351         if (storagePath.isEmpty())
352             return nil;
353
354         String storageDirectory = directoryName(storagePath);
355
356         if (!fileExists(storageDirectory)) {
357             if (!makeAllDirectories(storageDirectory))
358                 return nil;
359         }
360
361         m_contentKeySession = adoptNS([allocAVContentKeySessionInstance() initWithStorageDirectoryAtURL:[NSURL fileURLWithPath:storagePath]]);
362         m_contentKeySession.get().delegate = m_contentKeySessionDelegate.get();
363     }
364
365     return m_contentKeySession.get();
366 }
367
368 }
369
370 #endif