sgcSSH : SSH, SFTP et SCP post-quantiques pour Delphi et .NET

· Composants
sgcSSH : SSH, SFTP et SCP post-quantiques pour Delphi et .NET | Blog eSeGeCe
Nouveau produit · sgcSSH

SSH, SFTP et SCP pour Delphi et .NET.
Post-quantique par défaut.

Trois clients et deux serveurs qui placent SSH au cœur de vos propres applications. L'échange de clés hybride mlkem768x25519-sha256 est proposé en premier des deux côtés, et la cryptographie s'exécute en code natif.

  • ML-KEM-768 + X25519
  • SFTP v3
  • SCP
  • Ed25519
  • AES-GCM
Les démos sgcSSH côte à côte : le client SSH exécutant une commande et un shell interactif, le client SFTP parcourant un dossier distant, le serveur SFTP servant un dossier racine, et un terminal montrant l'échange de clés mlkem768x25519-sha256
5composants
16requêtes SFTP en vol
~1 spour 100 Mo sur un LAN
0DLL OpenSSL avec la crypto native

SSH est le moyen standard d'administrer des serveurs et d'échanger des fichiers en toute sécurité. sgcSSH l'apporte à vos applications Delphi, C++Builder et .NET sous la forme de composants ordinaires, côté client comme côté serveur.

Avec sgcSSH, vous exécutez une commande sur un serveur Linux et récupérez sa sortie sous forme de chaîne, ouvrez un shell interactif, redirigez un port, envoyez un dossier via SFTP ou SCP, ou transformez votre propre application en serveur SSH et SFTP avec un dossier privé pour chaque utilisateur. Le client et le serveur proposent tous deux en premier l'échange de clés hybride post-quantique, celui que les dernières versions de SSH utilisent par défaut.

sgcSSH en un coup d'œil : les clients, les serveurs et l'échange de clés post-quantique. Aussi sur YouTube.

Trois clients, deux serveurs

Chacun est un composant non visuel de la page de palette SGC SSH. Vous le déposez sur une fiche ou le créez dans le code, renseignez l'hôte et les identifiants, branchez les événements, puis vous vous connectez ou démarrez l'écoute. Les classes .NET portent les mêmes noms.

Client SSHTsgcSSHClientCommandes, shells interactifs avec pty, redirection de ports et renouvellement des clés.
Client SFTPTsgcSFTPClientTransferts de fichiers SFTP v3 avec 16 requêtes en vol.
Client SCPTsgcSCPClientFichiers et dossiers entiers avec scp, en conservant les dates des fichiers.
Serveur SSHTsgcSSHServerConnexion par mot de passe et par clé publique, exec, shell et sous-systèmes.
Serveur SFTPTsgcSFTPServerSFTP v3 et SCP depuis un dossier racine, avec une cellule isolée par utilisateur.

Échange de clés post-quantique, activé par défaut

Le trafic chiffré aujourd'hui peut être attaqué demain. Un attaquant enregistre dès maintenant la session chiffrée et la déchiffre plus tard, lorsqu'un ordinateur quantique assez puissant existera. C'est ce qu'on appelle harvest now, decrypt later (récolter maintenant, déchiffrer plus tard), et cela compte pour tout ce qui doit rester confidentiel pendant des années : identifiants, contrats, fichiers clients.

sgcSSH y répond avec l'échange de clés hybride mlkem768x25519-sha256. Il combine ML-KEM-768 (FIPS 203), un algorithme post-quantique, avec le classique X25519, de sorte que les clés de session restent secrètes tant que l'un des deux n'est pas cassé. C'est le choix par défaut des dernières versions de SSH.

Voici un client en ligne de commande ssh standard qui se connecte à la démo du serveur SSH. L'échange hybride est négocié avec les réglages par défaut des deux côtés :

ssh -v contre TsgcSSHServer
$ ssh -v -p 2290 deploy@127.0.0.1 "echo hello"
debug1: Remote protocol version 2.0, remote software version sgcSSH
debug1: kex: algorithm: mlkem768x25519-sha256
debug1: kex: host key algorithm: ssh-ed25519
debug1: kex: client->server cipher: aes128-ctr MAC: hmac-sha2-256 compression: none
Authenticated to 127.0.0.1 ([127.0.0.1]:2290) using "password".
hello

Cryptographie native, aucune DLL à déployer

