1: /*
2: * Copyright (C) 2012-2015 Andreas Steffen
3: * HSR Hochschule fuer Technik Rapperswil
4: *
5: * This program is free software; you can redistribute it and/or modify it
6: * under the terms of the GNU General Public License as published by the
7: * Free Software Foundation; either version 2 of the License, or (at your
8: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
9: *
10: * This program is distributed in the hope that it will be useful, but
11: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
12: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13: * for more details.
14: */
15:
16: #include "imc_msg.h"
17:
18: #include "ietf/ietf_attr.h"
19: #include "ietf/ietf_attr_assess_result.h"
20: #include "ietf/ietf_attr_remediation_instr.h"
21: #include "tcg/seg/tcg_seg_attr_max_size.h"
22: #include "tcg/seg/tcg_seg_attr_seg_env.h"
23: #include "tcg/seg/tcg_seg_attr_next_seg.h"
24:
25: #include <tncif_names.h>
26: #include <tncif_pa_subtypes.h>
27:
28: #include <pen/pen.h>
29: #include <collections/linked_list.h>
30: #include <utils/debug.h>
31:
32: typedef struct private_imc_msg_t private_imc_msg_t;
33:
34: /**
35: * Private data of a imc_msg_t object.
36: *
37: */
38: struct private_imc_msg_t {
39:
40: /**
41: * Public imc_msg_t interface.
42: */
43: imc_msg_t public;
44:
45: /**
46: * Connection ID
47: */
48: TNC_ConnectionID connection_id;
49:
50: /**
51: * source ID
52: */
53: TNC_UInt32 src_id;
54:
55: /**
56: * destination ID
57: */
58: TNC_UInt32 dst_id;
59:
60: /**
61: * PA-TNC message type
62: */
63: pen_type_t msg_type;
64:
65: /**
66: * List of PA-TNC attributes to be sent
67: */
68: linked_list_t *attr_list;
69:
70: /**
71: * PA-TNC message
72: */
73: pa_tnc_msg_t *pa_msg;
74:
75: /**
76: * Assigned IMC agent
77: */
78: imc_agent_t *agent;
79:
80: /**
81: * Assigned IMC state
82: */
83: imc_state_t *state;
84: };
85:
86: METHOD(imc_msg_t, get_src_id, TNC_UInt32,
87: private_imc_msg_t *this)
88: {
89: return this->src_id;
90: }
91:
92: METHOD(imc_msg_t, get_dst_id, TNC_UInt32,
93: private_imc_msg_t *this)
94: {
95: return this->dst_id;
96: }
97:
98: METHOD(imc_msg_t, get_msg_type, pen_type_t,
99: private_imc_msg_t *this)
100: {
101: return this->msg_type;
102: }
103:
104: METHOD(imc_msg_t, send_, TNC_Result,
105: private_imc_msg_t *this, bool excl)
106: {
107: pa_tnc_msg_t *pa_tnc_msg;
108: pa_tnc_attr_t *attr;
109: TNC_UInt32 msg_flags;
110: TNC_MessageType msg_type;
111: size_t max_msg_len, min_seg_attr_len, space_left;
112: bool attr_added, oversize;
113: chunk_t msg;
114: seg_contract_t *contract;
115: seg_contract_manager_t *contracts;
116: enumerator_t *enumerator;
117: TNC_Result result = TNC_RESULT_SUCCESS;
118:
119: /* Get IF-M segmentation contract for this subtype if any */
120: contracts = this->state->get_contracts(this->state);
121: contract = contracts->get_contract(contracts, this->msg_type,
122: FALSE, this->dst_id);
123:
124: /* Retrieve maximum allowed PA-TNC message size if set */
125: max_msg_len = this->state->get_max_msg_len(this->state);
126:
127: /* Minimum size needed for Segmentation Envelope Attribute */
128: min_seg_attr_len = PA_TNC_ATTR_HEADER_SIZE + TCG_SEG_ATTR_SEG_ENV_HEADER +
129: PA_TNC_ATTR_HEADER_SIZE;
130:
131: while (this->attr_list->get_count(this->attr_list))
132: {
133: pa_tnc_msg = pa_tnc_msg_create(max_msg_len);
134: attr_added = FALSE;
135:
136: enumerator = this->attr_list->create_enumerator(this->attr_list);
137: while (enumerator->enumerate(enumerator, &attr))
138: {
139: space_left = pa_tnc_msg->get_space(pa_tnc_msg);
140:
141: if (contract && contract->check_size(contract, attr, &oversize))
142: {
143: if (oversize)
144: {
145: /* TODO handle oversized attributes */
146: }
147: else if (max_msg_len == 0 || space_left >= min_seg_attr_len)
148: {
149: attr = contract->first_segment(contract, attr, space_left);
150: }
151: else
152: {
153: /* segment attribute in next iteration */
154: break;
155: }
156: }
157: if (pa_tnc_msg->add_attribute(pa_tnc_msg, attr))
158: {
159: attr_added = TRUE;
160: }
161: else
162: {
163: if (attr_added)
164: {
165: /* there might be space for attribute in next iteration */
166: break;
167: }
168: else
169: {
170: DBG1(DBG_IMV, "PA-TNC attribute too large to send, deleted");
171: attr->destroy(attr);
172: }
173: }
174: this->attr_list->remove_at(this->attr_list, enumerator);
175: }
176: enumerator->destroy(enumerator);
177:
178: /* build and send the PA-TNC message via the IF-IMC interface */
179: if (!pa_tnc_msg->build(pa_tnc_msg))
180: {
181: pa_tnc_msg->destroy(pa_tnc_msg);
182: return TNC_RESULT_FATAL;
183: }
184: msg = pa_tnc_msg->get_encoding(pa_tnc_msg);
185: DBG3(DBG_IMC, "created PA-TNC message: %B", &msg);
186:
187: if (this->state->has_long(this->state) && this->agent->send_message_long)
188: {
189: excl = excl && this->state->has_excl(this->state) &&
190: this->dst_id != TNC_IMVID_ANY;
191: msg_flags = excl ? TNC_MESSAGE_FLAGS_EXCLUSIVE : 0;
192: result = this->agent->send_message_long(this->src_id,
193: this->connection_id, msg_flags, msg.ptr, msg.len,
194: this->msg_type.vendor_id, this->msg_type.type,
195: this->dst_id);
196: }
197: else if (this->agent->send_message)
198: {
199: msg_type = (this->msg_type.vendor_id << 8) |
200: (this->msg_type.type & 0x000000ff);
201: result = this->agent->send_message(this->src_id, this->connection_id,
202: msg.ptr, msg.len, msg_type);
203: }
204:
205: pa_tnc_msg->destroy(pa_tnc_msg);
206:
207: if (result != TNC_RESULT_SUCCESS)
208: {
209: break;
210: }
211: }
212: return result;
213: }
214:
215: /**
216: * Print a clearly visible assessment header to the log
217: */
218: static void print_assessment_header(const char *name, TNC_UInt32 dst_id,
219: TNC_UInt32 src_id, bool *first)
220: {
221: if (*first)
222: {
223: if (src_id == TNC_IMCID_ANY)
224: {
225: DBG1(DBG_IMC, "***** assessment of IMC %u \"%s\" *****",
226: dst_id, name);
227: }
228: else
229: {
230: DBG1(DBG_IMC, "***** assessment of IMC %u \"%s\" from IMV %u *****",
231: dst_id, name, src_id);
232: }
233: *first = FALSE;
234: }
235: }
236:
237: /**
238: * Print a clearly visible assessment trailer to the log
239: */
240: static void print_assessment_trailer(bool first)
241: {
242: if (!first)
243: {
244: DBG1(DBG_IMC, "***** end of assessment *****");
245: }
246: }
247:
248: METHOD(imc_msg_t, receive, TNC_Result,
249: private_imc_msg_t *this, imc_msg_t *out_msg, bool *fatal_error)
250: {
251: linked_list_t *non_fatal_types;
252: TNC_UInt32 target_imc_id;
253: enumerator_t *enumerator;
254: pa_tnc_attr_t *attr;
255: pen_type_t attr_type;
256: chunk_t msg;
257: bool first = TRUE;
258:
259: if (this->state->has_long(this->state))
260: {
261: if (this->dst_id != TNC_IMCID_ANY)
262: {
263: DBG2(DBG_IMC, "IMC %u \"%s\" received message for Connection ID %u "
264: "from IMV %u to IMC %u",
265: this->agent->get_id(this->agent),
266: this->agent->get_name(this->agent),
267: this->connection_id, this->src_id, this->dst_id);
268: }
269: else
270: {
271: DBG2(DBG_IMC, "IMC %u \"%s\" received message for Connection ID %u "
272: "from IMV %u", this->agent->get_id(this->agent),
273: this->agent->get_name(this->agent),
274: this->connection_id, this->src_id);
275: }
276: }
277: else
278: {
279: DBG2(DBG_IMC, "IMC %u \"%s\" received message for Connection ID %u",
280: this->agent->get_id(this->agent),
281: this->agent->get_name(this->agent),
282: this->connection_id);
283: }
284: msg = this->pa_msg->get_encoding(this->pa_msg);
285: DBG3(DBG_IMC, "%B", &msg);
286:
287: switch (this->pa_msg->process(this->pa_msg))
288: {
289: case SUCCESS:
290: break;
291: case VERIFY_ERROR:
292: {
293: /* extract and copy by reference all error attributes */
294: enumerator = this->pa_msg->create_error_enumerator(this->pa_msg);
295: while (enumerator->enumerate(enumerator, &attr))
296: {
297: out_msg->add_attribute(out_msg, attr->get_ref(attr));
298: }
299: enumerator->destroy(enumerator);
300: return TNC_RESULT_SUCCESS;
301: }
302: case FAILED:
303: default:
304: return TNC_RESULT_FATAL;
305: }
306:
307: /* determine target IMC ID */
308: target_imc_id = (this->dst_id != TNC_IMCID_ANY) ?
309: this->dst_id : this->agent->get_id(this->agent);
310:
311: /* process any IF-M segmentation contracts */
312: enumerator = this->pa_msg->create_attribute_enumerator(this->pa_msg);
313: while (enumerator->enumerate(enumerator, &attr))
314: {
315: uint32_t max_attr_size, max_seg_size, my_max_attr_size, my_max_seg_size;
316: seg_contract_t *contract;
317: seg_contract_manager_t *contracts;
318: char buf[BUF_LEN];
319: pen_type_t type;
320:
321: type = attr->get_type(attr);
322:
323: contracts = this->state->get_contracts(this->state);
324:
325: if (type.vendor_id != PEN_TCG)
326: {
327: continue;
328: }
329:
330: switch (type.type)
331: {
332: case TCG_SEG_MAX_ATTR_SIZE_REQ:
333: {
334: tcg_seg_attr_max_size_t *attr_cast;
335:
336: attr_cast = (tcg_seg_attr_max_size_t*)attr;
337: attr_cast->get_attr_size(attr_cast, &max_attr_size,
338: &max_seg_size);
339: contract = contracts->get_contract(contracts, this->msg_type,
340: FALSE, this->src_id);
341: if (contract)
342: {
343: contract->set_max_size(contract, max_attr_size,
344: max_seg_size);
345: }
346: else
347: {
348: contract = seg_contract_create(this->msg_type, max_attr_size,
349: max_seg_size, FALSE, this->src_id, TRUE);
350: contract->set_responder(contract, target_imc_id);
351: contracts->add_contract(contracts, contract);
352: }
353: contract->get_info_string(contract, buf, BUF_LEN, TRUE);
354: DBG2(DBG_IMC, "%s", buf);
355:
356: /* Determine maximum PA-TNC attribute segment size */
357: my_max_seg_size = this->state->get_max_msg_len(this->state)
358: - PA_TNC_HEADER_SIZE
359: - PA_TNC_ATTR_HEADER_SIZE
360: - TCG_SEG_ATTR_SEG_ENV_HEADER;
361:
362: /* If segmentation is possible select lower segment size */
363: if (max_seg_size != SEG_CONTRACT_NO_FRAGMENTATION &&
364: max_seg_size > my_max_seg_size)
365: {
366: max_seg_size = my_max_seg_size;
367: contract->set_max_size(contract, max_attr_size,
368: max_seg_size);
369: DBG2(DBG_IMC, " lowered maximum segment size to %u bytes",
370: max_seg_size);
371: }
372:
373: /* Add Maximum Attribute Size Response attribute */
374: attr = tcg_seg_attr_max_size_create(max_attr_size,
375: max_seg_size, FALSE);
376: out_msg->add_attribute(out_msg, attr);
377: break;
378: }
379: case TCG_SEG_MAX_ATTR_SIZE_RESP:
380: {
381: tcg_seg_attr_max_size_t *attr_cast;
382:
383: attr_cast = (tcg_seg_attr_max_size_t*)attr;
384: attr_cast->get_attr_size(attr_cast, &max_attr_size,
385: &max_seg_size);
386: contract = contracts->get_contract(contracts, this->msg_type,
387: TRUE, this->src_id);
388: if (!contract)
389: {
390: contract = contracts->get_contract(contracts, this->msg_type,
391: TRUE, TNC_IMCID_ANY);
392: if (contract)
393: {
394: contract = contract->clone(contract);
395: contract->set_responder(contract, this->src_id);
396: contracts->add_contract(contracts, contract);
397: }
398: }
399: if (contract)
400: {
401: contract->get_max_size(contract, &my_max_attr_size,
402: &my_max_seg_size);
403: if (my_max_seg_size != SEG_CONTRACT_NO_FRAGMENTATION &&
404: my_max_seg_size > max_seg_size)
405: {
406: my_max_seg_size = max_seg_size;
407: contract->set_max_size(contract, my_max_attr_size,
408: my_max_seg_size);
409: }
410: contract->get_info_string(contract, buf, BUF_LEN, FALSE);
411: DBG2(DBG_IMC, "%s", buf);
412: }
413: else
414: {
415: /* TODO no request pending */
416: DBG1(DBG_IMC, "no contract for this PA message type found");
417: }
418: break;
419: }
420: case TCG_SEG_ATTR_SEG_ENV:
421: {
422: tcg_seg_attr_seg_env_t *seg_env_attr;
423: pa_tnc_attr_t *error;
424: uint32_t base_attr_id;
425: bool more;
426:
427: seg_env_attr = (tcg_seg_attr_seg_env_t*)attr;
428: base_attr_id = seg_env_attr->get_base_attr_id(seg_env_attr);
429:
430: contract = contracts->get_contract(contracts, this->msg_type,
431: TRUE, this->src_id);
432: if (!contract)
433: {
434: DBG2(DBG_IMC, "no contract for received attribute segment "
435: "with base attribute ID %u", base_attr_id);
436: continue;
437: }
438: attr = contract->add_segment(contract, attr, &error, &more);
439: if (error)
440: {
441: out_msg->add_attribute(out_msg, error);
442: }
443: if (attr)
444: {
445: this->pa_msg->add_attribute(this->pa_msg, attr);
446: }
447: if (more)
448: {
449: /* Send Next Segment Request */
450: attr = tcg_seg_attr_next_seg_create(base_attr_id, FALSE);
451: out_msg->add_attribute(out_msg, attr);
452: }
453: break;
454: }
455: case TCG_SEG_NEXT_SEG_REQ:
456: {
457: tcg_seg_attr_next_seg_t *attr_cast;
458: uint32_t base_attr_id;
459:
460: attr_cast = (tcg_seg_attr_next_seg_t*)attr;
461: base_attr_id = attr_cast->get_base_attr_id(attr_cast);
462:
463: contract = contracts->get_contract(contracts, this->msg_type,
464: FALSE, this->src_id);
465: if (!contract)
466: {
467: /* TODO no contract - generate error message */
468: DBG1(DBG_IMC, "no contract for received next segment "
469: "request with base attribute ID %u", base_attr_id);
470: continue;
471: }
472: attr = contract->next_segment(contract, base_attr_id);
473: if (attr)
474: {
475: out_msg->add_attribute(out_msg, attr);
476: }
477: else
478: {
479: /* TODO no more segments - generate error message */
480: DBG1(DBG_IMC, "no more segments found for "
481: "base attribute ID %u", base_attr_id);
482: }
483: break;
484: }
485: default:
486: break;
487: }
488: }
489: enumerator->destroy(enumerator);
490:
491: /* preprocess any received IETF standard error attributes */
492: non_fatal_types = this->agent->get_non_fatal_attr_types(this->agent);
493: *fatal_error = this->pa_msg->process_ietf_std_errors(this->pa_msg,
494: non_fatal_types);
495:
496: /* preprocess any received IETF assessment result attribute */
497: enumerator = this->pa_msg->create_attribute_enumerator(this->pa_msg);
498: while (enumerator->enumerate(enumerator, &attr))
499: {
500: attr_type = attr->get_type(attr);
501:
502: if (attr_type.vendor_id != PEN_IETF)
503: {
504: continue;
505: }
506: if (attr_type.type == IETF_ATTR_ASSESSMENT_RESULT)
507: {
508: ietf_attr_assess_result_t *attr_cast;
509: TNC_IMV_Evaluation_Result res;
510:
511: attr_cast = (ietf_attr_assess_result_t*)attr;
512: res = attr_cast->get_result(attr_cast);
513: this->state->set_result(this->state, target_imc_id, res);
514:
515: print_assessment_header(this->agent->get_name(this->agent),
516: target_imc_id, this->src_id, &first);
517: DBG1(DBG_IMC, "assessment result is '%N'",
518: TNC_IMV_Evaluation_Result_names, res);
519: }
520: else if (attr_type.type == IETF_ATTR_REMEDIATION_INSTRUCTIONS)
521: {
522: ietf_attr_remediation_instr_t *attr_cast;
523: pen_type_t parameters_type;
524: chunk_t parameters, string, lang_code;
525:
526: attr_cast = (ietf_attr_remediation_instr_t*)attr;
527: parameters_type = attr_cast->get_parameters_type(attr_cast);
528: parameters = attr_cast->get_parameters(attr_cast);
529:
530: print_assessment_header(this->agent->get_name(this->agent),
531: target_imc_id, this->src_id, &first);
532: if (parameters_type.vendor_id == PEN_IETF)
533: {
534: switch (parameters_type.type)
535: {
536: case IETF_REMEDIATION_PARAMETERS_URI:
537: DBG1(DBG_IMC, "remediation uri: %.*s",
538: parameters.len, parameters.ptr);
539: break;
540: case IETF_REMEDIATION_PARAMETERS_STRING:
541: string = attr_cast->get_string(attr_cast, &lang_code);
542: DBG1(DBG_IMC, "remediation string: [%.*s]\n%.*s",
543: lang_code.len, lang_code.ptr,
544: string.len, string.ptr);
545: break;
546: default:
547: DBG1(DBG_IMC, "remediation parameters: %B", ¶meters);
548: }
549: }
550: else
551: {
552: DBG1(DBG_IMC, "remediation parameters: %B", ¶meters);
553: }
554: }
555: }
556: enumerator->destroy(enumerator);
557:
558: print_assessment_trailer(first);
559:
560: return TNC_RESULT_SUCCESS;
561: }
562:
563: METHOD(imc_msg_t, add_attribute, void,
564: private_imc_msg_t *this, pa_tnc_attr_t *attr)
565: {
566: this->attr_list->insert_last(this->attr_list, attr);
567: }
568:
569: METHOD(imc_msg_t, create_attribute_enumerator, enumerator_t*,
570: private_imc_msg_t *this)
571: {
572: return this->pa_msg->create_attribute_enumerator(this->pa_msg);
573: }
574:
575: METHOD(imc_msg_t, get_encoding, chunk_t,
576: private_imc_msg_t *this)
577: {
578: if (this->pa_msg)
579: {
580: return this->pa_msg->get_encoding(this->pa_msg);
581: }
582: return chunk_empty;
583: }
584:
585: METHOD(imc_msg_t, destroy, void,
586: private_imc_msg_t *this)
587: {
588: this->attr_list->destroy_offset(this->attr_list,
589: offsetof(pa_tnc_attr_t, destroy));
590: DESTROY_IF(this->pa_msg);
591: free(this);
592: }
593:
594: /**
595: * See header
596: */
597: imc_msg_t *imc_msg_create(imc_agent_t *agent, imc_state_t *state,
598: TNC_ConnectionID connection_id,
599: TNC_UInt32 src_id, TNC_UInt32 dst_id,
600: pen_type_t msg_type)
601: {
602: private_imc_msg_t *this;
603:
604: INIT(this,
605: .public = {
606: .get_src_id = _get_src_id,
607: .get_dst_id = _get_dst_id,
608: .get_msg_type = _get_msg_type,
609: .send = _send_,
610: .receive = _receive,
611: .add_attribute = _add_attribute,
612: .create_attribute_enumerator = _create_attribute_enumerator,
613: .get_encoding = _get_encoding,
614: .destroy = _destroy,
615: },
616: .connection_id = connection_id,
617: .src_id = src_id,
618: .dst_id = dst_id,
619: .msg_type = msg_type,
620: .attr_list = linked_list_create(),
621: .agent = agent,
622: .state = state,
623: );
624:
625: return &this->public;
626: }
627:
628: /**
629: * See header
630: */
631: imc_msg_t* imc_msg_create_as_reply(imc_msg_t *msg)
632: {
633: private_imc_msg_t *in;
634: TNC_UInt32 src_id;
635:
636: in = (private_imc_msg_t*)msg;
637: src_id = (in->dst_id != TNC_IMCID_ANY) ?
638: in->dst_id : in->agent->get_id(in->agent);
639:
640: return imc_msg_create(in->agent, in->state, in->connection_id, src_id,
641: in->src_id, in->msg_type);
642: }
643:
644: /**
645: * See header
646: */
647: imc_msg_t *imc_msg_create_from_data(imc_agent_t *agent, imc_state_t *state,
648: TNC_ConnectionID connection_id,
649: TNC_MessageType msg_type,
650: chunk_t msg)
651: {
652: TNC_VendorID msg_vid;
653: TNC_MessageSubtype msg_subtype;
654:
655: msg_vid = msg_type >> 8;
656: msg_subtype = msg_type & TNC_SUBTYPE_ANY;
657:
658: return imc_msg_create_from_long_data(agent, state, connection_id,
659: TNC_IMVID_ANY, agent->get_id(agent),
660: msg_vid, msg_subtype, msg);
661: }
662:
663: /**
664: * See header
665: */
666: imc_msg_t *imc_msg_create_from_long_data(imc_agent_t *agent, imc_state_t *state,
667: TNC_ConnectionID connection_id,
668: TNC_UInt32 src_id,
669: TNC_UInt32 dst_id,
670: TNC_VendorID msg_vid,
671: TNC_MessageSubtype msg_subtype,
672: chunk_t msg)
673: {
674: private_imc_msg_t *this;
675:
676: this = (private_imc_msg_t*)imc_msg_create(agent, state,
677: connection_id, src_id, dst_id,
678: pen_type_create(msg_vid, msg_subtype));
679: this->pa_msg = pa_tnc_msg_create_from_data(msg);
680:
681: return &this->public;
682: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to imc_msg.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libimcv / imc