/*

 * pki_gcrypt.c private and public key handling using gcrypt.

 *

 * This file is part of the SSH Library

 *

 * Copyright (c) 2003-2009 Aris Adamantiadis

 * Copyright (c) 2009-2011 Andreas Schneider <asn@cryptomilk.org>

 * Copyright (C) 2016 g10 Code GmbH

 *

 * The SSH Library is free software; you can redistribute it and/or modify

 * it under the terms of the GNU Lesser General Public License as published by

 * the Free Software Foundation; either version 2.1 of the License, or (at your

 * option) any later version.

 *

 * The SSH Library is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY

 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public

 * License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with the SSH Library; see the file COPYING.  If not, write to

 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,

 * MA 02111-1307, USA.

 */

#include "config.h"

#ifdef HAVE_LIBGCRYPT

#include <assert.h>

#include <stdbool.h>

#include <string.h>

#include <stdlib.h>

#include <gcrypt.h>

#include <stdio.h>

#include "libssh/priv.h"

#include "libssh/buffer.h"

#include "libssh/session.h"

#include "libssh/wrapper.h"

#include "libssh/misc.h"

#include "libssh/pki.h"

#include "libssh/pki_priv.h"

#define MAXLINESIZE 80

#define RSA_HEADER_BEGIN "-----BEGIN RSA PRIVATE KEY-----"

#define RSA_HEADER_END "-----END RSA PRIVATE KEY-----"

#define DSA_HEADER_BEGIN "-----BEGIN DSA PRIVATE KEY-----"

#define DSA_HEADER_END "-----END DSA PRIVATE KEY-----"

#define ECDSA_HEADER_BEGIN "-----BEGIN EC PRIVATE KEY-----"

#define ECDSA_HEADER_END "-----END EC PRIVATE KEY-----"

#define MAX_KEY_SIZE 32

#define MAX_PASSPHRASE_SIZE 1024

#define ASN1_INTEGER 2

#define ASN1_BIT_STRING 3

#define ASN1_OCTET_STRING 4

#define ASN1_OBJECT_IDENTIFIER 6

#define ASN1_SEQUENCE 48

#define PKCS5_SALT_LEN 8

static int load_iv(const char *header, unsigned char *iv, int iv_len) {

  int i;

  int j;

  int k;

  memset(iv, 0, iv_len);

  for (i = 0; i < iv_len; i++) {

    if ((header[2*i] >= '0') && (header[2*i] <= '9'))

      j = header[2*i] - '0';

    else if ((header[2*i] >= 'A') && (header[2*i] <= 'F'))

      j = header[2*i] - 'A' + 10;

    else if ((header[2*i] >= 'a') && (header[2*i] <= 'f'))

      j = header[2*i] - 'a' + 10;

    else

      return -1;

    if ((header[2*i+1] >= '0') && (header[2*i+1] <= '9'))

      k = header[2*i+1] - '0';

    else if ((header[2*i+1] >= 'A') && (header[2*i+1] <= 'F'))

      k = header[2*i+1] - 'A' + 10;

    else if ((header[2*i+1] >= 'a') && (header[2*i+1] <= 'f'))

      k = header[2*i+1] - 'a' + 10;

    else

      return -1;

    iv[i] = (j << 4) + k;

  }

  return 0;

}

static uint32_t char_to_u32(unsigned char *data, uint32_t size) {

  uint32_t ret;

  uint32_t i;

  for (i = 0, ret = 0; i < size; ret = ret << 8, ret += data[i++])

    ;

  return ret;

}

static uint32_t asn1_get_len(ssh_buffer buffer) {

  uint32_t len;

  unsigned char tmp[4];

  if (ssh_buffer_get_data(buffer,tmp,1) == 0) {

    return 0;

  }

  if (tmp[0] > 127) {

    len = tmp[0] & 127;

    if (len > 4) {

      return 0; /* Length doesn't fit in u32. Can this really happen? */

    }

    if (ssh_buffer_get_data(buffer,tmp,len) == 0) {

      return 0;

    }

    len = char_to_u32(tmp, len);

  } else {

    len = char_to_u32(tmp, 1);

  }

  return len;

}

static ssh_string asn1_get(ssh_buffer buffer, unsigned char want) {

  ssh_string str;

  unsigned char type;

  uint32_t size;

  if (ssh_buffer_get_data(buffer, &type, 1) == 0 || type != want) {

    return NULL;

  }

  size = asn1_get_len(buffer);

  if (size == 0) {

    return NULL;

  }

  str = ssh_string_new(size);

  if (str == NULL) {

    return NULL;

  }

  if (ssh_buffer_get_data(buffer, ssh_string_data(str), size) == 0) {

    SSH_STRING_FREE(str);

    return NULL;

  }

  return str;

}

