pgp.cpp

pgpencrypt.rar

	while(fgets(buf, sizeof(buf), pfd)) {
		strip_newline(buf);
		if(!*buf)
			continue;

		if(!strcmp(buf, PGP_ENC_START)) {
			fclose(pfd);
			return 1;
		}

		if(!strcmp(buf, PGP_SIG_START)) {
			fclose(pfd);
			return 2;
		}

		if(!strcmp(buf, PGP_KEY_START)) {
			fclose(pfd);
			return 3;
		}

		fclose(pfd);
		return 0;
	}

	fclose(pfd);
	return 0;
}

int pgp_decode_file(char *file) {
	int res;
	struct pgpargs pgpargs;

	init_pgpargs(&pgpargs);
	pgpargs.passphrase = input_passphrase();

	if((res = pgp_action(file, DECODE, &pgpargs)) != 0)
		display_msg(MSG_WARN, "reply", "Failed to decode PGP message");

	if(pgpargs.passphrase)
		free(pgpargs.passphrase);

	return res;
}

int
compare_pgpkeys(struct _pgp_keylist *entry1, struct _pgp_keylist *entry2) {
	return strcasecmp(entry1->userid, entry2->userid);
}

char *get_pgp_recp(struct _mail_msg *msg) {
	static char recp[1024];
	struct _mail_addr *ptr = NULL, *addr;
	int i, pgpvers =
	Config.getInt("pgpversion", PGP_DEFAULT_VERS);
	*recp = '\0';

	//for(i = 0; i <= 1; i++) {
	for(i = 0; i < 3; i++) {
        switch(i) {
            case 0:
			    ptr = msg->header->To;
                break;

            case 1:
			    ptr = msg->header->Cc;
                break;

            case 2:
				if(Config.getInt("pgp_encrypt_bcc", 0)) {
			        ptr = msg->header->Bcc;
                } else {
                    ptr = NULL;
                }
                break;

            default:
                ptr = NULL;
        }

		while(ptr) {
			if(!ptr->pgpid || !strlen(ptr->pgpid))
				if((addr = find_addr(ptr)))
					if((addr->pgpid) && strlen(addr->pgpid)) {
						if((strlen(addr->pgpid) + strlen(recp) + 1)
						   >= sizeof(recp))
							break;
						if(pgpvers == 500 || pgpvers == 95)
							strcat(recp, "-r ");
						strcat(recp, addr->pgpid);
						goto nextitem;
					}
			if(ptr->pgpid && strlen(ptr->pgpid)) {
				if((strlen(ptr->pgpid) + strlen(recp) + 1) >=
				   sizeof(recp)) break;
				if(pgpvers == 500 || pgpvers == 95)
					strcat(recp, "-r ");
				strcat(recp, ptr->pgpid);
			} else {
				if((strlen(ptr->addr) + strlen(recp) + 1) >= sizeof(recp))
					break;
				if(pgpvers == 500 || pgpvers == 95)
					strcat(recp, "-r ");
				strcat(recp, ptr->addr);
			}
			nextitem:
			strcat(recp, " ");
			ptr = ptr->next_addr;
		}
	}

	return *recp ? recp : NULL;
}

