diff --git a/src/pkg/dkms/BUILD.bazel b/src/pkg/dkms/BUILD.bazel
index 0a49699..8c1c857 100644
--- a/src/pkg/dkms/BUILD.bazel
+++ b/src/pkg/dkms/BUILD.bazel
@@ -12,15 +12,29 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-load("@io_bazel_rules_go//go:def.bzl", "go_library")
+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "dkms",
     srcs = [
-        "package.go",
+        "config.go",
         "module.go",
+        "package.go",
     ],
     importpath = "cos.googlesource.com/cos/tools.git/src/pkg/dkms",
     visibility = ["//visibility:public"],
-    deps = [],
+    deps = [
+        "//src/pkg/utils",
+    ],
+)
+
+go_test(
+    name = "dkms_test",
+    srcs = [
+        "config_test.go",
+    ],
+    embed = [":dkms"],
+    deps = [
+        "@com_github_google_go_cmp//cmp",
+    ],
 )
\ No newline at end of file
diff --git a/src/pkg/dkms/config.go b/src/pkg/dkms/config.go
new file mode 100644
index 0000000..1b43e9e
--- /dev/null
+++ b/src/pkg/dkms/config.go
@@ -0,0 +1,370 @@
+package dkms
+
+import (
+	"cos.googlesource.com/cos/tools.git/src/pkg/utils"
+	"fmt"
+	"os"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+// Config is the set of configurations for a DKMS package.
+// See ParseConfig for details on how to write a dkms.conf file to
+// populate these values.
+type Config struct {
+	// The name of the package.
+	PackageName string
+	// The version of the package.
+	PackageVersion string
+	// The make command which will be used to compile all of the
+	// modules in the package.
+	MakeCommand string
+	// A list of patches to apply to the package before it is built.
+	// This is constructed from the PATCH[#] and PATCH_MATCH[#] arrays
+	Patches string
+	// The list of Modules in the package.
+	Modules []Module
+	// The make command which will be used to clean the package when
+	// it is unbuilt or removed.
+	Clean string
+	// Whether or not the package should be automatically installed when
+	// the kernel is upgraded.
+	Autoinstall bool
+	// A list of packages which should be built before this one.
+	// Currently, this is only an annotation and does not affect the
+	// build order.
+	BuildDepends []string
+	// A regex which specifies the kernels for which this package can
+	// be built.
+	BuildExclusiveKernel string
+	// A regex which specifies which arches for which this package can
+	// be built.
+	BuildExclusiveArch string
+	// The name of a script to run after adding the package..
+	PostAdd string
+	// The name of a script to run after building the package.
+	PostBuild string
+	// The name of a script to run after installing the package.
+	PostInstall string
+	// The name of a script to run after removing the package.
+	PostRemove string
+	// The name of a script to run before building the package.
+	PreBuild string
+	// The name of a script to run before installing the package.
+	PreInstall string
+}
+
+// LoadConfig reads a dkms.conf file for a package and parses its contents.
+// See ParseConfig for more details.
+func LoadConfig(pkg *Package) (*Config, error) {
+	configPath := pkg.ConfigPath()
+	var contents []byte
+	var err error
+	contents, err = os.ReadFile(configPath)
+	if err != nil {
+		return nil, err
+	}
+
+	configText := string(contents)
+	config, err := ParseConfig(configText, pkg)
+	if err != nil {
+		return nil, err
+	}
+
+	return config, nil
+}
+
+// ParseConfig parses the contents of a dkms.conf file for a package,
+// applying defaults where required.
+//
+// The defaults are assigned as bash variables in a string which is
+// prepended to the contents of dkms.conf. The resulting script is then
+// sourced, and the shell variables after executing the script are
+// collected into a Config.
+func ParseConfig(contents string, pkg *Package) (*Config, error) {
+	trees := pkg.Trees
+	buildDir := pkg.BuildDir()
+
+	// To quote the original DKMS authors: 'This is really ugly, but a neat hack'.
+	// By declaring the array variables as arrays initially, bash will always
+	// treat them as arrays, even if a normal assignment happens to the variable
+	// later. Thus, a user can assign to them and read from them as if they were
+	// either arrays or normal variables in their dkms.conf, but we can always
+	// read their values as array elements.
+	defaults := map[string]string{
+		"module":                 pkg.Name,
+		"module_version":         pkg.Version,
+		"arch":                   pkg.Arch,
+		"build_id":               pkg.BuildId,
+		"kernelver":              pkg.KernelVersion,
+		"dkms_tree":              trees.Dkms,
+		"source_tree":            trees.Source,
+		"kernel_source_dir":      trees.Kernel,
+		"MAKE":                   fmt.Sprintf("( 'make -C %s M=%s' )", trees.Kernel, buildDir),
+		"MAKE_MATCH":             "( '.*' )",
+		"CLEAN":                  fmt.Sprintf("'make -C %s M=%s clean'", trees.Kernel, buildDir),
+		"PATCH":                  "( '' )",
+		"PATCH_MATCH":            "( '.*' )",
+		"BUILT_MODULE_NAME":      fmt.Sprintf("( %s )", pkg.Name),
+		"BUILT_MODULE_LOCATION":  "()",
+		"DEST_MODULE_NAME":       "()", // if this is still empty later, it will default to BUILT_MODULE_NAME
+		"DEST_MODULE_LOCATION":   "( /kernel/updates )",
+		"STRIP":                  "( yes )",
+		"BUILD_DEPENDS":          "()",
+		"PACKAGE_NAME":           pkg.Name,
+		"PACKAGE_VERSION":        pkg.Version,
+		"AUTOINSTALL":            "no",
+		"BUILD_EXCLUSIVE_KERNEL": ".*",
+		"BUILD_EXCLUSIVE_ARCH":   ".*",
+	}
+	var defaultsLines []string
+	for variable, value := range defaults {
+		defaultsLines = append(defaultsLines, fmt.Sprintf("%s=%s", variable, value))
+	}
+	sort.Strings(defaultsLines)
+	defaultsString := strings.Join(defaultsLines, "\n")
+
+	configString := strings.Join([]string{defaultsString, contents}, "\n")
+
+	vars, err := utils.SourceString(configString)
+	if err != nil {
+		return nil, err
+	}
+
+	// Get the MAKE command.
+	makeCommands := utils.ArrayElements(vars["MAKE"])
+	makeMatches := utils.ArrayElements(vars["MAKE_MATCH"])
+	makeCommand, err := matchMakeCommand(pkg.KernelVersion, makeCommands, makeMatches)
+	if err != nil {
+		return nil, fmt.Errorf("error while matching MAKE command: %v", err)
+	}
+
+	// Get the set of patches to apply.
+	patchLists := utils.ArrayElements(vars["PATCH"])
+	patchListMatches := utils.ArrayElements(vars["PATCH_MATCH"])
+	patches, err := matchPatchList(pkg.KernelVersion, patchLists, patchListMatches)
+	if err != nil {
+		return nil, fmt.Errorf("error while matching PATCH: %v", err)
+	}
+
+	// Get the list of build dependencies. These should be kept in the numerical order in
+	// which they appear in the BUILD_DEPENDS array.
+	buildDependsMap := utils.ArrayElements(vars["BUILD_DEPENDS"])
+	var buildDependsKeys []string
+	buildDepends := []string{}
+	for key := range buildDependsMap {
+		buildDependsKeys = append(buildDependsKeys, key)
+	}
+	err = sortStringsAsInts(buildDependsKeys)
+	if err != nil {
+		return nil, fmt.Errorf("error while sorting BUILD_DEPENDS keys: %v", err)
+	}
+	for _, key := range buildDependsKeys {
+		buildDepends = append(buildDepends, buildDependsMap[key])
+	}
+
+	// Get the list of modules.
+	builtModuleNames := utils.ArrayElements(vars["BUILT_MODULE_NAME"])
+	builtModuleLocations := utils.ArrayElements(vars["BUILT_MODULE_LOCATION"])
+	destModuleNames := utils.ArrayElements(vars["DEST_MODULE_NAME"])
+	destModuleLocations := utils.ArrayElements(vars["DEST_MODULE_LOCATION"])
+	strips := utils.ArrayElements(vars["STRIP"])
+	modules, err := collateModules(pkg, builtModuleNames, builtModuleLocations, destModuleNames, destModuleLocations, strips)
+	if err != nil {
+		return nil, fmt.Errorf("error while collecting modules from config: %v", err)
+	}
+
+	autoinstall := vars["AUTOINSTALL"] == "yes"
+
+	config := Config{
+		PackageName:          vars["PACKAGE_NAME"],
+		PackageVersion:       vars["PACKAGE_VERSION"],
+		MakeCommand:          makeCommand,
+		Patches:              patches,
+		Modules:              modules,
+		Clean:                vars["CLEAN"],
+		Autoinstall:          autoinstall,
+		BuildDepends:         buildDepends,
+		BuildExclusiveKernel: vars["BUILD_EXCLUSIVE_KERNEL"],
+		BuildExclusiveArch:   vars["BUILD_EXCLUSIVE_ARCH"],
+		PostAdd:              vars["POST_ADD"],
+		PostBuild:            vars["POST_BUILD"],
+		PostInstall:          vars["POST_INSTALL"],
+		PostRemove:           vars["POST_REMOVE"],
+		PreBuild:             vars["PRE_BUILD"],
+		PreInstall:           vars["PRE_INSTALL"],
+	}
+	return &config, nil
+}
+
+// matchMakeCommand returns the first make command in numerical order which matches
+// the provided kernel version.
+func matchMakeCommand(kernelVersion string, makeCommands, makeMatches map[string]string) (string, error) {
+	if len(makeCommands) == 1 && len(makeMatches) == 0 {
+		// return the first make command since there is only one
+		for _, makeCommand := range makeCommands {
+			return makeCommand, nil
+		}
+	}
+
+	key, err := firstMatchingKey(kernelVersion, makeMatches)
+	if err != nil {
+		return "", fmt.Errorf("error while trying to match make commands to kernel version: %v", err)
+	}
+
+	makeCommand, ok := makeCommands[key]
+	if !ok {
+		return "", fmt.Errorf("kernelver matched MAKE_MATCH[%s], but no corresponding MAKE found", key)
+	}
+
+	return makeCommand, nil
+}
+
+// matchPatchList returns the first patch list in numerical order which matches
+// the provided kernel version.
+func matchPatchList(kernelVersion string, patchLists, patchListMatches map[string]string) (string, error) {
+	if len(patchLists) == 1 && len(patchListMatches) == 0 {
+		// return the first patch list since there is only one
+		for _, patchList := range patchLists {
+			return patchList, nil
+		}
+	}
+
+	key, err := firstMatchingKey(kernelVersion, patchListMatches)
+	if err != nil {
+		return "", fmt.Errorf("error while trying to match patch lists to kernel version: %v", err)
+	}
+
+	patches, ok := patchLists[key]
+	if !ok {
+		return "", fmt.Errorf("kernelver matched PATCH_MATCH[%s], but no corresponding PATCH found", key)
+	}
+
+	return patches, nil
+}
+
+// firstMatchingKey takes a mapping from keys to patterns and returns the first key
+// in ascending numerical order whose corresponding pattern matches a target string.
+// Errors if any key cannot be converted to an integer or if any of the patterns
+// cannot be compiled as a regexp.
+func firstMatchingKey(text string, patterns map[string]string) (string, error) {
+	var keys []string
+	for key := range patterns {
+		keys = append(keys, key)
+	}
+	err := sortStringsAsInts(keys)
+	if err != nil {
+		return "", fmt.Errorf("invalid keys in patterns array: %v", err)
+	}
+
+	var regexes []*regexp.Regexp
+	for _, key := range keys {
+		pattern := patterns[key]
+		regex, err := regexp.Compile(pattern)
+		if err != nil {
+			return "", fmt.Errorf("could not compile regexp %s for key %s", pattern, key)
+		}
+		regexes = append(regexes, regex)
+	}
+
+	for i, key := range keys {
+		if regexes[i].MatchString(text) {
+			return key, nil
+		}
+	}
+
+	return "", fmt.Errorf("no matching patterns found for text %s", text)
+}
+
+// sortStringsAsInts sorts a list of strings in ascending numerical order.
+// Returns an error if any of the strings cannot be converted to an int.
+func sortStringsAsInts(strings []string) error {
+	var ints []int
+	for _, s := range strings {
+		intValue, err := strconv.Atoi(s)
+		if err != nil {
+			return fmt.Errorf("error converting %s to int when sorting strings: %v", s, err)
+		}
+
+		ints = append(ints, intValue)
+	}
+
+	sort.Ints(ints)
+	for i, intValue := range ints {
+		strings[i] = strconv.Itoa(intValue)
+	}
+
+	return nil
+}
+
+// collateModules takes the module-related arrays from dkms.conf and collates them to
+// construct a list of Modules.
+// This gathers the full set of keys from all of the arrays and sorts them in
+// lexicographic order before iterating, which ensures that the output is deterministic.
+func collateModules(pkg *Package, builtNames, builtLocations, destNames, destLocations, strips map[string]string) ([]Module, error) {
+	moduleKeys := allKeys([]map[string]string{
+		builtNames,
+		builtLocations,
+		destNames,
+		destLocations,
+		strips,
+	})
+	sort.Strings(moduleKeys)
+
+	var modules []Module
+	for _, key := range moduleKeys {
+		builtName := builtNames[key]
+		builtLocation := builtLocations[key]
+
+		destName := destNames[key]
+		if destName == "" {
+			destName = builtName
+		}
+
+		destLocation := destLocations[key]
+		if !strings.HasPrefix(destLocation, "/kernel") {
+			return nil, fmt.Errorf("DEST_MODULE_LOCATION %s must begin with /kernel", destLocation)
+		}
+
+		strip := strips[key]
+		if strip == "" {
+			strip = strips[moduleKeys[0]]
+		}
+
+		modules = append(modules, Module{
+			Package:       pkg,
+			BuiltName:     builtName,
+			BuiltLocation: builtLocation,
+			DestName:      destName,
+			DestLocation:  destLocation,
+			Strip:         strip != "no",
+		})
+	}
+
+	if len(modules) == 0 {
+		return nil, fmt.Errorf("package must contain at least one module, found 0")
+	}
+
+	return modules, nil
+}
+
+// allKeys returns the set of all keys from a list of maps.
+// For example, allKeys([]map[string]int {{"a": "1", "b": "2"}, {"a": "3", "c": "4"}})
+// will output []string{"a", "b", "c"} (though the order of keys is not guaranteed).
+func allKeys(maps []map[string]string) []string {
+	keySet := make(map[string]bool)
+	for _, items := range maps {
+		for key := range items {
+			keySet[key] = true
+		}
+	}
+
+	var keys []string
+	for key := range keySet {
+		keys = append(keys, key)
+	}
+
+	return keys
+}
diff --git a/src/pkg/dkms/config_test.go b/src/pkg/dkms/config_test.go
new file mode 100644
index 0000000..5165bc3
--- /dev/null
+++ b/src/pkg/dkms/config_test.go
@@ -0,0 +1,142 @@
+package dkms
+
+import (
+	"fmt"
+	"github.com/google/go-cmp/cmp"
+	"testing"
+)
+
+func TestParseConfig(t *testing.T) {
+	trees := Trees{
+		Source:  "./source-tree",
+		Kernel:  "./kernel-source",
+		Dkms:    t.TempDir(),
+		Install: t.TempDir(),
+	}
+
+	pkg := Package{
+		Name:          "my-package",
+		Version:       "1.0",
+		Arch:          "x86_64",
+		KernelVersion: "6.1.100",
+		Trees:         &trees,
+	}
+
+	testCases := []struct {
+		configString string
+		expected     Config
+	}{
+		{
+			configString: "",
+			expected: Config{
+				PackageName:    pkg.Name,
+				PackageVersion: pkg.Version,
+				MakeCommand:    fmt.Sprintf("make -C %s M=%s", trees.Kernel, pkg.BuildDir()),
+				Patches:        "",
+				Modules: []Module{
+					{
+						Package:       &pkg,
+						BuiltName:     pkg.Name,
+						BuiltLocation: "",
+						DestName:      pkg.Name,
+						DestLocation:  "/kernel/updates",
+						Strip:         true,
+					},
+				},
+				Clean:                fmt.Sprintf("make -C %s M=%s clean", trees.Kernel, pkg.BuildDir()),
+				BuildDepends:         []string{},
+				BuildExclusiveKernel: ".*",
+				BuildExclusiveArch:   ".*",
+			},
+		},
+		{
+			configString: `
+			MAKE=abc
+			PACKAGE_VERSION=3.0
+			PACKAGE_NAME=my-module
+			BUILT_MODULE_NAME=my-built-module
+			`,
+			expected: Config{
+				PackageName:    "my-module",
+				PackageVersion: "3.0",
+				MakeCommand:    "abc",
+				Patches:        "",
+				Modules: []Module{
+					{
+						Package:       &pkg,
+						BuiltName:     "my-built-module",
+						BuiltLocation: "",
+						DestName:      "my-built-module",
+						DestLocation:  "/kernel/updates",
+						Strip:         true,
+					},
+				},
+				Clean:                fmt.Sprintf("make -C %s M=%s clean", trees.Kernel, pkg.BuildDir()),
+				BuildDepends:         []string{},
+				BuildExclusiveKernel: ".*",
+				BuildExclusiveArch:   ".*",
+			},
+		},
+		{
+			configString: `
+			MAKE[2]=abc
+			PACKAGE_VERSION=3.0
+			PACKAGE_NAME=my-module
+			BUILT_MODULE_NAME[0]=my-built-module
+			BUILT_MODULE_LOCATION=build/location
+			BUILT_MODULE_NAME[1]=my-built-module-2
+			DEST_MODULE_NAME[1]=my-installed-module-2
+			STRIP[0]=no
+			DEST_MODULE_LOCATION[1]=/kernel/install/location
+			MAKE[1]="make -C ${kernel_source_dir} M=${dkms_tree}/${module}/${module_version}/build/abc"
+			MAKE[0]='make 0'
+			MAKE_MATCH[0]='6\.6\..*'
+			MAKE_MATCH[1]='6\.1\..*'
+			CLEAN="make clean"
+			BUILD_DEPENDS[0]=module-1
+			BUILD_DEPENDS[1]=module-2
+			`,
+			expected: Config{
+				PackageName:    "my-module",
+				PackageVersion: "3.0",
+				MakeCommand:    fmt.Sprintf("make -C %s M=%s/%s/%s/build/abc", trees.Kernel, trees.Dkms, pkg.Name, pkg.Version),
+				Patches:        "",
+				Modules: []Module{
+					{
+						Package:       &pkg,
+						BuiltName:     "my-built-module",
+						BuiltLocation: "build/location",
+						DestName:      "my-built-module",
+						DestLocation:  "/kernel/updates",
+						Strip:         false,
+					},
+					{
+						Package:       &pkg,
+						BuiltName:     "my-built-module-2",
+						BuiltLocation: "",
+						DestName:      "my-installed-module-2",
+						DestLocation:  "/kernel/install/location",
+						Strip:         false,
+					},
+				},
+				Clean:                "make clean",
+				BuildDepends:         []string{"module-1", "module-2"},
+				BuildExclusiveKernel: ".*",
+				BuildExclusiveArch:   ".*",
+			},
+		},
+	}
+
+	for i, testCase := range testCases {
+		config, err := ParseConfig(testCase.configString, &pkg)
+
+		if err != nil {
+			t.Fatalf("failed test case %d: %v", i, err)
+		}
+
+		diff := cmp.Diff(testCase.expected, *config)
+		if len(diff) > 0 {
+			t.Fatalf("config for test case %d did not match expected value:\ndiff: %s", i, diff)
+		}
+	}
+}
diff --git a/src/pkg/utils/shell.go b/src/pkg/utils/shell.go
index 10e7194..d137aa8 100644
--- a/src/pkg/utils/shell.go
+++ b/src/pkg/utils/shell.go
@@ -89,6 +89,8 @@
 // For example, the input string `X=([0]="abc" [1]="def")` should return
 // map[string]string { "0": "abc", "1": "def" }.
 func ArrayElements(array string) map[string]string {
+	// declare escapes backslashes, which we need to un-escape
+	array = strings.ReplaceAll(array, `\\`, `\`)
 	// get rid of escaped quotes before we do our element matching; we make sure to keep
 	// the length of all substrings the same so that we can use the indices from the
 	// transformed string as the indices of matches in the original string
@@ -106,4 +108,4 @@
 	}
 
 	return result
-}
\ No newline at end of file
+}
diff --git a/src/pkg/utils/shell_test.go b/src/pkg/utils/shell_test.go
index 1233113..4865382 100644
--- a/src/pkg/utils/shell_test.go
+++ b/src/pkg/utils/shell_test.go
@@ -1,9 +1,9 @@
 package utils
 
 import (
+	"github.com/google/go-cmp/cmp"
 	"os"
 	"testing"
-	"github.com/google/go-cmp/cmp"
 )
 
 func TestSourceFile(t *testing.T) {
@@ -12,6 +12,7 @@
 W="a b c"
 X=10
 WEIRD_STRING='a"bc'
+KERNEL_VERSION_REGEX='6\.1\.1.*'
 echo some stdout message
 Q[0]=3
 echo some stderr message >&2
@@ -25,12 +26,13 @@
 	}
 
 	expected := map[string]string{
-		"WEIRD_STRING": "a\\\"bc",
-		"W": "a b c",
-		"X": "10",
-		"Y": "11",
-		"Z": "12",
-		"Q": `([0]="3" [1]="4")`,
+		"WEIRD_STRING":         `a\"bc`,
+		"KERNEL_VERSION_REGEX": `6\\.1\\.1.*`,
+		"W":                    "a b c",
+		"X":                    "10",
+		"Y":                    "11",
+		"Z":                    "12",
+		"Q":                    `([0]="3" [1]="4")`,
 	}
 
 	actual := make(map[string]string)
@@ -45,13 +47,14 @@
 }
 
 func TestArrayElements(t *testing.T) {
-	arrayString := `X=([0]="abc" [1]="def" [2]="gh\"i")`
-	elements  := ArrayElements(arrayString)
+	arrayString := `X=([0]="abc" [1]="def" [2]="gh\"i" [3]="6\\.1\\.1.*")`
+	elements := ArrayElements(arrayString)
 
 	expected := map[string]string{
 		"0": "abc",
 		"1": "def",
-		"2": "gh\\\"i",
+		"2": `gh\"i`,
+		"3": `6\.1\.1.*`,
 	}
 
 	diff := cmp.Diff(expected, elements)