diff --git a/app/src/main/java/com/tucavr/VRActivity.kt b/app/src/main/java/com/tucavr/VRActivity.kt index e557b258..434d1be4 100644 --- a/app/src/main/java/com/tucavr/VRActivity.kt +++ b/app/src/main/java/com/tucavr/VRActivity.kt @@ -2200,6 +2200,7 @@ class VRActivity : NativeActivity() { message: String, confirmText: String = getString(R.string.network_delete_server_confirm), cancelText: String = getString(R.string.network_delete_server_cancel), + onCancel: () -> Unit = {}, onConfirm: () -> Unit, ) { runOnUiThread { @@ -2209,6 +2210,7 @@ class VRActivity : NativeActivity() { message = message, confirmText = confirmText, cancelText = cancelText, + onCancel = onCancel, onConfirm = onConfirm, ) } diff --git a/app/src/main/java/com/tucavr/VRModalPresentation.kt b/app/src/main/java/com/tucavr/VRModalPresentation.kt index 4b3cf7da..fd43d7c2 100644 --- a/app/src/main/java/com/tucavr/VRModalPresentation.kt +++ b/app/src/main/java/com/tucavr/VRModalPresentation.kt @@ -202,6 +202,7 @@ class VRModalPresentation( message: String, confirmText: String = context.getString(R.string.network_delete_server_confirm), cancelText: String = context.getString(R.string.network_delete_server_cancel), + onCancel: () -> Unit = {}, onConfirm: () -> Unit, ) { val modal = @@ -215,7 +216,10 @@ class VRModalPresentation( dismissModal() onConfirm() }, - onDismiss = { dismissModal() }, + onDismiss = { + dismissModal() + onCancel() + }, ) showModal(modal) } diff --git a/app/src/main/java/com/tucavr/network/SftpCredentialStore.kt b/app/src/main/java/com/tucavr/network/SftpCredentialStore.kt index 96d5270a..12f06133 100644 --- a/app/src/main/java/com/tucavr/network/SftpCredentialStore.kt +++ b/app/src/main/java/com/tucavr/network/SftpCredentialStore.kt @@ -86,6 +86,22 @@ class SftpCredentialStore( } } + /** + * Pins [fingerprint] for a saved server, or forgets the pinned one when null so the next + * connection asks the user to trust the server again (#223). Password and key are kept. + */ + fun setHostKeyFingerprint( + id: String, + fingerprint: String?, + ) { + credentials.saveCredentials( + id, + password = credentials.getPassword(id), + privateKey = credentials.getPrivateKey(id), + hostKeyFingerprint = fingerprint, + ) + } + fun remove(id: String) { runBlocking(Dispatchers.IO) { try { diff --git a/app/src/main/java/com/tucavr/network/SftpHostKeyStatus.kt b/app/src/main/java/com/tucavr/network/SftpHostKeyStatus.kt new file mode 100644 index 00000000..f28a8737 --- /dev/null +++ b/app/src/main/java/com/tucavr/network/SftpHostKeyStatus.kt @@ -0,0 +1,49 @@ +package com.tucavr.network + +/** + * Host key outcome of an SFTP call, read from the `HOST_KEY_*` codes that + * `connect_nodelay` in `rust/protocols/src/sftp/mod.rs` returns (#57 TOFU, #223). + */ +sealed class SftpHostKeyStatus { + /** No fingerprint was pinned: the user must trust [fingerprint] before it is stored. */ + data class NeedsConfirmation(val fingerprint: String, val keyType: String?) : SftpHostKeyStatus() + + /** The server presented a key other than the pinned one (reinstalled server or MITM). */ + data class IdentityChanged(val expected: String?, val presented: String?) : SftpHostKeyStatus() + + companion object { + private const val CONFIRM = "HOST_KEY_CONFIRM:" + private const val CHANGED = "HOST_KEY_CHANGED:" + private val TYPE_TOKEN = Regex("""\btype=(\S+)""") + private val EXPECTED = Regex("""^expected (\S+?),""") + private val PRESENTED = Regex("""server presented (\S+)""") + + /** + * Parses a native SFTP result, with or without the `ERROR:` prefix + * ([com.tucavr.filebrowser.NetworkDirectoryLoader] strips it). Returns null for + * listings and for errors unrelated to the host key. + */ + fun parse(result: String): SftpHostKeyStatus? { + val message = result.trim().removePrefix("ERROR:").trim() + return when { + message.startsWith(CONFIRM) -> { + val rest = message.removePrefix(CONFIRM) + val fingerprint = rest.substringBefore(' ').trim() + if (fingerprint.isEmpty()) { + null + } else { + NeedsConfirmation(fingerprint, TYPE_TOKEN.find(rest)?.groupValues?.get(1)) + } + } + message.startsWith(CHANGED) -> { + val rest = message.removePrefix(CHANGED) + IdentityChanged( + expected = EXPECTED.find(rest)?.groupValues?.get(1), + presented = PRESENTED.find(rest)?.groupValues?.get(1), + ) + } + else -> null + } + } + } +} diff --git a/app/src/main/java/com/tucavr/screens/NetworkSftpScreen.kt b/app/src/main/java/com/tucavr/screens/NetworkSftpScreen.kt index 0467750e..22360c94 100644 --- a/app/src/main/java/com/tucavr/screens/NetworkSftpScreen.kt +++ b/app/src/main/java/com/tucavr/screens/NetworkSftpScreen.kt @@ -11,6 +11,7 @@ import androidx.recyclerview.widget.LinearLayoutManager import androidx.recyclerview.widget.RecyclerView import com.tucavr.R import com.tucavr.VRActivity +import com.tucavr.debug.VRLog import com.tucavr.designsystem.FieldValidators import com.tucavr.designsystem.VoidButton import com.tucavr.designsystem.VoidButtonStyle @@ -39,6 +40,7 @@ import com.tucavr.filebrowser.sortMediaEntries import com.tucavr.navigation.Destination import com.tucavr.navigation.PlaybackSource import com.tucavr.network.SftpCredentialStore +import com.tucavr.network.SftpHostKeyStatus import com.tucavr.network.SftpServer import com.tucavr.screens.adapters.FileAdapter import com.tucavr.screens.components.MediaBrowserToolbar @@ -196,6 +198,40 @@ class NetworkSftpScreen( } var currentFingerprint: String? = prefill?.hostKeyFingerprint + val savedServerId = prefill?.existingServerId + val serverLabel = { fieldName.getText().trim().ifEmpty { fieldHost.getText().trim() } } + + val pinnedKeyRow = + if (savedServerId != null && currentFingerprint != null) { + LinearLayout(context).apply { orientation = LinearLayout.VERTICAL } + } else { + null + } + if (pinnedKeyRow != null && savedServerId != null) { + pinnedKeyRow.addView( + VoidText.body( + context, + context.getString(R.string.network_sftp_pinned_host_key_format, currentFingerprint), + sizeSp = 14f, + secondary = true, + ), + ) + pinnedKeyRow.addView( + VoidButton(context, VoidButtonStyle.SECONDARY).apply { + text = context.getString(R.string.network_sftp_forget_host_key) + textSize = 15f + minHeight = VoidTheme.dpToPx(context, 48f) + setOnClickListener { + scope.launch { + withContext(Dispatchers.IO) { credentialStore.setHostKeyFingerprint(savedServerId, null) } + currentFingerprint = null + pinnedKeyRow.visibility = View.GONE + statusText.text = context.getString(R.string.network_sftp_host_key_forgotten) + } + } + }, + ) + } val btnTest = VoidButton(context, VoidButtonStyle.SECONDARY).apply { @@ -220,36 +256,41 @@ class NetworkSftpScreen( fieldKey.setError(context.getString(R.string.network_sftp_form_status_auth_required)) return@setOnClickListener } + + fun showResult(result: String) { + statusText.text = + if (result.startsWith("ERROR:")) { + sftpErrorText(result) + } else { + context.getString(R.string.network_sftp_form_status_connected) + } + } + statusText.text = context.getString(R.string.network_sftp_form_status_connecting) scope.launch { - val result = + val firstTry = withContext(Dispatchers.IO) { - val fp = currentFingerprint ?: "" - val firstTry = activity.nativeSftpListDirectory(hostStr, port, user, pass, key, fp, "") - if (firstTry.startsWith("ERROR:HOST_KEY_CONFIRM:")) { - val discovered = - firstTry.removePrefix("ERROR:HOST_KEY_CONFIRM:") - .trim() - .substringBefore(" ") - .trim() - if (discovered.isNotEmpty()) { - currentFingerprint = discovered - activity.nativeSftpListDirectory(hostStr, port, user, pass, key, discovered, "") - } else { - firstTry + activity.nativeSftpListDirectory(hostStr, port, user, pass, key, currentFingerprint ?: "", "") + } + val unknownKey = SftpHostKeyStatus.parse(firstTry) as? SftpHostKeyStatus.NeedsConfirmation + if (unknownKey == null) { + showResult(firstTry) + return@launch + } + askToTrustHostKey( + serverLabel(), + unknownKey, + onCancel = { statusText.text = context.getString(R.string.network_sftp_trust_canceled) }, + ) { + currentFingerprint = unknownKey.fingerprint + statusText.text = context.getString(R.string.network_sftp_form_status_connecting) + scope.launch { + val trusted = + withContext(Dispatchers.IO) { + activity.nativeSftpListDirectory(hostStr, port, user, pass, key, unknownKey.fingerprint, "") } - } else { - firstTry - } + showResult(trusted) } - if (result.startsWith("ERROR:")) { - statusText.text = - context.getString( - R.string.network_sftp_form_status_error_format, - result.removePrefix("ERROR:"), - ) - } else { - statusText.text = context.getString(R.string.network_sftp_form_status_connected) } } } @@ -279,12 +320,9 @@ class NetworkSftpScreen( return@setOnClickListener } - val serverId = prefill?.existingServerId ?: credentialStore.newId() - scope.launch { - val fpToSave = - currentFingerprint ?: withContext(Dispatchers.IO) { - activity.nativeSftpProbeHostKey(hostStr, port).takeIf { !it.startsWith("ERROR:") } - } + val serverId = savedServerId ?: credentialStore.newId() + + fun persist(fingerprint: String?) { val server = SftpServer( id = serverId, @@ -294,13 +332,43 @@ class NetworkSftpScreen( username = user, password = pass, privateKey = if (useKey) key else null, - hostKeyFingerprint = fpToSave, + hostKeyFingerprint = fingerprint, ) - withContext(Dispatchers.IO) { - credentialStore.save(server) + scope.launch { + withContext(Dispatchers.IO) { + credentialStore.save(server) + } + form.clearAll() + onSaved() + } + } + + val pinned = currentFingerprint + if (pinned != null) { + persist(pinned) + return@setOnClickListener + } + statusText.text = context.getString(R.string.network_sftp_form_status_connecting) + scope.launch { + val firstTry = + withContext(Dispatchers.IO) { + activity.nativeSftpListDirectory(hostStr, port, user, pass, key, "", "") + } + val unknownKey = SftpHostKeyStatus.parse(firstTry) as? SftpHostKeyStatus.NeedsConfirmation + if (unknownKey == null) { + // The key exchange never happened (server unreachable): keep the server + // unpinned, browsing it later asks to trust the key first. + persist(null) + return@launch + } + askToTrustHostKey( + finalName, + unknownKey, + onCancel = { statusText.text = context.getString(R.string.network_sftp_trust_canceled) }, + ) { + currentFingerprint = unknownKey.fingerprint + persist(unknownKey.fingerprint) } - form.clearAll() - onSaved() } } } @@ -318,12 +386,46 @@ class NetworkSftpScreen( LinearLayout.LayoutParams(0, ViewGroup.LayoutParams.WRAP_CONTENT, 1f), ) + pinnedKeyRow?.let { form.addView(it) } form.addView(statusText) form.addView(buttonsRow) return form } + /** Asks the user to trust an unknown host key (#223); nothing is pinned unless [onTrust] runs. */ + private fun askToTrustHostKey( + serverLabel: String, + unknownKey: SftpHostKeyStatus.NeedsConfirmation, + onCancel: () -> Unit, + onTrust: () -> Unit, + ) { + activity.openConfirmDeleteModal( + title = context.getString(R.string.network_sftp_trust_title), + message = + context.getString( + R.string.network_sftp_trust_message, + serverLabel, + unknownKey.fingerprint, + unknownKey.keyType ?: "?", + ), + confirmText = context.getString(R.string.network_sftp_trust_confirm), + cancelText = context.getString(R.string.network_sftp_trust_cancel), + onCancel = onCancel, + onConfirm = onTrust, + ) + } + + /** Translated text for a failed SFTP call; the fingerprints of a changed key go to the log only. */ + private fun sftpErrorText(error: String): String { + val changed = SftpHostKeyStatus.parse(error) as? SftpHostKeyStatus.IdentityChanged + if (changed != null) { + VRLog.w("SFTP host key changed: expected ${changed.expected}, server presented ${changed.presented}") + return context.getString(R.string.network_sftp_host_key_changed) + } + return context.getString(R.string.network_sftp_form_status_error_format, error.removePrefix("ERROR:")) + } + // ---- Navegação de diretório SFTP moderna ---- fun renderFiles( @@ -585,12 +687,24 @@ class NetworkSftpScreen( } is NetworkDirectoryState.Error -> { cachedRawEntries = emptyList() - val msg = context.getString(R.string.network_sftp_form_status_error_format, state.message) - countLabel?.text = msg - emptyLabel?.text = msg - clearFiltersButton?.visibility = View.GONE - recyclerView?.visibility = View.GONE - emptyContainer?.visibility = View.VISIBLE + val unknownKey = SftpHostKeyStatus.parse(state.message) as? SftpHostKeyStatus.NeedsConfirmation + showBrowseError( + if (unknownKey != null) context.getString(R.string.network_sftp_trust_title) else sftpErrorText(state.message), + ) + val server = browsingServer + if (unknownKey != null && server != null) { + askToTrustHostKey( + server.name, + unknownKey, + onCancel = { showBrowseError(context.getString(R.string.network_sftp_trust_canceled)) }, + ) { + val trusted = server.copy(hostKeyFingerprint = unknownKey.fingerprint) + scope.launch { + withContext(Dispatchers.IO) { credentialStore.setHostKeyFingerprint(trusted.id, unknownKey.fingerprint) } + renderFiles(trusted) + } + } + } } is NetworkDirectoryState.Empty -> { cachedRawEntries = emptyList() @@ -603,6 +717,14 @@ class NetworkSftpScreen( } } + private fun showBrowseError(message: String) { + countLabel?.text = message + emptyLabel?.text = message + clearFiltersButton?.visibility = View.GONE + recyclerView?.visibility = View.GONE + emptyContainer?.visibility = View.VISIBLE + } + private fun applyFiltersAndSort() { val currentAdapter = adapter ?: return val showUp = browsePath.isNotEmpty() diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml index d339c957..01b30f28 100644 --- a/app/src/main/res/values-es/strings.xml +++ b/app/src/main/res/values-es/strings.xml @@ -375,6 +375,15 @@ Conectando… Error: %1$s Conectado + ¿Confiar en este servidor? + Es la primera conexión con %1$s. Compara esta huella digital con la del servidor (ssh-keygen -lf en el servidor); una vez confiada, se guarda y se comprueba en cada conexión.\n\n%2$s · %3$s + Confiar y conectar + Cancelar + Servidor no confiado. No se guardó nada. + La identidad del servidor cambió. Si lo esperabas (servidor reinstalado o recreado), edita el servidor, olvida su clave y vuelve a conectar. + Clave de confianza del servidor: %1$s + Olvidar clave del servidor + Clave olvidada. La próxima conexión te pedirá confiar en el servidor de nuevo. Servidores guardados diff --git a/app/src/main/res/values-pt-rBR/strings.xml b/app/src/main/res/values-pt-rBR/strings.xml index cbc6755e..2f55514b 100644 --- a/app/src/main/res/values-pt-rBR/strings.xml +++ b/app/src/main/res/values-pt-rBR/strings.xml @@ -374,6 +374,15 @@ Conectando... Falha: %1$s Conectado + Confiar neste servidor? + É a primeira conexão com %1$s. Compare esta impressão digital com a do servidor (ssh-keygen -lf no servidor); depois de confiada, ela fica salva e é conferida em toda conexão.\n\n%2$s · %3$s + Confiar e conectar + Cancelar + Servidor não confiado. Nada foi salvo. + A identidade do servidor mudou. Se isso era esperado (servidor reinstalado ou recriado), edite o servidor, esqueça a chave dele e conecte de novo. + Chave confiável do servidor: %1$s + Esquecer chave do servidor + Chave esquecida. A próxima conexão vai pedir para confiar no servidor de novo. Servidores salvos diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 50022840..ac142ad1 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -384,6 +384,15 @@ Connecting… Failed: %1$s Connected + Trust this server? + This is the first connection to %1$s. Compare this fingerprint with the server\'s own (ssh-keygen -lf on the server); once trusted, it is saved and checked on every connection.\n\n%2$s · %3$s + Trust and connect + Cancel + Server not trusted. Nothing was saved. + The server identity changed. If you expected it (reinstalled or recreated server), edit the server, forget its host key and connect again. + Trusted host key: %1$s + Forget host key + Host key forgotten. The next connection will ask you to trust the server again. Saved servers diff --git a/app/src/test/java/com/tucavr/network/SftpHostKeyStatusTest.kt b/app/src/test/java/com/tucavr/network/SftpHostKeyStatusTest.kt new file mode 100644 index 00000000..7a74323e --- /dev/null +++ b/app/src/test/java/com/tucavr/network/SftpHostKeyStatusTest.kt @@ -0,0 +1,62 @@ +package com.tucavr.network + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Test + +/** + * The inputs are the exact strings `connect_nodelay` (`rust/protocols/src/sftp/mod.rs`) returned + * against the `sftp-test` container in `docker/network-tests/` (first connection, then the + * container recreated with a new host key), + * so a change to that format fails here instead of silently skipping the + * trust prompt (#223). + */ +class SftpHostKeyStatusTest { + private val fp = "SHA256:9dQnTSXZf+GVBocH6vN9Jl8uSqk8EmyRzYlqId6rVLE" + private val other = "SHA256:euilPQ6S0v7hH83tKpTAt+d+pLfbziFFY62NroAnAE4" + + @Test + fun unknownKeyAsksForConfirmationWithFingerprintAndKeyType() { + val status = + SftpHostKeyStatus.parse("ERROR:HOST_KEY_CONFIRM:$fp type=ssh-ed25519 needs confirmation: $fp") + + assertEquals(SftpHostKeyStatus.NeedsConfirmation(fp, "ssh-ed25519"), status) + } + + @Test + fun directoryLoaderMessageWithoutErrorPrefixIsStillRecognised() { + val status = SftpHostKeyStatus.parse("HOST_KEY_CONFIRM:$fp type=rsa-sha2-512 needs confirmation: $fp") + + assertEquals(SftpHostKeyStatus.NeedsConfirmation(fp, "rsa-sha2-512"), status) + } + + @Test + fun confirmationWithoutKeyTypeKeepsTheFingerprint() { + val status = SftpHostKeyStatus.parse("ERROR:HOST_KEY_CONFIRM:$fp needs confirmation: $fp") + + assertEquals(SftpHostKeyStatus.NeedsConfirmation(fp, null), status) + } + + @Test + fun changedKeyIsDistinctFromConfirmationAndKeepsBothFingerprints() { + val status = + SftpHostKeyStatus.parse( + "ERROR:HOST_KEY_CHANGED:expected $other, server presented $fp server identity changed: " + + "expected fingerprint $other, server presented $fp", + ) + + assertEquals(SftpHostKeyStatus.IdentityChanged(expected = other, presented = fp), status) + } + + @Test + fun confirmationWithoutFingerprintIsNotTrusted() { + assertNull(SftpHostKeyStatus.parse("ERROR:HOST_KEY_CONFIRM: needs confirmation: ")) + } + + @Test + fun listingsAndOtherErrorsAreNotHostKeyResults() { + assertNull(SftpHostKeyStatus.parse("movie.mkv\t0\t1024\t0")) + assertNull(SftpHostKeyStatus.parse("ERROR:autenticacao SFTP falhou (usuario/senha ou chave privada invalidos)")) + assertNull(SftpHostKeyStatus.parse("")) + } +} diff --git a/rust/protocols/src/sftp/host_key.rs b/rust/protocols/src/sftp/host_key.rs index f0709690..cb272f86 100644 --- a/rust/protocols/src/sftp/host_key.rs +++ b/rust/protocols/src/sftp/host_key.rs @@ -63,6 +63,17 @@ pub fn compute_fingerprint(key: &PublicKeyOrCertificate) -> String { } } +/// SSH algorithm name of the key behind [`compute_fingerprint`] (e.g. `ssh-ed25519`), shown next +/// to the fingerprint so the user can compare both against `ssh-keygen -lf` on the server. +pub fn key_type(key: &PublicKeyOrCertificate) -> String { + match key { + PublicKeyOrCertificate::PublicKey { key, .. } => key.algorithm().as_str().to_string(), + PublicKeyOrCertificate::Certificate(cert) => { + cert.public_key().algorithm().as_str().to_string() + } + } +} + /// Compares the expected host key fingerprint (if any) against the actual fingerprint. /// /// - If `expected_fingerprint` matches `actual_fingerprint`, returns `Ok(())`. @@ -118,6 +129,12 @@ mod tests { (public_key, expected_fp) } + #[test] + fn key_type_names_the_ssh_algorithm() { + let (key, _) = test_key_and_fingerprint(); + assert_eq!(key_type(&key), "ssh-ed25519"); + } + #[test] fn known_fingerprint_matches() { let (key, fingerprint) = test_key_and_fingerprint(); diff --git a/rust/protocols/src/sftp/mod.rs b/rust/protocols/src/sftp/mod.rs index efd487d3..95bc1367 100644 --- a/rust/protocols/src/sftp/mod.rs +++ b/rust/protocols/src/sftp/mod.rs @@ -73,8 +73,8 @@ pub mod host_key; pub mod uri; pub use host_key::{ - HostKeyError, compute_fingerprint, normalize_fingerprint, verify_host_key_fingerprint, - verify_server_public_key, + HostKeyError, compute_fingerprint, key_type, normalize_fingerprint, + verify_host_key_fingerprint, verify_server_public_key, }; pub use uri::{SftpTarget, is_sftp_uri, redact}; @@ -153,7 +153,12 @@ const SFTP_CHUNK_RETRY_TIMEOUT: Duration = Duration::from_millis(2000); /// Realiza a verificacao da host key do servidor (T6.2 / #57 TOFU). struct SftpHandler { expected_fingerprint: Option, - check_result: Arc>>>, + check_result: Arc>>, +} + +struct HostKeyCheck { + result: Result, + key_type: String, } impl Handler for SftpHandler { @@ -163,10 +168,14 @@ impl Handler for SftpHandler { &mut self, server_public_key: &PublicKeyOrCertificate, ) -> Result { - let res = verify_server_public_key(self.expected_fingerprint.as_deref(), server_public_key); - let ok = res.is_ok(); + let result = + verify_server_public_key(self.expected_fingerprint.as_deref(), server_public_key); + let ok = result.is_ok(); if let Ok(mut lock) = self.check_result.lock() { - *lock = Some(res); + *lock = Some(HostKeyCheck { + result, + key_type: key_type(server_public_key), + }); } Ok(ok) } @@ -205,13 +214,15 @@ async fn connect_nodelay( Ok(handle) => Ok(handle), Err(e) => { if let Ok(guard) = check_result.lock() { - match &*guard { - Some(Err(HostKeyError::NeedsConfirmation { fingerprint })) => { + match guard.as_ref().map(|check| (&check.result, &check.key_type)) { + Some((Err(HostKeyError::NeedsConfirmation { fingerprint }), key_type)) => { + // The fingerprint stays the first token: `probe_server_fingerprint` and + // the Kotlin parser (`SftpHostKeyStatus`) both read it that way. return Err(format!( - "HOST_KEY_CONFIRM:{fingerprint} needs confirmation: {fingerprint}" + "HOST_KEY_CONFIRM:{fingerprint} type={key_type} needs confirmation: {fingerprint}" )); } - Some(Err(HostKeyError::IdentityChanged { expected, actual })) => { + Some((Err(HostKeyError::IdentityChanged { expected, actual }), _)) => { return Err(format!( "HOST_KEY_CHANGED:expected {expected}, server presented {actual} server identity changed: expected fingerprint {expected}, server presented {actual}" )); diff --git a/rust/protocols/tests/sftp_integration.rs b/rust/protocols/tests/sftp_integration.rs index bb2582df..1190842d 100644 --- a/rust/protocols/tests/sftp_integration.rs +++ b/rust/protocols/tests/sftp_integration.rs @@ -380,6 +380,14 @@ fn tofu_first_connection_without_fingerprint_returns_needs_confirmation() { err.contains("needs confirmation") || err.contains("HOST_KEY_CONFIRM:"), "erro esperado de confirmacao de chave, obteve: {err}" ); + // #223: the trust prompt shows the key type next to the fingerprint. + assert!( + err.contains(&format!( + "HOST_KEY_CONFIRM:{} type=ssh-", + server_fingerprint() + )), + "erro de confirmacao sem o tipo da chave: {err}" + ); } /// T6.2 / #57: Conexão com fingerprint diferente do esperado (ou container recriado com nova chave)