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

Diff for /src/usr.bin/ssh/ssh-dss.c between version 1.31 and 1.32

version 1.31, 2014/02/02 03:44:31 version 1.32, 2014/06/24 01:13:21
Line 30 
Line 30 
   
 #include <string.h>  #include <string.h>
   
 #include "xmalloc.h"  #include "sshbuf.h"
 #include "buffer.h"  
 #include "compat.h"  #include "compat.h"
 #include "log.h"  #include "ssherr.h"
 #include "key.h"  
 #include "digest.h"  #include "digest.h"
   #define SSHKEY_INTERNAL
   #include "sshkey.h"
   
 #define INTBLOB_LEN     20  #define INTBLOB_LEN     20
 #define SIGBLOB_LEN     (2*INTBLOB_LEN)  #define SIGBLOB_LEN     (2*INTBLOB_LEN)
   
 int  int
 ssh_dss_sign(const Key *key, u_char **sigp, u_int *lenp,  ssh_dss_sign(const struct sshkey *key, u_char **sigp, size_t *lenp,
     const u_char *data, u_int datalen)      const u_char *data, size_t datalen, u_int compat)
 {  {
         DSA_SIG *sig;          DSA_SIG *sig = NULL;
         u_char digest[SSH_DIGEST_MAX_LENGTH], sigblob[SIGBLOB_LEN];          u_char digest[SSH_DIGEST_MAX_LENGTH], sigblob[SIGBLOB_LEN];
         u_int rlen, slen, len, dlen = ssh_digest_bytes(SSH_DIGEST_SHA1);          size_t rlen, slen, len, dlen = ssh_digest_bytes(SSH_DIGEST_SHA1);
         Buffer b;          struct sshbuf *b = NULL;
           int ret = SSH_ERR_INVALID_ARGUMENT;
   
         if (key == NULL || key_type_plain(key->type) != KEY_DSA ||          if (lenp != NULL)
             key->dsa == NULL) {                  *lenp = 0;
                 error("%s: no DSA key", __func__);          if (sigp != NULL)
                 return -1;                  *sigp = NULL;
         }  
   
         if (ssh_digest_memory(SSH_DIGEST_SHA1, data, datalen,          if (key == NULL || key->dsa == NULL ||
             digest, sizeof(digest)) != 0) {              sshkey_type_plain(key->type) != KEY_DSA)
                 error("%s: ssh_digest_memory failed", __func__);                  return SSH_ERR_INVALID_ARGUMENT;
                 return -1;          if (dlen == 0)
         }                  return SSH_ERR_INTERNAL_ERROR;
   
         sig = DSA_do_sign(digest, dlen, key->dsa);          if ((ret = ssh_digest_memory(SSH_DIGEST_SHA1, data, datalen,
         explicit_bzero(digest, sizeof(digest));              digest, sizeof(digest))) != 0)
                   goto out;
   
         if (sig == NULL) {          if ((sig = DSA_do_sign(digest, dlen, key->dsa)) == NULL) {
                 error("ssh_dss_sign: sign failed");                  ret = SSH_ERR_LIBCRYPTO_ERROR;
                 return -1;                  goto out;
         }          }
   
         rlen = BN_num_bytes(sig->r);          rlen = BN_num_bytes(sig->r);
         slen = BN_num_bytes(sig->s);          slen = BN_num_bytes(sig->s);
         if (rlen > INTBLOB_LEN || slen > INTBLOB_LEN) {          if (rlen > INTBLOB_LEN || slen > INTBLOB_LEN) {
                 error("bad sig size %u %u", rlen, slen);                  ret = SSH_ERR_INTERNAL_ERROR;
                 DSA_SIG_free(sig);                  goto out;
                 return -1;  
         }          }
         explicit_bzero(sigblob, SIGBLOB_LEN);          explicit_bzero(sigblob, SIGBLOB_LEN);
         BN_bn2bin(sig->r, sigblob+ SIGBLOB_LEN - INTBLOB_LEN - rlen);          BN_bn2bin(sig->r, sigblob + SIGBLOB_LEN - INTBLOB_LEN - rlen);
         BN_bn2bin(sig->s, sigblob+ SIGBLOB_LEN - slen);          BN_bn2bin(sig->s, sigblob + SIGBLOB_LEN - slen);
         DSA_SIG_free(sig);  
   
         if (datafellows & SSH_BUG_SIGBLOB) {          if (compat & SSH_BUG_SIGBLOB) {
                 if (lenp != NULL)  
                         *lenp = SIGBLOB_LEN;  
                 if (sigp != NULL) {                  if (sigp != NULL) {
                         *sigp = xmalloc(SIGBLOB_LEN);                          if ((*sigp = malloc(SIGBLOB_LEN)) == NULL) {
                                   ret = SSH_ERR_ALLOC_FAIL;
                                   goto out;
                           }
                         memcpy(*sigp, sigblob, SIGBLOB_LEN);                          memcpy(*sigp, sigblob, SIGBLOB_LEN);
                 }                  }
                   if (lenp != NULL)
                           *lenp = SIGBLOB_LEN;
                   ret = 0;
         } else {          } else {
                 /* ietf-drafts */                  /* ietf-drafts */
                 buffer_init(&b);                  if ((b = sshbuf_new()) == NULL) {
                 buffer_put_cstring(&b, "ssh-dss");                          ret = SSH_ERR_ALLOC_FAIL;
                 buffer_put_string(&b, sigblob, SIGBLOB_LEN);                          goto out;
                 len = buffer_len(&b);                  }
                 if (lenp != NULL)                  if ((ret = sshbuf_put_cstring(b, "ssh-dss")) != 0 ||
                         *lenp = len;                      (ret = sshbuf_put_string(b, sigblob, SIGBLOB_LEN)) != 0)
                           goto out;
                   len = sshbuf_len(b);
                 if (sigp != NULL) {                  if (sigp != NULL) {
                         *sigp = xmalloc(len);                          if ((*sigp = malloc(len)) == NULL) {
                         memcpy(*sigp, buffer_ptr(&b), len);                                  ret = SSH_ERR_ALLOC_FAIL;
                                   goto out;
                           }
                           memcpy(*sigp, sshbuf_ptr(b), len);
                 }                  }
                 buffer_free(&b);                  if (lenp != NULL)
                           *lenp = len;
                   ret = 0;
         }          }
         return 0;   out:
           explicit_bzero(digest, sizeof(digest));
           if (sig != NULL)
                   DSA_SIG_free(sig);
           if (b != NULL)
                   sshbuf_free(b);
           return ret;
 }  }
   
 int  int
 ssh_dss_verify(const Key *key, const u_char *signature, u_int signaturelen,  ssh_dss_verify(const struct sshkey *key,
     const u_char *data, u_int datalen)      const u_char *signature, size_t signaturelen,
       const u_char *data, size_t datalen, u_int compat)
 {  {
         DSA_SIG *sig;          DSA_SIG *sig = NULL;
         u_char digest[SSH_DIGEST_MAX_LENGTH], *sigblob;          u_char digest[SSH_DIGEST_MAX_LENGTH], *sigblob = NULL;
         u_int len, dlen = ssh_digest_bytes(SSH_DIGEST_SHA1);          size_t len, dlen = ssh_digest_bytes(SSH_DIGEST_SHA1);
         int rlen, ret;          int ret = SSH_ERR_INTERNAL_ERROR;
         Buffer b;          struct sshbuf *b = NULL;
           char *ktype = NULL;
   
         if (key == NULL || key_type_plain(key->type) != KEY_DSA ||          if (key == NULL || key->dsa == NULL ||
             key->dsa == NULL) {              sshkey_type_plain(key->type) != KEY_DSA)
                 error("%s: no DSA key", __func__);                  return SSH_ERR_INVALID_ARGUMENT;
                 return -1;          if (dlen == 0)
         }                  return SSH_ERR_INTERNAL_ERROR;
   
         /* fetch signature */          /* fetch signature */
         if (datafellows & SSH_BUG_SIGBLOB) {          if (compat & SSH_BUG_SIGBLOB) {
                 sigblob = xmalloc(signaturelen);                  if ((sigblob = malloc(signaturelen)) == NULL)
                           return SSH_ERR_ALLOC_FAIL;
                 memcpy(sigblob, signature, signaturelen);                  memcpy(sigblob, signature, signaturelen);
                 len = signaturelen;                  len = signaturelen;
         } else {          } else {
                 /* ietf-drafts */                  /* ietf-drafts */
                 char *ktype;                  if ((b = sshbuf_from(signature, signaturelen)) == NULL)
                 buffer_init(&b);                          return SSH_ERR_ALLOC_FAIL;
                 buffer_append(&b, signature, signaturelen);                  if (sshbuf_get_cstring(b, &ktype, NULL) != 0 ||
                 ktype = buffer_get_cstring(&b, NULL);                      sshbuf_get_string(b, &sigblob, &len) != 0) {
                           ret = SSH_ERR_INVALID_FORMAT;
                           goto out;
                   }
                 if (strcmp("ssh-dss", ktype) != 0) {                  if (strcmp("ssh-dss", ktype) != 0) {
                         error("%s: cannot handle type %s", __func__, ktype);                          ret = SSH_ERR_KEY_TYPE_MISMATCH;
                         buffer_free(&b);                          goto out;
                         free(ktype);  
                         return -1;  
                 }                  }
                 free(ktype);                  if (sshbuf_len(b) != 0) {
                 sigblob = buffer_get_string(&b, &len);                          ret = SSH_ERR_UNEXPECTED_TRAILING_DATA;
                 rlen = buffer_len(&b);                          goto out;
                 buffer_free(&b);  
                 if (rlen != 0) {  
                         error("%s: remaining bytes in signature %d",  
                             __func__, rlen);  
                         free(sigblob);  
                         return -1;  
                 }                  }
         }          }
   
         if (len != SIGBLOB_LEN) {          if (len != SIGBLOB_LEN) {
                 fatal("bad sigbloblen %u != SIGBLOB_LEN", len);                  ret = SSH_ERR_INVALID_FORMAT;
                   goto out;
         }          }
   
         /* parse signature */          /* parse signature */
         if ((sig = DSA_SIG_new()) == NULL)          if ((sig = DSA_SIG_new()) == NULL ||
                 fatal("%s: DSA_SIG_new failed", __func__);              (sig->r = BN_new()) == NULL ||
         if ((sig->r = BN_new()) == NULL)              (sig->s = BN_new()) == NULL) {
                 fatal("%s: BN_new failed", __func__);                  ret = SSH_ERR_ALLOC_FAIL;
         if ((sig->s = BN_new()) == NULL)                  goto out;
                 fatal("ssh_dss_verify: BN_new failed");          }
         if ((BN_bin2bn(sigblob, INTBLOB_LEN, sig->r) == NULL) ||          if ((BN_bin2bn(sigblob, INTBLOB_LEN, sig->r) == NULL) ||
             (BN_bin2bn(sigblob+ INTBLOB_LEN, INTBLOB_LEN, sig->s) == NULL))              (BN_bin2bn(sigblob+ INTBLOB_LEN, INTBLOB_LEN, sig->s) == NULL)) {
                 fatal("%s: BN_bin2bn failed", __func__);                  ret = SSH_ERR_LIBCRYPTO_ERROR;
                   goto out;
           }
   
         /* clean up */  
         explicit_bzero(sigblob, len);  
         free(sigblob);  
   
         /* sha1 the data */          /* sha1 the data */
         if (ssh_digest_memory(SSH_DIGEST_SHA1, data, datalen,          if ((ret = ssh_digest_memory(SSH_DIGEST_SHA1, data, datalen,
             digest, sizeof(digest)) != 0) {              digest, sizeof(digest))) != 0)
                 error("%s: digest_memory failed", __func__);                  goto out;
                 return -1;  
           switch (DSA_do_verify(digest, dlen, sig, key->dsa)) {
           case 1:
                   ret = 0;
                   break;
           case 0:
                   ret = SSH_ERR_SIGNATURE_INVALID;
                   goto out;
           default:
                   ret = SSH_ERR_LIBCRYPTO_ERROR;
                   goto out;
         }          }
   
         ret = DSA_do_verify(digest, dlen, sig, key->dsa);   out:
         explicit_bzero(digest, sizeof(digest));          explicit_bzero(digest, sizeof(digest));
           if (sig != NULL)
         DSA_SIG_free(sig);                  DSA_SIG_free(sig);
           if (b != NULL)
         debug("%s: signature %s", __func__,                  sshbuf_free(b);
             ret == 1 ? "correct" : ret == 0 ? "incorrect" : "error");          if (ktype != NULL)
                   free(ktype);
           if (sigblob != NULL) {
                   explicit_bzero(sigblob, len);
                   free(sigblob);
           }
         return ret;          return ret;
 }  }
Legend:
Removed from v.1.31  
changed lines
  Added in v.1.32