trunk/MyGPGME/keycache-openpgp.c

/* keycache-openpgp.c - OpenPGP code for the key cache
 *      Copyright (C) 2001, 2002, 2003 Timo Schulz
 *
 * This file is part of MyGPGME.
 *
 * MyGPGME is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * MyGPGME 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
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */

#include <stdio.h>
#include <sys/types.h>
#include <string.h>
#include <malloc.h>

#include "gpgme-config.h"
#ifdef WITH_OPENPGP
#include "gpgme.h"
#include "key.h"
#include "util.h"
#include "openpgp.h"


static void
buffer_to_string( char * dst, size_t dlen, const byte * buf, size_t nbytes )
{
    char dig[3];
    size_t i;

    memset( dst, 0, dlen );
    for( i = 0; i < nbytes && dlen > 0; i++ ) {
        sprintf( dig, "%02X", buf[i] );
        strcat( dst, dig );
        dlen -= 2;
    }
} /* buffer_to_string */


static void
parse_secring( gpgme_keycache_t cache, const char * secring )
{    
    PACKET * pkt = calloc( 1, sizeof * pkt );
    PKT_secret_key * sk;
    gpg_iobuf_t inp;
    gpgme_error_t err;
    gpgme_key_t key;    
    char keyid[16+1]; 
    int rc;

    inp = gpg_iobuf_open( secring );
    if( !inp ) {
        safe_free( pkt );
        return;
    }
    gpg_iobuf_ioctl( inp, 3, 1, NULL );
    gpg_init_packet( pkt );
    while( (rc = gpg_parse_packet( inp, pkt )) != -1 ) {
        if( pkt->pkttype == PKT_SECRET_KEY ) {
            sk = pkt->pkt.secret_key;
            _snprintf( keyid, sizeof keyid-1, "%08lX", 
                       gpg_keyid_from_sk( sk, NULL ) );
            err = gpgme_keycache_find_key (cache, keyid, 0, &key);
            if( !err ) {
                key->gloflags.is_protected = sk->is_protected;
                key->gloflags.divert_to_card = sk->protect.s2k.mode==1002? 1 : 0;
            }
        }
        gpg_free_packet( pkt );
        gpg_init_packet( pkt );
    }
    safe_free( pkt );
    gpg_iobuf_close( inp );
} /* parse_secring */


gpgme_error_t
gpgme_keycache_prepare( gpgme_keycache_t ctx, 
                        const char * pubring, const char * secring )
{
    gpgme_error_t err;
    gpgme_key_t key = NULL;
    gpg_iobuf_t inp;
    PACKET * pkt = calloc( 1, sizeof * pkt );
    struct revoker_key_s * r;
    const byte *sym_prefs;
    char keyid[16+1], * id = NULL;
    int rc = 0, key_seen = 0;
    size_t nbytes = 0, nsym =0;

    if( secring ) {
        parse_secring( ctx, secring );
        if( !pubring ) {
            safe_free( pkt );
            return 0;
        }
    }
    inp = gpg_iobuf_open( pubring );
    if( !inp ) {
        safe_free( pkt );
        return mk_error( File_Error );
    }
    gpg_iobuf_ioctl( inp, 3, 1, NULL ); /* disable cache */

    gpg_init_packet( pkt );
    while( (rc = gpg_parse_packet( inp, pkt )) != -1 ) {
        if( pkt->pkttype == PKT_PUBLIC_KEY )
            key_seen = 1;
        
        if( pkt->pkttype == PKT_SIGNATURE && pkt->pkt.signature->sig_class == 0x1F ) {
            if( pkt->pkt.signature->numrevkeys == 0 )
                continue;
            nbytes = pkt->pkt.signature->numrevkeys;
            _snprintf( keyid, sizeof keyid -1, "%08X", pkt->pkt.signature->keyid[1] );
            err = gpgme_keycache_find_key( ctx, keyid, 0, &key );
            if( err )           
                continue;
            while( nbytes-- ) {
                PKT_signature *sig = pkt->pkt.signature;
                r = calloc( 1, sizeof *r );             
                r->algo =  sig->revkey[nbytes]->algid;
                buffer_to_string( r->fpr, sizeof r->fpr-1, sig->revkey[nbytes]->fpr, 20 );
                r->next = key->rvks;
                key->rvks = r;
            }
        }
        if( pkt->pkttype == PKT_SIGNATURE && key_seen == 1 ) {      
            if( (sym_prefs=gpg_parse_sig_subpkt( pkt->pkt.signature->hashed,
                                       SIGSUBPKT_PREF_SYM, &nsym )) == NULL )
                continue;
            _snprintf( keyid, sizeof keyid - 1, "%08X", pkt->pkt.signature->keyid[1] );
            err = gpgme_keycache_find_key( ctx, keyid, 0, &key );
            if( err )
                continue;
            else if( nsym ) {
                key->sym_prefs = calloc( 1, nsym+1 );
                if( !key->sym_prefs )
                    return mk_error( Out_Of_Core );
                memcpy( key->sym_prefs, sym_prefs, nsym );
            }
        }
        if( pkt->pkttype == PKT_USER_ID ) {
            safe_free( id );
            id = strdup( pkt->pkt.user_id->name );              
        }
        if( (pkt->pkttype == PKT_USER_ID || pkt->pkttype == PKT_ATTRIBUTE)
            && pkt->pkt.user_id->attrib_data && key ) {
            PKT_user_id *id = pkt->pkt.user_id;     
            key->attrib.used = 1;
            key->attrib.len = id->attrib_len;
            key->attrib.d = malloc( id->attrib_len + 1 );
            if( !key->attrib.d ) {
                err = mk_error( Out_Of_Core );
                goto fail;
            }
            memcpy( key->attrib.d, id->attrib_data, id->attrib_len );
            key = NULL;
        }
        gpg_free_packet( pkt );
        gpg_init_packet( pkt );
    }

fail:
    safe_free( pkt );
    gpg_iobuf_close( inp );
    return err;
} /* gpgme_keycache_prepare */

