* protect-tool.c: New option --enable-status-msg.
[gnupg.git] / sm / fingerprint.c
index a8edf6f..6755f8e 100644 (file)
 #include <time.h>
 #include <assert.h>
 
-#include <gcrypt.h>
-#include <ksba.h>
 
 #include "gpgsm.h"
+#include <gcrypt.h>
+#include <ksba.h>
 
 /* Return the fingerprint of the certificate (we can't put this into
    libksba because we need libgcrypt support).  The caller must
    provide an array of sufficient length or NULL so that the function
    allocates the array.  If r_len is not NULL, the length of the
-   digest is return, well, this can also be done by using
+   digest is returned; well, this can also be done by using
    gcry_md_get_algo_dlen().  If algo is 0, a SHA-1 will be used.
    
    If there is a problem , the function does never return NULL but a
    digest of all 0xff.
  */
 char *
-gpgsm_get_fingerprint (KsbaCert cert, int algo, char *array, int *r_len)
+gpgsm_get_fingerprint (ksba_cert_t cert, int algo, char *array, int *r_len)
 {
-  GCRY_MD_HD md;
+  gcry_md_hd_t md;
   int rc, len;
   
   if (!algo)
@@ -59,10 +59,10 @@ gpgsm_get_fingerprint (KsbaCert cert, int algo, char *array, int *r_len)
   if (r_len)
     *r_len = len;
 
-  md = gcry_md_open (algo, 0);
-  if (!md)
+  rc = gcry_md_open (&md, algo, 0);
+  if (rc)
     {
-      log_error ("md_open failed: %s\n", gcry_strerror (-1));
+      log_error ("md_open failed: %s\n", gpg_strerror (rc));
       memset (array, 0xff, len); /* better return an invalid fpr than NULL */
       return array;
     }
@@ -70,7 +70,7 @@ gpgsm_get_fingerprint (KsbaCert cert, int algo, char *array, int *r_len)
   rc = ksba_cert_hash (cert, 0, HASH_FNC, md);
   if (rc)
     {
-      log_error ("ksba_cert_hash failed: %s\n", ksba_strerror (rc));
+      log_error ("ksba_cert_hash failed: %s\n", gpg_strerror (rc));
       gcry_md_close (md);
       memset (array, 0xff, len); /* better return an invalid fpr than NULL */
       return array;
@@ -83,7 +83,7 @@ gpgsm_get_fingerprint (KsbaCert cert, int algo, char *array, int *r_len)
 
 /* Return an allocated buffer with the formatted fingerprint */
 char *
-gpgsm_get_fingerprint_string (KsbaCert cert, int algo)
+gpgsm_get_fingerprint_string (ksba_cert_t cert, int algo)
 {
   unsigned char digest[MAX_DIGEST_LEN];
   char *buf;
@@ -102,10 +102,10 @@ gpgsm_get_fingerprint_string (KsbaCert cert, int algo)
   return buf;
 }
 
-/* Return an allocated buffer with the formatted fungerprint as one
+/* Return an allocated buffer with the formatted fingerprint as one
    large hexnumber */
 char *
-gpgsm_get_fingerprint_hexstring (KsbaCert cert, int algo)
+gpgsm_get_fingerprint_hexstring (ksba_cert_t cert, int algo)
 {
   unsigned char digest[MAX_DIGEST_LEN];
   char *buf;
@@ -124,17 +124,28 @@ gpgsm_get_fingerprint_hexstring (KsbaCert cert, int algo)
   return buf;
 }
 
+/* Return a certificate ID.  These are the last 4 bytes of the SHA-1
+   fingerprint. */
+unsigned long
+gpgsm_get_short_fingerprint (ksba_cert_t cert)
+{
+  unsigned char digest[20];
+
+  gpgsm_get_fingerprint (cert, GCRY_MD_SHA1, digest, NULL);
+  return ((digest[16]<<24)|(digest[17]<<16)|(digest[18]<< 8)|digest[19]);
+}
+
 \f
 /* Return the so called KEYGRIP which is the SHA-1 hash of the public
    key parameters expressed as an canoncial encoded S-Exp.  array must
    be 20 bytes long. returns the array or a newly allocated one if the
    passed one was NULL */
 char *
-gpgsm_get_keygrip (KsbaCert cert, char *array)
+gpgsm_get_keygrip (ksba_cert_t cert, char *array)
 {
-  GCRY_SEXP s_pkey;
+  gcry_sexp_t s_pkey;
   int rc;
-  KsbaSexp p;
+  ksba_sexp_t p;
   size_t n;
   
   p = ksba_cert_get_public_key (cert);
@@ -142,7 +153,7 @@ gpgsm_get_keygrip (KsbaCert cert, char *array)
     return NULL; /* oops */
 
   if (DBG_X509)
-    log_debug ("get_keygrip for public key: %s\n", p);
+    log_debug ("get_keygrip for public key\n");
   n = gcry_sexp_canon_len (p, 0, NULL, NULL);
   if (!n)
     {
@@ -153,14 +164,14 @@ gpgsm_get_keygrip (KsbaCert cert, char *array)
   xfree (p);
   if (rc)
     {
-      log_error ("gcry_sexp_scan failed: %s\n", gcry_strerror (rc));
+      log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (rc));
       return NULL;
     }
   array = gcry_pk_get_keygrip (s_pkey, array);
   gcry_sexp_release (s_pkey);
   if (!array)
     {
-      rc = seterr (General_Error);
+      rc = gpg_error (GPG_ERR_GENERAL);
       log_error ("can't calculate keygrip\n");
       return NULL;
     }
@@ -173,7 +184,7 @@ gpgsm_get_keygrip (KsbaCert cert, char *array)
 /* Return an allocated buffer with the keygrip of CERT in from of an
    hexstring.  NULL is returned in case of error */
 char *
-gpgsm_get_keygrip_hexstring (KsbaCert cert)
+gpgsm_get_keygrip_hexstring (ksba_cert_t cert)
 {
   unsigned char grip[20];
   char *buf, *p;
@@ -187,6 +198,73 @@ gpgsm_get_keygrip_hexstring (KsbaCert cert)
 }
 
 
+\f
+/* For certain purposes we need a certificate id which has an upper
+   limit of the size.  We use the hash of the issuer name and the
+   serial number for this.  In most cases the serial number is not
+   that large and the resulting string can be passed on an assuan
+   command line.  Everything is hexencoded with the serialnumber
+   delimited from the hash by a dot. 
+
+   The caller must free the string.
+*/
+char *
+gpgsm_get_certid (ksba_cert_t cert)
+{
+  ksba_sexp_t serial;
+  unsigned char *p;
+  char *endp;
+  unsigned char hash[20];
+  unsigned long n;
+  char *certid;
+  int i;
+  
+  p = ksba_cert_get_issuer (cert, 0);
+  if (!p)
+    return NULL; /* Ooops: No issuer */
+  gcry_md_hash_buffer (GCRY_MD_SHA1, hash, p, strlen (p));
+  xfree (p);
+
+  serial = ksba_cert_get_serial (cert);
+  if (!serial)
+    return NULL; /* oops: no serial number */
+  p = serial;
+  if (*p != '(')
+    {
+      log_error ("Ooops: invalid serial number\n");
+      xfree (serial);
+      return NULL;
+    }
+  p++;
+  n = strtoul (p, &endp, 10);
+  p = endp;
+  if (*p != ':')
+    {
+      log_error ("Ooops: invalid serial number (no colon)\n");
+      xfree (serial);
+      return NULL;
+    }
+  p++;
+
+  certid = xtrymalloc ( 40 + 1 + n*2 + 1);
+  if (!certid)
+    {
+      xfree (serial);
+      return NULL; /* out of core */
+    }
+
+  for (i=0, endp = certid; i < 20; i++, endp += 2 )
+    sprintf (endp, "%02X", hash[i]);
+  *endp++ = '.';
+  for (i=0; i < n; i++, endp += 2)
+    sprintf (endp, "%02X", p[i]);
+  *endp = 0;
+
+  xfree (serial);
+  return certid;
+}
+
+