Skip to content

Commit 0c9d911

Browse files
authored
mutate: bounds-check layer index when building rebase addendums (#2371)
createAddendums walks a config's history and advances a separate layer index only for non-empty history entries, then indexes layers[layerIndex] with no bounds check. A config whose history advertises more non-empty entries than the image has layers panics with an index out of range. Rebase feeds both newConfig.History/newBaseLayers and origConfig.History/origLayers straight in, and both configs come from pulled images, so a crafted base image crashes crane rebase and anything else embedding mutate.Rebase. Return an error describing the mismatch instead, which matches how #2304 handled the same class on the tarball side. Also fix the leftover-layer loop, which appended layers[layerIndex] instead of layers[i]. layerIndex is frozen after the history walk, so a base image with layers but no history had its first leftover layer repeated in place of the rest. Adds a test for each case against the exported Rebase entry point. Signed-off-by: Arpit Jain <[email protected]>
1 parent b757a3c commit 0c9d911

2 files changed

Lines changed: 81 additions & 5 deletions

File tree

‎pkg/v1/mutate/rebase.go‎

Lines changed: 16 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -97,13 +97,21 @@ func Rebase(orig, oldBase, newBase v1.Image) (v1.Image, error) {
9797
return nil, fmt.Errorf("could not get new base layers for new base: %w", err)
9898
}
9999
// Add new base layers.
100-
rebasedImage, err = Append(rebasedImage, createAddendums(0, 0, newConfig.History, newBaseLayers)...)
100+
newBaseAdds, err := createAddendums(0, 0, newConfig.History, newBaseLayers)
101+
if err != nil {
102+
return nil, fmt.Errorf("failed to process new base image: %w", err)
103+
}
104+
rebasedImage, err = Append(rebasedImage, newBaseAdds...)
101105
if err != nil {
102106
return nil, fmt.Errorf("failed to append new base image: %w", err)
103107
}
104108

105109
// Add original layers above the old base.
106-
rebasedImage, err = Append(rebasedImage, createAddendums(len(oldConfig.History), len(oldBaseLayers)+1, origConfig.History, origLayers)...)
110+
origAdds, err := createAddendums(len(oldConfig.History), len(oldBaseLayers)+1, origConfig.History, origLayers)
111+
if err != nil {
112+
return nil, fmt.Errorf("failed to process original image: %w", err)
113+
}
114+
rebasedImage, err = Append(rebasedImage, origAdds...)
107115
if err != nil {
108116
return nil, fmt.Errorf("failed to append original image: %w", err)
109117
}
@@ -113,7 +121,7 @@ func Rebase(orig, oldBase, newBase v1.Image) (v1.Image, error) {
113121

114122
// createAddendums makes a list of addendums from a history and layers starting from a specific history and layer
115123
// indexes.
116-
func createAddendums(startHistory, startLayer int, history []v1.History, layers []v1.Layer) []Addendum {
124+
func createAddendums(startHistory, startLayer int, history []v1.History, layers []v1.Layer) ([]Addendum, error) {
117125
var adds []Addendum
118126
// History should be a superset of layers; empty layers (e.g. ENV statements) only exist in history.
119127
// They cannot be iterated identically but must be walked independently, only advancing the iterator for layers
@@ -123,6 +131,9 @@ func createAddendums(startHistory, startLayer int, history []v1.History, layers
123131
var layer v1.Layer
124132
emptyLayer := history[historyIndex].EmptyLayer
125133
if !emptyLayer {
134+
if layerIndex >= len(layers) {
135+
return nil, fmt.Errorf("malformed image: config history references at least %d non-empty layer(s), but only %d layer(s) are present", layerIndex+1, len(layers))
136+
}
126137
layer = layers[layerIndex]
127138
layerIndex++
128139
}
@@ -136,9 +147,9 @@ func createAddendums(startHistory, startLayer int, history []v1.History, layers
136147
// In the event history was malformed or non-existent, append the remaining layers.
137148
for i := layerIndex; i < len(layers); i++ {
138149
if i >= startLayer {
139-
adds = append(adds, Addendum{Layer: layers[layerIndex]})
150+
adds = append(adds, Addendum{Layer: layers[i]})
140151
}
141152
}
142153

143-
return adds
154+
return adds, nil
144155
}

‎pkg/v1/mutate/rebase_test.go‎

Lines changed: 65 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -19,6 +19,7 @@ import (
1919
"time"
2020

2121
v1 "github.com/google/go-containerregistry/pkg/v1"
22+
"github.com/google/go-containerregistry/pkg/v1/empty"
2223
"github.com/google/go-containerregistry/pkg/v1/mutate"
2324
"github.com/google/go-containerregistry/pkg/v1/random"
2425
)
@@ -177,3 +178,67 @@ func TestRebase(t *testing.T) {
177178
t.Errorf("ConfigFile property OSVersion mismatch, got %q, want %q", rebasedConfig.OSVersion, newBaseConfig.OSVersion)
178179
}
179180
}
181+
182+
// TestRebaseMalformedHistory checks that Rebase returns an error, rather than
183+
// panicking, when an image's config history claims more non-empty layers than
184+
// the image actually has.
185+
func TestRebaseMalformedHistory(t *testing.T) {
186+
orig, err := random.Image(100, 1)
187+
if err != nil {
188+
t.Fatalf("random.Image (orig): %v", err)
189+
}
190+
191+
// A new base whose config advertises a non-empty (layer-bearing) history
192+
// entry while carrying no layers at all.
193+
badBase, err := mutate.ConfigFile(empty.Image, &v1.ConfigFile{
194+
History: []v1.History{{CreatedBy: "claims a layer that isn't there", EmptyLayer: false}},
195+
})
196+
if err != nil {
197+
t.Fatalf("mutate.ConfigFile (badBase): %v", err)
198+
}
199+
200+
if _, err := mutate.Rebase(orig, empty.Image, badBase); err == nil {
201+
t.Error("Rebase: expected an error for a config claiming more layers than exist, got nil")
202+
} else {
203+
t.Logf("Rebase returned: %v", err)
204+
}
205+
}
206+
207+
// TestRebaseNoHistory checks that when a base image's config carries no history
208+
// at all, Rebase still carries over each of its layers, in order.
209+
func TestRebaseNoHistory(t *testing.T) {
210+
base, err := random.Image(100, 3)
211+
if err != nil {
212+
t.Fatalf("random.Image (base): %v", err)
213+
}
214+
cf, err := base.ConfigFile()
215+
if err != nil {
216+
t.Fatalf("base.ConfigFile: %v", err)
217+
}
218+
stripped := cf.DeepCopy()
219+
stripped.History = nil
220+
newBase, err := mutate.ConfigFile(base, stripped)
221+
if err != nil {
222+
t.Fatalf("mutate.ConfigFile (newBase): %v", err)
223+
}
224+
want := layerDigests(t, newBase)
225+
226+
orig, err := random.Image(100, 1)
227+
if err != nil {
228+
t.Fatalf("random.Image (orig): %v", err)
229+
}
230+
rebased, err := mutate.Rebase(orig, empty.Image, newBase)
231+
if err != nil {
232+
t.Fatalf("Rebase: %v", err)
233+
}
234+
got := layerDigests(t, rebased)
235+
236+
if len(got) < len(want) {
237+
t.Fatalf("rebased image has %d layers, want at least %d", len(got), len(want))
238+
}
239+
for i, w := range want {
240+
if got[i] != w {
241+
t.Errorf("rebased layer %d = %s, want %s", i, got[i], w)
242+
}
243+
}
244+
}

0 commit comments

Comments
 (0)