Composant Delphi client SFTP sgcIndy

26 mars 2026 · Composants

Le transfert de fichiers sécurisé reste un pilier de l'intégration en entreprise. Que tu échanges des données avec des partenaires bancaires, synchronises des fichiers avec des serveurs distants ou automatises des pipelines de déploiement, SFTP (SSH File Transfer Protocol) est le standard du secteur pour transférer des fichiers en toute sécurité sur des réseaux non fiables.

Le package sgcIndy inclut TIdSFTPClient — un composant client SFTP Delphi natif qui fonctionne sur SSH sans nécessiter d'outils en ligne de commande externes ni d'exécutables tiers. Il prend en charge l'upload et le téléchargement de fichiers, la gestion des répertoires, les liens symboliques, les attributs de fichiers, le suivi de progression et les algorithmes cryptographiques modernes — le tout via une API propre et événementielle.

Cet article couvre l'ensemble des fonctionnalités et fournit du code Delphi prêt à l'emploi pour les opérations SFTP les plus courantes.

Fonctionnalités clés

Transfert de fichiers Téléverse et télécharge des fichiers avec des tailles de buffer configurables et des événements de progression en temps réel. Transfert à partir de chemins de fichiers ou directement depuis des objets TStream.	Opérations sur les répertoires Liste les répertoires avec toutes les métadonnées, crée et supprime des répertoires, et résout les chemins, y compris les liens symboliques.	Cryptographie moderne Curve25519, ECDH, AES-GCM, clés Ed25519 et HMAC-SHA2. Négociation d'algorithmes configurable pour les exigences de conformité.
Plusieurs méthodes d'authentification Authentification par mot de passe, par clé publique (RSA, ECDSA, Ed25519) et keyboard-interactive. Vérification de la clé hôte avec callbacks d'empreinte.	Attributs et permissions de fichiers Lis et modifie les permissions, le propriétaire, les horodatages et les tailles des fichiers. Prise en charge complète des bits de mode Unix et des liens symboliques.	Progression et événements Suis la progression du transfert avec les octets transférés et la taille totale. Transferts annulables. Événements d'erreur, de connexion et de déconnexion.

Démarrage rapide — se connecter et télécharger un fichier

Un exemple minimal qui se connecte à un serveur distant, télécharge un fichier et se déconnecte.

var
  oSFTP: TIdSFTPClient;
begin
  oSFTP := TIdSFTPClient.Create(nil);
  Try
    oSFTP.Host := 'sftp.example.com';
    oSFTP.Port := 22;
    oSFTP.Authentication.Username := 'deploy';
    oSFTP.Authentication.Password := 'secret';
    oSFTP.Connect;
    // Télécharger un fichier
    oSFTP.Get('/data/report.csv', 'C:\local\report.csv');
    oSFTP.Disconnect;
  Finally
    oSFTP.Free;
  End;
end;

Authentification

Le composant prend en charge trois méthodes d'authentification. Toutes les trois sont activées par défaut — le client et le serveur négocient automatiquement la méthode la plus appropriée.

Authentification par mot de passe

oSFTP.Authentication.Username := 'admin';
oSFTP.Authentication.Password := 'secret';

Authentification par clé publique

oSFTP.Authentication.Username := 'deploy';
oSFTP.Authentication.PrivateKeyFile := 'C:\keys\id_rsa';
oSFTP.Authentication.PublicKeyFile := 'C:\keys\id_rsa.pub';
oSFTP.Authentication.Passphrase := 'keypassphrase';

Vérification de la clé hôte

Vérifie l'identité du serveur en inspectant l'empreinte de la clé hôte dans l'événement OnSSHHostKey.

oSFTP.OnSSHHostKey := OnHostKey;
procedure TForm1.OnHostKey(Sender: TObject;
  const aHostKeyType, aFingerprint: string;
  var aAction: TIdSSHHostKeyVerification);
begin
  // Vérifie l'empreinte par rapport aux hôtes connus
  if aFingerprint = 'SHA256:xyzABC123...' then
    aAction := sshHostKeyAccept
  else
    aAction := sshHostKeyReject;
end;

Opérations sur les fichiers

Upload et téléchargement

// Téléverse un fichier
oSFTP.Put('C:\local\data.zip', '/uploads/data.zip');
// Télécharge un fichier
oSFTP.Get('/reports/monthly.pdf', 'C:\local\monthly.pdf');
// Téléverse depuis un flux
oSFTP.Put(oMemoryStream, '/uploads/stream-data.bin');
// Télécharge vers un flux
oSFTP.Get('/data/export.csv', oFileStream);

Méthodes de commodité pour les chaînes

// Lit un fichier distant dans une chaîne
vContent := oSFTP.GetFileAsString('/config/settings.json');
// Écrit une chaîne dans un fichier distant
oSFTP.PutFileFromString('{"key":"value"}', '/config/settings.json');

Suppression, renommage et liens symboliques

// Supprime un fichier distant
oSFTP.Delete('/tmp/old-file.log');
// Renomme / déplace un fichier
oSFTP.Rename('/data/temp.csv', '/data/final.csv');
// Crée un lien symbolique
oSFTP.Symlink('/data/final.csv', '/data/latest.csv');

Opérations sur les répertoires

// Liste le contenu d'un répertoire avec toutes les métadonnées
var
  oItems: TIdSFTPDirectoryItems;
  i: Integer;
