diff --git a/git/config.py b/git/config.py
index 821710ea3..8f94d1d9d 100644
--- a/git/config.py
+++ b/git/config.py
@@ -7,11 +7,18 @@
 
 __all__ = ["GitConfigParser", "SectionConstraint"]
 
-import abc
-import configparser as cp
+from collections import OrderedDict
+from collections.abc import MutableMapping
+from configparser import (
+    DuplicateSectionError,
+    Error as ConfigError,
+    MissingSectionHeaderError,
+    NoOptionError,
+    NoSectionError,
+    ParsingError,
+)
 import fnmatch
 from functools import wraps
-import inspect
 from io import BufferedReader, IOBase
 import logging
 import os
@@ -29,8 +36,10 @@
     Callable,
     Generic,
     IO,
+    Iterator,
     List,
     Dict,
+    NoReturn,
     Sequence,
     TYPE_CHECKING,
     Tuple,
@@ -47,17 +56,6 @@
     from git.repo.base import Repo
 
 T_ConfigParser = TypeVar("T_ConfigParser", bound="GitConfigParser")
-T_OMD_value = TypeVar("T_OMD_value", str, bytes, int, float, bool)
-
-if sys.version_info[:3] < (3, 7, 2):
-    # typing.Ordereddict not added until Python 3.7.2.
-    from collections import OrderedDict
-
-    OrderedDict_OMD = OrderedDict
-else:
-    from typing import OrderedDict
-
-    OrderedDict_OMD = OrderedDict[str, List[T_OMD_value]]  # type: ignore[assignment, misc]
 
 # -------------------------------------------------------------
 
@@ -66,45 +64,225 @@
 CONFIG_LEVELS: ConfigLevels_Tup = ("system", "user", "global", "repository")
 """The configuration level of a configuration file."""
 
-CONDITIONAL_INCLUDE_REGEXP = re.compile(r"(?<=includeIf )\"(gitdir|gitdir/i|onbranch|hasconfig:remote\.\*\.url):(.+)\"")
+CONDITIONAL_INCLUDE_REGEXP = re.compile(
+    r'(?<=includeif )"(gitdir|gitdir/i|onbranch|hasconfig:remote\.\*\.url):(.+)"',
+    re.IGNORECASE,
+)
 """Section pattern to detect conditional includes.
 
 See: https://git-scm.com/docs/git-config#_conditional_includes
 """
 
 UNSAFE_CONFIG_CHARS_RE = re.compile(r"[\r\n\x00]")
-"""Characters that cannot be safely written in config names or values."""
+"""Characters that cannot be safely written in config names."""
 
+UNSAFE_CONFIG_VALUE_CHARS_RE = re.compile(r"\x00")
+"""Characters that cannot be represented in Git config values."""
 
-class MetaParserBuilder(abc.ABCMeta):  # noqa: B024
-    """Utility class wrapping base-class methods into decorators that assure read-only
-    properties."""
+_MISSING = object()
 
-    def __new__(cls, name: str, bases: Tuple, clsdict: Dict[str, Any]) -> "MetaParserBuilder":
-        """Equip all base-class methods with a needs_values decorator, and all non-const
-        methods with a :func:`set_dirty_and_flush_changes` decorator in addition to
-        that.
-        """
-        kmm = "_mutating_methods_"
-        if kmm in clsdict:
-            mutating_methods = clsdict[kmm]
-            for base in bases:
-                methods = (t for t in inspect.getmembers(base, inspect.isroutine) if not t[0].startswith("_"))
-                for method_name, method in methods:
-                    if method_name in clsdict:
-                        continue
-                    method_with_values = needs_values(method)
-                    if method_name in mutating_methods:
-                        method_with_values = set_dirty_and_flush_changes(method_with_values)
-                    # END mutating methods handling
 
-                    clsdict[method_name] = method_with_values
-                # END for each name/method pair
-            # END for each base
-        # END if mutating methods configuration is set
+def _escape_section_subsection(value: str) -> str:
+    """Return *value* escaped for Git's double-quoted subsection syntax."""
+    return value.replace("\\", "\\\\").replace('"', '\\"')
+
 
-        new_type = super().__new__(cls, name, bases, clsdict)
-        return new_type
+def _escape_config_value(value: str) -> str:
+    """Return *value* in a canonical representation accepted by Git."""
+    escaped = value.replace("\\", "\\\\")
+    escaped = escaped.replace('"', '\\"')
+    escaped = escaped.replace("\n", "\\n").replace("\t", "\\t").replace("\b", "\\b")
+    return '"%s"' % escaped
+
+
+class _GitConfigFileParser:
+    """Parse Git config syntax using the grammar in Git's ``config.c``.
+
+    The state machine mirrors Git's ``git_parse_source()``, ``get_base_var()``,
+    ``get_value()``, and ``parse_value()``. It intentionally deals only with syntax;
+    includes are resolved by :class:`GitConfigParser` after each file is parsed.
+    """
+
+    def __init__(self, data: str, source: str) -> None:
+        self._data = data[1:] if data.startswith("\ufeff") else data
+        self._source = source
+        self._position = 0
+        self._line_number = 1
+        self._current_section: Union[str, None] = None
+
+    @staticmethod
+    def _is_key_char(char: str) -> bool:
+        return char.isascii() and (char.isalnum() or char == "-")
+
+    @staticmethod
+    def _is_space(char: str) -> bool:
+        return char in " \t\n\v\f\r"
+
+    def _get_char(self) -> Union[str, None]:
+        if self._position == len(self._data):
+            return None
+
+        char = self._data[self._position]
+        self._position += 1
+        if char == "\r" and self._position < len(self._data) and self._data[self._position] == "\n":
+            self._position += 1
+            char = "\n"
+        if char == "\n":
+            self._line_number += 1
+        return char
+
+    def _error(self, line_number: Union[int, None] = None) -> NoReturn:
+        number = self._line_number if line_number is None else line_number
+        lines = self._data.splitlines()
+        line = lines[number - 1] if 0 < number <= len(lines) else ""
+        error = ParsingError(self._source)
+        error.append(number, repr(line))
+        raise error
+
+    def _parse_section(self, line_number: int) -> str:
+        base: List[str] = []
+        while True:
+            char = self._get_char()
+            if char is None or char == "\n":
+                self._error(line_number)
+            if char == "]":
+                if not base:
+                    self._error(line_number)
+                return "".join(base)
+            if self._is_space(char):
+                break
+            if not self._is_key_char(char) and char != ".":
+                self._error(line_number)
+            base.append(char)
+
+        while char is not None and self._is_space(char) and char != "\n":
+            char = self._get_char()
+        if char != '"' or not base:
+            self._error(line_number)
+
+        subsection: List[str] = []
+        while True:
+            char = self._get_char()
+            if char is None or char == "\n":
+                self._error(line_number)
+            if char == '"':
+                break
+            if char == "\\":
+                char = self._get_char()
+                if char is None or char == "\n":
+                    self._error(line_number)
+            subsection.append(char)
+
+        if self._get_char() != "]":
+            self._error(line_number)
+        return '%s "%s"' % ("".join(base), _escape_section_subsection("".join(subsection)))
+
+    def _parse_value(self, line_number: int) -> str:
+        value: List[str] = []
+        pending_whitespace: List[str] = []
+        quoted = False
+        comment = False
+
+        while True:
+            char = self._get_char()
+            if char is None or char == "\n":
+                if quoted:
+                    self._error(line_number)
+                return "".join(value)
+            if char == "\x00":
+                self._error(line_number)
+            if comment:
+                continue
+            if self._is_space(char) and not quoted:
+                if value:
+                    pending_whitespace.append(char)
+                continue
+            if not quoted and char in ";#":
+                comment = True
+                continue
+
+            if pending_whitespace:
+                value.extend(pending_whitespace)
+                pending_whitespace = []
+            if char == "\\":
+                char = self._get_char()
+                if char is None:
+                    self._error(line_number)
+                if char == "\n":
+                    continue
+                escapes = {"t": "\t", "b": "\b", "n": "\n", "\\": "\\", '"': '"'}
+                if char not in escapes:
+                    self._error(line_number)
+                value.append(escapes[char])
+            elif char == '"':
+                quoted = not quoted
+            else:
+                value.append(char)
+
+    def _parse_entry(self, first_char: str, line_number: int) -> Tuple[str, Union[str, None]]:
+        option = [first_char]
+        char = self._get_char()
+        while char is not None and self._is_key_char(char):
+            option.append(char)
+            char = self._get_char()
+        while char in (" ", "\t"):
+            char = self._get_char()
+
+        # Git distinguishes a valueless key from a key whose value is "true".
+        if char is None or char == "\n":
+            return "".join(option), None
+        if char != "=":
+            self._error(line_number)
+        return "".join(option), self._parse_value(line_number)
+
+    def parse(self) -> List[Tuple[str, Union[str, None], Union[str, None]]]:
+        events: List[Tuple[str, Union[str, None], Union[str, None]]] = []
+        comment = False
+
+        while True:
+            line_number = self._line_number
+            char = self._get_char()
+            if char is None:
+                return events
+            if char == "\n":
+                comment = False
+                continue
+            if comment:
+                continue
+            if self._is_space(char):
+                continue
+            if char in "#;":
+                comment = True
+                continue
+            if char == "[":
+                self._current_section = self._parse_section(line_number)
+                events.append((self._current_section, None, None))
+                continue
+            if not (char.isascii() and char.isalpha()):
+                self._error(line_number)
+            if self._current_section is None:
+                line = self._data.splitlines()[line_number - 1]
+                raise MissingSectionHeaderError(self._source, line_number, line)
+            option, value = self._parse_entry(char, line_number)
+            events.append((self._current_section, option, value))
+
+
+def _canonical_section_name(name: str) -> str:
+    """Validate and canonicalize one section name using Git's own grammar."""
+    events = _GitConfigFileParser("[%s]" % name, "<section name>").parse()
+    sections = [section for section, option, _ in events if option is None]
+    if len(sections) != 1:
+        raise ValueError("Git config section name does not identify exactly one section")
+    return sections[0]
+
+
+def _section_name_key(name: str) -> str:
+    """Return Git's case-insensitive lookup key for a canonical section name."""
+    canonical_name = _canonical_section_name(name)
+    subsection_start = canonical_name.find(' "')
+    if subsection_start == -1:
+        return canonical_name.lower()
+    return canonical_name[:subsection_start].lower() + canonical_name[subsection_start:]
 
 
 def needs_values(func: Callable[..., _T]) -> Callable[..., _T]:
