int retrieve_key(PGconn *conn, char *fingerprint, unsigned int full,struct cks_config *config)
{
struct openPGP_keyring *keyring = NULL;
struct openPGP_pubkey *key_result = NULL;
int rslt = 0;
key_result = (struct openPGP_pubkey *)retrieve_pubkey(conn,fingerprint,D_SOURCE_ADD_CGI);
if(key_result == NULL)
{
fprintf(stderr,_("Failed to retrieve key: %s\n"),fingerprint);
do_error_page(_("Failed to retrieve key from database.\n"));
return -1;
}
rslt = parse_pubkey(&key_result,D_SOURCE_SEARCH_CGI);
if(rslt == -1)
{
fprintf(stderr,_("Failed to parse retrieved pubkey: %s\n"),fingerprint);
return -1;
}
rslt = parse_packets(&key_result,D_SOURCE_SEARCH_CGI);
if(rslt == -1)
{
fprintf(stderr,_("Failed to parse retrieved pubkey's packets: %s\n"),fingerprint);
return -1;
}
if(full)
{
echo_key_info(conn,key_result);
echo_radix_key(key_result,config);
}
else
{
printf("<pre>\n");
printf("<hr size=\"1\" width=\"100%%\">\n");
fflush(0);
echo_abrev_key_info(conn,key_result);
}
if(key_result != NULL)
{
free_pubkey(&key_result);
}
return rslt;
}
int main(int argc,char *argv[])
{
struct cks_config *config = NULL;
PGconn *conn = NULL;
FILE *kr = NULL;
PGresult *result = NULL;
struct openPGP_pubkey *key_result = NULL;
int rslt = 0;
int rslt_2 = 0;
unsigned long to_export = 0;
unsigned long exported = 0;
unsigned char fp[41];
unsigned long i = 0;
unsigned long j = 0;
/* 50000 pubkeys per file. */
unsigned long max_keys = 50000;
unsigned int file_num = 0;
unsigned char file_name[20];
unsigned int arg = 0;
unsigned int verbose = 0;
config = (struct cks_config *)malloc(sizeof(struct cks_config));
if(config == NULL)
{
fprintf(stderr,_("cks_export: Fatal Error: Malloc Call Failed: Out of memroy.\n"));
return -1;
}
rslt = init_config(&config);
if(rslt == -1)
{
fprintf(stderr,_("cks_export: Non-Fatal Error: Failed to read config.\n"));
fprintf(stderr,_("cks_export: Using default configuration information.\n"));
}
if(argc > 0)
{
for(arg=1;arg<argc;arg++)
{
if(argv[arg][0] == '-')
{
if(argv[arg][1] == '-')
{
if(strstr(argv[arg],"help") != NULL)
{
printf("Usage: cks_export\n");
printf(" -v Verbose Mode\n");
printf(" -h This Help Text\n");
printf(" --help This Help Text\n");
printf(" --version Display Version Information\n");
printf("\n");
return 0;
}
else if(strstr(argv[arg],"version") != NULL)
{
printf("CKS Version 0.2.2\n");
return 0;
}
}
else if(argv[arg][1] == 'v')
{
verbose = 1;
}
else
{
printf("Usage: cks_export\n");
printf(" -v Verbose Mode\n");
printf(" -h This Help Text\n");
printf(" --help This Help Text\n");
printf(" --version Display Version Information\n");
printf("\n");
return 0;
}
}
}
}
/* open the export file */
if((kr = fopen("cks_ring-000.pgp","wb")) == NULL)
{
fprintf(stderr,_("cks_export: Failed to open file export_ring.pgp\n"));
free(config);
return -1;
}
/* Make the DB Connection. */
conn = db_connect(config);
if(conn == NULL)
{
fprintf(stderr,_("cks_export: Failed to connect to postgres database"));
fprintf(stderr,_("cks_export: Connection to database failed.\n"));
fprintf(stderr,"cks_export: %s", PQerrorMessage(conn));
if(config != NULL)
{
free(config);
}
return -1;
}
result = PQexec(conn,"select fp from cks_fp_key_table\n");
if(PQresultStatus(result) != PGRES_TUPLES_OK)
{
fprintf(stderr,_("cks_export: Failed to return tuples.\n"));
fprintf(stderr,_("cks_export: Offending Query: select fp from cks_fp_key_table\n"));
PQclear(result);
db_disconnect(conn);
if(config != NULL)
{
free(config);
}
return -1;
}
to_export = PQntuples(result);
if(to_export == 0)
{
fprintf(stderr, _("cks_export: No Records Found.\n"));
fprintf(stderr,_("cks_export: Offending Query: select fp from cks_fp_key_table\n"));
PQclear(result);
db_disconnect(conn);
if(config != NULL)
{
free(config);
}
return -1;
}
printf(_("cks_export: exporting %lu keys.\n"),to_export);
printf(_("0 of %lu keys exported.\n"),to_export);
for(i=0;i<to_export;i++)
{
key_result = retrieve_pubkey(conn,PQgetvalue(result,i,0),0);
rslt_2 = parse_pubkey(&key_result,0);
if(rslt_2 != 0)
{
free_pubkey(&key_result);
continue;
}
rslt_2 = parse_packets(&key_result,0);
if(rslt_2 != 0)
{
/* Thank you. Drive Through. */
free_pubkey(&key_result);
continue;
}
/* Write the key to the out file. */
rslt_2 = decode_radix(key_result);
if(rslt_2 != 0)
{
free_pubkey(&key_result);
continue;
}
/* TODO: Speed this up with fwrite, it's fine for now though. */
for(j=0;j<key_result->buffer_idx;j++)
{
/* TODO: Check for success here. */
fputc(key_result->buffer[j],kr);
}
exported++;
if((exported % 5000) == 0)
{
printf(_("%lu of %lu keys exported.\n"),exported,to_export);
}
/* If i is divisable by max_keys (default: 50,000), open a new file */
if((exported % max_keys) == 0)
{
fclose(kr);
file_num++;
snprintf(file_name,19,"cks_ring-%03d.pgp",file_num);
if((kr = fopen(file_name,"wb")) == NULL)
{
fprintf(stderr,_("cks_export: Failed to open file %s\n"),file_name);
PQclear(result);
db_disconnect(conn);
if(config != NULL)
{
free(config);
}
return -1;
}
}
free_pubkey(&key_result);
}
/* Finish. Clean up memory and exit. */
PQclear(result);
db_disconnect(conn);
fclose(kr);
if(config != NULL)
{
free(config);
}
return 0;
}
int retrieve_key_and_display(PGconn *conn, char *fingerprint, unsigned int full,struct cks_config *config)
{
unsigned long i = 0;
FILE *test = NULL;
struct openPGP_packet *walk_packet = NULL;
int rslt = 0;
key_result = (struct openPGP_pubkey *)retrieve_pubkey(conn,fingerprint,D_SOURCE_ADD_CGI);
if(key_result == NULL)
{
fprintf(stderr,_("Failed to retrieve key: %s\n"),fingerprint);
do_error_page(_("Failed to retrieve key from database.\n"));
return -1;
}
rslt = parse_pubkey(&key_result,D_SOURCE_SEARCH_CGI);
if(rslt == -1)
{
fprintf(stderr,_("cks: cks_keyimg.c: Failed to parse retrieved pubkey: %s\n"),fingerprint);
return -1;
}
rslt = parse_packets(&key_result,D_SOURCE_SEARCH_CGI);
if(rslt == -1)
{
fprintf(stderr,_("Failed to parse retrieved pubkey's packets: %s\n"),fingerprint);
return -1;
}
// dump_pubkey_packet_info_stderr(key_result);
if(NULL == (test = fopen("/tmp/test.jpg","w")))
{
fprintf(stderr,"Failed to open out put file.\n");
return -1;
}
fprintf(stderr,"image_len = %lu\n",key_result->image_len);
fputc(0xd8,test);
fputc(0xff,test);
fputc(0xe0,test);
fputc(0xff,test);
fputc(0x10,test);
fputc(0x00,test);
fputc(0x46,test);
fputc(0x4a,test);
fputc(0x46,test);
fputc(0x49,test);
fputc(0x01,test);
fputc(0x00,test);
for(i=0;i<key_result->image_len;i++)
{
fputc(key_result->img_data[i],test);
}
fclose(test);
printf("Content-type: image/jpg\n\n");
printf("%c%c%c%c%c%c%c%c%c%c\n", 0xd8, 0xff, 0xe0, 0xff, 0x10, 0x00, 0x46, 0x4a, 0x46, 0x49, 0x01, 0x00);
for(i=0;i<key_result->image_len;i++)
{
printf("%c",key_result->img_data[i]);
}
free_pubkey(&key_result);
return rslt;
}
/*
* RSA public cryptography function.
* Encrypt 'in_len' bytes from 'plaintext' buffer with the public key contained in 'pub_key_file'
* Parameter 'outlen' is the size of output buffer
* It returns the envelope which has to be sent to the receiver or NULL if an error occurs.
*/
unsigned char* asym_crypto(unsigned char* plaintext, int in_len, int* out_len, char* pub_key_file){
EVP_PKEY* pubkey;
int ret;
EVP_CIPHER_CTX* ctx;
unsigned char* encrypted_key;
int encrypted_key_len;
unsigned char* iv;
int iv_len;
unsigned char* ciphertext;
int cipher_len;
int app;
unsigned char* output;
int total_output_size = 0;
if(plaintext == NULL || in_len < 0 || out_len == NULL || pub_key_file == NULL)
return NULL;
//Reads the receiver's public key for its file
pubkey = retrieve_pubkey(pub_key_file);
if(pubkey == NULL)
return NULL;
encrypted_key_len = EVP_PKEY_size(pubkey);
total_output_size += encrypted_key_len;
iv_len = EVP_CIPHER_iv_length(SYM_CIPHER);
total_output_size += iv_len;
//Allocation of encrypted symmetric key and initialization vector
encrypted_key = malloc(encrypted_key_len);
iv = malloc(iv_len);
//Seeding the RNG
RAND_seed(iv, 8);
//Instantiate and initialize the context
ctx = (EVP_CIPHER_CTX*)malloc(sizeof(EVP_CIPHER_CTX));
EVP_CIPHER_CTX_init(ctx);
ret = EVP_SealInit(ctx, SYM_CIPHER, &encrypted_key, &encrypted_key_len, iv, &pubkey ,1);
if(ret == 0){
fprintf(stderr, "Error in SealInit\n");
goto error;
}
//Encrypt the input buffer
cipher_len = in_len + EVP_CIPHER_block_size(SYM_CIPHER);
ciphertext = malloc(cipher_len);
cipher_len = 0;
ret = EVP_SealUpdate(ctx, ciphertext, &app, plaintext, in_len);
cipher_len += app;
if(ret == 0){
fprintf(stderr, "Error in SealUpdate\n");
goto error;
}
ret = EVP_SealFinal(ctx, ciphertext + app, &app);
cipher_len += app;
if(ret == 0){
fprintf(stderr, "Error in SealFinal\n");
goto error;
}
total_output_size += cipher_len;
//Concatenates the envelop in the outbuffer with format: <IV><Dim_Key><Ecrypt_KEY><Ciphertext>
total_output_size += sizeof(int);
output = malloc(total_output_size);
app = 0;
//<IV>
memcpy(output, iv, iv_len);
app += iv_len;
//<Dim_Key>
memcpy(output + app, &encrypted_key_len, sizeof(int));
app += sizeof(int);
//<Ecrypt_KEY>
memcpy(output + app, encrypted_key, encrypted_key_len);
app += encrypted_key_len;
//<Ciphertext>
memcpy(output + app, ciphertext, cipher_len);
app += encrypted_key_len;
*out_len = total_output_size;
//Cleanup
EVP_CIPHER_CTX_cleanup(ctx);
free(ctx);
free(ciphertext);
free(pubkey);
free(iv);
return output;
error:
if(ctx != NULL){
EVP_CIPHER_CTX_cleanup(ctx);
free(ctx);
}
if(encrypted_key != NULL)
free(ciphertext);
if(pubkey != NULL)
free(pubkey);
if(iv != NULL)
free(iv);
if(ciphertext != NULL)
free(ciphertext);
if(output != NULL)
free(output);
return NULL;
}
