[thirdparty/hostap.git] / src / tls / asn1_test.c

/*
 * Testing tool for ASN.1/X.509v3 routines
 * Copyright (c) 2006, Jouni Malinen <j@w1.fi>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * Alternatively, this software may be distributed under the terms of BSD
 * license.
 *
 * See README and COPYING for more details.
 */

#include "includes.h"

#include "common.h"
#include "asn1.h"
#include "x509v3.h"

extern int wpa_debug_level;


static const char * asn1_class_str(int class)
{
	switch (class) {
	case ASN1_CLASS_UNIVERSAL:
		return "Universal";
	case ASN1_CLASS_APPLICATION:
		return "Application";
	case ASN1_CLASS_CONTEXT_SPECIFIC:
		return "Context-specific";
	case ASN1_CLASS_PRIVATE:
		return "Private";
	default:
		return "?";
	}
}


int asn1_parse(const u8 *buf, size_t len, int level)
{
	const u8 *pos, *prev, *end;
	char prefix[10], str[100];
	int _level;
	struct asn1_hdr hdr;
	struct asn1_oid oid;
	u8 tmp;

	_level = level;
	if ((size_t) _level > sizeof(prefix) - 1)
		_level = sizeof(prefix) - 1;
	memset(prefix, ' ', _level);
	prefix[_level] = '\0';

	pos = buf;
	end = buf + len;

	while (pos < end) {
		if (asn1_get_next(pos, end - pos, &hdr) < 0)
			return -1;

		prev = pos;
		pos = hdr.payload;

		wpa_printf(MSG_MSGDUMP, "ASN.1:%s Class %d(%s) P/C %d(%s) "
			   "Tag %u Length %u",
			   prefix, hdr.class, asn1_class_str(hdr.class),
			   hdr.constructed,
			   hdr.constructed ? "Constructed" : "Primitive",
			   hdr.tag, hdr.length);

		if (hdr.class == ASN1_CLASS_CONTEXT_SPECIFIC &&
		    hdr.constructed) {
			if (asn1_parse(pos, hdr.length, level + 1) < 0)
				return -1;
			pos += hdr.length;
		}

		if (hdr.class != ASN1_CLASS_UNIVERSAL)
			continue;

		switch (hdr.tag) {
		case ASN1_TAG_EOC:
			if (hdr.length) {
				wpa_printf(MSG_DEBUG, "ASN.1: Non-zero "
					   "end-of-contents length (%u)",
					   hdr.length);
				return -1;
			}
			wpa_printf(MSG_MSGDUMP, "ASN.1:%s EOC", prefix);
			break;
		case ASN1_TAG_BOOLEAN:
			if (hdr.length != 1) {
				wpa_printf(MSG_DEBUG, "ASN.1: Unexpected "
					   "Boolean length (%u)", hdr.length);
				return -1;
			}
			tmp = *pos++;
			wpa_printf(MSG_MSGDUMP, "ASN.1:%s Boolean %s",
				   prefix, tmp ? "TRUE" : "FALSE");
			break;
		case ASN1_TAG_INTEGER:
			wpa_hexdump(MSG_MSGDUMP, "ASN.1: INTEGER",
				    pos, hdr.length);
			pos += hdr.length;
			break;
		case ASN1_TAG_BITSTRING:
			wpa_hexdump(MSG_MSGDUMP, "ASN.1: BitString",
				    pos, hdr.length);
			pos += hdr.length;
			break;
		case ASN1_TAG_OCTETSTRING:
			wpa_hexdump(MSG_MSGDUMP, "ASN.1: OctetString",
				    pos, hdr.length);
			pos += hdr.length;
			break;
		case ASN1_TAG_NULL:
			if (hdr.length) {
				wpa_printf(MSG_DEBUG, "ASN.1: Non-zero Null "
					   "length (%u)", hdr.length);
				return -1;
			}
			wpa_printf(MSG_MSGDUMP, "ASN.1:%s Null", prefix);
			break;
		case ASN1_TAG_OID:
			if (asn1_get_oid(prev, end - prev, &oid, &prev) < 0) {
				wpa_printf(MSG_DEBUG, "ASN.1: Invalid OID");
				return -1;
			}
			asn1_oid_to_str(&oid, str, sizeof(str));
			wpa_printf(MSG_DEBUG, "ASN.1:%s OID %s", prefix, str);
			pos += hdr.length;
			break;
		case ANS1_TAG_RELATIVE_OID:
			wpa_hexdump(MSG_MSGDUMP, "ASN.1: Relative OID",
				    pos, hdr.length);
			pos += hdr.length;
			break;
		case ASN1_TAG_SEQUENCE:
			wpa_printf(MSG_MSGDUMP, "ASN.1:%s SEQUENCE", prefix);
			if (asn1_parse(pos, hdr.length, level + 1) < 0)
				return -1;
			pos += hdr.length;
			break;
		case ASN1_TAG_SET:
			wpa_printf(MSG_MSGDUMP, "ASN.1:%s SET", prefix);
			if (asn1_parse(pos, hdr.length, level + 1) < 0)
				return -1;
			pos += hdr.length;
			break;
		case ASN1_TAG_PRINTABLESTRING:
			wpa_hexdump_ascii(MSG_MSGDUMP,
					  "ASN.1: PrintableString",
					  pos, hdr.length);
			pos += hdr.length;
			break;
		case ASN1_TAG_IA5STRING:
			wpa_hexdump_ascii(MSG_MSGDUMP, "ASN.1: IA5String",
					  pos, hdr.length);
			pos += hdr.length;
			break;
		case ASN1_TAG_UTCTIME:
			wpa_hexdump_ascii(MSG_MSGDUMP, "ASN.1: UTCTIME",
					  pos, hdr.length);
			pos += hdr.length;
			break;
		case ASN1_TAG_VISIBLESTRING:
			wpa_hexdump_ascii(MSG_MSGDUMP, "ASN.1: VisibleString",
					  pos, hdr.length);
			pos += hdr.length;
			break;
		default:
			wpa_printf(MSG_DEBUG, "ASN.1: Unknown tag %d",
				   hdr.tag);
			return -1;
		}
	}

	return 0;
}


