* call-scd.c (inq_needpin): Skip leading spaces in of PIN
[gnupg.git] / agent / protect.c
index 08f322b..658c8c5 100644 (file)
@@ -1,5 +1,6 @@
 /* protect.c - Un/Protect a secret key
- * Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002,
+ *               2003 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
@@ -45,6 +46,8 @@ static struct {
   int prot_from, prot_to;
 } protect_info[] = {
   { "rsa",  "nedpqu", 2, 5 },
+  { "dsa",  "pqgyx", 4, 4 },
+  { "elg",  "pgyx", 3, 3 },
   { NULL }
 };
 
@@ -57,7 +60,7 @@ hash_passphrase (const char *passphrase, int hashalgo,
 
 
 \f
-/* Calculate the MIC for a private key S-Exp. SHA1HASH should pint to
+/* Calculate the MIC for a private key S-Exp. SHA1HASH should point to
    a 20 byte buffer.  This function is suitable for any algorithms. */
 static int 
 calculate_mic (const unsigned char *plainkey, unsigned char *sha1hash)
@@ -68,20 +71,20 @@ calculate_mic (const unsigned char *plainkey, unsigned char *sha1hash)
 
   s = plainkey;
   if (*s != '(')
-    return GNUPG_Invalid_Sexp;
+    return gpg_error (GPG_ERR_INV_SEXP);
   s++;
   n = snext (&s);
   if (!n)
-    return GNUPG_Invalid_Sexp
+    return gpg_error (GPG_ERR_INV_SEXP)
   if (!smatch (&s, n, "private-key"))
-    return GNUPG_Unknown_Sexp
+    return gpg_error (GPG_ERR_UNKNOWN_SEXP)
   if (*s != '(')
-    return GNUPG_Unknown_Sexp;
+    return gpg_error (GPG_ERR_UNKNOWN_SEXP);
   hash_begin = s;
   s++;
   n = snext (&s);
   if (!n)
-    return GNUPG_Invalid_Sexp
+    return gpg_error (GPG_ERR_INV_SEXP)
   s += n; /* skip over the algorithm name */
 
   while (*s == '(')
@@ -89,18 +92,18 @@ calculate_mic (const unsigned char *plainkey, unsigned char *sha1hash)
       s++;
       n = snext (&s);
       if (!n)
-        return GNUPG_Invalid_Sexp
+        return gpg_error (GPG_ERR_INV_SEXP)
       s += n;
       n = snext (&s);
       if (!n)
-        return GNUPG_Invalid_Sexp
+        return gpg_error (GPG_ERR_INV_SEXP)
       s += n;
       if ( *s != ')' )
-        return GNUPG_Invalid_Sexp
+        return gpg_error (GPG_ERR_INV_SEXP)
       s++;
     }
   if (*s != ')')
-    return GNUPG_Invalid_Sexp
+    return gpg_error (GPG_ERR_INV_SEXP)
   s++;
   hash_end = s;
 
@@ -114,7 +117,7 @@ calculate_mic (const unsigned char *plainkey, unsigned char *sha1hash)
 \f
 /* Encrypt the parameter block starting at PROTBEGIN with length
    PROTLEN using the utf8 encoded key PASSPHRASE and return the entire
-   encrypted block in RESULT or ereturn with an error code.  SHA1HASH
+   encrypted block in RESULT or return with an error code.  SHA1HASH
    is the 20 byte SHA-1 hash required for the integrity code.
 
    The parameter block is expected to be an incomplete S-Expression of
@@ -135,19 +138,19 @@ do_encryption (const char *protbegin, size_t protlen,
                const char *passphrase,  const unsigned char *sha1hash,
                unsigned char **result, size_t *resultlen)
 {
-  GCRY_CIPHER_HD hd;
+  gcry_cipher_hd_t hd;
   const char *modestr = "openpgp-s2k3-sha1-" PROT_CIPHER_STRING "-cbc";
   int blklen, enclen, outlen;
   char *iv = NULL;
-  int rc = 0;
+  int rc;
   char *outbuf = NULL;
   char *p;
   int saltpos, ivpos, encpos;
 
-  hd = gcry_cipher_open (PROT_CIPHER, GCRY_CIPHER_MODE_CBC,
+  rc = gcry_cipher_open (&hd, PROT_CIPHER, GCRY_CIPHER_MODE_CBC,
                          GCRY_CIPHER_SECURE);
-  if (!hd)
-    return map_gcry_err (gcry_errno());
+  if (rc)
+    return rc;
 
 
   /* We need to work on a copy of the data because this makes it
@@ -164,15 +167,15 @@ do_encryption (const char *protbegin, size_t protlen,
   enclen = outlen/blklen * blklen;
   outbuf = gcry_malloc_secure (outlen);
   if (!outbuf)
-    rc = GNUPG_Out_Of_Core;
+    rc = out_of_core ();
   if (!rc)
     {
-      /* allocate random bytes to be used as IV, padding and s2k salt*/
-      iv = gcry_random_bytes (blklen*2+8, GCRY_WEAK_RANDOM);
+      /* Allocate random bytes to be used as IV, padding and s2k salt. */
+      iv = xtrymalloc (blklen*2+8);
       if (!iv)
