[proxmark3-svn] / client / emv / emv_pk.c

/*
 * libopenemv - a library to work with EMV family of smart cards
 * Copyright (C) 2012, 2015 Dmitry Eremin-Solenikov
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

/* For asprintf */
#define _GNU_SOURCE
#include <stdio.h>

#include "emv_pk.h"
#include "crypto.h"
#include "proxmark3.h"

#include <stdbool.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>

#define BCD(c) (((c) >= '0' && (c) <= '9') ? ((c) - '0') : \
		-1)

#define HEX(c) (((c) >= '0' && (c) <= '9') ? ((c) - '0') : \
		((c) >= 'A' && (c) <= 'F') ? ((c) - 'A' + 10) : \
		((c) >= 'a' && (c) <= 'f') ? ((c) - 'a' + 10) : \
		-1)

#define TOHEX(v) ((v) < 10 ? (v) + '0' : (v) - 10 + 'a')

static ssize_t emv_pk_read_bin(char *buf, unsigned char *bin, size_t size, size_t *read)
{
	size_t left = size;
	char *p = buf;
	while (*p && *p == ' ')
		p++;

	while (left > 0) {
		int c1, c2;
		c1 = HEX(*p);
		if (c1 == -1)
			return -(p - buf);
		p++;
		c2 = HEX(*p);
		if (c2 == -1)
			return -(p - buf);
		p++;
		*bin = (c1 * 16 + c2);
		bin ++;
		left --;
		if (*p == ':')
			p++;
		else if (read) {
			*read = (size - left);
			break;
		} else if (left == 0)
			break;
		else
			return -(p - buf);
	}

	while (*p && *p == ' ')
		p++;

	p--;

	return (p - buf);
}

static ssize_t emv_pk_read_ymv(char *buf, unsigned *ymv)
{
	int i;
	unsigned char temp[3];
	char *p = buf;

	*ymv = 0;

	while (*p && *p == ' ')
		p++;

	for (i = 0; i < 3; i++) {
		int c1, c2;
		c1 = BCD(*p);
		if (c1 == -1)
			return -(p - buf);
		p++;
		c2 = BCD(*p);
		if (c2 == -1)
			return -(p - buf);
		p++;
		temp[i] = (c1 * 16 + c2);
	}

	while (*p && *p == ' ')
		p++;

	p--;

	if (temp[1] > 0x12 || temp[2] > 0x31)
		return -(p - buf);

	*ymv = (temp[0] * 0x10000 + temp[1] * 0x100 + temp[2]);

	return (p - buf);
}

static ssize_t emv_pk_read_string(char *buf, char *str, size_t size)
{
	char *p = buf;
	while (*p && *p == ' ')
		p++;

	while (size > 1) {
		if (*p == ' ')
			break;
		else if (*p < 0x20 || *p >= 0x7f)
			return -(p - buf);
		*str = *p;
		p++;
		str ++;
		size --;
	}

	*str = 0;

	while (*p && *p == ' ')
		p++;

	p--;

	return (p - buf);
}


struct emv_pk *emv_pk_parse_pk(char *buf)
{
	struct emv_pk *r = calloc(1, sizeof(*r));
	ssize_t l;
	char temp[10];

	l = emv_pk_read_bin(buf, r->rid, 5, NULL);
	if (l <= 0)
		goto out;
	buf += l;

	l = emv_pk_read_bin(buf, &r->index, 1, NULL);
	if (l <= 0)
		goto out;
	buf += l;

	l = emv_pk_read_ymv(buf, &r->expire);
	if (l <= 0)
		goto out;
	buf += l;

	l = emv_pk_read_string(buf, temp, sizeof(temp));
	if (l <= 0)
		goto out;
	buf += l;

	if (!strcmp(temp, "rsa"))
		r->pk_algo = PK_RSA;
	else
		goto out;

	l = emv_pk_read_bin(buf, r->exp, sizeof(r->exp), &r->elen);
	if (l <= 0)
		goto out;
	buf += l;

