OmniNX/Atmosphere
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ams: globally prefer R_RETURN to return for ams::Result

Browse Source
This commit is contained in:
Michael Scire
2022-03-26 14:48:33 -07:00
parent dd78ede99f
commit bbf22b4c60
325 changed files with 1955 additions and 1993 deletions
Download Patch File Download Diff File Expand all files Collapse all files

64
libraries/libstratosphere/source/spl/impl/spl_api_impl.cpp
View File

@@ -386,7 +386,7 @@ namespace ams::spl::impl {
u8 seed[Drbg::SeedSize];
if (smc::Result res = smc::GenerateRandomBytes(seed, sizeof(seed)); res != smc::Result::Success) {
return smc::ConvertResult(res);
R_RETURN(smc::ConvertResult(res));
}
util::GetReference(g_drbg).Reseed(seed, sizeof(seed), nullptr, 0);
@@ -409,9 +409,9 @@ namespace ams::spl::impl {
std::memcpy(layout.data, src, src_size);
if (g_is_modern_device_unique_data) {
return smc::ConvertResult(smc::DecryptDeviceUniqueData(layout.data, src_size, access_key, key_source, static_cast<smc::DeviceUniqueDataMode>(option)));
R_RETURN(smc::ConvertResult(smc::DecryptDeviceUniqueData(layout.data, src_size, access_key, key_source, static_cast<smc::DeviceUniqueDataMode>(option))));
} else {
return smc::ConvertResult(smc::DecryptAndStoreGcKey(layout.data, src_size, access_key, key_source, option));
R_RETURN(smc::ConvertResult(smc::DecryptAndStoreGcKey(layout.data, src_size, access_key, key_source, option)));
}
}
@@ -444,12 +444,12 @@ namespace ams::spl::impl {
smc::AsyncOperationKey op_key;
smc::Result res = smc::ModularExponentiateWithStorageKey(std::addressof(op_key), layout.base, layout.mod, mode);
if (res != smc::Result::Success) {
return smc::ConvertResult(res);
R_RETURN(smc::ConvertResult(res));
}
res = WaitAndGetResultData(g_work_buffer, out_size, op_key);
if (res != smc::Result::Success) {
return smc::ConvertResult(res);
R_RETURN(smc::ConvertResult(res));
}
}
@@ -490,12 +490,12 @@ namespace ams::spl::impl {
smc::AsyncOperationKey op_key;
smc::Result res = smc::PrepareEsDeviceUniqueKey(std::addressof(op_key), layout.base, layout.mod, label_digest, label_digest_size, smc::GetPrepareEsDeviceUniqueKeyOption(type, generation));
if (res != smc::Result::Success) {
return smc::ConvertResult(res);
R_RETURN(smc::ConvertResult(res));
}
res = WaitAndGetResultData(g_work_buffer, sizeof(*out_access_key), op_key);
if (res != smc::Result::Success) {
return smc::ConvertResult(res);
R_RETURN(smc::ConvertResult(res));
}
}
@@ -537,7 +537,7 @@ namespace ams::spl::impl {
res = smc::Result::Success;
}
return smc::ConvertResult(res);
R_RETURN(smc::ConvertResult(res));
}
Result ModularExponentiate(void *out, size_t out_size, const void *base, size_t base_size, const void *exp, size_t exp_size, const void *mod, size_t mod_size) {
@@ -573,12 +573,12 @@ namespace ams::spl::impl {
smc::AsyncOperationKey op_key;
smc::Result res = smc::ModularExponentiate(std::addressof(op_key), layout.base, layout.exp, exp_size, layout.mod);
if (res != smc::Result::Success) {
return smc::ConvertResult(res);
R_RETURN(smc::ConvertResult(res));
}
res = WaitAndGetResultData(g_work_buffer, out_size, op_key);
if (res != smc::Result::Success) {
return smc::ConvertResult(res);
R_RETURN(smc::ConvertResult(res));
}
}
@@ -629,7 +629,7 @@ namespace ams::spl::impl {
/* Crypto. */
Result GenerateAesKek(AccessKey *out_access_key, const KeySource &key_source, u32 generation, u32 option) {
return smc::ConvertResult(smc::GenerateAesKek(out_access_key, key_source, generation, option));
R_RETURN(smc::ConvertResult(smc::GenerateAesKek(out_access_key, key_source, generation, option)));
}
Result LoadAesKey(s32 keyslot, const AccessKey &access_key, const KeySource &key_source) {
@@ -653,14 +653,14 @@ namespace ams::spl::impl {
R_TRY(LoadAesKey(keyslot_holder.GetIndex(), access_key, KeyGenerationSource));
return smc::ConvertResult(DecryptAes(out_key, keyslot_holder.GetIndex(), std::addressof(key_source)));
R_RETURN(smc::ConvertResult(DecryptAes(out_key, keyslot_holder.GetIndex(), std::addressof(key_source))));
}
Result DecryptAesKey(AesKey *out_key, const KeySource &key_source, u32 generation, u32 option) {
AccessKey access_key;
R_TRY(GenerateAesKek(std::addressof(access_key), AesKeyDecryptionSource, generation, option));
return GenerateAesKey(out_key, access_key, key_source);
R_RETURN(GenerateAesKey(out_key, access_key, key_source));
}
Result ComputeCtr(void *dst, size_t dst_size, s32 keyslot, const void *src, size_t src_size, const IvCtr &iv_ctr) {
@@ -718,12 +718,12 @@ namespace ams::spl::impl {
smc::AsyncOperationKey op_key;
smc::Result res = smc::ComputeAes(std::addressof(op_key), dst_ll_addr, mode, iv_ctr, src_ll_addr, src_size);
if (res != smc::Result::Success) {
return smc::ConvertResult(res);
R_RETURN(smc::ConvertResult(res));
}
res = WaitAndGetResult(op_key);
if (res != smc::Result::Success) {
return smc::ConvertResult(res);
R_RETURN(smc::ConvertResult(res));
}
}
os::FlushDataCache(dst, dst_size);
@@ -737,12 +737,12 @@ namespace ams::spl::impl {
smc::AsyncOperationKey op_key;
smc::Result res = smc::ComputeAes(std::addressof(op_key), reinterpret_cast<uintptr_t>(dst), mode, iv_ctr, reinterpret_cast<uintptr_t>(src), src_size);
if (res != smc::Result::Success) {
return smc::ConvertResult(res);
R_RETURN(smc::ConvertResult(res));
}
res = WaitAndGetResult(op_key);
if (res != smc::Result::Success) {
return smc::ConvertResult(res);
R_RETURN(smc::ConvertResult(res));
}
}
#endif
@@ -754,7 +754,7 @@ namespace ams::spl::impl {
R_UNLESS(size <= sizeof(g_work_buffer), spl::ResultInvalidBufferSize());
std::memcpy(g_work_buffer, data, size);
return smc::ConvertResult(smc::ComputeCmac(out_cmac, GetPhysicalAesKeySlot(keyslot, true), g_work_buffer, size));
R_RETURN(smc::ConvertResult(smc::ComputeCmac(out_cmac, GetPhysicalAesKeySlot(keyslot, true), g_work_buffer, size)));
}
Result AllocateAesKeySlot(s32 *out_keyslot) {
@@ -842,22 +842,22 @@ namespace ams::spl::impl {
std::memcpy(dst, layout.data, copy_size);
}
return smc::ConvertResult(smc_res);
R_RETURN(smc::ConvertResult(smc_res));
}
/* SSL */
Result DecryptAndStoreSslClientCertKey(const void *src, size_t src_size, const AccessKey &access_key, const KeySource &key_source) {
return DecryptAndStoreDeviceUniqueKey(src, src_size, access_key, key_source, static_cast<u32>(smc::DeviceUniqueDataMode::DecryptAndStoreSslKey));
R_RETURN(DecryptAndStoreDeviceUniqueKey(src, src_size, access_key, key_source, static_cast<u32>(smc::DeviceUniqueDataMode::DecryptAndStoreSslKey)));
}
Result ModularExponentiateWithSslClientCertKey(void *out, size_t out_size, const void *base, size_t base_size, const void *mod, size_t mod_size) {
return ModularExponentiateWithStorageKey(out, out_size, base, base_size, mod, mod_size, smc::ModularExponentiateWithStorageKeyMode::Ssl);
R_RETURN(ModularExponentiateWithStorageKey(out, out_size, base, base_size, mod, mod_size, smc::ModularExponentiateWithStorageKeyMode::Ssl));
}
/* ES */
Result LoadEsDeviceKey(const void *src, size_t src_size, const AccessKey &access_key, const KeySource &key_source, u32 option) {
if (g_is_modern_device_unique_data) {
return DecryptAndStoreDeviceUniqueKey(src, src_size, access_key, key_source, option);
R_RETURN(DecryptAndStoreDeviceUniqueKey(src, src_size, access_key, key_source, option));
} else {
struct LoadEsDeviceKeyLayout {
u8 data[DeviceUniqueDataMetaDataSize + 2 * Rsa2048BlockSize + 0x10];
@@ -869,33 +869,33 @@ namespace ams::spl::impl {
std::memcpy(layout.data, src, src_size);
return smc::ConvertResult(smc::LoadEsDeviceKey(layout.data, src_size, access_key, key_source, option));
R_RETURN(smc::ConvertResult(smc::LoadEsDeviceKey(layout.data, src_size, access_key, key_source, option)));
}
}
Result PrepareEsTitleKey(AccessKey *out_access_key, const void *base, size_t base_size, const void *mod, size_t mod_size, const void *label_digest, size_t label_digest_size, u32 generation) {
return PrepareEsDeviceUniqueKey(out_access_key, base, base_size, mod, mod_size, label_digest, label_digest_size, smc::EsDeviceUniqueKeyType::TitleKey, generation);
R_RETURN(PrepareEsDeviceUniqueKey(out_access_key, base, base_size, mod, mod_size, label_digest, label_digest_size, smc::EsDeviceUniqueKeyType::TitleKey, generation));
}
Result PrepareCommonEsTitleKey(AccessKey *out_access_key, const KeySource &key_source, u32 generation) {
return smc::ConvertResult(smc::PrepareCommonEsTitleKey(out_access_key, key_source, generation));
R_RETURN(smc::ConvertResult(smc::PrepareCommonEsTitleKey(out_access_key, key_source, generation)));
}
Result DecryptAndStoreDrmDeviceCertKey(const void *src, size_t src_size, const AccessKey &access_key, const KeySource &key_source) {
return DecryptAndStoreDeviceUniqueKey(src, src_size, access_key, key_source, static_cast<u32>(smc::DeviceUniqueDataMode::DecryptAndStoreDrmDeviceCertKey));
R_RETURN(DecryptAndStoreDeviceUniqueKey(src, src_size, access_key, key_source, static_cast<u32>(smc::DeviceUniqueDataMode::DecryptAndStoreDrmDeviceCertKey)));
}
Result ModularExponentiateWithDrmDeviceCertKey(void *out, size_t out_size, const void *base, size_t base_size, const void *mod, size_t mod_size) {
return ModularExponentiateWithStorageKey(out, out_size, base, base_size, mod, mod_size, smc::ModularExponentiateWithStorageKeyMode::DrmDeviceCert);
R_RETURN(ModularExponentiateWithStorageKey(out, out_size, base, base_size, mod, mod_size, smc::ModularExponentiateWithStorageKeyMode::DrmDeviceCert));
}
Result PrepareEsArchiveKey(AccessKey *out_access_key, const void *base, size_t base_size, const void *mod, size_t mod_size, const void *label_digest, size_t label_digest_size, u32 generation) {
return PrepareEsDeviceUniqueKey(out_access_key, base, base_size, mod, mod_size, label_digest, label_digest_size, smc::EsDeviceUniqueKeyType::ArchiveKey, generation);
R_RETURN(PrepareEsDeviceUniqueKey(out_access_key, base, base_size, mod, mod_size, label_digest, label_digest_size, smc::EsDeviceUniqueKeyType::ArchiveKey, generation));
}
/* FS */
Result DecryptAndStoreGcKey(const void *src, size_t src_size, const AccessKey &access_key, const KeySource &key_source, u32 option) {
return DecryptAndStoreDeviceUniqueKey(src, src_size, access_key, key_source, option);
R_RETURN(DecryptAndStoreDeviceUniqueKey(src, src_size, access_key, key_source, option));
}
Result DecryptGcMessage(u32 *out_size, void *dst, size_t dst_size, const void *base, size_t base_size, const void *mod, size_t mod_size, const void *label_digest, size_t label_digest_size) {
@@ -914,7 +914,7 @@ namespace ams::spl::impl {
}
Result GenerateSpecificAesKey(AesKey *out_key, const KeySource &key_source, u32 generation, u32 which) {
return smc::ConvertResult(smc::GenerateSpecificAesKey(out_key, key_source, generation, which));
R_RETURN(smc::ConvertResult(smc::GenerateSpecificAesKey(out_key, key_source, generation, which)));
}
Result LoadPreparedAesKey(s32 keyslot, const AccessKey &access_key) {
@@ -937,7 +937,7 @@ namespace ams::spl::impl {
const smc::Result smc_res = smc::GetConfig(hash, 4, ConfigItem::Package2Hash);
if (smc_res != smc::Result::Success) {
return smc::ConvertResult(smc_res);
R_RETURN(smc::ConvertResult(smc_res));
}
std::memcpy(dst, hash, sizeof(hash));
@@ -970,7 +970,7 @@ namespace ams::spl::impl {
std::memcpy(dst, layout.data, std::min(dst_size, src_size));
}
return smc::ConvertResult(smc_res);
R_RETURN(smc::ConvertResult(smc_res));
}
}

50
libraries/libstratosphere/source/spl/spl_api.os.horizon.cpp
View File

@@ -34,18 +34,18 @@ namespace ams::spl {
constinit InitializeMode g_initialize_mode = InitializeMode::None;
Result AllocateAesKeySlotImpl(s32 *out) {
return serviceDispatchOut(splCryptoGetServiceSession(), 21, *out);
R_RETURN(serviceDispatchOut(splCryptoGetServiceSession(), 21, *out));
}
Result DeallocateAesKeySlotImpl(s32 slot) {
return serviceDispatchIn(splCryptoGetServiceSession(), 22, slot);
R_RETURN(serviceDispatchIn(splCryptoGetServiceSession(), 22, slot));
}
Result GetAesKeySlotAvailableEventImpl(os::NativeHandle *out) {
return serviceDispatch(splCryptoGetServiceSession(), 23,
R_RETURN(serviceDispatch(splCryptoGetServiceSession(), 23,
.out_handle_attrs = { SfOutHandleAttr_HipcCopy },
.out_handles = out,
);
));
}
void GetAesKeySlotAvailableEvent(os::SystemEvent *out) {
@@ -153,27 +153,27 @@ namespace ams::spl {
}
Result AllocateAesKeySlot(s32 *out_slot) {
return WaitAvailableKeySlotAndExecute([&]() -> Result {
return AllocateAesKeySlotImpl(out_slot);
});
R_RETURN(WaitAvailableKeySlotAndExecute([&]() -> Result {
R_RETURN(AllocateAesKeySlotImpl(out_slot));
}));
}
Result DeallocateAesKeySlot(s32 slot) {
return DeallocateAesKeySlotImpl(slot);
R_RETURN(DeallocateAesKeySlotImpl(slot));
}
Result GenerateAesKek(AccessKey *access_key, const void *key_source, size_t key_source_size, s32 generation, u32 option) {
AMS_ASSERT(key_source_size == sizeof(KeySource));
AMS_UNUSED(key_source_size);
return splCryptoGenerateAesKek(key_source, generation, option, static_cast<void *>(access_key));
R_RETURN(splCryptoGenerateAesKek(key_source, generation, option, static_cast<void *>(access_key)));
}
Result LoadAesKey(s32 slot, const AccessKey &access_key, const void *key_source, size_t key_source_size) {
AMS_ASSERT(key_source_size == sizeof(KeySource));
AMS_UNUSED(key_source_size);
return splCryptoLoadAesKey(std::addressof(access_key), key_source, static_cast<u32>(slot));
R_RETURN(splCryptoLoadAesKey(std::addressof(access_key), key_source, static_cast<u32>(slot)));
}
Result GenerateAesKey(void *dst, size_t dst_size, const AccessKey &access_key, const void *key_source, size_t key_source_size) {
@@ -181,9 +181,9 @@ namespace ams::spl {
AMS_ASSERT(key_source_size == sizeof(KeySource));
AMS_UNUSED(dst_size, key_source_size);
return WaitAvailableKeySlotAndExecute([&]() -> Result {
return splCryptoGenerateAesKey(std::addressof(access_key), key_source, dst);
});
R_RETURN(WaitAvailableKeySlotAndExecute([&]() -> Result {
R_RETURN(splCryptoGenerateAesKey(std::addressof(access_key), key_source, dst));
}));
}
Result GenerateSpecificAesKey(void *dst, size_t dst_size, const void *key_source, size_t key_source_size, s32 generation, u32 option) {
@@ -191,7 +191,7 @@ namespace ams::spl {
AMS_ASSERT(key_source_size == sizeof(KeySource));
AMS_UNUSED(dst_size, key_source_size);
return splFsGenerateSpecificAesKey(key_source, static_cast<u32>(generation), option, dst);
R_RETURN(splFsGenerateSpecificAesKey(key_source, static_cast<u32>(generation), option, dst));
}
Result ComputeCtr(void *dst, size_t dst_size, s32 slot, const void *src, size_t src_size, const void *iv, size_t iv_size) {
@@ -199,7 +199,7 @@ namespace ams::spl {
AMS_ASSERT(dst_size >= src_size);
AMS_UNUSED(dst_size, iv_size);
return splCryptoCryptAesCtr(src, dst, src_size, static_cast<s32>(slot), iv);
R_RETURN(splCryptoCryptAesCtr(src, dst, src_size, static_cast<s32>(slot), iv));
}
Result DecryptAesKey(void *dst, size_t dst_size, const void *key_source, size_t key_source_size, s32 generation, u32 option) {
@@ -207,17 +207,17 @@ namespace ams::spl {
AMS_ASSERT(key_source_size == sizeof(KeySource));
AMS_UNUSED(dst_size, key_source_size);
return WaitAvailableKeySlotAndExecute([&]() -> Result {
return splCryptoDecryptAesKey(key_source, static_cast<u32>(generation), option, dst);
});
R_RETURN(WaitAvailableKeySlotAndExecute([&]() -> Result {
R_RETURN(splCryptoDecryptAesKey(key_source, static_cast<u32>(generation), option, dst));
}));
}
Result GetConfig(u64 *out, ConfigItem item) {
return splGetConfig(static_cast<::SplConfigItem>(item), out);
R_RETURN(splGetConfig(static_cast<::SplConfigItem>(item), out));
}
Result SetConfig(ConfigItem item, u64 v) {
return splSetConfig(static_cast<::SplConfigItem>(item), v);
R_RETURN(splSetConfig(static_cast<::SplConfigItem>(item), v));
}
bool IsDevelopment() {
@@ -249,7 +249,7 @@ namespace ams::spl {
u32 v;
std::memcpy(std::addressof(v), std::addressof(boot_reason), sizeof(v));
return splSetBootReason(v);
R_RETURN(splSetBootReason(v));
}
Result GetBootReason(BootReasonValue *out) {
@@ -278,19 +278,19 @@ namespace ams::spl {
Result GetPackage2Hash(void *dst, size_t dst_size) {
AMS_ASSERT(dst_size >= crypto::Sha256Generator::HashSize);
AMS_UNUSED(dst_size);
return splFsGetPackage2Hash(dst);
R_RETURN(splFsGetPackage2Hash(dst));
}
Result GenerateRandomBytes(void *out, size_t buffer_size) {
return splGetRandomBytes(out, buffer_size);
R_RETURN(splGetRandomBytes(out, buffer_size));
}
Result LoadPreparedAesKey(s32 slot, const AccessKey &access_key) {
if (g_initialize_mode == InitializeMode::Fs) {
return splFsLoadTitlekey(std::addressof(access_key), static_cast<u32>(slot));
R_RETURN(splFsLoadTitlekey(std::addressof(access_key), static_cast<u32>(slot)));
} else {
/* TODO: libnx binding not available. */
/* return splEsLoadTitlekey(std::addressof(access_key), static_cast<u32>(slot)); */
/* R_RETURN(splEsLoadTitlekey(std::addressof(access_key), static_cast<u32>(slot))); */
AMS_ABORT_UNLESS(false);
}
}