-        rc = GNUPG_Out_Of_Core;
-      else
-        rc = gcry_cipher_setiv (hd, iv, blklen);
+        rc = gpg_error (GPG_ERR_ENOMEM);
+      gcry_create_nonce (iv, blklen*2+8);
+      rc = gcry_cipher_setiv (hd, iv, blklen);
     }
   if (!rc)
     {
@@ -181,7 +184,7 @@ do_encryption (const char *protbegin, size_t protlen,
       
       key = gcry_malloc_secure (keylen);
       if (!key)
-        rc = GNUPG_Out_Of_Core;
+        rc = out_of_core ();
       else
         {
           rc = hash_passphrase (passphrase, GCRY_MD_SHA1,
@@ -232,7 +235,7 @@ do_encryption (const char *protbegin, size_t protlen,
             blklen, &ivpos, blklen, "",
             enclen, &encpos, enclen, "");
   if (p)
-    { /* asprintf does not use out malloc system */
+    { /* asprintf does not use our malloc system */
       char *psave = p;
       p = xtrymalloc (strlen (psave)+1);
       if (p)
@@ -241,9 +244,10 @@ do_encryption (const char *protbegin, size_t protlen,
     }
   if (!p)
     {
+      gpg_error_t tmperr = out_of_core ();
       xfree (iv);
       xfree (outbuf);
-      return GNUPG_Out_Of_Core;
+      return tmperr;
     }
   *resultlen = strlen (p);
   *result = p;
@@ -277,28 +281,28 @@ agent_protect (const unsigned char *plainkey, const char *passphrase,
 
   s = plainkey;
   if (*s != '(')
-    return GNUPG_Invalid_Sexp;
+    return gpg_error (GPG_ERR_INV_SEXP);
   depth++;
   s++;
   n = snext (&s);
   if (!n)
-    return GNUPG_Invalid_Sexp
+    return gpg_error (GPG_ERR_INV_SEXP)
   if (!smatch (&s, n, "private-key"))
-    return GNUPG_Unknown_Sexp
+    return gpg_error (GPG_ERR_UNKNOWN_SEXP)
   if (*s != '(')
-    return GNUPG_Unknown_Sexp;
+    return gpg_error (GPG_ERR_UNKNOWN_SEXP);
   depth++;
   hash_begin = s;
   s++;
   n = snext (&s);
   if (!n)
-    return GNUPG_Invalid_Sexp
+    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 GNUPG_Unsupported_Algorithm
+    return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM)
 
   prot_begin = prot_end = NULL;
   for (i=0; (c=protect_info[infidx].parmlist[i]); i++)
@@ -306,28 +310,28 @@ agent_protect (const unsigned char *plainkey, const char *passphrase,
       if (i == protect_info[infidx].prot_from)
         prot_begin = s;
       if (*s != '(')
-        return GNUPG_Invalid_Sexp;
+        return gpg_error (GPG_ERR_INV_SEXP);
       depth++;
       s++;
       n = snext (&s);
       if (!n)
-        return GNUPG_Invalid_Sexp
+        return gpg_error (GPG_ERR_INV_SEXP)
       if (n != 1 || c != *s)
-        return GNUPG_Invalid_Sexp
+        return gpg_error (GPG_ERR_INV_SEXP)
       s += n;
       n = snext (&s);
       if (!n)
-        return GNUPG_Invalid_Sexp
+        return gpg_error (GPG_ERR_INV_SEXP)
       s +=n; /* skip value */
       if (*s != ')')
-        return GNUPG_Invalid_Sexp
+        return gpg_error (GPG_ERR_INV_SEXP)
       depth--;
       if (i == protect_info[infidx].prot_to)
         prot_end = s;
       s++;
     }
   if (*s != ')' || !prot_begin || !prot_end )
-    return GNUPG_Invalid_Sexp
+    return gpg_error (GPG_ERR_INV_SEXP)
   depth--;
   hash_end = s;
   s++;
@@ -358,8 +362,9 @@ agent_protect (const unsigned char *plainkey, const char *passphrase,
   *result = p = xtrymalloc (*resultlen);
   if (!p)
     {
+      gpg_error_t tmperr = out_of_core ();
       xfree (protected);
-      return GNUPG_Out_Of_Core;
+      return tmperr;
     }
   memcpy (p, "(21:protected-", 14);
   p += 14;
@@ -385,22 +390,22 @@ do_decryption (const unsigned char *protected, size_t protectedlen,
 {
   int rc = 0;
   int blklen;
-  GCRY_CIPHER_HD hd;
+  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 GNUPG_Corrupted_Protection;
+    return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
 
-  hd = gcry_cipher_open (PROT_CIPHER, GCRY_CIPHER_MODE_CBC,
+  rc = gcry_cipher_open (&hd, PROT_CIPHER, GCRY_CIPHER_MODE_CBC,
                          GCRY_CIPHER_SECURE);
-  if (!hd)
-    return map_gcry_err (gcry_errno());
+  if (rc)
+    return rc;
 
   outbuf = gcry_malloc_secure (protectedlen);
   if (!outbuf)
-    rc = GNUPG_Out_Of_Core;
+    rc = out_of_core ();
   if (!rc)
     rc = gcry_cipher_setiv (hd, iv, ivlen);
   if (!rc)
@@ -410,7 +415,7 @@ do_decryption (const unsigned char *protected, size_t protectedlen,
       
       key = gcry_malloc_secure (keylen);
       if (!key)
-        rc = GNUPG_Out_Of_Core;
+        rc = out_of_core ();
       else
         {
           rc = hash_passphrase (passphrase, GCRY_MD_SHA1,
@@ -429,18 +434,18 @@ do_decryption (const unsigned char *protected, size_t protectedlen,
       xfree (outbuf);
       return rc;
     }
-  /* do a quick check first */
+  /* Do a quick check first. */
   if (*outbuf != '(' && outbuf[1] != '(')
     {
       xfree (outbuf);
-      return GNUPG_Bad_Passphrase;
+      return gpg_error (GPG_ERR_BAD_PASSPHRASE);
     }
-  /* check that we have a consistent S-Exp */
+  /* Check that we have a consistent S-Exp. */
   reallen = gcry_sexp_canon_len (outbuf, protectedlen, NULL, NULL);
   if (!reallen || (reallen + blklen < protectedlen) )
     {
       xfree (outbuf);
-      return GNUPG_Bad_Passphrase;
+      return gpg_error (GPG_ERR_BAD_PASSPHRASE);
     }
   *result = outbuf;
   return 0;
@@ -455,7 +460,8 @@ static int
 merge_lists (const unsigned char *protectedkey,
              size_t replacepos, 
              const unsigned char *cleartext,
-             unsigned char *sha1hash, unsigned char **result)
+             unsigned char *sha1hash,
+             unsigned char **result, size_t *resultlen)
 {
   size_t n, newlistlen;
   unsigned char *newlist, *p;
@@ -464,21 +470,21 @@ merge_lists (const unsigned char *protectedkey,
   int i, rc;
   
   if (replacepos < 26)
-    return GNUPG_Bug;
+    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 GNUPG_Bug;
+    return gpg_error (GPG_ERR_BUG);
   n = gcry_sexp_canon_len (cleartext, 0, NULL, NULL);
   if (!n)
-    return GNUPG_Bug;
+    return gpg_error (GPG_ERR_BUG);
   newlistlen += n;
   newlist = gcry_malloc_secure (newlistlen);
   if (!newlist)
-    return GNUPG_Out_Of_Core;
+    return out_of_core ();
 
   /* Copy the initial segment */
   strcpy (newlist, "(11:private-key");
@@ -489,7 +495,7 @@ merge_lists (const unsigned char *protectedkey,
   /* copy the cleartext */
   s = cleartext;
   if (*s != '(' && s[1] != '(')
-    return GNUPG_Bug;  /*we already checked this */
+    return gpg_error (GPG_ERR_BUG);  /*we already checked this */
   s += 2;
   startpos = s;
   while ( *s == '(' )
@@ -556,15 +562,18 @@ merge_lists (const unsigned char *protectedkey,
 
   /* ready */
   *result = newlist;
+  *resultlen = newlistlen;
   return 0;
 
  failure:
+  wipememory (newlist, newlistlen);
   xfree (newlist);
   return rc;
 
  invalid_sexp:
+  wipememory (newlist, newlistlen);
   xfree (newlist);
-  return GNUPG_Invalid_Sexp;
+  return gpg_error (GPG_ERR_INV_SEXP);
 }
 
 
@@ -586,30 +595,31 @@ agent_unprotect (const unsigned char *protectedkey, const char *passphrase,
   const unsigned char *prot_begin;
   unsigned char *cleartext;
   unsigned char *final;
+  size_t finallen;
 
   s = protectedkey;
   if (*s != '(')
-    return GNUPG_Invalid_Sexp;
+    return gpg_error (GPG_ERR_INV_SEXP);
   s++;
   n = snext (&s);
   if (!n)
-    return GNUPG_Invalid_Sexp
+    return gpg_error (GPG_ERR_INV_SEXP)
   if (!smatch (&s, n, "protected-private-key"))
-    return GNUPG_Unknown_Sexp
+    return gpg_error (GPG_ERR_UNKNOWN_SEXP)
   if (*s != '(')
-    return GNUPG_Unknown_Sexp;
+    return gpg_error (GPG_ERR_UNKNOWN_SEXP);
   s++;
   n = snext (&s);
   if (!n)
-    return GNUPG_Invalid_Sexp
+    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 GNUPG_Unsupported_Algorithm
+    return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM)
 
-  /* now find the list with the protected information.  Here is an
+  /* Now find the list with the protected information.  Here is an
      example for such a list:
      (protected openpgp-s2k3-sha1-aes-cbc 
         ((sha1 <salt> <count>) <Initialization_Vector>)
@@ -618,12 +628,12 @@ agent_unprotect (const unsigned char *protectedkey, const char *passphrase,
   for (;;)
     {
       if (*s != '(')
-        return GNUPG_Invalid_Sexp;
+        return gpg_error (GPG_ERR_INV_SEXP);
       prot_begin = s;
       s++;
       n = snext (&s);
       if (!n)
-        return GNUPG_Invalid_Sexp
+        return gpg_error (GPG_ERR_INV_SEXP)
       if (smatch (&s, n, "protected"))
         break;
       s += n;
@@ -635,47 +645,47 @@ agent_unprotect (const unsigned char *protectedkey, const char *passphrase,
   /* found */
   n = snext (&s);
   if (!n)
-    return GNUPG_Invalid_Sexp
+    return gpg_error (GPG_ERR_INV_SEXP)
   if (!smatch (&s, n, "openpgp-s2k3-sha1-" PROT_CIPHER_STRING "-cbc"))
-    return GNUPG_Unsupported_Protection;
+    return gpg_error (GPG_ERR_UNSUPPORTED_PROTECTION);
   if (*s != '(' || s[1] != '(')
-    return GNUPG_Invalid_Sexp;
+    return gpg_error (GPG_ERR_INV_SEXP);
   s += 2;
   n = snext (&s);
   if (!n)
-    return GNUPG_Invalid_Sexp
+    return gpg_error (GPG_ERR_INV_SEXP)
   if (!smatch (&s, n, "sha1"))
-    return GNUPG_Unsupported_Protection;
+    return gpg_error (GPG_ERR_UNSUPPORTED_PROTECTION);
   n = snext (&s);
   if (n != 8)
-    return GNUPG_Corrupted_Protection;
+    return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
   s2ksalt = s;
   s += n;
   n = snext (&s);
   if (!n)
-    return GNUPG_Corrupted_Protection;
+    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 GNUPG_Invalid_Sexp;
+    return gpg_error (GPG_ERR_INV_SEXP);
   s2kcount = strtoul (s, NULL, 10);
   if (!s2kcount)
-    return GNUPG_Corrupted_Protection;
+    return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
   s += n;
   s++; /* skip list end */
 
   n = snext (&s);
-  if (n != 16) /* Wrong blocksize for IV (we support ony aes-128) */
-    return GNUPG_Corrupted_Protection;
+  if (n != 16) /* Wrong blocksize for IV (we support only aes-128). */
+    return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
   iv = s;
   s += n;
   if (*s != ')' )
-    return GNUPG_Invalid_Sexp;
+    return gpg_error (GPG_ERR_INV_SEXP);
   s++;
   n = snext (&s);
   if (!n)
-    return GNUPG_Invalid_Sexp
+    return gpg_error (GPG_ERR_INV_SEXP)
   
   rc = do_decryption (s, n,
                       passphrase, s2ksalt, s2kcount,
@@ -685,16 +695,21 @@ agent_unprotect (const unsigned char *protectedkey, const char *passphrase,
     return rc;
 
   rc = merge_lists (protectedkey, prot_begin-protectedkey, cleartext,
-                    sha1hash, &final);
+                    sha1hash, &final, &finallen);
+  /* 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. */
+  wipememory (cleartext, n);
   xfree (cleartext);
   if (rc)
     return rc;
 
   rc = calculate_mic (final, sha1hash2);
   if (!rc && memcmp (sha1hash, sha1hash2, 20))
-    rc = GNUPG_Corrupted_Protection;
+    rc = gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
   if (rc)
     {
+      wipememory (final, finallen);
       xfree (final);
       return rc;
     }
@@ -748,20 +763,21 @@ hash_passphrase (const char *passphrase, int hashalgo,
                  unsigned long s2kcount,
                  unsigned char *key, size_t keylen)
 {
-  GCRY_MD_HD md;
+  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 GNUPG_Invalid_Value;
+    return gpg_error (GPG_ERR_INV_VALUE);
   if ((s2kmode == 1 ||s2kmode == 3) && !s2ksalt)
-    return GNUPG_Invalid_Value;
+    return gpg_error (GPG_ERR_INV_VALUE);
   
-  md = gcry_md_open (hashalgo, GCRY_MD_FLAG_SECURE);
-  if (!md)
-    return map_gcry_err (gcry_errno());
+  rc = gcry_md_open (&md, hashalgo, GCRY_MD_FLAG_SECURE);
+  if (rc)
+    return rc;
 
   for (pass=0; used < keylen; pass++)
     {
@@ -815,10 +831,43 @@ hash_passphrase (const char *passphrase, int hashalgo,
 
 
 \f
+
+/* 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;
+  unsigned char *info, *p;
+  char numbuf[21];
+  int n;
+
+  for (s=serialno, n=0; *s && s[1]; s += 2)
+    n++;
+
+  info = p = xtrymalloc (1 + 21 + n
+                           + 21 + strlen (idstring) + 1 + 1);
+  if (!info)
+    return NULL;
+  *p++ = '(';
+  sprintf (numbuf, "%d:", n);
+  p = stpcpy (p, numbuf);
+  for (s=serialno; *s && s[1]; s += 2)
+    *p++ = xtoi_2 (s);
+  sprintf (numbuf, "%d:", strlen (idstring));
+  p = stpcpy (p, numbuf);
+  p = stpcpy (p, idstring);
+  *p++ = ')';
+  *p = 0;
+  return info;
+}
+
+
+
 /* 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
-  to. The input parameters are expected to be valid canonilized
+  to. The input parameters are expected to be valid canonicalized
   S-expressions */
 int 
 agent_shadow_key (const unsigned char *pubkey,
@@ -834,42 +883,42 @@ agent_shadow_key (const unsigned char *pubkey,
   size_t shadow_info_len = gcry_sexp_canon_len (shadow_info, 0, NULL,NULL);
 
   if (!pubkey_len || !shadow_info_len)
-    return GNUPG_Invalid_Value;
+    return gpg_error (GPG_ERR_INV_VALUE);
   s = pubkey;
   if (*s != '(')
-    return GNUPG_Invalid_Sexp;
+    return gpg_error (GPG_ERR_INV_SEXP);
   depth++;
   s++;
   n = snext (&s);
   if (!n)
-    return GNUPG_Invalid_Sexp
+    return gpg_error (GPG_ERR_INV_SEXP)
   if (!smatch (&s, n, "public-key"))
-    return GNUPG_Unknown_Sexp
+    return gpg_error (GPG_ERR_UNKNOWN_SEXP)
   if (*s != '(')
-    return GNUPG_Unknown_Sexp;
+    return gpg_error (GPG_ERR_UNKNOWN_SEXP);
   depth++;
   s++;
   n = snext (&s); 
   if (!n)
-    return GNUPG_Invalid_Sexp
+    return gpg_error (GPG_ERR_INV_SEXP)
   s += n; /* skip over the algorithm name */
 
   while (*s != ')')
     {
       if (*s != '(')
-        return GNUPG_Invalid_Sexp;
+        return gpg_error (GPG_ERR_INV_SEXP);
       depth++;
       s++;
       n = snext (&s);
       if (!n) 
-        return GNUPG_Invalid_Sexp
+        return gpg_error (GPG_ERR_INV_SEXP)
       s += n;
       n = snext (&s);
       if (!n)
-        return GNUPG_Invalid_Sexp
+        return gpg_error (GPG_ERR_INV_SEXP)
       s +=n; /* skip value */
       if (*s != ')')
-        return GNUPG_Invalid_Sexp
+        return gpg_error (GPG_ERR_INV_SEXP)
       depth--;
       s++;
     }
@@ -878,12 +927,12 @@ agent_shadow_key (const unsigned char *pubkey,
   s++;
   assert (depth == 1);
 
-  /* calculate required length by taking in account: the "shadowed-"
+  /* Calculate required length by taking in account: the "shadowed-"
      prefix, the "shadowed", "t1-v1" as well as some parenthesis */
   n = 12 + pubkey_len + 1 + 3+8 + 2+5 + shadow_info_len + 1;
   *result = p = xtrymalloc (n);
   if (!p)
-      return GNUPG_Out_Of_Core;
+      return out_of_core ();
   p = stpcpy (p, "(20:shadowed-private-key");
   /* (10:public-key ...)*/
   memcpy (p, pubkey+14, point - (pubkey+14));
@@ -910,58 +959,58 @@ agent_get_shadow_info (const unsigned char *shadowkey,
 
   s = shadowkey;
   if (*s != '(')
-    return GNUPG_Invalid_Sexp;
+    return gpg_error (GPG_ERR_INV_SEXP);
   depth++;
   s++;
   n = snext (&s);
   if (!n)
-    return GNUPG_Invalid_Sexp
+    return gpg_error (GPG_ERR_INV_SEXP)
   if (!smatch (&s, n, "shadowed-private-key"))
-    return GNUPG_Unknown_Sexp
+    return gpg_error (GPG_ERR_UNKNOWN_SEXP)
   if (*s != '(')
-    return GNUPG_Unknown_Sexp;
+    return gpg_error (GPG_ERR_UNKNOWN_SEXP);
   depth++;
   s++;
   n = snext (&s); 
   if (!n)
-    return GNUPG_Invalid_Sexp
+    return gpg_error (GPG_ERR_INV_SEXP)
   s += n; /* skip over the algorithm name */
 
   for (;;)
     {
       if (*s == ')')
-        return GNUPG_Unknown_Sexp;
+        return gpg_error (GPG_ERR_UNKNOWN_SEXP);
       if (*s != '(')
-        return GNUPG_Invalid_Sexp;
+        return gpg_error (GPG_ERR_INV_SEXP);
       depth++;
       s++;
       n = snext (&s);
       if (!n) 
-        return GNUPG_Invalid_Sexp
+        return gpg_error (GPG_ERR_INV_SEXP)
       if (smatch (&s, n, "shadowed"))
         break;
       s += n;
       n = snext (&s);
       if (!n)
-        return GNUPG_Invalid_Sexp
+        return gpg_error (GPG_ERR_INV_SEXP)
       s +=n; /* skip value */
       if (*s != ')')
-        return GNUPG_Invalid_Sexp
+        return gpg_error (GPG_ERR_INV_SEXP)
       depth--;
       s++;
     }
-  /* found the shadowed list, s points to the protocol */
+  /* Found the shadowed list, S points to the protocol */
   n = snext (&s);
   if (!n) 
-    return GNUPG_Invalid_Sexp
+    return gpg_error (GPG_ERR_INV_SEXP)
   if (smatch (&s, n, "t1-v1"))
     {
       if (*s != '(')
-        return GNUPG_Invalid_Sexp;
+        return gpg_error (GPG_ERR_INV_SEXP);
       *shadow_info = s;
     }
   else
-    return GNUPG_Unsupported_Protocol;
+    return gpg_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
   return 0;
 }