begin
  oItems := oSFTP.ListDirectory('/data');
  for i := 0 to Length(oItems) - 1 do
    WriteLn(oItems[i].Filename + ' - ' +
      IntToStr(oItems[i].Attrs.Size) + ' bytes');
end;
// Crée et supprime des répertoires
oSFTP.MakeDirectory('/data/archive/2026');
oSFTP.RemoveDirectory('/data/temp');
// Obtient le répertoire de travail courant
vPath := oSFTP.GetCurrentDirectory;
// Résout un chemin (suit les symlinks, résout . et ..)
vRealPath := oSFTP.RealPath('../data/../data/./file.txt');

Attributs et informations sur les fichiers

// Vérifie l'existence
if oSFTP.FileExists('/data/report.csv') then
  WriteLn('Fichier trouvé');
if oSFTP.DirectoryExists('/data/archive') then
  WriteLn('Le répertoire existe');
// Obtient la taille du fichier
vSize := oSFTP.FileSize('/data/report.csv');
// Obtient tous les attributs (taille, permissions, horodatages, UID/GID)
var
  oAttrs: TIdSFTPFileAttributes;
begin
  oAttrs := oSFTP.Stat('/data/report.csv');
  WriteLn('Taille : ' + IntToStr(oAttrs.Size));
  WriteLn('Permissions : ' + IntToStr(oAttrs.Permissions));
end;

Progression et annulation des transferts

L'événement OnSFTPProgress est déclenché pendant chaque transfert de fichier, ce qui fournit un suivi en temps réel et la possibilité d'annuler en cours de transfert.

oSFTP.OnSFTPProgress := OnProgress;
procedure TForm1.OnProgress(Sender: TObject;
  const aFilename: string;
  aTransferred, aTotal: Int64;
  var Cancel: Boolean);
begin
  ProgressBar1.Max := aTotal;
  ProgressBar1.Position := aTransferred;
  Label1.Caption := Format('%s: %d / %d bytes',
    [aFilename, aTransferred, aTotal]);
  // Mets Cancel := True pour annuler le transfert
  Cancel := FUserCancelled;
end;

Configuration des algorithmes cryptographiques

Le composant prend en charge les standards cryptographiques modernes. Les valeurs par défaut sont sécurisées, mais tu peux personnaliser la négociation d'algorithmes pour des exigences de conformité ou d'interopérabilité.

Catégorie	Algorithmes pris en charge
Échange de clés	Curve25519, ECDH (P-256, P-384, P-521), DH Group14/16
Clés hôte	Ed25519, ECDSA (P-256, P-384, P-521), RSA (SHA2-256, SHA2-512)
Chiffrements	AES-256/192/128-CTR, AES-256/128-GCM
MAC	HMAC-SHA2-256, HMAC-SHA2-512, HMAC-SHA1

// Restreint aux algorithmes les plus forts uniquement
oSFTP.Algorithms.Ciphers := 'aes256-gcm@openssh.com'
		,aes256-ctr';
oSFTP.Algorithms.KexAlgorithms := 'curve25519-sha256';
oSFTP.Algorithms.MACs := 'hmac-sha2-256,hmac-sha2-512';

Exemple complet

Un exemple prêt pour la production qui se connecte avec authentification par clé publique, liste un répertoire, télécharge un fichier avec suivi de progression et gère les erreurs.

uses
  IdSFTPClient, IdSSHClasses;
var
  oSFTP: TIdSFTPClient;
  oItems: TIdSFTPDirectoryItems;
  i: Integer;
begin
  oSFTP := TIdSFTPClient.Create(nil);
  Try
    // Connexion
    oSFTP.Host := 'sftp.example.com';
    oSFTP.Port := 22;
    // Authentification par clé publique
    oSFTP.Authentication.Username := 'deploy';
    oSFTP.Authentication.PrivateKeyFile := 'C:\keys\id_ed25519';
    // Événements
    oSFTP.OnSFTPProgress := OnProgress;
    oSFTP.OnSFTPError := OnError;
    oSFTP.OnSSHHostKey := OnHostKey;
    // Connecter
    oSFTP.Connect;
    // Lister le répertoire distant
    oItems := oSFTP.ListDirectory('/data');
    for i := 0 to Length(oItems) - 1 do
      WriteLn(oItems[i].Filename);
    // Télécharger un fichier avec progression
    oSFTP.Get('/data/backup.tar.gz', 'C:\backups\backup.tar.gz');
    // Se déconnecter
    oSFTP.Disconnect;
  Finally
    oSFTP.Free;
  End;
end;

Référence des méthodes

Méthode	Description
`Get`	Télécharge un fichier vers un chemin local ou un TStream
`Put`	Téléverse un fichier depuis un chemin local ou un TStream
`Delete`	Supprime un fichier distant
`Rename`	Renomme ou déplace un fichier distant
`ListDirectory`	Liste le contenu d'un répertoire avec les métadonnées
`MakeDirectory`	Crée un répertoire distant
`Stat / LStat`	Obtient les attributs d'un fichier (avec/sans résolution des liens symboliques)
`FileExists / DirectoryExists`	Vérifie si un fichier ou répertoire existe
`Symlink / ReadLink`	Crée ou lit des liens symboliques
`GetFileAsString / PutFileFromString`	Méthodes de commodité basées sur des chaînes