Authentification mutuelle et ressortingction des certificates utilisateur à un ensemble spécifique sur le serveur

Une explication (pour la ligne de commande) et une demi-réponse (pour la bibliothèque):

J’ai (cette fois entièrement) refait ton esprit et on m’a rappelé une incohérence ici. Les utilitaires openssl xxx sont principalement conçus comme des outils de test / débogage, et en particulier:

• s_client normalement (sauf anonyme, SRP, etc.) reçoit une chaîne de cert du serveur, mais utilise un callback qui enregistre uniquement ce qu’il a obtenu et ignore / remplace toute erreur ; c’est le bloc

   depth=0 C = AU, ST = StateA, L = CityA, O = CompanyA, CN = localhost, emailAddress = [email protected] verify error:num=18:self signed certificatee verify return:1 depth=0 C = AU, ST = StateA, L = CityA, O = CompanyA, CN = localhost, emailAddress = [email protected] verify return:1 

  juste après CONNECTED(fd) dans votre sortie s_client , mais comme vous le voyez malgré l’erreur, il continue avec le handshake résultant en une connexion utilisable.

• s_server est un peu plus compliqué. Il ne demande pas de cert du client par défaut, seulement si vous spécifiez -verify ou -Verify (qui définit SSL_VERIFY_PEER qui n’est pas la valeur par défaut pour le serveur), et s’il demande un client cert a l’ option d’envoyer un preuve associée dans CertVerify). Si le client envoie une chaîne, s_server utilise le même rappel que s_client qui remplace toute erreur et continue la connexion. ceci dans votre sortie s_server avec la même verify error:num-18... ce qui signifie en réalité “root (y compris auto-signé qui est sa propre racine) dans la chaîne reçue mais pas dans truststore local”. Si le client n’envoie pas de chaîne, -verify continue, mais -Verify (qui définit également SSL_VERIFY_FAIL_IF_NO_PEER_CERT ) SSL_VERIFY_FAIL_IF_NO_PEER_CERT la prise de contact avec l’alerte 40 et renvoie une erreur. s_server sortie de s_server est donc très différente:

     vérifier que la profondeur est 0, doit retourner un certificate
     Utilisation des parameters DH par défaut
     Utilisation des parameters temp ECDH par défaut
     ACCEPTEZ
     ERREUR
     140679792887624: erreur: 140890C7: routines SSL: SSL3_GET_CLIENT_CERTIFICATE: homologue n'a pas renvoyé de certificate: s3_srvr.c: 3271:
     arrêter SSL
     CONNEXION FERMÉE
     ACCEPTEZ

