2003-08-05 17:11:04 +00:00
|
|
|
|
/* protect.c - Un/Protect a secret key
|
|
|
|
|
* Copyright (C) 1998, 1999, 2000, 2001, 2002,
|
2009-03-06 17:31:27 +00:00
|
|
|
|
* 2003, 2007, 2009 Free Software Foundation, Inc.
|
2003-08-05 17:11:04 +00:00
|
|
|
|
*
|
|
|
|
|
* This file is part of GnuPG.
|
|
|
|
|
*
|
|
|
|
|
* GnuPG is free software; you can redistribute it and/or modify
|
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
2007-07-04 19:49:40 +00:00
|
|
|
|
* the Free Software Foundation; either version 3 of the License, or
|
2003-08-05 17:11:04 +00:00
|
|
|
|
* (at your option) any later version.
|
|
|
|
|
*
|
|
|
|
|
* GnuPG 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 General Public License for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU General Public License
|
2007-07-04 19:49:40 +00:00
|
|
|
|
* along with this program; if not, see <http://www.gnu.org/licenses/>.
|
2003-08-05 17:11:04 +00:00
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <config.h>
|
|
|
|
|
#include <errno.h>
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
#include <string.h>
|
|
|
|
|
#include <ctype.h>
|
|
|
|
|
#include <assert.h>
|
|
|
|
|
#include <unistd.h>
|
|
|
|
|
#include <sys/stat.h>
|
2009-12-14 20:12:56 +00:00
|
|
|
|
#ifdef HAVE_W32_SYSTEM
|
|
|
|
|
# include <windows.h>
|
|
|
|
|
#else
|
|
|
|
|
# include <sys/times.h>
|
|
|
|
|
#endif
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
|
|
#include "agent.h"
|
|
|
|
|
|
|
|
|
|
#include "sexp-parse.h"
|
|
|
|
|
|
|
|
|
|
#define PROT_CIPHER GCRY_CIPHER_AES
|
|
|
|
|
#define PROT_CIPHER_STRING "aes"
|
|
|
|
|
#define PROT_CIPHER_KEYLEN (128/8)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* A table containing the information needed to create a protected
|
2011-01-21 12:00:57 +01:00
|
|
|
|
private key. */
|
2003-08-05 17:11:04 +00:00
|
|
|
|
static struct {
|
|
|
|
|
const char *algo;
|
|
|
|
|
const char *parmlist;
|
|
|
|
|
int prot_from, prot_to;
|
|
|
|
|
} protect_info[] = {
|
|
|
|
|
{ "rsa", "nedpqu", 2, 5 },
|
2004-02-03 16:24:37 +00:00
|
|
|
|
{ "dsa", "pqgyx", 4, 4 },
|
|
|
|
|
{ "elg", "pgyx", 3, 3 },
|
2011-01-05 17:33:17 -08:00
|
|
|
|
{ "ecdsa","cqd", 2, 2 },
|
|
|
|
|
{ "ecdh", "cqpd", 3, 3 },
|
2003-08-05 17:11:04 +00:00
|
|
|
|
{ NULL }
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
2009-12-14 20:12:56 +00:00
|
|
|
|
/* A helper object for time measurement. */
|
|
|
|
|
struct calibrate_time_s
|
|
|
|
|
{
|
|
|
|
|
#ifdef HAVE_W32_SYSTEM
|
|
|
|
|
FILETIME creation_time, exit_time, kernel_time, user_time;
|
|
|
|
|
#else
|
|
|
|
|
clock_t ticks;
|
|
|
|
|
#endif
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
|
static int
|
|
|
|
|
hash_passphrase (const char *passphrase, int hashalgo,
|
|
|
|
|
int s2kmode,
|
|
|
|
|
const unsigned char *s2ksalt, unsigned long s2kcount,
|
|
|
|
|
unsigned char *key, size_t keylen);
|
|
|
|
|
|
2010-08-31 15:58:39 +00:00
|
|
|
|
|
|
|
|
|
|
2009-12-14 20:12:56 +00:00
|
|
|
|
/* Get the process time and store it in DATA. */
|
|
|
|
|
static void
|
|
|
|
|
calibrate_get_time (struct calibrate_time_s *data)
|
|
|
|
|
{
|
|
|
|
|
#ifdef HAVE_W32_SYSTEM
|
2010-04-14 11:24:02 +00:00
|
|
|
|
# ifdef HAVE_W32CE_SYSTEM
|
|
|
|
|
GetThreadTimes (GetCurrentThread (),
|
|
|
|
|
# else
|
2009-12-14 20:12:56 +00:00
|
|
|
|
GetProcessTimes (GetCurrentProcess (),
|
2010-04-14 11:24:02 +00:00
|
|
|
|
# endif
|
2009-12-14 20:12:56 +00:00
|
|
|
|
&data->creation_time, &data->exit_time,
|
|
|
|
|
&data->kernel_time, &data->user_time);
|
|
|
|
|
#else
|
|
|
|
|
struct tms tmp;
|
|
|
|
|
|
|
|
|
|
times (&tmp);
|
|
|
|
|
data->ticks = tmp.tms_utime;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static unsigned long
|
|
|
|
|
calibrate_elapsed_time (struct calibrate_time_s *starttime)
|
|
|
|
|
{
|
|
|
|
|
struct calibrate_time_s stoptime;
|
|
|
|
|
|
|
|
|
|
calibrate_get_time (&stoptime);
|
|
|
|
|
#ifdef HAVE_W32_SYSTEM
|
|
|
|
|
{
|
|
|
|
|
unsigned long long t1, t2;
|
|
|
|
|
|
|
|
|
|
t1 = (((unsigned long long)starttime->kernel_time.dwHighDateTime << 32)
|
|
|
|
|
+ starttime->kernel_time.dwLowDateTime);
|
|
|
|
|
t1 += (((unsigned long long)starttime->user_time.dwHighDateTime << 32)
|
|
|
|
|
+ starttime->user_time.dwLowDateTime);
|
|
|
|
|
t2 = (((unsigned long long)stoptime.kernel_time.dwHighDateTime << 32)
|
|
|
|
|
+ stoptime.kernel_time.dwLowDateTime);
|
|
|
|
|
t2 += (((unsigned long long)stoptime.user_time.dwHighDateTime << 32)
|
|
|
|
|
+ stoptime.user_time.dwLowDateTime);
|
|
|
|
|
return (unsigned long)((t2 - t1)/10000);
|
|
|
|
|
}
|
|
|
|
|
#else
|
|
|
|
|
return (unsigned long)((((double) (stoptime.ticks - starttime->ticks))
|
|
|
|
|
/CLOCKS_PER_SEC)*10000000);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Run a test hashing for COUNT and return the time required in
|
|
|
|
|
milliseconds. */
|
|
|
|
|
static unsigned long
|
|
|
|
|
calibrate_s2k_count_one (unsigned long count)
|
|
|
|
|
{
|
|
|
|
|
int rc;
|
|
|
|
|
char keybuf[PROT_CIPHER_KEYLEN];
|
|
|
|
|
struct calibrate_time_s starttime;
|
|
|
|
|
|
|
|
|
|
calibrate_get_time (&starttime);
|
|
|
|
|
rc = hash_passphrase ("123456789abcdef0", GCRY_MD_SHA1,
|
|
|
|
|
3, "saltsalt", count, keybuf, sizeof keybuf);
|
|
|
|
|
if (rc)
|
|
|
|
|
BUG ();
|
|
|
|
|
return calibrate_elapsed_time (&starttime);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Measure the time we need to do the hash operations and deduce an
|
|
|
|
|
S2K count which requires about 100ms of time. */
|
|
|
|
|
static unsigned long
|
|
|
|
|
calibrate_s2k_count (void)
|
|
|
|
|
{
|
|
|
|
|
unsigned long count;
|
|
|
|
|
unsigned long ms;
|
|
|
|
|
|
|
|
|
|
for (count = 65536; count; count *= 2)
|
|
|
|
|
{
|
|
|
|
|
ms = calibrate_s2k_count_one (count);
|
|
|
|
|
if (opt.verbose > 1)
|
|
|
|
|
log_info ("S2K calibration: %lu -> %lums\n", count, ms);
|
|
|
|
|
if (ms > 100)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
count = (unsigned long)(((double)count / ms) * 100);
|
|
|
|
|
count /= 1024;
|
|
|
|
|
count *= 1024;
|
|
|
|
|
if (count < 65536)
|
|
|
|
|
count = 65536;
|
|
|
|
|
|
|
|
|
|
if (opt.verbose)
|
|
|
|
|
{
|
|
|
|
|
ms = calibrate_s2k_count_one (count);
|
2009-12-15 11:03:17 +00:00
|
|
|
|
log_info ("S2K calibration: %lu -> %lums\n", count, ms);
|
2009-12-14 20:12:56 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return count;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Return the standard S2K count. */
|
|
|
|
|
unsigned long
|
|
|
|
|
get_standard_s2k_count (void)
|
|
|
|
|
{
|
|
|
|
|
static unsigned long count;
|
|
|
|
|
|
|
|
|
|
if (!count)
|
|
|
|
|
count = calibrate_s2k_count ();
|
|
|
|
|
|
|
|
|
|
/* Enforce a lower limit. */
|
|
|
|
|
return count < 65536 ? 65536 : count;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
|
|
|
2010-10-01 20:33:53 +00:00
|
|
|
|
/* Calculate the MIC for a private key or shared secret S-expression.
|
|
|
|
|
SHA1HASH should point to a 20 byte buffer. This function is
|
|
|
|
|
suitable for all algorithms. */
|
2003-08-05 17:11:04 +00:00
|
|
|
|
static int
|
|
|
|
|
calculate_mic (const unsigned char *plainkey, unsigned char *sha1hash)
|
|
|
|
|
{
|
|
|
|
|
const unsigned char *hash_begin, *hash_end;
|
|
|
|
|
const unsigned char *s;
|
|
|
|
|
size_t n;
|
2010-10-01 20:33:53 +00:00
|
|
|
|
int is_shared_secret;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
|
|
s = plainkey;
|
|
|
|
|
if (*s != '(')
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
s++;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
2010-10-01 20:33:53 +00:00
|
|
|
|
if (smatch (&s, n, "private-key"))
|
|
|
|
|
is_shared_secret = 0;
|
|
|
|
|
else if (smatch (&s, n, "shared-secret"))
|
|
|
|
|
is_shared_secret = 1;
|
|
|
|
|
else
|
2003-08-05 17:11:04 +00:00
|
|
|
|
return gpg_error (GPG_ERR_UNKNOWN_SEXP);
|
|
|
|
|
if (*s != '(')
|
|
|
|
|
return gpg_error (GPG_ERR_UNKNOWN_SEXP);
|
|
|
|
|
hash_begin = s;
|
2010-10-01 20:33:53 +00:00
|
|
|
|
if (!is_shared_secret)
|
|
|
|
|
{
|
|
|
|
|
s++;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
s += n; /* Skip the algorithm name. */
|
|
|
|
|
}
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
|
|
while (*s == '(')
|
|
|
|
|
{
|
|
|
|
|
s++;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
s += n;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
s += n;
|
|
|
|
|
if ( *s != ')' )
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
s++;
|
|
|
|
|
}
|
|
|
|
|
if (*s != ')')
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
s++;
|
|
|
|
|
hash_end = s;
|
|
|
|
|
|
|
|
|
|
gcry_md_hash_buffer (GCRY_MD_SHA1, sha1hash,
|
|
|
|
|
hash_begin, hash_end - hash_begin);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Encrypt the parameter block starting at PROTBEGIN with length
|
|
|
|
|
PROTLEN using the utf8 encoded key PASSPHRASE and return the entire
|
2005-02-23 21:06:32 +00:00
|
|
|
|
encrypted block in RESULT or return with an error code. SHA1HASH
|
2003-08-05 17:11:04 +00:00
|
|
|
|
is the 20 byte SHA-1 hash required for the integrity code.
|
|
|
|
|
|
|
|
|
|
The parameter block is expected to be an incomplete S-Expression of
|
|
|
|
|
the form (example in advanced format):
|
|
|
|
|
|
|
|
|
|
(d #046129F..[some bytes not shown]..81#)
|
|
|
|
|
(p #00e861b..[some bytes not shown]..f1#)
|
|
|
|
|
(q #00f7a7c..[some bytes not shown]..61#)
|
|
|
|
|
(u #304559a..[some bytes not shown]..9b#)
|
|
|
|
|
|
|
|
|
|
the returned block is the S-Expression:
|
|
|
|
|
|
|
|
|
|
(protected mode (parms) encrypted_octet_string)
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
static int
|
2005-06-16 08:12:03 +00:00
|
|
|
|
do_encryption (const unsigned char *protbegin, size_t protlen,
|
2003-08-05 17:11:04 +00:00
|
|
|
|
const char *passphrase, const unsigned char *sha1hash,
|
|
|
|
|
unsigned char **result, size_t *resultlen)
|
|
|
|
|
{
|
|
|
|
|
gcry_cipher_hd_t hd;
|
|
|
|
|
const char *modestr = "openpgp-s2k3-sha1-" PROT_CIPHER_STRING "-cbc";
|
|
|
|
|
int blklen, enclen, outlen;
|
2005-06-16 08:12:03 +00:00
|
|
|
|
unsigned char *iv = NULL;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
int rc;
|
|
|
|
|
char *outbuf = NULL;
|
|
|
|
|
char *p;
|
|
|
|
|
int saltpos, ivpos, encpos;
|
|
|
|
|
|
2005-06-16 08:12:03 +00:00
|
|
|
|
*resultlen = 0;
|
|
|
|
|
*result = NULL;
|
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
|
rc = gcry_cipher_open (&hd, PROT_CIPHER, GCRY_CIPHER_MODE_CBC,
|
|
|
|
|
GCRY_CIPHER_SECURE);
|
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* We need to work on a copy of the data because this makes it
|
|
|
|
|
easier to add the trailer and the padding and more important we
|
|
|
|
|
have to prefix the text with 2 parenthesis, so we have to
|
|
|
|
|
allocate enough space for:
|
|
|
|
|
|
|
|
|
|
((<parameter_list>)(4:hash4:sha120:<hashvalue>)) + padding
|
|
|
|
|
|
|
|
|
|
We always append a full block of random bytes as padding but
|
2007-08-28 17:48:13 +00:00
|
|
|
|
encrypt only what is needed for a full blocksize. */
|
2003-08-05 17:11:04 +00:00
|
|
|
|
blklen = gcry_cipher_get_algo_blklen (PROT_CIPHER);
|
|
|
|
|
outlen = 2 + protlen + 2 + 6 + 6 + 23 + 2 + blklen;
|
|
|
|
|
enclen = outlen/blklen * blklen;
|
|
|
|
|
outbuf = gcry_malloc_secure (outlen);
|
|
|
|
|
if (!outbuf)
|
|
|
|
|
rc = out_of_core ();
|
|
|
|
|
if (!rc)
|
|
|
|
|
{
|
2003-12-16 11:30:38 +00:00
|
|
|
|
/* Allocate random bytes to be used as IV, padding and s2k salt. */
|
|
|
|
|
iv = xtrymalloc (blklen*2+8);
|
2003-08-05 17:11:04 +00:00
|
|
|
|
if (!iv)
|
|
|
|
|
rc = gpg_error (GPG_ERR_ENOMEM);
|
2009-06-24 14:03:09 +00:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
gcry_create_nonce (iv, blklen*2+8);
|
|
|
|
|
rc = gcry_cipher_setiv (hd, iv, blklen);
|
|
|
|
|
}
|
2003-08-05 17:11:04 +00:00
|
|
|
|
}
|
|
|
|
|
if (!rc)
|
|
|
|
|
{
|
|
|
|
|
unsigned char *key;
|
|
|
|
|
size_t keylen = PROT_CIPHER_KEYLEN;
|
|
|
|
|
|
|
|
|
|
key = gcry_malloc_secure (keylen);
|
|
|
|
|
if (!key)
|
|
|
|
|
rc = out_of_core ();
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
rc = hash_passphrase (passphrase, GCRY_MD_SHA1,
|
2009-12-14 20:12:56 +00:00
|
|
|
|
3, iv+2*blklen,
|
|
|
|
|
get_standard_s2k_count (), key, keylen);
|
2003-08-05 17:11:04 +00:00
|
|
|
|
if (!rc)
|
|
|
|
|
rc = gcry_cipher_setkey (hd, key, keylen);
|
|
|
|
|
xfree (key);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (!rc)
|
|
|
|
|
{
|
|
|
|
|
p = outbuf;
|
|
|
|
|
*p++ = '(';
|
|
|
|
|
*p++ = '(';
|
|
|
|
|
memcpy (p, protbegin, protlen);
|
|
|
|
|
p += protlen;
|
|
|
|
|
memcpy (p, ")(4:hash4:sha120:", 17);
|
|
|
|
|
p += 17;
|
|
|
|
|
memcpy (p, sha1hash, 20);
|
|
|
|
|
p += 20;
|
|
|
|
|
*p++ = ')';
|
|
|
|
|
*p++ = ')';
|
|
|
|
|
memcpy (p, iv+blklen, blklen);
|
|
|
|
|
p += blklen;
|
|
|
|
|
assert ( p - outbuf == outlen);
|
|
|
|
|
rc = gcry_cipher_encrypt (hd, outbuf, enclen, NULL, 0);
|
|
|
|
|
}
|
|
|
|
|
gcry_cipher_close (hd);
|
|
|
|
|
if (rc)
|
|
|
|
|
{
|
|
|
|
|
xfree (iv);
|
|
|
|
|
xfree (outbuf);
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Now allocate the buffer we want to return. This is
|
|
|
|
|
|
|
|
|
|
(protected openpgp-s2k3-sha1-aes-cbc
|
|
|
|
|
((sha1 salt no_of_iterations) 16byte_iv)
|
|
|
|
|
encrypted_octet_string)
|
|
|
|
|
|
|
|
|
|
in canoncical format of course. We use asprintf and %n modifier
|
2007-08-28 17:48:13 +00:00
|
|
|
|
and dummy values as placeholders. */
|
2010-01-26 16:15:12 +00:00
|
|
|
|
{
|
|
|
|
|
char countbuf[35];
|
|
|
|
|
|
|
|
|
|
snprintf (countbuf, sizeof countbuf, "%lu", get_standard_s2k_count ());
|
|
|
|
|
p = xtryasprintf
|
|
|
|
|
("(9:protected%d:%s((4:sha18:%n_8bytes_%u:%s)%d:%n%*s)%d:%n%*s)",
|
|
|
|
|
(int)strlen (modestr), modestr,
|
|
|
|
|
&saltpos,
|
|
|
|
|
(unsigned int)strlen (countbuf), countbuf,
|
|
|
|
|
blklen, &ivpos, blklen, "",
|
|
|
|
|
enclen, &encpos, enclen, "");
|
|
|
|
|
if (!p)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t tmperr = out_of_core ();
|
|
|
|
|
xfree (iv);
|
|
|
|
|
xfree (outbuf);
|
|
|
|
|
return tmperr;
|
|
|
|
|
}
|
|
|
|
|
}
|
2003-08-05 17:11:04 +00:00
|
|
|
|
*resultlen = strlen (p);
|
2005-06-16 08:12:03 +00:00
|
|
|
|
*result = (unsigned char*)p;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
memcpy (p+saltpos, iv+2*blklen, 8);
|
|
|
|
|
memcpy (p+ivpos, iv, blklen);
|
|
|
|
|
memcpy (p+encpos, outbuf, enclen);
|
|
|
|
|
xfree (iv);
|
|
|
|
|
xfree (outbuf);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2005-06-16 08:12:03 +00:00
|
|
|
|
/* Protect the key encoded in canonical format in PLAINKEY. We assume
|
2003-08-05 17:11:04 +00:00
|
|
|
|
a valid S-Exp here. */
|
|
|
|
|
int
|
|
|
|
|
agent_protect (const unsigned char *plainkey, const char *passphrase,
|
|
|
|
|
unsigned char **result, size_t *resultlen)
|
|
|
|
|
{
|
|
|
|
|
int rc;
|
|
|
|
|
const unsigned char *s;
|
|
|
|
|
const unsigned char *hash_begin, *hash_end;
|
|
|
|
|
const unsigned char *prot_begin, *prot_end, *real_end;
|
|
|
|
|
size_t n;
|
|
|
|
|
int c, infidx, i;
|
|
|
|
|
unsigned char hashvalue[20];
|
2007-08-28 17:48:13 +00:00
|
|
|
|
char timestamp_exp[35];
|
2003-08-05 17:11:04 +00:00
|
|
|
|
unsigned char *protected;
|
|
|
|
|
size_t protectedlen;
|
|
|
|
|
int depth = 0;
|
|
|
|
|
unsigned char *p;
|
2007-08-28 17:48:13 +00:00
|
|
|
|
gcry_md_hd_t md;
|
|
|
|
|
|
2010-06-17 15:44:44 +00:00
|
|
|
|
/* Create an S-expression with the protected-at timestamp. */
|
2007-08-28 17:48:13 +00:00
|
|
|
|
memcpy (timestamp_exp, "(12:protected-at15:", 19);
|
|
|
|
|
gnupg_get_isotime (timestamp_exp+19);
|
|
|
|
|
timestamp_exp[19+15] = ')';
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
2007-08-28 17:48:13 +00:00
|
|
|
|
/* Parse original key. */
|
2003-08-05 17:11:04 +00:00
|
|
|
|
s = plainkey;
|
|
|
|
|
if (*s != '(')
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
depth++;
|
|
|
|
|
s++;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
if (!smatch (&s, n, "private-key"))
|
|
|
|
|
return gpg_error (GPG_ERR_UNKNOWN_SEXP);
|
|
|
|
|
if (*s != '(')
|
|
|
|
|
return gpg_error (GPG_ERR_UNKNOWN_SEXP);
|
|
|
|
|
depth++;
|
|
|
|
|
hash_begin = s;
|
|
|
|
|
s++;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
|
|
|
|
|
for (infidx=0; protect_info[infidx].algo
|
|
|
|
|
&& !smatch (&s, n, protect_info[infidx].algo); infidx++)
|
|
|
|
|
;
|
2011-01-21 12:00:57 +01:00
|
|
|
|
if (!protect_info[infidx].algo)
|
2003-08-05 17:11:04 +00:00
|
|
|
|
return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
|
|
|
|
|
|
|
|
|
|
prot_begin = prot_end = NULL;
|
|
|
|
|
for (i=0; (c=protect_info[infidx].parmlist[i]); i++)
|
|
|
|
|
{
|
|
|
|
|
if (i == protect_info[infidx].prot_from)
|
|
|
|
|
prot_begin = s;
|
2011-01-21 12:00:57 +01:00
|
|
|
|
if (*s != '(')
|
2003-08-05 17:11:04 +00:00
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
depth++;
|
|
|
|
|
s++;
|
|
|
|
|
n = snext (&s);
|
2011-01-21 12:00:57 +01:00
|
|
|
|
if (!n)
|
2003-08-05 17:11:04 +00:00
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
2011-01-21 12:00:57 +01:00
|
|
|
|
if (n != 1 || c != *s)
|
2003-08-05 17:11:04 +00:00
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
2011-01-21 12:00:57 +01:00
|
|
|
|
s += n;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
n = snext (&s);
|
2011-01-21 12:00:57 +01:00
|
|
|
|
if (!n)
|
2003-08-05 17:11:04 +00:00
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
s +=n; /* skip value */
|
2011-01-21 12:00:57 +01:00
|
|
|
|
if (*s != ')')
|
2003-08-05 17:11:04 +00:00
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
depth--;
|
|
|
|
|
if (i == protect_info[infidx].prot_to)
|
|
|
|
|
prot_end = s;
|
|
|
|
|
s++;
|
|
|
|
|
}
|
2011-01-21 12:00:57 +01:00
|
|
|
|
if (*s != ')' || !prot_begin || !prot_end )
|
2003-08-05 17:11:04 +00:00
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
depth--;
|
|
|
|
|
hash_end = s;
|
|
|
|
|
s++;
|
2011-01-21 12:00:57 +01:00
|
|
|
|
/* Skip to the end of the S-expression. */
|
2003-08-05 17:11:04 +00:00
|
|
|
|
assert (depth == 1);
|
|
|
|
|
rc = sskip (&s, &depth);
|
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
|
|
|
|
assert (!depth);
|
|
|
|
|
real_end = s-1;
|
|
|
|
|
|
2007-08-28 17:48:13 +00:00
|
|
|
|
|
|
|
|
|
/* Hash the stuff. Because the timestamp_exp won't get protected,
|
|
|
|
|
we can't simply hash a continuous buffer but need to use several
|
|
|
|
|
md_writes. */
|
|
|
|
|
rc = gcry_md_open (&md, GCRY_MD_SHA1, 0 );
|
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
|
|
|
|
gcry_md_write (md, hash_begin, hash_end - hash_begin);
|
|
|
|
|
gcry_md_write (md, timestamp_exp, 35);
|
|
|
|
|
gcry_md_write (md, ")", 1);
|
|
|
|
|
memcpy (hashvalue, gcry_md_read (md, GCRY_MD_SHA1), 20);
|
|
|
|
|
gcry_md_close (md);
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
|
|
rc = do_encryption (prot_begin, prot_end - prot_begin + 1,
|
|
|
|
|
passphrase, hashvalue,
|
|
|
|
|
&protected, &protectedlen);
|
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
|
|
/* Now create the protected version of the key. Note that the 10
|
|
|
|
|
extra bytes are for for the inserted "protected-" string (the
|
2007-08-28 17:48:13 +00:00
|
|
|
|
beginning of the plaintext reads: "((11:private-key(" ). The 35
|
|
|
|
|
term is the space for (12:protected-at15:<timestamp>). */
|
2003-08-05 17:11:04 +00:00
|
|
|
|
*resultlen = (10
|
|
|
|
|
+ (prot_begin-plainkey)
|
|
|
|
|
+ protectedlen
|
2007-08-28 17:48:13 +00:00
|
|
|
|
+ 35
|
2003-08-05 17:11:04 +00:00
|
|
|
|
+ (real_end-prot_end));
|
|
|
|
|
*result = p = xtrymalloc (*resultlen);
|
|
|
|
|
if (!p)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t tmperr = out_of_core ();
|
|
|
|
|
xfree (protected);
|
|
|
|
|
return tmperr;
|
|
|
|
|
}
|
|
|
|
|
memcpy (p, "(21:protected-", 14);
|
|
|
|
|
p += 14;
|
|
|
|
|
memcpy (p, plainkey+4, prot_begin - plainkey - 4);
|
|
|
|
|
p += prot_begin - plainkey - 4;
|
|
|
|
|
memcpy (p, protected, protectedlen);
|
|
|
|
|
p += protectedlen;
|
2007-08-28 17:48:13 +00:00
|
|
|
|
|
|
|
|
|
memcpy (p, timestamp_exp, 35);
|
|
|
|
|
p += 35;
|
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
|
memcpy (p, prot_end+1, real_end - prot_end);
|
|
|
|
|
p += real_end - prot_end;
|
|
|
|
|
assert ( p - *result == *resultlen);
|
|
|
|
|
xfree (protected);
|
2007-08-28 17:48:13 +00:00
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Do the actual decryption and check the return list for consistency. */
|
|
|
|
|
static int
|
|
|
|
|
do_decryption (const unsigned char *protected, size_t protectedlen,
|
|
|
|
|
const char *passphrase,
|
|
|
|
|
const unsigned char *s2ksalt, unsigned long s2kcount,
|
|
|
|
|
const unsigned char *iv, size_t ivlen,
|
|
|
|
|
unsigned char **result)
|
|
|
|
|
{
|
|
|
|
|
int rc = 0;
|
|
|
|
|
int blklen;
|
|
|
|
|
gcry_cipher_hd_t hd;
|
|
|
|
|
unsigned char *outbuf;
|
|
|
|
|
size_t reallen;
|
|
|
|
|
|
|
|
|
|
blklen = gcry_cipher_get_algo_blklen (PROT_CIPHER);
|
|
|
|
|
if (protectedlen < 4 || (protectedlen%blklen))
|
|
|
|
|
return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
|
|
|
|
|
|
|
|
|
|
rc = gcry_cipher_open (&hd, PROT_CIPHER, GCRY_CIPHER_MODE_CBC,
|
|
|
|
|
GCRY_CIPHER_SECURE);
|
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
|
|
outbuf = gcry_malloc_secure (protectedlen);
|
|
|
|
|
if (!outbuf)
|
|
|
|
|
rc = out_of_core ();
|
|
|
|
|
if (!rc)
|
|
|
|
|
rc = gcry_cipher_setiv (hd, iv, ivlen);
|
|
|
|
|
if (!rc)
|
|
|
|
|
{
|
|
|
|
|
unsigned char *key;
|
|
|
|
|
size_t keylen = PROT_CIPHER_KEYLEN;
|
|
|
|
|
|
|
|
|
|
key = gcry_malloc_secure (keylen);
|
|
|
|
|
if (!key)
|
|
|
|
|
rc = out_of_core ();
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
rc = hash_passphrase (passphrase, GCRY_MD_SHA1,
|
|
|
|
|
3, s2ksalt, s2kcount, key, keylen);
|
|
|
|
|
if (!rc)
|
|
|
|
|
rc = gcry_cipher_setkey (hd, key, keylen);
|
|
|
|
|
xfree (key);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (!rc)
|
|
|
|
|
rc = gcry_cipher_decrypt (hd, outbuf, protectedlen,
|
|
|
|
|
protected, protectedlen);
|
|
|
|
|
gcry_cipher_close (hd);
|
|
|
|
|
if (rc)
|
|
|
|
|
{
|
|
|
|
|
xfree (outbuf);
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
2004-02-03 16:24:37 +00:00
|
|
|
|
/* Do a quick check first. */
|
2003-08-05 17:11:04 +00:00
|
|
|
|
if (*outbuf != '(' && outbuf[1] != '(')
|
|
|
|
|
{
|
|
|
|
|
xfree (outbuf);
|
|
|
|
|
return gpg_error (GPG_ERR_BAD_PASSPHRASE);
|
|
|
|
|
}
|
2004-02-03 16:24:37 +00:00
|
|
|
|
/* Check that we have a consistent S-Exp. */
|
2003-08-05 17:11:04 +00:00
|
|
|
|
reallen = gcry_sexp_canon_len (outbuf, protectedlen, NULL, NULL);
|
|
|
|
|
if (!reallen || (reallen + blklen < protectedlen) )
|
|
|
|
|
{
|
|
|
|
|
xfree (outbuf);
|
|
|
|
|
return gpg_error (GPG_ERR_BAD_PASSPHRASE);
|
|
|
|
|
}
|
|
|
|
|
*result = outbuf;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Merge the parameter list contained in CLEARTEXT with the original
|
|
|
|
|
protect lists PROTECTEDKEY by replacing the list at REPLACEPOS.
|
|
|
|
|
Return the new list in RESULT and the MIC value in the 20 byte
|
2007-08-28 17:48:13 +00:00
|
|
|
|
buffer SHA1HASH. CUTOFF and CUTLEN will receive the offset and the
|
|
|
|
|
length of the resulting list which should go into the MIC
|
|
|
|
|
calculation but then be removed. */
|
2003-08-05 17:11:04 +00:00
|
|
|
|
static int
|
|
|
|
|
merge_lists (const unsigned char *protectedkey,
|
|
|
|
|
size_t replacepos,
|
|
|
|
|
const unsigned char *cleartext,
|
2004-02-03 16:24:37 +00:00
|
|
|
|
unsigned char *sha1hash,
|
2007-08-28 17:48:13 +00:00
|
|
|
|
unsigned char **result, size_t *resultlen,
|
|
|
|
|
size_t *cutoff, size_t *cutlen)
|
2003-08-05 17:11:04 +00:00
|
|
|
|
{
|
|
|
|
|
size_t n, newlistlen;
|
|
|
|
|
unsigned char *newlist, *p;
|
|
|
|
|
const unsigned char *s;
|
|
|
|
|
const unsigned char *startpos, *endpos;
|
|
|
|
|
int i, rc;
|
|
|
|
|
|
2005-06-16 08:12:03 +00:00
|
|
|
|
*result = NULL;
|
|
|
|
|
*resultlen = 0;
|
2007-08-28 17:48:13 +00:00
|
|
|
|
*cutoff = 0;
|
|
|
|
|
*cutlen = 0;
|
2005-06-16 08:12:03 +00:00
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
|
if (replacepos < 26)
|
|
|
|
|
return gpg_error (GPG_ERR_BUG);
|
|
|
|
|
|
|
|
|
|
/* Estimate the required size of the resulting list. We have a large
|
|
|
|
|
safety margin of >20 bytes (MIC hash from CLEARTEXT and the
|
|
|
|
|
removed "protected-" */
|
|
|
|
|
newlistlen = gcry_sexp_canon_len (protectedkey, 0, NULL, NULL);
|
|
|
|
|
if (!newlistlen)
|
|
|
|
|
return gpg_error (GPG_ERR_BUG);
|
|
|
|
|
n = gcry_sexp_canon_len (cleartext, 0, NULL, NULL);
|
|
|
|
|
if (!n)
|
|
|
|
|
return gpg_error (GPG_ERR_BUG);
|
|
|
|
|
newlistlen += n;
|
|
|
|
|
newlist = gcry_malloc_secure (newlistlen);
|
|
|
|
|
if (!newlist)
|
|
|
|
|
return out_of_core ();
|
|
|
|
|
|
|
|
|
|
/* Copy the initial segment */
|
2005-06-16 08:12:03 +00:00
|
|
|
|
strcpy ((char*)newlist, "(11:private-key");
|
2003-08-05 17:11:04 +00:00
|
|
|
|
p = newlist + 15;
|
|
|
|
|
memcpy (p, protectedkey+15+10, replacepos-15-10);
|
|
|
|
|
p += replacepos-15-10;
|
|
|
|
|
|
|
|
|
|
/* copy the cleartext */
|
|
|
|
|
s = cleartext;
|
|
|
|
|
if (*s != '(' && s[1] != '(')
|
|
|
|
|
return gpg_error (GPG_ERR_BUG); /*we already checked this */
|
|
|
|
|
s += 2;
|
|
|
|
|
startpos = s;
|
|
|
|
|
while ( *s == '(' )
|
|
|
|
|
{
|
|
|
|
|
s++;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
goto invalid_sexp;
|
|
|
|
|
s += n;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
goto invalid_sexp;
|
|
|
|
|
s += n;
|
|
|
|
|
if ( *s != ')' )
|
|
|
|
|
goto invalid_sexp;
|
|
|
|
|
s++;
|
|
|
|
|
}
|
|
|
|
|
if ( *s != ')' )
|
|
|
|
|
goto invalid_sexp;
|
|
|
|
|
endpos = s;
|
|
|
|
|
s++;
|
2007-08-28 17:48:13 +00:00
|
|
|
|
/* Intermezzo: Get the MIC */
|
2003-08-05 17:11:04 +00:00
|
|
|
|
if (*s != '(')
|
|
|
|
|
goto invalid_sexp;
|
|
|
|
|
s++;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!smatch (&s, n, "hash"))
|
|
|
|
|
goto invalid_sexp;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!smatch (&s, n, "sha1"))
|
|
|
|
|
goto invalid_sexp;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (n != 20)
|
|
|
|
|
goto invalid_sexp;
|
|
|
|
|
memcpy (sha1hash, s, 20);
|
|
|
|
|
s += n;
|
|
|
|
|
if (*s != ')')
|
|
|
|
|
goto invalid_sexp;
|
2007-08-28 17:48:13 +00:00
|
|
|
|
/* End intermezzo */
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
|
|
/* append the parameter list */
|
|
|
|
|
memcpy (p, startpos, endpos - startpos);
|
|
|
|
|
p += endpos - startpos;
|
|
|
|
|
|
2007-08-28 17:48:13 +00:00
|
|
|
|
/* Skip over the protected list element in the original list. */
|
2003-08-05 17:11:04 +00:00
|
|
|
|
s = protectedkey + replacepos;
|
|
|
|
|
assert (*s == '(');
|
|
|
|
|
s++;
|
|
|
|
|
i = 1;
|
|
|
|
|
rc = sskip (&s, &i);
|
|
|
|
|
if (rc)
|
|
|
|
|
goto failure;
|
2007-08-28 17:48:13 +00:00
|
|
|
|
/* Record the position of the optional protected-at expression. */
|
|
|
|
|
if (*s == '(')
|
|
|
|
|
{
|
|
|
|
|
const unsigned char *save_s = s;
|
|
|
|
|
s++;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (smatch (&s, n, "protected-at"))
|
|
|
|
|
{
|
|
|
|
|
i = 1;
|
|
|
|
|
rc = sskip (&s, &i);
|
|
|
|
|
if (rc)
|
|
|
|
|
goto failure;
|
|
|
|
|
*cutlen = s - save_s;
|
|
|
|
|
}
|
|
|
|
|
s = save_s;
|
|
|
|
|
}
|
2003-08-05 17:11:04 +00:00
|
|
|
|
startpos = s;
|
|
|
|
|
i = 2; /* we are inside this level */
|
|
|
|
|
rc = sskip (&s, &i);
|
|
|
|
|
if (rc)
|
|
|
|
|
goto failure;
|
|
|
|
|
assert (s[-1] == ')');
|
|
|
|
|
endpos = s; /* one behind the end of the list */
|
|
|
|
|
|
2007-08-28 17:48:13 +00:00
|
|
|
|
/* Append the rest. */
|
|
|
|
|
if (*cutlen)
|
|
|
|
|
*cutoff = p - newlist;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
memcpy (p, startpos, endpos - startpos);
|
|
|
|
|
p += endpos - startpos;
|
2007-08-28 17:48:13 +00:00
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
|
|
/* ready */
|
|
|
|
|
*result = newlist;
|
2004-02-03 16:24:37 +00:00
|
|
|
|
*resultlen = newlistlen;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
failure:
|
2004-02-03 16:24:37 +00:00
|
|
|
|
wipememory (newlist, newlistlen);
|
2003-08-05 17:11:04 +00:00
|
|
|
|
xfree (newlist);
|
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
|
|
invalid_sexp:
|
2004-02-03 16:24:37 +00:00
|
|
|
|
wipememory (newlist, newlistlen);
|
2003-08-05 17:11:04 +00:00
|
|
|
|
xfree (newlist);
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Unprotect the key encoded in canonical format. We assume a valid
|
2007-08-28 17:48:13 +00:00
|
|
|
|
S-Exp here. If a protected-at item is available, its value will
|
|
|
|
|
be stored at protocted_at unless this is NULL. */
|
2003-08-05 17:11:04 +00:00
|
|
|
|
int
|
|
|
|
|
agent_unprotect (const unsigned char *protectedkey, const char *passphrase,
|
2007-08-28 17:48:13 +00:00
|
|
|
|
gnupg_isotime_t protected_at,
|
2003-08-05 17:11:04 +00:00
|
|
|
|
unsigned char **result, size_t *resultlen)
|
|
|
|
|
{
|
|
|
|
|
int rc;
|
|
|
|
|
const unsigned char *s;
|
2007-08-28 17:48:13 +00:00
|
|
|
|
const unsigned char *protect_list;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
size_t n;
|
|
|
|
|
int infidx, i;
|
|
|
|
|
unsigned char sha1hash[20], sha1hash2[20];
|
|
|
|
|
const unsigned char *s2ksalt;
|
|
|
|
|
unsigned long s2kcount;
|
|
|
|
|
const unsigned char *iv;
|
|
|
|
|
const unsigned char *prot_begin;
|
|
|
|
|
unsigned char *cleartext;
|
|
|
|
|
unsigned char *final;
|
2004-02-03 16:24:37 +00:00
|
|
|
|
size_t finallen;
|
2007-08-28 17:48:13 +00:00
|
|
|
|
size_t cutoff, cutlen;
|
|
|
|
|
|
|
|
|
|
if (protected_at)
|
|
|
|
|
*protected_at = 0;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
|
|
s = protectedkey;
|
|
|
|
|
if (*s != '(')
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
s++;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
if (!smatch (&s, n, "protected-private-key"))
|
|
|
|
|
return gpg_error (GPG_ERR_UNKNOWN_SEXP);
|
|
|
|
|
if (*s != '(')
|
|
|
|
|
return gpg_error (GPG_ERR_UNKNOWN_SEXP);
|
|
|
|
|
s++;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
|
|
|
|
|
for (infidx=0; protect_info[infidx].algo
|
|
|
|
|
&& !smatch (&s, n, protect_info[infidx].algo); infidx++)
|
|
|
|
|
;
|
|
|
|
|
if (!protect_info[infidx].algo)
|
|
|
|
|
return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
|
|
|
|
|
|
2007-08-28 17:48:13 +00:00
|
|
|
|
|
|
|
|
|
/* See wether we have a protected-at timestamp. */
|
|
|
|
|
protect_list = s; /* Save for later. */
|
|
|
|
|
if (protected_at)
|
|
|
|
|
{
|
|
|
|
|
while (*s == '(')
|
|
|
|
|
{
|
|
|
|
|
prot_begin = s;
|
|
|
|
|
s++;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
if (smatch (&s, n, "protected-at"))
|
|
|
|
|
{
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
if (n != 15)
|
|
|
|
|
return gpg_error (GPG_ERR_UNKNOWN_SEXP);
|
|
|
|
|
memcpy (protected_at, s, 15);
|
|
|
|
|
protected_at[15] = 0;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
s += n;
|
|
|
|
|
i = 1;
|
|
|
|
|
rc = sskip (&s, &i);
|
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2004-02-03 16:24:37 +00:00
|
|
|
|
/* Now find the list with the protected information. Here is an
|
2003-08-05 17:11:04 +00:00
|
|
|
|
example for such a list:
|
|
|
|
|
(protected openpgp-s2k3-sha1-aes-cbc
|
|
|
|
|
((sha1 <salt> <count>) <Initialization_Vector>)
|
|
|
|
|
<encrypted_data>)
|
|
|
|
|
*/
|
2007-08-28 17:48:13 +00:00
|
|
|
|
s = protect_list;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
for (;;)
|
|
|
|
|
{
|
|
|
|
|
if (*s != '(')
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
prot_begin = s;
|
|
|
|
|
s++;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
if (smatch (&s, n, "protected"))
|
|
|
|
|
break;
|
|
|
|
|
s += n;
|
|
|
|
|
i = 1;
|
|
|
|
|
rc = sskip (&s, &i);
|
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
/* found */
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
if (!smatch (&s, n, "openpgp-s2k3-sha1-" PROT_CIPHER_STRING "-cbc"))
|
|
|
|
|
return gpg_error (GPG_ERR_UNSUPPORTED_PROTECTION);
|
|
|
|
|
if (*s != '(' || s[1] != '(')
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
s += 2;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
if (!smatch (&s, n, "sha1"))
|
|
|
|
|
return gpg_error (GPG_ERR_UNSUPPORTED_PROTECTION);
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (n != 8)
|
|
|
|
|
return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
|
|
|
|
|
s2ksalt = s;
|
|
|
|
|
s += n;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
|
|
|
|
|
/* We expect a list close as next, so we can simply use strtoul()
|
|
|
|
|
here. We might want to check that we only have digits - but this
|
|
|
|
|
is nothing we should worry about */
|
|
|
|
|
if (s[n] != ')' )
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
2009-12-14 20:12:56 +00:00
|
|
|
|
|
|
|
|
|
/* Old versions of gpg-agent used the funny floating point number in
|
|
|
|
|
a byte encoding as specified by OpenPGP. However this is not
|
|
|
|
|
needed and thus we now store it as a plain unsigned integer. We
|
|
|
|
|
can easily distinguish the old format by looking at its value:
|
|
|
|
|
Less than 256 is an old-style encoded number; other values are
|
|
|
|
|
plain integers. In any case we check that they are at least
|
|
|
|
|
65536 because we never used a lower value in the past and we
|
|
|
|
|
should have a lower limit. */
|
2005-06-16 08:12:03 +00:00
|
|
|
|
s2kcount = strtoul ((const char*)s, NULL, 10);
|
2003-08-05 17:11:04 +00:00
|
|
|
|
if (!s2kcount)
|
|
|
|
|
return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
|
2009-12-14 20:12:56 +00:00
|
|
|
|
if (s2kcount < 256)
|
|
|
|
|
s2kcount = (16ul + (s2kcount & 15)) << ((s2kcount >> 4) + 6);
|
|
|
|
|
if (s2kcount < 65536)
|
|
|
|
|
return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
|
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
|
s += n;
|
|
|
|
|
s++; /* skip list end */
|
|
|
|
|
|
|
|
|
|
n = snext (&s);
|
2004-02-03 16:24:37 +00:00
|
|
|
|
if (n != 16) /* Wrong blocksize for IV (we support only aes-128). */
|
2003-08-05 17:11:04 +00:00
|
|
|
|
return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
|
|
|
|
|
iv = s;
|
|
|
|
|
s += n;
|
|
|
|
|
if (*s != ')' )
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
s++;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
|
2009-12-08 16:30:33 +00:00
|
|
|
|
cleartext = NULL; /* Avoid cc warning. */
|
2003-08-05 17:11:04 +00:00
|
|
|
|
rc = do_decryption (s, n,
|
|
|
|
|
passphrase, s2ksalt, s2kcount,
|
|
|
|
|
iv, 16,
|
|
|
|
|
&cleartext);
|
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
|
|
rc = merge_lists (protectedkey, prot_begin-protectedkey, cleartext,
|
2007-08-28 17:48:13 +00:00
|
|
|
|
sha1hash, &final, &finallen, &cutoff, &cutlen);
|
2004-02-03 16:24:37 +00:00
|
|
|
|
/* Albeit cleartext has been allocated in secure memory and thus
|
|
|
|
|
xfree will wipe it out, we do an extra wipe just in case
|
|
|
|
|
somethings goes badly wrong. */
|
2004-09-28 14:12:10 +00:00
|
|
|
|
wipememory (cleartext, n);
|
2003-08-05 17:11:04 +00:00
|
|
|
|
xfree (cleartext);
|
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
|
|
rc = calculate_mic (final, sha1hash2);
|
|
|
|
|
if (!rc && memcmp (sha1hash, sha1hash2, 20))
|
|
|
|
|
rc = gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
|
|
|
|
|
if (rc)
|
|
|
|
|
{
|
2004-02-03 16:24:37 +00:00
|
|
|
|
wipememory (final, finallen);
|
2003-08-05 17:11:04 +00:00
|
|
|
|
xfree (final);
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
2010-10-01 20:33:53 +00:00
|
|
|
|
/* Now remove the part which is included in the MIC but should not
|
2007-08-28 17:48:13 +00:00
|
|
|
|
go into the final thing. */
|
|
|
|
|
if (cutlen)
|
|
|
|
|
{
|
|
|
|
|
memmove (final+cutoff, final+cutoff+cutlen, finallen-cutoff-cutlen);
|
|
|
|
|
finallen -= cutlen;
|
|
|
|
|
}
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
|
|
*result = final;
|
|
|
|
|
*resultlen = gcry_sexp_canon_len (final, 0, NULL, NULL);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Check the type of the private key, this is one of the constants:
|
|
|
|
|
PRIVATE_KEY_UNKNOWN if we can't figure out the type (this is the
|
|
|
|
|
value 0), PRIVATE_KEY_CLEAR for an unprotected private key.
|
|
|
|
|
PRIVATE_KEY_PROTECTED for an protected private key or
|
|
|
|
|
PRIVATE_KEY_SHADOWED for a sub key where the secret parts are stored
|
|
|
|
|
elsewhere. */
|
|
|
|
|
int
|
|
|
|
|
agent_private_key_type (const unsigned char *privatekey)
|
|
|
|
|
{
|
|
|
|
|
const unsigned char *s;
|
|
|
|
|
size_t n;
|
|
|
|
|
|
|
|
|
|
s = privatekey;
|
|
|
|
|
if (*s != '(')
|
|
|
|
|
return PRIVATE_KEY_UNKNOWN;
|
|
|
|
|
s++;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
return PRIVATE_KEY_UNKNOWN;
|
|
|
|
|
if (smatch (&s, n, "protected-private-key"))
|
|
|
|
|
return PRIVATE_KEY_PROTECTED;
|
|
|
|
|
if (smatch (&s, n, "shadowed-private-key"))
|
|
|
|
|
return PRIVATE_KEY_SHADOWED;
|
|
|
|
|
if (smatch (&s, n, "private-key"))
|
|
|
|
|
return PRIVATE_KEY_CLEAR;
|
|
|
|
|
return PRIVATE_KEY_UNKNOWN;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Transform a passphrase into a suitable key of length KEYLEN and
|
|
|
|
|
store this key in the caller provided buffer KEY. The caller must
|
|
|
|
|
provide an HASHALGO, a valid S2KMODE (see rfc-2440) and depending on
|
2009-12-14 20:12:56 +00:00
|
|
|
|
that mode an S2KSALT of 8 random bytes and an S2KCOUNT.
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
|
|
Returns an error code on failure. */
|
|
|
|
|
static int
|
|
|
|
|
hash_passphrase (const char *passphrase, int hashalgo,
|
|
|
|
|
int s2kmode,
|
|
|
|
|
const unsigned char *s2ksalt,
|
|
|
|
|
unsigned long s2kcount,
|
|
|
|
|
unsigned char *key, size_t keylen)
|
|
|
|
|
{
|
|
|
|
|
int rc;
|
|
|
|
|
gcry_md_hd_t md;
|
|
|
|
|
int pass, i;
|
|
|
|
|
int used = 0;
|
|
|
|
|
int pwlen = strlen (passphrase);
|
|
|
|
|
|
|
|
|
|
if ( (s2kmode != 0 && s2kmode != 1 && s2kmode != 3)
|
|
|
|
|
|| !hashalgo || !keylen || !key || !passphrase)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_VALUE);
|
|
|
|
|
if ((s2kmode == 1 ||s2kmode == 3) && !s2ksalt)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_VALUE);
|
|
|
|
|
|
|
|
|
|
rc = gcry_md_open (&md, hashalgo, GCRY_MD_FLAG_SECURE);
|
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
|
|
for (pass=0; used < keylen; pass++)
|
|
|
|
|
{
|
|
|
|
|
if (pass)
|
|
|
|
|
{
|
|
|
|
|
gcry_md_reset (md);
|
|
|
|
|
for (i=0; i < pass; i++) /* preset the hash context */
|
|
|
|
|
gcry_md_putc (md, 0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (s2kmode == 1 || s2kmode == 3)
|
|
|
|
|
{
|
|
|
|
|
int len2 = pwlen + 8;
|
|
|
|
|
unsigned long count = len2;
|
|
|
|
|
|
|
|
|
|
if (s2kmode == 3)
|
|
|
|
|
{
|
2009-12-14 20:12:56 +00:00
|
|
|
|
count = s2kcount;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
if (count < len2)
|
|
|
|
|
count = len2;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
while (count > len2)
|
|
|
|
|
{
|
|
|
|
|
gcry_md_write (md, s2ksalt, 8);
|
|
|
|
|
gcry_md_write (md, passphrase, pwlen);
|
|
|
|
|
count -= len2;
|
|
|
|
|
}
|
|
|
|
|
if (count < 8)
|
|
|
|
|
gcry_md_write (md, s2ksalt, count);
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
gcry_md_write (md, s2ksalt, 8);
|
|
|
|
|
count -= 8;
|
|
|
|
|
gcry_md_write (md, passphrase, count);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
gcry_md_write (md, passphrase, pwlen);
|
|
|
|
|
|
|
|
|
|
gcry_md_final (md);
|
|
|
|
|
i = gcry_md_get_algo_dlen (hashalgo);
|
|
|
|
|
if (i > keylen - used)
|
|
|
|
|
i = keylen - used;
|
|
|
|
|
memcpy (key+used, gcry_md_read (md, hashalgo), i);
|
|
|
|
|
used += i;
|
|
|
|
|
}
|
|
|
|
|
gcry_md_close(md);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-08-31 15:58:39 +00:00
|
|
|
|
gpg_error_t
|
|
|
|
|
s2k_hash_passphrase (const char *passphrase, int hashalgo,
|
|
|
|
|
int s2kmode,
|
|
|
|
|
const unsigned char *s2ksalt,
|
|
|
|
|
unsigned int s2kcount,
|
|
|
|
|
unsigned char *key, size_t keylen)
|
|
|
|
|
{
|
|
|
|
|
return hash_passphrase (passphrase, hashalgo, s2kmode, s2ksalt,
|
|
|
|
|
(16ul + (s2kcount & 15)) << ((s2kcount >> 4) + 6),
|
|
|
|
|
key, keylen);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
2005-02-25 16:14:55 +00:00
|
|
|
|
|
|
|
|
|
/* Create an canonical encoded S-expression with the shadow info from
|
|
|
|
|
a card's SERIALNO and the IDSTRING. */
|
|
|
|
|
unsigned char *
|
|
|
|
|
make_shadow_info (const char *serialno, const char *idstring)
|
|
|
|
|
{
|
|
|
|
|
const char *s;
|
2005-06-16 08:12:03 +00:00
|
|
|
|
char *info, *p;
|
2007-05-15 16:10:48 +00:00
|
|
|
|
char numbuf[20];
|
|
|
|
|
size_t n;
|
2005-02-25 16:14:55 +00:00
|
|
|
|
|
|
|
|
|
for (s=serialno, n=0; *s && s[1]; s += 2)
|
|
|
|
|
n++;
|
|
|
|
|
|
2007-05-15 16:10:48 +00:00
|
|
|
|
info = p = xtrymalloc (1 + sizeof numbuf + n
|
|
|
|
|
+ sizeof numbuf + strlen (idstring) + 1 + 1);
|
2005-02-25 16:14:55 +00:00
|
|
|
|
if (!info)
|
|
|
|
|
return NULL;
|
|
|
|
|
*p++ = '(';
|
2007-05-15 16:10:48 +00:00
|
|
|
|
p = stpcpy (p, smklen (numbuf, sizeof numbuf, n, NULL));
|
2005-02-25 16:14:55 +00:00
|
|
|
|
for (s=serialno; *s && s[1]; s += 2)
|
2005-06-16 08:12:03 +00:00
|
|
|
|
*(unsigned char *)p++ = xtoi_2 (s);
|
2007-05-15 16:10:48 +00:00
|
|
|
|
p = stpcpy (p, smklen (numbuf, sizeof numbuf, strlen (idstring), NULL));
|
2005-02-25 16:14:55 +00:00
|
|
|
|
p = stpcpy (p, idstring);
|
|
|
|
|
*p++ = ')';
|
|
|
|
|
*p = 0;
|
2005-06-16 08:12:03 +00:00
|
|
|
|
return (unsigned char *)info;
|
2005-02-25 16:14:55 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
|
/* Create a shadow key from a public key. We use the shadow protocol
|
|
|
|
|
"ti-v1" and insert the S-expressionn SHADOW_INFO. The resulting
|
|
|
|
|
S-expression is returned in an allocated buffer RESULT will point
|
2005-02-25 16:14:55 +00:00
|
|
|
|
to. The input parameters are expected to be valid canonicalized
|
2003-08-05 17:11:04 +00:00
|
|
|
|
S-expressions */
|
|
|
|
|
int
|
|
|
|
|
agent_shadow_key (const unsigned char *pubkey,
|
|
|
|
|
const unsigned char *shadow_info,
|
|
|
|
|
unsigned char **result)
|
|
|
|
|
{
|
|
|
|
|
const unsigned char *s;
|
|
|
|
|
const unsigned char *point;
|
|
|
|
|
size_t n;
|
|
|
|
|
int depth = 0;
|
2005-06-16 08:12:03 +00:00
|
|
|
|
char *p;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
size_t pubkey_len = gcry_sexp_canon_len (pubkey, 0, NULL,NULL);
|
|
|
|
|
size_t shadow_info_len = gcry_sexp_canon_len (shadow_info, 0, NULL,NULL);
|
|
|
|
|
|
|
|
|
|
if (!pubkey_len || !shadow_info_len)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_VALUE);
|
|
|
|
|
s = pubkey;
|
|
|
|
|
if (*s != '(')
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
depth++;
|
|
|
|
|
s++;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
if (!smatch (&s, n, "public-key"))
|
|
|
|
|
return gpg_error (GPG_ERR_UNKNOWN_SEXP);
|
|
|
|
|
if (*s != '(')
|
|
|
|
|
return gpg_error (GPG_ERR_UNKNOWN_SEXP);
|
|
|
|
|
depth++;
|
|
|
|
|
s++;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
s += n; /* skip over the algorithm name */
|
|
|
|
|
|
|
|
|
|
while (*s != ')')
|
|
|
|
|
{
|
|
|
|
|
if (*s != '(')
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
depth++;
|
|
|
|
|
s++;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
s += n;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
s +=n; /* skip value */
|
|
|
|
|
if (*s != ')')
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
depth--;
|
|
|
|
|
s++;
|
|
|
|
|
}
|
|
|
|
|
point = s; /* insert right before the point */
|
|
|
|
|
depth--;
|
|
|
|
|
s++;
|
|
|
|
|
assert (depth == 1);
|
|
|
|
|
|
2005-02-25 16:14:55 +00:00
|
|
|
|
/* Calculate required length by taking in account: the "shadowed-"
|
2003-08-05 17:11:04 +00:00
|
|
|
|
prefix, the "shadowed", "t1-v1" as well as some parenthesis */
|
|
|
|
|
n = 12 + pubkey_len + 1 + 3+8 + 2+5 + shadow_info_len + 1;
|
2005-06-16 08:12:03 +00:00
|
|
|
|
*result = xtrymalloc (n);
|
|
|
|
|
p = (char*)*result;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
if (!p)
|
|
|
|
|
return out_of_core ();
|
|
|
|
|
p = stpcpy (p, "(20:shadowed-private-key");
|
|
|
|
|
/* (10:public-key ...)*/
|
|
|
|
|
memcpy (p, pubkey+14, point - (pubkey+14));
|
|
|
|
|
p += point - (pubkey+14);
|
|
|
|
|
p = stpcpy (p, "(8:shadowed5:t1-v1");
|
|
|
|
|
memcpy (p, shadow_info, shadow_info_len);
|
|
|
|
|
p += shadow_info_len;
|
|
|
|
|
*p++ = ')';
|
|
|
|
|
memcpy (p, point, pubkey_len - (point - pubkey));
|
|
|
|
|
p += pubkey_len - (point - pubkey);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Parse a canonical encoded shadowed key and return a pointer to the
|
|
|
|
|
inner list with the shadow_info */
|
|
|
|
|
int
|
|
|
|
|
agent_get_shadow_info (const unsigned char *shadowkey,
|
|
|
|
|
unsigned char const **shadow_info)
|
|
|
|
|
{
|
|
|
|
|
const unsigned char *s;
|
|
|
|
|
size_t n;
|
|
|
|
|
int depth = 0;
|
|
|
|
|
|
|
|
|
|
s = shadowkey;
|
|
|
|
|
if (*s != '(')
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
depth++;
|
|
|
|
|
s++;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
if (!smatch (&s, n, "shadowed-private-key"))
|
|
|
|
|
return gpg_error (GPG_ERR_UNKNOWN_SEXP);
|
|
|
|
|
if (*s != '(')
|
|
|
|
|
return gpg_error (GPG_ERR_UNKNOWN_SEXP);
|
|
|
|
|
depth++;
|
|
|
|
|
s++;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
s += n; /* skip over the algorithm name */
|
|
|
|
|
|
|
|
|
|
for (;;)
|
|
|
|
|
{
|
|
|
|
|
if (*s == ')')
|
|
|
|
|
return gpg_error (GPG_ERR_UNKNOWN_SEXP);
|
|
|
|
|
if (*s != '(')
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
depth++;
|
|
|
|
|
s++;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
if (smatch (&s, n, "shadowed"))
|
|
|
|
|
break;
|
|
|
|
|
s += n;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
s +=n; /* skip value */
|
|
|
|
|
if (*s != ')')
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
depth--;
|
|
|
|
|
s++;
|
|
|
|
|
}
|
2004-02-03 16:24:37 +00:00
|
|
|
|
/* Found the shadowed list, S points to the protocol */
|
2003-08-05 17:11:04 +00:00
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
if (smatch (&s, n, "t1-v1"))
|
|
|
|
|
{
|
|
|
|
|
if (*s != '(')
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
*shadow_info = s;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
return gpg_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2009-03-06 17:31:27 +00:00
|
|
|
|
|
|
|
|
|
/* Parse the canonical encoded SHADOW_INFO S-expression. On success
|
|
|
|
|
the hex encoded serial number is returned as a malloced strings at
|
|
|
|
|
R_HEXSN and the Id string as a malloced string at R_IDSTR. On
|
|
|
|
|
error an error code is returned and NULL is stored at the result
|
|
|
|
|
parameters addresses. If the serial number or the ID string is not
|
|
|
|
|
required, NULL may be passed for them. */
|
|
|
|
|
gpg_error_t
|
|
|
|
|
parse_shadow_info (const unsigned char *shadow_info,
|
|
|
|
|
char **r_hexsn, char **r_idstr)
|
|
|
|
|
{
|
|
|
|
|
const unsigned char *s;
|
|
|
|
|
size_t n;
|
|
|
|
|
|
|
|
|
|
if (r_hexsn)
|
|
|
|
|
*r_hexsn = NULL;
|
|
|
|
|
if (r_idstr)
|
|
|
|
|
*r_idstr = NULL;
|
|
|
|
|
|
|
|
|
|
s = shadow_info;
|
|
|
|
|
if (*s != '(')
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
s++;
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
|
|
|
|
|
if (r_hexsn)
|
|
|
|
|
{
|
|
|
|
|
*r_hexsn = bin2hex (s, n, NULL);
|
|
|
|
|
if (!*r_hexsn)
|
|
|
|
|
return gpg_error_from_syserror ();
|
|
|
|
|
}
|
|
|
|
|
s += n;
|
|
|
|
|
|
|
|
|
|
n = snext (&s);
|
|
|
|
|
if (!n)
|
|
|
|
|
{
|
|
|
|
|
if (r_hexsn)
|
|
|
|
|
{
|
|
|
|
|
xfree (*r_hexsn);
|
|
|
|
|
*r_hexsn = NULL;
|
|
|
|
|
}
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (r_idstr)
|
|
|
|
|
{
|
|
|
|
|
*r_idstr = xtrymalloc (n+1);
|
|
|
|
|
if (!*r_idstr)
|
|
|
|
|
{
|
|
|
|
|
if (r_hexsn)
|
|
|
|
|
{
|
|
|
|
|
xfree (*r_hexsn);
|
|
|
|
|
*r_hexsn = NULL;
|
|
|
|
|
}
|
|
|
|
|
return gpg_error_from_syserror ();
|
|
|
|
|
}
|
|
|
|
|
memcpy (*r_idstr, s, n);
|
|
|
|
|
(*r_idstr)[n] = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|