wasm_secure_storage.h

Go to the documentation of this file.

#ifndef YAZE_APP_PLATFORM_WASM_SECURE_STORAGE_H_
#define YAZE_APP_PLATFORM_WASM_SECURE_STORAGE_H_
 
#ifdef __EMSCRIPTEN__
 
#include <string>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/status/statusor.h"
 
namespace yaze {
namespace app {
namespace platform {
 
class WasmSecureStorage {
 public:
  enum class StorageType {
    kSession,  // sessionStorage (cleared on tab close)
    kLocal     // localStorage (persistent)
  };
 
  static absl::Status StoreApiKey(const std::string& service,
                                   const std::string& key,
                                   StorageType storage_type = StorageType::kSession);
 
  static absl::StatusOr<std::string> RetrieveApiKey(
      const std::string& service,
      StorageType storage_type = StorageType::kSession);
 
  static absl::Status ClearApiKey(const std::string& service,
                                   StorageType storage_type = StorageType::kSession);
 
  static bool HasApiKey(const std::string& service,
                        StorageType storage_type = StorageType::kSession);
 
  static absl::Status StoreSecret(const std::string& key,
                                   const std::string& value,
                                   StorageType storage_type = StorageType::kSession);
 
  static absl::StatusOr<std::string> RetrieveSecret(
      const std::string& key,
      StorageType storage_type = StorageType::kSession);
 
  static absl::Status ClearSecret(const std::string& key,
                                   StorageType storage_type = StorageType::kSession);
 
  static std::vector<std::string> ListStoredApiKeys(
      StorageType storage_type = StorageType::kSession);
 
  static absl::Status ClearAllApiKeys(StorageType storage_type = StorageType::kSession);
 
  static bool IsStorageAvailable();
 
  struct StorageQuota {
    size_t used_bytes = 0;
    size_t available_bytes = 0;
  };
  static absl::StatusOr<StorageQuota> GetStorageQuota(
      StorageType storage_type = StorageType::kSession);
 
 private:
  // Key prefixes for different types of data
  static constexpr const char* kApiKeyPrefix = "yaze_secure_api_";
  static constexpr const char* kSecretPrefix = "yaze_secure_secret_";
 
  static std::string BuildApiKeyStorageKey(const std::string& service);
 
  static std::string BuildSecretStorageKey(const std::string& key);
 
  static std::string ExtractServiceFromKey(const std::string& storage_key);
};
 
}  // namespace platform
}  // namespace app
}  // namespace yaze
 
#else  // !__EMSCRIPTEN__
 
// Stub for non-WASM builds
#include <string>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/status/statusor.h"
 
namespace yaze {
namespace app {
namespace platform {
 
class WasmSecureStorage {
 public:
  enum class StorageType { kSession, kLocal };
 
  static absl::Status StoreApiKey(const std::string&, const std::string&,
                                  StorageType = StorageType::kSession) {
    return absl::UnimplementedError("Secure storage requires WASM build");
  }
 
  static absl::StatusOr<std::string> RetrieveApiKey(
      const std::string&, StorageType = StorageType::kSession) {
    return absl::NotFoundError("Secure storage requires WASM build");
  }
 
  static absl::Status ClearApiKey(const std::string&,
                                  StorageType = StorageType::kSession) {
    return absl::UnimplementedError("Secure storage requires WASM build");
  }
 
  static bool HasApiKey(const std::string&,
                        StorageType = StorageType::kSession) {
    return false;
  }
 
  static absl::Status StoreSecret(const std::string&, const std::string&,
                                  StorageType = StorageType::kSession) {
    return absl::UnimplementedError("Secure storage requires WASM build");
  }
 
  static absl::StatusOr<std::string> RetrieveSecret(
      const std::string&, StorageType = StorageType::kSession) {
    return absl::NotFoundError("Secure storage requires WASM build");
  }
 
  static absl::Status ClearSecret(const std::string&,
                                  StorageType = StorageType::kSession) {
    return absl::UnimplementedError("Secure storage requires WASM build");
  }
 
  static std::vector<std::string> ListStoredApiKeys(
      StorageType = StorageType::kSession) {
    return {};
  }
 
  static absl::Status ClearAllApiKeys(StorageType = StorageType::kSession) {
    return absl::UnimplementedError("Secure storage requires WASM build");
  }
 
  static bool IsStorageAvailable() { return false; }
 
  struct StorageQuota {
    size_t used_bytes = 0;
    size_t available_bytes = 0;
  };
 
  static absl::StatusOr<StorageQuota> GetStorageQuota(
      StorageType = StorageType::kSession) {
    return absl::UnimplementedError("Secure storage requires WASM build");
  }
};
 
}  // namespace platform
}  // namespace app
}  // namespace yaze
 
#endif  // __EMSCRIPTEN__
 
#endif  // YAZE_APP_PLATFORM_WASM_SECURE_STORAGE_H_