static ssh_string asn1_get_int(ssh_buffer buffer) {

  return asn1_get(buffer, ASN1_INTEGER);

}

static ssh_string asn1_get_bit_string(ssh_buffer buffer)

{

    ssh_string str;

    unsigned char type;

    uint32_t size;

    unsigned char unused, last, *p;

    uint32_t len;

    len = ssh_buffer_get_data(buffer, &type, 1);

    if (len == 0 || type != ASN1_BIT_STRING) {

        return NULL;

    }

    size = asn1_get_len(buffer);

    if (size == 0) {

        return NULL;

    }

    /* The first octet encodes the number of unused bits.  */

    size -= 1;

    str = ssh_string_new(size);

    if (str == NULL) {

        return NULL;

    }

    len = ssh_buffer_get_data(buffer, &unused, 1);

    if (len == 0) {

        SSH_STRING_FREE(str);

        return NULL;

    }

    if (unused == 0) {

        len = ssh_buffer_get_data(buffer, ssh_string_data(str), size);

        if (len == 0) {

            SSH_STRING_FREE(str);

            return NULL;

        }

        return str;

    }

    /* The bit string is padded at the end, we must shift the whole

       string by UNUSED bits.  */

    for (p = ssh_string_data(str), last = 0; size; size--, p++) {

        unsigned char c;

        len = ssh_buffer_get_data(buffer, &c, 1);

        if (len == 0) {

            SSH_STRING_FREE(str);

            return NULL;

        }

        *p = last | (c >> unused);

        last = c << (8 - unused);

    }

    return str;

}

static int asn1_check_sequence(ssh_buffer buffer) {

  unsigned char *j = NULL;

  unsigned char tmp;

  int i;

  uint32_t size;

  uint32_t padding;

  if (ssh_buffer_get_data(buffer, &tmp, 1) == 0 || tmp != ASN1_SEQUENCE) {

    return 0;

  }

  size = asn1_get_len(buffer);

  if ((padding = ssh_buffer_get_len(buffer) - size) > 0) {

    for (i = ssh_buffer_get_len(buffer) - size,

         j = (unsigned char*)ssh_buffer_get(buffer) + size;

         i;

         i--, j++)

    {

      if (*j != padding) {                   /* padding is allowed */

        return 0;                            /* but nothing else */

      }

    }

  }

  return 1;

}

static int asn1_check_tag(ssh_buffer buffer, unsigned char tag) {

    unsigned char tmp;

    uint32_t len;

    len = ssh_buffer_get_data(buffer, &tmp, 1);

    if (len == 0 || tmp != tag) {

        return 0;

    }

    (void) asn1_get_len(buffer);

    return 1;

}

static int passphrase_to_key(char *data, unsigned int datalen,

    unsigned char *salt, unsigned char *key, unsigned int keylen) {

  MD5CTX md;

  unsigned char digest[MD5_DIGEST_LEN] = {0};

  unsigned int i;

  unsigned int j;

  unsigned int md_not_empty;

  for (j = 0, md_not_empty = 0; j < keylen; ) {

    md = md5_init();

    if (md == NULL) {

      return -1;

    }

    if (md_not_empty) {

      md5_update(md, digest, MD5_DIGEST_LEN);

    } else {

      md_not_empty = 1;

    }

    md5_update(md, data, datalen);

    if (salt) {

      md5_update(md, salt, PKCS5_SALT_LEN);

    }

    md5_final(digest, md);

    for (i = 0; j < keylen && i < MD5_DIGEST_LEN; j++, i++) {

      if (key) {

        key[j] = digest[i];

      }

    }

  }

  return 0;

}

static int privatekey_decrypt(int algo, int mode, unsigned int key_len,

                       unsigned char *iv, unsigned int iv_len,

                       ssh_buffer data, ssh_auth_callback cb,

                       void *userdata,

                       const char *desc)

