diff --git a/depstool/deps/parse.go b/depstool/deps/parse.go
new file mode 100644
index 0000000..238837b
--- /dev/null
+++ b/depstool/deps/parse.go
@@ -0,0 +1,123 @@
+// Package deps package provides methods to extract and manipulate external code dependencies from the QUICHE WORKSPACE.bazel file.
+package deps
+
+import (
+	"fmt"
+	"regexp"
+
+	"github.com/bazelbuild/buildtools/build"
+)
+
+var lastUpdatedRE = regexp.MustCompile(`Last updated (\d{4}-\d{2}-\d{2})`)
+
+// Entry is a parsed representation of a dependency entry in the WORKSPACE.bazel file.
+type Entry struct {
+	Name        string
+	SHA256      string
+	Prefix      string
+	URL         string
+	LastUpdated string
+}
+
+// HTTPArchiveRule returns a CallExpr describing the provided http_archive
+// rule, or nil if the expr in question is not an http_archive rule.
+func HTTPArchiveRule(expr build.Expr) (*build.CallExpr, bool) {
+	callexpr, ok := expr.(*build.CallExpr)
+	if !ok {
+		return nil, false
+	}
+	name, ok := callexpr.X.(*build.Ident)
+	if !ok || name.Name != "http_archive" {
+		return nil, false
+	}
+	return callexpr, true
+}
+
+func parseString(expr build.Expr) (string, error) {
+	str, ok := expr.(*build.StringExpr)
+	if !ok {
+		return "", fmt.Errorf("expected string as the function argument")
+	}
+	return str.Value, nil
+}
+
+func parseSingleElementList(expr build.Expr) (string, error) {
+	list, ok := expr.(*build.ListExpr)
+	if !ok {
+		return "", fmt.Errorf("expected a list as the function argument")
+	}
+	if len(list.List) != 1 {
+		return "", fmt.Errorf("expected a single-element list as the function argument, got %d elements", len(list.List))
+	}
+	return parseString(list.List[0])
+}
+
+// ParseHTTPArchiveRule parses the provided http_archive rule and returns all of the dependency metadata embedded.
+func ParseHTTPArchiveRule(callexpr *build.CallExpr) (*Entry, error) {
+	result := Entry{}
+	for _, arg := range callexpr.List {
+		assign, ok := arg.(*build.AssignExpr)
+		if !ok {
+			return nil, fmt.Errorf("a non-named argument passed as a function parameter")
+		}
+		argname, _ := build.GetParamName(assign.LHS)
+		var err error = nil
+		switch argname {
+		case "name":
+			result.Name, err = parseString(assign.RHS)
+		case "sha256":
+			result.SHA256, err = parseString(assign.RHS)
+
+			if len(assign.Comments.Suffix) != 1 {
+				return nil, fmt.Errorf("missing the \"Last updated\" comment on the sha256 field")
+			}
+			comment := assign.Comments.Suffix[0].Token
+			match := lastUpdatedRE.FindStringSubmatch(comment)
+			if match == nil {
+				return nil, fmt.Errorf("unable to parse the \"Last updated\" comment, comment value: %s", comment)
+			}
+			result.LastUpdated = match[1]
+		case "strip_prefix":
+			result.Prefix, err = parseString(assign.RHS)
+		case "urls":
+			result.URL, err = parseSingleElementList(assign.RHS)
+		default:
+			continue
+		}
+		if err != nil {
+			return nil, err
+		}
+	}
+	if result.Name == "" {
+		return nil, fmt.Errorf("missing the name field")
+	}
+	if result.SHA256 == "" {
+		return nil, fmt.Errorf("missing the sha256 field")
+	}
+	if result.URL == "" {
+		return nil, fmt.Errorf("missing the urls field")
+	}
+	return &result, nil
+}
+
+// ParseHTTPArchiveRules parses the entire WORKSPACE.bazel file and returns all of the http_archive rules in it.
+func ParseHTTPArchiveRules(source []byte) ([]*Entry, error) {
+	file, err := build.ParseWorkspace("WORKSPACE.bazel", source)
+	if err != nil {
+		return []*Entry{}, err
+	}
+
+	result := make([]*Entry, 0)
+	for _, expr := range file.Stmt {
+		callexpr, ok := HTTPArchiveRule(expr)
+		if !ok {
+			continue
+		}
+		parsed, err := ParseHTTPArchiveRule(callexpr)
+		if err != nil {
+			return []*Entry{}, err
+		}
+		result = append(result, parsed)
+	}
+	return result, nil
+}