keystore/IKeystoreService.cpp

/*
**
** Copyright 2008, The Android Open Source Project
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
**     http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/

#include <stdint.h>
#include <sys/limits.h>
#include <sys/types.h>

#include <algorithm>
#include <limits>

#define LOG_TAG "KeystoreService"
#include <utils/Log.h>

#include <binder/IPCThreadState.h>
#include <binder/IServiceManager.h>
#include <binder/Parcel.h>

#include <keystore/IKeystoreService.h>
#include <keystore/keystore_hidl_support.h>

#include "keystore_aidl_hidl_marshalling_utils.h"

namespace android {
using namespace ::keystore;

const ssize_t MAX_GENERATE_ARGS = 3;

KeystoreArg::KeystoreArg(const void* data, size_t len) : mData(data), mSize(len) {}

KeystoreArg::~KeystoreArg() {}

const void* KeystoreArg::data() const {
    return mData;
}

size_t KeystoreArg::size() const {
    return mSize;
}

OperationResult::OperationResult() : resultCode(), token(), handle(0), inputConsumed(0), data() {}

OperationResult::~OperationResult() {}

status_t OperationResult::readFromParcel(const Parcel* inn) {
    const Parcel& in = *inn;
    resultCode = ErrorCode(in.readInt32());
    token = in.readStrongBinder();
    handle = static_cast<uint64_t>(in.readInt64());
    inputConsumed = in.readInt32();
    data = readKeymasterBlob(in);
    outParams = readParamSetFromParcel(in);
    return OK;
}

status_t OperationResult::writeToParcel(Parcel* out) const {
    out->writeInt32(resultCode);
    out->writeStrongBinder(token);
    out->writeInt64(handle);
    out->writeInt32(inputConsumed);
    writeKeymasterBlob(data, out);
    writeParamSetToParcel(outParams, out);
    return OK;
}

ExportResult::ExportResult() : resultCode() {}

ExportResult::~ExportResult() {}

status_t ExportResult::readFromParcel(const Parcel* inn) {
    const Parcel& in = *inn;
    resultCode = ErrorCode(in.readInt32());
    exportData = readKeymasterBlob(in);
    return OK;
}

status_t ExportResult::writeToParcel(Parcel* out) const {
    out->writeInt32(resultCode);
    writeKeymasterBlob(exportData, out);
    return OK;
}

/**
 * Read a byte array from in. The data at *data is still owned by the parcel
 */
static void readByteArray(const Parcel& in, const uint8_t** data, size_t* length) {
    ssize_t slength = in.readInt32();
    if (slength > 0) {
        *data = reinterpret_cast<const uint8_t*>(in.readInplace(slength));
        if (*data) {
            *length = static_cast<size_t>(slength);
        } else {
            *length = 0;
        }
    } else {
        *data = NULL;
        *length = 0;
    }
}

class BpKeystoreService : public BpInterface<IKeystoreService> {
  public:
    explicit BpKeystoreService(const sp<IBinder>& impl) : BpInterface<IKeystoreService>(impl) {}