@@ -139,13 +317,12 @@ def flush_changes(self: "GitConfigParser", *args: Any, **kwargs: Any) -> _T:
 
 
 class SectionConstraint(Generic[T_ConfigParser]):
-    """Constrains a ConfigParser to only option commands which are constrained to
-    always use the section we have been initialized with.
+    """Constrain a configuration parser to commands for one section.
 
-    It supports all ConfigParser methods that operate on an option.
+    It supports all :class:`GitConfigParser` methods that operate on an option.
 
     :note:
-        If used as a context manager, will release the wrapped ConfigParser.
+        If used as a context manager, this releases the wrapped parser.
     """
 
     __slots__ = ("_config", "_section_name")
@@ -186,7 +363,7 @@ def _call_config(self, method: str, *args: Any, **kwargs: Any) -> Any:
 
     @property
     def config(self) -> T_ConfigParser:
-        """return: ConfigParser instance we constrain"""
+        """Return the :class:`GitConfigParser` instance being constrained."""
         return self._config
 
     def release(self) -> None:
@@ -202,49 +379,94 @@ def __exit__(self, exception_type: str, exception_value: str, traceback: str) ->
         self._config.__exit__(exception_type, exception_value, traceback)
 
 
-class _OMD(OrderedDict_OMD):
-    """Ordered multi-dict."""
+class _GitConfigSectionData:
+    """Ordered, multi-valued storage for one Git configuration section."""
 
-    def __setitem__(self, key: str, value: _T) -> None:
-        super().__setitem__(key, [value])
+    def __init__(self) -> None:
+        self._values: "OrderedDict[str, List[Union[str, None]]]" = OrderedDict()
 
-    def add(self, key: str, value: Any) -> None:
-        if key not in self:
-            super().__setitem__(key, [value])
-            return
+    def __contains__(self, option: str) -> bool:
+        return option in self._values
 
-        super().__getitem__(key).append(value)
+    def __len__(self) -> int:
+        return len(self._values)
 
-    def setall(self, key: str, values: List[_T]) -> None:
-        super().__setitem__(key, values)
+    def add(self, option: str, value: Union[str, None]) -> None:
+        self._values.setdefault(option, []).append(value)
 
-    def __getitem__(self, key: str) -> Any:
-        return super().__getitem__(key)[-1]
+    def set(self, option: str, value: Union[str, None]) -> None:
+        self._values[option] = [value]
 
-    def getlast(self, key: str) -> Any:
-        return super().__getitem__(key)[-1]
+    def setall(self, option: str, values: List[Union[str, None]]) -> None:
+        self._values[option] = list(values)
+
+    def getlast(self, option: str) -> Union[str, None]:
+        return self._values[option][-1]
+
+    def getall(self, option: str) -> List[Union[str, None]]:
+        return list(self._values[option])
+
+    def remove(self, option: str) -> bool:
+        if option not in self._values:
+            return False
+        del self._values[option]
+        return True
+
+    def options(self) -> List[str]:
+        return list(self._values)
+
+    def items_all(self) -> List[Tuple[str, List[Union[str, None]]]]:
+        return [(option, list(values)) for option, values in self._values.items()]
 
-    def setlast(self, key: str, value: Any) -> None:
-        if key not in self:
-            super().__setitem__(key, [value])
-            return
 
-        prior = super().__getitem__(key)
-        prior[-1] = value
+class _GitConfigSection(MutableMapping):
+    """Mapping-style view of one section in a :class:`GitConfigParser`."""
 
-    def get(self, key: str, default: Union[_T, None] = None) -> Union[_T, None]:
-        return super().get(key, [default])[-1]
+    def __init__(self, parser: "GitConfigParser", name: str) -> None:
+        self._parser = parser
+        self._name = name
 
-    def getall(self, key: str) -> List[_T]:
-        return super().__getitem__(key)
+    def __repr__(self) -> str:
+        return "<Git config section: %s>" % self._name
 
-    def items(self) -> List[Tuple[str, _T]]:  # type: ignore[override]
-        """List of (key, last value for key)."""
-        return [(k, self[k]) for k in self]
+    def __getitem__(self, option: str) -> str:
+        return self._parser.get(self._name, option)
 
-    def items_all(self) -> List[Tuple[str, List[_T]]]:
-        """List of (key, list of values for key)."""
-        return [(k, self.getall(k)) for k in self]
+    def __setitem__(self, option: str, value: Any) -> None:
+        self._parser.set(self._name, option, value)
+
+    def __delitem__(self, option: str) -> None:
+        if not self._parser.remove_option(self._name, option):
+            raise KeyError(option)
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self._parser.options(self._name))
+
+    def __len__(self) -> int:
+        return len(self._parser.options(self._name))
+
+    def __contains__(self, option: object) -> bool:
+        return isinstance(option, str) and self._parser.has_option(self._name, option)
+
+    def get(self, option: str, fallback: Any = None, **kwargs: Any) -> Any:  # type: ignore[override]
+        return self._parser.get(self._name, option, fallback=fallback, **kwargs)
+
+    def getint(self, option: str, fallback: Any = None, **kwargs: Any) -> Any:
+        return self._parser.getint(self._name, option, fallback=fallback, **kwargs)
+
+    def getfloat(self, option: str, fallback: Any = None, **kwargs: Any) -> Any:
+        return self._parser.getfloat(self._name, option, fallback=fallback, **kwargs)
+
+    def getboolean(self, option: str, fallback: Any = None, **kwargs: Any) -> Any:
+        return self._parser.getboolean(self._name, option, fallback=fallback, **kwargs)
+
+    @property
+    def parser(self) -> "GitConfigParser":
+        return self._parser
+
+    @property
+    def name(self) -> str:
+        return self._name
 
 
 def get_config_path(config_level: Lit_config_levels) -> str:
@@ -271,7 +493,7 @@ def get_config_path(config_level: Lit_config_levels) -> str:
         )
 
 
-class GitConfigParser(cp.RawConfigParser, metaclass=MetaParserBuilder):
+class GitConfigParser:
     """Implements specifics required to read git style configuration files.
 
     This variation behaves much like the :manpage:`git-config(1)` command, such that the
@@ -285,8 +507,8 @@ class GitConfigParser(cp.RawConfigParser, metaclass=MetaParserBuilder):
     other instances to write concurrently.
 
     :note:
-        The config is case-sensitive even when queried, hence section and option names
-        must match perfectly.
+        Section and option names are case-insensitive, while subsection names are
+        case-sensitive, matching Git.
 
     :note:
         If used as a context manager, this will release the locked file.
@@ -300,21 +522,6 @@ class GitConfigParser(cp.RawConfigParser, metaclass=MetaParserBuilder):
     A suitable alternative would be the :class:`~git.util.BlockingLockFile`.
     """
 
-    re_comment = re.compile(r"^\s*[#;]")
-    # } END configuration
-
-    optvalueonly_source = r"\s*(?P<option>[^:=\s][^:=]*)"
-
-    OPTVALUEONLY = re.compile(optvalueonly_source)
-
-    OPTCRE = re.compile(optvalueonly_source + r"\s*(?P<vi>[:=])\s*" + r"(?P<value>.*)$")
-
-    del optvalueonly_source
-
-    _mutating_methods_ = ("add_section", "remove_section", "remove_option", "set")
-    """Names of :class:`~configparser.RawConfigParser` methods able to change the
-    instance."""
-
     def __init__(
         self,
         file_or_files: Union[None, PathLike, "BytesIO", Sequence[Union[PathLike, "BytesIO"]]] = None,
@@ -330,9 +537,9 @@ def __init__(
             A file path or file object, or a sequence of possibly more than one of them.
 
         :param read_only:
-            If ``True``, the ConfigParser may only read the data, but not change it.
+            If ``True``, the parser may only read the data, but not change it.
             If ``False``, only a single file path or file object may be given. We will
-            write back the changes when they happen, or when the ConfigParser is
+            write back the changes when they happen, or when the parser is
             released. This will not happen if other configuration files have been
             included.
 
@@ -347,15 +554,11 @@ def __init__(
             Reference to repository to use if ``[includeIf]`` sections are found in
             configuration files.
         """
-        cp.RawConfigParser.__init__(self, dict_type=_OMD)
-        self._dict: Callable[..., _OMD]
-        self._defaults: _OMD
-        self._sections: _OMD
-
-        # Used in Python 3. Needs to stay in sync with sections for underlying
-        # implementation to work.
-        if not hasattr(self, "_proxies"):
-            self._proxies = self._dict()
+        self._sections: "OrderedDict[str, _GitConfigSectionData]" = OrderedDict()
+        # Lookups use case-normalized keys, while canonical rewrites retain the
+        # first spelling seen in the file or supplied through the API.
+        self._section_name_map: Dict[str, str] = {}
+        self._option_name_map: Dict[Tuple[str, str], str] = {}
 
         if file_or_files is not None:
             self._file_or_files: Union[PathLike, "BytesIO", Sequence[Union[PathLike, "BytesIO"]]] = file_or_files
@@ -385,7 +588,7 @@ def _acquire_lock(self) -> None:
                     file_or_files = self._file_or_files
                 elif isinstance(self._file_or_files, (tuple, list, Sequence)):
                     raise ValueError(
-                        "Write-ConfigParsers can operate on a single file only, multiple files have been passed"
+                        "Writable config parsers can operate on a single file only; multiple files were passed"
                     )
                 else:
                     file_or_files = self._file_or_files.name
