niceSOFT/libssh2: the SSH library

src/libgcrypt.c
567 строк13 KB
James Housley
Initially the libssh2 code was indented with tabs of 4 spaces. Some of
28 май 2007, 21:56
28 май 2007, 21:56412b25d
/* Copyright (C) 2006, 2007 The Written Word, Inc.  All rights reserved.
 * Author: Simon Josefsson
 *
 * Redistribution and use in source and binary forms,
 * with or without modification, are permitted provided
 * that the following conditions are met:
 *
 *   Redistributions of source code must retain the above
 *   copyright notice, this list of conditions and the
 *   following disclaimer.
 *
 *   Redistributions in binary form must reproduce the above
 *   copyright notice, this list of conditions and the following
 *   disclaimer in the documentation and/or other materials
 *   provided with the distribution.
 *
 *   Neither the name of the copyright holder nor the names
 *   of any other contributors may be used to endorse or
 *   promote products derived from this software without
 *   specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
 * OF SUCH DAMAGE.
 */

#include "libssh2_priv.h"
#include <string.h>

int _libssh2_rsa_new(libssh2_rsa_ctx **rsa,
             const unsigned char *edata,
             unsigned long elen,
             const unsigned char *ndata,
             unsigned long nlen,
             const unsigned char *ddata,
             unsigned long dlen,
             const unsigned char *pdata,
             unsigned long plen,
             const unsigned char *qdata,
             unsigned long qlen,
             const unsigned char *e1data,
             unsigned long e1len,
             const unsigned char *e2data,
             unsigned long e2len,
             const unsigned char *coeffdata,
             unsigned long coefflen)
{
    int rc;
    (void)e1data;
    (void)e1len;
    (void)e2data;
    (void)e2len;

    if (ddata) {
        rc = gcry_sexp_build
            (rsa, NULL,
             "(private-key(rsa(n%b)(e%b)(d%b)(q%b)(p%b)(u%b)))",
             nlen, ndata, elen, edata, dlen, ddata, plen, pdata,
             qlen, qdata, coefflen, coeffdata);
    } else {
        rc = gcry_sexp_build (rsa, NULL, "(public-key(rsa(n%b)(e%b)))",
                      nlen, ndata, elen, edata);
    }
    if (rc)
    {
        *rsa = NULL;
        return -1;
    }

    return 0;
}

int _libssh2_rsa_sha1_verify(libssh2_rsa_ctx *rsa,
                 const unsigned char *sig,
                 unsigned long sig_len,
                 const unsigned char *m,
                 unsigned long m_len)
{
    unsigned char hash[SHA_DIGEST_LENGTH];
    gcry_sexp_t s_sig, s_hash;
    int rc = -1;

    libssh2_sha1(m, m_len, hash);

    rc = gcry_sexp_build (&s_hash, NULL,
                  "(data (flags pkcs1) (hash sha1 %b))",
                  SHA_DIGEST_LENGTH, hash);
    if (rc != 0) {
        return -1;
    }

    rc = gcry_sexp_build (&s_sig, NULL, "(sig-val(rsa(s %b)))",
                  sig_len, sig);
    if (rc != 0) {
        gcry_sexp_release (s_hash);
        return -1;
    }

    rc = gcry_pk_verify (s_sig, s_hash, rsa);
    gcry_sexp_release (s_sig);
    gcry_sexp_release (s_hash);

    return (rc == 0) ? 0 : -1;
}

int _libssh2_dsa_new(libssh2_dsa_ctx **dsactx,
             const unsigned char *p,
             unsigned long p_len,
             const unsigned char *q,
             unsigned long q_len,
             const unsigned char *g,
             unsigned long g_len,
             const unsigned char *y,
             unsigned long y_len,
             const unsigned char *x,
             unsigned long x_len)
{
    int rc;

    if (x_len) {
        rc = gcry_sexp_build
            (dsactx, NULL,
             "(private-key(dsa(p%b)(q%b)(g%b)(y%b)(x%b)))",
             p_len, p, q_len, q, g_len, g, y_len, y, x_len, x);
    } else {
        rc = gcry_sexp_build (dsactx, NULL,
                      "(public-key(dsa(p%b)(q%b)(g%b)(y%b)))",
                      p_len, p, q_len, q, g_len, g, y_len, y);
    }

    if (rc) {
        *dsactx = NULL;
        return -1;
    }

    return 0;
}

