Enable meta-based validation for shared libraries.

src/trusted/validator/validation_cache_test.cc

 /*
  * Copyright (c) 2012 The Native Client Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gtest/gtest.h"
 
 #include <fcntl.h>
 
 #include "native_client/src/include/nacl_compiler_annotations.h"
 #include "native_client/src/shared/platform/nacl_host_desc.h"
 #include "native_client/src/shared/platform/nacl_log.h"
 #include "native_client/src/shared/utils/types.h"
 #include "native_client/src/trusted/desc/nacl_desc_io.h"
 #include "native_client/src/trusted/validator/ncvalidate.h"
 #include "native_client/src/trusted/validator/validation_cache.h"
 #include "native_client/src/trusted/cpu_features/arch/x86/cpu_x86.h"
 #include "native_client/src/trusted/service_runtime/include/sys/fcntl.h"
+#include "native_client/src/trusted/validator/rich_file_info.h"
 #include "native_client/src/trusted/validator/validation_metadata.h"
 
 #define CONTEXT_MARKER 31
 #define QUERY_MARKER 37
 
 #define CODE_SIZE 32
 
 // ret
 const char ret[CODE_SIZE + 1] =
     "\xc3\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
@@ skipping 215 matching lines @@
   metadata.mtime = 100;
   metadata_ptr = &metadata;
   context.add_count_expected = 12;
   NaClValidationStatus status = Validate();
   EXPECT_EQ(NaClValidationSucceeded, status);
   EXPECT_EQ(true, context.query_destroyed);
 }
 
 extern "C" {
   extern int SerializeNaClDescMetadata(
-      uint8_t known_file,
-      const char *file_name,
-      uint32_t file_name_length,
+      const struct RichFileInfo *info,
       uint8_t **buffer,
       uint32_t *buffer_length);
 
   extern int DeserializeNaClDescMetadata(
-      uint8_t *buffer,
+      const uint8_t *buffer,
       uint32_t buffer_length,
-      uint8_t *known_file,
-      char **file_name,
-      uint32_t *file_name_length);
+      struct RichFileInfo *info);
 }
 
 class ValidationCachingSerializationTests : public ::testing::Test {
  protected:
+  struct RichFileInfo info;
   uint8_t *buffer;
   uint32_t buffer_length;
-  uint8_t known_file;
-  char *file_name;
-  uint32_t file_name_length;
+  struct RichFileInfo inp;
+  struct RichFileInfo outp;
 
   void SetUp() {
     buffer = 0;
     buffer_length = 0;
-    known_file = 0;
-    file_name = 0;
-    file_name_length = 0;
+    RichFileInfoCtor(&inp);
+    RichFileInfoCtor(&outp);
+  }
+
+  void TearDown() {
+    free(buffer);
+    // Don't free the inp structure, it does not contain malloced memory.
+    RichFileInfoDtor(&outp);
   }
 };
 
 TEST_F(ValidationCachingSerializationTests, NormalOperationSimple) {
-  EXPECT_EQ(0, SerializeNaClDescMetadata(0, "foo", 3, &buffer, &buffer_length));
-  EXPECT_EQ(0, DeserializeNaClDescMetadata(buffer, buffer_length, &known_file,
-                                           &file_name, &file_name_length));
-  free(buffer);
+  inp.known_file = 0;
+  inp.file_path = "foo";
+  inp.file_path_length = 3;
+  EXPECT_EQ(0, SerializeNaClDescMetadata(&inp, &buffer, &buffer_length));
+  EXPECT_EQ(0, DeserializeNaClDescMetadata(buffer, buffer_length, &outp));
 
-  EXPECT_EQ((uint8_t) 0, known_file);
-  EXPECT_EQ((uint32_t) 0, file_name_length);
-  EXPECT_EQ(NULL, file_name);
+  EXPECT_EQ((uint8_t) 0, outp.known_file);
+  EXPECT_EQ((uint32_t) 0, outp.file_path_length);
+  EXPECT_EQ(NULL, outp.file_path);
 }
 
 TEST_F(ValidationCachingSerializationTests, NormalOperationFull) {
-  EXPECT_EQ(0, SerializeNaClDescMetadata(1, "foo", 3, &buffer, &buffer_length));
-  EXPECT_EQ(0, DeserializeNaClDescMetadata(buffer, buffer_length, &known_file,
-                                           &file_name, &file_name_length));
-  free(buffer);
+  inp.known_file = 1;
+  inp.file_path = "foo";
+  inp.file_path_length = 3;
 
-  EXPECT_EQ((uint8_t) 1, known_file);
-  EXPECT_EQ((uint32_t) 3, file_name_length);
-  EXPECT_EQ(0, memcmp("foo", file_name, file_name_length));
-  free(file_name);
+  EXPECT_EQ(0, SerializeNaClDescMetadata(&inp, &buffer, &buffer_length));
+  EXPECT_EQ(0, DeserializeNaClDescMetadata(buffer, buffer_length, &outp));
+
+  EXPECT_EQ((uint8_t) 1, outp.known_file);
+  EXPECT_EQ((uint32_t) 3, outp.file_path_length);
+  EXPECT_EQ(0, memcmp("foo", outp.file_path, outp.file_path_length));
 }
 
 TEST_F(ValidationCachingSerializationTests, BadSizeSimple) {
-  EXPECT_EQ(0, SerializeNaClDescMetadata(0, NULL, 0, &buffer, &buffer_length));
+  inp.known_file = 0;
+  EXPECT_EQ(0, SerializeNaClDescMetadata(&inp, &buffer, &buffer_length));
   for (uint32_t i = -1; i <= buffer_length + 4; i++) {
     /* The only case that is OK. */
     if (i == buffer_length)
       continue;
 
     /* Wrong number of bytes, fail. */
