1
0
mirror of git://git.gnupg.org/gnupg.git synced 2024-12-22 10:19:57 +01:00
gnupg/g10/parse-packet.c

1568 lines
39 KiB
C
Raw Normal View History

1997-11-18 14:06:00 +00:00
/* parse-packet.c - read packets
1998-02-24 18:50:46 +00:00
* Copyright (C) 1998 Free Software Foundation, Inc.
1997-11-18 14:06:00 +00:00
*
* This file is part of GnuPG.
1997-11-18 14:06:00 +00:00
*
* GnuPG is free software; you can redistribute it and/or modify
1997-11-18 14:06:00 +00:00
* 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.
*
* GnuPG is distributed in the hope that it will be useful,
1997-11-18 14:06:00 +00:00
* 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 <config.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include "packet.h"
#include "iobuf.h"
#include "mpi.h"
#include "util.h"
#include "cipher.h"
#include "memory.h"
#include "filter.h"
#include "options.h"
1998-06-25 10:19:08 +00:00
#include "main.h"
1998-11-10 12:59:59 +00:00
#include "i18n.h"
1997-11-18 14:06:00 +00:00
1998-04-14 17:51:16 +00:00
static int mpi_print_mode = 0;
static int list_mode = 0;
1997-11-18 14:06:00 +00:00
1997-12-12 12:03:58 +00:00
static int parse( IOBUF inp, PACKET *pkt, int reqtype,
ulong *retpos, int *skip, IOBUF out, int do_skip
#ifdef DEBUG_PARSE_PACKET
,const char *dbg_w, const char *dbg_f, int dbg_l
#endif
);
static int copy_packet( IOBUF inp, IOBUF out, int pkttype,
unsigned long pktlen );
1997-11-18 14:06:00 +00:00
static void skip_packet( IOBUF inp, int pkttype, unsigned long pktlen );
static void skip_rest( IOBUF inp, unsigned long pktlen );
static void *read_rest( IOBUF inp, ulong *r_pktlen );
1998-05-03 15:42:08 +00:00
static int parse_symkeyenc( IOBUF inp, int pkttype, unsigned long pktlen,
PACKET *packet );
static int parse_pubkeyenc( IOBUF inp, int pkttype, unsigned long pktlen,
1997-11-18 14:06:00 +00:00
PACKET *packet );
static int parse_signature( IOBUF inp, int pkttype, unsigned long pktlen,
PKT_signature *sig );
1997-12-02 19:36:53 +00:00
static int parse_onepass_sig( IOBUF inp, int pkttype, unsigned long pktlen,
PKT_onepass_sig *ops );
1998-06-29 12:30:57 +00:00
static int parse_key( IOBUF inp, int pkttype, unsigned long pktlen,
1997-11-18 14:06:00 +00:00
byte *hdr, int hdrlen, PACKET *packet );
static int parse_user_id( IOBUF inp, int pkttype, unsigned long pktlen,
PACKET *packet );
static int parse_comment( IOBUF inp, int pkttype, unsigned long pktlen,
PACKET *packet );
1997-11-18 14:06:00 +00:00
static void parse_trust( IOBUF inp, int pkttype, unsigned long pktlen );
static int parse_plaintext( IOBUF inp, int pkttype, unsigned long pktlen,
PACKET *packet, int new_ctb);
1997-11-18 14:06:00 +00:00
static int parse_compressed( IOBUF inp, int pkttype, unsigned long pktlen,
PACKET *packet, int new_ctb );
1997-11-18 14:06:00 +00:00
static int parse_encrypted( IOBUF inp, int pkttype, unsigned long pktlen,
PACKET *packet, int new_ctb);
1997-11-18 14:06:00 +00:00
1997-11-18 14:06:00 +00:00
static unsigned short
read_16(IOBUF inp)
{
unsigned short a;
a = iobuf_get_noeof(inp) << 8;
a |= iobuf_get_noeof(inp);
return a;
}
static unsigned long
read_32(IOBUF inp)
{
unsigned long a;
a = iobuf_get_noeof(inp) << 24;
a |= iobuf_get_noeof(inp) << 16;
a |= iobuf_get_noeof(inp) << 8;
a |= iobuf_get_noeof(inp);
return a;
}
1998-03-09 21:44:06 +00:00
1997-11-18 14:06:00 +00:00
int
set_packet_list_mode( int mode )
{
int old = list_mode;
list_mode = mode;
mpi_print_mode = DBG_MPI;
return old;
}
static void
unknown_pubkey_warning( int algo )
{
static byte unknown_pubkey_algos[256];
algo &= 0xff;
if( !unknown_pubkey_algos[algo] ) {
if( opt.verbose )
1998-11-10 12:59:59 +00:00
log_info(_("can't handle public key algorithm %d\n"), algo );
unknown_pubkey_algos[algo] = 1;
}
}
1997-11-18 14:06:00 +00:00
/****************
* Parse a Packet and return it in packet
* Returns: 0 := valid packet in pkt
* -1 := no more packets
* >0 := error
* Note: The function may return an error and a partly valid packet;
* caller must free this packet.
*/
#ifdef DEBUG_PARSE_PACKET
int
dbg_parse_packet( IOBUF inp, PACKET *pkt, const char *dbg_f, int dbg_l )
{
int skip, rc;
do {
rc = parse( inp, pkt, 0, NULL, &skip, NULL, 0, "parse", dbg_f, dbg_l );
} while( skip );
return rc;
}
#else
1997-11-18 14:06:00 +00:00
int
parse_packet( IOBUF inp, PACKET *pkt )
1997-12-12 12:03:58 +00:00
{
int skip, rc;
do {
rc = parse( inp, pkt, 0, NULL, &skip, NULL, 0 );
1997-12-12 12:03:58 +00:00
} while( skip );
return rc;
}
#endif
1997-12-12 12:03:58 +00:00
/****************
1998-04-14 17:51:16 +00:00
* Like parse packet, but only return packets of the given type.
1997-12-12 12:03:58 +00:00
*/
#ifdef DEBUG_PARSE_PACKET
int
dbg_search_packet( IOBUF inp, PACKET *pkt, int pkttype, ulong *retpos,
const char *dbg_f, int dbg_l )
{
int skip, rc;
do {
rc = parse( inp, pkt, pkttype, retpos, &skip, NULL, 0, "search", dbg_f, dbg_l );
} while( skip );
return rc;
}
#else
1997-12-12 12:03:58 +00:00
int
search_packet( IOBUF inp, PACKET *pkt, int pkttype, ulong *retpos )
{
int skip, rc;
do {
rc = parse( inp, pkt, pkttype, retpos, &skip, NULL, 0 );
1997-12-12 12:03:58 +00:00
} while( skip );
return rc;
}
#endif
1997-12-12 12:03:58 +00:00
/****************
* Copy all packets from INP to OUT, thereby removing unused spaces.
*/
#ifdef DEBUG_PARSE_PACKET
int
dbg_copy_all_packets( IOBUF inp, IOBUF out,
const char *dbg_f, int dbg_l )
{
PACKET pkt;
int skip, rc=0;
do {
init_packet(&pkt);
} while( !(rc = parse( inp, &pkt, 0, NULL, &skip, out, 0, "copy", dbg_f, dbg_l )));
return rc;
}
#else
int
copy_all_packets( IOBUF inp, IOBUF out )
{
PACKET pkt;
int skip, rc=0;
do {
init_packet(&pkt);
} while( !(rc = parse( inp, &pkt, 0, NULL, &skip, out, 0 )));
return rc;
}
#endif
/****************
* Copy some packets from INP to OUT, thereby removing unused spaces.
1998-04-14 17:51:16 +00:00
* Stop at offset STOPoff (i.e. don't copy packets at this or later offsets)
*/
#ifdef DEBUG_PARSE_PACKET
int
dbg_copy_some_packets( IOBUF inp, IOBUF out, ulong stopoff,
const char *dbg_f, int dbg_l )
{
PACKET pkt;
int skip, rc=0;
do {
if( iobuf_tell(inp) >= stopoff )
return 0;
init_packet(&pkt);
} while( !(rc = parse( inp, &pkt, 0, NULL, &skip, out, 0,
"some", dbg_f, dbg_l )) );
return rc;
}
#else
int
copy_some_packets( IOBUF inp, IOBUF out, ulong stopoff )
{
PACKET pkt;
int skip, rc=0;
do {
if( iobuf_tell(inp) >= stopoff )
return 0;
init_packet(&pkt);
} while( !(rc = parse( inp, &pkt, 0, NULL, &skip, out, 0 )) );
return rc;
}
#endif
/****************
* Skip over N packets
*/
#ifdef DEBUG_PARSE_PACKET
int
dbg_skip_some_packets( IOBUF inp, unsigned n,
const char *dbg_f, int dbg_l )
{
int skip, rc=0;
PACKET pkt;
for( ;n && !rc; n--) {
init_packet(&pkt);
rc = parse( inp, &pkt, 0, NULL, &skip, NULL, 1, "skip", dbg_f, dbg_l );
}
return rc;
}
#else
int
skip_some_packets( IOBUF inp, unsigned n )
{
int skip, rc=0;
PACKET pkt;
for( ;n && !rc; n--) {
init_packet(&pkt);
rc = parse( inp, &pkt, 0, NULL, &skip, NULL, 1 );
}
return rc;
}
#endif
1998-06-29 12:30:57 +00:00
1997-12-12 12:03:58 +00:00
/****************
* Parse packet. Set the variable skip points to to 1 if the packet
* should be skipped; this is the case if either there is a
* requested packet type and the parsed packet doesn't match or the
* packet-type is 0, indicating deleted stuff.
* if OUT is not NULL, a special copymode is used.
1997-12-12 12:03:58 +00:00
*/
static int
parse( IOBUF inp, PACKET *pkt, int reqtype, ulong *retpos,
int *skip, IOBUF out, int do_skip
#ifdef DEBUG_PARSE_PACKET
,const char *dbg_w, const char *dbg_f, int dbg_l
#endif
)
1997-11-18 14:06:00 +00:00
{
1998-07-06 10:23:57 +00:00
int rc=0, c, ctb, pkttype, lenbytes;
1997-11-18 14:06:00 +00:00
unsigned long pktlen;
1998-05-13 17:53:36 +00:00
byte hdr[8];
1997-11-18 14:06:00 +00:00
int hdrlen;
int new_ctb = 0;
1997-11-18 14:06:00 +00:00
1997-12-12 12:03:58 +00:00
*skip = 0;
1997-11-18 14:06:00 +00:00
assert( !pkt->pkt.generic );
1997-12-12 12:03:58 +00:00
if( retpos )
*retpos = iobuf_tell(inp);
1998-07-06 10:23:57 +00:00
if( (ctb = iobuf_get(inp)) == -1 ) {
rc = -1;
goto leave;
}
1997-11-18 14:06:00 +00:00
hdrlen=0;
hdr[hdrlen++] = ctb;
if( !(ctb & 0x80) ) {
log_error("%s: invalid packet (ctb=%02x) near %lu\n",
iobuf_where(inp), ctb, iobuf_tell(inp) );
1998-07-06 10:23:57 +00:00
rc = G10ERR_INVALID_PACKET;
goto leave;
1997-11-18 14:06:00 +00:00
}
pktlen = 0;
new_ctb = !!(ctb & 0x40);
if( new_ctb ) {
1998-01-16 21:15:24 +00:00
pkttype = ctb & 0x3f;
if( (c = iobuf_get(inp)) == -1 ) {
log_error("%s: 1st length byte missing\n", iobuf_where(inp) );
1998-07-06 10:23:57 +00:00
rc = G10ERR_INVALID_PACKET;
goto leave;
1998-01-16 21:15:24 +00:00
}
hdr[hdrlen++] = c;
if( c < 192 )
pktlen = c;
else if( c < 224 ) {
pktlen = (c - 192) * 256;
if( (c = iobuf_get(inp)) == -1 ) {
log_error("%s: 2nd length byte missing\n", iobuf_where(inp) );
1998-07-06 10:23:57 +00:00
rc = G10ERR_INVALID_PACKET;
goto leave;
1998-01-16 21:15:24 +00:00
}
hdr[hdrlen++] = c;
pktlen += c + 192;
}
else if( c == 255 ) {
1998-05-13 17:53:36 +00:00
pktlen = (hdr[hdrlen++] = iobuf_get_noeof(inp)) << 24;
pktlen |= (hdr[hdrlen++] = iobuf_get_noeof(inp)) << 16;
pktlen |= (hdr[hdrlen++] = iobuf_get_noeof(inp)) << 8;
if( (c = iobuf_get(inp)) == -1 ) {
log_error("%s: 4 byte length invalid\n", iobuf_where(inp) );
1998-07-06 10:23:57 +00:00
rc = G10ERR_INVALID_PACKET;
goto leave;
1998-05-13 17:53:36 +00:00
}
pktlen |= (hdr[hdrlen++] = c );
}
1998-01-16 21:15:24 +00:00
else { /* partial body length */
iobuf_set_partial_block_mode(inp, c & 0xff);
1998-01-16 21:15:24 +00:00
pktlen = 0;/* to indicate partial length */
}
1997-11-18 14:06:00 +00:00
}
else {
1998-01-16 21:15:24 +00:00
pkttype = (ctb>>2)&0xf;
lenbytes = ((ctb&3)==3)? 0 : (1<<(ctb & 3));
if( !lenbytes ) {
pktlen = 0; /* don't know the value */
if( pkttype != PKT_COMPRESSED )
iobuf_set_block_mode(inp, 1);
}
else {
for( ; lenbytes; lenbytes-- ) {
pktlen <<= 8;
pktlen |= hdr[hdrlen++] = iobuf_get_noeof(inp);
}
1997-11-18 14:06:00 +00:00
}
}
if( out && pkttype ) {
if( iobuf_write( out, hdr, hdrlen ) == -1 )
rc = G10ERR_WRITE_FILE;
else
rc = copy_packet(inp, out, pkttype, pktlen );
1998-07-06 10:23:57 +00:00
goto leave;
}
if( do_skip || !pkttype || (reqtype && pkttype != reqtype) ) {
1998-11-20 17:42:18 +00:00
skip_rest(inp, pktlen);
1997-12-12 12:03:58 +00:00
*skip = 1;
1998-07-06 10:23:57 +00:00
rc = 0;
goto leave;
1997-12-12 12:03:58 +00:00
}
if( DBG_PACKET ) {
#ifdef DEBUG_PARSE_PACKET
log_debug("parse_packet(iob=%d): type=%d length=%lu%s (%s.%s.%d)\n",
iobuf_id(inp), pkttype, pktlen, new_ctb?" (new_ctb)":"",
dbg_w, dbg_f, dbg_l );
#else
1998-01-16 21:15:24 +00:00
log_debug("parse_packet(iob=%d): type=%d length=%lu%s\n",
iobuf_id(inp), pkttype, pktlen, new_ctb?" (new_ctb)":"" );
#endif
}
1997-11-18 14:06:00 +00:00
pkt->pkttype = pkttype;
1998-01-16 21:15:24 +00:00
rc = G10ERR_UNKNOWN_PACKET; /* default error */
1997-11-18 14:06:00 +00:00
switch( pkttype ) {
1998-06-29 12:30:57 +00:00
case PKT_PUBLIC_KEY:
case PKT_PUBLIC_SUBKEY:
pkt->pkt.public_key = m_alloc_clear(sizeof *pkt->pkt.public_key );
rc = parse_key(inp, pkttype, pktlen, hdr, hdrlen, pkt );
1997-11-18 14:06:00 +00:00
break;
1998-06-29 12:30:57 +00:00
case PKT_SECRET_KEY:
case PKT_SECRET_SUBKEY:
pkt->pkt.secret_key = m_alloc_clear(sizeof *pkt->pkt.secret_key );
rc = parse_key(inp, pkttype, pktlen, hdr, hdrlen, pkt );
1997-11-18 14:06:00 +00:00
break;
1998-05-03 15:42:08 +00:00
case PKT_SYMKEY_ENC:
rc = parse_symkeyenc( inp, pkttype, pktlen, pkt );
break;
1997-11-18 14:06:00 +00:00
case PKT_PUBKEY_ENC:
1998-05-03 15:42:08 +00:00
rc = parse_pubkeyenc(inp, pkttype, pktlen, pkt );
1997-11-18 14:06:00 +00:00
break;
case PKT_SIGNATURE:
pkt->pkt.signature = m_alloc_clear(sizeof *pkt->pkt.signature );
rc = parse_signature(inp, pkttype, pktlen, pkt->pkt.signature );
break;
1997-12-02 19:36:53 +00:00
case PKT_ONEPASS_SIG:
pkt->pkt.onepass_sig = m_alloc_clear(sizeof *pkt->pkt.onepass_sig );
rc = parse_onepass_sig(inp, pkttype, pktlen, pkt->pkt.onepass_sig );
break;
1997-11-18 14:06:00 +00:00
case PKT_USER_ID:
rc = parse_user_id(inp, pkttype, pktlen, pkt );
break;
1998-05-03 19:35:33 +00:00
case PKT_OLD_COMMENT:
1997-11-18 14:06:00 +00:00
case PKT_COMMENT:
rc = parse_comment(inp, pkttype, pktlen, pkt);
1997-11-18 14:06:00 +00:00
break;
case PKT_RING_TRUST:
parse_trust(inp, pkttype, pktlen);
1998-06-29 12:30:57 +00:00
rc = G10ERR_UNKNOWN_PACKET;
1997-11-18 14:06:00 +00:00
break;
case PKT_PLAINTEXT:
rc = parse_plaintext(inp, pkttype, pktlen, pkt, new_ctb );
1997-11-18 14:06:00 +00:00
break;
1997-12-01 10:33:23 +00:00
case PKT_COMPRESSED:
rc = parse_compressed(inp, pkttype, pktlen, pkt, new_ctb );
1997-11-18 14:06:00 +00:00
break;
1997-12-01 10:33:23 +00:00
case PKT_ENCRYPTED:
rc = parse_encrypted(inp, pkttype, pktlen, pkt, new_ctb );
1997-11-18 14:06:00 +00:00
break;
default:
skip_packet(inp, pkttype, pktlen);
break;
}
1998-07-06 10:23:57 +00:00
leave:
1998-07-29 19:35:05 +00:00
if( !rc && iobuf_error(inp) )
1998-07-06 10:23:57 +00:00
rc = G10ERR_INV_KEYRING;
1997-11-18 14:06:00 +00:00
return rc;
}
1998-01-16 21:15:24 +00:00
static void
dump_hex_line( int c, int *i )
{
if( *i && !(*i%8) ) {
if( *i && !(*i%24) )
printf("\n%4d:", *i );
else
putchar(' ');
}
if( c == -1 )
printf(" EOF" );
else
printf(" %02x", c );
++*i;
}
1997-11-18 14:06:00 +00:00
static int
copy_packet( IOBUF inp, IOBUF out, int pkttype, unsigned long pktlen )
{
int n;
char buf[100];
if( iobuf_in_block_mode(inp) ) {
while( (n = iobuf_read( inp, buf, 100 )) != -1 )
if( iobuf_write(out, buf, n ) )
return G10ERR_WRITE_FILE; /* write error */
}
else if( !pktlen && pkttype == PKT_COMPRESSED ) {
log_debug("copy_packet: compressed!\n");
/* compressed packet, copy till EOF */
while( (n = iobuf_read( inp, buf, 100 )) != -1 )
if( iobuf_write(out, buf, n ) )
return G10ERR_WRITE_FILE; /* write error */
}
else {
for( ; pktlen; pktlen -= n ) {
n = pktlen > 100 ? 100 : pktlen;
n = iobuf_read( inp, buf, n );
if( n == -1 )
return G10ERR_READ_FILE;
if( iobuf_write(out, buf, n ) )
return G10ERR_WRITE_FILE; /* write error */
}
}
return 0;
}
1997-11-18 14:06:00 +00:00
static void
skip_packet( IOBUF inp, int pkttype, unsigned long pktlen )
{
1998-01-16 21:15:24 +00:00
if( list_mode ) {
1998-11-18 19:59:06 +00:00
if( pkttype == PKT_MARKER )
fputs(":marker packet:\n", stdout );
else
printf(":unknown packet: type %2d, length %lu\n", pkttype, pktlen);
1998-01-16 21:15:24 +00:00
if( pkttype ) {
int c, i=0 ;
1998-11-18 19:59:06 +00:00
if( pkttype != PKT_MARKER )
fputs("dump:", stdout );
1998-01-16 21:15:24 +00:00
if( iobuf_in_block_mode(inp) ) {
while( (c=iobuf_get(inp)) != -1 )
dump_hex_line(c, &i);
}
else {
for( ; pktlen; pktlen-- )
dump_hex_line(iobuf_get(inp), &i);
}
putchar('\n');
return;
}
}
1997-11-18 14:06:00 +00:00
skip_rest(inp,pktlen);
}
static void
skip_rest( IOBUF inp, unsigned long pktlen )
{
if( iobuf_in_block_mode(inp) ) {
while( iobuf_get(inp) != -1 )
;
}
else {
for( ; pktlen; pktlen-- )
1998-07-29 19:35:05 +00:00
if( iobuf_get(inp) == -1 )
break;
1997-11-18 14:06:00 +00:00
}
}
static void *
read_rest( IOBUF inp, ulong *r_pktlen )
{
byte *p;
int i;
size_t pktlen = *r_pktlen;
if( iobuf_in_block_mode(inp) ) {
log_error("read_rest: can't store stream data\n");
p = NULL;
}
else {
p = m_alloc( pktlen + 2 );
p[0] = pktlen >> 8;
p[1] = pktlen & 0xff;
for(i=2; pktlen; pktlen--, i++ )
p[i] = iobuf_get(inp);
}
*r_pktlen = 0;
return p;
}
1998-08-05 16:51:59 +00:00
static void *
read_rest2( IOBUF inp, size_t pktlen )
{
byte *p;
int i;
if( iobuf_in_block_mode(inp) ) {
log_error("read_rest: can't store stream data\n");
p = NULL;
}
else {
p = m_alloc( pktlen );
for(i=0; pktlen; pktlen--, i++ )
p[i] = iobuf_get(inp);
}
return p;
}
1997-11-18 14:06:00 +00:00
static int
1998-05-03 15:42:08 +00:00
parse_symkeyenc( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
{
PKT_symkey_enc *k;
int i, version, s2kmode, cipher_algo, hash_algo, seskeylen, minlen;
if( pktlen < 4 ) {
log_error("packet(%d) too short\n", pkttype);
goto leave;
}
version = iobuf_get_noeof(inp); pktlen--;
1998-05-04 18:49:26 +00:00
if( version != 4 ) {
1998-05-03 15:42:08 +00:00
log_error("packet(%d) with unknown version %d\n", pkttype, version);
goto leave;
}
if( pktlen > 200 ) { /* (we encode the seskeylen in a byte) */
log_error("packet(%d) too large\n", pkttype);
goto leave;
}
cipher_algo = iobuf_get_noeof(inp); pktlen--;
s2kmode = iobuf_get_noeof(inp); pktlen--;
hash_algo = iobuf_get_noeof(inp); pktlen--;
switch( s2kmode ) {
case 0: /* simple s2k */
minlen = 0;
break;
case 1: /* salted s2k */
minlen = 8;
break;
1998-08-05 16:51:59 +00:00
case 3: /* iterated+salted s2k */
minlen = 9;
1998-05-03 15:42:08 +00:00
break;
default:
log_error("unknown S2K %d\n", s2kmode );
goto leave;
}
if( minlen > pktlen ) {
log_error("packet with S2K %d too short\n", s2kmode );
goto leave;
}
seskeylen = pktlen - minlen;
k = packet->pkt.symkey_enc = m_alloc_clear( sizeof *packet->pkt.symkey_enc
+ seskeylen - 1 );
k->version = version;
k->cipher_algo = cipher_algo;
k->s2k.mode = s2kmode;
k->s2k.hash_algo = hash_algo;
1998-08-05 16:51:59 +00:00
if( s2kmode == 1 || s2kmode == 3 ) {
1998-05-03 15:42:08 +00:00
for(i=0; i < 8 && pktlen; i++, pktlen-- )
k->s2k.salt[i] = iobuf_get_noeof(inp);
}
1998-08-05 16:51:59 +00:00
if( s2kmode == 3 ) {
k->s2k.count = iobuf_get(inp); pktlen--;
1998-05-03 15:42:08 +00:00
}
k->seskeylen = seskeylen;
for(i=0; i < seskeylen && pktlen; i++, pktlen-- )
k->seskey[i] = iobuf_get_noeof(inp);
assert( !pktlen );
if( list_mode ) {
printf(":symkey enc packet: version %d, cipher %d, s2k %d, hash %d\n",
version, cipher_algo, s2kmode, hash_algo);
1998-08-05 16:51:59 +00:00
if( s2kmode == 1 || s2kmode == 3 ) {
1998-05-03 15:42:08 +00:00
printf("\tsalt ");
for(i=0; i < 8; i++ )
printf("%02x", k->s2k.salt[i]);
1998-08-05 16:51:59 +00:00
if( s2kmode == 3 )
1998-05-03 15:42:08 +00:00
printf(", count %lu\n", (ulong)k->s2k.count );
1998-05-04 18:49:26 +00:00
printf("\n");
1998-05-03 15:42:08 +00:00
}
}
leave:
skip_rest(inp, pktlen);
return 0;
}
static int
parse_pubkeyenc( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
1997-11-18 14:06:00 +00:00
{
unsigned n;
1998-06-13 06:59:14 +00:00
int i, ndata;
1997-11-18 14:06:00 +00:00
PKT_pubkey_enc *k;
k = packet->pkt.pubkey_enc = m_alloc(sizeof *packet->pkt.pubkey_enc );
if( pktlen < 12 ) {
log_error("packet(%d) too short\n", pkttype);
goto leave;
}
1998-03-19 15:27:29 +00:00
k->version = iobuf_get_noeof(inp); pktlen--;
if( k->version != 2 && k->version != 3 ) {
log_error("packet(%d) with unknown version %d\n", pkttype, k->version);
1997-11-18 14:06:00 +00:00
goto leave;
}
k->keyid[0] = read_32(inp); pktlen -= 4;
k->keyid[1] = read_32(inp); pktlen -= 4;
k->pubkey_algo = iobuf_get_noeof(inp); pktlen--;
1998-09-11 05:47:32 +00:00
k->throw_keyid = 0; /* only used as flag for build_packet */
1997-11-18 14:06:00 +00:00
if( list_mode )
1998-05-04 18:49:26 +00:00
printf(":pubkey enc packet: version %d, algo %d, keyid %08lX%08lX\n",
k->version, k->pubkey_algo, (ulong)k->keyid[0], (ulong)k->keyid[1]);
1998-06-13 06:59:14 +00:00
ndata = pubkey_get_nenc(k->pubkey_algo);
if( !ndata ) {
if( list_mode )
printf("\tunsupported algorithm %d\n", k->pubkey_algo );
unknown_pubkey_warning( k->pubkey_algo );
k->data[0] = NULL; /* no need to store the encrypted data */
}
else {
for( i=0; i < ndata; i++ ) {
n = pktlen;
k->data[i] = mpi_read(inp, &n, 0); pktlen -=n;
if( list_mode ) {
printf("\tdata: ");
mpi_print(stdout, k->data[i], mpi_print_mode );
putchar('\n');
}
1997-11-18 14:06:00 +00:00
}
}
leave:
skip_rest(inp, pktlen);
return 0;
}
1998-10-18 15:21:22 +00:00
static void
dump_sig_subpkt( int hashed, int type, int critical,
1998-11-18 19:59:06 +00:00
const byte *buffer, size_t buflen, size_t length )
1998-10-18 15:21:22 +00:00
{
const char *p=NULL;
1998-11-18 19:59:06 +00:00
int i;
1998-10-18 15:21:22 +00:00
printf("\t%s%ssubpkt %d len %u (", /*)*/
critical ? "critical ":"",
hashed ? "hashed ":"", type, (unsigned)length );
buffer++;
length--;
if( length > buflen ) {
printf("too short: buffer is only %u)\n", (unsigned)buflen );
return;
}
switch( type ) {
case SIGSUBPKT_SIG_CREATED:
if( length >= 4 )
printf("sig created %s", strtimestamp( buffer_to_u32(buffer) ) );
break;
case SIGSUBPKT_SIG_EXPIRE:
if( length >= 4 )
1998-11-20 17:42:18 +00:00
printf("sig expires after %s",
strtimevalue( buffer_to_u32(buffer) ) );
1998-10-18 15:21:22 +00:00
break;
case SIGSUBPKT_EXPORTABLE:
1998-11-03 19:38:58 +00:00
if( length )
printf("%sexportable", *buffer? "":"not ");
1998-10-18 15:21:22 +00:00
break;
case SIGSUBPKT_TRUST:
p = "trust signature";
break;
case SIGSUBPKT_REGEXP:
p = "regular expression";
break;
case SIGSUBPKT_REVOCABLE:
p = "revocable";
break;
case SIGSUBPKT_KEY_EXPIRE:
if( length >= 4 )
1998-11-20 17:42:18 +00:00
printf("key expires after %s",
strtimevalue( buffer_to_u32(buffer) ) );
1998-10-18 15:21:22 +00:00
break;
case SIGSUBPKT_ARR:
p = "additional recipient request";
break;
case SIGSUBPKT_PREF_SYM:
1998-11-18 19:59:06 +00:00
fputs("pref-sym-algos:", stdout );
for( i=0; i < length; i++ )
printf(" %d", buffer[i] );
1998-10-18 15:21:22 +00:00
break;
case SIGSUBPKT_REV_KEY:
p = "revocation key";
break;
case SIGSUBPKT_ISSUER:
if( length >= 8 )
printf("issuer key ID %08lX%08lX",
(ulong)buffer_to_u32(buffer),
(ulong)buffer_to_u32(buffer+4) );
break;
case SIGSUBPKT_NOTATION:
p = "notation data";
break;
case SIGSUBPKT_PREF_HASH:
1998-11-18 19:59:06 +00:00
fputs("pref-hash-algos:", stdout );
for( i=0; i < length; i++ )
printf(" %d", buffer[i] );
1998-10-18 15:21:22 +00:00
break;
case SIGSUBPKT_PREF_COMPR:
1998-11-18 19:59:06 +00:00
fputs("pref-zip-algos:", stdout );
for( i=0; i < length; i++ )
printf(" %d", buffer[i] );
1998-10-18 15:21:22 +00:00
break;
case SIGSUBPKT_KS_FLAGS:
p = "key server preferences";
break;
case SIGSUBPKT_PREF_KS:
p = "preferred key server";
break;
case SIGSUBPKT_PRIMARY_UID:
p = "primary user id";
break;
case SIGSUBPKT_POLICY:
p = "policy URL";
break;
case SIGSUBPKT_KEY_FLAGS:
p = "key flags";
break;
case SIGSUBPKT_SIGNERS_UID:
p = "signer's user id";
break;
case SIGSUBPKT_PRIV_ADD_SIG:
p = "signs additional user id";
break;
default: p = "?"; break;
}
printf("%s)\n", p? p: "");
}
/****************
* Returns: >= 0 offset into buffer
* -1 unknown type
* -2 unsupported type
* -3 subpacket too short
*/
static int
parse_one_sig_subpkt( const byte *buffer, size_t n, int type )
{
switch( type ) {
case SIGSUBPKT_SIG_CREATED:
case SIGSUBPKT_SIG_EXPIRE:
case SIGSUBPKT_KEY_EXPIRE:
if( n < 4 )
break;
return 0;
case SIGSUBPKT_EXPORTABLE:
if( !n )
break;
return 0;
case SIGSUBPKT_ISSUER:/* issuer key ID */
if( n < 8 )
break;
return 0;
case SIGSUBPKT_PREF_SYM:
case SIGSUBPKT_PREF_HASH:
case SIGSUBPKT_PREF_COMPR:
return 0;
case SIGSUBPKT_PRIV_ADD_SIG:
/* because we use private data, we check the GNUPG marker */
if( n < 24 )
break;
if( buffer[0] != 'G' || buffer[1] != 'P' || buffer[2] != 'G' )
return -2;
return 3;
default: return -1;
}
return -3;
}
1998-05-13 17:53:36 +00:00
const byte *
parse_sig_subpkt( const byte *buffer, sigsubpkttype_t reqtype, size_t *ret_n )
1998-03-09 21:44:06 +00:00
{
1998-05-13 17:53:36 +00:00
int buflen;
1998-03-09 21:44:06 +00:00
int type;
int critical;
int offset;
1998-03-09 21:44:06 +00:00
size_t n;
1998-05-13 17:53:36 +00:00
if( !buffer )
return NULL;
buflen = (*buffer << 8) | buffer[1];
1998-03-09 21:44:06 +00:00
buffer += 2;
while( buflen ) {
1998-03-09 21:44:06 +00:00
n = *buffer++; buflen--;
1998-05-13 17:53:36 +00:00
if( n == 255 ) {
if( buflen < 4 )
goto too_short;
n = (buffer[0] << 24) | (buffer[1] << 16)
| (buffer[2] << 8) | buffer[3];
buffer += 4;
buflen -= 4;
}
else if( n >= 192 ) {
1998-03-09 21:44:06 +00:00
if( buflen < 2 )
goto too_short;
n = (( n - 192 ) << 8) + *buffer + 192;
buflen--;
}
if( buflen < n )
goto too_short;
type = *buffer;
if( type & 0x80 ) {
type &= 0x7f;
critical = 1;
}
else
critical = 0;
if( reqtype == SIGSUBPKT_TEST_CRITICAL ) {
if( critical ) {
if( n-1 > buflen+1 )
goto too_short;
if( parse_one_sig_subpkt(buffer+1, n-1, type ) < 0 ) {
log_info(_("subpacket of type %d has critical bit set\n"),
type);
return NULL; /* this is an error */
}
}
}
else if( reqtype < 0 ) /* list packets */
1998-10-18 15:21:22 +00:00
dump_sig_subpkt( reqtype == SIGSUBPKT_LIST_HASHED,
type, critical, buffer, buflen, n );
else if( type == reqtype ) { /* found */
buffer++;
n--;
if( n > buflen )
goto too_short;
if( ret_n )
*ret_n = n;
offset = parse_one_sig_subpkt(buffer, n, type );
switch( offset ) {
case -3:
log_error("subpacket of type %d too short\n", type);
return NULL;
case -2:
return NULL;
case -1:
BUG(); /* not yet needed */
default:
break;
}
return buffer+offset;
}
1998-03-09 21:44:06 +00:00
buffer += n; buflen -=n;
}
if( reqtype == SIGSUBPKT_TEST_CRITICAL )
return buffer; /* as value true to indicate that there is no */
/* critical bit we don't understand */
return NULL; /* end of packets; not found */
1998-03-09 21:44:06 +00:00
too_short:
log_error("buffer shorter than subpacket\n");
return NULL;
}
1998-08-05 16:51:59 +00:00
const byte *
parse_sig_subpkt2( PKT_signature *sig, sigsubpkttype_t reqtype, size_t *ret_n )
{
const byte *p;
p = parse_sig_subpkt( sig->hashed_data, reqtype, ret_n );
if( !p )
p = parse_sig_subpkt( sig->unhashed_data, reqtype, ret_n );
return p;
}
1997-11-18 14:06:00 +00:00
static int
parse_signature( IOBUF inp, int pkttype, unsigned long pktlen,
PKT_signature *sig )
{
1998-03-09 21:44:06 +00:00
int md5_len=0;
1997-11-18 14:06:00 +00:00
unsigned n;
1998-03-09 21:44:06 +00:00
int is_v4=0;
int rc=0;
1998-06-13 06:59:14 +00:00
int i, ndata;
1997-11-18 14:06:00 +00:00
if( pktlen < 16 ) {
log_error("packet(%d) too short\n", pkttype);
goto leave;
}
1998-03-09 21:44:06 +00:00
sig->version = iobuf_get_noeof(inp); pktlen--;
if( sig->version == 4 )
is_v4=1;
else if( sig->version != 2 && sig->version != 3 ) {
log_error("packet(%d) with unknown version %d\n", pkttype, sig->version);
1997-11-18 14:06:00 +00:00
goto leave;
}
1998-03-09 21:44:06 +00:00
if( !is_v4 ) {
md5_len = iobuf_get_noeof(inp); pktlen--;
}
1997-11-18 14:06:00 +00:00
sig->sig_class = iobuf_get_noeof(inp); pktlen--;
1998-03-09 21:44:06 +00:00
if( !is_v4 ) {
sig->timestamp = read_32(inp); pktlen -= 4;
sig->keyid[0] = read_32(inp); pktlen -= 4;
sig->keyid[1] = read_32(inp); pktlen -= 4;
}
1997-11-18 14:06:00 +00:00
sig->pubkey_algo = iobuf_get_noeof(inp); pktlen--;
1998-03-09 21:44:06 +00:00
sig->digest_algo = iobuf_get_noeof(inp); pktlen--;
if( is_v4 ) { /* read subpackets */
n = read_16(inp); pktlen -= 2; /* length of hashed data */
if( n > 10000 ) {
log_error("signature packet: hashed data too long\n");
rc = G10ERR_INVALID_PACKET;
goto leave;
}
if( n ) {
sig->hashed_data = m_alloc( n + 2 );
sig->hashed_data[0] = n << 8;
sig->hashed_data[1] = n;
if( iobuf_read(inp, sig->hashed_data+2, n ) != n ) {
log_error("premature eof while reading hashed signature data\n");
rc = -1;
goto leave;
}
pktlen -= n;
}
n = read_16(inp); pktlen -= 2; /* length of unhashed data */
if( n > 10000 ) {
log_error("signature packet: unhashed data too long\n");
rc = G10ERR_INVALID_PACKET;
goto leave;
}
if( n ) {
sig->unhashed_data = m_alloc( n + 2 );
sig->unhashed_data[0] = n << 8;
sig->unhashed_data[1] = n;
if( iobuf_read(inp, sig->unhashed_data+2, n ) != n ) {
log_error("premature eof while reading unhashed signature data\n");
rc = -1;
goto leave;
}
pktlen -= n;
}
}
if( pktlen < 5 ) { /* sanity check */
log_error("packet(%d) too short\n", pkttype);
rc = G10ERR_INVALID_PACKET;
goto leave;
}
sig->digest_start[0] = iobuf_get_noeof(inp); pktlen--;
sig->digest_start[1] = iobuf_get_noeof(inp); pktlen--;
1998-04-14 17:51:16 +00:00
if( is_v4 ) { /*extract required information */
1998-03-09 21:44:06 +00:00
const byte *p;
1998-10-01 07:23:00 +00:00
/* set sig->flags.unknown_critical if there is a
* critical bit set for packets which we do not understand */
if( !parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_TEST_CRITICAL, NULL)
|| !parse_sig_subpkt( sig->unhashed_data, SIGSUBPKT_TEST_CRITICAL,
NULL) )
{
sig->flags.unknown_critical = 1;
}
1998-05-13 17:53:36 +00:00
p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_SIG_CREATED, NULL );
1998-03-09 21:44:06 +00:00
if( !p )
log_error("signature packet without timestamp\n");
else
sig->timestamp = buffer_to_u32(p);
1998-08-05 16:51:59 +00:00
p = parse_sig_subpkt2( sig, SIGSUBPKT_ISSUER, NULL );
1998-03-09 21:44:06 +00:00
if( !p )
log_error("signature packet without keyid\n");
else {
sig->keyid[0] = buffer_to_u32(p);
sig->keyid[1] = buffer_to_u32(p+4);
}
}
if( list_mode ) {
1998-05-04 18:49:26 +00:00
printf(":signature packet: algo %d, keyid %08lX%08lX\n"
1998-03-09 21:44:06 +00:00
"\tversion %d, created %lu, md5len %d, sigclass %02x\n"
"\tdigest algo %d, begin of digest %02x %02x\n",
1998-05-04 18:49:26 +00:00
sig->pubkey_algo,
1998-02-03 12:09:20 +00:00
(ulong)sig->keyid[0], (ulong)sig->keyid[1],
1998-03-09 21:44:06 +00:00
sig->version, (ulong)sig->timestamp, md5_len, sig->sig_class,
sig->digest_algo,
sig->digest_start[0], sig->digest_start[1] );
if( is_v4 ) {
1998-05-13 17:53:36 +00:00
parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_LIST_HASHED, NULL );
parse_sig_subpkt( sig->unhashed_data,SIGSUBPKT_LIST_UNHASHED, NULL);
1997-11-24 22:24:04 +00:00
}
1998-03-09 21:44:06 +00:00
}
1998-06-13 06:59:14 +00:00
ndata = pubkey_get_nsig(sig->pubkey_algo);
if( !ndata ) {
if( list_mode )
printf("\tunknown algorithm %d\n", sig->pubkey_algo );
unknown_pubkey_warning( sig->pubkey_algo );
/* we store the plain material in data[0], so that we are able
* to write it back with build_packet() */
sig->data[0] = read_rest(inp, &pktlen );
}
else {
for( i=0; i < ndata; i++ ) {
n = pktlen;
sig->data[i] = mpi_read(inp, &n, 0 );
pktlen -=n;
if( list_mode ) {
printf("\tdata: ");
mpi_print(stdout, sig->data[i], mpi_print_mode );
putchar('\n');
}
1997-11-18 14:06:00 +00:00
}
}
leave:
skip_rest(inp, pktlen);
1998-03-09 21:44:06 +00:00
return rc;
1997-11-18 14:06:00 +00:00
}
1997-12-02 19:36:53 +00:00
static int
parse_onepass_sig( IOBUF inp, int pkttype, unsigned long pktlen,
PKT_onepass_sig *ops )
{
int version;
if( pktlen < 13 ) {
log_error("packet(%d) too short\n", pkttype);
goto leave;
}
version = iobuf_get_noeof(inp); pktlen--;
if( version != 3 ) {
log_error("onepass_sig with unknown version %d\n", version);
goto leave;
}
ops->sig_class = iobuf_get_noeof(inp); pktlen--;
ops->digest_algo = iobuf_get_noeof(inp); pktlen--;
ops->pubkey_algo = iobuf_get_noeof(inp); pktlen--;
ops->keyid[0] = read_32(inp); pktlen -= 4;
ops->keyid[1] = read_32(inp); pktlen -= 4;
ops->last = iobuf_get_noeof(inp); pktlen--;
if( list_mode )
printf(":onepass_sig packet: keyid %08lX%08lX\n"
"\tversion %d, sigclass %02x, digest %d, pubkey %d, last=%d\n",
1998-02-03 12:09:20 +00:00
(ulong)ops->keyid[0], (ulong)ops->keyid[1],
1997-12-02 19:36:53 +00:00
version, ops->sig_class,
ops->digest_algo, ops->pubkey_algo, ops->last );
leave:
skip_rest(inp, pktlen);
return 0;
}
1997-11-18 14:06:00 +00:00
static int
1998-06-29 12:30:57 +00:00
parse_key( IOBUF inp, int pkttype, unsigned long pktlen,
1997-11-18 14:06:00 +00:00
byte *hdr, int hdrlen, PACKET *pkt )
{
int i, version, algorithm;
unsigned n;
1998-10-16 16:00:17 +00:00
unsigned long timestamp, expiredate;
1998-06-29 12:30:57 +00:00
int npkey, nskey;
1997-11-24 22:24:04 +00:00
int is_v4=0;
1998-02-24 18:50:46 +00:00
int rc=0;
1997-11-18 14:06:00 +00:00
version = iobuf_get_noeof(inp); pktlen--;
1998-06-29 12:30:57 +00:00
if( pkttype == PKT_PUBLIC_SUBKEY && version == '#' ) {
1998-05-03 19:35:33 +00:00
/* early versions of G10 use old PGP comments packets;
* luckily all those comments are started by a hash */
1998-04-02 10:30:03 +00:00
if( list_mode ) {
1998-05-03 19:35:33 +00:00
printf(":rfc1991 comment packet: \"" );
1998-04-02 10:30:03 +00:00
for( ; pktlen; pktlen-- ) {
int c;
c = iobuf_get_noeof(inp);
if( c >= ' ' && c <= 'z' )
putchar(c);
else
printf("\\x%02x", c );
}
printf("\"\n");
}
skip_rest(inp, pktlen);
return 0;
}
else if( version == 4 )
1997-11-24 22:24:04 +00:00
is_v4=1;
else if( version != 2 && version != 3 ) {
1997-11-18 14:06:00 +00:00
log_error("packet(%d) with unknown version %d\n", pkttype, version);
goto leave;
}
1998-04-02 10:30:03 +00:00
if( pktlen < 11 ) {
log_error("packet(%d) too short\n", pkttype);
goto leave;
}
1997-11-18 14:06:00 +00:00
timestamp = read_32(inp); pktlen -= 4;
1997-11-24 22:24:04 +00:00
if( is_v4 )
1998-10-16 16:00:17 +00:00
expiredate = 0; /* have to get it from the selfsignature */
1998-01-16 21:15:24 +00:00
else {
1998-10-16 16:00:17 +00:00
unsigned short ndays;
ndays = read_16(inp); pktlen -= 2;
if( ndays )
expiredate = timestamp + ndays * 86400L;
else
expiredate = 0;
1998-01-16 21:15:24 +00:00
}
1997-11-18 14:06:00 +00:00
algorithm = iobuf_get_noeof(inp); pktlen--;
if( list_mode )
1998-01-16 21:15:24 +00:00
printf(":%s key packet:\n"
1998-10-16 16:00:17 +00:00
"\tversion %d, algo %d, created %lu, expires %lu\n",
1998-06-29 12:30:57 +00:00
pkttype == PKT_PUBLIC_KEY? "public" :
pkttype == PKT_SECRET_KEY? "secret" :
pkttype == PKT_PUBLIC_SUBKEY? "public sub" :
pkttype == PKT_SECRET_SUBKEY? "secret sub" : "??",
1998-10-16 16:00:17 +00:00
version, algorithm, timestamp, expiredate );
1998-06-29 12:30:57 +00:00
if( pkttype == PKT_SECRET_KEY || pkttype == PKT_SECRET_SUBKEY ) {
PKT_secret_key *sk = pkt->pkt.secret_key;
sk->timestamp = timestamp;
1998-10-16 16:00:17 +00:00
sk->expiredate = expiredate;
1998-06-29 12:30:57 +00:00
sk->hdrbytes = hdrlen;
sk->version = version;
sk->is_primary = pkttype == PKT_SECRET_KEY;
1998-06-29 12:30:57 +00:00
sk->pubkey_algo = algorithm;
1998-07-06 10:23:57 +00:00
sk->pubkey_usage = 0; /* not yet used */
1997-11-18 14:06:00 +00:00
}
else {
1998-06-29 12:30:57 +00:00
PKT_public_key *pk = pkt->pkt.public_key;
1997-11-18 14:06:00 +00:00
1998-06-29 12:30:57 +00:00
pk->timestamp = timestamp;
1998-10-16 16:00:17 +00:00
pk->expiredate = expiredate;
1998-06-29 12:30:57 +00:00
pk->hdrbytes = hdrlen;
pk->version = version;
pk->pubkey_algo = algorithm;
1998-07-06 10:23:57 +00:00
pk->pubkey_usage = 0; /* not yet used */
1998-07-09 13:37:17 +00:00
pk->keyid[0] = 0;
pk->keyid[1] = 0;
1998-06-29 12:30:57 +00:00
}
nskey = pubkey_get_nskey( algorithm );
npkey = pubkey_get_npkey( algorithm );
if( !npkey ) {
if( list_mode )
printf("\tunknown algorithm %d\n", algorithm );
unknown_pubkey_warning( algorithm );
1998-06-29 12:30:57 +00:00
}
1998-02-24 18:50:46 +00:00
1998-08-05 16:51:59 +00:00
if( pkttype == PKT_SECRET_KEY || pkttype == PKT_SECRET_SUBKEY ) {
1998-06-29 12:30:57 +00:00
PKT_secret_key *sk = pkt->pkt.secret_key;
byte temp[8];
1998-02-24 18:50:46 +00:00
if( !npkey ) {
sk->skey[0] = read_rest( inp, &pktlen );
goto leave;
}
1998-06-29 12:30:57 +00:00
for(i=0; i < npkey; i++ ) {
n = pktlen; sk->skey[i] = mpi_read(inp, &n, 0 ); pktlen -=n;
if( list_mode ) {
printf( "\tskey[%d]: ", i);
mpi_print(stdout, sk->skey[i], mpi_print_mode );
putchar('\n');
}
}
sk->protect.algo = iobuf_get_noeof(inp); pktlen--;
if( sk->protect.algo ) {
sk->is_protected = 1;
sk->protect.s2k.count = 0;
if( sk->protect.algo == 255 ) {
if( pktlen < 3 ) {
rc = G10ERR_INVALID_PACKET;
goto leave;
1998-02-24 18:50:46 +00:00
}
1998-06-29 12:30:57 +00:00
sk->protect.algo = iobuf_get_noeof(inp); pktlen--;
sk->protect.s2k.mode = iobuf_get_noeof(inp); pktlen--;
sk->protect.s2k.hash_algo = iobuf_get_noeof(inp); pktlen--;
switch( sk->protect.s2k.mode ) {
case 1:
1998-08-05 16:51:59 +00:00
case 3:
1998-06-29 12:30:57 +00:00
for(i=0; i < 8 && pktlen; i++, pktlen-- )
temp[i] = iobuf_get_noeof(inp);
memcpy(sk->protect.s2k.salt, temp, 8 );
break;
1998-02-24 18:50:46 +00:00
}
1998-06-29 12:30:57 +00:00
switch( sk->protect.s2k.mode ) {
case 0: if( list_mode ) printf( "\tsimple S2K" );
break;
case 1: if( list_mode ) printf( "\tsalted S2K" );
break;
1998-08-05 16:51:59 +00:00
case 3: if( list_mode ) printf( "\titer+salt S2K" );
1998-06-29 12:30:57 +00:00
break;
default:
if( list_mode )
printf( "\tunknown S2K %d\n",
sk->protect.s2k.mode );
1998-02-24 18:50:46 +00:00
rc = G10ERR_INVALID_PACKET;
goto leave;
}
1998-06-29 12:30:57 +00:00
1997-11-24 22:24:04 +00:00
if( list_mode ) {
1998-06-29 12:30:57 +00:00
printf(", algo: %d, hash: %d",
sk->protect.algo,
sk->protect.s2k.hash_algo );
if( sk->protect.s2k.mode == 1
1998-08-05 16:51:59 +00:00
|| sk->protect.s2k.mode == 3 ) {
1998-06-29 12:30:57 +00:00
printf(", salt: ");
for(i=0; i < 8; i++ )
printf("%02x", sk->protect.s2k.salt[i]);
}
1997-11-24 22:24:04 +00:00
putchar('\n');
}
1998-06-29 12:30:57 +00:00
1998-08-05 16:51:59 +00:00
if( sk->protect.s2k.mode == 3 ) {
if( pktlen < 1 ) {
1998-03-09 21:44:06 +00:00
rc = G10ERR_INVALID_PACKET;
goto leave;
}
1998-08-05 16:51:59 +00:00
sk->protect.s2k.count = iobuf_get(inp);
pktlen--;
1998-09-28 19:25:31 +00:00
if( list_mode )
printf("\tprotect count: %lu\n",
(ulong)sk->protect.s2k.count);
1998-03-09 21:44:06 +00:00
}
1998-06-29 12:30:57 +00:00
}
else { /* old version; no S2K, so we set mode to 0, hash MD5 */
sk->protect.s2k.mode = 0;
/* We need a kludge to cope with old GNUPG versions */
sk->protect.s2k.hash_algo =
1998-08-11 17:29:34 +00:00
( sk->protect.algo == CIPHER_ALGO_BLOWFISH160
&& algorithm == PUBKEY_ALGO_ELGAMAL_E ) ?
DIGEST_ALGO_RMD160 : DIGEST_ALGO_MD5;
1998-06-29 12:30:57 +00:00
if( list_mode )
printf( "\tprotect algo: %d (hash algo: %d)\n",
sk->protect.algo, sk->protect.s2k.hash_algo );
}
if( pktlen < 8 ) {
rc = G10ERR_INVALID_PACKET;
goto leave;
}
1998-07-29 19:35:05 +00:00
/* fixme: Add support for other blocksizes */
1998-06-29 12:30:57 +00:00
for(i=0; i < 8 && pktlen; i++, pktlen-- )
temp[i] = iobuf_get_noeof(inp);
if( list_mode ) {
printf( "\tprotect IV: ");
for(i=0; i < 8; i++ )
printf(" %02x", temp[i] );
putchar('\n');
}
memcpy(sk->protect.iv, temp, 8 );
}
else
sk->is_protected = 0;
/* It does not make sense to read it into secure memory.
* If the user is so careless, not to protect his secret key,
* we can assume, that he operates an open system :=(.
* So we put the key into secure memory when we unprotect it. */
1998-08-08 19:27:00 +00:00
if( is_v4 && sk->is_protected ){
/* ugly; the length is encrypted too, so we read all
1998-08-05 16:51:59 +00:00
* stuff up to the end of the packet into the first
* skey element */
sk->skey[npkey] = mpi_set_opaque(NULL,
read_rest2(inp, pktlen), pktlen );
pktlen = 0;
1998-06-29 12:30:57 +00:00
if( list_mode ) {
1998-08-05 16:51:59 +00:00
printf("\tencrypted stuff follows\n");
}
}
else { /* v3 method: the mpi length is not encrypted */
for(i=npkey; i < nskey; i++ ) {
n = pktlen; sk->skey[i] = mpi_read(inp, &n, 0 ); pktlen -=n;
1998-06-29 12:30:57 +00:00
if( sk->is_protected )
1998-08-05 16:51:59 +00:00
mpi_set_protect_flag(sk->skey[i]);
if( list_mode ) {
printf( "\tskey[%d]: ", i);
if( sk->is_protected )
printf( "[encrypted]\n");
else {
mpi_print(stdout, sk->skey[i], mpi_print_mode );
putchar('\n');
}
1998-03-09 21:44:06 +00:00
}
}
1997-11-24 22:24:04 +00:00
1998-08-05 16:51:59 +00:00
sk->csum = read_16(inp); pktlen -= 2;
if( list_mode ) {
printf("\tchecksum: %04hx\n", sk->csum);
}
1997-11-18 14:06:00 +00:00
}
1998-06-29 12:30:57 +00:00
}
else {
PKT_public_key *pk = pkt->pkt.public_key;
1997-11-18 14:06:00 +00:00
if( !npkey ) {
pk->pkey[0] = read_rest( inp, &pktlen );
goto leave;
}
1998-06-29 12:30:57 +00:00
for(i=0; i < npkey; i++ ) {
n = pktlen; pk->pkey[i] = mpi_read(inp, &n, 0 ); pktlen -=n;
1997-11-18 14:06:00 +00:00
if( list_mode ) {
1998-06-29 12:30:57 +00:00
printf( "\tpkey[%d]: ", i);
mpi_print(stdout, pk->pkey[i], mpi_print_mode );
putchar('\n');
1997-11-18 14:06:00 +00:00
}
}
}
leave:
skip_rest(inp, pktlen);
1998-02-24 18:50:46 +00:00
return rc;
1997-11-18 14:06:00 +00:00
}
static int
parse_user_id( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
{
byte *p;
packet->pkt.user_id = m_alloc(sizeof *packet->pkt.user_id + pktlen);
1997-11-18 14:06:00 +00:00
packet->pkt.user_id->len = pktlen;
p = packet->pkt.user_id->name;
for( ; pktlen; pktlen--, p++ )
1997-11-18 14:06:00 +00:00
*p = iobuf_get_noeof(inp);
*p = 0;
1997-11-18 14:06:00 +00:00
if( list_mode ) {
int n = packet->pkt.user_id->len;
printf(":user id packet: \"");
/* fixme: Hey why don't we replace this wioth print_string?? */
1997-11-18 14:06:00 +00:00
for(p=packet->pkt.user_id->name; n; p++, n-- ) {
if( *p >= ' ' && *p <= 'z' )
putchar(*p);
else
printf("\\x%02x", *p );
}
printf("\"\n");
}
return 0;
}
1998-01-16 21:15:24 +00:00
static int
parse_comment( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
1997-11-18 14:06:00 +00:00
{
byte *p;
packet->pkt.comment = m_alloc(sizeof *packet->pkt.comment + pktlen - 1);
packet->pkt.comment->len = pktlen;
p = packet->pkt.comment->data;
for( ; pktlen; pktlen--, p++ )
*p = iobuf_get_noeof(inp);
1997-11-18 14:06:00 +00:00
if( list_mode ) {
int n = packet->pkt.comment->len;
1998-05-03 19:35:33 +00:00
printf(":%scomment packet: \"", pkttype == PKT_OLD_COMMENT?
"OpenPGP draft " : "" );
for(p=packet->pkt.comment->data; n; p++, n-- ) {
if( *p >= ' ' && *p <= 'z' )
putchar(*p);
1997-11-18 14:06:00 +00:00
else
printf("\\x%02x", *p );
1997-11-18 14:06:00 +00:00
}
printf("\"\n");
}
return 0;
1997-11-18 14:06:00 +00:00
}
static void
parse_trust( IOBUF inp, int pkttype, unsigned long pktlen )
{
int c;
c = iobuf_get_noeof(inp);
if( list_mode )
printf(":trust packet: flag=%02x\n", c );
}
static int
parse_plaintext( IOBUF inp, int pkttype, unsigned long pktlen,
PACKET *pkt, int new_ctb )
1997-11-18 14:06:00 +00:00
{
int mode, namelen;
PKT_plaintext *pt;
byte *p;
int c, i;
if( pktlen && pktlen < 6 ) {
log_error("packet(%d) too short (%lu)\n", pkttype, (ulong)pktlen);
goto leave;
}
mode = iobuf_get_noeof(inp); if( pktlen ) pktlen--;
namelen = iobuf_get_noeof(inp); if( pktlen ) pktlen--;
pt = pkt->pkt.plaintext = m_alloc(sizeof *pkt->pkt.plaintext + namelen -1);
pt->new_ctb = new_ctb;
1997-11-18 14:06:00 +00:00
pt->mode = mode;
pt->namelen = namelen;
if( pktlen ) {
for( i=0; pktlen > 4 && i < namelen; pktlen--, i++ )
pt->name[i] = iobuf_get_noeof(inp);
}
else {
for( i=0; i < namelen; i++ )
if( (c=iobuf_get(inp)) == -1 )
break;
else
pt->name[i] = c;
}
pt->timestamp = read_32(inp); if( pktlen) pktlen -= 4;
pt->len = pktlen;
pt->buf = inp;
pktlen = 0;
if( list_mode ) {
printf(":literal data packet:\n"
"\tmode %c, created %lu, name=\"",
mode >= ' ' && mode <'z'? mode : '?',
1998-02-03 12:09:20 +00:00
(ulong)pt->timestamp );
1997-11-18 14:06:00 +00:00
for(p=pt->name,i=0; i < namelen; p++, i++ ) {
if( *p >= ' ' && *p <= 'z' )
putchar(*p);
else
printf("\\x%02x", *p );
}
1998-02-03 12:09:20 +00:00
printf("\",\n\traw data: %lu bytes\n", (ulong)pt->len );
1997-11-18 14:06:00 +00:00
}
leave:
return 0;
}
static int
parse_compressed( IOBUF inp, int pkttype, unsigned long pktlen,
PACKET *pkt, int new_ctb )
1997-11-18 14:06:00 +00:00
{
PKT_compressed *zd;
/* pktlen is here 0, but data follows
* (this should be the last object in a file or
* the compress algorithm should know the length)
*/
zd = pkt->pkt.compressed = m_alloc(sizeof *pkt->pkt.compressed );
zd->len = 0; /* not yet used */
zd->algorithm = iobuf_get_noeof(inp);
zd->new_ctb = new_ctb;
1997-11-18 14:06:00 +00:00
zd->buf = inp;
if( list_mode )
printf(":compressed packet: algo=%d\n", zd->algorithm);
return 0;
}
static int
parse_encrypted( IOBUF inp, int pkttype, unsigned long pktlen,
PACKET *pkt, int new_ctb )
1997-11-18 14:06:00 +00:00
{
1997-12-01 10:33:23 +00:00
PKT_encrypted *ed;
1997-11-18 14:06:00 +00:00
1997-12-01 10:33:23 +00:00
ed = pkt->pkt.encrypted = m_alloc(sizeof *pkt->pkt.encrypted );
1997-11-18 14:06:00 +00:00
ed->len = pktlen;
ed->buf = NULL;
ed->new_ctb = new_ctb;
1997-11-18 14:06:00 +00:00
if( pktlen && pktlen < 10 ) {
log_error("packet(%d) too short\n", pkttype);
skip_rest(inp, pktlen);
goto leave;
}
1998-04-14 17:51:16 +00:00
if( list_mode ) {
1997-11-18 14:06:00 +00:00
if( pktlen )
printf(":encrypted data packet:\n\tlength: %lu\n", pktlen-10);
else
printf(":encrypted data packet:\n\tlength: unknown\n");
1998-04-14 17:51:16 +00:00
}
1997-11-18 14:06:00 +00:00
ed->buf = inp;
pktlen = 0;
leave:
return 0;
}
1998-03-09 21:44:06 +00:00