/**
\ingroup Core_Writers
\brief Create and initialise cinfo and mem; Set for writing to file
\param cinfo Address where new cinfo pointer will be set
\param filename File to write to
\param allow_overwrite Allows file to be overwritten, if set.
\return Newly-opened file descriptor
\note It is the caller's responsiblity to free cinfo and to close fd.
\sa ops_teardown_file_write()
*/
int ops_setup_file_write(ops_create_info_t **cinfo, const char* filename, ops_boolean_t allow_overwrite)
{
int fd=0;
int flags=0;
/*
* initialise needed structures for writing to file
*/
flags=O_WRONLY | O_CREAT;
if (allow_overwrite==ops_true)
flags |= O_TRUNC;
else
flags |= O_EXCL;
flags |= O_BINARY;
fd=open(filename, flags, 0600);
if(fd < 0)
{
perror(filename);
return fd;
}
*cinfo=ops_create_info_new();
ops_writer_set_fd(*cinfo,fd);
return fd;
}
int main(int argc,char **argv)
{
ops_create_info_t *info;
const unsigned char *id;
const char *nstr;
const char *estr;
BIGNUM *n=NULL;
BIGNUM *e=NULL;
if(argc != 4)
{
fprintf(stderr,"%s <n> <e> <user id>\n",argv[0]);
exit(1);
}
nstr=argv[1];
estr=argv[2];
id=(unsigned char *)argv[3];
BN_hex2bn(&n,nstr);
BN_hex2bn(&e,estr);
info=ops_create_info_new();
ops_writer_set_fd(info,1);
ops_write_rsa_public_key(time(NULL),n,e,info);
ops_write_user_id(id,info);
ops_create_info_delete(info);
return 0;
}
/**
\ingroup Core_Writers
\brief Create and initialise cinfo and mem; Set for writing to mem
\param cinfo Address where new cinfo pointer will be set
\param mem Address when new mem pointer will be set
\param bufsz Initial buffer size (will automatically be increased when necessary)
\note It is the caller's responsiblity to free cinfo and mem.
\sa ops_teardown_memory_write()
*/
void ops_setup_memory_write(ops_create_info_t **cinfo, ops_memory_t **mem, size_t bufsz)
{
/*
* initialise needed structures for writing to memory
*/
*cinfo=ops_create_info_new();
*mem=ops_memory_new();
ops_memory_init(*mem,bufsz);
ops_writer_set_memory(*cinfo,*mem);
}
void ops_build_public_key(ops_memory_t *out,const ops_public_key_t *key,
ops_boolean_t make_packet)
{
ops_create_info_t *info;
info=ops_create_info_new();
ops_memory_init(out,128);
ops_writer_set_memory(info,out);
write_public_key_body(key,info);
if(make_packet)
ops_memory_make_packet(out,OPS_PTAG_CT_PUBLIC_KEY);
ops_create_info_delete(info);
}
/**
\ingroup Core_Writers
\brief As ops_setup_file_write, but appends to file
*/
int ops_setup_file_append(ops_create_info_t **cinfo, const char* filename)
{
int fd;
/*
* initialise needed structures for writing to file
*/
fd=open(filename,O_WRONLY | O_APPEND | O_BINARY, 0600);
if(fd < 0)
{
perror(filename);
return fd;
}
*cinfo=ops_create_info_new();
ops_writer_set_fd(*cinfo,fd);
return fd;
}
int main(int argc,char **argv)
{
const char *keyfile;
const char *plainfile;
const char *user_id;
const char *hashstr;
const char *sigfile;
ops_secret_key_t *skey;
ops_create_signature_t *sig;
ops_hash_algorithm_t alg;
int fd;
ops_create_info_t *info;
unsigned char keyid[OPS_KEY_ID_SIZE];
if(argc != 6)
{
fprintf(stderr,"%s <secret key file> <user_id> <hash> <plaintext file>"
" <signature file>\n",argv[0]);
exit(1);
}
keyfile=argv[1];
user_id=argv[2];
hashstr=argv[3];
plainfile=argv[4];
sigfile=argv[5];
ops_init();
skey=get_secret_key(keyfile);
assert(skey);
alg=ops_hash_algorithm_from_text(hashstr);
if(alg == OPS_HASH_UNKNOWN)
{
fprintf(stderr,"Unkonwn hash algorithm: %s\n",hashstr);
exit(2);
}
sig=ops_create_signature_new();
ops_signature_start_cleartext_signature(sig,skey,alg,OPS_SIG_BINARY);
fd=open(plainfile,O_RDONLY);
if(fd < 0)
{
perror(plainfile);
exit(3);
}
for( ; ; )
{
unsigned char buf[8192];
int n;
n=read(fd,buf,sizeof buf);
if(!n)
break;
if(n < 0)
{
perror(plainfile);
exit(4);
}
ops_signature_add_data(sig,buf,n);
}
close(fd);
ops_signature_add_creation_time(sig,time(NULL));
ops_keyid(keyid,&skey->public_key);
ops_signature_add_issuer_key_id(sig,keyid);
ops_signature_hashed_subpackets_end(sig);
fd=open(sigfile,O_CREAT|O_TRUNC|O_WRONLY,0666);
if(fd < 0)
{
perror(sigfile);
exit(5);
}
info=ops_create_info_new();
ops_writer_set_fd(info,fd);
ops_write_signature(sig,&skey->public_key,skey,info);
ops_secret_key_free(skey);
return 0;
}