sgcSSH: SSH, SFTP e SCP post-quantum per Delphi e .NET

· Componenti
sgcSSH: SSH, SFTP e SCP post-quantum per Delphi e .NET
Nuovo prodotto · sgcSSH

SSH, SFTP e SCP per Delphi e .NET.
Post-quantum per impostazione predefinita.

Tre client e due server che portano SSH dentro le tue applicazioni. Lo scambio di chiavi ibrido mlkem768x25519-sha256 viene proposto per primo da entrambe le parti, e la crittografia gira come codice nativo.

  • ML-KEM-768 + X25519
  • SFTP v3
  • SCP
  • Ed25519
  • AES-GCM
Le demo di sgcSSH affiancate: il client SSH che esegue un comando e una shell interattiva, il client SFTP che esplora una cartella remota, il server SFTP che pubblica una cartella radice e un terminale che mostra lo scambio di chiavi mlkem768x25519-sha256
5componenti
16richieste SFTP in volo
~1 sogni 100 MB su una LAN
0DLL OpenSSL con la crittografia nativa

SSH è il modo standard per gestire i server e scambiare file in modo sicuro. sgcSSH lo porta nelle tue applicazioni Delphi, C++Builder e .NET sotto forma di normali componenti, sia lato client sia lato server.

Con sgcSSH puoi eseguire un comando su un server Linux e ottenerne l'output come stringa, aprire una shell interattiva, inoltrare una porta, caricare una cartella tramite SFTP o SCP, oppure trasformare la tua applicazione in un server SSH e SFTP con una cartella privata per ogni utente. Client e server propongono per primo lo scambio di chiavi ibrido post-quantum, lo stesso che le ultime versioni di SSH usano per impostazione predefinita.

sgcSSH in sintesi: i client, i server e lo scambio di chiavi post-quantum. Anche su YouTube.

Tre client, due server

Ognuno è un componente non visuale nella pagina SGC SSH della palette. Lo trascini su un form o lo crei nel codice, imposti host e credenziali, colleghi gli eventi, poi ti connetti o avvii l'ascolto. Le classi .NET hanno gli stessi nomi.

Client SSHTsgcSSHClientComandi, shell interattive con pty, inoltro di porte e rekey.
Client SFTPTsgcSFTPClientTrasferimenti di file SFTP v3 con 16 richieste in volo.
Client SCPTsgcSCPClientFile e intere cartelle con scp, conservando le date dei file.
Server SSHTsgcSSHServerAccesso con password e chiave pubblica, exec, shell e sottosistemi.
Server SFTPTsgcSFTPServerSFTP v3 e SCP da una cartella radice, con una jail per utente.

Scambio di chiavi post-quantum, attivo per impostazione predefinita

Il traffico cifrato oggi può essere attaccato domani. Un attaccante registra ora la sessione cifrata e la decifra più avanti, quando esisterà un computer quantistico abbastanza potente. Si chiama harvest now, decrypt later e conta per tutto ciò che deve restare riservato per anni: credenziali, contratti, file dei clienti.

sgcSSH risponde con lo scambio di chiavi ibrido mlkem768x25519-sha256. Combina ML-KEM-768 (FIPS 203), un algoritmo post-quantum, con il classico X25519, così le chiavi di sessione restano segrete finché almeno uno dei due non viene violato. È l'impostazione predefinita delle ultime versioni di SSH.

Ecco un normale client SSH da riga di comando che si connette alla demo del server SSH. Lo scambio ibrido viene negoziato con le impostazioni predefinite da entrambe le parti:

ssh -v verso 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

Crittografia nativa, nessuna DLL da distribuire

In Delphi, la proprietà CryptoLibrary sceglie dove vengono calcolati gli algoritmi classici (ECDH, Diffie-Hellman, AES, HMAC e le firme delle chiavi host):

Lo scambio ibrido ML-KEM-768 e X25519 è codice nativo della libreria con entrambe le opzioni. I componenti .NET sono interamente codice gestito, senza alcun OpenSSL, e da .NET 8 in poi AES-GCM è accelerato via hardware.

Caricare un file via SFTP con lo scambio post-quantum e la crittografia nativa richiede poche righe:

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;

Il client SSH: comandi, shell e tunnel

TsgcSSHClient accede con una password o una chiave privata, e OnSSHHostKey ti fornisce il tipo di chiave host e la sua impronta, così puoi confrontarla con i tuoi host noti e rifiutare una chiave sconosciuta o cambiata.

