sgcSSH: SSH, SFTP y SCP poscuánticos para Delphi y .NET

· Componentes
sgcSSH: SSH, SFTP y SCP poscuánticos para Delphi y .NET | Blog de eSeGeCe
Nuevo producto · sgcSSH

SSH, SFTP y SCP para Delphi y .NET.
Poscuántico por defecto.

Tres clientes y dos servidores que llevan SSH al interior de tus propias aplicaciones. El intercambio de claves híbrido mlkem768x25519-sha256 se ofrece en primer lugar en ambos lados, y la criptografía se ejecuta como código nativo.

  • ML-KEM-768 + X25519
  • SFTP v3
  • SCP
  • Ed25519
  • AES-GCM
Las demos de sgcSSH una junto a otra: el cliente SSH ejecutando un comando y una shell interactiva, el cliente SFTP explorando una carpeta remota, el servidor SFTP sirviendo una carpeta raíz y un terminal que muestra el intercambio de claves mlkem768x25519-sha256
5componentes
16peticiones SFTP simultáneas
~1 spor cada 100 MB en una LAN
0DLL de OpenSSL con cripto nativa

SSH es la forma estándar de administrar servidores y de intercambiar archivos de manera segura. sgcSSH lo incorpora a tus aplicaciones Delphi, C++Builder y .NET como componentes normales, tanto en el lado del cliente como en el del servidor.

Con sgcSSH ejecutas un comando en un servidor Linux y obtienes su salida como una cadena, abres una shell interactiva, rediriges un puerto, subes una carpeta por SFTP o SCP, o conviertes tu propia aplicación en un servidor SSH y SFTP con una carpeta privada para cada usuario. Cliente y servidor ofrecen en primer lugar el intercambio de claves híbrido poscuántico, el mismo que usan por defecto las últimas versiones de SSH.

sgcSSH de un vistazo: los clientes, los servidores y el intercambio de claves poscuántico. También en YouTube.

Tres clientes, dos servidores

Cada uno es un componente no visual de la página de paleta SGC SSH. Lo sueltas en un formulario o lo creas por código, indicas el host y las credenciales, conectas los eventos y después te conectas o empiezas a escuchar. Las clases de .NET tienen los mismos nombres.

Cliente SSHTsgcSSHClientComandos, shells interactivas con pty, redirección de puertos y renovación de claves.
Cliente SFTPTsgcSFTPClientTransferencias de archivos SFTP v3 con 16 peticiones simultáneas.
Cliente SCPTsgcSCPClientArchivos y carpetas completas con scp, conservando las fechas de los archivos.
Servidor SSHTsgcSSHServerInicio de sesión con contraseña y clave pública, exec, shell y subsistemas.
Servidor SFTPTsgcSFTPServerSFTP v3 y SCP desde una carpeta raíz, con una jaula por usuario.

Intercambio de claves poscuántico, activado por defecto

El tráfico cifrado hoy puede ser atacado mañana. Un atacante graba ahora la sesión cifrada y la descifra más adelante, cuando exista un ordenador cuántico lo bastante potente. Es lo que se conoce como harvest now, decrypt later (recolectar ahora, descifrar después), y importa para todo lo que debe seguir siendo privado durante años: credenciales, contratos, archivos de clientes.

sgcSSH lo resuelve con el intercambio de claves híbrido mlkem768x25519-sha256. Combina ML-KEM-768 (FIPS 203), un algoritmo poscuántico, con el clásico X25519, de modo que las claves de sesión siguen siendo secretas mientras uno de los dos no sea vulnerado. Es el valor por defecto de las últimas versiones de SSH.

Este es un cliente ssh estándar de línea de comandos conectándose a la demo del servidor SSH. El intercambio híbrido se negocia con la configuración por defecto en ambos lados:

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

Criptografía nativa, sin DLL que distribuir

En Delphi, la propiedad CryptoLibrary elige dónde se calculan los algoritmos clásicos (ECDH, Diffie-Hellman, AES, HMAC y las firmas de las claves de host):

El intercambio híbrido ML-KEM-768 y X25519 es código nativo de la biblioteca con ambas opciones. Los componentes .NET son código totalmente administrado, sin OpenSSL en absoluto, y en .NET 8 y posteriores AES-GCM está acelerado por hardware.

Subir un archivo por SFTP con el intercambio poscuántico y la criptografía nativa requiere unas pocas líneas:

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;

El cliente SSH: comandos, shells y túneles

TsgcSSHClient inicia sesión con una contraseña o una clave privada, y OnSSHHostKey te entrega el tipo de clave de host y su huella para que la compares con tus hosts conocidos y rechaces una clave desconocida o modificada.

