trunk/MyGPGME/keycache-openpgp.c

/* keycache-openpgp.c - OpenPGP code for the key cache
 *      Copyright (C) 2001, 2002, 2003, 2005 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 "ops.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 *kid, 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;
    struct keycache_s *c=NULL;
    char keyid[16+1]; 

    inp = gpg_iobuf_open (secring);
    if (!inp) {
        safe_free (pkt);
        return;
    }
    gpg_iobuf_ioctl (inp, 3, 1, NULL);
    gpg_init_packet (pkt);
    while (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));
            if (kid && strcmp (kid, keyid) != 0)
                goto next;
            err = _gpgme_keycache_find_key2 (cache, keyid, 0, &key, &c);                
            DEBUG2 ("parse_secring: keyid=%s %p\r\n", keyid, c);
            if (!err) {
                key->gloflags.is_protected = sk->is_protected;
                key->gloflags.divert_to_card = sk->protect.s2k.mode==1002? 1 : 0;
                if (c->pubpart != NULL) {
                    c->pubpart->gloflags.is_protected = sk->is_protected;
                    c->pubpart->gloflags.divert_to_card = sk->protect.s2k.mode==1002? 1 : 0;
                    DEBUG1 ("parse_secring: sync %s\r\n", keyid);
                }
            }
        }
next:
        gpg_free_packet (pkt);
        gpg_init_packet (pkt);
    }
    safe_free (pkt);
    gpg_iobuf_close (inp);
} /* parse_secring */