{

  char passphrase[MAX_PASSPHRASE_SIZE] = {0};

  unsigned char key[MAX_KEY_SIZE] = {0};

  unsigned char *tmp = NULL;

  gcry_cipher_hd_t cipher;

  int rc = -1;

  if (!algo) {

    return -1;

  }

  if (cb) {

    rc = (*cb)(desc, passphrase, MAX_PASSPHRASE_SIZE, 0, 0, userdata);

    if (rc < 0) {

      return -1;

    }

  } else if (cb == NULL && userdata != NULL) {

    snprintf(passphrase, MAX_PASSPHRASE_SIZE, "%s", (char *) userdata);

  }

  if (passphrase_to_key(passphrase, strlen(passphrase), iv, key, key_len) < 0) {

    return -1;

  }

  if (gcry_cipher_open(&cipher, algo, mode, 0)

      || gcry_cipher_setkey(cipher, key, key_len)

      || gcry_cipher_setiv(cipher, iv, iv_len)

      || (tmp = calloc(ssh_buffer_get_len(data), sizeof(unsigned char))) == NULL

      || gcry_cipher_decrypt(cipher, tmp, ssh_buffer_get_len(data),

                       ssh_buffer_get(data), ssh_buffer_get_len(data))) {

    gcry_cipher_close(cipher);

    return -1;

  }

  memcpy(ssh_buffer_get(data), tmp, ssh_buffer_get_len(data));

  SAFE_FREE(tmp);

  gcry_cipher_close(cipher);

  return 0;

}

static int privatekey_dek_header(const char *header, unsigned int header_len,

    int *algo, int *mode, unsigned int *key_len, unsigned char **iv,

    unsigned int *iv_len) {

  unsigned int iv_pos;

  if (header_len > 13 && !strncmp("DES-EDE3-CBC", header, 12))

  {

    *algo = GCRY_CIPHER_3DES;

    iv_pos = 13;

    *mode = GCRY_CIPHER_MODE_CBC;

    *key_len = 24;

    *iv_len = 8;

  }

  else if (header_len > 8 && !strncmp("DES-CBC", header, 7))

  {

    *algo = GCRY_CIPHER_DES;

    iv_pos = 8;

    *mode = GCRY_CIPHER_MODE_CBC;

    *key_len = 8;

    *iv_len = 8;

  }

  else if (header_len > 12 && !strncmp("AES-128-CBC", header, 11))

  {

    *algo = GCRY_CIPHER_AES128;

    iv_pos = 12;

    *mode = GCRY_CIPHER_MODE_CBC;

    *key_len = 16;

    *iv_len = 16;

  }

  else if (header_len > 12 && !strncmp("AES-192-CBC", header, 11))

  {

    *algo = GCRY_CIPHER_AES192;

    iv_pos = 12;

    *mode = GCRY_CIPHER_MODE_CBC;

    *key_len = 24;

    *iv_len = 16;

  }

  else if (header_len > 12 && !strncmp("AES-256-CBC", header, 11))

  {

    *algo = GCRY_CIPHER_AES256;

    iv_pos = 12;

    *mode = GCRY_CIPHER_MODE_CBC;

    *key_len = 32;

    *iv_len = 16;

  } else {

    return -1;

  }

  *iv = malloc(*iv_len);

  if (*iv == NULL) {

    return -1;

  }

  return load_iv(header + iv_pos, *iv, *iv_len);

}

#define get_next_line(p, len) {                                         \

        while(p[len] == '\n' || p[len] == '\r') /* skip empty lines */  \

            len++;                                                      \

        if(p[len] == '\0')    /* EOL */                                 \

            eol = true;                                                 \

        else                  /* calculate length */                    \

            for(p += len, len = 0; p[len] && p[len] != '\n'             \

                                          && p[len] != '\r'; len++);    \

    }