La demo del client SSH: connesso con lo scambio di chiavi post-quantum e la libreria crittografica nativa, l'output di un comando remoto, una shell interattiva che elenca una cartella e la chiave host Ed25519 accettata nel log
La demo del client SSH: un comando remoto, una shell interattiva e il controllo della chiave host.

Eseguire un comando di manutenzione con una chiave privata e il controllo della chiave host:

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 e SCP: trasferimenti di file veloci

TsgcSFTPClient parla SFTP v3 sulla stessa connessione SSH, con un metodo per ogni compito: RealPath risolve la cartella home, ListDirectory restituisce nomi, dimensioni e date, Put e Get caricano e scaricano un file, e Rename, Delete, MakeDirectory e RemoveDirectory coprono il resto di un file manager. OnSFTPProgress riporta i byte trasferiti per una barra di avanzamento.

I trasferimenti sono veloci perché il client non attende ogni blocco. Mantiene 16 richieste in volo, quindi un file da 100 MB richiede circa un secondo su una rete locale.

La demo del client SFTP: una cartella remota elencata con nomi, dimensioni, date e indicatori di cartella, e la barra di avanzamento di un download di grandi dimensioni
La demo del client SFTP mentre esplora una cartella remota e scarica un file di grandi dimensioni.

TsgcSCPClient copia i file tramite SSH su qualsiasi server che consenta il comando scp, senza un servizio di trasferimento file separato. Upload e Download copiano un singolo file, UploadFolder e DownloadFolder copiano un intero albero di cartelle, e PreserveTimes conserva sull'altro lato le date di modifica e di accesso.

La demo del client SCP con i pulsanti per caricare e scaricare un file o un'intera cartella, l'opzione per conservare le date dei file e l'avanzamento di un trasferimento
La demo del client SCP: file singoli o intere cartelle, con o senza le date dei file.

Il tuo server SSH e SFTP

TsgcSSHServer resta in ascolto sulla porta che scegli e dimostra la propria identità con chiavi host Ed25519, ECDSA o RSA caricate da HostKeyFiles. GenerateHostKeyEd25519 ne crea una per te. OnSSHAuthPassword e OnSSHAuthPublicKey decidono chi entra, il secondo con il tipo di chiave e la sua impronta SHA256. OnSSHExec risponde ai comandi remoti e OnSSHShell gestisce una sessione interattiva. Qualsiasi client SSH standard si connette, compresi gli strumenti da riga di comando ssh, sftp e scp.

Collega un TsgcSFTPServer e lo stesso server diventa un file server:

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;

Ecco lo strumento da riga di comando sftp standard che lavora con la demo del server SFTP:

sftp verso 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

Lato server, ognuna di queste operazioni è passata da OnSFTPOperation, dove la demo la registra nel log:

La demo del server SFTP in ascolto con la libreria crittografica nativa, una chiave host Ed25519 e le opzioni per una sottocartella per utente, sola lettura, SCP e cancellazioni negate; il log mostra l'accesso con password, gli elenchi, un'apertura in scrittura, un'apertura in lettura e una nuova cartella
La demo del server SFTP che registra la sessione qui sopra, una riga per operazione.

Dettagli di sicurezza

Delphi, C++Builder e .NET

Gli stessi cinque componenti sono disponibili su ogni piattaforma supportata da sgcSSH:

Il codice .NET si legge come quello 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();
}

Cinque demo in Demos\27.SSH mostrano ogni componente al lavoro: 01.SSH_Client, 02.SFTP_Client, 03.SCP_Client, 04.SSH_Server e 05.SFTP_Server. Le schermate di questo articolo provengono da queste demo.

Edizioni

sgcSSH è incluso in sgcWebSockets Enterprise e sgcWebSockets All-Access. In .NET i componenti sono distribuiti nel pacchetto sgcWebSockets registrato, non nell'edizione Community gratuita.

Se ti servono solo SSH e SFTP, il pacchetto sgcSSH standalone è autonomo: include il runtime sgcWebSockets Core insieme alla crittografia nativa su cui gira lo scambio di chiavi, l'add-on sgcCustomIndy su cui si basano i componenti Delphi è sempre incluso nell'ordine, e ogni licenza comprende il codice sorgente completo.

Da sapere. Controlla che cosa copre già la tua edizione di sgcWebSockets prima di acquistare. Se possiedi Enterprise o All-Access, hai già tutti e cinque i componenti.

SSH dentro la tua applicazione, pronto per ciò che verrà

Scarica la prova, avvia la demo del server SSH e connettiti con qualsiasi client SSH. Poi trascina un TsgcSFTPClient sul tuo form.

Domande o commenti? Contattaci, riceverai una risposta da chi ha scritto il codice.