Fix various potential crashes in the indexer resolver (#774)

Signed-off-by: Juan Cruz Viotti <jv@jviotti.com>

Author: jviotti

src/index/index.cc

@@ -531,11 +531,18 @@ auto main(int argc, char *argv[]) noexcept -> int {
   } catch (const sourcemeta::core::SchemaUnknownBaseDialectError &error) {
     std::cerr << "error: " << error.what() << "\n";
     return EXIT_FAILURE;
+  } catch (const sourcemeta::core::SchemaUnknownDialectError &error) {
+    std::cerr << "error: " << error.what() << "\n";
+    return EXIT_FAILURE;
   } catch (const sourcemeta::one::BuildTooManyDirectoryEntriesError &error) {
     std::cerr << "error: " << error.what() << "\n  at path "
               << error.path().string() << "\n  with count " << error.count()
               << "\n";
     return EXIT_FAILURE;
+  } catch (const sourcemeta::one::ResolverNotASchemaError &error) {
+    std::cerr << "error: " << error.what() << "\n  at " << error.path().string()
+              << "\n";
+    return EXIT_FAILURE;
   } catch (const sourcemeta::one::ResolverOutsideBaseError &error) {
     std::cerr << "error: " << error.what() << "\n  at " << error.uri()
               << "\n  with base " << error.base() << "\n";

src/resolver/include/sourcemeta/one/resolver_error.h

@@ -3,11 +3,29 @@
 
 #include <sourcemeta/core/json.h>
 
-#include <exception> // std::exception
-#include <utility>   // std::move
+#include <exception>  // std::exception
+#include <filesystem> // std::filesystem::path
+#include <utility>    // std::move
 
 namespace sourcemeta::one {
 
+class ResolverNotASchemaError : public std::exception {
+public:
+  ResolverNotASchemaError(std::filesystem::path path)
+      : path_{std::move(path)} {}
+
+  [[nodiscard]] auto what() const noexcept -> const char * override {
+    return "The file does not contain a valid JSON Schema";
+  }
+
+  [[nodiscard]] auto path() const noexcept -> const std::filesystem::path & {
+    return this->path_;
+  }
+
+private:
+  std::filesystem::path path_;
+};
+
 class ResolverOutsideBaseError : public std::exception {
 public:
   ResolverOutsideBaseError(sourcemeta::core::JSON::String uri,

src/resolver/resolver.cc

@@ -188,10 +188,7 @@ auto Resolver::operator()(
       auto &subschema{sourcemeta::core::get(schema, entry.second.pointer)};
       if (subschema.is_object()) {
         const auto maybe_ref{subschema.try_at("$ref", ref_hash)};
-        if (maybe_ref) {
-          // This is safe, as at this point we have validated all schemas
-          // against their meta-schemas
-          assert(maybe_ref->is_string());
+        if (maybe_ref && maybe_ref->is_string()) {
           normalise_ref(*result->second.collection, entry.second.base,
                         subschema, "$ref", maybe_ref->to_string());
         }
@@ -200,10 +197,7 @@ auto Resolver::operator()(
             sourcemeta::core::SchemaBaseDialect::JSON_Schema_2020_12) {
           const auto maybe_dynamic_ref{
               subschema.try_at("$dynamicRef", dynamic_ref_hash)};
-          if (maybe_dynamic_ref) {
-            // This is safe, as at this point we have validated all schemas
-            // against their meta-schemas
-            assert(maybe_dynamic_ref->is_string());
+          if (maybe_dynamic_ref && maybe_dynamic_ref->is_string()) {
             normalise_ref(*result->second.collection, entry.second.base,
                           subschema, "$dynamicRef",
                           maybe_dynamic_ref->to_string());
@@ -237,7 +231,9 @@ auto Resolver::add(const sourcemeta::core::JSON::String &server_url,
   /////////////////////////////////////////////////////////////////////////////
   assert(path.is_absolute());
   const auto schema{sourcemeta::core::read_yaml_or_json(path)};
-  assert(sourcemeta::core::is_schema(schema));
+  if (!sourcemeta::core::is_schema(schema)) {
+    throw ResolverNotASchemaError(path);
+  }
 
   const std::string default_dialect_str{
       collection.default_dialect.value_or("")};
@@ -296,8 +292,9 @@ auto Resolver::add(const sourcemeta::core::JSON::String &server_url,
   /////////////////////////////////////////////////////////////////////////////
   const auto raw_dialect{
       sourcemeta::core::dialect(schema, default_dialect_str)};
-  // If we couldn't determine the dialect, we would be in trouble!
-  assert(!raw_dialect.empty());
+  if (raw_dialect.empty()) {
+    throw sourcemeta::core::SchemaUnknownDialectError();
+  }
   const auto is_official_dialect{
       sourcemeta::core::is_known_schema(raw_dialect)};
   auto current_dialect{is_official_dialect

test/unit/resolver/resolver_test.cc

@@ -553,6 +553,30 @@ TEST_F(ResolverTest, entry_lookup) {
             "https://example.com/schemas/2020-12-with-id");
 }
 
+TEST_F(ResolverTest, non_schema_file) {
+  RESOLVER_INIT(resolver);
+  try {
+    RESOLVER_IMPORT(resolver, "example", "non-schema-array.json");
+    FAIL();
+  } catch (const sourcemeta::one::ResolverNotASchemaError &error) {
+    EXPECT_EQ(error.path().filename(), "non-schema-array.json");
+  }
+}
+
+TEST_F(ResolverTest, no_dialect) {
+  RESOLVER_INIT(resolver);
+  EXPECT_THROW(RESOLVER_IMPORT(resolver, "no-base", "no-dialect.json"),
+               sourcemeta::core::SchemaUnknownDialectError);
+}
+
+TEST_F(ResolverTest, non_string_ref_no_crash) {
+  RESOLVER_INIT(resolver);
+  const auto result{
+      RESOLVER_IMPORT(resolver, "example", "non-string-ref.json")};
+  EXPECT_THROW(resolver(result.first.get()),
+               sourcemeta::core::SchemaReferenceObjectResourceError);
+}
+
 TEST_F(ResolverTest, no_base_anonymous) {
   RESOLVER_INIT(resolver);
   RESOLVER_ADD(resolver, "no-base", "anonymous.json",

test/unit/resolver/schemas/example/non-schema-array.json

@@ -0,0 +1 @@
+[1, 2, 3]

test/unit/resolver/schemas/example/non-string-ref.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://example.com/schemas/non-string-ref",
+  "$ref": 42
+}

test/unit/resolver/schemas/no-base/no-dialect.json

@@ -0,0 +1,4 @@
+{
+  "$id": "https://example.com/no-dialect",
+  "type": "string"
+}