Page d'accueil>Lié à la programmation>C/C++
Télécharger

Fondage de socket sécurisé

Secure Socket Entonnage (SSF) est un outil réseau et une boîte à outils.

Il fournit des moyens simples et efficaces de transmettre les données de plusieurs sockets (TCP ou UDP) via un seul tunnel TLS sécurisé vers un ordinateur distant.

SSF est transformatrice (Windows, Linux, OSX) et est livrée sous forme de fonctionnalités autonomes.

Caractéristiques:

  • Transfert de port TCP local et distant
  • Transfert de port UDP local et distant
  • Serveur de chaussettes local et distant
  • Shell local et distant à travers des sockets
  • Copie de dossier
  • Protocole de relais natif
  • Connexion TLS avec les plans de chiffrement les plus forts

Télécharger les binaires prédéfinis

Documentation

Construire sur les fenêtres

Construire sur Unix / Linux

SSF de compilation croisée (par exemple, Raspberry Pi)

Comment utiliser

Ligne de commande

Client

Utilisation: ssf[.exe] [options] server_address

Options:

  • -v verbose_level : Verbosité: critique | Erreur | Avertissement | info | débogage | trace (par défaut: info)

  • -q : mode silencieux. Ne pas imprimer de journaux

  • -p port : Port distant (par défaut: 8011)

  • -c config_file_path : spécifiez le fichier de configuration. Si ce n'est pas défini, «config.json» est chargé à partir du répertoire de travail actuel

  • -m attempts : MAX Tentatives de connexion infructueuse avant de s'arrêter (par défaut: 1)

  • -t delay : il est temps d'attendre avant d'essayer de se reconnecter en quelques secondes (par défaut: 60)

  • -n : N'essayez pas de reconnecter le client si la connexion est interrompue

  • -g : Autoriser les ports de passerelle. Permettez au client de lier les prises locales pour un service à une adresse spécifique plutôt qu'à "localhost"

  • -S : Afficher l'état des microservices (marche / arrêt)

Options de services:

  • -D [[bind_address]:]port : exécutez un proxy de chaussettes sur le serveur accessible sur [[bind_address]:]port du côté local

  • -F [[bind_address]:]port : exécutez un proxy de chaussettes sur l'hôte local accessible depuis le serveur sur [[bind_address]:]port

  • -X [[bind_address]:]port : Faire des E / S du shell de serveur vers le port spécifié du côté local. Chaque connexion crée un nouveau processus de shell

  • -Y [[bind_address]:]port : transfert des E / S local à coque locale au port spécifié sur le serveur

  • -L [[bind_address]:]port:host:hostport : Faire des connexions TCP vers [[bind_address]:]port sur l'hôte local à host:hostport sur le serveur

  • -R [[bind_address]:]port:host:hostport : Faire des connexions TCP à [[bind_address]:]port sur le serveur à host:hostport du côté local

  • -U [[bind_address]:]port:host:hostport : transfaire le trafic UDP local sur [[bind_address]:]port à host:hostport sur le serveur

  • -V [[bind_address]:]port:host:hostport : transfert UDP sur [[bind_address]:]port sur le serveur à host:hostport du côté local

Serveur

Utilisation: ssfd[.exe] [options]

Options:

  • -v verbose_level : Verbosité: critique | Erreur | Avertissement | info | débogage | trace (par défaut: info)

  • -q : mode silencieux. Ne pas imprimer de journaux

  • -c config_file_path : spécifiez le fichier de configuration. Si ce n'est pas défini, «config.json» est chargé à partir du répertoire de travail actuel

  • -p port : Port local (par défaut: 8011)

  • -R : le serveur ne relayera que des connexions

  • -l host : Définissez l'adresse de liaison du serveur

  • -g : Autoriser les ports de passerelle. Permettez au client de lier les prises locales pour un service à une adresse spécifique plutôt qu'à "localhost"

  • -S : Afficher l'état des microservices (marche / arrêt)

Copie

La fonction de copie doit être activée sur le fichier de configuration du client et du serveur: 

{
  "ssf" : {
    "services" : {
      "copy" : { "enable" : true }
    }
  }
}

Utilisation: ssfcp[.exe] [options] [host@]/absolute/path/file [[host@]/absolute/path/file]