#endif /*WITH_OPENPGP*/
1	/* keycache-openpgp.c - OpenPGP code for the key cache
2	* Copyright (C) 2001, 2002, 2003 Timo Schulz
3	*
4	* This file is part of MyGPGME.
5	*
6	* MyGPGME is free software; you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License as published by
8	* the Free Software Foundation; either version 2 of the License, or
9	* (at your option) any later version.
10	*
11	* MyGPGME is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.
15	*
16	* You should have received a copy of the GNU General Public License
17	* along with this program; if not, write to the Free Software
18	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19	*/
20
21	#include <stdio.h>
22	#include <sys/types.h>
23	#include <string.h>
24	#include <malloc.h>
25
26	#include "gpgme-config.h"
27	#ifdef WITH_OPENPGP
28	#include "gpgme.h"
29	#include "key.h"
30	#include "util.h"
31	#include "openpgp.h"
32
33
34	static void
35	buffer_to_string( char * dst, size_t dlen, const byte * buf, size_t nbytes )
36	{
37	char dig[3];
38	size_t i;
39
40	memset( dst, 0, dlen );
41	for( i = 0; i < nbytes && dlen > 0; i++ ) {
42	sprintf( dig, "%02X", buf[i] );
43	strcat( dst, dig );
44	dlen -= 2;
45	}
46	} /* buffer_to_string */
47
48
49	static void
50	parse_secring( gpgme_keycache_t cache, const char * secring )
51	{
52	PACKET * pkt = calloc( 1, sizeof * pkt );
53	PKT_secret_key * sk;
54	gpg_iobuf_t inp;
55	gpgme_error_t err;
56	gpgme_key_t key;
57	char keyid[16+1];
58	int rc;
59
60	inp = gpg_iobuf_open( secring );
61	if( !inp ) {
62	safe_free( pkt );
63	return;
64	}
65	gpg_iobuf_ioctl( inp, 3, 1, NULL );
66	gpg_init_packet( pkt );
67	while( (rc = gpg_parse_packet( inp, pkt )) != -1 ) {
68	if( pkt->pkttype == PKT_SECRET_KEY ) {
69	sk = pkt->pkt.secret_key;
70	_snprintf( keyid, sizeof keyid-1, "%08lX",
71	gpg_keyid_from_sk( sk, NULL ) );
72	err = gpgme_keycache_find_key (cache, keyid, 0, &key);
73	if( !err ) {
74	key->gloflags.is_protected = sk->is_protected;
75	key->gloflags.divert_to_card = sk->protect.s2k.mode==1002? 1 : 0;
76	}
77	}
78	gpg_free_packet( pkt );
79	gpg_init_packet( pkt );
80	}
81	safe_free( pkt );
82	gpg_iobuf_close( inp );
83	} /* parse_secring */
84
85
86	gpgme_error_t
87	gpgme_keycache_prepare( gpgme_keycache_t ctx,
88	const char * pubring, const char * secring )
89	{
90	gpgme_error_t err;
91	gpgme_key_t key = NULL;
92	gpg_iobuf_t inp;
93	PACKET * pkt = calloc( 1, sizeof * pkt );
94	struct revoker_key_s * r;
95	const byte *sym_prefs;
96	char keyid[16+1], * id = NULL;
97	int rc = 0, key_seen = 0;
98	size_t nbytes = 0, nsym =0;
99
100	if( secring ) {
101	parse_secring( ctx, secring );
102	if( !pubring ) {
103	safe_free( pkt );
104	return 0;
105	}
106	}
107	inp = gpg_iobuf_open( pubring );
108	if( !inp ) {
109	safe_free( pkt );
110	return mk_error( File_Error );
111	}
112	gpg_iobuf_ioctl( inp, 3, 1, NULL ); /* disable cache */
113
114	gpg_init_packet( pkt );
115	while( (rc = gpg_parse_packet( inp, pkt )) != -1 ) {
116	if( pkt->pkttype == PKT_PUBLIC_KEY )
117	key_seen = 1;
118
119	if( pkt->pkttype == PKT_SIGNATURE && pkt->pkt.signature->sig_class == 0x1F ) {
120	if( pkt->pkt.signature->numrevkeys == 0 )
121	continue;
122	nbytes = pkt->pkt.signature->numrevkeys;
123	_snprintf( keyid, sizeof keyid -1, "%08X", pkt->pkt.signature->keyid[1] );
124	err = gpgme_keycache_find_key( ctx, keyid, 0, &key );
125	if( err )
126	continue;
127	while( nbytes-- ) {
128	PKT_signature *sig = pkt->pkt.signature;
129	r = calloc( 1, sizeof *r );
130	r->algo = sig->revkey[nbytes]->algid;
131	buffer_to_string( r->fpr, sizeof r->fpr-1, sig->revkey[nbytes]->fpr, 20 );
132	r->next = key->rvks;
133	key->rvks = r;
134	}
135	}
136	if( pkt->pkttype == PKT_SIGNATURE && key_seen == 1 ) {
137	if( (sym_prefs=gpg_parse_sig_subpkt( pkt->pkt.signature->hashed,
138	SIGSUBPKT_PREF_SYM, &nsym )) == NULL )
139	continue;
140	_snprintf( keyid, sizeof keyid - 1, "%08X", pkt->pkt.signature->keyid[1] );
141	err = gpgme_keycache_find_key( ctx, keyid, 0, &key );
142	if( err )
143	continue;
144	else if( nsym ) {
145	key->sym_prefs = calloc( 1, nsym+1 );
146	if( !key->sym_prefs )
147	return mk_error( Out_Of_Core );
148	memcpy( key->sym_prefs, sym_prefs, nsym );
149	}
150	}
151	if( pkt->pkttype == PKT_USER_ID ) {
152	safe_free( id );
153	id = strdup( pkt->pkt.user_id->name );
154	}
155	if( (pkt->pkttype == PKT_USER_ID \|\| pkt->pkttype == PKT_ATTRIBUTE)
156	&& pkt->pkt.user_id->attrib_data && key ) {
157	PKT_user_id *id = pkt->pkt.user_id;
158	key->attrib.used = 1;
159	key->attrib.len = id->attrib_len;
160	key->attrib.d = malloc( id->attrib_len + 1 );
161	if( !key->attrib.d ) {
162	err = mk_error( Out_Of_Core );
163	goto fail;
164	}
165	memcpy( key->attrib.d, id->attrib_data, id->attrib_len );
166	key = NULL;
167	}
168	gpg_free_packet( pkt );
169	gpg_init_packet( pkt );
170	}
171
172	fail:
173	safe_free( pkt );
174	gpg_iobuf_close( inp );
175	return err;
176	} /* gpgme_keycache_prepare */
177
178	#endif /WITH_OPENPGP/