/*
* gnome-keyring
*
* Copyright (C) 2011 Collabora Ltd.
*
* This program 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.
*
* This program 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 this program; if not, see <http://www.gnu.org/licenses/>.
*
* Author: Stef Walter <stefw@collabora.co.uk>
*/
#include "config.h"
#include "gcr-openssh.h"
#include "gcr-internal.h"
#include "gcr-types.h"
#include "gcr/gcr-oids.h"
#include "egg/egg-asn1x.h"
#include "egg/egg-asn1-defs.h"
#include "egg/egg-buffer.h"
#include "egg/egg-decimal.h"
#include <p11-kit/pkcs11.h>
#include <string.h>
typedef struct {
GcrOpensshPubCallback callback;
gpointer user_data;
} OpensshPubClosure;
static void
skip_spaces (const gchar ** line,
gsize *n_line)
{
while (*n_line > 0 && (*line)[0] == ' ') {
(*line)++;
(*n_line)--;
}
}
static gboolean
next_word (const gchar **line,
gsize *n_line,
const gchar **word,
gsize *n_word)
{
const gchar *beg;
const gchar *end;
const gchar *at;
gboolean quotes;
skip_spaces (line, n_line);
if (!*n_line) {
*word = NULL;
*n_word = 0;
return FALSE;
}
beg = at = *line;
end = beg + *n_line;
quotes = FALSE;
do {
switch (*at) {
case '"':
quotes = !quotes;
at++;
break;
case ' ':
if (!quotes)
end = at;
else
at++;
break;
default:
at++;
break;
}
} while (at < end);
*word = beg;
*n_word = end - beg;
(*line) += *n_word;
(*n_line) -= *n_word;
return TRUE;
}
static gboolean
match_word (const gchar *word,
gsize n_word,
const gchar *matches)
{
gsize len = strlen (matches);
if (len != n_word)
return FALSE;
return memcmp (word, matches, n_word) == 0;
}
static gulong
keytype_to_algo (const gchar *algo,
gsize length)
{
if (!algo)
return G_MAXULONG;
else if (match_word (algo, length, "ssh-rsa"))
return CKK_RSA;
else if (match_word (algo, length, "ssh-dss"))
return CKK_DSA;
else if (length >= 6 && strncmp (algo, "ecdsa-", 6) == 0)
return CKK_ECDSA;
return G_MAXULONG;
}
static gboolean
read_decimal_mpi (const gchar *decimal,
gsize n_decimal,
GckBuilder *builder,
gulong attribute_type)
{
gpointer data;
gsize n_data;
data = egg_decimal_decode (decimal, n_decimal, &n_data);
if (data == NULL)
return FALSE;
gck_builder_add_data (builder, attribute_type, data, n_data);
g_free (data);
return TRUE;
}
static gint
atoin (const char *p, gint digits)
{
gint ret = 0, base = 1;
while(--digits >= 0) {
if (p[digits] < '0' || p[digits] > '9')
return -1;
ret += (p[digits] - '0') * base;
base *= 10;
}
return ret;
}
static GcrDataError
parse_v1_public_line (const gchar *line,
gsize length,
GBytes *backing,
GcrOpensshPubCallback callback,
gpointer user_data)
{
const gchar *word_bits, *word_exponent, *word_modulus, *word_options, *outer;
gsize len_bits, len_exponent, len_modulus, len_options, n_outer;
GckBuilder builder = GCK_BUILDER_INIT;
GckAttributes *attrs;
gchar *label, *options;
GBytes *bytes;
gint bits;
g_assert (line);
outer = line;
n_outer = length;
options = NULL;
label = NULL;
/* Eat space at the front */
skip_spaces (&line, &length);
/* Blank line or comment */
if (length == 0 || line[0] == '#')
return GCR_ERROR_UNRECOGNIZED;
/*
* If the line starts with a digit, then no options:
*
* 2048 35 25213680043....93533757 Label
*
* If the line doesn't start with a digit, then have options:
*
* option,option 2048 35 25213680043....93533757 Label
*/
if (g_ascii_isdigit (line[0])) {
word_options = NULL;
len_options = 0;
} else {
if (!next_word (&line, &length, &word_options, &len_options))
return GCR_ERROR_UNRECOGNIZED;
}
if (!next_word (&line, &length, &word_bits, &len_bits) ||
!next_word (&line, &length, &word_exponent, &len_exponent) ||
!next_word (&line, &length, &word_modulus, &len_modulus))
return GCR_ERROR_UNRECOGNIZED;
bits = atoin (word_bits, len_bits);
if (bits <= 0)
return GCR_ERROR_UNRECOGNIZED;
if (!read_decimal_mpi (word_exponent, len_exponent, &builder, CKA_PUBLIC_EXPONENT) ||
!read_decimal_mpi (word_modulus, len_modulus, &builder, CKA_MODULUS)) {
gck_builder_clear (&builder);
return GCR_ERROR_UNRECOGNIZED;
}
gck_builder_add_ulong (&builder, CKA_KEY_TYPE, CKK_RSA);
gck_builder_add_ulong (&builder, CKA_CLASS, CKO_PUBLIC_KEY);
skip_spaces (&line, &length);
if (length > 0) {
label = g_strndup (line, length);
g_strstrip (label);
gck_builder_add_string (&builder, CKA_LABEL, label);
}
if (word_options)
options = g_strndup (word_options, len_options);
attrs = gck_attributes_ref_sink (gck_builder_end (&builder));
if (callback != NULL) {
bytes = g_bytes_new_with_free_func (outer, n_outer,
(GDestroyNotify)g_bytes_unref,
g_bytes_ref (backing));
(callback) (attrs, label, options, bytes, user_data);
g_bytes_unref (bytes);
}
gck_attributes_unref (attrs);
g_free (options);
g_free (label);
return GCR_SUCCESS;
}
static gboolean
read_buffer_mpi_to_der (EggBuffer *buffer,
gsize *offset,
GckBuilder *builder,
gulong attribute_type)
{
const guchar *data, *data_value;
GBytes *der_data = NULL;
gsize len, data_len;
GNode *asn = NULL;
gboolean rv = FALSE;
if (!egg_buffer_get_byte_array (buffer, *offset, offset, &data, &len))
return FALSE;
asn = egg_asn1x_create (pk_asn1_tab, "ECPoint");
if (!asn)
return FALSE;
egg_asn1x_set_string_as_raw (asn, (guchar *)data, len, NULL);
der_data = egg_asn1x_encode (asn, g_realloc);
if (!der_data)
goto out;
data_value = g_bytes_get_data (der_data, &data_len);
gck_builder_add_data (builder, attribute_type, data_value, data_len);
rv = TRUE;
out:
g_bytes_unref (der_data);
egg_asn1x_destroy (asn);
return rv;
}
static gboolean
read_buffer_mpi (EggBuffer *buffer,
gsize *offset,
GckBuilder *builder,
gulong attribute_type)
{
const guchar *data;
gsize len;
if (!egg_buffer_get_byte_array (buffer, *offset, offset, &data, &len))
return FALSE;
gck_builder_add_data (builder, attribute_type, data, len);
return TRUE;
}
static gboolean
read_v2_public_dsa (EggBuffer *buffer,
gsize *offset,
GckBuilder *builder)
{
if (!read_buffer_mpi (buffer, offset, builder, CKA_PRIME) ||
!read_buffer_mpi (buffer, offset, builder, CKA_SUBPRIME) ||
!read_buffer_mpi (buffer, offset, builder, CKA_BASE) ||
!read_buffer_mpi (buffer, offset, builder, CKA_VALUE)) {
return FALSE;
}
gck_builder_add_ulong (builder, CKA_KEY_TYPE, CKK_DSA);
gck_builder_add_ulong (builder, CKA_CLASS, CKO_PUBLIC_KEY);
return TRUE;
}
static gboolean
read_v2_public_rsa (EggBuffer *buffer,
gsize *offset,
GckBuilder *builder)
{
if (!read_buffer_mpi (buffer, offset, builder, CKA_PUBLIC_EXPONENT) ||
!read_buffer_mpi (buffer, offset, builder, CKA_MODULUS)) {
return FALSE;
}
gck_builder_add_ulong (builder, CKA_KEY_TYPE, CKK_RSA);
gck_builder_add_ulong (builder, CKA_CLASS, CKO_PUBLIC_KEY);
return TRUE;
}
static gboolean
read_v2_public_ecdsa (EggBuffer *buffer,
gsize *offset,
GckBuilder *builder)
{
gconstpointer data;
GBytes *bytes;
GNode *asn;
GNode *node;
gchar *curve;
GQuark oid;
gsize len;
/* The named curve */
if (!egg_buffer_get_string (buffer, *offset, offset,
&curve, (EggBufferAllocator)g_realloc))
return FALSE;
if (g_strcmp0 (curve, "nistp256") == 0) {
oid = GCR_OID_EC_SECP256R1;
} else if (g_strcmp0 (curve, "nistp384") == 0) {
oid = GCR_OID_EC_SECP384R1;
} else if (g_strcmp0 (curve, "nistp521") == 0) {
oid = GCR_OID_EC_SECP521R1;
} else {
g_free (curve);
g_message ("unknown or unsupported curve in ssh public key");
return FALSE;
}
g_free (curve);
asn = egg_asn1x_create (pk_asn1_tab, "ECParameters");
g_return_val_if_fail (asn != NULL, FALSE);
node = egg_asn1x_node (asn, "namedCurve", NULL);
if (!egg_asn1x_set_choice (asn, node))
g_return_val_if_reached (FALSE);
if (!egg_asn1x_set_oid_as_quark (node, oid))
g_return_val_if_reached (FALSE);
bytes = egg_asn1x_encode (asn, g_realloc);
g_return_val_if_fail (bytes != NULL, FALSE);
egg_asn1x_destroy (asn);
data = g_bytes_get_data (bytes, &len);
gck_builder_add_data (builder, CKA_EC_PARAMS, data, len);
g_bytes_unref (bytes);
/* need to convert to DER encoded OCTET STRING */
if (!read_buffer_mpi_to_der (buffer, offset, builder, CKA_EC_POINT))
return FALSE;
gck_builder_add_ulong (builder, CKA_KEY_TYPE, CKK_ECDSA);
gck_builder_add_ulong (builder, CKA_CLASS, CKO_PUBLIC_KEY);
return TRUE;
}
static gboolean
read_v2_public_key (gulong algo,
gconstpointer data,
gsize n_data,
GckBuilder *builder)
{
EggBuffer buffer;
gboolean ret;
gsize offset;
gchar *stype;
int alg;
egg_buffer_init_static (&buffer, data, n_data);
offset = 0;
/* The string algorithm */
if (!egg_buffer_get_string (&buffer, offset, &offset,
&stype, (EggBufferAllocator)g_realloc))
return FALSE;
alg = keytype_to_algo (stype, stype ? strlen (stype) : 0);
g_free (stype);
if (alg != algo) {
g_message ("invalid or mis-matched algorithm in ssh public key: %s", stype);
egg_buffer_uninit (&buffer);
return FALSE;
}
switch (algo) {
case CKK_RSA:
ret = read_v2_public_rsa (&buffer, &offset, builder);
break;
case CKK_DSA:
ret = read_v2_public_dsa (&buffer, &offset, builder);
break;
case CKK_ECDSA:
ret = read_v2_public_ecdsa (&buffer, &offset, builder);
break;
default:
g_assert_not_reached ();
break;
}
egg_buffer_uninit (&buffer);
return ret;
}
static gboolean
decode_v2_public_key (gulong algo,
const gchar *data,
gsize n_data,
GckBuilder *builder)
{
gpointer decoded;
gsize n_decoded;
gboolean ret;
guint save;
gint state;
/* Decode the base64 key */
save = state = 0;
decoded = g_malloc (n_data * 3 / 4);
n_decoded = g_base64_decode_step ((gchar*)data, n_data, decoded, &state, &save);
if (!n_decoded) {
g_free (decoded);
return FALSE;
}
/* Parse the actual key */
ret = read_v2_public_key (algo, decoded, n_decoded, builder);
g_free (decoded);
return ret;
}
static GcrDataError
parse_v2_public_line (const gchar *line,
gsize length,
GBytes *backing,
GcrOpensshPubCallback callback,
gpointer user_data)
{
const gchar *word_options, *word_algo, *word_key;
gsize len_options, len_algo, len_key;
GckBuilder builder = GCK_BUILDER_INIT;
GckAttributes *attrs;
gchar *options;
gchar *label = NULL;
const gchar *outer = line;
gsize n_outer = length;
GBytes *bytes;
gulong algo;
g_assert (line);
/* Eat space at the front */
skip_spaces (&line, &length);
/* Blank line or comment */
if (length == 0 || line[0] == '#')
return GCR_ERROR_UNRECOGNIZED;
if (!next_word (&line, &length, &word_algo, &len_algo))
return GCR_ERROR_UNRECOGNIZED;
/*
* If the first word is not the algorithm, then we have options:
*
* option,option ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAI...EAz8Ji= Label here
*
* If the first word is the algorithm, then we have no options:
*
* ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAI...EAz8Ji= Label here
*/
algo = keytype_to_algo (word_algo, len_algo);
if (algo == G_MAXULONG) {
word_options = word_algo;
len_options = len_algo;
if (!next_word (&line, &length, &word_algo, &len_algo))
return GCR_ERROR_UNRECOGNIZED;
algo = keytype_to_algo (word_algo, len_algo);
if (algo == G_MAXULONG)
return GCR_ERROR_UNRECOGNIZED;
} else {
word_options = NULL;
len_options = 0;
}
/* Must have at least two words */
if (!next_word (&line, &length, &word_key, &len_key))
return GCR_ERROR_FAILURE;
if (!decode_v2_public_key (algo, word_key, len_key, &builder)) {
gck_builder_clear (&builder);
return GCR_ERROR_FAILURE;
}
if (word_options)
options = g_strndup (word_options, len_options);
else
options = NULL;
/* The remainder of the line is the label */
skip_spaces (&line, &length);
if (length > 0) {
label = g_strndup (line, length);
g_strstrip (label);
gck_builder_add_string (&builder, CKA_LABEL, label);
}
attrs = gck_attributes_ref_sink (gck_builder_end (&builder));
if (callback != NULL) {
bytes = g_bytes_new_with_free_func (outer, n_outer,
(GDestroyNotify)g_bytes_unref,
g_bytes_ref (backing));
(callback) (attrs, label, options, bytes, user_data);
g_bytes_unref (bytes);
}
gck_attributes_unref (attrs);
g_free (options);
g_free (label);
return GCR_SUCCESS;
}
guint
_gcr_openssh_pub_parse (GBytes *data,
GcrOpensshPubCallback callback,
gpointer user_data)
{
const gchar *line;
const gchar *end;
gsize length;
gboolean last;
GcrDataError res;
guint num_parsed;
g_return_val_if_fail (data != NULL, FALSE);
line = g_bytes_get_data (data, NULL);
length = g_bytes_get_size (data);
last = FALSE;
num_parsed = 0;
for (;;) {
end = memchr (line, '\n', length);
if (end == NULL) {
end = line + length;
last = TRUE;
}
if (line != end) {
res = parse_v2_public_line (line, end - line, data, callback, user_data);
if (res == GCR_ERROR_UNRECOGNIZED)
res = parse_v1_public_line (line, end - line, data, callback, user_data);
if (res == GCR_SUCCESS)
num_parsed++;
}
if (last)
break;
end++;
length -= (end - line);
line = end;
}
return num_parsed;
}