int pgp_encode_rfc2015(struct _mail_msg *msg, int mode) {
	struct _mime_msg *mime;
	struct _head_field *fld;
	struct pgpargs pgpargs;
	char efile[255], vfile[255], buf[255];
	FILE *efd;

	init_pgpargs(&pgpargs);
	if(msg->flags & PGP_SIGNED) {
		display_msg(MSG_WARN, "encode",
					"Message is already signed by PGP");
		return -1;
	}

	if(msg->flags & PGP_ENCRYPTED) {
		display_msg(MSG_WARN, "encode",
					"Message is already encrypted with PGP");
		return -1;
	}

	if((pgpargs.recp = get_pgp_recp(msg)) == NULL) {
		display_msg(MSG_WARN, "encode",
					"Must specify at least one recipient");
		return -1;
	}

	if(!msg->mime)
		mime_scan(msg);

	mime = msg->mime;
	while(mime) {
		if(mime->flags & MSG_BODY)
			break;
		mime = mime->mime_next;
	}

	if(!mime)
		return -1;

	strcpy(efile, get_temp_file("pgpencr"));
	if((efd = fopen(efile, "w")) == NULL) {
		display_msg(MSG_WARN, "encode", "Can not create temp. file %-.64s",
					efile);
		return -1;
	}

	if((fld = find_field(msg, MIME_C_TYPE)) != NULL)
		print_header_field(fld, efd, 0);
	else
		fprintf(efd, "%s: %s/%s\n", MIME_C_TYPE, mime->mailcap->type_text,
				mime->mailcap->subtype_text);

	if(mime->encoding->c_trans_enc != CE_7BIT) {
		if((fld = find_field(msg, MIME_C_ENCR)) != NULL)
			print_header_field(fld, efd, 0);
		else
			fprintf(efd, "%s: %s\n", MIME_C_ENCR,
					mime->encoding->encoding_name);
	}

	fputc('\n', efd);
	if(msg->print_body(msg, efd) == -1) {
		display_msg(MSG_WARN, "encode", "Failed to write message");
		fclose(efd);
		unlink(efile);
		return -1;
	}
	fclose(efd);

	if(mode & SIGN)
		pgpargs.passphrase = input_passphrase();
	pgpargs.msg = msg;
	if(pgp_action(efile, mode, &pgpargs) != 0) {
		unlink(efile);

		if(pgpargs.passphrase)
			free(pgpargs.passphrase);
		return -1;
	}
	if(pgpargs.passphrase)
		free(pgpargs.passphrase);

	strcpy(vfile, get_temp_file("pgpvers"));
	if((efd = fopen(vfile, "w")) == NULL) {
		display_msg(MSG_WARN, "encode", "Can not create temp. file %-.64s",
					vfile);
		unlink(efile);
		return -1;
	}

	fprintf(efd, "Version: 1\n");
	fclose(efd);

	discard_mime(msg->mime);
	mime = msg->mime = create_mime();
	mime->mailcap = &mailcap[PGPENC_MAILCAP];
	mime->encoding = &supp_encodings[TEXT_ENCODING];
	mime->flags |= ATTACHMENT;
	mime->flags &= ~TEXT_PART;
	mime->src_info = strdup(vfile);
	snprintf(buf, sizeof(buf), "%s/%s", mailcap[PGPENC_MAILCAP].type_text,
			 mailcap[PGPENC_MAILCAP].subtype_text);
	replace_mime_field(mime, MIME_C_TYPE, buf);

	mime->mime_next = create_mime();
	mime = mime->mime_next;
	mime->mailcap = &mailcap[BINARY_MAILCAP];
	mime->encoding = &supp_encodings[TEXT_ENCODING];
	mime->flags |= ATTACHMENT;
	mime->flags &= ~TEXT_PART;
	mime->src_info = strdup(efile);
	snprintf(buf, sizeof(buf), "%s/%s", mailcap[BINARY_MAILCAP].type_text,
			 mailcap[BINARY_MAILCAP].subtype_text);
	replace_mime_field(mime, MIME_C_TYPE, buf);

	if(update_mime(msg) == -1) {
		unlink(vfile);
		unlink(efile);
		return -1;
	}

	unlink(vfile);
	unlink(efile);
	msg->flags |= PGP_ENCRYPTED;

	return 0;
}

