Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

fix: relaxed SNI hostname resolution#197

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to ourterms of service andprivacy statement. We’ll occasionally send you account related emails.

Already on GitHub?Sign in to your account

Merged
fioan89 merged 3 commits intomainfromfix-sni-resolution
Sep 22, 2025
Merged
Show file tree
Hide file tree
Changes fromall commits
Commits
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 4 additions & 0 deletionsCHANGELOG.md
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -2,6 +2,10 @@

## Unreleased

### Fixed

- relaxed SNI hostname resolution

## 0.6.5 - 2025-09-16

### Fixed
Expand Down
2 changes: 1 addition & 1 deletiongradle.properties
View file
Open in desktop
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,3 @@
version=0.6.5
version=0.6.6
group=com.coder.toolbox
name=coder-toolbox
22 changes: 17 additions & 5 deletionssrc/main/kotlin/com/coder/toolbox/util/TLS.kt
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -4,8 +4,10 @@ import com.coder.toolbox.settings.ReadOnlyTLSSettings
import okhttp3.internal.tls.OkHostnameVerifier
import java.io.File
import java.io.FileInputStream
import java.net.IDN
import java.net.InetAddress
import java.net.Socket
import java.nio.charset.StandardCharsets
import java.security.KeyFactory
import java.security.KeyStore
import java.security.cert.CertificateException
Expand All@@ -18,11 +20,12 @@ import java.util.Locale
import javax.net.ssl.HostnameVerifier
import javax.net.ssl.KeyManager
import javax.net.ssl.KeyManagerFactory
import javax.net.ssl.SNIHostName
import javax.net.ssl.SNIServerName
import javax.net.ssl.SSLContext
import javax.net.ssl.SSLSession
import javax.net.ssl.SSLSocket
import javax.net.ssl.SSLSocketFactory
import javax.net.ssl.StandardConstants
import javax.net.ssl.TrustManager
import javax.net.ssl.TrustManagerFactory
import javax.net.ssl.X509TrustManager
Expand DownExpand Up@@ -83,11 +86,13 @@ fun sslContextFromPEMs(

fun coderSocketFactory(settings: ReadOnlyTLSSettings): SSLSocketFactory {
val sslContext = sslContextFromPEMs(settings.certPath, settings.keyPath, settings.caPath)
if (settings.altHostname.isNullOrBlank()) {

val altHostname = settings.altHostname
if (altHostname.isNullOrBlank()) {
return sslContext.socketFactory
}

return AlternateNameSSLSocketFactory(sslContext.socketFactory,settings.altHostname)
return AlternateNameSSLSocketFactory(sslContext.socketFactory, altHostname)
}

fun coderTrustManagers(tlsCAPath: String?): Array<TrustManager> {
Expand All@@ -111,7 +116,7 @@ fun coderTrustManagers(tlsCAPath: String?): Array<TrustManager> {
return trustManagerFactory.trustManagers.map { MergedSystemTrustManger(it as X509TrustManager) }.toTypedArray()
}

class AlternateNameSSLSocketFactory(private val delegate: SSLSocketFactory, private val alternateName: String?) :
class AlternateNameSSLSocketFactory(private val delegate: SSLSocketFactory, private val alternateName: String) :
SSLSocketFactory() {
override fun getDefaultCipherSuites(): Array<String> = delegate.defaultCipherSuites

Expand DownExpand Up@@ -176,12 +181,19 @@ class AlternateNameSSLSocketFactory(private val delegate: SSLSocketFactory, priv

private fun customizeSocket(socket: SSLSocket) {
val params = socket.sslParameters
params.serverNames = listOf(SNIHostName(alternateName))

params.serverNames = listOf(RelaxedSNIHostname(alternateName))
socket.sslParameters = params
}
}

private class RelaxedSNIHostname(hostname: String) : SNIServerName(
StandardConstants.SNI_HOST_NAME,
IDN.toASCII(hostname, 0).toByteArray(StandardCharsets.UTF_8)
)

class CoderHostnameVerifier(private val alternateName: String?) : HostnameVerifier {

override fun verify(
host: String,
session: SSLSession,
Expand Down
View file
Open in desktop
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,237 @@
package com.coder.toolbox.util

import io.mockk.Runs
import io.mockk.every
import io.mockk.just
import io.mockk.mockk
import io.mockk.verify
import java.net.InetAddress
import java.net.Socket
import javax.net.ssl.SSLParameters
import javax.net.ssl.SSLSocket
import javax.net.ssl.SSLSocketFactory
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertNotNull
import kotlin.test.assertSame


class AlternateNameSSLSocketFactoryTest {

@Test
fun `createSocket with no parameters should customize socket with alternate name`() {
// Given
val mockFactory = mockk<SSLSocketFactory>()
val mockSocket = mockk<SSLSocket>(relaxed = true)
val mockParams = mockk<SSLParameters>(relaxed = true)

every { mockFactory.createSocket() } returns mockSocket
every { mockSocket.sslParameters } returns mockParams
every { mockSocket.sslParameters = any() } just Runs

val alternateFactory = AlternateNameSSLSocketFactory(mockFactory, "alternate.example.com")

// When
val result = alternateFactory.createSocket()

// Then
verify { mockSocket.sslParameters = any() }
assertSame(mockSocket, result)
}

@Test
fun `createSocket with host and port should customize socket with alternate name`() {
// Given
val mockFactory = mockk<SSLSocketFactory>()
val mockSocket = mockk<SSLSocket>(relaxed = true)
val mockParams = mockk<SSLParameters>(relaxed = true)

every { mockFactory.createSocket("original.com", 443) } returns mockSocket
every { mockSocket.sslParameters } returns mockParams
every { mockSocket.sslParameters = any() } just Runs

val alternateFactory = AlternateNameSSLSocketFactory(mockFactory, "alternate.example.com")

// When
val result = alternateFactory.createSocket("original.com", 443)

// Then
verify { mockSocket.sslParameters = any() }
assertSame(mockSocket, result)
}

@Test
fun `createSocket with host port and local address should customize socket`() {
// Given
val mockFactory = mockk<SSLSocketFactory>()
val mockSocket = mockk<SSLSocket>(relaxed = true)
val mockParams = mockk<SSLParameters>(relaxed = true)
val localHost = mockk<InetAddress>()

every { mockFactory.createSocket("original.com", 443, localHost, 8080) } returns mockSocket
every { mockSocket.sslParameters } returns mockParams
every { mockSocket.sslParameters = any() } just Runs

val alternateFactory = AlternateNameSSLSocketFactory(mockFactory, "alternate.example.com")

// When
val result = alternateFactory.createSocket("original.com", 443, localHost, 8080)

// Then
verify { mockSocket.sslParameters = any() }
assertSame(mockSocket, result)
}

@Test
fun `createSocket with InetAddress should customize socket with alternate name`() {
// Given
val mockFactory = mockk<SSLSocketFactory>()
val mockSocket = mockk<SSLSocket>(relaxed = true)
val mockParams = mockk<SSLParameters>(relaxed = true)
val address = mockk<InetAddress>()

every { mockFactory.createSocket(address, 443) } returns mockSocket
every { mockSocket.sslParameters } returns mockParams
every { mockSocket.sslParameters = any() } just Runs

val alternateFactory = AlternateNameSSLSocketFactory(mockFactory, "alternate.example.com")

// When
val result = alternateFactory.createSocket(address, 443)

// Then
verify { mockSocket.sslParameters = any() }
assertSame(mockSocket, result)
}

@Test
fun `createSocket with InetAddress and local address should customize socket`() {
// Given
val mockFactory = mockk<SSLSocketFactory>()
val mockSocket = mockk<SSLSocket>(relaxed = true)
val mockParams = mockk<SSLParameters>(relaxed = true)
val address = mockk<InetAddress>()
val localAddress = mockk<InetAddress>()

every { mockFactory.createSocket(address, 443, localAddress, 8080) } returns mockSocket
every { mockSocket.sslParameters } returns mockParams
every { mockSocket.sslParameters = any() } just Runs

val alternateFactory = AlternateNameSSLSocketFactory(mockFactory, "alternate.example.com")

// When
val result = alternateFactory.createSocket(address, 443, localAddress, 8080)

// Then
verify { mockSocket.sslParameters = any() }
assertSame(mockSocket, result)
}

@Test
fun `createSocket with existing socket should customize socket with alternate name`() {
// Given
val mockFactory = mockk<SSLSocketFactory>()
val mockSSLSocket = mockk<SSLSocket>(relaxed = true)
val mockParams = mockk<SSLParameters>(relaxed = true)
val existingSocket = mockk<Socket>()

every { mockFactory.createSocket(existingSocket, "original.com", 443, true) } returns mockSSLSocket
every { mockSSLSocket.sslParameters } returns mockParams
every { mockSSLSocket.sslParameters = any() } just Runs

val alternateFactory = AlternateNameSSLSocketFactory(mockFactory, "alternate.example.com")

// When
val result = alternateFactory.createSocket(existingSocket, "original.com", 443, true)

// Then
verify { mockSSLSocket.sslParameters = any() }
assertSame(mockSSLSocket, result)
}

@Test
fun `customizeSocket should set SNI hostname to alternate name for valid hostname`() {
// Given
val mockFactory = mockk<SSLSocketFactory>()
val mockSocket = mockk<SSLSocket>(relaxed = true)
val mockParams = mockk<SSLParameters>(relaxed = true)

every { mockFactory.createSocket() } returns mockSocket
every { mockSocket.sslParameters } returns mockParams
every { mockSocket.sslParameters = any() } just Runs

val alternateFactory = AlternateNameSSLSocketFactory(mockFactory, "valid-hostname.example.com")

// When & Then - This should work without throwing an exception
assertNotNull(alternateFactory.createSocket())
verify { mockSocket.sslParameters = any() }
}

@Test
fun `customizeSocket should NOT throw IllegalArgumentException for hostname with underscore`() {
// Given
val mockFactory = mockk<SSLSocketFactory>()
val mockSocket = mockk<SSLSocket>(relaxed = true)
val mockParams = mockk<SSLParameters>(relaxed = true)

every { mockFactory.createSocket() } returns mockSocket
every { mockSocket.sslParameters } returns mockParams
every { mockSocket.sslParameters = any() } just Runs

val alternateFactory = AlternateNameSSLSocketFactory(mockFactory, "non_compliant_hostname.example.com")

// When & Then - This should work without throwing an exception
assertNotNull(alternateFactory.createSocket())
verify { mockSocket.sslParameters = any() }
assertEquals(0, mockSocket.sslParameters.serverNames.size)
}

@Test
fun `createSocket should work with valid international domain names`() {
// Given
val mockFactory = mockk<SSLSocketFactory>()
val mockSocket = mockk<SSLSocket>(relaxed = true)
val mockParams = mockk<SSLParameters>(relaxed = true)

every { mockFactory.createSocket() } returns mockSocket
every { mockSocket.sslParameters } returns mockParams
every { mockSocket.sslParameters = any() } just Runs

val alternateFactory = AlternateNameSSLSocketFactory(mockFactory, "test-server.example.com")

// When & Then - This should work as hyphens are valid
assertNotNull(alternateFactory.createSocket())
verify { mockSocket.sslParameters = any() }
}

private fun createMockSSLSocketFactory(): SSLSocketFactory {
val mockFactory = mockk<SSLSocketFactory>()
val mockSocket = mockk<SSLSocket>(relaxed = true)
val mockParams = mockk<SSLParameters>(relaxed = true)

// Setup default behavior
every { mockFactory.defaultCipherSuites } returns arrayOf("TLS_AES_256_GCM_SHA384")
every { mockFactory.supportedCipherSuites } returns arrayOf("TLS_AES_256_GCM_SHA384", "TLS_AES_128_GCM_SHA256")

// Make all createSocket methods return our mock socket
every { mockFactory.createSocket() } returns mockSocket
every { mockFactory.createSocket(any<String>(), any<Int>()) } returns mockSocket
every { mockFactory.createSocket(any<String>(), any<Int>(), any<InetAddress>(), any<Int>()) } returns mockSocket
every { mockFactory.createSocket(any<InetAddress>(), any<Int>()) } returns mockSocket
every {
mockFactory.createSocket(
any<InetAddress>(),
any<Int>(),
any<InetAddress>(),
any<Int>()
)
} returns mockSocket
every { mockFactory.createSocket(any<Socket>(), any<String>(), any<Int>(), any<Boolean>()) } returns mockSocket

// Setup SSL parameters
every { mockSocket.sslParameters } returns mockParams
every { mockSocket.sslParameters = any() } just Runs

return mockFactory
}
}
Loading
Loading
[8]ページ先頭
©2009-2025 Movatter.jp