feat: sshnp pure dart for direct ssh

packages/sshnoports/bin/sshnp.dart

@@ -56,12 +56,14 @@ void main(List<String> args) async {
     await sshnp.init();
     SSHNPResult res = await sshnp.run();
     if (res is SSHNPFailed) {
+      stderr.write('$res\n');
       exit(1);
     }
     if (res is SSHCommand) {
       stdout.write('$res\n');
+      await sshnp.done;
+      exit(0);
     }
-    exit(0);
   }, (Object error, StackTrace stackTrace) async {
     stderr.writeln(error.toString());
 

packages/sshnoports/lib/common/defaults.dart

@@ -0,0 +1,11 @@
+import 'package:sshnoports/sshrv/sshrv.dart';
+
+const defaultVerbose = false;
+const defaultRsa = false;
+const defaultRootDomain = 'root.atsign.org';
+const defaultSshrvGenerator = SSHRV.localBinary;
+const defaultLocalSshdPort = 22;
+const defaultRemoteSshdPort = 22;
+
+/// value in seconds after which idle ssh tunnels will be closed
+const defaultIdleTimeout = 15;

packages/sshnoports/lib/common/utils.dart

@@ -112,6 +112,106 @@ void assertValidValue(Map m, String k, Type t) {
   }
 }
 
