diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 43060b5..ec9940a 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -44,12 +44,20 @@ jobs:
       - name: Build the SSH test server
         run: docker build -t ssh-core-test -f ssh-core/tests/docker/Dockerfile ssh-core/tests
 
+      # One network for the whole fixture: the bastion reaches the target only
+      # over it, and `ssh-core-http` has no published port at all. Port 9000 is
+      # published so a remote forward bound inside the container is reachable.
       - name: Start the SSH test servers
         run: |
-          docker run -d --name ssh-core-password -p 2222:2222 ssh-core-test password
-          docker run -d --name ssh-core-twofactor -p 2223:2222 ssh-core-test two-factor
-          docker run -d --name ssh-core-silent -p 2224:2222 ssh-core-test silent
-          for port in 2222 2223 2224; do
+          set -euo pipefail
+          docker network create ssh-core-net
+          docker run -d --name ssh-core-password --network ssh-core-net -p 2222:2222 -p 9000:9000 ssh-core-test password
+          docker run -d --name ssh-core-twofactor --network ssh-core-net -p 2223:2222 ssh-core-test two-factor
+          docker run -d --name ssh-core-silent --network ssh-core-net -p 2224:2222 ssh-core-test silent
+          docker run -d --name ssh-core-http --network ssh-core-net ssh-core-test http
+          docker run -d --name ssh-core-bastion --network ssh-core-net -p 2226:2222 ssh-core-test password
+          docker run -d --name ssh-core-target --network ssh-core-net ssh-core-test password
+          for port in 2222 2223 2224 2226; do
             for attempt in $(seq 1 30); do
               if (exec 3<>"/dev/tcp/127.0.0.1/$port") 2>/dev/null; then break; fi
               sleep 1
@@ -59,19 +67,29 @@ jobs:
       - name: Run the integration suite
         env:
           SSH_TEST_HOST: 127.0.0.1
-        run: cargo test --test integration
+          SSH_TEST_REMOTE_FORWARD_PORT: '9000'
+          SSH_TEST_HTTP_HOST: ssh-core-http
+          SSH_TEST_HTTP_PORT: '8080'
+          SSH_TEST_BASTION_PORT: '2226'
+          SSH_TEST_TARGET_HOST: ssh-core-target
+          SSH_TEST_TARGET_PORT: '2222'
+          SSH_TEST_THIRD_HOP_HOST: ssh-core-password
+          SSH_TEST_THIRD_HOP_PORT: '2222'
+        run: cargo test --test integration --test transfers
 
       - name: Show the server logs on failure
         if: failure()
         run: |
-          for name in ssh-core-password ssh-core-twofactor ssh-core-silent; do
+          for name in ssh-core-password ssh-core-twofactor ssh-core-silent ssh-core-http ssh-core-bastion ssh-core-target; do
             echo "== $name"
             docker logs "$name" || true
           done
 
       - name: Stop the SSH test servers
         if: always()
-        run: docker rm -f ssh-core-password ssh-core-twofactor ssh-core-silent
+        run: |
+          docker rm -f ssh-core-password ssh-core-twofactor ssh-core-silent ssh-core-http ssh-core-bastion ssh-core-target
+          docker network rm ssh-core-net
 
 
   android:
diff --git a/android/src/main/java/ai/kilo/reactnativessh/ReactNativeSshModule.kt b/android/src/main/java/ai/kilo/reactnativessh/ReactNativeSshModule.kt
index 0d020c3..d70f7d8 100644
--- a/android/src/main/java/ai/kilo/reactnativessh/ReactNativeSshModule.kt
+++ b/android/src/main/java/ai/kilo/reactnativessh/ReactNativeSshModule.kt
@@ -2,9 +2,18 @@ package ai.kilo.reactnativessh
 
 import ai.kilo.reactnativessh.terminal.TerminalSourceRegistry
 import ai.kilo.reactnativessh.uniffi.AuthMethod
+import ai.kilo.reactnativessh.uniffi.CancelToken
 import ai.kilo.reactnativessh.uniffi.ConnectConfig
+import ai.kilo.reactnativessh.uniffi.Entry
+import ai.kilo.reactnativessh.uniffi.EntryKind
+import ai.kilo.reactnativessh.uniffi.ForwardConfig
+import ai.kilo.reactnativessh.uniffi.ForwardHandle
+import ai.kilo.reactnativessh.uniffi.ForwardSink
+import ai.kilo.reactnativessh.uniffi.SessionHandler
+import ai.kilo.reactnativessh.uniffi.SftpClient
 import ai.kilo.reactnativessh.uniffi.SshException
 import ai.kilo.reactnativessh.uniffi.SshSession
+import ai.kilo.reactnativessh.uniffi.TransferProgress
 import ai.kilo.reactnativessh.uniffi.categoryIsRetryable
 import ai.kilo.reactnativessh.uniffi.coreVersion
 import ai.kilo.reactnativessh.uniffi.generateEd25519Key
@@ -21,18 +30,31 @@ import kotlinx.coroutines.launch
 internal const val EVENT_HOST_KEY = "onHostKey"
 internal const val EVENT_KEYBOARD_INTERACTIVE = "onKeyboardInteractive"
 internal const val EVENT_DISCONNECT = "onDisconnect"