Options:

  • -v verbose_level : Verbosité: critique | Erreur | Avertissement | info | débogage | trace (par défaut: info)

  • -q : mode silencieux. Ne pas imprimer de journaux

  • -c config_file_path : spécifiez le fichier de configuration. Si ce n'est pas défini, «config.json» est chargé à partir du répertoire de travail actuel

  • -p port : Port distant (par défaut: 8011)

  • -t : Utilisez STDIN comme entrée

  • --resume : tentez de reprendre le transfert de fichiers si le fichier de destination existe

  • --check-integrity : Vérifiez l'intégrité du fichier à la fin du transfert

  • -r : Copier les fichiers récursivement

  • --max-transfers arg : max transferts en parallèle (par défaut: 1)

Exemples

Client

Le client exécutera un proxy de chaussettes sur le port 9000 et transférera les demandes de connexion au serveur 192.168.0.1:8000 

 ssf -D 9000 -c config.json -p 8000 192.168.0.1

Serveur

Le serveur sera lié au port 8011 sur toutes les interfaces réseau 

 ssfd

Le serveur sera lié à 192.168.0.1:9000 

 ssfd -p 9000 -l 192.168.0.1

Copiez le fichier local sur le système de fichiers distant 

 ssfcp [-c config_file] [-p port] path/to/file host@absolute/path/directory_destination

 ssfcp [-c config_file] [-p port] path/to/file* host@absolute/path/directory_destination

 ssfcp [-c config_file] [-p port] -r path/to/dir host@absolute/path/directory_destination

Fichier de tuyaux de l'entrée standard au système de fichiers distant 

 data_in_stdin | ssfcp [-c config_file] [-p port] -t host@path/to/destination/file_destination

Copiez les fichiers distants vers le système de fichiers local: 

 ssfcp [-c config_file] [-p port] remote_host@path/to/file absolute/path/directory_destination

 ssfcp [-c config_file] [-p port] remote_host@path/to/file* absolute/path/directory_destination

 ssfcp [-c config_file] [-p port] -r remote_host@path/to/dir absolute/path/directory_destination

Fichier de configuration 

{
  "ssf" : {
    "arguments" : " " ,
    "circuit" : [],
    "http_proxy" : {
      "host" : " " ,
      "port" : " " ,
      "user_agent" : " " ,
      "credentials" : {
        "username" : " " ,
        "password" : " " ,
        "domain" : " " ,
        "reuse_ntlm" : true ,
        "reuse_nego" : true
      }
    },
    "socks_proxy" : {
      "version" : 5 ,
      "host" : " " ,
      "port" : " 1080 "
    },
    "tls" : {
      "ca_cert_path" : " ./certs/trusted/ca.crt " ,
      "cert_path" : " ./certs/certificate.crt " ,
      "key_path" : " ./certs/private.key " ,
      "key_password" : " " ,
      "dh_path" : " ./certs/dh4096.pem " ,
      "cipher_alg" : " DHE-RSA-AES256-GCM-SHA384 "
    },
    "services" : {
      "datagram_forwarder" : { "enable" : true },
      "datagram_listener" : {
        "enable" : true ,
        "gateway_ports" : false
      },
      "stream_forwarder" : { "enable" : true },
      "stream_listener" : {
        "enable" : true ,
        "gateway_ports" : false
      },
      "copy" : { "enable" : false },
      "shell" : {
        "enable" : false ,
        "path" : " /bin/bash|C: \ windows \ system32 \ cmd.exe " ,
        "args" : " "
      },
      "socks" : { "enable" : true }
    }
  }
}

Arguments

Clé de configuration Description
arguments Utilisez des arguments de configuration au lieu des arguments CLI donnés (sauf -c )

La clé arguments permet à l'utilisateur de personnaliser les arguments de ligne de commande dans le fichier de configuration. Cette fonctionnalité est un moyen pratique d'enregistrer différents profils de connexion client.

Compte tenu du fichier de configuration suivant conf.json : 

{
  "ssf" : {
    "arguments" : " 10.0.0.1 -p 443 -D 9000 -L 11000:localhost:12000 -v debug "
  }
}

SSF extrait les arguments donnés et les utilisera en remplacement des arguments initiaux (sauf -c ).

Par exemple, ssf -c conf.json sera équivalent à ssf 10.0.0.1 -p 443 -D 9000 -L 11000:localhost:12000 -v debug :

  • Connectez-vous à 10.0.0.1:443 ( 10.0.0.1 -p 443 )
  • Démarrer le service de chaussettes ( -D 9000 )
  • Démarrer le service de transfert de port TCP ( -L 11000:localhost:12000 )
  • Définir le niveau de verbosité pour déboguer ( -v debug )

Circuit

Clé de configuration Description
circuit Serveurs de chaîne de relais utilisés pour établir la connexion au serveur distant

Le circuit est un tableau JSON contenant les serveurs et les ports de rebond qui seront utilisés pour établir la connexion. Ils sont répertoriés comme suit: 

