diff --git a/bdk/libs/nx_savedata/allocation_table.c b/bdk/libs/nx_savedata/allocation_table.c new file mode 100644 index 0000000..b6a0a52 --- /dev/null +++ b/bdk/libs/nx_savedata/allocation_table.c @@ -0,0 +1,281 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#include "allocation_table.h" +#include "allocation_table_iterator.h" + +#include + +void save_allocation_table_init(allocation_table_ctx_t *ctx, void *storage, allocation_table_header_t *header) { + ctx->base_storage = storage; + ctx->header = header; + ctx->free_list_entry_index = 0; +} + +void save_allocation_table_set_free_list_entry_index(allocation_table_ctx_t *ctx, uint32_t head_block_index) { + allocation_table_entry_t free_list = {0, head_block_index}; + save_allocation_table_write_entry(ctx, ctx->free_list_entry_index, &free_list); +} + +void save_allocation_table_set_free_list_block_index(allocation_table_ctx_t *ctx, uint32_t head_block_index) { + save_allocation_table_set_free_list_entry_index(ctx, allocation_table_block_to_entry_index(head_block_index)); +} + +uint32_t save_allocation_table_get_list_tail(allocation_table_ctx_t *ctx, uint32_t entry_index) { + uint32_t tail_index = entry_index; + uint32_t table_size = ctx->header->fat_storage_info.count; + uint32_t nodes_traversed = 0; + + allocation_table_entry_t *entry = save_allocation_table_read_entry(ctx, entry_index); + + while (!allocation_table_is_list_end(entry)) { + nodes_traversed++; + tail_index = allocation_table_get_next(entry); + entry = save_allocation_table_read_entry(ctx, tail_index); + if (nodes_traversed > table_size) { + EPRINTF("Cycle detected in allocation table!"); + return 0xFFFFFFFF; + } + } + + return tail_index; +} + +bool save_allocation_table_split(allocation_table_ctx_t *ctx, uint32_t segment_block_index, uint32_t first_sub_segment_length) { + uint32_t seg_a_index = allocation_table_block_to_entry_index(segment_block_index); + + allocation_table_entry_t *seg_a = save_allocation_table_read_entry(ctx, seg_a_index); + + if (!allocation_table_is_multi_block_segment(seg_a)) { + EPRINTF("Cannot split a single-entry segment!"); + return false; + } + + allocation_table_entry_t *seg_a_range = save_allocation_table_read_entry(ctx, seg_a_index + 1); + uint32_t original_length = allocation_table_get_next(seg_a_range) - allocation_table_get_prev(seg_a_range) + 1; + + if (first_sub_segment_length >= original_length) { + EPRINTFARGS("Requested sub-segment length (%x) must\n be less than the full segment length (%x)!", first_sub_segment_length, original_length); + return false; + } + + uint32_t seg_b_index = seg_a_index + first_sub_segment_length; + uint32_t seg_a_length = first_sub_segment_length; + uint32_t seg_b_length = original_length - seg_a_length; + + allocation_table_entry_t seg_b = {seg_a_index, allocation_table_get_next(seg_a)}; + allocation_table_set_next(seg_a, seg_b_index); + + if (!allocation_table_is_list_end(&seg_b)) { + allocation_table_entry_t *seg_c = save_allocation_table_read_entry(ctx, allocation_table_get_next(&seg_b)); + allocation_table_set_prev(seg_c, seg_b_index); + } + + if (seg_b_length > 1) { + allocation_table_make_multi_block_segment(&seg_b); + allocation_table_entry_t seg_b_range; + allocation_table_set_range(&seg_b_range, seg_b_index, seg_b_index + seg_b_length - 1); + save_allocation_table_write_entry(ctx, seg_b_index + 1, &seg_b_range); + save_allocation_table_write_entry(ctx, seg_b_index + seg_b_length - 1, &seg_b_range); + } + + save_allocation_table_write_entry(ctx, seg_b_index, &seg_b); + + if (seg_a_length == 1) { + allocation_table_make_single_block_segment(seg_a); + } else { + allocation_table_set_range(seg_a_range, seg_a_index, seg_a_index + seg_a_length - 1); + save_allocation_table_write_entry(ctx, seg_a_index + seg_a_length - 1, seg_a_range); + } + + return true; +} + +uint32_t save_allocation_table_trim(allocation_table_ctx_t *ctx, uint32_t list_head_block_index, uint32_t new_list_length) { + uint32_t blocks_remaining = new_list_length; + uint32_t next_entry = allocation_table_block_to_entry_index(list_head_block_index); + uint32_t list_a_index = 0xFFFFFFFF; + uint32_t list_b_index = 0xFFFFFFFF; + + while (blocks_remaining > 0) { + if (next_entry == 0) + return 0xFFFFFFFF; + + uint32_t current_entry_index = next_entry; + + allocation_table_entry_t entry; + uint32_t segment_length = save_allocation_table_read_entry_with_length(ctx, allocation_table_entry_index_to_block(current_entry_index), &entry); + if (segment_length == 0) { + EPRINTF("Invalid entry detected in allocation table!"); + return 0xFFFFFFFF; + } + + next_entry = allocation_table_block_to_entry_index(entry.next); + + if (segment_length == blocks_remaining) { + list_a_index = current_entry_index; + list_b_index = next_entry; + } else if (segment_length > blocks_remaining) { + if (!save_allocation_table_split(ctx, allocation_table_entry_index_to_block(current_entry_index), blocks_remaining)) + return 0xFFFFFFFF; + list_a_index = current_entry_index; + list_b_index = current_entry_index + blocks_remaining; + segment_length = blocks_remaining; + } + + blocks_remaining -= segment_length; + } + + if (list_a_index == 0xFFFFFFFF || list_b_index == 0xFFFFFFFF) + return 0xFFFFFFFF; + + allocation_table_entry_t *list_a_node = save_allocation_table_read_entry(ctx, list_a_index); + allocation_table_entry_t *list_b_node = save_allocation_table_read_entry(ctx, list_b_index); + + allocation_table_set_next(list_a_node, 0); + allocation_table_make_list_start(list_b_node); + + return allocation_table_entry_index_to_block(list_b_index); +} + +bool save_allocation_table_join(allocation_table_ctx_t *ctx, uint32_t front_list_block_index, uint32_t back_list_block_index) { + uint32_t front_entry_index = allocation_table_block_to_entry_index(front_list_block_index); + uint32_t back_entry_index = allocation_table_block_to_entry_index(back_list_block_index); + + uint32_t front_tail_index = save_allocation_table_get_list_tail(ctx, front_entry_index); + if (front_tail_index == 0xFFFFFFFF) + return false; + + allocation_table_entry_t *front_tail = save_allocation_table_read_entry(ctx, front_tail_index); + allocation_table_entry_t *back_head = save_allocation_table_read_entry(ctx, back_entry_index); + + allocation_table_set_next(front_tail, back_entry_index); + allocation_table_set_prev(back_head, front_tail_index); + + return true; +} + +uint32_t save_allocation_table_allocate(allocation_table_ctx_t *ctx, uint32_t block_count) { + uint32_t free_list = save_allocation_table_get_free_list_block_index(ctx); + uint32_t new_free_list = save_allocation_table_trim(ctx, free_list, block_count); + if (new_free_list == 0xFFFFFFFF) + return 0xFFFFFFFF; + + save_allocation_table_set_free_list_block_index(ctx, new_free_list); + + return free_list; +} + +bool save_allocation_table_free(allocation_table_ctx_t *ctx, uint32_t list_block_index) { + uint32_t list_entry_index = allocation_table_block_to_entry_index(list_block_index); + allocation_table_entry_t *list_entry = save_allocation_table_read_entry(ctx, list_entry_index); + + if (!allocation_table_is_list_start(list_entry)) { + EPRINTF("The block to free must be the start of a list!"); + return false; + } + + uint32_t free_list_index = save_allocation_table_get_free_list_entry_index(ctx); + + if (free_list_index == 0) { + save_allocation_table_set_free_list_entry_index(ctx, list_entry_index); + return true; + } + + save_allocation_table_join(ctx, list_block_index, allocation_table_entry_index_to_block(free_list_index)); + save_allocation_table_set_free_list_block_index(ctx, list_block_index); + + return true; +} + +uint32_t save_allocation_table_read_entry_with_length(allocation_table_ctx_t *ctx, uint32_t block_index, allocation_table_entry_t *entry) { + uint32_t length; + uint32_t entry_index = allocation_table_block_to_entry_index(block_index); + + allocation_table_entry_t *entries = save_allocation_table_read_entry(ctx, entry_index); + if (allocation_table_is_single_block_segment(&entries[0])) { + length = 1; + if (allocation_table_is_range_entry(&entries[0])) { + EPRINTF("Invalid range entry in allocation table!"); + return 0; + } + } else { + length = entries[1].next - entry_index + 1; + } + + if (allocation_table_is_list_end(&entries[0])) { + entry->next = 0xFFFFFFFF; + } else { + entry->next = allocation_table_entry_index_to_block(allocation_table_get_next(&entries[0])); + } + + if (allocation_table_is_list_start(&entries[0])) { + entry->prev = 0xFFFFFFFF; + } else { + entry->prev = allocation_table_entry_index_to_block(allocation_table_get_prev(&entries[0])); + } + + return length; +} + +uint32_t save_allocation_table_get_list_length(allocation_table_ctx_t *ctx, uint32_t block_index) { + allocation_table_entry_t entry = {0, block_index}; + uint32_t total_length = 0; + uint32_t table_size = ctx->header->fat_storage_info.count; + uint32_t nodes_iterated = 0; + + while (entry.next != 0xFFFFFFFF) { + uint32_t length = save_allocation_table_read_entry_with_length(ctx, entry.next, &entry); + if (length == 0) { + EPRINTF("Invalid entry detected in allocation table!"); + return 0; + } + total_length += length; + nodes_iterated++; + if (nodes_iterated > table_size) { + EPRINTF("Cycle detected in allocation table!"); + return 0; + } + } + return total_length; +} + +uint32_t save_allocation_table_get_free_list_length(allocation_table_ctx_t *ctx) { + uint32_t free_list_start = save_allocation_table_get_free_list_block_index(ctx); + + if (free_list_start == 0xFFFFFFFF) + return 0; + + return save_allocation_table_get_list_length(ctx, free_list_start); +} diff --git a/bdk/libs/nx_savedata/allocation_table.h b/bdk/libs/nx_savedata/allocation_table.h new file mode 100644 index 0000000..97b3a85 --- /dev/null +++ b/bdk/libs/nx_savedata/allocation_table.h @@ -0,0 +1,171 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef _ALLOCATION_TABLE_H_ +#define _ALLOCATION_TABLE_H_ + +#include "storage.h" + +#include +#include +#include + +#define SAVE_FAT_ENTRY_SIZE 8 + +typedef struct { + uint64_t offset; + uint32_t count; + uint32_t _0xC; +} storage_info_t; + +typedef struct { + uint64_t block_size; + storage_info_t fat_storage_info; + storage_info_t data_storage_info; + uint32_t directory_table_block; + uint32_t file_table_block; +} allocation_table_header_t; + +static_assert(sizeof(allocation_table_header_t) == 0x30, "Allocation table header size is wrong!"); + +typedef struct { + uint32_t prev; + uint32_t next; +} allocation_table_entry_t; + +typedef struct { + uint32_t free_list_entry_index; + void *base_storage; + allocation_table_header_t *header; +} allocation_table_ctx_t; + +static ALWAYS_INLINE uint32_t allocation_table_entry_index_to_block(uint32_t entry_index) { + return entry_index - 1; +} + +static ALWAYS_INLINE uint32_t allocation_table_block_to_entry_index(uint32_t block_index) { + return block_index + 1; +} + +static ALWAYS_INLINE int allocation_table_get_prev(allocation_table_entry_t *entry) { + return entry->prev & 0x7FFFFFFF; +} + +static ALWAYS_INLINE int allocation_table_get_next(allocation_table_entry_t *entry) { + return entry->next & 0x7FFFFFFF; +} + +static ALWAYS_INLINE int allocation_table_is_list_start(allocation_table_entry_t *entry) { + return entry->prev == 0x80000000; +} + +static ALWAYS_INLINE int allocation_table_is_list_end(allocation_table_entry_t *entry) { + return (entry->next & 0x7FFFFFFF) == 0; +} + +static ALWAYS_INLINE bool allocation_table_is_multi_block_segment(allocation_table_entry_t *entry) { + return entry->next & 0x80000000; +} + +static ALWAYS_INLINE void allocation_table_make_multi_block_segment(allocation_table_entry_t *entry) { + entry->next |= 0x80000000; +} + +static ALWAYS_INLINE void allocation_table_make_single_block_segment(allocation_table_entry_t *entry) { + entry->next &= 0x7FFFFFFF; +} + +static ALWAYS_INLINE bool allocation_table_is_single_block_segment(allocation_table_entry_t *entry) { + return (entry->next & 0x80000000) == 0; +} + +static ALWAYS_INLINE void allocation_table_make_list_start(allocation_table_entry_t *entry) { + entry->prev = 0x80000000; +} + +static ALWAYS_INLINE bool allocation_table_is_range_entry(allocation_table_entry_t *entry) { + return (entry->prev & 0x80000000) == 0x80000000 && entry->prev != 0x80000000; +} + +static ALWAYS_INLINE void allocation_table_make_range_entry(allocation_table_entry_t *entry) { + entry->prev |= 0x80000000; +} + +static ALWAYS_INLINE void allocation_table_set_next(allocation_table_entry_t *entry, int val) { + entry->next = (entry->next & 0x80000000) | val; +} + +static ALWAYS_INLINE void allocation_table_set_prev(allocation_table_entry_t *entry, int val) { + entry->prev = val; +} + +static ALWAYS_INLINE void allocation_table_set_range(allocation_table_entry_t *entry, int start_index, int end_index) { + entry->next = end_index; + entry->prev = start_index; + allocation_table_make_range_entry(entry); +} + +static ALWAYS_INLINE uint64_t allocation_table_query_size(uint32_t block_count) { + return SAVE_FAT_ENTRY_SIZE * allocation_table_block_to_entry_index(block_count); +} + +static ALWAYS_INLINE allocation_table_entry_t *save_allocation_table_read_entry(allocation_table_ctx_t *ctx, uint32_t entry_index) { + return (allocation_table_entry_t *)((uint8_t *)ctx->base_storage + entry_index * SAVE_FAT_ENTRY_SIZE); +} + +static ALWAYS_INLINE void save_allocation_table_write_entry(allocation_table_ctx_t *ctx, uint32_t entry_index, allocation_table_entry_t *entry) { + memcpy((uint8_t *)ctx->base_storage + entry_index * SAVE_FAT_ENTRY_SIZE, entry, SAVE_FAT_ENTRY_SIZE); +} + +static ALWAYS_INLINE uint32_t save_allocation_table_get_free_list_entry_index(allocation_table_ctx_t *ctx) { + return allocation_table_get_next(save_allocation_table_read_entry(ctx, ctx->free_list_entry_index)); +} + +static ALWAYS_INLINE uint32_t save_allocation_table_get_free_list_block_index(allocation_table_ctx_t *ctx) { + return allocation_table_entry_index_to_block(save_allocation_table_get_free_list_entry_index(ctx)); +} + +void save_allocation_table_init(allocation_table_ctx_t *ctx, void *storage, allocation_table_header_t *header); +void save_allocation_table_set_free_list_entry_index(allocation_table_ctx_t *ctx, uint32_t head_block_index); +void save_allocation_table_set_free_list_block_index(allocation_table_ctx_t *ctx, uint32_t head_block_index); +bool save_allocation_table_split(allocation_table_ctx_t *ctx, uint32_t segment_block_index, uint32_t first_sub_segment_length); +uint32_t save_allocation_table_trim(allocation_table_ctx_t *ctx, uint32_t list_head_block_index, uint32_t new_list_length); +bool save_allocation_table_join(allocation_table_ctx_t *ctx, uint32_t front_list_block_index, uint32_t back_list_block_index); +uint32_t save_allocation_table_allocate(allocation_table_ctx_t *ctx, uint32_t block_count); +bool save_allocation_table_free(allocation_table_ctx_t *ctx, uint32_t list_block_index); +uint32_t save_allocation_table_read_entry_with_length(allocation_table_ctx_t *ctx, uint32_t block_index, allocation_table_entry_t *entry); +uint32_t save_allocation_table_get_list_length(allocation_table_ctx_t *ctx, uint32_t block_index); +uint32_t save_allocation_table_get_free_list_length(allocation_table_ctx_t *ctx); + +#endif diff --git a/bdk/libs/nx_savedata/allocation_table_iterator.c b/bdk/libs/nx_savedata/allocation_table_iterator.c new file mode 100644 index 0000000..957e17d --- /dev/null +++ b/bdk/libs/nx_savedata/allocation_table_iterator.c @@ -0,0 +1,111 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#include "allocation_table_iterator.h" + +#include + +bool save_allocation_table_iterator_begin(allocation_table_iterator_ctx_t *ctx, allocation_table_ctx_t *table, uint32_t initial_block) { + ctx->fat = table; + ctx->physical_block = initial_block; + ctx->virtual_block = 0; + + allocation_table_entry_t entry; + ctx->current_segment_size = save_allocation_table_read_entry_with_length(ctx->fat, initial_block, &entry); + if (ctx->current_segment_size == 0) { + EPRINTF("Invalid entry detected in allocation table!"); + return false; + } + ctx->next_block = entry.next; + ctx->prev_block = entry.prev; + + if (ctx->prev_block != 0xFFFFFFFF) { + EPRINTFARGS("Attempted to start FAT iteration from\n invalid block %x!", initial_block); + return false; + } + return true; +} + +bool save_allocation_table_iterator_move_next(allocation_table_iterator_ctx_t *ctx) { + if (ctx->next_block == 0xFFFFFFFF) + return false; + + ctx->virtual_block += ctx->current_segment_size; + ctx->physical_block = ctx->next_block; + + allocation_table_entry_t entry; + ctx->current_segment_size = save_allocation_table_read_entry_with_length(ctx->fat, ctx->next_block, &entry); + if (ctx->current_segment_size == 0) { + EPRINTF("Invalid entry detected in allocation table!"); + return false; + } + ctx->next_block = entry.next; + ctx->prev_block = entry.prev; + + return true; +} + +bool save_allocation_table_iterator_move_prev(allocation_table_iterator_ctx_t *ctx) { + if (ctx->prev_block == 0xFFFFFFFF) + return false; + + ctx->physical_block = ctx->prev_block; + + allocation_table_entry_t entry; + ctx->current_segment_size = save_allocation_table_read_entry_with_length(ctx->fat, ctx->prev_block, &entry); + if (ctx->current_segment_size == 0) { + EPRINTF("Invalid entry detected in allocation table!"); + return false; + } + ctx->next_block = entry.next; + ctx->prev_block = entry.prev; + + ctx->virtual_block -= ctx->current_segment_size; + + return true; +} + +bool save_allocation_table_iterator_seek(allocation_table_iterator_ctx_t *ctx, uint32_t block) { + for ( ; ; ) { + if (block < ctx->virtual_block) { + if (!save_allocation_table_iterator_move_prev(ctx)) + return false; + } else if (block >= ctx->virtual_block + ctx->current_segment_size) { + if (!save_allocation_table_iterator_move_next(ctx)) + return false; + } else { + return true; + } + } +} diff --git a/bdk/libs/nx_savedata/allocation_table_iterator.h b/bdk/libs/nx_savedata/allocation_table_iterator.h new file mode 100644 index 0000000..8c5ea74 --- /dev/null +++ b/bdk/libs/nx_savedata/allocation_table_iterator.h @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef _ALLOCATION_TABLE_ITER_H_ +#define _ALLOCATION_TABLE_ITER_H_ + +#include "allocation_table.h" + +#include + +typedef struct { + allocation_table_ctx_t *fat; + uint32_t virtual_block; + uint32_t physical_block; + uint32_t current_segment_size; + uint32_t next_block; + uint32_t prev_block; +} allocation_table_iterator_ctx_t; + +bool save_allocation_table_iterator_begin(allocation_table_iterator_ctx_t *ctx, allocation_table_ctx_t *table, uint32_t initial_block); +bool save_allocation_table_iterator_move_next(allocation_table_iterator_ctx_t *ctx); +bool save_allocation_table_iterator_move_prev(allocation_table_iterator_ctx_t *ctx); +bool save_allocation_table_iterator_seek(allocation_table_iterator_ctx_t *ctx, uint32_t block); + +#endif diff --git a/bdk/libs/nx_savedata/allocation_table_storage.c b/bdk/libs/nx_savedata/allocation_table_storage.c new file mode 100644 index 0000000..43cea04 --- /dev/null +++ b/bdk/libs/nx_savedata/allocation_table_storage.c @@ -0,0 +1,158 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#include "allocation_table_storage.h" + +#include "allocation_table_iterator.h" + +#include + +void save_allocation_table_storage_init(allocation_table_storage_ctx_t *ctx, substorage *data, allocation_table_ctx_t *table, uint32_t block_size, uint32_t initial_block) { + ctx->base_storage = data; + ctx->block_size = block_size; + ctx->fat = table; + ctx->initial_block = initial_block; + ctx->_length = initial_block == 0xFFFFFFFF ? 0 : save_allocation_table_get_list_length(table, initial_block) * block_size; +} + +uint32_t save_allocation_table_storage_read(allocation_table_storage_ctx_t *ctx, void *buffer, uint64_t offset, uint64_t count) { + allocation_table_iterator_ctx_t iterator; + if (!save_allocation_table_iterator_begin(&iterator, ctx->fat, ctx->initial_block)) + return 0; + uint64_t in_pos = offset; + uint32_t out_pos = 0; + uint32_t remaining = count; + + while (remaining) { + uint32_t block_num = (uint32_t)(in_pos / ctx->block_size); + if (!save_allocation_table_iterator_seek(&iterator, block_num)) { + EPRINTFARGS("Invalid allocation table offset: %x", (uint32_t)offset); + return 0; + } + + uint32_t segment_pos = (uint32_t)(in_pos - (uint64_t)iterator.virtual_block * ctx->block_size); + uint64_t physical_offset = iterator.physical_block * ctx->block_size + segment_pos; + + uint32_t remaining_in_segment = iterator.current_segment_size * ctx->block_size - segment_pos; + uint32_t bytes_to_read = MIN(remaining, remaining_in_segment); + + if (substorage_read(ctx->base_storage, (uint8_t *)buffer + out_pos, physical_offset, bytes_to_read) != bytes_to_read) + return 0; + + out_pos += bytes_to_read; + in_pos += bytes_to_read; + remaining -= bytes_to_read; + } + return out_pos; +} + +uint32_t save_allocation_table_storage_write(allocation_table_storage_ctx_t *ctx, const void *buffer, uint64_t offset, uint64_t count) { + allocation_table_iterator_ctx_t iterator; + if (!save_allocation_table_iterator_begin(&iterator, ctx->fat, ctx->initial_block)) + return 0; + uint64_t in_pos = offset; + uint32_t out_pos = 0; + uint32_t remaining = count; + + while (remaining) { + uint32_t block_num = (uint32_t)(in_pos / ctx->block_size); + if (!save_allocation_table_iterator_seek(&iterator, block_num)) { + EPRINTFARGS("Invalid allocation table offset: %x", (uint32_t)offset); + return 0; + } + + uint32_t segment_pos = (uint32_t)(in_pos - (uint64_t)iterator.virtual_block * ctx->block_size); + uint64_t physical_offset = iterator.physical_block * ctx->block_size + segment_pos; + + uint32_t remaining_in_segment = iterator.current_segment_size * ctx->block_size - segment_pos; + uint32_t bytes_to_write = MIN(remaining, remaining_in_segment); + + + if (substorage_write(ctx->base_storage, (uint8_t *)buffer + out_pos, physical_offset, bytes_to_write) != bytes_to_write) + return 0; + + out_pos += bytes_to_write; + in_pos += bytes_to_write; + remaining -= bytes_to_write; + } + return out_pos; +} + +bool save_allocation_table_storage_set_size(allocation_table_storage_ctx_t *ctx, uint64_t size) { + uint32_t old_block_count = (uint32_t)DIV_ROUND_UP(ctx->_length, ctx->block_size); + uint32_t new_block_count = (uint32_t)DIV_ROUND_UP(size, ctx->block_size); + + if (old_block_count == new_block_count) + return true; + + if (old_block_count == 0) { + ctx->initial_block = save_allocation_table_allocate(ctx->fat, new_block_count); + if (ctx->initial_block == 0xFFFFFFFF) { + EPRINTF("Not enough space to resize file!"); + return false; + } + ctx->_length = new_block_count * ctx->block_size; + return true; + } + + if (new_block_count == 0) { + save_allocation_table_free(ctx->fat, ctx->initial_block); + + ctx->initial_block = 0x80000000; + ctx->_length = 0; + return true; + } + + if (new_block_count > old_block_count) { + uint32_t new_blocks = save_allocation_table_allocate(ctx->fat, new_block_count - old_block_count); + if (new_blocks == 0xFFFFFFFF) { + EPRINTF("Not enough space to resize file!"); + return false; + } + if (!save_allocation_table_join(ctx->fat, ctx->initial_block, new_blocks)) + return false; + } else { + uint32_t old_blocks = save_allocation_table_trim(ctx->fat, ctx->initial_block, new_block_count); + if (old_blocks == 0xFFFFFFFF) { + EPRINTF("Failure to trim!"); + return false; + } + if (!save_allocation_table_free(ctx->fat, old_blocks)) + return false; + } + + ctx->_length = new_block_count * ctx->block_size; + + return true; +} diff --git a/bdk/libs/nx_savedata/allocation_table_storage.h b/bdk/libs/nx_savedata/allocation_table_storage.h new file mode 100644 index 0000000..86f55cf --- /dev/null +++ b/bdk/libs/nx_savedata/allocation_table_storage.h @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef _ALLOCATION_TABLE_STORAGE_H_ +#define _ALLOCATION_TABLE_STORAGE_H_ + +#include "allocation_table.h" +#include "storage.h" + +#include + +typedef struct { + substorage *base_storage; + uint32_t block_size; + uint32_t initial_block; + allocation_table_ctx_t *fat; + uint64_t _length; +} allocation_table_storage_ctx_t; + +static ALWAYS_INLINE void save_allocation_table_storage_get_size(allocation_table_storage_ctx_t *ctx, uint64_t *out_size) { + *out_size = ctx->_length; +} + +void save_allocation_table_storage_init(allocation_table_storage_ctx_t *ctx, substorage *data, allocation_table_ctx_t *table, uint32_t block_size, uint32_t initial_block); +uint32_t save_allocation_table_storage_read(allocation_table_storage_ctx_t *ctx, void *buffer, uint64_t offset, uint64_t count); +uint32_t save_allocation_table_storage_write(allocation_table_storage_ctx_t *ctx, const void *buffer, uint64_t offset, uint64_t count); +bool save_allocation_table_storage_set_size(allocation_table_storage_ctx_t *ctx, uint64_t size); + +#endif diff --git a/bdk/libs/nx_savedata/cached_storage.c b/bdk/libs/nx_savedata/cached_storage.c new file mode 100644 index 0000000..52d38a3 --- /dev/null +++ b/bdk/libs/nx_savedata/cached_storage.c @@ -0,0 +1,227 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#include "cached_storage.h" + +#include +#include + +#include + +static ALWAYS_INLINE cache_block_t *cache_block_init(cached_storage_ctx_t *ctx) { + cache_block_t *block = calloc(1, sizeof(cache_block_t)); + block->buffer = malloc(ctx->block_size); + block->index = -1; + return block; +} + +void save_cached_storage_init(cached_storage_ctx_t *ctx, substorage *base_storage, uint32_t block_size, uint32_t cache_size) { + memcpy(&ctx->base_storage, base_storage, sizeof(substorage)); + ctx->block_size = block_size; + substorage_get_size(base_storage, &ctx->length); + ctx->cache_size = cache_size; + + list_init(&ctx->blocks); + for (uint32_t i = 0; i < cache_size; i++) { + cache_block_t *block = cache_block_init(ctx); + list_append(&ctx->blocks, &block->link); + } +} + +void save_cached_storage_init_from_sector_storage(cached_storage_ctx_t *ctx, sector_storage *base_storage, uint32_t cache_size) { + save_cached_storage_init(ctx, &base_storage->base_storage, base_storage->sector_size, cache_size); +} + +static void cache_block_finalize(cache_block_t **block) { + free((*block)->buffer); + free(*block); +} + +void save_cached_storage_finalize(cached_storage_ctx_t *ctx) { + LIST_FOREACH_SAFE(curr_block, &ctx->blocks) { + cache_block_t *block = CONTAINER_OF(curr_block, cache_block_t, link) ; + cache_block_finalize(&block); + } +} + +static bool try_get_block_by_value(cached_storage_ctx_t *ctx, uint64_t index, cache_block_t **out_block) { + LIST_FOREACH_ENTRY(cache_block_t, block, &ctx->blocks, link) { + if (block->index == index) { + *out_block = block; + return true; + } + } + return false; +} + +static bool flush_block(cached_storage_ctx_t *ctx, cache_block_t *block) { + if (!block->dirty) + return true; + + uint64_t offset = block->index * ctx->block_size; + if (substorage_write(&ctx->base_storage, block->buffer, offset, block->length) != block->length) { + EPRINTF("Cached storage: Failed to write block!"); + return false; + } + block->dirty = false; + + return true; +} + +static bool read_block(cached_storage_ctx_t *ctx, cache_block_t *block, uint64_t index) { + uint64_t offset = index * ctx->block_size; + uint32_t length = ctx->block_size; + + if (ctx->length != -1) + length = (uint32_t)MIN(ctx->length - offset, length); + + if (substorage_read(&ctx->base_storage, block->buffer, offset, length) != length) { + EPRINTF("Cached storage: Failed to read block!"); + return false; + } + block->length = length; + block->index = index; + block->dirty = false; + + return true; +} + +static cache_block_t *get_block(cached_storage_ctx_t *ctx, uint64_t block_index) { + cache_block_t *block = NULL; + if (try_get_block_by_value(ctx, block_index, &block)) { + // Promote most recently used block to front of list if not already. + if (ctx->blocks.next != &block->link) { + list_remove(&block->link); + list_prepend(&ctx->blocks, &block->link); + } + return block; + } + + // Get a pointer either to the least recently used block or to a newly allocated block if storage is empty. + bool block_is_new = false; + if (ctx->blocks.prev != &ctx->blocks) { + block = CONTAINER_OF(ctx->blocks.prev, cache_block_t, link); + if (!flush_block(ctx, block)) + return NULL; + + // Remove least recently used block from list. + list_remove(&block->link); + } else { + block = cache_block_init(ctx); + block_is_new = true; + } + + if (!read_block(ctx, block, block_index)) { + if (block_is_new) + cache_block_finalize(&block); + return NULL; + } + + list_prepend(&ctx->blocks, &block->link); + + return block; +} + +uint32_t save_cached_storage_read(cached_storage_ctx_t *ctx, void *buffer, uint64_t offset, uint64_t count) { + uint64_t remaining = count; + uint64_t in_offset = offset; + uint32_t out_offset = 0; + + if (!is_range_valid(offset, count, ctx->length)) { + EPRINTF("Cached storage read out of range!"); + return 0; + } + + while (remaining) { + uint64_t block_index = in_offset / ctx->block_size; + uint32_t block_pos = (uint32_t)(in_offset % ctx->block_size); + cache_block_t *block = get_block(ctx,block_index); + if (!block) { + EPRINTFARGS("Cached storage read: Unable to get block\n at index %x", (uint32_t)block_index); + return 0; + } + + uint32_t bytes_to_read = (uint32_t)MIN(remaining, ctx->block_size - block_pos); + + memcpy((uint8_t *)buffer + out_offset, block->buffer + block_pos, bytes_to_read); + + out_offset += bytes_to_read; + in_offset += bytes_to_read; + remaining -= bytes_to_read; + } + + return out_offset; +} + +uint32_t save_cached_storage_write(cached_storage_ctx_t *ctx, const void *buffer, uint64_t offset, uint64_t count) { + uint64_t remaining = count; + uint64_t in_offset = offset; + uint32_t out_offset = 0; + + if (!is_range_valid(offset, count, ctx->length)) { + EPRINTF("Cached storage write out of range!"); + return 0; + } + + while (remaining) { + uint64_t block_index = in_offset / ctx->block_size; + uint32_t block_pos = (uint32_t)(in_offset % ctx->block_size); + cache_block_t *block = get_block(ctx,block_index); + if (!block) { + EPRINTFARGS("Cached storage write: Unable to get block\n at index %x", (uint32_t)block_index); + return 0; + } + + uint32_t bytes_to_write = (uint32_t)MIN(remaining, ctx->block_size - block_pos); + + memcpy(block->buffer + block_pos, (uint8_t *)buffer + out_offset, bytes_to_write); + + block->dirty = true; + + out_offset += bytes_to_write; + in_offset += bytes_to_write; + remaining -= bytes_to_write; + } + + return out_offset; +} + +bool save_cached_storage_flush(cached_storage_ctx_t *ctx) { + LIST_FOREACH_ENTRY(cache_block_t, block, &ctx->blocks, link) { + if (!flush_block(ctx, block)) + return false; + } + + return true; +} diff --git a/bdk/libs/nx_savedata/cached_storage.h b/bdk/libs/nx_savedata/cached_storage.h new file mode 100644 index 0000000..3bd7880 --- /dev/null +++ b/bdk/libs/nx_savedata/cached_storage.h @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef _CACHED_STORAGE_H_ +#define _CACHED_STORAGE_H_ + +#include "storage.h" + +#include +#include + +#include + +typedef struct { + uint64_t index; + uint8_t *buffer; + uint32_t length; + bool dirty; + link_t link; +} cache_block_t; + +typedef struct { + substorage base_storage; + uint32_t block_size; + uint64_t length; + uint32_t cache_size; + link_t blocks; +} cached_storage_ctx_t; + +void save_cached_storage_init(cached_storage_ctx_t *ctx, substorage *base_storage, uint32_t block_size, uint32_t cache_size); +void save_cached_storage_init_from_sector_storage(cached_storage_ctx_t *ctx, sector_storage *base_storage, uint32_t cache_size); +void save_cached_storage_finalize(cached_storage_ctx_t *ctx); +uint32_t save_cached_storage_read(cached_storage_ctx_t *ctx, void *buffer, uint64_t offset, uint64_t count); +uint32_t save_cached_storage_write(cached_storage_ctx_t *ctx, const void *buffer, uint64_t offset, uint64_t count); +bool save_cached_storage_flush(cached_storage_ctx_t *ctx); + +#endif diff --git a/bdk/libs/nx_savedata/directory_entry.h b/bdk/libs/nx_savedata/directory_entry.h new file mode 100644 index 0000000..797966d --- /dev/null +++ b/bdk/libs/nx_savedata/directory_entry.h @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef _DIRECTORY_ENTRY_H_ +#define _DIRECTORY_ENTRY_H_ + +#include + +typedef enum { + OPEN_DIR_MODE_DIR = 1, + OPEN_DIR_MODE_FILE = 2, + OPEN_DIR_MODE_NO_FILE_SIZE = -2147483648, + OPEN_DIR_MODE_ALL = OPEN_DIR_MODE_DIR | OPEN_DIR_MODE_FILE +} open_directory_mode_t; + +typedef enum { + DIR_ENT_TYPE_DIR = 0, + DIR_ENT_TYPE_FILE +} directory_entry_type_t; + +typedef struct { + char name[0x301]; + uint8_t attributes; + uint8_t _0x302[2]; + directory_entry_type_t type; + uint64_t size; +} directory_entry_t; + +#endif diff --git a/bdk/libs/nx_savedata/duplex_storage.c b/bdk/libs/nx_savedata/duplex_storage.c new file mode 100644 index 0000000..d7c4926 --- /dev/null +++ b/bdk/libs/nx_savedata/duplex_storage.c @@ -0,0 +1,108 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#include "duplex_storage.h" + +#include +#include + +void save_duplex_storage_init(duplex_storage_ctx_t *ctx, uint8_t *data_a, uint8_t *data_b, uint32_t block_size_power, void *bitmap, uint64_t bitmap_size) { + substorage_init(&ctx->data_a, &memory_storage_vt, data_a, 0, ctx->_length); + substorage_init(&ctx->data_b, &memory_storage_vt, data_b, 0, ctx->_length); + substorage_init(&ctx->bitmap_storage, &memory_storage_vt, bitmap, 0, bitmap_size); + ctx->block_size = 1 << block_size_power; + + ctx->bitmap.data = (uint8_t *)bitmap; + ctx->bitmap.bitmap = malloc(bitmap_size >> 3); + + uint32_t bits_remaining = (uint32_t)bitmap_size; + uint32_t bitmap_pos = 0; + uint32_t *buffer_pos = (uint32_t *)ctx->bitmap.data; + while (bits_remaining) { + uint32_t bits_to_read = MIN(bits_remaining, 0x20); + uint32_t val = *buffer_pos; + for (uint32_t i = 0; i < bits_to_read; i++) { + if (val & 0x80000000) + save_bitmap_set_bit(ctx->bitmap.bitmap, bitmap_pos); + else + save_bitmap_clear_bit(ctx->bitmap.bitmap, bitmap_pos); + bitmap_pos++; + bits_remaining--; + val <<= 1; + } + buffer_pos++; + } +} + +uint32_t save_duplex_storage_read(duplex_storage_ctx_t *ctx, void *buffer, uint64_t offset, uint64_t count) { + uint64_t in_pos = offset; + uint32_t out_pos = 0; + uint32_t remaining = count; + + while (remaining) { + uint32_t block_num = (uint32_t)(in_pos / ctx->block_size); + uint32_t block_pos = (uint32_t)(in_pos % ctx->block_size); + uint32_t bytes_to_read = MIN(ctx->block_size - block_pos, remaining); + + substorage *data = save_bitmap_check_bit(ctx->bitmap.bitmap, block_num) ? &ctx->data_b : &ctx->data_a; + if (substorage_read(data, (uint8_t *)buffer + out_pos, in_pos, bytes_to_read) != bytes_to_read) + return 0; + + out_pos += bytes_to_read; + in_pos += bytes_to_read; + remaining -= bytes_to_read; + } + return out_pos; +} + +uint32_t save_duplex_storage_write(duplex_storage_ctx_t *ctx, const void *buffer, uint64_t offset, uint64_t count) { + uint64_t in_pos = offset; + uint32_t out_pos = 0; + uint32_t remaining = count; + + while (remaining) { + uint32_t block_num = (uint32_t)(in_pos / ctx->block_size); + uint32_t block_pos = (uint32_t)(in_pos % ctx->block_size); + uint32_t bytes_to_write = MIN(ctx->block_size - block_pos, remaining); + + substorage *data = save_bitmap_check_bit(ctx->bitmap.bitmap, block_num) ? &ctx->data_b : &ctx->data_a; + if (substorage_write(data, (uint8_t *)buffer + out_pos, in_pos, bytes_to_write) != bytes_to_write) + return 0; + + out_pos += bytes_to_write; + in_pos += bytes_to_write; + remaining -= bytes_to_write; + } + return out_pos; +} \ No newline at end of file diff --git a/bdk/libs/nx_savedata/duplex_storage.h b/bdk/libs/nx_savedata/duplex_storage.h new file mode 100644 index 0000000..212a0f6 --- /dev/null +++ b/bdk/libs/nx_savedata/duplex_storage.h @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef _DUPLEX_STORAGE_H_ +#define _DUPLEX_STORAGE_H_ + +#include "storage.h" + +#include + +#define DUPLEX_BITMAP_SIZE_BITS 0x200 +#define DUPLEX_BITMAP_SIZE_BYTES 0x40 + +typedef struct { + uint8_t *data; + uint8_t *bitmap; +} duplex_bitmap_t; + +typedef struct { + uint32_t block_size; + substorage bitmap_storage; + substorage data_a; + substorage data_b; + duplex_bitmap_t bitmap; + uint64_t _length; + substorage base_storage; +} duplex_storage_ctx_t; + +static ALWAYS_INLINE void save_bitmap_set_bit(void *buffer, uint64_t bit_offset) { + *((uint8_t *)buffer + (bit_offset >> 3)) |= 1 << (bit_offset & 7); +} + +static ALWAYS_INLINE void save_bitmap_clear_bit(void *buffer, uint64_t bit_offset) { + *((uint8_t *)buffer + (bit_offset >> 3)) &= ~(uint8_t)(1 << (bit_offset & 7)); +} + +static ALWAYS_INLINE uint8_t save_bitmap_check_bit(const void *buffer, uint64_t bit_offset) { + return *((uint8_t *)buffer + (bit_offset >> 3)) & (1 << (bit_offset & 7)); +} + +void save_duplex_storage_init(duplex_storage_ctx_t *ctx, uint8_t *data_a, uint8_t *data_b, uint32_t block_size_power, void *bitmap, uint64_t bitmap_size); +uint32_t save_duplex_storage_read(duplex_storage_ctx_t *ctx, void *buffer, uint64_t offset, uint64_t count); +uint32_t save_duplex_storage_write(duplex_storage_ctx_t *ctx, const void *buffer, uint64_t offset, uint64_t count); + +#endif diff --git a/bdk/libs/nx_savedata/fs_int64.h b/bdk/libs/nx_savedata/fs_int64.h new file mode 100644 index 0000000..a814e47 --- /dev/null +++ b/bdk/libs/nx_savedata/fs_int64.h @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2018-2020 Atmosphère-NX + * Copyright (c) 2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef _FS_INT64_H_ +#define _FS_INT64_H_ + +#include + +#include + +/* For 64-bit integers which are 4-byte aligned but not 8-byte aligned. */ +typedef struct { + uint32_t low; + uint32_t high; +} fs_int64_t; + +static ALWAYS_INLINE void fs_int64_set(fs_int64_t *i, int64_t val) { + i->low = (uint32_t)((val & (uint64_t)(0x00000000FFFFFFFFul)) >> 0); + i->high = (uint32_t)((val & (uint64_t)(0xFFFFFFFF00000000ul)) >> 32); +} + +static ALWAYS_INLINE const int64_t fs_int64_get(fs_int64_t *i) { + return ((int64_t)(i->high) << 32) | ((int64_t)i->low); +} + +#endif diff --git a/bdk/libs/nx_savedata/header.h b/bdk/libs/nx_savedata/header.h new file mode 100644 index 0000000..3d65d83 --- /dev/null +++ b/bdk/libs/nx_savedata/header.h @@ -0,0 +1,237 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef _HEADER_H_ +#define _HEADER_H_ + +#include "allocation_table.h" +#include "duplex_storage.h" +#include "fs_int64.h" +#include "hierarchical_integrity_verification_storage.h" +#include "journal_map.h" +#include "journal_storage.h" +#include "remap_storage.h" + +#include +#include + +#define MAGIC_DISF 0x46534944 +#define MAGIC_DPFS 0x53465044 +#define MAGIC_JNGL 0x4C474E4A +#define MAGIC_SAVE 0x45564153 +#define MAGIC_RMAP 0x50414D52 +#define MAGIC_IVFC 0x43465649 + +#define VERSION_DISF_LEEGACY 0x40000 +#define VERSION_DISF_5 0x50000 +#define VERSION_DPFS 0x10000 +#define VERSION_JNGL 0x10000 +#define VERSION_SAVE 0x60000 +#define VERSION_RMAP 0x10000 +#define VERSION_IVFC 0x20000 + +#define SAVE_BLOCK_SIZE_DEFAULT 0x4000 + +#define SAVE_NUM_HEADERS 2 + +typedef struct { + uint32_t magic; /* DISF */ + uint32_t version; + uint8_t hash[0x20]; + uint64_t file_map_entry_offset; + uint64_t file_map_entry_size; + uint64_t meta_map_entry_offset; + uint64_t meta_map_entry_size; + uint64_t file_map_data_offset; + uint64_t file_map_data_size; + uint64_t duplex_l1_offset_a; + uint64_t duplex_l1_offset_b; + uint64_t duplex_l1_size; + uint64_t duplex_data_offset_a; + uint64_t duplex_data_offset_b; + uint64_t duplex_data_size; + uint64_t journal_data_offset; + uint64_t journal_data_size_a; + uint64_t journal_data_size_b; + uint64_t journal_size; + uint64_t duplex_master_offset_a; + uint64_t duplex_master_offset_b; + uint64_t duplex_master_size; + uint64_t ivfc_master_hash_offset_a; + uint64_t ivfc_master_hash_offset_b; + uint64_t ivfc_master_hash_size; + uint64_t journal_map_table_offset; + uint64_t journal_map_table_size; + uint64_t journal_physical_bitmap_offset; + uint64_t journal_physical_bitmap_size; + uint64_t journal_virtual_bitmap_offset; + uint64_t journal_virtual_bitmap_size; + uint64_t journal_free_bitmap_offset; + uint64_t journal_free_bitmap_size; + uint64_t ivfc_l1_offset; + uint64_t ivfc_l1_size; + uint64_t ivfc_l2_offset; + uint64_t ivfc_l2_size; + uint64_t ivfc_l3_offset; + uint64_t ivfc_l3_size; + uint64_t fat_offset; + uint64_t fat_size; + uint8_t duplex_index; + uint64_t fat_ivfc_master_hash_a; + uint64_t fat_ivfc_master_hash_b; + uint64_t fat_ivfc_l1_offset; + uint64_t fat_ivfc_l1_size; + uint64_t fat_ivfc_l2_offset; + uint64_t fat_ivfc_l2_size; + uint8_t _0x190[0x70]; +} fs_layout_t; + +static_assert(sizeof(fs_layout_t) == 0x200, "Save filesystem layout header size is wrong!"); + +typedef struct { + fs_int64_t offset; + fs_int64_t length; + uint32_t block_size_power; +} duplex_info_t; + +static_assert(sizeof(duplex_info_t) == 0x14, "Duplex info size is wrong!"); + +typedef enum { + DUPLEX_LAYER_MASTER = 0, + DUPLEX_LAYER_1 = 1, + DUPLEX_LAYER_2 = 2, +} duplex_layer_t; + +typedef struct { + uint32_t magic; /* DPFS */ + uint32_t version; + duplex_info_t layers[3]; +} duplex_header_t; + +typedef struct { + uint64_t level_block_size[2]; +} duplex_storage_control_input_param_t; + +static_assert(sizeof(duplex_header_t) == 0x44, "Duplex header size is wrong!"); + +typedef struct { + uint8_t id[0x10]; +} account_user_id_t; + +typedef enum { + SAVE_TYPE_SYSTEM = 0, + SAVE_TYPE_ACCOUNT = 1, + SAVE_TYPE_BCAT = 2, + SAVE_TYPE_DEVICE = 3, + SAVE_TYPE_TEMP = 4, + SAVE_TYPE_CACHE = 5, + SAVE_TYPE_SYSTEM_BCAT = 6 +} save_data_type_t; + +typedef enum { + SAVE_RANK_PRIMARY = 0, + SAVE_RANK_SECONDARY = 1, +} save_data_rank_t; + +typedef struct { + uint64_t program_id; + account_user_id_t user_id; + uint64_t save_id; + uint8_t save_data_type; + uint8_t save_data_rank; + uint16_t save_data_index; + uint8_t _0x24[0x1C]; +} save_data_attribute_t; + +static_assert(sizeof(save_data_attribute_t) == 0x40, "Save data attribute size is wrong!"); + +typedef enum { + SAVE_FLAG_KEEP_AFTER_RESETTING_SYSTEM_SAVE_DATA = 1, + SAVE_FLAG_KEEP_AFTER_REFURBISHMENT = 2, + SAVE_FLAG_KEEP_AFTER_RESETTING_SYSTEM_SAVE_DATA_WITHOUT_USER_SAVE_DATA = 4, + SAVE_FLAG_NEEDS_SECURE_DELETE = 8, +} save_data_flags_t; + +typedef struct { + save_data_attribute_t save_data_attribute; + uint64_t save_owner_id; + uint64_t timestamp; + uint32_t flags; + uint8_t _0x54[4]; + uint64_t savedata_size; + uint64_t journal_size; + uint64_t commit_id; + uint8_t reserved[0x190]; +} extra_data_t; + +static_assert(sizeof(extra_data_t) == 0x200, "Extra data size is wrong!"); + +typedef struct { + uint32_t magic; /* SAVE */ + uint32_t version; + uint64_t block_count; + uint64_t block_size; + allocation_table_header_t fat_header; +} save_fs_header_t; + +static_assert(sizeof(save_fs_header_t) == 0x48, "Save filesystem header size is wrong!"); + +typedef struct { + uint8_t cmac[0x10]; + uint8_t _0x10[0xF0]; + fs_layout_t layout; + duplex_header_t duplex_header; + ivfc_save_hdr_t data_ivfc_header; + uint32_t _0x404; + journal_header_t journal_header; + save_fs_header_t save_header; + remap_header_t main_remap_header, meta_remap_header; + uint64_t _0x6D0; + extra_data_t extra_data_a; + extra_data_t extra_data_b; + union { + struct { + ivfc_save_hdr_t fat_ivfc_header; + uint64_t _0xB98; + uint8_t additional_data[0x3460]; + } version_5; + struct { + uint8_t additional_data[0x3528]; + } legacy; + }; +} save_header_t; + +static_assert(sizeof(save_header_t) == 0x4000, "Save header size is wrong!"); + +#endif diff --git a/bdk/libs/nx_savedata/hierarchical_duplex_storage.c b/bdk/libs/nx_savedata/hierarchical_duplex_storage.c new file mode 100644 index 0000000..bcdcb27 --- /dev/null +++ b/bdk/libs/nx_savedata/hierarchical_duplex_storage.c @@ -0,0 +1,120 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#include "hierarchical_duplex_storage.h" + +#include +#include + +void save_duplex_fs_layer_info_init(duplex_fs_layer_info_t *ctx, uint8_t *data_a, uint8_t *data_b, duplex_info_t *info) { + if (data_a) + ctx->data_a = data_a; + if (data_b) + ctx->data_b = data_b; + ctx->info.offset = info->offset; + ctx->info.length = info->length; + ctx->info.block_size_power = info->block_size_power; +} + +bool save_hierarchical_duplex_storage_init(hierarchical_duplex_storage_ctx_t *ctx, remap_storage_ctx_t *storage, save_header_t *header) { + substorage base_storage; + substorage_init(&base_storage, &remap_storage_vt, storage, 0, -1); + fs_layout_t *layout = &header->layout; + duplex_fs_layer_info_t duplex_layers[3]; + + save_duplex_fs_layer_info_init(&duplex_layers[0], (uint8_t *)header + layout->duplex_master_offset_a, (uint8_t *)header + layout->duplex_master_offset_b, &header->duplex_header.layers[0]); + + duplex_layers[1].data_a = malloc(layout->duplex_l1_size); + duplex_layers[1].data_b = malloc(layout->duplex_l1_size); + if (substorage_read(&base_storage, duplex_layers[1].data_a, layout->duplex_l1_offset_a, layout->duplex_l1_size) != layout->duplex_l1_size) { + EPRINTF("Hier dup init: Failed to read L1 bitmap A!"); + return false; + } + if (substorage_read(&base_storage, duplex_layers[1].data_b, layout->duplex_l1_offset_b, layout->duplex_l1_size) != layout->duplex_l1_size) { + EPRINTF("Hier dup init: Failed to read L1 bitmap B!"); + return false; + } + save_duplex_fs_layer_info_init(&duplex_layers[1], NULL, NULL, &header->duplex_header.layers[1]); + + duplex_layers[2].data_a = malloc(layout->duplex_data_size); + duplex_layers[2].data_b = malloc(layout->duplex_data_size); + if (substorage_read(&base_storage, duplex_layers[2].data_a, layout->duplex_data_offset_a, layout->duplex_data_size) != layout->duplex_data_size) { + EPRINTF("Hier dup init: Failed to read duplex data A!"); + return false; + } + if (substorage_read(&base_storage, duplex_layers[2].data_b, layout->duplex_data_offset_b, layout->duplex_data_size) != layout->duplex_data_size) { + EPRINTF("Hier dup init: Failed to read duplex data B!"); + return false; + } + save_duplex_fs_layer_info_init(&duplex_layers[2], NULL, NULL, &header->duplex_header.layers[2]); + + uint8_t *bitmap = layout->duplex_index == 1 ? duplex_layers[0].data_b : duplex_layers[0].data_a; + ctx->layers[0]._length = layout->duplex_l1_size; + save_duplex_storage_init(&ctx->layers[0], duplex_layers[1].data_a, duplex_layers[1].data_b, duplex_layers[1].info.block_size_power, bitmap, layout->duplex_master_size); + + bitmap = malloc(ctx->layers[0]._length); + if (save_duplex_storage_read(&ctx->layers[0], bitmap, 0, ctx->layers[0]._length) != ctx->layers[0]._length) { + EPRINTF("Hier dup init: Failed to read bitmap!"); + return false; + } + ctx->layers[1]._length = layout->duplex_data_size; + save_duplex_storage_init(&ctx->layers[1], duplex_layers[2].data_a, duplex_layers[2].data_b, duplex_layers[2].info.block_size_power, bitmap, ctx->layers[0]._length); + + ctx->data_layer = &ctx->layers[1]; + ctx->_length = ctx->data_layer->_length; + + return true; +} + +bool save_hierarchical_duplex_storage_flush(hierarchical_duplex_storage_ctx_t *ctx, remap_storage_ctx_t *storage, save_header_t *header) { + substorage base_storage; + substorage_init(&base_storage, &remap_storage_vt, storage, 0, -1); + fs_layout_t *layout = &header->layout; + + if (save_duplex_storage_write(&ctx->layers[0], &ctx->layers[1].bitmap.data, 0, ctx->layers[0]._length) != ctx->layers[0]._length) { + EPRINTF("Hier dup flush: Failed to write bitmap!"); + return false; + } + + if (substorage_write(&base_storage, ctx->layers[1].data_a.base_storage.ctx, layout->duplex_data_offset_a, layout->duplex_data_size) != layout->duplex_data_size) { + EPRINTF("Hier dup flush: Failed to write data A!"); + return false; + } + if (substorage_write(&base_storage, ctx->layers[1].data_b.base_storage.ctx, layout->duplex_data_offset_b, layout->duplex_data_size) != layout->duplex_data_size) { + EPRINTF("Hier dup flush: Failed to write data B!"); + return false; + } + + return true; +} diff --git a/bdk/libs/nx_savedata/hierarchical_duplex_storage.h b/bdk/libs/nx_savedata/hierarchical_duplex_storage.h new file mode 100644 index 0000000..4353d6d --- /dev/null +++ b/bdk/libs/nx_savedata/hierarchical_duplex_storage.h @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef _HIER_DUPLEX_STORAGE_H_ +#define _HIER_DUPLEX_STORAGE_H_ + +#include "duplex_storage.h" +#include "header.h" +#include "remap_storage.h" +#include "storage.h" + +#include + +typedef struct { + duplex_storage_ctx_t layers[2]; + duplex_storage_ctx_t *data_layer; + uint64_t _length; + substorage storage; +} hierarchical_duplex_storage_ctx_t; + +typedef struct { + uint8_t *data_a; + uint8_t *data_b; + duplex_info_t info; +} duplex_fs_layer_info_t; + +bool save_hierarchical_duplex_storage_init(hierarchical_duplex_storage_ctx_t *ctx, remap_storage_ctx_t *storage, save_header_t *header); +bool save_hierarchical_duplex_storage_flush(hierarchical_duplex_storage_ctx_t *ctx, remap_storage_ctx_t *storage, save_header_t *header); + +#endif diff --git a/bdk/libs/nx_savedata/hierarchical_integrity_verification_storage.c b/bdk/libs/nx_savedata/hierarchical_integrity_verification_storage.c new file mode 100644 index 0000000..4d8153b --- /dev/null +++ b/bdk/libs/nx_savedata/hierarchical_integrity_verification_storage.c @@ -0,0 +1,174 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#include "hierarchical_integrity_verification_storage.h" + +#include "header.h" + +#include +#include + +#include + +void save_hierarchical_integrity_verification_storage_control_area_query_size(ivfc_size_set_t *out, const ivfc_storage_control_input_param_t *input_param, int32_t layer_count, uint64_t data_size) { + int64_t level_size[IVFC_MAX_LEVEL + 1]; + int32_t level = layer_count - 1; + + out->control_size = sizeof(ivfc_save_hdr_t); + + level_size[level] = ALIGN(data_size, input_param->level_block_size[level - 1]); + level--; + + for ( ; level > 0; --level) { + level_size[level] = ALIGN(level_size[level + 1] / input_param->level_block_size[level] * 0x20, input_param->level_block_size[level - 1]); + } + + level_size[0] = 0x20 * level_size[1] / input_param->level_block_size[0]; + out->master_hash_size = level_size[0]; + + for (level = 1; level < layer_count - 1; ++level) { + out->layered_hash_sizes[level - 1] = level_size[level]; + } +} + +bool save_hierarchical_integrity_verification_storage_control_area_expand(substorage *storage, const ivfc_save_hdr_t *header) { + return substorage_write(storage, header, 0, sizeof(ivfc_save_hdr_t)) == sizeof(ivfc_save_hdr_t); +} + +void save_hierarchical_integrity_verification_storage_init(hierarchical_integrity_verification_storage_ctx_t *ctx, integrity_verification_info_ctx_t *level_info, uint64_t num_levels, int integrity_check_level) { + ctx->integrity_check_level = integrity_check_level; + ctx->level_validities = malloc(sizeof(validity_t *) * (num_levels - 1)); + memcpy(&ctx->levels[0].base_storage, &level_info[0].data, sizeof(substorage)); + for (unsigned int i = 1; i < num_levels; i++) { + integrity_verification_storage_ctx_t *level_data = &ctx->integrity_storages[i - 1]; + save_ivfc_storage_init(level_data, &level_info[i], &ctx->levels[i - 1].base_storage, integrity_check_level); + + uint64_t level_size = level_data->base_storage.length; + uint32_t cache_count = MIN((uint32_t)(DIV_ROUND_UP(level_size, level_info[i].block_size)), 4); + save_cached_storage_init_from_sector_storage(&ctx->levels[i], &level_data->base_storage, cache_count); + substorage_init(&ctx->levels[i].base_storage, &ivfc_storage_vt, level_data, 0, level_info[i].data.length); + + ctx->level_validities[i - 1] = level_data->block_validities; + } + ctx->data_level = &ctx->levels[num_levels - 1]; + ctx->length = ctx->data_level->length; + substorage_init(&ctx->base_storage, &hierarchical_integrity_verification_storage_vt, ctx, 0, ctx->length); +} + +void save_hierarchical_integrity_verification_storage_get_ivfc_info(integrity_verification_info_ctx_t *init_info, ivfc_save_hdr_t *header, uint64_t num_levels, substorage *levels) { + struct salt_source_t { + char string[64]; + uint32_t length; + }; + + static const struct salt_source_t salt_sources[IVFC_MAX_LEVEL] = { + {"HierarchicalIntegrityVerificationStorage::Master", 48}, + {"HierarchicalIntegrityVerificationStorage::L1", 44}, + {"HierarchicalIntegrityVerificationStorage::L2", 44}, + {"HierarchicalIntegrityVerificationStorage::L3", 44}, + {"HierarchicalIntegrityVerificationStorage::L4", 44}, + {"HierarchicalIntegrityVerificationStorage::L5", 44} + }; + + memcpy(&init_info[0].data, &levels[0], sizeof(substorage)); + init_info[0].block_size = 0; + for (unsigned int i = 1; i < num_levels; i++) { + memcpy(&init_info[i].data, &levels[i], sizeof(substorage)); + init_info[i].block_size = 1 << header->level_hash_info.level_headers[i - 1].block_size; + se_calc_hmac_sha256(init_info[i].salt, &header->level_hash_info.seed, sizeof(hash_salt_t), salt_sources[i - 1].string, salt_sources[i - 1].length); + } +} + +static void save_hierarchical_integrity_verification_storage_to_storage_list(substorage *levels, ivfc_save_hdr_t *header, substorage *master_hash, substorage *data) { + memcpy(&levels[0], master_hash, sizeof(substorage)); + for (unsigned int i = 0; i < 3; i++) { + ivfc_level_hdr_t *level = &header->level_hash_info.level_headers[i]; + substorage_init(&levels[i + 1], &remap_storage_vt, data, fs_int64_get(&level->logical_offset), fs_int64_get(&level->hash_data_size)); + } +} + +void save_hierarchical_integrity_verification_storage_init_with_levels(hierarchical_integrity_verification_storage_ctx_t *ctx, ivfc_save_hdr_t *header, uint64_t num_levels, substorage *levels, int integrity_check_level) { + integrity_verification_info_ctx_t init_info[IVFC_MAX_LEVEL]; + save_hierarchical_integrity_verification_storage_get_ivfc_info(init_info, header, num_levels, levels); + save_hierarchical_integrity_verification_storage_init(ctx, init_info, num_levels, integrity_check_level); +} + +void save_hierarchical_integrity_verification_storage_init_for_fat(hierarchical_integrity_verification_storage_ctx_t *ctx, ivfc_save_hdr_t *header, substorage *master_hash, substorage *data, int integrity_check_level) { + const uint32_t ivfc_levels = IVFC_MAX_LEVEL - 2; + substorage levels[ivfc_levels + 1]; + save_hierarchical_integrity_verification_storage_to_storage_list(levels, header, master_hash, data); + save_hierarchical_integrity_verification_storage_init_with_levels(ctx, header, ivfc_levels, levels, integrity_check_level); +} + +validity_t save_hierarchical_integrity_verification_storage_validate(hierarchical_integrity_verification_storage_ctx_t *ctx) { + validity_t result = VALIDITY_VALID; + integrity_verification_storage_ctx_t *storage = &ctx->integrity_storages[3]; + + uint64_t block_size = storage->base_storage.sector_size; + uint32_t block_count = (uint32_t)(DIV_ROUND_UP(ctx->length, block_size)); + + uint8_t *buffer = malloc(block_size); + + for (unsigned int i = 0; i < block_count; i++) { + if (ctx->level_validities[3][i] == VALIDITY_UNCHECKED) { + uint64_t storage_size = storage->base_storage.length; + uint32_t to_read = MIN((uint32_t)(storage_size - block_size * i), (uint32_t)block_size); + substorage_read(&ctx->data_level->base_storage, buffer, block_size * i, to_read); + } + if (ctx->level_validities[3][i] == VALIDITY_INVALID) { + result = VALIDITY_INVALID; + break; + } + } + free(buffer); + + return result; +} + +void save_hierarchical_integrity_verification_storage_set_level_validities(hierarchical_integrity_verification_storage_ctx_t *ctx) { + for (unsigned int i = 0; i < IVFC_MAX_LEVEL - 2; i++) { + validity_t level_validity = VALIDITY_VALID; + for (unsigned int j = 0; j < ctx->integrity_storages[i].base_storage.sector_count; j++) { + if (ctx->level_validities[i][j] == VALIDITY_INVALID) { + level_validity = VALIDITY_INVALID; + break; + } + if (ctx->level_validities[i][j] == VALIDITY_UNCHECKED && level_validity != VALIDITY_INVALID) { + level_validity = VALIDITY_UNCHECKED; + } + } + ctx->hash_validity[i] = level_validity; + } +} + diff --git a/bdk/libs/nx_savedata/hierarchical_integrity_verification_storage.h b/bdk/libs/nx_savedata/hierarchical_integrity_verification_storage.h new file mode 100644 index 0000000..fd1c798 --- /dev/null +++ b/bdk/libs/nx_savedata/hierarchical_integrity_verification_storage.h @@ -0,0 +1,110 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef _HIVFC_H_ +#define _HIVFC_H_ + +#include "cached_storage.h" +#include "fs_int64.h" +#include "integrity_verification_storage.h" +#include "storage.h" + +#include + +#include +#include + +#define IVFC_MAX_LEVEL 6 + +typedef struct { + fs_int64_t logical_offset; + fs_int64_t hash_data_size; + uint32_t block_size; + uint8_t reserved[4]; +} ivfc_level_hdr_t; + +typedef struct { + ivfc_level_hdr_t *hdr; + validity_t hash_validity; +} ivfc_level_save_ctx_t; + +typedef struct { + uint8_t val[0x20]; +} hash_salt_t; + +typedef struct { + uint32_t num_levels; + ivfc_level_hdr_t level_headers[IVFC_MAX_LEVEL]; + hash_salt_t seed; +} ivfc_level_hash_info_t; + +typedef struct { + uint32_t magic; + uint32_t version; + uint32_t master_hash_size; + ivfc_level_hash_info_t level_hash_info; +} ivfc_save_hdr_t; + +static_assert(sizeof(ivfc_save_hdr_t) == 0xC0, "Ivfc header size invalid!"); + +typedef struct { + int64_t control_size; + int64_t master_hash_size; + int64_t layered_hash_sizes[IVFC_MAX_LEVEL]; +} ivfc_size_set_t; + +typedef struct { + uint64_t level_block_size[IVFC_MAX_LEVEL]; +} ivfc_storage_control_input_param_t; + +typedef struct { + cached_storage_ctx_t levels[IVFC_MAX_LEVEL - 1]; + cached_storage_ctx_t *data_level; + int integrity_check_level; + validity_t **level_validities; + uint64_t length; + integrity_verification_storage_ctx_t integrity_storages[IVFC_MAX_LEVEL - 2]; + validity_t hash_validity[IVFC_MAX_LEVEL - 2]; + substorage base_storage; +} hierarchical_integrity_verification_storage_ctx_t; + +void save_hierarchical_integrity_verification_storage_control_area_query_size(ivfc_size_set_t *out, const ivfc_storage_control_input_param_t *input_param, int32_t layer_count, uint64_t data_size); +bool save_hierarchical_integrity_verification_storage_control_area_expand(substorage *header_storage, const ivfc_save_hdr_t *header); +void save_hierarchical_integrity_verification_storage_init(hierarchical_integrity_verification_storage_ctx_t *ctx, integrity_verification_info_ctx_t *level_info, uint64_t num_levels, int integrity_check_level); +void save_hierarchical_integrity_verification_storage_init_with_levels(hierarchical_integrity_verification_storage_ctx_t *ctx, ivfc_save_hdr_t *header, uint64_t num_levels, substorage *levels, int integrity_check_level); +void save_hierarchical_integrity_verification_storage_init_for_fat(hierarchical_integrity_verification_storage_ctx_t *ctx, ivfc_save_hdr_t *header, substorage *master_hash, substorage *data, int integrity_check_level); +validity_t save_hierarchical_integrity_verification_storage_validate(hierarchical_integrity_verification_storage_ctx_t *ctx); +void save_hierarchical_integrity_verification_storage_set_level_validities(hierarchical_integrity_verification_storage_ctx_t *ctx); + +#endif diff --git a/bdk/libs/nx_savedata/hierarchical_save_file_table.c b/bdk/libs/nx_savedata/hierarchical_save_file_table.c new file mode 100644 index 0000000..0ae9126 --- /dev/null +++ b/bdk/libs/nx_savedata/hierarchical_save_file_table.c @@ -0,0 +1,483 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#include "hierarchical_save_file_table.h" +#include "path_parser.h" + +#include + +#include + +bool save_hierarchical_file_table_find_path_recursive(hierarchical_save_file_table_ctx_t *ctx, const char *path, save_entry_key_t *key) { + path_parser_ctx_t parser; + if (!save_path_parser_init(&parser, path)) { + EPRINTF("Failed to init path parser!"); + return false; + } + + uint32_t current_len = 0; + const char *current = save_path_parser_get_current(&parser, ¤t_len); + memset(key, 0, sizeof(save_entry_key_t)); + memcpy(key->name, current, current_len); + + while (!save_path_parser_is_finished(&parser)) { + key->parent = save_fs_list_get_index_from_key(&ctx->directory_table, key, NULL); + + if (key->parent & 0x80000000) + return false; + + save_path_parser_try_get_next(&parser, key->name); + } + return true; +} + +bool save_hierarchical_file_table_try_open_file(hierarchical_save_file_table_ctx_t *ctx, const char *path, save_file_info_t *file_info) { + save_entry_key_t key; + if (!save_hierarchical_file_table_find_path_recursive(ctx, path, &key)) { + memset(file_info, 0, sizeof(save_file_info_t)); + return false; + } + + save_table_entry_t value; + if (save_fs_list_try_get_value_by_key(&ctx->file_table, &key, &value)) { + memcpy(file_info, &value.save_file_info, sizeof(save_file_info_t)); + return true; + } + + memset(file_info, 0, sizeof(save_file_info_t)); + return false; +} + +bool save_hierarchical_file_table_try_open_directory(hierarchical_save_file_table_ctx_t *ctx, const char *path, save_find_position_t *position) { + save_entry_key_t key; + if (!save_hierarchical_file_table_find_path_recursive(ctx, path, &key)) { + memset(position, 0, sizeof(save_find_position_t)); + return false; + } + + save_table_entry_t entry; + if (save_fs_list_try_get_value_by_key(&ctx->file_table, &key, &entry)) { + memcpy(position, &entry.save_find_position, sizeof(save_find_position_t)); + return true; + } + + memset(position, 0, sizeof(save_find_position_t)); + return false; +} + +bool save_hierarchical_file_table_find_next_file(hierarchical_save_file_table_ctx_t *ctx, save_find_position_t *position, save_file_info_t *info, char *name) { + if (position->next_file == 0) { + memset(info, 0, sizeof(save_file_info_t)); + memset(name, 0, SAVE_FS_LIST_MAX_NAME_LENGTH); + return false; + } + + save_table_entry_t entry; + if (!save_fs_list_try_get_value_and_name(&ctx->file_table, position->next_file, &entry, name)) { + memset(info, 0, sizeof(save_file_info_t)); + memset(name, 0, SAVE_FS_LIST_MAX_NAME_LENGTH); + return false; + } + + position->next_file = entry.next_sibling; + memcpy(info, &entry.save_file_info, sizeof(save_file_info_t)); + return true; +} + +bool save_hierarchical_file_table_find_next_directory(hierarchical_save_file_table_ctx_t *ctx, save_find_position_t *position, char *name) { + if (position->next_directory == 0) { + return false; + } + + save_table_entry_t entry; + if(!save_fs_list_try_get_value_and_name(&ctx->directory_table, position->next_directory, &entry, name)) { + memset(name, 0, SAVE_FS_LIST_MAX_NAME_LENGTH); + return false; + } + + position->next_directory = entry.next_sibling; + return true; +} + +static bool save_hierarchical_file_table_link_file_to_parent(hierarchical_save_file_table_ctx_t *ctx, uint32_t parent_index, uint32_t file_index) { + save_table_entry_t parent_entry, file_entry; + if (!save_fs_list_get_value_by_index(&ctx->directory_table, parent_index, &parent_entry)) { + EPRINTF("Failed to get directory table value!"); + return false; + } + if (!save_fs_list_get_value_by_index(&ctx->file_table, file_index, &file_entry)) { + EPRINTF("Failed to get file table value!"); + return false; + } + + file_entry.next_sibling = parent_entry.save_find_position.next_file; + parent_entry.save_find_position.next_file = file_index; + + if (!save_fs_list_set_value(&ctx->directory_table, parent_index, &parent_entry)) { + EPRINTF("Failed to set directory table value!"); + return false; + } + if (!save_fs_list_set_value(&ctx->file_table, file_index, &file_entry)) { + EPRINTF("Failed to set file table value!"); + return false; + } + + return true; +} + + +static bool save_hierarchical_file_table_link_directory_to_parent(hierarchical_save_file_table_ctx_t *ctx, uint32_t parent_index, uint32_t dir_index) { + save_table_entry_t parent_entry, dir_entry; + if (!save_fs_list_get_value_by_index(&ctx->directory_table, parent_index, &parent_entry)) { + EPRINTF("Failed to get parent directory table value!"); + return false; + } + if (!save_fs_list_get_value_by_index(&ctx->directory_table, dir_index, &dir_entry)) { + EPRINTF("Failed to get directory table value!"); + return false; + } + + dir_entry.next_sibling = parent_entry.save_find_position.next_directory; + parent_entry.save_find_position.next_directory = dir_index; + + if (!save_fs_list_set_value(&ctx->directory_table, parent_index, &parent_entry)) { + EPRINTF("Failed to set parent directory table value!"); + return false; + } + if (!save_fs_list_set_value(&ctx->directory_table, dir_index, &dir_entry)) { + EPRINTF("Failed to set directory table value!"); + return false; + } + + return true; +} + +void save_hierarchical_file_table_unlink_file_from_parent(hierarchical_save_file_table_ctx_t *ctx, uint32_t parent_index, uint32_t file_index) { + save_table_entry_t parent_entry, file_entry; + save_fs_list_get_value_by_index(&ctx->directory_table, parent_index, &parent_entry); + save_fs_list_get_value_by_index(&ctx->file_table, file_index, &file_entry); + + if (parent_entry.save_find_position.next_file == file_index) { + parent_entry.save_find_position.next_file = file_entry.next_sibling; + save_fs_list_set_value(&ctx->directory_table, parent_index, &parent_entry); + return; + } + + uint32_t prev_index = parent_entry.save_find_position.next_file; + save_table_entry_t prev_entry, cur_entry; + save_fs_list_get_value_by_index(&ctx->file_table, prev_index, &prev_entry); + uint32_t cur_index = prev_entry.next_sibling; + + while (cur_index != 0) { + save_fs_list_get_value_by_index(&ctx->file_table, cur_index, &cur_entry); + if (cur_index == file_index) { + prev_entry.next_sibling = cur_entry.next_sibling; + save_fs_list_set_value(&ctx->file_table, prev_index, &prev_entry); + return; + } + prev_index = cur_index; + memcpy(&prev_entry, &cur_entry, sizeof(prev_entry)); + cur_index = prev_entry.next_sibling; + } +} + +void save_hierarchical_file_table_unlink_directory_from_parent(hierarchical_save_file_table_ctx_t *ctx, uint32_t parent_index, uint32_t dir_index) { + save_table_entry_t parent_entry, dir_entry; + save_fs_list_get_value_by_index(&ctx->directory_table, parent_index, &parent_entry); + save_fs_list_get_value_by_index(&ctx->directory_table, dir_index, &dir_entry); + + if (parent_entry.save_find_position.next_directory == dir_index) { + parent_entry.save_find_position.next_directory = dir_entry.next_sibling; + save_fs_list_set_value(&ctx->directory_table, parent_index, &parent_entry); + return; + } + + uint32_t prev_index = parent_entry.save_find_position.next_directory; + save_table_entry_t prev_entry, cur_entry; + save_fs_list_get_value_by_index(&ctx->directory_table, prev_index, &prev_entry); + uint32_t cur_index = prev_entry.next_sibling; + + while (cur_index != 0) { + save_fs_list_get_value_by_index(&ctx->directory_table, cur_index, &cur_entry); + if (cur_index == dir_index) { + prev_entry.next_sibling = cur_entry.next_sibling; + save_fs_list_set_value(&ctx->directory_table, prev_index, &prev_entry); + return; + } + prev_index = cur_index; + memcpy(&prev_entry, &cur_entry, sizeof(prev_entry)); + cur_index = prev_entry.next_sibling; + } +} + +bool save_hierarchical_file_table_delete_file(hierarchical_save_file_table_ctx_t *ctx, const char *path) { + save_entry_key_t key; + save_hierarchical_file_table_find_path_recursive(ctx, path, &key); + + uint32_t parent_index = key.parent; + uint32_t to_delete_index = save_fs_list_get_index_from_key(&ctx->file_table, &key, NULL); + + if (to_delete_index == 0xFFFFFFFF) { + EPRINTF("File not found!"); + return false; + } + + save_hierarchical_file_table_unlink_file_from_parent(ctx, parent_index, to_delete_index); + + return save_fs_list_remove(&ctx->file_table, &key); +} + +bool save_hierarchical_file_table_delete_directory(hierarchical_save_file_table_ctx_t *ctx, const char *path) { + save_entry_key_t key; + save_hierarchical_file_table_find_path_recursive(ctx, path, &key); + + uint32_t parent_index = key.parent; + uint32_t to_delete_index = save_fs_list_get_index_from_key(&ctx->directory_table, &key, NULL); + if (to_delete_index == 0xFFFFFFFF) { + EPRINTF("Directory not found!"); + return false; + } + + save_table_entry_t to_delete_entry; + save_fs_list_get_value_by_index(&ctx->directory_table, to_delete_index, &to_delete_entry); + if (to_delete_entry.save_find_position.next_directory != 0 || to_delete_entry.save_find_position.next_file != 0) { + EPRINTF("Directory is not empty!"); + return false; + } + + save_hierarchical_file_table_unlink_directory_from_parent(ctx, parent_index, to_delete_index); + + return save_fs_list_remove(&ctx->directory_table, &key); +} + +bool save_hierarchical_file_table_rename_file(hierarchical_save_file_table_ctx_t *ctx, const char *src_path, const char *dst_path) { + save_file_info_t file_info; + save_find_position_t position; + save_entry_key_t old_key, new_key; + + if (strcmp(src_path, dst_path) == 0 || save_hierarchical_file_table_try_open_file(ctx, dst_path, &file_info) || save_hierarchical_file_table_try_open_directory(ctx, dst_path, &position)) { + EPRINTF("Destination path already exists!"); + return false; + } + + if (!save_hierarchical_file_table_find_path_recursive(ctx, src_path, &old_key)) { + EPRINTF("File not found!"); + return false; + } + + uint32_t file_index = save_fs_list_get_index_from_key(&ctx->file_table, &old_key, NULL); + + if (!save_hierarchical_file_table_find_path_recursive(ctx, dst_path, &new_key)) { + EPRINTF("File not found!"); + return false; + } + + if (old_key.parent != new_key.parent) { + save_hierarchical_file_table_unlink_file_from_parent(ctx, old_key.parent, file_index); + save_hierarchical_file_table_link_file_to_parent(ctx, new_key.parent, file_index); + } + + return save_fs_list_change_key(&ctx->file_table, &old_key, &new_key); +} + +static ALWAYS_INLINE bool save_is_sub_path(const char *path1, const char *path2) { + /* Check if either path is subpath of the other. */ + uint64_t path1_len = strlen(path1), path2_len = strlen(path2); + if (path1_len == 0 || path2_len == 0) + return true; + + if (path1[path1_len - 1] == '/') + path1_len--; + if (path2[path2_len - 1] == '/') + path2_len--; + + const char *short_path, *long_path; + uint64_t short_path_len, long_path_len; + if (path1_len < path2_len) { + short_path = path1; + short_path_len = path1_len; + long_path = path2; + long_path_len = path2_len; + } else { + short_path = path2; + short_path_len = path2_len; + long_path = path1; + long_path_len = path1_len; + } + + if (strncmp(short_path, long_path, short_path_len) != 0) + return false; + + return long_path_len > short_path_len + 1 && long_path[short_path_len] == '/'; +} + +bool save_hierarchical_file_table_rename_directory(hierarchical_save_file_table_ctx_t *ctx, const char *src_path, const char *dst_path) { + save_file_info_t file_info; + save_find_position_t position; + save_entry_key_t old_key, new_key; + + if (strcmp(src_path, dst_path) == 0 || save_hierarchical_file_table_try_open_file(ctx, dst_path, &file_info) || save_hierarchical_file_table_try_open_directory(ctx, dst_path, &position)) { + EPRINTF("Destination path already exists!"); + return false; + } + + if (!save_hierarchical_file_table_find_path_recursive(ctx, src_path, &old_key)) { + EPRINTF("File not found!"); + return false; + } + + uint32_t dir_index = save_fs_list_get_index_from_key(&ctx->file_table, &old_key, NULL); + + if (!save_hierarchical_file_table_find_path_recursive(ctx, dst_path, &new_key)) { + EPRINTF("File not found!"); + return false; + } + + if (save_is_sub_path(src_path, dst_path)) { + EPRINTF("Destination is subpath of source!"); + return false; + } + + if (old_key.parent != new_key.parent) { + save_hierarchical_file_table_unlink_directory_from_parent(ctx, old_key.parent, dir_index); + save_hierarchical_file_table_link_directory_to_parent(ctx, new_key.parent, dir_index); + } + + return save_fs_list_change_key(&ctx->directory_table, &old_key, &new_key); +} + +uint32_t save_hierarchical_file_table_create_parent_directory_recursive(hierarchical_save_file_table_ctx_t *ctx, path_parser_ctx_t *parser, save_entry_key_t *key) { + uint32_t prev_index = 0; + + while (!save_path_parser_is_finished(parser)) { + uint32_t index = save_fs_list_get_index_from_key(&ctx->directory_table, key, NULL); + + if (index == 0xFFFFFFFF) { + save_table_entry_t new_entry; + memset(&new_entry, 0, sizeof(new_entry)); + index = save_fs_list_add(&ctx->directory_table, key, &new_entry); + + if ((prev_index & 0x80000000) == 0) + save_hierarchical_file_table_link_directory_to_parent(ctx, prev_index, index); + } + + prev_index = index; + key->parent = index; + save_path_parser_try_get_next(parser, key->name); + } + + return prev_index; +} + +static bool save_hierarchical_file_table_create_file_recursive(hierarchical_save_file_table_ctx_t *ctx, const char *path, save_file_info_t *file_info) { + path_parser_ctx_t parser; + if (!save_path_parser_init(&parser, path)) { + EPRINTF("Failed to init path parser!"); + return false; + } + + save_entry_key_t key = {"", 0}; + uint32_t current_len = 0; + const char *current = save_path_parser_get_current(&parser, ¤t_len); + memcpy(key.name, current, current_len); + + uint32_t parent_index = save_hierarchical_file_table_create_parent_directory_recursive(ctx, &parser, &key); + + uint32_t index = save_fs_list_get_index_from_key(&ctx->file_table, &key, NULL); + + save_table_entry_t file_entry; + memset(&file_entry, 0, sizeof(file_entry)); + + if ((index & 0x80000000) == 0) { + save_fs_list_get_value_by_index(&ctx->file_table, index, &file_entry); + memcpy(&file_entry.save_file_info, file_info, sizeof(save_file_info_t)); + save_fs_list_set_value(&ctx->file_table, index, &file_entry); + return true; + } + + memcpy(&file_entry.save_file_info, file_info, sizeof(save_file_info_t)); + index = save_fs_list_add(&ctx->file_table, &key, &file_entry); + if (index == 0) { + EPRINTF("Failed to add file to FS list!"); + return false; + } + + return save_hierarchical_file_table_link_file_to_parent(ctx, parent_index, index); +} + +static bool save_hierarchical_file_table_create_directory_recursive(hierarchical_save_file_table_ctx_t *ctx, const char *path) { + path_parser_ctx_t parser; + if (!save_path_parser_init(&parser, path)) { + EPRINTF("Failed to init path parser!"); + return false; + } + + save_entry_key_t key = {"", 0}; + uint32_t current_len = 0; + const char *current = save_path_parser_get_current(&parser, ¤t_len); + memcpy(key.name, current, current_len); + + uint32_t parent_index = save_hierarchical_file_table_create_parent_directory_recursive(ctx, &parser, &key); + + uint32_t index = save_fs_list_get_index_from_key(&ctx->directory_table, &key, NULL); + + if (index != 0xFFFFFFFF) + return true; + + save_table_entry_t dir_entry; + memset(&dir_entry, 0, sizeof(dir_entry)); + save_fs_list_add(&ctx->directory_table, &key, &dir_entry); + + return save_hierarchical_file_table_link_directory_to_parent(ctx, parent_index, index); +} + +bool save_hierarchical_file_table_add_file(hierarchical_save_file_table_ctx_t *ctx, const char *path, save_file_info_t *file_info) { + if (strlen(path) == 1 && path[0] == '/') { + EPRINTF("Path cannot be empty!"); + return false; + } + + return save_hierarchical_file_table_create_file_recursive(ctx, path, file_info); +} + +bool save_hierarchical_file_table_add_directory(hierarchical_save_file_table_ctx_t *ctx, const char *path) { + if (strlen(path) == 1 && path[0] == '/') { + EPRINTF("Directory path cannot be empty!"); + return false; + } + + save_hierarchical_file_table_create_directory_recursive(ctx, path); + return true; +} + diff --git a/bdk/libs/nx_savedata/hierarchical_save_file_table.h b/bdk/libs/nx_savedata/hierarchical_save_file_table.h new file mode 100644 index 0000000..15f71cd --- /dev/null +++ b/bdk/libs/nx_savedata/hierarchical_save_file_table.h @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef _HIERARCHICAL_SAVE_FILE_TABLE_H_ +#define _HIERARCHICAL_SAVE_FILE_TABLE_H_ + +#include "save_fs_entry.h" +#include "save_fs_list.h" + +#include + +typedef struct { + save_filesystem_list_ctx_t file_table; + save_filesystem_list_ctx_t directory_table; +} hierarchical_save_file_table_ctx_t; + +bool save_hierarchical_file_table_try_open_file(hierarchical_save_file_table_ctx_t *ctx, const char *path, save_file_info_t *file_info); +bool save_hierarchical_file_table_try_open_directory(hierarchical_save_file_table_ctx_t *ctx, const char *path, save_find_position_t *position); +bool save_hierarchical_file_table_find_next_file(hierarchical_save_file_table_ctx_t *ctx, save_find_position_t *position, save_file_info_t *info, char *name); +bool save_hierarchical_file_table_find_next_directory(hierarchical_save_file_table_ctx_t *ctx, save_find_position_t *position, char *name); +bool save_hierarchical_file_table_delete_file(hierarchical_save_file_table_ctx_t *ctx, const char *path); +bool save_hierarchical_file_table_delete_directory(hierarchical_save_file_table_ctx_t *ctx, const char *path); +bool save_hierarchical_file_table_rename_file(hierarchical_save_file_table_ctx_t *ctx, const char *src_path, const char *dst_path); +bool save_hierarchical_file_table_rename_directory(hierarchical_save_file_table_ctx_t *ctx, const char *src_path, const char *dst_path); +bool save_hierarchical_file_table_add_file(hierarchical_save_file_table_ctx_t *ctx, const char *path, save_file_info_t *file_info); +bool save_hierarchical_file_table_add_directory(hierarchical_save_file_table_ctx_t *ctx, const char *path); + +#endif diff --git a/bdk/libs/nx_savedata/integrity_verification_storage.c b/bdk/libs/nx_savedata/integrity_verification_storage.c new file mode 100644 index 0000000..fc76501 --- /dev/null +++ b/bdk/libs/nx_savedata/integrity_verification_storage.c @@ -0,0 +1,155 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#include "integrity_verification_storage.h" + +#include +#include +#include +#include + +#include + +void save_ivfc_storage_init(integrity_verification_storage_ctx_t *ctx, integrity_verification_info_ctx_t *info, substorage *hash_storage, int integrity_check_level) { + sector_storage_init(&ctx->base_storage, &info->data, info->block_size); + memcpy(&ctx->hash_storage, hash_storage, sizeof(substorage)); + ctx->integrity_check_level = integrity_check_level; + memcpy(ctx->salt, info->salt, sizeof(ctx->salt)); + ctx->block_validities = calloc(1, sizeof(validity_t) * ctx->base_storage.sector_count); +} + +/* buffer must have size count + 0x20 for salt to by copied in at offset 0. */ +static ALWAYS_INLINE void save_ivfc_storage_do_hash(integrity_verification_storage_ctx_t *ctx, uint8_t *out_hash, void *buffer, uint64_t count) { + memcpy(buffer, ctx->salt, sizeof(ctx->salt)); + se_calc_sha256(out_hash, buffer, count + sizeof(ctx->salt)); + out_hash[0x1F] |= 0x80; +} + +static ALWAYS_INLINE bool is_empty(const void *buffer, uint64_t count) { + bool empty = true; + const uint8_t *buf = (const uint8_t *)buffer; + for (uint64_t i = 0; i < count; i++) { + if (buf[i] != 0) { + empty = false; + break; + } + } + return empty; +} + +bool save_ivfc_storage_read(integrity_verification_storage_ctx_t *ctx, void *buffer, uint64_t offset, uint64_t count) { + if (count > ctx->base_storage.sector_size) { + EPRINTF("IVFC read exceeds sector size!"); + return false; + } + + uint64_t block_index = offset / ctx->base_storage.sector_size; + + if (ctx->block_validities[block_index] == VALIDITY_INVALID && ctx->integrity_check_level) { + EPRINTF("IVFC hash error!"); + return false; + } + + uint8_t hash_buffer[0x20] = {0}; + uint64_t hash_pos = block_index * sizeof(hash_buffer); + + if (substorage_read(&ctx->hash_storage, hash_buffer, hash_pos, sizeof(hash_buffer)) != sizeof(hash_buffer)) + return false; + + if (is_empty(hash_buffer, sizeof(hash_buffer))) { + memset(buffer, 0, count); + ctx->block_validities[block_index] = VALIDITY_VALID; + return true; + } + + uint8_t *data_buffer = calloc(1, ctx->base_storage.sector_size + 0x20); + if (substorage_read(&ctx->base_storage.base_storage, data_buffer + 0x20, offset - (offset % ctx->base_storage.sector_size), ctx->base_storage.sector_size) != ctx->base_storage.sector_size) { + free(data_buffer); + return false; + } + + if (ctx->integrity_check_level && ctx->block_validities[block_index] != VALIDITY_UNCHECKED) { + memcpy(buffer, data_buffer + 0x20 + (offset % ctx->base_storage.sector_size), count); + free(data_buffer); + return true; + } + + uint8_t hash[0x20] = {0}; + save_ivfc_storage_do_hash(ctx, hash, data_buffer, ctx->base_storage.sector_size); + memcpy(buffer, data_buffer + 0x20 + (offset % ctx->base_storage.sector_size), count); + free(data_buffer); + + if (memcmp(hash_buffer, hash, sizeof(hash_buffer)) == 0) { + ctx->block_validities[block_index] = VALIDITY_VALID; + } else { + ctx->block_validities[block_index] = VALIDITY_INVALID; + if (ctx->integrity_check_level) { + EPRINTF("IVFC hash error!"); + return false; + } + } + + return true; +} + +bool save_ivfc_storage_write(integrity_verification_storage_ctx_t *ctx, const void *buffer, uint64_t offset, uint64_t count) { + uint64_t block_index = offset / ctx->base_storage.sector_size; + uint64_t hash_pos = block_index * 0x20; + + uint8_t hash[0x20] = {0}; + uint8_t *data_buffer = calloc(1, ctx->base_storage.sector_size + 0x20); + if (count < ctx->base_storage.sector_size) { + if (substorage_read(&ctx->base_storage.base_storage, data_buffer + 0x20, offset - (offset % ctx->base_storage.sector_size), ctx->base_storage.sector_size) != ctx->base_storage.sector_size) { + free(data_buffer); + return false; + } + } + memcpy(data_buffer + 0x20 + (offset % ctx->base_storage.sector_size), buffer, count); + + if (!is_empty(buffer, count)) { + save_ivfc_storage_do_hash(ctx, hash, data_buffer, ctx->base_storage.sector_size); + } + + if (substorage_write(&ctx->base_storage.base_storage, data_buffer + 0x20, offset - (offset % ctx->base_storage.sector_size), ctx->base_storage.sector_size) != ctx->base_storage.sector_size) { + free(data_buffer); + return false; + } + free(data_buffer); + if (substorage_write(&ctx->hash_storage, hash, hash_pos, sizeof(hash)) != sizeof(hash)) + return false; + + ctx->block_validities[block_index] = VALIDITY_UNCHECKED; + + return true; +} diff --git a/bdk/libs/nx_savedata/integrity_verification_storage.h b/bdk/libs/nx_savedata/integrity_verification_storage.h new file mode 100644 index 0000000..9765e24 --- /dev/null +++ b/bdk/libs/nx_savedata/integrity_verification_storage.h @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef _IVFC_H_ +#define _IVFC_H_ + +#include "storage.h" + +#include + +typedef struct { + substorage hash_storage; + int integrity_check_level; + validity_t *block_validities; + uint8_t salt[0x20]; + sector_storage base_storage; +} integrity_verification_storage_ctx_t; + +typedef struct { + substorage data; + uint32_t block_size; + uint8_t salt[0x20]; +} integrity_verification_info_ctx_t; + +void save_ivfc_storage_init(integrity_verification_storage_ctx_t *ctx, integrity_verification_info_ctx_t *info, substorage *hash_storage, int integrity_check_level); +bool save_ivfc_storage_read(integrity_verification_storage_ctx_t *ctx, void *buffer, uint64_t offset, uint64_t count); +bool save_ivfc_storage_write(integrity_verification_storage_ctx_t *ctx, const void *buffer, uint64_t offset, uint64_t count); + +#endif diff --git a/bdk/libs/nx_savedata/journal_map.c b/bdk/libs/nx_savedata/journal_map.c new file mode 100644 index 0000000..3177139 --- /dev/null +++ b/bdk/libs/nx_savedata/journal_map.c @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#include "journal_map.h" + +#include "journal_storage.h" +#include "storage.h" + +#include +#include + +static journal_map_entry_t *read_map_entries(uint8_t *map_table, uint32_t count) { + journal_map_entry_t *reader = (journal_map_entry_t *)map_table; + journal_map_entry_t *map = malloc(count * sizeof(journal_map_entry_t)); + + for (uint32_t i = 0; i < count; i++) { + map[i].virtual_index = i; + map[i].physical_index = save_journal_map_entry_get_physical_index(reader->physical_index); + reader++; + } + + return map; +} + +void save_journal_map_init(journal_map_ctx_t *ctx, journal_map_header_t *header, journal_map_params_t *map_info) { + ctx->header = header; + ctx->map_storage = map_info->map_storage; + ctx->modified_physical_blocks = map_info->physical_block_bitmap; + ctx->modified_virtual_blocks = map_info->virtual_block_bitmap; + ctx->free_blocks = map_info->free_block_bitmap; + ctx->entries = read_map_entries(ctx->map_storage, header->main_data_block_count); +} diff --git a/bdk/libs/nx_savedata/journal_map.h b/bdk/libs/nx_savedata/journal_map.h new file mode 100644 index 0000000..af37e05 --- /dev/null +++ b/bdk/libs/nx_savedata/journal_map.h @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef _JOURNAL_MAP_H_ +#define _JOURNAL_MAP_H_ + +#include "storage.h" + +#include + +#include + +#define JOURNAL_MAP_ENTRY_SIZE 8 + +typedef struct { + uint32_t version; + uint32_t main_data_block_count; + uint32_t journal_block_count; + uint32_t _0x0C; +} journal_map_header_t; + +typedef struct { + uint8_t *map_storage; + uint8_t *physical_block_bitmap; + uint8_t *virtual_block_bitmap; + uint8_t *free_block_bitmap; +} journal_map_params_t; + +typedef struct { + uint32_t physical_index; + uint32_t virtual_index; +} journal_map_entry_t; + +typedef struct { + journal_map_header_t *header; + journal_map_entry_t *entries; + uint8_t *map_storage; + uint8_t *modified_physical_blocks; + uint8_t *modified_virtual_blocks; + uint8_t *free_blocks; +} journal_map_ctx_t; + +static ALWAYS_INLINE uint32_t save_journal_map_entry_make_physical_index(uint32_t index) { + return index | 0x80000000; +} + +static ALWAYS_INLINE uint32_t save_journal_map_entry_get_physical_index(uint32_t index) { + return index & 0x7FFFFFFF; +} + +void save_journal_map_init(journal_map_ctx_t *ctx, journal_map_header_t *header, journal_map_params_t *map_info); + +#endif diff --git a/bdk/libs/nx_savedata/journal_storage.c b/bdk/libs/nx_savedata/journal_storage.c new file mode 100644 index 0000000..434f154 --- /dev/null +++ b/bdk/libs/nx_savedata/journal_storage.c @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#include "journal_storage.h" + +#include "header.h" + +#include +#include + +#include + +void save_journal_storage_init(journal_storage_ctx_t *ctx, substorage *base_storage, journal_header_t *header, journal_map_params_t *map_info) { + memcpy(&ctx->base_storage, base_storage, sizeof(substorage)); + ctx->header = header; + save_journal_map_init(&ctx->map, &header->map_header, map_info); + ctx->block_size = (uint32_t)header->block_size; + ctx->length = header->total_size - header->journal_size; +} + +uint32_t save_journal_storage_read(journal_storage_ctx_t *ctx, void *buffer, uint64_t offset, uint64_t count) { + uint64_t in_pos = offset; + uint32_t out_pos = 0; + uint32_t remaining = count; + + while (remaining) { + uint32_t block_num = (uint32_t)(in_pos / ctx->block_size); + uint32_t block_pos = (uint32_t)(in_pos % ctx->block_size); + uint64_t physical_offset = ctx->map.entries[block_num].physical_index * ctx->block_size + block_pos; + uint32_t bytes_to_read = MIN(ctx->block_size - block_pos, remaining); + + if (substorage_read(&ctx->base_storage, (uint8_t *)buffer + out_pos, physical_offset, bytes_to_read) != bytes_to_read) + return 0; + + out_pos += bytes_to_read; + in_pos += bytes_to_read; + remaining -= bytes_to_read; + } + return out_pos; +} + +uint32_t save_journal_storage_write(journal_storage_ctx_t *ctx, const void *buffer, uint64_t offset, uint64_t count) { + uint64_t in_pos = offset; + uint32_t out_pos = 0; + uint32_t remaining = count; + + while (remaining) { + uint32_t block_num = (uint32_t)(in_pos / ctx->block_size); + uint32_t block_pos = (uint32_t)(in_pos % ctx->block_size); + uint64_t physical_offset = ctx->map.entries[block_num].physical_index * ctx->block_size + block_pos; + uint32_t bytes_to_write = MIN(ctx->block_size - block_pos, remaining); + + if (substorage_write(&ctx->base_storage, (uint8_t *)buffer + out_pos, physical_offset, bytes_to_write) != bytes_to_write) + return 0; + + out_pos += bytes_to_write; + in_pos += bytes_to_write; + remaining -= bytes_to_write; + } + return out_pos; +} diff --git a/bdk/libs/nx_savedata/journal_storage.h b/bdk/libs/nx_savedata/journal_storage.h new file mode 100644 index 0000000..2c98b20 --- /dev/null +++ b/bdk/libs/nx_savedata/journal_storage.h @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef _JOURNAL_STORAGE_H_ +#define _JOURNAL_STORAGE_H_ + +#include "hierarchical_integrity_verification_storage.h" +#include "journal_map.h" +#include "storage.h" + +#include +#include + +typedef struct { + uint32_t magic; /* JNGL */ + uint32_t version; + uint64_t total_size; + uint64_t journal_size; + uint64_t block_size; + journal_map_header_t map_header; + uint8_t reserved[0x1D0]; +} journal_header_t; + +static_assert(sizeof(journal_header_t) == 0x200, "Journal storage header size is wrong!"); + +typedef struct { + journal_map_ctx_t map; + journal_header_t *header; + uint32_t block_size; + uint64_t length; + substorage base_storage; +} journal_storage_ctx_t; + +void save_journal_storage_init(journal_storage_ctx_t *ctx, substorage *base_storage, journal_header_t *header, journal_map_params_t *map_info); +uint32_t save_journal_storage_read(journal_storage_ctx_t *ctx, void *buffer, uint64_t offset, uint64_t count); +uint32_t save_journal_storage_write(journal_storage_ctx_t *ctx, const void *buffer, uint64_t offset, uint64_t count); + +#endif diff --git a/bdk/libs/nx_savedata/path_parser.c b/bdk/libs/nx_savedata/path_parser.c new file mode 100644 index 0000000..afa8ee0 --- /dev/null +++ b/bdk/libs/nx_savedata/path_parser.c @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#include "path_parser.h" + +#include + +#include + +bool save_path_parser_init(path_parser_ctx_t *ctx, const char *path) { + ctx->path_len = strlen(path); + + if (ctx->path_len < 1 || path[0] != '/') { + EPRINTF("Path must begin with a '/'!"); + return false; + } + + ctx->_path = path; + ctx->_offset = 0; + ctx->_length = 0; + ctx->_finished = ctx->path_len == 1 || path[1] == '\0'; + return true; +} + +bool save_path_parser_move_next(path_parser_ctx_t *ctx) { + if (ctx->_finished) + return false; + + ctx->_offset = ctx->_offset + ctx->_length + 1; + uint32_t end = ctx->_offset; + + while (end < ctx->path_len && ctx->_path[end] != '\0' && ctx->_path[end] != '/') + end++; + + ctx->_finished = end + 1 >= ctx->path_len || ctx->_path[end + 1] == '\0'; + ctx->_length = end - ctx->_offset; + + return true; +} + +const char *save_path_parser_get_current(path_parser_ctx_t *ctx, uint32_t *out_len) { + if (out_len) + *out_len = ctx->_length; + return &ctx->_path[ctx->_offset]; +} + +bool save_path_parser_try_get_next(path_parser_ctx_t *ctx, char *name) { + bool success = save_path_parser_move_next(ctx); + uint32_t current_len = 0; + const char *current = save_path_parser_get_current(ctx, ¤t_len); + memcpy(name, current, current_len); + return success; +} diff --git a/bdk/libs/nx_savedata/path_parser.h b/bdk/libs/nx_savedata/path_parser.h new file mode 100644 index 0000000..f3637b2 --- /dev/null +++ b/bdk/libs/nx_savedata/path_parser.h @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef _PATH_PARSER_H_ +#define _PATH_PARSER_H_ + +#include + +#include + +typedef struct { + const char *_path; + uint64_t path_len; + uint32_t _offset; + uint32_t _length; + bool _finished; +} path_parser_ctx_t; + +static ALWAYS_INLINE bool save_path_parser_is_finished(path_parser_ctx_t *ctx) { + return ctx->_finished; +} + +bool save_path_parser_init(path_parser_ctx_t *ctx, const char *path); +bool save_path_parser_move_next(path_parser_ctx_t *ctx); +const char *save_path_parser_get_current(path_parser_ctx_t *ctx, uint32_t *out_len); +bool save_path_parser_try_get_next(path_parser_ctx_t *ctx, char *name); + +#endif diff --git a/bdk/libs/nx_savedata/remap_storage.c b/bdk/libs/nx_savedata/remap_storage.c new file mode 100644 index 0000000..b00c4e1 --- /dev/null +++ b/bdk/libs/nx_savedata/remap_storage.c @@ -0,0 +1,160 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#include "remap_storage.h" + +#include "header.h" + +#include +#include +#include + +#include + +remap_segment_ctx_t *save_remap_storage_init_segments(remap_storage_ctx_t *ctx) { + remap_header_t *header = ctx->header; + remap_entry_ctx_t *map_entries = ctx->map_entries; + + remap_segment_ctx_t *segments = calloc(1, sizeof(remap_segment_ctx_t) * header->map_segment_count); + unsigned int entry_idx = 0; + + for (unsigned int i = 0; i < header->map_segment_count; i++) { + remap_segment_ctx_t *seg = &segments[i]; + seg->entry_count = 0; + remap_entry_ctx_t **ptr = malloc(sizeof(remap_entry_ctx_t *) * (seg->entry_count + 1)); + if (!ptr) { + EPRINTF("Failed to allocate entries in remap storage!"); + return NULL; + } + seg->entries = ptr; + seg->entries[seg->entry_count++] = &map_entries[entry_idx]; + seg->offset = map_entries[entry_idx].entry.virtual_offset; + map_entries[entry_idx++].segment = seg; + + while (entry_idx < header->map_entry_count && map_entries[entry_idx - 1].ends.virtual_offset_end == map_entries[entry_idx].entry.virtual_offset) { + map_entries[entry_idx].segment = seg; + map_entries[entry_idx - 1].next = &map_entries[entry_idx]; + remap_entry_ctx_t **ptr = calloc(1, sizeof(remap_entry_ctx_t *) * (seg->entry_count + 1)); + if (!ptr) { + EPRINTF("Failed to allocate entries in remap storage!"); + return NULL; + } + memcpy(ptr, seg->entries, sizeof(remap_entry_ctx_t *) * (seg->entry_count)); + free(seg->entries); + seg->entries = ptr; + seg->entries[seg->entry_count++] = &map_entries[entry_idx++]; + } + seg->length = seg->entries[seg->entry_count - 1]->ends.virtual_offset_end - seg->entries[0]->entry.virtual_offset; + } + return segments; +} + +static ALWAYS_INLINE remap_entry_ctx_t *save_remap_storage_get_map_entry(remap_storage_ctx_t *ctx, uint64_t offset) { + uint32_t segment_idx = save_remap_get_segment_from_virtual_offset(ctx->header, offset); + if (segment_idx < ctx->header->map_segment_count) { + for (unsigned int i = 0; i < ctx->segments[segment_idx].entry_count; i++) { + if (ctx->segments[segment_idx].entries[i]->ends.virtual_offset_end > offset) { + return ctx->segments[segment_idx].entries[i]; + } + } + } + EPRINTFARGS("Remap offset %08x%08x out of range!", (uint32_t)(offset >> 32), (uint32_t)(offset & 0xFFFFFFFF)); + return NULL; +} + +uint32_t save_remap_storage_read(remap_storage_ctx_t *ctx, void *buffer, uint64_t offset, uint64_t count) { + remap_entry_ctx_t *entry = NULL; + entry = save_remap_storage_get_map_entry(ctx, offset); + if (!entry) { + EPRINTF("Unexpected failure in remap get entry!"); + return 0; + } + uint64_t in_pos = offset; + uint32_t out_pos = 0; + uint32_t remaining = count; + + while (remaining) { + uint64_t entry_pos = in_pos - entry->entry.virtual_offset; + uint32_t bytes_to_read = MIN((uint32_t)(entry->ends.virtual_offset_end - in_pos), remaining); + + if (substorage_read(&ctx->base_storage, (uint8_t *)buffer + out_pos, entry->entry.physical_offset + entry_pos, bytes_to_read) != bytes_to_read) + return 0; + + out_pos += bytes_to_read; + in_pos += bytes_to_read; + remaining -= bytes_to_read; + + if (in_pos >= entry->ends.virtual_offset_end) { + if (!entry->next && remaining) { + EPRINTF("Unexpected remap entry chain failure!"); + return 0; + } + entry = entry->next; + } + } + return out_pos; +} + +uint32_t save_remap_storage_write(remap_storage_ctx_t *ctx, const void *buffer, uint64_t offset, uint64_t count) { + remap_entry_ctx_t *entry = NULL; + entry = save_remap_storage_get_map_entry(ctx, offset); + if (!entry) { + EPRINTF("Unexpected failure in remap get entry!"); + return 0; + } + uint64_t in_pos = offset; + uint32_t out_pos = 0; + uint32_t remaining = count; + + while (remaining) { + uint64_t entry_pos = in_pos - entry->entry.virtual_offset; + uint32_t bytes_to_write = MIN((uint32_t)(entry->ends.virtual_offset_end - in_pos), remaining); + + if (substorage_write(&ctx->base_storage, (uint8_t *)buffer + out_pos, entry->entry.physical_offset + entry_pos, bytes_to_write) != bytes_to_write) + return 0; + + out_pos += bytes_to_write; + in_pos += bytes_to_write; + remaining -= bytes_to_write; + + if (in_pos >= entry->ends.virtual_offset_end) { + if (!entry->next && remaining) { + EPRINTF("Unexpected remap entry chain failure!"); + return 0; + } + entry = entry->next; + } + } + return out_pos; +} diff --git a/bdk/libs/nx_savedata/remap_storage.h b/bdk/libs/nx_savedata/remap_storage.h new file mode 100644 index 0000000..2f67e04 --- /dev/null +++ b/bdk/libs/nx_savedata/remap_storage.h @@ -0,0 +1,104 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef _REMAP_STORAGE_H_ +#define _REMAP_STORAGE_H_ + +#include "duplex_storage.h" +#include "storage.h" + +#include + +#define RMAP_ALIGN_SMALL 0x200 +#define RMAP_ALIGN_LARGE 0x4000 + +typedef struct { + uint32_t magic; /* RMAP */ + uint32_t version; + uint32_t map_entry_count; + uint32_t map_segment_count; + uint32_t segment_bits; + uint8_t _0x14[0x2C]; +} remap_header_t; + +typedef struct remap_segment_ctx_t remap_segment_ctx_t; +typedef struct remap_entry_ctx_t remap_entry_ctx_t; + +typedef struct { + uint64_t virtual_offset_end; + uint64_t physical_offset_end; +} remap_end_offsets_t; + +typedef struct { + uint64_t virtual_offset; + uint64_t physical_offset; + uint64_t size; + uint32_t alignment; + uint32_t _0x1C; +} remap_entry_t; + +struct remap_entry_ctx_t { + remap_entry_t entry; + remap_end_offsets_t ends; + remap_segment_ctx_t *segment; + remap_entry_ctx_t *next; +}; + +struct remap_segment_ctx_t{ + uint64_t offset; + uint64_t length; + remap_entry_ctx_t **entries; + uint64_t entry_count; +}; + +typedef struct { + remap_header_t *header; + remap_entry_ctx_t *map_entries; + remap_segment_ctx_t *segments; + substorage base_storage; +} remap_storage_ctx_t; + +static ALWAYS_INLINE uint32_t save_remap_get_segment_from_virtual_offset(remap_header_t *header, uint64_t offset) { + return (uint32_t)(offset >> (64 - header->segment_bits)); +} + +static ALWAYS_INLINE uint64_t save_remap_get_virtual_offset(remap_header_t *header, uint64_t segment) { + return segment << (64 - header->segment_bits); +} + +remap_segment_ctx_t *save_remap_storage_init_segments(remap_storage_ctx_t *ctx); +uint32_t save_remap_storage_read(remap_storage_ctx_t *ctx, void *buffer, uint64_t offset, uint64_t count); +uint32_t save_remap_storage_write(remap_storage_ctx_t *ctx, const void *buffer, uint64_t offset, uint64_t count); + +#endif diff --git a/bdk/libs/nx_savedata/save.c b/bdk/libs/nx_savedata/save.c new file mode 100644 index 0000000..7669e10 --- /dev/null +++ b/bdk/libs/nx_savedata/save.c @@ -0,0 +1,306 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#include "save.h" + +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +static void save_init_journal_ivfc_storage(save_ctx_t *ctx, hierarchical_integrity_verification_storage_ctx_t *out_ivfc, int integrity_check_level) { + const uint32_t ivfc_levels = 5; + ivfc_save_hdr_t *ivfc = &ctx->header.data_ivfc_header; + substorage levels[ivfc_levels]; + + substorage_init(&levels[0], &memory_storage_vt, ctx->data_ivfc_master, 0, ctx->header.layout.ivfc_master_hash_size); + for (unsigned int i = 0; i < ivfc_levels - 2; i++) { + ivfc_level_hdr_t *level = &ivfc->level_hash_info.level_headers[i]; + substorage_init(&levels[i + 1], &remap_storage_vt, &ctx->meta_remap_storage, fs_int64_get(&level->logical_offset), fs_int64_get(&level->hash_data_size)); + } + ivfc_level_hdr_t *data_level = &ivfc->level_hash_info.level_headers[ivfc_levels - 2]; + substorage_init(&levels[ivfc_levels - 1], &journal_storage_vt, &ctx->journal_storage, fs_int64_get(&data_level->logical_offset), fs_int64_get(&data_level->hash_data_size)); + + save_hierarchical_integrity_verification_storage_init_with_levels(out_ivfc, ivfc, ivfc_levels, levels, integrity_check_level); +} + +static void save_init_fat_ivfc_storage(save_ctx_t *ctx, hierarchical_integrity_verification_storage_ctx_t *out_ivfc, int integrity_check_level) { + substorage fat_ivfc_master; + substorage_init(&fat_ivfc_master, &memory_storage_vt, ctx->fat_ivfc_master, 0, ctx->header.layout.ivfc_master_hash_size); + save_hierarchical_integrity_verification_storage_init_for_fat(out_ivfc, &ctx->header.version_5.fat_ivfc_header, &fat_ivfc_master, &ctx->meta_remap_storage.base_storage, integrity_check_level); +} + +static validity_t save_filesystem_verify(save_ctx_t *ctx) { + validity_t journal_validity = save_hierarchical_integrity_verification_storage_validate(&ctx->core_data_ivfc_storage); + save_hierarchical_integrity_verification_storage_set_level_validities(&ctx->core_data_ivfc_storage); + + if (ctx->header.layout.version < VERSION_DISF_5) + return journal_validity; + + validity_t fat_validity = save_hierarchical_integrity_verification_storage_validate(&ctx->fat_ivfc_storage); + save_hierarchical_integrity_verification_storage_set_level_validities(&ctx->core_data_ivfc_storage); + + if (journal_validity != VALIDITY_VALID) + return journal_validity; + if (fat_validity != VALIDITY_VALID) + return fat_validity; + + return journal_validity; +} + +static bool save_process_header(save_ctx_t *ctx) { + if (ctx->header.layout.magic != MAGIC_DISF || ctx->header.duplex_header.magic != MAGIC_DPFS || + ctx->header.data_ivfc_header.magic != MAGIC_IVFC || ctx->header.journal_header.magic != MAGIC_JNGL || + ctx->header.save_header.magic != MAGIC_SAVE || ctx->header.main_remap_header.magic != MAGIC_RMAP || + ctx->header.meta_remap_header.magic != MAGIC_RMAP) + { + EPRINTF("Error: Save header is corrupt!"); + return false; + } + + ctx->data_ivfc_master = (uint8_t *)&ctx->header + ctx->header.layout.ivfc_master_hash_offset_a; + ctx->fat_ivfc_master = (uint8_t *)&ctx->header + ctx->header.layout.fat_ivfc_master_hash_a; + + uint8_t hash[0x20]; + uint32_t hashed_data_offset = sizeof(ctx->header.layout) + sizeof(ctx->header.cmac) + sizeof(ctx->header._0x10); + uint32_t hashed_data_size = sizeof(ctx->header) - hashed_data_offset; + se_calc_sha256(hash, (uint8_t *)&ctx->header + hashed_data_offset, hashed_data_size); + ctx->header_hash_validity = memcmp(hash, ctx->header.layout.hash, 0x20) == 0 ? VALIDITY_VALID : VALIDITY_INVALID; + + unsigned char cmac[0x10] = {}; + se_aes_key_set(10, ctx->save_mac_key, 0x10); + se_aes_cmac(10, cmac, 0x10, &ctx->header.layout, sizeof(ctx->header.layout)); + if (memcmp(cmac, &ctx->header.cmac, 0x10) == 0) { + ctx->header_cmac_validity = VALIDITY_VALID; + } else { + ctx->header_cmac_validity = VALIDITY_INVALID; + } + + return true; +} + +void save_init(save_ctx_t *ctx, FIL *file, const uint8_t *save_mac_key, uint32_t action) { + ctx->file = file; + ctx->action = action; + memcpy(ctx->save_mac_key, save_mac_key, sizeof(ctx->save_mac_key)); +} + +bool save_process(save_ctx_t *ctx) { + substorage_init(&ctx->base_storage, &file_storage_vt, ctx->file, 0, f_size(ctx->file)); + /* Try to parse Header A. */ + if (substorage_read(&ctx->base_storage, &ctx->header, 0, sizeof(ctx->header)) != sizeof(ctx->header)) { + EPRINTF("Failed to read save header!\n"); + return false; + } + + if (!save_process_header(ctx) || (ctx->header_hash_validity == VALIDITY_INVALID)) { + /* Try to parse Header B. */ + if (substorage_read(&ctx->base_storage, &ctx->header, sizeof(ctx->header), sizeof(ctx->header)) != sizeof(ctx->header)) { + EPRINTF("Failed to read save header!\n"); + return false; + } + + if (!save_process_header(ctx) || (ctx->header_hash_validity == VALIDITY_INVALID)) { + EPRINTF("Error: Save header is invalid!"); + return false; + } + } + + /* Initialize remap storages. */ + ctx->data_remap_storage.header = &ctx->header.main_remap_header; + ctx->meta_remap_storage.header = &ctx->header.meta_remap_header; + + substorage_init(&ctx->data_remap_storage.base_storage, &file_storage_vt, ctx->file, ctx->header.layout.file_map_data_offset, ctx->header.layout.file_map_data_size); + ctx->data_remap_storage.map_entries = calloc(1, sizeof(remap_entry_ctx_t) * ctx->data_remap_storage.header->map_entry_count); + uint8_t *remap_buffer = malloc(MAX(ctx->data_remap_storage.header->map_entry_count, ctx->meta_remap_storage.header->map_entry_count) * sizeof(remap_entry_t)); + if (substorage_read(&ctx->base_storage, remap_buffer, ctx->header.layout.file_map_entry_offset, sizeof(remap_entry_t) * ctx->data_remap_storage.header->map_entry_count) != sizeof(remap_entry_t) * ctx->data_remap_storage.header->map_entry_count) { + EPRINTF("Failed to read data remap table!"); + free(remap_buffer); + return false; + } + for (unsigned int i = 0; i < ctx->data_remap_storage.header->map_entry_count; i++) { + memcpy(&ctx->data_remap_storage.map_entries[i], remap_buffer + sizeof(remap_entry_t) * i, sizeof(remap_entry_t)); + ctx->data_remap_storage.map_entries[i].ends.physical_offset_end = ctx->data_remap_storage.map_entries[i].entry.physical_offset + ctx->data_remap_storage.map_entries[i].entry.size; + ctx->data_remap_storage.map_entries[i].ends.virtual_offset_end = ctx->data_remap_storage.map_entries[i].entry.virtual_offset + ctx->data_remap_storage.map_entries[i].entry.size; + } + + /* Initialize data remap storage. */ + ctx->data_remap_storage.segments = save_remap_storage_init_segments(&ctx->data_remap_storage); + if (!ctx->data_remap_storage.segments) { + free(remap_buffer); + return false; + } + + /* Initialize hierarchical duplex storage. */ + if (!save_hierarchical_duplex_storage_init(&ctx->duplex_storage, &ctx->data_remap_storage, &ctx->header)) { + free(remap_buffer); + return false; + } + + /* Initialize meta remap storage. */ + substorage_init(&ctx->meta_remap_storage.base_storage, &hierarchical_duplex_storage_vt, &ctx->duplex_storage, 0, ctx->duplex_storage.data_layer->_length); + ctx->meta_remap_storage.map_entries = calloc(1, sizeof(remap_entry_ctx_t) * ctx->meta_remap_storage.header->map_entry_count); + if (substorage_read(&ctx->base_storage, remap_buffer, ctx->header.layout.meta_map_entry_offset, sizeof(remap_entry_t) * ctx->meta_remap_storage.header->map_entry_count) != sizeof(remap_entry_t) * ctx->meta_remap_storage.header->map_entry_count) { + EPRINTF("Failed to read meta remap table!"); + free(remap_buffer); + return false; + } + for (unsigned int i = 0; i < ctx->meta_remap_storage.header->map_entry_count; i++) { + memcpy(&ctx->meta_remap_storage.map_entries[i], remap_buffer + sizeof(remap_entry_t) * i, sizeof(remap_entry_t)); + ctx->meta_remap_storage.map_entries[i].ends.physical_offset_end = ctx->meta_remap_storage.map_entries[i].entry.physical_offset + ctx->meta_remap_storage.map_entries[i].entry.size; + ctx->meta_remap_storage.map_entries[i].ends.virtual_offset_end = ctx->meta_remap_storage.map_entries[i].entry.virtual_offset + ctx->meta_remap_storage.map_entries[i].entry.size; + } + free(remap_buffer); + + ctx->meta_remap_storage.segments = save_remap_storage_init_segments(&ctx->meta_remap_storage); + if (!ctx->meta_remap_storage.segments) + return false; + + /* Initialize journal map. */ + journal_map_params_t journal_map_info; + journal_map_info.map_storage = malloc(ctx->header.layout.journal_map_table_size); + if (save_remap_storage_read(&ctx->meta_remap_storage, journal_map_info.map_storage, ctx->header.layout.journal_map_table_offset, ctx->header.layout.journal_map_table_size) != ctx->header.layout.journal_map_table_size) { + EPRINTF("Failed to read journal map!"); + return false; + } + + /* Initialize journal storage. */ + substorage journal_data; + substorage_init(&journal_data, &remap_storage_vt, &ctx->data_remap_storage, ctx->header.layout.journal_data_offset, ctx->header.layout.journal_data_size_b + ctx->header.layout.journal_size); + + save_journal_storage_init(&ctx->journal_storage, &journal_data, &ctx->header.journal_header, &journal_map_info); + + /* Initialize core IVFC storage. */ + save_init_journal_ivfc_storage(ctx, &ctx->core_data_ivfc_storage, ctx->action & ACTION_VERIFY); + + /* Initialize FAT storage. */ + if (ctx->header.layout.version < VERSION_DISF_5) { + ctx->fat_storage = malloc(ctx->header.layout.fat_size); + save_remap_storage_read(&ctx->meta_remap_storage, ctx->fat_storage, ctx->header.layout.fat_offset, ctx->header.layout.fat_size); + } else { + save_init_fat_ivfc_storage(ctx, &ctx->fat_ivfc_storage, ctx->action & ACTION_VERIFY); + ctx->fat_storage = malloc(ctx->fat_ivfc_storage.length); + save_remap_storage_read(&ctx->meta_remap_storage, ctx->fat_storage, fs_int64_get(&ctx->header.version_5.fat_ivfc_header.level_hash_info.level_headers[2].logical_offset), ctx->fat_ivfc_storage.length); + } + + if (ctx->action & ACTION_VERIFY) { + save_filesystem_verify(ctx); + } + + /* Initialize core save filesystem. */ + save_data_file_system_core_init(&ctx->save_filesystem_core, &ctx->core_data_ivfc_storage.base_storage, ctx->fat_storage, &ctx->header.save_header); + + return true; +} + +void save_free_contexts(save_ctx_t *ctx) { + for (unsigned int i = 0; i < ctx->data_remap_storage.header->map_segment_count; i++) { + free(ctx->data_remap_storage.segments[i].entries); + } + free(ctx->data_remap_storage.segments); + for (unsigned int i = 0; i < ctx->meta_remap_storage.header->map_segment_count; i++) { + free(ctx->meta_remap_storage.segments[i].entries); + } + free(ctx->meta_remap_storage.segments); + free(ctx->data_remap_storage.map_entries); + free(ctx->meta_remap_storage.map_entries); + for (unsigned int i = 0; i < 2; i++) { + free(ctx->duplex_storage.layers[i].bitmap.bitmap); + free(ctx->duplex_storage.layers[i].data_a.base_storage.ctx); + free(ctx->duplex_storage.layers[i].data_b.base_storage.ctx); + } + free(ctx->duplex_storage.layers[1].bitmap_storage.base_storage.ctx); + free(ctx->journal_storage.map.map_storage); + free(ctx->journal_storage.map.entries); + for (unsigned int i = 0; i < 4; i++) { + free(ctx->core_data_ivfc_storage.integrity_storages[i].block_validities); + save_cached_storage_finalize(&ctx->core_data_ivfc_storage.levels[i + 1]); + } + free(ctx->core_data_ivfc_storage.level_validities); + if (ctx->header.layout.version >= VERSION_DISF_5) { + for (unsigned int i = 0; i < 3; i++) { + free(ctx->fat_ivfc_storage.integrity_storages[i].block_validities); + save_cached_storage_finalize(&ctx->fat_ivfc_storage.levels[i + 1]); + } + } + free(ctx->fat_ivfc_storage.level_validities); + free(ctx->fat_storage); +} + +static ALWAYS_INLINE bool save_flush(save_ctx_t *ctx) { + if (ctx->header.layout.version < VERSION_DISF_5) { + if (!save_cached_storage_flush(ctx->core_data_ivfc_storage.data_level)) { + EPRINTF("Failed to flush cached storage!"); + } + if (save_remap_storage_write(&ctx->meta_remap_storage, ctx->fat_storage, ctx->header.layout.fat_offset, ctx->header.layout.fat_size) != ctx->header.layout.fat_size) { + EPRINTF("Failed to write meta remap storage!"); + } + } else { + if (!save_cached_storage_flush(ctx->fat_ivfc_storage.data_level)) { + EPRINTF("Failed to flush cached storage!"); + } + if (save_remap_storage_write(&ctx->meta_remap_storage, ctx->fat_storage, fs_int64_get(&ctx->header.version_5.fat_ivfc_header.level_hash_info.level_headers[2].logical_offset), ctx->fat_ivfc_storage.length) != ctx->fat_ivfc_storage.length) { + EPRINTF("Failed to write meta remap storage!"); + } + } + return save_hierarchical_duplex_storage_flush(&ctx->duplex_storage, &ctx->data_remap_storage, &ctx->header); +} + +bool save_commit(save_ctx_t *ctx) { + if (!save_flush(ctx)) { + EPRINTF("Failed to flush save!"); + return false; + } + + uint32_t hashed_data_offset = sizeof(ctx->header.layout) + sizeof(ctx->header.cmac) + sizeof(ctx->header._0x10); + uint32_t hashed_data_size = sizeof(ctx->header) - hashed_data_offset; + uint8_t *header = (uint8_t *)&ctx->header; + se_calc_sha256(ctx->header.layout.hash, header + hashed_data_offset, hashed_data_size); + + se_aes_key_set(10, ctx->save_mac_key, 0x10); + se_aes_cmac(10, ctx->header.cmac, 0x10, &ctx->header.layout, sizeof(ctx->header.layout)); + + if (substorage_write(&ctx->base_storage, &ctx->header, 0, sizeof(ctx->header)) != sizeof(ctx->header)) { + EPRINTF("Failed to write save header!"); + return false; + } + + return true; +} diff --git a/bdk/libs/nx_savedata/save.h b/bdk/libs/nx_savedata/save.h new file mode 100644 index 0000000..928ad56 --- /dev/null +++ b/bdk/libs/nx_savedata/save.h @@ -0,0 +1,154 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef _SAVE_H_ +#define _SAVE_H_ + +#include "header.h" +#include "hierarchical_duplex_storage.h" +#include "hierarchical_integrity_verification_storage.h" +#include "journal_map.h" +#include "journal_storage.h" +#include "remap_storage.h" +#include "save_data_file_system_core.h" +#include "storage.h" + +#include +#include + +#include +#include + +#define ACTION_VERIFY (1<<2) + +typedef struct { + save_header_t header; + FIL *file; + uint32_t action; + validity_t header_cmac_validity; + validity_t header_hash_validity; + uint8_t *data_ivfc_master; + uint8_t *fat_ivfc_master; + remap_storage_ctx_t data_remap_storage; + remap_storage_ctx_t meta_remap_storage; + hierarchical_duplex_storage_ctx_t duplex_storage; + journal_storage_ctx_t journal_storage; + hierarchical_integrity_verification_storage_ctx_t core_data_ivfc_storage; + hierarchical_integrity_verification_storage_ctx_t fat_ivfc_storage; + uint8_t *fat_storage; + save_data_file_system_core_ctx_t save_filesystem_core; + substorage base_storage; + uint8_t save_mac_key[0x10]; +} save_ctx_t; + +typedef enum { + SPACE_ID_SYSTEM = 0, + SPACE_ID_USER = 1, + SPACE_ID_SD_SYSTEM = 2, + SPACE_ID_TEMP = 3, + SPACE_ID_SD_USER = 4, + SPACE_ID_PROPER_SYSTEM = 100, + SPACE_ID_SAFE_MODE = 101, +} save_data_space_id_t; + +typedef struct { + int64_t save_data_size; + int64_t journal_size; + int64_t block_size; + uint64_t owner_id; + uint32_t flags; + uint8_t space_id; + uint8_t pseudo; + uint8_t reserved[0x1A]; +} save_data_creation_info_t; + +static_assert(sizeof(save_data_creation_info_t) == 0x40, "Save data creation info size is wrong!"); + +static ALWAYS_INLINE uint32_t save_calc_map_entry_storage_size(int32_t entry_count) { + int32_t val = entry_count < 1 ? entry_count : entry_count - 1; + return (entry_count + (val >> 1)) * sizeof(remap_entry_t); +} + +void save_init(save_ctx_t *ctx, FIL *file, const uint8_t *save_mac_key, uint32_t action); +bool save_process(save_ctx_t *ctx); +bool save_create(save_ctx_t *ctx, uint32_t version, const char *mount_path, const save_data_attribute_t *attr, const save_data_creation_info_t *creation_info); +bool save_create_system_save_data(save_ctx_t *ctx, uint32_t version, const char *mount_path, uint8_t space_id, uint64_t save_id, const account_user_id_t *user_id, uint64_t owner_id, uint64_t save_data_size, uint64_t journal_size, uint32_t flags); +void save_free_contexts(save_ctx_t *ctx); +bool save_commit(save_ctx_t *ctx); + +static ALWAYS_INLINE bool save_create_directory(save_ctx_t *ctx, const char *path) { + return save_data_file_system_core_create_directory(&ctx->save_filesystem_core, path); +} + +static ALWAYS_INLINE bool save_create_file(save_ctx_t *ctx, const char *path, uint64_t size) { + return save_data_file_system_core_create_file(&ctx->save_filesystem_core, path, size); +} + +static ALWAYS_INLINE bool save_delete_directory(save_ctx_t *ctx, const char *path) { + return save_data_file_system_core_delete_directory(&ctx->save_filesystem_core,path); +} + +static ALWAYS_INLINE bool save_delete_file(save_ctx_t *ctx, const char *path) { + return save_data_file_system_core_delete_file(&ctx->save_filesystem_core, path); +} + +static ALWAYS_INLINE bool save_open_directory(save_ctx_t *ctx, save_data_directory_ctx_t *directory, const char *path, open_directory_mode_t mode) { + return save_data_file_system_core_open_directory(&ctx->save_filesystem_core, directory, path, mode); +} + +static ALWAYS_INLINE bool save_open_file(save_ctx_t *ctx, save_data_file_ctx_t *file, const char *path, open_mode_t mode) { + return save_data_file_system_core_open_file(&ctx->save_filesystem_core, file, path, mode); +} + +static ALWAYS_INLINE bool save_rename_directory(save_ctx_t *ctx, const char *old_path, const char *new_path) { + return save_data_file_system_core_rename_directory(&ctx->save_filesystem_core, old_path, new_path); +} + +static ALWAYS_INLINE bool save_rename_file(save_ctx_t *ctx, const char *old_path, const char *new_path) { + return save_data_file_system_core_rename_file(&ctx->save_filesystem_core, old_path, new_path); +} + +static ALWAYS_INLINE bool save_get_entry_type(save_ctx_t *ctx, directory_entry_type_t *out_entry_type, const char *path) { + return save_data_file_system_core_get_entry_type(&ctx->save_filesystem_core, out_entry_type, path); +} + +static ALWAYS_INLINE void save_get_free_space_size(save_ctx_t *ctx, uint64_t *out_free_space) { + return save_data_file_system_core_get_free_space_size(&ctx->save_filesystem_core, out_free_space); +} + +static ALWAYS_INLINE void save_get_total_space_size(save_ctx_t *ctx, uint64_t *out_total_size) { + return save_data_file_system_core_get_total_space_size(&ctx->save_filesystem_core, out_total_size); +} + +#endif diff --git a/bdk/libs/nx_savedata/save_data_directory.c b/bdk/libs/nx_savedata/save_data_directory.c new file mode 100644 index 0000000..2afa372 --- /dev/null +++ b/bdk/libs/nx_savedata/save_data_directory.c @@ -0,0 +1,89 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#include "save_data_directory.h" + +#include + +void save_data_directory_init(save_data_directory_ctx_t *ctx, hierarchical_save_file_table_ctx_t *table, save_find_position_t *position, open_directory_mode_t mode) { + ctx->parent_file_table = table; + ctx->initial_position = position; + ctx->_current_position = position; + ctx->mode = mode; +} + +bool save_data_directory_read_impl(save_data_directory_ctx_t *ctx, uint64_t *out_entries_read, save_find_position_t *position, directory_entry_t *entry_buffer, uint64_t entry_count) { + hierarchical_save_file_table_ctx_t *tab = ctx->parent_file_table; + uint32_t i = 0; + save_file_info_t info; + char name[SAVE_FS_LIST_MAX_NAME_LENGTH]; + + if (ctx->mode & OPEN_DIR_MODE_DIR) { + while ((!entry_buffer || i < entry_count) && save_hierarchical_file_table_find_next_directory(tab, position, name)) { + directory_entry_t *entry = &entry_buffer[i]; + + memcpy(entry->name, name, SAVE_FS_LIST_MAX_NAME_LENGTH); + entry->name[SAVE_FS_LIST_MAX_NAME_LENGTH] = 0; + entry->type = DIR_ENT_TYPE_DIR; + entry->size = 0; + + i++; + } + } + + if (ctx->mode & OPEN_DIR_MODE_FILE) { + while ((!entry_buffer || i < entry_count) && save_hierarchical_file_table_find_next_file(tab, position, &info, name)) { + directory_entry_t *entry = &entry_buffer[i]; + + memcpy(entry->name, name, SAVE_FS_LIST_MAX_NAME_LENGTH); + entry->name[SAVE_FS_LIST_MAX_NAME_LENGTH] = 0; + entry->type = DIR_ENT_TYPE_FILE; + entry->size = 0; + + i++; + } + } + + *out_entries_read = i; + + return true; +} + +bool save_data_directory_read(save_data_directory_ctx_t *ctx, uint64_t *out_entries_read, directory_entry_t *entry_buffer, uint64_t entry_count) { + return save_data_directory_read_impl(ctx, out_entries_read, ctx->_current_position, entry_buffer, entry_count); +} + +bool save_data_directory_get_entry_count(save_data_directory_ctx_t *ctx, uint64_t *out_entry_count) { + return save_data_directory_read_impl(ctx, out_entry_count, ctx->initial_position, NULL, 0); +} diff --git a/bdk/libs/nx_savedata/save_data_directory.h b/bdk/libs/nx_savedata/save_data_directory.h new file mode 100644 index 0000000..ee8c296 --- /dev/null +++ b/bdk/libs/nx_savedata/save_data_directory.h @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef _SAVE_DATA_DIRECTORY_H_ +#define _SAVE_DATA_DIRECTORY_H_ + +#include "directory_entry.h" +#include "hierarchical_save_file_table.h" +#include "save_data_directory.h" +#include "save_fs_entry.h" + +#include + +typedef struct { + hierarchical_save_file_table_ctx_t *parent_file_table; + open_directory_mode_t mode; + save_find_position_t *initial_position; + save_find_position_t *_current_position; +} save_data_directory_ctx_t; + +void save_data_directory_init(save_data_directory_ctx_t *ctx, hierarchical_save_file_table_ctx_t *table, save_find_position_t *position, open_directory_mode_t mode); +bool save_data_directory_read(save_data_directory_ctx_t *ctx, uint64_t *out_entries_read, directory_entry_t *entry_buffer, uint64_t entry_count); +bool save_data_directory_get_entry_count(save_data_directory_ctx_t *ctx, uint64_t *out_entry_count); + +#endif diff --git a/bdk/libs/nx_savedata/save_data_file.c b/bdk/libs/nx_savedata/save_data_file.c new file mode 100644 index 0000000..0940052 --- /dev/null +++ b/bdk/libs/nx_savedata/save_data_file.c @@ -0,0 +1,132 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#include "save_data_file.h" + +#include + +void save_data_file_init(save_data_file_ctx_t *ctx, allocation_table_storage_ctx_t *base_storage, const char *path, hierarchical_save_file_table_ctx_t *file_table, uint64_t size, open_mode_t mode) { + ctx->mode = mode; + memcpy(&ctx->base_storage, base_storage, sizeof(ctx->base_storage)); + ctx->path = path; + ctx->file_table = file_table; + ctx->size = size; +} + +bool save_data_file_validate_read_params(save_data_file_ctx_t *ctx, uint64_t *out_bytes_to_read, uint64_t offset, uint32_t size, open_mode_t open_mode) { + *out_bytes_to_read = 0; + + if ((open_mode & OPEN_MODE_READ) == 0) + return false; + + uint64_t file_size = ctx->size; + + if (offset > file_size) + return false; + + *out_bytes_to_read = MIN(file_size - offset, size); + + return true; +} + +bool save_data_file_validate_write_params(save_data_file_ctx_t *ctx, uint64_t offset, uint32_t size, open_mode_t open_mode, bool *out_is_resize_needed) { + *out_is_resize_needed = false; + + if ((open_mode & OPEN_MODE_WRITE) == 0) + return false; + + uint64_t file_size = ctx->size; + + if (offset + size > file_size) { + *out_is_resize_needed = true; + + if ((open_mode & OPEN_MODE_ALLOW_APPEND) == 0) + return false; + } + + return true; +} + +bool save_data_file_read(save_data_file_ctx_t *ctx, uint64_t *out_bytes_read, uint64_t offset, void *buffer, uint64_t count) { + uint64_t to_read = 0; + + if (!save_data_file_validate_read_params(ctx, &to_read, offset, count, ctx->mode)) + return false; + + if (to_read == 0) { + *out_bytes_read = 0; + return true; + } + + *out_bytes_read = save_allocation_table_storage_read(&ctx->base_storage, buffer, offset, to_read); + return true; +} + +bool save_data_file_write(save_data_file_ctx_t *ctx, uint64_t *out_bytes_written, uint64_t offset, const void *buffer, uint64_t count) { + bool is_resize_needed; + + if (!save_data_file_validate_write_params(ctx, offset, count, ctx->mode, &is_resize_needed)) + return false; + + if (is_resize_needed) { + if (!save_data_file_set_size(ctx, offset + count)) + return false; + } + + *out_bytes_written = save_allocation_table_storage_write(&ctx->base_storage, buffer, offset, count); + return true; +} + +bool save_data_file_set_size(save_data_file_ctx_t *ctx, uint64_t size) { + if (ctx->size == size) + return true; + + save_allocation_table_storage_set_size(&ctx->base_storage, size); + + save_file_info_t file_info; + if (!save_hierarchical_file_table_try_open_file(ctx->file_table, ctx->path, &file_info)) { + EPRINTF("File not found!"); + return false; + } + + file_info.start_block = ctx->base_storage.initial_block; + fs_int64_set(&file_info.length, size); + + if (!save_hierarchical_file_table_add_file(ctx->file_table, ctx->path, &file_info)) + return false; + + ctx->size = size; + + return true; +} diff --git a/bdk/libs/nx_savedata/save_data_file.h b/bdk/libs/nx_savedata/save_data_file.h new file mode 100644 index 0000000..970624c --- /dev/null +++ b/bdk/libs/nx_savedata/save_data_file.h @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef _SAVE_DATA_FILE_H_ +#define _SAVE_DATA_FILE_H_ + +#include "allocation_table_storage.h" +#include "hierarchical_save_file_table.h" + +#include + +#include + +typedef struct { + allocation_table_storage_ctx_t base_storage; + const char *path; + hierarchical_save_file_table_ctx_t *file_table; + uint64_t size; + open_mode_t mode; +} save_data_file_ctx_t; + +static ALWAYS_INLINE void save_data_file_get_size(save_data_file_ctx_t *ctx, uint64_t *out_size) { + *out_size = ctx->size; +} + +void save_data_file_init(save_data_file_ctx_t *ctx, allocation_table_storage_ctx_t *base_storage, const char *path, hierarchical_save_file_table_ctx_t *file_table, uint64_t size, open_mode_t mode); +bool save_data_file_read(save_data_file_ctx_t *ctx, uint64_t *out_bytes_read, uint64_t offset, void *buffer, uint64_t count); +bool save_data_file_write(save_data_file_ctx_t *ctx, uint64_t *out_bytes_written, uint64_t offset, const void *buffer, uint64_t count); +bool save_data_file_set_size(save_data_file_ctx_t *ctx, uint64_t size); + +#endif \ No newline at end of file diff --git a/bdk/libs/nx_savedata/save_data_file_system_core.c b/bdk/libs/nx_savedata/save_data_file_system_core.c new file mode 100644 index 0000000..ccd3a2c --- /dev/null +++ b/bdk/libs/nx_savedata/save_data_file_system_core.c @@ -0,0 +1,142 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#include "save_data_file_system_core.h" + +#include "allocation_table_storage.h" +#include "header.h" +#include "save.h" + +#include +#include + +static ALWAYS_INLINE void save_data_file_system_core_open_fat_storage(save_data_file_system_core_ctx_t *ctx, allocation_table_storage_ctx_t *storage_ctx, uint32_t block_index) { + save_allocation_table_storage_init(storage_ctx, ctx->base_storage, &ctx->allocation_table, (uint32_t)ctx->header->block_size, block_index); +} + +void save_data_file_system_core_init(save_data_file_system_core_ctx_t *ctx, substorage *storage, void *allocation_table, save_fs_header_t *save_fs_header) { + save_allocation_table_init(&ctx->allocation_table, allocation_table, &save_fs_header->fat_header); + ctx->header = save_fs_header; + ctx->base_storage = storage; + + save_filesystem_list_ctx_t *dir_table = &ctx->file_table.directory_table; + save_filesystem_list_ctx_t *file_table = &ctx->file_table.file_table; + save_data_file_system_core_open_fat_storage(ctx, &dir_table->storage, save_fs_header->fat_header.directory_table_block); + save_data_file_system_core_open_fat_storage(ctx, &file_table->storage, save_fs_header->fat_header.file_table_block); + save_fs_list_init(dir_table); + save_fs_list_init(file_table); +} + +bool save_data_file_system_core_create_directory(save_data_file_system_core_ctx_t *ctx, const char *path) { + return save_hierarchical_file_table_add_directory(&ctx->file_table, path); +} + +bool save_data_file_system_core_create_file(save_data_file_system_core_ctx_t *ctx, const char *path, uint64_t size) { + if (size == 0) { + save_file_info_t empty_file_entry = {0x80000000, {0}, {0}}; + save_hierarchical_file_table_add_file(&ctx->file_table, path, &empty_file_entry); + return true; + } + + uint32_t block_count = (uint32_t)DIV_ROUND_UP(size, ctx->allocation_table.header->block_size); + uint32_t start_block = save_allocation_table_allocate(&ctx->allocation_table, block_count); + + if (start_block == 0xFFFFFFFF) + return false; + + save_file_info_t file_entry = {start_block, {0}, {0}}; + fs_int64_set(&file_entry.length, size); + return save_hierarchical_file_table_add_file(&ctx->file_table, path, &file_entry); +} + +bool save_data_file_system_core_delete_directory(save_data_file_system_core_ctx_t *ctx, const char *path) { + return save_hierarchical_file_table_delete_directory(&ctx->file_table, path); +} + +bool save_data_file_system_core_delete_file(save_data_file_system_core_ctx_t *ctx, const char *path) { + save_file_info_t file_info; + if (!save_hierarchical_file_table_try_open_file(&ctx->file_table, path, &file_info)) + return false; + + if (file_info.start_block != 0x80000000) { + save_allocation_table_free(&ctx->allocation_table, file_info.start_block); + } + + save_hierarchical_file_table_delete_file(&ctx->file_table, path); + + return true; +} + +bool save_data_file_system_core_open_directory(save_data_file_system_core_ctx_t *ctx, save_data_directory_ctx_t *directory, const char *path, open_directory_mode_t mode) { + memset(directory, 0, sizeof(save_data_directory_ctx_t)); + + save_find_position_t position; + if (!save_hierarchical_file_table_try_open_directory(&ctx->file_table, path, &position)) + return false; + + save_data_directory_init(directory, &ctx->file_table, &position, mode); + + return true; +} + +bool save_data_file_system_core_open_file(save_data_file_system_core_ctx_t *ctx, save_data_file_ctx_t *file, const char *path, open_mode_t mode) { + memset(file, 0, sizeof(save_data_file_ctx_t)); + + save_file_info_t file_info; + if (!save_hierarchical_file_table_try_open_file(&ctx->file_table, path, &file_info)) + return false; + + allocation_table_storage_ctx_t storage; + save_data_file_system_core_open_fat_storage(ctx, &storage, file_info.start_block); + + save_data_file_init(file, &storage, path, &ctx->file_table, fs_int64_get(&file_info.length), mode); + + return true; +} + +bool save_data_file_system_core_get_entry_type(save_data_file_system_core_ctx_t *ctx, directory_entry_type_t *out_entry_type, const char *path) { + save_file_info_t info; + if (save_hierarchical_file_table_try_open_file(&ctx->file_table, path, &info)) { + *out_entry_type = DIR_ENT_TYPE_FILE; + return true; + } + + save_find_position_t position; + if (save_hierarchical_file_table_try_open_directory(&ctx->file_table, path, &position)) { + *out_entry_type = DIR_ENT_TYPE_DIR; + return true; + } + + return false; +} diff --git a/bdk/libs/nx_savedata/save_data_file_system_core.h b/bdk/libs/nx_savedata/save_data_file_system_core.h new file mode 100644 index 0000000..14c4523 --- /dev/null +++ b/bdk/libs/nx_savedata/save_data_file_system_core.h @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef _SAVE_DATA_FILE_SYSTEM_CORE_H_ +#define _SAVE_DATA_FILE_SYSTEM_CORE_H_ + +#include "allocation_table.h" +#include "header.h" +#include "hierarchical_save_file_table.h" +#include "save_data_directory.h" +#include "save_data_file.h" +#include "storage.h" + +typedef struct { + substorage *base_storage; + allocation_table_ctx_t allocation_table; + save_fs_header_t *header; + hierarchical_save_file_table_ctx_t file_table; +} save_data_file_system_core_ctx_t; + +static ALWAYS_INLINE bool save_data_file_system_core_rename_directory(save_data_file_system_core_ctx_t *ctx, const char *old_path, const char *new_path) { + return save_hierarchical_file_table_rename_directory(&ctx->file_table, old_path, new_path); +} + +static ALWAYS_INLINE bool save_data_file_system_core_rename_file(save_data_file_system_core_ctx_t *ctx, const char *old_path, const char *new_path) { + return save_hierarchical_file_table_rename_file(&ctx->file_table, old_path, new_path); +} + +static ALWAYS_INLINE void save_data_file_system_core_get_free_space_size(save_data_file_system_core_ctx_t *ctx, uint64_t *out_free_space) { + uint32_t free_block_count = save_allocation_table_get_free_list_length(&ctx->allocation_table); + *out_free_space = ctx->header->block_size * free_block_count; +} + +static ALWAYS_INLINE void save_data_file_system_core_get_total_space_size(save_data_file_system_core_ctx_t *ctx, uint64_t *out_total_space) { + *out_total_space = ctx->header->block_size * ctx->header->block_count; +} + +void save_data_file_system_core_init(save_data_file_system_core_ctx_t *ctx, substorage *storage, void *allocation_table, save_fs_header_t *save_fs_header); + +bool save_data_file_system_core_create_directory(save_data_file_system_core_ctx_t *ctx, const char *path); +bool save_data_file_system_core_create_file(save_data_file_system_core_ctx_t *ctx, const char *path, uint64_t size); +bool save_data_file_system_core_delete_directory(save_data_file_system_core_ctx_t *ctx, const char *path); +bool save_data_file_system_core_delete_file(save_data_file_system_core_ctx_t *ctx, const char *path); +bool save_data_file_system_core_open_directory(save_data_file_system_core_ctx_t *ctx, save_data_directory_ctx_t *directory, const char *path, open_directory_mode_t mode); +bool save_data_file_system_core_open_file(save_data_file_system_core_ctx_t *ctx, save_data_file_ctx_t *file, const char *path, open_mode_t mode); +bool save_data_file_system_core_get_entry_type(save_data_file_system_core_ctx_t *ctx, directory_entry_type_t *out_entry_type, const char *path); + +#endif diff --git a/bdk/libs/nx_savedata/save_fs_entry.h b/bdk/libs/nx_savedata/save_fs_entry.h new file mode 100644 index 0000000..8f49944 --- /dev/null +++ b/bdk/libs/nx_savedata/save_fs_entry.h @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef _SAVE_FS_ENTRY_H_ +#define _SAVE_FS_ENTRY_H_ + +#include "fs_int64.h" + +#include +#include + +typedef struct { + char name[0x40]; + uint32_t parent; +} save_entry_key_t; + +static_assert(sizeof(save_entry_key_t) == 0x44, "Save entry key size is wrong!"); + +typedef struct { + uint32_t start_block; + fs_int64_t length; + uint32_t _0xC[2]; +} save_file_info_t; + +static_assert(sizeof(save_file_info_t) == 0x14, "Save file info size is wrong!"); + +typedef struct { + uint32_t next_directory; + uint32_t next_file; + uint32_t _0x8[3]; +} save_find_position_t; + +static_assert(sizeof(save_find_position_t) == 0x14, "Save find position size is wrong!"); + +#endif diff --git a/bdk/libs/nx_savedata/save_fs_list.c b/bdk/libs/nx_savedata/save_fs_list.c new file mode 100644 index 0000000..78e2abe --- /dev/null +++ b/bdk/libs/nx_savedata/save_fs_list.c @@ -0,0 +1,300 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#include "save_fs_list.h" + +#include + +#include + +void save_fs_list_init(save_filesystem_list_ctx_t *ctx) { + ctx->free_list_head_index = 0; + ctx->used_list_head_index = 1; +} + +static ALWAYS_INLINE uint32_t save_fs_list_get_capacity(save_filesystem_list_ctx_t *ctx) { + uint32_t capacity; + if (save_allocation_table_storage_read(&ctx->storage, &capacity, 4, 4) != 4) { + EPRINTF("Failed to read FS list capacity!"); + return 0; + } + return capacity; +} + +static ALWAYS_INLINE uint32_t save_fs_list_get_length(save_filesystem_list_ctx_t *ctx) { + uint32_t length; + if (save_allocation_table_storage_read(&ctx->storage, &length, 0, 4) != 4) { + EPRINTF("Failed to read FS list length!"); + return 0; + } + return length; +} + +static ALWAYS_INLINE bool save_fs_list_set_capacity(save_filesystem_list_ctx_t *ctx, uint32_t capacity) { + return save_allocation_table_storage_write(&ctx->storage, &capacity, 4, 4) == 4; +} + +static ALWAYS_INLINE bool save_fs_list_set_length(save_filesystem_list_ctx_t *ctx, uint32_t length) { + return save_allocation_table_storage_write(&ctx->storage, &length, 0, 4) == 4; +} + +uint32_t save_fs_list_get_index_from_key(save_filesystem_list_ctx_t *ctx, const save_entry_key_t *key, uint32_t *prev_index) { + save_fs_list_entry_t entry; + uint32_t capacity = save_fs_list_get_capacity(ctx); + if (save_fs_list_read_entry(ctx, ctx->used_list_head_index, &entry) != SAVE_FS_LIST_ENTRY_SIZE) { + EPRINTF("Failed to read used list head entry!"); + return 0xFFFFFFFF; + } + uint32_t prev; + if (!prev_index) { + prev_index = &prev; + } + *prev_index = ctx->used_list_head_index; + uint32_t index = entry.next; + while (index) { + if (index > capacity) { + EPRINTFARGS("Save entry index %d out of range!", index); + return 0xFFFFFFFF; + } + if (save_fs_list_read_entry(ctx, index, &entry) != SAVE_FS_LIST_ENTRY_SIZE) + return 0xFFFFFFFF; + if (entry.parent == key->parent && !strcmp(entry.name, key->name)) { + return index; + } + *prev_index = index; + index = entry.next; + } + *prev_index = 0xFFFFFFFF; + return 0xFFFFFFFF; +} + +bool save_fs_list_get_value_by_index(save_filesystem_list_ctx_t *ctx, uint32_t index, save_table_entry_t *value) { + save_fs_list_entry_t entry; + memset(&entry, 0, sizeof(entry)); + if (save_fs_list_read_entry(ctx, index, &entry) != SAVE_FS_LIST_ENTRY_SIZE) { + EPRINTFARGS("Failed to read FS list entry at index %x!", index); + return false; + } + memcpy(value, &entry.value, sizeof(save_table_entry_t)); + return true; +} + +bool save_fs_list_get_value_and_name(save_filesystem_list_ctx_t *ctx, uint32_t index, save_table_entry_t *value, char *name) { + save_fs_list_entry_t entry; + memset(&entry, 0, sizeof(entry)); + if (save_fs_list_read_entry(ctx, index, &entry) != SAVE_FS_LIST_ENTRY_SIZE) { + EPRINTFARGS("Failed to read FS list entry at index %x!", index); + return false; + } + memcpy(value, &entry.value, sizeof(save_table_entry_t)); + memcpy(name, entry.name, SAVE_FS_LIST_MAX_NAME_LENGTH); + return true; +} + +bool save_fs_list_try_get_value_by_index(save_filesystem_list_ctx_t *ctx, uint32_t index, save_table_entry_t *value) { + if ((index & 0x80000000) != 0 || index >= save_fs_list_get_capacity(ctx)) { + memset(value, 0, sizeof(save_table_entry_t)); + return false; + } + + return save_fs_list_get_value_by_index(ctx, index, value); +} + +bool save_fs_list_try_get_value_by_key(save_filesystem_list_ctx_t *ctx, save_entry_key_t *key, save_table_entry_t *value) { + uint32_t index = save_fs_list_get_index_from_key(ctx, key, NULL); + + if ((index & 0x80000000) != 0) { + memset(value, 0, sizeof(save_table_entry_t)); + return false; + } + + return save_fs_list_try_get_value_by_index(ctx, index, value); +} + +bool save_fs_list_try_get_value_and_name(save_filesystem_list_ctx_t *ctx, uint32_t index, save_table_entry_t *value, char *name) { + if ((index & 0x80000000) != 0 || index >= save_fs_list_get_capacity(ctx)) { + memset(value, 0, sizeof(save_table_entry_t)); + return false; + } + + return save_fs_list_get_value_and_name(ctx, index, value, name); +} + +bool save_fs_list_set_value(save_filesystem_list_ctx_t *ctx, uint32_t index, const save_table_entry_t *value) { + save_fs_list_entry_t entry = {0}; + if (save_fs_list_read_entry(ctx, index, &entry) != SAVE_FS_LIST_ENTRY_SIZE) + return false; + memcpy(&entry.value, value, sizeof(save_table_entry_t)); + return save_fs_list_write_entry(ctx, index, &entry) == SAVE_FS_LIST_ENTRY_SIZE; +} + +bool save_fs_list_free(save_filesystem_list_ctx_t *ctx, uint32_t entry_index) { + save_fs_list_entry_t free_entry, entry; + if (save_fs_list_read_entry(ctx, ctx->free_list_head_index, &free_entry) != SAVE_FS_LIST_ENTRY_SIZE) + return false; + if (save_fs_list_read_entry(ctx, entry_index, &entry) != SAVE_FS_LIST_ENTRY_SIZE) + return false; + + entry.next = free_entry.next; + free_entry.next = entry_index; + + if (save_fs_list_write_entry(ctx, ctx->free_list_head_index, &free_entry) != SAVE_FS_LIST_ENTRY_SIZE) + return false; + return save_fs_list_write_entry(ctx, entry_index, &entry) == SAVE_FS_LIST_ENTRY_SIZE; +} + +bool save_fs_list_remove(save_filesystem_list_ctx_t *ctx, const save_entry_key_t *key) { + uint32_t index, previous_index; + index = save_fs_list_get_index_from_key(ctx, key, &previous_index); + if (index == 0xFFFFFFFF) + return false; + + save_fs_list_entry_t prev_entry, entry_to_del; + if (save_fs_list_read_entry(ctx, previous_index, &prev_entry) != SAVE_FS_LIST_ENTRY_SIZE) + return false; + if (save_fs_list_read_entry(ctx, index, &entry_to_del) != SAVE_FS_LIST_ENTRY_SIZE) + return false; + + prev_entry.next = entry_to_del.next; + if (save_fs_list_write_entry(ctx, previous_index, &prev_entry) != SAVE_FS_LIST_ENTRY_SIZE) + return false; + + return save_fs_list_free(ctx, index); +} + +bool save_fs_list_change_key(save_filesystem_list_ctx_t *ctx, save_entry_key_t *old_key, save_entry_key_t *new_key) { + uint32_t index = save_fs_list_get_index_from_key(ctx, old_key, NULL); + uint32_t new_index = save_fs_list_get_index_from_key(ctx, new_key, NULL); + + if (index == 0xFFFFFFFF) { + EPRINTF("Old key was not found!"); + return false; + } + if (new_index != 0xFFFFFFFF) { + EPRINTF("New key already exists!"); + return false; + } + + save_fs_list_entry_t entry; + if (save_fs_list_read_entry(ctx, index, &entry) != SAVE_FS_LIST_ENTRY_SIZE) + return false; + + entry.parent = new_key->parent; + memcpy(entry.name, new_key->name, SAVE_FS_LIST_MAX_NAME_LENGTH); + + return save_fs_list_write_entry(ctx, index, &entry) == SAVE_FS_LIST_ENTRY_SIZE; +} + +uint32_t save_fs_list_allocate_entry(save_filesystem_list_ctx_t *ctx) { + save_fs_list_entry_t free_list_head, used_list_head; + if (save_fs_list_read_entry(ctx, ctx->free_list_head_index, &free_list_head) != SAVE_FS_LIST_ENTRY_SIZE) + return 0; + if (save_fs_list_read_entry(ctx, ctx->used_list_head_index, &used_list_head) != SAVE_FS_LIST_ENTRY_SIZE) + return 0; + + uint32_t allocated_index = free_list_head.next; + + if (allocated_index != 0) { + save_fs_list_entry_t first_free_entry; + if (save_fs_list_read_entry(ctx, allocated_index, &first_free_entry) != SAVE_FS_LIST_ENTRY_SIZE) + return 0; + + free_list_head.next = first_free_entry.next; + first_free_entry.next = used_list_head.next; + used_list_head.next = allocated_index; + + if (save_fs_list_write_entry(ctx, ctx->free_list_head_index, &free_list_head) != SAVE_FS_LIST_ENTRY_SIZE) + return 0; + if (save_fs_list_write_entry(ctx, ctx->used_list_head_index, &used_list_head) != SAVE_FS_LIST_ENTRY_SIZE) + return 0; + if (save_fs_list_write_entry(ctx, allocated_index, &first_free_entry) != SAVE_FS_LIST_ENTRY_SIZE) + return 0; + + return allocated_index; + } + + uint32_t length = save_fs_list_get_length(ctx); + uint32_t capacity = save_fs_list_get_capacity(ctx); + + if (capacity == 0 || length >= capacity) { + uint64_t current_size, new_size; + save_allocation_table_storage_get_size(&ctx->storage, ¤t_size); + if (!save_allocation_table_storage_set_size(&ctx->storage, current_size + 0x4000)) + return 0; + save_allocation_table_storage_get_size(&ctx->storage, &new_size); + if (!save_fs_list_set_capacity(ctx, (uint32_t)(new_size / sizeof(save_fs_list_entry_t)))) + return 0; + } + + if (!save_fs_list_set_length(ctx, length + 1)) + return 0; + + save_fs_list_entry_t new_entry; + if (save_fs_list_read_entry(ctx, length, &new_entry) != SAVE_FS_LIST_ENTRY_SIZE) + return 0; + + new_entry.next = used_list_head.next; + used_list_head.next = length; + + if (save_fs_list_write_entry(ctx, ctx->used_list_head_index, &used_list_head) != SAVE_FS_LIST_ENTRY_SIZE) + return 0; + if (save_fs_list_write_entry(ctx, length, &new_entry) != SAVE_FS_LIST_ENTRY_SIZE) + return 0; + + return length; +} + +uint32_t save_fs_list_add(save_filesystem_list_ctx_t *ctx, const save_entry_key_t *key, const save_table_entry_t *value) { + uint32_t index = save_fs_list_get_index_from_key(ctx, key, NULL); + + if (index != 0xFFFFFFFF) { + save_fs_list_set_value(ctx, index, value); + return index; + } + + index = save_fs_list_allocate_entry(ctx); + if (index == 0) { + EPRINTF("Failed to allocate FS list entry!"); + return 0; + } + + save_fs_list_entry_t entry; + save_fs_list_read_entry(ctx, index, &entry); + memcpy(&entry.value, value, sizeof(save_table_entry_t)); + entry.parent = key->parent; + memcpy(entry.name, key->name, SAVE_FS_LIST_MAX_NAME_LENGTH); + save_fs_list_write_entry(ctx, index, &entry); + + return index; +} diff --git a/bdk/libs/nx_savedata/save_fs_list.h b/bdk/libs/nx_savedata/save_fs_list.h new file mode 100644 index 0000000..72b4e4b --- /dev/null +++ b/bdk/libs/nx_savedata/save_fs_list.h @@ -0,0 +1,99 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef _SAVE_FS_LIST_H_ +#define _SAVE_FS_LIST_H_ + +#include "allocation_table_storage.h" +#include "save_fs_entry.h" + +#include +#include + +#define SAVE_FS_LIST_ENTRY_SIZE 0x60 +#define SAVE_FS_LIST_MAX_NAME_LENGTH 0x40 + +typedef struct { + uint32_t free_list_head_index; + uint32_t used_list_head_index; + allocation_table_storage_ctx_t storage; +} save_filesystem_list_ctx_t; + +typedef struct { + uint32_t next_sibling; + union { /* Save table entry type. Size = 0x14. */ + save_file_info_t save_file_info; + save_find_position_t save_find_position; + }; +} save_table_entry_t; + +static_assert(sizeof(save_table_entry_t) == 0x18, "Save table entry size is wrong!"); + +typedef struct { + uint32_t parent; + char name[SAVE_FS_LIST_MAX_NAME_LENGTH]; + save_table_entry_t value; + uint32_t next; +} save_fs_list_entry_t; + +typedef struct { + uint32_t list_size; + uint32_t list_capacity; + uint8_t rsvd[0x54]; + uint32_t next; +} save_fs_list_entry_meta_t; + +static_assert(sizeof(save_fs_list_entry_t) == 0x60, "Save filesystem list entry size is wrong!"); + +static ALWAYS_INLINE uint32_t save_fs_list_read_entry(save_filesystem_list_ctx_t *ctx, uint32_t index, void *entry) { + return save_allocation_table_storage_read(&ctx->storage, entry, index * SAVE_FS_LIST_ENTRY_SIZE, SAVE_FS_LIST_ENTRY_SIZE); +} + +static ALWAYS_INLINE uint32_t save_fs_list_write_entry(save_filesystem_list_ctx_t *ctx, uint32_t index, const void *entry) { + return save_allocation_table_storage_write(&ctx->storage, entry, index * SAVE_FS_LIST_ENTRY_SIZE, SAVE_FS_LIST_ENTRY_SIZE); +} + +void save_fs_list_init(save_filesystem_list_ctx_t *ctx); +uint32_t save_fs_list_get_index_from_key(save_filesystem_list_ctx_t *ctx, const save_entry_key_t *key, uint32_t *prev_index); +bool save_fs_list_get_value_by_index(save_filesystem_list_ctx_t *ctx, uint32_t index, save_table_entry_t *value); +bool save_fs_list_get_value_and_name(save_filesystem_list_ctx_t *ctx, uint32_t index, save_table_entry_t *value, char *name); +bool save_fs_list_try_get_value_by_index(save_filesystem_list_ctx_t *ctx, uint32_t index, save_table_entry_t *value); +bool save_fs_list_try_get_value_by_key(save_filesystem_list_ctx_t *ctx, save_entry_key_t *key, save_table_entry_t *value); +bool save_fs_list_try_get_value_and_name(save_filesystem_list_ctx_t *ctx, uint32_t index, save_table_entry_t *value, char *name); +bool save_fs_list_set_value(save_filesystem_list_ctx_t *ctx, uint32_t index, const save_table_entry_t *value); +bool save_fs_list_remove(save_filesystem_list_ctx_t *ctx, const save_entry_key_t *key); +bool save_fs_list_change_key(save_filesystem_list_ctx_t *ctx, save_entry_key_t *old_key, save_entry_key_t *new_key); +uint32_t save_fs_list_add(save_filesystem_list_ctx_t *ctx, const save_entry_key_t *key, const save_table_entry_t *value); + +#endif diff --git a/bdk/libs/nx_savedata/storage.c b/bdk/libs/nx_savedata/storage.c new file mode 100644 index 0000000..326f051 --- /dev/null +++ b/bdk/libs/nx_savedata/storage.c @@ -0,0 +1,241 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#include "storage.h" + +#include "cached_storage.h" +#include "hierarchical_duplex_storage.h" +#include "hierarchical_integrity_verification_storage.h" +#include "journal_storage.h" +#include "remap_storage.h" + +#include +#include + +#include + +void storage_init(storage *this, const storage_vt *vt, void *ctx) { + this->vt = vt; + this->ctx = ctx; +} + +void substorage_init(substorage *this, const storage_vt *vt, void *ctx, uint64_t offset, uint64_t length) { + storage_init(&this->base_storage, vt, ctx); + this->offset = offset; + this->length = length; +} + +bool substorage_init_from_other(substorage *this, const substorage *other, uint64_t offset, uint64_t length) { + if (offset + length > other->length) { + EPRINTF("Invalid size for substorage init!"); + EPRINTFARGS("ofs %x len %x size %x", (uint32_t)offset, (uint32_t)length, (uint32_t)other->length); + return false; + } + substorage_init(this, other->base_storage.vt, other->base_storage.ctx, other->offset + offset, length); + return true; +} + +void sector_storage_init(sector_storage *ctx, substorage *base_storage, uint32_t sector_size) { + memcpy(&ctx->base_storage, base_storage, sizeof(substorage)); + ctx->sector_size = sector_size; + ctx->length = base_storage->length; + ctx->sector_count = (uint32_t)(DIV_ROUND_UP(ctx->length, ctx->sector_size)); +} + +uint32_t sector_storage_read(sector_storage *ctx, void *buffer, uint64_t offset, uint64_t count) { + uint64_t remaining = count; + uint64_t in_offset = offset; + uint32_t out_offset = 0; + uint32_t sector_size = ctx->sector_size; + + while (remaining) { + uint32_t sector_pos = (uint32_t)(in_offset % sector_size); + uint32_t bytes_to_read = MIN((uint32_t)remaining, (uint32_t)(sector_size - sector_pos)); + + substorage_read(&ctx->base_storage, (uint8_t *)buffer + out_offset, in_offset, bytes_to_read); + + out_offset += bytes_to_read; + in_offset += bytes_to_read; + remaining -= bytes_to_read; + } + + return out_offset; +} + +uint32_t sector_storage_write(sector_storage *ctx, const void *buffer, uint64_t offset, uint64_t count) { + uint64_t remaining = count; + uint64_t in_offset = offset; + uint32_t out_offset = 0; + uint32_t sector_size = ctx->sector_size; + + while (remaining) { + uint32_t sector_pos = (uint32_t)(in_offset % sector_size); + uint32_t bytes_to_write = MIN((uint32_t)remaining, (uint32_t)(sector_size - sector_pos)); + + substorage_write(&ctx->base_storage, (uint8_t *)buffer + out_offset, in_offset, bytes_to_write); + + out_offset += bytes_to_write; + in_offset += bytes_to_write; + remaining -= bytes_to_write; + } + + return out_offset; +} + +uint32_t save_hierarchical_integrity_verification_storage_read_wrapper(void *ctx, void *buffer, uint64_t offset, uint64_t count) { + hierarchical_integrity_verification_storage_ctx_t *storage = (hierarchical_integrity_verification_storage_ctx_t *)ctx; + return save_cached_storage_read(storage->data_level, buffer, offset, count); +} + +uint32_t save_hierarchical_integrity_verification_storage_write_wrapper(void *ctx, const void *buffer, uint64_t offset, uint64_t count) { + hierarchical_integrity_verification_storage_ctx_t *storage = (hierarchical_integrity_verification_storage_ctx_t *)ctx; + return save_cached_storage_write(storage->data_level, buffer, offset, count); +} + +void save_hierarchical_integrity_verification_storage_get_size_wrapper(void *ctx, uint64_t *out_size) { + hierarchical_integrity_verification_storage_ctx_t *storage = (hierarchical_integrity_verification_storage_ctx_t *)ctx; + *out_size = storage->length; +} + +uint32_t memory_storage_read(uint8_t *storage, void *buffer, uint64_t offset, uint64_t count) { + memcpy(buffer, storage + offset, count); + return count; +} + +uint32_t memory_storage_write(uint8_t *storage, const void *buffer, uint64_t offset, uint64_t count) { + memcpy(storage + offset, buffer, count); + return count; +} + +uint32_t memory_storage_read_wrapper(void *ctx, void *buffer, uint64_t offset, uint64_t count) { + return memory_storage_read((uint8_t *)ctx, buffer, offset, count); +} + +uint32_t memory_storage_write_wrapper(void *ctx, const void *buffer, uint64_t offset, uint64_t count) { + return memory_storage_write((uint8_t *)ctx, buffer, offset, count); +} + +uint32_t save_file_read(FIL *fp, void *buffer, uint64_t offset, uint64_t count) { + UINT bytes_read = 0; + + if (f_lseek(fp, offset) || f_read(fp, buffer, count, &bytes_read) || bytes_read != count) { + EPRINTFARGS("Failed to read file at offset %x!\nRead %x bytes. Req %x bytes.", (uint32_t)offset, bytes_read, (uint32_t)count); + return 0; + } + return bytes_read; +} + +uint32_t save_file_write(FIL *fp, const void *buffer, uint64_t offset, uint64_t count) { + UINT bytes_written = 0; + if (f_lseek(fp, offset) || f_write(fp, buffer, count, &bytes_written) || bytes_written != count) { + EPRINTFARGS("Failed to write file at offset %x!", (uint32_t)offset); + return 0; + } + return bytes_written; +} + +void save_file_get_size(FIL *fp, uint64_t *out_size) { + *out_size = f_size(fp); +} + +uint32_t save_file_read_wrapper(void *ctx, void *buffer, uint64_t offset, uint64_t count) { + return save_file_read((FIL *)ctx, buffer, offset, count); +} + +uint32_t save_file_write_wrapper(void *ctx, const void *buffer, uint64_t offset, uint64_t count) { + return save_file_write((FIL *)ctx, buffer, offset, count); +} + +void save_file_get_size_wrapper(void *ctx, uint64_t *out_size) { + save_file_get_size((FIL *)ctx, out_size); +} + +uint32_t save_remap_storage_read_wrapper(void *ctx, void *buffer, uint64_t offset, uint64_t count) { + return save_remap_storage_read((remap_storage_ctx_t *)ctx, buffer, offset, count); +} + +uint32_t save_remap_storage_write_wrapper(void *ctx, const void *buffer, uint64_t offset, uint64_t count) { + return save_remap_storage_write((remap_storage_ctx_t *)ctx, buffer, offset, count); +} + +void save_remap_storage_get_size_wrapper(__attribute__((unused)) void *ctx, uint64_t *out_size) { + *out_size = -1; +} + +uint32_t save_journal_storage_read_wrapper(void *ctx, void *buffer, uint64_t offset, uint64_t count) { + return save_journal_storage_read((journal_storage_ctx_t *)ctx, buffer, offset, count); +} + +uint32_t save_journal_storage_write_wrapper(void *ctx, const void *buffer, uint64_t offset, uint64_t count) { + return save_journal_storage_write((journal_storage_ctx_t *)ctx, buffer, offset, count); +} + +void save_journal_storage_get_size_wrapper(void *ctx, uint64_t *out_size) { + journal_storage_ctx_t *journal = (journal_storage_ctx_t *)ctx; + *out_size = journal->length; +} + +uint32_t save_ivfc_storage_read_wrapper(void *ctx, void *buffer, uint64_t offset, uint64_t count) { + return save_ivfc_storage_read((integrity_verification_storage_ctx_t *)ctx, buffer, offset, count) ? count : 0; +} + +uint32_t save_ivfc_storage_write_wrapper(void *ctx, const void *buffer, uint64_t offset, uint64_t count) { + return save_ivfc_storage_write((integrity_verification_storage_ctx_t *)ctx, buffer, offset, count) ? count : 0; +} + +void save_ivfc_storage_get_size_wrapper(void *ctx, uint64_t *out_size) { + integrity_verification_storage_ctx_t *ivfc = (integrity_verification_storage_ctx_t *)ctx; + *out_size = ivfc->base_storage.length; +} + +uint32_t save_hierarchical_duplex_storage_read(hierarchical_duplex_storage_ctx_t *ctx, void *buffer, uint64_t offset, uint64_t count) { + return save_duplex_storage_read(ctx->data_layer, buffer, offset, count); +} + +uint32_t save_hierarchical_duplex_storage_write(hierarchical_duplex_storage_ctx_t *ctx, const void *buffer, uint64_t offset, uint64_t count) { + return save_duplex_storage_write(ctx->data_layer, buffer, offset, count); +} + +uint32_t save_hierarchical_duplex_storage_read_wrapper(void *ctx, void *buffer, uint64_t offset, uint64_t count) { + return save_hierarchical_duplex_storage_read((hierarchical_duplex_storage_ctx_t *)ctx, buffer, offset, count); +} + +uint32_t save_hierarchical_duplex_storage_write_wrapper(void *ctx, const void *buffer, uint64_t offset, uint64_t count) { + return save_hierarchical_duplex_storage_write((hierarchical_duplex_storage_ctx_t *)ctx, buffer, offset, count); +} + +void save_hierarchical_duplex_storage_get_size_wrapper(void *ctx, uint64_t *out_size) { + hierarchical_duplex_storage_ctx_t *duplex = (hierarchical_duplex_storage_ctx_t *)ctx; + *out_size = duplex->_length; +} diff --git a/bdk/libs/nx_savedata/storage.h b/bdk/libs/nx_savedata/storage.h new file mode 100644 index 0000000..545a26b --- /dev/null +++ b/bdk/libs/nx_savedata/storage.h @@ -0,0 +1,169 @@ +/* + * Copyright (c) 2019-2020 shchmue + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* +ISC License + +hactool Copyright (c) 2018, SciresM + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef HACTOOL_STORAGE_H +#define HACTOOL_STORAGE_H + +#include + +#include + +typedef struct { + uint32_t (*read)(void *ctx, void *buffer, uint64_t offset, uint64_t count); + uint32_t (*write)(void *ctx, const void *buffer, uint64_t offset, uint64_t count); + void (*set_size)(void *ctx, uint64_t size); + void (*get_size)(void *ctx, uint64_t *out_size); +} storage_vt; + +typedef struct { + const storage_vt *vt; + void *ctx; +} storage; + +void storage_init(storage *this, const storage_vt *vt, void *ctx); + +typedef struct { + uint64_t offset; + uint64_t length; + storage base_storage; +} substorage; + +void substorage_init(substorage *this, const storage_vt *vt, void *ctx, uint64_t offset, uint64_t length); +bool substorage_init_from_other(substorage *this, const substorage *other, uint64_t offset, uint64_t length); + +static ALWAYS_INLINE uint32_t substorage_read(substorage *ctx, void *buffer, uint64_t offset, uint64_t count) { + return ctx->base_storage.vt->read(ctx->base_storage.ctx, buffer, ctx->offset + offset, count); +} + +static ALWAYS_INLINE uint32_t substorage_write(substorage *ctx, const void *buffer, uint64_t offset, uint64_t count) { + return ctx->base_storage.vt->write(ctx->base_storage.ctx, buffer, ctx->offset + offset, count); +} + +static ALWAYS_INLINE void substorage_get_size(substorage *ctx, uint64_t *out_size) { + ctx->base_storage.vt->get_size(ctx->base_storage.ctx, out_size); +} + +typedef struct { + substorage base_storage; + uint32_t sector_size; + uint32_t sector_count; + uint64_t length; +} sector_storage; + +void sector_storage_init(sector_storage *ctx, substorage *base_storage, uint32_t sector_size); + +uint32_t save_hierarchical_integrity_verification_storage_read_wrapper(void *ctx, void *buffer, uint64_t offset, uint64_t count); +uint32_t save_hierarchical_integrity_verification_storage_write_wrapper(void *ctx, const void *buffer, uint64_t offset, uint64_t count); +void save_hierarchical_integrity_verification_storage_get_size_wrapper(void *ctx, uint64_t *out_size); + +static const storage_vt hierarchical_integrity_verification_storage_vt = { + save_hierarchical_integrity_verification_storage_read_wrapper, + save_hierarchical_integrity_verification_storage_write_wrapper, + NULL, + save_hierarchical_integrity_verification_storage_get_size_wrapper +}; + +uint32_t memory_storage_read_wrapper(void *ctx, void *buffer, uint64_t offset, uint64_t count); +uint32_t memory_storage_write_wrapper(void *ctx, const void *buffer, uint64_t offset, uint64_t count); + +static const storage_vt memory_storage_vt = { + memory_storage_read_wrapper, + memory_storage_write_wrapper, + NULL, + NULL +}; + +uint32_t save_file_read_wrapper(void *ctx, void *buffer, uint64_t offset, uint64_t count); +uint32_t save_file_write_wrapper(void *ctx, const void *buffer, uint64_t offset, uint64_t count); +void save_file_get_size_wrapper(void *ctx, uint64_t *out_size); + +static const storage_vt file_storage_vt = { + save_file_read_wrapper, + save_file_write_wrapper, + NULL, + save_file_get_size_wrapper +}; + +uint32_t save_remap_storage_read_wrapper(void *ctx, void *buffer, uint64_t offset, uint64_t count); +uint32_t save_remap_storage_write_wrapper(void *ctx, const void *buffer, uint64_t offset, uint64_t count); +void save_remap_storage_get_size_wrapper(void *ctx, uint64_t *out_size); + +static const storage_vt remap_storage_vt = { + save_remap_storage_read_wrapper, + save_remap_storage_write_wrapper, + NULL, + save_remap_storage_get_size_wrapper +}; + +uint32_t save_journal_storage_read_wrapper(void *ctx, void *buffer, uint64_t offset, uint64_t count); +uint32_t save_journal_storage_write_wrapper(void *ctx, const void *buffer, uint64_t offset, uint64_t count); +void save_journal_storage_get_size_wrapper(void *ctx, uint64_t *out_size); + +static const storage_vt journal_storage_vt = { + save_journal_storage_read_wrapper, + save_journal_storage_write_wrapper, + NULL, + save_journal_storage_get_size_wrapper +}; + +uint32_t save_ivfc_storage_read_wrapper(void *ctx, void *buffer, uint64_t offset, uint64_t count); +uint32_t save_ivfc_storage_write_wrapper(void *ctx, const void *buffer, uint64_t offset, uint64_t count); +void save_ivfc_storage_get_size_wrapper(void *ctx, uint64_t *out_size); + +static const storage_vt ivfc_storage_vt = { + save_ivfc_storage_read_wrapper, + save_ivfc_storage_write_wrapper, + NULL, + save_ivfc_storage_get_size_wrapper +}; + +uint32_t save_hierarchical_duplex_storage_read_wrapper(void *ctx, void *buffer, uint64_t offset, uint64_t count); +uint32_t save_hierarchical_duplex_storage_write_wrapper(void *ctx, const void *buffer, uint64_t offset, uint64_t count); +void save_hierarchical_duplex_storage_get_size_wrapper(void *ctx, uint64_t *out_size); + +static const storage_vt hierarchical_duplex_storage_vt = { + save_hierarchical_duplex_storage_read_wrapper, + save_hierarchical_duplex_storage_write_wrapper, + NULL, + save_hierarchical_duplex_storage_get_size_wrapper +}; + +static ALWAYS_INLINE bool is_range_valid(uint64_t offset, uint64_t size, uint64_t total_size) { + return offset >= 0 && + size >= 0 && + size <= total_size && + offset <= total_size - size; +} + +#endif diff --git a/source/keys/save.c b/source/keys/save.c deleted file mode 100644 index 463bb95..0000000 --- a/source/keys/save.c +++ /dev/null @@ -1,829 +0,0 @@ -#include -#include -#include "save.h" - -#include -#include -#include -#include -#include - -#define REMAP_ENTRY_LENGTH 0x20 - -static inline void save_bitmap_set_bit(void *buffer, size_t bit_offset) { - *((uint8_t *)buffer + (bit_offset >> 3)) |= 1 << (bit_offset & 7); -} - -static inline void save_bitmap_clear_bit(void *buffer, size_t bit_offset) { - *((uint8_t *)buffer + (bit_offset >> 3)) &= ~(uint8_t)(1 << (bit_offset & 7)); -} - -static inline uint8_t save_bitmap_check_bit(const void *buffer, size_t bit_offset) { - return *((uint8_t *)buffer + (bit_offset >> 3)) & (1 << (bit_offset & 7)); -} - -void save_duplex_storage_init(duplex_storage_ctx_t *ctx, duplex_fs_layer_info_t *layer, void *bitmap, uint64_t bitmap_size) { - ctx->data_a = layer->data_a; - ctx->data_b = layer->data_b; - ctx->bitmap_storage = (uint8_t *)bitmap; - ctx->block_size = 1 << layer->info.block_size_power; - - ctx->bitmap.data = ctx->bitmap_storage; - ctx->bitmap.bitmap = malloc(bitmap_size >> 3); - - uint32_t bits_remaining = bitmap_size; - uint32_t bitmap_pos = 0; - uint32_t *buffer_pos = (uint32_t *)bitmap; - while (bits_remaining) { - uint32_t bits_to_read = bits_remaining < 32 ? bits_remaining : 32; - uint32_t val = *buffer_pos; - for (uint32_t i = 0; i < bits_to_read; i++) { - if (val & 0x80000000) - save_bitmap_set_bit(ctx->bitmap.bitmap, bitmap_pos); - else - save_bitmap_clear_bit(ctx->bitmap.bitmap, bitmap_pos); - bitmap_pos++; - bits_remaining--; - val <<= 1; - } - buffer_pos++; - } -} - -uint32_t save_duplex_storage_read(duplex_storage_ctx_t *ctx, void *buffer, uint64_t offset, size_t count) { - uint64_t in_pos = offset; - uint32_t out_pos = 0; - uint32_t remaining = count; - - while (remaining) { - uint32_t block_num = (uint32_t)(in_pos / ctx->block_size); - uint32_t block_pos = (uint32_t)(in_pos % ctx->block_size); - uint32_t bytes_to_read = ctx->block_size - block_pos < remaining ? ctx->block_size - block_pos : remaining; - - uint8_t *data = save_bitmap_check_bit(ctx->bitmap.bitmap, block_num) ? ctx->data_b : ctx->data_a; - memcpy((uint8_t *)buffer + out_pos, data + in_pos, bytes_to_read); - - out_pos += bytes_to_read; - in_pos += bytes_to_read; - remaining -= bytes_to_read; - } - return out_pos; -} - -remap_segment_ctx_t *save_remap_init_segments(remap_header_t *header, remap_entry_ctx_t *map_entries, uint32_t num_map_entries) { - remap_segment_ctx_t *segments = calloc(1, sizeof(remap_segment_ctx_t) * header->map_segment_count); - unsigned int entry_idx = 0; - - for (unsigned int i = 0; i < header->map_segment_count; i++) { - remap_segment_ctx_t *seg = &segments[i]; - seg->entry_count = 0; - seg->entries = malloc(sizeof(remap_entry_ctx_t *)); - seg->entries[seg->entry_count++] = &map_entries[entry_idx]; - seg->offset = map_entries[entry_idx].virtual_offset; - map_entries[entry_idx++].segment = seg; - - while (entry_idx < num_map_entries && map_entries[entry_idx - 1].virtual_offset_end == map_entries[entry_idx].virtual_offset) { - map_entries[entry_idx].segment = seg; - map_entries[entry_idx - 1].next = &map_entries[entry_idx]; - remap_entry_ctx_t **ptr = calloc(1, sizeof(remap_entry_ctx_t *) * (seg->entry_count + 1)); - memcpy(ptr, seg->entries, sizeof(remap_entry_ctx_t *) * (seg->entry_count)); - free(seg->entries); - seg->entries = ptr; - seg->entries[seg->entry_count++] = &map_entries[entry_idx++]; - } - seg->length = seg->entries[seg->entry_count - 1]->virtual_offset_end - seg->entries[0]->virtual_offset; - } - return segments; -} - -remap_entry_ctx_t *save_remap_get_map_entry(remap_storage_ctx_t *ctx, uint64_t offset) { - uint32_t segment_idx = (uint32_t)(offset >> (64 - ctx->header->segment_bits)); - if (segment_idx < ctx->header->map_segment_count) { - for (unsigned int i = 0; i < ctx->segments[segment_idx].entry_count; i++) - if (ctx->segments[segment_idx].entries[i]->virtual_offset_end > offset) - return ctx->segments[segment_idx].entries[i]; - } - return NULL; -} - -uint32_t save_remap_read(remap_storage_ctx_t *ctx, void *buffer, uint64_t offset, size_t count) { - remap_entry_ctx_t *entry = save_remap_get_map_entry(ctx, offset); - uint64_t in_pos = offset; - uint32_t out_pos = 0; - uint32_t remaining = count; - - while (remaining) { - uint64_t entry_pos = in_pos - entry->virtual_offset; - uint32_t bytes_to_read = entry->virtual_offset_end - in_pos < remaining ? (uint32_t)(entry->virtual_offset_end - in_pos) : remaining; - - switch (ctx->type) { - case STORAGE_BYTES: - f_lseek(ctx->file, ctx->base_storage_offset + entry->physical_offset + entry_pos); - f_read(ctx->file, (uint8_t *)buffer + out_pos, bytes_to_read, NULL); - break; - case STORAGE_DUPLEX: - save_duplex_storage_read(ctx->duplex, (uint8_t *)buffer + out_pos, ctx->base_storage_offset + entry->physical_offset + entry_pos, bytes_to_read); - break; - default: - break; - } - - out_pos += bytes_to_read; - in_pos += bytes_to_read; - remaining -= bytes_to_read; - - if (in_pos >= entry->virtual_offset_end) - entry = entry->next; - } - return out_pos; -} - -uint32_t save_journal_storage_read(journal_storage_ctx_t *ctx, remap_storage_ctx_t *remap, void *buffer, uint64_t offset, size_t count) { - uint64_t in_pos = offset; - uint32_t out_pos = 0; - uint32_t remaining = count; - - while (remaining) { - uint32_t block_num = (uint32_t)(in_pos / ctx->block_size); - uint32_t block_pos = (uint32_t)(in_pos % ctx->block_size); - uint64_t physical_offset = ctx->map.entries[block_num].physical_index * ctx->block_size + block_pos; - uint32_t bytes_to_read = ctx->block_size - block_pos < remaining ? ctx->block_size - block_pos : remaining; - - save_remap_read(remap, (uint8_t *)buffer + out_pos, ctx->journal_data_offset + physical_offset, bytes_to_read); - - out_pos += bytes_to_read; - in_pos += bytes_to_read; - remaining -= bytes_to_read; - } - return out_pos; -} - -void save_ivfc_storage_init(hierarchical_integrity_verification_storage_ctx_t *ctx, uint64_t master_hash_offset, ivfc_save_hdr_t *ivfc) { - ivfc_level_save_ctx_t *levels = ctx->levels; - levels[0].type = STORAGE_BYTES; - levels[0].hash_offset = master_hash_offset; - for (unsigned int i = 1; i < 4; i++) { - ivfc_level_hdr_t *level = &ivfc->level_headers[i - 1]; - levels[i].type = STORAGE_REMAP; - levels[i].data_offset = level->logical_offset; - levels[i].data_size = level->hash_data_size; - } - if (ivfc->num_levels == 5) { - ivfc_level_hdr_t *data_level = &ivfc->level_headers[ivfc->num_levels - 2]; - levels[ivfc->num_levels - 1].type = STORAGE_JOURNAL; - levels[ivfc->num_levels - 1].data_offset = data_level->logical_offset; - levels[ivfc->num_levels - 1].data_size = data_level->hash_data_size; - } - - struct salt_source_t { - char string[50]; - uint32_t length; - }; - - static const struct salt_source_t salt_sources[6] = { - {"HierarchicalIntegrityVerificationStorage::Master", 48}, - {"HierarchicalIntegrityVerificationStorage::L1", 44}, - {"HierarchicalIntegrityVerificationStorage::L2", 44}, - {"HierarchicalIntegrityVerificationStorage::L3", 44}, - {"HierarchicalIntegrityVerificationStorage::L4", 44}, - {"HierarchicalIntegrityVerificationStorage::L5", 44} - }; - integrity_verification_info_ctx_t init_info[ivfc->num_levels]; - - init_info[0].data = &levels[0]; - init_info[0].block_size = 0; - for (unsigned int i = 1; i < ivfc->num_levels; i++) { - init_info[i].data = &levels[i]; - init_info[i].block_size = 1 << ivfc->level_headers[i - 1].block_size; - se_calc_hmac_sha256(init_info[i].salt, ivfc->salt_source, 0x20, salt_sources[i - 1].string, salt_sources[i - 1].length); - } - - ctx->integrity_storages[0].next_level = NULL; - ctx->level_validities = malloc(sizeof(validity_t *) * (ivfc->num_levels - 1)); - for (unsigned int i = 1; i < ivfc->num_levels; i++) { - integrity_verification_storage_ctx_t *level_data = &ctx->integrity_storages[i - 1]; - level_data->hash_storage = &levels[i - 1]; - level_data->base_storage = &levels[i]; - level_data->sector_size = init_info[i].block_size; - level_data->_length = init_info[i].data->data_size; - level_data->sector_count = (level_data->_length + level_data->sector_size - 1) / level_data->sector_size; - memcpy(level_data->salt, init_info[i].salt, 0x20); - level_data->block_validities = calloc(1, sizeof(validity_t) * level_data->sector_count); - ctx->level_validities[i - 1] = level_data->block_validities; - if (i > 1) { - level_data->next_level = &ctx->integrity_storages[i - 2]; - } - } - ctx->data_level = &levels[ivfc->num_levels - 1]; - ctx->_length = ctx->integrity_storages[ivfc->num_levels - 2]._length; -} - -size_t save_ivfc_level_fread(ivfc_level_save_ctx_t *ctx, void *buffer, uint64_t offset, size_t count) { - switch (ctx->type) { - case STORAGE_BYTES: - f_lseek(ctx->save_ctx->file, ctx->hash_offset + offset); - UINT br = 0; - f_read(ctx->save_ctx->file, buffer, count, &br); - return br; - case STORAGE_REMAP: - save_remap_read(&ctx->save_ctx->meta_remap_storage, buffer, ctx->data_offset + offset, count); - return count; - case STORAGE_JOURNAL: - save_journal_storage_read(&ctx->save_ctx->journal_storage, &ctx->save_ctx->data_remap_storage, buffer, ctx->data_offset + offset, count); - return count; - default: - return 0; - } -} - -void save_ivfc_storage_read(integrity_verification_storage_ctx_t *ctx, void *buffer, uint64_t offset, size_t count, uint32_t verify) { - if (count > ctx->sector_size) { - EPRINTF("IVFC read exceeds sector size!"); - return; - } - - uint64_t block_index = offset / ctx->sector_size; - - if (ctx->block_validities[block_index] == VALIDITY_INVALID && verify) { - EPRINTFARGS("Hash error from previous check\n found at offset %x count %x!", (u32)offset, count); - return; - } - - uint8_t hash_buffer[0x20] = {0}; - uint8_t zeroes[0x20] = {0}; - uint64_t hash_pos = block_index * 0x20; - if (ctx->next_level) { - save_ivfc_storage_read(ctx->next_level, hash_buffer, hash_pos, 0x20, verify); - } else { - save_ivfc_level_fread(ctx->hash_storage, hash_buffer, hash_pos, 0x20); - } - - if (!memcmp(hash_buffer, zeroes, 0x20)) { - memset(buffer, 0, count); - ctx->block_validities[block_index] = VALIDITY_VALID; - return; - } - - save_ivfc_level_fread(ctx->base_storage, buffer, offset, count); - - if (!(verify && ctx->block_validities[block_index] == VALIDITY_UNCHECKED)) { - return; - } - - uint8_t hash[0x20] = {0}; - uint8_t *data_buffer = calloc(1, ctx->sector_size + 0x20); - memcpy(data_buffer, ctx->salt, 0x20); - memcpy(data_buffer + 0x20, buffer, ctx->sector_size); - - se_calc_sha256(hash, data_buffer, ctx->sector_size + 0x20); - hash[0x1F] |= 0x80; - - free(data_buffer); - if (memcmp(hash_buffer, hash, 0x20) != 0) { - ctx->block_validities[block_index] = VALIDITY_INVALID; - } else { - ctx->block_validities[block_index] = VALIDITY_VALID; - } - - if (ctx->block_validities[block_index] == VALIDITY_INVALID && verify) { - EPRINTFARGS("Hash error from current check\n found at offset %x count %x!", (u32)offset, count); - return; - } -} - -uint32_t save_allocation_table_read_entry_with_length(allocation_table_ctx_t *ctx, allocation_table_entry_t *entry) { - uint32_t length = 1; - uint32_t entry_index = allocation_table_block_to_entry_index(entry->next); - uint32_t offset = entry_index * SAVE_FAT_ENTRY_SIZE; - - allocation_table_entry_t *entries = (allocation_table_entry_t *)((uint8_t *)(ctx->base_storage) + offset); - if (allocation_table_is_single_block_segment(&entries[0])) { - if (allocation_table_is_range_entry(&entries[0])) { - EPRINTF("Invalid range entry in allocation table!"); - return 0; - } - } else { - length = entries[1].next - entry_index + 1; - } - - if (allocation_table_is_list_end(&entries[0])) { - entry->next = 0xFFFFFFFF; - } else { - entry->next = allocation_table_entry_index_to_block(allocation_table_get_next(&entries[0])); - } - - if (allocation_table_is_list_start(&entries[0])) { - entry->prev = 0xFFFFFFFF; - } else { - entry->prev = allocation_table_entry_index_to_block(allocation_table_get_prev(&entries[0])); - } - - return length; -} - -uint32_t save_allocation_table_get_list_length(allocation_table_ctx_t *ctx, uint32_t block_index) { - allocation_table_entry_t entry; - entry.next = block_index; - uint32_t total_length = 0; - uint32_t table_size = ctx->header->allocation_table_block_count; - uint32_t nodes_iterated = 0; - - while (entry.next != 0xFFFFFFFF) { - total_length += save_allocation_table_read_entry_with_length(ctx, &entry); - nodes_iterated++; - if (nodes_iterated > table_size) { - EPRINTF("Cycle detected in allocation table!"); - return 0; - } - } - return total_length; -} - -uint64_t save_allocation_table_get_free_space_size(save_filesystem_ctx_t *ctx) { - uint32_t free_list_start = save_allocation_table_get_free_list_block_index(&ctx->allocation_table); - - if (free_list_start == 0xFFFFFFFF) return 0; - - return ctx->header->block_size * save_allocation_table_get_list_length(&ctx->allocation_table, free_list_start); -} - -void save_allocation_table_iterator_begin(allocation_table_iterator_ctx_t *ctx, allocation_table_ctx_t *table, uint32_t initial_block) { - ctx->fat = table; - ctx->physical_block = initial_block; - ctx->virtual_block = 0; - - allocation_table_entry_t entry = {0, 0}; - entry.next = initial_block; - ctx->current_segment_size = save_allocation_table_read_entry_with_length(ctx->fat, &entry); - ctx->next_block = entry.next; - ctx->prev_block = entry.prev; - - if (ctx->prev_block != 0xFFFFFFFF) { - EPRINTFARGS("Attempted to start FAT iteration from\n invalid block %x!", initial_block); - return; - } -} - -int save_allocation_table_iterator_move_next(allocation_table_iterator_ctx_t *ctx) { - if (ctx->next_block == 0xFFFFFFFF) return 0; - - ctx->virtual_block += ctx->current_segment_size; - ctx->physical_block = ctx->next_block; - - allocation_table_entry_t entry = {0, 0}; - entry.next = ctx->next_block; - ctx->current_segment_size = save_allocation_table_read_entry_with_length(ctx->fat, &entry); - ctx->next_block = entry.next; - ctx->prev_block = entry.prev; - - return 1; -} - -int save_allocation_table_iterator_move_prev(allocation_table_iterator_ctx_t *ctx) { - if (ctx->prev_block == 0xFFFFFFFF) return 0; - - ctx->physical_block = ctx->prev_block; - - allocation_table_entry_t entry = {0, 0}; - entry.next = ctx->prev_block; - ctx->current_segment_size = save_allocation_table_read_entry_with_length(ctx->fat, &entry); - ctx->next_block = entry.next; - ctx->prev_block = entry.prev; - - ctx->virtual_block -= ctx->current_segment_size; - - return 1; -} - -int save_allocation_table_iterator_seek(allocation_table_iterator_ctx_t *ctx, uint32_t block) { - while (1) { - if (block < ctx->virtual_block) { - if (!save_allocation_table_iterator_move_prev(ctx)) return 0; - } else if (block >= ctx->virtual_block + ctx->current_segment_size) { - if (!save_allocation_table_iterator_move_next(ctx)) return 0; - } else { - return 1; - } - - } -} - -uint32_t save_allocation_table_storage_read(allocation_table_storage_ctx_t *ctx, void *buffer, uint64_t offset, size_t count) { - allocation_table_iterator_ctx_t iterator; - save_allocation_table_iterator_begin(&iterator, ctx->fat, ctx->initial_block); - uint64_t in_pos = offset; - uint32_t out_pos = 0; - uint32_t remaining = count; - - while (remaining) { - uint32_t block_num = (uint32_t)(in_pos / ctx->block_size); - save_allocation_table_iterator_seek(&iterator, block_num); - - uint32_t segment_pos = (uint32_t)(in_pos - (uint64_t)iterator.virtual_block * ctx->block_size); - uint64_t physical_offset = iterator.physical_block * ctx->block_size + segment_pos; - - uint32_t remaining_in_segment = iterator.current_segment_size * ctx->block_size - segment_pos; - uint32_t bytes_to_read = remaining < remaining_in_segment ? remaining : remaining_in_segment; - - uint32_t sector_size = ctx->base_storage->integrity_storages[3].sector_size; - uint32_t chunk_remaining = bytes_to_read; - for (unsigned int i = 0; i < bytes_to_read; i += sector_size) { - uint32_t bytes_to_request = chunk_remaining < sector_size ? chunk_remaining : sector_size; - save_ivfc_storage_read(&ctx->base_storage->integrity_storages[3], (uint8_t *)buffer + out_pos + i, physical_offset + i, bytes_to_request, ctx->base_storage->data_level->save_ctx->tool_ctx.action & ACTION_VERIFY); - chunk_remaining -= bytes_to_request; - } - - out_pos += bytes_to_read; - in_pos += bytes_to_read; - remaining -= bytes_to_read; - } - return out_pos; -} - -uint32_t save_fs_list_get_capacity(save_filesystem_list_ctx_t *ctx) { - if (!ctx->capacity) - save_allocation_table_storage_read(&ctx->storage, &ctx->capacity, 4, 4); - return ctx->capacity; -} - -uint32_t save_fs_list_read_entry(save_filesystem_list_ctx_t *ctx, uint32_t index, save_fs_list_entry_t *entry) { - return save_allocation_table_storage_read(&ctx->storage, entry, index * SAVE_FS_LIST_ENTRY_SIZE, SAVE_FS_LIST_ENTRY_SIZE); -} - -int save_fs_list_get_value(save_filesystem_list_ctx_t *ctx, uint32_t index, save_fs_list_entry_t *value) { - if (index >= save_fs_list_get_capacity(ctx)) { - return 0; - } - save_fs_list_read_entry(ctx, index, value); - return 1; -} - -uint32_t save_fs_list_get_index_from_key(save_filesystem_list_ctx_t *ctx, save_entry_key_t *key, uint32_t *prev_index) { - save_fs_list_entry_t entry; - uint32_t capacity = save_fs_list_get_capacity(ctx); - save_fs_list_read_entry(ctx, ctx->used_list_head_index, &entry); - uint32_t prev; - if (!prev_index) { - prev_index = &prev; - } - *prev_index = ctx->used_list_head_index; - uint32_t index = entry.next; - while (index) { - if (index > capacity) { - EPRINTFARGS("Save entry index %d out of range!", index); - *prev_index = 0xFFFFFFFF; - return 0xFFFFFFFF; - } - save_fs_list_read_entry(ctx, index, &entry); - if (entry.parent == key->parent && !strcmp(entry.name, key->name)) { - return index; - } - *prev_index = index; - index = entry.next; - } - *prev_index = 0xFFFFFFFF; - return 0xFFFFFFFF; -} - -int save_hierarchical_file_table_find_path_recursive(hierarchical_save_file_table_ctx_t *ctx, save_entry_key_t *key, const char *path) { - key->parent = 0; - const char *pos = strchr(path, '/'); - while (pos) { - memset(key->name, 0, SAVE_FS_LIST_MAX_NAME_LENGTH); - const char *tmp = strchr(pos, '/'); - if (!tmp) { - memcpy(key->name, pos, strlen(pos)); - break; - } - memcpy(key->name, pos, tmp - pos); - key->parent = save_fs_list_get_index_from_key(&ctx->directory_table, key, NULL); - if (key->parent == 0xFFFFFFFF) - return 0; - pos = tmp + 1; - } - return 1; -} - -int save_hierarchical_file_table_find_next_file(hierarchical_save_file_table_ctx_t *ctx, save_find_position_t *position, save_file_info_t *info, char *name) { - if (position->next_file == 0) { - return 0; - } - save_fs_list_entry_t entry; - if(!save_fs_list_get_value(&ctx->file_table, position->next_file, &entry)) { - return 0; - } - position->next_file = entry.value.next_sibling; - memcpy(name, &entry.name, SAVE_FS_LIST_MAX_NAME_LENGTH); - memcpy(info, &entry.value.save_file_info, sizeof(save_file_info_t)); - return 1; -} - -int save_hierarchical_file_table_find_next_directory(hierarchical_save_file_table_ctx_t *ctx, save_find_position_t *position, char *name) { - if (position->next_directory == 0) { - return 0; - } - save_fs_list_entry_t entry; - if(!save_fs_list_get_value(&ctx->directory_table, position->next_directory, &entry)) { - return 0; - } - position->next_directory = entry.value.next_sibling; - memcpy(name, &entry.name, SAVE_FS_LIST_MAX_NAME_LENGTH); - return 1; -} - -int save_hierarchical_file_table_get_file_entry_by_path(hierarchical_save_file_table_ctx_t *ctx, const char *path, save_fs_list_entry_t *entry) { - save_entry_key_t key; - if (!save_hierarchical_file_table_find_path_recursive(ctx, &key, path)) { - EPRINTF("Unable to locate file."); - return 0; - } - u32 index = save_fs_list_get_index_from_key(&ctx->file_table, &key, NULL); - if (index == 0xFFFFFFFF) { - EPRINTF("Unable to get table index for file."); - return 0; - } - if (!save_fs_list_get_value(&ctx->file_table, index, entry)) { - EPRINTF("Unable to get file entry from index."); - return 0; - } - return 1; -} - -void save_open_fat_storage(save_filesystem_ctx_t *ctx, allocation_table_storage_ctx_t *storage_ctx, uint32_t block_index) { - storage_ctx->base_storage = ctx->base_storage; - storage_ctx->fat = &ctx->allocation_table; - storage_ctx->block_size = (uint32_t)ctx->header->block_size; - storage_ctx->initial_block = block_index; - storage_ctx->_length = block_index == 0xFFFFFFFF ? 0 : save_allocation_table_get_list_length(storage_ctx->fat, block_index) * storage_ctx->block_size; -} - -void save_filesystem_init(save_filesystem_ctx_t *ctx, void *fat, save_fs_header_t *save_fs_header, fat_header_t *fat_header) { - ctx->allocation_table.base_storage = fat; - ctx->allocation_table.header = fat_header; - ctx->allocation_table.free_list_entry_index = 0; - ctx->header = save_fs_header; - - save_open_fat_storage(ctx, &ctx->file_table.directory_table.storage, fat_header->directory_table_block); - save_open_fat_storage(ctx, &ctx->file_table.file_table.storage, fat_header->file_table_block); - ctx->file_table.file_table.free_list_head_index = 0; - ctx->file_table.file_table.used_list_head_index = 1; - ctx->file_table.directory_table.free_list_head_index = 0; - ctx->file_table.directory_table.used_list_head_index = 1; -} - -validity_t save_ivfc_validate(hierarchical_integrity_verification_storage_ctx_t *ctx, ivfc_save_hdr_t *ivfc) { - validity_t result = VALIDITY_VALID; - for (unsigned int i = 0; i < ivfc->num_levels - 1 && result != VALIDITY_INVALID; i++) { - integrity_verification_storage_ctx_t *storage = &ctx->integrity_storages[i]; - - uint64_t block_size = storage->sector_size; - uint32_t block_count = (uint32_t)((storage->_length + block_size - 1) / block_size); - - uint8_t *buffer = malloc(block_size); - - for (unsigned int j = 0; j < block_count; j++) { - if (ctx->level_validities[ivfc->num_levels - 2][j] == VALIDITY_UNCHECKED) { - uint32_t to_read = storage->_length - block_size * j < block_size ? storage->_length - block_size * j : block_size; - save_ivfc_storage_read(storage, buffer, block_size * j, to_read, 1); - } - if (ctx->level_validities[ivfc->num_levels - 2][j] == VALIDITY_INVALID) { - result = VALIDITY_INVALID; - break; - } - } - free(buffer); - } - - return result; -} - -void save_ivfc_set_level_validities(hierarchical_integrity_verification_storage_ctx_t *ctx, ivfc_save_hdr_t *ivfc) { - for (unsigned int i = 0; i < ivfc->num_levels - 1; i++) { - validity_t level_validity = VALIDITY_VALID; - for (unsigned int j = 0; j < ctx->integrity_storages[i].sector_count; j++) { - if (ctx->level_validities[i][j] == VALIDITY_INVALID) { - level_validity = VALIDITY_INVALID; - break; - } - if (ctx->level_validities[i][j] == VALIDITY_UNCHECKED && level_validity != VALIDITY_INVALID) { - level_validity = VALIDITY_UNCHECKED; - } - } - ctx->levels[i].hash_validity = level_validity; - } -} - -validity_t save_filesystem_verify(save_ctx_t *ctx) { - validity_t journal_validity = save_ivfc_validate(&ctx->core_data_ivfc_storage, &ctx->header.data_ivfc_header); - save_ivfc_set_level_validities(&ctx->core_data_ivfc_storage, &ctx->header.data_ivfc_header); - - if (!ctx->fat_ivfc_storage.levels[0].save_ctx) return journal_validity; - - validity_t fat_validity = save_ivfc_validate(&ctx->fat_ivfc_storage, &ctx->header.fat_ivfc_header); - save_ivfc_set_level_validities(&ctx->fat_ivfc_storage, &ctx->header.fat_ivfc_header); - - if (journal_validity != VALIDITY_VALID) return journal_validity; - if (fat_validity != VALIDITY_VALID) return fat_validity; - - return journal_validity; -} - -bool save_process(save_ctx_t *ctx) { - /* Try to parse Header A. */ - f_lseek(ctx->file, 0); - if (f_read(ctx->file, &ctx->header, sizeof(ctx->header), NULL)) { - EPRINTF("Failed to read save header!\n"); - return false; - } - - if (!save_process_header(ctx) || (ctx->header_hash_validity == VALIDITY_INVALID)) { - /* Try to parse Header B. */ - f_lseek(ctx->file, 0x4000); - if (f_read(ctx->file, &ctx->header, sizeof(ctx->header), NULL)) { - EPRINTF("Failed to read save header!\n"); - return false; - } - - if (!save_process_header(ctx) || (ctx->header_hash_validity == VALIDITY_INVALID)) { - EPRINTF("Error: Save header is invalid!"); - return false; - } - } - - unsigned char cmac[0x10] = {}; - se_aes_key_set(10, ctx->save_mac_key, 0x10); - se_aes_cmac(10, cmac, 0x10, &ctx->header.layout, sizeof(ctx->header.layout)); - if (memcmp(cmac, &ctx->header.cmac, 0x10) == 0) { - ctx->header_cmac_validity = VALIDITY_VALID; - } else { - ctx->header_cmac_validity = VALIDITY_INVALID; - } - - /* Initialize remap storages. */ - ctx->data_remap_storage.type = STORAGE_BYTES; - ctx->data_remap_storage.base_storage_offset = ctx->header.layout.file_map_data_offset; - ctx->data_remap_storage.header = &ctx->header.main_remap_header; - ctx->data_remap_storage.map_entries = malloc(sizeof(remap_entry_ctx_t) * ctx->data_remap_storage.header->map_entry_count); - ctx->data_remap_storage.file = ctx->file; - f_lseek(ctx->file, ctx->header.layout.file_map_entry_offset); - for (unsigned int i = 0; i < ctx->data_remap_storage.header->map_entry_count; i++) { - f_read(ctx->file, &ctx->data_remap_storage.map_entries[i], 0x20, NULL); - ctx->data_remap_storage.map_entries[i].physical_offset_end = ctx->data_remap_storage.map_entries[i].physical_offset + ctx->data_remap_storage.map_entries[i].size; - ctx->data_remap_storage.map_entries[i].virtual_offset_end = ctx->data_remap_storage.map_entries[i].virtual_offset + ctx->data_remap_storage.map_entries[i].size; - } - - /* Initialize data remap storage. */ - ctx->data_remap_storage.segments = save_remap_init_segments(ctx->data_remap_storage.header, ctx->data_remap_storage.map_entries, ctx->data_remap_storage.header->map_entry_count); - - /* Initialize duplex storage. */ - ctx->duplex_layers[0].data_a = (uint8_t *)&ctx->header + ctx->header.layout.duplex_master_offset_a; - ctx->duplex_layers[0].data_b = (uint8_t *)&ctx->header + ctx->header.layout.duplex_master_offset_b; - memcpy(&ctx->duplex_layers[0].info, &ctx->header.duplex_header.layers[0], sizeof(duplex_info_t)); - - ctx->duplex_layers[1].data_a = malloc(ctx->header.layout.duplex_l1_size); - save_remap_read(&ctx->data_remap_storage, ctx->duplex_layers[1].data_a, ctx->header.layout.duplex_l1_offset_a, ctx->header.layout.duplex_l1_size); - ctx->duplex_layers[1].data_b = malloc(ctx->header.layout.duplex_l1_size); - save_remap_read(&ctx->data_remap_storage, ctx->duplex_layers[1].data_b, ctx->header.layout.duplex_l1_offset_b, ctx->header.layout.duplex_l1_size); - memcpy(&ctx->duplex_layers[1].info, &ctx->header.duplex_header.layers[1], sizeof(duplex_info_t)); - - ctx->duplex_layers[2].data_a = malloc(ctx->header.layout.duplex_data_size); - save_remap_read(&ctx->data_remap_storage, ctx->duplex_layers[2].data_a, ctx->header.layout.duplex_data_offset_a, ctx->header.layout.duplex_data_size); - ctx->duplex_layers[2].data_b = malloc(ctx->header.layout.duplex_data_size); - save_remap_read(&ctx->data_remap_storage, ctx->duplex_layers[2].data_b, ctx->header.layout.duplex_data_offset_b, ctx->header.layout.duplex_data_size); - memcpy(&ctx->duplex_layers[2].info, &ctx->header.duplex_header.layers[2], sizeof(duplex_info_t)); - - /* Initialize hierarchical duplex storage. */ - uint8_t *bitmap = ctx->header.layout.duplex_index == 1 ? ctx->duplex_layers[0].data_b : ctx->duplex_layers[0].data_a; - save_duplex_storage_init(&ctx->duplex_storage.layers[0], &ctx->duplex_layers[1], bitmap, ctx->header.layout.duplex_master_size); - ctx->duplex_storage.layers[0]._length = ctx->header.layout.duplex_l1_size; - - bitmap = malloc(ctx->duplex_storage.layers[0]._length); - save_duplex_storage_read(&ctx->duplex_storage.layers[0], bitmap, 0, ctx->duplex_storage.layers[0]._length); - save_duplex_storage_init(&ctx->duplex_storage.layers[1], &ctx->duplex_layers[2], bitmap, ctx->duplex_storage.layers[0]._length); - ctx->duplex_storage.layers[1]._length = ctx->header.layout.duplex_data_size; - - ctx->duplex_storage.data_layer = ctx->duplex_storage.layers[1]; - - /* Initialize meta remap storage. */ - ctx->meta_remap_storage.type = STORAGE_DUPLEX; - ctx->meta_remap_storage.duplex = &ctx->duplex_storage.data_layer; - ctx->meta_remap_storage.header = &ctx->header.meta_remap_header; - ctx->meta_remap_storage.map_entries = malloc(sizeof(remap_entry_ctx_t) * ctx->meta_remap_storage.header->map_entry_count); - ctx->meta_remap_storage.file = ctx->file; - f_lseek(ctx->file, ctx->header.layout.meta_map_entry_offset); - for (unsigned int i = 0; i < ctx->meta_remap_storage.header->map_entry_count; i++) { - f_read(ctx->file, &ctx->meta_remap_storage.map_entries[i], 0x20, NULL); - ctx->meta_remap_storage.map_entries[i].physical_offset_end = ctx->meta_remap_storage.map_entries[i].physical_offset + ctx->meta_remap_storage.map_entries[i].size; - ctx->meta_remap_storage.map_entries[i].virtual_offset_end = ctx->meta_remap_storage.map_entries[i].virtual_offset + ctx->meta_remap_storage.map_entries[i].size; - } - - ctx->meta_remap_storage.segments = save_remap_init_segments(ctx->meta_remap_storage.header, ctx->meta_remap_storage.map_entries, ctx->meta_remap_storage.header->map_entry_count); - - /* Initialize journal map. */ - ctx->journal_map_info.map_storage = malloc(ctx->header.layout.journal_map_table_size); - save_remap_read(&ctx->meta_remap_storage, ctx->journal_map_info.map_storage, ctx->header.layout.journal_map_table_offset, ctx->header.layout.journal_map_table_size); - - /* Initialize journal storage. */ - ctx->journal_storage.header = &ctx->header.journal_header; - ctx->journal_storage.journal_data_offset = ctx->header.layout.journal_data_offset; - ctx->journal_storage._length = ctx->journal_storage.header->total_size - ctx->journal_storage.header->journal_size; - ctx->journal_storage.file = ctx->file; - ctx->journal_storage.map.header = &ctx->header.map_header; - ctx->journal_storage.map.map_storage = ctx->journal_map_info.map_storage; - ctx->journal_storage.map.entries = malloc(sizeof(journal_map_entry_t) * ctx->journal_storage.map.header->main_data_block_count); - uint32_t *pos = (uint32_t *)ctx->journal_storage.map.map_storage; - for (unsigned int i = 0; i < ctx->journal_storage.map.header->main_data_block_count; i++) { - ctx->journal_storage.map.entries[i].virtual_index = i; - ctx->journal_storage.map.entries[i].physical_index = *pos & 0x7FFFFFFF; - pos += 2; - } - ctx->journal_storage.block_size = ctx->journal_storage.header->block_size; - ctx->journal_storage._length = ctx->journal_storage.header->total_size - ctx->journal_storage.header->journal_size; - - /* Initialize core IVFC storage. */ - for (unsigned int i = 0; i < 5; i++) { - ctx->core_data_ivfc_storage.levels[i].save_ctx = ctx; - } - save_ivfc_storage_init(&ctx->core_data_ivfc_storage, ctx->header.layout.ivfc_master_hash_offset_a, &ctx->header.data_ivfc_header); - - /* Initialize FAT storage. */ - if (ctx->header.layout.version < 0x50000) { - ctx->fat_storage = malloc(ctx->header.layout.fat_size); - save_remap_read(&ctx->meta_remap_storage, ctx->fat_storage, ctx->header.layout.fat_offset, ctx->header.layout.fat_size); - } else { - for (unsigned int i = 0; i < 5; i++) { - ctx->fat_ivfc_storage.levels[i].save_ctx = ctx; - } - save_ivfc_storage_init(&ctx->fat_ivfc_storage, ctx->header.layout.fat_ivfc_master_hash_a, &ctx->header.fat_ivfc_header); - ctx->fat_storage = malloc(ctx->fat_ivfc_storage._length); - save_remap_read(&ctx->meta_remap_storage, ctx->fat_storage, ctx->header.fat_ivfc_header.level_headers[ctx->header.fat_ivfc_header.num_levels - 2].logical_offset, ctx->fat_ivfc_storage._length); - } - - if (ctx->tool_ctx.action & ACTION_VERIFY) { - save_filesystem_verify(ctx); - } - - /* Initialize core save filesystem. */ - ctx->save_filesystem_core.base_storage = &ctx->core_data_ivfc_storage; - save_filesystem_init(&ctx->save_filesystem_core, ctx->fat_storage, &ctx->header.save_header, &ctx->header.fat_header); - - return true; -} - -bool save_process_header(save_ctx_t *ctx) { - if (ctx->header.layout.magic != MAGIC_DISF || ctx->header.duplex_header.magic != MAGIC_DPFS || - ctx->header.data_ivfc_header.magic != MAGIC_IVFC || ctx->header.journal_header.magic != MAGIC_JNGL || - ctx->header.save_header.magic != MAGIC_SAVE || ctx->header.main_remap_header.magic != MAGIC_RMAP || - ctx->header.meta_remap_header.magic != MAGIC_RMAP) - { - EPRINTF("Error: Save header is corrupt!"); - return false; - } - - ctx->data_ivfc_master = (uint8_t *)&ctx->header + ctx->header.layout.ivfc_master_hash_offset_a; - ctx->fat_ivfc_master = (uint8_t *)&ctx->header + ctx->header.layout.fat_ivfc_master_hash_a; - - uint8_t hash[0x20]; - se_calc_sha256(hash, &ctx->header.duplex_header, 0x3D00); - ctx->header_hash_validity = memcmp(hash, ctx->header.layout.hash, 0x20) == 0 ? VALIDITY_VALID : VALIDITY_INVALID; - - ctx->header.data_ivfc_header.num_levels = 5; - - if (ctx->header.layout.version >= 0x50000) { - ctx->header.fat_ivfc_header.num_levels = 4; - } - return true; -} - -void save_free_contexts(save_ctx_t *ctx) { - for (unsigned int i = 0; i < ctx->data_remap_storage.header->map_segment_count; i++) { - free(ctx->data_remap_storage.segments[i].entries); - } - free(ctx->data_remap_storage.segments); - for (unsigned int i = 0; i < ctx->meta_remap_storage.header->map_segment_count; i++) { - free(ctx->meta_remap_storage.segments[i].entries); - } - free(ctx->meta_remap_storage.segments); - free(ctx->data_remap_storage.map_entries); - free(ctx->meta_remap_storage.map_entries); - free(ctx->duplex_storage.layers[0].bitmap.bitmap); - free(ctx->duplex_storage.layers[1].bitmap.bitmap); - free(ctx->duplex_storage.layers[1].bitmap_storage); - for (unsigned int i = 1; i < 3; i++) { - free(ctx->duplex_layers[i].data_a); - free(ctx->duplex_layers[i].data_b); - } - free(ctx->journal_map_info.map_storage); - free(ctx->journal_storage.map.entries); - for (unsigned int i = 0; i < ctx->header.data_ivfc_header.num_levels - 1; i++) { - free(ctx->core_data_ivfc_storage.integrity_storages[i].block_validities); - } - free(ctx->core_data_ivfc_storage.level_validities); - if (ctx->header.layout.version >= 0x50000) { - for (unsigned int i = 0; i < ctx->header.fat_ivfc_header.num_levels - 1; i++) { - free(ctx->fat_ivfc_storage.integrity_storages[i].block_validities); - } - } - free(ctx->fat_ivfc_storage.level_validities); - free(ctx->fat_storage); -} diff --git a/source/keys/save.h b/source/keys/save.h deleted file mode 100644 index 2e11f4a..0000000 --- a/source/keys/save.h +++ /dev/null @@ -1,526 +0,0 @@ -#ifndef _SAVE_H -#define _SAVE_H - -#include -#include - -#include - -#define SAVE_HEADER_SIZE 0x4000 -#define SAVE_FAT_ENTRY_SIZE 8 -#define SAVE_FS_LIST_MAX_NAME_LENGTH 0x40 -#define SAVE_FS_LIST_ENTRY_SIZE 0x60 - -#define IVFC_MAX_LEVEL 6 - -#define MAGIC_DISF 0x46534944 -#define MAGIC_DPFS 0x53465044 -#define MAGIC_JNGL 0x4C474E4A -#define MAGIC_SAVE 0x45564153 -#define MAGIC_RMAP 0x50414D52 -#define MAGIC_IVFC 0x43465649 - -typedef enum { - VALIDITY_UNCHECKED = 0, - VALIDITY_INVALID, - VALIDITY_VALID -} validity_t; - -typedef struct save_ctx_t save_ctx_t; - -typedef struct { - uint32_t magic; /* DISF */ - uint32_t version; - uint8_t hash[0x20]; - uint64_t file_map_entry_offset; - uint64_t file_map_entry_size; - uint64_t meta_map_entry_offset; - uint64_t meta_map_entry_size; - uint64_t file_map_data_offset; - uint64_t file_map_data_size; - uint64_t duplex_l1_offset_a; - uint64_t duplex_l1_offset_b; - uint64_t duplex_l1_size; - uint64_t duplex_data_offset_a; - uint64_t duplex_data_offset_b; - uint64_t duplex_data_size; - uint64_t journal_data_offset; - uint64_t journal_data_size_a; - uint64_t journal_data_size_b; - uint64_t journal_size; - uint64_t duplex_master_offset_a; - uint64_t duplex_master_offset_b; - uint64_t duplex_master_size; - uint64_t ivfc_master_hash_offset_a; - uint64_t ivfc_master_hash_offset_b; - uint64_t ivfc_master_hash_size; - uint64_t journal_map_table_offset; - uint64_t journal_map_table_size; - uint64_t journal_physical_bitmap_offset; - uint64_t journal_physical_bitmap_size; - uint64_t journal_virtual_bitmap_offset; - uint64_t journal_virtual_bitmap_size; - uint64_t journal_free_bitmap_offset; - uint64_t journal_free_bitmap_size; - uint64_t ivfc_l1_offset; - uint64_t ivfc_l1_size; - uint64_t ivfc_l2_offset; - uint64_t ivfc_l2_size; - uint64_t ivfc_l3_offset; - uint64_t ivfc_l3_size; - uint64_t fat_offset; - uint64_t fat_size; - uint64_t duplex_index; - uint64_t fat_ivfc_master_hash_a; - uint64_t fat_ivfc_master_hash_b; - uint64_t fat_ivfc_l1_offset; - uint64_t fat_ivfc_l1_size; - uint64_t fat_ivfc_l2_offset; - uint64_t fat_ivfc_l2_size; - uint8_t _0x190[0x70]; -} fs_layout_t; - -#pragma pack(push, 1) -typedef struct { - uint64_t offset; - uint64_t length; - uint32_t block_size_power; -} duplex_info_t; -#pragma pack(pop) - -typedef struct { - uint32_t magic; /* DPFS */ - uint32_t version; - duplex_info_t layers[3]; -} duplex_header_t; - -typedef struct { - uint32_t version; - uint32_t main_data_block_count; - uint32_t journal_block_count; - uint32_t _0x0C; -} journal_map_header_t; - -typedef struct { - uint32_t magic; /* JNGL */ - uint32_t version; - uint64_t total_size; - uint64_t journal_size; - uint64_t block_size; -} journal_header_t; - -typedef struct { - uint32_t magic; /* SAVE */ - uint32_t version; - uint64_t block_count; - uint64_t block_size; -} save_fs_header_t; - -typedef struct { - uint64_t block_size; - uint64_t allocation_table_offset; - uint32_t allocation_table_block_count; - uint32_t _0x14; - uint64_t data_offset; - uint32_t data_block_count; - uint32_t _0x24; - uint32_t directory_table_block; - uint32_t file_table_block; -} fat_header_t; - -typedef struct { - uint32_t magic; /* RMAP */ - uint32_t version; - uint32_t map_entry_count; - uint32_t map_segment_count; - uint32_t segment_bits; - uint8_t _0x14[0x2C]; -} remap_header_t; - -typedef struct remap_segment_ctx_t remap_segment_ctx_t; -typedef struct remap_entry_ctx_t remap_entry_ctx_t; - -#pragma pack(push, 1) -struct remap_entry_ctx_t { - uint64_t virtual_offset; - uint64_t physical_offset; - uint64_t size; - uint32_t alignment; - uint32_t _0x1C; - uint64_t virtual_offset_end; - uint64_t physical_offset_end; - remap_segment_ctx_t *segment; - remap_entry_ctx_t *next; -}; -#pragma pack(pop) - -struct remap_segment_ctx_t{ - uint64_t offset; - uint64_t length; - remap_entry_ctx_t **entries; - uint64_t entry_count; -}; - -typedef struct { - uint8_t *data; - uint8_t *bitmap; -} duplex_bitmap_t; - -typedef struct { - uint32_t block_size; - uint8_t *bitmap_storage; - uint8_t *data_a; - uint8_t *data_b; - duplex_bitmap_t bitmap; - uint64_t _length; -} duplex_storage_ctx_t; - -enum base_storage_type { - STORAGE_BYTES = 0, - STORAGE_DUPLEX = 1, - STORAGE_REMAP = 2, - STORAGE_JOURNAL = 3 -}; - -typedef struct { - remap_header_t *header; - remap_entry_ctx_t *map_entries; - remap_segment_ctx_t *segments; - enum base_storage_type type; - uint64_t base_storage_offset; - duplex_storage_ctx_t *duplex; - FIL *file; -} remap_storage_ctx_t; - -typedef struct { - uint64_t program_id; - uint8_t user_id[0x10]; - uint64_t save_id; - uint8_t save_data_type; - uint8_t _0x21[0x1F]; - uint64_t save_owner_id; - uint64_t timestamp; - uint64_t _0x50; - uint64_t data_size; - uint64_t journal_size; - uint64_t commit_id; -} extra_data_t; - -typedef struct { - uint64_t logical_offset; - uint64_t hash_data_size; - uint32_t block_size; - uint32_t reserved; -} ivfc_level_hdr_t; - -typedef struct { - uint32_t magic; - uint32_t id; - uint32_t master_hash_size; - uint32_t num_levels; - ivfc_level_hdr_t level_headers[IVFC_MAX_LEVEL]; - uint8_t salt_source[0x20]; -} ivfc_save_hdr_t; - -#pragma pack(push, 1) -typedef struct { - uint8_t cmac[0x10]; - uint8_t _0x10[0xF0]; - fs_layout_t layout; - duplex_header_t duplex_header; - ivfc_save_hdr_t data_ivfc_header; - uint32_t _0x404; - journal_header_t journal_header; - journal_map_header_t map_header; - uint8_t _0x438[0x1D0]; - save_fs_header_t save_header; - fat_header_t fat_header; - remap_header_t main_remap_header, meta_remap_header; - uint64_t _0x6D0; - extra_data_t extra_data; - uint8_t _0x748[0x390]; - ivfc_save_hdr_t fat_ivfc_header; - uint8_t _0xB98[0x3468]; -} save_header_t; -#pragma pack(pop) - -typedef struct { - duplex_storage_ctx_t layers[2]; - duplex_storage_ctx_t data_layer; - uint64_t _length; -} hierarchical_duplex_storage_ctx_t; - -typedef struct { - uint8_t *data_a; - uint8_t *data_b; - duplex_info_t info; -} duplex_fs_layer_info_t; - -typedef struct { - uint8_t *map_storage; - uint8_t *physical_block_bitmap; - uint8_t *virtual_block_bitmap; - uint8_t *free_block_bitmap; -} journal_map_params_t; - -typedef struct { - uint32_t physical_index; - uint32_t virtual_index; -} journal_map_entry_t; - - -typedef struct { - journal_map_header_t *header; - journal_map_entry_t *entries; - uint8_t *map_storage; -} journal_map_ctx_t; - -typedef struct { - journal_map_ctx_t map; - journal_header_t *header; - uint32_t block_size; - uint64_t journal_data_offset; - uint64_t _length; - FIL *file; -} journal_storage_ctx_t; - -typedef struct { - uint64_t data_offset; - uint64_t data_size; - uint64_t hash_offset; - uint32_t hash_block_size; - validity_t hash_validity; - enum base_storage_type type; - save_ctx_t *save_ctx; -} ivfc_level_save_ctx_t; - -typedef struct { - ivfc_level_save_ctx_t *data; - uint32_t block_size; - uint8_t salt[0x20]; -} integrity_verification_info_ctx_t; - - -typedef struct integrity_verification_storage_ctx_t integrity_verification_storage_ctx_t; - -struct integrity_verification_storage_ctx_t { - ivfc_level_save_ctx_t *hash_storage; - ivfc_level_save_ctx_t *base_storage; - validity_t *block_validities; - uint8_t salt[0x20]; - uint32_t sector_size; - uint32_t sector_count; - uint64_t _length; - integrity_verification_storage_ctx_t *next_level; -}; - -typedef struct { - ivfc_level_save_ctx_t levels[5]; - ivfc_level_save_ctx_t *data_level; - validity_t **level_validities; - uint64_t _length; - integrity_verification_storage_ctx_t integrity_storages[4]; -} hierarchical_integrity_verification_storage_ctx_t; - -typedef struct { - uint32_t prev; - uint32_t next; -} allocation_table_entry_t; - -typedef struct { - uint32_t free_list_entry_index; - void *base_storage; - fat_header_t *header; -} allocation_table_ctx_t; - -typedef struct { - hierarchical_integrity_verification_storage_ctx_t *base_storage; - uint32_t block_size; - uint32_t initial_block; - allocation_table_ctx_t *fat; - uint64_t _length; -} allocation_table_storage_ctx_t; - -typedef struct { - allocation_table_ctx_t *fat; - uint32_t virtual_block; - uint32_t physical_block; - uint32_t current_segment_size; - uint32_t next_block; - uint32_t prev_block; -} allocation_table_iterator_ctx_t; - -typedef struct { - char name[SAVE_FS_LIST_MAX_NAME_LENGTH]; - uint32_t parent; -} save_entry_key_t; - -#pragma pack(push, 1) -typedef struct { - uint32_t start_block; - uint64_t length; - uint32_t _0xC[2]; -} save_file_info_t; -#pragma pack(pop) - -#pragma pack(push, 1) -typedef struct { - uint32_t next_directory; - uint32_t next_file; - uint32_t _0x8[3]; -} save_find_position_t; -#pragma pack(pop) - -#pragma pack(push, 1) -typedef struct { - uint32_t next_sibling; - union { /* Save table entry type. Size = 0x14. */ - save_file_info_t save_file_info; - save_find_position_t save_find_position; - }; -} save_table_entry_t; -#pragma pack(pop) - -#pragma pack(push, 1) -typedef struct { - uint32_t parent; - char name[SAVE_FS_LIST_MAX_NAME_LENGTH]; - save_table_entry_t value; - uint32_t next; -} save_fs_list_entry_t; -#pragma pack(pop) - -typedef struct { - uint32_t free_list_head_index; - uint32_t used_list_head_index; - allocation_table_storage_ctx_t storage; - uint32_t capacity; -} save_filesystem_list_ctx_t; - -typedef struct { - save_filesystem_list_ctx_t file_table; - save_filesystem_list_ctx_t directory_table; -} hierarchical_save_file_table_ctx_t; - -typedef struct { - hierarchical_integrity_verification_storage_ctx_t *base_storage; - allocation_table_ctx_t allocation_table; - save_fs_header_t *header; - hierarchical_save_file_table_ctx_t file_table; -} save_filesystem_ctx_t; - -#define ACTION_VERIFY (1<<2) - -struct save_ctx_t { - save_header_t header; - FIL *file; - struct { - FIL *file; - uint32_t action; - } tool_ctx; - validity_t header_cmac_validity; - validity_t header_hash_validity; - uint8_t *data_ivfc_master; - uint8_t *fat_ivfc_master; - remap_storage_ctx_t data_remap_storage; - remap_storage_ctx_t meta_remap_storage; - duplex_fs_layer_info_t duplex_layers[3]; - hierarchical_duplex_storage_ctx_t duplex_storage; - journal_storage_ctx_t journal_storage; - journal_map_params_t journal_map_info; - hierarchical_integrity_verification_storage_ctx_t core_data_ivfc_storage; - hierarchical_integrity_verification_storage_ctx_t fat_ivfc_storage; - uint8_t *fat_storage; - save_filesystem_ctx_t save_filesystem_core; - uint8_t save_mac_key[0x10]; -}; - -static inline uint32_t allocation_table_entry_index_to_block(uint32_t entry_index) { - return entry_index - 1; -} - -static inline uint32_t allocation_table_block_to_entry_index(uint32_t block_index) { - return block_index + 1; -} - -static inline int allocation_table_get_prev(allocation_table_entry_t *entry) { - return entry->prev & 0x7FFFFFFF; -} - -static inline int allocation_table_get_next(allocation_table_entry_t *entry) { - return entry->next & 0x7FFFFFFF; -} - -static inline int allocation_table_is_list_start(allocation_table_entry_t *entry) { - return entry->prev == 0x80000000; -} - -static inline int allocation_table_is_list_end(allocation_table_entry_t *entry) { - return (entry->next & 0x7FFFFFFF) == 0; -} - -static inline bool allocation_table_is_multi_block_segment(allocation_table_entry_t *entry) { - return entry->next & 0x80000000; -} - -static inline void allocation_table_make_multi_block_segment(allocation_table_entry_t *entry) { - entry->next |= 0x80000000; -} - -static inline void allocation_table_make_single_block_segment(allocation_table_entry_t *entry) { - entry->next &= 0x7FFFFFFF; -} - -static inline bool allocation_table_is_single_block_segment(allocation_table_entry_t *entry) { - return (entry->next & 0x80000000) == 0; -} - -static inline void allocation_table_make_list_start(allocation_table_entry_t *entry) { - entry->prev = 0x80000000; -} - -static inline bool allocation_table_is_range_entry(allocation_table_entry_t *entry) { - return (entry->prev & 0x80000000) != 0 && entry->prev != 0x80000000; -} - -static inline void allocation_table_make_range_entry(allocation_table_entry_t *entry) { - entry->prev |= 0x80000000; -} - -static inline void allocation_table_set_next(allocation_table_entry_t *entry, int val) { - entry->next = (entry->next & 0x80000000) | val; -} - -static inline void allocation_table_set_prev(allocation_table_entry_t *entry, int val) { - entry->prev = val; -} - -static inline void allocation_table_set_range(allocation_table_entry_t *entry, int start_index, int end_index) { - entry->next = end_index; - entry->prev = start_index; - allocation_table_make_range_entry(entry); -} - -static inline allocation_table_entry_t *save_allocation_table_read_entry(allocation_table_ctx_t *ctx, uint32_t entry_index) { - return (allocation_table_entry_t *)((uint8_t *)ctx->base_storage + entry_index * SAVE_FAT_ENTRY_SIZE); -} - -static inline uint32_t save_allocation_table_get_free_list_entry_index(allocation_table_ctx_t *ctx) { - return allocation_table_get_next(save_allocation_table_read_entry(ctx, ctx->free_list_entry_index)); -} - -static inline uint32_t save_allocation_table_get_free_list_block_index(allocation_table_ctx_t *ctx) { - return allocation_table_entry_index_to_block(save_allocation_table_get_free_list_entry_index(ctx)); -} - -bool save_process(save_ctx_t *ctx); -bool save_process_header(save_ctx_t *ctx); - -void save_free_contexts(save_ctx_t *ctx); - -void save_open_fat_storage(save_filesystem_ctx_t *ctx, allocation_table_storage_ctx_t *storage_ctx, uint32_t block_index); -uint32_t save_allocation_table_storage_read(allocation_table_storage_ctx_t *ctx, void *buffer, uint64_t offset, size_t count); -int save_fs_list_get_value(save_filesystem_list_ctx_t *ctx, uint32_t index, save_fs_list_entry_t *value); -int save_hierarchical_file_table_get_file_entry_by_path(hierarchical_save_file_table_ctx_t *ctx, const char *path, save_fs_list_entry_t *entry); - -#endif