static ssh_buffer privatekey_string_to_buffer(const char *pkey, int type,

                ssh_auth_callback cb, void *userdata, const char *desc) {

    ssh_buffer buffer = NULL;

    ssh_buffer out = NULL;

    const char *p;

    unsigned char *iv = NULL;

    const char *header_begin;

    const char *header_end;

    unsigned int header_begin_size;

    unsigned int header_end_size;

    unsigned int key_len = 0;

    unsigned int iv_len = 0;

    int algo = 0;

    int mode = 0;

    bool eol = false;

    size_t len;

    buffer = ssh_buffer_new();

    if (buffer == NULL) {

        return NULL;

    }

    switch(type) {

        case SSH_KEYTYPE_DSS:

            header_begin = DSA_HEADER_BEGIN;

            header_end = DSA_HEADER_END;

            break;

        case SSH_KEYTYPE_RSA:

            header_begin = RSA_HEADER_BEGIN;

            header_end = RSA_HEADER_END;

            break;

        case SSH_KEYTYPE_ECDSA_P256:

        case SSH_KEYTYPE_ECDSA_P384:

        case SSH_KEYTYPE_ECDSA_P521:

            header_begin = ECDSA_HEADER_BEGIN;

            header_end = ECDSA_HEADER_END;

            break;

        default:

            SSH_BUFFER_FREE(buffer);

            return NULL;

    }

    header_begin_size = strlen(header_begin);

    header_end_size = strlen(header_end);

    p = pkey;

    len = 0;

    get_next_line(p, len);

    while(!eol && strncmp(p, header_begin, header_begin_size)) {

        /* skip line */

        get_next_line(p, len);

    }

    if (eol) {

        SSH_BUFFER_FREE(buffer);

        return NULL;

    }

    /* skip header line */

    get_next_line(p, len);

    if (eol) {

        SSH_BUFFER_FREE(buffer);

        return NULL;

    }

    if (len > 11 && strncmp("Proc-Type: 4,ENCRYPTED", p, 11) == 0) {

        /* skip line */

        get_next_line(p, len);

        if (eol) {

            SSH_BUFFER_FREE(buffer);

            return NULL;

        }

        if (len > 10 && strncmp("DEK-Info: ", p, 10) == 0) {

            p += 10;

            len = 0;

            get_next_line(p, len);

            if (eol) {

                SSH_BUFFER_FREE(buffer);

                return NULL;

            }

            if (privatekey_dek_header(p, len, &algo, &mode, &key_len,

                        &iv, &iv_len) < 0) {

                SSH_BUFFER_FREE(buffer);

                SAFE_FREE(iv);

                return NULL;

            }

        } else {

            SSH_BUFFER_FREE(buffer);

            SAFE_FREE(iv);

            return NULL;

        }

    } else {

        if(len > 0) {

            if (ssh_buffer_add_data(buffer, p, len) < 0) {

                SSH_BUFFER_FREE(buffer);

                SAFE_FREE(iv);

                return NULL;

            }

        }

    }

    get_next_line(p, len);

    while(!eol && strncmp(p, header_end, header_end_size) != 0) {

        if (ssh_buffer_add_data(buffer, p, len) < 0) {

            SSH_BUFFER_FREE(buffer);

            SAFE_FREE(iv);

            return NULL;

        }

        get_next_line(p, len);

    }

    if (eol || strncmp(p, header_end, header_end_size) != 0) {

        SSH_BUFFER_FREE(buffer);

        SAFE_FREE(iv);

        return NULL;

    }

    if (ssh_buffer_add_data(buffer, "\0", 1) < 0) {

        SSH_BUFFER_FREE(buffer);

        SAFE_FREE(iv);

        return NULL;

    }

    out = base64_to_bin(ssh_buffer_get(buffer));

    SSH_BUFFER_FREE(buffer);

    if (out == NULL) {

        SAFE_FREE(iv);

        return NULL;

    }

    if (algo) {

        if (privatekey_decrypt(algo, mode, key_len, iv, iv_len, out,

                    cb, userdata, desc) < 0) {

            SSH_BUFFER_FREE(out);

            SAFE_FREE(iv);

            return NULL;

        }

    }

    SAFE_FREE(iv);

    return out;

}