@@ -436,112 +639,131 @@ def release(self) -> None:
                 self._lock._release_lock()
 
     def optionxform(self, optionstr: str) -> str:
-        """Do not transform options in any way when writing."""
-        return optionstr
+        """Normalize option names as Git does; their spelling is case-insensitive."""
+        return optionstr.lower()
 
-    def _read(self, fp: Union[BufferedReader, IO[bytes]], fpname: str) -> None:
-        """Originally a direct copy of the Python 2.4 version of
-        :meth:`RawConfigParser._read <configparser.RawConfigParser._read>`, to ensure it
-        uses ordered dicts.
+    @needs_values
+    def sections(self) -> List[str]:
+        """Return section names with the spelling used in the configuration."""
+        return [self._section_name_map.get(section, section) for section in self._sections]
 
-        The ordering bug was fixed in Python 2.4, and dict itself keeps ordering since
-        Python 3.7. This has some other changes, especially that it ignores initial
-        whitespace, since git uses tabs. (Big comments are removed to be more compact.)
-        """
-        cursect = None  # None, or a dictionary.
-        optname = None
-        lineno = 0
-        is_multi_line = False
-        e = None  # None, or an exception.
+    def __iter__(self) -> Iterator[str]:
+        """Iterate over section names with their original spelling."""
+        return iter(self.sections())
 
-        def string_decode(v: str) -> str:
-            if v and v.endswith("\\"):
-                v = v[:-1]
-            # END cut trailing escapes to prevent decode error
+    def __len__(self) -> int:
+        self.read()
+        return len(self._sections)
 
-            return v.encode(defenc).decode("unicode_escape")
+    def __contains__(self, section: object) -> bool:
+        return isinstance(section, str) and self.has_section(section)
 
-        # END string_decode
+    @needs_values
+    def __getitem__(self, section: str) -> _GitConfigSection:
+        """Return a section proxy using Git's section case rules."""
+        section_key = self._normalize_section_name(section)
+        if section_key not in self._sections:
+            raise KeyError(section)
+        return _GitConfigSection(self, self._section_name_map.get(section_key, section_key))
 
-        while True:
-            # We assume to read binary!
-            line = fp.readline().decode(defenc)
-            if not line:
-                break
-            lineno = lineno + 1
-            # Comment or blank line?
-            if line.strip() == "" or self.re_comment.match(line):
-                continue
-            if line.split(None, 1)[0].lower() == "rem" and line[0] in "rR":
-                # No leading whitespace.
-                continue
+    def keys(self) -> List[str]:
+        return self.sections()
 
-            # Is it a section header?
-            mo = self.SECTCRE.match(line.strip())
-            if not is_multi_line and mo:
-                sectname: str = mo.group("header").strip()
-                if sectname in self._sections:
-                    cursect = self._sections[sectname]
-                elif sectname == cp.DEFAULTSECT:
-                    cursect = self._defaults
-                else:
-                    cursect = self._dict((("__name__", sectname),))
-                    self._sections[sectname] = cursect
-                    self._proxies[sectname] = None
-                # So sections can't start with a continuation line.
-                optname = None
-            # No section header in the file?
-            elif cursect is None:
-                raise cp.MissingSectionHeaderError(fpname, lineno, line)
-            # An option line?
-            elif not is_multi_line:
-                mo = self.OPTCRE.match(line)
-                if mo:
-                    # We might just have handled the last line, which could contain a quotation we want to remove.
-                    optname, vi, optval = mo.group("option", "vi", "value")
-                    optname = self.optionxform(optname.rstrip())
-
-                    if vi in ("=", ":") and ";" in optval and not optval.strip().startswith('"'):
-                        pos = optval.find(";")
-                        if pos != -1 and optval[pos - 1].isspace():
-                            optval = optval[:pos]
-                    optval = optval.strip()
-
-                    if len(optval) < 2 or optval[0] != '"':
-                        # Does not open quoting.
-                        pass
-                    elif optval[-1] != '"':
-                        # Opens quoting and does not close: appears to start multi-line quoting.
-                        is_multi_line = True
-                        optval = string_decode(optval[1:])
-                    elif optval.find("\\", 1, -1) == -1 and optval.find('"', 1, -1) == -1:
-                        # Opens and closes quoting. Single line, and all we need is quote removal.
-                        optval = optval[1:-1]
-                    # TODO: Handle other quoted content, especially well-formed backslash escapes.
-
-                    # Preserves multiple values for duplicate optnames.
-                    cursect.add(optname, optval)
-                else:
-                    # Check if it's an option with no value - it's just ignored by git.
-                    if not self.OPTVALUEONLY.match(line):
-                        if not e:
-                            e = cp.ParsingError(fpname)
-                        e.append(lineno, repr(line))
-                    continue
-            else:
-                line = line.rstrip()
-                if line.endswith('"'):
-                    is_multi_line = False
-                    line = line[:-1]
-                # END handle quotations
-                optval = cursect.getlast(optname)
-                cursect.setlast(optname, optval + string_decode(line))
-            # END parse section or option
-        # END while reading
-
-        # If any parsing errors occurred, raise an exception.
-        if e:
-            raise e
+    def values(self) -> List[_GitConfigSection]:
+        return [self[section] for section in self.sections()]
+
+    @staticmethod
+    def _normalize_section_name(section: str) -> str:
+        return _section_name_key(section)
+
+    @needs_values
+    def get(
+        self,
+        section: str,
+        option: str,
+        raw: bool = False,
+        vars: Union[Dict[str, Any], None] = None,
+        fallback: Any = _MISSING,
+    ) -> Any:
+        """Get an option using Git's section and option case rules."""
+        del raw  # Git config values are never interpolated.
+        section_key = self._normalize_section_name(section)
+        if section_key not in self._sections:
+            if fallback is not _MISSING:
+                return fallback
+            raise NoSectionError(section)
+
+        option_key = self.optionxform(option)
+        if vars is not None:
+            for var_name, var_value in vars.items():
+                if self.optionxform(var_name) == option_key:
+                    return var_value
+        section_data = self._sections[section_key]
+        if option_key not in section_data:
+            if fallback is not _MISSING:
+                return fallback
+            raise NoOptionError(option, self._section_name_map.get(section_key, section))
+        value = section_data.getlast(option_key)
+        return "true" if value is None else value
+
+    @needs_values
+    def has_section(self, section: str) -> bool:
+        """Return whether *section* exists, ignoring case in its base name."""
+        section = self._normalize_section_name(section)
+        return section in self._sections
+
+    @needs_values
+    def has_option(self, section: str, option: str) -> bool:
+        """Return whether *option* exists using Git's case rules."""
+        section = self._normalize_section_name(section)
+        return section in self._sections and self.optionxform(option) in self._sections[section]
+
+    @needs_values
+    def options(self, section: str) -> List[str]:
+        """Return option names with their original spelling."""
+        section = self._normalize_section_name(section)
+        if section not in self._sections:
+            raise NoSectionError(section)
+        return [self._option_name_map.get((section, option), option) for option in self._sections[section].options()]
+
+    @needs_values
+    @set_dirty_and_flush_changes
+    def remove_option(self, section: str, option: str) -> bool:
+        """Remove an option using Git's section and option case rules."""
+        section = self._normalize_section_name(section)
+        option_key = self.optionxform(option)
+        if section not in self._sections:
+            raise NoSectionError(section)
+        removed = self._sections[section].remove(option_key)
+        if removed:
+            self._option_name_map.pop((section, option_key), None)
+        return removed
+
+    @needs_values
+    @set_dirty_and_flush_changes
+    def remove_section(self, section: str) -> bool:
+        """Remove a section while ignoring case in its base name."""
+        section = self._normalize_section_name(section)
+        removed = section in self._sections
+        if removed:
+            del self._sections[section]
+            self._section_name_map.pop(section, None)
+            for name_key in [name_key for name_key in self._option_name_map if name_key[0] == section]:
+                del self._option_name_map[name_key]
+        return removed
+
+    def _read(self, fp: Union[BufferedReader, IO[bytes]], fpname: str) -> None:
+        """Parse one file according to the grammar implemented by Git itself."""
+        parser = _GitConfigFileParser(fp.read().decode(defenc), fpname)
+        for section, option, value in parser.parse():
+            section_key = _section_name_key(section)
+            if section_key not in self._sections:
+                self._sections[section_key] = _GitConfigSectionData()
+                self._section_name_map[section_key] = section
+            if option is not None:
+                option_key = self.optionxform(option)
+                self._sections[section_key].add(option_key, value)
+                self._option_name_map.setdefault((section_key, option_key), option)
 
     def _has_includes(self) -> Union[bool, int]:
         return self._merge_includes and len(self._included_paths())
@@ -555,17 +777,17 @@ def _included_paths(self) -> List[Tuple[str, str]]:
 
         def _all_items(section: str) -> List[Tuple[str, str]]:
             """Return all (key, value) pairs for a section, including duplicate keys."""
+            section = _section_name_key(section)
             return [
-                (key, value)
+                (key, "true" if value is None else value)
                 for key, values in self._sections[section].items_all()
-                if key != "__name__"
                 for value in values
             ]
 
         paths = []
 
         for section in self.sections():
-            if section == "include":
+            if _section_name_key(section) == "include":
                 paths += _all_items(section)
 
             match = CONDITIONAL_INCLUDE_REGEXP.search(section)
@@ -610,7 +832,7 @@ def _all_items(section: str) -> List[Tuple[str, str]]:
                         break
         return paths
 