	r->modulus = malloc(2048/8);
	l = emv_pk_read_bin(buf, r->modulus, 2048/8, &r->mlen);
	if (l <= 0)
		goto out2;
	buf += l;

	l = emv_pk_read_string(buf, temp, sizeof(temp));
	if (l <= 0)
		goto out2;
	buf += l;

	if (!strcmp(temp, "sha1"))
		r->hash_algo = HASH_SHA_1;
	else
		goto out2;

	l = emv_pk_read_bin(buf, r->hash, 20, NULL);
	if (l <= 0)
		goto out2;

	return r;

out2:
	free(r->modulus);
out:
	free(r);
	return NULL;
}

static size_t emv_pk_write_bin(char *out, size_t outlen, const unsigned char *buf, size_t len)
{
	int i;
	size_t pos = 0;

	if (len == 0)
		return 0;
	if (outlen < len * 3)
		return 0;

	out[pos++] = TOHEX(buf[0] >> 4);
	out[pos++] = TOHEX(buf[0] & 0xf);
	for (i = 1; i < len; i++) {
		out[pos++] = ':';
		out[pos++] = TOHEX(buf[i] >> 4);
		out[pos++] = TOHEX(buf[i] & 0xf);
	}
	out[pos++] = ' ';

	return pos;
}

static size_t emv_pk_write_str(char *out, size_t outlen, const char *str)
{
	size_t len = strlen(str);

	if (len == 0)
		return 0;
	if (outlen < len)
		return 0;

	memcpy(out, str, len);

	return len;
}

char *emv_pk_dump_pk(const struct emv_pk *pk)
{
	size_t outsize = 1024; /* should be enough */
	char *out = malloc(outsize); /* should be enough */
	size_t outpos = 0;
	size_t rc;

	if (!out)
		return NULL;

	rc = emv_pk_write_bin(out + outpos, outsize - outpos, pk->rid, 5);
	if (rc == 0)
		goto err;
	outpos += rc;

	rc = emv_pk_write_bin(out + outpos, outsize - outpos, &pk->index, 1);
	if (rc == 0)
		goto err;
	outpos += rc;

	if (outpos + 7 > outsize)
		goto err;
	out[outpos++] = TOHEX((pk->expire >> 20) & 0xf);
	out[outpos++] = TOHEX((pk->expire >> 16) & 0xf);
	out[outpos++] = TOHEX((pk->expire >> 12) & 0xf);
	out[outpos++] = TOHEX((pk->expire >> 8 ) & 0xf);
	out[outpos++] = TOHEX((pk->expire >> 4 ) & 0xf);
	out[outpos++] = TOHEX((pk->expire >> 0 ) & 0xf);
	out[outpos++] = ' ';

	if (pk->pk_algo == PK_RSA) {
		rc = emv_pk_write_str(out + outpos, outsize - outpos, "rsa");
		if (rc == 0)
			goto err;
		outpos += rc;
		out[outpos++] = ' ';
	} else {
		if (outpos + 4 > outsize)
			goto err;
		out[outpos++] = '?';
		out[outpos++] = '?';
		out[outpos++] = TOHEX(pk->pk_algo >> 4);
		out[outpos++] = TOHEX(pk->pk_algo & 0xf);
	}

	rc = emv_pk_write_bin(out + outpos, outsize - outpos, pk->exp, pk->elen);
	if (rc == 0)
		goto err;
	outpos += rc;

	rc = emv_pk_write_bin(out + outpos, outsize - outpos, pk->modulus, pk->mlen);
	if (rc == 0)
		goto err;
	outpos += rc;

	if (pk->hash_algo == HASH_SHA_1) {
		rc = emv_pk_write_str(out + outpos, outsize - outpos, "sha1");
		if (rc == 0)
			goto err;
		outpos += rc;
		out[outpos++] = ' ';
	} else {
		if (outpos + 4 > outsize)
			goto err;
		out[outpos++] = '?';
		out[outpos++] = '?';
		out[outpos++] = TOHEX(pk->pk_algo >> 4);
		out[outpos++] = TOHEX(pk->pk_algo & 0xf);
	}


	rc = emv_pk_write_bin(out + outpos, outsize - outpos, pk->hash, 20);
	if (rc == 0)
		goto err;
	outpos += rc;

	out[outpos-1] = '\0';

	return out;

err:
	free(out);
	return NULL;
}

