Changeset 137

Show
Ignore:
Timestamp:
05/20/05 15:10:24
Author:
ben
Message:

Refactor public key packet construction.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • openpgpsdk/trunk/examples/Makefile.template

    r136 r137  
    88LIBS=$(LIBDEPS) -lcrypto -lz $(DM_LIB) 
    99 
    10 all: Makefile .depend packet-dump verify create-key create-signed-key 
     10all: Makefile lib .depend packet-dump verify create-key create-signed-key 
     11 
     12lib: 
     13        cd ../src && make 
    1114 
    1215packet-dump: packet-dump.o $(LIBDEPS) 

  • openpgpsdk/trunk/include/memory.h

    r136 r137  
    1919void ops_memory_pad(ops_memory_t *mem,size_t length); 
    2020void ops_memory_add(ops_memory_t *mem,const unsigned char *src,size_t length); 
    21 void ops_memory_add_int(ops_memory_t *mem,unsigned n,size_t length); 
    2221void ops_memory_place_int(ops_memory_t *mem,unsigned offset,unsigned n, 
    2322                          size_t length); 
    24 void ops_memory_add_mpi(ops_memory_t *out,const BIGNUM *bn); 
    2523void ops_memory_make_packet(ops_memory_t *out,ops_content_tag_t tag); 
    2624void ops_memory_release(ops_memory_t *mem); 

  • openpgpsdk/trunk/src/build.c

    r136 r137  
    1010#include <string.h> 
    1111 
     12// XXX: move this to memory.c? 
    1213void ops_memory_make_packet(ops_memory_t *out,ops_content_tag_t tag) 
    1314    { 
    …… 
    4445    out->length+=extra+1; 
    4546    } 
    46  
    47 // XXX: this should be refactored into a write 
    48 void ops_build_public_key(ops_memory_t *out,const ops_public_key_t *key, 
    49                           ops_boolean_t make_packet) 
    50     { 
    51     ops_memory_init(out,128); 
    52     ops_memory_add_int(out,key->version,1); 
    53     ops_memory_add_int(out,key->creation_time,4); 
    54     if(key->version != 4) 
    55         ops_memory_add_int(out,key->days_valid,2); 
    56     ops_memory_add_int(out,key->algorithm,1); 
    57  
    58     switch(key->algorithm) 
    59         { 
    60     case OPS_PKA_DSA: 
    61         ops_memory_add_mpi(out,key->key.dsa.p); 
    62         ops_memory_add_mpi(out,key->key.dsa.q); 
    63         ops_memory_add_mpi(out,key->key.dsa.g); 
    64         ops_memory_add_mpi(out,key->key.dsa.y); 
    65         break; 
    66  
    67     case OPS_PKA_RSA: 
    68     case OPS_PKA_RSA_ENCRYPT_ONLY: 
    69     case OPS_PKA_RSA_SIGN_ONLY: 
    70         ops_memory_add_mpi(out,key->key.rsa.n); 
    71         ops_memory_add_mpi(out,key->key.rsa.e); 
    72         break; 
    73  
    74     case OPS_PKA_ELGAMAL: 
    75         ops_memory_add_mpi(out,key->key.elgamal.p); 
    76         ops_memory_add_mpi(out,key->key.elgamal.g); 
    77         ops_memory_add_mpi(out,key->key.elgamal.y); 
    78         break; 
    79         } 
    80  
    81     if(make_packet) 
    82         ops_memory_make_packet(out,OPS_PTAG_CT_PUBLIC_KEY); 
    83     } 

  • openpgpsdk/trunk/src/create.c

    r136 r137  
    44#include "create.h" 
    55#include "util.h" 
     6#include "build.h" 
    67#include <string.h> 
    78#include <assert.h> 
    …… 
    125126    } 
    126127 
     128// Note that we support v3 keys here because they're needed for 
     129// for verification - the writer doesn't allow them, though 
     130static int write_public_key_body(const ops_public_key_t *key, 
     131                                  ops_create_options_t *opt) 
     132    { 
     133    if(!(ops_write_scalar(key->version,1,opt) 
     134         && ops_write_scalar(key->creation_time,4,opt))) 
     135        return ops_false; 
     136 
     137    if(key->version != 4 && !ops_write_scalar(key->days_valid,2,opt)) 
     138        return ops_false; 
     139 
     140    if(!ops_write_scalar(key->algorithm,1,opt)) 
     141        return ops_false; 
     142 
     143    switch(key->algorithm) 
     144        { 
     145    case OPS_PKA_DSA: 
     146        return ops_write_mpi(key->key.dsa.p,opt) 
     147            && ops_write_mpi(key->key.dsa.q,opt) 
     148            && ops_write_mpi(key->key.dsa.g,opt) 
     149            && ops_write_mpi(key->key.dsa.y,opt); 
     150 
     151    case OPS_PKA_RSA: 
     152    case OPS_PKA_RSA_ENCRYPT_ONLY: 
     153    case OPS_PKA_RSA_SIGN_ONLY: 
     154        return ops_write_mpi(key->key.rsa.n,opt) 
     155            && ops_write_mpi(key->key.rsa.e,opt); 
     156 
     157    case OPS_PKA_ELGAMAL: 
     158        return ops_write_mpi(key->key.elgamal.p,opt) 
     159            && ops_write_mpi(key->key.elgamal.g,opt) 
     160            && ops_write_mpi(key->key.elgamal.y,opt); 
     161 
     162    default: 
     163        assert(0); 
     164        break; 
     165        } 
     166 
     167    /* not reached */ 
     168    return ops_false; 
     169    } 
     170 
    127171ops_boolean_t ops_write_struct_public_key(const ops_public_key_t *key, 
    128172                                          ops_create_options_t *opt) 
    …… 
    130174    assert(key->version == 4); 
    131175 
    132     if(!(ops_write_ptag(OPS_PTAG_CT_PUBLIC_KEY,opt) 
    133          && ops_write_length(1+4+1+public_key_length(key),opt) 
    134          && ops_write_scalar(key->version,1,opt) 
    135          && ops_write_scalar(key->creation_time,4,opt) 
    136          && ops_write_scalar(key->algorithm,1,opt))) 
    137         return ops_false; 
    138  
    139     switch(key->algorithm) 
    140         { 
    141     case OPS_PKA_RSA: 
    142         return ops_write_mpi(key->key.rsa.n,opt) 
    143             && ops_write_mpi(key->key.rsa.e,opt); 
    144  
    145     default: 
    146         assert(!"unknown key algorithm"); 
    147         } 
    148  
    149     /* not reached */ 
    150     return ops_false; 
     176    return ops_write_ptag(OPS_PTAG_CT_PUBLIC_KEY,opt) 
     177        && ops_write_length(1+4+1+public_key_length(key),opt) 
     178        && write_public_key_body(key,opt); 
    151179    } 
    152180 
    …… 
    161189    return ops_write_struct_public_key(&key,opt); 
    162190    } 
     191 
     192void ops_build_public_key(ops_memory_t *out,const ops_public_key_t *key, 
     193                          ops_boolean_t make_packet) 
     194    { 
     195    ops_create_options_t opt; 
     196 
     197    ops_memory_init(out,128); 
     198    opt.writer=ops_writer_memory; 
     199    opt.arg=out; 
     200 
     201    write_public_key_body(key,&opt); 
     202 
     203    if(make_packet) 
     204        ops_memory_make_packet(out,OPS_PTAG_CT_PUBLIC_KEY); 
     205    } 

  • openpgpsdk/trunk/src/memory.c

    r136 r137  
    4646    } 
    4747 
    48 void ops_memory_add_int(ops_memory_t *mem,unsigned n,size_t length) 
    49     { 
    50     unsigned char c[1]; 
    51  
    52     while(length--) 
    53         { 
    54         c[0]=n >> (length*8); 
    55         ops_memory_add(mem,c,1); 
    56         } 
    57     } 
    58  
     48// XXX: this could be refactored via the writer, but an awful lot of 
     49// hoops to jump through for 2 lines of code! 
    5950void ops_memory_place_int(ops_memory_t *mem,unsigned offset,unsigned n, 
    6051                          size_t length) 
    …… 
    6455    while(length--) 
    6556        mem->buf[offset++]=n >> (length*8); 
    66     } 
    67  
    68 void ops_memory_add_mpi(ops_memory_t *out,const BIGNUM *bn) 
    69     { 
    70     unsigned length=BN_num_bits(bn); 
    71     unsigned char buf[8192]; 
    72  
    73     assert(length <= 65535); 
    74     BN_bn2bin(bn,buf); 
    75     ops_memory_add_int(out,length,2); 
    76     ops_memory_add(out,buf,(length+7)/8); 
    7757    } 
    7858 
    …… 
    9171    return OPS_W_OK; 
    9272    } 
    93  

  • openpgpsdk/trunk/src/signature.c

    r136 r137  
    241241    { 
    242242    // XXX: refactor with check (in several ways - check should probably 
    243     // use the buffered writer to construct packets, and also should 
     243    // use the buffered writer to construct packets (done), and also should 
    244244    // share code for hash calculation) 
    245245    sig->sig.version=OPS_SIG_V4;