-    EXPECT_EQ(1, DeserializeNaClDescMetadata(buffer, i, &known_file,
-                                             &file_name, &file_name_length));
+    EXPECT_EQ(1, DeserializeNaClDescMetadata(buffer, i, &outp));
   }
-  free(buffer);
 }
 
 TEST_F(ValidationCachingSerializationTests, BadSizeFull) {
-  EXPECT_EQ(0, SerializeNaClDescMetadata(1, "foo", 3, &buffer, &buffer_length));
+  inp.known_file = 1;
+  inp.file_path = "foo";
+  inp.file_path_length = 3;
+  EXPECT_EQ(0, SerializeNaClDescMetadata(&inp, &buffer, &buffer_length));
   for (uint32_t i = -1; i <= buffer_length + 4; i++) {
     /* The only case that is OK. */
     if (i == buffer_length)
       continue;
 
     /* Wrong number of bytes, fail. */
-    EXPECT_EQ(1, DeserializeNaClDescMetadata(buffer, i, &known_file,
-                                             &file_name, &file_name_length));
+    EXPECT_EQ(1, DeserializeNaClDescMetadata(buffer, i, &outp));
     /* Paranoia. */
-    EXPECT_EQ(0, known_file);
+    EXPECT_EQ(0, outp.known_file);
     /* Make sure we don't leak on failure. */
-    EXPECT_EQ(NULL, file_name);
+    EXPECT_EQ(NULL, outp.file_path);
   }
-  free(buffer);
 }
 