+Future<(String, String)> generateSshKeys(
+    {required bool rsa,
+    required String sessionId,
+    String? sshHomeDirectory}) async {
+  sshHomeDirectory ??=
+      getDefaultSshDirectory(getHomeDirectory(throwIfNull: true)!);
+  if (!Directory(sshHomeDirectory).existsSync()) {
+    Directory(sshHomeDirectory).createSync();
+  }
+
+  if (rsa) {
+    await Process.run('ssh-keygen',
+        ['-t', 'rsa', '-b', '4096', '-f', '${sessionId}_sshnp', '-q', '-N', ''],
+        workingDirectory: sshHomeDirectory);
+  } else {
+    await Process.run(
+        'ssh-keygen',
+        [
+          '-t',
+          'ed25519',
+          '-a',
+          '100',
+          '-f',
+          '${sessionId}_sshnp',
+          '-q',
+          '-N',
+          ''
+        ],
+        workingDirectory: sshHomeDirectory);
+  }
+
+  String sshPublicKey =
+      await File('$sshHomeDirectory${sessionId}_sshnp.pub').readAsString();
+  String sshPrivateKey =
+      await File('$sshHomeDirectory${sessionId}_sshnp').readAsString();
+
+  return (sshPublicKey, sshPrivateKey);
+}
+
+Future<void> addEphemeralKeyToAuthorizedKeys(
+    {required String sshPublicKey,
+    required int localSshdPort,
+    String? homeDirectory,
+    String sessionId = '',
+    String permissions = ''}) async {
+  // Check to see if the ssh public key looks like one!
+  if (!sshPublicKey.startsWith('ssh-')) {
+    throw ('$sshPublicKey does not look like a public key');
+  }
+
+  homeDirectory ??= getHomeDirectory(throwIfNull: true)!;
+
+  var sshHomeDirectory =
+      '$homeDirectory/.ssh/'.replaceAll('/', Platform.pathSeparator);
+  if (!Directory(sshHomeDirectory).existsSync()) {
+    Directory(sshHomeDirectory).createSync();
+  }
+
+  // Check to see if the ssh Publickey is already in the authorized_keys file.
+  // If not, then append it.
+  var authKeys = File('${sshHomeDirectory}authorized_keys');
+
+  var authKeysContent = await authKeys.readAsString();
+  if (!authKeysContent.endsWith('\n')) {
+    await authKeys.writeAsString('\n', mode: FileMode.append);
+  }
+
+  if (!authKeysContent.contains(sshPublicKey)) {
+    if (permissions.isNotEmpty && !permissions.startsWith(',')) {
+      permissions = ',$permissions';
+    }
+    // Set up a safe authorized_keys file, for the ssh tunnel
+    await authKeys.writeAsString(
+        'command="echo \\"ssh session complete\\";sleep 20"'
+        ',PermitOpen="localhost:$localSshdPort"'
+        '$permissions'
+        ' '
+        '${sshPublicKey.trim()}'
+        ' '
+        '$sessionId\n',
+        mode: FileMode.append);
+  }
+}
+
+Future<void> removeEphemeralKeyFromAuthorizedKeys(
+    String sshHomeDirectory, String sessionId, AtSignLogger logger) async {
+  try {
+    final File file = File('${sshHomeDirectory}authorized_keys');
+    // read into List of strings
+    final List<String> lines = await file.readAsLines();
+    // find the line we want to remove
+    lines.removeWhere((element) => element.contains(sessionId));
+    // Write back the file and add a \n
+    await file.writeAsString(lines.join('\n'));
+    await file.writeAsString('\n', mode: FileMode.writeOnlyAppend);
+  } catch (e) {
+    logger.severe('Unable to tidy up ${sshHomeDirectory}authorized_keys');
+  }
+}
+
 String signAndWrapAndJsonEncode(AtClient atClient, Map payload) {
   Map envelope = {'payload': payload};
 

packages/sshnoports/lib/sshnp/sshnp.dart

@@ -7,6 +7,7 @@ import 'package:at_client/at_client.dart' hide StringBuffer;
 import 'package:at_commons/at_builders.dart';
 import 'package:at_utils/at_logger.dart';
 import 'package:at_utils/at_utils.dart';
+import 'package:dartssh2/dartssh2.dart';
 import 'package:logging/logging.dart';
 import 'package:meta/meta.dart';
 import 'package:path/path.dart' as path;
@@ -21,6 +22,8 @@ import 'package:sshnoports/sshrvd/sshrvd.dart';
 import 'package:sshnoports/version.dart';
 import 'package:uuid/uuid.dart';
 
+import 'package:sshnoports/common/defaults.dart' as defaults;
+
 part 'sshnp_impl.dart';
 part 'sshnp_params.dart';
 part 'sshnp_result.dart';
@@ -83,10 +86,13 @@ abstract class SSHNP {
   abstract int localPort;
 
   /// Port that local sshd is listening on localhost interface
-  /// Default set to 22
-
+  /// Default set to [defaultLocalSshdPort]
   abstract int localSshdPort;
 
+  /// Port that the remote sshd is listening on localhost interface
+  /// Default set to [defaultRemoteSshdPort]
+  abstract int remoteSshdPort;
+
   // ====================================================================
   // Derived final instance variables, set during construction or init
   // ====================================================================
@@ -146,19 +152,27 @@ abstract class SSHNP {
 
   abstract final bool direct;
 
+  /// If ssh tunnel is unused (no active connections via port forwards) for
+  /// longer than this many seconds, then the connection will be closed.
+  /// Defaults to [defaults.defaultIdleTimeout]
+  abstract int idleTimeout;
+
+  /// The ssh client to use when doing outbound ssh within this program
+  abstract SupportedSshClient sshClient;
+
+  /// Completes when the SSHNP instance is no longer doing anything
+  /// e.g. controlling a direct ssh tunnel using the pure-dart SSHClient
+  Future<void> get done;
+
   /// Default parameters for sshnp
   static const defaultDevice = 'default';
   static const defaultPort = 22;
   static const defaultLocalPort = 0;
   static const defaultSendSshPublicKey = '';
   static const defaultLocalSshOptions = <String>[];
-  static const defaultVerbose = false;
-  static const defaultRsa = false;
-  static const defaultRootDomain = 'root.atsign.org';
-  static const defaultSshrvGenerator = SSHRV.localBinary;
-  static const defaultLocalSshdPort = 22;
   static const defaultLegacyDaemon = true;
   static const defaultListDevices = false;
+  static const defaultSshClient = SupportedSshClient.hostSsh;
 
   factory SSHNP({
     // final fields
@@ -177,9 +191,12 @@ abstract class SSHNP {
     required int localPort,
     String? remoteUsername,
     bool verbose = false,
-    SSHRVGenerator sshrvGenerator = defaultSshrvGenerator,
-    int localSshdPort = defaultLocalSshdPort,
+    SSHRVGenerator sshrvGenerator = defaults.defaultSshrvGenerator,
+    int localSshdPort = defaults.defaultLocalSshdPort,
     bool legacyDaemon = defaultLegacyDaemon,
+    int remoteSshdPort = defaults.defaultRemoteSshdPort,
+    int idleTimeout = defaults.defaultIdleTimeout,
+    required SupportedSshClient sshClient,
   }) {
     return SSHNPImpl(
       atClient: atClient,
@@ -199,6 +216,9 @@ abstract class SSHNP {
       sshrvGenerator: sshrvGenerator,
       localSshdPort: localSshdPort,
       legacyDaemon: legacyDaemon,
+      remoteSshdPort: remoteSshdPort,
+      idleTimeout: idleTimeout,
+      sshClient: sshClient,
     );
   }
 

packages/sshnoports/lib/sshnp/sshnp_arg.dart

@@ -1,3 +1,6 @@
+import 'package:sshnoports/common/supported_ssh_clients.dart';
+
+import 'package:sshnoports/common/defaults.dart';
 import 'sshnp.dart';
 
 enum ArgFormat {
@@ -20,6 +23,7 @@ class SSHNPArg {
   final bool mandatory;
   final dynamic defaultsTo;
   final ArgType type;
+  final Iterable<String>? allowed;
 
   const SSHNPArg({
     required this.name,
@@ -29,6 +33,7 @@ class SSHNPArg {
     this.format = ArgFormat.option,
     this.defaultsTo,
     this.type = ArgType.string,
+    this.allowed,
   });
 
   String get bashName => name.replaceAll('-', '_').toUpperCase();
@@ -90,13 +95,12 @@ class SSHNPArg {
       type: ArgType.integer,
     ),
     SSHNPArg(
-      name: 'local-port',
-      abbr: 'l',
-      help:
-          'Reverse ssh port to listen on, on your local machine, by sshnp default finds a spare port',
-      defaultsTo: SSHNP.defaultLocalPort,
-      type: ArgType.integer
-    ),
+        name: 'local-port',
+        abbr: 'l',
+        help:
+            'Reverse ssh port to listen on, on your local machine, by sshnp default finds a spare port',
+        defaultsTo: SSHNP.defaultLocalPort,
+        type: ArgType.integer),
     SSHNPArg(
       name: 'ssh-public-key',
       abbr: 's',
@@ -113,14 +117,14 @@ class SSHNPArg {
     SSHNPArg(
       name: 'verbose',
       abbr: 'v',
-      defaultsTo: SSHNP.defaultVerbose,
+      defaultsTo: defaultVerbose,
       help: 'More logging',
       format: ArgFormat.flag,
     ),
     SSHNPArg(
       name: 'rsa',
       abbr: 'r',
-      defaultsTo: SSHNP.defaultRsa,
+      defaultsTo: defaultRsa,
       help: 'Use RSA 4096 keys rather than the default ED25519 keys',
       format: ArgFormat.flag,
     ),
@@ -132,26 +136,50 @@ class SSHNPArg {
     SSHNPArg(
       name: 'root-domain',
       help: 'atDirectory domain',
-      defaultsTo: SSHNP.defaultRootDomain,
+      defaultsTo: defaultRootDomain,
       mandatory: false,
       format: ArgFormat.option,
     ),
     SSHNPArg(
       name: 'local-sshd-port',
-      help: 'port sshd is listening locally on localhost',
-      defaultsTo: SSHNP.defaultLocalSshdPort,
+      help: 'port on which sshd is listening locally on the client host',
+      defaultsTo: defaultLocalSshdPort,
       abbr: 'P',
       mandatory: false,
       format: ArgFormat.option,
       type: ArgType.integer,
     ),
-
     SSHNPArg(
       name: 'legacy-daemon',
       defaultsTo: SSHNP.defaultLegacyDaemon,
       help: 'Request is to a legacy (< 3.5.0) noports daemon',
       format: ArgFormat.flag,
     ),
+    SSHNPArg(
+      name: 'remote-sshd-port',
+      help: 'port on which sshd is listening locally on the device host',
+      defaultsTo: defaultRemoteSshdPort,
+      mandatory: false,
+      format: ArgFormat.option,
+      type: ArgType.integer,
+    ),
+    SSHNPArg(
+      name: 'idle-timeout',
+      help:
+          'number of seconds after which inactive ssh connections will be closed',
+      defaultsTo: defaultIdleTimeout,
+      mandatory: false,
+      format: ArgFormat.option,
+      type: ArgType.integer,
+    ),
+    SSHNPArg(
+        name: 'ssh-client',
+        help: 'What to use for outbound ssh connections',
+        defaultsTo: SupportedSshClient.hostSsh.cliArg,
+        mandatory: false,
+        format: ArgFormat.option,
+        type: ArgType.string,
+        allowed: SupportedSshClient.values.map((c) => c.cliArg).toList()),
   ];
 
   @override