int main(int argc, char *argv[])
{
	FILE *f;
	u8 buf[3000];
	size_t len;
	struct x509_certificate *cert;

	wpa_debug_level = 0;

	f = fopen(argv[1], "rb");
	if (f == NULL)
		return -1;
	len = fread(buf, 1, sizeof(buf), f);
	fclose(f);

	if (asn1_parse(buf, len, 0) < 0)
		printf("Failed to parse DER ASN.1\n");

	printf("\n\n");

	cert = x509_certificate_parse(buf, len);
	if (cert == NULL)
		printf("Failed to parse X.509 certificate\n");
	x509_certificate_free(cert);

	return 0;
}
Commit	Line	Data
6fc6879b JM	1	/*
	2	* Testing tool for ASN.1/X.509v3 routines
	3	* Copyright (c) 2006, Jouni Malinen <j@w1.fi>
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License version 2 as
	7	* published by the Free Software Foundation.
	8	*
	9	* Alternatively, this software may be distributed under the terms of BSD
	10	* license.
	11	*
	12	* See README and COPYING for more details.
	13	*/
	14
	15	#include "includes.h"
	16
	17	#include "common.h"
	18	#include "asn1.h"
	19	#include "x509v3.h"
	20
	21	extern int wpa_debug_level;
	22
	23
	24	static const char * asn1_class_str(int class)
	25	{
	26	switch (class) {
	27	case ASN1_CLASS_UNIVERSAL:
	28	return "Universal";
	29	case ASN1_CLASS_APPLICATION:
	30	return "Application";
	31	case ASN1_CLASS_CONTEXT_SPECIFIC:
	32	return "Context-specific";
	33	case ASN1_CLASS_PRIVATE:
	34	return "Private";
	35	default:
	36	return "?";
	37	}
	38	}
	39
	40
	41	int asn1_parse(const u8 *buf, size_t len, int level)
	42	{
	43	const u8 pos, prev, *end;
	44	char prefix[10], str[100];
	45	int _level;
	46	struct asn1_hdr hdr;
	47	struct asn1_oid oid;
	48	u8 tmp;
	49
	50	_level = level;
	51	if ((size_t) _level > sizeof(prefix) - 1)
	52	_level = sizeof(prefix) - 1;
	53	memset(prefix, ' ', _level);
	54	prefix[_level] = '\0';
	55
	56	pos = buf;
	57	end = buf + len;
	58
	59	while (pos < end) {
	60	if (asn1_get_next(pos, end - pos, &hdr) < 0)
	61	return -1;
	62
	63	prev = pos;
	64	pos = hdr.payload;
65
66	wpa_printf(MSG_MSGDUMP, "ASN.1:%s Class %d(%s) P/C %d(%s) "
67	"Tag %u Length %u",
68	prefix, hdr.class, asn1_class_str(hdr.class),
69	hdr.constructed,
70	hdr.constructed ? "Constructed" : "Primitive",
71	hdr.tag, hdr.length);
72
73	if (hdr.class == ASN1_CLASS_CONTEXT_SPECIFIC &&
74	hdr.constructed) {
75	if (asn1_parse(pos, hdr.length, level + 1) < 0)
76	return -1;
77	pos += hdr.length;
78	}
79
80	if (hdr.class != ASN1_CLASS_UNIVERSAL)
81	continue;
82
83	switch (hdr.tag) {
84	case ASN1_TAG_EOC:
85	if (hdr.length) {
86	wpa_printf(MSG_DEBUG, "ASN.1: Non-zero "
87	"end-of-contents length (%u)",
88	hdr.length);
89	return -1;
90	}
91	wpa_printf(MSG_MSGDUMP, "ASN.1:%s EOC", prefix);
92	break;
93	case ASN1_TAG_BOOLEAN:
94	if (hdr.length != 1) {
95	wpa_printf(MSG_DEBUG, "ASN.1: Unexpected "
96	"Boolean length (%u)", hdr.length);
97	return -1;
98	}
99	tmp = *pos++;
100	wpa_printf(MSG_MSGDUMP, "ASN.1:%s Boolean %s",
101	prefix, tmp ? "TRUE" : "FALSE");
102	break;
103	case ASN1_TAG_INTEGER:
104	wpa_hexdump(MSG_MSGDUMP, "ASN.1: INTEGER",
105	pos, hdr.length);
106	pos += hdr.length;
107	break;
108	case ASN1_TAG_BITSTRING:
109	wpa_hexdump(MSG_MSGDUMP, "ASN.1: BitString",
110	pos, hdr.length);
111	pos += hdr.length;
112	break;
113	case ASN1_TAG_OCTETSTRING:
114	wpa_hexdump(MSG_MSGDUMP, "ASN.1: OctetString",
115	pos, hdr.length);
116	pos += hdr.length;
117	break;
118	case ASN1_TAG_NULL:
119	if (hdr.length) {
120	wpa_printf(MSG_DEBUG, "ASN.1: Non-zero Null "
121	"length (%u)", hdr.length);
122	return -1;
123	}
124	wpa_printf(MSG_MSGDUMP, "ASN.1:%s Null", prefix);
125	break;
126	case ASN1_TAG_OID:
127	if (asn1_get_oid(prev, end - prev, &oid, &prev) < 0) {
128	wpa_printf(MSG_DEBUG, "ASN.1: Invalid OID");
129	return -1;
130	}
131	asn1_oid_to_str(&oid, str, sizeof(str));
132	wpa_printf(MSG_DEBUG, "ASN.1:%s OID %s", prefix, str);
133	pos += hdr.length;
134	break;
135	case ANS1_TAG_RELATIVE_OID:
136	wpa_hexdump(MSG_MSGDUMP, "ASN.1: Relative OID",
137	pos, hdr.length);
138	pos += hdr.length;
139	break;
140	case ASN1_TAG_SEQUENCE:
141	wpa_printf(MSG_MSGDUMP, "ASN.1:%s SEQUENCE", prefix);
142	if (asn1_parse(pos, hdr.length, level + 1) < 0)
143	return -1;
144	pos += hdr.length;
145	break;
146	case ASN1_TAG_SET:
147	wpa_printf(MSG_MSGDUMP, "ASN.1:%s SET", prefix);
148	if (asn1_parse(pos, hdr.length, level + 1) < 0)
149	return -1;
150	pos += hdr.length;
151	break;
152	case ASN1_TAG_PRINTABLESTRING:
153	wpa_hexdump_ascii(MSG_MSGDUMP,
154	"ASN.1: PrintableString",
155	pos, hdr.length);
156	pos += hdr.length;
157	break;
158	case ASN1_TAG_IA5STRING:
159	wpa_hexdump_ascii(MSG_MSGDUMP, "ASN.1: IA5String",
160	pos, hdr.length);
161	pos += hdr.length;
162	break;
163	case ASN1_TAG_UTCTIME:
164	wpa_hexdump_ascii(MSG_MSGDUMP, "ASN.1: UTCTIME",
165	pos, hdr.length);
166	pos += hdr.length;
167	break;
168	case ASN1_TAG_VISIBLESTRING:
169	wpa_hexdump_ascii(MSG_MSGDUMP, "ASN.1: VisibleString",
170	pos, hdr.length);
171	pos += hdr.length;
172	break;
173	default:
174	wpa_printf(MSG_DEBUG, "ASN.1: Unknown tag %d",
175	hdr.tag);
176	return -1;
177	}
178	}
179
180	return 0;
181	}
182
183
184	int main(int argc, char *argv[])
185	{
186	FILE *f;
187	u8 buf[3000];
188	size_t len;
189	struct x509_certificate *cert;
190
191	wpa_debug_level = 0;
192
193	f = fopen(argv[1], "rb");
194	if (f == NULL)
195	return -1;
196	len = fread(buf, 1, sizeof(buf), f);
197	fclose(f);
198
199	if (asn1_parse(buf, len, 0) < 0)
200	printf("Failed to parse DER ASN.1\n");
201
202	printf("\n\n");
203
204	cert = x509_certificate_parse(buf, len);
205	if (cert == NULL)
206	printf("Failed to parse X.509 certificate\n");
207	x509_certificate_free(cert);
208
209	return 0;
210	}