edit-key is now complete
[gnupg.git] / g10 / ringedit.c
index ba71f0e..58eb6d6 100644 (file)
@@ -69,16 +69,13 @@ typedef struct resource_table_struct RESTBL;
 #define MAX_RESOURCES 10
 static RESTBL resource_table[MAX_RESOURCES];
 
-
 static int search( PACKET *pkt, KBPOS *kbpos, int secret );
 
 
 static int keyring_search( PACKET *pkt, KBPOS *kbpos, IOBUF iobuf,
                                                const char *fname );
-static int keyring_search2( PUBKEY_FIND_INFO info, KBPOS *kbpos,
-                                                  const char *fname);
 static int keyring_read( KBPOS *kbpos, KBNODE *ret_root );
-static int keyring_enum( KBPOS *kbpos, KBNODE *ret_root );
+static int keyring_enum( KBPOS *kbpos, KBNODE *ret_root, int skipsigs );
 static int keyring_copy( KBPOS *kbpos, int mode, KBNODE root );
 
 
@@ -94,13 +91,12 @@ check_pos( KBPOS *kbpos )
 }
 
 
-
 /****************************************************************
  ****************** public functions ****************************
  ****************************************************************/
 
 /****************
- * Register a resource (which currently may ionly be a keyring file).
+ * Register a resource (which currently may only be a keyring file).
  */
 int
 add_keyblock_resource( const char *filename, int force, int secret )
@@ -121,6 +117,17 @@ add_keyblock_resource( const char *filename, int force, int secret )
     if( !iobuf && !force )
        return G10ERR_OPEN_FILE;
   #endif
+
+    if( !iobuf ) {
+       iobuf = iobuf_create( filename );
+       if( !iobuf ) {
+           log_error("%s: can't create: %s\n", filename, strerror(errno));
+           return G10ERR_OPEN_FILE;
+       }
+       else
+           log_info("%s: keyring created\n", filename );
+    }
+
     resource_table[i].used = 1;
     resource_table[i].secret = !!secret;
     resource_table[i].fname = m_strdup(filename);
@@ -165,44 +172,14 @@ get_keyblock_handle( const char *filename, int secret, KBPOS *kbpos )
 }
 
 
-/****************
- * Find a keyblock from the informations provided in INFO
- * This can only be used fro public keys
- */
-int
-find_keyblock( PUBKEY_FIND_INFO info, KBPOS *kbpos )
-{
-    int i, rc, last_rc=-1;
-
-    for(i=0; i < MAX_RESOURCES; i++ ) {
-       if( resource_table[i].used && !resource_table[i].secret ) {
-           /* note: here we have to add different search functions,
-            * depending on the type of the resource */
-           rc = keyring_search2( info, kbpos, resource_table[i].fname );
-           if( !rc ) {
-               kbpos->resno = i;
-               kbpos->fp = NULL;
-               return 0;
-           }
-           if( rc != -1 ) {
-               log_error("error searching resource %d: %s\n",
-                                                 i, g10_errstr(rc));
-               last_rc = rc;
-           }
-       }
-    }
-    return last_rc;
-}
-
-
 
 /****************
- * Search a keyblock which starts with the given packet and put all
- * informations into KBPOS, which can be used later to access this key block.
+ * Search a keyblock which starts with the given packet and puts all
+ * information into KBPOS, which can be used later to access this key block.
  * This function looks into all registered keyblock sources.
- * PACKET must be a packet with either a secret_cert or a public_cert
+ * PACKET must be a packet with either a secret_key or a public_key
  *
- * This function is intended to check wether a given certificate
+ * This function is intended to check whether a given certificate
  * is already in a keyring or to prepare it for editing.
  *
  * Returns: 0 if found, -1 if not found or an errorcode.
@@ -242,20 +219,20 @@ int
 find_keyblock_byname( KBPOS *kbpos, const char *username )
 {
     PACKET pkt;
-    PKT_public_cert *pkc = m_alloc_clear( sizeof *pkc );
+    PKT_public_key *pk = m_alloc_clear( sizeof *pk );
     int rc;
 
-    rc = get_pubkey_byname( pkc, username );
+    rc = get_pubkey_byname( pk, username );
     if( rc ) {
-       free_public_cert(pkc);
+       free_public_key(pk);
        return rc;
     }
 
     init_packet( &pkt );
-    pkt.pkttype = PKT_PUBLIC_CERT;
-    pkt.pkt.public_cert = pkc;
+    pkt.pkttype = PKT_PUBLIC_KEY;
+    pkt.pkt.public_key = pk;
     rc = search( &pkt, kbpos, 0 );
-    free_public_cert(pkc);
+    free_public_key(pk);
     return rc;
 }
 
@@ -265,14 +242,14 @@ find_keyblock_byname( KBPOS *kbpos, const char *username )
  * of the keyblock.
  */
 int
