IKeystoreService.cpp revision 0ebf13dbf975028735a8afc42e39c6ea47cec704 
1/*
2**
3** Copyright 2008, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9**     http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18#include <stdint.h>
19#include <sys/limits.h>
20#include <sys/types.h>
21
22#define LOG_TAG "KeystoreService"
23#include <utils/Log.h>
24
25#include <binder/Parcel.h>
26#include <binder/IPCThreadState.h>
27#include <binder/IServiceManager.h>
28
29#include <keystore/IKeystoreService.h>
30
31namespace android {
32
33const ssize_t MAX_GENERATE_ARGS = 3;
34static keymaster_key_param_t* readParamList(const Parcel& in, size_t* length);
35
36KeystoreArg::KeystoreArg(const void* data, size_t len)
37    : mData(data), mSize(len) {
38}
39
40KeystoreArg::~KeystoreArg() {
41}
42
43const void *KeystoreArg::data() const {
44    return mData;
45}
46
47size_t KeystoreArg::size() const {
48    return mSize;
49}
50
51OperationResult::OperationResult() : resultCode(0), token(), handle(0), inputConsumed(0),
52    data(NULL), dataLength(0) {
53}
54
55OperationResult::~OperationResult() {
56}
57
58void OperationResult::readFromParcel(const Parcel& in) {
59    resultCode = in.readInt32();
60    token = in.readStrongBinder();
61    handle = static_cast<keymaster_operation_handle_t>(in.readInt64());
62    inputConsumed = in.readInt32();
63    ssize_t length = in.readInt32();
64    dataLength = 0;
65    if (length > 0) {
66        const void* buf = in.readInplace(length);
67        if (buf) {
68            data.reset(reinterpret_cast<uint8_t*>(malloc(length)));
69            if (data.get()) {
70                memcpy(data.get(), buf, length);
71                dataLength = (size_t) length;
72            } else {
73                ALOGE("Failed to allocate OperationResult buffer");
74            }
75        } else {
76            ALOGE("Failed to readInplace OperationResult data");
77        }
78    }
79    outParams.readFromParcel(in);
80}
81
82void OperationResult::writeToParcel(Parcel* out) const {
83    out->writeInt32(resultCode);
84    out->writeStrongBinder(token);
85    out->writeInt64(handle);
86    out->writeInt32(inputConsumed);
87    out->writeInt32(dataLength);
88    if (dataLength && data) {
89        void* buf = out->writeInplace(dataLength);
90        if (buf) {
91            memcpy(buf, data.get(), dataLength);
92        } else {
93            ALOGE("Failed to writeInplace OperationResult data.");
94        }
95    }
96    outParams.writeToParcel(out);
97}
98
99ExportResult::ExportResult() : resultCode(0), exportData(NULL), dataLength(0) {
100}
101
102ExportResult::~ExportResult() {
103}
104
105void ExportResult::readFromParcel(const Parcel& in) {
106    resultCode = in.readInt32();
107    ssize_t length = in.readInt32();
108    dataLength = 0;
109    if (length > 0) {
110        const void* buf = in.readInplace(length);
111        if (buf) {
112            exportData.reset(reinterpret_cast<uint8_t*>(malloc(length)));
113            if (exportData.get()) {
114                memcpy(exportData.get(), buf, length);
115                dataLength = (size_t) length;
116            } else {
117                ALOGE("Failed to allocate ExportData buffer");
118            }
119        } else {
120            ALOGE("Failed to readInplace ExportData data");
121        }
122    }
123}
124
125void ExportResult::writeToParcel(Parcel* out) const {
126    out->writeInt32(resultCode);
127    out->writeInt32(dataLength);
128    if (exportData && dataLength) {
129        void* buf = out->writeInplace(dataLength);
130        if (buf) {
131            memcpy(buf, exportData.get(), dataLength);
132        } else {
133            ALOGE("Failed to writeInplace ExportResult data.");
134        }
135    }
136}
137
138KeymasterArguments::KeymasterArguments() {
139}
140
141KeymasterArguments::~KeymasterArguments() {
142    keymaster_free_param_values(params.data(), params.size());
143}
144
145void KeymasterArguments::readFromParcel(const Parcel& in) {
146    ssize_t length = in.readInt32();
147    size_t ulength = (size_t) length;
148    if (length < 0) {
149        ulength = 0;
150    }
151    keymaster_free_param_values(params.data(), params.size());
152    params.clear();
153    for(size_t i = 0; i < ulength; i++) {
154        keymaster_key_param_t param;
155        if (!readKeymasterArgumentFromParcel(in, &param)) {
156            ALOGE("Error reading keymaster argument from parcel");
157            break;
158        }
159        params.push_back(param);
160    }
161}
162
163void KeymasterArguments::writeToParcel(Parcel* out) const {
164    out->writeInt32(params.size());
165    for (auto param : params) {
166        out->writeInt32(1);
167        writeKeymasterArgumentToParcel(param, out);
168    }
169}
170
171KeyCharacteristics::KeyCharacteristics() {
172    memset((void*) &characteristics, 0, sizeof(characteristics));
173}
174
175KeyCharacteristics::~KeyCharacteristics() {
176    keymaster_free_characteristics(&characteristics);
177}
178
179void KeyCharacteristics::readFromParcel(const Parcel& in) {
180    size_t length = 0;
181    keymaster_key_param_t* params = readParamList(in, &length);
182    characteristics.sw_enforced.params = params;
183    characteristics.sw_enforced.length = length;
184
185    params = readParamList(in, &length);
186    characteristics.hw_enforced.params = params;
187    characteristics.hw_enforced.length = length;
188}
189
190void KeyCharacteristics::writeToParcel(Parcel* out) const {
191    if (characteristics.sw_enforced.params) {
192        out->writeInt32(characteristics.sw_enforced.length);
193        for (size_t i = 0; i < characteristics.sw_enforced.length; i++) {
194            out->writeInt32(1);
195            writeKeymasterArgumentToParcel(characteristics.sw_enforced.params[i], out);
196        }
197    } else {
198        out->writeInt32(0);
199    }
200    if (characteristics.hw_enforced.params) {
201        out->writeInt32(characteristics.hw_enforced.length);
202        for (size_t i = 0; i < characteristics.hw_enforced.length; i++) {
203            out->writeInt32(1);
204            writeKeymasterArgumentToParcel(characteristics.hw_enforced.params[i], out);
205        }
206    } else {
207        out->writeInt32(0);
208    }
209}
210
211void writeKeymasterArgumentToParcel(const keymaster_key_param_t& param, Parcel* out) {
212    switch (keymaster_tag_get_type(param.tag)) {
213        case KM_ENUM:
214        case KM_ENUM_REP: {
215            out->writeInt32(param.tag);
216            out->writeInt32(param.enumerated);
217            break;
218        }
219        case KM_UINT:
220        case KM_UINT_REP: {
221            out->writeInt32(param.tag);
222            out->writeInt32(param.integer);
223            break;
224        }
225        case KM_ULONG:
226        case KM_ULONG_REP: {
227            out->writeInt32(param.tag);
228            out->writeInt64(param.long_integer);
229            break;
230        }
231        case KM_DATE: {
232            out->writeInt32(param.tag);
233            out->writeInt64(param.date_time);
234            break;
235        }
236        case KM_BOOL: {
237            out->writeInt32(param.tag);
238            break;
239        }
240        case KM_BIGNUM:
241        case KM_BYTES: {
242            out->writeInt32(param.tag);
243            out->writeInt32(param.blob.data_length);
244            void* buf = out->writeInplace(param.blob.data_length);
245            if (buf) {
246                memcpy(buf, param.blob.data, param.blob.data_length);
247            } else {
248                ALOGE("Failed to writeInplace keymaster blob param");
249            }
250            break;
251        }
252        default: {
253            ALOGE("Failed to write argument: Unsupported keymaster_tag_t %d", param.tag);
254        }
255    }
256}
257
258
259bool readKeymasterArgumentFromParcel(const Parcel& in, keymaster_key_param_t* out) {
260    if (in.readInt32() == 0) {
261        return false;
262    }
263    keymaster_tag_t tag = static_cast<keymaster_tag_t>(in.readInt32());
264    switch (keymaster_tag_get_type(tag)) {
265        case KM_ENUM:
266        case KM_ENUM_REP: {
267            uint32_t value = in.readInt32();
268            *out = keymaster_param_enum(tag, value);
269            break;
270        }
271        case KM_UINT:
272        case KM_UINT_REP: {
273            uint32_t value = in.readInt32();
274            *out = keymaster_param_int(tag, value);
275            break;
276        }
277        case KM_ULONG:
278        case KM_ULONG_REP: {
279            uint64_t value = in.readInt64();
280            *out = keymaster_param_long(tag, value);
281            break;
282        }
283        case KM_DATE: {
284            uint64_t value = in.readInt64();
285            *out = keymaster_param_date(tag, value);
286            break;
287        }
288        case KM_BOOL: {
289            *out = keymaster_param_bool(tag);
290            break;
291        }
292        case KM_BIGNUM:
293        case KM_BYTES: {
294            ssize_t length = in.readInt32();
295            uint8_t* data = NULL;
296            size_t ulength = 0;
297            if (length >= 0) {
298                ulength = (size_t) length;
299                // use malloc here so we can use keymaster_free_param_values
300                // consistently.
301                data = reinterpret_cast<uint8_t*>(malloc(ulength));
302                const void* buf = in.readInplace(ulength);
303                if (!buf || !data) {
304                    ALOGE("Failed to allocate buffer for keymaster blob param");
305                    return false;
306                }
307                memcpy(data, buf, ulength);
308            }
309            *out = keymaster_param_blob(tag, data, ulength);
310            break;
311        }
312        default: {
313            ALOGE("Unsupported keymaster_tag_t %d", tag);
314            return false;
315        }
316    }
317    return true;
318}
319
320/**
321 * Read a byte array from in. The data at *data is still owned by the parcel
322 */
323static void readByteArray(const Parcel& in, const uint8_t** data, size_t* length) {
324    ssize_t slength = in.readInt32();
325    if (slength > 0) {
326        *data = reinterpret_cast<const uint8_t*>(in.readInplace(slength));
327        if (*data) {
328            *length = static_cast<size_t>(slength);
329        } else {
330            *length = 0;
331        }
332    } else {
333        *data = NULL;
334        *length = 0;
335    }
336}
337
338// Read a keymaster_key_param_t* from a Parcel for use in a
339// keymaster_key_characteristics_t. This will be free'd by calling
340// keymaster_free_key_characteristics.
341static keymaster_key_param_t* readParamList(const Parcel& in, size_t* length) {
342    ssize_t slength = in.readInt32();
343    *length = 0;
344    if (slength < 0) {
345        return NULL;
346    }
347    *length = (size_t) slength;
348    if (*length >= UINT_MAX / sizeof(keymaster_key_param_t)) {
349        return NULL;
350    }
351    keymaster_key_param_t* list =
352            reinterpret_cast<keymaster_key_param_t*>(malloc(*length *
353                                                            sizeof(keymaster_key_param_t)));
354    if (!list) {
355        ALOGD("Failed to allocate buffer for generateKey outCharacteristics");
356        goto err;
357    }
358    for (size_t i = 0; i < *length ; i++) {
359        if (!readKeymasterArgumentFromParcel(in, &list[i])) {
360            ALOGE("Failed to read keymaster argument");
361            keymaster_free_param_values(list, i);
362            goto err;
363        }
364    }
365    return list;
366err:
367    free(list);
368    return NULL;
369}
370
371static std::unique_ptr<keymaster_blob_t> readKeymasterBlob(const Parcel& in) {
372    std::unique_ptr<keymaster_blob_t> blob;
373    if (in.readInt32() != 1) {
374        blob.reset(NULL);
375        return blob;
376    }
377    ssize_t length = in.readInt32();
378    blob.reset(new keymaster_blob_t);
379    if (length > 0) {
380        blob->data = reinterpret_cast<const uint8_t*>(in.readInplace(length));
381        if (blob->data) {
382            blob->data_length = static_cast<size_t>(length);
383        } else {
384            blob->data_length = 0;
385        }
386    } else {
387        blob->data = NULL;
388        blob->data_length = 0;
389    }
390    return blob;
391}
392
393class BpKeystoreService: public BpInterface<IKeystoreService>
394{
395public:
396    BpKeystoreService(const sp<IBinder>& impl)
397        : BpInterface<IKeystoreService>(impl)
398    {
399    }
400
401    // test ping
402    virtual int32_t getState(int32_t userId)
403    {
404        Parcel data, reply;
405        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
406        data.writeInt32(userId);
407        status_t status = remote()->transact(BnKeystoreService::GET_STATE, data, &reply);
408        if (status != NO_ERROR) {
409            ALOGD("getState() could not contact remote: %d\n", status);
410            return -1;
411        }
412        int32_t err = reply.readExceptionCode();
413        int32_t ret = reply.readInt32();
414        if (err < 0) {
415            ALOGD("getState() caught exception %d\n", err);
416            return -1;
417        }
418        return ret;
419    }
420
421    virtual int32_t get(const String16& name, uint8_t** item, size_t* itemLength)
422    {
423        Parcel data, reply;
424        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
425        data.writeString16(name);
426        status_t status = remote()->transact(BnKeystoreService::GET, data, &reply);
427        if (status != NO_ERROR) {
428            ALOGD("get() could not contact remote: %d\n", status);
429            return -1;
430        }
431        int32_t err = reply.readExceptionCode();
432        ssize_t len = reply.readInt32();
433        if (len >= 0 && (size_t) len <= reply.dataAvail()) {
434            size_t ulen = (size_t) len;
435            const void* buf = reply.readInplace(ulen);
436            *item = (uint8_t*) malloc(ulen);
437            if (*item != NULL) {
438                memcpy(*item, buf, ulen);
439                *itemLength = ulen;
440            } else {
441                ALOGE("out of memory allocating output array in get");
442                *itemLength = 0;
443            }
444        } else {
445            *itemLength = 0;
446        }
447        if (err < 0) {
448            ALOGD("get() caught exception %d\n", err);
449            return -1;
450        }
451        return 0;
452    }
453
454    virtual int32_t insert(const String16& name, const uint8_t* item, size_t itemLength, int uid,
455            int32_t flags)
456    {
457        Parcel data, reply;
458        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
459        data.writeString16(name);
460        data.writeInt32(itemLength);
461        void* buf = data.writeInplace(itemLength);
462        memcpy(buf, item, itemLength);
463        data.writeInt32(uid);
464        data.writeInt32(flags);
465        status_t status = remote()->transact(BnKeystoreService::INSERT, data, &reply);
466        if (status != NO_ERROR) {
467            ALOGD("import() could not contact remote: %d\n", status);
468            return -1;
469        }
470        int32_t err = reply.readExceptionCode();
471        int32_t ret = reply.readInt32();
472        if (err < 0) {
473            ALOGD("import() caught exception %d\n", err);
474            return -1;
475        }
476        return ret;
477    }
478
479    virtual int32_t del(const String16& name, int uid)
480    {
481        Parcel data, reply;
482        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
483        data.writeString16(name);
484        data.writeInt32(uid);
485        status_t status = remote()->transact(BnKeystoreService::DEL, data, &reply);
486        if (status != NO_ERROR) {
487            ALOGD("del() could not contact remote: %d\n", status);
488            return -1;
489        }
490        int32_t err = reply.readExceptionCode();
491        int32_t ret = reply.readInt32();
492        if (err < 0) {
493            ALOGD("del() caught exception %d\n", err);
494            return -1;
495        }
496        return ret;
497    }
498
499    virtual int32_t exist(const String16& name, int uid)
500    {
501        Parcel data, reply;
502        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
503        data.writeString16(name);
504        data.writeInt32(uid);
505        status_t status = remote()->transact(BnKeystoreService::EXIST, data, &reply);
506        if (status != NO_ERROR) {
507            ALOGD("exist() could not contact remote: %d\n", status);
508            return -1;
509        }
510        int32_t err = reply.readExceptionCode();
511        int32_t ret = reply.readInt32();
512        if (err < 0) {
513            ALOGD("exist() caught exception %d\n", err);
514            return -1;
515        }
516        return ret;
517    }
518
519    virtual int32_t list(const String16& prefix, int uid, Vector<String16>* matches)
520    {
521        Parcel data, reply;
522        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
523        data.writeString16(prefix);
524        data.writeInt32(uid);
525        status_t status = remote()->transact(BnKeystoreService::LIST, data, &reply);
526        if (status != NO_ERROR) {
527            ALOGD("list() could not contact remote: %d\n", status);
528            return -1;
529        }
530        int32_t err = reply.readExceptionCode();
531        int32_t numMatches = reply.readInt32();
532        for (int32_t i = 0; i < numMatches; i++) {
533            matches->push(reply.readString16());
534        }
535        int32_t ret = reply.readInt32();
536        if (err < 0) {
537            ALOGD("list() caught exception %d\n", err);
538            return -1;
539        }
540        return ret;
541    }
542
543    virtual int32_t reset()
544    {
545        Parcel data, reply;
546        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
547        status_t status = remote()->transact(BnKeystoreService::RESET, data, &reply);
548        if (status != NO_ERROR) {
549            ALOGD("reset() could not contact remote: %d\n", status);
550            return -1;
551        }
552        int32_t err = reply.readExceptionCode();
553        int32_t ret = reply.readInt32();
554        if (err < 0) {
555            ALOGD("reset() caught exception %d\n", err);
556            return -1;
557        }
558        return ret;
559    }
560
561    virtual int32_t onUserPasswordChanged(int32_t userId, const String16& password)
562    {
563        Parcel data, reply;
564        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
565        data.writeInt32(userId);
566        data.writeString16(password);
567        status_t status = remote()->transact(BnKeystoreService::ON_USER_PASSWORD_CHANGED, data,
568                                             &reply);
569        if (status != NO_ERROR) {
570            ALOGD("onUserPasswordChanged() could not contact remote: %d\n", status);
571            return -1;
572        }
573        int32_t err = reply.readExceptionCode();
574        int32_t ret = reply.readInt32();
575        if (err < 0) {
576            ALOGD("onUserPasswordChanged() caught exception %d\n", err);
577            return -1;
578        }
579        return ret;
580    }
581
582    virtual int32_t lock(int32_t userId)
583    {
584        Parcel data, reply;
585        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
586        data.writeInt32(userId);
587        status_t status = remote()->transact(BnKeystoreService::LOCK, data, &reply);
588        if (status != NO_ERROR) {
589            ALOGD("lock() could not contact remote: %d\n", status);
590            return -1;
591        }
592        int32_t err = reply.readExceptionCode();
593        int32_t ret = reply.readInt32();
594        if (err < 0) {
595            ALOGD("lock() caught exception %d\n", err);
596            return -1;
597        }
598        return ret;
599    }
600
601    virtual int32_t unlock(int32_t userId, const String16& password)
602    {
603        Parcel data, reply;
604        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
605        data.writeInt32(userId);
606        data.writeString16(password);
607        status_t status = remote()->transact(BnKeystoreService::UNLOCK, data, &reply);
608        if (status != NO_ERROR) {
609            ALOGD("unlock() could not contact remote: %d\n", status);
610            return -1;
611        }
612        int32_t err = reply.readExceptionCode();
613        int32_t ret = reply.readInt32();
614        if (err < 0) {
615            ALOGD("unlock() caught exception %d\n", err);
616            return -1;
617        }
618        return ret;
619    }
620
621    virtual bool isEmpty(int32_t userId)
622    {
623        Parcel data, reply;
624        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
625        data.writeInt32(userId);
626        status_t status = remote()->transact(BnKeystoreService::IS_EMPTY, data, &reply);
627        if (status != NO_ERROR) {
628            ALOGD("isEmpty() could not contact remote: %d\n", status);
629            return false;
630        }
631        int32_t err = reply.readExceptionCode();
632        int32_t ret = reply.readInt32();
633        if (err < 0) {
634            ALOGD("isEmpty() caught exception %d\n", err);
635            return false;
636        }
637        return ret != 0;
638    }
639
640    virtual int32_t generate(const String16& name, int32_t uid, int32_t keyType, int32_t keySize,
641            int32_t flags, Vector<sp<KeystoreArg> >* args)
642    {
643        Parcel data, reply;
644        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
645        data.writeString16(name);
646        data.writeInt32(uid);
647        data.writeInt32(keyType);
648        data.writeInt32(keySize);
649        data.writeInt32(flags);
650        data.writeInt32(1);
651        data.writeInt32(args->size());
652        for (Vector<sp<KeystoreArg> >::iterator it = args->begin(); it != args->end(); ++it) {
653            sp<KeystoreArg> item = *it;
654            size_t keyLength = item->size();
655            data.writeInt32(keyLength);
656            void* buf = data.writeInplace(keyLength);
657            memcpy(buf, item->data(), keyLength);
658        }
659        status_t status = remote()->transact(BnKeystoreService::GENERATE, data, &reply);
660        if (status != NO_ERROR) {
661            ALOGD("generate() could not contact remote: %d\n", status);
662            return -1;
663        }
664        int32_t err = reply.readExceptionCode();
665        int32_t ret = reply.readInt32();
666        if (err < 0) {
667            ALOGD("generate() caught exception %d\n", err);
668            return -1;
669        }
670        return ret;
671    }
672
673    virtual int32_t import(const String16& name, const uint8_t* key, size_t keyLength, int uid,
674            int flags)
675    {
676        Parcel data, reply;
677        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
678        data.writeString16(name);
679        data.writeInt32(keyLength);
680        void* buf = data.writeInplace(keyLength);
681        memcpy(buf, key, keyLength);
682        data.writeInt32(uid);
683        data.writeInt32(flags);
684        status_t status = remote()->transact(BnKeystoreService::IMPORT, data, &reply);
685        if (status != NO_ERROR) {
686            ALOGD("import() could not contact remote: %d\n", status);
687            return -1;
688        }
689        int32_t err = reply.readExceptionCode();
690        int32_t ret = reply.readInt32();
691        if (err < 0) {
692            ALOGD("import() caught exception %d\n", err);
693            return -1;
694        }
695        return ret;
696    }
697
698    virtual int32_t sign(const String16& name, const uint8_t* in, size_t inLength, uint8_t** out,
699            size_t* outLength)
700    {
701        Parcel data, reply;
702        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
703        data.writeString16(name);
704        data.writeInt32(inLength);
705        void* buf = data.writeInplace(inLength);
706        memcpy(buf, in, inLength);
707        status_t status = remote()->transact(BnKeystoreService::SIGN, data, &reply);
708        if (status != NO_ERROR) {
709            ALOGD("import() could not contact remote: %d\n", status);
710            return -1;
711        }
712        int32_t err = reply.readExceptionCode();
713        ssize_t len = reply.readInt32();
714        if (len >= 0 && (size_t) len <= reply.dataAvail()) {
715            size_t ulen = (size_t) len;
716            const void* outBuf = reply.readInplace(ulen);
717            *out = (uint8_t*) malloc(ulen);
718            if (*out != NULL) {
719                memcpy((void*) *out, outBuf, ulen);
720                *outLength = ulen;
721            } else {
722                ALOGE("out of memory allocating output array in sign");
723                *outLength = 0;
724            }
725        } else {
726            *outLength = 0;
727        }
728        if (err < 0) {
729            ALOGD("import() caught exception %d\n", err);
730            return -1;
731        }
732        return 0;
733    }
734
735    virtual int32_t verify(const String16& name, const uint8_t* in, size_t inLength,
736            const uint8_t* signature, size_t signatureLength)
737    {
738        Parcel data, reply;
739        void* buf;
740
741        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
742        data.writeString16(name);
743        data.writeInt32(inLength);
744        buf = data.writeInplace(inLength);
745        memcpy(buf, in, inLength);
746        data.writeInt32(signatureLength);
747        buf = data.writeInplace(signatureLength);
748        memcpy(buf, signature, signatureLength);
749        status_t status = remote()->transact(BnKeystoreService::VERIFY, data, &reply);
750        if (status != NO_ERROR) {
751            ALOGD("verify() could not contact remote: %d\n", status);
752            return -1;
753        }
754        int32_t err = reply.readExceptionCode();
755        int32_t ret = reply.readInt32();
756        if (err < 0) {
757            ALOGD("verify() caught exception %d\n", err);
758            return -1;
759        }
760        return ret;
761    }
762
763    virtual int32_t get_pubkey(const String16& name, uint8_t** pubkey, size_t* pubkeyLength)
764    {
765        Parcel data, reply;
766        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
767        data.writeString16(name);
768        status_t status = remote()->transact(BnKeystoreService::GET_PUBKEY, data, &reply);
769        if (status != NO_ERROR) {
770            ALOGD("get_pubkey() could not contact remote: %d\n", status);
771            return -1;
772        }
773        int32_t err = reply.readExceptionCode();
774        ssize_t len = reply.readInt32();
775        if (len >= 0 && (size_t) len <= reply.dataAvail()) {
776            size_t ulen = (size_t) len;
777            const void* buf = reply.readInplace(ulen);
778            *pubkey = (uint8_t*) malloc(ulen);
779            if (*pubkey != NULL) {
780                memcpy(*pubkey, buf, ulen);
781                *pubkeyLength = ulen;
782            } else {
783                ALOGE("out of memory allocating output array in get_pubkey");
784                *pubkeyLength = 0;
785            }
786        } else {
787            *pubkeyLength = 0;
788        }
789        if (err < 0) {
790            ALOGD("get_pubkey() caught exception %d\n", err);
791            return -1;
792        }
793        return 0;
794     }
795
796    virtual int32_t grant(const String16& name, int32_t granteeUid)
797    {
798        Parcel data, reply;
799        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
800        data.writeString16(name);
801        data.writeInt32(granteeUid);
802        status_t status = remote()->transact(BnKeystoreService::GRANT, data, &reply);
803        if (status != NO_ERROR) {
804            ALOGD("grant() could not contact remote: %d\n", status);
805            return -1;
806        }
807        int32_t err = reply.readExceptionCode();
808        int32_t ret = reply.readInt32();
809        if (err < 0) {
810            ALOGD("grant() caught exception %d\n", err);
811            return -1;
812        }
813        return ret;
814    }
815
816    virtual int32_t ungrant(const String16& name, int32_t granteeUid)
817    {
818        Parcel data, reply;
819        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
820        data.writeString16(name);
821        data.writeInt32(granteeUid);
822        status_t status = remote()->transact(BnKeystoreService::UNGRANT, data, &reply);
823        if (status != NO_ERROR) {
824            ALOGD("ungrant() could not contact remote: %d\n", status);
825            return -1;
826        }
827        int32_t err = reply.readExceptionCode();
828        int32_t ret = reply.readInt32();
829        if (err < 0) {
830            ALOGD("ungrant() caught exception %d\n", err);
831            return -1;
832        }
833        return ret;
834    }
835
836    int64_t getmtime(const String16& name)
837    {
838        Parcel data, reply;
839        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
840        data.writeString16(name);
841        status_t status = remote()->transact(BnKeystoreService::GETMTIME, data, &reply);
842        if (status != NO_ERROR) {
843            ALOGD("getmtime() could not contact remote: %d\n", status);
844            return -1;
845        }
846        int32_t err = reply.readExceptionCode();
847        int64_t ret = reply.readInt64();
848        if (err < 0) {
849            ALOGD("getmtime() caught exception %d\n", err);
850            return -1;
851        }
852        return ret;
853    }
854
855    virtual int32_t duplicate(const String16& srcKey, int32_t srcUid, const String16& destKey,
856            int32_t destUid)
857    {
858        Parcel data, reply;
859        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
860        data.writeString16(srcKey);
861        data.writeInt32(srcUid);
862        data.writeString16(destKey);
863        data.writeInt32(destUid);
864        status_t status = remote()->transact(BnKeystoreService::DUPLICATE, data, &reply);
865        if (status != NO_ERROR) {
866            ALOGD("duplicate() could not contact remote: %d\n", status);
867            return -1;
868        }
869        int32_t err = reply.readExceptionCode();
870        int32_t ret = reply.readInt32();
871        if (err < 0) {
872            ALOGD("duplicate() caught exception %d\n", err);
873            return -1;
874        }
875        return ret;
876    }
877
878    virtual int32_t is_hardware_backed(const String16& keyType)
879    {
880        Parcel data, reply;
881        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
882        data.writeString16(keyType);
883        status_t status = remote()->transact(BnKeystoreService::IS_HARDWARE_BACKED, data, &reply);
884        if (status != NO_ERROR) {
885            ALOGD("is_hardware_backed() could not contact remote: %d\n", status);
886            return -1;
887        }
888        int32_t err = reply.readExceptionCode();
889        int32_t ret = reply.readInt32();
890        if (err < 0) {
891            ALOGD("is_hardware_backed() caught exception %d\n", err);
892            return -1;
893        }
894        return ret;
895    }
896
897    virtual int32_t clear_uid(int64_t uid)
898    {
899        Parcel data, reply;
900        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
901        data.writeInt64(uid);
902        status_t status = remote()->transact(BnKeystoreService::CLEAR_UID, data, &reply);
903        if (status != NO_ERROR) {
904            ALOGD("clear_uid() could not contact remote: %d\n", status);
905            return -1;
906        }
907        int32_t err = reply.readExceptionCode();
908        int32_t ret = reply.readInt32();
909        if (err < 0) {
910            ALOGD("clear_uid() caught exception %d\n", err);
911            return -1;
912        }
913        return ret;
914    }
915
916    virtual int32_t addRngEntropy(const uint8_t* buf, size_t bufLength)
917    {
918        Parcel data, reply;
919        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
920        data.writeByteArray(bufLength, buf);
921        status_t status = remote()->transact(BnKeystoreService::ADD_RNG_ENTROPY, data, &reply);
922        if (status != NO_ERROR) {
923            ALOGD("addRngEntropy() could not contact remote: %d\n", status);
924            return -1;
925        }
926        int32_t err = reply.readExceptionCode();
927        int32_t ret = reply.readInt32();
928        if (err < 0) {
929            ALOGD("addRngEntropy() caught exception %d\n", err);
930            return -1;
931        }
932        return ret;
933    };
934
935    virtual int32_t generateKey(const String16& name, const KeymasterArguments& params,
936                                const uint8_t* entropy, size_t entropyLength, int uid, int flags,
937                                KeyCharacteristics* outCharacteristics)
938    {
939        Parcel data, reply;
940        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
941        data.writeString16(name);
942        data.writeInt32(1);
943        params.writeToParcel(&data);
944        data.writeByteArray(entropyLength, entropy);
945        data.writeInt32(uid);
946        data.writeInt32(flags);
947        status_t status = remote()->transact(BnKeystoreService::GENERATE_KEY, data, &reply);
948        if (status != NO_ERROR) {
949            ALOGD("generateKey() could not contact remote: %d\n", status);
950            return KM_ERROR_UNKNOWN_ERROR;
951        }
952        int32_t err = reply.readExceptionCode();
953        int32_t ret = reply.readInt32();
954        if (err < 0) {
955            ALOGD("generateKey() caught exception %d\n", err);
956            return KM_ERROR_UNKNOWN_ERROR;
957        }
958        if (reply.readInt32() != 0 && outCharacteristics) {
959            outCharacteristics->readFromParcel(reply);
960        }
961        return ret;
962    }
963    virtual int32_t getKeyCharacteristics(const String16& name,
964                                          const keymaster_blob_t* clientId,
965                                          const keymaster_blob_t* appData,
966                                          KeyCharacteristics* outCharacteristics)
967    {
968        Parcel data, reply;
969        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
970        data.writeString16(name);
971        if (clientId) {
972            data.writeByteArray(clientId->data_length, clientId->data);
973        } else {
974            data.writeInt32(-1);
975        }
976        if (appData) {
977            data.writeByteArray(appData->data_length, appData->data);
978        } else {
979            data.writeInt32(-1);
980        }
981        status_t status = remote()->transact(BnKeystoreService::GET_KEY_CHARACTERISTICS,
982                                             data, &reply);
983        if (status != NO_ERROR) {
984            ALOGD("getKeyCharacteristics() could not contact remote: %d\n", status);
985            return KM_ERROR_UNKNOWN_ERROR;
986        }
987        int32_t err = reply.readExceptionCode();
988        int32_t ret = reply.readInt32();
989        if (err < 0) {
990            ALOGD("getKeyCharacteristics() caught exception %d\n", err);
991            return KM_ERROR_UNKNOWN_ERROR;
992        }
993        if (reply.readInt32() != 0 && outCharacteristics) {
994            outCharacteristics->readFromParcel(reply);
995        }
996        return ret;
997    }
998    virtual int32_t importKey(const String16& name, const KeymasterArguments&  params,
999                              keymaster_key_format_t format, const uint8_t *keyData,
1000                              size_t keyLength, int uid, int flags,
1001                              KeyCharacteristics* outCharacteristics)
1002    {
1003        Parcel data, reply;
1004        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
1005        data.writeString16(name);
1006        data.writeInt32(1);
1007        params.writeToParcel(&data);
1008        data.writeInt32(format);
1009        data.writeByteArray(keyLength, keyData);
1010        data.writeInt32(uid);
1011        data.writeInt32(flags);
1012        status_t status = remote()->transact(BnKeystoreService::IMPORT_KEY, data, &reply);
1013        if (status != NO_ERROR) {
1014            ALOGD("importKey() could not contact remote: %d\n", status);
1015            return KM_ERROR_UNKNOWN_ERROR;
1016        }
1017        int32_t err = reply.readExceptionCode();
1018        int32_t ret = reply.readInt32();
1019        if (err < 0) {
1020            ALOGD("importKey() caught exception %d\n", err);
1021            return KM_ERROR_UNKNOWN_ERROR;
1022        }
1023        if (reply.readInt32() != 0 && outCharacteristics) {
1024            outCharacteristics->readFromParcel(reply);
1025        }
1026        return ret;
1027    }
1028
1029    virtual void exportKey(const String16& name, keymaster_key_format_t format,
1030                           const keymaster_blob_t* clientId,
1031                           const keymaster_blob_t* appData, ExportResult* result)
1032    {
1033        if (!result) {
1034            return;
1035        }
1036
1037        Parcel data, reply;
1038        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
1039        data.writeString16(name);
1040        data.writeInt32(format);
1041        if (clientId) {
1042            data.writeByteArray(clientId->data_length, clientId->data);
1043        } else {
1044            data.writeInt32(-1);
1045        }
1046        if (appData) {
1047            data.writeByteArray(appData->data_length, appData->data);
1048        } else {
1049            data.writeInt32(-1);
1050        }
1051        status_t status = remote()->transact(BnKeystoreService::EXPORT_KEY, data, &reply);
1052        if (status != NO_ERROR) {
1053            ALOGD("exportKey() could not contact remote: %d\n", status);
1054            result->resultCode = KM_ERROR_UNKNOWN_ERROR;
1055            return;
1056        }
1057        int32_t err = reply.readExceptionCode();
1058        if (err < 0) {
1059            ALOGD("exportKey() caught exception %d\n", err);
1060            result->resultCode = KM_ERROR_UNKNOWN_ERROR;
1061            return;
1062        }
1063        if (reply.readInt32() != 0) {
1064            result->readFromParcel(reply);
1065        }
1066    }
1067
1068    virtual void begin(const sp<IBinder>& appToken, const String16& name,
1069                       keymaster_purpose_t purpose, bool pruneable,
1070                       const KeymasterArguments& params, const uint8_t* entropy,
1071                       size_t entropyLength, OperationResult* result)
1072    {
1073        if (!result) {
1074            return;
1075        }
1076        Parcel data, reply;
1077        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
1078        data.writeStrongBinder(appToken);
1079        data.writeString16(name);
1080        data.writeInt32(purpose);
1081        data.writeInt32(pruneable ? 1 : 0);
1082        data.writeInt32(1);
1083        params.writeToParcel(&data);
1084        data.writeByteArray(entropyLength, entropy);
1085        status_t status = remote()->transact(BnKeystoreService::BEGIN, data, &reply);
1086        if (status != NO_ERROR) {
1087            ALOGD("begin() could not contact remote: %d\n", status);
1088            result->resultCode = KM_ERROR_UNKNOWN_ERROR;
1089            return;
1090        }
1091        int32_t err = reply.readExceptionCode();
1092        if (err < 0) {
1093            ALOGD("begin() caught exception %d\n", err);
1094            result->resultCode = KM_ERROR_UNKNOWN_ERROR;
1095            return;
1096        }
1097        if (reply.readInt32() != 0) {
1098            result->readFromParcel(reply);
1099        }
1100    }
1101
1102    virtual void update(const sp<IBinder>& token, const KeymasterArguments& params,
1103                        const uint8_t* opData, size_t dataLength, OperationResult* result)
1104    {
1105        if (!result) {
1106            return;
1107        }
1108        Parcel data, reply;
1109        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
1110        data.writeStrongBinder(token);
1111        data.writeInt32(1);
1112        params.writeToParcel(&data);
1113        data.writeByteArray(dataLength, opData);
1114        status_t status = remote()->transact(BnKeystoreService::UPDATE, data, &reply);
1115        if (status != NO_ERROR) {
1116            ALOGD("update() could not contact remote: %d\n", status);
1117            result->resultCode = KM_ERROR_UNKNOWN_ERROR;
1118            return;
1119        }
1120        int32_t err = reply.readExceptionCode();
1121        if (err < 0) {
1122            ALOGD("update() caught exception %d\n", err);
1123            result->resultCode = KM_ERROR_UNKNOWN_ERROR;
1124            return;
1125        }
1126        if (reply.readInt32() != 0) {
1127            result->readFromParcel(reply);
1128        }
1129    }
1130
1131    virtual void finish(const sp<IBinder>& token, const KeymasterArguments& params,
1132                        const uint8_t* signature, size_t signatureLength,
1133                        const uint8_t* entropy, size_t entropyLength,
1134                        OperationResult* result)
1135    {
1136        if (!result) {
1137            return;
1138        }
1139        Parcel data, reply;
1140        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
1141        data.writeStrongBinder(token);
1142        data.writeInt32(1);
1143        params.writeToParcel(&data);
1144        data.writeByteArray(signatureLength, signature);
1145        data.writeByteArray(entropyLength, entropy);
1146        status_t status = remote()->transact(BnKeystoreService::FINISH, data, &reply);
1147        if (status != NO_ERROR) {
1148            ALOGD("finish() could not contact remote: %d\n", status);
1149            result->resultCode = KM_ERROR_UNKNOWN_ERROR;
1150            return;
1151        }
1152        int32_t err = reply.readExceptionCode();
1153        if (err < 0) {
1154            ALOGD("finish() caught exception %d\n", err);
1155            result->resultCode = KM_ERROR_UNKNOWN_ERROR;
1156            return;
1157        }
1158        if (reply.readInt32() != 0) {
1159            result->readFromParcel(reply);
1160        }
1161    }
1162
1163    virtual int32_t abort(const sp<IBinder>& token)
1164    {
1165        Parcel data, reply;
1166        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
1167        data.writeStrongBinder(token);
1168        status_t status = remote()->transact(BnKeystoreService::ABORT, data, &reply);
1169        if (status != NO_ERROR) {
1170            ALOGD("abort() could not contact remote: %d\n", status);
1171            return KM_ERROR_UNKNOWN_ERROR;
1172        }
1173        int32_t err = reply.readExceptionCode();
1174        int32_t ret = reply.readInt32();
1175        if (err < 0) {
1176            ALOGD("abort() caught exception %d\n", err);
1177            return KM_ERROR_UNKNOWN_ERROR;
1178        }
1179        return ret;
1180    }
1181
1182    virtual bool isOperationAuthorized(const sp<IBinder>& token)
1183    {
1184        Parcel data, reply;
1185        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
1186        data.writeStrongBinder(token);
1187        status_t status = remote()->transact(BnKeystoreService::IS_OPERATION_AUTHORIZED, data,
1188                                             &reply);
1189        if (status != NO_ERROR) {
1190            ALOGD("isOperationAuthorized() could not contact remote: %d\n", status);
1191            return false;
1192        }
1193        int32_t err = reply.readExceptionCode();
1194        int32_t ret = reply.readInt32();
1195        if (err < 0) {
1196            ALOGD("isOperationAuthorized() caught exception %d\n", err);
1197            return false;
1198        }
1199        return ret == 1;
1200    }
1201
1202    virtual int32_t addAuthToken(const uint8_t* token, size_t length)
1203    {
1204        Parcel data, reply;
1205        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
1206        data.writeByteArray(length, token);
1207        status_t status = remote()->transact(BnKeystoreService::ADD_AUTH_TOKEN, data, &reply);
1208        if (status != NO_ERROR) {
1209            ALOGD("addAuthToken() could not contact remote: %d\n", status);
1210            return -1;
1211        }
1212        int32_t err = reply.readExceptionCode();
1213        int32_t ret = reply.readInt32();
1214        if (err < 0) {
1215            ALOGD("addAuthToken() caught exception %d\n", err);
1216            return -1;
1217        }
1218        return ret;
1219    };
1220
1221    virtual int32_t onUserAdded(int32_t userId, int32_t parentId)
1222    {
1223        Parcel data, reply;
1224        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
1225        data.writeInt32(userId);
1226        data.writeInt32(parentId);
1227        status_t status = remote()->transact(BnKeystoreService::ON_USER_ADDED, data, &reply);
1228        if (status != NO_ERROR) {
1229            ALOGD("onUserAdded() could not contact remote: %d\n", status);
1230            return -1;
1231        }
1232        int32_t err = reply.readExceptionCode();
1233        int32_t ret = reply.readInt32();
1234        if (err < 0) {
1235            ALOGD("onUserAdded() caught exception %d\n", err);
1236            return -1;
1237        }
1238        return ret;
1239    }
1240
1241    virtual int32_t onUserRemoved(int32_t userId)
1242    {
1243        Parcel data, reply;
1244        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
1245        data.writeInt32(userId);
1246        status_t status = remote()->transact(BnKeystoreService::ON_USER_REMOVED, data, &reply);
1247        if (status != NO_ERROR) {
1248            ALOGD("onUserRemoved() could not contact remote: %d\n", status);
1249            return -1;
1250        }
1251        int32_t err = reply.readExceptionCode();
1252        int32_t ret = reply.readInt32();
1253        if (err < 0) {
1254            ALOGD("onUserRemoved() caught exception %d\n", err);
1255            return -1;
1256        }
1257        return ret;
1258    }
1259
1260};
1261
1262IMPLEMENT_META_INTERFACE(KeystoreService, "android.security.IKeystoreService");
1263
1264// ----------------------------------------------------------------------
1265
1266status_t BnKeystoreService::onTransact(
1267    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
1268{
1269    switch(code) {
1270        case GET_STATE: {
1271            CHECK_INTERFACE(IKeystoreService, data, reply);
1272            int32_t userId = data.readInt32();
1273            int32_t ret = getState(userId);
1274            reply->writeNoException();
1275            reply->writeInt32(ret);
1276            return NO_ERROR;
1277        } break;
1278        case GET: {
1279            CHECK_INTERFACE(IKeystoreService, data, reply);
1280            String16 name = data.readString16();
1281            void* out = NULL;
1282            size_t outSize = 0;
1283            int32_t ret = get(name, (uint8_t**) &out, &outSize);
1284            reply->writeNoException();
1285            if (ret == 1) {
1286                reply->writeInt32(outSize);
1287                void* buf = reply->writeInplace(outSize);
1288                memcpy(buf, out, outSize);
1289                free(out);
1290            } else {
1291                reply->writeInt32(-1);
1292            }
1293            return NO_ERROR;
1294        } break;
1295        case INSERT: {
1296            CHECK_INTERFACE(IKeystoreService, data, reply);
1297            String16 name = data.readString16();
1298            ssize_t inSize = data.readInt32();
1299            const void* in;
1300            if (inSize >= 0 && (size_t) inSize <= data.dataAvail()) {
1301                in = data.readInplace(inSize);
1302            } else {
1303                in = NULL;
1304                inSize = 0;
1305            }
1306            int uid = data.readInt32();
1307            int32_t flags = data.readInt32();
1308            int32_t ret = insert(name, (const uint8_t*) in, (size_t) inSize, uid, flags);
1309            reply->writeNoException();
1310            reply->writeInt32(ret);
1311            return NO_ERROR;
1312        } break;
1313        case DEL: {
1314            CHECK_INTERFACE(IKeystoreService, data, reply);
1315            String16 name = data.readString16();
1316            int uid = data.readInt32();
1317            int32_t ret = del(name, uid);
1318            reply->writeNoException();
1319            reply->writeInt32(ret);
1320            return NO_ERROR;
1321        } break;
1322        case EXIST: {
1323            CHECK_INTERFACE(IKeystoreService, data, reply);
1324            String16 name = data.readString16();
1325            int uid = data.readInt32();
1326            int32_t ret = exist(name, uid);
1327            reply->writeNoException();
1328            reply->writeInt32(ret);
1329            return NO_ERROR;
1330        } break;
1331        case LIST: {
1332            CHECK_INTERFACE(IKeystoreService, data, reply);
1333            String16 prefix = data.readString16();
1334            int uid = data.readInt32();
1335            Vector<String16> matches;
1336            int32_t ret = list(prefix, uid, &matches);
1337            reply->writeNoException();
1338            reply->writeInt32(matches.size());
1339            Vector<String16>::const_iterator it = matches.begin();
1340            for (; it != matches.end(); ++it) {
1341                reply->writeString16(*it);
1342            }
1343            reply->writeInt32(ret);
1344            return NO_ERROR;
1345        } break;
1346        case RESET: {
1347            CHECK_INTERFACE(IKeystoreService, data, reply);
1348            int32_t ret = reset();
1349            reply->writeNoException();
1350            reply->writeInt32(ret);
1351            return NO_ERROR;
1352        } break;
1353        case ON_USER_PASSWORD_CHANGED: {
1354            CHECK_INTERFACE(IKeystoreService, data, reply);
1355            int32_t userId = data.readInt32();
1356            String16 pass = data.readString16();
1357            int32_t ret = onUserPasswordChanged(userId, pass);
1358            reply->writeNoException();
1359            reply->writeInt32(ret);
1360            return NO_ERROR;
1361        } break;
1362        case LOCK: {
1363            CHECK_INTERFACE(IKeystoreService, data, reply);
1364            int32_t userId = data.readInt32();
1365            int32_t ret = lock(userId);
1366            reply->writeNoException();
1367            reply->writeInt32(ret);
1368            return NO_ERROR;
1369        } break;
1370        case UNLOCK: {
1371            CHECK_INTERFACE(IKeystoreService, data, reply);
1372            int32_t userId = data.readInt32();
1373            String16 pass = data.readString16();
1374            int32_t ret = unlock(userId, pass);
1375            reply->writeNoException();
1376            reply->writeInt32(ret);
1377            return NO_ERROR;
1378        } break;
1379        case IS_EMPTY: {
1380            CHECK_INTERFACE(IKeystoreService, data, reply);
1381            int32_t userId = data.readInt32();
1382            bool ret = isEmpty(userId);
1383            reply->writeNoException();
1384            reply->writeInt32(ret ? 1 : 0);
1385            return NO_ERROR;
1386        } break;
1387        case GENERATE: {
1388            CHECK_INTERFACE(IKeystoreService, data, reply);
1389            String16 name = data.readString16();
1390            int32_t uid = data.readInt32();
1391            int32_t keyType = data.readInt32();
1392            int32_t keySize = data.readInt32();
1393            int32_t flags = data.readInt32();
1394            Vector<sp<KeystoreArg> > args;
1395            int32_t argsPresent = data.readInt32();
1396            if (argsPresent == 1) {
1397                ssize_t numArgs = data.readInt32();
1398                if (numArgs > MAX_GENERATE_ARGS) {
1399                    return BAD_VALUE;
1400                }
1401                if (numArgs > 0) {
1402                    for (size_t i = 0; i < (size_t) numArgs; i++) {
1403                        ssize_t inSize = data.readInt32();
1404                        if (inSize >= 0 && (size_t) inSize <= data.dataAvail()) {
1405                            sp<KeystoreArg> arg = new KeystoreArg(data.readInplace(inSize),
1406                                                                  inSize);
1407                            args.push_back(arg);
1408                        } else {
1409                            args.push_back(NULL);
1410                        }
1411                    }
1412                }
1413            }
1414            int32_t ret = generate(name, uid, keyType, keySize, flags, &args);
1415            reply->writeNoException();
1416            reply->writeInt32(ret);
1417            return NO_ERROR;
1418        } break;
1419        case IMPORT: {
1420            CHECK_INTERFACE(IKeystoreService, data, reply);
1421            String16 name = data.readString16();
1422            ssize_t inSize = data.readInt32();
1423            const void* in;
1424            if (inSize >= 0 && (size_t) inSize <= data.dataAvail()) {
1425                in = data.readInplace(inSize);
1426            } else {
1427                in = NULL;
1428                inSize = 0;
1429            }
1430            int uid = data.readInt32();
1431            int32_t flags = data.readInt32();
1432            int32_t ret = import(name, (const uint8_t*) in, (size_t) inSize, uid, flags);
1433            reply->writeNoException();
1434            reply->writeInt32(ret);
1435            return NO_ERROR;
1436        } break;
1437        case SIGN: {
1438            CHECK_INTERFACE(IKeystoreService, data, reply);
1439            String16 name = data.readString16();
1440            ssize_t inSize = data.readInt32();
1441            const void* in;
1442            if (inSize >= 0 && (size_t) inSize <= data.dataAvail()) {
1443                in = data.readInplace(inSize);
1444            } else {
1445                in = NULL;
1446                inSize = 0;
1447            }
1448            void* out = NULL;
1449            size_t outSize = 0;
1450            int32_t ret = sign(name, (const uint8_t*) in, (size_t) inSize, (uint8_t**) &out, &outSize);
1451            reply->writeNoException();
1452            if (outSize > 0 && out != NULL) {
1453                reply->writeInt32(outSize);
1454                void* buf = reply->writeInplace(outSize);
1455                memcpy(buf, out, outSize);
1456                delete[] reinterpret_cast<uint8_t*>(out);
1457            } else {
1458                reply->writeInt32(-1);
1459            }
1460            reply->writeInt32(ret);
1461            return NO_ERROR;
1462        } break;
1463        case VERIFY: {
1464            CHECK_INTERFACE(IKeystoreService, data, reply);
1465            String16 name = data.readString16();
1466            ssize_t inSize = data.readInt32();
1467            const void* in;
1468            if (inSize >= 0 && (size_t) inSize <= data.dataAvail()) {
1469                in = data.readInplace(inSize);
1470            } else {
1471                in = NULL;
1472                inSize = 0;
1473            }
1474            ssize_t sigSize = data.readInt32();
1475            const void* sig;
1476            if (sigSize >= 0 && (size_t) sigSize <= data.dataAvail()) {
1477                sig = data.readInplace(sigSize);
1478            } else {
1479                sig = NULL;
1480                sigSize = 0;
1481            }
1482            bool ret = verify(name, (const uint8_t*) in, (size_t) inSize, (const uint8_t*) sig,
1483                    (size_t) sigSize);
1484            reply->writeNoException();
1485            reply->writeInt32(ret ? 1 : 0);
1486            return NO_ERROR;
1487        } break;
1488        case GET_PUBKEY: {
1489            CHECK_INTERFACE(IKeystoreService, data, reply);
1490            String16 name = data.readString16();
1491            void* out = NULL;
1492            size_t outSize = 0;
1493            int32_t ret = get_pubkey(name, (unsigned char**) &out, &outSize);
1494            reply->writeNoException();
1495            if (outSize > 0 && out != NULL) {
1496                reply->writeInt32(outSize);
1497                void* buf = reply->writeInplace(outSize);
1498                memcpy(buf, out, outSize);
1499                free(out);
1500            } else {
1501                reply->writeInt32(-1);
1502            }
1503            reply->writeInt32(ret);
1504            return NO_ERROR;
1505        } break;
1506        case GRANT: {
1507            CHECK_INTERFACE(IKeystoreService, data, reply);
1508            String16 name = data.readString16();
1509            int32_t granteeUid = data.readInt32();
1510            int32_t ret = grant(name, granteeUid);
1511            reply->writeNoException();
1512            reply->writeInt32(ret);
1513            return NO_ERROR;
1514        } break;
1515        case UNGRANT: {
1516            CHECK_INTERFACE(IKeystoreService, data, reply);
1517            String16 name = data.readString16();
1518            int32_t granteeUid = data.readInt32();
1519            int32_t ret = ungrant(name, granteeUid);
1520            reply->writeNoException();
1521            reply->writeInt32(ret);
1522            return NO_ERROR;
1523        } break;
1524        case GETMTIME: {
1525            CHECK_INTERFACE(IKeystoreService, data, reply);
1526            String16 name = data.readString16();
1527            int64_t ret = getmtime(name);
1528            reply->writeNoException();
1529            reply->writeInt64(ret);
1530            return NO_ERROR;
1531        } break;
1532        case DUPLICATE: {
1533            CHECK_INTERFACE(IKeystoreService, data, reply);
1534            String16 srcKey = data.readString16();
1535            int32_t srcUid = data.readInt32();
1536            String16 destKey = data.readString16();
1537            int32_t destUid = data.readInt32();
1538            int32_t ret = duplicate(srcKey, srcUid, destKey, destUid);
1539            reply->writeNoException();
1540            reply->writeInt32(ret);
1541            return NO_ERROR;
1542        } break;
1543        case IS_HARDWARE_BACKED: {
1544            CHECK_INTERFACE(IKeystoreService, data, reply);
1545            String16 keyType = data.readString16();
1546            int32_t ret = is_hardware_backed(keyType);
1547            reply->writeNoException();
1548            reply->writeInt32(ret);
1549            return NO_ERROR;
1550        }
1551        case CLEAR_UID: {
1552            CHECK_INTERFACE(IKeystoreService, data, reply);
1553            int64_t uid = data.readInt64();
1554            int32_t ret = clear_uid(uid);
1555            reply->writeNoException();
1556            reply->writeInt32(ret);
1557            return NO_ERROR;
1558        }
1559        case ADD_RNG_ENTROPY: {
1560            CHECK_INTERFACE(IKeystoreService, data, reply);
1561            const uint8_t* bytes = NULL;
1562            size_t size = 0;
1563            readByteArray(data, &bytes, &size);
1564            int32_t ret = addRngEntropy(bytes, size);
1565            reply->writeNoException();
1566            reply->writeInt32(ret);
1567            return NO_ERROR;
1568        }
1569        case GENERATE_KEY: {
1570            CHECK_INTERFACE(IKeystoreService, data, reply);
1571            String16 name = data.readString16();
1572            KeymasterArguments args;
1573            if (data.readInt32() != 0) {
1574                args.readFromParcel(data);
1575            }
1576            const uint8_t* entropy = NULL;
1577            size_t entropyLength = 0;
1578            readByteArray(data, &entropy, &entropyLength);
1579            int32_t uid = data.readInt32();
1580            int32_t flags = data.readInt32();
1581            KeyCharacteristics outCharacteristics;
1582            int32_t ret = generateKey(name, args, entropy, entropyLength, uid, flags,
1583                                      &outCharacteristics);
1584            reply->writeNoException();
1585            reply->writeInt32(ret);
1586            reply->writeInt32(1);
1587            outCharacteristics.writeToParcel(reply);
1588            return NO_ERROR;
1589        }
1590        case GET_KEY_CHARACTERISTICS: {
1591            CHECK_INTERFACE(IKeystoreService, data, reply);
1592            String16 name = data.readString16();
1593            std::unique_ptr<keymaster_blob_t> clientId = readKeymasterBlob(data);
1594            std::unique_ptr<keymaster_blob_t> appData = readKeymasterBlob(data);
1595            KeyCharacteristics outCharacteristics;
1596            int ret = getKeyCharacteristics(name, clientId.get(), appData.get(),
1597                                            &outCharacteristics);
1598            reply->writeNoException();
1599            reply->writeInt32(ret);
1600            reply->writeInt32(1);
1601            outCharacteristics.writeToParcel(reply);
1602            return NO_ERROR;
1603        }
1604        case IMPORT_KEY: {
1605            CHECK_INTERFACE(IKeystoreService, data, reply);
1606            String16 name = data.readString16();
1607            KeymasterArguments args;
1608            if (data.readInt32() != 0) {
1609                args.readFromParcel(data);
1610            }
1611            keymaster_key_format_t format = static_cast<keymaster_key_format_t>(data.readInt32());
1612            const uint8_t* keyData = NULL;
1613            size_t keyLength = 0;
1614            readByteArray(data, &keyData, &keyLength);
1615            int32_t uid = data.readInt32();
1616            int32_t flags = data.readInt32();
1617            KeyCharacteristics outCharacteristics;
1618            int32_t ret = importKey(name, args, format, keyData, keyLength, uid, flags,
1619                                    &outCharacteristics);
1620            reply->writeNoException();
1621            reply->writeInt32(ret);
1622            reply->writeInt32(1);
1623            outCharacteristics.writeToParcel(reply);
1624
1625            return NO_ERROR;
1626        }
1627        case EXPORT_KEY: {
1628            CHECK_INTERFACE(IKeystoreService, data, reply);
1629            String16 name = data.readString16();
1630            keymaster_key_format_t format = static_cast<keymaster_key_format_t>(data.readInt32());
1631            std::unique_ptr<keymaster_blob_t> clientId = readKeymasterBlob(data);
1632            std::unique_ptr<keymaster_blob_t> appData = readKeymasterBlob(data);
1633            ExportResult result;
1634            exportKey(name, format, clientId.get(), appData.get(), &result);
1635            reply->writeNoException();
1636            reply->writeInt32(1);
1637            result.writeToParcel(reply);
1638
1639            return NO_ERROR;
1640        }
1641        case BEGIN: {
1642            CHECK_INTERFACE(IKeystoreService, data, reply);
1643            sp<IBinder> token = data.readStrongBinder();
1644            String16 name = data.readString16();
1645            keymaster_purpose_t purpose = static_cast<keymaster_purpose_t>(data.readInt32());
1646            bool pruneable = data.readInt32() != 0;
1647            KeymasterArguments args;
1648            if (data.readInt32() != 0) {
1649                args.readFromParcel(data);
1650            }
1651            const uint8_t* entropy = NULL;
1652            size_t entropyLength = 0;
1653            readByteArray(data, &entropy, &entropyLength);
1654            OperationResult result;
1655            begin(token, name, purpose, pruneable, args, entropy, entropyLength, &result);
1656            reply->writeNoException();
1657            reply->writeInt32(1);
1658            result.writeToParcel(reply);
1659
1660            return NO_ERROR;
1661        }
1662        case UPDATE: {
1663            CHECK_INTERFACE(IKeystoreService, data, reply);
1664            sp<IBinder> token = data.readStrongBinder();
1665            KeymasterArguments args;
1666            if (data.readInt32() != 0) {
1667                args.readFromParcel(data);
1668            }
1669            const uint8_t* buf = NULL;
1670            size_t bufLength = 0;
1671            readByteArray(data, &buf, &bufLength);
1672            OperationResult result;
1673            update(token, args, buf, bufLength, &result);
1674            reply->writeNoException();
1675            reply->writeInt32(1);
1676            result.writeToParcel(reply);
1677
1678            return NO_ERROR;
1679        }
1680        case FINISH: {
1681            CHECK_INTERFACE(IKeystoreService, data, reply);
1682            sp<IBinder> token = data.readStrongBinder();
1683            KeymasterArguments args;
1684            if (data.readInt32() != 0) {
1685                args.readFromParcel(data);
1686            }
1687            const uint8_t* signature = NULL;
1688            size_t signatureLength = 0;
1689            readByteArray(data, &signature, &signatureLength);
1690            const uint8_t* entropy = NULL;
1691            size_t entropyLength = 0;
1692            readByteArray(data, &entropy, &entropyLength);
1693            OperationResult result;
1694            finish(token, args, signature, signatureLength, entropy, entropyLength,  &result);
1695            reply->writeNoException();
1696            reply->writeInt32(1);
1697            result.writeToParcel(reply);
1698
1699            return NO_ERROR;
1700        }
1701        case ABORT: {
1702            CHECK_INTERFACE(IKeystoreService, data, reply);
1703            sp<IBinder> token = data.readStrongBinder();
1704            int32_t result = abort(token);
1705            reply->writeNoException();
1706            reply->writeInt32(result);
1707
1708            return NO_ERROR;
1709        }
1710        case IS_OPERATION_AUTHORIZED: {
1711            CHECK_INTERFACE(IKeystoreService, data, reply);
1712            sp<IBinder> token = data.readStrongBinder();
1713            bool result = isOperationAuthorized(token);
1714            reply->writeNoException();
1715            reply->writeInt32(result ? 1 : 0);
1716
1717            return NO_ERROR;
1718        }
1719        case ADD_AUTH_TOKEN: {
1720            CHECK_INTERFACE(IKeystoreService, data, reply);
1721            const uint8_t* token_bytes = NULL;
1722            size_t size = 0;
1723            readByteArray(data, &token_bytes, &size);
1724            int32_t result = addAuthToken(token_bytes, size);
1725            reply->writeNoException();
1726            reply->writeInt32(result);
1727
1728            return NO_ERROR;
1729        }
1730        case ON_USER_ADDED: {
1731            CHECK_INTERFACE(IKeystoreService, data, reply);
1732            int32_t userId = data.readInt32();
1733            int32_t parentId = data.readInt32();
1734            int32_t result = onUserAdded(userId, parentId);
1735            reply->writeNoException();
1736            reply->writeInt32(result);
1737
1738            return NO_ERROR;
1739        }
1740        case ON_USER_REMOVED: {
1741            CHECK_INTERFACE(IKeystoreService, data, reply);
1742            int32_t userId = data.readInt32();
1743            int32_t result = onUserRemoved(userId);
1744            reply->writeNoException();
1745            reply->writeInt32(result);
1746
1747            return NO_ERROR;
1748        }
1749        default:
1750            return BBinder::onTransact(code, data, reply, flags);
1751    }
1752}
1753
1754// ----------------------------------------------------------------------------
1755
1756}; // namespace android
1757