Dans Delphi, la propriété CryptoLibrary choisit où sont calculés les algorithmes classiques (ECDH, Diffie-Hellman, AES, HMAC et les signatures des clés d'hôte) :

L'échange hybride ML-KEM-768 et X25519 est du code natif de la bibliothèque avec les deux options. Les composants .NET sont entièrement en code managé, sans aucun OpenSSL, et sur .NET 8 et versions ultérieures AES-GCM est accéléré matériellement.

Envoyer un fichier via SFTP avec l'échange post-quantique et la cryptographie native tient en quelques lignes :

uses
  sgcSSH_Crypto, sgcSSH_Client;

procedure TForm1.UploadInvoices;
var
  SFTP: TsgcSFTPClient;
begin
  SFTP := TsgcSFTPClient.Create(nil);
  try
    SFTP.Host := 'files.example.com';
    SFTP.Authentication.Username := 'partner';
    SFTP.Authentication.Password := 'secret';
    SFTP.PostQuantumKex := True;      // the default: mlkem768x25519-sha256 first
    SFTP.CryptoLibrary := sshcNative; // sgcCrypto units, no OpenSSL DLL
    SFTP.Connect;
    SFTP.Put('C:\export\invoices.zip', '/upload/invoices.zip');
    Memo1.Lines.Add('Uploaded ' +
      IntToStr(SFTP.FileSize('/upload/invoices.zip')) + ' bytes');
    SFTP.Disconnect;
  finally
    SFTP.Free;
  end;
end;

Le client SSH : commandes, shells et tunnels

TsgcSSHClient s'authentifie avec un mot de passe ou une clé privée, et OnSSHHostKey vous fournit le type de clé d'hôte et son empreinte afin que vous puissiez la comparer à vos hôtes connus et rejeter une clé inconnue ou modifiée.

La démo du client SSH : connexion avec l'échange de clés post-quantique et la bibliothèque crypto native, la sortie d'une commande distante, un shell interactif listant un dossier, et la clé d'hôte Ed25519 acceptée dans le journal
La démo du client SSH : une commande distante, un shell interactif et la vérification de la clé d'hôte.

Exécuter une commande de maintenance avec une clé privée et une vérification de la clé d'hôte :

procedure TForm1.CheckDisk;
var
  SSH: TsgcSSHClient;
begin
  SSH := TsgcSSHClient.Create(nil);
  try
    SSH.Host := 'build01.example.com';
    SSH.Authentication.Username := 'deploy';
    SSH.Authentication.PrivateKeyFile := 'C:\keys\id_ed25519.pem';
    SSH.OnSSHHostKey := DoHostKey;
    SSH.Connect;
    Memo1.Text := SSH.Execute('df -h /var');
    SSH.Disconnect;
  finally
    SSH.Free;
  end;
end;

procedure TForm1.DoHostKey(Sender: TObject; const aHostKeyType,
  aFingerprint: string; var aAction: TIdSSHHostKeyVerification);
begin
  if aFingerprint <> FKnownFingerprint then
    aAction := sshHostKeyReject;
end;

SFTP et SCP : des transferts de fichiers rapides

TsgcSFTPClient parle SFTP v3 sur la même connexion SSH, avec une méthode par tâche : RealPath résout le dossier personnel, ListDirectory renvoie les noms, les tailles et les dates, Put et Get envoient et téléchargent un fichier, et Rename, Delete, MakeDirectory et RemoveDirectory couvrent le reste d'un gestionnaire de fichiers. OnSFTPProgress signale les octets transférés pour une barre de progression.

Les transferts sont rapides parce que le client n'attend pas chaque bloc. Il garde 16 requêtes en vol, si bien qu'un fichier de 100 Mo prend environ une seconde sur un réseau local.

La démo du client SFTP : un dossier distant listé avec les noms, les tailles, les dates et les indicateurs de dossier, et la barre de progression d'un gros téléchargement
La démo du client SFTP parcourant un dossier distant pendant le téléchargement d'un gros fichier.

TsgcSCPClient copie des fichiers via SSH vers tout serveur qui autorise la commande scp, sans service de transfert de fichiers distinct. Upload et Download copient un fichier, UploadFolder et DownloadFolder copient une arborescence entière, et PreserveTimes conserve les dates de modification et d'accès de l'autre côté.

La démo du client SCP avec des boutons pour envoyer et télécharger un fichier ou un dossier entier, l'option de conservation des dates des fichiers et la progression d'un transfert
La démo du client SCP : fichiers isolés ou dossiers entiers, avec ou sans les dates des fichiers.

Votre propre serveur SSH et SFTP

TsgcSSHServer écoute sur le port de votre choix et prouve son identité avec des clés d'hôte Ed25519, ECDSA ou RSA chargées depuis HostKeyFiles. GenerateHostKeyEd25519 en crée une pour vous. OnSSHAuthPassword et OnSSHAuthPublicKey décident qui entre, le second avec le type de clé et son empreinte SHA256. OnSSHExec répond aux commandes distantes et OnSSHShell sert une session interactive. Tout client SSH standard peut s'y connecter, y compris les outils en ligne de commande ssh, sftp et scp.

Associez un TsgcSFTPServer et le même serveur devient un serveur de fichiers :

uses
  sgcSSH_Crypto, sgcSSH_Server, sgcSSH_SFTP_Server;

procedure TForm1.StartServer;
begin
  if not FileExists('hostkey_ed25519.pem') then
    TsgcSSHServer.GenerateHostKeyEd25519('hostkey_ed25519.pem');

  SFTP := TsgcSFTPServer.Create(Self);
  SFTP.RootFolder := 'D:\sftp';
  SFTP.OnSFTPUserRoot := DoUserRoot;
  SFTP.OnSFTPOperation := DoOperation;

  SSH := TsgcSSHServer.Create(Self);
  SSH.Port := 22;
  SSH.HostKeyFiles.Text := 'hostkey_ed25519.pem';
  SSH.CryptoLibrary := sshcNative;
  SSH.SFTPServer := SFTP;
  SSH.OnSSHAuthPassword := DoAuthPassword;
  SSH.Active := True;
end;

procedure TForm1.DoAuthPassword(Sender: TObject;
  aConnection: TsgcSSHServerConnection; const aUsername, aPassword: string;
  var aAccept: Boolean);
begin
  aAccept := CheckUser(aUsername, aPassword); // your own user store
end;

procedure TForm1.DoUserRoot(Sender: TObject; const aUsername: string;
  var aRootFolder: string);
begin
  aRootFolder := 'D:\sftp\' + aUsername; // every user in its own folder
  ForceDirectories(aRootFolder);
end;

procedure TForm1.DoOperation(Sender: TObject; const aUsername: string;
  aOperation: TsgcSFTPOperation; const aPath, aNewPath: string;
  var aAccept: Boolean);
begin
  if aOperation = sfoRemove then
    aAccept := False; // the client gets permission denied
end;

Ici, l'outil en ligne de commande sftp standard travaille avec la démo du serveur SFTP :

sftp contre TsgcSFTPServer
$ sftp -P 2291 -b batch.txt deploy@127.0.0.1
sftp> cd reports
sftp> put Q4-summary-2026.xlsx
sftp> ls -l
-rw-r--r--   1 deploy   deploy     150000 Nov 13 10:28 Q3-summary-2026.xlsx
-rw-r--r--   1 deploy   deploy     204800 Nov 13 10:28 Q4-summary-2026.xlsx
sftp> cd ..
sftp> get catalog-2026.pdf
sftp> mkdir archive-2026

Côté serveur, chacune de ces opérations est passée par OnSFTPOperation, où la démo la journalise :

La démo du serveur SFTP en écoute avec la bibliothèque crypto native, une clé d'hôte Ed25519 et des options pour un sous-dossier par utilisateur, la lecture seule, SCP et les suppressions refusées ; le journal montre la connexion par mot de passe, les listages, une ouverture en écriture, une ouverture en lecture et un nouveau dossier
La démo du serveur SFTP journalisant la session ci-dessus, une ligne par opération.

Détails de sécurité

Delphi, C++Builder et .NET

Les mêmes cinq composants sont disponibles sur toutes les plateformes prises en charge par sgcSSH :

Le code .NET se lit comme le code Delphi :

using esegece.sgcWebSockets;

using (var sftp = new TsgcSFTPClient())
{
    sftp.Host = "files.example.com";
    sftp.Authentication.Username = "partner";
    sftp.Authentication.Password = "secret";
    sftp.Connect();
    sftp.Put(@"C:\export\invoices.zip", "/upload/invoices.zip");
    foreach (var item in sftp.ListDirectory("/upload"))
        Console.WriteLine($"{item.FileName}  {item.Size}");
    sftp.Disconnect();
}

Cinq démos dans Demos\27.SSH montrent chaque composant à l'œuvre : 01.SSH_Client, 02.SFTP_Client, 03.SCP_Client, 04.SSH_Server et 05.SFTP_Server. Les captures d'écran de cet article en sont issues.

Éditions

sgcSSH est inclus dans sgcWebSockets Enterprise et sgcWebSockets All-Access. En .NET, les composants sont livrés dans le package sgcWebSockets enregistré, pas dans l'édition Community gratuite.

Si vous n'avez besoin que de SSH et SFTP, le pack sgcSSH autonome est complet : il regroupe le runtime sgcWebSockets Core avec la cryptographie native sur laquelle s'appuie l'échange de clés, le module complémentaire sgcCustomIndy sur lequel reposent les composants Delphi est toujours inclus dans la commande, et chaque licence est livrée avec le code source complet.

Bon à savoir. Vérifiez ce que votre édition de sgcWebSockets couvre déjà avant d'acheter. Si vous possédez Enterprise ou All-Access, vous disposez déjà des cinq composants.

SSH au cœur de votre application, prêt pour la suite

Téléchargez l'essai, lancez la démo du serveur SSH et connectez-vous-y avec n'importe quel client SSH. Déposez ensuite un TsgcSFTPClient sur votre propre fiche.

Des questions ou des remarques ? Contactez-nous, vous recevrez une réponse de ceux qui ont écrit le code.