/*
|
**
|
** Copyright 2016, 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 "keystore_aidl_hidl_marshalling_utils.h"
|
|
#include <keystore/ExportResult.h>
|
#include <keystore/KeyCharacteristics.h>
|
#include <keystore/KeymasterBlob.h>
|
#include <keystore/KeymasterCertificateChain.h>
|
#include <keystore/keymaster_types.h>
|
#include <keystore/keystore_hidl_support.h>
|
|
namespace keystore {
|
|
// reads byte[]
|
hidl_vec<uint8_t> readKeymasterBlob(const android::Parcel& in) {
|
|
ssize_t length = in.readInt32();
|
if (length <= 0) {
|
return {};
|
}
|
|
const void* buf = in.readInplace(length);
|
if (!buf) return {};
|
|
return blob2hidlVec(reinterpret_cast<const uint8_t*>(buf), size_t(length));
|
}
|
|
android::status_t writeKeymasterBlob(const hidl_vec<uint8_t>& blob, android::Parcel* out) {
|
int32_t size = int32_t(std::min<size_t>(blob.size(), std::numeric_limits<int32_t>::max()));
|
|
auto rc = out->writeInt32(size);
|
if (rc != ::android::OK) return rc;
|
|
if (!size) return ::android::OK;
|
|
return out->write(blob.data(), size);
|
}
|
|
android::status_t writeKeymasterBlob(const ::std::vector<int32_t>& blob, android::Parcel* out) {
|
|
int32_t size = int32_t(std::min<size_t>(blob.size(), std::numeric_limits<int32_t>::max()));
|
|
auto rc = out->writeInt32(size);
|
if (rc != ::android::OK) return rc;
|
|
if (!size) return ::android::OK;
|
|
return out->write(blob.data(), size);
|
}
|
|
NullOr<KeyParameter> readKeyParameterFromParcel(const android::Parcel& in) {
|
// Method must be in sync with KeymasterArgument.java
|
if (in.readInt32() == 0) {
|
return {};
|
}
|
KeyParameter result;
|
|
Tag tag = static_cast<Tag>(in.readInt32());
|
result.tag = tag;
|
switch (typeFromTag(tag)) {
|
case TagType::ENUM:
|
case TagType::ENUM_REP:
|
case TagType::UINT:
|
case TagType::UINT_REP:
|
result.f.integer = in.readInt32();
|
break;
|
case TagType::ULONG:
|
case TagType::ULONG_REP:
|
case TagType::DATE:
|
result.f.longInteger = in.readInt64();
|
break;
|
case TagType::BOOL:
|
result.f.boolValue = true;
|
break;
|
case TagType::BIGNUM:
|
case TagType::BYTES:
|
result.blob = readKeymasterBlob(in); // byte array
|
break;
|
default:
|
ALOGE("Unsupported KeyParameter tag %d", tag);
|
return {};
|
}
|
return result;
|
}
|
|
android::status_t writeKeyParameterToParcel(const KeyParameter& param, android::Parcel* out) {
|
// Method must be in sync with with KeymasterArgument.java
|
// Presence flag must be written by caller.
|
|
auto tag = param.tag;
|
auto rc = out->writeInt32(uint32_t(tag));
|
if (rc != ::android::OK) return rc;
|
switch (typeFromTag(param.tag)) {
|
case TagType::ENUM:
|
case TagType::ENUM_REP:
|
case TagType::UINT:
|
case TagType::UINT_REP:
|
rc = out->writeInt32(param.f.integer);
|
break;
|
case TagType::ULONG:
|
case TagType::ULONG_REP:
|
case TagType::DATE:
|
rc = out->writeInt64(param.f.longInteger);
|
break;
|
case TagType::BOOL:
|
// nothing to do here presence indicates true
|
break;
|
case TagType::BIGNUM:
|
case TagType::BYTES:
|
rc = writeKeymasterBlob(param.blob, out);
|
break;
|
default:
|
ALOGE("Failed to write KeyParameter: Unsupported tag %d", param.tag);
|
rc = android::BAD_VALUE;
|
break;
|
}
|
return rc;
|
}
|
|
hidl_vec<KeyParameter> readParamSetFromParcel(const android::Parcel& in) {
|
|
ssize_t length = in.readInt32(); // -1 for null
|
size_t ulength = (size_t)length;
|
if (length < 0) {
|
ulength = 0;
|
}
|
hidl_vec<KeyParameter> result;
|
result.resize(ulength);
|
for (size_t i = 0; i < ulength; ++i) {
|
auto param = readKeyParameterFromParcel(in);
|
if (!param.isOk()) {
|
ALOGE("Error reading KeyParameter from parcel");
|
return {};
|
}
|
result[i] = param.value();
|
}
|
return result;
|
}
|
|
android::status_t writeParamSetToParcel(const hidl_vec<KeyParameter>& params,
|
android::Parcel* out) {
|
int32_t size = int32_t(std::min<size_t>(params.size(), std::numeric_limits<int32_t>::max()));
|
|
auto rc = out->writeInt32(size);
|
if (rc != ::android::OK) return rc;
|
for (int32_t i = 0; i < size; ++i) {
|
rc = out->writeInt32(1); // writeTypedObject presence flag.
|
if (rc != ::android::OK) return rc;
|
rc = writeKeyParameterToParcel(params[i], out);
|
if (rc != ::android::OK) return rc;
|
}
|
return rc;
|
}
|
|
hidl_vec<hidl_vec<uint8_t>> readCertificateChainFromParcel(const android::Parcel& in) {
|
hidl_vec<hidl_vec<uint8_t>> result;
|
|
ssize_t count = in.readInt32();
|
size_t ucount = count;
|
if (count <= 0) {
|
return result;
|
}
|
|
result.resize(ucount);
|
|
for (size_t i = 0; i < ucount; ++i) {
|
result[i] = readKeymasterBlob(in);
|
}
|
return result;
|
};
|
|
android::status_t writeCertificateChainToParcel(const hidl_vec<hidl_vec<uint8_t>>& certs,
|
android::Parcel* out) {
|
int32_t count = int32_t(std::min<size_t>(certs.size(), std::numeric_limits<int32_t>::max()));
|
auto rc = out->writeInt32(count);
|
|
for (int32_t i = 0; i < count; ++i) {
|
rc = writeKeymasterBlob(certs[i], out);
|
if (rc != ::android::OK) return rc;
|
}
|
return rc;
|
}
|
|
}; // namespace keystore
|
|
// Implementation for keystore parcelables.
|
// TODO: split implementation into separate classes
|
namespace android {
|
namespace security {
|
namespace keymaster {
|
|
using ::android::status_t;
|
using ::keystore::keymaster::ErrorCode;
|
|
ExportResult::ExportResult() : resultCode() {}
|
|
ExportResult::~ExportResult() {}
|
|
status_t ExportResult::readFromParcel(const Parcel* inn) {
|
const Parcel& in = *inn;
|
resultCode = ErrorCode(in.readInt32());
|
exportData = keystore::readKeymasterBlob(in);
|
return OK;
|
}
|
|
status_t ExportResult::writeToParcel(Parcel* out) const {
|
out->writeInt32(resultCode.getErrorCode());
|
return keystore::writeKeymasterBlob(exportData, out);
|
}
|
|
status_t KeyCharacteristics::readFromParcel(const Parcel* in) {
|
softwareEnforced.readFromParcel(in);
|
return hardwareEnforced.readFromParcel(in);
|
}
|
|
status_t KeyCharacteristics::writeToParcel(Parcel* out) const {
|
softwareEnforced.writeToParcel(out);
|
return hardwareEnforced.writeToParcel(out);
|
}
|
|
status_t KeymasterBlob::readFromParcel(const Parcel* in) {
|
data_ = keystore::readKeymasterBlob(*in);
|
return OK;
|
}
|
|
status_t KeymasterBlob::writeToParcel(Parcel* out) const {
|
return keystore::writeKeymasterBlob(data_, out);
|
}
|
|
status_t KeymasterCertificateChain::readFromParcel(const Parcel* in) {
|
chain = keystore::readCertificateChainFromParcel(*in);
|
return OK;
|
}
|
|
status_t KeymasterCertificateChain::writeToParcel(Parcel* out) const {
|
return keystore::writeCertificateChainToParcel(chain, out);
|
}
|
|
} // namespace keymaster
|
} // namespace security
|
|
} // namespace android
|
