int md_command(XID id, int cmd, void *data, int data_len, char **buffer) { int res; struct mcmd_header mcmd; *buffer=NULL; mcmd.id = id; mcmd.cmd = cmd; mcmd.len = data_len; if(md_write(&mcmd, sizeof(mcmd))!=sizeof(mcmd) || md_write(data, data_len)!=data_len || md_read(&res, sizeof(res))!=sizeof(res)) return -1; while(res<-1) { md_get_async(~res); if(md_read(&res, sizeof(res))!=sizeof(res)) return -1; } if(res>0) { *buffer=malloc(res); if(md_read(*buffer, res)!=res) return -1; } return res; }
/* Read the entire file into memory */ static void * get_binary_file_image(char *filename, int *pnbytes) { unsigned char *image; int fd; jlong nbytes; int nread; *pnbytes = 0; fd = md_open_binary(filename); CHECK_FOR_ERROR(fd>=0); if ( (nbytes = md_seek(fd, (jlong)-1)) == (jlong)-1 ) { HPROF_ERROR(JNI_TRUE, "Cannot md_seek() to end of file"); } CHECK_FOR_ERROR(((jint)nbytes)>512); if ( md_seek(fd, (jlong)0) != (jlong)0 ) { HPROF_ERROR(JNI_TRUE, "Cannot md_seek() to start of file"); } image = HPROF_MALLOC(((jint)nbytes)+1); CHECK_FOR_ERROR(image!=NULL); /* Read the entire file image into memory */ nread = md_read(fd, image, (jint)nbytes); if ( nread <= 0 ) { HPROF_ERROR(JNI_TRUE, "System read failed."); } CHECK_FOR_ERROR(((jint)nbytes)==nread); md_close(fd); *pnbytes = (jint)nbytes; return image; }
static int md_int_load(int len) { if(len>=md_int_len) if(md_int_buf!=NULL) md_int_buf=realloc(md_int_buf, md_int_len=len+1); else md_int_buf=malloc(md_int_len=len+1); md_int_buf[len]='\0'; return md_read(md_int_buf, len); }
/**************** * This filter is used to en/de-cipher data with a conventional algorithm */ int cipher_filter( void *opaque, int control, IOBUF a, byte *buf, size_t *ret_len) { size_t size = *ret_len; cipher_filter_context_t *cfx = opaque; int rc=0; if( control == IOBUFCTRL_UNDERFLOW ) { /* decrypt */ rc = -1; /* not yet used */ } else if( control == IOBUFCTRL_FLUSH ) { /* encrypt */ assert(a); if( !cfx->header ) { write_header( cfx, a ); } if( cfx->mdc_hash ) md_write( cfx->mdc_hash, buf, size ); cipher_encrypt( cfx->cipher_hd, buf, buf, size); if( iobuf_write( a, buf, size ) ) rc = G10ERR_WRITE_FILE; } else if( control == IOBUFCTRL_FREE ) { if( cfx->mdc_hash ) { byte *hash; int hashlen = md_digest_length( md_get_algo( cfx->mdc_hash ) ); byte temp[22]; assert( hashlen == 20 ); /* we must hash the prefix of the MDC packet here */ temp[0] = 0xd3; temp[1] = 0x14; md_putc( cfx->mdc_hash, temp[0] ); md_putc( cfx->mdc_hash, temp[1] ); md_final( cfx->mdc_hash ); hash = md_read( cfx->mdc_hash, 0 ); memcpy(temp+2, hash, 20); cipher_encrypt( cfx->cipher_hd, temp, temp, 22 ); md_close( cfx->mdc_hash ); cfx->mdc_hash = NULL; if( iobuf_write( a, temp, 22 ) ) log_error("writing MDC packet failed\n" ); } cipher_close(cfx->cipher_hd); } else if( control == IOBUFCTRL_DESC ) { *(char**)buf = "cipher_filter"; } return rc; }
int md_handle_input() { int res; if(md_read(&res, sizeof(res))!=sizeof(res)) return -1; if(res>=0) { if(!res) return 0; md_int_load(res); return 0; } else { res=~res; if(!res) return 0; return md_get_async(res); } }
int signature_check2( PKT_signature *sig, MD_HANDLE digest, u32 *r_expiredate, int *r_expired ) { PKT_public_key *pk = m_alloc_clear( sizeof *pk ); int rc=0; *r_expiredate = 0; /* Sanity check that the md has a context for the hash that the sig is expecting. This can happen if a onepass sig header does not match the actual sig, and also if the clearsign "Hash:" header is missing or does not match the actual sig. */ if(!md_algo_present(digest,sig->digest_algo)) { log_info(_("WARNING: signature digest conflict in message\n")); rc=G10ERR_BAD_SIGN; } else if( get_pubkey( pk, sig->keyid ) ) rc = G10ERR_NO_PUBKEY; else if(!pk->is_valid && !pk->is_primary) rc=G10ERR_BAD_PUBKEY; /* you cannot have a good sig from an invalid subkey */ else { *r_expiredate = pk->expiredate; rc = do_check( pk, sig, digest, r_expired ); } free_public_key( pk ); if( !rc && sig->sig_class < 2 && is_status_enabled() ) { /* This signature id works best with DLP algorithms because * they use a random parameter for every signature. Instead of * this sig-id we could have also used the hash of the document * and the timestamp, but the drawback of this is, that it is * not possible to sign more than one identical document within * one second. Some remote batch processing applications might * like this feature here */ MD_HANDLE md; u32 a = sig->timestamp; int i, nsig = pubkey_get_nsig( sig->pubkey_algo ); byte *p, *buffer; md = md_open( DIGEST_ALGO_RMD160, 0); md_putc( digest, sig->pubkey_algo ); md_putc( digest, sig->digest_algo ); md_putc( digest, (a >> 24) & 0xff ); md_putc( digest, (a >> 16) & 0xff ); md_putc( digest, (a >> 8) & 0xff ); md_putc( digest, a & 0xff ); for(i=0; i < nsig; i++ ) { unsigned n = mpi_get_nbits( sig->data[i]); md_putc( md, n>>8); md_putc( md, n ); p = mpi_get_buffer( sig->data[i], &n, NULL ); md_write( md, p, n ); m_free(p); } md_final( md ); p = make_radix64_string( md_read( md, 0 ), 20 ); buffer = m_alloc( strlen(p) + 60 ); sprintf( buffer, "%s %s %lu", p, strtimestamp( sig->timestamp ), (ulong)sig->timestamp ); write_status_text( STATUS_SIG_ID, buffer ); m_free(buffer); m_free(p); md_close(md); }
int signature_check2( PKT_signature *sig, MD_HANDLE digest, u32 *r_expiredate, int *r_expired, int *r_revoked, PKT_public_key *ret_pk ) { PKT_public_key *pk = xmalloc_clear( sizeof *pk ); int rc=0; if( (rc=check_digest_algo(sig->digest_algo)) ) ; /* we don't have this digest */ else if((rc=check_pubkey_algo(sig->pubkey_algo))) ; /* we don't have this pubkey algo */ else if(!md_algo_present(digest,sig->digest_algo)) { /* Sanity check that the md has a context for the hash that the sig is expecting. This can happen if a onepass sig header does not match the actual sig, and also if the clearsign "Hash:" header is missing or does not match the actual sig. */ log_info(_("WARNING: signature digest conflict in message\n")); rc=G10ERR_GENERAL; } else if( get_pubkey( pk, sig->keyid ) ) rc = G10ERR_NO_PUBKEY; else if(!pk->is_valid && !pk->is_primary) rc=G10ERR_BAD_PUBKEY; /* you cannot have a good sig from an invalid subkey */ else { if(r_expiredate) *r_expiredate = pk->expiredate; rc = do_check( pk, sig, digest, r_expired, r_revoked, ret_pk ); /* Check the backsig. This is a 0x19 signature from the subkey on the primary key. The idea here is that it should not be possible for someone to "steal" subkeys and claim them as their own. The attacker couldn't actually use the subkey, but they could try and claim ownership of any signaures issued by it. */ if(rc==0 && !pk->is_primary && pk->backsig<2) { if(pk->backsig==0) { log_info(_("WARNING: signing subkey %s is not" " cross-certified\n"),keystr_from_pk(pk)); log_info(_("please see %s for more information\n"), "http://www.gnupg.org/faq/subkey-cross-certify.html"); /* --require-cross-certification makes this warning an error. TODO: change the default to require this after more keys have backsigs. */ if(opt.flags.require_cross_cert) rc=G10ERR_GENERAL; } else if(pk->backsig==1) { log_info(_("WARNING: signing subkey %s has an invalid" " cross-certification\n"),keystr_from_pk(pk)); rc=G10ERR_GENERAL; } } } free_public_key( pk ); if( !rc && sig->sig_class < 2 && is_status_enabled() ) { /* This signature id works best with DLP algorithms because * they use a random parameter for every signature. Instead of * this sig-id we could have also used the hash of the document * and the timestamp, but the drawback of this is, that it is * not possible to sign more than one identical document within * one second. Some remote batch processing applications might * like this feature here */ MD_HANDLE md; u32 a = sig->timestamp; int i, nsig = pubkey_get_nsig( sig->pubkey_algo ); byte *p, *buffer; md = md_open( DIGEST_ALGO_RMD160, 0); md_putc( digest, sig->pubkey_algo ); md_putc( digest, sig->digest_algo ); md_putc( digest, (a >> 24) & 0xff ); md_putc( digest, (a >> 16) & 0xff ); md_putc( digest, (a >> 8) & 0xff ); md_putc( digest, a & 0xff ); for(i=0; i < nsig; i++ ) { unsigned n = mpi_get_nbits( sig->data[i]); md_putc( md, n>>8); md_putc( md, n ); p = mpi_get_buffer( sig->data[i], &n, NULL ); md_write( md, p, n ); xfree(p); } md_final( md ); p = make_radix64_string( md_read( md, 0 ), 20 ); buffer = xmalloc( strlen(p) + 60 ); sprintf( buffer, "%s %s %lu", p, strtimestamp( sig->timestamp ), (ulong)sig->timestamp ); write_status_text( STATUS_SIG_ID, buffer ); xfree(buffer); xfree(p); md_close(md); }