int pgp_sign_rfc2015(struct _mail_msg *msg) {
	struct _mime_msg *mime, *mime1, *mbody;
	struct _head_field *fld;
	char efile[255], vfile[255], buf[255];
	FILE *efd;
	struct pgpargs pgpargs;

	init_pgpargs(&pgpargs);
	if(msg->flags & PGP_SIGNED) {
		display_msg(MSG_WARN, "sign", "Message is already signed by PGP");
		return -1;
	}

	if(msg->flags & PGP_ENCRYPTED) {
		display_msg(MSG_WARN, "sign",
					"Message is already encrypted with PGP");
		return -1;
	}

	if(!msg->mime)
		mime_scan(msg);

	mbody = msg->mime;
	while(mbody) {
		if(mbody->flags & MSG_BODY)
			break;
		mbody = mbody->mime_next;
	}

	if(!mbody)
		return -1;

	strcpy(efile, get_temp_file("pgpsign"));
	if((efd = fopen(efile, "w")) == NULL) {
		display_msg(MSG_WARN, "sign", "Can not create temp. file %-.64s",
					efile);
		return -1;
	}

	if((fld = find_field(msg, MIME_C_TYPE)) != NULL)
		print_header_field(fld, efd, 0);
	else
		fprintf(efd, "%s: %s/%s\n", MIME_C_TYPE, mbody->mailcap->type_text,
				mbody->mailcap->subtype_text);

	if(mbody->encoding->c_trans_enc !=
	   supp_encodings[DEFAULT_ENCODING].c_trans_enc) {
		if((fld = find_field(msg, MIME_C_ENCR)) != NULL)
			print_header_field(fld, efd, 0);
		else
			fprintf(efd, "%s: %s\n", MIME_C_ENCR,
					mbody->encoding->encoding_name);
	}

	fputc('\n', efd);
	if(msg->print_body(msg, efd) == -1) {
		display_msg(MSG_WARN, "sign", "Failed to write message");
		fclose(efd);
		unlink(efile);
		return -1;
	}
	fclose(efd);

	strcpy(vfile, get_temp_file("pgps"));
	pgpargs.passphrase = input_passphrase();
	pgpargs.recp = vfile;
	pgpargs.msg = msg;
	if(pgp_action(efile, SIGNFL, &pgpargs) != 0) {
		unlink(efile);
		unlink(vfile);
		if(pgpargs.passphrase)
			free(pgpargs.passphrase);
		return -1;
	}
	if(pgpargs.passphrase)
		free(pgpargs.passphrase);

	if((efd = fopen(efile, "w")) == NULL) {
		display_msg(MSG_WARN, "sign", "Can not create temp. file %-.64s",
					efile);
		unlink(efile);
		unlink(vfile);
		return -1;
	}

	if(msg->print_body(msg, efd) == -1) {
		display_msg(MSG_WARN, "sign", "Failed to write message");
		fclose(efd);
		unlink(efile);
		unlink(vfile);
		return -1;
	}
	fclose(efd);

	mime = create_mime();
	mime->mime_next = NULL;
	mime->mailcap = &mailcap[PGPSIG_MAILCAP];
	mime->encoding = &supp_encodings[NO_ENCODING];
	mime->flags |= ATTACHMENT;
	mime->flags &= ~TEXT_PART;
	mime->src_info = strdup(vfile);
	snprintf(buf, sizeof(buf), "%s/%s", mailcap[PGPSIG_MAILCAP].type_text,
			 mailcap[PGPSIG_MAILCAP].subtype_text);
	replace_mime_field(mime, MIME_C_TYPE, buf);

	mime1 = create_mime();
	mime1->mime_next = mime;
	mime1->mailcap = find_mailcap(mbody->mailcap->type_text,
								  mbody->mailcap->subtype_text, 1);
	mime1->encoding = &supp_encodings[NO_ENCODING];
	mime1->flags |= ATTACHMENT;
	mime1->flags &= ~TEXT_PART;
	mime1->src_info = strdup(efile);
	if((fld = find_field(msg, MIME_C_TYPE)) != NULL)
		replace_mime_field(mime1, MIME_C_TYPE, fld->f_line);
	else {
		snprintf(buf, sizeof(buf), "%s: %s/%s", MIME_C_TYPE,
				 mbody->mailcap->type_text, mbody->mailcap->subtype_text);
		replace_mime_field(mime1, MIME_C_TYPE, buf);
	}

	if(mbody->encoding->c_trans_enc !=
	   supp_encodings[DEFAULT_ENCODING].c_trans_enc) {
		if((fld = find_field(msg, MIME_C_ENCR)) != NULL)
			replace_mime_field(mime1, MIME_C_ENCR, fld->f_line);
		else {
			snprintf(buf, sizeof(buf), "%s: %s\n", MIME_C_ENCR,
					 mbody->encoding->encoding_name);
			replace_mime_field(mime1, MIME_C_ENCR, buf);
		}
	}

	discard_mime(msg->mime);
	msg->mime = mime1;

	if(update_mime(msg) == -1) {
		unlink(vfile);
		unlink(efile);
		return -1;
	}

	unlink(vfile);
	unlink(efile);
	msg->flags |= PGP_SIGNED;

	return 0;
}