+internal const val EVENT_TRANSFER_PROGRESS = "onTransferProgress"
+internal const val EVENT_FORWARD_ERROR = "onForwardError"
 
 class ReactNativeSshModule : Module() {
   private val sessions = ConcurrentHashMap<String, SshSession>()
   private val shells = ConcurrentHashMap<String, SshShellSource>()
+  private val sftps = ConcurrentHashMap<String, SftpClient>()
+  private val forwards = ConcurrentHashMap<String, ForwardHandle>()
+  private val cancels = ConcurrentHashMap<String, CancelToken>()
   private val hostKeyRequests = ConcurrentHashMap<String, CompletableDeferred<Boolean>>()
   private val promptRequests = ConcurrentHashMap<String, CompletableDeferred<List<String>?>>()
   private val sessionIds = IdSequence("session-")
   private val shellIds = IdSequence("shell-")
+  private val sftpIds = IdSequence("sftp-")
+  private val forwardIds = IdSequence("forward-")
 
   override fun definition() = ModuleDefinition {
     Name("ReactNativeSsh")
-    Events(EVENT_HOST_KEY, EVENT_KEYBOARD_INTERACTIVE, EVENT_DISCONNECT)
+    Events(
+      EVENT_HOST_KEY,
+      EVENT_KEYBOARD_INTERACTIVE,
+      EVENT_DISCONNECT,
+      EVENT_TRANSFER_PROGRESS,
+      EVENT_FORWARD_ERROR,
+    )
 
     Function("coreVersion") {
       coreVersion()
@@ -56,7 +78,13 @@ class ReactNativeSshModule : Module() {
     }
 
     AsyncFunction("connect").SuspendBody { config: ConnectConfigRecord ->
-      connectSession(config)
+      connectSession(config) { handler -> SshSession.connect(config.toNative(), handler) }
+    }
+
+    AsyncFunction("connectVia").SuspendBody { jumpSessionId: String, config: ConnectConfigRecord ->
+      val jump = session(jumpSessionId)
+
+      connectSession(config) { handler -> SshSession.connectVia(jump, config.toNative(), handler) }
     }
 
     AsyncFunction("exec").SuspendBody { sessionId: String, command: String ->
@@ -87,16 +115,95 @@ class ReactNativeSshModule : Module() {
       categoryIsRetryable(code)
     }
 
+    AsyncFunction("openSftp").SuspendBody { sessionId: String ->
+      val sftpId = sftpIds.next()
+      sftps[sftpId] = translateSuspendFailures { session(sessionId).openSftp() }
+
+      sftpId
+    }
+
+    AsyncFunction("closeSftp").SuspendBody { sftpId: String ->
+      sftps.remove(sftpId)?.let { client -> translateSuspendFailures { client.shutdown() } }
+    }
+
+    AsyncFunction("sftpList").SuspendBody { sftpId: String, path: String ->
+      translateSuspendFailures { sftp(sftpId).list(path) }.map(Entry::toRecord)
+    }
+
+    AsyncFunction("sftpStat").SuspendBody { sftpId: String, path: String ->
+      translateSuspendFailures { sftp(sftpId).stat(path) }.toRecord()
+    }
+
+    AsyncFunction("sftpRealpath").SuspendBody { sftpId: String, path: String ->
+      translateSuspendFailures { sftp(sftpId).realpath(path) }
+    }
+
+    AsyncFunction("sftpMkdir").SuspendBody { sftpId: String, path: String ->
+      translateSuspendFailures { sftp(sftpId).mkdir(path) }
+    }
+
+    AsyncFunction("sftpRename").SuspendBody { sftpId: String, from: String, to: String ->
+      translateSuspendFailures { sftp(sftpId).rename(from, to) }
+    }
+
+    AsyncFunction("sftpRemoveFile").SuspendBody { sftpId: String, path: String ->
+      translateSuspendFailures { sftp(sftpId).removeFile(path) }
+    }
+
+    AsyncFunction("sftpRemoveDir").SuspendBody { sftpId: String, path: String ->
+      translateSuspendFailures { sftp(sftpId).removeDir(path) }
+    }
+
+    AsyncFunction("sftpDownload")
+      .SuspendBody { sftpId: String, remotePath: String, localPath: String, transferId: String ->
+        transfer(transferId) { progress, cancel ->
+          sftp(sftpId).download(remotePath, localPath, progress, cancel)
+        }
+      }
+
+    AsyncFunction("sftpUpload")
+      .SuspendBody { sftpId: String, localPath: String, remotePath: String, transferId: String ->
+        transfer(transferId) { progress, cancel ->
+          sftp(sftpId).upload(localPath, remotePath, progress, cancel)
+        }
+      }
+
+    Function("cancelTransfer") { transferId: String ->
+      cancels[transferId]?.cancel()
+    }
+
+    AsyncFunction("startLocalForward").SuspendBody { sessionId: String, config: ForwardConfigRecord ->
+      registerForward {
+        session(sessionId).startLocalForward(config.toNative(), forwardSink(sessionId))
+      }
+    }
+
+    AsyncFunction("startRemoteForward").SuspendBody { sessionId: String, config: ForwardConfigRecord ->
+      registerForward {
+        session(sessionId).startRemoteForward(config.toNative(), forwardSink(sessionId))
+      }
+    }
+
+    AsyncFunction("stopForward").SuspendBody { forwardId: String ->
+      forwards.remove(forwardId)?.let { handle -> translateSuspendFailures { handle.stop() } }
+    }
+
     OnDestroy {
       val scope = CoroutineScope(Dispatchers.IO)
 
       shells.keys.forEach(::closeShell)
+      sftps.values.forEach { client -> scope.launch { runCatching { client.shutdown() } } }
+      forwards.values.forEach { handle -> scope.launch { runCatching { handle.stop() } } }
+      cancels.values.forEach { token -> token.cancel() }
       sessions.forEach { (_, session) -> scope.launch { runCatching { session.disconnect() } } }
       sessions.clear()
     }
   }
 
-  private suspend fun connectSession(config: ConnectConfigRecord): String {
+  private suspend fun connectSession(
+    config: ConnectConfigRecord,
+    connect: suspend (SessionHandler) -> SshSession,
+  ): String {
     val sessionId = sessionIds.next()
     val handler = JsSessionHandler(
       sessionId = sessionId,
@@ -108,8 +215,7 @@ class ReactNativeSshModule : Module() {
       },
     )
 
-    val session = translateSuspendFailures { SshSession.connect(config.toNative(), handler) }
-    sessions[sessionId] = session
+    sessions[sessionId] = translateSuspendFailures { connect(handler) }
 
     return sessionId
   }
@@ -156,6 +262,52 @@ class ReactNativeSshModule : Module() {
     shells.filterValues { it.sessionId == sessionId }.keys.forEach(::closeShell)
   }
 
+  private suspend fun transfer(
+    transferId: String,
+    run: suspend (TransferProgress, CancelToken) -> ULong,
+  ): Double {
+    val cancel = CancelToken()
+    cancels[transferId] = cancel
+
+    return try {
+      translateSuspendFailures { run(progressSink(transferId), cancel) }.toDouble()
+    } finally {
+      cancels.remove(transferId)
+    }
+  }
+
+  private suspend fun registerForward(start: suspend () -> ForwardHandle): ForwardStartRecord {
+    val forwardId = forwardIds.next()
+    val handle = translateSuspendFailures(start)
+
+    forwards[forwardId] = handle
+
+    return ForwardStartRecord(forwardId, handle.actualPort().toInt())
+  }
+
+  private fun progressSink(transferId: String) = object : TransferProgress {
+    override fun onProgress(transferred: ULong, total: ULong?) {
+      runCatching {
+        sendEvent(
+          EVENT_TRANSFER_PROGRESS,
+          mapOf(
+            "transferId" to transferId,
+            "transferred" to transferred.toDouble(),
+            "total" to total?.toDouble(),
+          ),
+        )
+      }
+    }
+  }
+
+  private fun forwardSink(sessionId: String) = object : ForwardSink {
+    override fun onError(message: String) {
+      runCatching {
+        sendEvent(EVENT_FORWARD_ERROR, mapOf("sessionId" to sessionId, "message" to message))
+      }
+    }
+  }
+
   private suspend fun requestHostKey(request: HostKeyRequestRecord): Boolean {
     val decision = CompletableDeferred<Boolean>()
     hostKeyRequests[request.requestId] = decision
@@ -183,6 +335,10 @@ class ReactNativeSshModule : Module() {
   private fun session(sessionId: String): SshSession =
     sessions[sessionId]
       ?: throw SshException.ChannelClosed("session $sessionId is not connected").toCodedException()
+
+  private fun sftp(sftpId: String): SftpClient =
+    sftps[sftpId]
+      ?: throw SshException.ChannelClosed("sftp $sftpId is not open").toCodedException()
 }
 
 /** Runs a core call, translating its failure into a coded JavaScript error. */
@@ -198,6 +354,33 @@ private suspend fun <T> translateSuspendFailures(call: suspend () -> T): T = try
   throw error.toCodedException()
 }
 
+private fun Entry.toRecord() = SftpEntryRecord(
+  name = name,
+  kind = kind.eventName(),
+  size = size.toDouble(),
+  modifiedUnix = modifiedUnix?.toDouble(),
+  permissions = permissions?.toInt(),
+)
+
+private fun EntryKind.eventName(): String = when (this) {
+  EntryKind.FILE -> "file"
+  EntryKind.DIRECTORY -> "directory"
+  EntryKind.SYMLINK -> "symlink"
+  EntryKind.OTHER -> "other"
+}
+
+private fun ForwardConfigRecord.toNative(): ForwardConfig {
+  require(bindPort in 0..65535) { "bindPort must be between 0 and 65535" }
+  require(destPort in 1..65535) { "destPort must be between 1 and 65535" }
+
+  return ForwardConfig(
+    bindHost = bindHost,
+    bindPort = bindPort.toUShort(),
+    destHost = destHost,
+    destPort = destPort.toUShort(),
+  )
+}
+
 private fun AuthRecord.toNative(): AuthMethod = when (type) {
   "password" -> AuthMethod.Password(requireNotNull(password) { "password auth needs a password" })
   "key" -> AuthMethod.Key(
diff --git a/android/src/main/java/ai/kilo/reactnativessh/SshErrors.kt b/android/src/main/java/ai/kilo/reactnativessh/SshErrors.kt
index 24add4e..178224c 100644
--- a/android/src/main/java/ai/kilo/reactnativessh/SshErrors.kt
+++ b/android/src/main/java/ai/kilo/reactnativessh/SshErrors.kt
@@ -25,4 +25,9 @@ private fun SshException.code(): String = when (this) {
   is SshException.ChannelClosed -> "ChannelClosed"
   is SshException.Protocol -> "Protocol"
   is SshException.KeyGeneration -> "KeyGeneration"
+  is SshException.NotFound -> "NotFound"
+  is SshException.PermissionDenied -> "PermissionDenied"
+  is SshException.Cancelled -> "Cancelled"
+  is SshException.Forwarding -> "Forwarding"
+  is SshException.LocalIo -> "LocalIo"
 }
diff --git a/android/src/main/java/ai/kilo/reactnativessh/SshRecords.kt b/android/src/main/java/ai/kilo/reactnativessh/SshRecords.kt
index d707600..e266921 100644
--- a/android/src/main/java/ai/kilo/reactnativessh/SshRecords.kt
+++ b/android/src/main/java/ai/kilo/reactnativessh/SshRecords.kt
@@ -46,6 +46,26 @@ class ExecOutputRecord(
   @Field val exitStatus: Int?,
 ) : Record
 
+class SftpEntryRecord(
+  @Field val name: String,
+  @Field val kind: String,
+  @Field val size: Double,
+  @Field val modifiedUnix: Double?,
+  @Field val permissions: Int?,
+) : Record
+
+class ForwardConfigRecord : Record {
+  @Field var bindHost: String = "127.0.0.1"
+  @Field var bindPort: Int = 0
+  @Field var destHost: String = ""
+  @Field var destPort: Int = 22
+}
+
+class ForwardStartRecord(
+  @Field val forwardId: String,
+  @Field val port: Int,
+) : Record
+
 internal class HostKeyRequestRecord(
   val sessionId: String,
   val requestId: String,
diff --git a/example/App.tsx b/example/App.tsx
index c6597ec..4a73dbe 100644
--- a/example/App.tsx
+++ b/example/App.tsx
@@ -2,11 +2,13 @@ import { useState } from 'react';
 import { Pressable, StyleSheet, Text, View } from 'react-native';
 
 import SshDemo from './SshDemo';
+import SshFilesDemo from './SshFilesDemo';
 import SshTerminalDemo from './SshTerminalDemo';
 import TerminalDemo from './TerminalDemo';
 
 const DEMOS = [
   { key: 'ssh-terminal', label: 'SSH terminal', Screen: SshTerminalDemo },
+  { key: 'ssh-files', label: 'SSH files', Screen: SshFilesDemo },
   { key: 'terminal', label: 'PTY server terminal', Screen: TerminalDemo },
   { key: 'ssh', label: 'SSH commands', Screen: SshDemo },
 ] as const;
diff --git a/example/SshFilesDemo.tsx b/example/SshFilesDemo.tsx
new file mode 100644
index 0000000..1720bd3
--- /dev/null
+++ b/example/SshFilesDemo.tsx
@@ -0,0 +1,221 @@
+import {
+  SshError,
+  addSshListener,
+  answerHostKey,
+  closeSftp,
+  connect,
+  disconnect,
+  download,
+  exec,
+  isRetryableError,
+  listDirectory,
+  openSftp,
+  startLocalForward,
+} from '@kilocode/react-native-ssh';
+import type { Forward } from '@kilocode/react-native-ssh';
+import { useEffect, useState } from 'react';
+import { Alert, Button, ScrollView, StyleSheet, Text, View } from 'react-native';
+
+/**
+ * Drives SFTP and a local forward against the containers published by
+ * `rust/ssh-core/tests/docker` (`adb reverse tcp:2222 tcp:2222` in the example
+ * app). The forward's destination is resolved from the server, so it names the
+ * `http` container.
+ *
+ * The download target is the example app's own sandbox; an app reads the
+ * directory from `expo-file-system` and appends the file name.
+ */
+const SERVER = {
+  host: '127.0.0.1',
+  port: 2222,
+  username: 'user',
+  password: 'ssh-core-password',
+};
+const REMOTE_DIR = '/home/user';
+const REMOTE_SAMPLE = `${REMOTE_DIR}/sftp-demo.txt`;
+const SANDBOX_FILES = 'file:///data/user/0/ai.kilo.reactnativessh.example/files';
+const HTTP_FIXTURE = { host: 'ssh-core-http', port: 8080 };
+
+export default function SshFilesDemo() {
+  const [sessionId, setSessionId] = useState<string | null>(null);
+  const [sftpId, setSftpId] = useState<string | null>(null);
+  const [lines, setLines] = useState<string[]>([]);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(
+    () =>
+      addSshListener('onHostKey', (request) => {
+        Alert.alert(
+          'Unknown host key',
+          `${request.algorithm}\n${request.fingerprintSha256}`,
+          [
+            {
+              text: 'Reject',
+              style: 'cancel',
+              onPress: () => answerHostKey(request.requestId, false),
+            },
+            { text: 'Accept', onPress: () => answerHostKey(request.requestId, true) },
+          ],
+          { cancelable: false }
+        );
+      }).remove,
+    []
+  );
+
+  useEffect(
+    () =>
+      addSshListener('onForwardError', (notice) => {
+        append(`forward error: ${notice.message}`);
+      }).remove,
+    []
+  );
+
+  function append(line: string) {
+    setLines((current) => [...current, line]);
+  }
+
+  async function openSession() {
+    setError(null);
+    setLines([]);
+
+    try {
+      const id = await connect({
+        host: SERVER.host,
+        port: SERVER.port,
+        username: SERVER.username,
+        auth: { type: 'password', password: SERVER.password },
+      });
+      setSessionId(id);
+      setSftpId(await openSftp(id));
+      append('session and SFTP channel open');
+    } catch (cause) {
+      setError(describe(cause));
+    }
+  }
+
+  async function listRemote() {
+    if (!sftpId) {
+      return;
+    }
+
+    try {
+      const entries = await listDirectory(sftpId, REMOTE_DIR);
+      entries.forEach((entry) =>
+        append(`${entry.kind} ${entry.size} ${entry.name}`)
+      );
+    } catch (cause) {
+      setError(describe(cause));
+    }
+  }
+
+  async function downloadSample() {
+    if (!sftpId || !sessionId) {
+      return;
+    }
+
+    try {
+      await exec(sessionId, `printf 'hello from sftp\\n' > ${REMOTE_SAMPLE}`);
+      const localUrl = `${SANDBOX_FILES}/sftp-demo.txt`;
+      const written = await download(sftpId, REMOTE_SAMPLE, localUrl, {
+        onProgress: (progress) => {
+          append(`downloaded ${progress.transferred}/${progress.total ?? '?'} bytes`);
+        },
+      });
+      append(`download complete: ${written} bytes at ${localUrl}`);
+    } catch (cause) {
+      setError(describe(cause));
+    }
+  }
+
+  async function fetchThroughForward() {
+    if (!sessionId) {
+      return;
+    }
+
+    let forward: Forward | null = null;
+
+    try {
+      forward = await startLocalForward(sessionId, {
+        destHost: HTTP_FIXTURE.host,
+        destPort: HTTP_FIXTURE.port,
+      });
+      append(`forward listening on 127.0.0.1:${forward.port}`);
+
+      const response = await fetch(`http://127.0.0.1:${forward.port}/`);
+      append(`forward response: ${await response.text()}`);
+    } catch (cause) {
+      setError(describe(cause));
+    } finally {
+      await forward?.stop();
+    }
+  }
+
+  async function closeSession() {
+    if (sftpId) {
+      await closeSftp(sftpId);
+      setSftpId(null);
+    }
+    if (sessionId) {
+      await disconnect(sessionId);
+      setSessionId(null);
+    }
+  }
+
+  return (
+    <View style={styles.container}>
+      <ScrollView contentContainerStyle={styles.content}>
+        <Text style={styles.heading}>SFTP and forwarding</Text>
+        <Text testID="sftp-session">{sessionId ?? 'not connected'}</Text>
+
+        <Button title="Connect" onPress={openSession} disabled={!!sessionId} />
+        <Button
+          accessibilityLabel="List remote directory"
+          title="List remote directory"
+          onPress={listRemote}
+          disabled={!sftpId}
+        />
+        <Button
+          accessibilityLabel="Download sample file"
+          title="Download sample file"
+          onPress={downloadSample}
+          disabled={!sftpId}
+        />
+        <Button
+          accessibilityLabel="Fetch through local forward"
+          title="Fetch through local forward"
+          onPress={fetchThroughForward}
+          disabled={!sessionId}
+        />
+        <Button title="Disconnect" onPress={closeSession} disabled={!sessionId} />
+
+        {lines.map((line, index) => (
+          <Text key={`${index}-${line}`} style={styles.output} testID="sftp-output">
+            {line}
+          </Text>
+        ))}
+
+        {error ? (
+          <Text style={styles.error} testID="sftp-error">
+            {error}
+          </Text>
+        ) : null}
+      </ScrollView>
+    </View>
+  );
+}
+
+function describe(cause: unknown): string {
+  if (cause instanceof SshError) {
+    return `${cause.code} (retryable: ${isRetryableError(cause)}): ${cause.message}`;
+  }
+
+  return cause instanceof Error ? cause.message : String(cause);
+}
+
+const styles = StyleSheet.create({
+  container: { flex: 1, backgroundColor: '#f2f2f2', paddingTop: 72 },
+  content: { padding: 20, gap: 12 },
+  heading: { fontSize: 16, fontWeight: '600' },
+  output: { fontFamily: 'Courier', fontSize: 12 },
+  error: { color: '#b00020' },
+});
diff --git a/ios/ReactNativeSshModule.swift b/ios/ReactNativeSshModule.swift
index 4b0b779..886326a 100644
--- a/ios/ReactNativeSshModule.swift
+++ b/ios/ReactNativeSshModule.swift
@@ -5,7 +5,13 @@ public final class ReactNativeSshModule: Module {
 
   public func definition() -> ModuleDefinition {
     Name("ReactNativeSsh")
-    Events("onHostKey", "onKeyboardInteractive", "onDisconnect")
+    Events(
+      "onHostKey",
+      "onKeyboardInteractive",
+      "onDisconnect",
+      "onTransferProgress",
+      "onForwardError"
+    )
 
     Function("coreVersion") { () -> String in
       coreVersion()
@@ -36,6 +42,10 @@ public final class ReactNativeSshModule: Module {
       try await self.connectSession(config)
     }
 
+    AsyncFunction("connectVia") { (jumpSessionId: String, config: ConnectConfigRecord) async throws -> String in
+      try await self.connectSession(config, via: jumpSessionId)
+    }
+
     AsyncFunction("exec") { (sessionId: String, command: String) async throws -> ExecOutputRecord in
       try await self.runCommand(sessionId, command)
     }
@@ -66,9 +76,134 @@ public final class ReactNativeSshModule: Module {
       self.isRetryable(code)
     }
 
+    AsyncFunction("openSftp") { (sessionId: String) async throws -> String in
+      guard let session = self.state.session(sessionId) else {
+        throw channelClosed(sessionId)
+      }
+
+      let sftpId = self.state.sftpIds.next()
+      let client = try await translateAsync { try await session.openSftp() }
+      self.state.store(sftp: client, id: sftpId)
+
+      return sftpId
+    }
+
+    AsyncFunction("closeSftp") { (sftpId: String) async throws in
+      guard let client = self.state.removeSftp(sftpId) else {
+        return
+      }
+
+      try await translateAsync { try await client.shutdown() }
+    }
+
+    AsyncFunction("sftpList") { (sftpId: String, path: String) async throws -> [SftpEntryRecord] in
+      let client = try self.sftp(sftpId)
+      let entries = try await translateAsync { try await client.list(path: path) }
+
+      return entries.map(sftpEntryRecord)
+    }
+
+    AsyncFunction("sftpStat") { (sftpId: String, path: String) async throws -> SftpEntryRecord in
+      let client = try self.sftp(sftpId)
+      let entry = try await translateAsync { try await client.stat(path: path) }
+
+      return sftpEntryRecord(entry)
+    }
+
+    AsyncFunction("sftpRealpath") { (sftpId: String, path: String) async throws -> String in
+      let client = try self.sftp(sftpId)
+
+      return try await translateAsync { try await client.realpath(path: path) }
+    }
+
+    AsyncFunction("sftpMkdir") { (sftpId: String, path: String) async throws in
+      let client = try self.sftp(sftpId)
+
+      try await translateAsync { try await client.mkdir(path: path) }
+    }
+
+    AsyncFunction("sftpRename") { (sftpId: String, from: String, to: String) async throws in
+      let client = try self.sftp(sftpId)
+
+      try await translateAsync { try await client.rename(from: from, to: to) }
+    }
+
+    AsyncFunction("sftpRemoveFile") { (sftpId: String, path: String) async throws in
+      let client = try self.sftp(sftpId)
+
+      try await translateAsync { try await client.removeFile(path: path) }
+    }
+
+    AsyncFunction("sftpRemoveDir") { (sftpId: String, path: String) async throws in
+      let client = try self.sftp(sftpId)
+
+      try await translateAsync { try await client.removeDir(path: path) }
+    }
+
+    AsyncFunction("sftpDownload")
+    { (sftpId: String, remotePath: String, localPath: String, transferId: String) async throws -> Double in
+      let client = try self.sftp(sftpId)
+
+      return try await self.transfer(transferId) { progress, cancel in
+        try await client.download(
+          remotePath: remotePath,
+          localPath: localPath,
+          progress: progress,
+          cancel: cancel
+        )
+      }
+    }
+
+    AsyncFunction("sftpUpload")
+    { (sftpId: String, localPath: String, remotePath: String, transferId: String) async throws -> Double in
+      let client = try self.sftp(sftpId)
+
+      return try await self.transfer(transferId) { progress, cancel in
+        try await client.upload(
+          localPath: localPath,
+          remotePath: remotePath,
+          progress: progress,
+          cancel: cancel
+        )
+      }
+    }
+
+    Function("cancelTransfer") { (transferId: String) in
+      self.state.cancel(transferId)?.cancel()
+    }
+
+    AsyncFunction("startLocalForward")
+    { (sessionId: String, config: ForwardConfigRecord) async throws -> ForwardStartRecord in
+      try await self.startForward(sessionId, config) { session, native, sink in
+        try await session.startLocalForward(config: native, events: sink)
+      }
+    }
+
+    AsyncFunction("startRemoteForward")
+    { (sessionId: String, config: ForwardConfigRecord) async throws -> ForwardStartRecord in
+      try await self.startForward(sessionId, config) { session, native, sink in
+        try await session.startRemoteForward(config: native, events: sink)
+      }
+    }
+
+    AsyncFunction("stopForward") { (forwardId: String) async throws in
+      guard let handle = self.state.removeForward(forwardId) else {
+        return
+      }
+
+      try await translateAsync { try await handle.stop() }
+    }
+
     OnDestroy {
       self.state.allShellIds().forEach { self.closeShell($0) }
+      self.state.allCancels().forEach { $0.cancel() }
       Task {
+        for client in self.state.allSftps() {
+          try? await client.shutdown()
+        }
+        for forward in self.state.allForwards() {
+          try? await forward.stop()
+        }
         for session in self.state.allSessions() {
           try? await session.disconnect()
         }
@@ -80,7 +215,10 @@ public final class ReactNativeSshModule: Module {
     categoryIsRetryable(category: code)
   }
 
-  private func connectSession(_ config: ConnectConfigRecord) async throws -> String {
+  private func connectSession(
+    _ config: ConnectConfigRecord,
+    via jumpSessionId: String? = nil
+  ) async throws -> String {
     let sessionId = state.sessionIds.next()
     let handler = JsSessionHandler(
       sessionId: sessionId,
@@ -95,12 +233,71 @@ public final class ReactNativeSshModule: Module {
       }
     )
 
-    let session = try await translateAsync { try await SshSession.connect(config: config.toNative(), handler: handler) }
+    let session: SshSession
+    if let jumpSessionId {
+      guard let jump = state.session(jumpSessionId) else {
+        throw channelClosed(jumpSessionId)
+      }
+      session = try await translateAsync {
+        try await SshSession.connectVia(jump: jump, config: config.toNative(), handler: handler)
+      }
+    } else {
+      session = try await translateAsync {
+        try await SshSession.connect(config: config.toNative(), handler: handler)
+      }
+    }
+
     state.store(session: session, id: sessionId)
 
     return sessionId
   }
 
+  private func sftp(_ sftpId: String) throws -> SftpClient {
+    guard let client = state.sftp(sftpId) else {
+      throw channelClosed(sftpId)
+    }
+
+    return client
+  }
+
+  private func transfer(
+    _ transferId: String,
+    run: (TransferProgress, CancelToken) async throws -> UInt64
+  ) async throws -> Double {
+    let cancel = CancelToken()
+    state.store(cancel: cancel, id: transferId)
+    defer { _ = state.removeCancel(transferId) }
+    let progress = TransferProgressSink(transferId: transferId) { event, payload in
+      self.sendEvent(event, payload)
+    }
+
+    return Double(try await translateAsync { try await run(progress, cancel) })
+  }
+
+  private func startForward(
+    _ sessionId: String,
+    _ config: ForwardConfigRecord,
+    start: (SshSession, ForwardConfig, ForwardSink) async throws -> ForwardHandle
+  ) async throws -> ForwardStartRecord {
+    guard let session = state.session(sessionId) else {
+      throw channelClosed(sessionId)
+    }
+
+    let forwardId = state.forwardIds.next()
+    let sink = ForwardErrorSink(sessionId: sessionId) { event, payload in
+      self.sendEvent(event, payload)
+    }
+    let handle = try await translateAsync {
+      try await start(session, config.toNative(), sink)
+    }
+    state.store(forward: handle, id: forwardId)
+
+    var record = ForwardStartRecord()
+    record.forwardId = forwardId
+    record.port = Int(handle.actualPort())
+    return record
+  }
+
   private func runCommand(_ sessionId: String, _ command: String) async throws -> ExecOutputRecord {
     guard let session = state.session(sessionId) else {
       throw channelClosed(sessionId)
@@ -216,6 +413,24 @@ private extension ConnectConfigRecord {
   }
 }
 
+private extension ForwardConfigRecord {
+  func toNative() throws -> ForwardConfig {
+    guard bindPort >= 0 && bindPort <= 65535 else {
+      throw Exception(name: "SshError", description: "bindPort must be between 0 and 65535", code: "Protocol")
+    }
+    guard destPort >= 1 && destPort <= 65535 else {
+      throw Exception(name: "SshError", description: "destPort must be between 1 and 65535", code: "Protocol")
+    }
+
+    return ForwardConfig(
+      bindHost: bindHost,
+      bindPort: UInt16(bindPort),
+      destHost: destHost,
+      destPort: UInt16(destPort)
+    )
+  }
+}
+
 private extension AuthRecord {
   func toNative() throws -> AuthMethod {
     switch type {
diff --git a/ios/SshErrors.swift b/ios/SshErrors.swift
index 4088e02..31a061b 100644
--- a/ios/SshErrors.swift
+++ b/ios/SshErrors.swift
@@ -31,6 +31,16 @@ extension SshError {
       return "Protocol"
     case .KeyGeneration:
       return "KeyGeneration"
+    case .NotFound:
+      return "NotFound"
+    case .PermissionDenied:
+      return "PermissionDenied"
+    case .Cancelled:
+      return "Cancelled"
+    case .Forwarding:
+      return "Forwarding"
+    case .LocalIo:
+      return "LocalIo"
     }
   }
 
@@ -43,14 +53,20 @@ extension SshError {
       .KeyParse(let message),
       .ChannelClosed(let message),
       .Protocol(let message),
-      .KeyGeneration(let message):
+      .KeyGeneration(let message),
+      .Forwarding(let message),
+      .LocalIo(let message):
       return message
+    case .NotFound(let path), .PermissionDenied(let path):
+      return path
     case .HostKeyRejected:
       return "The host key was rejected"
     case .AuthCancelled:
       return "Authentication was cancelled"
     case .WrongPassphrase:
       return "Wrong or missing passphrase"
+    case .Cancelled:
+      return "The transfer was cancelled"
     }
   }
 
diff --git a/ios/SshEventSinks.swift b/ios/SshEventSinks.swift
new file mode 100644
index 0000000..264eb97
--- /dev/null
+++ b/ios/SshEventSinks.swift
@@ -0,0 +1,33 @@
+import Foundation
+
+public final class TransferProgressSink: TransferProgress, @unchecked Sendable {
+  private let transferId: String
+  private let emit: (String, [String: Any?]) -> Void
+
+  public init(transferId: String, emit: @escaping (String, [String: Any?]) -> Void) {
+    self.transferId = transferId
+    self.emit = emit
+  }
+
+  public func onProgress(transferred: UInt64, total: UInt64?) {
+    emit("onTransferProgress", [
+      "transferId": transferId,
+      "transferred": Double(transferred),
+      "total": total.map(Double.init),
+    ])
+  }
+}
+
+public final class ForwardErrorSink: ForwardSink, @unchecked Sendable {
+  private let sessionId: String
+  private let emit: (String, [String: Any?]) -> Void
+
+  public init(sessionId: String, emit: @escaping (String, [String: Any?]) -> Void) {
+    self.sessionId = sessionId
+    self.emit = emit
+  }
+
+  public func onError(message: String) {
+    emit("onForwardError", ["sessionId": sessionId, "message": message])
+  }
+}
diff --git a/ios/SshModuleState.swift b/ios/SshModuleState.swift
index ced4ba3..db7ad27 100644
--- a/ios/SshModuleState.swift
+++ b/ios/SshModuleState.swift
@@ -4,10 +4,15 @@ import Foundation
 final class SshModuleState: @unchecked Sendable {
   let sessionIds = IdSequence(prefix: "session-")
   let shellIds = IdSequence(prefix: "shell-")
+  let sftpIds = IdSequence(prefix: "sftp-")
+  let forwardIds = IdSequence(prefix: "forward-")
 
   private let lock = NSLock()
   private var sessions: [String: SshSession] = [:]
   private var shells: [String: SshShellSource] = [:]
+  private var sftps: [String: SftpClient] = [:]
+  private var forwards: [String: ForwardHandle] = [:]
+  private var cancels: [String: CancelToken] = [:]
   private var hostKeyRequests: [String: PendingRequest<Bool>] = [:]
   private var promptRequests: [String: PendingRequest<PromptReply>] = [:]
 
@@ -59,6 +64,72 @@ final class SshModuleState: @unchecked Sendable {
     return Array(shells.keys)
   }
 
+  func store(sftp: SftpClient, id: String) {
+    lock.lock()
+    sftps[id] = sftp
+    lock.unlock()
+  }
+
+  func sftp(_ id: String) -> SftpClient? {
+    lock.lock()
+    defer { lock.unlock() }
+    return sftps[id]
+  }
+
+  func removeSftp(_ id: String) -> SftpClient? {
+    lock.lock()
+    defer { lock.unlock() }
+    return sftps.removeValue(forKey: id)
+  }
+
+  func allSftps() -> [SftpClient] {
+    lock.lock()
+    defer { lock.unlock() }
+    return Array(sftps.values)
+  }
+
+  func store(forward: ForwardHandle, id: String) {
+    lock.lock()
+    forwards[id] = forward
+    lock.unlock()
+  }
+
+  func removeForward(_ id: String) -> ForwardHandle? {
+    lock.lock()
+    defer { lock.unlock() }
+    return forwards.removeValue(forKey: id)
+  }
+
+  func allForwards() -> [ForwardHandle] {
+    lock.lock()
+    defer { lock.unlock() }
+    return Array(forwards.values)
+  }
+
+  func store(cancel: CancelToken, id: String) {
+    lock.lock()
+    cancels[id] = cancel
+    lock.unlock()
+  }
+
+  func cancel(_ id: String) -> CancelToken? {
+    lock.lock()
+    defer { lock.unlock() }
+    return cancels[id]
+  }
+
+  func removeCancel(_ id: String) -> CancelToken? {
+    lock.lock()
+    defer { lock.unlock() }
+    return cancels.removeValue(forKey: id)
+  }
+
+  func allCancels() -> [CancelToken] {
+    lock.lock()
+    defer { lock.unlock() }
+    return Array(cancels.values)
+  }
+
   func store(hostKeyRequest: PendingRequest<Bool>, id: String) {
     lock.lock()
     hostKeyRequests[id] = hostKeyRequest
diff --git a/ios/SshRecords.swift b/ios/SshRecords.swift
index 1ff131d..47c4654 100644
--- a/ios/SshRecords.swift
+++ b/ios/SshRecords.swift
@@ -47,6 +47,51 @@ struct ExecOutputRecord: Record, @unchecked Sendable {
   @Field var exitStatus: Int?
 }
 
+struct SftpEntryRecord: Record, @unchecked Sendable {
+  @Field var name: String = ""
+  @Field var kind: String = ""
+  @Field var size: Double = 0
+  @Field var modifiedUnix: Double?
+  @Field var permissions: Int?
+}
+
+extension EntryKind {
+  var recordName: String {
+    switch self {
+    case .file:
+      return "file"
+    case .directory:
+      return "directory"
+    case .symlink:
+      return "symlink"
+    case .other:
+      return "other"
+    }
+  }
+}
+
+func sftpEntryRecord(_ entry: Entry) -> SftpEntryRecord {
+  var record = SftpEntryRecord()
+  record.name = entry.name
+  record.kind = entry.kind.recordName
+  record.size = Double(entry.size)
+  record.modifiedUnix = entry.modifiedUnix.map(Double.init)
+  record.permissions = entry.permissions.map { Int($0) }
+  return record
+}
+
+struct ForwardConfigRecord: Record, @unchecked Sendable {
+  @Field var bindHost: String = "127.0.0.1"
+  @Field var bindPort: Int = 0
+  @Field var destHost: String = ""
+  @Field var destPort: Int = 22
+}
+
+struct ForwardStartRecord: Record, @unchecked Sendable {
+  @Field var forwardId: String = ""
+  @Field var port: Int = 0
+}
+
 struct HostKeyRequest: Sendable {
   let sessionId: String
   let requestId: String
diff --git a/rust/Cargo.lock b/rust/Cargo.lock
index bbeedc8..6f1e15b 100644
--- a/rust/Cargo.lock
+++ b/rust/Cargo.lock
@@ -125,6 +125,17 @@ dependencies = [
  "winnow",
 ]
 
+[[package]]
+name = "async-trait"
+version = "0.1.92"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82f6aeea286b8eb4dd3431a1be1b59d290ace00f5bfd8e2a159bc2a05e2c1667"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.10",
+]
+
 [[package]]
 name = "autocfg"
 version = "1.5.1"
@@ -168,6 +179,9 @@ name = "bitflags"
 version = "2.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06"
+dependencies = [
+ "serde_core",
+]
 
 [[package]]
 name = "blake2"
@@ -372,6 +386,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a31eee39dddec8330830986fcd7625edb5a24ec90ea038215273bbc3adb08ac6"
+
 [[package]]
 name = "crypto-bigint"
 version = "0.7.11"
@@ -400,6 +420,16 @@ dependencies = [
  "rand_core",
 ]
 
+[[package]]
+name = "crypto-primes"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3633a51a39c69ebbaa4feaa694bd83d241e4093901c84a0963b19d9bb3f0cf8f"
+dependencies = [
+ "crypto-bigint",
+ "rand_core",
+]
+
 [[package]]
 name = "ctr"
 version = "0.10.1"
@@ -447,6 +477,20 @@ dependencies = [
  "syn 2.0.119",
 ]
 
+[[package]]
+name = "dashmap"
+version = "6.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6361d5c062261c78a176addb82d4c821ae42bed6089de0e12603cd25de2059c"
+dependencies = [
+ "cfg-if",
+ "crossbeam-utils",
+ "hashbrown 0.14.5",
+ "lock_api",
+ "once_cell",
+ "parking_lot_core",
+]
+
 [[package]]
 name = "data-encoding"
 version = "2.11.1"
@@ -763,6 +807,18 @@ version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e4eba85ea1d0a966a983acd07deee566e67395d2d96b6fb39e62b5a833f1eb0b"
 
+[[package]]
+name = "gloo-timers"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "482ce8a491a501da4cd806bd190275363d674f2845005c6ddbd5d3e1dd54495d"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "js-sys",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "goblin"
 version = "0.8.2"
@@ -785,6 +841,12 @@ dependencies = [
  "subtle",
 ]
 
+[[package]]
+name = "hashbrown"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+
 [[package]]
 name = "hashbrown"
 version = "0.17.1"
@@ -870,7 +932,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855"
 dependencies = [
  "equivalent",
- "hashbrown",
+ "hashbrown 0.17.1",
  "serde",
  "serde_core",
 ]
@@ -934,6 +996,15 @@ version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
 
+[[package]]
+name = "lock_api"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
+dependencies = [
+ "scopeguard",
+]
+
 [[package]]
 name = "log"
 version = "0.4.35"
@@ -1114,6 +1185,19 @@ dependencies = [
  "windows-strings",
 ]
 
+[[package]]
+name = "parking_lot_core"
+version = "0.9.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-link",
+]
+
 [[package]]
 name = "password-hash"
 version = "0.6.1"
@@ -1164,6 +1248,16 @@ version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
 
+[[package]]
+name = "pkcs1"
+version = "0.8.0-rc.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "986d2e952779af96ea048f160fd9194e1751b4faea78bcf3ceb456efe008088e"
+dependencies = [
+ "der",
+ "spki",
+]
+
 [[package]]
 name = "pkcs5"
 version = "0.8.1"
@@ -1290,6 +1384,15 @@ version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
 
+[[package]]
+name = "redox_syscall"
+version = "0.5.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
+dependencies = [
+ "bitflags",
+]
+
 [[package]]
 name = "rfc6979"
 version = "0.6.0"
@@ -1314,6 +1417,25 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "rsa"
+version = "0.10.0-rc.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30b2aa4ba0d89f73d1e332df05be0eeab8840351c36ca5654341dfdb57bb3caf"
+dependencies = [
+ "const-oid",
+ "crypto-bigint",
+ "crypto-primes",
+ "digest",
+ "pkcs1",
+ "pkcs8",
+ "rand_core",
+ "sha2",
+ "signature",
+ "spki",
+ "zeroize",
+]
+
 [[package]]
 name = "russh"
 version = "0.65.1"
@@ -1356,12 +1478,14 @@ dependencies = [
  "p521",
  "pageant",
  "pbkdf2",
+ "pkcs1",
  "pkcs5",
  "pkcs8",
  "polyval",
  "rand",
  "rand_core",
  "ring",
+ "rsa",
  "russh-cryptovec",
  "russh-util",
  "salsa20",
@@ -1394,6 +1518,26 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "russh-sftp"
+version = "3.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9bb17f72aba4314656b359ffba72c68dcbd70ed9e97497898b75498fe7198042"
+dependencies = [
+ "bitflags",
+ "bytes",
+ "chrono",
+ "dashmap",
+ "gloo-timers",
+ "log",
+ "serde",
+ "serde_bytes",
+ "thiserror",
+ "tokio",
+ "tokio-util",
+ "wasm-bindgen-futures",
+]
+
 [[package]]
 name = "russh-util"
 version = "0.52.0"
@@ -1450,6 +1594,12 @@ dependencies = [
  "cipher",
 ]
 
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
 [[package]]
 name = "scroll"
 version = "0.12.0"
@@ -1512,6 +1662,16 @@ dependencies = [
  "serde_derive",
 ]
 
+[[package]]
+name = "serde_bytes"
+version = "0.11.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5d440709e79d88e51ac01c4b72fc6cb7314017bb7da9eeff678aa94c10e3ea8"
+dependencies = [
+ "serde",
+ "serde_core",
+]
+
 [[package]]
 name = "serde_core"
 version = "1.0.229"
@@ -1636,6 +1796,12 @@ version = "0.4.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
 
+[[package]]
+name = "smallvec"
+version = "1.16.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "149309498a5f7334b12ddae0cad8aba81ce785fe91755068867e017cf98fee46"
+
 [[package]]
 name = "smawk"
 version = "0.3.3"
@@ -1690,8 +1856,11 @@ dependencies = [
 name = "ssh-core"
 version = "0.0.0"
 dependencies = [
+ "async-trait",
  "getrandom 0.4.3",
  "russh",
+ "russh-sftp",
+ "tokio",
  "uniffi",
 ]
 
@@ -1703,6 +1872,7 @@ checksum = "7b54d0ed0498daf3f78d82e00e28c8eec9d75a067c4cfbcc7a0f7d0f4077749e"
 dependencies = [
  "base64ct",
  "bytes",
+ "crypto-bigint",
  "ctutils",
  "digest",
  "pem-rfc7468",
@@ -1725,6 +1895,7 @@ dependencies = [
  "p384",
  "p521",
  "rand_core",
+ "rsa",
  "sec1",
  "sha1",
  "sha2",
@@ -1843,6 +2014,20 @@ dependencies = [
  "syn 3.0.10",
 ]
 
+[[package]]
+name = "tokio-util"
+version = "0.7.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e464cf451ba96ebfc6f9b6542f17ee8b8956e33f1e40d9690624e59d7a7f8a4b"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "futures-util",
+ "pin-project-lite",
+ "tokio",
+]
+
 [[package]]
 name = "toml"
 version = "1.2.1+spec-1.1.0"
diff --git a/rust/ssh-core/Cargo.toml b/rust/ssh-core/Cargo.toml
index ae1bc4f..741d851 100644
--- a/rust/ssh-core/Cargo.toml
+++ b/rust/ssh-core/Cargo.toml
@@ -17,8 +17,10 @@ getrandom = { version = "0.4", features = ["sys_rng"] }
 # to iOS without a host CMake/Go toolchain, which aws-lc-rs requires.
 # rsa adds RSA host and user key support (PKCS#1 parsing lives in russh's key loader).
 russh = { version = "0.65.1", default-features = false, features = ["ring", "rsa"] }
-tokio = { version = "1", features = ["macros", "rt-multi-thread", "net", "sync", "time"] }
+russh-sftp = "3.0.1"
+tokio = { version = "1", features = ["fs", "io-util", "macros", "rt-multi-thread", "net", "sync", "time"] }
 uniffi = { workspace = true }
 
 [dev-dependencies]
-tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
+sha2 = "0.10"
+tokio = { version = "1", features = ["io-util", "macros", "net", "rt-multi-thread", "sync", "time"] }
diff --git a/rust/ssh-core/src/error.rs b/rust/ssh-core/src/error.rs
index 033a91e..b4807c9 100644
--- a/rust/ssh-core/src/error.rs
+++ b/rust/ssh-core/src/error.rs
@@ -39,6 +39,16 @@ pub enum SshError {
     Protocol { message: String },
     /// A local key pair could not be created.
     KeyGeneration { message: String },
+    /// The remote path does not exist.
+    NotFound { path: String },
+    /// The server refused access to the path.
+    PermissionDenied { path: String },
+    /// The app cancelled the transfer.
+    Cancelled,
+    /// A port forward could not be set up.
+    Forwarding { message: String },
+    /// A file in the app sandbox could not be read or written.
+    LocalIo { message: String },
 }
 
 impl SshError {
@@ -61,6 +71,11 @@ impl SshError {
             Self::ChannelClosed { .. } => "ChannelClosed",
             Self::Protocol { .. } => "Protocol",
             Self::KeyGeneration { .. } => "KeyGeneration",
+            Self::NotFound { .. } => "NotFound",
+            Self::PermissionDenied { .. } => "PermissionDenied",
+            Self::Cancelled => "Cancelled",
+            Self::Forwarding { .. } => "Forwarding",
+            Self::LocalIo { .. } => "LocalIo",
         }
     }
 
@@ -101,6 +116,11 @@ impl fmt::Display for SshError {
             Self::ChannelClosed { message } => write!(f, "channel closed: {message}"),
             Self::Protocol { message } => write!(f, "protocol error: {message}"),
             Self::KeyGeneration { message } => write!(f, "key generation failed: {message}"),
+            Self::NotFound { path } => write!(f, "not found: {path}"),
+            Self::PermissionDenied { path } => write!(f, "permission denied: {path}"),
+            Self::Cancelled => write!(f, "cancelled"),
+            Self::Forwarding { message } => write!(f, "forwarding failed: {message}"),
+            Self::LocalIo { message } => write!(f, "local I/O error: {message}"),
         }
     }
 }
@@ -178,6 +198,70 @@ pub(crate) fn key_error(error: ssh_key::Error) -> SshError {
     }
 }
 
+/// Maps an SFTP failure, naming the path the operation addressed.
+pub(crate) fn sftp_error(path: &str, error: russh_sftp::client::error::Error) -> SshError {
+    use russh_sftp::client::error::Error as SftpError;
+    use russh_sftp::protocol::StatusCode;
+
+    match error {
+        SftpError::Status(status) => match status.status_code {
+            StatusCode::NoSuchFile => SshError::NotFound {
+                path: path.to_string(),
+            },
+            StatusCode::PermissionDenied => SshError::PermissionDenied {
+                path: path.to_string(),
+            },
+            StatusCode::NoConnection | StatusCode::ConnectionLost => SshError::Network {
+                message: status.error_message,
+            },
+            code => SshError::Protocol {
+                message: format!("{code} for {path}: {}", status.error_message),
+            },
+        },
+        other => other.into(),
+    }
+}
+
+/// Maps an I/O failure of an SFTP file object back to its protocol cause.
+pub(crate) fn sftp_io(path: &str, error: std::io::Error) -> SshError {
+    let message = error.to_string();
+
+    match error
+        .into_inner()
+        .map(|inner| inner.downcast::<russh_sftp::client::error::Error>())
+    {
+        Some(Ok(cause)) => sftp_error(path, *cause),
+        _ => SshError::Protocol {
+            message: format!("{path}: {message}"),
+        },
+    }
+}
+
+pub(crate) fn local_io(path: &std::path::Path, error: std::io::Error) -> SshError {
+    SshError::LocalIo {
+        message: format!("{}: {error}", path.display()),
+    }
+}
+
+impl From<russh_sftp::client::error::Error> for SshError {
+    fn from(error: russh_sftp::client::error::Error) -> Self {
+        use russh_sftp::client::error::Error as SftpError;
+
+        match error {
+            SftpError::Status(status) => SshError::Protocol {
+                message: format!("{}: {}", status.status_code, status.error_message),
+            },
+            SftpError::Timeout => SshError::Timeout {
+                message: "sftp request".to_string(),
+            },
+            SftpError::IO(message) => SshError::Network { message },
+            other => SshError::Protocol {
+                message: other.to_string(),
+            },
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -211,6 +295,19 @@ mod tests {
             SshError::KeyGeneration {
                 message: "no entropy".into(),
             },
+            SshError::NotFound {
+                path: "/missing".into(),
+            },
+            SshError::PermissionDenied {
+                path: "/root".into(),
+            },
+            SshError::Cancelled,
+            SshError::Forwarding {
+                message: "port busy".into(),
+            },
+            SshError::LocalIo {
+                message: "no space".into(),
+            },
         ]
     }
 
@@ -245,6 +342,11 @@ mod tests {
                 "ChannelClosed",
                 "Protocol",
                 "KeyGeneration",
+                "NotFound",
+                "PermissionDenied",
+                "Cancelled",
+                "Forwarding",
+                "LocalIo",
             ]
         );
     }
diff --git a/rust/ssh-core/src/forward.rs b/rust/ssh-core/src/forward.rs
new file mode 100644
index 0000000..2ea08cc
--- /dev/null
+++ b/rust/ssh-core/src/forward.rs
@@ -0,0 +1,341 @@
+//! TCP port forwarding: device-side listeners and server-side forwards, both
+//! carried over channels of a session.
+
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
+
+use russh::Channel;
+use russh::client::Msg;
+use tokio::net::{TcpListener, TcpStream};
+use tokio::sync::watch;
+use tokio::task::{JoinHandle, JoinSet};
+
+use crate::error::SshError;
+use crate::runtime;
+use crate::session::SessionHandle;
+
+const ORIGINATOR_ADDRESS: &str = "127.0.0.1";
+
+/// Receives the failures a forward cannot report through its return value,
+/// because they happen after it started or on a single connection.
+#[uniffi::export(with_foreign)]
+pub trait ForwardSink: Send + Sync {
+    fn on_error(&self, message: String);
+}
+
+#[derive(Debug, Clone, uniffi::Record)]
+pub struct ForwardConfig {
+    /// Interface the forward listens on: the device for a local forward, the
+    /// server for a remote one.
+    pub bind_host: String,
+    /// `0` asks the operating system or the server for a free port.
+    pub bind_port: u16,
+    pub dest_host: String,
+    pub dest_port: u16,
+}
+
+/// A running forward. Dropping it leaves the forward running; call
+/// [`ForwardHandle::stop`] to end it.
+#[derive(uniffi::Object)]
+pub struct ForwardHandle {
+    actual_port: u16,
+    stopper: Mutex<Option<Stopper>>,
+}
+
+#[uniffi::export]
+impl ForwardHandle {
+    /// The port data actually reaches: the bound port for a local forward, the
+    /// one the server selected for a remote one.
+    pub fn actual_port(&self) -> u16 {
+        self.actual_port
+    }
+
+    /// Closes the listener and every connection it carries. Calling it twice
+    /// is harmless.
+    pub async fn stop(&self) -> Result<(), SshError> {
+        let stopper = self
+            .stopper
+            .lock()
+            .unwrap_or_else(|poisoned| poisoned.into_inner())
+            .take();
+        let Some(stopper) = stopper else {
+            return Ok(());
+        };
+
+        runtime::run(async move { stopper.stop().await }).await
+    }
+}
+
+enum Stopper {
+    Local {
+        cancel: watch::Sender<bool>,
+        task: JoinHandle<()>,
+    },
+    Remote {
+        session: SessionHandle,
+        forwards: Arc<RemoteForwards>,
+        address: String,
+        port: u32,
+    },
+}
+
+impl Stopper {
+    async fn stop(self) -> Result<(), SshError> {
+        match self {
+            Self::Local { cancel, task } => {
+                cancel.send_replace(true);
+                let _ = task.await;
+                Ok(())
+            }
+            Self::Remote {
+                session,
+                forwards,
+                address,
+                port,
+            } => {
+                forwards.remove(port);
+                let session = session.lock().await;
+
+                session
+                    .cancel_tcpip_forward(address, port)
+                    .await
+                    .map_err(|error| SshError::Forwarding {
+                        message: format!("withdrawing the forward failed: {error}"),
+                    })
+            }
+        }
+    }
+}
+
+#[derive(Clone)]
+pub(crate) struct Destination {
+    pub(crate) host: String,
+    pub(crate) port: u16,
+    pub(crate) events: Arc<dyn ForwardSink>,
+}
+
+impl Destination {
+    fn label(&self) -> String {
+        format!("{}:{}", self.host, self.port)
+    }
+}
+
+/// The destinations of the remote forwards this session asked the server for,
+/// keyed by the port the server bound.
+#[derive(Default)]
+pub(crate) struct RemoteForwards {
+    targets: Mutex<HashMap<u32, Destination>>,
+}
+
+impl RemoteForwards {
+    pub(crate) fn insert(&self, port: u32, destination: Destination) {
+        self.targets
+            .lock()
+            .unwrap_or_else(|poisoned| poisoned.into_inner())
+            .insert(port, destination);
+    }
+
+    pub(crate) fn remove(&self, port: u32) {
+        self.targets
+            .lock()
+            .unwrap_or_else(|poisoned| poisoned.into_inner())
+            .remove(&port);
+    }
+
+    pub(crate) fn destination(&self, port: u32) -> Option<Destination> {
+        self.targets
+            .lock()
+            .unwrap_or_else(|poisoned| poisoned.into_inner())
+            .get(&port)
+            .cloned()
+    }
+}
+
+pub(crate) async fn start_local(
+    session: SessionHandle,
+    config: ForwardConfig,
+    events: Arc<dyn ForwardSink>,
+) -> Result<Arc<ForwardHandle>, SshError> {
+    let listener = TcpListener::bind((config.bind_host.as_str(), config.bind_port))
+        .await
+        .map_err(|error| binding_error(&config, error))?;
+    let actual_port = listener
+        .local_addr()
+        .map_err(|error| binding_error(&config, error))?
+        .port();
+
+    let (cancel, cancelled) = watch::channel(false);
+    let destination = Destination {
+        host: config.dest_host,
+        port: config.dest_port,
+        events,
+    };
+    let task = tokio::spawn(accept_connections(
+        listener,
+        cancelled,
+        session,
+        destination,
+    ));
+
+    Ok(Arc::new(ForwardHandle {
+        actual_port,
+        stopper: Mutex::new(Some(Stopper::Local { cancel, task })),
+    }))
+}
+
+pub(crate) async fn start_remote(
+    session: SessionHandle,
+    forwards: Arc<RemoteForwards>,
+    config: ForwardConfig,
+    events: Arc<dyn ForwardSink>,
+) -> Result<Arc<ForwardHandle>, SshError> {
+    let reported = {
+        let handle = session.lock().await;
+
+        handle
+            .tcpip_forward(config.bind_host.clone(), u32::from(config.bind_port))
+            .await
+            .map_err(|error| SshError::Forwarding {
+                message: format!(
+                    "requesting {}:{} failed: {error}",
+                    config.bind_host, config.bind_port
+                ),
+            })?
+    };
+    let bound = port_bound(reported, config.bind_port)?;
+
+    forwards.insert(
+        bound,
+        Destination {
+            host: config.dest_host,
+            port: config.dest_port,
+            events,
+        },
+    );
+
+    Ok(Arc::new(ForwardHandle {
+        actual_port: u16::try_from(bound).map_err(|_| SshError::Forwarding {
+            message: format!("the server bound an invalid port {bound}"),
+        })?,
+        stopper: Mutex::new(Some(Stopper::Remote {
+            session,
+            forwards,
+            address: config.bind_host,
+            port: bound,
+        })),
+    }))
+}
+
+/// Carries a connection the server opened for a remote forward to the device
+/// destination. Runs after the handler accepted the channel.
+pub(crate) async fn pump_forwarded(channel: Channel<Msg>, destination: Destination) {
+    match TcpStream::connect((destination.host.as_str(), destination.port)).await {
+        Ok(transport) => bridge(transport, channel, &destination).await,
+        Err(error) => {
+            destination.events.on_error(format!(
+                "connecting to {} on the device failed: {error}",
+                destination.label()
+            ));
+            let _ = channel.close().await;
+        }
+    }
+}
+
+async fn accept_connections(
+    listener: TcpListener,
+    mut cancelled: watch::Receiver<bool>,
+    session: SessionHandle,
+    destination: Destination,
+) {
+    let mut pumps = JoinSet::new();
+
+    loop {
+        tokio::select! {
+            biased;
+            _ = cancelled.wait_for(|value| *value) => break,
+            Some(_) = pumps.join_next(), if !pumps.is_empty() => {}
+            accepted = listener.accept() => match accepted {
+                Ok((transport, _)) => {
+                    pumps.spawn(forward(transport, Arc::clone(&session), destination.clone()));
+                }
+                Err(error) => {
+                    destination.events.on_error(format!("accepting a connection failed: {error}"));
+                    break;
+                }
+            },
+        }
+    }
+
+    pumps.abort_all();
+    while pumps.join_next().await.is_some() {}
+}
+
+async fn forward(transport: TcpStream, session: SessionHandle, destination: Destination) {
+    let channel = {
+        let handle = session.lock().await;
+
+        handle
+            .channel_open_direct_tcpip(
+                destination.host.clone(),
+                u32::from(destination.port),
+                ORIGINATOR_ADDRESS,
+                0,
+            )
+            .await
+    };
+
+    match channel {
+        Ok(channel) => bridge(transport, channel, &destination).await,
+        Err(error) => destination.events.on_error(format!(
+            "opening {} over the session failed: {error}",
+            destination.label()
+        )),
+    }
+}
+
+async fn bridge(mut transport: TcpStream, channel: Channel<Msg>, destination: &Destination) {
+    let mut stream = channel.into_stream();
+
+    if let Err(error) = tokio::io::copy_bidirectional(&mut transport, &mut stream).await {
+        destination.events.on_error(format!(
+            "forwarding to {} failed: {error}",
+            destination.label()
+        ));
+    }
+}
+
+/// The port a remote forward actually listens on.
+///
+/// OpenSSH answers with `0` when it accepted the requested port; only a request
+/// for port `0` carries the port the server picked.
+fn port_bound(reported: u32, requested: u16) -> Result<u32, SshError> {
+    match reported {
+        0 if requested > 0 => Ok(u32::from(requested)),
+        0 => Err(SshError::Forwarding {
+            message: "the server did not report the port it bound".to_string(),
+        }),
+        port => Ok(port),
+    }
+}
+
+fn binding_error(config: &ForwardConfig, error: std::io::Error) -> SshError {
+    SshError::Forwarding {
+        message: format!(
+            "binding {}:{} failed: {error}",
+            config.bind_host, config.bind_port
+        ),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_server_that_answers_zero_bound_the_requested_port() {
+        assert_eq!(port_bound(0, 19_000).unwrap(), 19_000);
+        assert_eq!(port_bound(2_200, 19_000).unwrap(), 2_200);
+        assert_eq!(port_bound(6_000, 0).unwrap(), 6_000);
+        assert!(port_bound(0, 0).is_err());
+    }
+}
diff --git a/rust/ssh-core/src/lib.rs b/rust/ssh-core/src/lib.rs
index 5a99cf3..5448c57 100644
--- a/rust/ssh-core/src/lib.rs
+++ b/rust/ssh-core/src/lib.rs
@@ -5,14 +5,19 @@
 uniffi::setup_scaffolding!();
 
 mod error;
+mod forward;
 mod key;
 mod runtime;
 mod session;
+mod sftp;
 mod shell;
+mod transfer;
 
 pub use error::SshError;
+pub use forward::{ForwardConfig, ForwardHandle, ForwardSink};
 pub use key::{GeneratedKey, ParsedKey, generate_ed25519_key, parse_private_key};
 pub use session::{AuthMethod, ConnectConfig, ExecResult, Prompt, SessionHandler, SshSession};
+pub use sftp::{CancelToken, Entry, EntryKind, SftpClient, TransferProgress};
 pub use shell::{ByteSink, ShellChannel};
 
 #[uniffi::export]
diff --git a/rust/ssh-core/src/session.rs b/rust/ssh-core/src/session.rs
index 83f8ea2..91c3b30 100644
--- a/rust/ssh-core/src/session.rs
+++ b/rust/ssh-core/src/session.rs
@@ -5,17 +5,20 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::time::Duration;
 
 use russh::client::{
-    AuthResult, Config, DisconnectReason, Handle, KeyboardInteractiveAuthResponse,
+    AuthResult, ChannelOpenHandle, Config, DisconnectReason, Handle,
+    KeyboardInteractiveAuthResponse, Msg, Session,
 };
 use russh::keys::ssh_key;
 use russh::keys::{HashAlg, PrivateKeyWithHashAlg, PublicKeyBase64, PublicKeyOrCertificate};
-use russh::{Channel, ChannelMsg, Disconnect};
+use russh::{Channel, ChannelMsg, ChannelOpenFailure, Disconnect};
 use tokio::sync::Mutex;
 use tokio::time::Instant;
 
 use crate::error::SshError;
+use crate::forward::{self, ForwardConfig, ForwardHandle, ForwardSink, RemoteForwards};
 use crate::key::load_private_key;
 use crate::runtime;
+use crate::sftp::SftpClient;
 use crate::shell::{ByteSink, ShellChannel};
 
 /// The keepalives a session may miss before russh gives up on the server.
@@ -94,10 +97,36 @@ pub trait SessionHandler: Send + Sync {
     fn on_disconnect(&self, reason: String);
 }
 
+/// The session's channel handle, shared with the forwards it owns.
+pub(crate) type SessionHandle = Arc<Mutex<Handle<ClientHandler>>>;
+
 #[derive(uniffi::Object)]
 pub struct SshSession {
-    handle: Mutex<Handle<ClientHandler>>,
-    closed_by_app: Arc<AtomicBool>,
+    handle: SessionHandle,
+    handshake: Arc<Handshake>,
+    forwards: Arc<RemoteForwards>,
+}
+
+struct Handshake {
+    host: String,
+    port: u16,
+    timeout_ms: u32,
+    awaiting_user: AtomicBool,
+    host_key_rejected: AtomicBool,
+    closed_by_app: AtomicBool,
+}
+
+impl Handshake {
+    fn new(config: &ConnectConfig) -> Self {
+        Self {
+            host: config.host.clone(),
+            port: config.port,
+            timeout_ms: config.connect_timeout_ms.max(1),
+            awaiting_user: AtomicBool::new(false),
+            host_key_rejected: AtomicBool::new(false),
+            closed_by_app: AtomicBool::new(false),
+        }
+    }
 }
 
 #[uniffi::export]
@@ -112,6 +141,18 @@ impl SshSession {
         runtime::run(connect(config, handler)).await
     }
 
+    /// Connects through `jump`, which must already be authenticated: the stream
+    /// to the target is a `direct-tcpip` channel of the jump session. Chaining
+    /// more than one bastion composes, because each jump is itself a session.
+    #[uniffi::constructor]
+    pub async fn connect_via(
+        jump: Arc<SshSession>,
+        config: ConnectConfig,
+        handler: Arc<dyn SessionHandler>,
+    ) -> Result<Arc<Self>, SshError> {
+        runtime::run(connect_via(jump, config, handler)).await
+    }
+
     /// Opens a pty-backed shell whose output goes to `sink`.
     pub async fn open_shell(
         &self,
@@ -167,10 +208,54 @@ impl SshSession {
         Ok(result)
     }
 
+    /// Opens the SFTP subsystem on a new channel of this session.
+    pub async fn open_sftp(&self) -> Result<Arc<SftpClient>, SshError> {
+        let handle = Arc::clone(&self.handle);
+
+        runtime::run(async move {
+            let mut channel = handle.lock().await.channel_open_session().await?;
+            channel.request_subsystem(true, "sftp").await?;
+            await_success(&mut channel).await?;
+
+            let session = russh_sftp::client::SftpSession::new(channel.into_stream())
+                .await
+                .map_err(SshError::from)?;
+
+            Ok(Arc::new(SftpClient::new(session)))
+        })
+        .await
+    }
+
+    /// Listens on the device and tunnels each connection to
+    /// `dest_host:dest_port` from the server's network.
+    pub async fn start_local_forward(
+        &self,
+        config: ForwardConfig,
+        events: Arc<dyn ForwardSink>,
+    ) -> Result<Arc<ForwardHandle>, SshError> {
+        let session = Arc::clone(&self.handle);
+
+        runtime::run(async move { forward::start_local(session, config, events).await }).await
+    }
+
+    /// Asks the server to listen and tunnels each connection it accepts to
+    /// `dest_host:dest_port` on the device.
+    pub async fn start_remote_forward(
+        &self,
+        config: ForwardConfig,
+        events: Arc<dyn ForwardSink>,
+    ) -> Result<Arc<ForwardHandle>, SshError> {
+        let session = Arc::clone(&self.handle);
+        let forwards = Arc::clone(&self.forwards);
+
+        runtime::run(async move { forward::start_remote(session, forwards, config, events).await })
+            .await
+    }
+
     /// Ends the connection. Shell channels close and report it through their
     /// sink; [`SessionHandler::on_disconnect`] is not called.
     pub async fn disconnect(&self) -> Result<(), SshError> {
-        if self.closed_by_app.swap(true, Ordering::SeqCst) {
+        if self.handshake.closed_by_app.swap(true, Ordering::SeqCst) {
             return Ok(());
         }
 
@@ -182,6 +267,28 @@ impl SshSession {
     }
 }
 
+impl SshSession {
+    async fn open_bastion_channel(
+        &self,
+        host: &str,
+        port: u16,
+        budget: Duration,
+    ) -> Result<Channel<Msg>, SshError> {
+        let handle = self.handle.lock().await;
+        let connecting =
+            handle.channel_open_direct_tcpip(host.to_string(), u32::from(port), "127.0.0.1", 0);
+
+        tokio::time::timeout(budget, connecting)
+            .await
+            .map_err(|_| SshError::Timeout {
+                message: format!("opening a channel to {host}:{port}"),
+            })?
+            .map_err(|error| SshError::Forwarding {
+                message: format!("the bastion refused {host}:{port}: {error}"),
+            })
+    }
+}
+
 /// RFC 4254 extended data type for stderr.
 const STDERR_EXTENDED_DATA: u32 = 1;
 
@@ -189,57 +296,107 @@ async fn connect(
     config: ConnectConfig,
     handler: Arc<dyn SessionHandler>,
 ) -> Result<Arc<SshSession>, SshError> {
-    let awaiting_user = Arc::new(AtomicBool::new(false));
-    let host_key_rejected = Arc::new(AtomicBool::new(false));
-    let closed_by_app = Arc::new(AtomicBool::new(false));
-
-    let client_config = Arc::new(client_config(&config));
-    let timeout = Duration::from_millis(u64::from(config.connect_timeout_ms.max(1)));
-    let address = (config.host.clone(), config.port);
-    let client_handler = ClientHandler {
-        host: address.0.clone(),
-        port: address.1,
-        app: Arc::clone(&handler),
-        awaiting_user: Arc::clone(&awaiting_user),
-        host_key_rejected: Arc::clone(&host_key_rejected),
-        closed_by_app: Arc::clone(&closed_by_app),
-    };
-
-    let mut connecting = Box::pin(russh::client::connect(
-        client_config,
-        (address.0.clone(), address.1),
+    let handshake = Arc::new(Handshake::new(&config));
+    let forwards = Arc::new(RemoteForwards::default());
+    let client_handler = ClientHandler::new(
+        &config,
+        Arc::clone(&handler),
+        Arc::clone(&handshake),
+        Arc::clone(&forwards),
+    );
+    let connecting = russh::client::connect(
+        Arc::new(client_config(&config)),
+        (config.host.clone(), config.port),
+        client_handler,
+    );
+
+    let handle = await_handshake(connecting, &handshake).await?;
+
+    finish(config, handler, handshake, forwards, handle).await
+}
+
+async fn connect_via(
+    jump: Arc<SshSession>,
+    config: ConnectConfig,
+    handler: Arc<dyn SessionHandler>,
+) -> Result<Arc<SshSession>, SshError> {
+    let channel = jump
+        .open_bastion_channel(
+            &config.host,
+            config.port,
+            Duration::from_millis(u64::from(config.connect_timeout_ms.max(1))),
+        )
+        .await?;
+    let handshake = Arc::new(Handshake::new(&config));
+    let forwards = Arc::new(RemoteForwards::default());
+    let client_handler = ClientHandler::new(
+        &config,
+        Arc::clone(&handler),
+        Arc::clone(&handshake),
+        Arc::clone(&forwards),
+    );
+    let connecting = russh::client::connect_stream(
+        Arc::new(client_config(&config)),
+        channel.into_stream(),
         client_handler,
-    ));
+    );
+
+    let handle = await_handshake(connecting, &handshake).await?;
+
+    finish(config, handler, handshake, forwards, handle).await
+}
+
+async fn finish(
+    config: ConnectConfig,
+    handler: Arc<dyn SessionHandler>,
+    handshake: Arc<Handshake>,
+    forwards: Arc<RemoteForwards>,
+    mut handle: Handle<ClientHandler>,
+) -> Result<Arc<SshSession>, SshError> {
+    authenticate(&mut handle, &config, handler.as_ref()).await?;
+
+    Ok(Arc::new(SshSession {
+        handle: Arc::new(Mutex::new(handle)),
+        handshake,
+        forwards,
+    }))
+}
+
+/// Waits for the handshake, extending the budget while the session handler has
+/// a question open with the user.
+async fn await_handshake<C>(
+    connecting: C,
+    handshake: &Handshake,
+) -> Result<Handle<ClientHandler>, SshError>
+where
+    C: Future<Output = Result<Handle<ClientHandler>, SshError>>,
+{
+    let timeout = Duration::from_millis(u64::from(handshake.timeout_ms));
+    let mut connecting = Box::pin(connecting);
     let mut deadline = Instant::now() + timeout;
-    let connected = loop {
+
+    loop {
         tokio::select! {
-            connected = &mut connecting => break connected,
+            connected = &mut connecting => {
+                return match connected {
+                    Ok(handle) => Ok(handle),
+                    Err(_) if handshake.host_key_rejected.load(Ordering::SeqCst) => {
+                        Err(SshError::HostKeyRejected)
+                    }
+                    Err(error) => Err(error),
+                };
+            }
             () = tokio::time::sleep_until(deadline) => {
-                if awaiting_user.load(Ordering::SeqCst) {
+                if handshake.awaiting_user.load(Ordering::SeqCst) {
                     deadline = Instant::now() + timeout;
                 } else {
                     return Err(SshError::Timeout {
-                        message: format!("connecting to {}:{}", address.0, address.1),
+                        message: format!("connecting to {}:{}", handshake.host, handshake.port),
                     });
                 }
             }
         }
-    };
-
-    let mut handle = match connected {
-        Ok(handle) => handle,
-        Err(_) if host_key_rejected.load(Ordering::SeqCst) => {
-            return Err(SshError::HostKeyRejected);
-        }
-        Err(error) => return Err(error),
-    };
-
-    authenticate(&mut handle, &config, handler.as_ref()).await?;
-
-    Ok(Arc::new(SshSession {
-        handle: Mutex::new(handle),
-        closed_by_app,
-    }))
+    }
 }
 
 fn client_config(config: &ConnectConfig) -> Config {
@@ -364,13 +521,29 @@ async fn await_success(channel: &mut Channel<russh::client::Msg>) -> Result<(),
     }
 }
 
-struct ClientHandler {
+pub(crate) struct ClientHandler {
     host: String,
     port: u16,
     app: Arc<dyn SessionHandler>,
-    awaiting_user: Arc<AtomicBool>,
-    host_key_rejected: Arc<AtomicBool>,
-    closed_by_app: Arc<AtomicBool>,
+    handshake: Arc<Handshake>,
+    forwards: Arc<RemoteForwards>,
+}
+
+impl ClientHandler {
+    fn new(
+        config: &ConnectConfig,
+        app: Arc<dyn SessionHandler>,
+        handshake: Arc<Handshake>,
+        forwards: Arc<RemoteForwards>,
+    ) -> Self {
+        Self {
+            host: config.host.clone(),
+            port: config.port,
+            app,
+            handshake,
+            forwards,
+        }
+    }
 }
 
 impl russh::client::Handler for ClientHandler {
@@ -396,7 +569,7 @@ impl russh::client::Handler for ClientHandler {
             }
         };
 
-        self.awaiting_user.store(true, Ordering::SeqCst);
+        self.handshake.awaiting_user.store(true, Ordering::SeqCst);
         let accepted = self
             .app
             .verify_host_key(
@@ -407,20 +580,46 @@ impl russh::client::Handler for ClientHandler {
                 fingerprint,
             )
             .await;
-        self.awaiting_user.store(false, Ordering::SeqCst);
+        self.handshake.awaiting_user.store(false, Ordering::SeqCst);
 
         if !accepted {
-            self.host_key_rejected.store(true, Ordering::SeqCst);
+            self.handshake
+                .host_key_rejected
+                .store(true, Ordering::SeqCst);
         }
 
         Ok(accepted)
     }
 
+    /// Routes a connection the server accepted on a remote forward to the
+    /// destination the app asked for, or declines it when no forward owns the
+    /// port.
+    async fn server_channel_open_forwarded_tcpip(
+        &mut self,
+        channel: Channel<Msg>,
+        _connected_address: &str,
+        connected_port: u32,
+        _originator_address: &str,
+        _originator_port: u32,
+        reply: ChannelOpenHandle,
+        _session: &mut Session,
+    ) -> Result<(), Self::Error> {
+        let Some(destination) = self.forwards.destination(connected_port) else {
+            reply.reject(ChannelOpenFailure::ConnectFailed).await;
+            return Ok(());
+        };
+
+        reply.accept().await;
+        runtime::spawn(forward::pump_forwarded(channel, destination));
+
+        Ok(())
+    }
+
     async fn disconnected(
         &mut self,
         reason: DisconnectReason<Self::Error>,
     ) -> Result<(), Self::Error> {
-        if !self.closed_by_app.load(Ordering::SeqCst) {
+        if !self.handshake.closed_by_app.load(Ordering::SeqCst) {
             let text = match reason {
                 DisconnectReason::ReceivedDisconnect(info) => {
                     format!("{:?}: {}", info.reason_code, info.message)
diff --git a/rust/ssh-core/src/sftp.rs b/rust/ssh-core/src/sftp.rs
new file mode 100644
index 0000000..97656a3
--- /dev/null
+++ b/rust/ssh-core/src/sftp.rs
@@ -0,0 +1,277 @@
+//! SFTP: the remote file system reached over a session channel.
+
+use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
+
+use russh_sftp::client::SftpSession;
+use russh_sftp::protocol::{FileAttributes, FileType};
+
+use crate::error::{SshError, sftp_error};
+use crate::runtime;
+use crate::transfer;
+
+/// What a directory entry points at, taken from the server's `lstat`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, uniffi::Enum)]
+pub enum EntryKind {
+    File,
+    Directory,
+    Symlink,
+    Other,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, uniffi::Record)]
+pub struct Entry {
+    pub name: String,
+    pub kind: EntryKind,
+    pub size: u64,
+    /// Seconds since the Unix epoch, when the server reported a time.
+    pub modified_unix: Option<u64>,
+    /// POSIX mode bits, when the server reported them.
+    pub permissions: Option<u32>,
+}
+
+/// Receives the byte count of a transfer while it runs.
+///
+/// The core calls it at most ten times a second, so an implementation may
+/// forward every call to the platform event emitter.
+#[uniffi::export(with_foreign)]
+pub trait TransferProgress: Send + Sync {
+    /// `total` is the expected size when the source reported one.
+    fn on_progress(&self, transferred: u64, total: Option<u64>);
+}
+
+/// Stops a running transfer at its next chunk boundary.
+#[derive(uniffi::Object)]
+pub struct CancelToken {
+    cancelled: AtomicBool,
+}
+
+#[uniffi::export]
+impl CancelToken {
+    #[uniffi::constructor]
+    pub fn new() -> Arc<Self> {
+        Arc::new(Self {
+            cancelled: AtomicBool::new(false),
+        })
+    }
+
+    pub fn cancel(&self) {
+        self.cancelled.store(true, Ordering::SeqCst);
+    }
+
+    pub fn is_cancelled(&self) -> bool {
+        self.cancelled.load(Ordering::SeqCst)
+    }
+}
+
+/// A remote file system on one channel of a session.
+#[derive(uniffi::Object)]
+pub struct SftpClient {
+    session: Arc<SftpSession>,
+}
+
+impl SftpClient {
+    pub(crate) fn new(session: SftpSession) -> Self {
+        Self {
+            session: Arc::new(session),
+        }
+    }
+}
+
+#[uniffi::export]
+impl SftpClient {
+    /// Lists a directory. `.` and `..` are not returned.
+    pub async fn list(&self, path: String) -> Result<Vec<Entry>, SshError> {
+        let session = Arc::clone(&self.session);
+        runtime::run(async move {
+            let entries = session
+                .read_dir(path.clone())
+                .await
+                .map_err(|error| sftp_error(&path, error))?;
+
+            Ok(entries
+                .map(|entry| entry_from(&entry.file_name(), &entry.metadata()))
+                .collect())
+        })
+        .await
+    }
+
+    /// Reads the attributes of `path` without following a final symlink.
+    pub async fn stat(&self, path: String) -> Result<Entry, SshError> {
+        let session = Arc::clone(&self.session);
+        runtime::run(async move {
+            let attributes = session
+                .symlink_metadata(path.clone())
+                .await
+                .map_err(|error| sftp_error(&path, error))?;
+
+            Ok(entry_from(&file_name(&path), &attributes))
+        })
+        .await
+    }
+
+    /// Resolves a server-side path, including symbolic links and `~`.
+    pub async fn realpath(&self, path: String) -> Result<String, SshError> {
+        let session = Arc::clone(&self.session);
+        runtime::run(async move {
+            session
+                .canonicalize(path.clone())
+                .await
+                .map_err(|error| sftp_error(&path, error))
+        })
+        .await
+    }
+
+    pub async fn mkdir(&self, path: String) -> Result<(), SshError> {
+        let session = Arc::clone(&self.session);
+        runtime::run(async move {
+            session
+                .create_dir(path.clone())
+                .await
+                .map_err(|error| sftp_error(&path, error))
+        })
+        .await
+    }
+
+    pub async fn rename(&self, from: String, to: String) -> Result<(), SshError> {
+        let session = Arc::clone(&self.session);
+        runtime::run(async move {
+            session
+                .rename(from.clone(), to)
+                .await
+                .map_err(|error| sftp_error(&from, error))
+        })
+        .await
+    }
+
+    pub async fn remove_file(&self, path: String) -> Result<(), SshError> {
+        let session = Arc::clone(&self.session);
+        runtime::run(async move {
+            session
+                .remove_file(path.clone())
+                .await
+                .map_err(|error| sftp_error(&path, error))
+        })
+        .await
+    }
+
+    pub async fn remove_dir(&self, path: String) -> Result<(), SshError> {
+        let session = Arc::clone(&self.session);
+        runtime::run(async move {
+            session
+                .remove_dir(path.clone())
+                .await
+                .map_err(|error| sftp_error(&path, error))
+        })
+        .await
+    }
+
+    /// Copies a remote file to `local_path`, a `file://` URL in the app
+    /// sandbox. Returns the number of bytes written.
+    ///
+    /// The bytes go to `<local_path>.part` first, which is renamed into place
+    /// on success and removed on failure or cancellation, so an interrupted
+    /// download never leaves a truncated file at `local_path`.
+    pub async fn download(
+        &self,
+        remote_path: String,
+        local_path: String,
+        progress: Option<Arc<dyn TransferProgress>>,
+        cancel: Arc<CancelToken>,
+    ) -> Result<u64, SshError> {
+        let session = Arc::clone(&self.session);
+        runtime::run(async move {
+            let local = transfer::local_path(&local_path)?;
+            transfer::download(&session, &remote_path, &local, progress, &cancel).await
+        })
+        .await
+    }
+
+    /// Copies `local_path`, a `file://` URL in the app sandbox, to the server.
+    /// Returns the number of bytes read.
+    ///
+    /// The bytes go to `<remote_path>.part` first, which is renamed into place
+    /// on success and removed on failure or cancellation, so an interrupted
+    /// upload never leaves a truncated file at `remote_path`.
+    pub async fn upload(
+        &self,
+        local_path: String,
+        remote_path: String,
+        progress: Option<Arc<dyn TransferProgress>>,
+        cancel: Arc<CancelToken>,
+    ) -> Result<u64, SshError> {
+        let session = Arc::clone(&self.session);
+        runtime::run(async move {
+            let local = transfer::local_path(&local_path)?;
+            transfer::upload(&session, &local, &remote_path, progress, &cancel).await
+        })
+        .await
+    }
+
+    /// Ends the SFTP subsystem channel. Other channels of the session stay up.
+    /// Named `shutdown` because `close` collides with the `AutoCloseable.close`
+    /// that uniffi generates for every exported object.
+    pub async fn shutdown(&self) -> Result<(), SshError> {
+        let session = Arc::clone(&self.session);
+        runtime::run(async move { session.close().await.map_err(SshError::from) }).await
+    }
+}
+
+fn entry_from(name: &str, attributes: &FileAttributes) -> Entry {
+    Entry {
+        name: name.to_string(),
+        kind: kind_of(attributes.file_type()),
+        size: attributes.size.unwrap_or(0),
+        modified_unix: attributes.mtime.map(u64::from),
+        permissions: attributes.permissions,
+    }
+}
+
+fn kind_of(file_type: FileType) -> EntryKind {
+    match file_type {
+        FileType::File => EntryKind::File,
+        FileType::Dir => EntryKind::Directory,
+        FileType::Symlink => EntryKind::Symlink,
+        FileType::Other => EntryKind::Other,
+    }
+}
+
+fn file_name(path: &str) -> String {
+    let trimmed = path.trim_end_matches('/');
+
+    if trimmed.is_empty() {
+        return path.to_string();
+    }
+
+    trimmed.rsplit('/').next().unwrap_or(trimmed).to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn every_protocol_file_type_maps_to_a_kind() {
+        assert_eq!(kind_of(FileType::File), EntryKind::File);
+        assert_eq!(kind_of(FileType::Dir), EntryKind::Directory);
+        assert_eq!(kind_of(FileType::Symlink), EntryKind::Symlink);
+        assert_eq!(kind_of(FileType::Other), EntryKind::Other);
+    }
+
+    #[test]
+    fn stat_names_use_the_last_path_segment() {
+        assert_eq!(file_name("/home/user/notes.txt"), "notes.txt");
+        assert_eq!(file_name("/home/user/notes.txt/"), "notes.txt");
+        assert_eq!(file_name("/"), "/");
+        assert_eq!(file_name("notes.txt"), "notes.txt");
+    }
+
+    #[test]
+    fn cancel_tokens_start_and_stay_cancelled() {
+        let token = CancelToken::new();
+
+        assert!(!token.is_cancelled());
+        token.cancel();
+        assert!(token.is_cancelled());
+    }
+}
diff --git a/rust/ssh-core/src/transfer.rs b/rust/ssh-core/src/transfer.rs
new file mode 100644
index 0000000..85d672a
--- /dev/null
+++ b/rust/ssh-core/src/transfer.rs
@@ -0,0 +1,327 @@
+//! Chunked, cancellable, progress-reporting file transfers.
+
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+
+use russh_sftp::client::SftpSession;
+use tokio::fs::File;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+use crate::error::{SshError, local_io, sftp_error, sftp_io};
+use crate::sftp::{CancelToken, TransferProgress};
+
+/// Bytes moved per read and per write request.
+const CHUNK_BYTES: usize = 256 * 1024;
+/// Shortest gap between two progress callbacks.
+const REPORT_INTERVAL: Duration = Duration::from_millis(100);
+/// Suffix of the staging file a transfer writes before renaming it into place.
+const STAGING_SUFFIX: &str = ".part";
+
+/// Copies a remote file into the app sandbox.
+pub(crate) async fn download(
+    session: &SftpSession,
+    remote: &str,
+    local: &Path,
+    progress: Option<Arc<dyn TransferProgress>>,
+    cancel: &CancelToken,
+) -> Result<u64, SshError> {
+    let attributes = session
+        .symlink_metadata(remote.to_string())
+        .await
+        .map_err(|error| sftp_error(remote, error))?;
+    let staged = staging_path(local);
+    let mut target = File::create(&staged)
+        .await
+        .map_err(|error| local_io(&staged, error))?;
+
+    let result = async {
+        let mut source = session
+            .open(remote.to_string())
+            .await
+            .map_err(|error| sftp_error(remote, error))?;
+        let mut reporter = Reporter::new(progress, attributes.size);
+        let mut buffer = vec![0u8; CHUNK_BYTES];
+        let mut transferred = 0u64;
+
+        loop {
+            if cancel.is_cancelled() {
+                return Err(SshError::Cancelled);
+            }
+            let read = source
+                .read(&mut buffer)
+                .await
+                .map_err(|error| sftp_io(remote, error))?;
+            if read == 0 {
+                break;
+            }
+            target
+                .write_all(&buffer[..read])
+                .await
+                .map_err(|error| local_io(&staged, error))?;
+            transferred += read as u64;
+            reporter.advance(transferred);
+        }
+
+        target
+            .flush()
+            .await
+            .map_err(|error| local_io(&staged, error))?;
+        reporter.finish(transferred);
+
+        Ok(transferred)
+    }
+    .await;
+
+    let transferred = match result {
+        Ok(transferred) => transferred,
+        Err(error) => {
+            let _ = tokio::fs::remove_file(&staged).await;
+            return Err(error);
+        }
+    };
+
+    tokio::fs::rename(&staged, local)
+        .await
+        .map_err(|error| local_io(local, error))?;
+
+    Ok(transferred)
+}
+
+/// Copies a file from the app sandbox to the server.
+pub(crate) async fn upload(
+    session: &SftpSession,
+    local: &Path,
+    remote: &str,
+    progress: Option<Arc<dyn TransferProgress>>,
+    cancel: &CancelToken,
+) -> Result<u64, SshError> {
+    let mut source = File::open(local)
+        .await
+        .map_err(|error| local_io(local, error))?;
+    let total = source
+        .metadata()
+        .await
+        .map_err(|error| local_io(local, error))?
+        .len();
+    let staged = format!("{remote}{STAGING_SUFFIX}");
+    let mut target = session
+        .create(staged.clone())
+        .await
+        .map_err(|error| sftp_error(remote, error))?;
+
+    let result = async {
+        let mut reporter = Reporter::new(progress, Some(total));
+        let mut buffer = vec![0u8; CHUNK_BYTES];
+        let mut transferred = 0u64;
+
+        loop {
+            if cancel.is_cancelled() {
+                return Err(SshError::Cancelled);
+            }
+            let read = source
+                .read(&mut buffer)
+                .await
+                .map_err(|error| local_io(local, error))?;
+            if read == 0 {
+                break;
+            }
+            target
+                .write_all(&buffer[..read])
+                .await
+                .map_err(|error| sftp_io(&staged, error))?;
+            transferred += read as u64;
+            reporter.advance(transferred);
+        }
+
+        target
+            .shutdown()
+            .await
+            .map_err(|error| sftp_io(&staged, error))?;
+        session
+            .rename(staged.clone(), remote.to_string())
+            .await
+            .map_err(|error| sftp_error(remote, error))?;
+        reporter.finish(transferred);
+
+        Ok(transferred)
+    }
+    .await;
+
+    if result.is_err() {
+        let _ = session.remove_file(staged).await;
+    }
+
+    result
+}
+
+fn staging_path(local: &Path) -> PathBuf {
+    let mut staged = local.as_os_str().to_os_string();
+    staged.push(STAGING_SUFFIX);
+
+    PathBuf::from(staged)
+}
+
+/// Turns a `file://` URL from the app sandbox into a path.
+pub(crate) fn local_path(url: &str) -> Result<PathBuf, SshError> {
+    let Some(rest) = url.strip_prefix("file://") else {
+        return Ok(PathBuf::from(url));
+    };
+    let path = rest.strip_prefix("localhost").unwrap_or(rest);
+
+    Ok(PathBuf::from(percent_decode(path)?))
+}
+
+fn percent_decode(input: &str) -> Result<String, SshError> {
+    let bytes = input.as_bytes();
+    let mut decoded = Vec::with_capacity(bytes.len());
+    let mut index = 0;
+
+    while index < bytes.len() {
+        if bytes[index] == b'%' {
+            let digits = input
+                .get(index + 1..index + 3)
+                .ok_or_else(|| SshError::LocalIo {
+                    message: format!("truncated escape in {input}"),
+                })?;
+            let byte = u8::from_str_radix(digits, 16).map_err(|_| SshError::LocalIo {
+                message: format!("invalid escape %{digits} in {input}"),
+            })?;
+            decoded.push(byte);
+            index += 3;
+        } else {
+            decoded.push(bytes[index]);
+            index += 1;
+        }
+    }
+
+    String::from_utf8(decoded).map_err(|_| SshError::LocalIo {
+        message: format!("{input} is not valid UTF-8"),
+    })
+}
+
+struct Reporter {
+    sink: Option<Arc<dyn TransferProgress>>,
+    total: Option<u64>,
+    last: Option<Instant>,
+    reported: Option<u64>,
+}
+
+impl Reporter {
+    fn new(sink: Option<Arc<dyn TransferProgress>>, total: Option<u64>) -> Self {
+        Self {
+            sink,
+            total,
+            last: None,
+            reported: None,
+        }
+    }
+
+    fn advance(&mut self, transferred: u64) {
+        let due = self
+            .last
+            .is_none_or(|last| last.elapsed() >= REPORT_INTERVAL);
+
+        if due {
+            self.report(transferred);
+        }
+    }
+
+    fn finish(&mut self, transferred: u64) {
+        if self.reported != Some(transferred) {
+            self.report(transferred);
+        }
+    }
+
+    fn report(&mut self, transferred: u64) {
+        self.last = Some(Instant::now());
+        self.reported = Some(transferred);
+
+        if let Some(sink) = &self.sink {
+            sink.on_progress(transferred, self.total);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::Mutex;
+
+    struct RecordingSink {
+        reports: Mutex<Vec<(u64, Option<u64>)>>,
+    }
+
+    impl TransferProgress for RecordingSink {
+        fn on_progress(&self, transferred: u64, total: Option<u64>) {
+            self.reports
+                .lock()
+                .unwrap_or_else(|poisoned| poisoned.into_inner())
+                .push((transferred, total));
+        }
+    }
+
+    #[test]
+    fn file_urls_become_sandbox_paths() {
+        assert_eq!(
+            local_path("file:///data/user/0/app/files/notes.txt")
+                .unwrap()
+                .to_str(),
+            Some("/data/user/0/app/files/notes.txt")
+        );
+        assert_eq!(
+            local_path("file://localhost/var/tmp/a%20b.txt")
+                .unwrap()
+                .to_str(),
+            Some("/var/tmp/a b.txt")
+        );
+        assert_eq!(
+            local_path("/already/a/path").unwrap().to_str(),
+            Some("/already/a/path")
+        );
+    }
+
+    #[test]
+    fn malformed_file_urls_are_local_io_errors() {
+        for url in ["file:///tmp/%", "file:///tmp/%zz", "file:///tmp/%ff"] {
+            let error = local_path(url).unwrap_err();
+
+            assert_eq!(error.category(), "LocalIo", "{url}");
+        }
+    }
+
+    #[test]
+    fn progress_is_throttled_and_always_ends_with_the_total() {
+        let sink = Arc::new(RecordingSink {
+            reports: Mutex::new(Vec::new()),
+        });
+        let mut reporter = Reporter::new(Some(sink.clone()), Some(1_000));
+
+        for step in 1..=100 {
+            reporter.advance(step * 10);
+        }
+        reporter.finish(1_000);
+
+        let reports = sink
+            .reports
+            .lock()
+            .unwrap_or_else(|poisoned| poisoned.into_inner())
+            .clone();
+        assert!(reports.len() <= 3, "throttling reported {reports:?}");
+        assert_eq!(
+            reports.first().map(|(transferred, _)| *transferred),
+            Some(10)
+        );
+        assert_eq!(reports.last(), Some(&(1_000, Some(1_000))));
+    }
+
+    #[test]
+    fn staging_keeps_the_original_extension_visible() {
+        assert_eq!(
+            staging_path(Path::new("/data/app/notes.txt"))
+                .to_str()
+                .unwrap(),
+            "/data/app/notes.txt.part"
+        );
+    }
+}
diff --git a/rust/ssh-core/tests/docker/Dockerfile b/rust/ssh-core/tests/docker/Dockerfile
index 0b96c39..d8d3433 100644
--- a/rust/ssh-core/tests/docker/Dockerfile
+++ b/rust/ssh-core/tests/docker/Dockerfile
@@ -37,6 +37,8 @@ RUN printf '%s\n' \
 
 COPY docker/sshd_config.password /etc/ssh/sshd_config.password
 COPY docker/sshd_config.twofactor /etc/ssh/sshd_config.twofactor
+COPY docker/http_response.sh /usr/local/bin/http-response
+RUN chmod +x /usr/local/bin/http-response
 COPY docker/entrypoint.sh /usr/local/bin/entrypoint
 
 EXPOSE 2222
diff --git a/rust/ssh-core/tests/docker/entrypoint.sh b/rust/ssh-core/tests/docker/entrypoint.sh
index 66ac3ac..54c18a9 100755
--- a/rust/ssh-core/tests/docker/entrypoint.sh
+++ b/rust/ssh-core/tests/docker/entrypoint.sh
@@ -18,6 +18,11 @@ silent)
   # Accepts TCP and never speaks SSH, so connect timeouts can be observed.
   exec socat TCP-LISTEN:2222,reuseaddr,fork EXEC:'/bin/sleep 300'
   ;;
+http)
+  # Answers every request with a fixed body, so a local forward can prove it
+  # reached the server's network.
+  exec socat TCP-LISTEN:8080,reuseaddr,fork EXEC:/usr/local/bin/http-response
+  ;;
 *)
   echo "unknown role: $1" >&2
   exit 1
diff --git a/rust/ssh-core/tests/docker/http_response.sh b/rust/ssh-core/tests/docker/http_response.sh
new file mode 100755
index 0000000..51cab93
--- /dev/null
+++ b/rust/ssh-core/tests/docker/http_response.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+# Fixture HTTP response for the local-forward test. A file rather than an
+# inline socat SYSTEM command, whose option parser strips the quotes printf
+# needs around its format string.
+printf 'HTTP/1.1 200 OK\r\nContent-Length: 5\r\nConnection: close\r\n\r\nhello'
diff --git a/rust/ssh-core/tests/docker/sshd_config.password b/rust/ssh-core/tests/docker/sshd_config.password
index 2447d03..0ea1dc0 100644
--- a/rust/ssh-core/tests/docker/sshd_config.password
+++ b/rust/ssh-core/tests/docker/sshd_config.password
@@ -21,3 +21,10 @@ ClientAliveCountMax 1
 PrintMotd no
 AcceptEnv LANG LC_*
 Subsystem sftp internal-sftp
+
+# Port forwarding fixtures: the bastion role tunnels to a host only it can
+# reach, and the remote-forward role binds a port the test reaches from the
+# host through a published container port.
+AllowTcpForwarding yes
+GatewayPorts clientspecified
+PermitOpen any
diff --git a/rust/ssh-core/tests/integration.rs b/rust/ssh-core/tests/integration.rs
index 816e8c4..6c14f6b 100644
--- a/rust/ssh-core/tests/integration.rs
+++ b/rust/ssh-core/tests/integration.rs
@@ -1,321 +1,21 @@
-//! Integration coverage against the OpenSSH test server in `tests/docker`.
+//! Session coverage against the OpenSSH test server in `tests/docker`.
 //!
 //! The suite needs a server, so it runs only when `SSH_TEST_HOST` is set (the
-//! CI job starts the container and sets it). Without it every test returns
+//! CI job starts the containers and sets it). Without it every test returns
 //! immediately and `cargo test` stays hermetic.
 
-use std::path::PathBuf;
-use std::sync::atomic::{AtomicUsize, Ordering};
-use std::sync::{Arc, Mutex};
+mod support;
+
+use std::sync::Arc;
+use std::sync::atomic::Ordering;
 use std::time::Duration;
 
-use async_trait::async_trait;
-use ssh_core::{
-    AuthMethod, ByteSink, ConnectConfig, Prompt, SessionHandler, ShellChannel, SshError, SshSession,
+use ssh_core::{AuthMethod, Prompt, SessionHandler, SshError, SshSession};
+use support::{
+    TestHandler, expect_failure, open_shell, password_session, server, wait_for_close,
+    wait_for_text,
 };
 
-const TIMEOUT: Duration = Duration::from_secs(4_000);
-const OUTPUT_WAIT: Duration = Duration::from_secs(20);
-const POLL: Duration = Duration::from_millis(25);
-
-struct Server {
-    host: String,
-    password_port: u16,
-    keyboard_interactive_port: u16,
-    silent_port: u16,
-    user: String,
-    password: String,
-    keyboard_interactive_code: String,
-    keys: PathBuf,
-}
-
-impl Server {
-    fn from_env() -> Option<Self> {
-        let host = std::env::var("SSH_TEST_HOST").ok()?;
-        let port = |name: &str, default: u16| {
-            std::env::var(name)
-                .ok()
-                .and_then(|value| value.parse().ok())
-                .unwrap_or(default)
-        };
-        let variable =
-            |name: &str, default: &str| std::env::var(name).unwrap_or_else(|_| default.to_string());
-        let keys = std::env::var("SSH_TEST_KEYS").map_or_else(
-            |_| PathBuf::from(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/fixtures")),
-            PathBuf::from,
-        );
-
-        Some(Self {
-            host,
-            password_port: port("SSH_TEST_PASSWORD_PORT", 2222),
-            keyboard_interactive_port: port("SSH_TEST_KEYBOARD_INTERACTIVE_PORT", 2223),
-            silent_port: port("SSH_TEST_SILENT_PORT", 2224),
-            user: variable("SSH_TEST_USER", "user"),
-            password: variable("SSH_TEST_PASSWORD", "ssh-core-password"),
-            keyboard_interactive_code: variable("SSH_TEST_KEYBOARD_INTERACTIVE_CODE", "424242"),
-            keys,
-        })
-    }
-
-    fn config(&self, port: u16, auth: AuthMethod) -> ConnectConfig {
-        ConnectConfig {
-            host: self.host.clone(),
-            port,
-            username: self.user.clone(),
-            auth,
-            connect_timeout_ms: TIMEOUT.as_millis() as u32,
-            keepalive_interval_s: KEEPALIVE_INTERVAL_S,
-        }
-    }
-
-    fn password_config(&self) -> ConnectConfig {
-        let password = AuthMethod::Password {
-            password: self.password.clone(),
-        };
-        self.config(self.password_port, password)
-    }
-
-    fn key_config(&self, name: &str, passphrase: Option<&str>) -> ConnectConfig {
-        let key = AuthMethod::Key {
-            private_key_openssh: self.key(name),
-            passphrase: passphrase.map(str::to_string),
-        };
-        self.config(self.password_port, key)
-    }
-
-    fn key(&self, name: &str) -> String {
-        let path = self.keys.join(name);
-        std::fs::read_to_string(&path)
-            .unwrap_or_else(|error| panic!("reading {}: {error}", path.display()))
-    }
-}
-
-const KEEPALIVE_INTERVAL_S: u32 = 5;
-
-macro_rules! server {
-    () => {
-        match Server::from_env() {
-            Some(server) => server,
-            None => {
-                eprintln!("skipped: SSH_TEST_HOST is not set");
-                return;
-            }
-        }
-    };
-}
-
-#[derive(Debug)]
-struct SeenHostKey {
-    host: String,
-    port: u16,
-    algorithm: String,
-    public_key_base64: String,
-    fingerprint_sha256: String,
-}
-
-struct TestHandler {
-    accept_host_key: bool,
-    answers: Vec<Vec<String>>,
-    answer_by_prompt: Option<(String, String)>,
-    rounds: Mutex<Vec<Vec<Prompt>>>,
-    host_keys: Mutex<Vec<SeenHostKey>>,
-    disconnects: AtomicUsize,
-}
-
-impl TestHandler {
-    fn accepting() -> Self {
-        Self {
-            accept_host_key: true,
-            answers: Vec::new(),
-            answer_by_prompt: None,
-            rounds: Mutex::new(Vec::new()),
-            host_keys: Mutex::new(Vec::new()),
-            disconnects: AtomicUsize::new(0),
-        }
-    }
-
-    fn answering_by_prompt(code: String, password: String) -> Self {
-        Self {
-            answer_by_prompt: Some((code, password)),
-            ..Self::accepting()
-        }
-    }
-
-    fn answering(answers: Vec<Vec<String>>, accept_host_key: bool) -> Self {
-        Self {
-            accept_host_key,
-            answers,
-            ..Self::accepting()
-        }
-    }
-
-    fn rounds(&self) -> Vec<Vec<Prompt>> {
-        let mut rounds = self.rounds.lock().expect("rounds");
-        std::mem::take(&mut *rounds)
-    }
-
-    fn host_keys(&self) -> Vec<SeenHostKey> {
-        let mut keys = self.host_keys.lock().expect("host keys");
-        std::mem::take(&mut *keys)
-    }
-}
-
-#[async_trait]
-impl SessionHandler for TestHandler {
-    async fn verify_host_key(
-        &self,
-        host: String,
-        port: u16,
-        algorithm: String,
-        public_key_base64: String,
-        fingerprint_sha256: String,
-    ) -> bool {
-        self.host_keys.lock().expect("host keys").push(SeenHostKey {
-            host,
-            port,
-            algorithm,
-            public_key_base64,
-            fingerprint_sha256,
-        });
-
-        self.accept_host_key
-    }
-
-    async fn keyboard_interactive(
-        &self,
-        name: String,
-        _instructions: String,
-        prompts: Vec<Prompt>,
-    ) -> Option<Vec<String>> {
-        assert!(name.len() < 256, "the server name is a short identifier");
-        let answers = self.answer_by_prompt.as_ref().map(|(code, password)| {
-            prompts
-                .iter()
-                .map(|prompt| {
-                    if prompt.text.to_lowercase().contains("password") {
-                        password.clone()
-                    } else {
-                        code.clone()
-                    }
-                })
-                .collect::<Vec<String>>()
-        });
-
-        let round = {
-            let mut rounds = self.rounds.lock().expect("rounds");
-            let round = rounds.len();
-            rounds.push(prompts);
-            round
-        };
-
-        answers.or_else(|| self.answers.get(round).cloned())
-    }
-
-    fn on_disconnect(&self, _reason: String) {
-        self.disconnects.fetch_add(1, Ordering::SeqCst);
-    }
-}
-
-#[derive(Default)]
-struct CollectingSink {
-    data: Mutex<Vec<u8>>,
-    closed: Mutex<Option<(Option<u32>, Option<String>)>>,
-}
-
-impl CollectingSink {
-    fn text(&self) -> String {
-        String::from_utf8_lossy(&self.data.lock().expect("data")).to_string()
-    }
-
-    fn clear(&self) {
-        self.data.lock().expect("data").clear();
-    }
-
-    fn closed(&self) -> Option<(Option<u32>, Option<String>)> {
-        self.closed.lock().expect("closed").clone()
-    }
-}
-
-impl ByteSink for CollectingSink {
-    fn on_data(&self, bytes: Vec<u8>) {
-        self.data.lock().expect("data").extend_from_slice(&bytes);
-    }
-
-    fn on_closed(&self, exit_status: Option<u32>, error: Option<String>) {
-        *self.closed.lock().expect("closed") = Some((exit_status, error));
-    }
-}
-
-async fn wait_for_text(sink: &CollectingSink, needle: &str) {
-    let deadline = tokio::time::Instant::now() + OUTPUT_WAIT;
-
-    loop {
-        let text = sink.text();
-        if text.contains(needle) {
-            return;
-        }
-        assert!(
-            tokio::time::Instant::now() < deadline,
-            "waited {OUTPUT_WAIT:?} for {needle:?}; output so far: {text:?}"
-        );
-        tokio::time::sleep(POLL).await;
-    }
-}
-
-async fn wait_for_close(sink: &CollectingSink) {
-    let deadline = tokio::time::Instant::now() + OUTPUT_WAIT;
-
-    while sink.closed().is_none() {
-        assert!(
-            tokio::time::Instant::now() < deadline,
-            "channel never reported a close; output: {:?}",
-            sink.text()
-        );
-        tokio::time::sleep(POLL).await;
-    }
-}
-
-/// Fails a test with `context` when the connection unexpectedly succeeds.
-#[track_caller]
-fn expect_failure(result: Result<Arc<SshSession>, SshError>, context: &str) -> SshError {
-    match result {
-        Ok(_) => panic!("{context}"),
-        Err(error) => error,
-    }
-}
-
-async fn password_session(server: &Server) -> (Arc<SshSession>, Arc<TestHandler>) {
-    let handler = Arc::new(TestHandler::accepting());
-    let session = SshSession::connect(
-        server.password_config(),
-        handler.clone() as Arc<dyn SessionHandler>,
-    )
-    .await
-    .expect("password session");
-
-    (session, handler)
-}
-
-async fn open_shell(
-    server: &Server,
-    cols: u32,
-    rows: u32,
-) -> (Arc<SshSession>, Arc<ShellChannel>, Arc<CollectingSink>) {
-    let (session, _handler) = password_session(server).await;
-    let sink = Arc::new(CollectingSink::default());
-    let shell = session
-        .open_shell(
-            "xterm-256color".to_string(),
-            cols,
-            rows,
-            Arc::clone(&sink) as Arc<dyn ByteSink>,
-        )
-        .await
-        .expect("shell");
-
-    (session, shell, sink)
-}
-
 #[tokio::test]
 async fn password_authentication_succeeds() {
     let server = server!();
diff --git a/rust/ssh-core/tests/support/mod.rs b/rust/ssh-core/tests/support/mod.rs
new file mode 100644
index 0000000..497b774
--- /dev/null
+++ b/rust/ssh-core/tests/support/mod.rs
@@ -0,0 +1,462 @@
+//! Fixtures shared by the integration suites: the test server description, the
+//! session handler, and the sinks the tests observe.
+//!
+//! The module is compiled into each suite separately, so a suite that only uses
+//! part of it must not leave the rest unused.
+#![allow(dead_code, unused_imports, unused_macros)]
+
+use std::io::Write;
+use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
+
+use async_trait::async_trait;
+use sha2::{Digest, Sha256};
+use ssh_core::{
+    AuthMethod, ByteSink, CancelToken, ConnectConfig, ForwardSink, Prompt, SessionHandler,
+    ShellChannel, SshError, SshSession, TransferProgress,
+};
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::net::TcpListener;
+use tokio::task::JoinHandle;
+
+pub const TIMEOUT: Duration = Duration::from_secs(4_000);
+pub const OUTPUT_WAIT: Duration = Duration::from_secs(20);
+pub const POLL: Duration = Duration::from_millis(25);
+pub const KEEPALIVE_INTERVAL_S: u32 = 5;
+
+pub struct Server {
+    pub host: String,
+    pub password_port: u16,
+    pub keyboard_interactive_port: u16,
+    pub silent_port: u16,
+    pub user: String,
+    pub password: String,
+    pub keyboard_interactive_code: String,
+    pub keys: PathBuf,
+}
+
+impl Server {
+    pub fn from_env() -> Option<Self> {
+        let host = std::env::var("SSH_TEST_HOST").ok()?;
+        let variable =
+            |name: &str, default: &str| std::env::var(name).unwrap_or_else(|_| default.to_string());
+        let keys = std::env::var("SSH_TEST_KEYS").map_or_else(
+            |_| PathBuf::from(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/fixtures")),
+            PathBuf::from,
+        );
+
+        Some(Self {
+            host,
+            password_port: port_or("SSH_TEST_PASSWORD_PORT", 2222),
+            keyboard_interactive_port: port_or("SSH_TEST_KEYBOARD_INTERACTIVE_PORT", 2223),
+            silent_port: port_or("SSH_TEST_SILENT_PORT", 2224),
+            user: variable("SSH_TEST_USER", "user"),
+            password: variable("SSH_TEST_PASSWORD", "ssh-core-password"),
+            keyboard_interactive_code: variable("SSH_TEST_KEYBOARD_INTERACTIVE_CODE", "424242"),
+            keys,
+        })
+    }
+
+    pub fn config(&self, port: u16, auth: AuthMethod) -> ConnectConfig {
+        ConnectConfig {
+            host: self.host.clone(),
+            port,
+            username: self.user.clone(),
+            auth,
+            connect_timeout_ms: TIMEOUT.as_millis() as u32,
+            keepalive_interval_s: KEEPALIVE_INTERVAL_S,
+        }
+    }
+
+    pub fn password_config(&self) -> ConnectConfig {
+        let password = AuthMethod::Password {
+            password: self.password.clone(),
+        };
+        self.config(self.password_port, password)
+    }
+
+    pub fn key_config(&self, name: &str, passphrase: Option<&str>) -> ConnectConfig {
+        let key = AuthMethod::Key {
+            private_key_openssh: self.key(name),
+            passphrase: passphrase.map(str::to_string),
+        };
+        self.config(self.password_port, key)
+    }
+
+    pub fn key(&self, name: &str) -> String {
+        let path = self.keys.join(name);
+        std::fs::read_to_string(&path)
+            .unwrap_or_else(|error| panic!("reading {}: {error}", path.display()))
+    }
+}
+
+macro_rules! server {
+    () => {
+        match crate::support::Server::from_env() {
+            Some(server) => server,
+            None => {
+                eprintln!("skipped: SSH_TEST_HOST is not set");
+                return;
+            }
+        }
+    };
+}
+
+macro_rules! fixture {
+    ($name:expr) => {
+        match std::env::var($name) {
+            Ok(value) => value,
+            Err(_) => {
+                eprintln!("skipped: {} is not set", $name);
+                return;
+            }
+        }
+    };
+}
+
+pub(crate) use fixture;
+pub(crate) use server;
+
+pub fn port_or(name: &str, default: u16) -> u16 {
+    std::env::var(name)
+        .ok()
+        .and_then(|value| value.parse().ok())
+        .unwrap_or(default)
+}
+
+#[derive(Debug)]
+pub struct SeenHostKey {
+    pub host: String,
+    pub port: u16,
+    pub algorithm: String,
+    pub public_key_base64: String,
+    pub fingerprint_sha256: String,
+}
+
+pub struct TestHandler {
+    accept_host_key: bool,
+    answers: Vec<Vec<String>>,
+    answer_by_prompt: Option<(String, String)>,
+    rounds: Mutex<Vec<Vec<Prompt>>>,
+    pub host_keys: Mutex<Vec<SeenHostKey>>,
+    pub disconnects: AtomicUsize,
+}
+
+impl TestHandler {
+    pub fn accepting() -> Self {
+        Self {
+            accept_host_key: true,
+            answers: Vec::new(),
+            answer_by_prompt: None,
+            rounds: Mutex::new(Vec::new()),
+            host_keys: Mutex::new(Vec::new()),
+            disconnects: AtomicUsize::new(0),
+        }
+    }
+
+    pub fn answering_by_prompt(code: String, password: String) -> Self {
+        Self {
+            answer_by_prompt: Some((code, password)),
+            ..Self::accepting()
+        }
+    }
+
+    pub fn answering(answers: Vec<Vec<String>>, accept_host_key: bool) -> Self {
+        Self {
+            accept_host_key,
+            answers,
+            ..Self::accepting()
+        }
+    }
+
+    pub fn rounds(&self) -> Vec<Vec<Prompt>> {
+        let mut rounds = self.rounds.lock().expect("rounds");
+        std::mem::take(&mut *rounds)
+    }
+
+    pub fn host_keys(&self) -> Vec<SeenHostKey> {
+        let mut keys = self.host_keys.lock().expect("host keys");
+        std::mem::take(&mut *keys)
+    }
+}
+
+#[async_trait]
+impl SessionHandler for TestHandler {
+    async fn verify_host_key(
+        &self,
+        host: String,
+        port: u16,
+        algorithm: String,
+        public_key_base64: String,
+        fingerprint_sha256: String,
+    ) -> bool {
+        self.host_keys.lock().expect("host keys").push(SeenHostKey {
+            host,
+            port,
+            algorithm,
+            public_key_base64,
+            fingerprint_sha256,
+        });
+
+        self.accept_host_key
+    }
+
+    async fn keyboard_interactive(
+        &self,
+        name: String,
+        _instructions: String,
+        prompts: Vec<Prompt>,
+    ) -> Option<Vec<String>> {
+        assert!(name.len() < 256, "the server name is a short identifier");
+        let answers = self.answer_by_prompt.as_ref().map(|(code, password)| {
+            prompts
+                .iter()
+                .map(|prompt| {
+                    if prompt.text.to_lowercase().contains("password") {
+                        password.clone()
+                    } else {
+                        code.clone()
+                    }
+                })
+                .collect::<Vec<String>>()
+        });
+
+        let round = {
+            let mut rounds = self.rounds.lock().expect("rounds");
+            let round = rounds.len();
+            rounds.push(prompts);
+            round
+        };
+
+        answers.or_else(|| self.answers.get(round).cloned())
+    }
+
+    fn on_disconnect(&self, _reason: String) {
+        self.disconnects.fetch_add(1, Ordering::SeqCst);
+    }
+}
+
+#[derive(Default)]
+pub struct CollectingSink {
+    data: Mutex<Vec<u8>>,
+    closed: Mutex<Option<(Option<u32>, Option<String>)>>,
+}
+
+impl CollectingSink {
+    pub fn text(&self) -> String {
+        String::from_utf8_lossy(&self.data.lock().expect("data")).to_string()
+    }
+
+    pub fn clear(&self) {
+        self.data.lock().expect("data").clear();
+    }
+
+    pub fn closed(&self) -> Option<(Option<u32>, Option<String>)> {
+        self.closed.lock().expect("closed").clone()
+    }
+}
+
+impl ByteSink for CollectingSink {
+    fn on_data(&self, bytes: Vec<u8>) {
+        self.data.lock().expect("data").extend_from_slice(&bytes);
+    }
+
+    fn on_closed(&self, exit_status: Option<u32>, error: Option<String>) {
+        *self.closed.lock().expect("closed") = Some((exit_status, error));
+    }
+}
+
+#[derive(Default)]
+pub struct RecordingProgress {
+    reports: Mutex<Vec<(u64, Option<u64>)>>,
+    cancel_on_report: Option<(usize, Arc<CancelToken>)>,
+}
+
+impl RecordingProgress {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn cancelling_on_report(index: usize, token: Arc<CancelToken>) -> Self {
+        Self {
+            reports: Mutex::new(Vec::new()),
+            cancel_on_report: Some((index, token)),
+        }
+    }
+
+    pub fn reports(&self) -> Vec<(u64, Option<u64>)> {
+        self.reports.lock().expect("reports").clone()
+    }
+}
+
+impl TransferProgress for RecordingProgress {
+    fn on_progress(&self, transferred: u64, total: Option<u64>) {
+        let mut reports = self.reports.lock().expect("reports");
+        reports.push((transferred, total));
+
+        if let Some((index, token)) = &self.cancel_on_report
+            && reports.len() == *index
+        {
+            token.cancel();
+        }
+    }
+}
+
+#[derive(Default)]
+pub struct RecordingForwardSink {
+    messages: Mutex<Vec<String>>,
+}
+
+impl RecordingForwardSink {
+    pub fn messages(&self) -> Vec<String> {
+        self.messages.lock().expect("messages").clone()
+    }
+}
+
+impl ForwardSink for RecordingForwardSink {
+    fn on_error(&self, message: String) {
+        self.messages.lock().expect("messages").push(message);
+    }
+}
+
+pub async fn wait_for_text(sink: &CollectingSink, needle: &str) {
+    let deadline = tokio::time::Instant::now() + OUTPUT_WAIT;
+
+    loop {
+        let text = sink.text();
+        if text.contains(needle) {
+            return;
+        }
+        assert!(
+            tokio::time::Instant::now() < deadline,
+            "waited {OUTPUT_WAIT:?} for {needle:?}; output so far: {text:?}"
+        );
+        tokio::time::sleep(POLL).await;
+    }
+}
+
+pub async fn wait_for_close(sink: &CollectingSink) {
+    let deadline = tokio::time::Instant::now() + OUTPUT_WAIT;
+
+    while sink.closed().is_none() {
+        assert!(
+            tokio::time::Instant::now() < deadline,
+            "channel never reported a close; output: {:?}",
+            sink.text()
+        );
+        tokio::time::sleep(POLL).await;
+    }
+}
+
+/// Fails a test with `context` when the connection unexpectedly succeeds.
+#[track_caller]
+pub fn expect_failure(result: Result<Arc<SshSession>, SshError>, context: &str) -> SshError {
+    match result {
+        Ok(_) => panic!("{context}"),
+        Err(error) => error,
+    }
+}
+
+pub async fn password_session(server: &Server) -> (Arc<SshSession>, Arc<TestHandler>) {
+    let handler = Arc::new(TestHandler::accepting());
+    let session = SshSession::connect(
+        server.password_config(),
+        Arc::clone(&handler) as Arc<dyn SessionHandler>,
+    )
+    .await
+    .expect("password session");
+
+    (session, handler)
+}
+
+pub async fn open_shell(
+    server: &Server,
+    cols: u32,
+    rows: u32,
+) -> (Arc<SshSession>, Arc<ShellChannel>, Arc<CollectingSink>) {
+    let (session, _handler) = password_session(server).await;
+    let sink = Arc::new(CollectingSink::default());
+    let shell = session
+        .open_shell(
+            "xterm-256color".to_string(),
+            cols,
+            rows,
+            Arc::clone(&sink) as Arc<dyn ByteSink>,
+        )
+        .await
+        .expect("shell");
+
+    (session, shell, sink)
+}
+
+pub fn temp_path(name: &str) -> PathBuf {
+    std::env::temp_dir().join(format!("ssh-core-{}-{name}", std::process::id()))
+}
+
+pub fn local_url(path: &Path) -> String {
+    format!("file://{}", path.display())
+}
+
+/// Writes `size` bytes of deterministic content and returns their SHA-256.
+pub fn write_file(path: &Path, size: usize) -> String {
+    const BLOCK: usize = 64 * 1024;
+
+    let mut hasher = Sha256::new();
+    let mut file = std::fs::File::create(path).expect("create fixture");
+    let mut block = vec![0u8; BLOCK];
+    let mut remaining = size;
+
+    while remaining > 0 {
+        let take = remaining.min(BLOCK);
+        for (index, byte) in block.iter_mut().enumerate().take(take) {
+            *byte = (index % 251) as u8;
+        }
+        block[take - 1] = (remaining % 251) as u8;
+        file.write_all(&block[..take]).expect("write fixture");
+        hasher.update(&block[..take]);
+        remaining -= take;
+    }
+
+    hex(hasher.finalize().as_slice())
+}
+
+pub fn sha256(path: &Path) -> String {
+    let mut hasher = Sha256::new();
+    let mut file = std::fs::File::open(path).expect("open for hashing");
+    std::io::copy(&mut file, &mut hasher).expect("hash");
+
+    hex(hasher.finalize().as_slice())
+}
+
+fn hex(bytes: &[u8]) -> String {
+    bytes.iter().map(|byte| format!("{byte:02x}")).collect()
+}
+
+/// Echoes every byte back until the peer closes, on a device port.
+pub async fn echo_server() -> (u16, JoinHandle<()>) {
+    let listener = TcpListener::bind(("127.0.0.1", 0))
+        .await
+        .expect("echo bind");
+    let port = listener.local_addr().expect("echo address").port();
+    let task = tokio::spawn(async move {
+        while let Ok((mut stream, _)) = listener.accept().await {
+            tokio::spawn(async move {
+                let mut buffer = [0u8; 1024];
+                loop {
+                    match stream.read(&mut buffer).await {
+                        Ok(0) | Err(_) => break,
+                        Ok(read) => {
+                            if stream.write_all(&buffer[..read]).await.is_err() {
+                                break;
+                            }
+                        }
+                    }
+                }
+            });
+        }
+    });
+
+    (port, task)
+}
diff --git a/rust/ssh-core/tests/transfers.rs b/rust/ssh-core/tests/transfers.rs
new file mode 100644
index 0000000..baad597
--- /dev/null
+++ b/rust/ssh-core/tests/transfers.rs
@@ -0,0 +1,392 @@
+//! SFTP, port forwarding and bastion coverage against the containers in
+//! `tests/docker`.
+//!
+//! Like the session suite, every test returns immediately unless the fixture
+//! variables are set; the CI job starts the containers and exports them.
+
+mod support;
+
+use std::sync::Arc;
+
+use ssh_core::{
+    CancelToken, EntryKind, ForwardConfig, ForwardSink, SessionHandler, SftpClient, SshError,
+    SshSession, TransferProgress,
+};
+use support::{
+    RecordingForwardSink, RecordingProgress, Server, TestHandler, echo_server, fixture, local_url,
+    password_session, port_or, server, sha256, temp_path, write_file,
+};
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+const FIFTY_MEGABYTES: usize = 50 * 1024 * 1024;
+const MULTI_CHUNK_BYTES: usize = 4 * 1024 * 1024;
+
+async fn sftp(server: &Server) -> (Arc<SshSession>, Arc<SftpClient>) {
+    let (session, _handler) = password_session(server).await;
+    let sftp = session.open_sftp().await.expect("sftp subsystem");
+
+    (session, sftp)
+}
+
+#[tokio::test]
+async fn sftp_manages_remote_paths() {
+    let server = server!();
+    let (session, sftp) = sftp(&server).await;
+    let root = format!("/home/user/sftp-{}", std::process::id());
+    let _ = sftp.remove_dir(root.clone()).await;
+
+    sftp.mkdir(root.clone()).await.expect("mkdir");
+    let created = sftp.stat(root.clone()).await.expect("stat directory");
+    assert_eq!(created.kind, EntryKind::Directory);
+    assert_eq!(created.name, root.rsplit('/').next().expect("segment"));
+
+    let local = temp_path("notes.txt");
+    let digest = write_file(&local, 10);
+    let file = format!("{root}/notes.txt");
+    let written = sftp
+        .upload(local_url(&local), file.clone(), None, CancelToken::new())
+        .await
+        .expect("upload");
+    assert_eq!(written, 10);
+
+    let stored = sftp.stat(file.clone()).await.expect("stat file");
+    assert_eq!(stored.kind, EntryKind::File);
+    assert_eq!(stored.size, 10);
+    assert_eq!(stored.name, "notes.txt");
+    assert!(stored.modified_unix.is_some(), "the server reports mtime");
+    assert!(stored.permissions.is_some(), "the server reports mode");
+
+    let listed = sftp.list(root.clone()).await.expect("list");
+    assert_eq!(listed.len(), 1, "listed {listed:?}");
+    assert_eq!(listed[0].name, "notes.txt");
+    assert_eq!(listed[0].kind, EntryKind::File);
+
+    let renamed = format!("{root}/renamed.txt");
+    sftp.rename(file.clone(), renamed.clone())
+        .await
+        .expect("rename");
+    assert!(
+        matches!(sftp.stat(file).await, Err(SshError::NotFound { .. })),
+        "the old name is gone"
+    );
+    assert_eq!(
+        sftp.stat(renamed.clone()).await.expect("stat renamed").name,
+        "renamed.txt"
+    );
+
+    let resolved = sftp.realpath(root.clone()).await.expect("realpath");
+    assert_eq!(resolved, root);
+
+    let downloaded = temp_path("notes-download.txt");
+    let read = sftp
+        .download(
+            renamed.clone(),
+            local_url(&downloaded),
+            None,
+            CancelToken::new(),
+        )
+        .await
+        .expect("download");
+    assert_eq!(read, 10);
+    assert_eq!(
+        sha256(&downloaded),
+        digest,
+        "the bytes round-trip unchanged"
+    );
+
+    let denied = sftp.mkdir("/etc/ssh-core-denied".to_string()).await;
+    assert_eq!(
+        denied.expect_err("the user cannot write /etc").category(),
+        "PermissionDenied"
+    );
+
+    sftp.remove_file(renamed).await.expect("remove file");
+    sftp.remove_dir(root.clone())
+        .await
+        .expect("remove directory");
+    assert!(
+        matches!(sftp.stat(root).await, Err(SshError::NotFound { .. })),
+        "the directory is gone"
+    );
+
+    sftp.shutdown().await.expect("shutdown");
+    session.disconnect().await.expect("disconnect");
+}
+
+#[tokio::test]
+async fn sftp_transfers_fifty_megabytes_with_monotonic_progress() {
+    let server = server!();
+    let (session, sftp) = sftp(&server).await;
+    let local = temp_path("upload-50m.bin");
+    let digest = write_file(&local, FIFTY_MEGABYTES);
+    let remote = format!("/home/user/upload-{}.bin", std::process::id());
+
+    let upload_progress = Arc::new(RecordingProgress::new());
+    let uploaded = sftp
+        .upload(
+            local_url(&local),
+            remote.clone(),
+            Some(Arc::clone(&upload_progress) as Arc<dyn TransferProgress>),
+            CancelToken::new(),
+        )
+        .await
+        .expect("upload 50 MB");
+    assert_eq!(uploaded as usize, FIFTY_MEGABYTES);
+    assert_monotonic(&upload_progress, FIFTY_MEGABYTES as u64);
+
+    let stored = sftp.stat(remote.clone()).await.expect("stat 50 MB");
+    assert_eq!(stored.size, FIFTY_MEGABYTES as u64);
+
+    let downloaded = temp_path("download-50m.bin");
+    let download_progress = Arc::new(RecordingProgress::new());
+    let read = sftp
+        .download(
+            remote.clone(),
+            local_url(&downloaded),
+            Some(Arc::clone(&download_progress) as Arc<dyn TransferProgress>),
+            CancelToken::new(),
+        )
+        .await
+        .expect("download 50 MB");
+    assert_eq!(read as usize, FIFTY_MEGABYTES);
+    assert_monotonic(&download_progress, FIFTY_MEGABYTES as u64);
+    assert_eq!(
+        sha256(&downloaded),
+        digest,
+        "the download matches the upload"
+    );
+
+    sftp.remove_file(remote).await.expect("remove 50 MB");
+    sftp.shutdown().await.expect("shutdown");
+    session.disconnect().await.expect("disconnect");
+}
+
+#[tokio::test]
+async fn cancelling_an_upload_leaves_no_remote_file() {
+    let server = server!();
+    let (session, sftp) = sftp(&server).await;
+    let local = temp_path("cancelled.bin");
+    write_file(&local, MULTI_CHUNK_BYTES);
+    let remote = format!("/home/user/cancelled-{}.bin", std::process::id());
+    let token = CancelToken::new();
+    let progress = Arc::new(RecordingProgress::cancelling_on_report(
+        1,
+        Arc::clone(&token),
+    ));
+
+    let error = sftp
+        .upload(
+            local_url(&local),
+            remote.clone(),
+            Some(progress as Arc<dyn TransferProgress>),
+            token,
+        )
+        .await
+        .expect_err("the cancelled upload fails");
+
+    assert_eq!(error.category(), "Cancelled", "{error:?}");
+    assert!(
+        matches!(
+            sftp.stat(remote.clone()).await,
+            Err(SshError::NotFound { .. })
+        ),
+        "an interrupted upload leaves no file at the destination"
+    );
+    assert!(
+        matches!(
+            sftp.stat(format!("{remote}.part")).await,
+            Err(SshError::NotFound { .. })
+        ),
+        "the staging file is removed"
+    );
+
+    sftp.shutdown().await.expect("shutdown");
+    session.disconnect().await.expect("disconnect");
+}
+
+fn assert_monotonic(progress: &RecordingProgress, total: u64) {
+    let reports = progress.reports();
+    assert!(
+        reports.len() > 1,
+        "progress reported {} times",
+        reports.len()
+    );
+
+    let mut last = 0;
+    for (transferred, reported_total) in &reports {
+        assert!(*transferred >= last, "progress went backwards: {reports:?}");
+        assert_eq!(
+            *reported_total,
+            Some(total),
+            "every report carries the total"
+        );
+        last = *transferred;
+    }
+    assert_eq!(last, total, "the last report is the full size");
+}
+
+#[tokio::test]
+async fn a_local_forward_reaches_the_server_network() {
+    let server = server!();
+    let http_host = fixture!("SSH_TEST_HTTP_HOST");
+    let http_port = port_or("SSH_TEST_HTTP_PORT", 8080);
+    let handler = Arc::new(TestHandler::accepting());
+    let session = SshSession::connect(server.password_config(), handler as Arc<dyn SessionHandler>)
+        .await
+        .expect("password session");
+    let events = Arc::new(RecordingForwardSink::default());
+    let forward = session
+        .start_local_forward(
+            ForwardConfig {
+                bind_host: "127.0.0.1".to_string(),
+                bind_port: 0,
+                dest_host: http_host,
+                dest_port: http_port,
+            },
+            Arc::clone(&events) as Arc<dyn ForwardSink>,
+        )
+        .await
+        .expect("local forward");
+    assert_ne!(
+        forward.actual_port(),
+        0,
+        "the operating system picked a port"
+    );
+
+    let mut stream = tokio::net::TcpStream::connect(("127.0.0.1", forward.actual_port()))
+        .await
+        .expect("connect through the forward");
+    stream
+        .write_all(b"GET / HTTP/1.1\r\nHost: fixture\r\nConnection: close\r\n\r\n")
+        .await
+        .expect("request");
+    let mut response = Vec::new();
+    stream.read_to_end(&mut response).await.expect("response");
+    let response = String::from_utf8_lossy(&response).to_string();
+    assert!(response.contains("hello"), "response: {response:?}");
+
+    forward.stop().await.expect("stop");
+    assert!(
+        tokio::net::TcpStream::connect(("127.0.0.1", forward.actual_port()))
+            .await
+            .is_err(),
+        "stop closes the listener"
+    );
+    assert!(events.messages().is_empty(), "{:?}", events.messages());
+    session.disconnect().await.expect("disconnect");
+}
+
+#[tokio::test]
+async fn a_remote_forward_reaches_a_device_server() {
+    let server = server!();
+    let bind_port = fixture!("SSH_TEST_REMOTE_FORWARD_PORT")
+        .parse()
+        .expect("SSH_TEST_REMOTE_FORWARD_PORT is a port");
+    let (echo_port, echo_task) = echo_server().await;
+    let handler = Arc::new(TestHandler::accepting());
+    let session = SshSession::connect(server.password_config(), handler as Arc<dyn SessionHandler>)
+        .await
+        .expect("password session");
+    let events = Arc::new(RecordingForwardSink::default());
+    let forward = session
+        .start_remote_forward(
+            ForwardConfig {
+                bind_host: "0.0.0.0".to_string(),
+                bind_port,
+                dest_host: "127.0.0.1".to_string(),
+                dest_port: echo_port,
+            },
+            Arc::clone(&events) as Arc<dyn ForwardSink>,
+        )
+        .await
+        .expect("remote forward");
+    assert_eq!(forward.actual_port(), bind_port);
+
+    let mut stream = tokio::net::TcpStream::connect((server.host.as_str(), bind_port))
+        .await
+        .expect("connect to the server's listener");
+    let payload = b"ping over the forward";
+    stream.write_all(payload).await.expect("write");
+    let mut echoed = vec![0u8; payload.len()];
+    stream.read_exact(&mut echoed).await.expect("read");
+    assert_eq!(echoed, payload, "the device echo server answered");
+    drop(stream);
+
+    forward.stop().await.expect("stop");
+    assert!(events.messages().is_empty(), "{:?}", events.messages());
+    echo_task.abort();
+    session.disconnect().await.expect("disconnect");
+}
+
+#[tokio::test]
+async fn a_bastion_reaches_a_host_only_it_can_see() {
+    let server = server!();
+    let bastion_port = fixture!("SSH_TEST_BASTION_PORT")
+        .parse()
+        .expect("SSH_TEST_BASTION_PORT is a port");
+    let target_host =
+        std::env::var("SSH_TEST_TARGET_HOST").unwrap_or_else(|_| "target".to_string());
+    let target_port = port_or("SSH_TEST_TARGET_PORT", 2222);
+
+    let mut bastion_config = server.password_config();
+    bastion_config.port = bastion_port;
+    let handler = Arc::new(TestHandler::accepting());
+    let bastion = SshSession::connect(
+        bastion_config,
+        Arc::clone(&handler) as Arc<dyn SessionHandler>,
+    )
+    .await
+    .expect("bastion session");
+
+    let mut target_config = server.password_config();
+    target_config.host = target_host;
+    target_config.port = target_port;
+    let handler = Arc::new(TestHandler::accepting());
+    let target = SshSession::connect_via(
+        Arc::clone(&bastion),
+        target_config,
+        handler as Arc<dyn SessionHandler>,
+    )
+    .await
+    .expect("the target is reachable through the bastion");
+
+    let result = target
+        .exec("echo through-the-bastion".to_string())
+        .await
+        .expect("exec through the bastion");
+    assert_eq!(
+        String::from_utf8_lossy(&result.stdout).trim(),
+        "through-the-bastion"
+    );
+
+    let sftp = target.open_sftp().await.expect("sftp through the bastion");
+    let entries = sftp.list("/home/user".to_string()).await.expect("list");
+    assert!(
+        entries.iter().any(|entry| entry.name == ".ssh"),
+        "listed {entries:?}"
+    );
+    sftp.shutdown().await.expect("shutdown");
+
+    if let Ok(third_host) = std::env::var("SSH_TEST_THIRD_HOP_HOST") {
+        let mut third_config = server.password_config();
+        third_config.host = third_host;
+        third_config.port = port_or("SSH_TEST_THIRD_HOP_PORT", 2222);
+        let handler = Arc::new(TestHandler::accepting());
+        let third = SshSession::connect_via(
+            Arc::clone(&target),
+            third_config,
+            handler as Arc<dyn SessionHandler>,
+        )
+        .await
+        .expect("a chain of two bastions composes");
+        let result = third
+            .exec("echo three-hops".to_string())
+            .await
+            .expect("exec");
+        assert_eq!(String::from_utf8_lossy(&result.stdout).trim(), "three-hops");
+        third.disconnect().await.expect("disconnect");
+    }
+
+    target.disconnect().await.expect("disconnect");
+    bastion.disconnect().await.expect("disconnect");
+}
diff --git a/src/ReactNativeSsh.types.ts b/src/ReactNativeSsh.types.ts
index 4706d57..b942ad0 100644
--- a/src/ReactNativeSsh.types.ts
+++ b/src/ReactNativeSsh.types.ts
@@ -26,6 +26,11 @@ export const SSH_ERROR_CODES = [
   'ChannelClosed',
   'Protocol',
   'KeyGeneration',
+  'NotFound',
+  'PermissionDenied',
+  'Cancelled',
+  'Forwarding',
+  'LocalIo',
 ] as const;
 
 export type SshErrorCode = (typeof SSH_ERROR_CODES)[number];
@@ -106,10 +111,45 @@ export type DisconnectNotice = {
   reason: string;
 };
 
+/** What a directory entry points at, from the server's `lstat`. */
+export type EntryKind = 'file' | 'directory' | 'symlink' | 'other';
+
+export type SftpEntry = {
+  name: string;
+  kind: EntryKind;
+  size: number;
+  /** Seconds since the Unix epoch; `null` when the server reported no time. */
+  modifiedUnix: number | null;
+  /** POSIX mode bits; `null` when the server reported none. */
+  permissions: number | null;
+};
+
+export type TransferProgress = {
+  transferred: number;
+  /** `null` when the source did not report its size. */
+  total: number | null;
+};
+
+export type TransferProgressEvent = TransferProgress & { transferId: string };
+
+export type TransferOptions = {
+  /** Called at most ten times a second while bytes move. */
+  onProgress?: (progress: TransferProgress) => void;
+  /** Cancels the transfer; the promise rejects with code `Cancelled`. */
+  signal?: AbortSignal;
+};
+
+export type ForwardErrorNotice = {
+  sessionId: string;
+  message: string;
+};
+
 export type SshEvents = {
   onHostKey: (request: HostKeyRequest) => void;
   onKeyboardInteractive: (request: KeyboardInteractiveRequest) => void;
   onDisconnect: (notice: DisconnectNotice) => void;
+  onTransferProgress: (event: TransferProgressEvent) => void;
+  onForwardError: (notice: ForwardErrorNotice) => void;
 };
 
 /** The record shapes the native module exchanges; the public API maps to them. */
@@ -140,3 +180,16 @@ export type NativeShellOptions = {
 };
 
 export type NativeParsedKey = ParsedKey;
+
+export type NativeForwardConfig = {
+  bindHost: string;
+  bindPort: number;
+  destHost: string;
+  destPort: number;
+};
+
+export type NativeForwardStart = {
+  forwardId: string;
+  /** The port the forward listens on. */
+  port: number;
+};
diff --git a/src/ReactNativeSshModule.ts b/src/ReactNativeSshModule.ts
index 6d655b5..c1d4c32 100644
--- a/src/ReactNativeSshModule.ts
+++ b/src/ReactNativeSshModule.ts
@@ -4,8 +4,11 @@ import type {
   GeneratedKey,
   NativeConnectConfig,
   NativeExecOutput,
+  NativeForwardConfig,
+  NativeForwardStart,
   NativeShellOptions,
   ParsedKey,
+  SftpEntry,
   SshEvents,
 } from './ReactNativeSsh.types';
 
@@ -14,6 +17,8 @@ declare class ReactNativeSshModule extends NativeModule<SshEvents> {
   generateEd25519Key(comment: string): Promise<GeneratedKey>;
   parsePrivateKey(pem: string, passphrase: string | null): ParsedKey;
   connect(config: NativeConnectConfig): Promise<string>;
+  /** Connects through an authenticated session that carries the stream. */
+  connectVia(jumpSessionId: string, config: NativeConnectConfig): Promise<string>;
   exec(sessionId: string, command: string): Promise<NativeExecOutput>;
   disconnect(sessionId: string): Promise<void>;
   /** Returns the id of a shell whose bytes go to a native `SshShellSource`. */
@@ -22,6 +27,40 @@ declare class ReactNativeSshModule extends NativeModule<SshEvents> {
   answerHostKey(requestId: string, accept: boolean): boolean;
   answerPrompts(requestId: string, answers: string[] | null): boolean;
   isRetryableCode(code: string): boolean;
+
+  openSftp(sessionId: string): Promise<string>;
+  closeSftp(sftpId: string): Promise<void>;
+  sftpList(sftpId: string, path: string): Promise<SftpEntry[]>;
+  sftpStat(sftpId: string, path: string): Promise<SftpEntry>;
+  sftpRealpath(sftpId: string, path: string): Promise<string>;
+  sftpMkdir(sftpId: string, path: string): Promise<void>;
+  sftpRename(sftpId: string, from: string, to: string): Promise<void>;
+  sftpRemoveFile(sftpId: string, path: string): Promise<void>;
+  sftpRemoveDir(sftpId: string, path: string): Promise<void>;
+  /** Resolves with the transferred byte count. */
+  sftpDownload(
+    sftpId: string,
+    remotePath: string,
+    localPath: string,
+    transferId: string
+  ): Promise<number>;
+  sftpUpload(
+    sftpId: string,
+    localPath: string,
+    remotePath: string,
+    transferId: string
+  ): Promise<number>;
+  cancelTransfer(transferId: string): void;
+
+  startLocalForward(
+    sessionId: string,
+    config: NativeForwardConfig
+  ): Promise<NativeForwardStart>;
+  startRemoteForward(
+    sessionId: string,
+    config: NativeForwardConfig
+  ): Promise<NativeForwardStart>;
+  stopForward(forwardId: string): Promise<void>;
 }
 
 export default requireNativeModule<ReactNativeSshModule>('ReactNativeSsh');
diff --git a/src/ReactNativeSshModule.web.ts b/src/ReactNativeSshModule.web.ts
index fd7a7ee..f9ecbd9 100644
--- a/src/ReactNativeSshModule.web.ts
+++ b/src/ReactNativeSshModule.web.ts
@@ -4,8 +4,11 @@ import type {
   GeneratedKey,
   NativeConnectConfig,
   NativeExecOutput,
+  NativeForwardConfig,
+  NativeForwardStart,
   NativeShellOptions,
   ParsedKey,
+  SftpEntry,
   SshEvents,
 } from './ReactNativeSsh.types';
 
@@ -32,6 +35,13 @@ class ReactNativeSshModule extends NativeModule<SshEvents> {
     return Promise.reject(new Error(unavailable));
   }
 
+  connectVia(
+    _jumpSessionId: string,
+    _config: NativeConnectConfig
+  ): Promise<string> {
+    return Promise.reject(new Error(unavailable));
+  }
+
   exec(_sessionId: string, _command: string): Promise<NativeExecOutput> {
     return Promise.reject(new Error(unavailable));
   }
@@ -59,6 +69,82 @@ class ReactNativeSshModule extends NativeModule<SshEvents> {
   isRetryableCode(_code: string): boolean {
     return unsupported();
   }
+
+  openSftp(_sessionId: string): Promise<string> {
+    return Promise.reject(new Error(unavailable));
+  }
+
+  closeSftp(_sftpId: string): Promise<void> {
+    return Promise.reject(new Error(unavailable));
+  }
+
+  sftpList(_sftpId: string, _path: string): Promise<SftpEntry[]> {
+    return Promise.reject(new Error(unavailable));
+  }
+
+  sftpStat(_sftpId: string, _path: string): Promise<SftpEntry> {
+    return Promise.reject(new Error(unavailable));
+  }
+
+  sftpRealpath(_sftpId: string, _path: string): Promise<string> {
+    return Promise.reject(new Error(unavailable));
+  }
+
+  sftpMkdir(_sftpId: string, _path: string): Promise<void> {
+    return Promise.reject(new Error(unavailable));
+  }
+
+  sftpRename(_sftpId: string, _from: string, _to: string): Promise<void> {
+    return Promise.reject(new Error(unavailable));
+  }
+
+  sftpRemoveFile(_sftpId: string, _path: string): Promise<void> {
+    return Promise.reject(new Error(unavailable));
+  }
+
+  sftpRemoveDir(_sftpId: string, _path: string): Promise<void> {
+    return Promise.reject(new Error(unavailable));
+  }
+
+  sftpDownload(
+    _sftpId: string,
+    _remotePath: string,
+    _localPath: string,
+    _transferId: string
+  ): Promise<number> {
+    return Promise.reject(new Error(unavailable));
+  }
+
+  sftpUpload(
+    _sftpId: string,
+    _localPath: string,
+    _remotePath: string,
+    _transferId: string
+  ): Promise<number> {
+    return Promise.reject(new Error(unavailable));
+  }
+
+  cancelTransfer(_transferId: string): void {
+    unsupported();
+  }
+
+  startLocalForward(
+    _sessionId: string,
+    _config: NativeForwardConfig
+  ): Promise<NativeForwardStart> {
+    return Promise.reject(new Error(unavailable));
+  }
+
+  startRemoteForward(
+    _sessionId: string,
+    _config: NativeForwardConfig
+  ): Promise<NativeForwardStart> {
+    return Promise.reject(new Error(unavailable));
+  }
+
+  stopForward(_forwardId: string): Promise<void> {
+    return Promise.reject(new Error(unavailable));
+  }
 }
 
 export default registerWebModule(ReactNativeSshModule, 'ReactNativeSsh');
diff --git a/src/errors.ts b/src/errors.ts
new file mode 100644
index 0000000..acaa567
--- /dev/null
+++ b/src/errors.ts
@@ -0,0 +1,52 @@
+import {
+  SSH_ERROR_CODES,
+  type SshErrorCode,
+} from './ReactNativeSsh.types';
+import ReactNativeSsh from './ReactNativeSshModule';
+
+/** A failed SSH call, categorised by [`SshErrorCode`]. */
+export class SshError extends Error {
+  readonly code: SshErrorCode;
+
+  constructor(code: SshErrorCode, message: string) {
+    super(message);
+    this.name = 'SshError';
+    this.code = code;
+  }
+}
+
+/**
+ * Whether repeating the call that failed can succeed without changing its
+ * inputs. Only transient transport failures are retryable.
+ */
+export function isRetryableError(error: SshError): boolean {
+  return ReactNativeSsh.isRetryableCode(error.code);
+}
+
+export async function guard<T>(call: () => Promise<T>): Promise<T> {
+  try {
+    return await call();
+  } catch (cause) {
+    throw translate(cause);
+  }
+}
+
+export function translate(cause: unknown): SshError {
+  if (cause instanceof SshError) {
+    return cause;
+  }
+
+  const message = cause instanceof Error ? cause.message : String(cause);
+  return new SshError(codeOf(cause), message);
+}
+
+function codeOf(cause: unknown): SshErrorCode {
+  const candidate = hasCode(cause) ? cause.code : undefined;
+  const match = SSH_ERROR_CODES.find((code) => code === candidate);
+
+  return match ?? 'Protocol';
+}
+
+function hasCode(cause: unknown): cause is { code: unknown } {
+  return typeof cause === 'object' && cause !== null && 'code' in cause;
+}
diff --git a/src/forward.ts b/src/forward.ts
new file mode 100644
index 0000000..6b89984
--- /dev/null
+++ b/src/forward.ts
@@ -0,0 +1,63 @@
+import type {
+  NativeForwardConfig,
+  NativeForwardStart,
+} from './ReactNativeSsh.types';
+import ReactNativeSsh from './ReactNativeSshModule';
+import { guard } from './errors';
+
+/** Where a forward listens and where it delivers connections. */
+export type ForwardConfig = {
+  /** Interface the forward listens on: the device locally, the server remotely. */
+  bindHost?: string;
+  /** `0` asks the operating system or the server for a free port. */
+  bindPort?: number;
+  destHost: string;
+  destPort: number;
+};
+
+/** A running forward. `stop` ends the listener and its open connections. */
+export type Forward = {
+  /** The port data actually reaches. */
+  port: number;
+  stop: () => Promise<void>;
+};
+
+const DEFAULT_BIND_HOST = '127.0.0.1';
+
+/** Listens on the device and reaches `destHost:destPort` from the server. */
+export function startLocalForward(
+  sessionId: string,
+  config: ForwardConfig
+): Promise<Forward> {
+  return track(() =>
+    ReactNativeSsh.startLocalForward(sessionId, nativeConfig(config))
+  );
+}
+
+/** Asks the server to listen and delivers connections to the device. */
+export function startRemoteForward(
+  sessionId: string,
+  config: ForwardConfig
+): Promise<Forward> {
+  return track(() =>
+    ReactNativeSsh.startRemoteForward(sessionId, nativeConfig(config))
+  );
+}
+
+async function track(start: () => Promise<NativeForwardStart>): Promise<Forward> {
+  const forward = await guard(start);
+
+  return {
+    port: forward.port,
+    stop: () => guard(() => ReactNativeSsh.stopForward(forward.forwardId)),
+  };
+}
+
+function nativeConfig(config: ForwardConfig): NativeForwardConfig {
+  return {
+    bindHost: config.bindHost ?? DEFAULT_BIND_HOST,
+    bindPort: config.bindPort ?? 0,
+    destHost: config.destHost,
+    destPort: config.destPort,
+  };
+}
diff --git a/src/index.ts b/src/index.ts
index 644045b..8b9718e 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,29 +1,50 @@
 export * from './terminal';
 export { default } from './ReactNativeSshModule';
 export type { GeneratedKey } from './ReactNativeSsh.types';
+export { SshError, isRetryableError } from './errors';
 export {
-  SshError,
   addSshListener,
   answerHostKey,
   answerPrompts,
   closeShell,
   connect,
+  connectVia,
   disconnect,
   exec,
-  isRetryableError,
   openShell,
   parsePrivateKey,
 } from './ssh';
+export { startLocalForward, startRemoteForward } from './forward';
+export {
+  closeSftp,
+  download,
+  listDirectory,
+  makeDirectory,
+  openSftp,
+  realpath as resolvePath,
+  removeDirectory,
+  removeFile,
+  renamePath,
+  statPath,
+  upload,
+} from './sftp';
+export type { Forward, ForwardConfig } from './forward';
 export type {
   ConnectOptions,
   DisconnectNotice,
+  EntryKind,
   ExecOutput,
+  ForwardErrorNotice,
   HostKeyRequest,
   KeyboardInteractivePrompt,
   KeyboardInteractiveRequest,
   ParsedKey,
+  SftpEntry,
   ShellOptions,
   SshAuth,
   SshErrorCode,
   SshEvents,
+  TransferOptions,
+  TransferProgress,
+  TransferProgressEvent,
 } from './ReactNativeSsh.types';
diff --git a/src/sftp.ts b/src/sftp.ts
new file mode 100644
index 0000000..f40dd63
--- /dev/null
+++ b/src/sftp.ts
@@ -0,0 +1,116 @@
+import type { SftpEntry, TransferOptions } from './ReactNativeSsh.types';
+import ReactNativeSsh from './ReactNativeSshModule';
+import { guard } from './errors';
+
+/** Opens the SFTP subsystem on a new channel of the session. */
+export function openSftp(sessionId: string): Promise<string> {
+  return guard(() => ReactNativeSsh.openSftp(sessionId));
+}
+
+/** Ends the SFTP channel. Other channels of the session stay up. */
+export function closeSftp(sftpId: string): Promise<void> {
+  return guard(() => ReactNativeSsh.closeSftp(sftpId));
+}
+
+export function listDirectory(
+  sftpId: string,
+  path: string
+): Promise<SftpEntry[]> {
+  return guard(() => ReactNativeSsh.sftpList(sftpId, path));
+}
+
+export function statPath(sftpId: string, path: string): Promise<SftpEntry> {
+  return guard(() => ReactNativeSsh.sftpStat(sftpId, path));
+}
+
+/** Resolves symbolic links and `~` into an absolute server path. */
+export function realpath(sftpId: string, path: string): Promise<string> {
+  return guard(() => ReactNativeSsh.sftpRealpath(sftpId, path));
+}
+
+export function makeDirectory(sftpId: string, path: string): Promise<void> {
+  return guard(() => ReactNativeSsh.sftpMkdir(sftpId, path));
+}
+
+export function renamePath(
+  sftpId: string,
+  from: string,
+  to: string
+): Promise<void> {
+  return guard(() => ReactNativeSsh.sftpRename(sftpId, from, to));
+}
+
+export function removeFile(sftpId: string, path: string): Promise<void> {
+  return guard(() => ReactNativeSsh.sftpRemoveFile(sftpId, path));
+}
+
+export function removeDirectory(sftpId: string, path: string): Promise<void> {
+  return guard(() => ReactNativeSsh.sftpRemoveDir(sftpId, path));
+}
+
+/**
+ * Copies a remote file to `localFileUrl`, a `file://` URL in the app sandbox.
+ * Resolves with the number of bytes written once the file is complete: an
+ * interrupted transfer leaves nothing at `localFileUrl`.
+ */
+export function download(
+  sftpId: string,
+  remotePath: string,
+  localFileUrl: string,
+  options: TransferOptions = {}
+): Promise<number> {
+  return transfer(
+    (transferId) =>
+      ReactNativeSsh.sftpDownload(sftpId, remotePath, localFileUrl, transferId),
+    options
+  );
+}
+
+/**
+ * Copies a `file://` URL from the app sandbox to `remotePath`. Resolves with
+ * the number of bytes read once the server has the complete file.
+ */
+export function upload(
+  sftpId: string,
+  localFileUrl: string,
+  remotePath: string,
+  options: TransferOptions = {}
+): Promise<number> {
+  return transfer(
+    (transferId) =>
+      ReactNativeSsh.sftpUpload(sftpId, localFileUrl, remotePath, transferId),
+    options
+  );
+}
+
+let transfers = 0;
+
+async function transfer(
+  start: (transferId: string) => Promise<number>,
+  options: TransferOptions
+): Promise<number> {
+  const transferId = `transfer-${(transfers += 1)}`;
+  const subscription = options.onProgress
+    ? listen(transferId, options.onProgress)
+    : undefined;
+  const abort = () => ReactNativeSsh.cancelTransfer(transferId);
+  options.signal?.addEventListener('abort', abort);
+
+  try {
+    return await guard(() => start(transferId));
+  } finally {
+    subscription?.remove();
+    options.signal?.removeEventListener('abort', abort);
+  }
+}
+
+function listen(
+  transferId: string,
+  onProgress: NonNullable<TransferOptions['onProgress']>
+) {
+  return ReactNativeSsh.addListener('onTransferProgress', (event) => {
+    if (event.transferId === transferId) {
+      onProgress({ transferred: event.transferred, total: event.total });
+    }
+  });
+}
diff --git a/src/ssh.ts b/src/ssh.ts
index 3fc2a26..88d40af 100644
--- a/src/ssh.ts
+++ b/src/ssh.ts
@@ -1,16 +1,16 @@
 import type { EventSubscription } from 'expo';
 
-import {
-  SSH_ERROR_CODES,
-  type ConnectOptions,
-  type ExecOutput,
-  type NativeAuth,
-  type ParsedKey,
-  type ShellOptions,
-  type SshErrorCode,
-  type SshEvents,
+import type {
+  ConnectOptions,
+  ExecOutput,
+  NativeAuth,
+  NativeConnectConfig,
+  ParsedKey,
+  ShellOptions,
+  SshEvents,
 } from './ReactNativeSsh.types';
 import ReactNativeSsh from './ReactNativeSshModule';
+import { guard, isRetryableError, SshError, translate } from './errors';
 
 const DEFAULT_PORT = 22;
 const DEFAULT_CONNECT_TIMEOUT_MS = 15_000;
@@ -19,39 +19,25 @@ const DEFAULT_TERM = 'xterm-256color';
 const DEFAULT_COLS = 80;
 const DEFAULT_ROWS = 24;
 
-/** A failed SSH call, categorised by [`SshErrorCode`]. */
-export class SshError extends Error {
-  readonly code: SshErrorCode;
-
-  constructor(code: SshErrorCode, message: string) {
-    super(message);
-    this.name = 'SshError';
-    this.code = code;
-  }
-}
-
 /**
- * Whether repeating the call that failed can succeed without changing its
- * inputs. Only transient transport failures are retryable.
+ * Connects and authenticates. Host-key and keyboard-interactive decisions
+ * arrive through [`addSshListener`] while this promise is pending.
  */
-export function isRetryableError(error: SshError): boolean {
-  return ReactNativeSsh.isRetryableCode(error.code);
+export function connect(options: ConnectOptions): Promise<string> {
+  return guard(() => ReactNativeSsh.connect(nativeConnectConfig(options)));
 }
 
 /**
- * Connects and authenticates. Host-key and keyboard-interactive decisions
- * arrive through [`addSshListener`] while this promise is pending.
+ * Connects through `jumpSessionId`, an authenticated session whose network
+ * reaches the target. Chaining bastions works the same way: each jump session
+ * may itself have been opened through another one.
  */
-export function connect(options: ConnectOptions): Promise<string> {
+export function connectVia(
+  jumpSessionId: string,
+  options: ConnectOptions
+): Promise<string> {
   return guard(() =>
-    ReactNativeSsh.connect({
-      host: options.host,
-      port: options.port ?? DEFAULT_PORT,
-      username: options.username,
-      auth: nativeAuth(options.auth),
-      connectTimeoutMs: options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS,
-      keepaliveIntervalS: options.keepaliveIntervalS ?? DEFAULT_KEEPALIVE_INTERVAL_S,
-    })
+    ReactNativeSsh.connectVia(jumpSessionId, nativeConnectConfig(options))
   );
 }
 
@@ -115,6 +101,8 @@ export function addSshListener<K extends keyof SshEvents>(
   return ReactNativeSsh.addListener(event, listener);
 }
 
+export { isRetryableError, SshError };
+
 export type {
   ConnectOptions,
   DisconnectNotice,
@@ -128,6 +116,18 @@ export type {
   SshEvents,
 } from './ReactNativeSsh.types';
 
+function nativeConnectConfig(options: ConnectOptions): NativeConnectConfig {
+  return {
+    host: options.host,
+    port: options.port ?? DEFAULT_PORT,
+    username: options.username,
+    auth: nativeAuth(options.auth),
+    connectTimeoutMs: options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS,
+    keepaliveIntervalS:
+      options.keepaliveIntervalS ?? DEFAULT_KEEPALIVE_INTERVAL_S,
+  };
+}
+
 function nativeAuth(auth: ConnectOptions['auth']): NativeAuth {
   switch (auth.type) {
     case 'password':
@@ -143,30 +143,3 @@ function nativeAuth(auth: ConnectOptions['auth']): NativeAuth {
   }
 }
 
-async function guard<T>(call: () => Promise<T>): Promise<T> {
-  try {
-    return await call();
-  } catch (cause) {
-    throw translate(cause);
-  }
-}
-
-function translate(cause: unknown): SshError {
-  if (cause instanceof SshError) {
-    return cause;
-  }
-
-  const message = cause instanceof Error ? cause.message : String(cause);
-  return new SshError(codeOf(cause), message);
-}
-
-function codeOf(cause: unknown): SshErrorCode {
-  const candidate = hasCode(cause) ? cause.code : undefined;
-  const match = SSH_ERROR_CODES.find((code) => code === candidate);
-
-  return match ?? 'Protocol';
-}
-
-function hasCode(cause: unknown): cause is { code: unknown } {
-  return typeof cause === 'object' && cause !== null && 'code' in cause;
-}