static int b64decode_rsa_privatekey(const char *pkey, gcry_sexp_t *r,

    ssh_auth_callback cb, void *userdata, const char *desc) {

  const unsigned char *data;

  ssh_string n = NULL;

  ssh_string e = NULL;

  ssh_string d = NULL;

  ssh_string p = NULL;

  ssh_string q = NULL;

  ssh_string unused1 = NULL;

  ssh_string unused2 = NULL;

  ssh_string u = NULL;

  ssh_string v = NULL;

  ssh_buffer buffer = NULL;

  int rc = 1;

  buffer = privatekey_string_to_buffer(pkey, SSH_KEYTYPE_RSA, cb, userdata, desc);

  if (buffer == NULL) {

    return 0;

  }

  if (!asn1_check_sequence(buffer)) {

    SSH_BUFFER_FREE(buffer);

    return 0;

  }

  v = asn1_get_int(buffer);

  if (v == NULL) {

    SSH_BUFFER_FREE(buffer);

    return 0;

  }

  data = ssh_string_data(v);

  if (ssh_string_len(v) != 1 || data[0] != 0) {

    SSH_STRING_FREE(v);

    SSH_BUFFER_FREE(buffer);

    return 0;

  }

  n = asn1_get_int(buffer);

  e = asn1_get_int(buffer);

  d = asn1_get_int(buffer);

  q = asn1_get_int(buffer);

  p = asn1_get_int(buffer);

  unused1 = asn1_get_int(buffer);

  unused2 = asn1_get_int(buffer);

  u = asn1_get_int(buffer);

  SSH_BUFFER_FREE(buffer);

  if (n == NULL || e == NULL || d == NULL || p == NULL || q == NULL ||

      unused1 == NULL || unused2 == NULL|| u == NULL) {

    rc = 0;

    goto error;

  }

  if (gcry_sexp_build(r, NULL,

      "(private-key(rsa(n %b)(e %b)(d %b)(p %b)(q %b)(u %b)))",

      ssh_string_len(n), ssh_string_data(n),

      ssh_string_len(e), ssh_string_data(e),

      ssh_string_len(d), ssh_string_data(d),

      ssh_string_len(p), ssh_string_data(p),

      ssh_string_len(q), ssh_string_data(q),

      ssh_string_len(u), ssh_string_data(u))) {

    rc = 0;

  }

error:

  ssh_string_burn(n);

  SSH_STRING_FREE(n);

  ssh_string_burn(e);

  SSH_STRING_FREE(e);

  ssh_string_burn(d);

  SSH_STRING_FREE(d);

  ssh_string_burn(p);

  SSH_STRING_FREE(p);

  ssh_string_burn(q);

  SSH_STRING_FREE(q);

  SSH_STRING_FREE(unused1);

  SSH_STRING_FREE(unused2);

  ssh_string_burn(u);

  SSH_STRING_FREE(u);

  SSH_STRING_FREE(v);

  return rc;

}

static int b64decode_dsa_privatekey(const char *pkey, gcry_sexp_t *r, ssh_auth_callback cb,

    void *userdata, const char *desc) {

  const unsigned char *data;

  ssh_buffer buffer = NULL;

  ssh_string p = NULL;

  ssh_string q = NULL;

  ssh_string g = NULL;

  ssh_string y = NULL;

  ssh_string x = NULL;

  ssh_string v = NULL;

  int rc = 1;

  buffer = privatekey_string_to_buffer(pkey, SSH_KEYTYPE_DSS, cb, userdata, desc);

  if (buffer == NULL) {

    return 0;

  }

  if (!asn1_check_sequence(buffer)) {

    SSH_BUFFER_FREE(buffer);

    return 0;

  }

  v = asn1_get_int(buffer);

  if (v == NULL) {

    SSH_BUFFER_FREE(buffer);

    return 0;

  }

  data = ssh_string_data(v);

  if (ssh_string_len(v) != 1 || data[0] != 0) {

    SSH_STRING_FREE(v);

    SSH_BUFFER_FREE(buffer);

    return 0;

  }

  p = asn1_get_int(buffer);

  q = asn1_get_int(buffer);

  g = asn1_get_int(buffer);

  y = asn1_get_int(buffer);

  x = asn1_get_int(buffer);

  SSH_BUFFER_FREE(buffer);

  if (p == NULL || q == NULL || g == NULL || y == NULL || x == NULL) {

    rc = 0;

    goto error;

  }

  if (gcry_sexp_build(r, NULL,

        "(private-key(dsa(p %b)(q %b)(g %b)(y %b)(x %b)))",

        ssh_string_len(p), ssh_string_data(p),

        ssh_string_len(q), ssh_string_data(q),

        ssh_string_len(g), ssh_string_data(g),

        ssh_string_len(y), ssh_string_data(y),

        ssh_string_len(x), ssh_string_data(x))) {

    rc = 0;

  }

error:

  ssh_string_burn(p);

  SSH_STRING_FREE(p);

  ssh_string_burn(q);

  SSH_STRING_FREE(q);

  ssh_string_burn(g);

  SSH_STRING_FREE(g);

  ssh_string_burn(y);

  SSH_STRING_FREE(y);

  ssh_string_burn(x);

  SSH_STRING_FREE(x);

  SSH_STRING_FREE(v);

  return rc;

}

#ifdef HAVE_GCRYPT_ECC

static int pki_key_ecdsa_to_nid(gcry_sexp_t k)