-find_keyblock_bypkc( KBPOS *kbpos, PKT_public_cert *pkc )
+find_keyblock_bypk( KBPOS *kbpos, PKT_public_key *pk )
 {
     PACKET pkt;
     int rc;
 
     init_packet( &pkt );
-    pkt.pkttype = PKT_PUBLIC_CERT;
-    pkt.pkt.public_cert = pkc;
+    pkt.pkttype = PKT_PUBLIC_KEY;
+    pkt.pkt.public_key = pk;
     rc = search( &pkt, kbpos, 0 );
     return rc;
 }
@@ -286,20 +263,20 @@ int
 find_secret_keyblock_byname( KBPOS *kbpos, const char *username )
 {
     PACKET pkt;
-    PKT_secret_cert *skc = m_alloc_clear( sizeof *skc );
+    PKT_secret_key *sk = m_alloc_clear( sizeof *sk );
     int rc;
 
-    rc = get_seckey_byname( skc, username, 0 );
+    rc = get_seckey_byname( sk, username, 0 );
     if( rc ) {
-       free_secret_cert(skc);
+       free_secret_key(sk);
        return rc;
     }
 
     init_packet( &pkt );
-    pkt.pkttype = PKT_SECRET_CERT;
-    pkt.pkt.secret_cert = skc;
+    pkt.pkttype = PKT_SECRET_KEY;
+    pkt.pkt.secret_key = sk;
     rc = search( &pkt, kbpos, 1 );
-    free_secret_cert(skc);
+    free_secret_key(sk);
     return rc;
 }
 
@@ -308,7 +285,7 @@ find_secret_keyblock_byname( KBPOS *kbpos, const char *username )
 /****************
  * Lock the keyblock; wait until it's available
  * This function may change the internal data in kbpos, in cases
- * when the to be locked keyblock has been modified.
+ * when the keyblock to be locked has been modified.
  * fixme: remove this function and add an option to search()?
  */
 int
@@ -342,15 +319,17 @@ read_keyblock( KBPOS *kbpos, KBNODE *ret_root )
 
 
 /****************
- * This functions can be used to read trough a complete keyring.
+ * This functions can be used to read through a complete keyring.
  * Mode is: 0 = open
  *         1 = read
  *         2 = close
+ *         5 = open secret keyrings
+ *         11 = read but skip signature and comment packets.
  *         all others are reserved!
- * Note that you do not need a search prior to call this function,
- * only handle is needed.
- * NOTE: It is not alloed to do an insert/update/delte with this
- *      keyblock, if you want to do this, user search/read!
+ * Note that you do not need a search prior to this function,
+ * only handle is needed.
+ * NOTE: It is not allowed to do an insert/update/delte with this
+ *      keyblock, if you want to do this, use search/read!
  */
 int
 enum_keyblocks( int mode, KBPOS *kbpos, KBNODE *ret_root )
@@ -358,15 +337,23 @@ enum_keyblocks( int mode, KBPOS *kbpos, KBNODE *ret_root )
     int rc = 0;
     RESTBL *rentry;
 