gpgme_error_t
keycache_prepare2 (gpgme_keycache_t ctx, const char *kid,
                   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 key_seen = 0;
    size_t nbytes = 0, nsym =0;

    if (secring) {
        parse_secring (ctx, kid, 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 (gpg_parse_packet (inp, pkt) != -1) {
        if (pkt->pkttype == PKT_PUBLIC_KEY) {
            strcpy (keyid, "");
            key_seen = 1;
        }

        if( pkt->pkttype == PKT_SIGNATURE && pkt->pkt.signature->sig_class == 0x1F ) {
            if (pkt->pkt.signature->numrevkeys == 0)
                goto next;
            nbytes = pkt->pkt.signature->numrevkeys;
            _snprintf (keyid, sizeof keyid -1, "%08X", pkt->pkt.signature->keyid[1]);
            if (kid && strcmp (kid, keyid) != 0)
                goto next;
            err = gpgme_keycache_find_key (ctx, keyid, 0, &key);
            if (err)
                goto next;
            while( nbytes-- ) {
                PKT_signature *sig = pkt->pkt.signature;
                r = calloc( 1, sizeof *r );
                if (!r) {
                    err = mk_error (Out_Of_Core);
                    goto fail;
                }
                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)
                goto next;
            _snprintf (keyid, sizeof keyid - 1, "%08X", pkt->pkt.signature->keyid[1]);
            if (kid && strcmp (kid, keyid) != 0)
                goto next;
            err = gpgme_keycache_find_key (ctx, keyid, 0, &key);
            if (err)
                goto next;
            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 (!id) {
                err = mk_error (Out_Of_Core);
                goto fail;
            }
        }
        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;
        }
next:
        gpg_free_packet (pkt);
        gpg_init_packet(pkt);
    }

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


gpgme_error_t
gpgme_keycache_prepare (gpgme_keycache_t ctx, const char *pubr, const char *secr)
{
    return keycache_prepare2 (ctx, NULL, pubr, secr);
}

gpgme_error_t
gpgme_keycache_prepare_single (gpgme_keycache_t ctx, const char *keyid,
                               const char *pubr, const char *secr)
{
    if (!strncmp (keyid, "0x", 2))
        keyid += 2;
    DEBUG1 ("keycache_prepare_single: %s\r\n", keyid);
    return keycache_prepare2 (ctx, keyid, pubr, secr);
}
#endif /*WITH_OPENPGP*/
1	/* keycache-openpgp.c - OpenPGP code for the key cache
2	* Copyright (C) 2001, 2002, 2003, 2005 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 "ops.h"
32	#include "openpgp.h"
33
34
35	static void
36	buffer_to_string (char * dst, size_t dlen, const byte *buf, size_t nbytes)
37	{
38	char dig[3];
39	size_t i;
40
41	memset( dst, 0, dlen );
42	for( i = 0; i < nbytes && dlen > 0; i++ ) {
43	sprintf( dig, "%02X", buf[i] );
44	strcat( dst, dig );
45	dlen -= 2;
46	}
47	} /* buffer_to_string */
48
49
50	static void
51	parse_secring (gpgme_keycache_t cache, const char kid, const char secring)
52	{
53	PACKET pkt = calloc (1, sizeof pkt);
54	PKT_secret_key *sk;
55	gpg_iobuf_t inp;
56	gpgme_error_t err;
57	gpgme_key_t key;
58	struct keycache_s *c=NULL;
59	char keyid[16+1];
60
61	inp = gpg_iobuf_open (secring);
62	if (!inp) {
63	safe_free (pkt);
64	return;
65	}
66	gpg_iobuf_ioctl (inp, 3, 1, NULL);
67	gpg_init_packet (pkt);
68	while (gpg_parse_packet (inp, pkt) != -1) {
69	if (pkt->pkttype == PKT_SECRET_KEY) {
70	sk = pkt->pkt.secret_key;
71	_snprintf (keyid, sizeof keyid-1, "%08lX",
72	gpg_keyid_from_sk (sk, NULL));
73	if (kid && strcmp (kid, keyid) != 0)
74	goto next;
75	err = _gpgme_keycache_find_key2 (cache, keyid, 0, &key, &c);
76	DEBUG2 ("parse_secring: keyid=%s %p\r\n", keyid, c);
77	if (!err) {
78	key->gloflags.is_protected = sk->is_protected;
79	key->gloflags.divert_to_card = sk->protect.s2k.mode==1002? 1 : 0;
80	if (c->pubpart != NULL) {
81	c->pubpart->gloflags.is_protected = sk->is_protected;
82	c->pubpart->gloflags.divert_to_card = sk->protect.s2k.mode==1002? 1 : 0;
83	DEBUG1 ("parse_secring: sync %s\r\n", keyid);
84	}
85	}
86	}
87	next:
88	gpg_free_packet (pkt);
89	gpg_init_packet (pkt);
90	}
91	safe_free (pkt);
92	gpg_iobuf_close (inp);
93	} /* parse_secring */
94
95
96	gpgme_error_t
97	keycache_prepare2 (gpgme_keycache_t ctx, const char *kid,
98	const char pubring, const char secring)
99	{
100	gpgme_error_t err;
101	gpgme_key_t key = NULL;
102	gpg_iobuf_t inp;
103	PACKET pkt = calloc (1, sizeof pkt);
104	struct revoker_key_s *r;
105	const byte *sym_prefs;
106	char keyid[16+1], *id = NULL;
107	int key_seen = 0;
108	size_t nbytes = 0, nsym =0;
109
110	if (secring) {
111	parse_secring (ctx, kid, secring);
112	if (!pubring) {
113	safe_free(pkt);
114	return 0;
115	}
116	}
117	inp = gpg_iobuf_open( pubring );
118	if( !inp ) {
119	safe_free( pkt );
120	return mk_error( File_Error );
121	}
122	gpg_iobuf_ioctl( inp, 3, 1, NULL ); /* disable cache */
123
124	gpg_init_packet( pkt );
125	while (gpg_parse_packet (inp, pkt) != -1) {
126	if (pkt->pkttype == PKT_PUBLIC_KEY) {
127	strcpy (keyid, "");
128	key_seen = 1;
129	}
130
131	if( pkt->pkttype == PKT_SIGNATURE && pkt->pkt.signature->sig_class == 0x1F ) {
132	if (pkt->pkt.signature->numrevkeys == 0)
133	goto next;
134	nbytes = pkt->pkt.signature->numrevkeys;
135	_snprintf (keyid, sizeof keyid -1, "%08X", pkt->pkt.signature->keyid[1]);
136	if (kid && strcmp (kid, keyid) != 0)
137	goto next;
138	err = gpgme_keycache_find_key (ctx, keyid, 0, &key);
139	if (err)
140	goto next;
141	while( nbytes-- ) {
142	PKT_signature *sig = pkt->pkt.signature;
143	r = calloc( 1, sizeof *r );
144	if (!r) {
145	err = mk_error (Out_Of_Core);
146	goto fail;
147	}
148	r->algo = sig->revkey[nbytes]->algid;
149	buffer_to_string( r->fpr, sizeof r->fpr-1, sig->revkey[nbytes]->fpr, 20 );
150	r->next = key->rvks;
151	key->rvks = r;
152	}
153	}
154	if( pkt->pkttype == PKT_SIGNATURE && key_seen == 1 ) {
155	if( (sym_prefs=gpg_parse_sig_subpkt( pkt->pkt.signature->hashed,
156	SIGSUBPKT_PREF_SYM, &nsym )) == NULL)
157	goto next;
158	_snprintf (keyid, sizeof keyid - 1, "%08X", pkt->pkt.signature->keyid[1]);
159	if (kid && strcmp (kid, keyid) != 0)
160	goto next;
161	err = gpgme_keycache_find_key (ctx, keyid, 0, &key);
162	if (err)
163	goto next;
164	else if (nsym) {
165	key->sym_prefs = calloc (1, nsym+1);
166	if (!key->sym_prefs)
167	return mk_error (Out_Of_Core);
168	memcpy (key->sym_prefs, sym_prefs, nsym);
169	}
170	}
171	if (pkt->pkttype == PKT_USER_ID) {
172	safe_free (id);
173	id = strdup (pkt->pkt.user_id->name);
174	if (!id) {
175	err = mk_error (Out_Of_Core);
176	goto fail;
177	}
178	}
179	if( (pkt->pkttype == PKT_USER_ID \|\| pkt->pkttype == PKT_ATTRIBUTE)
180	&& pkt->pkt.user_id->attrib_data && key ) {
181	PKT_user_id *id = pkt->pkt.user_id;
182	key->attrib.used = 1;
183	key->attrib.len = id->attrib_len;
184	key->attrib.d = malloc (id->attrib_len + 1);
185	if( !key->attrib.d ) {
186	err = mk_error( Out_Of_Core );
187	goto fail;
188	}
189	memcpy (key->attrib.d, id->attrib_data, id->attrib_len);
190	key = NULL;
191	}
192	next:
193	gpg_free_packet (pkt);
194	gpg_init_packet(pkt);
195	}
196
197	fail:
198	safe_free (id);
199	safe_free (pkt);
200	gpg_iobuf_close (inp);
201	return err;
202	} /* gpgme_keycache_prepare */
203
204
205	gpgme_error_t
206	gpgme_keycache_prepare (gpgme_keycache_t ctx, const char pubr, const char secr)
207	{
208	return keycache_prepare2 (ctx, NULL, pubr, secr);
209	}
210
211	gpgme_error_t
212	gpgme_keycache_prepare_single (gpgme_keycache_t ctx, const char *keyid,
213	const char pubr, const char secr)
214	{
215	if (!strncmp (keyid, "0x", 2))
216	keyid += 2;
217	DEBUG1 ("keycache_prepare_single: %s\r\n", keyid);
218	return keycache_prepare2 (ctx, keyid, pubr, secr);
219	}
220	#endif /WITH_OPENPGP/