2 * Copyright (C) 2011 Dan Carpenter.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version 2
7 * of the License, or (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
19 * There are a couple checks that try to see if a variable
20 * comes from the user. It would be better to unify them
21 * into one place. Also it we should follow the data down
22 * the call paths. Hence this file.
26 #include "smatch_slist.h"
27 #include "smatch_extra.h"
30 static int my_call_id
;
34 static const char * kstr_funcs
[] = {
35 "kstrtoull", "kstrtoll", "kstrtoul", "kstrtol", "kstrtouint",
36 "kstrtoint", "kstrtou64", "kstrtos64", "kstrtou32", "kstrtos32",
37 "kstrtou16", "kstrtos16", "kstrtou8", "kstrtos8", "kstrtoull_from_user"
38 "kstrtoll_from_user", "kstrtoul_from_user", "kstrtol_from_user",
39 "kstrtouint_from_user", "kstrtoint_from_user", "kstrtou16_from_user",
40 "kstrtos16_from_user", "kstrtou8_from_user", "kstrtos8_from_user",
41 "kstrtou64_from_user", "kstrtos64_from_user", "kstrtou32_from_user",
42 "kstrtos32_from_user",
45 static void set_points_to_user_data(struct expression
*expr
);
47 static struct stree
*start_states
;
48 static struct stree_stack
*saved_stack
;
49 static void save_start_states(struct statement
*stmt
)
51 start_states
= clone_stree(__get_cur_stree());
54 static void free_start_states(void)
56 free_stree(&start_states
);
59 static void match_save_states(struct expression
*expr
)
61 push_stree(&saved_stack
, start_states
);
65 static void match_restore_states(struct expression
*expr
)
67 free_stree(&start_states
);
68 start_states
= pop_stree(&saved_stack
);
71 static struct smatch_state
*empty_state(struct sm_state
*sm
)
73 return alloc_estate_empty();
76 static void pre_merge_hook(struct sm_state
*sm
)
78 struct smatch_state
*user
;
79 struct smatch_state
*extra
;
80 struct range_list
*rl
;
82 extra
= get_state(SMATCH_EXTRA
, sm
->name
, sm
->sym
);
83 if (!extra
|| !estate_rl(extra
))
85 user
= get_state(my_id
, sm
->name
, sm
->sym
);
86 if (!user
|| !estate_rl(user
))
88 rl
= rl_intersection(estate_rl(user
), estate_rl(extra
));
89 set_state(my_id
, sm
->name
, sm
->sym
, alloc_estate_rl(clone_rl(rl
)));
92 static void tag_inner_struct_members(struct expression
*expr
, struct symbol
*member
)
94 struct expression
*edge_member
;
95 struct symbol
*base
= get_real_base_type(member
);
99 expr
= member_expression(expr
, '.', member
->ident
);
101 FOR_EACH_PTR(base
->symbol_list
, tmp
) {
104 type
= get_real_base_type(tmp
);
108 if (type
->type
== SYM_UNION
|| type
->type
== SYM_STRUCT
) {
109 tag_inner_struct_members(expr
, tmp
);
116 edge_member
= member_expression(expr
, '.', tmp
->ident
);
117 set_state_expr(my_id
, edge_member
, alloc_estate_whole(type
));
118 } END_FOR_EACH_PTR(tmp
);
123 static void tag_struct_members(struct symbol
*type
, struct expression
*expr
)
126 struct expression
*member
;
129 if (expr
->type
== EXPR_PREOP
&& expr
->op
== '&') {
130 expr
= strip_expr(expr
->unop
);
134 FOR_EACH_PTR(type
->symbol_list
, tmp
) {
135 type
= get_real_base_type(tmp
);
139 if (type
->type
== SYM_UNION
|| type
->type
== SYM_STRUCT
) {
140 tag_inner_struct_members(expr
, tmp
);
147 member
= member_expression(expr
, op
, tmp
->ident
);
148 set_state_expr(my_id
, member
, alloc_estate_whole(get_type(member
)));
150 if (type
->type
== SYM_ARRAY
)
151 set_points_to_user_data(member
);
152 } END_FOR_EACH_PTR(tmp
);
155 static void tag_base_type(struct expression
*expr
)
157 if (expr
->type
== EXPR_PREOP
&& expr
->op
== '&')
158 expr
= strip_expr(expr
->unop
);
160 expr
= deref_expression(expr
);
161 set_state_expr(my_id
, expr
, alloc_estate_whole(get_type(expr
)));
164 static void tag_as_user_data(struct expression
*expr
)
168 expr
= strip_expr(expr
);
170 type
= get_type(expr
);
171 if (!type
|| type
->type
!= SYM_PTR
)
173 type
= get_real_base_type(type
);
176 if (type
== &void_ctype
) {
177 set_state_expr(my_id
, deref_expression(expr
), alloc_estate_whole(&ulong_ctype
));
180 if (type
->type
== SYM_BASETYPE
)
182 if (type
->type
== SYM_STRUCT
) {
183 if (expr
->type
!= EXPR_PREOP
|| expr
->op
!= '&')
184 expr
= deref_expression(expr
);
186 set_state_expr(my_id
, deref_expression(expr
), alloc_estate_whole(&ulong_ctype
));
187 tag_struct_members(type
, expr
);
191 static void match_user_copy(const char *fn
, struct expression
*expr
, void *_param
)
193 int param
= PTR_INT(_param
);
194 struct expression
*dest
;
196 dest
= get_argument_from_call_expr(expr
->args
, param
);
197 dest
= strip_expr(dest
);
200 tag_as_user_data(dest
);
203 static void match_sscanf(const char *fn
, struct expression
*expr
, void *unused
)
205 struct expression
*arg
;
209 FOR_EACH_PTR(expr
->args
, arg
) {
213 tag_as_user_data(arg
);
214 } END_FOR_EACH_PTR(arg
);
217 static int points_to_user_data(struct expression
*expr
)
219 struct smatch_state
*state
;
225 expr
= strip_expr(expr
);
227 if (expr
->type
== EXPR_BINOP
&& expr
->op
== '+') {
228 if (points_to_user_data(expr
->left
))
230 if (points_to_user_data(expr
->right
))
235 name
= expr_to_var_sym(expr
, &sym
);
238 snprintf(buf
, sizeof(buf
), "*%s", name
);
239 state
= get_state(my_id
, buf
, sym
);
240 if (state
&& estate_rl(state
))
247 static void set_points_to_user_data(struct expression
*expr
)
253 name
= expr_to_var_sym(expr
, &sym
);
256 snprintf(buf
, sizeof(buf
), "*%s", name
);
257 set_state(my_id
, buf
, sym
, alloc_estate_whole(&llong_ctype
));
262 static int is_skb_data(struct expression
*expr
)
266 expr
= strip_expr(expr
);
267 if (!expr
|| expr
->type
!= EXPR_DEREF
)
272 if (strcmp(expr
->member
->name
, "data") != 0)
275 sym
= expr_to_sym(expr
->deref
);
278 sym
= get_real_base_type(sym
);
279 if (!sym
|| sym
->type
!= SYM_PTR
)
281 sym
= get_real_base_type(sym
);
282 if (!sym
|| sym
->type
!= SYM_STRUCT
|| !sym
->ident
)
284 if (strcmp(sym
->ident
->name
, "sk_buff") != 0)
290 static int comes_from_skb_data(struct expression
*expr
)
292 expr
= strip_expr(expr
);
296 switch (expr
->type
) {
298 if (comes_from_skb_data(expr
->left
))
300 if (comes_from_skb_data(expr
->right
))
304 return comes_from_skb_data(expr
->unop
);
306 if (is_skb_data(expr
))
308 return comes_from_skb_data(expr
->deref
);
315 static int handle_struct_assignment(struct expression
*expr
)
317 struct expression
*right
;
318 struct symbol
*left_type
, *right_type
;
320 left_type
= get_type(expr
->left
);
321 if (!left_type
|| left_type
->type
!= SYM_PTR
)
323 left_type
= get_real_base_type(left_type
);
324 if (!left_type
|| left_type
->type
!= SYM_STRUCT
)
328 * Ignore struct to struct assignments because for those we look at the
329 * individual members.
331 right
= strip_expr(expr
->right
);
332 right_type
= get_type(right
);
333 if (!right_type
|| right_type
->type
!= SYM_PTR
)
336 /* If we are assigning struct members then normally that is handled
337 * by fake assignments, however if we cast one struct to a different
338 * of struct then we handle that here.
340 right_type
= get_real_base_type(right_type
);
341 if (right_type
== left_type
)
344 if (!points_to_user_data(right
) && !is_skb_data(right
))
347 tag_as_user_data(expr
->left
);
351 static int handle_get_user(struct expression
*expr
)
356 name
= get_macro_name(expr
->pos
);
357 if (!name
|| strcmp(name
, "get_user") != 0)
360 name
= expr_to_var(expr
->right
);
361 if (!name
|| strcmp(name
, "__val_gu") != 0)
363 set_state_expr(my_id
, expr
->left
, alloc_estate_whole(get_type(expr
->left
)));
370 static void match_assign(struct expression
*expr
)
372 struct range_list
*rl
;
374 if (is_fake_call(expr
->right
))
376 if (handle_get_user(expr
))
378 if (points_to_user_data(expr
->right
))
379 set_points_to_user_data(expr
->left
);
380 if (handle_struct_assignment(expr
))
383 if (expr
->right
->type
== EXPR_CALL
||
384 !get_user_rl(expr
->right
, &rl
))
385 goto clear_old_state
;
387 rl
= cast_rl(get_type(expr
->left
), rl
);
388 set_state_expr(my_id
, expr
->left
, alloc_estate_rl(rl
));
393 if (get_state_expr(my_id
, expr
->left
))
394 set_state_expr(my_id
, expr
->left
, alloc_estate_empty());
397 static void match_user_assign_function(const char *fn
, struct expression
*expr
, void *unused
)
399 tag_as_user_data(expr
->left
);
400 set_points_to_user_data(expr
->left
);
403 static void match_simple_strtoul(const char *fn
, struct expression
*expr
, void *unused
)
405 set_state_expr(my_id
, expr
->left
, alloc_estate_whole(get_type(expr
->left
)));
408 static int get_user_macro_rl(struct expression
*expr
, struct range_list
**rl
)
414 macro
= get_macro_name(expr
->pos
);
419 if (strcmp(macro
, "ntohl") == 0) {
420 *rl
= alloc_whole_rl(&uint_ctype
);
423 if (strcmp(macro
, "ntohs") == 0) {
424 *rl
= alloc_whole_rl(&ushort_ctype
);
430 static int user_data_flag
;
431 static struct range_list
*var_user_rl(struct expression
*expr
)
433 struct smatch_state
*state
;
434 struct range_list
*rl
;
435 struct range_list
*absolute_rl
;
437 if (get_user_macro_rl(expr
, &rl
))
440 if (comes_from_skb_data(expr
)) {
441 rl
= alloc_whole_rl(get_type(expr
));
445 state
= get_state_expr(my_id
, expr
);
446 if (state
&& estate_rl(state
)) {
447 rl
= estate_rl(state
);
454 absolute_rl
= var_to_absolute_rl(expr
);
455 return clone_rl(rl_intersection(rl
, absolute_rl
));
458 int get_user_rl(struct expression
*expr
, struct range_list
**rl
)
462 custom_get_absolute_rl(expr
, &var_user_rl
, rl
);
463 if (!user_data_flag
) {
470 static void match_call_info(struct expression
*expr
)
472 struct range_list
*rl
;
473 struct expression
*arg
;
477 FOR_EACH_PTR(expr
->args
, arg
) {
480 if (!get_user_rl(arg
, &rl
))
483 sql_insert_caller_info(expr
, USER_DATA3
, i
, "$", show_rl(rl
));
484 } END_FOR_EACH_PTR(arg
);
487 static void struct_member_callback(struct expression
*call
, int param
, char *printed_name
, struct sm_state
*sm
)
489 struct smatch_state
*state
;
490 struct range_list
*rl
;
492 if (strcmp(sm
->state
->name
, "") == 0)
495 state
= get_state(SMATCH_EXTRA
, sm
->name
, sm
->sym
);
496 if (!state
|| !estate_rl(state
))
497 rl
= estate_rl(sm
->state
);
499 rl
= rl_intersection(estate_rl(sm
->state
), estate_rl(state
));
501 sql_insert_caller_info(call
, USER_DATA3
, param
, printed_name
, show_rl(rl
));
504 static void set_param_user_data(const char *name
, struct symbol
*sym
, char *key
, char *value
)
506 struct range_list
*rl
= NULL
;
507 struct smatch_state
*state
;
511 if (strcmp(key
, "*$") == 0)
512 snprintf(fullname
, sizeof(fullname
), "*%s", name
);
513 else if (strncmp(key
, "$", 1) == 0)
514 snprintf(fullname
, 256, "%s%s", name
, key
+ 1);
518 type
= get_member_type_from_key(symbol_expression(sym
), key
);
520 /* if the caller passes a void pointer with user data */
521 if (strcmp(key
, "*$") == 0 && type
&& type
!= &void_ctype
) {
522 struct expression
*expr
= symbol_expression(sym
);
524 tag_as_user_data(expr
);
525 set_points_to_user_data(expr
);
528 str_to_rl(type
, value
, &rl
);
529 state
= alloc_estate_rl(rl
);
530 set_state(my_id
, fullname
, sym
, state
);
533 static void set_called(const char *name
, struct symbol
*sym
, char *key
, char *value
)
535 set_state(my_call_id
, "this_function", NULL
, &called
);
538 static void match_syscall_definition(struct symbol
*sym
)
545 macro
= get_macro_name(sym
->pos
);
547 (strncmp("SYSCALL_DEFINE", macro
, strlen("SYSCALL_DEFINE")) == 0 ||
548 strncmp("COMPAT_SYSCALL_DEFINE", macro
, strlen("COMPAT_SYSCALL_DEFINE")) == 0))
551 name
= get_function();
552 if (!option_no_db
&& get_state(my_call_id
, "this_function", NULL
) != &called
) {
553 if (name
&& strncmp(name
, "sys_", 4) == 0)
557 if (name
&& strncmp(name
, "compat_sys_", 11) == 0)
563 FOR_EACH_PTR(sym
->ctype
.base_type
->arguments
, arg
) {
564 set_state(my_id
, arg
->ident
->name
, arg
, alloc_estate_whole(get_real_base_type(arg
)));
565 } END_FOR_EACH_PTR(arg
);
568 static void returns_param_user_data(struct expression
*expr
, int param
, char *key
, char *value
)
570 struct expression
*arg
;
574 struct range_list
*rl
= NULL
;
576 while (expr
->type
== EXPR_ASSIGNMENT
)
577 expr
= strip_expr(expr
->right
);
578 if (expr
->type
!= EXPR_CALL
)
581 arg
= get_argument_from_call_expr(expr
->args
, param
);
584 type
= get_member_type_from_key(arg
, key
);
585 name
= get_variable_from_key(arg
, key
, &sym
);
589 call_results_to_rl(expr
, type
, value
, &rl
);
591 set_state(my_id
, name
, sym
, alloc_estate_rl(rl
));
596 static int has_empty_state(struct sm_state
*sm
)
598 struct sm_state
*tmp
;
600 FOR_EACH_PTR(sm
->possible
, tmp
) {
601 if (!estate_rl(tmp
->state
))
603 } END_FOR_EACH_PTR(tmp
);
608 static void param_set_to_user_data(int return_id
, char *return_ranges
, struct expression
*expr
)
611 struct smatch_state
*start_state
;
613 const char *param_name
;
615 FOR_EACH_MY_SM(my_id
, __get_cur_stree(), sm
) {
616 if (has_empty_state(sm
))
620 param
= get_param_num_from_sym(sm
->sym
);
622 if (expr_to_sym(expr
) == sm
->sym
)
629 start_state
= get_state_stree(start_states
, my_id
, sm
->name
, sm
->sym
);
630 if (start_state
&& estates_equiv(sm
->state
, start_state
))
634 param_name
= get_param_name(sm
);
637 if (strcmp(param_name
, "$") == 0)
640 sql_insert_return_states(return_id
, return_ranges
, USER_DATA3
,
641 param
, param_name
, show_rl(estate_rl(sm
->state
)));
642 } END_FOR_EACH_SM(sm
);
645 void check_user_data2(int id
)
651 if (option_project
!= PROJ_KERNEL
)
654 add_hook(&save_start_states
, AFTER_DEF_HOOK
);
655 add_hook(&free_start_states
, END_FUNC_HOOK
);
656 add_hook(&match_save_states
, INLINE_FN_START
);
657 add_hook(&match_restore_states
, INLINE_FN_END
);
659 add_unmatched_state_hook(my_id
, &empty_state
);
660 add_pre_merge_hook(my_id
, &pre_merge_hook
);
661 add_merge_hook(my_id
, &merge_estates
);
663 add_function_hook("copy_from_user", &match_user_copy
, INT_PTR(0));
664 add_function_hook("__copy_from_user", &match_user_copy
, INT_PTR(0));
665 add_function_hook("memcpy_fromiovec", &match_user_copy
, INT_PTR(0));
666 for (i
= 0; i
< ARRAY_SIZE(kstr_funcs
); i
++)
667 add_function_hook(kstr_funcs
[i
], &match_user_copy
, INT_PTR(2));
669 add_function_assign_hook("simple_strtol", &match_simple_strtoul
, NULL
);
670 add_function_assign_hook("simple_strtoll", &match_simple_strtoul
, NULL
);
671 add_function_assign_hook("simple_strtoul", &match_simple_strtoul
, NULL
);
672 add_function_assign_hook("simple_strtoull", &match_simple_strtoul
, NULL
);
674 add_function_hook("sscanf", &match_sscanf
, NULL
);
676 add_function_assign_hook("memdup_user", &match_user_assign_function
, NULL
);
677 add_function_assign_hook("kmap_atomic", &match_user_assign_function
, NULL
);
678 add_function_assign_hook("skb_network_header", &match_user_assign_function
, NULL
);
680 add_hook(&match_syscall_definition
, AFTER_DEF_HOOK
);
682 add_hook(&match_assign
, ASSIGNMENT_HOOK
);
684 add_hook(&match_call_info
, FUNCTION_CALL_HOOK
);
685 add_member_info_callback(my_id
, struct_member_callback
);
686 select_caller_info_hook(set_param_user_data
, USER_DATA3
);
687 select_return_states_hook(USER_DATA3
, &returns_param_user_data
);
688 add_split_return_callback(¶m_set_to_user_data
);
691 void check_user_data3(int id
)
695 if (option_project
!= PROJ_KERNEL
)
697 select_caller_info_hook(set_called
, INTERNAL
);