Mais un programme utilisant la bibliothèque devrait fonctionner . J’ai piraté ce test simple à partir de parties d’autres programmes (d’où l’indentation):

 / * SO36821430 2016-04-25 * /

 #include 
 #si défini (_WIN32) &&! defined (WIN32)
 #définir WIN32 / * n'importe quoi * /
 #fin si
 #ifdef WIN32
   #include 
   typedef int socklen_t;
   #define SOCKERR WSAGetLastError ()
   #include "openssl / applink.c"
 #autre
   #include 
   #include 
   #include 
   #include 
   #ifndef INADDR_NONE
   #define INADDR_NONE (ipaddr_t) -1
   #fin si
   typedef int SOCKET;
   enum {INVALID_SOCKET = -1, SOCKET_ERROR = -1};
   #define SOCKERR errno
   #define closeocket fermer
 #fin si

 #include "openssl / ssl.h"
 #include "openssl / err.h"
 #include "openssl / rand.h"

 void sockerr (const char * what) {
   fprintf (stderr, "% s% d% s \ n", quoi, SOCKERR, strerror (SOCKERR));
 }
 void sslerrn (const char * what) {
   fprintf (stderr, "*% s échoué: \ n", quoi);
   ERR_print_errors_fp (stderr);
 }
 void sslerr (const char * quoi, int rv) {
   fprintf (stderr, "*% s retourne% d: \ n", quoi, rv);
   ERR_print_errors_fp (stderr);
 }
 Annuler sslerrx (SSL * ssl, const char * quoi, int rv) {
   int rc = SSL_get_error (ssl, rv);
   if (rv == -1 && rc == SSL_ERROR_SYSCALL) sockerr (quoi);
   sinon fprintf (stderr, "*% s retourne% d,% d \ n", quoi, rv, rc);
   ERR_print_errors_fp (stderr); 
 }
 void subj_oneline (X509 * cert, FILE * fp) {
   X509_NAME * subj = X509_get_subject_name (cert);
   BIO * bmem = BIO_new (BIO_s_mem ());  char * ptr;  int n;
   X509_NAME_print_ex (bmem, subj, 0, XN_FLAG_ONELINE); 
   n = (int) BIO_get_mem_data (bmem, & ptr);
   si (n <= 0) ptr = "?", n = 1;
   fwrite (ptr, 1, n, fp);
 }

 const char * inaddr;
 int inport;
 char buf [9999];

 int main (int argc, char * argv [])
 {
   int rv; 
   struct sockaddr_in sin;  socklen_t sinlen;
   SOCKET SI, S2;  SSL_CTX * ctx = NULL;
   time_t maintenant;  struct tm * tm;
 #ifdef WIN32
   struct WSAData wsa;
   rv = WSAStartup (MAKEWORD (1,1), & wsa);
   if (rv) {printf ("WSAStartup% d \ n", rv);  sortie (1);  }
 #fin si

   if (argc <2 || argc> 6)
     printf ("utilisation:% s clé de port cert CAcerts \ n", argv [0]), exit (1);
   sin.sin_addr.s_addr = INADDR_ANY;
   sin.sin_port = htons (atoi (argv [1]));
   sin.sin_family = AF_INET;

   / ** /
     SSL_library_init ();
     SSL_load_error_ssortingngs ();
     ctx = SSL_CTX_new (SSLv23_server_method ());
     if (! ctx) {sslerrn ("CTX_new");  sortie (1);  }
     SSL_CTX_set_options (ctx, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);
     rv = SSL_CTX_use_PrivateKey_file (ctx, argv [2], SSL_FILETYPE_PEM);
     if (rv! = 1) {sslerr ("use_PrivateKey_file", rv);  sortie (1);  }
     rv = SSL_CTX_use_certificatee_file (ctx, argv [3], SSL_FILETYPE_PEM);
     if (rv! = 1) {sslerr ("use_certificatee_file", rv);  sortie (1);  }
     SSL_CTX_set_verify (ctx, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, NULL); 
     if (! SSL_CTX_load_verify_locations (ctx, argv [4], NULL)) {
       sslerrn ("load_verify_locations");  sortie (1);  }
     SSL_CTX_set_client_CA_list (ctx, SSL_load_client_CA_file (argv [4]));
   / ** /
   if ((s1 = socket (AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) {
     sockerr ("socket ()");  sortie (1);  }
   if (bind (s1, (struct sockaddr *) & sin, sizeof sin) <0) {
     sockerr ("bind ()");  sortie (1);  }
   si (écoutez (s1, 5) <0) {
     sockerr ("listen ()");  sortie (1);  }

   faire{
     sinlen = taille du péché;
     if ((s2 = accept (s1, (struct sockaddr *) & sin, & sinlen)) == INVALID_SOCKET) {
       sockerr ("accept ()");  sortie (1);  }
     now = time (NULL);  tm = localtime (& now);
     printf ("+% s% u @% 02d.% 02d.% 02d \ n", inet_ntoa (sin.sin_addr),
       ntohs (sin.sin_port), tm-> tm_hour, tm-> tm_min, tm-> tm_sec);

     / ** /
       SSL * ssl = SSL_new (ctx);
       if (! ssl) {sslerrn ("SSL_new");  aller ensuite;  }
       SSL_set_fd (ssl, s2);
       if ((rv = SSL_accept (ssl)) <0) {
         sslerrx (SSL, "SSL_accept", rv);  aller ensuite;  }
       {X509 * cert = SSL_get_peer_certificate (ssl);
         / * EVP_PKEY * key = cert?  X509_get_pubkey (cert): NULL; * /
         fprintf (stdout, "=% ld", SSL_get_verify_result (ssl));
         if (cert) putchar (':'), subj_oneline (cert, stdout);
         putchar ('\ n');
       }
       while ((rv = SSL_read (ssl, buf, sizeof buf))> 0)
         printf ("% d:%. * s \ n", rv, rv, buf);
       sslerrx (ssl, "SSL_read", rv);
 prochain:
       if (ssl) SSL_free (ssl);
     / ** /
     now = time (NULL);  tm = localtime (& now);
     printf ("-% s% u @% 02d.% 02d.% 02d \ n", inet_ntoa (sin.sin_addr),
       ntohs (sin.sin_port), tm-> tm_hour, tm-> tm_min, tm-> tm_sec);
     closureocket (s2);
   } tant que (1);
   retourne 0;
 }

Lorsqu’elle est exécutée avec $port cert1.key cert1.pem CAbundle.pem et connectée à partir du client à l’aide de cert2.key & cert2.pem, cela interrompt la prise de contact avec l’alerte 48 unknown_ca et renvoie une erreur si nécessaire:

 + 127.0.0.1 46765 @22.07.36 * SSL_accept return -1,1 140240689366696:error:14089086:SSL routines:ssl3_get_client_certificatee:certificatee verify failed:s3_srvr.c:3270: - 127.0.0.1 46765 @22.07.36 

HTH

Si vous voulez une liste blanche de certificates clients spécifiques, vous pouvez préparer une liste indexée en mémoire lors de l’initialisation.

Par exemple, vous pouvez utiliser PEM_X509_INFO_read pour lire un fichier concaténé de tous les certificates clients au format PEM. Cela vous donnera un STACK_OF(X509_INFO)* des certificates. Le nombre de certificates peut être trouvé avec sk_X509_INFO_num , et vous pouvez voir chaque certificate à sk_X509_INFO_value(..)->x509 .

Ensuite, par exemple, vous pouvez simplement créer un index en mémoire et qsort par compare_x509 .

Maintenant, lorsque votre rappel de vérification est appelé, faites simplement une bsearch sur votre index par compare_x509 , et le certificate est sur votre liste blanche, ou ce n’est pas le cas.

Vous pouvez accepter la correspondance sur le résultat de compare_x5099 ou bien, bien sûr, vous pouvez vérifier en vérifiant le certificate complet une fois que la recherche a trouvé une correspondance dans l’index.