Changeset 470
- Timestamp:
- 04/22/07 17:05:42
- Files:
-
- openpgpsdk/trunk/examples/Makefile.template (modified) (2 diffs)
- openpgpsdk/trunk/include/openpgpsdk/crypto.h (modified) (4 diffs)
- openpgpsdk/trunk/include/openpgpsdk/packet-parse.h (modified) (1 diff)
- openpgpsdk/trunk/include/openpgpsdk/random.h (added)
- openpgpsdk/trunk/include/openpgpsdk/types.h (modified) (1 diff)
- openpgpsdk/trunk/src/advanced/Makefile.template (modified) (1 diff)
- openpgpsdk/trunk/src/advanced/adv_create.c (modified) (5 diffs)
- openpgpsdk/trunk/src/advanced/adv_crypto.c (modified) (3 diffs)
- openpgpsdk/trunk/src/advanced/adv_openssl_crypto.c (modified) (1 diff)
- openpgpsdk/trunk/src/advanced/adv_packet-parse.c (modified) (6 diffs)
- openpgpsdk/trunk/src/advanced/adv_symmetric.c (modified) (16 diffs)
- openpgpsdk/trunk/src/advanced/parse_local.h (modified) (1 diff)
- openpgpsdk/trunk/src/advanced/random.c (added)
- openpgpsdk/trunk/tests/Makefile.template (modified) (1 diff)
Legend:
- Unmodified
- Added
- Removed
- Modified
- Copied
- Moved
openpgpsdk/trunk/examples/Makefile.template
r460 r470 14 14 15 15 test: test-dump test-verify test-verify-armoured test-create-key \ 16 test-v3-secring Makefile 16 test-v3-secring Makefile test-encrypt 17 17 18 18 ../src/standard/libops_std.a:: … … 112 112 ./packet-dump -p ../test/v3-secring.pgp 113 113 114 $(SCRATCH)/t1.sec $(SCRATCH)/t1.pub: 115 ./create-gpg-key.sh 116 117 test-encrypt: encrypt $(SCRATCH)/t1.pub 118 echo 'Test encryption' | ./encrypt $(SCRATCH)/t1.pub "OPS Test (This is a test) <ops@links.org>" > $(SCRATCH)/encrypted 119 gpg --no-default-keyring --secret-keyring $(SCRATCH)/t1.sec $(SCRATCH)/encrypted 120 114 121 include .depend openpgpsdk/trunk/include/openpgpsdk/crypto.h
r438 r470 28 28 }; 29 29 30 typedef void ops_decrypt_set_iv_t(ops_decrypt_t *decrypt, 31 const unsigned char *iv); 32 typedef void ops_decrypt_set_key_t(ops_decrypt_t *decrypt, 33 const unsigned char *key); 34 typedef void ops_decrypt_init_t(ops_decrypt_t *decrypt); 35 typedef void ops_decrypt_resync_t(ops_decrypt_t *decrypt); 36 //typedef size_t ops_decrypt_decrypt_t(ops_decrypt_t *decrypt,void *out, 37 // const void *in,int count); 38 typedef void ops_decrypt_block_encrypt_t(ops_decrypt_t *decrypt,void *out, 39 const void *in); 40 typedef void ops_decrypt_finish_t(ops_decrypt_t *decrypt); 30 typedef void ops_crypt_set_iv_t(ops_crypt_t *crypt, 31 const unsigned char *iv); 32 typedef void ops_crypt_set_key_t(ops_crypt_t *crypt, 33 const unsigned char *key); 34 typedef void ops_crypt_init_t(ops_crypt_t *crypt); 35 typedef void ops_crypt_resync_t(ops_crypt_t *crypt); 36 typedef void ops_crypt_block_encrypt_t(ops_crypt_t *crypt,void *out, 37 const void *in); 38 typedef void ops_crypt_finish_t(ops_crypt_t *crypt); 41 39 42 40 /** _ops_decrypt_t */ 43 struct _ops_ decrypt_t41 struct _ops_crypt_t 44 42 { 45 43 ops_symmetric_algorithm_t algorithm; 46 44 size_t blocksize; 47 45 size_t keysize; 48 ops_decrypt_set_iv_t *set_iv; /* Call this before init! */ 49 ops_decrypt_set_iv_t *set_key; /* Call this before init! */ 50 ops_decrypt_init_t *base_init; 51 ops_decrypt_resync_t *resync; 52 // ops_decrypt_decrypt_t *decrypt; 53 ops_decrypt_block_encrypt_t *block_encrypt; 54 ops_decrypt_finish_t *finish; 46 ops_crypt_set_iv_t *set_iv; /* Call this before decrypt init! */ 47 ops_crypt_set_key_t *set_key; /* Call this before init! */ 48 ops_crypt_init_t *base_init; 49 ops_crypt_resync_t *decrypt_resync; 50 ops_crypt_block_encrypt_t *block_encrypt; 51 ops_crypt_finish_t *decrypt_finish; 55 52 unsigned char iv[OPS_MAX_BLOCK_SIZE]; 56 53 unsigned char civ[OPS_MAX_BLOCK_SIZE]; … … 79 76 int ops_rsa_public_decrypt(unsigned char *out,const unsigned char *in, 80 77 size_t length,const ops_rsa_public_key_t *rsa); 78 int ops_rsa_public_encrypt(unsigned char *out,const unsigned char *in, 79 size_t length,const ops_rsa_public_key_t *rsa); 81 80 int ops_rsa_private_encrypt(unsigned char *out,const unsigned char *in, 82 81 size_t length,const ops_rsa_secret_key_t *srsa, … … 92 91 ops_parse_info_t *parse_info); 93 92 94 void ops_decrypt_any(ops_decrypt_t *decrypt,ops_symmetric_algorithm_t alg); 95 void ops_decrypt_init(ops_decrypt_t *decrypt); 96 size_t ops_decrypt_decrypt(ops_decrypt_t *decrypt,void *out,const void *in, 97 size_t count); 93 void ops_crypt_any(ops_crypt_t *decrypt,ops_symmetric_algorithm_t alg); 94 void ops_decrypt_init(ops_crypt_t *decrypt); 95 size_t ops_decrypt(ops_crypt_t *decrypt,void *out,const void *in, 96 size_t count); 97 size_t ops_encrypt(ops_crypt_t *encrypt,void *out,const void *in, 98 size_t count); 98 99 99 void ops_reader_push_decrypt(ops_parse_info_t *pinfo,ops_ decrypt_t *decrypt,100 void ops_reader_push_decrypt(ops_parse_info_t *pinfo,ops_crypt_t *decrypt, 100 101 ops_region_t *region); 101 102 void ops_reader_pop_decrypt(ops_parse_info_t *pinfo); … … 107 108 int ops_decrypt_mpi(unsigned char *buf,unsigned buflen,const BIGNUM *encmpi, 108 109 const ops_secret_key_t *skey); 110 ops_boolean_t ops_encrypt_mpi(const unsigned char *buf, size_t buflen, 111 const ops_public_key_t *pkey, 112 ops_pk_session_key_parameters_t *spk); 113 109 114 110 115 // Encrypt everything that's written openpgpsdk/trunk/include/openpgpsdk/packet-parse.h
r457 r470 94 94 void ops_parse_info_delete(ops_parse_info_t *pinfo); 95 95 ops_error_t *ops_parse_info_get_errors(ops_parse_info_t *pinfo); 96 ops_ decrypt_t *ops_parse_get_decrypt(ops_parse_info_t *pinfo);96 ops_crypt_t *ops_parse_get_decrypt(ops_parse_info_t *pinfo); 97 97 98 98 void ops_parse_cb_set(ops_parse_info_t *pinfo,ops_parse_cb_t *cb,void *arg); openpgpsdk/trunk/include/openpgpsdk/types.h
r388 r470 25 25 typedef enum ops_content_tag_t ops_content_tag_t; 26 26 27 typedef struct _ops_ decrypt_t ops_decrypt_t;27 typedef struct _ops_crypt_t ops_crypt_t; 28 28 29 29 /** ops_hash_t */ openpgpsdk/trunk/src/advanced/Makefile.template
r437 r470 13 13 adv_signature.o adv_compress.o adv_packet-show.o adv_create.o \ 14 14 adv_validate.o adv_lists.o adv_armour.o adv_errors.o \ 15 adv_symmetric.o adv_crypto.o 15 adv_symmetric.o adv_crypto.o random.o 16 16 17 17 headers: openpgpsdk/trunk/src/advanced/adv_create.c
r452 r470 4 4 #include <openpgpsdk/create.h> 5 5 #include <openpgpsdk/keyring.h> 6 #include <openpgpsdk/random.h> 6 7 #include "keyring_local.h" 7 8 #include <openpgpsdk/packet.h> … … 669 670 // Make sure the finaliser has been called. 670 671 assert(!info->winfo.finaliser); 671 // Make wsure this is a stacked writer672 // Make sure this is a stacked writer 672 673 assert(info->winfo.next); 673 674 if(info->winfo.destroyer) … … 752 753 ops_pk_session_key_t *session_key=ops_mallocz(sizeof *session_key); 753 754 755 assert(key->type == OPS_PTAG_CT_PUBLIC_KEY); 754 756 session_key->version=OPS_PKSK_V3; 755 757 memcpy(session_key->key_id, key->key_id, sizeof session_key->key_id); 756 // XXX: finish filling in the structure 758 759 assert(key->key.pkey.algorithm == OPS_PKA_RSA); 760 session_key->algorithm=key->key.pkey.algorithm; 761 session_key->symmetric_algorithm=OPS_SA_AES_256; 762 ops_random(session_key->key, 256/8); 763 764 if(!ops_encrypt_mpi(session_key->key, 256/8, &key->key.pkey, &session_key->parameters)) 765 return NULL; 766 757 767 return session_key; 758 768 } 759 769 760 // XXX: should these be common and just be called ops_crypt_*?761 typedef struct _ops_encrypt_t ops_encrypt_t;762 typedef void ops_encrypt_set_iv_t(ops_encrypt_t *encrypt,763 const unsigned char *iv);764 typedef void ops_encrypt_init_t(ops_encrypt_t *encrypt);765 typedef void ops_encrypt_resync_t(ops_encrypt_t *encrypt);766 typedef void ops_encrypt_block_encrypt_t(ops_encrypt_t *encrypt,void *out,767 const void *in);768 typedef void ops_encrypt_finish_t(ops_encrypt_t *encrypt);769 770 /** _ops_encrypt_t */771 struct _ops_encrypt_t772 {773 ops_symmetric_algorithm_t algorithm;774 size_t blocksize;775 size_t keysize;776 // ops_encrypt_set_iv_t *set_iv; /* Call this before init! */777 ops_encrypt_set_iv_t *set_key; /* Call this before init! */778 ops_encrypt_init_t *base_init; /* Once the key is set, call this */779 ops_encrypt_resync_t *resync;780 // ops_decrypt_decrypt_t *decrypt;781 ops_encrypt_block_encrypt_t *block_encrypt;782 ops_encrypt_finish_t *finish;783 unsigned char iv[OPS_MAX_BLOCK_SIZE];784 unsigned char civ[OPS_MAX_BLOCK_SIZE];785 unsigned char siv[OPS_MAX_BLOCK_SIZE]; /* Needed for weird v3 resync */786 unsigned char key[OPS_MAX_KEY_SIZE];787 size_t num;788 void *data;789 };790 791 770 typedef struct 792 771 { 793 ops_ encrypt_t *encrypter;772 ops_crypt_t *encrypter; 794 773 } encrypted_arg_t; 795 796 797 /* dummy function */798 774 799 775 #ifndef ATTRIBUTE_UNUSED … … 801 777 #endif /* ATTRIBUTE_UNUSED */ 802 778 803 void ops_write_pk_session_key(ops_create_info_t *info ATTRIBUTE_UNUSED, ops_pk_session_key_t *session_key ATTRIBUTE_UNUSED) 804 { 805 /* \todo write ops_write_pk_session_key() */ 779 ops_boolean_t ops_write_pk_session_key(ops_create_info_t *info, 780 ops_pk_session_key_t *pksk) 781 { 782 assert(pksk->algorithm == OPS_PKA_RSA); 783 return ops_write_ptag(OPS_PTAG_CT_PK_SESSION_KEY, info) 784 && ops_write_length(1 + 8 + 1 + BN_num_bytes(pksk->parameters.rsa.encrypted_m) + 2, info) 785 && ops_write_scalar(pksk->version, 1, info) 786 && ops_write(pksk->key_id, 8, info) 787 && ops_write_scalar(pksk->algorithm, 1, info) 788 && ops_write_mpi(pksk->parameters.rsa.encrypted_m, info) 789 /* XXX: write the checksum! */ 790 && ops_write_scalar(0, 2, info); 791 } 792 793 static ops_boolean_t encrypted_writer(const unsigned char *src ATTRIBUTE_UNUSED, 794 unsigned length ATTRIBUTE_UNUSED, 795 ops_error_t **errors ATTRIBUTE_UNUSED, 796 ops_writer_info_t *winfo ATTRIBUTE_UNUSED) 797 { 798 /* \todo */ 806 799 assert(0); 807 }808 809 static ops_boolean_t encrypted_writer(const unsigned char *src ATTRIBUTE_UNUSED,810 unsigned length ATTRIBUTE_UNUSED,811 ops_error_t **errors ATTRIBUTE_UNUSED,812 ops_writer_info_t *winfo ATTRIBUTE_UNUSED813 )814 {815 /* \todo */816 assert(0);817 800 818 801 return ops_false; … … 820 803 821 804 static ops_boolean_t encrypted_finaliser(ops_error_t **errors ATTRIBUTE_UNUSED, 822 ops_writer_info_t *winfo ATTRIBUTE_UNUSED)805 ops_writer_info_t *winfo ATTRIBUTE_UNUSED) 823 806 { 824 807 /* \todo */ openpgpsdk/trunk/src/advanced/adv_crypto.c
r462 r470 1 1 #include <openpgpsdk/crypto.h> 2 #include <openpgpsdk/random.h> 2 3 3 4 #include <assert.h> … … 28 29 return -1; 29 30 30 /*31 /* 31 32 printf(" decrypt=%d ",n); 32 33 hexdump(mpibuf,n); 33 34 printf("\n"); 34 */35 */ 35 36 36 37 // Decode EME-PKCS1_V1_5 (RFC 2437). … … 54 55 return n-i; 55 56 } 57 58 ops_boolean_t ops_encrypt_mpi(const unsigned char *buf, size_t buflen, 59 const ops_public_key_t *pkey, 60 ops_pk_session_key_parameters_t *skp) 61 { 62 unsigned char encmpibuf[8192]; 63 unsigned char padded[8192]; 64 int n; 65 unsigned i; 66 67 assert(pkey->algorithm == OPS_PKA_RSA); 68 69 n=BN_num_bytes(pkey->key.rsa.n); 70 padded[0]=0; 71 padded[1]=2; 72 // add non-zero random bytes 73 for(i=2 ; i < n-buflen-1 ; ++i) 74 do 75 ops_random(padded+i, 1); 76 while(padded[i] == 0); 77 padded[i++]=0; 78 memcpy(padded+i, buf, buflen); 79 80 n=ops_rsa_public_encrypt(encmpibuf, padded, n, &pkey->key.rsa); 81 82 if(n <= 0) 83 return ops_false; 84 85 skp->rsa.encrypted_m=BN_bin2bn(encmpibuf, n, NULL); 86 87 return ops_true; 88 } openpgpsdk/trunk/src/advanced/adv_openssl_crypto.c
r426 r470 173 173 } 174 174 175 int ops_rsa_public_encrypt(unsigned char *out,const unsigned char *in, 176 size_t length,const ops_rsa_public_key_t *rsa) 177 { 178 RSA *orsa; 179 int n; 180 181 orsa=RSA_new(); 182 orsa->n=rsa->n; 183 orsa->e=rsa->e; 184 185 n=RSA_public_encrypt(length,in,out,orsa,RSA_NO_PADDING); 186 187 orsa->n=orsa->e=NULL; 188 RSA_free(orsa); 189 190 return n; 191 } 192 175 193 void ops_crypto_init() 176 194 { openpgpsdk/trunk/src/advanced/adv_packet-parse.c
r465 r470 1888 1888 ops_parser_content_t content; 1889 1889 unsigned char c[1]; 1890 ops_ decrypt_t decrypt;1890 ops_crypt_t decrypt; 1891 1891 int ret=1; 1892 1892 ops_region_t encregion; … … 2041 2041 free(passphrase); 2042 2042 2043 ops_ decrypt_any(&decrypt,C.secret_key.algorithm);2043 ops_crypt_any(&decrypt,C.secret_key.algorithm); 2044 2044 decrypt.set_iv(&decrypt,C.secret_key.iv); 2045 2045 decrypt.set_key(&decrypt,key); … … 2238 2238 CBP(pinfo,OPS_PTAG_CT_PK_SESSION_KEY,&content); 2239 2239 2240 ops_ decrypt_any(&pinfo->decrypt,C.pk_session_key.symmetric_algorithm);2240 ops_crypt_any(&pinfo->decrypt,C.pk_session_key.symmetric_algorithm); 2241 2241 pinfo->decrypt.set_key(&pinfo->decrypt,C.pk_session_key.key); 2242 2242 … … 2249 2249 { 2250 2250 int r=1; 2251 ops_ decrypt_t *decrypt=ops_parse_get_decrypt(pinfo);2251 ops_crypt_t *decrypt=ops_parse_get_decrypt(pinfo); 2252 2252 2253 2253 if(decrypt) … … 2276 2276 if(tag == OPS_PTAG_CT_SE_DATA_BODY) 2277 2277 { 2278 decrypt-> resync(decrypt);2278 decrypt->decrypt_resync(decrypt); 2279 2279 decrypt->block_encrypt(decrypt,decrypt->civ,decrypt->civ); 2280 2280 } … … 2752 2752 { return pinfo->errors; } 2753 2753 2754 ops_ decrypt_t *ops_parse_get_decrypt(ops_parse_info_t *pinfo)2754 ops_crypt_t *ops_parse_get_decrypt(ops_parse_info_t *pinfo) 2755 2755 { 2756 2756 if(pinfo->decrypt.algorithm) openpgpsdk/trunk/src/advanced/adv_symmetric.c
r457 r470 17 17 size_t decrypted_count; 18 18 size_t decrypted_offset; 19 ops_ decrypt_t *decrypt;19 ops_crypt_t *decrypt; 20 20 ops_region_t *region; 21 21 ops_boolean_t prev_read_was_plain:1; … … 33 33 { 34 34 assert(rinfo->pinfo->reading_v3_secret); 35 arg->decrypt-> resync(arg->decrypt);35 arg->decrypt->decrypt_resync(arg->decrypt); 36 36 arg->prev_read_was_plain=ops_false; 37 37 } … … 94 94 if(!rinfo->pinfo->reading_v3_secret 95 95 || !rinfo->pinfo->reading_mpi_length) 96 arg->decrypted_count=ops_decrypt _decrypt(arg->decrypt,97 arg->decrypted,98 buffer,n);96 arg->decrypted_count=ops_decrypt(arg->decrypt, 97 arg->decrypted, 98 buffer,n); 99 99 else 100 100 { … … 115 115 { free(ops_reader_get_arg(rinfo)); } 116 116 117 void ops_reader_push_decrypt(ops_parse_info_t *pinfo,ops_ decrypt_t *decrypt,117 void ops_reader_push_decrypt(ops_parse_info_t *pinfo,ops_crypt_t *decrypt, 118 118 ops_region_t *region) 119 119 { … … 132 132 encrypted_arg_t *arg=ops_reader_get_arg(ops_parse_get_rinfo(pinfo)); 133 133 134 arg->decrypt-> finish(arg->decrypt);134 arg->decrypt->decrypt_finish(arg->decrypt); 135 135 free(arg); 136 136 … … 138 138 } 139 139 140 static void std_set_iv(ops_ decrypt_t *decrypt,const unsigned char *iv)141 { memcpy( decrypt->iv,iv,decrypt->blocksize); }142 143 static void std_set_key(ops_ decrypt_t *decrypt,const unsigned char *key)144 { memcpy( decrypt->key,key,decrypt->keysize); }145 146 static void std_resync(ops_ decrypt_t *decrypt)140 static void std_set_iv(ops_crypt_t *crypt,const unsigned char *iv) 141 { memcpy(crypt->iv,iv,crypt->blocksize); } 142 143 static void std_set_key(ops_crypt_t *crypt,const unsigned char *key) 144 { memcpy(crypt->key,key,crypt->keysize); } 145 146 static void std_resync(ops_crypt_t *decrypt) 147 147 { 148 148 if(decrypt->num == decrypt->blocksize) … … 156 156 } 157 157 158 static void std_finish(ops_ decrypt_t *decrypt)159 { 160 free( decrypt->data);161 decrypt->data=NULL;162 } 163 164 static void cast5_init(ops_ decrypt_t *decrypt)165 { 166 free( decrypt->data);167 decrypt->data=malloc(sizeof(CAST_KEY));168 CAST_set_key( decrypt->data,decrypt->keysize,decrypt->key);169 } 170 171 static void cast5_encrypt(ops_ decrypt_t *decrypt,void *out,const void *in)172 { CAST_ecb_encrypt(in,out, decrypt->data,1); }158 static void std_finish(ops_crypt_t *crypt) 159 { 160 free(crypt->data); 161 crypt->data=NULL; 162 } 163 164 static void cast5_init(ops_crypt_t *crypt) 165 { 166 free(crypt->data); 167 crypt->data=malloc(sizeof(CAST_KEY)); 168 CAST_set_key(crypt->data,crypt->keysize,crypt->key); 169 } 170 171 static void cast5_encrypt(ops_crypt_t *crypt,void *out,const void *in) 172 { CAST_ecb_encrypt(in,out,crypt->data,1); } 173 173 174 174 #define TRAILER "","","","",0,NULL 175 175 176 static ops_ decrypt_t cast5=176 static ops_crypt_t cast5= 177 177 { 178 178 OPS_SA_CAST5, … … 189 189 190 190 #ifndef OPENSSL_NO_IDEA 191 static void idea_init(ops_ decrypt_t *decrypt)192 { 193 assert( decrypt->keysize == IDEA_KEY_LENGTH);194 195 free( decrypt->data);196 decrypt->data=malloc(sizeof(IDEA_KEY_SCHEDULE));197 198 // note that we don't invert the key for CFB mode199 idea_set_encrypt_key( decrypt->key,decrypt->data);200 } 201 202 static void idea_block_encrypt(ops_ decrypt_t *decrypt,void *out,const void *in)203 { idea_ecb_encrypt(in,out, decrypt->data); }204 205 static const ops_ decrypt_t idea=191 static void idea_init(ops_crypt_t *crypt) 192 { 193 assert(crypt->keysize == IDEA_KEY_LENGTH); 194 195 free(crypt->data); 196 crypt->data=malloc(sizeof(IDEA_KEY_SCHEDULE)); 197 198 // note that we don't invert the key when decrypting for CFB mode 199 idea_set_encrypt_key(crypt->key,crypt->data); 200 } 201 202 static void idea_block_encrypt(ops_crypt_t *crypt,void *out,const void *in) 203 { idea_ecb_encrypt(in,out,crypt->data); } 204 205 static const ops_crypt_t idea= 206 206 { 207 207 OPS_SA_IDEA, … … 218 218 #endif /* OPENSSL_NO_IDEA */ 219 219 220 static void aes256_init(ops_ decrypt_t *decrypt)221 { 222 free( decrypt->data);223 decrypt->data=malloc(sizeof(AES_KEY));224 AES_set_encrypt_key( decrypt->key,256,decrypt->data);225 } 226 227 static void aes_block_encrypt(ops_ decrypt_t *decrypt,void *out,const void *in)228 { AES_encrypt(in,out, decrypt->data); }229 230 static const ops_ decrypt_t aes256=220 static void aes256_init(ops_crypt_t *crypt) 221 { 222 free(crypt->data); 223 crypt->data=malloc(sizeof(AES_KEY)); 224 AES_set_encrypt_key(crypt->key,256,crypt->data); 225 } 226 227 static void aes_block_encrypt(ops_crypt_t *crypt,void *out,const void *in) 228 { AES_encrypt(in,out,crypt->data); } 229 230 static const ops_crypt_t aes256= 231 231 { 232 232 OPS_SA_AES_256, … … 242 242 }; 243 243 244 static void tripledes_init(ops_ decrypt_t *decrypt)244 static void tripledes_init(ops_crypt_t *crypt) 245 245 { 246 246 DES_key_schedule *keys; 247 247 int n; 248 248 249 free( decrypt->data);250 keys= decrypt->data=malloc(3*sizeof(DES_key_schedule));249 free(crypt->data); 250 keys=crypt->data=malloc(3*sizeof(DES_key_schedule)); 251 251 252 252 for(n=0 ; n < 3 ; ++n) 253 DES_set_key((DES_cblock *)( decrypt->key+n*8),&keys[n]);254 } 255 256 static void tripledes_block_encrypt(ops_ decrypt_t *decrypt,void *out,253 DES_set_key((DES_cblock *)(crypt->key+n*8),&keys[n]); 254 } 255 256 static void tripledes_block_encrypt(ops_crypt_t *crypt,void *out, 257 257 const void *in) 258 258 { 259 DES_key_schedule *keys= decrypt->data;259 DES_key_schedule *keys=crypt->data; 260 260 261 261 DES_ecb3_encrypt((void *)in,out,&keys[0],&keys[1],&keys[2],1); 262 262 } 263 263 264 static const ops_ decrypt_t tripledes=264 static const ops_crypt_t tripledes= 265 265 { 266 266 OPS_SA_TRIPLEDES, … … 276 276 }; 277 277 278 static const ops_ decrypt_t *get_proto(ops_symmetric_algorithm_t alg)278 static const ops_crypt_t *get_proto(ops_symmetric_algorithm_t alg) 279 279 { 280 280 switch(alg) … … 303 303 } 304 304 305 void ops_ decrypt_any(ops_decrypt_t *decrypt,ops_symmetric_algorithm_t alg)306 { * decrypt=*get_proto(alg); }305 void ops_crypt_any(ops_crypt_t *crypt,ops_symmetric_algorithm_t alg) 306 { *crypt=*get_proto(alg); } 307 307 308 308 unsigned ops_block_size(ops_symmetric_algorithm_t alg) 309 309 { 310 const ops_ decrypt_t *p=get_proto(alg);310 const ops_crypt_t *p=get_proto(alg); 311 311 312 312 if(!p) … … 318 318 unsigned ops_key_size(ops_symmetric_algorithm_t alg) 319 319 { 320 const ops_ decrypt_t *p=get_proto(alg);320 const ops_crypt_t *p=get_proto(alg); 321 321 322 322 if(!p) … … 326 326 } 327 327 328 void ops_decrypt_init(ops_ decrypt_t *decrypt)328 void ops_decrypt_init(ops_crypt_t *decrypt) 329 329 { 330 330 decrypt->base_init(decrypt); … … 334 334 } 335 335 336 size_t ops_decrypt _decrypt(ops_decrypt_t *decrypt,void *out_,const void *in_,337 size_t count)336 size_t ops_decrypt(ops_crypt_t *decrypt,void *out_,const void *in_, 337 size_t count) 338 338 { 339 339 unsigned char *out=out_; … … 359 359 return saved; 360 360 } 361 362 size_t ops_encrypt(ops_crypt_t *decrypt,void *out_,const void *in_, 363 size_t count) 364 { 365 unsigned char *out=out_; 366 const unsigned char *in=in_; 367 int saved=count; 368 369 /* in order to support v3's weird resyncing we have to implement CFB mode 370 ourselves */ 371 while(count-- > 0) 372 { 373 if(decrypt->num == decrypt->blocksize) 374 { 375 memcpy(decrypt->siv,decrypt->civ,decrypt->blocksize); 376 decrypt->block_encrypt(decrypt,decrypt->civ,decrypt->civ); 377 decrypt->num=0; 378 } 379 decrypt->civ[decrypt->num]=*out++=decrypt->civ[decrypt->num]^*in++; 380 ++decrypt->num; 381 } 382 383 return saved; 384 } openpgpsdk/trunk/src/advanced/parse_local.h
r426 r470 69 69 ops_parse_cb_info_t cbinfo; 70 70 ops_error_t *errors; 71 ops_ decrypt_t decrypt;71 ops_crypt_t decrypt; 72 72 size_t nhashes; 73 73 ops_parse_hash_info_t *hashes; openpgpsdk/trunk/tests/Makefile.template
r468 r470 26 26 $(CUNIT_LIB): 27 27 tar xvfz CUnit-2.1-0-src.tar.gz 28 (cd CUnit-2.1-0 ; ./configure --prefix $(PWD)/../; make;make install)28 (cd CUnit-2.1-0 && ./configure --prefix $(PWD)/../ && make && make install) 29 29 30 30 clean:
