Changeset 22

Timestamp:

01/16/05 21:14:46

Author:

ben

Message:

signature subpacket sketch.

Files:

• openpgpsdk/trunk/src/packet-dump.c (modified) (3 diffs)
• openpgpsdk/trunk/src/packet-parse.c (modified) (8 diffs)
• openpgpsdk/trunk/src/packet-parse.h (modified) (1 diff)
• openpgpsdk/trunk/src/packet.h (modified) (4 diffs)

openpgpsdk/trunk/src/packet-dump.c

@@ -5 +5 @@
-#include <assert.h>
-#include <stdlib.h>
+
+static void hexdump(const unsigned char *src,size_t length)
+    {
+    while(length--)
+        printf("%02X",*src++);
+    }
-
-static ops_packet_reader_ret_t reader(unsigned char *dest,unsigned length)
@@ -15 +21 @@
-    if(n != length)
-        return OPS_PR_EARLY_EOF;
-
+
+
+
+
+
-    return OPS_PR_OK;
-    }
-
-static void hexdump(const char *src,size_t length)
-    {
-    while(length--)
-        printf("%02X",*src++);
-    }
-
@@ -120 +124 @@
-int main(int argc,char **argv)
-    {
-
+
+
+
+
-
-    return 0;

openpgpsdk/trunk/src/packet-parse.c

@@ -12 +12 @@
-#define ERR1(fmt,x)     do { format_error(&content,(fmt),(x)); E; } while(0)
-
+/* XXX: replace ops_ptag_t with something more appropriate for limiting
+   reads */
+
-/* Note that this makes the parser non-reentrant, in a limited way */
-/* It is the caller's responsibility to avoid overflow in the buffer */
@@ -60 +63 @@
-    ptag->length_read+=length;
-
+    return 1;
+    }
+
+static int limited_skip(unsigned length,ops_ptag_t *ptag,
+                        ops_packet_reader_t *reader,
+                        ops_packet_parse_callback_t *cb)
+    {
+    unsigned char buf[8192];
+
+    while(length)
+        {
+        int n=length%8192;
+        if(!limited_read(buf,n,ptag,reader,cb))
+            return 0;
+        length-=n;
+        }
-    return 1;
-    }
@@ -116 +135 @@
-    *pbn=BN_bin2bn(buf,length,NULL);
-    return 1;
+    }
+
+static int limited_read_new_length(unsigned *length,ops_ptag_t *ptag,
+                                   ops_packet_reader_t *reader,
+                                   ops_packet_parse_callback_t *cb)
+    {
+    unsigned char c[1];
+
+    if(!limited_read(c,1,ptag,reader,cb))
+        return 0;
+    if(c[0] < 192)
+        {
+        *length=c[0];
+        return 1;
+        }
+    if(c[0] < 255)
+        {
+        unsigned t=(c[0]-192) << 8;
+
+        if(!limited_read(c,1,ptag,reader,cb))
+            return 0;
+        *length=t+c[1]+192;
+        return 1;
+        }
+    return limited_read_scalar(length,4,ptag,reader,cb);
-    }
-
@@ -253 +297 @@
-    }
-
+static int parse_one_signature_subpacket(ops_ptag_t *ptag,
+                                         ops_packet_reader_t *reader,
+                                         ops_packet_parse_callback_t *cb,
+                                         ops_parse_packet_options_t *opt)
+    {
+    ops_ptag_t subptag;
+    char c[1];
+    ops_parser_content_t content;
+    unsigned t8,t7;
+
+    memset(&subptag,'\0',sizeof subptag);
+    if(!limited_read_new_length(&subptag.length,ptag,reader,cb))
+        return 0;
+
+    if(!limited_read(c,1,&subptag,reader,cb))
+        return 0;
+
+    t8=(c[0]&0x7f)/8;
+    t7=1 << (c[0]&7);
+
+    content.critical=c[0] >> 7;
+    content.tag=OPS_PTAG_SIGNATURE_SUBPACKET_BASE+(c[0]&0x7f);
+    if(opt->ss_raw[t8]&t7)
+        {
+        C.ss_raw.tag=content.tag;
+        C.ss_raw.raw=malloc(subptag.length-1);
+        if(!limited_read(C.ss_raw.raw,subptag.length-1,ptag,reader,cb))
+            return 0;
+        ptag->length_read+=subptag.length;
+        CB(OPS_PTAG_RAW_SS,&content);
+        return 1;
+        }
+    if(!(opt->ss_parsed[t8]&t7))
+        {
+        if(content.critical)
+            ERR1("Critical signature subpacket ignored (%d)",c[0]&0x7f);
+        if(!limited_skip(subptag.length-1,&subptag,reader,cb))
+            return 0;
+        printf("skipped %d length %d\n",c[0]&0x7f,subptag.length);
+        ptag->length_read+=subptag.length;
+        return 1;
+        }
+
+    switch(content.tag)
+        {
+    case OPS_PTAG_SS_TRUST:
+        if(!limited_read(&C.ss_trust.level,1,&subptag,reader,cb)
+           || !limited_read(&C.ss_trust.level,1,&subptag,reader,cb))
+            return 0;
+        break;
+
+    default:
+        ERR1("Unknown signature subpacket type (%d)",c[0]&0x7f);
+        }
+ 
+    ptag->length_read+=subptag.length;
+    cb(&content);
+
+    return 1;
+    }
+
+static int parse_signature_subpackets(ops_ptag_t *ptag,
+                                      ops_packet_reader_t *reader,
+                                      ops_packet_parse_callback_t *cb,
+                                      ops_parse_packet_options_t *opt)
+    {
+    ops_ptag_t subptag;
+
+    memset(&subptag,'\0',sizeof subptag);
+    if(!limited_read_scalar(&subptag.length,2,ptag,reader,cb))
+        return 0;
+
+    while(subptag.length_read < subptag.length)
+        if(!parse_one_signature_subpacket(&subptag,reader,cb,opt))
+            {
+            ptag->length_read+=subptag.length_read;
+            return 0;
+            }
+
+    assert(subptag.length_read == subptag.length);
+    ptag->length_read+=subptag.length_read;
+
+    return 1;
+    }
+
-static int parse_v4_signature(ops_ptag_t *ptag,ops_packet_reader_t *reader,
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-    return 1;
@@ -262 +443 @@
-
-static int parse_signature(ops_ptag_t *ptag,ops_packet_reader_t *reader,
-
+
+
-    {
-    unsigned char c[1];
@@ -274 +456 @@
-        return parse_v3_signature(ptag,reader,cb);
-    else if(c[0] == 4)
-
+,opt
-    ERR1("Bad signature version (%d)",c[0]);
-    }
-
-static int ops_parse_one_packet(ops_packet_reader_t *reader,
-
+
+
-    {
-    char ptag[1];
@@ -336 +519 @@
-        {
-    case OPS_PTAG_CT_SIGNATURE:
-
+,opt
-        break;
-
@@ -357 +540 @@
-
-void ops_parse_packet(ops_packet_reader_t *reader,
-
-
-
+
+
+
+
-        ;
-    }
+
+void ops_parse_packet_options(ops_parse_packet_options_t *opt,
+                              ops_content_tag_t tag,
+                              ops_parse_type_t type)
+    {
+    int t8,t7;
+
+    assert(tag >= OPS_PTAG_SIGNATURE_SUBPACKET_BASE
+           && tag <= OPS_PTAG_SIGNATURE_SUBPACKET_BASE+255);
+    t8=(tag-OPS_PTAG_SIGNATURE_SUBPACKET_BASE)/8;
+    t7=1 << ((tag-OPS_PTAG_SIGNATURE_SUBPACKET_BASE)&7);
+    switch(type)
+        {
+    case OPS_PARSE_RAW:
+        opt->ss_raw[t8] |= t7;
+        opt->ss_parsed[t8] &= ~t7;
+        break;
+
+    case OPS_PARSE_PARSED:
+        opt->ss_raw[t8] &= ~t7;
+        opt->ss_parsed[t8] |= t7;
+        break;
+
+    case OPS_PARSE_IGNORE:
+        opt->ss_raw[t8] &= ~t7;
+        opt->ss_parsed[t8] &= ~t7;
+        break;
+        }
+    }
+
+        

openpgpsdk/trunk/src/packet-parse.h

@@ -10 +10 @@
-                                                  unsigned length);
-
+typedef struct
+    {
+    unsigned char ss_raw[256/8];
+    unsigned char ss_parsed[256/8];
+    } ops_parse_packet_options_t;
+
-void ops_parse_packet(ops_packet_reader_t *reader,
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

openpgpsdk/trunk/src/packet.h

@@ -57 +57 @@
-    OPS_PARSER_ERROR                    =0x100,
-    OPS_PARSER_PTAG                     =0x101,
+    OPS_PTAG_RAW_SS                     =0x102,
+
+    /* signature subpackets (0x200-2ff) (type+0x200) */
+    /* only those we can parse are listed here */
+    OPS_PTAG_SIGNATURE_SUBPACKET_BASE   =0x200,
+    OPS_PTAG_SS_CREATION_TIME           =0x200+2,
+    OPS_PTAG_SS_EXPIRATION_TIME         =0x200+3,
+    OPS_PTAG_SS_TRUST                   =0x200+5,
-    } ops_content_tag_t;
-
@@ -186 +194 @@
-    } ops_signature_t;
-
+typedef struct
+    {
+    ops_content_tag_t           tag;
+    unsigned char               *raw;
+    } ops_ss_raw_t;
+
+typedef struct
+    {
+    unsigned char               level;
+    unsigned char               amount;
+    } ops_ss_trust_t;
+
-typedef union
-    {
@@ -193 +213 @@
-    ops_user_id_t               user_id;
-    ops_signature_t             signature;
+    ops_ss_raw_t                ss_raw;
+    ops_ss_trust_t              ss_trust;
-    } ops_parser_content_union_t;
-
@@ -198 +220 @@
-    {
-    ops_content_tag_t           tag;
+    unsigned char               critical; /* for signature subpackets */
-    ops_parser_content_union_t  content;
-    } ops_parser_content_t;