int _libssh2_rsa_new_private (libssh2_rsa_ctx **rsa,
                  LIBSSH2_SESSION *session,
                  FILE *fp,
                  unsigned const char *passphrase)
{
    char *data, *save_data;
    unsigned int datalen;
    int ret;
    char *n, *e, *d, *p, *q, *e1, *e2, *coeff;
    unsigned int nlen, elen, dlen, plen, qlen, e1len, e2len, coefflen;

    (void)passphrase;

    ret = _libssh2_pem_parse (session,
                  "-----BEGIN RSA PRIVATE KEY-----",
                  "-----END RSA PRIVATE KEY-----",
                  fp, &data, &datalen);
    if (ret) {
        return -1;
    }

    save_data = data;

    if (_libssh2_pem_decode_sequence (&data, &datalen)) {
        ret = -1;
        goto fail;
    }
/* First read Version field (should be 0). */
    ret = _libssh2_pem_decode_integer (&data, &datalen, &n, &nlen);
    if (ret != 0 || (nlen != 1 && *n != '\0')) {
        ret = -1;
        goto fail;
    }

    ret = _libssh2_pem_decode_integer (&data, &datalen, &n, &nlen);
    if (ret != 0) {
        ret = -1;
        goto fail;
    }

    ret = _libssh2_pem_decode_integer (&data, &datalen, &e, &elen);
    if (ret != 0) {
        ret = -1;
        goto fail;
    }

    ret = _libssh2_pem_decode_integer (&data, &datalen, &d, &dlen);
    if (ret != 0) {
        ret = -1;
        goto fail;
    }

    ret = _libssh2_pem_decode_integer (&data, &datalen, &p, &plen);
    if (ret != 0) {
        ret = -1;
        goto fail;
    }

    ret = _libssh2_pem_decode_integer (&data, &datalen, &q, &qlen);
    if (ret != 0) {
        ret = -1;
        goto fail;
    }

    ret = _libssh2_pem_decode_integer (&data, &datalen, &e1, &e1len);
    if (ret != 0) {
        ret = -1;
        goto fail;
    }

    ret = _libssh2_pem_decode_integer (&data, &datalen, &e2, &e2len);
    if (ret != 0) {
        ret = -1;
        goto fail;
    }

    ret = _libssh2_pem_decode_integer (&data, &datalen, &coeff, &coefflen);
    if (ret != 0) {
        ret = -1;
        goto fail;
    }

    if (_libssh2_rsa_new (rsa, e, elen, n, nlen, d, dlen, p, plen,
                  q, qlen, e1, e1len, e2, e2len,
                  coeff, coefflen)) {
        ret = -1;
        goto fail;
    }

    ret = 0;

fail:
    LIBSSH2_FREE (session, save_data);
    return ret;
}

int _libssh2_dsa_new_private (libssh2_dsa_ctx **dsa,
                  LIBSSH2_SESSION *session,
                  FILE *fp,
                  unsigned const char *passphrase)
{
    char *data, *save_data;
    unsigned int datalen;
    int ret;
    char *p, *q, *g, *y, *x;
    unsigned int plen, qlen, glen, ylen, xlen;

    (void)passphrase;

    ret = _libssh2_pem_parse (session,
                  "-----BEGIN DSA PRIVATE KEY-----",
                  "-----END DSA PRIVATE KEY-----",
                  fp, &data, &datalen);
    if (ret) {
        return -1;
    }

    save_data = data;

    if (_libssh2_pem_decode_sequence (&data, &datalen)) {
        ret = -1;
        goto fail;
    }

/* First read Version field (should be 0). */
    ret = _libssh2_pem_decode_integer (&data, &datalen, &p, &plen);
    if (ret != 0 || (plen != 1 && *p != '\0')) {
        ret = -1;
        goto fail;
    }

    ret = _libssh2_pem_decode_integer (&data, &datalen, &p, &plen);
    if (ret != 0) {
        ret = -1;
        goto fail;
    }

    ret = _libssh2_pem_decode_integer (&data, &datalen, &q, &qlen);
    if (ret != 0) {
        ret = -1;
        goto fail;
    }

    ret = _libssh2_pem_decode_integer (&data, &datalen, &g, &glen);
    if (ret != 0) {
        ret = -1;
        goto fail;
    }

    ret = _libssh2_pem_decode_integer (&data, &datalen, &y, &ylen);
    if (ret != 0) {
        ret = -1;
        goto fail;
    }

    ret = _libssh2_pem_decode_integer (&data, &datalen, &x, &xlen);
    if (ret != 0) {
        ret = -1;
        goto fail;
    }

    if (datalen != 0) {
        ret = -1;
        goto fail;
    }

    if (_libssh2_dsa_new (dsa, p, plen, q, qlen,
                  g, glen, y, ylen, x, xlen)) {
        ret = -1;
        goto fail;
    }

    ret = 0;

fail:
    LIBSSH2_FREE (session, save_data);
    return ret;
}

int _libssh2_rsa_sha1_sign(LIBSSH2_SESSION *session,
               libssh2_dsa_ctx *rsactx,
               const unsigned char *hash,
               unsigned long hash_len,
               unsigned char **signature,
               unsigned long *signature_len)
{
    gcry_sexp_t sig_sexp;
    gcry_sexp_t data;
    int rc;
    const char *tmp;
    size_t size;

    if (hash_len != SHA_DIGEST_LENGTH) {
        return -1;
    }

    if (gcry_sexp_build (&data, NULL,
                 "(data (flags pkcs1) (hash sha1 %b))",
                 hash_len, hash)) {
        return -1;
    }

    rc = gcry_pk_sign (&sig_sexp, data, rsactx);

    gcry_sexp_release (data);

    if (rc != 0) {
        return -1;
    }

    data = gcry_sexp_find_token(sig_sexp, "s", 0);
    if (!data) {
        return -1;
    }

    tmp = gcry_sexp_nth_data(data, 1, &size);
    if (!tmp) {
        return -1;
    }

    if (tmp[0] == '\0') {
        tmp++;
        size--;
    }

    *signature = LIBSSH2_ALLOC(session, size);
    memcpy (*signature, tmp, size);
    *signature_len = size;

    return rc;
}