-    def read(self) -> None:  # type: ignore[override]
+    def read(self) -> None:
         """Read the data stored in the files we have been initialized with.
 
         This will ignore files that cannot be read, possibly leaving an empty
@@ -686,50 +908,50 @@ def read(self) -> None:  # type: ignore[override]
             self._merge_includes = False
 
     def _write(self, fp: IO) -> None:
-        """Write an .ini-format representation of the configuration state in
-        git compatible format."""
+        """Write a canonical Git-config representation of the configuration state."""
 
-        def write_section(name: str, section_dict: _OMD) -> None:
-            fp.write(("[%s]\n" % name).encode(defenc))
-
-            values: Sequence[str]  # Runtime only gets str in tests, but should be whatever _OMD stores.
-            v: str
-            for key, values in section_dict.items_all():
-                if key == "__name__":
-                    continue
+        def write_section(name: str, section_data: _GitConfigSectionData) -> None:
+            section_name = self._section_name_map.get(name, name)
+            fp.write(("[%s]\n" % _canonical_section_name(section_name)).encode(defenc))
 
-                for v in values:
-                    fp.write(("\t%s = %s\n" % (key, self._value_to_string(v).replace("\n", "\n\t"))).encode(defenc))
-                # END if key is not __name__
+            for key, values in section_data.items_all():
+                for raw_value in values:
+                    option_name = self._option_name_map.get((name, key), key)
+                    if raw_value is None:
+                        fp.write(("\t%s\n" % option_name).encode(defenc))
+                        continue
+                    value = _escape_config_value(self._value_to_string(raw_value))
+                    fp.write(("\t%s = %s\n" % (option_name, value)).encode(defenc))
 
         # END section writing
 
-        if self._defaults:
-            write_section(cp.DEFAULTSECT, self._defaults)
-        value: _OMD
-
-        for name, value in self._sections.items():
-            write_section(name, value)
+        for name, section_data in self._sections.items():
+            write_section(name, section_data)
 
-    def items(self, section_name: str) -> List[Tuple[str, str]]:  # type: ignore[override]
+    @needs_values
+    def items(self, section_name: str) -> List[Tuple[str, str]]:
         """:return: list((option, value), ...) pairs of all items in the given section"""
-        return [(k, v) for k, v in super().items(section_name) if k != "__name__"]
+        section_name = self._normalize_section_name(section_name)
+        if section_name not in self._sections:
+            raise NoSectionError(section_name)
+        return [
+            (self._option_name_map.get((section_name, key), key), "true" if values[-1] is None else values[-1])
+            for key, values in self._sections[section_name].items_all()
+        ]
 
+    @needs_values
     def items_all(self, section_name: str) -> List[Tuple[str, List[str]]]:
         """:return: list((option, [values...]), ...) pairs of all items in the given section"""
-        rv = _OMD(self._defaults)
-
-        for k, vs in self._sections[section_name].items_all():
-            if k == "__name__":
-                continue
-
-            if k in rv and rv.getall(k) == vs:
-                continue
-
-            for v in vs:
-                rv.add(k, v)
-
-        return rv.items_all()
+        section_name = self._normalize_section_name(section_name)
+        if section_name not in self._sections:
+            raise NoSectionError(section_name)
+        return [
+            (
+                self._option_name_map.get((section_name, key), key),
+                ["true" if value is None else value for value in values],
+            )
+            for key, values in self._sections[section_name].items_all()
+        ]
 
     @needs_values
     def write(self) -> None:
@@ -781,10 +1003,20 @@ def _assure_writable(self, method_name: str) -> None:
         if self.read_only:
             raise IOError("Cannot execute non-constant method %s.%s" % (self, method_name))
 
-    def add_section(self, section: "cp._SectionName") -> None:
+    def _add_section(self, section: str) -> None:
+        section_name = _canonical_section_name(section)
+        section_key = _section_name_key(section_name)
+        if section_key in self._sections:
+            raise DuplicateSectionError(section_name)
+        self._sections[section_key] = _GitConfigSectionData()
+        self._section_name_map[section_key] = section_name
+
+    @needs_values
+    @set_dirty_and_flush_changes
+    def add_section(self, section: str) -> None:
         """Assures added options will stay in order."""
         self._assure_config_name_safe(section, "section")
-        return super().add_section(section)
+        self._add_section(section)
 
     @property
     def read_only(self) -> bool:
@@ -812,7 +1044,7 @@ def get_value(
 
         :raise TypeError:
             In case the value could not be understood.
-            Otherwise the exceptions known to the ConfigParser will be raised.
+            Otherwise the parser's lookup exceptions will be raised.
         """
         try:
             valuestr = self.get(section, option)