-    if( !mode || mode == 100 ) {
+    if( !mode || mode == 5 || mode == 100 ) {
        int i;
        kbpos->fp = NULL;
-       if( !mode )
+       if( !mode ) {
+           kbpos->secret = 0;
+           i = 0;
+       }
+       else if( mode == 5 ) {
+           kbpos->secret = 1;
+           mode = 0;
            i = 0;
+       }
        else
            i = kbpos->resno+1;
        for(; i < MAX_RESOURCES; i++ )
-           if( resource_table[i].used && !resource_table[i].secret )
+           if( resource_table[i].used
+               && !resource_table[i].secret == !kbpos->secret )
                break;
        if( i == MAX_RESOURCES )
            return -1; /* no resources */
@@ -379,13 +366,13 @@ enum_keyblocks( int mode, KBPOS *kbpos, KBNODE *ret_root )
        }
        kbpos->pkt = NULL;
     }
-    else if( mode == 1 ) {
+    else if( mode == 1 || mode == 11 ) {
        int cont;
        do {
            cont = 0;
            if( !kbpos->fp )
                return G10ERR_GENERAL;
-           rc = keyring_enum( kbpos, ret_root );
+           rc = keyring_enum( kbpos, ret_root, mode == 11 );
            if( rc == -1 ) {
                assert( !kbpos->pkt );
                rentry = check_pos( kbpos );
@@ -432,7 +419,7 @@ insert_keyblock( KBPOS *kbpos, KBNODE root )
 /****************
  * Delete the keyblock described by KBPOS.
  * The current code simply changes the keyblock in the keyring
- * to packet of type 0 with the correct length.  To help detecting errors,
+ * to packet of type 0 with the correct length.  To help detect errors,
  * zero bytes are written.
  */
 int
@@ -470,6 +457,35 @@ update_keyblock( KBPOS *kbpos, KBNODE root )
  ********** Functions which operates on regular keyrings ********
  ****************************************************************/
 
+static int
+cmp_seckey( PKT_secret_key *req_sk, PKT_secret_key *sk )
+{
+    int n,i;
+
+    assert( req_sk->pubkey_algo == sk->pubkey_algo );
+
+    n = pubkey_get_nskey( req_sk->pubkey_algo );
+    for(i=0; i < n; i++ ) {
+       if( mpi_cmp( req_sk->skey[i], sk->skey[i] ) )
+           return -1;
+    }
+    return 0;
+}
+
+static int
+cmp_pubkey( PKT_public_key *req_pk, PKT_public_key *pk )
+{
+    int n, i;
+
+    assert( req_pk->pubkey_algo == pk->pubkey_algo );
+
+    n = pubkey_get_npkey( req_pk->pubkey_algo );
+    for(i=0; i < n; i++ ) {
+       if( mpi_cmp( req_pk->pkey[i], pk->pkey[i] )  )
+           return -1;
+    }
+    return 0;
+}
 
 /****************
  * search one keyring, return 0 if found, -1 if not found or an errorcode.
@@ -482,8 +498,8 @@ keyring_search( PACKET *req, KBPOS *kbpos, IOBUF iobuf, const char *fname )
     int save_mode;
     ulong offset;
     int pkttype = req->pkttype;
-    PKT_public_cert *req_pkc = req->pkt.public_cert;
-    PKT_secret_cert *req_skc = req->pkt.secret_cert;
+    PKT_public_key *req_pk = req->pkt.public_key;
+    PKT_secret_key *req_sk = req->pkt.secret_key;
 
     init_packet(&pkt);
     save_mode = set_packet_list_mode(0);
@@ -505,44 +521,22 @@ keyring_search( PACKET *req, KBPOS *kbpos, IOBUF iobuf, const char *fname )
   #endif
 
     while( !(rc=search_packet(iobuf, &pkt, pkttype, &offset)) ) {
-       if( pkt.pkttype == PKT_SECRET_CERT ) {
-           PKT_secret_cert *skc = pkt.pkt.secret_cert;
-
-           if(   req_skc->timestamp == skc->timestamp
-              && req_skc->valid_days == skc->valid_days
-              && req_skc->pubkey_algo == skc->pubkey_algo
-              && (   ( skc->pubkey_algo == PUBKEY_ALGO_ELGAMAL
-                       && !mpi_cmp( req_skc->d.elg.p, skc->d.elg.p )
-                       && !mpi_cmp( req_skc->d.elg.g, skc->d.elg.g )
-                       && !mpi_cmp( req_skc->d.elg.y, skc->d.elg.y )
-                       && !mpi_cmp( req_skc->d.elg.x, skc->d.elg.x )
-                     )
-                  || ( skc->pubkey_algo == PUBKEY_ALGO_RSA
-                       && !mpi_cmp( req_skc->d.rsa.rsa_n, skc->d.rsa.rsa_n )
-                       && !mpi_cmp( req_skc->d.rsa.rsa_e, skc->d.rsa.rsa_e )
-                       && !mpi_cmp( req_skc->d.rsa.rsa_d, skc->d.rsa.rsa_d )
-                     )
-                 )
-             )
+       if( pkt.pkttype == PKT_SECRET_KEY ) {
+           PKT_secret_key *sk = pkt.pkt.secret_key;
+
+           if(   req_sk->timestamp == sk->timestamp
+              && req_sk->valid_days == sk->valid_days
+              && req_sk->pubkey_algo == sk->pubkey_algo
+              && !cmp_seckey( req_sk, sk) )
                break; /* found */
        }
-       else if( pkt.pkttype == PKT_PUBLIC_CERT ) {
-           PKT_public_cert *pkc = pkt.pkt.public_cert;
-
-           if(   req_pkc->timestamp == pkc->timestamp
-              && req_pkc->valid_days == pkc->valid_days
-              && req_pkc->pubkey_algo == pkc->pubkey_algo
-              && (   ( pkc->pubkey_algo == PUBKEY_ALGO_ELGAMAL
-                       && !mpi_cmp( req_pkc->d.elg.p, pkc->d.elg.p )
-                       && !mpi_cmp( req_pkc->d.elg.g, pkc->d.elg.g )
-                       && !mpi_cmp( req_pkc->d.elg.y, pkc->d.elg.y )
-                     )
-                  || ( pkc->pubkey_algo == PUBKEY_ALGO_RSA
-                       && !mpi_cmp( req_pkc->d.rsa.rsa_n, pkc->d.rsa.rsa_n )
-                       && !mpi_cmp( req_pkc->d.rsa.rsa_e, pkc->d.rsa.rsa_e )
-                     )
-                 )
-             )
+       else if( pkt.pkttype == PKT_PUBLIC_KEY ) {
+           PKT_public_key *pk = pkt.pkt.public_key;
+
+           if(   req_pk->timestamp == pk->timestamp
+              && req_pk->valid_days == pk->valid_days
+              && req_pk->pubkey_algo == pk->pubkey_algo
+              && !cmp_pubkey( req_pk, pk ) )
                break; /* found */
        }
        else
@@ -561,60 +555,6 @@ keyring_search( PACKET *req, KBPOS *kbpos, IOBUF iobuf, const char *fname )
     return rc;
 }
 
-/****************
- * search one keyring, return 0 if found, -1 if not found or an errorcode.
- * this version uses the finger print and other informations
- */
-static int
-keyring_search2( PUBKEY_FIND_INFO info, KBPOS *kbpos, const char *fname )
-{
-    int rc;
-    PACKET pkt;
-    int save_mode;
-    ulong offset;
-    IOBUF iobuf;
-
-    init_packet(&pkt);
-    save_mode = set_packet_list_mode(0);
-
-    iobuf = iobuf_open( fname );
-    if( !iobuf ) {
-       log_error("can't open '%s'\n", fname );
-       rc = G10ERR_OPEN_FILE;
-       goto leave;
-    }
-
-    while( !(rc=search_packet(iobuf, &pkt, PKT_PUBLIC_CERT, &offset)) ) {
-       PKT_public_cert *pkc = pkt.pkt.public_cert;
-       u32 keyid[2];
-
-       assert( pkt.pkttype == PKT_PUBLIC_CERT );
-       keyid_from_pkc( pkc, keyid );
-       if( keyid[0] == info->keyid[0] && keyid[1] == info->keyid[1]
-           && pkc->pubkey_algo == info->pubkey_algo ) {
-           /* fixme: shall we check nbits too? (good for rsa keys) */
-           /* fixme: check userid???? */
-           size_t len;
-           byte *fp = fingerprint_from_pkc( pkc, &len );
-
-           if( !memcmp( fp, info->fingerprint, len ) ) {
-               m_free(fp);
-               break; /* found */
-           }
-           m_free(fp);
-       }
-       free_packet(&pkt);
-    }
-    if( !rc )
-       kbpos->offset = offset;
-
-  leave:
-    iobuf_close(iobuf);
-    free_packet(&pkt);
-    set_packet_list_mode(save_mode);
-    return rc;
-}
-
 
 static int
 keyring_read( KBPOS *kbpos, KBNODE *ret_root )
@@ -658,8 +598,8 @@ keyring_read( KBPOS *kbpos, KBNODE *ret_root )
        }
        /* make a linked list of all packets */
        switch( pkt->pkttype ) {
-         case PKT_PUBLIC_CERT:
-         case PKT_SECRET_CERT:
+         case PKT_PUBLIC_KEY:
+         case PKT_SECRET_KEY:
            if( in_cert )
                goto ready;
            in_cert = 1;
@@ -690,13 +630,12 @@ keyring_read( KBPOS *kbpos, KBNODE *ret_root )
 
 
 static int
-keyring_enum( KBPOS *kbpos, KBNODE *ret_root )
+keyring_enum( KBPOS *kbpos, KBNODE *ret_root, int skipsigs )
 {
     PACKET *pkt;
     int rc;
     RESTBL *rentry;
     KBNODE root = NULL;
-    int in_cert = 0;
 
     if( !(rentry=check_pos(kbpos)) )
        return G10ERR_GENERAL;
@@ -721,19 +660,32 @@ keyring_enum( KBPOS *kbpos, KBNODE *ret_root )
        }
        /* make a linked list of all packets */
        switch( pkt->pkttype ) {
-         case PKT_PUBLIC_CERT:
-         case PKT_SECRET_CERT:
-           if( in_cert ) { /* store this packet */
+         case PKT_PUBLIC_KEY:
+         case PKT_SECRET_KEY:
+           if( root ) { /* store this packet */
                kbpos->pkt = pkt;
                pkt = NULL;
                goto ready;
            }
-           in_cert = 1;
+           root = new_kbnode( pkt );
+           pkt = m_alloc( sizeof *pkt );
+           init_packet(pkt);
+           break;
+
          default:
-           if( !root )
-               root = new_kbnode( pkt );
-           else
-               add_kbnode( root, new_kbnode( pkt ) );
+           /* skip pakets at the beginning of a keyring, until we find
+            * a start packet; issue a warning if it is not a comment */
+           if( !root && pkt->pkttype != PKT_COMMENT
+                     && pkt->pkttype != PKT_OLD_COMMENT )
+               log_info("keyring_enum: skipped packet of type %d\n",
+                           pkt->pkttype );
+           if( !root || (skipsigs && ( pkt->pkttype == PKT_SIGNATURE
+                                     ||pkt->pkttype == PKT_COMMENT
+                                     ||pkt->pkttype == PKT_OLD_COMMENT )) ) {
+               init_packet(pkt);
+               break;
+           }
+           add_kbnode( root, new_kbnode( pkt ) );
            pkt = m_alloc( sizeof *pkt );
            init_packet(pkt);
            break;
@@ -755,7 +707,7 @@ keyring_enum( KBPOS *kbpos, KBNODE *ret_root )
 
 
 /****************
- * Peromf insert/delete/update operation.
+ * Perform insert/delete/update operation.
  * mode 1 = insert
  *     2 = delete
  *     3 = update
@@ -785,6 +737,8 @@ keyring_copy( KBPOS *kbpos, int mode, KBNODE root )
            log_error("%s: can't create: %s\n", rentry->fname, strerror(errno));
            return G10ERR_OPEN_FILE;
        }
+       else
+           log_info("%s: keyring created\n", rentry->fname );
 
        kbctx=NULL;
        while( (node = walk_kbnode( root, &kbctx, 0 )) ) {