8 * Copyright (C) 2005 Jan Hutter, Martin Willi
9 * Hochschule fuer Technik Rapperswil
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by the
13 * Free Software Foundation; either version 2 of the License, or (at your
14 * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
16 * This program is distributed in the hope that it will be useful, but
17 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
18 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
24 #include "parser_test.h"
26 #include <utils/allocator.h>
27 #include <utils/logger_manager.h>
28 #include <encoding/generator.h>
29 #include <encoding/parser.h>
30 #include <encoding/payloads/encodings.h>
31 #include <encoding/payloads/ike_header.h>
32 #include <encoding/payloads/sa_payload.h>
33 #include <encoding/payloads/nonce_payload.h>
34 #include <encoding/payloads/ke_payload.h>
35 #include <encoding/payloads/notify_payload.h>
38 extern logger_manager_t
*global_logger_manager
;
44 void test_parser_with_header_payload(tester_t
*tester
)
47 ike_header_t
*ike_header
;
51 u_int8_t header_bytes
[] = {
60 header_chunk
.ptr
= header_bytes
;
61 header_chunk
.len
= sizeof(header_bytes
);
64 parser
= parser_create(header_chunk
);
65 tester
->assert_true(tester
,(parser
!= NULL
), "parser create check");
66 status
= parser
->parse_payload(parser
, HEADER
, (payload_t
**)&ike_header
);
67 tester
->assert_true(tester
,(status
== SUCCESS
),"parse_payload call check");
68 parser
->destroy(parser
);
70 if (status
!= SUCCESS
)
75 tester
->assert_true(tester
,(ike_header
->get_initiator_spi(ike_header
) == 1),"parsed initiator_spi value");
76 tester
->assert_true(tester
,(ike_header
->get_responder_spi(ike_header
) == 2),"parsed responder_spi value");
77 tester
->assert_true(tester
,(ike_header
->payload_interface
.get_next_type((payload_t
*)ike_header
) == 3),"parsed next_payload value");
78 tester
->assert_true(tester
,(ike_header
->get_maj_version(ike_header
) == 4),"parsed maj_version value");
79 tester
->assert_true(tester
,(ike_header
->get_min_version(ike_header
) == 5),"parsed min_version value");
80 tester
->assert_true(tester
,(ike_header
->get_exchange_type(ike_header
) == 6),"parsed exchange_type value");
81 tester
->assert_true(tester
,(ike_header
->get_initiator_flag(ike_header
) == TRUE
),"parsed flags.initiator value");
82 tester
->assert_true(tester
,(ike_header
->get_version_flag(ike_header
) == FALSE
),"parsed flags.version value");
83 tester
->assert_true(tester
,(ike_header
->get_response_flag(ike_header
) == TRUE
),"parsed flags.response value");
84 tester
->assert_true(tester
,(ike_header
->get_message_id(ike_header
) == 7),"parsed message_id value");
85 tester
->assert_true(tester
,(ike_header
->payload_interface
.get_length((payload_t
*)ike_header
) == 0x1C),"parsed length value");
87 ike_header
->destroy(ike_header
);
93 void test_parser_with_sa_payload(tester_t
*tester
)
96 sa_payload_t
*sa_payload
;
99 iterator_t
*proposals
, *transforms
, *attributes
;
101 u_int8_t sa_bytes
[] = {
102 0x00,0x80,0x00,0x24, /* payload header*/
103 0x00,0x00,0x00,0x20, /* a proposal */
105 0x01,0x02,0x03,0x04, /* spi */
106 0x00,0x00,0x00,0x14, /* transform */
108 0x80,0x01,0x00,0x05, /* attribute without length */
109 0x00,0x03,0x00,0x04, /* attribute with lenngth */
115 sa_chunk
.ptr
= sa_bytes
;
116 sa_chunk
.len
= sizeof(sa_bytes
);
119 parser
= parser_create(sa_chunk
);
120 tester
->assert_true(tester
,(parser
!= NULL
), "parser create check");
121 status
= parser
->parse_payload(parser
, SECURITY_ASSOCIATION
, (payload_t
**)&sa_payload
);
122 tester
->assert_true(tester
,(status
== SUCCESS
),"parse_payload call check");
123 parser
->destroy(parser
);
125 if (status
!= SUCCESS
)
131 sa_payload
->create_proposal_substructure_iterator(sa_payload
, &proposals
, TRUE
);
132 while (proposals
->has_next(proposals
))
134 proposal_substructure_t
*proposal
;
135 proposals
->current(proposals
, (void**)&proposal
);
137 u_int8_t spi_should
[] = {0x01, 0x02, 0x03, 0x04};
139 tester
->assert_true(tester
,(proposal
->get_proposal_number(proposal
) == 1),"proposal number");
140 tester
->assert_true(tester
,(proposal
->get_protocol_id(proposal
) == 2),"proposal id");
141 spi
= proposal
->get_spi(proposal
);
142 tester
->assert_false(tester
,(memcmp(&spi_should
, spi
.ptr
, spi
.len
)),"proposal spi");
144 proposal
->create_transform_substructure_iterator(proposal
, &transforms
, TRUE
);
145 while(transforms
->has_next(transforms
))
147 transform_substructure_t
*transform
;
149 transforms
->current(transforms
, (void**)&transform
);
150 tester
->assert_true(tester
,(transform
->get_transform_type(transform
) == 7),"transform type");
151 tester
->assert_true(tester
,(transform
->get_transform_id(transform
) == 3),"transform id");
152 transform
->create_transform_attribute_iterator(transform
, &attributes
, TRUE
);
154 while (attributes
->has_next(attributes
))
156 transform_attribute_t
*attribute
;
157 attributes
->current(attributes
, (void**)&attribute
);
160 u_int8_t value
[] = {0x05, 0x00};
161 chunk_t attribute_value
;
162 tester
->assert_true(tester
,(attribute
->get_attribute_type(attribute
) == 1),"attribute 1 type");
163 attribute_value
= attribute
->get_value_chunk(attribute
);
164 tester
->assert_false(tester
,(memcmp(&value
, attribute_value
.ptr
, attribute_value
.len
)),"attribute 1 value");
168 u_int8_t value
[] = {0x01, 0x02, 0x03, 0x04};
169 chunk_t attribute_value
;
170 tester
->assert_true(tester
,(attribute
->get_attribute_type(attribute
) == 3),"attribute 2 type");
171 attribute_value
= attribute
->get_value_chunk(attribute
);
172 tester
->assert_false(tester
,(memcmp(&value
, attribute_value
.ptr
, attribute_value
.len
)),"attribute 2 value");
176 attributes
->destroy(attributes
);
178 transforms
->destroy(transforms
);
180 proposals
->destroy(proposals
);
184 sa_payload
->destroy(sa_payload
);
188 * Described in Header
190 void test_parser_with_nonce_payload(tester_t
*tester
)
193 nonce_payload_t
*nonce_payload
;
195 chunk_t nonce_chunk
, result
;
197 u_int8_t nonce_bytes
[] = {
198 0x00,0x00,0x00,0x14, /* payload header */
199 0x00,0x01,0x02,0x03, /* 16 Byte nonce */
205 nonce_chunk
.ptr
= nonce_bytes
;
206 nonce_chunk
.len
= sizeof(nonce_bytes
);
208 parser
= parser_create(nonce_chunk
);
209 tester
->assert_true(tester
,(parser
!= NULL
), "parser create check");
210 status
= parser
->parse_payload(parser
, NONCE
, (payload_t
**)&nonce_payload
);
211 tester
->assert_true(tester
,(status
== SUCCESS
),"parse_payload call check");
212 parser
->destroy(parser
);
214 if (status
!= SUCCESS
)
218 nonce_payload
->get_nonce(nonce_payload
, &result
);
219 tester
->assert_true(tester
,(result
.len
== 16), "parsed nonce lenght");
220 tester
->assert_false(tester
,(memcmp(nonce_bytes
+ 4, result
.ptr
, result
.len
)), "parsed nonce data");
221 nonce_payload
->destroy(nonce_payload
);
222 allocator_free_chunk(&result
);
226 * Described in Header
228 void test_parser_with_ke_payload(tester_t
*tester
)
231 ke_payload_t
*ke_payload
;
233 chunk_t ke_chunk
, result
;
235 u_int8_t ke_bytes
[] = {
236 0x00,0x00,0x00,0x18, /* payload header */
237 0x00,0x03,0x00,0x00, /* dh group 3 */
238 0x01,0x02,0x03,0x03, /* 16 Byte dh data */
244 ke_chunk
.ptr
= ke_bytes
;
245 ke_chunk
.len
= sizeof(ke_bytes
);
247 parser
= parser_create(ke_chunk
);
248 tester
->assert_true(tester
,(parser
!= NULL
), "parser create check");
249 status
= parser
->parse_payload(parser
, KEY_EXCHANGE
, (payload_t
**)&ke_payload
);
250 tester
->assert_true(tester
,(status
== SUCCESS
),"parse_payload call check");
251 parser
->destroy(parser
);
253 if (status
!= SUCCESS
)
257 tester
->assert_true(tester
,(ke_payload
->get_dh_group_number(ke_payload
) == 3), "DH group");
258 result
= ke_payload
->get_key_exchange_data(ke_payload
);
259 tester
->assert_true(tester
,(result
.len
== 16), "parsed key lenght");
260 tester
->assert_false(tester
,(memcmp(ke_bytes
+ 8, result
.ptr
, result
.len
)), "parsed key data");
261 ke_payload
->destroy(ke_payload
);
266 * Described in Header
268 void test_parser_with_notify_payload(tester_t
*tester
)
271 notify_payload_t
*notify_payload
;
273 chunk_t notify_chunk
, result
;
275 u_int8_t notify_bytes
[] = {
276 0x00,0x00,0x00,0x1C, /* payload header */
278 0x01,0x02,0x03,0x03, /* spi */
279 0x04,0x05,0x06,0x07, /* noti dati */
285 notify_chunk
.ptr
= notify_bytes
;
286 notify_chunk
.len
= sizeof(notify_bytes
);
288 parser
= parser_create(notify_chunk
);
289 tester
->assert_true(tester
,(parser
!= NULL
), "parser create check");
290 status
= parser
->parse_payload(parser
, NOTIFY
, (payload_t
**)¬ify_payload
);
291 tester
->assert_true(tester
,(status
== SUCCESS
),"parse_payload call check");
292 parser
->destroy(parser
);
294 if (status
!= SUCCESS
)
298 tester
->assert_true(tester
,(notify_payload
->get_protocol_id(notify_payload
) == 3), "Protocol id");
299 tester
->assert_true(tester
,(notify_payload
->get_notify_message_type(notify_payload
) == 1), "notify message type");
301 result
= notify_payload
->get_spi(notify_payload
);
302 tester
->assert_false(tester
,(memcmp(notify_bytes
+ 8, result
.ptr
, result
.len
)), "parsed spi");
304 result
= notify_payload
->get_notification_data(notify_payload
);
305 tester
->assert_false(tester
,(memcmp(notify_bytes
+ 12, result
.ptr
, result
.len
)), "parsed notification data");
307 notify_payload
->destroy(notify_payload
);