repos/pEpEngine: src/message_api.c@5bd49bd73192 (annotated)

vb@1513	1	// This file is under GNU General Public License 3.0
vb@1513	2	// see LICENSE.txt
vb@1513	3
vb@125	4	#include "pEp_internal.h"
vb@37	5	#include "message_api.h"
vb@37	6
vb@130	7	#include "platform.h"
vb@220	8	#include "mime.h"
vb@952	9	#include "sync_fsm.h"
vb@85	10
vb@37	11	#include <assert.h>
vb@37	12	#include <string.h>
vb@39	13	#include <stdlib.h>
vb@39	14
vb@926	15
vb@951	16	#ifndef _MIN
vb@951	17	#define _MIN(A, B) ((B) > (A) ? (A) : (B))
vb@190	18	#endif
vb@951	19	#ifndef _MAX
vb@951	20	#define _MAX(A, B) ((B) > (A) ? (B) : (A))
vb@300	21	#endif
vb@190	22
vb@235	23
vb@235	24	static bool string_equality(const char s1, const char s2)
vb@235	25	{
vb@235	26	if (s1 == NULL \|\| s2 == NULL)
vb@235	27	return false;
vb@235	28
vb@235	29	assert(s1 && s2);
vb@235	30
vb@235	31	return strcmp(s1, s2) == 0;
vb@235	32	}
vb@235	33
vb@235	34	static bool is_mime_type(const bloblist_t bl, const char mt)
vb@235	35	{
vb@235	36	assert(mt);
vb@235	37
vb@235	38	return bl && string_equality(bl->mime_type, mt);
vb@235	39	}
vb@235	40
krista@854	41	//
krista@854	42	// This function presumes the file ending is a proper substring of the
krista@854	43	// filename (i.e. if bl->filename is "a.pgp" and fe is ".pgp", it will
krista@854	44	// return true, but if bl->filename is ".pgp" and fe is ".pgp", it will
krista@854	45	// return false. This is desired behaviour.
krista@854	46	//
vb@235	47	static bool is_fileending(const bloblist_t bl, const char fe)
vb@235	48	{
vb@235	49	assert(fe);
krista@1427	50
krista@853	51	if (bl == NULL \|\| bl->filename == NULL \|\| fe == NULL)
vb@235	52	return false;
vb@235	53
vb@235	54	assert(bl && bl->filename);
vb@235	55
vb@235	56	size_t fe_len = strlen(fe);
vb@235	57	size_t fn_len = strlen(bl->filename);
vb@235	58
vb@235	59	if (fn_len <= fe_len)
vb@235	60	return false;
vb@235	61
vb@235	62	assert(fn_len > fe_len);
vb@235	63
vb@235	64	return strcmp(bl->filename + (fn_len - fe_len), fe) == 0;
vb@235	65	}
vb@235	66
vb@952	67	void add_opt_field(message msg, const char name, const char *value)
vb@284	68	{
vb@952	69	assert(msg && name && value);
vb@284	70
vb@284	71	if (msg && name && value) {
vb@284	72	stringpair_t *pair = new_stringpair(name, value);
vb@284	73	if (pair == NULL)
vb@284	74	return;
vb@284	75
vb@284	76	stringpair_list_t *field = stringpair_list_add(msg->opt_fields, pair);
vb@284	77	if (field == NULL)
Edouard@833	78	{
Edouard@833	79	free_stringpair(pair);
vb@284	80	return;
Edouard@833	81	}
vb@284	82
vb@284	83	if (msg->opt_fields == NULL)
vb@284	84	msg->opt_fields = field;
vb@284	85	}
vb@284	86	}
vb@284	87
vb@83	88	static char * combine_short_and_long(const char shortmsg, const char longmsg)
vb@62	89	{
vb@83	90	assert(shortmsg);
vb@83	91	assert(strcmp(shortmsg, "pEp") != 0);
vb@855	92
vb@857	93	if (!shortmsg \|\| strcmp(shortmsg, "pEp") == 0) {
vb@857	94	if (!longmsg) {
vb@857	95	return NULL;
vb@857	96	}
vb@857	97	else {
vb@857	98	char *result = strdup(longmsg);
vb@857	99	assert(result);
vb@857	100	return result;
vb@857	101	}
vb@857	102	}
krista@1427	103
vb@83	104	if (longmsg == NULL)
vb@63	105	longmsg = "";
vb@63	106
krista@935	107	const char * const subject = "Subject: ";
krista@935	108	const size_t SUBJ_LEN = 9;
krista@935	109	const char * const newlines = "\n\n";
krista@935	110	const size_t NL_LEN = 2;
krista@935	111
roker@1559	112	const size_t bufsize = SUBJ_LEN + strlen(shortmsg) + NL_LEN + strlen(longmsg) + 1;
roker@1559	113	char * ptext = calloc(1, bufsize);
vb@109	114	assert(ptext);
vb@62	115	if (ptext == NULL)
vb@62	116	return NULL;
vb@62	117
krista@935	118	strlcpy(ptext, subject, bufsize);
krista@918	119	strlcat(ptext, shortmsg, bufsize);
krista@935	120	strlcat(ptext, newlines, bufsize);
krista@918	121	strlcat(ptext, longmsg, bufsize);
vb@62	122
vb@62	123	return ptext;
vb@62	124	}
vb@44	125
krista@853	126	static int separate_short_and_long(const char src, char shortmsg, char *longmsg)
vb@82	127	{
vb@82	128	char *_shortmsg = NULL;
vb@82	129	char *_longmsg = NULL;
vb@82	130
vb@82	131	assert(src);
vb@82	132	assert(shortmsg);
vb@82	133	assert(longmsg);
krista@1427	134
krista@853	135	if (src == NULL \|\| shortmsg == NULL \|\| longmsg == NULL)
krista@853	136	return -1;
vb@82	137
vb@82	138	*shortmsg = NULL;
vb@82	139	*longmsg = NULL;
vb@82	140
vb@85	141	if (strncasecmp(src, "subject: ", 9) == 0) {
vb@82	142	char *line_end = strchr(src, '\n');
vb@311	143
vb@82	144	if (line_end == NULL) {
vb@82	145	_shortmsg = strdup(src + 9);
vb@469	146	assert(_shortmsg);
vb@82	147	if (_shortmsg == NULL)
vb@82	148	goto enomem;
vb@82	149	// _longmsg = NULL;
vb@82	150	}
vb@82	151	else {
vb@82	152	size_t n = line_end - src;
vb@166	153
vb@82	154	if (*(line_end - 1) == '\r')
vb@166	155	_shortmsg = strndup(src + 9, n - 10);
vb@82	156	else
vb@166	157	_shortmsg = strndup(src + 9, n - 9);
vb@469	158	assert(_shortmsg);
vb@82	159	if (_shortmsg == NULL)
vb@82	160	goto enomem;
vb@166	161
vb@166	162	while ((src + n) && ((src + n) == '\n' \|\| *(src + n) == '\r'))
vb@166	163	++n;
vb@166	164
vb@166	165	if (*(src + n)) {
vb@166	166	_longmsg = strdup(src + n);
vb@469	167	assert(_longmsg);
vb@166	168	if (_longmsg == NULL)
vb@166	169	goto enomem;
vb@166	170	}
vb@82	171	}
vb@82	172	}
vb@82	173	else {
vb@113	174	_shortmsg = strdup("");
vb@469	175	assert(_shortmsg);
vb@82	176	if (_shortmsg == NULL)
vb@82	177	goto enomem;
vb@82	178	_longmsg = strdup(src);
vb@469	179	assert(_longmsg);
vb@82	180	if (_longmsg == NULL)
vb@82	181	goto enomem;
vb@82	182	}
vb@311	183
vb@82	184	*shortmsg = _shortmsg;
vb@82	185	*longmsg = _longmsg;
vb@82	186
vb@82	187	return 0;
vb@82	188
vb@82	189	enomem:
vb@82	190	free(_shortmsg);
vb@82	191	free(_longmsg);
vb@82	192
vb@82	193	return -1;
vb@82	194	}
vb@82	195
vb@113	196	static PEP_STATUS copy_fields(message dst, const message src)
vb@113	197	{
vb@164	198	assert(dst);
vb@164	199	assert(src);
vb@164	200
Edouard@840	201	if(!(dst && src))
Edouard@840	202	return PEP_ILLEGAL_VALUE;
Edouard@840	203
vb@113	204	free_timestamp(dst->sent);
vb@113	205	dst->sent = NULL;
vb@113	206	if (src->sent) {
vb@113	207	dst->sent = timestamp_dup(src->sent);
vb@113	208	if (dst->sent == NULL)
vb@113	209	return PEP_OUT_OF_MEMORY;
vb@113	210	}
vb@113	211
vb@113	212	free_timestamp(dst->recv);
vb@113	213	dst->recv = NULL;
vb@113	214	if (src->recv) {
vb@113	215	dst->recv = timestamp_dup(src->recv);
vb@113	216	if (dst->recv == NULL)
vb@113	217	return PEP_OUT_OF_MEMORY;
vb@113	218	}
vb@113	219
vb@113	220	free_identity(dst->from);
vb@113	221	dst->from = NULL;
vb@113	222	if (src->from) {
vb@113	223	dst->from = identity_dup(src->from);
vb@113	224	if (dst->from == NULL)
vb@113	225	return PEP_OUT_OF_MEMORY;
vb@113	226	}
vb@113	227
vb@113	228	free_identity_list(dst->to);
vb@113	229	dst->to = NULL;
vb@274	230	if (src->to && src->to->ident) {
vb@113	231	dst->to = identity_list_dup(src->to);
vb@113	232	if (dst->to == NULL)
vb@113	233	return PEP_OUT_OF_MEMORY;
vb@113	234	}
vb@113	235
vb@113	236	free_identity(dst->recv_by);
vb@113	237	dst->recv_by = NULL;
vb@113	238	if (src->recv_by) {
vb@113	239	dst->recv_by = identity_dup(src->recv_by);
vb@113	240	if (dst->recv_by == NULL)
vb@113	241	return PEP_OUT_OF_MEMORY;
vb@113	242	}
vb@113	243
vb@113	244	free_identity_list(dst->cc);
vb@113	245	dst->cc = NULL;
vb@274	246	if (src->cc && src->cc->ident) {
vb@113	247	dst->cc = identity_list_dup(src->cc);
vb@113	248	if (dst->cc == NULL)
vb@113	249	return PEP_OUT_OF_MEMORY;
vb@113	250	}
vb@113	251
vb@113	252	free_identity_list(dst->bcc);
vb@113	253	dst->bcc = NULL;
vb@274	254	if (src->bcc && src->bcc->ident) {
vb@113	255	dst->bcc = identity_list_dup(src->bcc);
vb@113	256	if (dst->bcc == NULL)
vb@113	257	return PEP_OUT_OF_MEMORY;
vb@113	258	}
vb@113	259
vb@113	260	free_identity_list(dst->reply_to);
vb@113	261	dst->reply_to = NULL;
vb@274	262	if (src->reply_to && src->reply_to->ident) {
vb@113	263	dst->reply_to = identity_list_dup(src->reply_to);
vb@113	264	if (dst->reply_to == NULL)
vb@113	265	return PEP_OUT_OF_MEMORY;
vb@113	266	}
vb@113	267
vb@113	268	free_stringlist(dst->in_reply_to);
vb@113	269	dst->in_reply_to = NULL;
vb@274	270	if (src->in_reply_to && src->in_reply_to->value) {
vb@113	271	dst->in_reply_to = stringlist_dup(src->in_reply_to);
vb@113	272	if (dst->in_reply_to == NULL)
vb@113	273	return PEP_OUT_OF_MEMORY;
vb@113	274	}
vb@113	275
vb@113	276	free_stringlist(dst->references);
vb@113	277	dst->references = NULL;
vb@113	278	if (src->references) {
vb@113	279	dst->references = stringlist_dup(src->references);
vb@113	280	if (dst->references == NULL)
vb@113	281	return PEP_OUT_OF_MEMORY;
vb@113	282	}
vb@113	283
vb@113	284	free_stringlist(dst->keywords);
vb@113	285	dst->keywords = NULL;
vb@274	286	if (src->keywords && src->keywords->value) {
vb@113	287	dst->keywords = stringlist_dup(src->keywords);
vb@113	288	if (dst->keywords == NULL)
vb@113	289	return PEP_OUT_OF_MEMORY;
vb@113	290	}
vb@113	291
vb@113	292	free(dst->comments);
vb@113	293	dst->comments = NULL;
vb@113	294	if (src->comments) {
vb@113	295	dst->comments = strdup(src->comments);
vb@113	296	assert(dst->comments);
vb@113	297	if (dst->comments == NULL)
vb@113	298	return PEP_OUT_OF_MEMORY;
vb@113	299	}
vb@113	300
vb@1092	301	free_stringpair_list(dst->opt_fields);
vb@1092	302	dst->opt_fields = NULL;
vb@1092	303	if (src->opt_fields) {
vb@1092	304	dst->opt_fields = stringpair_list_dup(src->opt_fields);
vb@1092	305	if (dst->opt_fields == NULL)
vb@1092	306	return PEP_OUT_OF_MEMORY;
vb@1092	307	}
vb@1092	308
vb@113	309	return PEP_STATUS_OK;
vb@113	310	}
vb@113	311
vb@81	312	static message * clone_to_empty_message(const message * src)
vb@80	313	{
vb@113	314	PEP_STATUS status;
vb@80	315	message * msg = NULL;
vb@80	316
vb@81	317	assert(src);
krista@853	318	if (src == NULL)
krista@853	319	return NULL;
vb@81	320
vb@113	321	msg = calloc(1, sizeof(message));
vb@113	322	assert(msg);
vb@80	323	if (msg == NULL)
vb@80	324	goto enomem;
vb@80	325
vb@82	326	msg->dir = src->dir;
vb@82	327
vb@113	328	status = copy_fields(msg, src);
vb@113	329	if (status != PEP_STATUS_OK)
vb@113	330	goto enomem;
vb@81	331
vb@80	332	return msg;
vb@80	333
vb@80	334	enomem:
vb@113	335	free_message(msg);
vb@80	336	return NULL;
vb@80	337	}
vb@80	338
vb@260	339	static PEP_STATUS encrypt_PGP_MIME(
vb@311	340	PEP_SESSION session,
vb@311	341	const message *src,
vb@311	342	stringlist_t *keys,
krista@1639	343	message *dst,
krista@1639	344	PEP_encrypt_flags_t flags
vb@260	345	)
vb@260	346	{
vb@260	347	PEP_STATUS status = PEP_STATUS_OK;
vb@260	348	bool free_ptext = false;
vb@468	349	char *ptext = NULL;
Edouard@882	350	char *ctext = NULL;
vb@260	351	char *mimetext = NULL;
vb@260	352	size_t csize;
vb@260	353	assert(dst->longmsg == NULL);
vb@260	354	dst->enc_format = PEP_enc_PGP_MIME;
vb@260	355
vb@260	356	if (src->shortmsg && strcmp(src->shortmsg, "pEp") != 0) {
vb@466	357	if (session->unencrypted_subject) {
vb@466	358	dst->shortmsg = strdup(src->shortmsg);
vb@469	359	assert(dst->shortmsg);
vb@466	360	if (dst->shortmsg == NULL)
vb@466	361	goto enomem;
vb@466	362	ptext = src->longmsg;
vb@466	363	}
vb@466	364	else {
vb@466	365	ptext = combine_short_and_long(src->shortmsg, src->longmsg);
vb@466	366	if (ptext == NULL)
vb@466	367	goto enomem;
vb@466	368	free_ptext = true;
vb@466	369	}
vb@260	370	}
vb@260	371	else if (src->longmsg) {
vb@260	372	ptext = src->longmsg;
vb@260	373	}
vb@260	374	else {
vb@260	375	ptext = "pEp";
vb@260	376	}
vb@260	377
vb@260	378	message *_src = calloc(1, sizeof(message));
vb@260	379	assert(_src);
vb@260	380	if (_src == NULL)
vb@260	381	goto enomem;
vb@260	382	_src->longmsg = ptext;
vb@260	383	_src->longmsg_formatted = src->longmsg_formatted;
vb@260	384	_src->attachments = src->attachments;
vb@260	385	_src->enc_format = PEP_enc_none;
vb@260	386	status = mime_encode_message(_src, true, &mimetext);
vb@260	387	assert(status == PEP_STATUS_OK);
krista@853	388	if (status != PEP_STATUS_OK)
krista@853	389	goto pep_error;
krista@1427	390
Edouard@371	391	if (free_ptext){
vb@260	392	free(ptext);
Edouard@371	393	free_ptext=0;
Edouard@371	394	}
vb@260	395	free(_src);
vb@260	396	assert(mimetext);
vb@260	397	if (mimetext == NULL)
vb@260	398	goto pep_error;
vb@260	399
krista@1639	400	if (flags & PEP_encrypt_flag_force_unsigned)
krista@1639	401	status = encrypt_only(session, keys, mimetext, strlen(mimetext),
krista@1639	402	&ctext, &csize);
krista@1639	403	else
krista@1639	404	status = encrypt_and_sign(session, keys, mimetext, strlen(mimetext),
krista@1639	405	&ctext, &csize);
vb@260	406	free(mimetext);
vb@260	407	if (ctext == NULL)
vb@260	408	goto pep_error;
vb@260	409
vb@260	410	dst->longmsg = strdup("this message was encrypted with p≡p "
lix@487	411	"https://pEp-project.org");
vb@469	412	assert(dst->longmsg);
vb@260	413	if (dst->longmsg == NULL)
vb@260	414	goto enomem;
vb@260	415
vb@260	416	char *v = strdup("Version: 1");
vb@469	417	assert(v);
vb@260	418	if (v == NULL)
vb@260	419	goto enomem;
vb@260	420
roker@801	421	bloblist_t *_a = new_bloblist(v, strlen(v), "application/pgp-encrypted", NULL);
vb@260	422	if (_a == NULL)
vb@260	423	goto enomem;
vb@260	424	dst->attachments = _a;
vb@288	425
Edouard@882	426	_a = bloblist_add(_a, ctext, csize, "application/octet-stream",
Edouard@427	427	"msg.asc");
vb@260	428	if (_a == NULL)
vb@260	429	goto enomem;
vb@260	430
vb@260	431	return PEP_STATUS_OK;
vb@260	432
vb@260	433	enomem:
vb@260	434	status = PEP_OUT_OF_MEMORY;
vb@260	435
vb@260	436	pep_error:
vb@260	437	if (free_ptext)
vb@260	438	free(ptext);
Edouard@882	439	free(ctext);
vb@260	440	return status;
vb@260	441	}
vb@260	442
vb@260	443	static PEP_STATUS encrypt_PGP_in_pieces(
vb@311	444	PEP_SESSION session,
vb@311	445	const message *src,
vb@311	446	stringlist_t *keys,
krista@1639	447	message *dst,
krista@1639	448	PEP_encrypt_flags_t flags
vb@260	449	)
vb@260	450	{
vb@260	451	PEP_STATUS status = PEP_STATUS_OK;
Edouard@882	452	char *ctext = NULL;
vb@260	453	size_t csize;
vb@468	454	char *ptext = NULL;
vb@466	455	bool free_ptext = false;
vb@260	456
vb@260	457	assert(dst->longmsg == NULL);
vb@260	458	assert(dst->attachments == NULL);
vb@260	459
vb@260	460	dst->enc_format = PEP_enc_pieces;
vb@260	461
krista@1639	462	bool nosign = (flags & PEP_encrypt_flag_force_unsigned);
krista@1639	463
vb@320	464	if (src->shortmsg && src->shortmsg[0] && strcmp(src->shortmsg, "pEp") != 0) {
vb@466	465	if (session->unencrypted_subject) {
vb@466	466	dst->shortmsg = strdup(src->shortmsg);
vb@469	467	assert(dst->shortmsg);
vb@466	468	if (dst->shortmsg == NULL)
vb@466	469	goto enomem;
vb@466	470	ptext = src->longmsg;
vb@466	471	}
vb@466	472	else {
vb@466	473	ptext = combine_short_and_long(src->shortmsg, src->longmsg);
vb@466	474	if (ptext == NULL)
vb@466	475	goto enomem;
vb@466	476	free_ptext = true;
vb@466	477	}
vb@260	478
krista@1639	479	if (nosign)
krista@1639	480	status = encrypt_only(session, keys, ptext, strlen(ptext), &ctext,
krista@1639	481	&csize);
krista@1639	482	else
krista@1639	483	status = encrypt_and_sign(session, keys, ptext, strlen(ptext), &ctext,
krista@1639	484	&csize);
vb@466	485	if (free_ptext)
vb@466	486	free(ptext);
vb@466	487	free_ptext = false;
vb@288	488	if (ctext) {
Edouard@882	489	dst->longmsg = ctext;
vb@288	490	}
vb@288	491	else {
vb@260	492	goto pep_error;
vb@288	493	}
vb@260	494	}
vb@320	495	else if (src->longmsg && src->longmsg[0]) {
vb@466	496	ptext = src->longmsg;
krista@1639	497	if (nosign)
krista@1639	498	status = encrypt_only(session, keys, ptext, strlen(ptext), &ctext,
krista@1639	499	&csize);
krista@1639	500	else
krista@1639	501	status = encrypt_and_sign(session, keys, ptext, strlen(ptext), &ctext,
krista@1639	502	&csize);
vb@288	503	if (ctext) {
Edouard@882	504	dst->longmsg = ctext;
vb@288	505	}
vb@288	506	else {
vb@260	507	goto pep_error;
vb@288	508	}
vb@284	509	}
vb@284	510	else {
vb@284	511	dst->longmsg = strdup("");
vb@469	512	assert(dst->longmsg);
vb@284	513	if (dst->longmsg == NULL)
vb@284	514	goto enomem;
vb@260	515	}
vb@260	516
vb@320	517	if (src->longmsg_formatted && src->longmsg_formatted[0]) {
vb@466	518	ptext = src->longmsg_formatted;
krista@1639	519	if (nosign)
krista@1639	520	status = encrypt_only(session, keys, ptext, strlen(ptext), &ctext,
krista@1639	521	&csize);
krista@1639	522	else
krista@1639	523	status = encrypt_and_sign(session, keys, ptext, strlen(ptext), &ctext,
krista@1639	524	&csize);
vb@260	525	if (ctext) {
vb@288	526
Edouard@882	527	bloblist_t *_a = bloblist_add(dst->attachments, ctext, csize,
vb@311	528	"application/octet-stream", "PGPexch.htm.pgp");
vb@284	529	if (_a == NULL)
vb@260	530	goto enomem;
vb@284	531	if (dst->attachments == NULL)
vb@284	532	dst->attachments = _a;
vb@260	533	}
vb@260	534	else {
vb@260	535	goto pep_error;
vb@260	536	}
vb@260	537	}
vb@260	538
vb@260	539	if (src->attachments) {
vb@284	540	if (dst->attachments == NULL) {
vb@284	541	dst->attachments = new_bloblist(NULL, 0, NULL, NULL);
vb@284	542	if (dst->attachments == NULL)
vb@284	543	goto enomem;
vb@284	544	}
vb@260	545
vb@284	546	bloblist_t *_s = src->attachments;
vb@284	547	bloblist_t *_d = dst->attachments;
vb@284	548
Edouard@754	549	for (int n = 0; _s; _s = _s->next) {
Edouard@754	550	if (_s->value == NULL && _s->size == 0) {
Edouard@754	551	_d = bloblist_add(_d, NULL, 0, _s->mime_type, _s->filename);
vb@260	552	if (_d == NULL)
vb@260	553	goto enomem;
vb@260	554	}
vb@260	555	else {
Edouard@754	556	size_t psize = _s->size;
Edouard@754	557	ptext = _s->value;
krista@1639	558	if (nosign)
krista@1639	559	status = encrypt_only(session, keys, ptext, psize, &ctext,
krista@1639	560	&csize);
krista@1639	561	else
krista@1639	562	status = encrypt_and_sign(session, keys, ptext, psize, &ctext,
krista@1639	563	&csize);
Edouard@754	564	if (ctext) {
Edouard@754	565	char *filename = NULL;
Edouard@754	566
Edouard@754	567	if (_s->filename) {
Edouard@754	568	size_t len = strlen(_s->filename);
krista@975	569	size_t bufsize = len + 5; // length of .pgp extension + NUL
krista@975	570	filename = calloc(1, bufsize);
Edouard@754	571	if (filename == NULL)
Edouard@754	572	goto enomem;
Edouard@754	573
krista@975	574	strlcpy(filename, _s->filename, bufsize);
krista@975	575	strlcat(filename, ".pgp", bufsize);
Edouard@754	576	}
Edouard@754	577	else {
Edouard@754	578	filename = calloc(1, 20);
Edouard@754	579	if (filename == NULL)
Edouard@754	580	goto enomem;
Edouard@754	581
Edouard@754	582	++n;
Edouard@754	583	n &= 0xffff;
Edouard@754	584	snprintf(filename, 20, "Attachment%d.pgp", n);
Edouard@754	585	}
Edouard@754	586
Edouard@882	587	_d = bloblist_add(_d, ctext, csize, "application/octet-stream",
Edouard@754	588	filename);
roker@866	589	free(filename);
Edouard@754	590	if (_d == NULL)
Edouard@754	591	goto enomem;
Edouard@754	592	}
Edouard@754	593	else {
Edouard@754	594	goto pep_error;
Edouard@754	595	}
vb@260	596	}
vb@260	597	}
vb@260	598	}
vb@260	599
vb@260	600	return PEP_STATUS_OK;
vb@260	601
vb@260	602	enomem:
vb@260	603	status = PEP_OUT_OF_MEMORY;
vb@260	604
vb@260	605	pep_error:
vb@466	606	if (free_ptext)
vb@466	607	free(ptext);
vb@260	608	return status;
vb@260	609	}
vb@260	610
vb@311	611	static char * keylist_to_string(const stringlist_t *keylist)
vb@311	612	{
vb@311	613	if (keylist) {
vb@311	614	size_t size = stringlist_length(keylist);
vb@311	615
vb@311	616	const stringlist_t *_kl;
vb@311	617	for (_kl = keylist; _kl && _kl->value; _kl = _kl->next) {
vb@311	618	size += strlen(_kl->value);
vb@311	619	}
vb@311	620
vb@311	621	char *result = calloc(1, size);
vb@311	622	if (result == NULL)
vb@311	623	return NULL;
vb@311	624
vb@311	625	char *_r = result;
vb@311	626	for (_kl = keylist; _kl && _kl->value; _kl = _kl->next) {
vb@311	627	_r = stpcpy(_r, _kl->value);
vb@311	628	if (_kl->next && _kl->next->value)
vb@311	629	_r = stpcpy(_r, ",");
vb@311	630	}
vb@311	631
vb@311	632	return result;
vb@311	633	}
vb@311	634	else {
vb@311	635	return NULL;
vb@311	636	}
vb@311	637	}
vb@311	638
vb@1004	639	static const char * rating_to_string(PEP_rating rating)
vb@311	640	{
vb@1004	641	switch (rating) {
vb@311	642	case PEP_rating_cannot_decrypt:
vb@311	643	return "cannot_decrypt";
vb@311	644	case PEP_rating_have_no_key:
vb@311	645	return "have_no_key";
vb@311	646	case PEP_rating_unencrypted:
vb@311	647	return "unencrypted";
vb@486	648	case PEP_rating_unencrypted_for_some:
vb@486	649	return "unencrypted_for_some";
vb@311	650	case PEP_rating_unreliable:
vb@311	651	return "unreliable";
vb@311	652	case PEP_rating_reliable:
vb@311	653	return "reliable";
vb@311	654	case PEP_rating_trusted:
vb@311	655	return "trusted";
vb@311	656	case PEP_rating_trusted_and_anonymized:
vb@311	657	return "trusted_and_anonymized";
vb@311	658	case PEP_rating_fully_anonymous:
vb@311	659	return "fully_anonymous";
Edouard@442	660	case PEP_rating_mistrust:
Edouard@442	661	return "mistrust";
Edouard@442	662	case PEP_rating_b0rken:
Edouard@442	663	return "b0rken";
vb@311	664	case PEP_rating_under_attack:
krista@961	665	return "under_attack";
vb@311	666	default:
vb@311	667	return "undefined";
vb@311	668	}
vb@311	669	}
vb@311	670
vb@311	671	static void decorate_message(
vb@311	672	message *msg,
vb@1004	673	PEP_rating rating,
vb@311	674	stringlist_t *keylist
vb@311	675	)
vb@311	676	{
vb@311	677	assert(msg);
vb@311	678
krista@942	679	add_opt_field(msg, "X-pEp-Version", PEP_VERSION);
krista@1427	680
vb@1004	681	if (rating != PEP_rating_undefined)
vb@1004	682	add_opt_field(msg, "X-EncStatus", rating_to_string(rating));
vb@311	683
vb@311	684	if (keylist) {
vb@311	685	char *_keylist = keylist_to_string(keylist);
vb@311	686	add_opt_field(msg, "X-KeyList", _keylist);
vb@311	687	free(_keylist);
vb@311	688	}
vb@311	689	}
vb@311	690
vb@1004	691	static PEP_rating _rating(PEP_comm_type ct, PEP_rating rating)
vb@311	692	{
vb@311	693	if (ct == PEP_ct_unknown)
vb@311	694	return PEP_rating_undefined;
krista@1427	695
krista@1243	696	else if (ct == PEP_ct_key_not_found)
krista@1243	697	return PEP_rating_have_no_key;
krista@1427	698
vb@311	699	else if (ct == PEP_ct_compromized)
vb@311	700	return PEP_rating_under_attack;
vb@311	701
Edouard@442	702	else if (ct == PEP_ct_mistrusted)
Edouard@442	703	return PEP_rating_mistrust;
krista@1427	704
vb@1004	705	if (rating == PEP_rating_unencrypted_for_some)
vb@486	706	return PEP_rating_unencrypted_for_some;
vb@486	707
vb@486	708	if (ct == PEP_ct_no_encryption \|\| ct == PEP_ct_no_encrypted_channel \|\|
vb@486	709	ct == PEP_ct_my_key_not_included) {
vb@1004	710	if (rating > PEP_rating_unencrypted_for_some)
vb@486	711	return PEP_rating_unencrypted_for_some;
vb@486	712	else
vb@486	713	return PEP_rating_unencrypted;
vb@486	714	}
vb@486	715
vb@1004	716	if (rating == PEP_rating_unencrypted)
vb@486	717	return PEP_rating_unencrypted_for_some;
vb@486	718
vb@486	719	if (ct >= PEP_ct_confirmed_enc_anon)
vb@311	720	return PEP_rating_trusted_and_anonymized;
vb@311	721
vb@311	722	else if (ct >= PEP_ct_strong_encryption)
vb@311	723	return PEP_rating_trusted;
vb@311	724
vb@311	725	else if (ct >= PEP_ct_strong_but_unconfirmed && ct < PEP_ct_confirmed)
vb@311	726	return PEP_rating_reliable;
vb@311	727
vb@311	728	else
vb@311	729	return PEP_rating_unreliable;
vb@311	730	}
vb@311	731
vb@311	732	static bool is_encrypted_attachment(const bloblist_t *blob)
vb@311	733	{
vb@311	734	assert(blob);
vb@311	735
krista@853	736	if (blob == NULL \|\| blob->filename == NULL)
vb@311	737	return false;
krista@1427	738
roker@1559	739	char *ext = strrchr(blob->filename, '.');
vb@311	740	if (ext == NULL)
vb@311	741	return false;
vb@311	742
vb@320	743	if (strcmp(blob->mime_type, "application/octet-stream") == 0) {
vb@311	744	if (strcmp(ext, ".pgp") == 0 \|\| strcmp(ext, ".gpg") == 0 \|\|
vb@311	745	strcmp(ext, ".asc") == 0)
vb@311	746	return true;
vb@311	747	}
vb@320	748	else if (strcmp(blob->mime_type, "text/plain") == 0) {
vb@311	749	if (strcmp(ext, ".asc") == 0)
vb@311	750	return true;
vb@311	751	}
vb@311	752
vb@311	753	return false;
vb@311	754	}
vb@311	755
vb@311	756	static bool is_encrypted_html_attachment(const bloblist_t *blob)
vb@311	757	{
vb@311	758	assert(blob);
vb@311	759	assert(blob->filename);
krista@853	760	if (blob == NULL \|\| blob->filename == NULL)
krista@853	761	return false;
vb@311	762
vb@311	763	if (strncmp(blob->filename, "PGPexch.htm.", 12) == 0) {
vb@311	764	if (strcmp(blob->filename + 11, ".pgp") == 0 \|\|
vb@311	765	strcmp(blob->filename + 11, ".asc") == 0)
vb@311	766	return true;
vb@311	767	}
vb@311	768
vb@311	769	return false;
vb@311	770	}
vb@311	771
vb@311	772	static char * without_double_ending(const char *filename)
vb@311	773	{
vb@311	774	assert(filename);
krista@853	775	if (filename == NULL)
krista@853	776	return NULL;
krista@1427	777
roker@862	778	char *ext = strrchr(filename, '.');
vb@311	779	if (ext == NULL)
vb@311	780	return NULL;
vb@311	781
vb@469	782	char *result = strndup(filename, ext - filename);
vb@469	783	assert(result);
vb@469	784	return result;
vb@311	785	}
vb@311	786
vb@1004	787	static PEP_rating decrypt_rating(PEP_STATUS status)
vb@311	788	{
vb@311	789	switch (status) {
vb@311	790	case PEP_UNENCRYPTED:
vb@311	791	case PEP_VERIFIED:
vb@311	792	case PEP_VERIFY_NO_KEY:
vb@311	793	case PEP_VERIFIED_AND_TRUSTED:
vb@311	794	return PEP_rating_unencrypted;
vb@311	795
vb@311	796	case PEP_DECRYPTED:
vb@311	797	return PEP_rating_unreliable;
vb@311	798
vb@311	799	case PEP_DECRYPTED_AND_VERIFIED:
vb@311	800	return PEP_rating_reliable;
vb@311	801
vb@311	802	case PEP_DECRYPT_NO_KEY:
vb@311	803	return PEP_rating_have_no_key;
vb@311	804
vb@311	805	case PEP_DECRYPT_WRONG_FORMAT:
vb@311	806	case PEP_CANNOT_DECRYPT_UNKNOWN:
vb@311	807	return PEP_rating_cannot_decrypt;
vb@311	808
vb@311	809	default:
vb@311	810	return PEP_rating_undefined;
vb@311	811	}
vb@311	812	}
vb@311	813
vb@1004	814	static PEP_rating key_rating(PEP_SESSION session, const char *fpr)
vb@311	815	{
vb@311	816
vb@311	817	assert(session);
vb@311	818	assert(fpr);
krista@1427	819
krista@853	820	if (session == NULL \|\| fpr == NULL)
krista@853	821	return PEP_rating_undefined;
vb@311	822
edouard@1632	823
edouard@1632	824	PEP_comm_type bare_comm_type = PEP_ct_unknown;
krista@1615	825	PEP_STATUS status = get_key_rating(session, fpr, &bare_comm_type);
vb@311	826	if (status != PEP_STATUS_OK)
vb@311	827	return PEP_rating_undefined;
vb@311	828
krista@1615	829	PEP_comm_type least_trust_type = PEP_ct_unknown;
edouard@1632	830	least_trust(session, fpr, &least_trust_type);
edouard@1632	831
edouard@1632	832	if (least_trust_type == PEP_ct_unknown) {
edouard@1632	833	return _rating(bare_comm_type, PEP_rating_undefined);
edouard@1632	834	} else {
edouard@1632	835	return _rating(least_trust_type, PEP_rating_undefined);
edouard@1632	836	}
vb@311	837	}
vb@311	838
krista@1579	839	static PEP_rating worst_rating(PEP_rating rating1, PEP_rating rating2) {
krista@1579	840	return ((rating1 < rating2) ? rating1 : rating2);
krista@1579	841	}
krista@1579	842
vb@1004	843	static PEP_rating keylist_rating(PEP_SESSION session, stringlist_t *keylist)
vb@311	844	{
krista@1610	845	PEP_rating rating = PEP_rating_undefined;
vb@311	846
vb@311	847	assert(keylist && keylist->value);
vb@311	848	if (keylist == NULL \|\| keylist->value == NULL)
vb@486	849	return PEP_rating_undefined;
vb@311	850
vb@311	851	stringlist_t *_kl;
krista@1610	852	bool first = true;
vb@311	853	for (_kl = keylist; _kl && _kl->value; _kl = _kl->next) {
vb@311	854	PEP_comm_type ct;
vb@311	855	PEP_STATUS status;
vb@311	856
vb@1004	857	PEP_rating _rating_ = key_rating(session, _kl->value);
krista@1579	858
vb@1004	859	if (_rating_ <= PEP_rating_mistrust)
vb@1004	860	return _rating_;
krista@1610	861
krista@1610	862	if (first) {
krista@1610	863	rating = _rating_;
krista@1610	864	first = false;
krista@1610	865	}
krista@1610	866	else if (rating == PEP_rating_undefined)
krista@1579	867	rating = worst_rating(rating, _rating_);
vb@486	868
vb@1004	869	if (_rating_ >= PEP_rating_reliable) {
vb@311	870	status = least_trust(session, _kl->value, &ct);
vb@311	871	if (status != PEP_STATUS_OK)
vb@311	872	return PEP_rating_undefined;
edouard@1156	873	if (ct == PEP_ct_unknown){
krista@1615	874	/* per edouard, we reduce reliable+ ratings to reliable because
krista@1615	875	ct unknown */
edouard@1156	876	if (rating >= PEP_rating_reliable){
krista@1615	877	rating = PEP_rating_reliable;
edouard@1156	878	}
edouard@1156	879	}
edouard@1156	880	else{
krista@1579	881	rating = worst_rating(rating, _rating(ct, rating));
edouard@1156	882	}
vb@486	883	}
vb@1004	884	else if (_rating_ == PEP_rating_unencrypted) {
vb@1004	885	if (rating > PEP_rating_unencrypted_for_some)
krista@1579	886	rating = worst_rating(rating, PEP_rating_unencrypted_for_some);
vb@311	887	}
vb@311	888	}
vb@311	889
vb@1004	890	return rating;
vb@311	891	}
vb@311	892
vb@311	893	static PEP_comm_type _get_comm_type(
vb@311	894	PEP_SESSION session,
vb@311	895	PEP_comm_type max_comm_type,
vb@311	896	pEp_identity *ident
vb@311	897	)
vb@311	898	{
vb@311	899	PEP_STATUS status = update_identity(session, ident);
vb@311	900
vb@311	901	if (max_comm_type == PEP_ct_compromized)
vb@311	902	return PEP_ct_compromized;
krista@1427	903
Edouard@510	904	if (max_comm_type == PEP_ct_mistrusted)
Edouard@510	905	return PEP_ct_mistrusted;
vb@311	906
vb@311	907	if (status == PEP_STATUS_OK) {
vb@311	908	if (ident->comm_type == PEP_ct_compromized)
vb@311	909	return PEP_ct_compromized;
Edouard@510	910	else if (ident->comm_type == PEP_ct_mistrusted)
Edouard@510	911	return PEP_ct_mistrusted;
vb@311	912	else
vb@951	913	return _MIN(max_comm_type, ident->comm_type);
vb@311	914	}
vb@311	915	else {
vb@311	916	return PEP_ct_unknown;
vb@311	917	}
vb@311	918	}
vb@311	919
vb@731	920	static void free_bl_entry(bloblist_t *bl)
vb@731	921	{
vb@731	922	if (bl) {
vb@731	923	free(bl->value);
vb@731	924	free(bl->mime_type);
vb@731	925	free(bl->filename);
vb@731	926	free(bl);
vb@731	927	}
vb@731	928	}
vb@731	929
vb@731	930	static bool is_key(const bloblist_t *bl)
vb@731	931	{
Edouard@728	932	return (// workaround for Apple Mail bugs
Edouard@728	933	(is_mime_type(bl, "application/x-apple-msg-attachment") &&
Edouard@728	934	is_fileending(bl, ".asc")) \|\|
Edouard@728	935	// as binary, by file name
Edouard@728	936	((bl->mime_type == NULL \|\|
Edouard@728	937	is_mime_type(bl, "application/octet-stream")) &&
Edouard@728	938	(is_fileending(bl, ".pgp") \|\| is_fileending(bl, ".gpg") \|\|
Edouard@728	939	is_fileending(bl, ".key") \|\| is_fileending(bl, ".asc"))) \|\|
krista@1427	940	// explicit mime type
Edouard@728	941	is_mime_type(bl, "application/pgp-keys") \|\|
Edouard@728	942	// as text, by file name
Edouard@728	943	(is_mime_type(bl, "text/plain") &&
Edouard@728	944	(is_fileending(bl, ".pgp") \|\| is_fileending(bl, ".gpg") \|\|
Edouard@728	945	is_fileending(bl, ".key") \|\| is_fileending(bl, ".asc")))
Edouard@728	946	);
vb@731	947	}
vb@731	948
vb@731	949	static void remove_attached_keys(message *msg)
vb@731	950	{
vb@731	951	if (msg) {
vb@731	952	bloblist_t *last = NULL;
vb@731	953	for (bloblist_t *bl = msg->attachments; bl && bl->value; ) {
vb@731	954	bloblist_t *next = bl->next;
vb@731	955
vb@731	956	if (is_key(bl)) {
vb@731	957	if (last) {
vb@731	958	last->next = next;
vb@731	959	}
vb@731	960	else {
vb@731	961	msg->attachments = next;
vb@731	962	}
vb@731	963	free_bl_entry(bl);
vb@731	964	}
vb@731	965	else {
vb@731	966	last = bl;
vb@731	967	}
vb@731	968	bl = next;
vb@731	969	}
vb@731	970	}
vb@731	971	}
vb@731	972
Edouard@734	973	bool import_attached_keys(
krista@1427	974	PEP_SESSION session,
Edouard@728	975	const message *msg,
Edouard@728	976	identity_list **private_idents
Edouard@728	977	)
vb@311	978	{
vb@311	979	assert(session);
vb@311	980	assert(msg);
krista@1427	981
krista@853	982	if (session == NULL \|\| msg == NULL)
krista@853	983	return false;
vb@311	984
vb@731	985	bool remove = false;
vb@731	986
vb@908	987	int i = 0;
roker@1559	988	for (bloblist_t *bl = msg->attachments; i < MAX_KEYS_TO_IMPORT && bl && bl->value;
krista@1427	989	bl = bl->next, i++)
Edouard@747	990	{
vb@908	991	if (bl && bl->value && bl->size && bl->size < MAX_KEY_SIZE
krista@1427	992	&& is_key(bl))
Edouard@728	993	{
Edouard@728	994	import_key(session, bl->value, bl->size, private_idents);
vb@731	995	remove = true;
vb@311	996	}
vb@311	997	}
vb@731	998	return remove;
vb@311	999	}
vb@311	1000
Edouard@694	1001
Edouard@694	1002	PEP_STATUS _attach_key(PEP_SESSION session, const char* fpr, message *msg)
vb@311	1003	{
roker@1559	1004	char *keydata = NULL;
vb@311	1005	size_t size;
vb@311	1006
Edouard@694	1007	PEP_STATUS status = export_key(session, fpr, &keydata, &size);
Edouard@694	1008	assert(status == PEP_STATUS_OK);
Edouard@694	1009	if (status != PEP_STATUS_OK)
Edouard@694	1010	return status;
Edouard@694	1011	assert(size);
krista@1427	1012
roker@1559	1013	bloblist_t *bl = bloblist_add(msg->attachments, keydata, size, "application/pgp-keys",
Edouard@694	1014	"pEpkey.asc");
krista@1427	1015
Edouard@694	1016	if (msg->attachments == NULL && bl)
Edouard@694	1017	msg->attachments = bl;
Edouard@694	1018
Edouard@694	1019	return PEP_STATUS_OK;
Edouard@694	1020	}
Edouard@694	1021
Edouard@694	1022	#define ONE_WEEK (7243600)
Edouard@694	1023
Edouard@694	1024	void attach_own_key(PEP_SESSION session, message *msg)
Edouard@694	1025	{
vb@311	1026	assert(session);
vb@311	1027	assert(msg);
krista@1427	1028
Edouard@558	1029	if (msg->dir == PEP_dir_incoming)
Edouard@558	1030	return;
Edouard@558	1031
vb@311	1032	assert(msg->from && msg->from->fpr);
vb@311	1033	if (msg->from == NULL \|\| msg->from->fpr == NULL)
vb@311	1034	return;
vb@311	1035
Edouard@694	1036	if(_attach_key(session, msg->from->fpr, msg) != PEP_STATUS_OK)
vb@311	1037	return;
krista@1427	1038
Edouard@694	1039	char *revoked_fpr = NULL;
Edouard@694	1040	uint64_t revocation_date = 0;
krista@1427	1041
Edouard@694	1042	if(get_revoked(session, msg->from->fpr,
Edouard@694	1043	&revoked_fpr, &revocation_date) == PEP_STATUS_OK &&
Edouard@694	1044	revoked_fpr != NULL)
Edouard@694	1045	{
Edouard@694	1046	time_t now = time(NULL);
krista@1427	1047
Edouard@694	1048	if (now < (time_t)revocation_date + ONE_WEEK)
Edouard@694	1049	{
Edouard@694	1050	_attach_key(session, revoked_fpr, msg);
Edouard@694	1051	}
Edouard@694	1052	}
Edouard@694	1053	free(revoked_fpr);
vb@311	1054	}
vb@311	1055
vb@311	1056	PEP_cryptotech determine_encryption_format(message *msg)
vb@311	1057	{
vb@311	1058	assert(msg);
krista@1427	1059
vb@311	1060	if (is_PGP_message_text(msg->longmsg)) {
vb@311	1061	msg->enc_format = PEP_enc_pieces;
vb@311	1062	return PEP_crypt_OpenPGP;
vb@311	1063	}
vb@311	1064	else if (msg->attachments && msg->attachments->next &&
vb@311	1065	is_mime_type(msg->attachments, "application/pgp-encrypted") &&
vb@311	1066	is_PGP_message_text(msg->attachments->next->value)
vb@311	1067	) {
vb@311	1068	msg->enc_format = PEP_enc_PGP_MIME;
vb@311	1069	return PEP_crypt_OpenPGP;
vb@311	1070	}
edouard@1557	1071	else if (msg->attachments && msg->attachments->next &&
edouard@1557	1072	is_mime_type(msg->attachments->next, "application/pgp-encrypted") &&
edouard@1557	1073	is_PGP_message_text(msg->attachments->value)
edouard@1557	1074	) {
edouard@1557	1075	msg->enc_format = PEP_enc_PGP_MIME_Outlook1;
edouard@1557	1076	return PEP_crypt_OpenPGP;
edouard@1557	1077	}
vb@311	1078	else {
vb@311	1079	msg->enc_format = PEP_enc_none;
vb@311	1080	return PEP_crypt_none;
vb@311	1081	}
vb@311	1082	}
vb@311	1083
vb@48	1084	DYNAMIC_API PEP_STATUS encrypt_message(
vb@37	1085	PEP_SESSION session,
vb@113	1086	message *src,
vb@37	1087	stringlist_t * extra,
vb@38	1088	message **dst,
vb@939	1089	PEP_enc_format enc_format,
vb@939	1090	PEP_encrypt_flags_t flags
vb@37	1091	)
vb@37	1092	{
vb@37	1093	PEP_STATUS status = PEP_STATUS_OK;
vb@63	1094	message * msg = NULL;
vb@63	1095	stringlist_t * keys = NULL;
vb@37	1096
vb@37	1097	assert(session);
vb@37	1098	assert(src);
vb@37	1099	assert(dst);
Edouard@558	1100	assert(enc_format != PEP_enc_none);
vb@81	1101
Edouard@558	1102	if (!(session && src && dst && enc_format != PEP_enc_none))
vb@191	1103	return PEP_ILLEGAL_VALUE;
vb@191	1104
Edouard@550	1105	if (src->dir == PEP_dir_incoming)
Edouard@550	1106	return PEP_ILLEGAL_VALUE;
krista@1427	1107
vb@259	1108	determine_encryption_format(src);
vb@260	1109	if (src->enc_format != PEP_enc_none)
vb@260	1110	return PEP_ILLEGAL_VALUE;
vb@259	1111
vb@37	1112	*dst = NULL;
vb@67	1113
vb@236	1114	status = myself(session, src->from);
vb@236	1115	if (status != PEP_STATUS_OK)
vb@236	1116	goto pep_error;
Edouard@558	1117
vb@80	1118	keys = new_stringlist(src->from->fpr);
vb@63	1119	if (keys == NULL)
vb@63	1120	goto enomem;
vb@37	1121
vb@39	1122	stringlist_t *_k = keys;
vb@39	1123
vb@39	1124	if (extra) {
vb@39	1125	_k = stringlist_append(_k, extra);
vb@63	1126	if (_k == NULL)
vb@63	1127	goto enomem;
vb@37	1128	}
vb@39	1129
vb@299	1130	bool dest_keys_found = true;
Edouard@510	1131	PEP_comm_type max_comm_type = PEP_ct_pEp;
vb@299	1132
vb@37	1133	identity_list * _il;
krista@1427	1134
Edouard@545	1135	if ((_il = src->bcc) && _il->ident)
Edouard@545	1136	{
Edouard@545	1137	// BCC limited support:
Edouard@545	1138	// - App splits mails with BCC in multiple mails.
Edouard@545	1139	// - Each email is encrypted separately
krista@1427	1140
Edouard@789	1141	if(_il->next \|\| (src->to && src->to->ident) \|\| (src->cc && src->cc->ident))
Edouard@545	1142	{
Edouard@545	1143	// Only one Bcc with no other recipient allowed for now
Edouard@545	1144	return PEP_ILLEGAL_VALUE;
Edouard@545	1145	}
krista@1427	1146
vb@299	1147	PEP_STATUS _status = update_identity(session, _il->ident);
vb@299	1148	if (_status != PEP_STATUS_OK) {
vb@299	1149	status = _status;
vb@63	1150	goto pep_error;
vb@299	1151	}
krista@1427	1152
vb@299	1153	if (_il->ident->fpr && _il->ident->fpr[0]) {
vb@39	1154	_k = stringlist_add(_k, _il->ident->fpr);
vb@63	1155	if (_k == NULL)
vb@63	1156	goto enomem;
Edouard@510	1157	max_comm_type = _get_comm_type(session, max_comm_type,
Edouard@510	1158	_il->ident);
vb@37	1159	}
vb@299	1160	else {
vb@299	1161	dest_keys_found = false;
vb@37	1162	status = PEP_KEY_NOT_FOUND;
krista@1427	1163	}
vb@299	1164	}
Edouard@545	1165	else
Edouard@545	1166	{
Edouard@545	1167	for (_il = src->to; _il && _il->ident; _il = _il->next) {
Edouard@545	1168	PEP_STATUS _status = update_identity(session, _il->ident);
Edouard@545	1169	if (_status != PEP_STATUS_OK) {
Edouard@545	1170	status = _status;
Edouard@545	1171	goto pep_error;
Edouard@545	1172	}
vb@299	1173
Edouard@545	1174	if (_il->ident->fpr && _il->ident->fpr[0]) {
Edouard@545	1175	_k = stringlist_add(_k, _il->ident->fpr);
Edouard@545	1176	if (_k == NULL)
Edouard@545	1177	goto enomem;
Edouard@545	1178	max_comm_type = _get_comm_type(session, max_comm_type,
Edouard@545	1179	_il->ident);
Edouard@545	1180	}
Edouard@545	1181	else {
Edouard@545	1182	dest_keys_found = false;
Edouard@545	1183	status = PEP_KEY_NOT_FOUND;
Edouard@545	1184	}
vb@299	1185	}
vb@299	1186
Edouard@545	1187	for (_il = src->cc; _il && _il->ident; _il = _il->next) {
Edouard@545	1188	PEP_STATUS _status = update_identity(session, _il->ident);
Edouard@545	1189	if (_status != PEP_STATUS_OK)
Edouard@545	1190	{
Edouard@545	1191	status = _status;
Edouard@545	1192	goto pep_error;
Edouard@545	1193	}
Edouard@545	1194
Edouard@545	1195	if (_il->ident->fpr && _il->ident->fpr[0]) {
Edouard@545	1196	_k = stringlist_add(_k, _il->ident->fpr);
Edouard@545	1197	if (_k == NULL)
Edouard@545	1198	goto enomem;
Edouard@545	1199	max_comm_type = _get_comm_type(session, max_comm_type,
Edouard@545	1200	_il->ident);
Edouard@545	1201	}
Edouard@545	1202	else {
Edouard@545	1203	dest_keys_found = false;
Edouard@545	1204	status = PEP_KEY_NOT_FOUND;
Edouard@545	1205	}
vb@299	1206	}
vb@37	1207	}
krista@1427	1208
Edouard@510	1209	if (!dest_keys_found \|\|
krista@1640	1210	stringlist_length(keys) == 0 \|\|
Edouard@510	1211	_rating(max_comm_type,
Edouard@510	1212	PEP_rating_undefined) < PEP_rating_reliable)
Edouard@510	1213	{
vb@301	1214	free_stringlist(keys);
krista@1640	1215	if (!session->passive_mode && !(flags & PEP_encrypt_flag_force_no_attached_key))
vb@465	1216	attach_own_key(session, src);
vb@301	1217	return PEP_UNENCRYPTED;
vb@301	1218	}
vb@301	1219	else {
vb@299	1220	msg = clone_to_empty_message(src);
vb@299	1221	if (msg == NULL)
vb@299	1222	goto enomem;
vb@299	1223
krista@1640	1224	if (!(flags & PEP_encrypt_flag_force_no_attached_key))
krista@1640	1225	attach_own_key(session, src);
Edouard@428	1226
vb@81	1227	switch (enc_format) {
vb@260	1228	case PEP_enc_PGP_MIME:
vb@336	1229	case PEP_enc_PEP: // BUG: should be implemented extra
krista@1639	1230	status = encrypt_PGP_MIME(session, src, keys, msg, flags);
vb@260	1231	break;
vb@62	1232
vb@62	1233	case PEP_enc_pieces:
krista@1639	1234	status = encrypt_PGP_in_pieces(session, src, keys, msg, flags);
vb@38	1235	break;
vb@38	1236
vb@336	1237	/* case PEP_enc_PEP:
vb@81	1238	// TODO: implement
vb@336	1239	NOT_IMPLEMENTED */
vb@81	1240
vb@38	1241	default:
vb@38	1242	assert(0);
vb@63	1243	status = PEP_ILLEGAL_VALUE;
vb@63	1244	goto pep_error;
vb@37	1245	}
krista@1427	1246
Edouard@392	1247	if (status == PEP_OUT_OF_MEMORY)
Edouard@392	1248	goto enomem;
krista@1427	1249
vb@480	1250	if (status != PEP_STATUS_OK)
Edouard@392	1251	goto pep_error;
vb@37	1252	}
vb@37	1253
vb@37	1254	free_stringlist(keys);
vb@63	1255
vb@469	1256	if (msg && msg->shortmsg == NULL) {
vb@64	1257	msg->shortmsg = strdup("pEp");
vb@469	1258	assert(msg->shortmsg);
krista@853	1259	if (msg->shortmsg == NULL)
krista@853	1260	goto enomem;
vb@469	1261	}
vb@64	1262
edouard@1542	1263	if (msg) {
vb@311	1264	decorate_message(msg, PEP_rating_undefined, NULL);
edouard@1542	1265	if (src->id) {
edouard@1542	1266	msg->id = strdup(src->id);
edouard@1542	1267	assert(msg->id);
edouard@1542	1268	if (msg->id == NULL)
edouard@1542	1269	goto enomem;
edouard@1542	1270	}
edouard@1542	1271	}
vb@311	1272
vb@63	1273	*dst = msg;
vb@299	1274	return status;
vb@63	1275
vb@63	1276	enomem:
vb@63	1277	status = PEP_OUT_OF_MEMORY;
vb@63	1278
vb@63	1279	pep_error:
vb@63	1280	free_stringlist(keys);
vb@63	1281	free_message(msg);
vb@63	1282
vb@37	1283	return status;
vb@37	1284	}
vb@37	1285
krista@995	1286	DYNAMIC_API PEP_STATUS encrypt_message_for_self(
krista@992	1287	PEP_SESSION session,
krista@992	1288	pEp_identity* target_id,
krista@992	1289	message *src,
krista@992	1290	message **dst,
markus@1633	1291	PEP_enc_format enc_format,
markus@1633	1292	PEP_encrypt_flags_t flags
krista@992	1293	)
krista@992	1294	{
krista@992	1295	PEP_STATUS status = PEP_STATUS_OK;
krista@992	1296	message * msg = NULL;
krista@992	1297	stringlist_t * keys = NULL;
krista@992	1298
krista@992	1299	assert(session);
krista@992	1300	assert(src);
krista@992	1301	assert(dst);
krista@992	1302	assert(enc_format != PEP_enc_none);
krista@992	1303
krista@992	1304	if (!(session && src && dst && enc_format != PEP_enc_none))
krista@992	1305	return PEP_ILLEGAL_VALUE;
krista@992	1306
krista@992	1307	if (src->dir == PEP_dir_incoming)
krista@992	1308	return PEP_ILLEGAL_VALUE;
krista@1427	1309
krista@992	1310	determine_encryption_format(src);
krista@992	1311	if (src->enc_format != PEP_enc_none)
krista@992	1312	return PEP_ILLEGAL_VALUE;
krista@992	1313
krista@995	1314	status = myself(session, target_id);
krista@995	1315	if (status != PEP_STATUS_OK)
krista@995	1316	goto pep_error;
krista@995	1317
krista@992	1318	*dst = NULL;
krista@992	1319
krista@1427	1320
krista@992	1321	PEP_STATUS _status = update_identity(session, target_id);
krista@992	1322	if (_status != PEP_STATUS_OK) {
krista@992	1323	status = _status;
krista@992	1324	goto pep_error;
krista@992	1325	}
krista@992	1326
krista@994	1327	char* target_fpr = target_id->fpr;
krista@994	1328	if (!target_fpr)
krista@994	1329	return PEP_KEY_NOT_FOUND; // FIXME: Error condition
krista@1685	1330
krista@994	1331	keys = new_stringlist(target_fpr);
krista@1685	1332
krista@1640	1333	/* KG: did we ever do this??? */
krista@1640	1334	if (!(flags & PEP_encrypt_flag_force_no_attached_key))
krista@1685	1335	_attach_key(session, target_fpr, src);
krista@1427	1336
krista@992	1337	msg = clone_to_empty_message(src);
krista@992	1338	if (msg == NULL)
krista@992	1339	goto enomem;
krista@992	1340
krista@992	1341	switch (enc_format) {
krista@992	1342	case PEP_enc_PGP_MIME:
krista@992	1343	case PEP_enc_PEP: // BUG: should be implemented extra
krista@1639	1344	status = encrypt_PGP_MIME(session, src, keys, msg, flags);
krista@992	1345	break;
krista@992	1346
krista@992	1347	case PEP_enc_pieces:
krista@1639	1348	status = encrypt_PGP_in_pieces(session, src, keys, msg, flags);
krista@992	1349	break;
krista@992	1350
krista@992	1351	/* case PEP_enc_PEP:
krista@1641	1352	NOT_IMPLEMENTED */
krista@992	1353	// TODO: implement
krista@992	1354
krista@992	1355	default:
krista@992	1356	assert(0);
krista@992	1357	status = PEP_ILLEGAL_VALUE;
krista@992	1358	goto pep_error;
krista@992	1359	}
krista@1427	1360
krista@992	1361	if (status == PEP_OUT_OF_MEMORY)
krista@992	1362	goto enomem;
krista@1427	1363
krista@992	1364	if (status != PEP_STATUS_OK)
krista@992	1365	goto pep_error;
krista@992	1366
krista@994	1367	if (msg && msg->shortmsg == NULL) {
krista@994	1368	msg->shortmsg = strdup("pEp");
krista@994	1369	assert(msg->shortmsg);
krista@994	1370	if (msg->shortmsg == NULL)
krista@994	1371	goto enomem;
krista@994	1372	}
krista@992	1373
edouard@1542	1374	if (msg) {
edouard@1542	1375	if (src->id) {
edouard@1542	1376	msg->id = strdup(src->id);
edouard@1542	1377	assert(msg->id);
edouard@1542	1378	if (msg->id == NULL)
edouard@1542	1379	goto enomem;
edouard@1542	1380	}
edouard@1542	1381	}
edouard@1542	1382
krista@992	1383	*dst = msg;
krista@992	1384	return status;
krista@992	1385
krista@992	1386	enomem:
krista@992	1387	status = PEP_OUT_OF_MEMORY;
krista@992	1388
krista@992	1389	pep_error:
krista@992	1390	free_stringlist(keys);
krista@992	1391	free_message(msg);
krista@992	1392
krista@992	1393	return status;
krista@992	1394	}
krista@992	1395
vb@781	1396	static bool is_a_pEpmessage(const message *msg)
vb@781	1397	{
vb@781	1398	for (stringpair_list_t *i = msg->opt_fields; i && i->value ; i=i->next) {
vb@781	1399	if (strcasecmp(i->value->key, "X-pEp-Version") == 0)
vb@781	1400	return true;
vb@781	1401	}
vb@781	1402	return false;
vb@781	1403	}
vb@781	1404
vb@781	1405	// update comm_type to pEp_ct_pEp if needed
vb@781	1406
Edouard@858	1407	static PEP_STATUS _update_identity_for_incoming_message(
vb@781	1408	PEP_SESSION session,
vb@781	1409	const message *src
vb@781	1410	)
vb@781	1411	{
Edouard@858	1412	PEP_STATUS status;
Edouard@858	1413	if (src->from && src->from->address) {
Edouard@858	1414	status = update_identity(session, src->from);
krista@1192	1415	if (status == PEP_STATUS_OK
Edouard@858	1416	&& is_a_pEpmessage(src)
vb@781	1417	&& src->from->comm_type >= PEP_ct_OpenPGP_unconfirmed
vb@781	1418	&& src->from->comm_type != PEP_ct_pEp_unconfirmed
vb@781	1419	&& src->from->comm_type != PEP_ct_pEp)
vb@781	1420	{
vb@781	1421	src->from->comm_type \|= PEP_ct_pEp_unconfirmed;
Edouard@858	1422	status = update_identity(session, src->from);
vb@781	1423	}
Edouard@858	1424	return status;
vb@781	1425	}
Edouard@858	1426	return PEP_ILLEGAL_VALUE;
vb@781	1427	}
vb@781	1428
krista@1397	1429
krista@1397	1430	PEP_STATUS _get_detached_signature(message* msg, bloblist_t** signature_blob) {
krista@1397	1431	bloblist_t* attach_curr = msg->attachments;
krista@1427	1432
krista@1427	1433	*signature_blob = NULL;
krista@1427	1434
krista@1397	1435	while (attach_curr) {
krista@1427	1436	if (strcasecmp(attach_curr->mime_type, "application/pgp-signature") == 0) {
krista@1397	1437	*signature_blob = attach_curr;
krista@1397	1438	break;
krista@1397	1439	}
krista@1397	1440	attach_curr = attach_curr->next;
krista@1397	1441	}
krista@1427	1442
krista@1427	1443	return PEP_STATUS_OK;
krista@1427	1444	}
krista@1427	1445
krista@1427	1446	PEP_STATUS _get_signed_text(const char* ptext, const size_t psize,
krista@1427	1447	char** stext, size_t* ssize) {
krista@1427	1448
krista@1427	1449	char* signed_boundary = NULL;
krista@1427	1450	char* signpost = strstr(ptext, "Content-Type: multipart/signed");
krista@1427	1451
krista@1427	1452	*ssize = 0;
krista@1427	1453	*stext = NULL;
krista@1427	1454
krista@1427	1455	if (!signpost)
krista@1427	1456	return PEP_UNKNOWN_ERROR;
krista@1427	1457
krista@1427	1458	char* curr_line = signpost;
krista@1427	1459	// const char* end_text = ptext + psize;
krista@1427	1460	const char* boundary_key = "boundary=\"";
krista@1427	1461	const size_t BOUNDARY_KEY_SIZE = 10;
krista@1427	1462
krista@1427	1463	char* start_boundary = strstr(curr_line, boundary_key);
krista@1427	1464	if (!start_boundary)
krista@1427	1465	return PEP_UNKNOWN_ERROR;
krista@1427	1466
krista@1427	1467	start_boundary += BOUNDARY_KEY_SIZE;
krista@1427	1468
krista@1427	1469	char* end_boundary = strstr(start_boundary, "\"");
krista@1427	1470
krista@1427	1471	if (!end_boundary)
krista@1427	1472	return PEP_UNKNOWN_ERROR;
krista@1427	1473
krista@1427	1474	size_t boundary_strlen = (end_boundary - start_boundary) + 2;
krista@1427	1475
krista@1427	1476	signed_boundary = calloc(1, boundary_strlen + 1);
krista@1427	1477	strlcpy(signed_boundary, "--", boundary_strlen + 1);
krista@1427	1478	strlcat(signed_boundary, start_boundary, boundary_strlen + 1);
krista@1427	1479
krista@1427	1480	start_boundary = strstr(end_boundary, signed_boundary);
krista@1427	1481
krista@1427	1482	if (!start_boundary)
krista@1427	1483	return PEP_UNKNOWN_ERROR;
krista@1427	1484
krista@1427	1485	start_boundary += boundary_strlen;
krista@1427	1486
krista@1427	1487	while (*start_boundary == '\n')
krista@1427	1488	start_boundary++;
krista@1427	1489
krista@1427	1490	end_boundary = strstr(start_boundary + boundary_strlen, signed_boundary);
krista@1427	1491
krista@1427	1492	if (!end_boundary)
krista@1427	1493	return PEP_UNKNOWN_ERROR;
krista@1427	1494
krista@1427	1495	end_boundary--; // See RFC3156 section 5...
krista@1427	1496
krista@1427	1497	*ssize = end_boundary - start_boundary;
krista@1427	1498	*stext = start_boundary;
krista@1427	1499	free(signed_boundary);
krista@1427	1500
krista@1397	1501	return PEP_STATUS_OK;
krista@1397	1502	}
krista@1397	1503
krista@1484	1504	PEP_STATUS combine_keylists(PEP_SESSION session, stringlist_t** verify_in,
krista@1484	1505	stringlist_t** keylist_in_out,
krista@1484	1506	pEp_identity* from) {
krista@1484	1507
krista@1484	1508	if (!verify_in \|\| !(*verify_in)) // this isn't really a problem.
krista@1484	1509	return PEP_STATUS_OK;
krista@1484	1510
krista@1484	1511	stringlist_t* orig_verify = *verify_in;
krista@1484	1512
roker@1559	1513	stringlist_t* verify_curr = NULL;
roker@1559	1514	stringlist_t* from_keys = NULL;
krista@1484	1515
krista@1484	1516	/* FIXME: what to do if head needs to be null */
krista@1484	1517	PEP_STATUS status = find_keys(session, from->address, &from_keys);
krista@1484	1518
krista@1484	1519	stringlist_t* from_fpr_node = NULL;
krista@1484	1520	stringlist_t* from_curr;
krista@1484	1521
krista@1484	1522	for (from_curr = from_keys; from_curr; from_curr = from_curr->next) {
krista@1484	1523	for (verify_curr = orig_verify; verify_curr; verify_curr = verify_curr->next) {
krista@1484	1524	if (from_curr->value && verify_curr->value &&
edouard@1573	1525	_same_fpr(from_curr->value, strlen(from_curr->value),
edouard@1573	1526	verify_curr->value, strlen(verify_curr->value))) {
krista@1484	1527	from_fpr_node = from_curr;
krista@1484	1528	break;
krista@1484	1529	}
krista@1484	1530	}
krista@1484	1531	}
krista@1484	1532
krista@1484	1533	if (!from_fpr_node) {
krista@1484	1534	status = PEP_KEY_NOT_FOUND;
krista@1484	1535	goto free;
krista@1484	1536	}
krista@1484	1537
krista@1484	1538	verify_curr = orig_verify;
krista@1484	1539
krista@1484	1540	/* put "from" signer at the beginning of the list */
edouard@1573	1541	if (!_same_fpr(orig_verify->value, strlen(orig_verify->value),
edouard@1573	1542	from_fpr_node->value, strlen(from_fpr_node->value))) {
krista@1484	1543	orig_verify = stringlist_delete(orig_verify, from_fpr_node->value);
krista@1484	1544	verify_curr = new_stringlist(from_fpr_node->value);
krista@1484	1545	verify_curr->next = orig_verify;
krista@1484	1546	}
krista@1484	1547
krista@1484	1548	/* append keylist to signers */
krista@1484	1549	if (keylist_in_out && keylist_in_out && (keylist_in_out)->value) {
krista@1484	1550	stringlist_t** tail_pp = &verify_curr->next;
krista@1484	1551
krista@1484	1552	while (*tail_pp) {
krista@1484	1553	tail_pp = &((*tail_pp)->next);
krista@1484	1554	}
krista@1615	1555	stringlist_t* second_list = *keylist_in_out;
krista@1615	1556	if (second_list) {
krista@1615	1557	char* listhead_val = second_list->value;
krista@1615	1558	if (!listhead_val \|\| listhead_val[0] == '\0') {
krista@1615	1559	/* remove head, basically. This can happen when,
krista@1615	1560	for example, the signature is detached and
krista@1615	1561	verification is not seen directly after
krista@1615	1562	decryption, so no signer is presumed in
krista@1615	1563	the first construction of the keylist */
krista@1615	1564	keylist_in_out = (keylist_in_out)->next;
krista@1615	1565	second_list->next = NULL;
krista@1615	1566	free_stringlist(second_list);
krista@1615	1567	}
krista@1615	1568	}
krista@1484	1569	tail_pp = keylist_in_out;
krista@1484	1570	}
krista@1484	1571
krista@1484	1572	*keylist_in_out = verify_curr;
krista@1484	1573
krista@1484	1574	status = PEP_STATUS_OK;
krista@1484	1575
krista@1484	1576	free:
krista@1484	1577	free_stringlist(from_keys);
roker@1559	1578	return status;
krista@1484	1579	}
krista@1484	1580
krista@1484	1581
Edouard@741	1582	DYNAMIC_API PEP_STATUS _decrypt_message(
vb@37	1583	PEP_SESSION session,
vb@113	1584	message *src,
vb@241	1585	message **dst,
vb@251	1586	stringlist_t **keylist,
vb@1004	1587	PEP_rating *rating,
krista@1427	1588	PEP_decrypt_flags_t *flags,
Edouard@741	1589	identity_list **private_il
vb@37	1590	)
vb@37	1591	{
vb@37	1592	PEP_STATUS status = PEP_STATUS_OK;
vb@261	1593	PEP_STATUS decrypt_status = PEP_CANNOT_DECRYPT_UNKNOWN;
vb@73	1594	message *msg = NULL;
vb@112	1595	char *ctext;
vb@112	1596	size_t csize;
vb@269	1597	char *ptext = NULL;
vb@112	1598	size_t psize;
vb@241	1599	stringlist_t *_keylist = NULL;
vb@37	1600
vb@74	1601	assert(session);
vb@74	1602	assert(src);
vb@74	1603	assert(dst);
vb@241	1604	assert(keylist);
vb@1004	1605	assert(rating);
Edouard@739	1606	assert(flags);
vb@73	1607
vb@1004	1608	if (!(session && src && dst && keylist && rating && flags))
vb@191	1609	return PEP_ILLEGAL_VALUE;
vb@191	1610
Edouard@739	1611	*flags = 0;
Edouard@739	1612
Edouard@734	1613	// Private key in unencrypted mail are ignored -> NULL
Edouard@734	1614	bool imported_keys = import_attached_keys(session, src, NULL);
Edouard@728	1615
Edouard@728	1616	// Update src->from in case we just imported a key
Edouard@728	1617	// we would need to check signature
Edouard@858	1618	status = _update_identity_for_incoming_message(session, src);
Edouard@858	1619	if(status != PEP_STATUS_OK)
Edouard@858	1620	return status;
Edouard@858	1621
krista@1397	1622	// Get detached signature, if any
krista@1397	1623	bloblist_t* detached_sig = NULL;
krista@1397	1624	char* dsig_text = NULL;
krista@1397	1625	size_t dsig_size = 0;
krista@1397	1626	status = _get_detached_signature(src, &detached_sig);
krista@1397	1627	if (detached_sig) {
krista@1397	1628	dsig_text = detached_sig->value;
krista@1397	1629	dsig_size = detached_sig->size;
krista@1397	1630	}
krista@1427	1631
vb@259	1632	PEP_cryptotech crypto = determine_encryption_format(src);
vb@259	1633
vb@74	1634	*dst = NULL;
vb@251	1635	*keylist = NULL;
vb@1004	1636	*rating = PEP_rating_undefined;
krista@1427	1637
vb@261	1638	switch (src->enc_format) {
vb@269	1639	case PEP_enc_none:
vb@1004	1640	*rating = PEP_rating_unencrypted;
vb@731	1641	if (imported_keys)
vb@731	1642	remove_attached_keys(src);
edouard@1603	1643	if(session->sync_session->inject_sync_msg){
edouard@1165	1644	status = receive_DeviceState_msg(session, src, rating, keylist);
krista@1427	1645	if (status == PEP_MESSAGE_CONSUME \|\|
edouard@1369	1646	status == PEP_MESSAGE_IGNORE) {
vb@1134	1647	free_message(msg);
vb@1134	1648	msg = NULL;
edouard@1369	1649	*flags \|= (status == PEP_MESSAGE_IGNORE) ?
edouard@1369	1650	PEP_decrypt_flag_ignore :
edouard@1369	1651	PEP_decrypt_flag_consume;
vb@1134	1652	}
vb@1134	1653	else if (status != PEP_STATUS_OK) {
vb@1134	1654	return status;
vb@1134	1655	}
vb@1099	1656	}
krista@1484	1657
krista@1484	1658	char* slong = src->longmsg;
krista@1484	1659	char* sform = src->longmsg_formatted;
krista@1484	1660	bloblist_t* satt = src->attachments;
roker@1563	1661
krista@1484	1662	if ((!slong \|\| slong[0] == '\0')
krista@1484	1663	&& (!sform \|\| sform[0] == '\0')) {
krista@1484	1664	if (satt) {
krista@1484	1665	const char* inner_mime_type = satt->mime_type;
krista@1484	1666	if (strcasecmp(inner_mime_type, "text/plain") == 0) {
krista@1484	1667	free(slong); /* in case of "" */
roker@1563	1668	src->longmsg = strndup(satt->value, satt->size); // N.B.: longmsg might be shorter, if attachment contains NUL bytes which are not allowed in text/plain!
roker@1563	1669
krista@1484	1670	bloblist_t* next_node = satt->next;
krista@1484	1671	if (next_node) {
krista@1484	1672	inner_mime_type = next_node->mime_type;
krista@1484	1673	if (strcasecmp(inner_mime_type, "text/html") == 0) {
krista@1484	1674	free(sform);
roker@1563	1675	src->longmsg_formatted = strndup(next_node->value, next_node->size); // N.B.: longmsg might be shorter, if attachment contains NUL bytes which are not allowed in text/plain!
krista@1484	1676	}
krista@1484	1677	}
krista@1484	1678	}
krista@1484	1679	else if (strcasecmp(inner_mime_type, "text/html") == 0) {
krista@1484	1680	free(sform);
roker@1563	1681	src->longmsg_formatted = strndup(satt->value, satt->size); // N.B.: longmsg might be shorter, if attachment contains NUL bytes which are not allowed in text/plain!
roker@1563	1682	}
krista@1484	1683	}
roker@1563	1684	}
krista@1484	1685
vb@301	1686	return PEP_UNENCRYPTED;
vb@269	1687
vb@261	1688	case PEP_enc_PGP_MIME:
vb@301	1689	ctext = src->attachments->next->value;
vb@269	1690	csize = src->attachments->next->size;
vb@261	1691	break;
vb@261	1692
edouard@1557	1693	case PEP_enc_PGP_MIME_Outlook1:
edouard@1557	1694	ctext = src->attachments->value;
edouard@1557	1695	csize = src->attachments->size;
edouard@1557	1696	break;
edouard@1557	1697
vb@261	1698	case PEP_enc_pieces:
vb@261	1699	ctext = src->longmsg;
vb@261	1700	csize = strlen(ctext);
vb@261	1701	break;
vb@261	1702
vb@261	1703	default:
vb@261	1704	NOT_IMPLEMENTED
vb@259	1705	}
Edouard@431	1706	status = cryptotech[crypto].decrypt_and_verify(session, ctext,
krista@1427	1707	csize, dsig_text, dsig_size,
krista@1397	1708	&ptext, &psize, &_keylist);
edouard@1195	1709	if (status > PEP_CANNOT_DECRYPT_UNKNOWN){
edouard@1271	1710	goto pep_error;
edouard@1271	1711	}
edouard@1271	1712
edouard@1273	1713	decrypt_status = status;
edouard@1273	1714
edouard@1271	1715	if (status == PEP_DECRYPT_NO_KEY){
edouard@1299	1716	PEP_STATUS sync_status = inject_DeviceState_event(session, CannotDecrypt, NULL, NULL);
edouard@1299	1717	if (sync_status == PEP_OUT_OF_MEMORY){
edouard@1299	1718	status = PEP_OUT_OF_MEMORY;
edouard@1273	1719	goto pep_error;
edouard@1299	1720	}
edouard@1195	1721	}
vb@113	1722
krista@1427	1723	bool imported_private_key_address = false;
Edouard@728	1724
vb@256	1725	if (ptext) {
vb@256	1726	switch (src->enc_format) {
vb@256	1727	case PEP_enc_PGP_MIME:
edouard@1557	1728	case PEP_enc_PGP_MIME_Outlook1:
vb@269	1729	status = mime_decode_message(ptext, psize, &msg);
vb@113	1730	if (status != PEP_STATUS_OK)
roker@1563	1731	goto pep_error;
krista@1484	1732
krista@1484	1733	char* mlong = msg->longmsg;
krista@1484	1734	char* mform = msg->longmsg_formatted;
krista@1484	1735	bloblist_t* matt = msg->attachments;
roker@1563	1736
krista@1484	1737	if ((!mlong \|\| mlong[0] == '\0')
krista@1484	1738	&& (!mform \|\| mform[0] == '\0')) {
krista@1484	1739	if (matt) {
krista@1484	1740	const char* inner_mime_type = matt->mime_type;
krista@1484	1741	if (strcasecmp(inner_mime_type, "text/plain") == 0) {
krista@1484	1742	free(mlong); /* in case of "" */
roker@1563	1743	msg->longmsg = strndup(matt->value, matt->size);
roker@1563	1744
krista@1484	1745	bloblist_t* next_node = matt->next;
krista@1484	1746	if (next_node) {
krista@1484	1747	inner_mime_type = next_node->mime_type;
krista@1484	1748	if (strcasecmp(inner_mime_type, "text/html") == 0) {
krista@1484	1749	free(mform);
roker@1563	1750	msg->longmsg_formatted = strndup(next_node->value, next_node->size);
krista@1484	1751	}
krista@1484	1752	}
krista@1484	1753	}
krista@1484	1754	else if (strcasecmp(inner_mime_type, "text/html") == 0) {
krista@1484	1755	free(mform);
roker@1563	1756	msg->longmsg_formatted = strndup(matt->value, matt->size);
roker@1563	1757	}
krista@1484	1758	}
krista@1484	1759	if (msg->shortmsg) {
krista@1484	1760	free(src->shortmsg);
krista@1484	1761	src->shortmsg = strdup(msg->shortmsg);
krista@1484	1762	}
roker@1563	1763	}
krista@1484	1764
krista@1484	1765	if (decrypt_status != PEP_DECRYPTED_AND_VERIFIED) {
krista@1484	1766	status = _get_detached_signature(msg, &detached_sig);
krista@1484	1767	if (decrypt_status == PEP_DECRYPTED && detached_sig) {
krista@1484	1768	dsig_text = detached_sig->value;
krista@1484	1769	dsig_size = detached_sig->size;
krista@1484	1770	size_t ssize = 0;
krista@1484	1771	char* stext = NULL;
krista@1484	1772
krista@1484	1773	status = _get_signed_text(ptext, psize, &stext, &ssize);
krista@1484	1774	stringlist_t *_verify_keylist = NULL;
krista@1484	1775
krista@1484	1776	if (ssize > 0 && stext) {
krista@1484	1777	status = cryptotech[crypto].verify_text(session, stext,
krista@1484	1778	ssize, dsig_text, dsig_size,
krista@1484	1779	&_verify_keylist);
krista@1484	1780
krista@1484	1781	if (status == PEP_VERIFIED \|\| status == PEP_VERIFIED_AND_TRUSTED)
krista@1484	1782	decrypt_status = PEP_DECRYPTED_AND_VERIFIED;
krista@1484	1783
krista@1484	1784	status = combine_keylists(session, &_verify_keylist, &_keylist, src->from);
krista@1484	1785	}
krista@1427	1786	}
krista@1427	1787	}
vb@256	1788	break;
vb@256	1789
vb@256	1790	case PEP_enc_pieces:
vb@256	1791	msg = clone_to_empty_message(src);
vb@256	1792	if (msg == NULL)
vb@113	1793	goto enomem;
vb@113	1794
Edouard@882	1795	msg->longmsg = ptext;
Edouard@882	1796	ptext = NULL;
vb@256	1797
vb@256	1798	bloblist_t *_m = msg->attachments;
vb@320	1799	if (_m == NULL && src->attachments && src->attachments->value) {
vb@320	1800	msg->attachments = new_bloblist(NULL, 0, NULL, NULL);
vb@320	1801	_m = msg->attachments;
vb@320	1802	}
vb@320	1803
vb@256	1804	bloblist_t *_s;
Edouard@754	1805	for (_s = src->attachments; _s; _s = _s->next) {
Edouard@754	1806	if (_s->value == NULL && _s->size == 0){
Edouard@754	1807	_m = bloblist_add(_m, NULL, 0, _s->mime_type, _s->filename);
Edouard@754	1808	if (_m == NULL)
Edouard@754	1809	goto enomem;
Edouard@754	1810
Edouard@754	1811	}
Edouard@754	1812	else if (is_encrypted_attachment(_s)) {
vb@256	1813	stringlist_t *_keylist = NULL;
roker@862	1814	char *attctext = _s->value;
roker@862	1815	size_t attcsize = _s->size;
Edouard@431	1816
Edouard@842	1817	free(ptext);
Edouard@842	1818	ptext = NULL;
Edouard@842	1819
krista@1397	1820	// FIXME: What about attachments with separate sigs???
Edouard@431	1821	status = decrypt_and_verify(session, attctext, attcsize,
krista@1397	1822	NULL, 0,
krista@1397	1823	&ptext, &psize, &_keylist);
krista@1484	1824	free_stringlist(_keylist); // FIXME: Why do we do this?
vb@256	1825
vb@289	1826	if (ptext) {
vb@289	1827	if (is_encrypted_html_attachment(_s)) {
Edouard@882	1828	msg->longmsg_formatted = ptext;
Edouard@882	1829	ptext = NULL;
vb@289	1830	}
vb@289	1831	else {
roker@862	1832	static const char * const mime_type = "application/octet-stream";
roker@864	1833	char * const filename =
vb@289	1834	without_double_ending(_s->filename);
vb@289	1835	if (filename == NULL)
vb@289	1836	goto enomem;
vb@289	1837
Edouard@882	1838	_m = bloblist_add(_m, ptext, psize, mime_type,
vb@289	1839	filename);
roker@862	1840	free(filename);
vb@290	1841	if (_m == NULL)
vb@289	1842	goto enomem;
vb@290	1843
Edouard@882	1844	ptext = NULL;
Edouard@882	1845
vb@290	1846	if (msg->attachments == NULL)
vb@290	1847	msg->attachments = _m;
vb@289	1848	}
vb@256	1849	}
vb@256	1850	else {
vb@320	1851	char *copy = malloc(_s->size);
vb@350	1852	assert(copy);
vb@350	1853	if (copy == NULL)
vb@350	1854	goto enomem;
vb@320	1855	memcpy(copy, _s->value, _s->size);
vb@320	1856	_m = bloblist_add(_m, copy, _s->size, _s->mime_type, _s->filename);
vb@256	1857	if (_m == NULL)
vb@256	1858	goto enomem;
vb@256	1859	}
vb@256	1860	}
vb@320	1861	else {
vb@320	1862	char *copy = malloc(_s->size);
vb@350	1863	assert(copy);
vb@350	1864	if (copy == NULL)
vb@350	1865	goto enomem;
vb@320	1866	memcpy(copy, _s->value, _s->size);
vb@320	1867	_m = bloblist_add(_m, copy, _s->size, _s->mime_type, _s->filename);
vb@320	1868	if (_m == NULL)
vb@320	1869	goto enomem;
vb@320	1870	}
vb@256	1871	}
vb@256	1872
vb@256	1873	break;
vb@256	1874
vb@256	1875	default:
vb@256	1876	// BUG: must implement more
vb@256	1877	NOT_IMPLEMENTED
vb@256	1878	}
krista@1427	1879
vb@256	1880	switch (src->enc_format) {
vb@256	1881	case PEP_enc_PGP_MIME:
vb@256	1882	case PEP_enc_pieces:
edouard@1557	1883	case PEP_enc_PGP_MIME_Outlook1:
vb@256	1884	status = copy_fields(msg, src);
vb@256	1885	if (status != PEP_STATUS_OK)
vb@256	1886	goto pep_error;
vb@256	1887
vb@280	1888	if (src->shortmsg == NULL \|\| strcmp(src->shortmsg, "pEp") == 0)
vb@256	1889	{
vb@256	1890	char * shortmsg;
vb@256	1891	char * longmsg;
vb@256	1892
krista@853	1893	int r = separate_short_and_long(msg->longmsg, &shortmsg,
vb@256	1894	&longmsg);
vb@256	1895	if (r == -1)
vb@256	1896	goto enomem;
vb@256	1897
vb@256	1898	free(msg->shortmsg);
vb@256	1899	free(msg->longmsg);
vb@256	1900
vb@256	1901	msg->shortmsg = shortmsg;
vb@256	1902	msg->longmsg = longmsg;
vb@256	1903	}
vb@256	1904	else {
vb@256	1905	msg->shortmsg = strdup(src->shortmsg);
vb@469	1906	assert(msg->shortmsg);
vb@256	1907	if (msg->shortmsg == NULL)
vb@256	1908	goto enomem;
vb@256	1909	}
vb@256	1910	break;
vb@256	1911	default:
krista@1484	1912	// BUG: must implement more
krista@1484	1913	NOT_IMPLEMENTED
vb@256	1914	}
krista@1427	1915
Edouard@734	1916	// check for private key in decrypted message attachement while inporting
Edouard@741	1917	identity_list *_private_il = NULL;
Edouard@741	1918	imported_keys = import_attached_keys(session, msg, &_private_il);
krista@1427	1919	if (_private_il &&
Edouard@741	1920	identity_list_length(_private_il) == 1 &&
Edouard@741	1921	_private_il->ident->address)
Edouard@728	1922	{
Edouard@741	1923	imported_private_key_address = true;
Edouard@728	1924	}
Edouard@741	1925
Edouard@741	1926	if(private_il && imported_private_key_address){
Edouard@741	1927	*private_il = _private_il;
Edouard@741	1928	}else{
Edouard@741	1929	free_identity_list(_private_il);
Edouard@741	1930	}
krista@1427	1931
Edouard@694	1932	if(decrypt_status == PEP_DECRYPTED){
Edouard@728	1933
Edouard@728	1934	// TODO optimize if import_attached_keys didn't import any key
krista@1427	1935
Edouard@431	1936	// In case message did decrypt, but no valid signature could be found
Edouard@431	1937	// then retry decrypt+verify after importing key.
Edouard@728	1938
Edouard@728	1939	// Update msg->from in case we just imported a key
Edouard@728	1940	// we would need to check signature
vb@781	1941
Edouard@861	1942	status = _update_identity_for_incoming_message(session, src);
Edouard@858	1943	if(status != PEP_STATUS_OK)
Edouard@858	1944	goto pep_error;
krista@1427	1945
Edouard@431	1946	char *re_ptext = NULL;
Edouard@431	1947	size_t re_psize;
krista@1427	1948
Edouard@431	1949	free_stringlist(_keylist);
Edouard@431	1950	_keylist = NULL;
vb@256	1951
Edouard@431	1952	status = cryptotech[crypto].decrypt_and_verify(session, ctext,
krista@1397	1953	csize, dsig_text, dsig_size, &re_ptext, &re_psize, &_keylist);
krista@1427	1954
Edouard@882	1955	free(re_ptext);
krista@1427	1956
Edouard@431	1957	if (status > PEP_CANNOT_DECRYPT_UNKNOWN)
Edouard@431	1958	goto pep_error;
krista@1427	1959
Edouard@431	1960	decrypt_status = status;
Edouard@431	1961	}
krista@1427	1962
vb@1004	1963	*rating = decrypt_rating(decrypt_status);
krista@1427	1964
vb@1004	1965	if (*rating > PEP_rating_mistrust) {
vb@1004	1966	PEP_rating kl_rating = PEP_rating_undefined;
krista@1427	1967
Edouard@431	1968	if (_keylist)
vb@1004	1969	kl_rating = keylist_rating(session, _keylist);
krista@1427	1970
vb@1004	1971	if (kl_rating <= PEP_rating_mistrust) {
vb@1004	1972	*rating = kl_rating;
Edouard@445	1973	}
vb@1004	1974	else if (*rating >= PEP_rating_reliable &&
vb@1004	1975	kl_rating < PEP_rating_reliable) {
vb@1004	1976	*rating = PEP_rating_unreliable;
Edouard@431	1977	}
vb@1004	1978	else if (*rating >= PEP_rating_reliable &&
vb@1004	1979	kl_rating >= PEP_rating_reliable) {
Edouard@431	1980	if (!(src->from && src->from->user_id && src->from->user_id[0])) {
vb@1004	1981	*rating = PEP_rating_unreliable;
Edouard@431	1982	}
Edouard@431	1983	else {
Edouard@431	1984	char *fpr = _keylist->value;
Edouard@431	1985	pEp_identity *_from = new_identity(src->from->address, fpr,
Edouard@431	1986	src->from->user_id, src->from->username);
Edouard@431	1987	if (_from == NULL)
Edouard@431	1988	goto enomem;
edouard@1156	1989	status = get_trust(session, _from);
krista@1615	1990	if (_from->comm_type != PEP_ct_unknown) {
krista@1615	1991	*rating = worst_rating(_rating(_from->comm_type, PEP_rating_undefined),
krista@1615	1992	kl_rating);
krista@1615	1993	}
Edouard@431	1994	free_identity(_from);
edouard@1156	1995	if (status == PEP_CANNOT_FIND_IDENTITY)
edouard@1156	1996	status = PEP_STATUS_OK;
Edouard@431	1997	if (status != PEP_STATUS_OK)
Edouard@431	1998	goto pep_error;
Edouard@431	1999	}
Edouard@431	2000	}
Edouard@431	2001	}
vb@113	2002	}
Edouard@745	2003	else
Edouard@745	2004	{
vb@1004	2005	*rating = decrypt_rating(decrypt_status);
Edouard@745	2006	goto pep_error;
Edouard@745	2007	}
vb@731	2008
Edouard@728	2009	// Case of own key imported from own trusted message
krista@1427	2010	if (// Message have been reliably decrypted
Edouard@728	2011	msg &&
vb@1004	2012	*rating >= PEP_rating_trusted &&
Edouard@728	2013	imported_private_key_address &&
Edouard@728	2014	// to is [own]
Edouard@728	2015	msg->to->ident->user_id &&
krista@1427	2016	strcmp(msg->to->ident->user_id, PEP_OWN_USERID) == 0
Edouard@729	2017	)
Edouard@728	2018	{
Edouard@738	2019	*flags \|= PEP_decrypt_flag_own_private_key;
Edouard@728	2020	}
vb@113	2021
vb@731	2022	if (msg) {
vb@1004	2023	decorate_message(msg, *rating, _keylist);
vb@731	2024	if (imported_keys)
vb@731	2025	remove_attached_keys(msg);
edouard@1603	2026	if (*rating >= PEP_rating_reliable &&
edouard@1603	2027	session->sync_session->inject_sync_msg) {
edouard@1165	2028	status = receive_DeviceState_msg(session, msg, *rating, _keylist);
krista@1427	2029	if (status == PEP_MESSAGE_CONSUME \|\|
edouard@1369	2030	status == PEP_MESSAGE_IGNORE) {
vb@1099	2031	free_message(msg);
vb@1099	2032	msg = NULL;
edouard@1369	2033	*flags \|= (status == PEP_MESSAGE_IGNORE) ?
edouard@1369	2034	PEP_decrypt_flag_ignore :
edouard@1369	2035	PEP_decrypt_flag_consume;
edouard@1355	2036
edouard@1355	2037	status = decrypt_status;
vb@1099	2038	}
vb@1099	2039	else if (status != PEP_STATUS_OK){
vb@1099	2040	goto pep_error;
vb@1099	2041	}
vb@1099	2042	}
edouard@1558	2043	}
edouard@1558	2044	if (msg) {
edouard@1542	2045	if (src->id) {
edouard@1542	2046	msg->id = strdup(src->id);
edouard@1542	2047	assert(msg->id);
edouard@1542	2048	if (msg->id == NULL)
edouard@1542	2049	goto enomem;
edouard@1542	2050	}
vb@731	2051	}
vb@235	2052
vb@74	2053	*dst = msg;
vb@241	2054	*keylist = _keylist;
vb@241	2055
vb@953	2056	return status;
vb@73	2057
vb@73	2058	enomem:
vb@73	2059	status = PEP_OUT_OF_MEMORY;
vb@73	2060
vb@73	2061	pep_error:
Edouard@882	2062	free(ptext);
vb@73	2063	free_message(msg);
vb@241	2064	free_stringlist(_keylist);
vb@39	2065
vb@37	2066	return status;
vb@37	2067	}
vb@37	2068
Edouard@741	2069	DYNAMIC_API PEP_STATUS decrypt_message(
Edouard@741	2070	PEP_SESSION session,
Edouard@741	2071	message *src,
Edouard@741	2072	message **dst,
Edouard@741	2073	stringlist_t **keylist,
vb@1004	2074	PEP_rating *rating,
krista@1427	2075	PEP_decrypt_flags_t *flags
Edouard@741	2076	)
Edouard@741	2077	{
vb@1004	2078	return _decrypt_message( session, src, dst, keylist, rating, flags, NULL );
Edouard@741	2079	}
Edouard@741	2080
Edouard@728	2081	DYNAMIC_API PEP_STATUS own_message_private_key_details(
Edouard@728	2082	PEP_SESSION session,
Edouard@728	2083	message *msg,
krista@1427	2084	pEp_identity **ident
Edouard@728	2085	)
Edouard@728	2086	{
Edouard@728	2087	assert(session);
Edouard@728	2088	assert(msg);
Edouard@728	2089	assert(ident);
Edouard@728	2090
Edouard@736	2091	if (!(session && msg && ident))
Edouard@728	2092	return PEP_ILLEGAL_VALUE;
Edouard@728	2093
krista@1427	2094	message *dst = NULL;
krista@956	2095	stringlist_t *keylist = NULL;
vb@1004	2096	PEP_rating rating;
krista@1427	2097	PEP_decrypt_flags_t flags;
Edouard@728	2098
Edouard@729	2099	*ident = NULL;
Edouard@729	2100
Edouard@740	2101	identity_list *private_il = NULL;
vb@1004	2102	PEP_STATUS status = _decrypt_message(session, msg, &dst, &keylist, &rating, &flags, &private_il);
vb@953	2103	free_message(dst);
vb@953	2104	free_stringlist(keylist);
Edouard@728	2105
Edouard@729	2106	if (status == PEP_STATUS_OK &&
Edouard@741	2107	flags & PEP_decrypt_flag_own_private_key &&
Edouard@741	2108	private_il)
Edouard@729	2109	{
Edouard@740	2110	*ident = identity_dup(private_il->ident);
Edouard@729	2111	}
Edouard@729	2112
Edouard@741	2113	free_identity_list(private_il);
Edouard@741	2114
Edouard@728	2115	return status;
Edouard@741	2116
Edouard@728	2117	}
Edouard@728	2118
Edouard@858	2119	static void _max_comm_type_from_identity_list(
krista@1427	2120	identity_list *identities,
Edouard@858	2121	PEP_SESSION session,
Edouard@858	2122	PEP_comm_type *max_comm_type,
Edouard@858	2123	bool *comm_type_determined
Edouard@858	2124	)
Edouard@858	2125	{
Edouard@858	2126	identity_list * il;
Edouard@858	2127	for (il = identities; il != NULL; il = il->next)
Edouard@858	2128	{
Edouard@858	2129	if (il->ident)
Edouard@858	2130	{
edouard@1385	2131	PEP_STATUS status = update_identity(session, il->ident);
Edouard@858	2132	if (status == PEP_STATUS_OK)
Edouard@858	2133	{
Edouard@858	2134	max_comm_type = _get_comm_type(session, max_comm_type,
Edouard@858	2135	il->ident);
Edouard@858	2136	*comm_type_determined = true;
Edouard@858	2137	}
Edouard@858	2138	}
Edouard@858	2139	}
Edouard@858	2140	}
Edouard@858	2141
vb@1004	2142	DYNAMIC_API PEP_STATUS outgoing_message_rating(
vb@190	2143	PEP_SESSION session,
vb@190	2144	message *msg,
vb@1004	2145	PEP_rating *rating
vb@190	2146	)
vb@190	2147	{
vb@190	2148	PEP_comm_type max_comm_type = PEP_ct_pEp;
vb@190	2149	bool comm_type_determined = false;
vb@190	2150
vb@190	2151	assert(session);
vb@190	2152	assert(msg);
vb@251	2153	assert(msg->dir == PEP_dir_outgoing);
vb@1004	2154	assert(rating);
vb@190	2155
vb@1004	2156	if (!(session && msg && rating))
vb@191	2157	return PEP_ILLEGAL_VALUE;
vb@191	2158
vb@1360	2159	if (msg->dir != PEP_dir_outgoing)
vb@251	2160	return PEP_ILLEGAL_VALUE;
vb@251	2161
vb@1004	2162	*rating = PEP_rating_undefined;
vb@190	2163
Edouard@858	2164	_max_comm_type_from_identity_list(msg->to, session,
Edouard@858	2165	&max_comm_type, &comm_type_determined);
vb@190	2166
Edouard@858	2167	_max_comm_type_from_identity_list(msg->cc, session,
Edouard@858	2168	&max_comm_type, &comm_type_determined);
krista@1427	2169
Edouard@858	2170	_max_comm_type_from_identity_list(msg->bcc, session,
Edouard@858	2171	&max_comm_type, &comm_type_determined);
vb@190	2172
vb@190	2173	if (comm_type_determined == false)
vb@1004	2174	*rating = PEP_rating_undefined;
vb@190	2175	else
vb@1004	2176	*rating = _MAX(_rating(max_comm_type, PEP_rating_undefined),
vb@486	2177	PEP_rating_unencrypted);
vb@190	2178
vb@190	2179	return PEP_STATUS_OK;
vb@190	2180	}
vb@190	2181
vb@1004	2182	DYNAMIC_API PEP_STATUS identity_rating(
vb@239	2183	PEP_SESSION session,
vb@239	2184	pEp_identity *ident,
vb@1004	2185	PEP_rating *rating
vb@239	2186	)
vb@239	2187	{
vb@239	2188	PEP_STATUS status = PEP_STATUS_OK;
vb@239	2189
vb@239	2190	assert(session);
vb@239	2191	assert(ident);
vb@1004	2192	assert(rating);
vb@239	2193
vb@1004	2194	if (!(session && ident && rating))
vb@239	2195	return PEP_ILLEGAL_VALUE;
vb@239	2196
vb@239	2197	if (ident->me)
edouard@1406	2198	status = _myself(session, ident, false, true);
vb@239	2199	else
vb@239	2200	status = update_identity(session, ident);
vb@239	2201
vb@239	2202	if (status == PEP_STATUS_OK)
vb@1004	2203	*rating = _rating(ident->comm_type, PEP_rating_undefined);
vb@239	2204
vb@239	2205	return status;
vb@239	2206	}
vb@239	2207
vb@507	2208	DYNAMIC_API PEP_STATUS get_binary_path(PEP_cryptotech tech, const char **path)
vb@507	2209	{
vb@507	2210	PEP_STATUS status = PEP_STATUS_OK;
vb@507	2211
vb@507	2212	assert(path);
vb@507	2213	if (path == NULL)
vb@507	2214	return PEP_ILLEGAL_VALUE;
vb@507	2215
vb@507	2216	if (cryptotech[tech].binary_path == NULL)
vb@507	2217	*path = NULL;
vb@507	2218	else
vb@507	2219	status = cryptotech[tech].binary_path(path);
vb@507	2220
vb@507	2221	return status;
vb@507	2222	}
vb@507	2223
vb@1004	2224
vb@1004	2225	DYNAMIC_API PEP_color color_from_rating(PEP_rating rating)
vb@1004	2226	{
krista@1243	2227	if (rating == PEP_rating_b0rken \|\| rating == PEP_rating_have_no_key)
vb@1004	2228	return PEP_color_no_color;
vb@1004	2229
vb@1004	2230	if (rating < PEP_rating_undefined)
vb@1004	2231	return PEP_color_red;
vb@1004	2232
vb@1004	2233	if (rating < PEP_rating_reliable)
vb@1004	2234	return PEP_color_no_color;
vb@1004	2235
vb@1004	2236	if (rating < PEP_rating_trusted)
vb@1004	2237	return PEP_color_yellow;
vb@1004	2238
vb@1004	2239	if (rating >= PEP_rating_trusted)
vb@1004	2240	return PEP_color_green;
vb@1004	2241
vb@1004	2242	// this should never happen
vb@1004	2243	assert(false);
vb@1475	2244	return PEP_color_no_color;
vb@1004	2245	}
vb@1004	2246
krista@1315	2247	static bool _is_valid_hex(const char* hexstr) {
krista@1315	2248	if (!hexstr)
krista@1315	2249	return false;
krista@1427	2250
krista@1315	2251	const char* curr = hexstr;
krista@1315	2252	char currchar;
krista@1427	2253
krista@1315	2254	for (currchar = curr; currchar != '\0'; currchar = (++curr)) {
krista@1315	2255	if ((currchar >= '0' && currchar <= '9') \|\|
krista@1315	2256	(currchar >= 'a' && currchar <= 'f') \|\|
krista@1427	2257	(currchar >= 'A' && currchar <= 'F'))
krista@1315	2258	{
krista@1315	2259	continue;
krista@1315	2260	}
krista@1315	2261	return false;
krista@1315	2262	}
krista@1427	2263	return true;
krista@1315	2264	}
krista@1315	2265
krista@1312	2266	// Returns, in comparison: 1 if fpr1 > fpr2, 0 if equal, -1 if fpr1 < fpr2
krista@1312	2267	static PEP_STATUS _compare_fprs(const char* fpr1, const char* fpr2, int* comparison) {
krista@1427	2268
krista@1312	2269	const int _FULL_FINGERPRINT_LENGTH = 40;
krista@1312	2270	const int _ASCII_LOWERCASE_OFFSET = 32;
krista@1312	2271
krista@1312	2272	size_t fpr1_len = strlen(fpr1);
krista@1312	2273	size_t fpr2_len = strlen(fpr2);
krista@1427	2274
krista@1312	2275	if (fpr1_len != _FULL_FINGERPRINT_LENGTH \|\| fpr2_len != _FULL_FINGERPRINT_LENGTH)
krista@1312	2276	return PEP_TRUSTWORDS_FPR_WRONG_LENGTH;
krista@1427	2277
krista@1315	2278	if (!_is_valid_hex(fpr1) \|\| !_is_valid_hex(fpr2))
krista@1315	2279	return PEP_ILLEGAL_VALUE;
krista@1427	2280
krista@1312	2281	const char* fpr1_curr = fpr1;
krista@1312	2282	const char* fpr2_curr = fpr2;
krista@1427	2283
krista@1312	2284	char current;
krista@1312	2285
krista@1315	2286	// Advance past leading zeros.
krista@1313	2287	for (current = fpr1_curr; current != '0' && current != '\0'; current = (++fpr1_curr), fpr1_len--);
krista@1313	2288	for (current = fpr2_curr; current != '0' && current != '\0'; current = (++fpr2_curr), fpr2_len--);
krista@1427	2289
krista@1312	2290	if (fpr1_len == fpr2_len) {
krista@1312	2291	char digit1;
krista@1312	2292	char digit2;
krista@1312	2293
krista@1315	2294	while (fpr1_curr && *fpr1_curr != '\0') {
krista@1312	2295	digit1 = *fpr1_curr++;
krista@1312	2296	digit2 = *fpr2_curr++;
krista@1312	2297
krista@1312	2298	// Adjust for case-insensitive compare
krista@1312	2299	if (digit1 >= 'a' && digit1 <= 'f')
krista@1312	2300	digit1 -= _ASCII_LOWERCASE_OFFSET;
krista@1312	2301	if (digit2 >= 'a' && digit2 <= 'f')
krista@1312	2302	digit2 -= _ASCII_LOWERCASE_OFFSET;
krista@1427	2303
krista@1312	2304	// We take advantage of the fact that 'a'-'f' are larger
krista@1312	2305	// integer values in the ASCII table than '0'-'9'.
krista@1312	2306	// This allows us to compare digits directly.
krista@1312	2307	if (digit1 > digit2) {
krista@1312	2308	*comparison = 1;
krista@1312	2309	return PEP_STATUS_OK;
krista@1312	2310	} else if (digit1 < digit2) {
krista@1312	2311	*comparison = -1;
krista@1312	2312	return PEP_STATUS_OK;
krista@1312	2313	}
krista@1427	2314
krista@1312	2315	// pointers already advanced above. Keep going.
krista@1312	2316	}
krista@1312	2317	*comparison = 0;
krista@1312	2318	return PEP_STATUS_OK;
krista@1312	2319	}
krista@1312	2320	else if (fpr1_len > fpr2_len) {
krista@1312	2321	*comparison = 1;
krista@1312	2322	return PEP_STATUS_OK;
krista@1312	2323	}
krista@1312	2324	// Otherwise, fpr1_len < fpr2_len
krista@1312	2325	*comparison = -1;
krista@1312	2326	return PEP_STATUS_OK;
krista@1312	2327	}
krista@1312	2328
krista@1307	2329	DYNAMIC_API PEP_STATUS get_trustwords(
roker@1509	2330	PEP_SESSION session, const pEp_identity* id1, const pEp_identity* id2,
krista@1307	2331	const char* lang, char *words, size_t wsize, bool full
krista@1307	2332	)
krista@1307	2333	{
krista@1307	2334	assert(session);
krista@1307	2335	assert(id1);
krista@1307	2336	assert(id2);
krista@1307	2337	assert(id1->fpr);
krista@1307	2338	assert(id2->fpr);
krista@1307	2339	assert(words);
krista@1307	2340	assert(wsize);
krista@1427	2341
krista@1307	2342	if (!(session && id1 && id2 && words && wsize) \|\|
krista@1307	2343	!(id1->fpr) \|\| (!id2->fpr))
krista@1307	2344	return PEP_ILLEGAL_VALUE;
krista@1427	2345
krista@1307	2346	const char *source1 = id1->fpr;
krista@1307	2347	const char *source2 = id2->fpr;
krista@1427	2348
krista@1307	2349	*words = NULL;
krista@1307	2350	*wsize = 0;
krista@1307	2351
krista@1307	2352	const size_t SHORT_NUM_TWORDS = 5;
krista@1427	2353
krista@1307	2354	// N.B. THIS will have to be changed once we start checking trustword entropy.
krista@1307	2355	// For now, full is ALL, and otherwise it's 5-per-id.
krista@1307	2356	size_t max_words_per_id = (full ? 0 : SHORT_NUM_TWORDS);
krista@1427	2357
krista@1307	2358	char* first_set = NULL;
krista@1307	2359	char* second_set = NULL;
krista@1307	2360	size_t first_wsize = 0;
krista@1307	2361	size_t second_wsize = 0;
krista@1427	2362
krista@1312	2363	int fpr_comparison = -255;
krista@1312	2364	PEP_STATUS status = _compare_fprs(source1, source2, &fpr_comparison);
krista@1312	2365	if (status != PEP_STATUS_OK)
krista@1312	2366	return status;
krista@1312	2367
krista@1307	2368	char* _retstr = NULL;
krista@1312	2369
krista@1312	2370	switch (fpr_comparison) {
krista@1312	2371	case 1: // source1 > source2
krista@1312	2372	status = trustwords(session, source2, lang, &first_set, &first_wsize, max_words_per_id);
krista@1312	2373	if (status != PEP_STATUS_OK)
krista@1312	2374	goto error_release;
krista@1427	2375	status = trustwords(session, source1, lang, &second_set, &second_wsize, max_words_per_id);
krista@1312	2376	if (status != PEP_STATUS_OK)
krista@1312	2377	goto error_release;
krista@1312	2378	break;
krista@1427	2379	case 0:
krista@1312	2380	case -1: // source1 <= source2
krista@1312	2381	status = trustwords(session, source1, lang, &first_set, &first_wsize, max_words_per_id);
krista@1312	2382	if (status != PEP_STATUS_OK)
krista@1312	2383	goto error_release;
krista@1427	2384	status = trustwords(session, source2, lang, &second_set, &second_wsize, max_words_per_id);
krista@1312	2385	if (status != PEP_STATUS_OK)
krista@1312	2386	goto error_release;
krista@1315	2387	break;
krista@1312	2388	default:
krista@1312	2389	return PEP_UNKNOWN_ERROR; // shouldn't be possible
krista@1312	2390	}
krista@1427	2391
krista@1307	2392	size_t _wsize = first_wsize + second_wsize;
krista@1427	2393
krista@1315	2394	bool needs_space = (first_set[first_wsize - 1] != ' ');
krista@1427	2395
krista@1315	2396	if (needs_space)
krista@1315	2397	_wsize++;
krista@1427	2398
krista@1307	2399	_retstr = calloc(1, _wsize + 1);
krista@1427	2400
krista@1307	2401	size_t len = strlcpy(_retstr, first_set, _wsize);
krista@1307	2402	if (len >= _wsize) {
krista@1307	2403	status = PEP_UNKNOWN_ERROR;
krista@1307	2404	goto error_release;
krista@1307	2405	}
krista@1315	2406	if (needs_space) {
krista@1315	2407	strlcat(_retstr, " ", _wsize);
krista@1315	2408	if (len >= _wsize) {
krista@1315	2409	status = PEP_UNKNOWN_ERROR;
krista@1315	2410	goto error_release;
krista@1315	2411	}
krista@1315	2412	}
krista@1307	2413	strlcat(_retstr, second_set, _wsize);
krista@1307	2414	if (len >= _wsize){
krista@1307	2415	status = PEP_UNKNOWN_ERROR;
krista@1307	2416	goto error_release;
krista@1307	2417	}
krista@1427	2418
krista@1307	2419	*words = _retstr;
krista@1307	2420	*wsize = _wsize;
krista@1307	2421	status = PEP_STATUS_OK;
krista@1427	2422
krista@1307	2423	goto the_end;
krista@1427	2424
krista@1307	2425	error_release:
krista@1307	2426	free(_retstr);
krista@1427	2427
krista@1307	2428	the_end:
krista@1307	2429	free(first_set);
krista@1307	2430	free(second_set);
krista@1307	2431	return status;
vb@1309	2432	}
vb@1309	2433
edouard@1553	2434	DYNAMIC_API PEP_STATUS get_message_trustwords(
edouard@1553	2435	PEP_SESSION session,
edouard@1553	2436	message *msg,
edouard@1553	2437	stringlist_t *keylist,
edouard@1553	2438	pEp_identity* received_by,
edouard@1553	2439	const char* lang, char **words, bool full
edouard@1553	2440	)
edouard@1553	2441	{
edouard@1553	2442	assert(session);
edouard@1553	2443	assert(msg);
edouard@1553	2444	assert(received_by);
edouard@1553	2445	assert(received_by->address);
edouard@1553	2446	assert(lang);
edouard@1553	2447	assert(words);
edouard@1553	2448
edouard@1553	2449	if (!(session &&
edouard@1553	2450	msg &&
edouard@1553	2451	received_by &&
edouard@1553	2452	received_by->address &&
edouard@1553	2453	lang &&
edouard@1553	2454	words))
edouard@1553	2455	return PEP_ILLEGAL_VALUE;
edouard@1553	2456
edouard@1557	2457	pEp_identity* partner = NULL;
edouard@1553	2458
edouard@1553	2459	PEP_STATUS status = PEP_STATUS_OK;
edouard@1553	2460
edouard@1553	2461	*words = NULL;
edouard@1553	2462
edouard@1553	2463	// We want fingerprint of key that did sign the message
edouard@1553	2464
edouard@1553	2465	if (keylist == NULL) {
edouard@1553	2466
edouard@1553	2467	// Message is to be decrypted
roker@1554	2468	message *dst = NULL;
edouard@1553	2469	stringlist_t *_keylist = keylist;
edouard@1553	2470	PEP_rating rating;
edouard@1553	2471	PEP_decrypt_flags_t flags;
edouard@1553	2472	status = decrypt_message( session, msg, &dst, &_keylist, &rating, &flags);
edouard@1553	2473
edouard@1553	2474	if (status != PEP_STATUS_OK) {
edouard@1553	2475	free_message(dst);
edouard@1553	2476	free_stringlist(_keylist);
edouard@1553	2477	return status;
edouard@1553	2478	}
edouard@1553	2479
edouard@1553	2480	if (dst && dst->from && _keylist) {
edouard@1553	2481	partner = identity_dup(dst->from);
edouard@1553	2482	if(partner){
edouard@1553	2483	free(partner->fpr);
edouard@1553	2484	partner->fpr = strdup(_keylist->value);
edouard@1553	2485	if (partner->fpr == NULL)
edouard@1553	2486	status = PEP_OUT_OF_MEMORY;
edouard@1553	2487	} else {
edouard@1553	2488	status = PEP_OUT_OF_MEMORY;
edouard@1553	2489	}
edouard@1553	2490	} else {
edouard@1553	2491	status = PEP_UNKNOWN_ERROR;
edouard@1553	2492	}
edouard@1553	2493
edouard@1553	2494	free_message(dst);
edouard@1553	2495	free_stringlist(_keylist);
edouard@1553	2496
edouard@1553	2497	} else {
edouard@1553	2498
edouard@1553	2499	// Message already decrypted
edouard@1553	2500	if (keylist->value) {
edouard@1553	2501	partner = identity_dup(msg->from);
edouard@1553	2502	if(partner){
edouard@1553	2503	free(partner->fpr);
edouard@1553	2504	partner->fpr = strdup(keylist->value);
edouard@1553	2505	if (partner->fpr == NULL)
edouard@1553	2506	status = PEP_OUT_OF_MEMORY;
edouard@1553	2507	} else {
edouard@1553	2508	status = PEP_OUT_OF_MEMORY;
edouard@1553	2509	}
edouard@1553	2510	} else {
edouard@1553	2511	status = PEP_ILLEGAL_VALUE;
edouard@1553	2512	}
edouard@1553	2513	}
edouard@1553	2514
edouard@1553	2515	if (status != PEP_STATUS_OK) {
edouard@1553	2516	free_identity(partner);
edouard@1553	2517	return status;
edouard@1553	2518	}
edouard@1553	2519
edouard@1553	2520	// Find own identity corresponding to given account address.
edouard@1553	2521	// In that case we want default key attached to own identity
edouard@1553	2522	pEp_identity *stored_identity = NULL;
edouard@1553	2523	status = get_identity(session,
edouard@1553	2524	received_by->address,
edouard@1553	2525	PEP_OWN_USERID,
edouard@1553	2526	&stored_identity);
edouard@1553	2527
edouard@1553	2528	if (status != PEP_STATUS_OK) {
edouard@1553	2529	free_identity(stored_identity);
edouard@1553	2530	return status;
edouard@1553	2531	}
edouard@1553	2532
edouard@1553	2533	// get the trustwords
edouard@1553	2534	size_t wsize;
edouard@1553	2535	status = get_trustwords(session,
edouard@1553	2536	partner, received_by,
edouard@1553	2537	lang, words, &wsize, full);
edouard@1553	2538
edouard@1553	2539	return status;
edouard@1553	2540	}
krista@1325	2541
krista@1325	2542	DYNAMIC_API PEP_STATUS MIME_decrypt_message(
krista@1325	2543	PEP_SESSION session,
krista@1325	2544	const char *mimetext,
krista@1325	2545	size_t size,
krista@1325	2546	char** mime_plaintext,
krista@1325	2547	stringlist_t **keylist,
krista@1325	2548	PEP_rating *rating,
krista@1325	2549	PEP_decrypt_flags_t *flags
krista@1427	2550	)
krista@1325	2551	{
roker@1741	2552	assert(mimetext);
roker@1741	2553	assert(mime_plaintext);
roker@1741	2554	assert(keylist);
roker@1741	2555	assert(rating);
roker@1741	2556	assert(flags);
roker@1741	2557
krista@1325	2558	PEP_STATUS status = PEP_STATUS_OK;
krista@1325	2559	message* tmp_msg = NULL;
krista@1325	2560	message* dec_msg = NULL;
krista@1427	2561
krista@1325	2562	status = mime_decode_message(mimetext, size, &tmp_msg);
krista@1325	2563	if (status != PEP_STATUS_OK)
krista@1325	2564	goto pep_error;
krista@1427	2565
krista@1644	2566	PEP_STATUS decrypt_status = decrypt_message(session,
krista@1644	2567	tmp_msg,
krista@1644	2568	&dec_msg,
krista@1644	2569	keylist,
krista@1644	2570	rating,
krista@1644	2571	flags);
krista@1715	2572	if (decrypt_status > PEP_CANNOT_DECRYPT_UNKNOWN)
roker@1708	2573	{
roker@1708	2574	status = decrypt_status;
roker@1708	2575	goto pep_error;
roker@1708	2576	}
roker@1708	2577
roker@1741	2578	assert(dec_msg);
roker@1741	2579
krista@1325	2580	status = mime_encode_message(dec_msg, false, mime_plaintext);
krista@1427	2581
krista@1644	2582	if (status == PEP_STATUS_OK)
roker@1708	2583	{
roker@1708	2584	free(tmp_msg);
krista@1644	2585	return decrypt_status;
roker@1708	2586	}
roker@1708	2587
krista@1325	2588	pep_error:
krista@1325	2589	free_message(tmp_msg);
krista@1325	2590	free_message(dec_msg);
krista@1427	2591
krista@1325	2592	return status;
krista@1325	2593	}
krista@1325	2594
krista@1641	2595
krista@1325	2596	DYNAMIC_API PEP_STATUS MIME_encrypt_message(

author	Roker <roker@pep-project.org>
	Tue, 02 May 2017 08:48:35 +0200
branch	ENGINE-198
changeset 1741	5bd49bd73192
parent 1715	dcd33a52a194
child 1743	67f9eecd5535
permissions	-rw-r--r--