Polish "Support authentication to private Docker registry"

See gh-22972

spring-boot-project/spring-boot-tools/spring-boot-buildpack-platform/src/test/java/org/springframework/boot/buildpack/platform/build/BuilderTests.java

@@ -30,7 +30,6 @@ import org.springframework.boot.buildpack.platform.docker.DockerApi.ContainerApi
 import org.springframework.boot.buildpack.platform.docker.DockerApi.ImageApi;
 import org.springframework.boot.buildpack.platform.docker.DockerApi.VolumeApi;
 import org.springframework.boot.buildpack.platform.docker.TotalProgressPullListener;
-import org.springframework.boot.buildpack.platform.docker.configuration.DockerConfiguration;
 import org.springframework.boot.buildpack.platform.docker.transport.DockerEngineException;
 import org.springframework.boot.buildpack.platform.docker.type.ContainerReference;
 import org.springframework.boot.buildpack.platform.docker.type.ContainerStatus;
@@ -67,7 +66,7 @@ class BuilderTests {
 
 	@Test
 	void createWithDockerConfiguration() {
-		Builder builder = new Builder(BuildLog.toSystemOut(), new DockerConfiguration());
+		Builder builder = new Builder(BuildLog.toSystemOut());
 		assertThat(builder).isNotNull();
 	}
 

spring-boot-project/spring-boot-tools/spring-boot-buildpack-platform/src/test/java/org/springframework/boot/buildpack/platform/docker/DockerApiTests.java

@@ -20,9 +20,7 @@ import java.io.ByteArrayOutputStream;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.net.URI;
-import java.util.Collection;
 
-import org.apache.http.Header;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
@@ -36,8 +34,6 @@ import org.mockito.junit.jupiter.MockitoExtension;
 import org.springframework.boot.buildpack.platform.docker.DockerApi.ContainerApi;
 import org.springframework.boot.buildpack.platform.docker.DockerApi.ImageApi;
 import org.springframework.boot.buildpack.platform.docker.DockerApi.VolumeApi;
-import org.springframework.boot.buildpack.platform.docker.configuration.DockerConfiguration;
-import org.springframework.boot.buildpack.platform.docker.configuration.DockerRegistryConfiguration;
 import org.springframework.boot.buildpack.platform.docker.transport.HttpTransport;
 import org.springframework.boot.buildpack.platform.docker.transport.HttpTransport.Response;
 import org.springframework.boot.buildpack.platform.docker.type.ContainerConfig;
@@ -52,7 +48,6 @@ import org.springframework.boot.buildpack.platform.io.Content;
 import org.springframework.boot.buildpack.platform.io.IOConsumer;
 import org.springframework.boot.buildpack.platform.io.Owner;
 import org.springframework.boot.buildpack.platform.io.TarArchive;
-import org.springframework.util.Base64Utils;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
@@ -124,40 +119,6 @@ class DockerApiTests {
 		assertThat(api).isNotNull();
 	}
 
-	@Test
-	void createDockerApiWithDockerConfiguration() {
-		DockerApi api = new DockerApi(new DockerConfiguration());
-		assertThat(api).isNotNull();
-	}
-
-	@Test
-	void createWhenDockerConfigurationIsNullThrowsException() {
-		assertThatIllegalArgumentException().isThrownBy(() -> new DockerApi((DockerConfiguration) null))
-				.withMessage("Docker configuration must not be null");
-	}
-
-	@Test
-	void createDockerEngineAuthenticationHeaders() {
-		DockerRegistryConfiguration dockerRegistryConfiguration = new DockerRegistryConfiguration();
-		dockerRegistryConfiguration.setUsername("username");
-		dockerRegistryConfiguration.setPassword("password");
-		dockerRegistryConfiguration.setEmail("mock@spring.com");
-		dockerRegistryConfiguration.setUrl("http://mock.docker.registry");
-		DockerConfiguration dockerConfiguration = new DockerConfiguration();
-		dockerConfiguration.setDockerRegistryConfiguration(dockerRegistryConfiguration);
-		Collection<Header> dockerEngineAuthenticationHeaders = DockerApi
-				.createDockerEngineAuthenticationHeaders(dockerConfiguration);
-		assertThat(dockerEngineAuthenticationHeaders.size() == 1).isTrue();
-		Header header = dockerEngineAuthenticationHeaders.iterator().next();
-		assertThat(header.getName()).isEqualTo("X-Registry-Auth");
-		assertThat(header.getValue()).isEqualTo(
-				"ewogICJ1c2VybmFtZSIgOiAidXNlcm5hbWUiLAogICJwYXNzd29yZCIgOiAicGFzc3dvcmQiLAogICJlbWFpbCIgOiAibW9ja0BzcHJpbmcuY29tIiwKICAic2VydmVyYWRkcmVzcyIgOiAiaHR0cDovL21vY2suZG9ja2VyLnJlZ2lzdHJ5Igp9");
-		assertThat(new String(Base64Utils.decodeFromString(header.getValue())))
-				.isEqualTo("{\n" + "  \"username\" : \"username\",\n" + "  \"password\" : \"password\",\n"
-						+ "  \"email\" : \"mock@spring.com\",\n"
-						+ "  \"serveraddress\" : \"http://mock.docker.registry\"\n" + "}");
-	}
-
 	@Nested
 	class ImageDockerApiTests {
 

spring-boot-project/spring-boot-tools/spring-boot-buildpack-platform/src/test/java/org/springframework/boot/buildpack/platform/docker/configuration/DockerConfigurationTests.java

@@ -24,12 +24,38 @@ import static org.assertj.core.api.Assertions.assertThat;
  * Tests for {@link DockerConfiguration}.
  *
  * @author Wei Jiang
+ * @author Scott Frederick
  */
 public class DockerConfigurationTests {
 
 	@Test
-	void createDockerConfiguration() {
-		assertThat(new DockerConfiguration()).isNotNull();
+	void createDockerConfigurationWithDefaults() {
+		DockerConfiguration configuration = DockerConfiguration.withDefaults();
+		assertThat(configuration.getRegistryAuthentication()).isNull();
+	}
+
+	@Test
+	void createDockerConfigurationWithUserAuth() {
+		DockerConfiguration configuration = DockerConfiguration.withRegistryUserAuthentication("user", "secret",
+				"https://docker.example.com", "docker@example.com");
+		DockerRegistryAuthentication auth = configuration.getRegistryAuthentication();
+		assertThat(auth).isNotNull();
+		assertThat(auth).isInstanceOf(DockerRegistryUserAuthentication.class);
+		DockerRegistryUserAuthentication userAuth = (DockerRegistryUserAuthentication) auth;
+		assertThat(userAuth.getUrl()).isEqualTo("https://docker.example.com");
+		assertThat(userAuth.getUsername()).isEqualTo("user");
+		assertThat(userAuth.getPassword()).isEqualTo("secret");
+		assertThat(userAuth.getEmail()).isEqualTo("docker@example.com");
+	}
+
+	@Test
+	void createDockerConfigurationWithTokenAuth() {
+		DockerConfiguration configuration = DockerConfiguration.withRegistryTokenAuthentication("token");
+		DockerRegistryAuthentication auth = configuration.getRegistryAuthentication();
+		assertThat(auth).isNotNull();
+		assertThat(auth).isInstanceOf(DockerRegistryTokenAuthentication.class);
+		DockerRegistryTokenAuthentication tokenAuth = (DockerRegistryTokenAuthentication) auth;
+		assertThat(tokenAuth.getToken()).isEqualTo("token");
 	}
 
 }

spring-boot-project/spring-boot-tools/spring-boot-buildpack-platform/src/test/java/org/springframework/boot/buildpack/platform/docker/configuration/DockerRegistryConfigurationTests.java

@@ -1,79 +0,0 @@
-/*
- * Copyright 2012-2020 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.boot.buildpack.platform.docker.configuration;
-
-import org.junit.jupiter.api.Test;
-
-import org.springframework.util.Base64Utils;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Tests for {@link DockerRegistryConfiguration}.
- *
- * @author Wei Jiang
- */
-public class DockerRegistryConfigurationTests {
-
-	@Test
-	void createDockerRegistryAuthTokenWithToken() {
-		DockerRegistryConfiguration dockerRegistryConfiguration = new DockerRegistryConfiguration();
-		dockerRegistryConfiguration.setToken("mockToken");
-		assertThat(dockerRegistryConfiguration.createDockerRegistryAuthToken()).isEqualTo("mockToken");
-	}
-
-	@Test
-	void createDockerRegistryAuthTokenWithoutToken() {
-		DockerRegistryConfiguration dockerRegistryConfiguration = new DockerRegistryConfiguration();
-		dockerRegistryConfiguration.setUsername("username");
-		dockerRegistryConfiguration.setPassword("password");
-		dockerRegistryConfiguration.setEmail("mock@spring.com");
-		dockerRegistryConfiguration.setUrl("http://mock.docker.registry");
-		String token = dockerRegistryConfiguration.createDockerRegistryAuthToken();
-		assertThat(token).isEqualTo(
-				"ewogICJ1c2VybmFtZSIgOiAidXNlcm5hbWUiLAogICJwYXNzd29yZCIgOiAicGFzc3dvcmQiLAogICJlbWFpbCIgOiAibW9ja0BzcHJpbmcuY29tIiwKICAic2VydmVyYWRkcmVzcyIgOiAiaHR0cDovL21vY2suZG9ja2VyLnJlZ2lzdHJ5Igp9");
-		assertThat(new String(Base64Utils.decodeFromString(token))).isEqualTo("{\n" + "  \"username\" : \"username\",\n"
-				+ "  \"password\" : \"password\",\n" + "  \"email\" : \"mock@spring.com\",\n"
-				+ "  \"serveraddress\" : \"http://mock.docker.registry\"\n" + "}");
-	}
-
-	@Test
-	void createDockerRegistryAuthTokenWithUsernameAndPassword() {
-		DockerRegistryConfiguration dockerRegistryConfiguration = new DockerRegistryConfiguration();
-		dockerRegistryConfiguration.setUsername("username");
-		dockerRegistryConfiguration.setPassword("password");
-		String token = dockerRegistryConfiguration.createDockerRegistryAuthToken();
-		assertThat(dockerRegistryConfiguration.getEmail()).isNull();
-		assertThat(dockerRegistryConfiguration.getUrl()).isNull();
-		assertThat(token).isEqualTo(
-				"ewogICJ1c2VybmFtZSIgOiAidXNlcm5hbWUiLAogICJwYXNzd29yZCIgOiAicGFzc3dvcmQiLAogICJlbWFpbCIgOiBudWxsLAogICJzZXJ2ZXJhZGRyZXNzIiA6IG51bGwKfQ==");
-		assertThat(new String(Base64Utils.decodeFromString(token))).isEqualTo("{\n" + "  \"username\" : \"username\",\n"
-				+ "  \"password\" : \"password\",\n" + "  \"email\" : null,\n" + "  \"serveraddress\" : null\n" + "}");
-	}
-
-	@Test
-	void createDockerRegistryAuthTokenWithTokenAndUsername() {
-		DockerRegistryConfiguration dockerRegistryConfiguration = new DockerRegistryConfiguration();
-		dockerRegistryConfiguration.setToken("mockToken");
-		dockerRegistryConfiguration.setUsername("username");
-		dockerRegistryConfiguration.setPassword("password");
-		dockerRegistryConfiguration.setEmail("mock@spring.com");
-		dockerRegistryConfiguration.setUrl("http://mock.docker.registry");
-		assertThat(dockerRegistryConfiguration.createDockerRegistryAuthToken()).isEqualTo("mockToken");
-	}
-
-}

spring-boot-project/spring-boot-tools/spring-boot-buildpack-platform/src/test/java/org/springframework/boot/buildpack/platform/docker/configuration/DockerRegistryTokenAuthenticationTests.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2012-2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.buildpack.platform.docker.configuration;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+
+import org.json.JSONException;
+import org.junit.jupiter.api.Test;
+import org.skyscreamer.jsonassert.JSONAssert;
+
+import org.springframework.boot.buildpack.platform.json.AbstractJsonTests;
+import org.springframework.util.Base64Utils;
+import org.springframework.util.StreamUtils;
+
+/**
+ * Tests for {@link DockerRegistryTokenAuthentication}.
+ */
+class DockerRegistryTokenAuthenticationTests extends AbstractJsonTests {
+
+	@Test
+	void createAuthHeaderReturnsEncodedHeader() throws IOException, JSONException {
+		DockerRegistryTokenAuthentication auth = new DockerRegistryTokenAuthentication("tokenvalue");
+		String header = auth.createAuthHeader();
+		String expectedJson = StreamUtils.copyToString(getContent("auth-token.json"), StandardCharsets.UTF_8);
+		JSONAssert.assertEquals(expectedJson, new String(Base64Utils.decodeFromUrlSafeString(header)), false);
+	}
+
+}

spring-boot-project/spring-boot-tools/spring-boot-buildpack-platform/src/test/java/org/springframework/boot/buildpack/platform/docker/configuration/DockerRegistryUserAuthenticationTests.java

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2012-2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.buildpack.platform.docker.configuration;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+
+import org.json.JSONException;
+import org.junit.jupiter.api.Test;
+import org.skyscreamer.jsonassert.JSONAssert;
+
+import org.springframework.boot.buildpack.platform.json.AbstractJsonTests;
+import org.springframework.util.Base64Utils;
+import org.springframework.util.StreamUtils;
+
+/**
+ * Tests for {@link DockerRegistryUserAuthentication}.
+ */
+class DockerRegistryUserAuthenticationTests extends AbstractJsonTests {
+
+	@Test
+	void createMinimalAuthHeaderReturnsEncodedHeader() throws IOException, JSONException {
+		DockerRegistryUserAuthentication auth = new DockerRegistryUserAuthentication("user", "secret",
+				"https://docker.example.com", "docker@example.com");
+		JSONAssert.assertEquals(jsonContent("auth-user-full.json"), decoded(auth.createAuthHeader()), false);
+	}
+
+	@Test
+	void createFullAuthHeaderReturnsEncodedHeader() throws IOException, JSONException {
+		DockerRegistryUserAuthentication auth = new DockerRegistryUserAuthentication("user", "secret", null, null);
+		JSONAssert.assertEquals(jsonContent("auth-user-minimal.json"), decoded(auth.createAuthHeader()), false);
+	}
+
+	private String jsonContent(String s) throws IOException {
+		return StreamUtils.copyToString(getContent(s), StandardCharsets.UTF_8);
+	}
+
+	private String decoded(String header) {
+		return new String(Base64Utils.decodeFromUrlSafeString(header));
+	}
+
+}

spring-boot-project/spring-boot-tools/spring-boot-buildpack-platform/src/test/java/org/springframework/boot/buildpack/platform/docker/transport/HttpClientTransportTests.java

@@ -22,6 +22,7 @@ import java.io.InputStream;
 import java.net.URI;
 import java.nio.charset.StandardCharsets;
 
+import org.apache.http.Header;
 import org.apache.http.HttpEntity;
 import org.apache.http.HttpEntityEnclosingRequest;
 import org.apache.http.HttpHeaders;
@@ -43,7 +44,9 @@ import org.mockito.Captor;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 
+import org.springframework.boot.buildpack.platform.docker.configuration.DockerConfiguration;
 import org.springframework.boot.buildpack.platform.docker.transport.HttpTransport.Response;
+import org.springframework.util.Base64Utils;
 import org.springframework.util.StreamUtils;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -234,6 +237,47 @@ class HttpClientTransportTests {
 				.satisfies((ex) -> assertThat(ex.getMessage()).contains("test IO exception"));
 	}
 
+	@Test
+	void getWithDockerRegistryUserAuthWillSendAuthHeader() throws IOException {
+		DockerConfiguration dockerConfiguration = DockerConfiguration.withRegistryUserAuthentication("user", "secret",
+				"https://docker.example.com", "docker@example.com");
+		this.http = new TestHttpClientTransport(this.client, dockerConfiguration);
+		givenClientWillReturnResponse();
+		given(this.entity.getContent()).willReturn(this.content);
+		given(this.statusLine.getStatusCode()).willReturn(200);
+		Response response = this.http.get(this.uri);
+		verify(this.client).execute(this.hostCaptor.capture(), this.requestCaptor.capture());
+		HttpUriRequest request = this.requestCaptor.getValue();
+		assertThat(request).isInstanceOf(HttpGet.class);
+		assertThat(request.getURI()).isEqualTo(this.uri);
+		Header[] registryAuthHeaders = request.getHeaders("X-Registry-Auth");
+		assertThat(registryAuthHeaders).isNotNull();
+		assertThat(new String(Base64Utils.decodeFromString(registryAuthHeaders[0].getValue())))
+				.contains("\"username\" : \"user\"").contains("\"password\" : \"secret\"")
+				.contains("\"email\" : \"docker@example.com\"")
+				.contains("\"serveraddress\" : \"https://docker.example.com\"");
+		assertThat(response.getContent()).isSameAs(this.content);
+	}
+
+	@Test
+	void getWithDockerRegistryTokenAuthWillSendAuthHeader() throws IOException {
+		DockerConfiguration dockerConfiguration = DockerConfiguration.withRegistryTokenAuthentication("token");
+		this.http = new TestHttpClientTransport(this.client, dockerConfiguration);
+		givenClientWillReturnResponse();
+		given(this.entity.getContent()).willReturn(this.content);
+		given(this.statusLine.getStatusCode()).willReturn(200);
+		Response response = this.http.get(this.uri);
+		verify(this.client).execute(this.hostCaptor.capture(), this.requestCaptor.capture());
+		HttpUriRequest request = this.requestCaptor.getValue();
+		assertThat(request).isInstanceOf(HttpGet.class);
+		assertThat(request.getURI()).isEqualTo(this.uri);
+		Header[] registryAuthHeaders = request.getHeaders("X-Registry-Auth");
+		assertThat(registryAuthHeaders).isNotNull();
+		assertThat(new String(Base64Utils.decodeFromString(registryAuthHeaders[0].getValue())))
+				.contains("\"identitytoken\" : \"token\"");
+		assertThat(response.getContent()).isSameAs(this.content);
+	}
+
 	private String writeToString(HttpEntity entity) throws IOException {
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
 		entity.writeTo(out);
@@ -252,7 +296,11 @@ class HttpClientTransportTests {
 	static class TestHttpClientTransport extends HttpClientTransport {
 
 		protected TestHttpClientTransport(CloseableHttpClient client) {
-			super(client, HttpHost.create("docker://localhost"));
+			super(client, HttpHost.create("docker://localhost"), null);
+		}
+
+		protected TestHttpClientTransport(CloseableHttpClient client, DockerConfiguration dockerConfiguration) {
+			super(client, HttpHost.create("docker://localhost"), dockerConfiguration);
 		}
 
 	}

spring-boot-project/spring-boot-tools/spring-boot-buildpack-platform/src/test/java/org/springframework/boot/buildpack/platform/docker/transport/HttpTransportTests.java

@@ -19,13 +19,9 @@ package org.springframework.boot.buildpack.platform.docker.transport;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.Arrays;
-import java.util.Collection;
 import java.util.Collections;
 import java.util.Map;
 
-import org.apache.http.Header;
-import org.apache.http.message.BasicHeader;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
 
@@ -69,12 +65,4 @@ class HttpTransportTests {
 		assertThat(transport).isInstanceOf(LocalHttpClientTransport.class);
 	}
 
-	@Test
-	void createWithDockerEngineAuthenticationHeaders() {
-		Collection<Header> dockerEngineAuthenticationHeaders = Arrays.asList(new BasicHeader("X-Registry-Auth",
-				"eyJ1c2VybmFtZSI6ICJ1c2VybmFtZSIsInBhc3N3b3JkIjogInBhc3N3b3JkIiwiZW1haWwiOiAibW9ja0BzcHJpbmcuY29tIiwic2VydmVyYWRkcmVzcyI6ICJodHRwOi8vbW9jay5kb2NrZXIucmVnaXN0cnkifQ=="));
-		HttpTransport transport = HttpTransport.create((name) -> null, dockerEngineAuthenticationHeaders);
-		assertThat(transport).isInstanceOf(LocalHttpClientTransport.class);
-	}
-
 }

spring-boot-project/spring-boot-tools/spring-boot-buildpack-platform/src/test/java/org/springframework/boot/buildpack/platform/docker/transport/RemoteHttpClientTransportTests.java

@@ -19,20 +19,17 @@ package org.springframework.boot.buildpack.platform.docker.transport;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.Arrays;
-import java.util.Collection;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.function.Consumer;
 
 import javax.net.ssl.SSLContext;
 
-import org.apache.http.Header;
 import org.apache.http.HttpHost;
-import org.apache.http.message.BasicHeader;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
 
+import org.springframework.boot.buildpack.platform.docker.configuration.DockerConfiguration;
 import org.springframework.boot.buildpack.platform.docker.ssl.SslContextFactory;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -50,9 +47,12 @@ class RemoteHttpClientTransportTests {
 
 	private final Map<String, String> environment = new LinkedHashMap<>();
 
+	private final DockerConfiguration dockerConfiguration = DockerConfiguration.withDefaults();
+
 	@Test
 	void createIfPossibleWhenDockerHostIsNotSetReturnsNull() {
-		RemoteHttpClientTransport transport = RemoteHttpClientTransport.createIfPossible(this.environment::get);
+		RemoteHttpClientTransport transport = RemoteHttpClientTransport.createIfPossible(this.environment::get,
+				this.dockerConfiguration);
 		assertThat(transport).isNull();
 	}
 
@@ -61,24 +61,16 @@ class RemoteHttpClientTransportTests {
 		String dummySocketFilePath = Files.createTempFile(tempDir, "remote-transport", null).toAbsolutePath()
 				.toString();
 		this.environment.put("DOCKER_HOST", dummySocketFilePath);
-		RemoteHttpClientTransport transport = RemoteHttpClientTransport.createIfPossible(this.environment::get);
+		RemoteHttpClientTransport transport = RemoteHttpClientTransport.createIfPossible(this.environment::get,
+				this.dockerConfiguration);
 		assertThat(transport).isNull();
 	}
 
 	@Test
 	void createIfPossibleWhenDockerHostIsAddressReturnsTransport() {
 		this.environment.put("DOCKER_HOST", "tcp://192.168.1.2:2376");
-		RemoteHttpClientTransport transport = RemoteHttpClientTransport.createIfPossible(this.environment::get);
-		assertThat(transport).isNotNull();
-	}
-
-	@Test
-	void createWithDockerEngineAuthenticationHeaders() {
-		Collection<Header> dockerEngineAuthenticationHeaders = Arrays.asList(new BasicHeader("X-Registry-Auth",
-				"eyJ1c2VybmFtZSI6ICJ1c2VybmFtZSIsInBhc3N3b3JkIjogInBhc3N3b3JkIiwiZW1haWwiOiAibW9ja0BzcHJpbmcuY29tIiwic2VydmVyYWRkcmVzcyI6ICJodHRwOi8vbW9jay5kb2NrZXIucmVnaXN0cnkifQ=="));
-		this.environment.put("DOCKER_HOST", "tcp://192.168.1.2:2376");
 		RemoteHttpClientTransport transport = RemoteHttpClientTransport.createIfPossible(this.environment::get,
-				dockerEngineAuthenticationHeaders);
+				this.dockerConfiguration);
 		assertThat(transport).isNotNull();
 	}
 
@@ -86,15 +78,16 @@ class RemoteHttpClientTransportTests {
 	void createIfPossibleWhenTlsVerifyWithMissingCertPathThrowsException() {
 		this.environment.put("DOCKER_HOST", "tcp://192.168.1.2:2376");
 		this.environment.put("DOCKER_TLS_VERIFY", "1");
-		assertThatIllegalArgumentException()
-				.isThrownBy(() -> RemoteHttpClientTransport.createIfPossible(this.environment::get))
+		assertThatIllegalArgumentException().isThrownBy(
+				() -> RemoteHttpClientTransport.createIfPossible(this.environment::get, this.dockerConfiguration))
 				.withMessageContaining("DOCKER_CERT_PATH");
 	}
 
 	@Test
 	void createIfPossibleWhenNoTlsVerifyUsesHttp() {
 		this.environment.put("DOCKER_HOST", "tcp://192.168.1.2:2376");
-		RemoteHttpClientTransport transport = RemoteHttpClientTransport.createIfPossible(this.environment::get);
+		RemoteHttpClientTransport transport = RemoteHttpClientTransport.createIfPossible(this.environment::get,
+				this.dockerConfiguration);
 		assertThat(transport.getHost()).satisfies(hostOf("http", "192.168.1.2", 2376));
 	}
 
@@ -106,10 +99,19 @@ class RemoteHttpClientTransportTests {
 		SslContextFactory sslContextFactory = mock(SslContextFactory.class);
 		given(sslContextFactory.forDirectory("/test-cert-path")).willReturn(SSLContext.getDefault());
 		RemoteHttpClientTransport transport = RemoteHttpClientTransport.createIfPossible(this.environment::get,
-				sslContextFactory);
+				this.dockerConfiguration, sslContextFactory);
 		assertThat(transport.getHost()).satisfies(hostOf("https", "192.168.1.2", 2376));
 	}
 
+	@Test
+	void createIfPossibleWithDockerConfigurationUserAuthReturnsTransport() {
+		this.environment.put("DOCKER_HOST", "tcp://192.168.1.2:2376");
+		RemoteHttpClientTransport transport = RemoteHttpClientTransport.createIfPossible(this.environment::get,
+				DockerConfiguration.withRegistryUserAuthentication("user", "secret", "http://docker.example.com",
+						"docker@example.com"));
+		assertThat(transport).isNotNull();
+	}
+
 	private Consumer<HttpHost> hostOf(String scheme, String hostName, int port) {
 		return (host) -> {
 			assertThat(host).isNotNull();

spring-boot-project/spring-boot-tools/spring-boot-buildpack-platform/src/test/resources/org/springframework/boot/buildpack/platform/docker/configuration/auth-token.json

@@ -0,0 +1,3 @@
+{
+	"identitytoken": "tokenvalue"
+}

spring-boot-project/spring-boot-tools/spring-boot-buildpack-platform/src/test/resources/org/springframework/boot/buildpack/platform/docker/configuration/auth-user-full.json

@@ -0,0 +1,6 @@
+{
+	"username": "user",
+	"password": "secret",
+	"email": "docker@example.com",
+	"serveraddress": "https://docker.example.com"
+}

spring-boot-project/spring-boot-tools/spring-boot-buildpack-platform/src/test/resources/org/springframework/boot/buildpack/platform/docker/configuration/auth-user-minimal.json

@@ -0,0 +1,4 @@
+{
+	"username": "user",
+	"password": "secret"
+}