From 0383bbb9015898cbc79abd7b64316484d7713b44 Mon Sep 17 00:00:00 2001
From: Jeff King <peff@peff.net>
Date: Mon, 30 Apr 2018 03:25:25 -0400
Subject: [PATCH 01/11] submodule-config: verify submodule names as paths

Submodule "names" come from the untrusted .gitmodules file,
but we blindly append them to $GIT_DIR/modules to create our
on-disk repo paths. This means you can do bad things by
putting "../" into the name (among other things).

Let's sanity-check these names to avoid building a path that
can be exploited. There are two main decisions:

  1. What should the allowed syntax be?

     It's tempting to reuse verify_path(), since submodule
     names typically come from in-repo paths. But there are
     two reasons not to:

       a. It's technically more strict than what we need, as
          we really care only about breaking out of the
          $GIT_DIR/modules/ hierarchy.  E.g., having a
          submodule named "foo/.git" isn't actually
          dangerous, and it's possible that somebody has
          manually given such a funny name.

       b. Since we'll eventually use this checking logic in
          fsck to prevent downstream repositories, it should
          be consistent across platforms. Because
          verify_path() relies on is_dir_sep(), it wouldn't
          block "foo\..\bar" on a non-Windows machine.

  2. Where should we enforce it? These days most of the
     .gitmodules reads go through submodule-config.c, so
     I've put it there in the reading step. That should
     cover all of the C code.

     We also construct the name for "git submodule add"
     inside the git-submodule.sh script. This is probably
     not a big deal for security since the name is coming
     from the user anyway, but it would be polite to remind
     them if the name they pick is invalid (and we need to
     expose the name-checker to the shell anyway for our
     test scripts).

     This patch issues a warning when reading .gitmodules
     and just ignores the related config entry completely.
     This will generally end up producing a sensible error,
     as it works the same as a .gitmodules file which is
     missing a submodule entry (so "submodule update" will
     barf, but "git clone --recurse-submodules" will print
     an error but not abort the clone.

     There is one minor oddity, which is that we print the
     warning once per malformed config key (since that's how
     the config subsystem gives us the entries). So in the
     new test, for example, the user would see three
     warnings. That's OK, since the intent is that this case
     should never come up outside of malicious repositories
     (and then it might even benefit the user to see the
     message multiple times).

Credit for finding this vulnerability and the proof of
concept from which the test script was adapted goes to
Etienne Stalmans.

Signed-off-by: Jeff King <peff@peff.net>
---
 builtin/submodule--helper.c |   24 ++++++++++++++++++++++++
 git-submodule.sh            |    5 +++++
 submodule-config.c          |   31 +++++++++++++++++++++++++++++++
 submodule-config.h          |    7 +++++++
 4 files changed, 67 insertions(+)
 create mode 100755 t/t7415-submodule-names.sh

Index: git-1.7.12.4/git-submodule.sh
===================================================================
--- git-1.7.12.4.orig/git-submodule.sh
+++ git-1.7.12.4/git-submodule.sh
@@ -345,6 +345,11 @@ Use -f if you really want to add it." >&
 		exit 1
 	fi
 
+	if ! git z-submodule--helper-check-name "$sm_path"
+	then
+		die "$(eval_gettext "'$sm_path' is not a valid submodule name")"
+	fi
+
 	# perhaps the path exists and is already a git repo, else clone it
 	if test -e "$sm_path"
 	then
Index: git-1.7.12.4/git.c
===================================================================
--- git-1.7.12.4.orig/git.c
+++ git-1.7.12.4/git.c
@@ -4,6 +4,7 @@
 #include "help.h"
 #include "quote.h"
 #include "run-command.h"
+#include "submodule.h"
 
 const char git_usage_string[] =
 	"git [--version] [--exec-path[=<path>]] [--html-path] [--man-path] [--info-path]\n"
@@ -324,6 +325,29 @@ static int run_builtin(struct cmd_struct
 	return 0;
 }
 
+/*
+ * Exit non-zero if any of the submodule names given on the command line is
+ * invalid. If no names are given, filter stdin to print only valid names
+ * (which is primarily intended for testing).
+ */
+static int cmd_helper_check_name(int argc, const char **argv, const char *prefix)
+{
+        if (argc > 1) {
+                while (*++argv) {
+                        if (check_submodule_name(*argv) < 0)
+                                return 1;
+                }
+        } else {
+                struct strbuf buf = STRBUF_INIT;
+                while (strbuf_getline(&buf, stdin, '\n') != EOF) {
+                        if (!check_submodule_name(buf.buf))
+                                printf("%s\n", buf.buf);
+                }
+                strbuf_release(&buf);
+        }
+        return 0;
+}
+
 static void handle_internal_command(int argc, const char **argv)
 {
 	const char *cmd = argv[0];
@@ -441,6 +465,7 @@ static void handle_internal_command(int
 		{ "version", cmd_version },
 		{ "whatchanged", cmd_whatchanged, RUN_SETUP },
 		{ "write-tree", cmd_write_tree, RUN_SETUP },
+		{ "z-submodule--helper-check-name", cmd_helper_check_name, 0},
 	};
 	int i;
 	static const char ext[] = STRIP_EXTENSION;
Index: git-1.7.12.4/submodule.c
===================================================================
--- git-1.7.12.4.orig/submodule.c
+++ git-1.7.12.4/submodule.c
@@ -124,6 +124,31 @@ void gitmodules_config(void)
 	}
 }
 
+int check_submodule_name(const char *name)
+{
+        /* Disallow empty names */
+        if (!*name)
+                return -1;
+
+        /*
+         * Look for '..' as a path component. Check both '/' and '\\' as
+         * separators rather than is_dir_sep(), because we want the name rules
+         * to be consistent across platforms.
+         */
+        goto in_component; /* always start inside component */
+        while (*name) {
+                char c = *name++;
+                if (c == '/' || c == '\\') {
+in_component:
+                        if (name[0] == '.' && name[1] == '.' &&
+                            (!name[2] || name[2] == '/' || name[2] == '\\'))
+                                return -1;
+                }
+        }
+
+        return 0;
+}
+
 int parse_submodule_config_option(const char *var, const char *value)
 {
 	int len;
@@ -132,6 +157,12 @@ int parse_submodule_config_option(const
 
 	var += 10;		/* Skip "submodule." */
 
+	if (check_submodule_name(submodname.buf) < 0) {
+                warning(_("ignoring suspicious submodule name: %s"), submodname.buf);
+                strbuf_release(&submodname);
+                return 0;
+        }
+
 	len = strlen(var);
 	if ((len > 5) && !strcmp(var + len - 5, ".path")) {
 		strbuf_add(&submodname, var, len - 5);
Index: git-1.7.12.4/submodule.h
===================================================================
--- git-1.7.12.4.orig/submodule.h
+++ git-1.7.12.4/submodule.h
@@ -15,6 +15,14 @@ void set_diffopt_flags_from_submodule_co
 		const char *path);
 int submodule_config(const char *var, const char *value, void *cb);
 void gitmodules_config(void);
+
+/*
+ * Returns 0 if the name is syntactically acceptable as a submodule "name"
+ * (e.g., that may be found in the subsection of a .gitmodules file) and -1
+ * otherwise.
+ */
+int check_submodule_name(const char *name);
+
 int parse_submodule_config_option(const char *var, const char *value);
 void handle_ignore_submodules_arg(struct diff_options *diffopt, const char *);
 int parse_fetch_recurse_submodules_arg(const char *opt, const char *arg);
