Changeset 438

Show
Ignore:
Timestamp:
02/15/07 18:30:31
Author:
rachel
Message:

Ben's stub encryption code.
Libraries compile but encrypt.c is needed in examples directory.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • openpgpsdk/trunk/examples/Makefile.template

    r432 r438  
    88LIBS=$(LIBDEPS) %CRYPTO_LIBS% %ZLIB% $(DM_LIB) %LIBS% 
    99EXES=packet-dump verify create-key verify2 sign-detached \ 
    10      sign-inline decrypt build-keyring 
     10     sign-inline decrypt build-keyring encrypt 
    1111# create-signed-key  
    1212 
     
    4646        $(CC) $(LDFLAGS) -o decrypt decrypt.o $(LIBS) 
    4747 
     48encrypt: encrypt.o $(LIBDEPS) 
     49        $(CC) $(LDFLAGS) -o encrypt encrypt.o $(LIBS) 
    4850 
    4951tags: 
  • openpgpsdk/trunk/include/openpgpsdk/armour.h

    r327 r438  
    1111                                  ops_create_signature_t *sig); 
    1212void ops_writer_switch_to_signature(ops_create_info_t *info); 
    13  
  • openpgpsdk/trunk/include/openpgpsdk/crypto.h

    r417 r438  
    108108                    const ops_secret_key_t *skey); 
    109109 
     110// Encrypt everything that's written 
     111struct ops_key_data; 
     112void ops_writer_push_encrypt(ops_create_info_t *info, 
     113                             const struct ops_key_data *key); 
     114 
    110115#endif 
  • openpgpsdk/trunk/src/advanced/adv_accumulate.c

    r426 r438  
    5252               sizeof keyring->keys[keyring->nkeys]); 
    5353 
    54         ops_keyid(keyring->keys[keyring->nkeys].keyid,pkey); 
     54        ops_keyid(keyring->keys[keyring->nkeys].key_id,pkey); 
    5555        ops_fingerprint(&keyring->keys[keyring->nkeys].fingerprint,pkey); 
    5656 
     
    132132 
    133133    printf("Key ID: "); 
    134     hexdump(key->keyid,8); 
     134    hexdump(key->key_id,8); 
    135135 
    136136    printf("\nFingerpint: "); 
  • openpgpsdk/trunk/src/advanced/adv_create.c

    r426 r438  
    33 
    44#include <openpgpsdk/create.h> 
     5#include <openpgpsdk/keyring.h> 
     6#include "keyring_local.h" 
     7#include <openpgpsdk/packet.h> 
    58#include <openpgpsdk/util.h> 
    69#include <string.h> 
     
    744747                                     ops_writer_info_t *winfo) 
    745748    { return ops_stacked_write(src,length,errors,winfo); } 
     749 
     750 
     751ops_pk_session_key_t *ops_create_pk_session_key(const ops_key_data_t *key) 
     752    { 
     753    ops_pk_session_key_t *session_key=ops_mallocz(sizeof *session_key); 
     754 
     755    session_key->version=OPS_PKSK_V3; 
     756    memcpy(session_key->key_id, key->key_id, sizeof session_key->key_id); 
     757    // XXX: finish filling in the structure 
     758    return session_key; 
     759    } 
     760 
     761// XXX: should these be common and just be called ops_crypt_*? 
     762typedef struct _ops_encrypt_t ops_encrypt_t; 
     763typedef void ops_encrypt_set_iv_t(ops_encrypt_t *encrypt, 
     764                                  const unsigned char *iv); 
     765typedef void ops_encrypt_init_t(ops_encrypt_t *encrypt); 
     766typedef void ops_encrypt_resync_t(ops_encrypt_t *encrypt); 
     767typedef void ops_encrypt_block_encrypt_t(ops_encrypt_t *encrypt,void *out, 
     768                                         const void *in); 
     769typedef void ops_encrypt_finish_t(ops_encrypt_t *encrypt); 
     770 
     771/** _ops_encrypt_t */ 
     772struct _ops_encrypt_t 
     773    { 
     774    ops_symmetric_algorithm_t algorithm; 
     775    size_t blocksize; 
     776    size_t keysize; 
     777    //    ops_encrypt_set_iv_t *set_iv; /* Call this before init! */ 
     778    ops_encrypt_set_iv_t *set_key; /* Call this before init! */ 
     779    ops_encrypt_init_t *base_init; /* Once the key is set, call this */ 
     780    ops_encrypt_resync_t *resync; 
     781    //    ops_decrypt_decrypt_t *decrypt; 
     782    ops_encrypt_block_encrypt_t *block_encrypt; 
     783    ops_encrypt_finish_t *finish; 
     784    unsigned char iv[OPS_MAX_BLOCK_SIZE]; 
     785    unsigned char civ[OPS_MAX_BLOCK_SIZE]; 
     786    unsigned char siv[OPS_MAX_BLOCK_SIZE]; /* Needed for weird v3 resync */ 
     787    unsigned char key[OPS_MAX_KEY_SIZE]; 
     788    size_t num; 
     789    void *data; 
     790    }; 
     791 
     792typedef struct 
     793    { 
     794    ops_encrypt_t *encrypter; 
     795    } encrypted_arg_t; 
     796 
     797 
     798/* dummy function */ 
     799 
     800#ifndef ATTRIBUTE_UNUSED 
     801#define ATTRIBUTE_UNUSED __attribute__ ((__unused__)) 
     802#endif /* ATTRIBUTE_UNUSED */ 
     803 
     804void ops_write_pk_session_key(ops_create_info_t *info ATTRIBUTE_UNUSED, ops_pk_session_key_t *session_key ATTRIBUTE_UNUSED) 
     805    { 
     806    /* \todo write ops_write_pk_session_key() */ 
     807    assert(0); 
     808    } 
     809 
     810static ops_boolean_t encrypted_writer(const unsigned char *src ATTRIBUTE_UNUSED, 
     811                              unsigned length ATTRIBUTE_UNUSED, 
     812                              ops_error_t **errors ATTRIBUTE_UNUSED, 
     813                              ops_writer_info_t *winfo ATTRIBUTE_UNUSED 
     814                              ) 
     815    { 
     816     /* \todo */ 
     817    assert(0); 
     818    } 
     819 
     820static ops_boolean_t encrypted_finaliser(ops_error_t **errors ATTRIBUTE_UNUSED, 
     821                                           ops_writer_info_t *winfo ATTRIBUTE_UNUSED) 
     822    { 
     823    /* \todo */ 
     824    assert(0); 
     825    } 
     826 
     827void encrypted_destroyer (ops_writer_info_t *winfo ATTRIBUTE_UNUSED) 
     828      
     829    { 
     830    /* \todo */ 
     831    assert(0); 
     832    } 
     833 
     834/* end of dummy code */ 
     835 
     836void ops_writer_push_encrypt(ops_create_info_t *info, 
     837                             const ops_key_data_t *key) 
     838    { 
     839    ops_pk_session_key_t *session_key; 
     840    encrypted_arg_t *arg=ops_mallocz(sizeof *arg); 
     841 
     842    session_key=ops_create_pk_session_key(key); 
     843    ops_write_pk_session_key(info,session_key); 
     844 
     845    ops_write_ptag(OPS_PTAG_CT_SE_DATA,info); 
     846    ops_writer_push(info,encrypted_writer,encrypted_finaliser, 
     847                    encrypted_destroyer,arg); 
     848    } 
  • openpgpsdk/trunk/src/advanced/keyring_local.h

    r426 r438  
    2626    DECLARE_ARRAY(ops_user_id_t,uids); 
    2727    DECLARE_ARRAY(ops_packet_t,packets); 
    28     unsigned char keyid[8]; 
     28    unsigned char key_id[8]; 
    2929    ops_fingerprint_t fingerprint; 
    3030    ops_content_tag_t type; 
  • openpgpsdk/trunk/src/standard/std_keyring.c

    r436 r438  
    165165 
    166166    for(n=0 ; n < keyring->nkeys ; ++n) 
    167         if(!memcmp(keyring->keys[n].keyid,keyid,OPS_KEY_ID_SIZE)) 
     167        if(!memcmp(keyring->keys[n].key_id,keyid,OPS_KEY_ID_SIZE)) 
    168168            return &keyring->keys[n]; 
    169169 
  • openpgpsdk/trunk/src/standard/std_print.c

    r431 r438  
    5454    printf(" "); 
    5555 
    56     hexdump(key->keyid, OPS_KEY_ID_SIZE); 
     56    hexdump(key->key_id, OPS_KEY_ID_SIZE); 
    5757    printf(" "); 
    5858