/*
* gnome-keyring
*
* Copyright (C) 2008 Stefan Walter
*
* 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
* .
*/
#include "config.h"
#include "gkm-attributes.h"
#include "gkm-data-der.h"
#include "gkm-util.h"
#include "egg/egg-timegm.h"
#include
#include
#include
#include
CK_RV
gkm_attribute_get_bool (CK_ATTRIBUTE_PTR attr, gboolean *value)
{
CK_BBOOL* booly;
g_return_val_if_fail (attr, CKR_GENERAL_ERROR);
g_return_val_if_fail (value, CKR_GENERAL_ERROR);
if (attr->ulValueLen != sizeof (CK_BBOOL) || attr->pValue == NULL)
return CKR_ATTRIBUTE_VALUE_INVALID;
booly = attr->pValue;
*value = *booly ? TRUE : FALSE;
return CKR_OK;
}
CK_RV
gkm_attribute_get_ulong (CK_ATTRIBUTE_PTR attr, CK_ULONG *value)
{
CK_ULONG* ulong;
g_return_val_if_fail (attr, CKR_GENERAL_ERROR);
g_return_val_if_fail (value, CKR_GENERAL_ERROR);
if (attr->ulValueLen != sizeof (CK_ULONG) || attr->pValue == NULL)
return CKR_ATTRIBUTE_VALUE_INVALID;
ulong = attr->pValue;
*value = *ulong;
return CKR_OK;
}
CK_RV
gkm_attribute_get_time (CK_ATTRIBUTE_PTR attr, glong *when)
{
struct tm tm;
gchar buf[15];
time_t time;
g_return_val_if_fail (attr, CKR_GENERAL_ERROR);
g_return_val_if_fail (when, CKR_GENERAL_ERROR);
if (attr->ulValueLen == 0) {
*when = (glong)-1;
return CKR_OK;
}
if (!attr->pValue || attr->ulValueLen != 16)
return CKR_ATTRIBUTE_VALUE_INVALID;
memset (&tm, 0, sizeof (tm));
memcpy (buf, attr->pValue, 14);
buf[14] = 0;
if (!strptime(buf, "%Y%m%d%H%M%S", &tm))
return CKR_ATTRIBUTE_VALUE_INVALID;
/* Convert to seconds since epoch */
time = timegm (&tm);
if (time < 0)
return CKR_ATTRIBUTE_VALUE_INVALID;
*when = time;
return CKR_OK;
}
CK_RV
gkm_attribute_get_string (CK_ATTRIBUTE_PTR attr, gchar **value)
{
g_return_val_if_fail (attr, CKR_GENERAL_ERROR);
g_return_val_if_fail (value, CKR_GENERAL_ERROR);
if (attr->ulValueLen == 0) {
*value = NULL;
return CKR_OK;
}
if (!attr->pValue)
return CKR_ATTRIBUTE_VALUE_INVALID;
if (!g_utf8_validate (attr->pValue, attr->ulValueLen, NULL))
return CKR_ATTRIBUTE_VALUE_INVALID;
*value = g_strndup (attr->pValue, attr->ulValueLen);
return CKR_OK;
}
CK_RV
gkm_attribute_get_bytes (CK_ATTRIBUTE_PTR attr, GBytes **value)
{
g_return_val_if_fail (attr, CKR_GENERAL_ERROR);
g_return_val_if_fail (value, CKR_GENERAL_ERROR);
if (attr->ulValueLen == 0) {
*value = NULL;
return CKR_OK;
}
if (!attr->pValue)
return CKR_ATTRIBUTE_VALUE_INVALID;
*value = g_bytes_new (attr->pValue, attr->ulValueLen);
return CKR_OK;
}
CK_RV
gkm_attribute_get_mpi (CK_ATTRIBUTE_PTR attr, gcry_mpi_t *value)
{
gcry_error_t gcry;
g_return_val_if_fail (attr, CKR_GENERAL_ERROR);
g_return_val_if_fail (value, CKR_GENERAL_ERROR);
gcry = gcry_mpi_scan (value, GCRYMPI_FMT_USG, attr->pValue, attr->ulValueLen, NULL);
if (gcry != 0)
return CKR_ATTRIBUTE_VALUE_INVALID;
return CKR_OK;
}
CK_RV
gkm_attribute_get_template (CK_ATTRIBUTE_PTR attr, GArray **template)
{
CK_ULONG n_attrs;
g_return_val_if_fail (attr, CKR_GENERAL_ERROR);
g_return_val_if_fail (attr, CKR_GENERAL_ERROR);
/* Validate everything first */
if (attr->ulValueLen % sizeof (CK_ATTRIBUTE) != 0)
return CKR_ATTRIBUTE_VALUE_INVALID;
n_attrs = attr->ulValueLen / sizeof (CK_ATTRIBUTE);
if (n_attrs != 0 && !attr->pValue)
return CKR_ATTRIBUTE_VALUE_INVALID;
*template = gkm_template_new (attr->pValue, n_attrs);
return CKR_OK;
}
CK_RV
gkm_attribute_set_empty (CK_ATTRIBUTE_PTR attr)
{
return gkm_attribute_set_data (attr, "", 0);
}
CK_RV
gkm_attribute_set_bool (CK_ATTRIBUTE_PTR attr, CK_BBOOL value)
{
return gkm_attribute_set_data (attr, &value, sizeof (CK_BBOOL));
}
CK_RV
gkm_attribute_set_ulong (CK_ATTRIBUTE_PTR attr, CK_ULONG value)
{
return gkm_attribute_set_data (attr, &value, sizeof (CK_ULONG));
}
CK_RV
gkm_attribute_set_string (CK_ATTRIBUTE_PTR attr, const gchar* string)
{
return gkm_attribute_set_data (attr, (CK_VOID_PTR)string,
string ? strlen (string) : 0);
}
CK_RV
gkm_attribute_set_date (CK_ATTRIBUTE_PTR attr, time_t time)
{
CK_DATE date;
struct tm tm;
gchar buf[16];
/* 'Empty' date as defined in PKCS#11 */
if (time == (time_t)-1)
return gkm_attribute_set_data (attr, NULL, 0);
if (!attr->pValue) {
attr->ulValueLen = sizeof (CK_DATE);
return CKR_OK;
}
if (!gmtime_r (&time, &tm))
g_return_val_if_reached (CKR_GENERAL_ERROR);
g_assert (sizeof (date.year) == 4);
if (G_UNLIKELY (snprintf ((char*)buf, 5, "%04d", 1900 + tm.tm_year) < 0))
abort ();
memcpy (date.year, buf, 4);
g_assert (sizeof (date.month) == 2);
if (G_UNLIKELY (snprintf ((char*)buf, 3, "%02d", tm.tm_mon + 1) < 0))
abort ();
memcpy (date.month, buf, 2);
g_assert (sizeof (date.day) == 2);
if (G_UNLIKELY (snprintf ((char*)buf, 3, "%02d", tm.tm_mday) < 0))
abort ();
memcpy (date.day, buf, 2);
return gkm_attribute_set_data (attr, &date, sizeof (date));
}
CK_RV
gkm_attribute_set_time (CK_ATTRIBUTE_PTR attr, glong when)
{
struct tm tm;
gchar buf[20];
/* 'Empty' time as defined in PKCS#11 */
if (when == (glong)-1)
return gkm_attribute_set_data (attr, NULL, 0);
if (!attr->pValue) {
attr->ulValueLen = 16;
return CKR_OK;
}
time_t time = when;
if (!gmtime_r (&time, &tm))
g_return_val_if_reached (CKR_GENERAL_ERROR);
if (!strftime(buf, sizeof (buf), "%Y%m%d%H%M%S00", &tm))
g_return_val_if_reached (CKR_GENERAL_ERROR);
return gkm_attribute_set_data (attr, buf, 16);
}
CK_RV
gkm_attribute_set_data (CK_ATTRIBUTE_PTR attr, gconstpointer value, gsize n_value)
{
CK_RV rv = gkm_util_return_data (attr->pValue, &(attr->ulValueLen), value, n_value);
if (rv == CKR_BUFFER_TOO_SMALL)
attr->ulValueLen = (CK_ULONG)-1;
return rv;
}
CK_RV
gkm_attribute_set_bytes (CK_ATTRIBUTE_PTR attr,
GBytes *value)
{
return gkm_attribute_set_data (attr, g_bytes_get_data (value, NULL),
g_bytes_get_size (value));
}
CK_RV
gkm_attribute_set_mpi (CK_ATTRIBUTE_PTR attr, gcry_mpi_t mpi)
{
gsize len;
gcry_error_t gcry;
g_assert (attr);
g_assert (mpi);
/* Get the size */
gcry = gcry_mpi_print (GCRYMPI_FMT_USG, NULL, 0, &len, mpi);
g_return_val_if_fail (gcry == 0, CKR_GENERAL_ERROR);
if (!attr->pValue) {
attr->ulValueLen = len;
return CKR_OK;
}
if (len > attr->ulValueLen) {
attr->ulValueLen = (CK_ULONG)-1;
return CKR_BUFFER_TOO_SMALL;
}
/* Write in directly to attribute */
gcry = gcry_mpi_print (GCRYMPI_FMT_USG, attr->pValue, len, &len, mpi);
g_return_val_if_fail (gcry == 0, CKR_GENERAL_ERROR);
attr->ulValueLen = len;
return CKR_OK;
}
CK_RV
gkm_attribute_set_template (CK_ATTRIBUTE_PTR attr, GArray *template)
{
CK_ATTRIBUTE_PTR array;
CK_ATTRIBUTE_PTR at;
CK_RV rv;
gulong len;
gulong i;
g_assert (attr);
g_warn_if_fail ((attr->type & CKF_ARRAY_ATTRIBUTE) != 0);
len = sizeof (CK_ATTRIBUTE) * template->len;
if (!attr->pValue) {
attr->ulValueLen = len;
return CKR_OK;
} else if (len > attr->ulValueLen) {
attr->ulValueLen = (CK_ULONG)-1;
return CKR_BUFFER_TOO_SMALL;
}
attr->ulValueLen = len;
array = attr->pValue;
rv = CKR_OK;
/* Start working with individual elements */
for (i = 0; i < template->len; ++i) {
at = &g_array_index (template, CK_ATTRIBUTE, i);
array[i].type = at->type;
if (!array[i].pValue) {
array[i].ulValueLen = at->ulValueLen;
} else if (array[i].ulValueLen < at->ulValueLen) {
array[i].ulValueLen = (CK_ULONG)-1;
rv = CKR_BUFFER_TOO_SMALL;
} else {
memcpy(array[i].pValue, at->pValue, at->ulValueLen);
array[i].ulValueLen = at->ulValueLen;
}
}
return rv;
}
CK_RV
gkm_attribute_set_checksum (CK_ATTRIBUTE_PTR attr, GChecksumType ctype,
gconstpointer data, gsize n_data)
{
GChecksum *checksum;
gssize length;
gsize result;
g_assert (attr);
g_return_val_if_fail (data, CKR_GENERAL_ERROR);
g_return_val_if_fail (n_data, CKR_GENERAL_ERROR);
length = g_checksum_type_get_length (ctype);
g_return_val_if_fail (length > 0, CKR_GENERAL_ERROR);
/* Just asking for the length */
if (!attr->pValue) {
attr->ulValueLen = length;
return CKR_OK;
}
/* Buffer is too short */
if (length > attr->ulValueLen) {
attr->ulValueLen = length;
return CKR_BUFFER_TOO_SMALL;
}
checksum = g_checksum_new (ctype);
g_checksum_update (checksum, data, n_data);
result = attr->ulValueLen;
g_checksum_get_digest (checksum, attr->pValue, &result);
g_checksum_free (checksum);
attr->ulValueLen = result;
return CKR_OK;
}
gboolean
gkm_attribute_equal (gconstpointer v1, gconstpointer v2)
{
const CK_ATTRIBUTE *a1 = v1;
const CK_ATTRIBUTE *a2 = v2;
g_assert (a1);
g_assert (a2);
if (a1 == a2)
return TRUE;
if (a1->type != a2->type)
return FALSE;
if (a1->ulValueLen != a2->ulValueLen)
return FALSE;
if (a1->pValue == a2->pValue)
return TRUE;
if (a1->ulValueLen == 0)
return TRUE;
g_assert (a1->pValue);
g_assert (a2->pValue);
return memcmp (a1->pValue, a2->pValue, a1->ulValueLen) == 0;
}
guint
gkm_attribute_hash (gconstpointer v)
{
const CK_ATTRIBUTE *a = v;
const signed char *p;
guint i, h;
g_assert (a);
p = (const signed char*)&(a->type);
h = *p;
for(i = 0; i < sizeof (CK_ATTRIBUTE_PTR); ++i)
h = (h << 5) - h + *(p++);
p = a->pValue;
for(i = 0; i < a->ulValueLen; ++i)
h = (h << 5) - h + *(p++);
return h;
}
gboolean
gkm_attribute_consumed (CK_ATTRIBUTE_PTR attr)
{
g_return_val_if_fail (attr, FALSE);
return attr->type == (CK_ULONG)-1;
}
void
gkm_attribute_consume (CK_ATTRIBUTE_PTR attr)
{
attr->type = (CK_ULONG)-1;
}
void
gkm_attributes_consume (CK_ATTRIBUTE_PTR attrs, CK_ULONG n_attrs, ...)
{
CK_ATTRIBUTE_TYPE type;
GArray *types;
guint i, j;
va_list va;
/* Convert the var args into an array */
types = g_array_new (FALSE, TRUE, sizeof (CK_ATTRIBUTE_TYPE));
va_start (va, n_attrs);
while ((type = va_arg (va, CK_ATTRIBUTE_TYPE)) != G_MAXULONG)
g_array_append_val (types, type);
va_end (va);
/* Consume each attribute whose type was in the var args */
for (i = 0; i < n_attrs; ++i) {
if (gkm_attribute_consumed (&attrs[i]))
continue;
for (j = 0; j < types->len; ++j) {
if (attrs[i].type == g_array_index (types, CK_ATTRIBUTE_TYPE, j)) {
attrs[i].type = (CK_ULONG)-1;
break;
}
}
}
g_array_free (types, TRUE);
}
gboolean
gkm_attributes_contains (CK_ATTRIBUTE_PTR attrs, CK_ULONG n_attrs, CK_ATTRIBUTE_PTR attr)
{
CK_ULONG i;
g_assert (attrs || !n_attrs);
g_assert (attr);
for (i = 0; i < n_attrs; ++i) {
if (gkm_attribute_equal (attr, &attrs[i]))
return TRUE;
}
return FALSE;
}
CK_ATTRIBUTE_PTR
gkm_attributes_find (CK_ATTRIBUTE_PTR attrs, CK_ULONG n_attrs, CK_ATTRIBUTE_TYPE type)
{
CK_ULONG i;
g_assert (attrs || !n_attrs);
for (i = 0; i < n_attrs; ++i) {
if(attrs[i].type == type && attrs[i].ulValueLen != (CK_ULONG)-1)
return &attrs[i];
}
return NULL;
}
gboolean
gkm_attributes_find_boolean (CK_ATTRIBUTE_PTR attrs, CK_ULONG n_attrs, CK_ATTRIBUTE_TYPE type, gboolean *value)
{
CK_ATTRIBUTE_PTR attr;
g_assert (attrs || !n_attrs);
attr = gkm_attributes_find (attrs, n_attrs, type);
if (attr == NULL)
return FALSE;
if (attr->ulValueLen != sizeof (CK_BBOOL))
return FALSE;
if (value != NULL) {
CK_BBOOL bbool;
memcpy (&bbool, attr->pValue, sizeof (CK_BBOOL));
*value = bbool == CK_TRUE ? TRUE : FALSE;
}
return TRUE;
}
gboolean
gkm_attributes_find_ulong (CK_ATTRIBUTE_PTR attrs, CK_ULONG n_attrs, CK_ATTRIBUTE_TYPE type, gulong *value)
{
CK_ATTRIBUTE_PTR attr;
g_assert (attrs || !n_attrs);
attr = gkm_attributes_find (attrs, n_attrs, type);
if (attr == NULL)
return FALSE;
if (attr->ulValueLen != sizeof (CK_ULONG))
return FALSE;
if (value != NULL) {
CK_ULONG ulong;
memcpy (&ulong, attr->pValue, sizeof (CK_ULONG));
*value = ulong;
}
return TRUE;
}
gboolean
gkm_attributes_find_mpi (CK_ATTRIBUTE_PTR attrs, CK_ULONG n_attrs,
CK_ATTRIBUTE_TYPE type, gcry_mpi_t *value)
{
CK_ATTRIBUTE_PTR attr;
g_assert (attrs || !n_attrs);
attr = gkm_attributes_find (attrs, n_attrs, type);
if (attr == NULL)
return FALSE;
return gkm_attribute_get_mpi (attr, value) == CKR_OK;
}
gboolean
gkm_attributes_find_string (CK_ATTRIBUTE_PTR attrs, CK_ULONG n_attrs,
CK_ATTRIBUTE_TYPE type, gchar **value)
{
CK_ATTRIBUTE_PTR attr;
g_return_val_if_fail (attrs || !n_attrs, FALSE);
attr = gkm_attributes_find (attrs, n_attrs, type);
if (attr == NULL)
return FALSE;
return gkm_attribute_get_string (attr, value) == CKR_OK;
}
/* Need to get DER encoded EC parameters and point */
gboolean
gkm_attributes_find_bytes (CK_ATTRIBUTE_PTR attrs, CK_ULONG n_attrs,
CK_ATTRIBUTE_TYPE type, GBytes **value)
{
CK_ATTRIBUTE_PTR attr;
g_return_val_if_fail (attrs || !n_attrs, FALSE);
attr = gkm_attributes_find (attrs, n_attrs, type);
if (attr == NULL)
return FALSE;
return gkm_attribute_get_bytes (attr, value) == CKR_OK;
}
GArray*
gkm_template_new (CK_ATTRIBUTE_PTR attrs, CK_ULONG n_attrs)
{
GArray *template = g_array_new (FALSE, FALSE, sizeof (CK_ATTRIBUTE));
CK_ATTRIBUTE_PTR pat;
gulong i;
g_return_val_if_fail (attrs || !n_attrs, NULL);
g_array_append_vals (template, attrs, n_attrs);
for (i = 0; i < n_attrs; ++i) {
pat = &g_array_index (template, CK_ATTRIBUTE, i);
if (pat->pValue) {
g_return_val_if_fail (pat->ulValueLen != (CK_ULONG)-1, NULL);
pat->pValue = g_memdup2 (pat->pValue, pat->ulValueLen ? pat->ulValueLen : 1);
}
}
return template;
}
void
gkm_template_set (GArray *template, CK_ATTRIBUTE_PTR attr)
{
CK_ATTRIBUTE at;
guint i;
g_return_if_fail (template);
g_return_if_fail (attr);
g_return_if_fail (attr->ulValueLen != (CK_ULONG)-1);
/* Remove any previous value */
for (i = 0; i < template->len; ++i) {
if (g_array_index (template, CK_ATTRIBUTE, i).type == attr->type) {
g_free (g_array_index (template, CK_ATTRIBUTE, i).pValue);
g_array_remove_index_fast (template, i);
break;
}
}
/* Add a new attribute */
memcpy (&at, attr, sizeof (at));
if (at.pValue)
at.pValue = g_memdup2 (at.pValue, at.ulValueLen ? at.ulValueLen : 1);
g_array_append_vals (template, &at, 1);
}
void
gkm_template_set_value (GArray *template, CK_ATTRIBUTE_TYPE type,
CK_VOID_PTR value, CK_ULONG length)
{
CK_ATTRIBUTE attr;
g_return_if_fail (template);
attr.type = type;
attr.pValue = value;
attr.ulValueLen = length;
gkm_template_set (template, &attr);
}
void
gkm_template_set_string (GArray *template, CK_ATTRIBUTE_TYPE type, const gchar *value)
{
CK_ATTRIBUTE attr;
g_return_if_fail (template);
g_return_if_fail (value);
attr.type = type;
attr.pValue = (CK_VOID_PTR)value;
attr.ulValueLen = strlen (value);
gkm_template_set (template, &attr);
}
void
gkm_template_set_ulong (GArray *template, CK_ATTRIBUTE_TYPE type, CK_ULONG value)
{
CK_ATTRIBUTE attr;
g_return_if_fail (template);
attr.type = type;
attr.pValue = &value;
attr.ulValueLen = sizeof (value);
gkm_template_set (template, &attr);
}
void
gkm_template_set_boolean (GArray *template, CK_ATTRIBUTE_TYPE type, CK_BBOOL value)
{
CK_ATTRIBUTE attr;
g_return_if_fail (template);
attr.type = type;
attr.pValue = &value;
attr.ulValueLen = sizeof (value);
gkm_template_set (template, &attr);
}
void
gkm_template_free (GArray *template)
{
guint i;
if (!template)
return;
for (i = 0; i < template->len; ++i)
g_free (g_array_index (template, CK_ATTRIBUTE, i).pValue);
g_array_free (template, TRUE);
}
CK_ATTRIBUTE_PTR
gkm_template_find (GArray *template, CK_ATTRIBUTE_TYPE type)
{
g_return_val_if_fail (template, NULL);
return gkm_attributes_find ((CK_ATTRIBUTE_PTR)template->data, template->len, type);
}
gboolean
gkm_template_find_boolean (GArray *template, CK_ATTRIBUTE_TYPE type, gboolean *value)
{
g_return_val_if_fail (template, FALSE);
return gkm_attributes_find_boolean ((CK_ATTRIBUTE_PTR)template->data, template->len, type, value);
}
gboolean
gkm_template_find_ulong (GArray *template, CK_ATTRIBUTE_TYPE type, gulong *value)
{
g_return_val_if_fail (template, FALSE);
return gkm_attributes_find_ulong ((CK_ATTRIBUTE_PTR)template->data, template->len, type, value);
}