{

    gcry_sexp_t sexp;

    const char *tmp;

    size_t size;

    sexp = gcry_sexp_find_token(k, "curve", 0);

    if (sexp == NULL) {

        return -1;

    }

    tmp = gcry_sexp_nth_data(sexp, 1, &size);

    if (size == 10) {

        int cmp;

        cmp = memcmp("NIST P-256", tmp, size);

        if (cmp == 0) {

            gcry_sexp_release(sexp);

            return NID_gcrypt_nistp256;

        }

        cmp = memcmp("NIST P-384", tmp, size);

        if (cmp == 0) {

            gcry_sexp_release(sexp);

            return NID_gcrypt_nistp384;

        }

        cmp = memcmp("NIST P-521", tmp, size);

        if (cmp == 0) {

            gcry_sexp_release(sexp);

            return NID_gcrypt_nistp521;

        }

    }

    gcry_sexp_release(sexp);

    return -1;

}

static enum ssh_keytypes_e pki_key_ecdsa_to_key_type(gcry_sexp_t k)

{

    int nid;

    nid = pki_key_ecdsa_to_nid(k);

    switch (nid) {

        case NID_gcrypt_nistp256:

            return SSH_KEYTYPE_ECDSA_P256;

        case NID_gcrypt_nistp384:

            return SSH_KEYTYPE_ECDSA_P384;

        case NID_gcrypt_nistp521:

            return SSH_KEYTYPE_ECDSA_P521;

        default:

            return SSH_KEYTYPE_UNKNOWN;

    }

}

static const char *pki_key_ecdsa_nid_to_gcrypt_name(int nid)

{

    switch (nid) {

    case NID_gcrypt_nistp256:

        return "NIST P-256";

    case NID_gcrypt_nistp384:

        return "NIST P-384";

    case NID_gcrypt_nistp521:

        return "NIST P-521";

    }

    return "unknown";

}

const char *pki_key_ecdsa_nid_to_name(int nid)

{

    switch (nid) {

    case NID_gcrypt_nistp256:

        return "ecdsa-sha2-nistp256";

    case NID_gcrypt_nistp384:

        return "ecdsa-sha2-nistp384";

    case NID_gcrypt_nistp521:

        return "ecdsa-sha2-nistp521";

    }

    return "unknown";

}

static const char *pki_key_ecdsa_nid_to_char(int nid)

{

    switch (nid) {

    case NID_gcrypt_nistp256:

        return "nistp256";

    case NID_gcrypt_nistp384:

        return "nistp384";

    case NID_gcrypt_nistp521:

        return "nistp521";

    default:

        break;

    }

    return "unknown";

}

int pki_key_ecdsa_nid_from_name(const char *name)

{

    int cmp;

    cmp = strcmp(name, "nistp256");

    if (cmp == 0) {

        return NID_gcrypt_nistp256;

    }

    cmp = strcmp(name, "nistp384");

    if (cmp == 0) {

        return NID_gcrypt_nistp384;

    }

    cmp = strcmp(name, "nistp521");

    if (cmp == 0) {

        return NID_gcrypt_nistp521;

    }

    return -1;

}

static int asn1_oi_to_nid(const ssh_string oi)

{

    static const struct {

        int nid;

        size_t length;

        const char *identifier;

    } *e, mapping[] = {

        {NID_gcrypt_nistp256, 8, "\x2a\x86\x48\xce\x3d\x03\x01\x07"},

        {NID_gcrypt_nistp384, 5, "\x2b\x81\x04\x00\x22"},

        {NID_gcrypt_nistp521, 5, "\x2b\x81\x04\x00\x23"},

        {0},

    };

    size_t len = ssh_string_len(oi);

    for (e = mapping; e->length; e++) {

        if (len == e->length

            && memcmp(ssh_string_data(oi), e->identifier, len) == 0) {

            return e->nid;

        }

    }

    return -1;

}

static int b64decode_ecdsa_privatekey(const char *pkey, gcry_sexp_t *r,

                                      ssh_auth_callback cb,

                                      void *userdata,

                                      const char *desc)

{

    const unsigned char *data;

    ssh_buffer buffer = NULL;

    gcry_error_t err = 0;

    ssh_string v = NULL;

    ssh_string d = NULL;

    ssh_string oi = NULL;

    int nid;

    ssh_string q = NULL;

    int valid = 0;

    int ok;

    buffer = privatekey_string_to_buffer(pkey,

                                         SSH_KEYTYPE_ECDSA_P256,

                                         cb,

                                         userdata,

                                         desc);

    if (buffer == NULL) {

        goto error;

    }

    ok = asn1_check_sequence(buffer);

    if (!ok) {

        goto error;

    }

    /* RFC5915 specifies version 1.  */

    v = asn1_get_int(buffer);