-extern "C" {
-  extern int SetFileOriginInfo(
-      struct NaClDesc *desc,
-      uint8_t known_file,
-      const char *file_name,
-      uint32_t file_name_length);
-
-  extern int GetFileOriginInfo(
-      struct NaClDesc *desc,
-      uint8_t *known_file,
-      char **file_name,
-      uint32_t *file_name_length);
-}
-
-char *AN_ARBITRARY_FILE_PATH = NULL;
+static char *AN_ARBITRARY_FILE_PATH = NULL;
 
 class ValidationCachingFileOriginTests : public ::testing::Test {
  protected:
   struct NaClDesc *desc;
 
-  uint8_t known_file;
-  char *file_name;
-  uint32_t file_name_length;
+  struct RichFileInfo inp;
+  struct RichFileInfo outp;
 
   void SetUp() {
     struct NaClHostDesc *host_desc = NULL;
     int fd = open(AN_ARBITRARY_FILE_PATH, O_RDONLY);
 
     desc = NULL;
-    known_file = 0;
-    file_name = NULL;
-    file_name_length = 0;
+    RichFileInfoCtor(&inp);
+    RichFileInfoCtor(&outp);
 
     ASSERT_NE(-1, fd);
     host_desc = NaClHostDescPosixMake(fd, NACL_ABI_O_RDONLY);
     desc = (struct NaClDesc *) NaClDescIoDescMake(host_desc);
     ASSERT_NE((struct NaClDesc *) NULL, desc);
   }
 
   void TearDown() {
-    free(file_name);
+    // Don't free the inp structure, it does not contain malloced memory.
+    RichFileInfoDtor(&outp);
     NaClDescSafeUnref(desc);
   }
 };
 
 TEST_F(ValidationCachingFileOriginTests, None) {
-  EXPECT_EQ(1, GetFileOriginInfo(desc, &known_file, &file_name,
-                                 &file_name_length));
+  EXPECT_EQ(1, GetFileOriginInfo(desc, &outp));
 }
 
 TEST_F(ValidationCachingFileOriginTests, Simple) {
-  EXPECT_EQ(0, SetFileOriginInfo(desc, 0, "foobar", 6));
-  EXPECT_EQ(0, GetFileOriginInfo(desc, &known_file, &file_name,
-                                 &file_name_length));
+  inp.known_file = 0;
+  inp.file_path = "foobar";
+  inp.file_path_length = 6;
+  EXPECT_EQ(0, SetFileOriginInfo(desc, &inp));
+  EXPECT_EQ(0, GetFileOriginInfo(desc, &outp));
 
-  EXPECT_EQ(0, known_file);
-  EXPECT_EQ((uint32_t) 0, file_name_length);
-  EXPECT_EQ(NULL, file_name);
+  EXPECT_EQ(0, outp.known_file);
+  EXPECT_EQ((uint32_t) 0, outp.file_path_length);
+  EXPECT_EQ(NULL, outp.file_path);
 }
 
 
 TEST_F(ValidationCachingFileOriginTests, Full) {
-  EXPECT_EQ(0, SetFileOriginInfo(desc, 1, "foobar", 6));
-  EXPECT_EQ(0, GetFileOriginInfo(desc, &known_file, &file_name,
-                                 &file_name_length));
+  inp.known_file = 1;
+  inp.file_path = "foobar";
+  inp.file_path_length = 6;
+  EXPECT_EQ(0, SetFileOriginInfo(desc, &inp));
+  EXPECT_EQ(0, GetFileOriginInfo(desc, &outp));
 
-  EXPECT_EQ(1, known_file);
-  EXPECT_EQ((uint32_t) 6, file_name_length);
-  EXPECT_EQ(0, memcmp("foobar", file_name, file_name_length));
+  EXPECT_EQ(1, outp.known_file);
+  EXPECT_EQ((uint32_t) 6, outp.file_path_length);
+  EXPECT_EQ(0, memcmp("foobar", outp.file_path, outp.file_path_length));
 }
 
 // Test driver function.
 int main(int argc, char *argv[]) {
   // One file we know must exist is this executable.
   AN_ARBITRARY_FILE_PATH = argv[0];
   // The IllegalInst test touches the log mutex deep inside the validator.
   // This causes an SEH exception to be thrown on Windows if the mutex is not
   // initialized.
   // http://code.google.com/p/nativeclient/issues/detail?id=1696
   NaClLogModuleInit();
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }