trunk/MyGPGME/revoke.c

/* revoke.c - Revocation certificates
 *      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 <string.h>
#include <sys/types.h>

#include "ops.h"
#include "context.h"
#include "util.h"
#include "openpgp.h"

struct revoke_result_s {
    int bad_passphrase;
};


static void
revoke_set_reason( gpgme_editkey_t ctx, int id )
{
    switch (id) {
    case GPGME_REVOKE_INSECURE:   ctx->u.revoke.reason_id = "1"; break;
    case GPGME_REVOKE_SUPERSEDED: ctx->u.revoke.reason_id = "2"; break;
    case GPGME_REVOKE_NOUSED:     ctx->u.revoke.reason_id = "3"; break;
    default:                      ctx->u.revoke.reason_id = "0"; break;
    }
} /* revoke_set_reason */


gpgme_error_t
gpgme_revoke_set( gpgme_editkey_t ctx, const char * uid, const char * text,
                 int reason, int pgpmode, const char *pass )
{
    char * p;

    if( !ctx )
        return mk_error( Invalid_Value );
    revoke_set_reason( ctx, reason );
    ctx->type = GPGME_EDITKEY_REVOKE;
    ctx->u.revoke.uid = uid;
    if( text ) {
        p = ctx->u.revoke.reason_text = strdup( text );
        if (!p)
            return mk_error (Out_Of_Core);
        ctx->u.revoke.reason_sent = 0;
    }
    ctx->u.revoke.passwd = pass;
    ctx->u.revoke.pgp = pgpmode;
    return 0;
} /* gpgme_revoke_set */


static void
revoke_status_handler (gpgme_ctx_t ctx, gpg_statcode_t code, char * args)
{
    struct revoke_result_s * c = ctx->tmp_res;

    if( ctx->out_of_core )
        return;
    
    switch( code ) {
    case STATUS_EOF: 
        break;

    case STATUS_GOOD_PASSPHRASE:
        c->bad_passphrase = 0;
        break;
        
    default: /* ignore all other codes */
        break;
    }
} /* revoke_status_handler */


static const char *
revoke_command_handler( void *opaque, gpg_statcode_t code, const char *key )
{
    gpgme_editkey_t c = opaque;
    
    if( !code ) {
        /* cleanup */
        return NULL;
    }
    
    if( !key )
        return NULL;
    
    if( code == STATUS_GET_BOOL && !strcmp( key, "gen_revoke.okay" ) ) {
        c->u.revoke.reason_sent = 0;
        return "Y";
    }

    if( code == STATUS_GET_LINE && !strcmp( key, "ask_revocation_reason.code" ) )
        return c->u.revoke.reason_id;

    if( code == STATUS_GET_LINE && !strcmp( key, "ask_revocation_reason.text" ) ) {
        if( c->u.revoke.reason_sent == 0 && c->u.revoke.reason_text ) {
            c->u.revoke.reason_sent++;
            return c->u.revoke.reason_text;
        }
        return "";
    }
    
    if( code == STATUS_GET_BOOL && !strcmp( key, "ask_revocation_reason.okay" ) )
        return "Y";
    
    if( code == STATUS_GET_HIDDEN && !strcmp( key, "passphrase.enter" ) )
        return c->u.revoke.passwd;
    
    return NULL;
} /* command_handler */


static gpgme_error_t
revoke_start( gpgme_ctx_t ctx, gpgme_editkey_t rev, gpgme_data_t cert )
{
    gpgme_error_t rc;
    
    fail_on_pending_request( ctx );
    ctx->pending = 1;
    
    _gpgme_gpg_release( &ctx->gpg ); 
    rc = _gpgme_gpg_new( &ctx->gpg );
    if( rc )
        goto leave;

    if( ctx->use_logging )
        _gpgme_gpg_set_logging_handler( ctx->gpg, ctx );
    _gpgme_gpg_set_status_handler( ctx->gpg, revoke_status_handler, ctx );
    _gpgme_gpg_set_command_handler( ctx->gpg, revoke_command_handler, rev );
    
    _gpgme_data_set_mode( cert, GPGME_DATA_MODE_IN );
    
    if( rev->u.revoke.pgp )
        _gpgme_gpg_add_arg( ctx->gpg, "--pgp7" );
    _gpgme_gpg_add_arg( ctx->gpg, "--output");
    _gpgme_gpg_add_arg( ctx->gpg, "-" );
    _gpgme_gpg_add_data( ctx->gpg, cert, 1 );
    
    _gpgme_gpg_add_arg( ctx->gpg, "--gen-revoke" );
    _gpgme_gpg_add_arg( ctx->gpg, rev->u.revoke.uid );
    
    rc = _gpgme_gpg_spawn( ctx->gpg, ctx );
    
leave:
    if( rc ) {
        _gpgme_gpg_release( &ctx->gpg );
        ctx->pending = 0;
    }
    
    return rc;
} /* gpgme_op_revoke_start */


gpgme_error_t
gpgme_op_revoke (gpgme_ctx_t ctx, gpgme_editkey_t rev, gpgme_data_t cert)
{
    struct revoke_result_s res;
    gpgme_error_t rc;
    
    res.bad_passphrase = 1;
    ctx->tmp_res = &res;

    rc = revoke_start (ctx, rev, cert);
    if( !rc ) {
        gpgme_wait (ctx, 1);
        if (res.bad_passphrase)
            rc = mk_error (Bad_Passphrase);
        ctx->pending = 0;
    }
    
    return rc;
} /* gpgme_op_revoke */


gpgme_error_t
gpgme_revcert_new( gpgme_revcert_t *r_cert )
{
    gpgme_revcert_t ctx;

    if( !r_cert )
        return mk_error( Invalid_Value );
    ctx = calloc( 1, sizeof *ctx );
    if( !ctx )
        return mk_error( Out_Of_Core );
    *r_cert = ctx;
    return 0;
} /* gpgme_revcert_new */


void
gpgme_revcert_release( gpgme_revcert_t cert )
{
    if( cert ) {
        safe_free( cert->reason );
        safe_free( cert );      
    }
} /* gpgme_revcert_release */

gpgme_error_t
gpgme_revcert_parse( const char *data, gpgme_revcert_t cert, char * keyid )
{
    gpg_iobuf_t tmp;
    armor_filter_context_t afx;
    PACKET *pkt = calloc( 1, sizeof *pkt );
    PKT_signature * sig;
    int rc = 0, len = 0, seq = 0;
    const byte *p;
    FILE * fp;
    
    if( !data || !cert )
        return mk_error( Invalid_Value );

    fp = fopen( "temp.winpt.xxx", "wb" );
    if( fp ) {
        fwrite( data, 1, strlen( data ), fp );
        fclose( fp );
    }
    tmp = gpg_iobuf_open( "temp.winpt.xxx" );
    if( tmp == NULL )
        return mk_error( General_Error );
    gpg_iobuf_ioctl( tmp, 3, 1, NULL ); /* disable cache */
    if( gpg_use_armor_filter( tmp ) ) {
        memset( &afx, 0, sizeof afx );
        gpg_iobuf_push_filter( tmp, gpg_armor_filter, &afx );
    }

    gpg_iobuf_seek( tmp, 0 );
    gpg_init_packet( pkt );
    while( ( rc = gpg_parse_packet( tmp, pkt ) ) != -1 ) {
        if( pkt->pkttype == PKT_SIGNATURE )
            break;
        gpg_free_packet( pkt );
    }

    if( pkt->pkttype != PKT_SIGNATURE )
        goto fail;
    sig = pkt->pkt.signature;

    p = gpg_parse_sig_subpkt2( sig, SIGSUBPKT_REVOC_REASON, &len );
    if( p ) {
        cert->code = p[0];
        if( len > 1 ) {
            cert->reason = calloc( 1, len );
            if( !cert->reason )
                goto fail;
            memcpy( cert->reason , p + 1, len - 1 );
            cert->reason[len-1] = '\0';
        }
        else
            cert->reason = NULL;
    }
    sprintf( cert->keyid, "%08lX%08lX", sig->keyid[0], sig->keyid[1] );
    if( keyid )
        strcpy( keyid, cert->keyid );
    cert->timestamp = 0;
    p = gpg_parse_sig_subpkt2( sig, SIGSUBPKT_SIG_CREATED, &len );
    if( p  && len == 4 )
        cert->timestamp = p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3];    

fail:
    gpg_iobuf_close( tmp );
    unlink( "temp.winpt.xxx" );
    gpg_free_packet( pkt );
    safe_free( pkt );    
    return 0;
} /* gpgme_revcert_parse */
1	twoaday	2	/* revoke.c - Revocation certificates
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 <string.h>
22			#include <sys/types.h>
23
24			#include "ops.h"
25			#include "context.h"
26			#include "util.h"
27			#include "openpgp.h"
28
29			struct revoke_result_s {
30			int bad_passphrase;
31			};
32
33
34			static void
35			revoke_set_reason( gpgme_editkey_t ctx, int id )
36			{
37			switch (id) {
38			case GPGME_REVOKE_INSECURE: ctx->u.revoke.reason_id = "1"; break;
39			case GPGME_REVOKE_SUPERSEDED: ctx->u.revoke.reason_id = "2"; break;
40			case GPGME_REVOKE_NOUSED: ctx->u.revoke.reason_id = "3"; break;
41			default: ctx->u.revoke.reason_id = "0"; break;
42			}
43			} /* revoke_set_reason */
44
45
46			gpgme_error_t
47			gpgme_revoke_set( gpgme_editkey_t ctx, const char * uid, const char * text,
48			int reason, int pgpmode, const char *pass )
49			{
50			char * p;
51
52			if( !ctx )
53			return mk_error( Invalid_Value );
54			revoke_set_reason( ctx, reason );
55			ctx->type = GPGME_EDITKEY_REVOKE;
56			ctx->u.revoke.uid = uid;
57			if( text ) {
58			p = ctx->u.revoke.reason_text = strdup( text );
59			if (!p)
60			return mk_error (Out_Of_Core);
61			ctx->u.revoke.reason_sent = 0;
62			}
63			ctx->u.revoke.passwd = pass;
64			ctx->u.revoke.pgp = pgpmode;
65			return 0;
66			} /* gpgme_revoke_set */
67
68
69			static void
70			revoke_status_handler (gpgme_ctx_t ctx, gpg_statcode_t code, char * args)
71			{
72			struct revoke_result_s * c = ctx->tmp_res;
73
74			if( ctx->out_of_core )
75			return;
76
77			switch( code ) {
78			case STATUS_EOF:
79			break;
80
81			case STATUS_GOOD_PASSPHRASE:
82			c->bad_passphrase = 0;
83			break;
84
85			default: /* ignore all other codes */
86			break;
87			}
88			} /* revoke_status_handler */
89
90
91			static const char *
92			revoke_command_handler( void opaque, gpg_statcode_t code, const char key )
93			{
94			gpgme_editkey_t c = opaque;
95
96			if( !code ) {
97			/* cleanup */
98			return NULL;
99			}
100
101			if( !key )
102			return NULL;
103
104			if( code == STATUS_GET_BOOL && !strcmp( key, "gen_revoke.okay" ) ) {
105			c->u.revoke.reason_sent = 0;
106			return "Y";
107			}
108
109			if( code == STATUS_GET_LINE && !strcmp( key, "ask_revocation_reason.code" ) )
110			return c->u.revoke.reason_id;
111
112			if( code == STATUS_GET_LINE && !strcmp( key, "ask_revocation_reason.text" ) ) {
113			if( c->u.revoke.reason_sent == 0 && c->u.revoke.reason_text ) {
114			c->u.revoke.reason_sent++;
115			return c->u.revoke.reason_text;
116			}
117			return "";
118			}
119
120			if( code == STATUS_GET_BOOL && !strcmp( key, "ask_revocation_reason.okay" ) )
121			return "Y";
122
123			if( code == STATUS_GET_HIDDEN && !strcmp( key, "passphrase.enter" ) )
124			return c->u.revoke.passwd;
125
126			return NULL;
127			} /* command_handler */
128
129
130			static gpgme_error_t
131			revoke_start( gpgme_ctx_t ctx, gpgme_editkey_t rev, gpgme_data_t cert )
132			{
133			gpgme_error_t rc;
134
135			fail_on_pending_request( ctx );
136			ctx->pending = 1;
137
138			_gpgme_gpg_release( &ctx->gpg );
139			rc = _gpgme_gpg_new( &ctx->gpg );
140			if( rc )
141			goto leave;
142
143			if( ctx->use_logging )
144			_gpgme_gpg_set_logging_handler( ctx->gpg, ctx );
145			_gpgme_gpg_set_status_handler( ctx->gpg, revoke_status_handler, ctx );
146			_gpgme_gpg_set_command_handler( ctx->gpg, revoke_command_handler, rev );
147
148			_gpgme_data_set_mode( cert, GPGME_DATA_MODE_IN );
149
150			if( rev->u.revoke.pgp )
151			_gpgme_gpg_add_arg( ctx->gpg, "--pgp7" );
152			_gpgme_gpg_add_arg( ctx->gpg, "--output");
153			_gpgme_gpg_add_arg( ctx->gpg, "-" );
154			_gpgme_gpg_add_data( ctx->gpg, cert, 1 );
155
156			_gpgme_gpg_add_arg( ctx->gpg, "--gen-revoke" );
157			_gpgme_gpg_add_arg( ctx->gpg, rev->u.revoke.uid );
158
159			rc = _gpgme_gpg_spawn( ctx->gpg, ctx );
160
161			leave:
162			if( rc ) {
163			_gpgme_gpg_release( &ctx->gpg );
164			ctx->pending = 0;
165			}
166
167			return rc;
168			} /* gpgme_op_revoke_start */
169
170
171			gpgme_error_t
172			gpgme_op_revoke (gpgme_ctx_t ctx, gpgme_editkey_t rev, gpgme_data_t cert)
173			{
174			struct revoke_result_s res;
175			gpgme_error_t rc;
176
177			res.bad_passphrase = 1;
178			ctx->tmp_res = &res;
179
180			rc = revoke_start (ctx, rev, cert);
181			if( !rc ) {
182			gpgme_wait (ctx, 1);
183			if (res.bad_passphrase)
184			rc = mk_error (Bad_Passphrase);
185			ctx->pending = 0;
186			}
187
188			return rc;
189			} /* gpgme_op_revoke */
190
191
192			gpgme_error_t
193			gpgme_revcert_new( gpgme_revcert_t *r_cert )
194			{
195			gpgme_revcert_t ctx;
196
197			if( !r_cert )
198			return mk_error( Invalid_Value );
199			ctx = calloc( 1, sizeof *ctx );
200			if( !ctx )
201			return mk_error( Out_Of_Core );
202			*r_cert = ctx;
203			return 0;
204			} /* gpgme_revcert_new */
205
206
207			void
208			gpgme_revcert_release( gpgme_revcert_t cert )
209			{
210			if( cert ) {
211			safe_free( cert->reason );
212			safe_free( cert );
213			}
214			} /* gpgme_revcert_release */
215
216			gpgme_error_t
217			gpgme_revcert_parse( const char data, gpgme_revcert_t cert, char keyid )
218			{
219			gpg_iobuf_t tmp;
220			armor_filter_context_t afx;
221			PACKET pkt = calloc( 1, sizeof pkt );
222			PKT_signature * sig;
223			int rc = 0, len = 0, seq = 0;
224			const byte *p;
225			FILE * fp;
226
227			if( !data \|\| !cert )
228			return mk_error( Invalid_Value );
229
230			fp = fopen( "temp.winpt.xxx", "wb" );
231			if( fp ) {
232			fwrite( data, 1, strlen( data ), fp );
233			fclose( fp );
234			}
235			tmp = gpg_iobuf_open( "temp.winpt.xxx" );
236			if( tmp == NULL )
237			return mk_error( General_Error );
238			gpg_iobuf_ioctl( tmp, 3, 1, NULL ); /* disable cache */
239			if( gpg_use_armor_filter( tmp ) ) {
240			memset( &afx, 0, sizeof afx );
241			gpg_iobuf_push_filter( tmp, gpg_armor_filter, &afx );
242			}
243
244			gpg_iobuf_seek( tmp, 0 );
245			gpg_init_packet( pkt );
246			while( ( rc = gpg_parse_packet( tmp, pkt ) ) != -1 ) {
247			if( pkt->pkttype == PKT_SIGNATURE )
248			break;
249			gpg_free_packet( pkt );
250			}
251
252			if( pkt->pkttype != PKT_SIGNATURE )
253			goto fail;
254			sig = pkt->pkt.signature;
255
256			p = gpg_parse_sig_subpkt2( sig, SIGSUBPKT_REVOC_REASON, &len );
257			if( p ) {
258			cert->code = p[0];
259			if( len > 1 ) {
260			cert->reason = calloc( 1, len );
261			if( !cert->reason )
262			goto fail;
263			memcpy( cert->reason , p + 1, len - 1 );
264			cert->reason[len-1] = '\0';
265			}
266			else
267			cert->reason = NULL;
268			}
269			sprintf( cert->keyid, "%08lX%08lX", sig->keyid[0], sig->keyid[1] );
270			if( keyid )
271			strcpy( keyid, cert->keyid );
272			cert->timestamp = 0;
273			p = gpg_parse_sig_subpkt2( sig, SIGSUBPKT_SIG_CREATED, &len );
274			if( p && len == 4 )
275			cert->timestamp = p[0] << 24 \| p[1] << 16 \| p[2] << 8 \| p[3];
276
277			fail:
278			gpg_iobuf_close( tmp );
279			unlink( "temp.winpt.xxx" );
280			gpg_free_packet( pkt );
281			safe_free( pkt );
282			return 0;
283			} /* gpgme_revcert_parse */