@@ -843,17 +1075,75 @@ def get_values(
 
         :raise TypeError:
             In case the value could not be understood.
-            Otherwise the exceptions known to the ConfigParser will be raised.
+            Otherwise the parser's lookup exceptions will be raised.
         """
         try:
             self.sections()
-            lst = self._sections[section].getall(option)
+            section = self._normalize_section_name(section)
+            lst = self._sections[section].getall(self.optionxform(option))
         except Exception:
             if default is not None:
                 return [default]
             raise
 
-        return [self._string_to_value(valuestr) for valuestr in lst]
+        return [True if valuestr is None else self._string_to_value(valuestr) for valuestr in lst]
+
+    def _get_with_fallback(self, section: str, option: str, fallback: Any) -> Any:
+        if fallback is _MISSING:
+            return self.get(section, option)
+        return self.get(section, option, fallback=fallback)
+
+    def getint(self, section: str, option: str, fallback: Any = _MISSING, **kwargs: Any) -> Any:
+        """Return an integer parsed with Git's base prefixes and binary suffixes."""
+        del kwargs
+        value = self._get_with_fallback(section, option, fallback)
+        if value is fallback and fallback is not _MISSING:
+            return fallback
+        match = re.fullmatch(r"([+-]?)(0[xX][0-9a-fA-F]+|0[0-7]*|[1-9][0-9]*)([kKmMgG]?)", value)
+        if match is None:
+            raise ValueError("Not a valid Git integer: %r" % value)
+        sign, number, suffix = match.groups()
+        if number.lower().startswith("0x"):
+            base = 16
+        elif len(number) > 1 and number.startswith("0"):
+            base = 8
+        else:
+            base = 10
+        factor = {"": 1, "k": 1024, "m": 1024**2, "g": 1024**3}[suffix.lower()]
+        parsed = int(number, base) * factor
+        return -parsed if sign == "-" else parsed
+
+    def getfloat(self, section: str, option: str, fallback: Any = _MISSING, **kwargs: Any) -> Any:
+        """Return a floating-point value parsed with Git's binary suffixes."""
+        del kwargs
+        value = self._get_with_fallback(section, option, fallback)
+        if value is fallback and fallback is not _MISSING:
+            return fallback
+        match = re.fullmatch(
+            r"([+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?)([kKmMgG]?)",
+            value,
+        )
+        if match is None:
+            raise ValueError("Not a valid Git floating-point value: %r" % value)
+        number, suffix = match.groups()
+        factor = {"": 1, "k": 1024, "m": 1024**2, "g": 1024**3}[suffix.lower()]
+        return float(number) * factor
+
+    def getboolean(self, section: str, option: str, fallback: Any = _MISSING, **kwargs: Any) -> Any:
+        """Return a boolean using Git's spelling and numeric rules."""
+        del kwargs
+        value = self._get_with_fallback(section, option, fallback)
+        if value is fallback and fallback is not _MISSING:
+            return fallback
+        normalized = value.lower()
+        if normalized in ("true", "yes", "on"):
+            return True
+        if normalized in ("", "false", "no", "off"):
+            return False
+        try:
+            return self.getint(section, option) != 0
+        except ValueError as error:
+            raise ValueError("Not a boolean: %r" % value) from error
 
     def _string_to_value(self, valuestr: str) -> Union[int, float, str, bool]:
         types = (int, float)
@@ -890,29 +1180,25 @@ def _value_to_string(self, value: Union[str, bytes, int, float, bool]) -> str:
 
     def _value_to_string_safe(self, value: Union[str, bytes, int, float, bool]) -> str:
         value_str = self._value_to_string(value)
-        if UNSAFE_CONFIG_CHARS_RE.search(value_str):
-            raise ValueError("Git config values must not contain CR, LF, or NUL")
+        if UNSAFE_CONFIG_VALUE_CHARS_RE.search(value_str):
+            raise ValueError("Git config values must not contain NUL")
         return value_str
 
-    def _assure_config_name_safe(self, name: "cp._SectionName", label: str) -> None:
-        if isinstance(name, str) and UNSAFE_CONFIG_CHARS_RE.search(name):
+    def _assure_config_name_safe(self, name: str, label: str) -> None:
+        if not isinstance(name, str):
+            raise TypeError("Git config %s names must be strings" % label)
+        if UNSAFE_CONFIG_CHARS_RE.search(name):
             raise ValueError("Git config %s names must not contain CR, LF, or NUL" % label)
-        if label == "section" and isinstance(name, str):
-            in_quotes = False
-            escaped = False
-            for index, char in enumerate(name):
-                if escaped:
-                    escaped = False
-                elif in_quotes and char == "\\":
-                    escaped = True
-                elif char == '"':
-                    if not in_quotes and (index == 0 or name[index - 1] not in " \t"):
-                        raise ValueError("Git config quoted subsection names must begin after whitespace")
-                    in_quotes = not in_quotes
-                elif char == "]" and not in_quotes:
-                    raise ValueError("Git config section names must not contain an unquoted closing bracket")
-            if in_quotes:
-                raise ValueError("Git config section names must not contain an unterminated quote")
+        if label == "section":
+            try:
+                _canonical_section_name(name)
+            except ConfigError as error:
+                raise ValueError("Invalid Git config section name: %s" % name) from error
+        elif label == "option":
+            if not name or not (name[0].isascii() and name[0].isalpha()):
+                raise ValueError("Git config option names must start with an ASCII letter")
+            if not all(_GitConfigFileParser._is_key_char(char) for char in name):
+                raise ValueError("Git config option names may contain only ASCII letters, digits, and hyphens")
 
     @needs_values
     @set_dirty_and_flush_changes
@@ -924,9 +1210,14 @@ def set(
     ) -> None:
         self._assure_config_name_safe(section, "section")
         self._assure_config_name_safe(option, "option")
+        section = self._normalize_section_name(section)
+        option_key = self.optionxform(option)
         if value is not None:
             value = self._value_to_string_safe(value)
-        return super().set(section, option, value)
+        if section not in self._sections:
+            raise NoSectionError(section)
+        self._sections[section].set(option_key, value)
+        self._option_name_map.setdefault((section, option_key), option)
 
     @needs_values
     @set_dirty_and_flush_changes
@@ -934,7 +1225,7 @@ def set_value(self, section: str, option: str, value: Union[str, bytes, int, flo
         """Set the given option in section to the given value.
 
         This will create the section if required, and will not throw as opposed to the
-        default ConfigParser ``set`` method.
+        lower-level :meth:`set` method.
 
         :param section:
             Name of the section in which the option resides or should reside.
@@ -950,10 +1241,14 @@ def set_value(self, section: str, option: str, value: Union[str, bytes, int, flo
         """
         self._assure_config_name_safe(section, "section")
         self._assure_config_name_safe(option, "option")
+        section_name = _canonical_section_name(section)
+        section = self._normalize_section_name(section)
+        option_key = self.optionxform(option)
         value_str = self._value_to_string_safe(value)
         if not self.has_section(section):
-            self.add_section(section)
-        super().set(section, option, value_str)
+            self._add_section(section_name)
+        self._sections[section].set(option_key, value_str)
+        self._option_name_map.setdefault((section, option_key), option)
         return self
 
     @needs_values
@@ -962,7 +1257,7 @@ def add_value(self, section: str, option: str, value: Union[str, bytes, int, flo
         """Add a value for the given option in section.
 
         This will create the section if required, and will not throw as opposed to the
-        default ConfigParser ``set`` method. The value becomes the new value of the
+        lower-level :meth:`set` method. The value becomes the new value of the
         option as returned by :meth:`get_value`, and appends to the list of values
         returned by :meth:`get_values`.
 
@@ -980,10 +1275,15 @@ def add_value(self, section: str, option: str, value: Union[str, bytes, int, flo
         """
         self._assure_config_name_safe(section, "section")
         self._assure_config_name_safe(option, "option")
+        section_name = _canonical_section_name(section)
+        section = self._normalize_section_name(section)
+        option_name = option
+        option = self.optionxform(option_name)
         value_str = self._value_to_string_safe(value)
         if not self.has_section(section):
-            self.add_section(section)
+            self.add_section(section_name)
         self._sections[section].add(option, value_str)
+        self._option_name_map.setdefault((section, option), option_name)
         return self
 
     def rename_section(self, section: str, new_name: str) -> "GitConfigParser":
@@ -998,16 +1298,21 @@ def rename_section(self, section: str, new_name: str) -> "GitConfigParser":
         :return:
             This instance
         """
+        section = self._normalize_section_name(section)
+        self._assure_config_name_safe(new_name, "section")
+        new_section_name = _canonical_section_name(new_name)
+        new_name = self._normalize_section_name(new_section_name)
         if not self.has_section(section):
             raise ValueError("Source section '%s' doesn't exist" % section)
-        self._assure_config_name_safe(new_name, "section")
         if self.has_section(new_name):
             raise ValueError("Destination section '%s' already exists" % new_name)
 
-        super().add_section(new_name)
+        self._sections[new_name] = _GitConfigSectionData()
+        self._section_name_map[new_name] = new_section_name
         new_section = self._sections[new_name]
-        for k, vs in self.items_all(section):
-            new_section.setall(k, vs)
+        for option_key, values in self._sections[section].items_all():
+            new_section.setall(option_key, values)
+            self._option_name_map[(new_name, option_key)] = self._option_name_map.get((section, option_key), option_key)
         # END for each value to copy
 
         # This call writes back the changes, which is why we don't have the respective
diff --git a/git/objects/submodule/base.py b/git/objects/submodule/base.py
index 7984db340..0e90ec53b 100644
--- a/git/objects/submodule/base.py
+++ b/git/objects/submodule/base.py
@@ -4,6 +4,7 @@
 __all__ = ["Submodule", "UpdateProgress"]
 
 import gc
+from configparser import NoSectionError
 from io import BytesIO
 import logging
 import os
@@ -16,7 +17,7 @@
 import git
 from git.cmd import Git
 from git.compat import defenc
-from git.config import GitConfigParser, SectionConstraint, cp
+from git.config import GitConfigParser, SectionConstraint
 from git.exc import (
     BadName,
     InvalidGitRepositoryError,
@@ -172,7 +173,7 @@ def _set_cache_(self, attr: str) -> None:
             # Default submodule values.
             try:
                 self.path = reader.get("path")
-            except cp.NoSectionError as e:
+            except NoSectionError as e:
                 if self.repo.working_tree_dir is not None:
                     raise ValueError(
                         "This submodule instance does not exist anymore in '%s' file"
@@ -1503,7 +1504,7 @@ def exists(self) -> bool:
                 if hasattr(self, attr):
                     loc[attr] = getattr(self, attr)
                 # END if we have the attribute cache
-            except (cp.NoSectionError, ValueError):
+            except (NoSectionError, ValueError):
                 # On PY3, this can happen apparently... don't know why this doesn't
                 # happen on PY2.
                 pass
diff --git a/git/objects/submodule/util.py b/git/objects/submodule/util.py
index c021510d8..50c3fdb89 100644
--- a/git/objects/submodule/util.py
+++ b/git/objects/submodule/util.py
@@ -110,7 +110,7 @@ def flush_to_index(self) -> None:
     # } END interface
 
     # { Overridden Methods
-    def write(self) -> None:  # type: ignore[override]
+    def write(self) -> None:
         rval: None = super().write()
         self.flush_to_index()
         return rval
diff --git a/git/remote.py b/git/remote.py
index 0c3dbfe15..79850ab11 100644
--- a/git/remote.py
+++ b/git/remote.py
@@ -8,12 +8,13 @@
 __all__ = ["RemoteProgress", "PushInfo", "FetchInfo", "Remote"]
 
 import contextlib
+from configparser import NoOptionError, NoSectionError
 import logging
 import re
 
 from git.cmd import Git, handle_process_output
 from git.compat import defenc, force_text
-from git.config import GitConfigParser, SectionConstraint, cp
+from git.config import GitConfigParser, SectionConstraint
 from git.exc import GitCommandError
 from git.refs import Head, Reference, RemoteReference, SymbolicReference, TagReference
 from git.util import (
@@ -577,7 +578,7 @@ def __getattr__(self, attr: str) -> Any:
         # though a slot of the same name exists.
         try:
             return self._config_reader.get(attr)
-        except cp.NoOptionError:
+        except NoOptionError:
             return super().__getattr__(attr)
         # END handle exception
 
@@ -619,10 +620,10 @@ def exists(self) -> bool:
         try:
             self.config_reader.get("url")
             return True
-        except cp.NoOptionError:
+        except NoOptionError:
             # We have the section at least...
             return True
-        except cp.NoSectionError:
+        except NoSectionError:
             return False
 
     @classmethod
diff --git a/test/fixtures/git_config b/test/fixtures/git_config
index a8cad56e8..904946288 100644
--- a/test/fixtures/git_config
+++ b/test/fixtures/git_config
@@ -22,8 +22,7 @@
 	url = git://gitorious.org/~martin.marcher/git-python/serverhorror.git
 	fetch = +refs/heads/*:refs/remotes/MartinMarcher/*
     # can handle comments - the section name is supposed to be stripped
-# causes stock git-config puke
-[  gui ]
+[gui]
 	geometry = 1316x820+219+243 207 192
 [branch "mainline_performance"]
 	remote = mainline
@@ -43,4 +42,3 @@
 # inclusions should be processed immediately
 [sec]
     var1 = value1_main
-
diff --git a/test/fixtures/git_config_multiple b/test/fixtures/git_config_multiple
index 03a975680..0c5c71ca2 100644
--- a/test/fixtures/git_config_multiple
+++ b/test/fixtures/git_config_multiple
@@ -4,4 +4,4 @@
 [section1]
     option1 = value1a
     option1 = value1b
-    other_option1 = other_value1
+    other-option1 = other_value1
diff --git a/test/fixtures/git_config_with_quotes_escapes b/test/fixtures/git_config_with_quotes_escapes
index 33332c221..c67c68bc7 100644
--- a/test/fixtures/git_config_with_quotes_escapes
+++ b/test/fixtures/git_config_with_quotes_escapes
@@ -3,7 +3,5 @@
   hasbackslash = "foo\\bar"
   hasquote = "ab\"cd"
   hastrailingbackslash = "word\\"
-  hasunrecognized = "p\qrs"
-  hasunescapedquotes = "ab"cd"e"
   ordinary = "hello world"
   unquoted = good evening
diff --git a/test/test_config.py b/test/test_config.py
index 361a51fa9..279f6b454 100644
--- a/test/test_config.py
+++ b/test/test_config.py
@@ -4,6 +4,7 @@
 # 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
 
 import glob
+import configparser as cp
 import io
 import os
 import os.path as osp
@@ -12,8 +13,8 @@
 
 import pytest
 
-from git import GitConfigParser
-from git.config import _OMD, cp
+from git import Git, GitConfigParser
+from git.config import _escape_config_value, _escape_section_subsection
 from git.util import rmfile
 
 from test.lib import SkipTest, TestCase, fixture_path, with_rw_directory
@@ -66,7 +67,7 @@ def test_read_write(self):
                 assert w_config._lock._has_lock()
 
                 # Changes should be written right away.
-                sname = "my_section"
+                sname = "my-section"
                 oname = "mykey"
                 val = "myvalue"
                 w_config.add_section(sname)
@@ -75,8 +76,8 @@ def test_read_write(self):
                 assert w_config.has_option(sname, oname)
                 assert w_config.get(sname, oname) == val
 
-                sname_new = "new_section"
-                oname_new = "new_key"
+                sname_new = "new-section"
+                oname_new = "new-key"
                 ival = 10
                 w_config.set_value(sname_new, oname_new, ival)
                 assert w_config.get_value(sname_new, oname_new) == ival
@@ -107,10 +108,10 @@ def test_lock_reentry(self, rw_dir):
         fpl = osp.join(rw_dir, "l")
         gcp = GitConfigParser(fpl, read_only=False)
         with gcp as cw:
-            cw.set_value("include", "some_value", "a")
+            cw.set_value("include", "some-value", "a")
         # Entering again locks the file again...
         with gcp as cw:
-            cw.set_value("include", "some_other_value", "b")
+            cw.set_value("include", "some-other-value", "b")
             # ...so creating an additional config writer must fail due to exclusive
             # access.
             with self.assertRaises(IOError):
@@ -142,25 +143,160 @@ def test_multi_line_config(self):
             )
             self.assertEqual(len(config.sections()), 23)
 
-    def test_config_value_with_trailing_new_line(self):
+    def test_config_rejects_colon_delimiter_and_unterminated_quote(self):
         config_content = b'[section-header]\nkey:"value\n"'
         config_file = io.BytesIO(config_content)
         config_file.name = "multiline_value.config"
 
         git_config = GitConfigParser(config_file)
-        git_config.read()  # This should not throw an exception
+        with pytest.raises(cp.ParsingError):
+            git_config.read()
+
+    def test_git_parser_handles_stream_syntax_comments_and_continuations(self):
+        config_file = io.BytesIO(
+            b"\xef\xbb\xbf; comment\r\n[Core] [other]\r\nenabled\r\npath = one\\\r\n two # trailing comment\r\n"
+        )
+        config_file.name = "git-syntax.config"
+
+        git_config = GitConfigParser(config_file)
+        self.assertEqual(git_config.sections(), ["Core", "other"])
+        self.assertTrue(git_config.has_section("CORE"))
+        self.assertIs(git_config.get_value("other", "enabled"), True)
+        self.assertEqual(git_config.get_value("other", "path"), "one two")
+
+    @with_rw_directory
+    def test_section_and_option_case_match_git(self, rw_dir):
+        config_path = osp.join(rw_dir, "config")
+        with open(config_path, "wb") as config_file:
+            config_file.write(b'[CoRe]\n\tMixedOption = "one"\n[Remote "Origin"]\n\tFetchURL = "example"\n')
+
+        with GitConfigParser(config_path, read_only=False) as git_config:
+            git_config.set_value("CORE", "MIXEDOPTION", "two")
+            git_config.set_value("core", "NewOption", "new")
+
+            self.assertEqual(git_config.sections(), ["CoRe", 'Remote "Origin"'])
+            self.assertEqual(git_config.get_value("cOrE", "mixedOPTION"), "two")
+            self.assertEqual(git_config.get_values("CORE", "MixedOption"), ["two"])
+            self.assertEqual(git_config.options("CORE"), ["MixedOption", "NewOption"])
+            self.assertEqual(git_config.items("CORE"), [("MixedOption", "two"), ("NewOption", "new")])
+            self.assertEqual(git_config.items_all("CORE"), [("MixedOption", ["two"]), ("NewOption", ["new"])])
+            core = git_config["CORE"]
+            self.assertEqual(core.name, "CoRe")
+            self.assertEqual(list(core), ["MixedOption", "NewOption"])
+            self.assertEqual(list(core.items()), [("MixedOption", "two"), ("NewOption", "new")])
+            self.assertEqual(core["MixedOption"], "two")
+            self.assertEqual(list(git_config), ["CoRe", 'Remote "Origin"'])
+            self.assertTrue(git_config.has_option("CORE", "MixedOption"))
+            self.assertTrue(git_config.has_section('REMOTE "Origin"'))
+            self.assertFalse(git_config.has_section('remote "origin"'))
+
+        with open(config_path, "rb") as config_file:
+            self.assertEqual(
+                config_file.read(),
+                b'[CoRe]\n\tMixedOption = "two"\n\tNewOption = "new"\n[Remote "Origin"]\n\tFetchURL = "example"\n',
+            )
+
+        with GitConfigParser(config_path, read_only=False) as git_config:
+            git_config.rename_section('REMOTE "Origin"', 'Branch "Origin"')
+            self.assertEqual(git_config.get_value('BRANCH "Origin"', "fetchurl"), "example")
+            self.assertEqual(git_config.sections(), ["CoRe", 'Branch "Origin"'])
+            self.assertEqual(git_config.options('branch "Origin"'), ["FetchURL"])
+            self.assertEqual(git_config['branch "Origin"'].name, 'Branch "Origin"')
+
+        with open(config_path, "rb") as config_file:
+            self.assertEqual(
+                config_file.read(),
+                b'[CoRe]\n\tMixedOption = "two"\n\tNewOption = "new"\n[Branch "Origin"]\n\tFetchURL = "example"\n',
+            )
+
+        with GitConfigParser(config_path, read_only=True) as git_config:
+            self.assertEqual(git_config.get_value("CORE", "MIXEDOPTION"), "two")
+            self.assertEqual(git_config.get_value('branch "Origin"', "FETCHURL"), "example")
+
+    def test_git_parser_rejects_syntax_rejected_by_git(self):
+        invalid_configs = (
+            b"[  gui]\nkey = value\n",
+            b"[core]\nbad_key = value\n",
+            b"[core]\nkey: value\n",
+            b'[core]\nkey = "unterminated\n',
+            b'[core]\nkey = "bad\\q"\n',
+            b'[core]\nkey = "bad\x00value"\n',
+        )
+        for config_content in invalid_configs:
+            with self.subTest(config_content=config_content):
+                config_file = io.BytesIO(config_content)
+                config_file.name = "invalid-git-syntax.config"
+
+                with pytest.raises(cp.ParsingError):
+                    GitConfigParser(config_file).read()
+
+    @with_rw_directory
+    def test_git_parser_and_canonical_writer_round_trip(self, rw_dir):
+        config_path = osp.join(rw_dir, "config")
+        section = 'submodule "docs]archive"'
+        value = ' leading #; "quoted" \\ tail\nsecond\tcolumn\b'
+        with open(config_path, "wb") as config_file:
+            config_file.write(
+                b'[submodule "docs]archive"]\npayload = " leading #; \\"quoted\\" \\\\ tail\\nsecond\\tcolumn\\b"\n'
+            )
+
+        with GitConfigParser(config_path, read_only=False) as git_config:
+            self.assertEqual(git_config.get_value(section, "payload"), value)
+            git_config.set_value(section, "other", "x#;y")
+
+        with GitConfigParser(config_path, read_only=True) as git_config:
+            self.assertEqual(git_config.get_value(section, "payload"), value)
+            self.assertEqual(git_config.get_value(section, "other"), "x#;y")
+
+        with open(config_path, "rb") as config_file:
+            self.assertEqual(
+                config_file.read(),
+                b'[submodule "docs]archive"]\n'
+                b'\tpayload = " leading #; \\"quoted\\" \\\\ tail\\nsecond\\tcolumn\\b"\n'
+                b'\tother = "x#;y"\n',
+            )
+
+        self.assertEqual(Git().config("--file", config_path, "--get", "submodule.docs]archive.payload"), value)
+
+    @with_rw_directory
+    def test_writer_rejects_names_outside_git_grammar(self, rw_dir):
+        config_path = osp.join(rw_dir, "config")
+        with GitConfigParser(config_path, read_only=False) as git_config:
+            git_config.add_section("core")
+            for option in ("bad_option", "-bad", "bad.option"):
+                with self.subTest(option=option), pytest.raises(ValueError, match="option names"):
+                    git_config.set_value("core", option, "value")
+
+            for section in (" gui", "user trailing", "user] [other"):
+                with self.subTest(section=section), pytest.raises(ValueError, match="section name"):
+                    git_config.add_section(section)
 
     @with_rw_directory
-    def test_set_value_rejects_config_injection(self, rw_dir):
+    def test_writer_escapes_quoted_subsection_names(self, rw_dir):
+        config_path = osp.join(rw_dir, "config")
+        section = 'submodule "docs\\"archive\\\\part]"'
+        with GitConfigParser(config_path, read_only=False) as git_config:
+            git_config.set_value(section, "path", "docs")
+
+        with open(config_path, "rb") as config_file:
+            self.assertEqual(config_file.read(), b'[submodule "docs\\"archive\\\\part]"]\n\tpath = "docs"\n')
+
+        with GitConfigParser(config_path, read_only=True) as git_config:
+            self.assertEqual(git_config.sections(), [section])
+            self.assertEqual(git_config.get_value(section, "path"), "docs")
+
+        self.assertEqual(Git().config("--file", config_path, "--get", 'submodule.docs"archive\\part].path'), "docs")
+
+    @with_rw_directory
+    def test_set_value_escapes_config_injection(self, rw_dir):
         config_path = osp.join(rw_dir, "config")
         payload = "foo\n[core]\nhooksPath=/tmp/hooks"
 
         with GitConfigParser(config_path, read_only=False) as git_config:
-            with pytest.raises(ValueError, match="CR, LF, or NUL"):
-                git_config.set_value("user", "name", payload)
+            git_config.set_value("user", "name", payload)
 
         with GitConfigParser(config_path, read_only=True) as git_config:
-            self.assertFalse(git_config.has_section("user"))
+            self.assertEqual(git_config.get_value("user", "name"), payload)
             self.assertFalse(git_config.has_section("core"))
 
     @with_rw_directory
@@ -197,13 +333,7 @@ def test_set_value_rejects_unsafe_section_and_option_names(self, rw_dir):
     @with_rw_directory
     def test_writer_rejects_unquoted_section_terminators(self, rw_dir):
         config_path = osp.join(rw_dir, "config")
-        bad_sections = (
-            "user] [other",
-            'user"] [other"',
-            'submodule "docs"] [other',
-            'submodule "docs] [other',
-            'submodule "docs] [other\\',
-        )
+        bad_sections = ("user] [other", 'submodule "docs"] [other')
         safe_section = 'submodule "docs]archive"'
 
         with GitConfigParser(config_path, read_only=False) as git_config:
@@ -242,24 +372,26 @@ def test_writer_rejects_unquoted_section_terminators(self, rw_dir):
             self.assertFalse(git_config.has_section("other"), "an unsafe section name injected an [other] section")
 
     @with_rw_directory
-    def test_set_and_add_value_reject_unsafe_value_characters(self, rw_dir):
+    def test_set_and_add_value_match_git_control_character_handling(self, rw_dir):
         config_path = osp.join(rw_dir, "config")
-        bad_values = ("foo\rbar", "foo\nbar", "foo\x00bar", b"foo\nbar")
 
         with GitConfigParser(config_path, read_only=False) as git_config:
             git_config.add_section("user")
-            for bad_value in bad_values:
-                with pytest.raises(ValueError, match="CR, LF, or NUL"):
-                    git_config.set("user", "name", bad_value)
-                with pytest.raises(ValueError, match="CR, LF, or NUL"):
-                    git_config.set_value("user", "name", bad_value)
-                with pytest.raises(ValueError, match="CR, LF, or NUL"):
-                    git_config.add_value("user", "name", bad_value)
+            git_config.set("user", "carriage-return", "foo\rbar")
+            git_config.set_value("user", "line-feed", "foo\nbar")
+            git_config.add_value("user", "bytes-line-feed", b"foo\nbar")
 
-            git_config.set_value("user", "name", "safe")
+            for setter in (git_config.set, git_config.set_value, git_config.add_value):
+                with pytest.raises(ValueError, match="must not contain NUL"):
+                    setter("user", "name", "foo\x00bar")
 
         with GitConfigParser(config_path, read_only=True) as git_config:
-            self.assertEqual(git_config.get_value("user", "name"), "safe")
+            self.assertEqual(git_config.get_value("user", "carriage-return"), "foo\rbar")
+            self.assertEqual(git_config.get_value("user", "line-feed"), "foo\nbar")
+            self.assertEqual(git_config.get_value("user", "bytes-line-feed"), "foo\nbar")
+
+        self.assertEqual(Git().config("--file", config_path, "--get", "user.carriage-return"), "foo\rbar")
+        self.assertEqual(Git().config("--file", config_path, "--get", "user.line-feed"), "foo\nbar")
 
     def test_base(self):
         path_repo = fixture_path("git_config")
@@ -317,19 +449,19 @@ def check_test_value(cr, value):
 
             fpb = osp.join(rw_dir, "b")
             fpc = osp.join(rw_dir, "c")
-            cw.set_value("include", "relative_path_b", "b")
+            cw.set_value("include", "relative-path-b", "b")
             cw.set_value("include", "doesntexist", "foobar")
-            cw.set_value("include", "relative_cycle_a_a", "a")
-            cw.set_value("include", "absolute_cycle_a_a", fpa)
+            cw.set_value("include", "relative-cycle-a-a", "a")
+            cw.set_value("include", "absolute-cycle-a-a", fpa)
         assert osp.exists(fpa)
 
         # PREPARE CONFIG FILE B
         with GitConfigParser(fpb, read_only=False) as cw:
             write_test_value(cw, "b")
-            cw.set_value("include", "relative_cycle_b_a", "a")
-            cw.set_value("include", "absolute_cycle_b_a", fpa)
-            cw.set_value("include", "relative_path_c", "c")
-            cw.set_value("include", "absolute_path_c", fpc)
+            cw.set_value("include", "relative-cycle-b-a", "a")
+            cw.set_value("include", "absolute-cycle-b-a", fpa)
+            cw.set_value("include", "relative-path-c", "c")
+            cw.set_value("include", "absolute-path-c", fpc)
 
         # PREPARE CONFIG FILE C
         with GitConfigParser(fpc, read_only=False) as cw:
@@ -385,8 +517,8 @@ def test_multiple_include_paths_with_same_key(self, rw_dir):
                 path = file1
                 path = file2
 
-        Previously only one of these was included because _OMD.items() returns
-        only the last value for each key.
+        Previously only one of these was included because the old INI-backed storage
+        exposed only the last value for each key.
         """
         # Create two config files to be included.
         fp_inc1 = osp.join(rw_dir, "inc1.cfg")
@@ -403,8 +535,8 @@ def test_multiple_include_paths_with_same_key(self, rw_dir):
         # We write it manually because set_value would overwrite the key.
         with open(fp_main, "w") as f:
             f.write("[include]\n")
-            f.write(f"\tpath = {fp_inc1}\n")
-            f.write(f"\tpath = {fp_inc2}\n")
+            f.write(f"\tpath = {_escape_config_value(fp_inc1)}\n")
+            f.write(f"\tpath = {_escape_config_value(fp_inc2)}\n")
 
         with GitConfigParser(fp_main, read_only=True) as cr:
             # Both included files should be loaded.
@@ -430,8 +562,15 @@ def test_conditional_includes_from_git_dir(self, rw_dir):
         path2 = osp.join(rw_dir, "config2")
         template = '[includeIf "{}:{}"]\n    path={}\n'
 
+        def include_config(condition, pattern):
+            return template.format(
+                condition,
+                _escape_section_subsection(pattern),
+                _escape_config_value(path2),
+            )
+
         with open(path1, "w") as stream:
-            stream.write(template.format("gitdir", git_dir, path2))
+            stream.write(include_config("gitdir", git_dir))
 
         # Ensure that config is ignored if no repo is set.
         with GitConfigParser(path1) as config:
@@ -445,7 +584,7 @@ def test_conditional_includes_from_git_dir(self, rw_dir):
 
         # Ensure that config is ignored if case is incorrect.
         with open(path1, "w") as stream:
-            stream.write(template.format("gitdir", git_dir.upper(), path2))
+            stream.write(include_config("gitdir", git_dir.upper()))
 
         with GitConfigParser(path1, repo=repo) as config:
             assert not config._has_includes()
@@ -453,7 +592,7 @@ def test_conditional_includes_from_git_dir(self, rw_dir):
 
         # Ensure that config is included if case is ignored.
         with open(path1, "w") as stream:
-            stream.write(template.format("gitdir/i", git_dir.upper(), path2))
+            stream.write(include_config("gitdir/i", git_dir.upper()))
 
         with GitConfigParser(path1, repo=repo) as config:
             assert config._has_includes()
@@ -461,7 +600,7 @@ def test_conditional_includes_from_git_dir(self, rw_dir):
 
         # Ensure that config is included with path using glob pattern.
         with open(path1, "w") as stream:
-            stream.write(template.format("gitdir", "**/repo1", path2))
+            stream.write(include_config("gitdir", "**/repo1"))
 
         with GitConfigParser(path1, repo=repo) as config:
             assert config._has_includes()
@@ -469,7 +608,7 @@ def test_conditional_includes_from_git_dir(self, rw_dir):
 
         # Ensure that config is ignored if path is not matching git_dir.
         with open(path1, "w") as stream:
-            stream.write(template.format("gitdir", "incorrect", path2))
+            stream.write(include_config("gitdir", "incorrect"))
 
         with GitConfigParser(path1, repo=repo) as config:
             assert not config._has_includes()
@@ -477,7 +616,7 @@ def test_conditional_includes_from_git_dir(self, rw_dir):
 
         # Ensure that config is included if path in hierarchy.
         with open(path1, "w") as stream:
-            stream.write(template.format("gitdir", "target1/", path2))
+            stream.write(include_config("gitdir", "target1/"))
 
         with GitConfigParser(path1, repo=repo) as config:
             assert config._has_includes()
@@ -499,7 +638,7 @@ def test_conditional_includes_from_branch_name(self, rw_dir):
 
         # Ensure that config is included is branch is correct.
         with open(path1, "w") as stream:
-            stream.write(template.format("/foo/branch", path2))
+            stream.write(template.format("/foo/branch", _escape_config_value(path2)))
 
         with GitConfigParser(path1, repo=repo) as config:
             assert config._has_includes()
@@ -507,7 +646,7 @@ def test_conditional_includes_from_branch_name(self, rw_dir):
 
         # Ensure that config is included is branch is incorrect.
         with open(path1, "w") as stream:
-            stream.write(template.format("incorrect", path2))
+            stream.write(template.format("incorrect", _escape_config_value(path2)))
 
         with GitConfigParser(path1, repo=repo) as config:
             assert not config._has_includes()
@@ -515,7 +654,7 @@ def test_conditional_includes_from_branch_name(self, rw_dir):
 
         # Ensure that config is included with branch using glob pattern.
         with open(path1, "w") as stream:
-            stream.write(template.format("/foo/**", path2))
+            stream.write(template.format("/foo/**", _escape_config_value(path2)))
 
         with GitConfigParser(path1, repo=repo) as config:
             assert config._has_includes()
@@ -551,7 +690,7 @@ def test_conditional_includes_remote_url(self, rw_dir):
 
         # Ensure that config with hasconfig and full url is correct.
         with open(path1, "w") as stream:
-            stream.write(template.format("https://github.com/foo/repo", path2))
+            stream.write(template.format("https://github.com/foo/repo", _escape_config_value(path2)))
 
         with GitConfigParser(path1, repo=repo) as config:
             assert config._has_includes()
@@ -559,7 +698,7 @@ def test_conditional_includes_remote_url(self, rw_dir):
 
         # Ensure that config with hasconfig and incorrect url is incorrect.
         with open(path1, "w") as stream:
-            stream.write(template.format("incorrect", path2))
+            stream.write(template.format("incorrect", _escape_config_value(path2)))
 
         with GitConfigParser(path1, repo=repo) as config:
             assert not config._has_includes()
@@ -567,7 +706,7 @@ def test_conditional_includes_remote_url(self, rw_dir):
 
         # Ensure that config with hasconfig and url using glob pattern is correct.
         with open(path1, "w") as stream:
-            stream.write(template.format("**/**github.com*/**", path2))
+            stream.write(template.format("**/**github.com*/**", _escape_config_value(path2)))
 
         with GitConfigParser(path1, repo=repo) as config:
             assert config._has_includes()
@@ -607,8 +746,7 @@ def test_empty_config_value(self):
 
         assert cr.get_value("core", "filemode"), "Should read keys with values"
 
-        with self.assertRaises(cp.NoOptionError):
-            cr.get_value("color", "ui")
+        self.assertIs(cr.get_value("color", "ui"), True, "a valueless Git config entry means boolean true")
 
     def test_config_with_quotes(self):
         cr = GitConfigParser(fixture_path("git_config_with_quotes"), read_only=True)
@@ -629,18 +767,13 @@ def test_config_with_quotes_with_whitespace_outside_value(self):
         self.assertEqual(cr.get("init", "defaultBranch"), "trunk")
 
     def test_config_with_quotes_containing_escapes(self):
-        """For now just suppress quote removal. But it would be good to interpret most of these."""
+        """Interpret the quoted-value escapes supported by Git."""
         cr = GitConfigParser(fixture_path("git_config_with_quotes_escapes"), read_only=True)
 
-        # These can eventually be supported by substituting the represented character.
-        self.assertEqual(cr.get("custom", "hasnewline"), R'"first\nsecond"')
-        self.assertEqual(cr.get("custom", "hasbackslash"), R'"foo\\bar"')
-        self.assertEqual(cr.get("custom", "hasquote"), R'"ab\"cd"')
-        self.assertEqual(cr.get("custom", "hastrailingbackslash"), R'"word\\"')
-        self.assertEqual(cr.get("custom", "hasunrecognized"), R'"p\qrs"')
-
-        # It is less obvious whether and what to eventually do with this.
-        self.assertEqual(cr.get("custom", "hasunescapedquotes"), '"ab"cd"e"')
+        self.assertEqual(cr.get("custom", "hasnewline"), "first\nsecond")
+        self.assertEqual(cr.get("custom", "hasbackslash"), R"foo\bar")
+        self.assertEqual(cr.get("custom", "hasquote"), 'ab"cd')
+        self.assertEqual(cr.get("custom", "hastrailingbackslash"), "word\\")
 
         # Cases where quote removal is clearly safe should happen even after those.
         self.assertEqual(cr.get("custom", "ordinary"), "hello world")
@@ -657,7 +790,7 @@ def test_get_values_works_without_requiring_any_other_calls_first(self):
         self.assertEqual(cr.get_values("section1", "option1"), ["value1a", "value1b"])
         file_obj.seek(0)
         cr = GitConfigParser(file_obj, read_only=True)
-        self.assertEqual(cr.get_values("section1", "other_option1"), ["other_value1"])
+        self.assertEqual(cr.get_values("section1", "other-option1"), ["other_value1"])
 
     def test_multiple_values(self):
         file_obj = self._to_memcache(fixture_path("git_config_multiple"))
@@ -671,13 +804,13 @@ def test_multiple_values(self):
             self.assertEqual(cw.get_values("section1", "option1"), ["value1a", "value1b"])
             self.assertEqual(
                 cw.items("section1"),
-                [("option1", "value1b"), ("other_option1", "other_value1")],
+                [("option1", "value1b"), ("other-option1", "other_value1")],
             )
             self.assertEqual(
                 cw.items_all("section1"),
                 [
                     ("option1", ["value1a", "value1b"]),
-                    ("other_option1", ["other_value1"]),
+                    ("other-option1", ["other_value1"]),
                 ],
             )
             with self.assertRaises(KeyError):
@@ -697,13 +830,13 @@ def test_multiple_values_rename(self):
             self.assertEqual(cr.get_values("section2", "option1"), ["value1a", "value1b"])
             self.assertEqual(
                 cr.items("section2"),
-                [("option1", "value1b"), ("other_option1", "other_value1")],
+                [("option1", "value1b"), ("other-option1", "other_value1")],
             )
             self.assertEqual(
                 cr.items_all("section2"),
                 [
                     ("option1", ["value1a", "value1b"]),
-                    ("other_option1", ["other_value1"]),
+                    ("other-option1", ["other_value1"]),
                 ],
             )
 
@@ -719,37 +852,37 @@ def test_multiple_to_single(self):
             self.assertEqual(cr.get_values("section1", "option1"), ["value1c"])
             self.assertEqual(
                 cr.items("section1"),
-                [("option1", "value1c"), ("other_option1", "other_value1")],
+                [("option1", "value1c"), ("other-option1", "other_value1")],
             )
             self.assertEqual(
                 cr.items_all("section1"),
-                [("option1", ["value1c"]), ("other_option1", ["other_value1"])],
+                [("option1", ["value1c"]), ("other-option1", ["other_value1"])],
             )
 
     def test_single_to_multiple(self):
         file_obj = self._to_memcache(fixture_path("git_config_multiple"))
         with GitConfigParser(file_obj, read_only=False) as cw:
-            cw.add_value("section1", "other_option1", "other_value1a")
+            cw.add_value("section1", "other-option1", "other_value1a")
 
             cw.write()
             file_obj.seek(0)
             cr = GitConfigParser(file_obj, read_only=True)
             self.assertEqual(cr.get_value("section1", "option1"), "value1b")
             self.assertEqual(cr.get_values("section1", "option1"), ["value1a", "value1b"])
-            self.assertEqual(cr.get_value("section1", "other_option1"), "other_value1a")
+            self.assertEqual(cr.get_value("section1", "other-option1"), "other_value1a")
             self.assertEqual(
-                cr.get_values("section1", "other_option1"),
+                cr.get_values("section1", "other-option1"),
                 ["other_value1", "other_value1a"],
             )
             self.assertEqual(
                 cr.items("section1"),
-                [("option1", "value1b"), ("other_option1", "other_value1a")],
+                [("option1", "value1b"), ("other-option1", "other_value1a")],
             )
             self.assertEqual(
                 cr.items_all("section1"),
                 [
                     ("option1", ["value1a", "value1b"]),
-                    ("other_option1", ["other_value1", "other_value1a"]),
+                    ("other-option1", ["other_value1", "other_value1a"]),
                 ],
             )
 
@@ -764,22 +897,43 @@ def test_add_to_multiple(self):
             self.assertEqual(cr.get_values("section1", "option1"), ["value1a", "value1b", "value1c"])
             self.assertEqual(
                 cr.items("section1"),
-                [("option1", "value1c"), ("other_option1", "other_value1")],
+                [("option1", "value1c"), ("other-option1", "other_value1")],
             )
             self.assertEqual(
                 cr.items_all("section1"),
                 [
                     ("option1", ["value1a", "value1b", "value1c"]),
-                    ("other_option1", ["other_value1"]),
+                    ("other-option1", ["other_value1"]),
                 ],
             )
 
-    def test_setlast(self):
-        # Test directly, not covered by higher-level tests.
-        omd = _OMD()
-        omd.setlast("key", "value1")
-        self.assertEqual(omd["key"], "value1")
-        self.assertEqual(omd.getall("key"), ["value1"])
-        omd.setlast("key", "value2")
-        self.assertEqual(omd["key"], "value2")
-        self.assertEqual(omd.getall("key"), ["value2"])
+    def test_parser_uses_git_native_storage(self):
+        self.assertFalse(issubclass(GitConfigParser, cp.RawConfigParser))
+
+    @with_rw_directory
+    def test_valueless_entries_remain_distinct_from_literal_true(self, rw_dir):
+        config_path = osp.join(rw_dir, "config")
+        with open(config_path, "wb") as config_file:
+            config_file.write(b'[Feature]\n\tImplicit\n\tExplicit = "true"\n')
+
+        with GitConfigParser(config_path, read_only=False) as git_config:
+            self.assertIs(git_config.get_value("feature", "implicit"), True)
+            self.assertIs(git_config.get_value("FEATURE", "EXPLICIT"), True)
+            git_config.set_value("feature", "Other", "value")
+
+        with open(config_path, "rb") as config_file:
+            self.assertEqual(
+                config_file.read(),
+                b'[Feature]\n\tImplicit\n\tExplicit = "true"\n\tOther = "value"\n',
+            )
+
+    def test_git_typed_accessors(self):
+        config_file = io.BytesIO(b"[values]\nsize = 2k\nratio = 1.5m\nyes = on\nno = 0\nimplicit\n")
+        config_file.name = "typed-values.config"
+        git_config = GitConfigParser(config_file)
+
+        self.assertEqual(git_config.getint("VALUES", "SIZE"), 2048)
+        self.assertEqual(git_config.getfloat("values", "ratio"), 1.5 * 1024**2)
+        self.assertIs(git_config.getboolean("values", "yes"), True)
+        self.assertIs(git_config.getboolean("values", "no"), False)
+        self.assertIs(git_config.getboolean("values", "implicit"), True)
diff --git a/test/test_submodule.py b/test/test_submodule.py
index 265ee2ffb..6922b0da6 100644
--- a/test/test_submodule.py
+++ b/test/test_submodule.py
@@ -2,6 +2,7 @@
 # 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
 
 import contextlib
+import configparser as cp
 import gc
 import os
 import os.path as osp
@@ -15,7 +16,7 @@
 
 import git
 from git.cmd import Git
-from git.config import GitConfigParser, cp
+from git.config import GitConfigParser
 from git.exc import (
     GitCommandError,
     InvalidGitRepositoryError,
@@ -987,10 +988,10 @@ def test_git_submodules_and_add_sm_with_new_commit(self, rwdir):
 
         parent.index.commit("moved submodules")
 
-        with sm.config_writer() as writer:
-            writer.set_value("user.email", "example@example.com")
-            writer.set_value("user.name", "me")
         smm = sm.module()
+        with smm.config_writer() as writer:
+            writer.set_value("user", "email", "example@example.com")
+            writer.set_value("user", "name", "me")
         fp = osp.join(smm.working_tree_dir, "empty-file")
         with open(fp, "w"):
             pass