InitDataParser.cpp revision 6b3c1473199927264691bb50445cf0b35c2f8892 
1/*
2 * Copyright (C) 2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17//#define LOG_NDEBUG 0
18#define LOG_TAG "ClearKeyCryptoPlugin"
19#include <utils/Log.h>
20
21#include <endian.h>
22#include <media/stagefright/foundation/AString.h>
23#include <media/stagefright/foundation/base64.h>
24#include <media/stagefright/MediaErrors.h>
25#include <string.h>
26
27#include "InitDataParser.h"
28
29#include "ClearKeyUUID.h"
30#include "Utils.h"
31
32namespace clearkeydrm {
33
34using android::AString;
35using android::String8;
36using android::Vector;
37
38namespace {
39    const size_t kKeyIdSize = 16;
40    const size_t kSystemIdSize = 16;
41}
42
43android::status_t InitDataParser::parse(const Vector<uint8_t>& initData,
44        const String8& initDataType,
45        Vector<uint8_t>* licenseRequest) {
46    // Build a list of the key IDs
47    Vector<const uint8_t*> keyIds;
48    if (initDataType == "cenc") {
49        android::status_t res = parsePssh(initData, &keyIds);
50        if (res != android::OK) {
51            return res;
52        }
53    } else if (initDataType == "webm") {
54        // WebM "init data" is just a single key ID
55        if (initData.size() != kKeyIdSize) {
56            return android::ERROR_DRM_CANNOT_HANDLE;
57        }
58        keyIds.push(initData.array());
59    } else {
60        return android::ERROR_DRM_CANNOT_HANDLE;
61    }
62
63    // Build the request
64    String8 requestJson = generateRequest(keyIds);
65    licenseRequest->clear();
66    licenseRequest->appendArray(
67            reinterpret_cast<const uint8_t*>(requestJson.string()),
68            requestJson.size());
69    return android::OK;
70}
71
72android::status_t InitDataParser::parsePssh(const Vector<uint8_t>& initData,
73        Vector<const uint8_t*>* keyIds) {
74    size_t readPosition = 0;
75
76    // Validate size field
77    uint32_t expectedSize = initData.size();
78    expectedSize = htonl(expectedSize);
79    if (memcmp(&initData[readPosition], &expectedSize,
80               sizeof(expectedSize)) != 0) {
81        return android::ERROR_DRM_CANNOT_HANDLE;
82    }
83    readPosition += sizeof(expectedSize);
84
85    // Validate PSSH box identifier
86    const char psshIdentifier[4] = {'p', 's', 's', 'h'};
87    if (memcmp(&initData[readPosition], psshIdentifier,
88               sizeof(psshIdentifier)) != 0) {
89        return android::ERROR_DRM_CANNOT_HANDLE;
90    }
91    readPosition += sizeof(psshIdentifier);
92
93    // Validate EME version number
94    const uint8_t psshVersion1[4] = {1, 0, 0, 0};
95    if (memcmp(&initData[readPosition], psshVersion1,
96               sizeof(psshVersion1)) != 0) {
97        return android::ERROR_DRM_CANNOT_HANDLE;
98    }
99    readPosition += sizeof(psshVersion1);
100
101    // Validate system ID
102    if (!isClearKeyUUID(&initData[readPosition])) {
103        return android::ERROR_DRM_CANNOT_HANDLE;
104    }
105    readPosition += kSystemIdSize;
106
107    // Read key ID count
108    uint32_t keyIdCount;
109    memcpy(&keyIdCount, &initData[readPosition], sizeof(keyIdCount));
110    keyIdCount = ntohl(keyIdCount);
111    readPosition += sizeof(keyIdCount);
112    if (readPosition + (keyIdCount * kKeyIdSize) !=
113            initData.size() - sizeof(uint32_t)) {
114        return android::ERROR_DRM_CANNOT_HANDLE;
115    }
116
117    // Calculate the key ID offsets
118    for (uint32_t i = 0; i < keyIdCount; ++i) {
119        size_t keyIdPosition = readPosition + (i * kKeyIdSize);
120        keyIds->push(&initData[keyIdPosition]);
121    }
122    return android::OK;
123}
124
125String8 InitDataParser::generateRequest(const Vector<const uint8_t*>& keyIds) {
126    const String8 kRequestPrefix("{\"kids\":[");
127    const String8 kRequestSuffix("],\"type\":\"temporary\"}");
128    const String8 kBase64Padding("=");
129
130    String8 request(kRequestPrefix);
131    AString encodedId;
132    for (size_t i = 0; i < keyIds.size(); ++i) {
133        encodedId.clear();
134        android::encodeBase64(keyIds[i], kKeyIdSize, &encodedId);
135        if (i != 0) {
136            request.append(",");
137        }
138        request.appendFormat("\"%s\"", encodedId.c_str());
139    }
140    request.append(kRequestSuffix);
141
142    // Android's Base64 encoder produces padding. EME forbids padding.
143    request.removeAll(kBase64Padding);
144    return request;
145}
146
147} // namespace clearkeydrm
148