{
  "ssf" : {
    "circuit" : [
      { "host" : " SERVER1 " , "port" : " PORT1 " },
      { "host" : " SERVER2 " , "port" : " PORT2 " },
      { "host" : " SERVER3 " , "port" : " PORT3 " }
    ]
  }
}

Cette configuration créera la chaîne de connexion suivante: 

 CLIENT -> SERVER1:PORT1 -> SERVER2:PORT2 -> SERVER3:PORT3 -> TARGET

Procuration

SSF prend en charge la connexion à travers:

  • Proxy http en utilisant la méthode CONNECT HTTP
  • Proxy de chaussettes (V4 ou V5)
Proxy http
Clé de configuration Description
http_proxy.host Hôte de proxy http
http_proxy.port Port proxy http
http_proxy.user_agent Valeur d'en-tête d'utilisateur-agent dans la demande de connexion HTTP
http_proxy.credentials.Username Informations sur nom d'utilisateur proxy (toutes plates-formes: basique ou digest, Windows: NTLM et négocier si réutiliser = false)
http_proxy.credentials.password Informations sur le mot de passe proxy (toutes les plateformes: base ou digest, Windows: NTLM et négocier si réutiliser = false)
http_proxy.credentials.domain Domaine utilisateur (NTLM et négociez l'authentique uniquement sur Windows)
http_proxy.credentials.reuse_ntlm Réutiliser les informations d'identification de l'utilisateur de l'ordinateur actuel à s'authentifier avec Proxy NTLM Auth (SSO)
http_proxy.credentials.reuse_kerb Réutiliser les informations d'identification actuelles de l'utilisateur de l'ordinateur (billet Kerberos) pour s'authentifier avec Proxy Négocier Auth (SSO)

Schémas d'authentification pris en charge:

  • Basique
  • Digérer
  • NTLM (Windows uniquement)
  • Négocier avec Kerberos (réutiliser les informations d'identification de l'utilisateur de l'ordinateur)
Procuration de chaussettes
Clé de configuration Description
socks_proxy.version Version de chaussettes (4 ou 5)
socks_proxy.host Hôte de proxy de chaussettes
socks_proxy.port Port proxy de chaussettes

Aucun schéma d'authentification pris en charge.

TLS

Utilisation de fichiers externes
Clé de configuration Description
tls.ca_cert_path Filepath relatif ou absolu au fichier de certificat CA
tls.cert_path Filepath relatif ou absolu au fichier de certificat d'instance
tls.key_path Filepath relatif ou absolu au fichier de clé privée
tls.key_password Mot de passe clé
tls.dh_path Filepath relatif ou absolu au fichier Diffie-Hellman (serveur uniquement)
tls.cipher_alg algorithme de chiffre

Avec les options par défaut, les fichiers et dossiers suivants doivent être dans le répertoire de travail du client ou du serveur:

  • ./certs/dh4096.pem
  • ./certs/certificate.crt
  • ./certs/private.key
  • ./certs/trusted/ca.crt

Où:

  • DH4096.pem contient les paramètres Diffie-Hellman (générer des paramètres DH)
  • certificate.crt et private.key sont le certificat et la clé privée du serveur ou du client SSF (générer un certificat)
  • CA.CRT est la liste concaténée des certificats de confiance par le serveur ou le client SSF (générer CA)

Si vous voulez ces fichiers sur différents chemins, il est possible de les personnaliser grâce aux touches TLS Path: 

{
  "ssf" : {
    "tls" : {
      "ca_cert_path" : " ./certs/trusted/ca.crt " ,
      "cert_path" : " ./certs/certificate.crt " ,
      "key_path" : " ./certs/private.key " ,
      "key_password" : " " ,
      "dh_path" : " ./certs/dh4096.pem " ,
      "cipher_alg" : " DHE-RSA-AES256-GCM-SHA384 "
    }
  }
}
Utilisation du fichier de configuration uniquement
Clé de configuration Description
tls.ca_cert_buffer Contenu du fichier de certificat CA au format PEM (: AVERTISSEMENT: n entre les données et l'en-tête / pied de page PEM)
tls.cert_buffer Contenu du fichier de certificat d'instance au format PEM (: avertissement: n entre les données et l'en-tête / pied de page PEM)
tls.key_buffer Contenu de fichier de clé privée au format PEM (: AVERTISSEMENT: n entre les données et l'en-tête / pied de page PEM)
tls.key_password Mot de passe clé
tls.dh_buffer Diffie-Hellman Paramètres Fichier Contenu du fichier au format PEM (: AVERTISSEMENT: n entre les données et l'en-tête / pied de page PEM, le serveur uniquement)
tls.cipher_alg algorithme de chiffre

Vous pouvez intégrer directement les paramètres TLS dans le fichier de configuration en utilisant le tls.ca_cert_buffer , tls.cert_buffer , tls.key_buffer ET tls.dh_buffer . 

{
  "ssf" : {
    "tls" : {
      "ca_cert_buffer" : " -----BEGIN CERTIFICATE----- n ... n -----END CERTIFICATE----- " ,
      "cert_buffer" : " -----BEGIN CERTIFICATE----- n ... n -----END CERTIFICATE----- " ,
      "key_buffer" : " -----BEGIN RSA PRIVATE KEY----- n ... n -----END RSA PRIVATE KEY----- " ,
      "key_password" : " " ,
      "dh_buffer" : " -----BEGIN DH PARAMETERS----- n ... n -----END DH PARAMETERS----- " ,
      "cipher_alg" : " DHE-RSA-AES256-GCM-SHA384 "
    }
  }
}

Les certificats, les clés privées et les paramètres DH doivent être au format PEM. ️ n entre les données et l'en-tête / pied de page PEM sont obligatoires.

Microservices

Clé de configuration Description
services. *. Activer Activer / désactiver le microservice
services. *. Gateway_ports Activer / désactiver les ports de passerelle
services.shell.path Chemin binaire utilisé pour la création de coquilles
services.shell.args Arguments binaires utilisés pour la création de coquilles

Les fonctionnalités de SSF sont construites à l'aide de microservices (transfert TCP, chaussettes distantes, ...)

Il y a 7 microservices:

  • stream_forwarcher
  • stream_listener
  • datagram_forwarcher
  • datagram_listener
  • copie
  • chaussettes
  • coquille

Chaque fonctionnalité est la combinaison d'au moins un microservice côté client et un microservice côté serveur.

Ce tableau résume la façon dont chaque fonctionnalité est assemblée:

fonctionnalité SSF côté client microservice côté serveur de microservice
-L : transfert TCP stream_listener stream_forwarcher
-R : transfert TCP distant stream_forwarcher stream_listener
-U : transfert UDP datagram_listener datagram_forwarcher
-V : transfert UDP distant datagram_forwarcher datagram_listener
-D : chaussettes stream_listener chaussettes
-F : chaussettes distantes chaussettes stream_listener
-X : shell stream_listener coquille
-Y : coquille distante coquille stream_listener

Cette architecture facilite la création de fonctionnalités distantes: ils utilisent les mêmes microservices mais du côté opposé.

ssf et ssfd sont livrés avec des microservices pré-compatibles. Voici la configuration des microservices par défaut: 

{
  "ssf" : {
    "services" : {
      "datagram_forwarder" : { "enable" : true },
      "datagram_listener" : { "enable" : true },
      "stream_forwarder" : { "enable" : true },
      "stream_listener" : { "enable" : true },
      "socks" : { "enable" : true },
      "copy" : { "enable" : false },
      "shell" : { "enable" : false }
    }
  }
}

Pour activer ou désactiver un microservice, définissez la touche enable à true ou false .

Essayer d'utiliser une fonction nécessitant un microservice désactivé entraînera un message d'erreur.

Comment générer des certificats pour les connexions TLS

Manuellement

Générer des paramètres Diffie-Hellman 

openssl dhparam 4096 -outform PEM -out dh4096.pem

Génération d'une autorité de certification auto-signée (CA)

Tout d'abord, créez un fichier nommé Extfile.txt contenant les lignes suivantes: 

 [ v3_req_p ]
basicConstraints = CA:FALSE
keyUsage = nonRepudiation, digitalSignature, keyEncipherment

Ensuite, générez un certificat auto-signé (le CA) CA.Crt et sa clé privée CA.Key : 

openssl req -x509 -nodes -newkey rsa:4096 -keyout ca.key -out ca.crt -days 3650

Génération d'une clé privée et d'un certificat (signé avec le CA)

Générer une clé privée privée.Key et un certificat de demande de signature de certificat Certificate.csr : 

openssl req -newkey rsa:4096 -nodes -keyout private.key -out certificate.csr

Générez le certificat ( certificate.pem ) en signant le RSE avec le CA ( CA.Crt , CA.Key ): 

openssl x509 -extfile extfile.txt -extensions v3_req_p -req -sha1 -days 3650 -CA ca.crt -CAkey ca.key -CAcreateserial -in certificate.csr -out certificate.pem
Développer
Informations supplémentaires
Applications connexes
Recommandé pour vous
Actualités connexes Tout