[BACK]Return to ssh-pkcs11-client.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / ssh

Diff for /src/usr.bin/ssh/ssh-pkcs11-client.c between version 1.17 and 1.18

version 1.17, 2020/10/18 11:32:02 version 1.18, 2023/07/19 14:03:45
Line 24 
Line 24 
 #include <string.h>  #include <string.h>
 #include <unistd.h>  #include <unistd.h>
 #include <errno.h>  #include <errno.h>
   #include <limits.h>
   
 #include <openssl/ecdsa.h>  #include <openssl/ecdsa.h>
 #include <openssl/rsa.h>  #include <openssl/rsa.h>
Line 41 
Line 42 
   
 /* borrows code from sftp-server and ssh-agent */  /* borrows code from sftp-server and ssh-agent */
   
 static int fd = -1;  /*
 static pid_t pid = -1;   * Maintain a list of ssh-pkcs11-helper subprocesses. These may be looked up
    * by provider path or their unique EC/RSA METHOD pointers.
    */
   struct helper {
           char *path;
           pid_t pid;
           int fd;
           RSA_METHOD *rsa_meth;
           EC_KEY_METHOD *ec_meth;
           int (*rsa_finish)(RSA *rsa);
           void (*ec_finish)(EC_KEY *key);
           size_t nrsa, nec; /* number of active keys of each type */
   };
   static struct helper **helpers;
   static size_t nhelpers;
   
   static struct helper *
   helper_by_provider(const char *path)
   {
           size_t i;
   
           for (i = 0; i < nhelpers; i++) {
                   if (helpers[i] == NULL || helpers[i]->path == NULL ||
                       helpers[i]->fd == -1)
                           continue;
                   if (strcmp(helpers[i]->path, path) == 0)
                           return helpers[i];
           }
           return NULL;
   }
   
   static struct helper *
   helper_by_rsa(const RSA *rsa)
   {
           size_t i;
           const RSA_METHOD *meth;
   
           if ((meth = RSA_get_method(rsa)) == NULL)
                   return NULL;
           for (i = 0; i < nhelpers; i++) {
                   if (helpers[i] != NULL && helpers[i]->rsa_meth == meth)
                           return helpers[i];
           }
           return NULL;
   
   }
   
   static struct helper *
   helper_by_ec(const EC_KEY *ec)
   {
           size_t i;
           const EC_KEY_METHOD *meth;
   
           if ((meth = EC_KEY_get_method(ec)) == NULL)
                   return NULL;
           for (i = 0; i < nhelpers; i++) {
                   if (helpers[i] != NULL && helpers[i]->ec_meth == meth)
                           return helpers[i];
           }
           return NULL;
   
   }
   
 static void  static void
 send_msg(struct sshbuf *m)  helper_free(struct helper *helper)
 {  {
           size_t i;
           int found = 0;
   
           if (helper == NULL)
                   return;
           if (helper->path == NULL || helper->ec_meth == NULL ||
               helper->rsa_meth == NULL)
                   fatal_f("inconsistent helper");
           debug3_f("free helper for provider %s", helper->path);
           for (i = 0; i < nhelpers; i++) {
                   if (helpers[i] == helper) {
                           if (found)
                                   fatal_f("helper recorded more than once");
                           found = 1;
                   }
                   else if (found)
                           helpers[i - 1] = helpers[i];
           }
           if (found) {
                   helpers = xrecallocarray(helpers, nhelpers,
                       nhelpers - 1, sizeof(*helpers));
                   nhelpers--;
           }
           free(helper->path);
           EC_KEY_METHOD_free(helper->ec_meth);
           RSA_meth_free(helper->rsa_meth);
           free(helper);
   }
   
   static void
   helper_terminate(struct helper *helper)
   {
           if (helper == NULL) {
                   return;
           } else if (helper->fd == -1) {
                   debug3_f("already terminated");
           } else {
                   debug3_f("terminating helper for %s; "
                       "remaining %zu RSA %zu ECDSA",
                       helper->path, helper->nrsa, helper->nec);
                   close(helper->fd);
                   /* XXX waitpid() */
                   helper->fd = -1;
                   helper->pid = -1;
           }
           /*
            * Don't delete the helper entry until there are no remaining keys
            * that reference it. Otherwise, any signing operation would call
            * a free'd METHOD pointer and that would be bad.
            */
           if (helper->nrsa == 0 && helper->nec == 0)
                   helper_free(helper);
   }
   
   static void
   send_msg(int fd, struct sshbuf *m)
   {
         u_char buf[4];          u_char buf[4];
         size_t mlen = sshbuf_len(m);          size_t mlen = sshbuf_len(m);
         int r;          int r;
   
           if (fd == -1)
                   return;
         POKE_U32(buf, mlen);          POKE_U32(buf, mlen);
         if (atomicio(vwrite, fd, buf, 4) != 4 ||          if (atomicio(vwrite, fd, buf, 4) != 4 ||
             atomicio(vwrite, fd, sshbuf_mutable_ptr(m),              atomicio(vwrite, fd, sshbuf_mutable_ptr(m),
Line 61 
Line 182 
 }  }
   
 static int  static int
 recv_msg(struct sshbuf *m)  recv_msg(int fd, struct sshbuf *m)
 {  {
         u_int l, len;          u_int l, len;
         u_char c, buf[1024];          u_char c, buf[1024];
         int r;          int r;
   
           sshbuf_reset(m);
           if (fd == -1)
                   return 0; /* XXX */
         if ((len = atomicio(read, fd, buf, 4)) != 4) {          if ((len = atomicio(read, fd, buf, 4)) != 4) {
                 error("read from helper failed: %u", len);                  error("read from helper failed: %u", len);
                 return (0); /* XXX */                  return (0); /* XXX */
Line 75 
Line 199 
         if (len > 256 * 1024)          if (len > 256 * 1024)
                 fatal("response too long: %u", len);                  fatal("response too long: %u", len);
         /* read len bytes into m */          /* read len bytes into m */
         sshbuf_reset(m);  
         while (len > 0) {          while (len > 0) {
                 l = len;                  l = len;
                 if (l > sizeof(buf))                  if (l > sizeof(buf))
Line 96 
Line 219 
 int  int
 pkcs11_init(int interactive)  pkcs11_init(int interactive)
 {  {
         return (0);          return 0;
 }  }
   
 void  void
 pkcs11_terminate(void)  pkcs11_terminate(void)
 {  {
         if (fd >= 0)          size_t i;
                 close(fd);  
           debug3_f("terminating %zu helpers", nhelpers);
           for (i = 0; i < nhelpers; i++)
                   helper_terminate(helpers[i]);
 }  }
   
 static int  static int
Line 114 
Line 240 
         u_char *blob = NULL, *signature = NULL;          u_char *blob = NULL, *signature = NULL;
         size_t blen, slen = 0;          size_t blen, slen = 0;
         int r, ret = -1;          int r, ret = -1;
           struct helper *helper;
   
           if ((helper = helper_by_rsa(rsa)) == NULL || helper->fd == -1)
                   fatal_f("no helper for PKCS11 key");
           debug3_f("signing with PKCS11 provider %s", helper->path);
         if (padding != RSA_PKCS1_PADDING)          if (padding != RSA_PKCS1_PADDING)
                 goto fail;                  goto fail;
         key = sshkey_new(KEY_UNSPEC);          key = sshkey_new(KEY_UNSPEC);
Line 136 
Line 266 
             (r = sshbuf_put_string(msg, from, flen)) != 0 ||              (r = sshbuf_put_string(msg, from, flen)) != 0 ||
             (r = sshbuf_put_u32(msg, 0)) != 0)              (r = sshbuf_put_u32(msg, 0)) != 0)
                 fatal_fr(r, "compose");                  fatal_fr(r, "compose");
         send_msg(msg);          send_msg(helper->fd, msg);
         sshbuf_reset(msg);          sshbuf_reset(msg);
   
         if (recv_msg(msg) == SSH2_AGENT_SIGN_RESPONSE) {          if (recv_msg(helper->fd, msg) == SSH2_AGENT_SIGN_RESPONSE) {
                 if ((r = sshbuf_get_string(msg, &signature, &slen)) != 0)                  if ((r = sshbuf_get_string(msg, &signature, &slen)) != 0)
                         fatal_fr(r, "parse");                          fatal_fr(r, "parse");
                 if (slen <= (size_t)RSA_size(rsa)) {                  if (slen <= (size_t)RSA_size(rsa)) {
Line 155 
Line 285 
         return (ret);          return (ret);
 }  }
   
   static int
   rsa_finish(RSA *rsa)
   {
           struct helper *helper;
   
           if ((helper = helper_by_rsa(rsa)) == NULL)
                   fatal_f("no helper for PKCS11 key");
           debug3_f("free PKCS11 RSA key for provider %s", helper->path);
           if (helper->rsa_finish != NULL)
                   helper->rsa_finish(rsa);
           if (helper->nrsa == 0)
                   fatal_f("RSA refcount error");
           helper->nrsa--;
           debug3_f("provider %s remaining keys: %zu RSA %zu ECDSA",
               helper->path, helper->nrsa, helper->nec);
           if (helper->nrsa == 0 && helper->nec == 0)
                   helper_terminate(helper);
           return 1;
   }
   
 static ECDSA_SIG *  static ECDSA_SIG *
 ecdsa_do_sign(const unsigned char *dgst, int dgst_len, const BIGNUM *inv,  ecdsa_do_sign(const unsigned char *dgst, int dgst_len, const BIGNUM *inv,
     const BIGNUM *rp, EC_KEY *ec)      const BIGNUM *rp, EC_KEY *ec)
Line 166 
Line 316 
         u_char *blob = NULL, *signature = NULL;          u_char *blob = NULL, *signature = NULL;
         size_t blen, slen = 0;          size_t blen, slen = 0;
         int r, nid;          int r, nid;
           struct helper *helper;
   
           if ((helper = helper_by_ec(ec)) == NULL || helper->fd == -1)
                   fatal_f("no helper for PKCS11 key");
           debug3_f("signing with PKCS11 provider %s", helper->path);
         nid = sshkey_ecdsa_key_to_nid(ec);          nid = sshkey_ecdsa_key_to_nid(ec);
         if (nid < 0) {          if (nid < 0) {
                 error_f("couldn't get curve nid");                  error_f("couldn't get curve nid");
Line 194 
Line 348 
             (r = sshbuf_put_string(msg, dgst, dgst_len)) != 0 ||              (r = sshbuf_put_string(msg, dgst, dgst_len)) != 0 ||
             (r = sshbuf_put_u32(msg, 0)) != 0)              (r = sshbuf_put_u32(msg, 0)) != 0)
                 fatal_fr(r, "compose");                  fatal_fr(r, "compose");
         send_msg(msg);          send_msg(helper->fd, msg);
         sshbuf_reset(msg);          sshbuf_reset(msg);
   
         if (recv_msg(msg) == SSH2_AGENT_SIGN_RESPONSE) {          if (recv_msg(helper->fd, msg) == SSH2_AGENT_SIGN_RESPONSE) {
                 if ((r = sshbuf_get_string(msg, &signature, &slen)) != 0)                  if ((r = sshbuf_get_string(msg, &signature, &slen)) != 0)
                         fatal_fr(r, "parse");                          fatal_fr(r, "parse");
                 cp = signature;                  cp = signature;
Line 212 
Line 366 
         return (ret);          return (ret);
 }  }
   
 static RSA_METHOD       *helper_rsa;  static void
 static EC_KEY_METHOD    *helper_ecdsa;  ecdsa_do_finish(EC_KEY *ec)
   {
           struct helper *helper;
   
           if ((helper = helper_by_ec(ec)) == NULL)
                   fatal_f("no helper for PKCS11 key");
           debug3_f("free PKCS11 ECDSA key for provider %s", helper->path);
           if (helper->ec_finish != NULL)
                   helper->ec_finish(ec);
           if (helper->nec == 0)
                   fatal_f("ECDSA refcount error");
           helper->nec--;
           debug3_f("provider %s remaining keys: %zu RSA %zu ECDSA",
               helper->path, helper->nrsa, helper->nec);
           if (helper->nrsa == 0 && helper->nec == 0)
                   helper_terminate(helper);
   }
   
 /* redirect private key crypto operations to the ssh-pkcs11-helper */  /* redirect private key crypto operations to the ssh-pkcs11-helper */
 static void  static void
 wrap_key(struct sshkey *k)  wrap_key(struct helper *helper, struct sshkey *k)
 {  {
         if (k->type == KEY_RSA)          debug3_f("wrap %s for provider %s", sshkey_type(k), helper->path);
                 RSA_set_method(k->rsa, helper_rsa);          if (k->type == KEY_RSA) {
         else if (k->type == KEY_ECDSA)                  RSA_set_method(k->rsa, helper->rsa_meth);
                 EC_KEY_set_method(k->ecdsa, helper_ecdsa);                  if (helper->nrsa++ >= INT_MAX)
         else                          fatal_f("RSA refcount error");
           } else if (k->type == KEY_ECDSA) {
                   EC_KEY_set_method(k->ecdsa, helper->ec_meth);
                   if (helper->nec++ >= INT_MAX)
                           fatal_f("EC refcount error");
           } else
                 fatal_f("unknown key type");                  fatal_f("unknown key type");
           k->flags |= SSHKEY_FLAG_EXT;
           debug3_f("provider %s remaining keys: %zu RSA %zu ECDSA",
               helper->path, helper->nrsa, helper->nec);
 }  }
   
 static int  static int
 pkcs11_start_helper_methods(void)  pkcs11_start_helper_methods(struct helper *helper)
 {  {
         if (helper_ecdsa != NULL)          int (*ec_init)(EC_KEY *key);
                 return (0);          int (*ec_copy)(EC_KEY *dest, const EC_KEY *src);
           int (*ec_set_group)(EC_KEY *key, const EC_GROUP *grp);
         int (*orig_sign)(int, const unsigned char *, int, unsigned char *,          int (*ec_set_private)(EC_KEY *key, const BIGNUM *priv_key);
           int (*ec_set_public)(EC_KEY *key, const EC_POINT *pub_key);
           int (*ec_sign)(int, const unsigned char *, int, unsigned char *,
             unsigned int *, const BIGNUM *, const BIGNUM *, EC_KEY *) = NULL;              unsigned int *, const BIGNUM *, const BIGNUM *, EC_KEY *) = NULL;
         if (helper_ecdsa != NULL)          RSA_METHOD *rsa_meth;
                 return (0);          EC_KEY_METHOD *ec_meth;
         helper_ecdsa = EC_KEY_METHOD_new(EC_KEY_OpenSSL());  
         if (helper_ecdsa == NULL)  
                 return (-1);  
         EC_KEY_METHOD_get_sign(helper_ecdsa, &orig_sign, NULL, NULL);  
         EC_KEY_METHOD_set_sign(helper_ecdsa, orig_sign, NULL, ecdsa_do_sign);  
   
         if ((helper_rsa = RSA_meth_dup(RSA_get_default_method())) == NULL)          if ((ec_meth = EC_KEY_METHOD_new(EC_KEY_OpenSSL())) == NULL)
                   return -1;
           EC_KEY_METHOD_get_sign(ec_meth, &ec_sign, NULL, NULL);
           EC_KEY_METHOD_set_sign(ec_meth, ec_sign, NULL, ecdsa_do_sign);
           EC_KEY_METHOD_get_init(ec_meth, &ec_init, &helper->ec_finish,
               &ec_copy, &ec_set_group, &ec_set_private, &ec_set_public);
           EC_KEY_METHOD_set_init(ec_meth, ec_init, ecdsa_do_finish,
               ec_copy, ec_set_group, ec_set_private, ec_set_public);
   
           if ((rsa_meth = RSA_meth_dup(RSA_get_default_method())) == NULL)
                 fatal_f("RSA_meth_dup failed");                  fatal_f("RSA_meth_dup failed");
         if (!RSA_meth_set1_name(helper_rsa, "ssh-pkcs11-helper") ||          helper->rsa_finish = RSA_meth_get_finish(rsa_meth);
             !RSA_meth_set_priv_enc(helper_rsa, rsa_encrypt))          if (!RSA_meth_set1_name(rsa_meth, "ssh-pkcs11-helper") ||
               !RSA_meth_set_priv_enc(rsa_meth, rsa_encrypt) ||
               !RSA_meth_set_finish(rsa_meth, rsa_finish))
                 fatal_f("failed to prepare method");                  fatal_f("failed to prepare method");
   
         return (0);          helper->ec_meth = ec_meth;
           helper->rsa_meth = rsa_meth;
           return 0;
 }  }
   
 static int  static struct helper *
 pkcs11_start_helper(void)  pkcs11_start_helper(const char *path)
 {  {
         int pair[2];          int pair[2];
         char *helper, *verbosity = NULL;          char *prog, *verbosity = NULL;
           struct helper *helper;
           pid_t pid;
   
         if (log_level_get() >= SYSLOG_LEVEL_DEBUG1)          if (nhelpers >= INT_MAX)
                 verbosity = "-vvv";                  fatal_f("too many helpers");
           debug3_f("start helper for %s", path);
         if (pkcs11_start_helper_methods() == -1) {  
                 error("pkcs11_start_helper_methods failed");  
                 return (-1);  
         }  
   
         if (socketpair(AF_UNIX, SOCK_STREAM, 0, pair) == -1) {          if (socketpair(AF_UNIX, SOCK_STREAM, 0, pair) == -1) {
                 error("socketpair: %s", strerror(errno));                  error_f("socketpair: %s", strerror(errno));
                 return (-1);                  return NULL;
         }          }
           helper = xcalloc(1, sizeof(*helper));
           if (pkcs11_start_helper_methods(helper) == -1) {
                   error_f("pkcs11_start_helper_methods failed");
                   goto fail;
           }
         if ((pid = fork()) == -1) {          if ((pid = fork()) == -1) {
                 error("fork: %s", strerror(errno));                  error_f("fork: %s", strerror(errno));
                 return (-1);   fail:
                   close(pair[0]);
                   close(pair[1]);
                   RSA_meth_free(helper->rsa_meth);
                   EC_KEY_METHOD_free(helper->ec_meth);
                   free(helper);
                   return NULL;
         } else if (pid == 0) {          } else if (pid == 0) {
                 if ((dup2(pair[1], STDIN_FILENO) == -1) ||                  if ((dup2(pair[1], STDIN_FILENO) == -1) ||
                     (dup2(pair[1], STDOUT_FILENO) == -1)) {                      (dup2(pair[1], STDOUT_FILENO) == -1)) {
Line 281 
Line 477 
                 }                  }
                 close(pair[0]);                  close(pair[0]);
                 close(pair[1]);                  close(pair[1]);
                 helper = getenv("SSH_PKCS11_HELPER");                  prog = getenv("SSH_PKCS11_HELPER");
                 if (helper == NULL || strlen(helper) == 0)                  if (prog == NULL || strlen(prog) == 0)
                         helper = _PATH_SSH_PKCS11_HELPER;                          prog = _PATH_SSH_PKCS11_HELPER;
                 debug_f("starting %s %s", helper,                  if (log_level_get() >= SYSLOG_LEVEL_DEBUG1)
                           verbosity = "-vvv";
                   debug_f("starting %s %s", prog,
                     verbosity == NULL ? "" : verbosity);                      verbosity == NULL ? "" : verbosity);
                 execlp(helper, helper, verbosity, (char *)NULL);                  execlp(prog, prog, verbosity, (char *)NULL);
                 fprintf(stderr, "exec: %s: %s\n", helper, strerror(errno));                  fprintf(stderr, "exec: %s: %s\n", prog, strerror(errno));
                 _exit(1);                  _exit(1);
         }          }
         close(pair[1]);          close(pair[1]);
         fd = pair[0];          helper->fd = pair[0];
         return (0);          helper->path = xstrdup(path);
           helper->pid = pid;
           debug3_f("helper %zu for \"%s\" on fd %d pid %ld", nhelpers,
               helper->path, helper->fd, (long)helper->pid);
           helpers = xrecallocarray(helpers, nhelpers,
               nhelpers + 1, sizeof(*helpers));
           helpers[nhelpers++] = helper;
           return helper;
 }  }
   
 int  int
Line 306 
Line 511 
         size_t blen;          size_t blen;
         u_int nkeys, i;          u_int nkeys, i;
         struct sshbuf *msg;          struct sshbuf *msg;
           struct helper *helper;
   
         if (fd < 0 && pkcs11_start_helper() < 0)          if ((helper = helper_by_provider(name)) == NULL &&
                 return (-1);              (helper = pkcs11_start_helper(name)) == NULL)
                   return -1;
   
         if ((msg = sshbuf_new()) == NULL)          if ((msg = sshbuf_new()) == NULL)
                 fatal_f("sshbuf_new failed");                  fatal_f("sshbuf_new failed");
Line 316 
Line 523 
             (r = sshbuf_put_cstring(msg, name)) != 0 ||              (r = sshbuf_put_cstring(msg, name)) != 0 ||
             (r = sshbuf_put_cstring(msg, pin)) != 0)              (r = sshbuf_put_cstring(msg, pin)) != 0)
                 fatal_fr(r, "compose");                  fatal_fr(r, "compose");
         send_msg(msg);          send_msg(helper->fd, msg);
         sshbuf_reset(msg);          sshbuf_reset(msg);
   
         type = recv_msg(msg);          type = recv_msg(helper->fd, msg);
         if (type == SSH2_AGENT_IDENTITIES_ANSWER) {          if (type == SSH2_AGENT_IDENTITIES_ANSWER) {
                 if ((r = sshbuf_get_u32(msg, &nkeys)) != 0)                  if ((r = sshbuf_get_u32(msg, &nkeys)) != 0)
                         fatal_fr(r, "parse nkeys");                          fatal_fr(r, "parse nkeys");
Line 333 
Line 540 
                                 fatal_fr(r, "parse key");                                  fatal_fr(r, "parse key");
                         if ((r = sshkey_from_blob(blob, blen, &k)) != 0)                          if ((r = sshkey_from_blob(blob, blen, &k)) != 0)
                                 fatal_fr(r, "decode key");                                  fatal_fr(r, "decode key");
                         wrap_key(k);                          wrap_key(helper, k);
                         (*keysp)[i] = k;                          (*keysp)[i] = k;
                         if (labelsp)                          if (labelsp)
                                 (*labelsp)[i] = label;                                  (*labelsp)[i] = label;
Line 354 
Line 561 
 int  int
 pkcs11_del_provider(char *name)  pkcs11_del_provider(char *name)
 {  {
         int r, ret = -1;          struct helper *helper;
         struct sshbuf *msg;  
   
         if ((msg = sshbuf_new()) == NULL)          /*
                 fatal_f("sshbuf_new failed");           * ssh-agent deletes keys before calling this, so the helper entry
         if ((r = sshbuf_put_u8(msg, SSH_AGENTC_REMOVE_SMARTCARD_KEY)) != 0 ||           * should be gone before we get here.
             (r = sshbuf_put_cstring(msg, name)) != 0 ||           */
             (r = sshbuf_put_cstring(msg, "")) != 0)          debug3_f("delete %s", name);
                 fatal_fr(r, "compose");          if ((helper = helper_by_provider(name)) != NULL)
         send_msg(msg);                  helper_terminate(helper);
         sshbuf_reset(msg);          return 0;
   
         if (recv_msg(msg) == SSH_AGENT_SUCCESS)  
                 ret = 0;  
         sshbuf_free(msg);  
         return (ret);  
 }  }
Legend:
Removed from v.1.17  
changed lines
  Added in v.1.18