    // test ping
    KeyStoreServiceReturnCode getState(int32_t userId) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeInt32(userId);
        status_t status = remote()->transact(BnKeystoreService::GET_STATE, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("getState() could not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        ResponseCode ret = ResponseCode(reply.readInt32());
        if (err < 0) {
            ALOGD("getState() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        return ret;
    }

    KeyStoreServiceReturnCode get(const String16& name, int32_t uid,
                                  hidl_vec<uint8_t>* item) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeString16(name);
        data.writeInt32(uid);
        status_t status = remote()->transact(BnKeystoreService::GET, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("get() could not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("get() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        auto resultItem = readBlobAsByteArray(reply);
        if (item) *item = resultItem.value();
        return ResponseCode(reply.readInt32());
    }

    KeyStoreServiceReturnCode insert(const String16& name, const hidl_vec<uint8_t>& item, int uid,
                                     int32_t flags) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeString16(name);
        writeBlobAsByteArray(item, &data);
        data.writeInt32(uid);
        data.writeInt32(flags);
        status_t status = remote()->transact(BnKeystoreService::INSERT, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("import() could not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("import() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        return ResponseCode(reply.readInt32());
    }

    KeyStoreServiceReturnCode del(const String16& name, int uid) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeString16(name);
        data.writeInt32(uid);
        status_t status = remote()->transact(BnKeystoreService::DEL, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("del() could not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("del() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        return ResponseCode(reply.readInt32());
    }

    KeyStoreServiceReturnCode exist(const String16& name, int uid) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeString16(name);
        data.writeInt32(uid);
        status_t status = remote()->transact(BnKeystoreService::EXIST, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("exist() could not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("exist() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        return ResponseCode(reply.readInt32());
    }

    KeyStoreServiceReturnCode list(const String16& prefix, int uid,
                                   Vector<String16>* matches) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeString16(prefix);
        data.writeInt32(uid);
        status_t status = remote()->transact(BnKeystoreService::LIST, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("list() could not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        int32_t numMatches = reply.readInt32();
        for (int32_t i = 0; i < numMatches; i++) {
            matches->push(reply.readString16());
        }
        if (err < 0) {
            ALOGD("list() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        return ResponseCode(reply.readInt32());
    }

    KeyStoreServiceReturnCode reset() override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        status_t status = remote()->transact(BnKeystoreService::RESET, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("reset() could not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("reset() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        return ResponseCode(reply.readInt32());
    }

    KeyStoreServiceReturnCode onUserPasswordChanged(int32_t userId,
                                                    const String16& password) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeInt32(userId);
        data.writeString16(password);
        status_t status =
            remote()->transact(BnKeystoreService::ON_USER_PASSWORD_CHANGED, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("onUserPasswordChanged() could not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("onUserPasswordChanged() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        return ResponseCode(reply.readInt32());
    }

    KeyStoreServiceReturnCode lock(int32_t userId) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeInt32(userId);
        status_t status = remote()->transact(BnKeystoreService::LOCK, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("lock() could not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("lock() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        return ResponseCode(reply.readInt32());
    }

    KeyStoreServiceReturnCode unlock(int32_t userId, const String16& password) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeInt32(userId);
        data.writeString16(password);
        status_t status = remote()->transact(BnKeystoreService::UNLOCK, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("unlock() could not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("unlock() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        return ResponseCode(reply.readInt32());
    }

    bool isEmpty(int32_t userId) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeInt32(userId);
        status_t status = remote()->transact(BnKeystoreService::IS_EMPTY, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("isEmpty() could not contact remote: %d\n", status);
            return false;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("isEmpty() caught exception %d\n", err);
            return false;
        }
        return reply.readInt32() != 0;
    }

    KeyStoreServiceReturnCode generate(const String16& name, int32_t uid, int32_t keyType,
                                       int32_t keySize, int32_t flags,
                                       Vector<sp<KeystoreArg>>* args) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeString16(name);
        data.writeInt32(uid);
        data.writeInt32(keyType);
        data.writeInt32(keySize);
        data.writeInt32(flags);
        data.writeInt32(1);
        data.writeInt32(args->size());
        for (Vector<sp<KeystoreArg>>::iterator it = args->begin(); it != args->end(); ++it) {
            sp<KeystoreArg> item = *it;
            size_t keyLength = item->size();
            data.writeInt32(keyLength);
            void* buf = data.writeInplace(keyLength);
            memcpy(buf, item->data(), keyLength);
        }
        status_t status = remote()->transact(BnKeystoreService::GENERATE, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("generate() could not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("generate() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        return ResponseCode(reply.readInt32());
    }

    KeyStoreServiceReturnCode import(const String16& name, const hidl_vec<uint8_t>& key, int uid,
                                     int flags) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeString16(name);
        writeBlobAsByteArray(key, &data);
        data.writeInt32(uid);
        data.writeInt32(flags);
        status_t status = remote()->transact(BnKeystoreService::IMPORT, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("import() could not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("import() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        return ResponseCode(reply.readInt32());
    }

    KeyStoreServiceReturnCode sign(const String16& name, const hidl_vec<uint8_t>& in,
                                   hidl_vec<uint8_t>* out) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeString16(name);
        writeBlobAsByteArray(in, &data);
        status_t status = remote()->transact(BnKeystoreService::SIGN, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("import() could not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("import() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        auto outBlob = readBlobAsByteArray(reply);
        if (out) {
            // don't need to check outBlob.isOk()
            // if !outBlob.isOk() the wrapped value is default constructed and therefore empty,
            // as expected.
            *out = outBlob.value();
        }
        return ResponseCode(reply.readInt32());
    }

    KeyStoreServiceReturnCode verify(const String16& name, const hidl_vec<uint8_t>& in,
                                     const hidl_vec<uint8_t>& signature) override {
        Parcel data, reply;

        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeString16(name);
        writeBlobAsByteArray(in, &data);
        writeBlobAsByteArray(signature, &data);
        status_t status = remote()->transact(BnKeystoreService::VERIFY, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("verify() could not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("verify() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        return ResponseCode(reply.readInt32());
    }

    KeyStoreServiceReturnCode get_pubkey(const String16& name, hidl_vec<uint8_t>* pubkey) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeString16(name);
        status_t status = remote()->transact(BnKeystoreService::GET_PUBKEY, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("get_pubkey() could not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("get_pubkey() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        auto resultKey = readBlobAsByteArray(reply);
        if (pubkey) *pubkey = resultKey.value();
        return ResponseCode(reply.readInt32());
    }

    KeyStoreServiceReturnCode grant(const String16& name, int32_t granteeUid) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeString16(name);
        data.writeInt32(granteeUid);
        status_t status = remote()->transact(BnKeystoreService::GRANT, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("grant() could not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("grant() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        return ResponseCode(reply.readInt32());
    }

    KeyStoreServiceReturnCode ungrant(const String16& name, int32_t granteeUid) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeString16(name);
        data.writeInt32(granteeUid);
        status_t status = remote()->transact(BnKeystoreService::UNGRANT, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("ungrant() could not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("ungrant() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        return ResponseCode(reply.readInt32());
    }

    int64_t getmtime(const String16& name, int32_t uid) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeString16(name);
        data.writeInt32(uid);
        status_t status = remote()->transact(BnKeystoreService::GETMTIME, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("getmtime() could not contact remote: %d\n", status);
            return -1;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("getmtime() caught exception %d\n", err);
            return -1;
        }
        return reply.readInt64();
    }

    KeyStoreServiceReturnCode duplicate(const String16& srcKey, int32_t srcUid,
                                        const String16& destKey, int32_t destUid) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeString16(srcKey);
        data.writeInt32(srcUid);
        data.writeString16(destKey);
        data.writeInt32(destUid);
        status_t status = remote()->transact(BnKeystoreService::DUPLICATE, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("duplicate() could not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("duplicate() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        return ResponseCode(reply.readInt32());
    }

    int32_t is_hardware_backed(const String16& keyType) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeString16(keyType);
        status_t status = remote()->transact(BnKeystoreService::IS_HARDWARE_BACKED, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("is_hardware_backed() could not contact remote: %d\n", status);
            return -1;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("is_hardware_backed() caught exception %d\n", err);
            return -1;
        }
        return reply.readInt32();
    }

    KeyStoreServiceReturnCode clear_uid(int64_t uid) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeInt64(uid);
        status_t status = remote()->transact(BnKeystoreService::CLEAR_UID, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("clear_uid() could not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("clear_uid() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        return ResponseCode(reply.readInt32());
    }

    KeyStoreServiceReturnCode addRngEntropy(const hidl_vec<uint8_t>& entropy) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        writeBlobAsByteArray(entropy, &data);
        status_t status = remote()->transact(BnKeystoreService::ADD_RNG_ENTROPY, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("addRngEntropy() could not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("addRngEntropy() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        return ResponseCode(reply.readInt32());
    };

    KeyStoreServiceReturnCode generateKey(const String16& name,
                                          const hidl_vec<KeyParameter>& params,
                                          const hidl_vec<uint8_t>& entropy, int uid, int flags,
                                          KeyCharacteristics* outCharacteristics) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeString16(name);
        nullable(writeParamSetToParcel, params, &data);
        writeBlobAsByteArray(entropy, &data);
        data.writeInt32(uid);
        data.writeInt32(flags);
        status_t status = remote()->transact(BnKeystoreService::GENERATE_KEY, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("generateKey() could not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        ResponseCode ret = ResponseCode(reply.readInt32());
        if (err < 0) {
            ALOGD("generateKey() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        if (outCharacteristics) {
            *outCharacteristics = nullable(readKeyCharacteristicsFromParcel, reply).value();
        }
        return ret;
    }
    KeyStoreServiceReturnCode
    getKeyCharacteristics(const String16& name, const hidl_vec<uint8_t>& clientId,
                          const hidl_vec<uint8_t>& appData, int32_t uid,
                          KeyCharacteristics* outCharacteristics) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeString16(name);
        writeBlobAsByteArray(clientId, &data);
        writeBlobAsByteArray(appData, &data);
        data.writeInt32(uid);
        status_t status =
            remote()->transact(BnKeystoreService::GET_KEY_CHARACTERISTICS, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("getKeyCharacteristics() could not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        ResponseCode ret = ResponseCode(reply.readInt32());
        if (err < 0) {
            ALOGD("getKeyCharacteristics() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        if (outCharacteristics) {
            *outCharacteristics = nullable(readKeyCharacteristicsFromParcel, reply).value();
        }
        return ret;
    }
    KeyStoreServiceReturnCode importKey(const String16& name, const hidl_vec<KeyParameter>& params,
                                        KeyFormat format, const hidl_vec<uint8_t>& keyData, int uid,
                                        int flags,
                                        KeyCharacteristics* outCharacteristics) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeString16(name);
        nullable(writeParamSetToParcel, params, &data);
        data.writeInt32(uint32_t(format));
        writeBlobAsByteArray(keyData, &data);
        data.writeInt32(uid);
        data.writeInt32(flags);
        status_t status = remote()->transact(BnKeystoreService::IMPORT_KEY, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("importKey() could not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        ResponseCode ret = ResponseCode(reply.readInt32());
        if (err < 0) {
            ALOGD("importKey() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        if (outCharacteristics) {
            *outCharacteristics = nullable(readKeyCharacteristicsFromParcel, reply).value();
        }
        return ret;
    }

    void exportKey(const String16& name, KeyFormat format, const hidl_vec<uint8_t>& clientId,
                   const hidl_vec<uint8_t>& appData, int32_t uid, ExportResult* result) override {
        if (!result) {
            return;
        }

        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeString16(name);
        data.writeInt32(int32_t(format));
        writeBlobAsByteArray(clientId, &data);
        writeBlobAsByteArray(appData, &data);
        data.writeInt32(uid);
        status_t status = remote()->transact(BnKeystoreService::EXPORT_KEY, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("exportKey() could not contact remote: %d\n", status);
            result->resultCode = ResponseCode::SYSTEM_ERROR;
            return;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("exportKey() caught exception %d\n", err);
            result->resultCode = ResponseCode::SYSTEM_ERROR;
            return;
        }

        reply.readParcelable(result);
    }

    void begin(const sp<IBinder>& appToken, const String16& name, KeyPurpose purpose,
               bool pruneable, const hidl_vec<KeyParameter>& params,
               const hidl_vec<uint8_t>& entropy, int32_t uid, OperationResult* result) override {
        if (!result) {
            return;
        }
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeStrongBinder(appToken);
        data.writeString16(name);
        data.writeInt32(int32_t(purpose));
        data.writeInt32(pruneable ? 1 : 0);
        nullable(writeParamSetToParcel, params, &data);
        writeBlobAsByteArray(entropy, &data);
        data.writeInt32(uid);
        status_t status = remote()->transact(BnKeystoreService::BEGIN, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("begin() could not contact remote: %d\n", status);
            result->resultCode = ResponseCode::SYSTEM_ERROR;
            return;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("begin() caught exception %d\n", err);
            result->resultCode = ResponseCode::SYSTEM_ERROR;
            return;
        }

        reply.readParcelable(result);
    }

    void update(const sp<IBinder>& token, const hidl_vec<KeyParameter>& params,
                const hidl_vec<uint8_t>& opData, OperationResult* result) override {
        if (!result) {
            return;
        }
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeStrongBinder(token);
        nullable(writeParamSetToParcel, params, &data);
        writeBlobAsByteArray(opData, &data);
        status_t status = remote()->transact(BnKeystoreService::UPDATE, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("update() could not contact remote: %d\n", status);
            result->resultCode = ResponseCode::SYSTEM_ERROR;
            return;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("update() caught exception %d\n", err);
            result->resultCode = ResponseCode::SYSTEM_ERROR;
            return;
        }

        reply.readParcelable(result);
    }

    void finish(const sp<IBinder>& token, const hidl_vec<KeyParameter>& params,
                const hidl_vec<uint8_t>& signature, const hidl_vec<uint8_t>& entropy,
                OperationResult* result) override {
        if (!result) {
            return;
        }
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeStrongBinder(token);
        nullable(writeParamSetToParcel, params, &data);
        writeBlobAsByteArray(signature, &data);
        writeBlobAsByteArray(entropy, &data);
        status_t status = remote()->transact(BnKeystoreService::FINISH, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("finish() could not contact remote: %d\n", status);
            result->resultCode = ResponseCode::SYSTEM_ERROR;
            return;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("finish() caught exception %d\n", err);
            result->resultCode = ResponseCode::SYSTEM_ERROR;
            return;
        }

        reply.readParcelable(result);
    }

    KeyStoreServiceReturnCode abort(const sp<IBinder>& token) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeStrongBinder(token);
        status_t status = remote()->transact(BnKeystoreService::ABORT, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("abort() could not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("abort() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        return ResponseCode(reply.readInt32());
    }

    bool isOperationAuthorized(const sp<IBinder>& token) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeStrongBinder(token);
        status_t status =
            remote()->transact(BnKeystoreService::IS_OPERATION_AUTHORIZED, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("isOperationAuthorized() could not contact remote: %d\n", status);
            return false;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("isOperationAuthorized() caught exception %d\n", err);
            return false;
        }
        return reply.readInt32() == 1;
    }

    KeyStoreServiceReturnCode addAuthToken(const uint8_t* token, size_t length) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeByteArray(length, token);
        status_t status = remote()->transact(BnKeystoreService::ADD_AUTH_TOKEN, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("addAuthToken() could not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("addAuthToken() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        return ResponseCode(reply.readInt32());
    };

    KeyStoreServiceReturnCode onUserAdded(int32_t userId, int32_t parentId) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeInt32(userId);
        data.writeInt32(parentId);
        status_t status = remote()->transact(BnKeystoreService::ON_USER_ADDED, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("onUserAdded() could not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("onUserAdded() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        return ResponseCode(reply.readInt32());
    }

    KeyStoreServiceReturnCode onUserRemoved(int32_t userId) override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeInt32(userId);
        status_t status = remote()->transact(BnKeystoreService::ON_USER_REMOVED, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("onUserRemoved() could not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("onUserRemoved() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        return ResponseCode(reply.readInt32());
    }

    KeyStoreServiceReturnCode attestKey(const String16& name, const hidl_vec<KeyParameter>& params,
                                        hidl_vec<hidl_vec<uint8_t>>* outChain) override {
        if (!outChain) return ErrorCode::OUTPUT_PARAMETER_NULL;

        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        data.writeString16(name);
        nullable(writeParamSetToParcel, params, &data);

        status_t status = remote()->transact(BnKeystoreService::ATTEST_KEY, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("attestkey() count not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        ResponseCode ret = ResponseCode(reply.readInt32());
        if (err < 0) {
            ALOGD("attestKey() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        if (reply.readInt32() != 0) {
            *outChain = readCertificateChainFromParcel(reply);
        }
        return ret;
    }

    KeyStoreServiceReturnCode onDeviceOffBody() override {
        Parcel data, reply;
        data.writeInterfaceToken(IKeystoreService::getInterfaceDescriptor());
        status_t status = remote()->transact(BnKeystoreService::ON_DEVICE_OFF_BODY, data, &reply);
        if (status != NO_ERROR) {
            ALOGD("onDeviceOffBody() could not contact remote: %d\n", status);
            return ResponseCode::SYSTEM_ERROR;
        }
        int32_t err = reply.readExceptionCode();
        if (err < 0) {
            ALOGD("onDeviceOffBody() caught exception %d\n", err);
            return ResponseCode::SYSTEM_ERROR;
        }
        return ResponseCode(reply.readInt32());
    }
};

IMPLEMENT_META_INTERFACE(KeystoreService, "android.security.IKeystoreService");

// ----------------------------------------------------------------------

status_t BnKeystoreService::onTransact(uint32_t code, const Parcel& data, Parcel* reply,
                                       uint32_t flags) {
    switch (code) {
    case GET_STATE: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        int32_t userId = data.readInt32();
        int32_t ret = getState(userId);
        reply->writeNoException();
        reply->writeInt32(ret);
        return NO_ERROR;
    } break;
    case GET: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        String16 name = data.readString16();
        int32_t uid = data.readInt32();
        hidl_vec<uint8_t> out;
        auto ret = get(name, uid, &out);
        reply->writeNoException();
        if (ret.isOk()) {
            writeBlobAsByteArray(out, reply);
        } else {
            reply->writeInt32(-1);
        }
        reply->writeInt32(ret);
        return NO_ERROR;
    } break;
    case INSERT: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        String16 name = data.readString16();
        auto in = readBlobAsByteArray(data);
        int uid = data.readInt32();
        int32_t flags = data.readInt32();
        int32_t ret = insert(name, in.value(), uid, flags);
        reply->writeNoException();
        reply->writeInt32(ret);
        return NO_ERROR;
    } break;
    case DEL: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        String16 name = data.readString16();
        int uid = data.readInt32();
        int32_t ret = del(name, uid);
        reply->writeNoException();
        reply->writeInt32(ret);
        return NO_ERROR;
    } break;
    case EXIST: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        String16 name = data.readString16();
        int uid = data.readInt32();
        int32_t ret = exist(name, uid);
        reply->writeNoException();
        reply->writeInt32(ret);
        return NO_ERROR;
    } break;
    case LIST: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        String16 prefix = data.readString16();
        int uid = data.readInt32();
        Vector<String16> matches;
        int32_t ret = list(prefix, uid, &matches);
        reply->writeNoException();
        reply->writeInt32(matches.size());
        Vector<String16>::const_iterator it = matches.begin();
        for (; it != matches.end(); ++it) {
            reply->writeString16(*it);
        }
        reply->writeInt32(ret);
        return NO_ERROR;
    } break;
    case RESET: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        int32_t ret = reset();
        reply->writeNoException();
        reply->writeInt32(ret);
        return NO_ERROR;
    } break;
    case ON_USER_PASSWORD_CHANGED: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        int32_t userId = data.readInt32();
        String16 pass = data.readString16();
        int32_t ret = onUserPasswordChanged(userId, pass);
        reply->writeNoException();
        reply->writeInt32(ret);
        return NO_ERROR;
    } break;
    case LOCK: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        int32_t userId = data.readInt32();
        int32_t ret = lock(userId);
        reply->writeNoException();
        reply->writeInt32(ret);
        return NO_ERROR;
    } break;
    case UNLOCK: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        int32_t userId = data.readInt32();
        String16 pass = data.readString16();
        int32_t ret = unlock(userId, pass);
        reply->writeNoException();
        reply->writeInt32(ret);
        return NO_ERROR;
    } break;
    case IS_EMPTY: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        int32_t userId = data.readInt32();
        bool ret = isEmpty(userId);
        reply->writeNoException();
        reply->writeInt32(ret ? 1 : 0);
        return NO_ERROR;
    } break;
    case GENERATE: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        String16 name = data.readString16();
        int32_t uid = data.readInt32();
        int32_t keyType = data.readInt32();
        int32_t keySize = data.readInt32();
        int32_t flags = data.readInt32();
        Vector<sp<KeystoreArg>> args;
        int32_t argsPresent = data.readInt32();
        if (argsPresent == 1) {
            ssize_t numArgs = data.readInt32();
            if (numArgs > MAX_GENERATE_ARGS) {
                return BAD_VALUE;
            }
            if (numArgs > 0) {
                for (size_t i = 0; i < (size_t)numArgs; i++) {
                    ssize_t inSize = data.readInt32();
                    if (inSize >= 0 && (size_t)inSize <= data.dataAvail()) {
                        sp<KeystoreArg> arg = new KeystoreArg(data.readInplace(inSize), inSize);
                        args.push_back(arg);
                    } else {
                        args.push_back(NULL);
                    }
                }
            }
        }
        int32_t ret = generate(name, uid, keyType, keySize, flags, &args);
        reply->writeNoException();
        reply->writeInt32(ret);
        return NO_ERROR;
    } break;
    case IMPORT: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        String16 name = data.readString16();
        auto in = readBlobAsByteArray(data);
        int uid = data.readInt32();
        int32_t flags = data.readInt32();
        auto ret = import(name, in.value(), uid, flags);
        reply->writeNoException();
        reply->writeInt32(ret);
        return NO_ERROR;
    } break;
    case SIGN: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        String16 name = data.readString16();
        auto in = readBlobAsByteArray(data);
        hidl_vec<uint8_t> out;
        auto ret = sign(name, in.value(), &out);
        reply->writeNoException();
        writeBlobAsByteArray(out, reply);
        reply->writeInt32(ret);
        return NO_ERROR;
    } break;
    case VERIFY: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        String16 name = data.readString16();
        auto in = readBlobAsByteArray(data);
        auto signature = readBlobAsByteArray(data);
        auto ret = verify(name, in.value(), signature.value());
        reply->writeNoException();
        reply->writeInt32(ret);
        return NO_ERROR;
    } break;
    case GET_PUBKEY: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        String16 name = data.readString16();
        hidl_vec<uint8_t> out;
        auto ret = get_pubkey(name, &out);
        reply->writeNoException();
        writeBlobAsByteArray(out, reply);
        reply->writeInt32(ret);
        return NO_ERROR;
    } break;
    case GRANT: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        String16 name = data.readString16();
        int32_t granteeUid = data.readInt32();
        int32_t ret = grant(name, granteeUid);
        reply->writeNoException();
        reply->writeInt32(ret);
        return NO_ERROR;
    } break;
    case UNGRANT: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        String16 name = data.readString16();
        int32_t granteeUid = data.readInt32();
        int32_t ret = ungrant(name, granteeUid);
        reply->writeNoException();
        reply->writeInt32(ret);
        return NO_ERROR;
    } break;
    case GETMTIME: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        String16 name = data.readString16();
        int32_t uid = data.readInt32();
        int64_t ret = getmtime(name, uid);
        reply->writeNoException();
        reply->writeInt64(ret);
        return NO_ERROR;
    } break;
    case DUPLICATE: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        String16 srcKey = data.readString16();
        int32_t srcUid = data.readInt32();
        String16 destKey = data.readString16();
        int32_t destUid = data.readInt32();
        int32_t ret = duplicate(srcKey, srcUid, destKey, destUid);
        reply->writeNoException();
        reply->writeInt32(ret);
        return NO_ERROR;
    } break;
    case IS_HARDWARE_BACKED: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        String16 keyType = data.readString16();
        int32_t ret = is_hardware_backed(keyType);
        reply->writeNoException();
        reply->writeInt32(ret);
        return NO_ERROR;
    }
    case CLEAR_UID: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        int64_t uid = data.readInt64();
        int32_t ret = clear_uid(uid);
        reply->writeNoException();
        reply->writeInt32(ret);
        return NO_ERROR;
    }
    case ADD_RNG_ENTROPY: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        auto entropy = readBlobAsByteArray(data);
        auto ret = addRngEntropy(entropy.value());
        reply->writeNoException();
        reply->writeInt32(ret);
        return NO_ERROR;
    }
    case GENERATE_KEY: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        String16 name = data.readString16();
        auto params = nullable(readParamSetFromParcel, data);
        auto entropy = readBlobAsByteArray(data);
        int32_t uid = data.readInt32();
        int32_t flags = data.readInt32();
        KeyCharacteristics outCharacteristics;
        int32_t ret =
            generateKey(name, params.value(), entropy.value(), uid, flags, &outCharacteristics);
        reply->writeNoException();
        reply->writeInt32(ret);
        nullable(writeKeyCharacteristicsToParcel, outCharacteristics, reply);
        return NO_ERROR;
    }
    case GET_KEY_CHARACTERISTICS: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        String16 name = data.readString16();
        auto clientId = nullable(readKeymasterBlob, data, true);
        auto appData = nullable(readKeymasterBlob, data, true);
        int32_t uid = data.readInt32();
        KeyCharacteristics outCharacteristics;
        int ret = getKeyCharacteristics(name, clientId.value(), appData.value(), uid,
                                        &outCharacteristics);
        reply->writeNoException();
        reply->writeInt32(ret);
        nullable(writeKeyCharacteristicsToParcel, outCharacteristics, reply);
        return NO_ERROR;
    }
    case IMPORT_KEY: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        String16 name = data.readString16();
        auto args = nullable(readParamSetFromParcel, data);
        KeyFormat format = static_cast<KeyFormat>(data.readInt32());
        auto keyData = readBlobAsByteArray(data);
        int32_t uid = data.readInt32();
        int32_t flags = data.readInt32();
        KeyCharacteristics outCharacteristics;
        int32_t ret =
            importKey(name, args.value(), format, keyData.value(), uid, flags, &outCharacteristics);
        reply->writeNoException();
        reply->writeInt32(ret);
        nullable(writeKeyCharacteristicsToParcel, outCharacteristics, reply);
        return NO_ERROR;
    }
    case EXPORT_KEY: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        String16 name = data.readString16();
        KeyFormat format = static_cast<KeyFormat>(data.readInt32());
        auto clientId = nullable(readKeymasterBlob, data, true);
        auto appData = nullable(readKeymasterBlob, data, true);
        int32_t uid = data.readInt32();
        ExportResult result;
        exportKey(name, format, clientId.value(), appData.value(), uid, &result);
        reply->writeNoException();
        reply->writeParcelable(result);

        return NO_ERROR;
    }
    case BEGIN: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        sp<IBinder> token = data.readStrongBinder();
        String16 name = data.readString16();
        KeyPurpose purpose = static_cast<KeyPurpose>(data.readInt32());
        bool pruneable = data.readInt32() != 0;
        auto args = nullable(readParamSetFromParcel, data);
        auto entropy = readBlobAsByteArray(data);
        int32_t uid = data.readInt32();
        OperationResult result;
        begin(token, name, purpose, pruneable, args.value(), entropy.value(), uid, &result);
        reply->writeNoException();
        reply->writeParcelable(result);

        return NO_ERROR;
    }
    case UPDATE: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        sp<IBinder> token = data.readStrongBinder();
        auto args = nullable(readParamSetFromParcel, data);
        auto buf = readBlobAsByteArray(data);
        OperationResult result;
        update(token, args.value(), buf.value(), &result);
        reply->writeNoException();
        reply->writeParcelable(result);

        return NO_ERROR;
    }
    case FINISH: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        sp<IBinder> token = data.readStrongBinder();
        auto args = nullable(readParamSetFromParcel, data);
        auto signature = readBlobAsByteArray(data);
        auto entropy = readBlobAsByteArray(data);
        OperationResult result;
        finish(token, args.value(), signature.value(), entropy.value(), &result);
        reply->writeNoException();
        reply->writeParcelable(result);

        return NO_ERROR;
    }
    case ABORT: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        sp<IBinder> token = data.readStrongBinder();
        int32_t result = abort(token);
        reply->writeNoException();
        reply->writeInt32(result);

        return NO_ERROR;
    }
    case IS_OPERATION_AUTHORIZED: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        sp<IBinder> token = data.readStrongBinder();
        bool result = isOperationAuthorized(token);
        reply->writeNoException();
        reply->writeInt32(result ? 1 : 0);

        return NO_ERROR;
    }
    case ADD_AUTH_TOKEN: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        const uint8_t* token_bytes = NULL;
        size_t size = 0;
        readByteArray(data, &token_bytes, &size);
        int32_t result = addAuthToken(token_bytes, size);
        reply->writeNoException();
        reply->writeInt32(result);

        return NO_ERROR;
    }
    case ON_USER_ADDED: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        int32_t userId = data.readInt32();
        int32_t parentId = data.readInt32();
        int32_t result = onUserAdded(userId, parentId);
        reply->writeNoException();
        reply->writeInt32(result);

        return NO_ERROR;
    }
    case ON_USER_REMOVED: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        int32_t userId = data.readInt32();
        int32_t result = onUserRemoved(userId);
        reply->writeNoException();
        reply->writeInt32(result);

        return NO_ERROR;
    }
    case ATTEST_KEY: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        String16 name = data.readString16();
        auto params = nullable(readParamSetFromParcel, data);
        hidl_vec<hidl_vec<uint8_t>> chain;
        int ret = attestKey(name, params.value(), &chain);
        reply->writeNoException();
        reply->writeInt32(ret);
        nullable(writeCertificateChainToParcel, chain, reply);

        return NO_ERROR;
    }
    case ON_DEVICE_OFF_BODY: {
        CHECK_INTERFACE(IKeystoreService, data, reply);
        int32_t ret = onDeviceOffBody();
        reply->writeNoException();
        reply->writeInt32(ret);

        return NO_ERROR;
    }
    default:
        return BBinder::onTransact(code, data, reply, flags);
    }
}

// ----------------------------------------------------------------------------

};  // namespace android