bool emv_pk_verify(const struct emv_pk *pk)
{
	struct crypto_hash *ch = crypto_hash_open(pk->hash_algo);
	if (!ch)
		return false;

	crypto_hash_write(ch, pk->rid, sizeof(pk->rid));
	crypto_hash_write(ch, &pk->index, 1);
	crypto_hash_write(ch, pk->modulus, pk->mlen);
	crypto_hash_write(ch, pk->exp, pk->elen);

	unsigned char *h = crypto_hash_read(ch);
	if (!h) {
		crypto_hash_close(ch);
		return false;
	}

	size_t hsize = crypto_hash_get_size(ch);
	bool r = hsize && !memcmp(h, pk->hash, hsize) ? true : false;

	crypto_hash_close(ch);

	return r;
}

struct emv_pk *emv_pk_new(size_t modlen, size_t explen)
{
	struct emv_pk *pk;

	/* Not supported ATM */
	if (explen > 3)
		return NULL;

	pk = calloc(1, sizeof(*pk));
	if (!pk)
		return NULL;

	pk->mlen = modlen;
	pk->elen = explen;

	pk->modulus = calloc(modlen, 1);
	if (!pk->modulus) {
		free(pk);
		pk = NULL;
	}

	return pk;
}

void emv_pk_free(struct emv_pk *pk)
{
	if (!pk)
		return;

	free(pk->modulus);
	free(pk);
}

static struct emv_pk *emv_pk_get_ca_pk_from_file(const char *fname,
		const unsigned char *rid,
		unsigned char idx)
{
	if  (!fname)
		return NULL;

	FILE *f = fopen(fname, "r");
	if (!f) {
		perror("fopen");
		return NULL;
	}

	while (!feof(f)) {
		char buf[2048];
		if (fgets(buf, sizeof(buf), f) == NULL)
			break;

		struct emv_pk *pk = emv_pk_parse_pk(buf);
		if (!pk)
			continue;
		if (memcmp(pk->rid, rid, 5) || pk->index != idx) {
			emv_pk_free(pk);
			continue;
		}

		fclose(f);

		return pk;
	}

	fclose(f);

	return NULL;
}

char *emv_pk_get_ca_pk_file(const char *dirname, const unsigned char *rid, unsigned char idx)
{
	if (!dirname)
		dirname = ".";//openemv_config_get_str("capk.dir", NULL);

	if (!dirname)
		return NULL;

	char *filename;
	int ret = asprintf(&filename, "%s/%02hhx%02hhx%02hhx%02hhx%02hhx_%02hhx.0",
			dirname,
			rid[0],
			rid[1],
			rid[2],
			rid[3],
			rid[4],
			idx);

	if (ret <= 0)
		return NULL;

	return filename;
}

char *emv_pk_get_ca_pk_rid_file(const char *dirname, const unsigned char *rid)
{
	if (!dirname)
		dirname = "."; //openemv_config_get_str("capk.dir", NULL);

	if (!dirname)
		return NULL;

	char *filename;
	int ret = asprintf(&filename, "%s/%02hhx%02hhx%02hhx%02hhx%02hhx.pks",
			dirname,
			rid[0],
			rid[1],
			rid[2],
			rid[3],
			rid[4]);

	if (ret <= 0)
		return NULL;

	return filename;
}

struct emv_pk *emv_pk_get_ca_pk(const unsigned char *rid, unsigned char idx)
{
	struct emv_pk *pk = NULL;

/*	if (!pk) {
		char *fname = emv_pk_get_ca_pk_file(NULL, rid, idx);
		if (fname) {
			pk = emv_pk_get_ca_pk_from_file(fname, rid, idx);
			free(fname);
		}
	}

	if (!pk) {
		char *fname = emv_pk_get_ca_pk_rid_file(NULL, rid);
		if (fname) {
			pk = emv_pk_get_ca_pk_from_file(fname, rid, idx);
			free(fname);
		}
	}
*/
	if (!pk) {
		const char *relfname = "emv/capk.txt"; 

		char fname[strlen(get_my_executable_directory()) + strlen(relfname) + 1];
		strcpy(fname, get_my_executable_directory());
		strcat(fname, relfname);

		pk = emv_pk_get_ca_pk_from_file(fname, rid, idx);
	}
	if (!pk)
		return NULL;

