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
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.
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.
- El cliente lo ofrece primero mientras
PostQuantumKexsea True, que es el valor por defecto. - El servidor lo ofrece primero a todos los clientes que se conectan.
- Nada que configurar. Cuando el otro lado no lo admite, el intercambio recurre a curve25519, ECDH y Diffie-Hellman group14 y group16.
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 -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):
sshcNativeusa las unidades sgcCrypto en Object Pascal puro. No hay ninguna DLL de OpenSSL que distribuir, y se prefieren los cifrados AES-GCM por ser el cifrado nativo más rápido. Es el valor por defecto siempre que la criptografía nativa esté disponible en tu licencia.sshcOpenSSLusa las DLL de OpenSSL 1.1.1 o 3.x, como los demás componentes TLS de sgcWebSockets.
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.
Executeejecuta un comando y devuelve su salida en una sola llamada, con un tiempo de espera.OpenChannel,RequestPTYandRequestShellabren un terminal interactivo.SendChannelDataescribe en él,OnSSHChannelDatadevuelve lo que imprime el servidor, ySendWindowChangeySendSignalcubren el resto del protocolo de terminal.OpenDirectTCPIPredirige una conexión local a través del servidor, por ejemplo para llegar a una base de datos detrás de un host bastión, yRequestForwardingpide al servidor que te redirija un puerto remoto.Rekeyrenueva las claves de sesión de una conexión de larga duración.
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.
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.
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:
- Una jaula por usuario. Los clientes no pueden salir de
RootFolder, yOnSFTPUserRootda a cada usuario una carpeta propia. - Modo de solo lectura.
ReadOnlyrechaza subidas, borrados y cambios de nombre. - Cada operación bajo tu control.
OnSFTPOperationse dispara en cada apertura, borrado, cambio de nombre, cambio de carpeta, cambio de atributos y listado. PonaAccepta False y el cliente recibe un error de permiso denegado. - También sirve SCP. Con
SCPactivado, las transferencias scp se sirven desde la misma carpeta raíz. - Memoria constante. El control de flujo mantiene constante la memoria de una descarga grande, sea cual sea el tamaño del archivo.
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 -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:
Detalles de seguridad
- El intercambio de claves estricto cierra el ataque de truncamiento de prefijo conocido como Terrapin.
- server-sig-algs (RFC 8308) permite que las claves de usuario RSA firmen con rsa-sha2-512 o rsa-sha2-256 en lugar de SHA-1.
- Cifrados: AES-GCM y AES-CTR. MAC: HMAC-SHA2-256 y HMAC-SHA2-512, mientras que los cifrados GCM incluyen su propia autenticación.
- Claves: Ed25519, ECDSA y RSA para claves de host y de usuario, cargadas desde archivos PEM y PKCS#8. Las claves privadas cifradas se abren con una frase de contraseña.
- Tú eliges los algoritmos. Las listas del cliente están en la propiedad
Algorithms. El cliente Delphi aún ofrece diffie-hellman-group14-sha1 y ssh-rsa para servidores antiguos, y puedes quitarlos para rechazar SHA-1 por completo.
Delphi, C++Builder y .NET
Los mismos cinco componentes están disponibles en todas las plataformas que admite sgcSSH:
- Delphi 7 a 13, para VCL, FireMonkey, aplicaciones de consola y servicios, en Windows Win32, Windows Win64 y Linux64.
- C++Builder, con los mismos componentes y eventos.
- .NET 8, .NET 9, .NET 10 y .NET Standard 2.0, en código totalmente administrado, en el espacio de nombres
esegece.sgcWebSockets.
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.
- Página del producto sgcSSH
- Matriz de características de sgcSSH
- Descargar la prueba gratuita
- Precios de sgcSSH
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.
