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#ifndef CLEARKEY_DRM_PLUGIN_H_
18#define CLEARKEY_DRM_PLUGIN_H_
19
20#include <media/drm/DrmAPI.h>
21#include <media/stagefright/foundation/ABase.h>
22#include <media/stagefright/MediaErrors.h>
23#include <utils/Errors.h>
24#include <utils/KeyedVector.h>
25#include <utils/List.h>
26#include <utils/String8.h>
27#include <utils/Vector.h>
28
29#include "SessionLibrary.h"
30#include "Utils.h"
31
32namespace clearkeydrm {
33
34using android::KeyedVector;
35using android::List;
36using android::status_t;
37using android::String8;
38using android::Vector;
39
40class DrmPlugin : public android::DrmPlugin {
41public:
42    explicit DrmPlugin(SessionLibrary* sessionLibrary)
43            : mSessionLibrary(sessionLibrary) {}
44    virtual ~DrmPlugin() {}
45
46    virtual status_t openSession(Vector<uint8_t>& sessionId);
47
48    virtual status_t closeSession(const Vector<uint8_t>& sessionId);
49
50    virtual status_t getKeyRequest(
51            const Vector<uint8_t>& scope,
52            const Vector<uint8_t>& mimeType,
53            const String8& initDataType,
54            KeyType keyType,
55            const KeyedVector<String8, String8>& optionalParameters,
56            Vector<uint8_t>& request,
57            String8& defaultUrl,
58            DrmPlugin::KeyRequestType *keyRequestType);
59
60    virtual status_t provideKeyResponse(
61            const Vector<uint8_t>& scope,
62            const Vector<uint8_t>& response,
63            Vector<uint8_t>& keySetId);
64
65    virtual status_t removeKeys(const Vector<uint8_t>& sessionId) {
66        if (sessionId.size() == 0) {
67            return android::BAD_VALUE;
68        }
69
70        return android::ERROR_DRM_CANNOT_HANDLE;
71    }
72
73    virtual status_t restoreKeys(
74            const Vector<uint8_t>& sessionId,
75            const Vector<uint8_t>& keySetId) {
76        if (sessionId.size() == 0 || keySetId.size() == 0) {
77            return android::BAD_VALUE;
78        }
79        return android::ERROR_DRM_CANNOT_HANDLE;
80    }
81
82    virtual status_t queryKeyStatus(
83            const Vector<uint8_t>& sessionId,
84            KeyedVector<String8, String8>& infoMap) const {
85        if (sessionId.size() == 0) {
86            return android::BAD_VALUE;
87        }
88        UNUSED(infoMap);
89        return android::ERROR_DRM_CANNOT_HANDLE;
90    }
91
92    virtual status_t getProvisionRequest(
93            const String8& cert_type,
94            const String8& cert_authority,
95            Vector<uint8_t>& request,
96            String8& defaultUrl) {
97        UNUSED(cert_type);
98        UNUSED(cert_authority);
99        UNUSED(request);
100        UNUSED(defaultUrl);
101        return android::ERROR_DRM_CANNOT_HANDLE;
102    }
103
104    virtual status_t provideProvisionResponse(
105            const Vector<uint8_t>& response,
106            Vector<uint8_t>& certificate,
107            Vector<uint8_t>& wrappedKey) {
108        UNUSED(certificate);
109        UNUSED(wrappedKey);
110        if (response.size() == 0) {
111            // empty response
112            return android::BAD_VALUE;
113        }
114        return android::ERROR_DRM_CANNOT_HANDLE;
115    }
116
117    virtual status_t getSecureStops(List<Vector<uint8_t> >& secureStops) {
118        UNUSED(secureStops);
119        return android::ERROR_DRM_CANNOT_HANDLE;
120    }
121
122    virtual status_t getSecureStop(Vector<uint8_t> const &ssid, Vector<uint8_t> &secureStop) {
123        if (ssid.size() == 0) {
124            return android::BAD_VALUE;
125        }
126
127        UNUSED(secureStop);
128        return android::ERROR_DRM_CANNOT_HANDLE;
129    }
130
131    virtual status_t releaseSecureStops(const Vector<uint8_t>& ssRelease) {
132        if (ssRelease.size() == 0) {
133            return android::BAD_VALUE;
134        }
135        return android::ERROR_DRM_CANNOT_HANDLE;
136    }
137
138    virtual status_t releaseAllSecureStops() {
139        return android::ERROR_DRM_CANNOT_HANDLE;
140    }
141
142    virtual status_t getPropertyString(
143            const String8& name, String8& value) const;
144
145    virtual status_t getPropertyByteArray(
146            const String8& name, Vector<uint8_t>& value) const {
147        UNUSED(name);
148        UNUSED(value);
149        return android::ERROR_DRM_CANNOT_HANDLE;
150    }
151
152    virtual status_t setPropertyString(
153            const String8& name, const String8& value) {
154        UNUSED(name);
155        UNUSED(value);
156        return android::ERROR_DRM_CANNOT_HANDLE;
157    }
158
159    virtual status_t setPropertyByteArray(
160            const String8& name, const Vector<uint8_t>& value) {
161        UNUSED(name);
162        UNUSED(value);
163        return android::ERROR_DRM_CANNOT_HANDLE;
164    }
165
166    virtual status_t setCipherAlgorithm(
167            const Vector<uint8_t>& sessionId, const String8& algorithm) {
168        if (sessionId.size() == 0 || algorithm.size() == 0) {
169            return android::BAD_VALUE;
170        }
171        return android::ERROR_DRM_CANNOT_HANDLE;
172    }
173
174    virtual status_t setMacAlgorithm(
175            const Vector<uint8_t>& sessionId, const String8& algorithm) {
176        if (sessionId.size() == 0 || algorithm.size() == 0) {
177            return android::BAD_VALUE;
178        }
179        return android::ERROR_DRM_CANNOT_HANDLE;
180    }
181
182    virtual status_t encrypt(
183            const Vector<uint8_t>& sessionId,
184            const Vector<uint8_t>& keyId,
185            const Vector<uint8_t>& input,
186            const Vector<uint8_t>& iv,
187            Vector<uint8_t>& output) {
188        if (sessionId.size() == 0 || keyId.size() == 0 ||
189                input.size() == 0 || iv.size() == 0) {
190            return android::BAD_VALUE;
191        }
192        UNUSED(output);
193        return android::ERROR_DRM_CANNOT_HANDLE;
194    }
195
196    virtual status_t decrypt(
197            const Vector<uint8_t>& sessionId,
198            const Vector<uint8_t>& keyId,
199            const Vector<uint8_t>& input,
200            const Vector<uint8_t>& iv,
201            Vector<uint8_t>& output) {
202        if (sessionId.size() == 0 || keyId.size() == 0 ||
203                input.size() == 0 || iv.size() == 0) {
204            return android::BAD_VALUE;
205        }
206        UNUSED(output);
207        return android::ERROR_DRM_CANNOT_HANDLE;
208    }
209
210    virtual status_t sign(
211            const Vector<uint8_t>& sessionId,
212            const Vector<uint8_t>& keyId,
213            const Vector<uint8_t>& message,
214            Vector<uint8_t>& signature) {
215        if (sessionId.size() == 0 || keyId.size() == 0 ||
216                message.size() == 0) {
217            return android::BAD_VALUE;
218        }
219        UNUSED(signature);
220        return android::ERROR_DRM_CANNOT_HANDLE;
221    }
222
223    virtual status_t verify(
224            const Vector<uint8_t>& sessionId,
225            const Vector<uint8_t>& keyId,
226            const Vector<uint8_t>& message,
227            const Vector<uint8_t>& signature, bool& match) {
228        if (sessionId.size() == 0 || keyId.size() == 0 ||
229                message.size() == 0 || signature.size() == 0) {
230            return android::BAD_VALUE;
231        }
232        UNUSED(match);
233        return android::ERROR_DRM_CANNOT_HANDLE;
234    }
235
236    virtual status_t signRSA(
237            const Vector<uint8_t>& sessionId,
238            const String8& algorithm,
239            const Vector<uint8_t>& message,
240            const Vector<uint8_t>& wrappedKey,
241            Vector<uint8_t>& signature) {
242        if (sessionId.size() == 0 || algorithm.size() == 0 ||
243                message.size() == 0 || wrappedKey.size() == 0) {
244            return android::BAD_VALUE;
245        }
246        UNUSED(signature);
247        return android::ERROR_DRM_CANNOT_HANDLE;
248    }
249
250private:
251    DISALLOW_EVIL_CONSTRUCTORS(DrmPlugin);
252
253    SessionLibrary* mSessionLibrary;
254};
255
256} // namespace clearkeydrm
257
258#endif // CLEARKEY_DRM_PLUGIN_H_
259