	printf("Verifying CA PK for %02hhx:%02hhx:%02hhx:%02hhx:%02hhx IDX %02hhx %zd bits...",
				pk->rid[0],
				pk->rid[1],
				pk->rid[2],
				pk->rid[3],
				pk->rid[4],
				pk->index,
				pk->mlen * 8);
	if (emv_pk_verify(pk)) {
		printf("OK\n");

		return pk;
	}

	printf("Failed!\n");
	emv_pk_free(pk);

	return NULL;
}
Commit	Line	Data
d03fb293 OM	1	/*
	2	* libopenemv - a library to work with EMV family of smart cards
	3	* Copyright (C) 2012, 2015 Dmitry Eremin-Solenikov
	4	*
	5	* This library is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU Lesser General Public
	7	* License as published by the Free Software Foundation; either
	8	* version 2.1 of the License, or (at your option) any later version.
	9	*
	10	* This library is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	* Lesser General Public License for more details.
	14	*/
	15
	16	#ifdef HAVE_CONFIG_H
	17	#include <config.h>
	18	#endif
	19
	20	/* For asprintf */
	21	#define _GNU_SOURCE
	22	#include <stdio.h>
	23
	24	#include "emv_pk.h"
	25	#include "crypto.h"
	26	#include "proxmark3.h"
	27
	28	#include <stdbool.h>
	29	#include <string.h>
	30	#include <stdlib.h>
	31	#include <sys/types.h>
	32
	33	#define BCD(c) (((c) >= '0' && (c) <= '9') ? ((c) - '0') : \
	34	-1)
	35
	36	#define HEX(c) (((c) >= '0' && (c) <= '9') ? ((c) - '0') : \
	37	((c) >= 'A' && (c) <= 'F') ? ((c) - 'A' + 10) : \
	38	((c) >= 'a' && (c) <= 'f') ? ((c) - 'a' + 10) : \
	39	-1)
	40
	41	#define TOHEX(v) ((v) < 10 ? (v) + '0' : (v) - 10 + 'a')
	42
	43	static ssize_t emv_pk_read_bin(char buf, unsigned char bin, size_t size, size_t *read)
	44	{
	45	size_t left = size;
	46	char *p = buf;
	47	while (p && p == ' ')
	48	p++;
	49
	50	while (left > 0) {
	51	int c1, c2;
	52	c1 = HEX(*p);
	53	if (c1 == -1)
	54	return -(p - buf);
	55	p++;
	56	c2 = HEX(*p);
	57	if (c2 == -1)
	58	return -(p - buf);
	59	p++;
	60	bin = (c1 16 + c2);
	61	bin ++;
	62	left --;
	63	if (*p == ':')
	64	p++;
65	else if (read) {
66	*read = (size - left);
67	break;
68	} else if (left == 0)
69	break;
70	else
71	return -(p - buf);
72	}
73
74	while (p && p == ' ')
75	p++;
76
77	p--;
78
79	return (p - buf);
80	}
81
82	static ssize_t emv_pk_read_ymv(char buf, unsigned ymv)
83	{
84	int i;
85	unsigned char temp[3];
86	char *p = buf;
87
88	*ymv = 0;
89
90	while (p && p == ' ')
91	p++;
92
93	for (i = 0; i < 3; i++) {
94	int c1, c2;
95	c1 = BCD(*p);
96	if (c1 == -1)
97	return -(p - buf);
98	p++;
99	c2 = BCD(*p);
100	if (c2 == -1)
101	return -(p - buf);
102	p++;
103	temp[i] = (c1 * 16 + c2);
104	}
105
106	while (p && p == ' ')
107	p++;
108
109	p--;
110
111	if (temp[1] > 0x12 \|\| temp[2] > 0x31)
112	return -(p - buf);
113
114	ymv = (temp[0] 0x10000 + temp[1] * 0x100 + temp[2]);
115
116	return (p - buf);
117	}
118
119	static ssize_t emv_pk_read_string(char buf, char str, size_t size)
120	{
121	char *p = buf;
122	while (p && p == ' ')
123	p++;
124
125	while (size > 1) {
126	if (*p == ' ')
127	break;
128	else if (p < 0x20 \|\| p >= 0x7f)
129	return -(p - buf);
130	str = p;
131	p++;
132	str ++;
133	size --;
134	}
135
136	*str = 0;
137
138	while (p && p == ' ')
139	p++;
140
141	p--;
142
143	return (p - buf);
144	}
145
146
147	struct emv_pk emv_pk_parse_pk(char buf)
148	{
149	struct emv_pk r = calloc(1, sizeof(r));
150	ssize_t l;
151	char temp[10];
152
153	l = emv_pk_read_bin(buf, r->rid, 5, NULL);
154	if (l <= 0)
155	goto out;
156	buf += l;
157
158	l = emv_pk_read_bin(buf, &r->index, 1, NULL);
159	if (l <= 0)
160	goto out;
161	buf += l;
162
163	l = emv_pk_read_ymv(buf, &r->expire);
164	if (l <= 0)
165	goto out;
166	buf += l;
167
168	l = emv_pk_read_string(buf, temp, sizeof(temp));
169	if (l <= 0)
170	goto out;
171	buf += l;
172
173	if (!strcmp(temp, "rsa"))
174	r->pk_algo = PK_RSA;
175	else
176	goto out;
177
178	l = emv_pk_read_bin(buf, r->exp, sizeof(r->exp), &r->elen);
179	if (l <= 0)
180	goto out;
181	buf += l;
182
183	r->modulus = malloc(2048/8);
184	l = emv_pk_read_bin(buf, r->modulus, 2048/8, &r->mlen);
185	if (l <= 0)
186	goto out2;
187	buf += l;
188
189	l = emv_pk_read_string(buf, temp, sizeof(temp));
190	if (l <= 0)
191	goto out2;
192	buf += l;
193
194	if (!strcmp(temp, "sha1"))
195	r->hash_algo = HASH_SHA_1;
196	else
197	goto out2;
198
199	l = emv_pk_read_bin(buf, r->hash, 20, NULL);
200	if (l <= 0)
201	goto out2;
202
203	return r;
204
205	out2:
206	free(r->modulus);
207	out:
208	free(r);
209	return NULL;
210	}
211
212	static size_t emv_pk_write_bin(char out, size_t outlen, const unsigned char buf, size_t len)
213	{
214	int i;
215	size_t pos = 0;
216
217	if (len == 0)
218	return 0;
219	if (outlen < len * 3)
220	return 0;
221
222	out[pos++] = TOHEX(buf[0] >> 4);
223	out[pos++] = TOHEX(buf[0] & 0xf);
224	for (i = 1; i < len; i++) {
225	out[pos++] = ':';
226	out[pos++] = TOHEX(buf[i] >> 4);
227	out[pos++] = TOHEX(buf[i] & 0xf);
228	}
229	out[pos++] = ' ';
230
231	return pos;
232	}
233
234	static size_t emv_pk_write_str(char out, size_t outlen, const char str)
235	{
236	size_t len = strlen(str);
237
238	if (len == 0)
239	return 0;
240	if (outlen < len)
241	return 0;
242
243	memcpy(out, str, len);
244
245	return len;
246	}
247
248	char emv_pk_dump_pk(const struct emv_pk pk)
249	{
250	size_t outsize = 1024; /* should be enough */
251	char out = malloc(outsize); / should be enough */
252	size_t outpos = 0;
253	size_t rc;
254
255	if (!out)
256	return NULL;
257
258	rc = emv_pk_write_bin(out + outpos, outsize - outpos, pk->rid, 5);
259	if (rc == 0)
260	goto err;
261	outpos += rc;
262
263	rc = emv_pk_write_bin(out + outpos, outsize - outpos, &pk->index, 1);
264	if (rc == 0)
265	goto err;
266	outpos += rc;
267
268	if (outpos + 7 > outsize)
269	goto err;
270	out[outpos++] = TOHEX((pk->expire >> 20) & 0xf);
271	out[outpos++] = TOHEX((pk->expire >> 16) & 0xf);
272	out[outpos++] = TOHEX((pk->expire >> 12) & 0xf);
273	out[outpos++] = TOHEX((pk->expire >> 8 ) & 0xf);
274	out[outpos++] = TOHEX((pk->expire >> 4 ) & 0xf);
275	out[outpos++] = TOHEX((pk->expire >> 0 ) & 0xf);
276	out[outpos++] = ' ';
277
278	if (pk->pk_algo == PK_RSA) {
279	rc = emv_pk_write_str(out + outpos, outsize - outpos, "rsa");
280	if (rc == 0)
281	goto err;
282	outpos += rc;
283	out[outpos++] = ' ';
284	} else {
285	if (outpos + 4 > outsize)
286	goto err;
287	out[outpos++] = '?';
288	out[outpos++] = '?';
289	out[outpos++] = TOHEX(pk->pk_algo >> 4);
290	out[outpos++] = TOHEX(pk->pk_algo & 0xf);
291	}
292
293	rc = emv_pk_write_bin(out + outpos, outsize - outpos, pk->exp, pk->elen);
294	if (rc == 0)
295	goto err;
296	outpos += rc;
297
298	rc = emv_pk_write_bin(out + outpos, outsize - outpos, pk->modulus, pk->mlen);
299	if (rc == 0)
300	goto err;
301	outpos += rc;
302
303	if (pk->hash_algo == HASH_SHA_1) {
304	rc = emv_pk_write_str(out + outpos, outsize - outpos, "sha1");
305	if (rc == 0)
306	goto err;
307	outpos += rc;
308	out[outpos++] = ' ';
309	} else {
310	if (outpos + 4 > outsize)
311	goto err;
312	out[outpos++] = '?';
313	out[outpos++] = '?';
314	out[outpos++] = TOHEX(pk->pk_algo >> 4);
315	out[outpos++] = TOHEX(pk->pk_algo & 0xf);
316	}
317
318
319	rc = emv_pk_write_bin(out + outpos, outsize - outpos, pk->hash, 20);
320	if (rc == 0)
321	goto err;
322	outpos += rc;
323
324	out[outpos-1] = '\0';
325
326	return out;
327
328	err:
329	free(out);
330	return NULL;
331	}
332
333	bool emv_pk_verify(const struct emv_pk *pk)
334	{
335	struct crypto_hash *ch = crypto_hash_open(pk->hash_algo);
336	if (!ch)
337	return false;
338
339	crypto_hash_write(ch, pk->rid, sizeof(pk->rid));
340	crypto_hash_write(ch, &pk->index, 1);
341	crypto_hash_write(ch, pk->modulus, pk->mlen);
342	crypto_hash_write(ch, pk->exp, pk->elen);
343
344	unsigned char *h = crypto_hash_read(ch);
345	if (!h) {
346	crypto_hash_close(ch);
347	return false;
348	}
349
350	size_t hsize = crypto_hash_get_size(ch);
351	bool r = hsize && !memcmp(h, pk->hash, hsize) ? true : false;
352
353	crypto_hash_close(ch);
354
355	return r;
356	}
357
358	struct emv_pk *emv_pk_new(size_t modlen, size_t explen)
359	{
360	struct emv_pk *pk;
361
362	/* Not supported ATM */
363	if (explen > 3)
364	return NULL;
365
366	pk = calloc(1, sizeof(*pk));
367	if (!pk)
368	return NULL;
369
370	pk->mlen = modlen;
371	pk->elen = explen;
372
373	pk->modulus = calloc(modlen, 1);
374	if (!pk->modulus) {
375	free(pk);
376	pk = NULL;
377	}
378
379	return pk;
380	}
381
382	void emv_pk_free(struct emv_pk *pk)
383	{
384	if (!pk)
385	return;
386
387	free(pk->modulus);
388	free(pk);
389	}
390
391	static struct emv_pk emv_pk_get_ca_pk_from_file(const char fname,
392	const unsigned char *rid,
393	unsigned char idx)
394	{
395	if (!fname)
396	return NULL;
397
398	FILE *f = fopen(fname, "r");
399	if (!f) {
400	perror("fopen");
401	return NULL;
402	}
403
404	while (!feof(f)) {
405	char buf[2048];
406	if (fgets(buf, sizeof(buf), f) == NULL)
407	break;
408
409	struct emv_pk *pk = emv_pk_parse_pk(buf);
410	if (!pk)
411	continue;
412	if (memcmp(pk->rid, rid, 5) \|\| pk->index != idx) {
413	emv_pk_free(pk);
414	continue;
415	}
416
417	fclose(f);
418
419	return pk;
420	}
421
422	fclose(f);
423
424	return NULL;
425	}
426
427	char emv_pk_get_ca_pk_file(const char dirname, const unsigned char *rid, unsigned char idx)
428	{
429	if (!dirname)
430	dirname = ".";//openemv_config_get_str("capk.dir", NULL);
431
432	if (!dirname)
433	return NULL;
434
435	char *filename;
436	int ret = asprintf(&filename, "%s/%02hhx%02hhx%02hhx%02hhx%02hhx_%02hhx.0",
437	dirname,
438	rid[0],
439	rid[1],
440	rid[2],
441	rid[3],
442	rid[4],
443	idx);
444
445	if (ret <= 0)
446	return NULL;
447
448	return filename;
449	}
450
451	char emv_pk_get_ca_pk_rid_file(const char dirname, const unsigned char *rid)
452	{
453	if (!dirname)
454	dirname = "."; //openemv_config_get_str("capk.dir", NULL);
455
456	if (!dirname)
457	return NULL;
458
459	char *filename;
460	int ret = asprintf(&filename, "%s/%02hhx%02hhx%02hhx%02hhx%02hhx.pks",
461	dirname,
462	rid[0],
463	rid[1],
464	rid[2],
465	rid[3],
466	rid[4]);
467
468	if (ret <= 0)
469	return NULL;
470
471	return filename;
472	}
473
474	struct emv_pk emv_pk_get_ca_pk(const unsigned char rid, unsigned char idx)
475	{
476	struct emv_pk *pk = NULL;
477
478	/* if (!pk) {
479	char *fname = emv_pk_get_ca_pk_file(NULL, rid, idx);
480	if (fname) {
481	pk = emv_pk_get_ca_pk_from_file(fname, rid, idx);
482	free(fname);
483	}
484	}
485
486	if (!pk) {
487	char *fname = emv_pk_get_ca_pk_rid_file(NULL, rid);
488	if (fname) {
489	pk = emv_pk_get_ca_pk_from_file(fname, rid, idx);
490	free(fname);
491	}
492	}
493	*/
494	if (!pk) {
495	const char *relfname = "emv/capk.txt";
496
497	char fname[strlen(get_my_executable_directory()) + strlen(relfname) + 1];
498	strcpy(fname, get_my_executable_directory());
499	strcat(fname, relfname);
500
501	pk = emv_pk_get_ca_pk_from_file(fname, rid, idx);
502	}
503	if (!pk)
504	return NULL;
505
506	printf("Verifying CA PK for %02hhx:%02hhx:%02hhx:%02hhx:%02hhx IDX %02hhx %zd bits...",
507	pk->rid[0],
508	pk->rid[1],
509	pk->rid[2],
510	pk->rid[3],
511	pk->rid[4],
512	pk->index,
513	pk->mlen * 8);
514	if (emv_pk_verify(pk)) {
515	printf("OK\n");
516
517	return pk;
518	}
519
520	printf("Failed!\n");
521	emv_pk_free(pk);
522
523	return NULL;
524	}