La demo del cliente SSH: conectado con el intercambio de claves poscuántico y la biblioteca criptográfica nativa, la salida de un comando remoto, una shell interactiva listando una carpeta y la clave de host Ed25519 aceptada en el registro
La demo del cliente SSH: un comando remoto, una shell interactiva y la comprobación de la clave de host.

Ejecución de un comando de mantenimiento con una clave privada y comprobación de la clave de 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 y SCP: transferencias de archivos rápidas

TsgcSFTPClient habla SFTP v3 sobre la misma conexión SSH, con un método para cada tarea: RealPath resuelve la carpeta personal, ListDirectory devuelve nombres, tamaños y fechas, Put y Get suben y descargan un archivo, y Rename, Delete, MakeDirectory y RemoveDirectory cubren el resto de un gestor de archivos. OnSFTPProgress informa de los bytes transferidos para una barra de progreso.

Las transferencias son rápidas porque el cliente no espera a cada bloque. Mantiene 16 peticiones simultáneas, así que un archivo de 100 MB tarda alrededor de un segundo en una red local.

La demo del cliente SFTP: una carpeta remota listada con nombres, tamaños, fechas e indicadores de carpeta, y la barra de progreso de una descarga grande
La demo del cliente SFTP explorando una carpeta remota mientras se descarga un archivo grande.

TsgcSCPClient copia archivos por SSH a cualquier servidor que admita el comando scp, sin un servicio de transferencia de archivos aparte. Upload y Download copian un archivo, UploadFolder y DownloadFolder copian un árbol de carpetas completo, y PreserveTimes conserva las fechas de modificación y de acceso en el otro lado.

La demo del cliente SCP con botones para subir y descargar un archivo o una carpeta completa, la opción de conservar las fechas de los archivos y el progreso de una transferencia
La demo del cliente SCP: archivos sueltos o carpetas completas, con o sin las fechas de los archivos.

Tu propio servidor SSH y SFTP

TsgcSSHServer escucha en el puerto que elijas y demuestra su identidad con claves de host Ed25519, ECDSA o RSA cargadas desde HostKeyFiles. GenerateHostKeyEd25519 crea una por ti. OnSSHAuthPassword y OnSSHAuthPublicKey deciden quién entra, el segundo con el tipo de clave y su huella SHA256. OnSSHExec responde a los comandos remotos y OnSSHShell atiende una sesión interactiva. Cualquier cliente SSH estándar puede conectarse, incluidas las herramientas de línea de comandos ssh, sftp y scp.

Enlaza un TsgcSFTPServer y el mismo servidor se convierte en un servidor de archivos:

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;

Aquí la herramienta estándar de línea de comandos sftp trabaja con la demo del servidor SFTP:

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

En el lado del servidor, cada una de esas operaciones pasó por OnSFTPOperation, donde la demo la registra:

La demo del servidor SFTP escuchando con la biblioteca criptográfica nativa, una clave de host Ed25519 y opciones de una subcarpeta por usuario, solo lectura, SCP y borrados denegados; el registro muestra el inicio de sesión con contraseña, los listados, una apertura para escritura, una apertura para lectura y una carpeta nueva
La demo del servidor SFTP registrando la sesión anterior, una línea por operación.

Detalles de seguridad

Delphi, C++Builder y .NET

Los mismos cinco componentes están disponibles en todas las plataformas que admite sgcSSH:

El código .NET se lee igual que el código 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();
}

Cinco demos en Demos\27.SSH muestran cada componente en funcionamiento: 01.SSH_Client, 02.SFTP_Client, 03.SCP_Client, 04.SSH_Server y 05.SFTP_Server. Las capturas de pantalla de este artículo proceden de ellas.

Ediciones

sgcSSH está incluido en sgcWebSockets Enterprise y en sgcWebSockets All-Access. En .NET los componentes se entregan en el paquete registrado de sgcWebSockets, no en la edición Community gratuita.

Si solo necesitas SSH y SFTP, el paquete independiente sgcSSH es autocontenido: incluye el runtime de sgcWebSockets Core junto con la criptografía nativa sobre la que se ejecuta el intercambio de claves, el complemento sgcCustomIndy en el que se basan los componentes Delphi se incluye siempre en el pedido, y todas las licencias incluyen el código fuente completo.

Conviene saber. Comprueba qué cubre ya tu edición de sgcWebSockets antes de comprar. Si tienes Enterprise o All-Access, ya dispones de los cinco componentes.

SSH dentro de tu aplicación, preparado para lo que viene

Descarga la prueba, ejecuta la demo del servidor SSH y conéctate a ella con cualquier cliente SSH. Después suelta un TsgcSFTPClient en tu propio formulario.

¿Preguntas o comentarios? Ponte en contacto, te responderán las personas que escribieron el código.