int _libssh2_dsa_sha1_sign(libssh2_dsa_ctx *dsactx,
               const unsigned char *hash,
               unsigned long hash_len,
               unsigned char *sig)
{
    unsigned char zhash[SHA_DIGEST_LENGTH+1];
    gcry_sexp_t sig_sexp;
    gcry_sexp_t data;
    int ret;
    const char *tmp;
    size_t size;

    if (hash_len != SHA_DIGEST_LENGTH) {
        return -1;
    }

    memcpy (zhash + 1, hash, hash_len);
    zhash[0] = 0;

    if (gcry_sexp_build (&data, NULL, "(data (value %b))",
                 hash_len + 1, zhash)) {
        return -1;
    }

    ret = gcry_pk_sign (&sig_sexp, data, dsactx);

    gcry_sexp_release (data);

    if (ret != 0) {
        return -1;
    }

/* Extract R. */

    data = gcry_sexp_find_token(sig_sexp, "r", 0);
    if (!data) {
        ret = -1;
        goto out;
    }

    tmp = gcry_sexp_nth_data(data, 1, &size);
    if (!tmp) {
        ret = -1;
        goto out;
    }

    if (tmp[0] == '\0') {
        tmp++;
        size--;
    }

    if (size != 20) {
        ret = -1;
        goto out;
    }

    memcpy (sig, tmp, 20);

    gcry_sexp_release (data);

/* Extract S. */

    data = gcry_sexp_find_token(sig_sexp, "s",0);
    if (!data) {
        ret = -1;
        goto out;
    }

    tmp = gcry_sexp_nth_data(data, 1, &size);
    if (!tmp) {
        ret = -1;
        goto out;
    }

    if (tmp[0] == '\0') {
        tmp++;
        size--;
    }

    if (size != 20) {
        ret = -1;
        goto out;
    }

    memcpy (sig + 20, tmp, 20);

    ret = 0;
out:
    if (sig_sexp) {
        gcry_sexp_release (sig_sexp);
    }
    if (data) {
        gcry_sexp_release (data);
    }
    return ret;
}

int _libssh2_dsa_sha1_verify(libssh2_dsa_ctx *dsactx,
                 const unsigned char *sig,
                 const unsigned char *m,
                 unsigned long m_len)
{
    unsigned char hash[SHA_DIGEST_LENGTH+1];
    gcry_sexp_t s_sig, s_hash;
    int rc = -1;

    libssh2_sha1(m, m_len, hash+1);
    hash[0] = 0;

    if (gcry_sexp_build (&s_hash, NULL, "(data(flags raw)(value %b))",
                 SHA_DIGEST_LENGTH+1, hash)) {
        return -1;
    }

    if (gcry_sexp_build (&s_sig, NULL, "(sig-val(dsa(r %b)(s %b)))",
                 20, sig, 20, sig + 20)) {
        gcry_sexp_release (s_hash);
        return -1;
    }

    rc = gcry_pk_verify (s_sig, s_hash, dsactx);
    gcry_sexp_release (s_sig);
    gcry_sexp_release (s_hash);

    return (rc == 0) ? 0 : -1;
}

int _libssh2_cipher_init (_libssh2_cipher_ctx *h,
              _libssh2_cipher_type(algo),
              unsigned char *iv,
              unsigned char *secret,
              int encrypt)
{
    int mode = 0, ret;
    int keylen = gcry_cipher_get_algo_keylen (algo);

    (void)encrypt;

    if (algo != GCRY_CIPHER_ARCFOUR) {
        mode = GCRY_CIPHER_MODE_CBC;
    }

    ret = gcry_cipher_open (h, algo, mode, 0);
    if (ret) {
        return -1;
    }

    ret = gcry_cipher_setkey (*h, secret, keylen);
    if (ret) {
        gcry_cipher_close (*h);
        return -1;
    }

    if (algo != GCRY_CIPHER_ARCFOUR) {
        int blklen = gcry_cipher_get_algo_blklen (algo);
        ret = gcry_cipher_setiv (*h, iv, blklen);
        if (ret) {
            gcry_cipher_close (*h);
            return -1;
        }
    }

    return 0;
}

int _libssh2_cipher_crypt(_libssh2_cipher_ctx *ctx,
              _libssh2_cipher_type(algo),
              int encrypt,
              unsigned char *block)
{
    size_t blklen = gcry_cipher_get_algo_blklen (algo);
    int ret;
    if (blklen == 1) {
/* Hack for arcfour. */
        blklen = 8;
    }

    if (encrypt) {
        ret = gcry_cipher_encrypt (*ctx, block, blklen,
                       block, blklen);
    } else {
        ret = gcry_cipher_decrypt (*ctx, block, blklen,
                       block, blklen);
    }
    return ret;
}