command_storage_backend.cc | Explore in Territory

// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/40285824): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif

#include "components/sessions/core/command_storage_backend.h"

#include <stdint.h>

#include <algorithm>
#include <limits>
#include <string_view>
#include <utility>

#include "base/feature_list.h"
#include "base/features.h"
#include "base/files/file.h"
#include "base/files/file_enumerator.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/logging.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_split.h"
#include "base/strings/string_util.h"
#include "base/task/sequenced_task_runner.h"
#include "base/task/single_thread_task_runner.h"
#include "base/time/default_clock.h"
#include "build/build_config.h"
#include "components/sessions/core/session_constants.h"
#include "components/sessions/core/session_service_commands.h"
#include "crypto/aead.h"

namespace sessions {

SessionType;

namespace {

// File version number.
// TODO(sky): remove these in ~1 year. They are no longer written as of
// ~5/2021.
constexpr int32_t kFileVersion1 = …;
constexpr int32_t kEncryptedFileVersion = …;
// The versions that are used if `use_marker` is true.
constexpr int32_t kFileVersionWithMarker = …;
constexpr int32_t kEncryptedFileVersionWithMarker = …;

// The signature at the beginning of the file = SSNS (Sessions).
constexpr int32_t kFileSignature = …;

// Length (in bytes) of the nonce (used when encrypting).
constexpr int kNonceLength = …;

// Kill switch for the change to stop calling `File::Flush()` when appending
// commands to a file. This can be removed if the change rolls out without
// causing issues.
BASE_FEATURE(…);

// The file header is the first bytes written to the file,
// and is used to identify the file as one written by us.
struct FileHeader { … };

// See CommandStorageBackend for details.
const SessionCommand::id_type kInitialStateMarkerCommandId = …;

// SessionFileReader ----------------------------------------------------------

// SessionFileReader is responsible for reading the set of SessionCommands that
// describe a Session back from a file. SessionFileRead does minimal error
// checking on the file (pretty much only that the header is valid).

class SessionFileReader { … };

CommandStorageBackend::ReadCommandsResult SessionFileReader::Read() { … }

bool SessionFileReader::ReadHeader() { … }

bool SessionFileReader::ReadToMarker() { … }

SessionFileReader::ReadResult SessionFileReader::ReadCommand() { … }

std::unique_ptr<sessions::SessionCommand>
SessionFileReader::CreateCommandFromEncrypted(const char* data,
                                              size_type length) { … }

std::unique_ptr<sessions::SessionCommand> SessionFileReader::CreateCommand(
    const char* data,
    size_type length) { … }

bool SessionFileReader::FillBuffer() { … }

base::FilePath::StringType TimestampToString(const base::Time time) { … }

// Returns the directory the files are stored in.
base::FilePath GetSessionDirName(CommandStorageManager::SessionType type,
                                 const base::FilePath& supplied_path) { … }

base::FilePath::StringType GetSessionBaseName(
    CommandStorageManager::SessionType type,
    const base::FilePath& supplied_path) { … }

base::FilePath::StringType GetSessionFilename(
    CommandStorageManager::SessionType type,
    const base::FilePath& supplied_path,
    const base::FilePath::StringType& timestamp_str) { … }

base::FilePath GetLegacySessionPath(CommandStorageManager::SessionType type,
                                    const base::FilePath& base_path,
                                    bool current) { … }

}  // namespace

CommandStorageBackend::ReadCommandsResult::ReadCommandsResult() = default;
CommandStorageBackend::ReadCommandsResult::ReadCommandsResult(
    CommandStorageBackend::ReadCommandsResult&& other) = default;
CommandStorageBackend::ReadCommandsResult&
CommandStorageBackend::ReadCommandsResult::operator=(
    CommandStorageBackend::ReadCommandsResult&& other) = default;
CommandStorageBackend::ReadCommandsResult::~ReadCommandsResult() = default;

// CommandStorageBackend
// -------------------------------------------------------------

CommandStorageBackend::OpenFile::OpenFile() = default;
CommandStorageBackend::OpenFile::~OpenFile() = default;

// static
const int CommandStorageBackend::kFileReadBufferSize = …;

// static
const SessionCommand::size_type
    CommandStorageBackend::kEncryptionOverheadInBytes = …;

CommandStorageBackend::CommandStorageBackend(
    scoped_refptr<base::SequencedTaskRunner> owning_task_runner,
    const base::FilePath& path,
    SessionType type,
    const std::vector<uint8_t>& decryption_key,
    base::Clock* clock)
    : … { … }

// static
bool CommandStorageBackend::IsValidFile(const base::FilePath& path) { … }

void CommandStorageBackend::AppendCommands(
    std::vector<std::unique_ptr<SessionCommand>> commands,
    bool truncate,
    base::OnceClosure error_callback,
    const std::vector<uint8_t>& crypto_key) { … }

// static
bool CommandStorageBackend::TimestampFromPath(const base::FilePath& path,
                                              base::Time& timestamp_result) { … }

// static
std::set<base::FilePath> CommandStorageBackend::GetSessionFilePaths(
    const base::FilePath& path,
    CommandStorageManager::SessionType type) { … }

CommandStorageBackend::ReadCommandsResult
CommandStorageBackend::ReadLastSessionCommands() { … }

void CommandStorageBackend::DeleteLastSession() { … }

void CommandStorageBackend::MoveCurrentSessionToLastSession() { … }

// static
void CommandStorageBackend::ForceAppendCommandsToFailForTesting() { … }

bool CommandStorageBackend::AppendCommandsToFile(
    base::File* file,
    const std::vector<std::unique_ptr<sessions::SessionCommand>>& commands) { … }

CommandStorageBackend::~CommandStorageBackend() = default;

void CommandStorageBackend::InitIfNecessary() { … }

// static
base::FilePath CommandStorageBackend::FilePathFromTime(
    const SessionType type,
    const base::FilePath& path,
    base::Time time) { … }

// static
CommandStorageBackend::ReadCommandsResult
CommandStorageBackend::ReadCommandsFromFile(
    const base::FilePath& path,
    const std::vector<uint8_t>& crypto_key) { … }

void CommandStorageBackend::CloseFile() { … }

void CommandStorageBackend::TruncateOrOpenFile() { … }

std::unique_ptr<base::File> CommandStorageBackend::OpenAndWriteHeader(
    const base::FilePath& path) const { … }

bool CommandStorageBackend::AppendCommandToFile(
    base::File* file,
    const sessions::SessionCommand& command) { … }

bool CommandStorageBackend::AppendEncryptedCommandToFile(
    base::File* file,
    const sessions::SessionCommand& command) { … }

std::optional<CommandStorageBackend::SessionInfo>
CommandStorageBackend::FindLastSessionFile() const { … }

void CommandStorageBackend::DeleteLastSessionFiles() const { … }

// static
std::vector<CommandStorageBackend::SessionInfo>
CommandStorageBackend::GetSessionFilesSortedByReverseTimestamp(
    const base::FilePath& path,
    CommandStorageManager::SessionType type) { … }

bool CommandStorageBackend::CanUseFileForLastSession(
    const base::FilePath& path) const { … }

}  // namespace sessions
chromium/components/sessions/core/command_storage_backend.cc
