Instruction
stringclasses 1
value | Input
stringlengths 79
33k
| Response
stringlengths 106
9.29k
| __index_level_0__
int64 0
2.83k
|
|---|---|---|---|
Find vulnerabilities in this ABAP code snippet.
|
```abap
CLASS ZCL_ZOSQL_DB_LAYER IMPLEMENTATION.
method ZIF_ZOSQL_DB_LAYER~COMMIT.
IF iv_wait = abap_true.
COMMIT WORK AND WAIT.
ELSE.
COMMIT WORK.
ENDIF.
endmethod.
method ZIF_ZOSQL_DB_LAYER~DELETE.
DATA: lv_table_name TYPE string,
lv_where TYPE string,
lv_new_syntax TYPE abap_bool,
lo_sql_parser TYPE REF TO zcl_zosql_parser_recurs_desc.
_split_delete_into_parts( EXPORTING iv_delete_statement = iv_delete_statement
IMPORTING ev_table_name = lv_table_name
ev_where = lv_where
ev_new_syntax = lv_new_syntax
eo_sql_parser = lo_sql_parser ).
_delete_by_sql_parts( iv_table_name = lv_table_name
iv_where = lv_where
iv_new_syntax = lv_new_syntax
it_parameters = it_parameters
io_sql_parser = lo_sql_parser ).
endmethod.
method ZIF_ZOSQL_DB_LAYER~DELETE_BY_ITAB.
DATA: ld_itab_for_db_operation TYPE REF TO data,
lv_table_name TYPE tabname.
FIELD-SYMBOLS: <lt_itab_for_db_operation> TYPE STANDARD TABLE.
lv_table_name = iv_table_name.
IF lv_table_name IS INITIAL.
lv_table_name = zcl_zosql_utils=>try_to_guess_tabname_by_data( it_lines_for_delete ).
ENDIF.
ld_itab_for_db_operation = _convert_itab_for_db_operation( iv_table_name = lv_table_name
it_input_itab = it_lines_for_delete ).
ASSIGN ld_itab_for_db_operation->* TO <lt_itab_for_db_operation>.
DELETE (lv_table_name) FROM TABLE <lt_itab_for_db_operation>.
endmethod.
method ZIF_ZOSQL_DB_LAYER~FETCH_NEXT_CURSOR.
FIELD-SYMBOLS: <ls_cursor_parameters> LIKE LINE OF mt_database_cursor_parameters,
<lt_result_set> TYPE STANDARD TABLE,
<lt_result_of_method> TYPE STANDARD TABLE.
READ TABLE mt_database_cursor_parameters WITH KEY cursor = iv_cursor
ASSIGNING <ls_cursor_parameters>.
IF sy-subrc <> 0.
ev_subrc = 4.
RETURN.
ENDIF.
ASSIGN <ls_cursor_parameters>-ref_to_result_dataset->* TO <lt_result_set>.
CREATE DATA ed_result_as_table LIKE <lt_result_set>.
ASSIGN ed_result_as_table->* TO <lt_result_of_method>.
zif_zosql_db_layer~fetch_next_cursor_to_itab( EXPORTING iv_cursor = iv_cursor
iv_package_size = iv_package_size
IMPORTING et_result_table = <lt_result_of_method>
ev_subrc = ev_subrc ).
endmethod.
method ZIF_ZOSQL_DB_LAYER~FETCH_NEXT_CURSOR_TO_ITAB.
DATA: lt_dummy_table TYPE TABLE OF t000.
FIELD-SYMBOLS: <lt_result_table> TYPE any table.
IF if_table_consists_of_structs( et_result_table ) = abap_true.
ASSIGN et_result_table TO <lt_result_table>.
ELSE.
ASSIGN lt_dummy_table TO <lt_result_table>.
ENDIF.
IF iv_do_into_corresponding = abap_true.
FETCH NEXT CURSOR iv_cursor
INTO CORRESPONDING FIELDS OF TABLE <lt_result_table>
PACKAGE SIZE iv_package_size.
ELSE.
FETCH NEXT CURSOR iv_cursor
INTO TABLE <lt_result_table>
PACKAGE SIZE iv_package_size.
ENDIF.
ev_subrc = sy-subrc.
endmethod.
method ZIF_ZOSQL_DB_LAYER~INSERT_BY_ITAB.
DATA: ld_itab_for_db_operation TYPE REF TO data,
lv_table_name TYPE tabname.
FIELD-SYMBOLS: <lt_itab_for_db_operation> TYPE STANDARD TABLE.
lv_table_name = iv_table_name.
IF lv_table_name IS INITIAL.
lv_table_name = zcl_zosql_utils=>try_to_guess_tabname_by_data( it_new_lines ).
ENDIF.
ld_itab_for_db_operation = _convert_itab_for_db_operation( iv_table_name = lv_table_name
it_input_itab = it_new_lines ).
ASSIGN ld_itab_for_db_operation->* TO <lt_itab_for_db_operation>.
INSERT (lv_table_name) FROM TABLE <lt_itab_for_db_operation>.
endmethod.
method ZIF_ZOSQL_DB_LAYER~MODIFY_BY_ITAB.
DATA: ld_itab_for_db_operation TYPE REF TO data,
lv_table_name TYPE tabname.
FIELD-SYMBOLS: <lt_itab_for_db_operation> TYPE STANDARD TABLE.
lv_table_name = iv_table_name.
IF lv_table_name IS INITIAL.
lv_table_name = zcl_zosql_utils=>try_to_guess_tabname_by_data( it_lines_for_modify ).
ENDIF.
ld_itab_for_db_operation = _convert_itab_for_db_operation( iv_table_name = lv_table_name
it_input_itab = it_lines_for_modify ).
ASSIGN ld_itab_for_db_operation->* TO <lt_itab_for_db_operation>.
MODIFY (lv_table_name) FROM TABLE <lt_itab_for_db_operation>.
endmethod.
method ZIF_ZOSQL_DB_LAYER~OPEN_CURSOR.
DATA: lv_select_field_list TYPE string,
lv_from TYPE string,
lv_for_all_entries_tabname TYPE string,
lv_where TYPE string,
lv_group_by TYPE string,
lv_order_by TYPE string,
lv_distinct TYPE abap_bool,
lv_new_syntax TYPE abap_bool,
lv_number_of_rows_expr TYPE string,
lv_from_ready_for_select TYPE string,
lv_where_ready_for_select TYPE string,
ld_struct_with_params TYPE REF TO data,
ld_result_table_prepared TYPE REF TO data,
lv_number_of_rows_to_select TYPE i,
ls_cursor_parameters TYPE ty_database_cursor_parameters,
lo_sql_parser TYPE REF TO zcl_zosql_parser_recurs_desc.
FIELD-SYMBOLS: <ls_result_first_line> TYPE any,
<ls_struct_with_params> TYPE any,
<lt_result_table> TYPE ANY TABLE.
_split_select_into_parts( EXPORTING iv_select = iv_select
IMPORTING ev_select_field_list = lv_select_field_list
ev_from = lv_from
ev_for_all_entries_tabname = lv_for_all_entries_tabname
ev_where = lv_where
ev_group_by = lv_group_by
ev_order_by = lv_order_by
ev_distinct = lv_distinct
ev_new_syntax = lv_new_syntax
ev_number_of_rows_expr = lv_number_of_rows_expr
eo_sql_parser = lo_sql_parser ).
lv_from_ready_for_select = lv_from.
lv_where_ready_for_select = lv_where.
_prepare_for_select( EXPORTING it_parameters = it_parameters
iv_name_of_struct_with_params = 'IS_DYNAMIC_STRUCT_WITH_PARAMS'
iv_name_of_for_all_ent_in_sel = lv_for_all_entries_tabname
iv_name_of_for_all_ent_var = 'IT_FOR_ALL_ENTRIES_TABLE'
iv_new_syntax = lv_new_syntax
iv_number_of_rows_expr = lv_number_of_rows_expr
io_sql_parser = lo_sql_parser
IMPORTING ed_dynamic_struct_with_params = ld_struct_with_params
ev_number_of_rows_to_select = lv_number_of_rows_to_select
CHANGING cv_from = lv_from_ready_for_select
cv_where = lv_where_ready_for_select
).
ASSIGN ld_struct_with_params->* TO <ls_struct_with_params>.
rv_cursor = _open_cursor( iv_select = lv_select_field_list
iv_from = lv_from_ready_for_select
iv_where = lv_where_ready_for_select
iv_group_by = lv_group_by
iv_order_by = lv_order_by
iv_distinct = lv_distinct
iv_new_syntax = lv_new_syntax
it_for_all_entries_table = it_for_all_entries_table
is_dynamic_struct_with_params = <ls_struct_with_params>
iv_number_of_rows_to_select = lv_number_of_rows_to_select ).
ls_cursor_parameters-cursor = rv_cursor.
ls_cursor_parameters-ref_to_result_dataset =
create_dynamic_tab_for_result( lo_sql_parser ).
APPEND ls_cursor_parameters TO mt_database_cursor_parameters.
endmethod.
method ZIF_ZOSQL_DB_LAYER~SELECT_TO_ITAB.
DATA: lv_select_field_list TYPE string,
lv_from TYPE string,
lv_for_all_entries_tabname TYPE string,
lv_where TYPE string,
lv_group_by TYPE string,
lv_order_by TYPE string,
lv_distinct TYPE abap_bool,
lv_new_syntax TYPE abap_bool,
lv_number_of_rows_expr TYPE string,
lo_sql_parser TYPE REF TO zcl_zosql_parser_recurs_desc.
_split_select_into_parts( EXPORTING iv_select = iv_select
IMPORTING ev_select_field_list = lv_select_field_list
ev_from = lv_from
ev_for_all_entries_tabname = lv_for_all_entries_tabname
ev_where = lv_where
ev_group_by = lv_group_by
ev_order_by = lv_order_by
ev_distinct = lv_distinct
ev_new_syntax = lv_new_syntax
ev_number_of_rows_expr = lv_number_of_rows_expr
eo_sql_parser = lo_sql_parser ).
_select_by_sql_parts( EXPORTING iv_select = lv_select_field_list
iv_from = lv_from
iv_where = lv_where
iv_group_by = lv_group_by
iv_order_by = lv_order_by
iv_distinct = lv_distinct
iv_new_syntax = lv_new_syntax
it_parameters = it_parameters
it_for_all_entries_table = it_for_all_entries_table
iv_for_all_entries_tabname = lv_for_all_entries_tabname
iv_do_into_corresponding = iv_do_into_corresponding
iv_number_of_rows_expr = lv_number_of_rows_expr
io_sql_parser = lo_sql_parser
IMPORTING et_result_table = et_result_table
es_result_line = es_result_line
ev_subrc = ev_subrc ).
endmethod.
METHOD zif_zosql_db_layer~update.
DATA: lv_table_name TYPE string,
lv_set_statement TYPE string,
lv_where TYPE string,
lv_new_syntax TYPE abap_bool,
lo_sql_parser TYPE REF TO zcl_zosql_parser_recurs_desc.
_split_update_into_parts( EXPORTING iv_update_statement = iv_update_statement
IMPORTING ev_table_name = lv_table_name
ev_set_statement = lv_set_statement
ev_where = lv_where
ev_new_syntax = lv_new_syntax
eo_sql_parser = lo_sql_parser ).
_update_by_sql_parts( iv_table_name = lv_table_name
iv_set_statement = lv_set_statement
iv_where = lv_where
iv_new_syntax = lv_new_syntax
it_parameters = it_parameters
io_sql_parser = lo_sql_parser ).
ENDMETHOD.
method ZIF_ZOSQL_DB_LAYER~UPDATE_BY_ITAB.
DATA: ld_itab_for_db_operation TYPE REF TO data,
lv_table_name TYPE tabname.
FIELD-SYMBOLS: <lt_itab_for_db_operation> TYPE STANDARD TABLE.
lv_table_name = iv_table_name.
IF lv_table_name IS INITIAL.
lv_table_name = zcl_zosql_utils=>try_to_guess_tabname_by_data( it_lines_for_update ).
ENDIF.
ld_itab_for_db_operation = _convert_itab_for_db_operation( iv_table_name = lv_table_name
it_input_itab = it_lines_for_update ).
ASSIGN ld_itab_for_db_operation->* TO <lt_itab_for_db_operation>.
UPDATE (lv_table_name) FROM TABLE <lt_itab_for_db_operation>.
endmethod.
method _CHECK_COMP_NAME_UNIQUE.
```
|
I found vulnerabilities in the line:
```abap
DELETE (lv_table_name) FROM TABLE <lt_itab_for_db_operation>.
```
Explanation: Modify only own DB tables | Potential dangerous statement Dynamic SQL.
```abap
INSERT (lv_table_name) FROM TABLE <lt_itab_for_db_operation>.
```
Explanation: Modify only own DB tables | Potential dangerous statement Dynamic SQL.
```abap
MODIFY (lv_table_name) FROM TABLE <lt_itab_for_db_operation>.
```
Explanation: Modify only own DB tables | Potential dangerous statement Dynamic SQL.
```abap
UPDATE (lv_table_name) FROM TABLE <lt_itab_for_db_operation>.
```
Explanation: Modify only own DB tables | Potential dangerous statement Dynamic SQL.
| 2,780 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
method wait_for_free_dialog.
"hardcoded 3 on purpose. Less than that and systems get weird.
data num_free_dia_wps type i.
data num_wps type i.
constants opcode_wp_get_info type x value 25.
call 'ThWpInfo'
id 'OPCODE' field opcode_wp_get_info
id 'WP' field num_wps
id 'FREE_DIAWP' field num_free_dia_wps.
while num_free_dia_wps < 3.
"can lead to starvation if server usage is too high for too long
wait up to gc_wait_period_interval seconds.
call 'ThWpInfo'
id 'OPCODE' field opcode_wp_get_info
id 'WP' field num_wps
id 'FREE_DIAWP' field num_free_dia_wps.
endwhile.
endmethod.
```
|
I found vulnerabilities in the line:
```abap
constants opcode_wp_get_info type x value 25.
call 'ThWpInfo' * <-- There is a problem here
id 'OPCODE' field opcode_wp_get_info
id 'WP' field num_wps
```
Explanation: Potential dangerous statement KERNEL CALL.
| 2,792 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
while num_free_dia_wps < 3.
"can lead to starvation if server usage is too high for too long
wait up to gc_wait_period_interval seconds.
call 'ThWpInfo'
id 'OPCODE' field opcode_wp_get_info
id 'WP' field num_wps
id 'FREE_DIAWP' field num_free_dia_wps.
endwhile.
```
|
I found vulnerabilities in the line:
```abap
wait up to gc_wait_period_interval seconds.
call 'ThWpInfo' * <-- There is a problem here
id 'OPCODE' field opcode_wp_get_info
```
Explanation: Potential dangerous statement KERNEL CALL.
| 2,793 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
IF fw_display = space.
GENERATE SUBROUTINE POOL lt_code_string NAME fw_program.
ELSE.
```
|
I found vulnerabilities in the line:
```abap
ENDIF.
IF fw_display = space.
GENERATE SUBROUTINE POOL lt_code_string NAME fw_program. * <-- There is a problem here
ELSE.
IF lw_mess IS NOT INITIAL.
lw_explicit = lw_line.
```
Explanation: Potential dangerous statement GENERATE SUBROUTINE.
```abap
ENDIF.
IF fw_display = space.
GENERATE SUBROUTINE POOL lt_code_string NAME fw_program. * <-- There is a problem here
ELSE.
IF lw_mess IS NOT INITIAL.
lw_explicit = lw_line.
```
Explanation: Potential dangerous statement GENERATE SUBROUTINE.
| 2,794 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
FORM query_process_native USING fw_command TYPE string.
DATA : lw_lines TYPE i,
lw_sql_code TYPE i,
lw_sql_msg(255) TYPE c,
lw_row_num TYPE i,
lw_command(255) TYPE c,
lw_msg TYPE string,
lw_timestart TYPE timestampl,
lw_timeend TYPE timestampl,
lw_time TYPE p LENGTH 8 DECIMALS 2,
lw_charnumb(12) TYPE c,
lw_answer(1) TYPE c.
* Have a user confirmation before execute Native SQL Command
CONCATENATE 'Are you sure you want to do a'(m31) fw_command
'?'(m33)
INTO lw_msg SEPARATED BY space.
CALL FUNCTION 'POPUP_TO_CONFIRM'
EXPORTING
titlebar = 'Warning : critical operation'(t04)
text_question = lw_msg
default_button = '2'
display_cancel_button = space
IMPORTING
answer = lw_answer
EXCEPTIONS
text_not_found = 1
OTHERS = 2.
IF sy-subrc NE 0 OR lw_answer NE '1'.
RETURN.
ENDIF.
lw_command = fw_command.
lw_lines = strlen( lw_command ).
GET TIME STAMP FIELD lw_timestart.
CALL 'C_DB_EXECUTE'
ID 'STATLEN' FIELD lw_lines
ID 'STATTXT' FIELD lw_command
ID 'SQLERR' FIELD lw_sql_code
ID 'ERRTXT' FIELD lw_sql_msg
ID 'ROWNUM' FIELD lw_row_num.
IF sy-subrc NE 0.
MESSAGE lw_sql_msg TYPE c_msg_success DISPLAY LIKE c_msg_error.
RETURN.
ELSE.
GET TIME STAMP FIELD lw_timeend.
lw_time = cl_abap_tstmp=>subtract(
tstmp1 = lw_timeend
tstmp2 = lw_timestart
).
lw_charnumb = lw_time.
CONCATENATE 'Query executed in'(m09) lw_charnumb 'seconds.'(m10)
INTO lw_msg SEPARATED BY space.
CONDENSE lw_msg.
MESSAGE lw_msg TYPE c_msg_success.
ENDIF.
ENDFORM. " QUERY_PROCESS_NATIVE
```
|
I found vulnerabilities in the line:
```abap
CALL 'C_DB_EXECUTE'
```
Explanation: Potential dangerous statement KERNEL CALL.
| 2,795 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
FORM ddic_add_tree_zspro.
DATA : lo_zspro TYPE REF TO data,
ls_node LIKE LINE OF s_tab_active-t_node_ddic,
ls_item LIKE LINE OF s_tab_active-t_item_ddic,
lw_nodekey TYPE tv_nodekey,
BEGIN OF ls_ddic_fields,
tabname TYPE dd03l-tabname,
fieldname TYPE dd03l-fieldname,
position TYPE dd03l-position,
keyflag TYPE dd03l-keyflag,
ddtext1 TYPE dd03t-ddtext,
ddtext2 TYPE dd04t-ddtext,
END OF ls_ddic_fields,
lt_ddic_fields LIKE TABLE OF ls_ddic_fields,
lw_node_number(11) TYPE n,
lw_found(1) TYPE c.
CONSTANTS lc_zspro(30) TYPE c VALUE 'ZSPRO'.
FIELD-SYMBOLS : <ft_zspro> TYPE standard table,
<fs_zspro> TYPE any,
<fw_zspro> TYPE any.
REFRESH : t_node_zspro, t_item_zspro.
* Try to create zspro internal table
TRY.
CREATE DATA lo_zspro TYPE TABLE OF (lc_zspro).
CATCH cx_sy_create_data_error.
* If ZSPRO does not exist, leave the subroutine
RETURN.
ENDTRY.
ASSIGN lo_zspro->* TO <ft_zspro>.
* Get all data from ZSPRO (node or table entry)
SELECT * FROM (lc_zspro)
INTO TABLE <ft_zspro>
WHERE nodetype = 0
OR nodetype = 1
OR nodetype = space
ORDER BY relatkey sort.
* If ZSPRO does not contain any valuable data, leave the subroutine
IF sy-subrc NE 0.
RETURN.
ENDIF.
* Get field list for each table
LOOP AT <ft_zspro> ASSIGNING <fs_zspro>.
ASSIGN COMPONENT 'NODETYPE' OF STRUCTURE <fs_zspro> TO <fw_zspro>.
IF sy-subrc NE 0 OR <fw_zspro> NE 1.
CONTINUE.
ENDIF.
ASSIGN COMPONENT 'NODEPARAM' OF STRUCTURE <fs_zspro> TO <fw_zspro>.
IF sy-subrc = 0.
ls_ddic_fields-tabname = <fw_zspro>.
APPEND ls_ddic_fields TO lt_ddic_fields.
ENDIF.
ENDLOOP.
IF NOT lt_ddic_fields IS INITIAL.
SELECT dd03l~tabname dd03l~fieldname dd03l~position
dd03l~keyflag dd03t~ddtext dd04t~ddtext
INTO TABLE lt_ddic_fields
FROM dd03l
LEFT OUTER JOIN dd03t
ON dd03l~tabname = dd03t~tabname
AND dd03l~fieldname = dd03t~fieldname
AND dd03l~as4local = dd03t~as4local
AND dd03t~ddlanguage = sy-langu
LEFT OUTER JOIN dd04t
ON dd03l~rollname = dd04t~rollname
AND dd03l~as4local = dd04t~as4local
AND dd04t~ddlanguage = sy-langu
FOR ALL ENTRIES IN lt_ddic_fields
WHERE dd03l~tabname = lt_ddic_fields-tabname
AND dd03l~as4local = c_vers_active
AND dd03l~as4vers = space
AND ( dd03l~comptype = c_ddic_dtelm
OR dd03l~comptype = space ).
SORT lt_ddic_fields BY tabname keyflag DESCENDING position.
DELETE ADJACENT DUPLICATES FROM lt_ddic_fields
COMPARING tabname fieldname.
ENDIF.
CLEAR ls_node.
ls_node-node_key = 'ZSPRO'.
ls_node-isfolder = abap_true.
ls_node-expander = abap_true.
APPEND ls_node TO t_node_zspro.
CLEAR ls_item.
ls_item-node_key = 'ZSPRO'.
ls_item-class = cl_gui_column_tree=>item_class_text.
ls_item-item_name = c_ddic_col1.
ls_item-text = 'ZSPRO'.
APPEND ls_item TO t_item_zspro.
ls_item-item_name = c_ddic_col2.
ls_item-text = space.
APPEND ls_item TO t_item_zspro.
LOOP AT <ft_zspro> ASSIGNING <fs_zspro>.
ASSIGN COMPONENT 'NODE_KEY' OF STRUCTURE <fs_zspro> TO <fw_zspro>.
CONCATENATE 'Z' <fw_zspro>+1 INTO lw_nodekey.
CLEAR ls_node.
ls_node-node_key = lw_nodekey.
ASSIGN COMPONENT 'RELATKEY' OF STRUCTURE <fs_zspro> TO <fw_zspro>.
IF <fw_zspro> IS INITIAL.
ls_node-relatkey = 'ZSPRO'.
ELSE.
CONCATENATE 'Z' <fw_zspro>+1 INTO ls_node-relatkey.
ENDIF.
ls_node-isfolder = abap_true.
ASSIGN COMPONENT 'NODETYPE' OF STRUCTURE <fs_zspro> TO <fw_zspro>.
IF <fw_zspro> = 1. "table entry
ls_node-n_image = '@PO@'.
ls_node-exp_image = '@PO@'.
ENDIF.
ls_node-expander = abap_true.
APPEND ls_node TO t_node_zspro.
CLEAR ls_item.
ls_item-node_key = lw_nodekey.
ls_item-class = cl_gui_column_tree=>item_class_text.
ls_item-item_name = c_ddic_col1.
IF <fw_zspro> = 1. "table entry
ASSIGN COMPONENT 'NODEPARAM' OF STRUCTURE <fs_zspro> TO <fw_zspro>.
ls_item-text = <fw_zspro>.
ELSE.
ASSIGN COMPONENT 'TEXT' OF STRUCTURE <fs_zspro> TO <fw_zspro>.
ls_item-text = <fw_zspro>.
ENDIF.
APPEND ls_item TO t_item_zspro.
ls_item-item_name = c_ddic_col2.
ASSIGN COMPONENT 'NODETYPE' OF STRUCTURE <fs_zspro> TO <fw_zspro>.
IF <fw_zspro> = 1. "table entry
ASSIGN COMPONENT 'TEXT' OF STRUCTURE <fs_zspro> TO <fw_zspro>.
ls_item-text = <fw_zspro>.
ELSE.
ls_item-text = space.
ENDIF.
APPEND ls_item TO t_item_zspro.
* For each table entry, add all fields
ASSIGN COMPONENT 'NODETYPE' OF STRUCTURE <fs_zspro> TO <fw_zspro>.
IF <fw_zspro> = 1.
ASSIGN COMPONENT 'NODEPARAM' OF STRUCTURE <fs_zspro>
TO <fw_zspro>.
LOOP AT lt_ddic_fields INTO ls_ddic_fields
WHERE tabname = <fw_zspro>.
CLEAR ls_node.
lw_node_number = lw_node_number + 1.
CONCATENATE 'F' lw_node_number INTO ls_node-node_key.
ls_node-relatkey = lw_nodekey.
ls_node-relatship = cl_gui_column_tree=>relat_last_child.
IF ls_ddic_fields-keyflag = space.
ls_node-n_image = '@3W@'.
ls_node-exp_image = '@3W@'.
ELSE.
ls_node-n_image = '@3V@'.
ls_node-exp_image = '@3V@'.
ENDIF.
ls_node-dragdropid = w_dragdrop_handle_tree.
APPEND ls_node TO t_node_zspro.
CLEAR ls_item.
ls_item-node_key = ls_node-node_key.
ls_item-class = cl_gui_column_tree=>item_class_text.
ls_item-item_name = c_ddic_col1.
ls_item-text = ls_ddic_fields-fieldname.
APPEND ls_item TO t_item_zspro.
ls_item-item_name = c_ddic_col2.
IF NOT ls_ddic_fields-ddtext1 IS INITIAL.
ls_item-text = ls_ddic_fields-ddtext1.
ELSE.
ls_item-text = ls_ddic_fields-ddtext2.
ENDIF.
APPEND ls_item TO t_item_zspro.
ENDLOOP.
ENDIF.
ENDLOOP.
* Clean Empty nodes
DO.
lw_found = space.
LOOP AT t_node_zspro INTO ls_node WHERE isfolder = abap_true.
READ TABLE t_node_zspro WITH KEY relatkey = ls_node-node_key
TRANSPORTING NO FIELDS.
IF sy-subrc NE 0.
lw_found = abap_true.
DELETE t_node_zspro.
DELETE t_item_zspro WHERE node_key = ls_node-node_key.
ENDIF.
ENDLOOP.
IF lw_found = space.
EXIT.
ENDIF.
ENDDO.
ENDFORM. "ddic_add_tree_zspro
```
|
I found vulnerabilities in the line:
```abap
SELECT * FROM (lc_zspro)
```
Explanation: Potential dangerous statement Dynamic SQL.
| 2,796 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
TRY.
SELECT COUNT(*) UP TO 1 ROWS FROM (table).
CATCH cx_sy_dynamic_osql_syntax
cx_sy_dynamic_osql_semantics INTO lx.
MESSAGE lx TYPE 'S' DISPLAY LIKE 'E'.
RETURN.
ENDTRY.
```
|
I found vulnerabilities in the line:
```abap
SELECT COUNT(*) UP TO 1 ROWS FROM (table).
```
Explanation: Potential dangerous statement Dynamic SQL.
| 2,797 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
TRY.
SELECT * UP TO @rows ROWS
FROM (table)
INTO TABLE @<lt_data>
ORDER BY PRIMARY KEY.
CATCH cx_sy_dynamic_osql_syntax
cx_sy_dynamic_osql_semantics INTO lx.
MESSAGE lx TYPE 'S' DISPLAY LIKE 'E'.
RETURN.
ENDTRY.
```
|
I found vulnerabilities in the line:
```abap
SELECT * UP TO @rows ROWS
```
Explanation: Potential dangerous statement Dynamic SQL.
| 2,798 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
CLASS zcl_dbbr_sql_selection IMPLEMENTATION.
METHOD create.
rr_instance = NEW zcl_dbbr_sql_selection( ).
rr_instance->mt_select = it_select.
rr_instance->mt_from = it_from.
rr_instance->mt_having = it_having.
rr_instance->mt_where = it_where.
rr_instance->mt_order_by = it_order_by.
rr_instance->mt_group_by = it_group_by.
rr_instance->mv_max_size = iv_max_size.
ENDMETHOD.
METHOD determine_size_for_group_by.
DATA: lx_root TYPE REF TO cx_root.
FIELD-SYMBOLS: <lt_data> TYPE table.
*** IF sy-saprl > 751. " Common table expressions exist
*** rv_size = get_group_by_size_by_cte( ).
*** ELSE.
ASSIGN ir_t_data->* TO <lt_data>.
TRY.
SELECT (mt_select)
FROM (mt_from)
WHERE (mt_where)
GROUP BY (mt_group_by)
HAVING (mt_having)
ORDER BY (mt_order_by)
INTO CORRESPONDING FIELDS OF TABLE @<lt_data>.
rv_size = lines( <lt_data> ).
CLEAR <lt_data>.
CATCH cx_root INTO lx_root.
RAISE EXCEPTION TYPE zcx_dbbr_selection_common
EXPORTING
previous = lx_root.
ENDTRY.
*** ENDIF.
ENDMETHOD.
METHOD determine_size.
DATA: lx_root TYPE REF TO cx_root.
FIELD-SYMBOLS: <lt_for_all_data> TYPE table.
TRY.
SELECT COUNT( * )
FROM (mt_from)
WHERE (mt_where)
INTO @rv_size.
CATCH cx_root INTO lx_root.
RAISE EXCEPTION TYPE zcx_dbbr_selection_common
EXPORTING
previous = lx_root.
ENDTRY.
ENDMETHOD.
METHOD fill_having.
DATA: lv_having TYPE string.
LOOP AT mt_having ASSIGNING FIELD-SYMBOL(<lv_having>).
CLEAR: lv_having.
IF sy-tabix = 1.
lv_having = | HAVING { <lv_having> }|.
ELSE.
lv_having = | { <lv_having> }|.
ENDIF.
ct_lines = VALUE #( BASE ct_lines ( lv_having ) ).
ENDLOOP.
ENDMETHOD.
METHOD fill_from.
DATA: lv_from TYPE string.
LOOP AT mt_from ASSIGNING FIELD-SYMBOL(<lv_from>).
CLEAR: lv_from.
IF sy-tabix = 1.
lv_from = | FROM { <lv_from> }|.
ELSE.
lv_from = | { <lv_from> }|.
ENDIF.
ct_lines = VALUE #( BASE ct_lines ( lv_from ) ).
ENDLOOP.
ENDMETHOD.
METHOD fill_group_by.
DATA: lv_group_by TYPE string.
LOOP AT mt_group_by ASSIGNING FIELD-SYMBOL(<lv_group_by>).
CLEAR: lv_group_by.
IF sy-tabix = 1.
lv_group_by = | GROUP BY { <lv_group_by> }|.
ELSE.
lv_group_by = | { <lv_group_by> }|.
ENDIF.
ct_lines = VALUE #( BASE ct_lines ( lv_group_by ) ).
ENDLOOP.
ENDMETHOD.
METHOD fill_order_by.
DATA: lv_order_by TYPE string.
LOOP AT mt_order_by ASSIGNING FIELD-SYMBOL(<lv_order_by>).
CLEAR: lv_order_by.
IF sy-tabix = 1.
lv_order_by = | ORDER BY { <lv_order_by> }|.
ELSE.
lv_order_by = | { <lv_order_by> }|.
ENDIF.
ct_lines = VALUE #( BASE ct_lines ( lv_order_by ) ).
ENDLOOP.
ENDMETHOD.
METHOD fill_select.
DATA: lv_select TYPE string.
LOOP AT mt_select ASSIGNING FIELD-SYMBOL(<lv_select>).
CLEAR: lv_select.
IF sy-tabix = 1.
lv_select = |SELECT { <lv_select> }|.
ELSE.
lv_select = | { <lv_select> }|.
ENDIF.
ct_lines = VALUE #( BASE ct_lines ( lv_select ) ).
ENDLOOP.
ENDMETHOD.
METHOD fill_where.
DATA: lv_where TYPE string.
LOOP AT mt_where ASSIGNING FIELD-SYMBOL(<lv_where>).
CLEAR: lv_where.
IF sy-tabix = 1.
lv_where = |WHERE { <lv_where> }|.
ELSE.
lv_where = | { <lv_where> }|.
ENDIF.
ct_lines = VALUE #( BASE ct_lines ( lv_where ) ).
ENDLOOP.
ENDMETHOD.
METHOD select_data.
DATA: lx_root TYPE REF TO cx_root.
TRY.
SELECT (mt_select)
FROM (mt_from)
WHERE (mt_where)
GROUP BY (mt_group_by)
HAVING (mt_having)
ORDER BY (mt_order_by)
INTO CORRESPONDING FIELDS OF TABLE @et_data
UP TO @mv_max_size ROWS.
CATCH cx_root INTO lx_root.
RAISE EXCEPTION TYPE zcx_dbbr_selection_common
EXPORTING
previous = lx_root.
ENDTRY.
ENDMETHOD.
METHOD set_max_rows.
mv_max_size = iv_max_rows.
ENDMETHOD.
METHOD update_from.
mt_from = it_from.
ENDMETHOD.
METHOD get_select_sql.
DATA: lt_sql_lines TYPE string_table.
fill_select( CHANGING ct_lines = lt_sql_lines ).
fill_from( CHANGING ct_lines = lt_sql_lines ).
fill_where( CHANGING ct_lines = lt_sql_lines ).
fill_group_by( CHANGING ct_lines = lt_sql_lines ).
fill_having( CHANGING ct_lines = lt_sql_lines ).
fill_order_by( CHANGING ct_lines = lt_sql_lines ).
CONCATENATE LINES OF lt_sql_lines INTO rv_select_sql SEPARATED BY cl_abap_char_utilities=>cr_lf.
ENDMETHOD.
METHOD create_count_query_for_cte.
DATA: lt_sql_lines TYPE string_table,
lv_query TYPE string.
lt_sql_lines = VALUE #(
( |WITH| )
( | +group_select as (| )
( || ) ).
fill_select( CHANGING ct_lines = lt_sql_lines ).
fill_from( CHANGING ct_lines = lt_sql_lines ).
fill_where( CHANGING ct_lines = lt_sql_lines ).
fill_group_by( CHANGING ct_lines = lt_sql_lines ).
fill_having( CHANGING ct_lines = lt_sql_lines ).
lt_sql_lines = VALUE #( BASE lt_sql_lines
( |)| )
( |SELECT COUNT(*) FROM +group_select| ) ).
CONCATENATE LINES OF lt_sql_lines INTO lv_query SEPARATED BY cl_abap_char_utilities=>cr_lf.
TRY.
ro_query = NEW zcl_dbbr_sql_query_parser(
iv_query = lv_query
if_fill_log_for_messages = abap_false
)->parse( ).
CATCH zcx_dbbr_sql_query_error INTO DATA(lx_error).
lx_error->zif_sat_exception_message~print( ).
ENDTRY.
ENDMETHOD.
METHOD get_group_by_size_by_cte.
DATA(lo_count_query) = create_count_query_for_cte( ).
CHECK lo_count_query IS NOT INITIAL.
zcl_dbbr_sql_query_exec=>execute_query(
EXPORTING
io_query = lo_count_query
iv_row_count = mv_max_size
IMPORTING
et_data_info = DATA(lt_data_info)
ev_execution_time = DATA(lv_exec_time)
ev_message = DATA(lv_message)
ev_message_type = DATA(lv_message_type)
er_data = DATA(lr_t_result) ).
zcl_dbbr_sql_query_exec=>get_single_value_from_result(
EXPORTING
it_result_info = lt_data_info
ir_t_data = lr_t_result
IMPORTING
ev_value = rv_size ).
ENDMETHOD.
ENDCLASS.
```
|
I found vulnerabilities in the line:
```abap
SELECT COUNT( * )
```
Explanation: Potential dangerous statement Dynamic SQL.
Suggested fix:
```abap
CLASS zcl_dbbr_sql_selection IMPLEMENTATION.
METHOD create.
ro_instance = NEW zcl_dbbr_sql_selection( ).
ro_instance->mt_select = it_select.
ro_instance->mt_from = it_from.
ro_instance->mt_having = it_having.
ro_instance->mt_where = it_where.
ro_instance->mt_order_by = it_order_by.
ro_instance->mt_group_by = it_group_by.
ro_instance->mv_max_size = iv_max_size.
SET HANDLER ro_instance->on_async_query_finished ACTIVATION 'X'.
ENDMETHOD.
METHOD unregister_evt_handlers.
SET HANDLER on_async_query_finished ACTIVATION space.
ENDMETHOD.
METHOD determine_size_for_group_by.
DATA: lx_root TYPE REF TO cx_root.
FIELD-SYMBOLS: <lt_data> TYPE table.
IF sy-saprl > 751.
rv_size = get_group_by_size_by_cte( ).
ELSE.
ASSIGN ir_t_data->* TO <lt_data>.
TRY.
SELECT (mt_select)
FROM (mt_from)
WHERE (mt_where)
GROUP BY (mt_group_by)
HAVING (mt_having)
ORDER BY (mt_order_by)
INTO CORRESPONDING FIELDS OF TABLE @<lt_data>.
rv_size = lines( <lt_data> ).
CLEAR <lt_data>.
CATCH cx_root INTO lx_root.
RAISE EXCEPTION TYPE zcx_dbbr_selection_common
EXPORTING
previous = lx_root.
ENDTRY.
ENDIF.
ENDMETHOD.
METHOD determine_size.
TRY.
SELECT COUNT( * )
FROM (mt_from)
WHERE (mt_where)
INTO @rv_size.
CATCH cx_root INTO DATA(lx_root).
RAISE EXCEPTION TYPE zcx_dbbr_selection_common
EXPORTING
previous = lx_root.
ENDTRY.
ENDMETHOD.
METHOD determine_size_async.
DATA: lt_sql_lines TYPE string_table.
lt_sql_lines = VALUE #( ( `SELECT COUNT(*)` ) ).
fill_from( CHANGING ct_lines = lt_sql_lines ).
fill_where( CHANGING ct_lines = lt_sql_lines ).
TRY.
zcl_dbbr_sql_query_exec=>execute_query_async(
io_query = NEW zcl_dbbr_sql_query_parser(
iv_query = concat_lines_of( table = lt_sql_lines sep = cl_abap_char_utilities=>cr_lf )
if_fill_log_for_messages = abap_false
)->parse( ) ).
CATCH zcx_dbbr_sql_query_error INTO DATA(lx_error).
RAISE EXCEPTION TYPE zcx_dbbr_selection_common
EXPORTING
previous = lx_error.
ENDTRY.
ENDMETHOD.
METHOD determine_group_by_size_async.
DATA: lt_sql_lines TYPE string_table,
lo_count_query TYPE REF TO zcl_dbbr_sql_query.
IF sy-saprl > 751.
lo_count_query = create_count_query_for_cte( ).
ELSE.
fill_select( CHANGING ct_lines = lt_sql_lines ).
fill_from( CHANGING ct_lines = lt_sql_lines ).
fill_where( CHANGING ct_lines = lt_sql_lines ).
fill_group_by( CHANGING ct_lines = lt_sql_lines ).
fill_having( CHANGING ct_lines = lt_sql_lines ).
TRY.
lo_count_query = NEW zcl_dbbr_sql_query_parser(
iv_query = concat_lines_of( table = lt_sql_lines sep = cl_abap_char_utilities=>cr_lf )
if_fill_log_for_messages = abap_false
)->parse( ).
CATCH zcx_dbbr_sql_query_error INTO DATA(lx_error).
RAISE EXCEPTION TYPE zcx_dbbr_selection_common
EXPORTING
previous = lx_error.
ENDTRY.
ENDIF.
IF lo_count_query IS NOT INITIAL.
zcl_dbbr_sql_query_exec=>execute_query_async(
io_query = lo_count_query
iv_row_count = 0 ).
ENDIF.
ENDMETHOD.
METHOD fill_having.
DATA: lv_having TYPE string.
LOOP AT mt_having ASSIGNING FIELD-SYMBOL(<lv_having>).
CLEAR: lv_having.
IF sy-tabix = 1.
lv_having = | HAVING { <lv_having> }|.
ELSE.
lv_having = | { <lv_having> }|.
ENDIF.
ct_lines = VALUE #( BASE ct_lines ( lv_having ) ).
ENDLOOP.
ENDMETHOD.
METHOD fill_from.
DATA: lv_from TYPE string.
LOOP AT mt_from ASSIGNING FIELD-SYMBOL(<lv_from>).
CLEAR: lv_from.
IF sy-tabix = 1.
lv_from = | FROM { <lv_from> }|.
ELSE.
lv_from = | { <lv_from> }|.
ENDIF.
ct_lines = VALUE #( BASE ct_lines ( lv_from ) ).
ENDLOOP.
ENDMETHOD.
METHOD fill_group_by.
DATA: lv_group_by TYPE string.
LOOP AT mt_group_by ASSIGNING FIELD-SYMBOL(<lv_group_by>).
CLEAR: lv_group_by.
IF sy-tabix = 1.
lv_group_by = | GROUP BY { <lv_group_by> }|.
ELSE.
lv_group_by = | { <lv_group_by> }|.
ENDIF.
ct_lines = VALUE #( BASE ct_lines ( lv_group_by ) ).
ENDLOOP.
ENDMETHOD.
METHOD fill_order_by.
DATA: lv_order_by TYPE string.
LOOP AT mt_order_by ASSIGNING FIELD-SYMBOL(<lv_order_by>).
CLEAR: lv_order_by.
IF sy-tabix = 1.
lv_order_by = | ORDER BY { <lv_order_by> }|.
ELSE.
lv_order_by = | { <lv_order_by> }|.
ENDIF.
ct_lines = VALUE #( BASE ct_lines ( lv_order_by ) ).
ENDLOOP.
ENDMETHOD.
METHOD fill_select.
DATA: lv_select TYPE string.
LOOP AT mt_select ASSIGNING FIELD-SYMBOL(<lv_select>).
CLEAR: lv_select.
IF sy-tabix = 1.
lv_select = |SELECT { <lv_select> }|.
ELSE.
lv_select = | { <lv_select> }|.
ENDIF.
ct_lines = VALUE #( BASE ct_lines ( lv_select ) ).
ENDLOOP.
ENDMETHOD.
METHOD fill_where.
DATA: lv_where TYPE string.
LOOP AT mt_where ASSIGNING FIELD-SYMBOL(<lv_where>).
CLEAR: lv_where.
IF sy-tabix = 1.
lv_where = |WHERE { <lv_where> }|.
ELSE.
lv_where = | { <lv_where> }|.
ENDIF.
ct_lines = VALUE #( BASE ct_lines ( lv_where ) ).
ENDLOOP.
ENDMETHOD.
METHOD select_data.
DATA: lx_root TYPE REF TO cx_root.
TRY.
SELECT (mt_select)
FROM (mt_from)
WHERE (mt_where)
GROUP BY (mt_group_by)
HAVING (mt_having)
ORDER BY (mt_order_by)
INTO CORRESPONDING FIELDS OF TABLE @et_data
UP TO @mv_max_size ROWS.
CATCH cx_root INTO lx_root.
RAISE EXCEPTION TYPE zcx_dbbr_selection_common
EXPORTING
previous = lx_root.
ENDTRY.
ENDMETHOD.
METHOD set_max_rows.
mv_max_size = iv_max_rows.
ENDMETHOD.
METHOD update_from.
mt_from = it_from.
ENDMETHOD.
METHOD get_select_sql.
DATA: lt_sql_lines TYPE string_table.
fill_select( CHANGING ct_lines = lt_sql_lines ).
fill_from( CHANGING ct_lines = lt_sql_lines ).
fill_where( CHANGING ct_lines = lt_sql_lines ).
fill_group_by( CHANGING ct_lines = lt_sql_lines ).
fill_having( CHANGING ct_lines = lt_sql_lines ).
fill_order_by( CHANGING ct_lines = lt_sql_lines ).
CONCATENATE LINES OF lt_sql_lines INTO rv_select_sql SEPARATED BY cl_abap_char_utilities=>cr_lf.
ENDMETHOD.
METHOD create_count_query_for_cte.
DATA: lt_sql_lines TYPE string_table,
lv_query TYPE string.
lt_sql_lines = VALUE #(
( |WITH| )
( | +group_select as (| ) ).
fill_select( CHANGING ct_lines = lt_sql_lines ).
fill_from( CHANGING ct_lines = lt_sql_lines ).
fill_where( CHANGING ct_lines = lt_sql_lines ).
fill_group_by( CHANGING ct_lines = lt_sql_lines ).
fill_having( CHANGING ct_lines = lt_sql_lines ).
lt_sql_lines = VALUE #( BASE lt_sql_lines
( |)| )
( |SELECT COUNT(*) FROM +group_select| ) ).
CONCATENATE LINES OF lt_sql_lines INTO lv_query SEPARATED BY cl_abap_char_utilities=>cr_lf.
TRY.
ro_query = NEW zcl_dbbr_sql_query_parser(
iv_query = lv_query
if_fill_log_for_messages = abap_false
)->parse( ).
CATCH zcx_dbbr_sql_query_error INTO DATA(lx_error).
lx_error->zif_sat_exception_message~print( ).
ENDTRY.
ENDMETHOD.
METHOD get_group_by_size_by_cte.
DATA(lo_count_query) = create_count_query_for_cte( ).
CHECK lo_count_query IS NOT INITIAL.
zcl_dbbr_sql_query_exec=>execute_query(
EXPORTING
io_query = lo_count_query
iv_row_count = mv_max_size
IMPORTING
et_data_info = DATA(lt_data_info)
ev_execution_time = DATA(lv_exec_time)
ev_message = DATA(lv_message)
ev_message_type = DATA(lv_message_type)
er_data = DATA(lr_t_result) ).
zcl_dbbr_sql_query_exec=>get_single_value_from_result(
EXPORTING
it_result_info = lt_data_info
ir_t_data = lr_t_result
IMPORTING
ev_value = rv_size ).
ENDMETHOD.
METHOD on_async_query_finished.
DATA: lv_count TYPE zdbbr_no_of_lines.
FIELD-SYMBOLS: <lt_data> TYPE table.
ASSIGN er_data->* TO <lt_data>.
IF sy-subrc = 0 AND lines( <lt_data> ) > 1.
lv_count = lines( <lt_data> ).
ELSE.
zcl_dbbr_sql_query_exec=>get_single_value_from_result(
EXPORTING it_result_info = et_data_info
ir_t_data = er_data
IMPORTING ev_value = lv_count ).
ENDIF.
RAISE EVENT count_query_finished
EXPORTING
ev_count = lv_count.
ENDMETHOD.
ENDCLASS.
```
| 2,801 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
CLASS zcl_art_shade_rec IMPLEMENTATION.
METHOD constructor.
IF i_world IS SUPPLIED.
ASSERT i_world IS BOUND.
hit_an_object = abap_false.
CREATE OBJECT local_hit_point.
CREATE OBJECT normal.
CREATE OBJECT color
EXPORTING
i_color = zcl_art_rgb_color=>black.
world = i_world.
RETURN.
ENDIF.
IF i_shade_rec IS SUPPLIED.
ASSERT i_shade_rec IS BOUND.
SYSTEM-CALL OBJMGR CLONE i_shade_rec TO me.
ENDIF.
ENDMETHOD.
ENDCLASS.
```
|
I found vulnerabilities in the line:
```abap
SYSTEM-CALL OBJMGR CLONE i_shade_rec TO me.
```
Explanation: Potential dangerous statement SYSTEM-CALL.
Suggested fix:
```abap
CLASS ZCL_ART_SHADE_REC IMPLEMENTATION.
METHOD new_copy.
ASSERT i_shade_rec IS BOUND.
r_instance = NEW #( ).
r_instance->hit_an_object = i_shade_rec->hit_an_object.
r_instance->local_hit_point = zcl_art_point3d=>new_copy( i_shade_rec->local_hit_point ).
r_instance->color = zcl_art_rgb_color=>new_copy( i_shade_rec->color ).
r_instance->world = i_shade_rec->world.
ENDMETHOD.
METHOD new_from_world.
ASSERT i_world IS BOUND.
r_instance = NEW #( ).
r_instance->world = i_world.
r_instance->hit_an_object = abap_false.
r_instance->normal = NEW #( ).
r_instance->local_hit_point = zcl_art_point3d=>new_default( ).
r_instance->color = zcl_art_rgb_color=>new_copy( zcl_art_rgb_color=>black ).
ENDMETHOD.
ENDCLASS.
```
| 2,802 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
METHOD determine_tagged_object_count.
DATA: where TYPE TABLE OF string.
LOOP AT object_refs ASSIGNING FIELD-SYMBOL(<obj_ref>).
DATA(operator) = COND #( WHEN sy-tabix <> 1 THEN ` OR ` ELSE `` ).
where = VALUE #( BASE where
( |{ operator }( OBJECT_TYPE = { cl_abap_dyn_prg=>quote( <obj_ref>-tadir_type ) } | &&
|AND OBJECT_NAME = { cl_abap_dyn_prg=>quote( <obj_ref>-name ) } )| ) ).
ENDLOOP.
SELECT tag_id, COUNT( * ) AS count
FROM zabaptags_tgobj
WHERE (where)
GROUP BY tag_id
INTO CORRESPONDING FIELDS OF TABLE @tagged_obj_counts.
ENDMETHOD.
```
|
I found vulnerabilities in the line:
```abap
SELECT tag_id, COUNT( * ) AS count
```
Explanation: Potential dangerous statement Dynamic SQL.
Suggested fix:
```abap
METHOD determine_tagged_object_count.
tagged_obj_counts = tags_dac->get_tagged_obj_count( object_refs = CORRESPONDING #( object_refs ) ).
ENDMETHOD.
```
| 2,803 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
WHILE child_tags IS NOT INITIAL.
SELECT (fields)
FROM zabaptags_tags
FOR ALL ENTRIES IN @child_tags
WHERE parent_tag_id = @child_tags-tag_id
INTO CORRESPONDING FIELDS OF TABLE @new_child_tags.
tags = CORRESPONDING #( BASE ( tags ) new_child_tags ).
child_tags = CORRESPONDING #( new_child_tags ).
ENDWHILE.
```
|
I found vulnerabilities in the line:
```abap
SELECT (fields)
```
Explanation: Potential dangerous statement Dynamic SQL.
Suggested fix:
```abap
WHILE child_tags IS NOT INITIAL.
new_child_tags = zcl_abaptags_tags_dac=>get_instance( )->find_tags(
columns = columns
parent_tag_id_range = VALUE #( FOR child IN child_tags
( sign = 'I' option = 'EQ' low = child-tag_id ) ) ).
tags = CORRESPONDING #( BASE ( tags ) new_child_tags ).
child_tags = CORRESPONDING #( new_child_tags ).
ENDWHILE.
```
| 2,804 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
METHOD deserialize_program.
DATA: lv_exists TYPE abap_bool,
lv_progname TYPE reposrc-progname,
ls_tpool LIKE LINE OF it_tpool,
lv_title TYPE rglif-title,
ls_progdir_new TYPE progdir.
FIELD-SYMBOLS: <lg_any> TYPE any.
CALL FUNCTION 'RS_CORR_INSERT'
EXPORTING
object = is_progdir-name
object_class = 'ABAP'
devclass = iv_package
master_language = mv_language
mode = 'I'
suppress_dialog = abap_true
EXCEPTIONS
cancelled = 1
permission_failure = 2
unknown_objectclass = 3
OTHERS = 4.
IF sy-subrc <> 0.
zcx_abapgit_exception=>raise_t100( ).
ENDIF.
READ TABLE it_tpool INTO ls_tpool WITH KEY id = 'R'.
IF sy-subrc = 0.
* there is a bug in RPY_PROGRAM_UPDATE, the header line of TTAB is not
* cleared, so the title length might be inherited from a different program.
ASSIGN ('(SAPLSIFP)TTAB') TO <lg_any>.
IF sy-subrc = 0.
CLEAR <lg_any>.
ENDIF.
lv_title = ls_tpool-entry.
ENDIF.
SELECT SINGLE progname FROM reposrc INTO lv_progname
WHERE progname = is_progdir-name
AND r3state = 'A'.
lv_exists = boolc( sy-subrc = 0 ).
IF lv_exists = abap_true.
zcl_abapgit_language=>set_current_language( mv_language ).
CALL FUNCTION 'RPY_PROGRAM_UPDATE'
EXPORTING
program_name = is_progdir-name
title_string = lv_title
save_inactive = 'I'
TABLES
source_extended = it_source
EXCEPTIONS
cancelled = 1
permission_error = 2
not_found = 3
OTHERS = 4.
IF sy-subrc <> 0.
zcl_abapgit_language=>restore_login_language( ).
IF sy-msgid = 'EU' AND sy-msgno = '510'.
zcx_abapgit_exception=>raise( 'User is currently editing program' ).
ELSEIF sy-msgid = 'EU' AND sy-msgno = '522'.
* for generated table maintenance function groups, the author is set to SAP* instead of the user which
* generates the function group. This hits some standard checks, pulling new code again sets the author
* to the current user which avoids the check
zcx_abapgit_exception=>raise( |Delete function group and pull again, { is_progdir-name } (EU522)| ).
ELSE.
zcx_abapgit_exception=>raise( |PROG { is_progdir-name }, updating error: { sy-msgid } { sy-msgno }| ).
ENDIF.
ENDIF.
zcl_abapgit_language=>restore_login_language( ).
ELSEIF strlen( is_progdir-name ) > 30.
* function module RPY_PROGRAM_INSERT cannot handle function group includes
" special treatment for extensions
" if the program name exceeds 30 characters it is not a usual
" ABAP program but might be some extension, which requires the internal
" addition EXTENSION TYPE, see
" http://help.sap.com/abapdocu_751/en/abapinsert_report_internal.htm#!ABAP_ADDITION_1@1@
" This e.g. occurs in case of transportable Code Inspector variants (ending with ===VC)
INSERT REPORT is_progdir-name
FROM it_source
STATE 'I'
EXTENSION TYPE is_progdir-name+30.
IF sy-subrc <> 0.
zcx_abapgit_exception=>raise( 'error from INSERT REPORT .. EXTENSION TYPE' ).
ENDIF.
ELSE.
INSERT REPORT is_progdir-name
FROM it_source
STATE 'I'
PROGRAM TYPE is_progdir-subc.
IF sy-subrc <> 0.
zcx_abapgit_exception=>raise( 'error from INSERT REPORT' ).
ENDIF.
ENDIF.
IF NOT it_tpool[] IS INITIAL.
INSERT TEXTPOOL is_progdir-name
FROM it_tpool
LANGUAGE mv_language
STATE 'I'.
IF sy-subrc <> 0.
zcx_abapgit_exception=>raise( 'error from INSERT TEXTPOOL' ).
ENDIF.
ENDIF.
CALL FUNCTION 'READ_PROGDIR'
EXPORTING
i_progname = is_progdir-name
i_state = 'I'
IMPORTING
e_progdir = ls_progdir_new
EXCEPTIONS
not_exists = 1
OTHERS = 2.
IF sy-subrc <> 0.
zcx_abapgit_exception=>raise( |not found in PROGDIR. Subrc = { sy-subrc }| ).
ENDIF.
* todo, package?
ls_progdir_new-ldbname = is_progdir-ldbname.
ls_progdir_new-dbna = is_progdir-dbna.
ls_progdir_new-dbapl = is_progdir-dbapl.
ls_progdir_new-rload = is_progdir-rload.
ls_progdir_new-fixpt = is_progdir-fixpt.
ls_progdir_new-varcl = is_progdir-varcl.
ls_progdir_new-appl = is_progdir-appl.
ls_progdir_new-rstat = is_progdir-rstat.
ls_progdir_new-sqlx = is_progdir-sqlx.
ls_progdir_new-uccheck = is_progdir-uccheck.
ls_progdir_new-clas = is_progdir-clas.
CALL FUNCTION 'UPDATE_PROGDIR'
EXPORTING
i_progdir = ls_progdir_new
i_progname = ls_progdir_new-name
i_state = ls_progdir_new-state
EXCEPTIONS
not_executed = 1
OTHERS = 2.
IF sy-subrc <> 0.
zcx_abapgit_exception=>raise( |PROG, error inserting. Subrc = { sy-subrc }| ).
ENDIF.
SELECT SINGLE * FROM progdir INTO ls_progdir_new
WHERE name = ls_progdir_new-name
AND state = ls_progdir_new-state.
IF sy-subrc = 0 AND is_progdir-varcl = space AND ls_progdir_new-varcl = abap_true.
* function module UPDATE_PROGDIR does not update VARCL
UPDATE progdir SET varcl = is_progdir-varcl
WHERE name = ls_progdir_new-name
AND state = ls_progdir_new-state. "#EC CI_SUBRC
ENDIF.
zcl_abapgit_objects_activation=>add(
iv_type = 'REPS'
iv_name = is_progdir-name ).
ENDMETHOD.
```
|
I found vulnerabilities in the line:
```abap
ELSE.
INSERT REPORT is_progdir-name * <-- There is a problem here
FROM it_source
```
Explanation: Potential dangerous statement INSERT REPORT.
Suggested fix:
```abap
METHOD deserialize_program.
DATA: lv_exists TYPE abap_bool,
lt_empty_src LIKE it_source,
lv_progname TYPE reposrc-progname,
ls_tpool LIKE LINE OF it_tpool,
lv_title TYPE rglif-title,
ls_progdir_new TYPE progdir.
FIELD-SYMBOLS: <lg_any> TYPE any.
CALL FUNCTION 'RS_CORR_INSERT'
EXPORTING
object = is_progdir-name
object_class = 'ABAP'
devclass = iv_package
master_language = mv_language
mode = 'I'
suppress_dialog = abap_true
EXCEPTIONS
cancelled = 1
permission_failure = 2
unknown_objectclass = 3
OTHERS = 4.
IF sy-subrc <> 0.
zcx_abapgit_exception=>raise_t100( ).
ENDIF.
READ TABLE it_tpool INTO ls_tpool WITH KEY id = 'R'.
IF sy-subrc = 0.
ASSIGN ('(SAPLSIFP)TTAB') TO <lg_any>.
IF sy-subrc = 0.
CLEAR <lg_any>.
ENDIF.
lv_title = ls_tpool-entry.
ENDIF.
SELECT SINGLE progname FROM reposrc INTO lv_progname
WHERE progname = is_progdir-name
AND r3state = 'A'.
lv_exists = boolc( sy-subrc = 0 ).
IF lv_exists = abap_true.
zcl_abapgit_language=>set_current_language( mv_language ).
CALL FUNCTION 'RPY_PROGRAM_UPDATE'
EXPORTING
program_name = is_progdir-name
title_string = lv_title
save_inactive = 'I'
TABLES
source_extended = it_source
EXCEPTIONS
cancelled = 1
permission_error = 2
not_found = 3
OTHERS = 4.
IF sy-subrc <> 0.
zcl_abapgit_language=>restore_login_language( ).
IF sy-msgid = 'EU' AND sy-msgno = '510'.
zcx_abapgit_exception=>raise( 'User is currently editing program' ).
ELSEIF sy-msgid = 'EU' AND sy-msgno = '522'.
zcx_abapgit_exception=>raise( |Delete function group and pull again, { is_progdir-name } (EU522)| ).
ELSE.
zcx_abapgit_exception=>raise_t100( ).
ENDIF.
ENDIF.
zcl_abapgit_language=>restore_login_language( ).
ELSEIF strlen( is_progdir-name ) > 30.
INSERT REPORT is_progdir-name
FROM it_source
STATE 'I'
EXTENSION TYPE is_progdir-name+30.
IF sy-subrc <> 0.
zcx_abapgit_exception=>raise( 'error from INSERT REPORT .. EXTENSION TYPE' ).
ENDIF.
ELSE.
CALL FUNCTION 'RPY_PROGRAM_INSERT'
EXPORTING
development_class = iv_package
program_name = is_progdir-name
program_type = is_progdir-subc
title_string = lv_title
save_inactive = 'I'
suppress_dialog = abap_true
TABLES
source_extended = it_source
EXCEPTIONS
already_exists = 1
cancelled = 2
name_not_allowed = 3
permission_error = 4
OTHERS = 5.
IF sy-subrc <> 0.
zcx_abapgit_exception=>raise_t100( ).
ENDIF.
ENDIF.
IF NOT it_tpool[] IS INITIAL.
INSERT TEXTPOOL is_progdir-name
FROM it_tpool
LANGUAGE mv_language
STATE 'I'.
IF sy-subrc <> 0.
zcx_abapgit_exception=>raise( 'error from INSERT TEXTPOOL' ).
ENDIF.
ENDIF.
CALL FUNCTION 'READ_PROGDIR'
EXPORTING
i_progname = is_progdir-name
i_state = 'I'
IMPORTING
e_progdir = ls_progdir_new
EXCEPTIONS
not_exists = 1
OTHERS = 2.
IF sy-subrc <> 0.
zcx_abapgit_exception=>raise( |not found in PROGDIR. Subrc = { sy-subrc }| ).
ENDIF.
ls_progdir_new-ldbname = is_progdir-ldbname.
ls_progdir_new-dbna = is_progdir-dbna.
ls_progdir_new-dbapl = is_progdir-dbapl.
ls_progdir_new-rload = is_progdir-rload.
ls_progdir_new-fixpt = is_progdir-fixpt.
ls_progdir_new-varcl = is_progdir-varcl.
ls_progdir_new-appl = is_progdir-appl.
ls_progdir_new-rstat = is_progdir-rstat.
ls_progdir_new-sqlx = is_progdir-sqlx.
ls_progdir_new-uccheck = is_progdir-uccheck.
ls_progdir_new-clas = is_progdir-clas.
CALL FUNCTION 'UPDATE_PROGDIR'
EXPORTING
i_progdir = ls_progdir_new
i_progname = ls_progdir_new-name
i_state = ls_progdir_new-state
EXCEPTIONS
not_executed = 1
OTHERS = 2.
IF sy-subrc <> 0.
zcx_abapgit_exception=>raise( |PROG, error inserting. Subrc = { sy-subrc }| ).
ENDIF.
SELECT SINGLE * FROM progdir INTO ls_progdir_new
WHERE name = ls_progdir_new-name
AND state = ls_progdir_new-state.
IF sy-subrc = 0 AND is_progdir-varcl = space AND ls_progdir_new-varcl = abap_true.
UPDATE progdir SET varcl = is_progdir-varcl
WHERE name = ls_progdir_new-name
AND state = ls_progdir_new-state.
ENDIF.
zcl_abapgit_objects_activation=>add(
iv_type = 'REPS'
iv_name = is_progdir-name ).
ENDMETHOD.
```
| 2,805 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
method ADD_TABLE_TO_BUNDLE.
FIELD-SYMBOLS: <con> TYPE STANDARD TABLE.
IF _table-fake_table IS INITIAL.
_table-fake_table = _table-source_table.
ENDIF.
IF line_exists( cluster_objects[ name = _table-fake_table ] ).
RAISE EXCEPTION TYPE zcx_export_table_duplicate
EXPORTING
table = _table-fake_table.
ENDIF.
INSERT _table INTO TABLE table_list.
APPEND INITIAL LINE TO cluster_objects
ASSIGNING FIELD-SYMBOL(<content>).
<content>-name = _table-fake_table.
CREATE DATA <content>-value TYPE STANDARD TABLE OF
(_table-source_table).
ASSIGN <content>-value->* TO <con>.
TRY.
SELECT * FROM (_table-source_table) INTO TABLE @<con>
WHERE (_table-where_restriction).
CATCH cx_sy_dynamic_osql_error INTO DATA(osql_syntax_error).
RAISE EXCEPTION TYPE zcx_export_where_clause_invali
EXPORTING
table = _table-source_table
where_clause = _table-where_restriction
failure_description = osql_syntax_error->msgtext.
ENDTRY.
instance = me.
endmethod.
```
|
I found vulnerabilities in the line:
```abap
SELECT * FROM (_table-source_table) INTO TABLE @<con>
```
Explanation: Potential dangerous statement Dynamic SQL.
Suggested fix:
```abap
METHOD add_table_to_bundle.
FIELD-SYMBOLS: <con> TYPE STANDARD TABLE.
IF _table-fake_table IS INITIAL.
_table-fake_table = _table-source_table.
ENDIF.
IF line_exists( cluster_objects[ name = _table-fake_table ] ).
RAISE EXCEPTION TYPE zcx_export_table_duplicate
EXPORTING
table = _table-fake_table.
ENDIF.
INSERT _table INTO TABLE table_list.
APPEND INITIAL LINE TO cluster_objects
ASSIGNING FIELD-SYMBOL(<content>).
<content>-name = _table-fake_table.
CREATE DATA <content>-value TYPE STANDARD TABLE OF
(_table-source_table).
ASSIGN <content>-value->* TO <con>.
select( EXPORTING table_conjunction = _table
IMPORTING content = <con> ).
instance = me.
ENDMETHOD.
```
| 2,806 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
TRY.
_table-tdc_parameter_name = create_parameter( _table-fake_table ).
CREATE DATA content TYPE STANDARD TABLE OF (_table-source_table).
ASSIGN content->* TO <con>.
SELECT * FROM (_table-source_table) INTO TABLE @<con>
WHERE (_table-where_restriction).
_table-is_initial = xsdbool( <con> IS INITIAL ).
set_parameter_value( content = <con> name = _table-tdc_parameter_name ).
INSERT _table INTO TABLE table_list.
CATCH cx_sy_dynamic_osql_error INTO DATA(osql_syntax_error).
RAISE EXCEPTION TYPE zcx_export_where_clause_invali
EXPORTING
table = _table-source_table
where_clause = _table-where_restriction
failure_description = osql_syntax_error->msgtext.
CATCH cx_ecatt_tdc_access INTO DATA(ecatt_failure).
zcx_export_error=>wrap_ecatt_failure( ecatt_failure ).
ENDTRY.
```
|
I found vulnerabilities in the line:
```abap
SELECT * FROM (_table-source_table) INTO TABLE @<con>
```
Explanation: Potential dangerous statement Dynamic SQL.
Suggested fix:
```abap
TRY.
_table-tdc_parameter_name = create_parameter( _table-fake_table ).
CREATE DATA content TYPE STANDARD TABLE OF (_table-fake_table).
ASSIGN content->* TO <con>.
select( EXPORTING table_conjunction = _table
IMPORTING content = <con> ).
_table-is_initial = xsdbool( <con> IS INITIAL ).
set_parameter_value( content = <con> name = _table-tdc_parameter_name ).
INSERT _table INTO TABLE table_list.
CATCH cx_ecatt_tdc_access INTO DATA(ecatt_failure).
zcx_export_error=>wrap_ecatt_failure( ecatt_failure ).
ENDTRY.
```
| 2,807 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
LOOP AT cluster_objects REFERENCE INTO DATA(object).
ASSIGN object->*-value->* TO <con>.
READ TABLE table_list REFERENCE INTO DATA(_table)
WITH KEY fake_table = CONV tabname( object->*-name ).
ASSERT FIELDS object->*-name CONDITION sy-subrc = 0.
DELETE FROM (object->*-name) WHERE (_table->*-where_restriction).
INSERT (object->*-name) FROM TABLE <con>.
ENDLOOP.
```
|
I found vulnerabilities in the line:
```abap
DELETE FROM (object->*-name) WHERE (_table->*-where_restriction).
```
Explanation: Modify only own DB tables | Potential dangerous statement Dynamic SQL.
Suggested fix:
```abap
LOOP AT cluster_objects REFERENCE INTO DATA(object).
ASSIGN object->*-value->* TO <con>.
READ TABLE table_list REFERENCE INTO DATA(_table)
WITH KEY fake_table = CONV tabname( object->*-name ).
ASSERT FIELDS object->*-name CONDITION sy-subrc = 0.
delete( _table->* ).
INSERT (object->*-name) FROM TABLE <con>.
ENDLOOP.
```
| 2,808 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
LOOP AT table_list REFERENCE INTO DATA(table).
CREATE DATA content TYPE STANDARD TABLE OF (table->*-fake_table).
ASSIGN content->* TO <con>.
tdc->get_value( EXPORTING i_param_name = get_tdc_parameter_name( table->* )
i_variant_name = variant
CHANGING e_param_value = <con> ).
DELETE FROM (table->*-fake_table) WHERE (table->*-where_restriction).
" If no content is exported in other than the "ECATTDEFAULT"-variant,
" <con> contains the parameter value of the "ECATTDEFAULT"-variant.
" Therefore INSERT-Statement is only executed, when the exported content is not initial.
IF table->*-is_initial = abap_false.
MODIFY (table->*-fake_table) FROM TABLE <con>.
ENDIF.
ENDLOOP.
```
|
I found vulnerabilities in the line:
```abap
DELETE FROM (table->*-fake_table) WHERE (table->*-where_restriction).
```
Explanation: Modify only own DB tables | Potential dangerous statement Dynamic SQL.
Suggested fix:
```abap
LOOP AT table_list REFERENCE INTO DATA(table).
CREATE DATA content TYPE STANDARD TABLE OF (table->*-fake_table).
ASSIGN content->* TO <con>.
tdc->get_value( EXPORTING i_param_name = get_tdc_parameter_name( table->* )
i_variant_name = variant
CHANGING e_param_value = <con> ).
delete( table->* ).
IF table->*-is_initial = abap_false.
MODIFY (table->*-fake_table) FROM TABLE <con>.
ENDIF.
ENDLOOP.
```
| 2,809 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
CLASS Y_CHECK_DB_ACCESS_IN_UT IMPLEMENTATION.
METHOD constructor.
super->constructor( ).
settings-pseudo_comment = '"#EC DB_ACCESS_UT' ##NO_TEXT.
settings-disable_threshold_selection = abap_true.
settings-disable_on_prodcode_selection = abap_true.
settings-disable_on_testcode_selection = abap_true.
settings-threshold = 0.
settings-apply_on_productive_code = abap_false.
settings-apply_on_test_code = abap_true.
settings-documentation = |{ c_docs_path-checks }db-access-in-ut.md|.
set_check_message( 'Database access(es) within a Unit-Test should be removed!' ).
ENDMETHOD. "CONSTRUCTOR
METHOD execute_check.
CHECK has_osql_or_cds_framework( ) = abap_false.
LOOP AT ref_scan_manager->get_structures( ) ASSIGNING FIELD-SYMBOL(<structure>)
WHERE stmnt_type EQ scan_struc_stmnt_type-method.
is_testcode = test_code_detector->is_testcode( <structure> ).
IF is_testcode EQ abap_false.
CONTINUE.
ENDIF.
DATA(index) = <structure>-stmnt_from.
LOOP AT ref_scan_manager->get_statements( ) ASSIGNING FIELD-SYMBOL(<statement>)
FROM <structure>-stmnt_from TO <structure>-stmnt_to.
inspect_tokens( index = index
statement = <statement> ).
index = index + 1.
ENDLOOP.
ENDLOOP.
ENDMETHOD.
METHOD inspect_tokens.
DATA(token1) = get_token_abs( statement-from ).
DATA(token2) = get_token_abs( statement-from + 1 ).
DATA(token3) = get_token_abs( statement-from + 2 ).
DATA(has_db_keyword) = xsdbool( token1 = 'COMMIT'
OR token1 = 'ROLLBACK'
OR token1 = 'SELECT'
OR token1 = 'EXEC'
OR token1 = 'ALTER' ).
DATA(is_name_in_token3) = xsdbool( ( token1 = 'INSERT' AND token2 = 'INTO' )
OR ( token1 = 'DELETE' AND token2 = 'FROM' ) ).
DATA(is_name_in_token2) = xsdbool( ( token1 = 'INSERT'
OR token1 = 'UPDATE'
OR token1 = 'MODIFY'
OR token1 = 'DELETE' ) AND token3 = 'FROM' ).
IF has_db_keyword = abap_true
OR ( is_name_in_token3 = abap_true AND is_persistent_object( to_upper( token3 ) ) = abap_true )
OR ( is_name_in_token2 = abap_true AND is_persistent_object( to_upper( token2 ) ) = abap_true ).
check_if_error( index = index
statement = statement ).
ENDIF.
ENDMETHOD.
METHOD is_persistent_object.
TRY.
SELECT SINGLE devclass FROM tadir INTO @DATA(package)
WHERE pgmid = 'R3TR' AND
object = 'TABL' AND
obj_name = @obj_name.
IF sy-subrc NE 0.
result = abap_false.
RETURN.
ENDIF.
DATA(checked_object) = cl_abap_dyn_prg=>check_table_name_str(
val = obj_name
packages = package ).
DATA dynamic_line TYPE REF TO data.
FIELD-SYMBOLS <table_structure> TYPE any.
CREATE DATA dynamic_line TYPE (checked_object).
ASSIGN dynamic_line->* TO <table_structure>.
SELECT SINGLE * FROM (checked_object) INTO <table_structure>.
result = abap_true.
CATCH cx_root. "#EC NEED_CX_ROOT
result = abap_false.
ENDTRY.
ENDMETHOD.
METHOD check_if_error.
DATA check_configuration TYPE y_if_clean_code_manager=>check_configuration.
DATA(key_word) = get_token_abs( statement-from ).
check_configuration = detect_check_configuration( statement ).
IF check_configuration IS INITIAL.
RETURN.
ENDIF.
raise_error( statement_level = statement-level
statement_index = index
statement_from = statement-from
error_priority = check_configuration-prio
parameter_01 = |{ key_word }| ).
ENDMETHOD.
METHOD has_osql_or_cds_framework.
DATA(tokens) = ref_scan_manager->get_tokens( ).
IF line_exists( tokens[ str = 'IF_OSQL_TEST_ENVIRONMENT' ] )
OR line_exists( tokens[ str = 'IF_CDS_TEST_ENVIRONMENT' ] ).
result = abap_true.
ENDIF.
ENDMETHOD.
ENDCLASS.
```
|
I found vulnerabilities in the line:
```abap
SELECT SINGLE * FROM (checked_object) INTO <table_structure>.
```
Explanation: Potential dangerous statement Dynamic SQL.
Suggested fix:
```abap
CLASS y_check_db_access_in_ut IMPLEMENTATION.
METHOD constructor.
super->constructor( ).
settings-pseudo_comment = '
settings-disable_threshold_selection = abap_true.
settings-disable_on_prodcode_selection = abap_true.
settings-disable_on_testcode_selection = abap_true.
settings-threshold = 0.
settings-apply_on_productive_code = abap_false.
settings-apply_on_test_code = abap_true.
settings-documentation = |{ c_docs_path-checks }db-access-in-ut.md|.
set_check_message( 'Database access(es) within a Unit-Test should be removed!' ).
ENDMETHOD.
METHOD execute_check.
LOOP AT ref_scan_manager->get_structures( ) ASSIGNING FIELD-SYMBOL(<structure>)
WHERE stmnt_type EQ scan_struc_stmnt_type-method.
is_testcode = test_code_detector->is_testcode( <structure> ).
IF is_testcode = abap_false.
CONTINUE.
ENDIF.
IF has_osql_or_cds_framework( <structure> ) = abap_true.
CONTINUE.
ENDIF.
determine_tokens_not_allowed( <structure> ).
DATA(index) = <structure>-stmnt_from.
LOOP AT ref_scan_manager->get_statements( ) ASSIGNING FIELD-SYMBOL(<statement>)
FROM <structure>-stmnt_from TO <structure>-stmnt_to.
inspect_tokens( index = index
statement = <statement> ).
index = index + 1.
ENDLOOP.
ENDLOOP.
ENDMETHOD.
METHOD inspect_tokens.
DATA(tokens) = consolidade_tokens( statement ).
LOOP AT tokens_not_allowed ASSIGNING FIELD-SYMBOL(<token_not_allowed>).
IF tokens NP <token_not_allowed>.
CONTINUE.
ENDIF.
IF has_ddic_itab_same_syntax( <token_not_allowed> ) = abap_true
AND is_internal_table( statement ) = abap_true.
CONTINUE.
ENDIF.
DATA(check_configuration) = detect_check_configuration( statement ).
IF check_configuration IS INITIAL.
RETURN.
ENDIF.
raise_error( statement_level = statement-level
statement_index = index
statement_from = statement-from
error_priority = check_configuration-prio ).
ENDLOOP.
ENDMETHOD.
METHOD is_persistent_object.
cl_abap_structdescr=>describe_by_name( EXPORTING p_name = obj_name
EXCEPTIONS OTHERS = 1 ).
result = xsdbool( sy-subrc = 0 ).
ENDMETHOD.
METHOD has_osql_or_cds_framework.
TRY.
DATA(class_definition) = get_class_definition( method ).
CATCH cx_sy_itab_line_not_found.
RETURN.
ENDTRY.
LOOP AT ref_scan_manager->get_statements( ) ASSIGNING FIELD-SYMBOL(<statement>)
FROM class_definition-stmnt_from TO class_definition-stmnt_to.
LOOP AT ref_scan_manager->get_tokens( ) ASSIGNING FIELD-SYMBOL(<token>)
FROM <statement>-from TO <statement>-to
WHERE str = 'IF_OSQL_TEST_ENVIRONMENT'
OR str = 'CL_OSQL_TEST_ENVIRONMENT'
OR str = 'IF_CDS_TEST_ENVIRONMENT'
OR str = 'CL_CDS_TEST_ENVIRONMENT'.
result = abap_true.
RETURN.
ENDLOOP.
ENDLOOP.
ENDMETHOD.
METHOD consolidade_tokens.
LOOP AT ref_scan_manager->get_tokens( ) INTO DATA(token)
FROM statement-from TO statement-to.
token-str = condense( token-str ).
result = COND #( WHEN result IS INITIAL THEN token-str
ELSE |{ result } { token-str }| ).
ENDLOOP.
ENDMETHOD.
METHOD get_class_definition.
DATA(structures) = ref_scan_manager->get_structures( ).
DATA(class_implementation) = structures[ method-back ].
result = structures[ class_implementation-back ].
ENDMETHOD.
METHOD get_test_risk_level.
TRY.
DATA(class_definition) = get_class_definition( method ).
CATCH cx_sy_itab_line_not_found.
RETURN.
ENDTRY.
LOOP AT ref_scan_manager->get_statements( ) ASSIGNING FIELD-SYMBOL(<statement>)
FROM class_definition-stmnt_from TO class_definition-stmnt_to.
DATA(tokens) = consolidade_tokens( <statement> ).
result = COND #( WHEN tokens CS 'RISK LEVEL HARMLESS' THEN risk_level_harmless
WHEN tokens CS 'RISK LEVEL DANGEROUS' THEN risk_level_dangerous
WHEN tokens CS 'RISK LEVEL CRITICAL' THEN risk_level_critical ).
IF result IS NOT INITIAL.
RETURN.
ENDIF.
ENDLOOP.
result = risk_level_not_set.
ENDMETHOD.
METHOD determine_tokens_not_allowed.
DATA(test_risk_level) = get_test_risk_level( method ).
tokens_not_allowed = COND #( WHEN test_risk_level = risk_level_harmless THEN VALUE #( ( 'ALTER *' ) ( 'DELETE *' ) ( 'UPDATE *' ) ( 'MODIFY *' ) ( 'INSERT INTO *' ) ( 'SELECT *' ) ( 'COMMIT*' ) ( 'ROLLBACK*' ) )
WHEN test_risk_level = risk_level_not_set THEN VALUE #( ( 'ALTER *' ) ( 'DELETE *' ) ( 'UPDATE *' ) ( 'MODIFY *' ) ( 'INSERT INTO *' ) ( 'SELECT *' ) ( 'COMMIT*' ) ( 'ROLLBACK*' ) )
WHEN test_risk_level = risk_level_dangerous THEN VALUE #( ( 'ALTER *' ) ( 'DELETE *' ) ( 'UPDATE *' ) ( 'MODIFY *' ) )
WHEN test_risk_level = risk_level_critical THEN VALUE #( ( 'ALTER *' ) ( 'DELETE *' ) ( 'UPDATE *' ) ( 'MODIFY *' ) ) ).
ENDMETHOD.
METHOD has_ddic_itab_same_syntax.
result = xsdbool( token CS 'MODIFY'
OR token CS 'UPDATE'
OR token CS 'DELETE' ).
ENDMETHOD.
METHOD is_internal_table.
result = xsdbool( is_persistent_object( get_token_abs( statement-from + 1 ) ) = abap_false
AND is_persistent_object( get_token_abs( statement-from + 2 ) ) = abap_false ).
ENDMETHOD.
ENDCLASS.
```
| 2,814 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
REPORT zcute_main.
PARAMETERS p_table TYPE tabname16 DEFAULT 'ZCUTE_TEST'.
CLASS lcl_cute_source_information DEFINITION.
PUBLIC SECTION.
CLASS-METHODS get_instance
IMPORTING
source TYPE tabname16
RETURNING
VALUE(instance) TYPE REF TO lcl_cute_source_information.
METHODS read_source
IMPORTING
source TYPE tabname16.
DATA header TYPE dd02v.
DATA technical TYPE dd09v.
DATA components TYPE STANDARD TABLE OF dd03p.
ENDCLASS.
CLASS lcl_cute_source_information IMPLEMENTATION.
METHOD get_instance.
instance = NEW lcl_cute_source_information( ).
instance->read_source( source ).
ENDMETHOD.
METHOD read_source.
DATA source_name TYPE ddobjname.
source_name = source.
CALL FUNCTION 'DDIF_TABL_GET'
EXPORTING
name = source_name
state = 'A'
langu = sy-langu
IMPORTING
dd02v_wa = header
TABLES
dd03p_tab = components
EXCEPTIONS
illegal_input = 1
OTHERS = 2.
IF sy-subrc = 0.
ENDIF.
ENDMETHOD.
ENDCLASS.
CLASS lcl_cute_tab_helper DEFINITION.
PUBLIC SECTION.
CLASS-METHODS get_instance
IMPORTING
source_info TYPE REF TO lcl_cute_source_information
RETURNING
VALUE(instance) TYPE REF TO lcl_cute_tab_helper.
METHODS set_source
IMPORTING
source_info TYPE REF TO lcl_cute_source_information.
METHODS get_components
RETURNING
VALUE(components) TYPE cl_abap_structdescr=>component_table.
METHODS set_components
IMPORTING
components TYPE cl_abap_structdescr=>component_table.
METHODS get_data_reference_edit
RETURNING
VALUE(dataref) TYPE REF TO data.
METHODS get_data_reference_origin
RETURNING
VALUE(dataref) TYPE REF TO data.
METHODS get_field_catalog
RETURNING
VALUE(fcat) TYPE lvc_t_fcat.
PRIVATE SECTION.
METHODS create.
DATA struc_origin_descr TYPE REF TO cl_abap_structdescr.
DATA table_origin_descr TYPE REF TO cl_abap_tabledescr.
DATA table_origin_data TYPE REF TO data.
DATA table_edit_data TYPE REF TO data.
DATA table_edit_descr TYPE REF TO cl_abap_tabledescr.
DATA struc_edit_descr TYPE REF TO cl_abap_structdescr.
DATA source_information TYPE REF TO lcl_cute_source_information.
DATA components TYPE cl_abap_structdescr=>component_table.
ENDCLASS.
CLASS lcl_cute_tab_helper IMPLEMENTATION.
METHOD get_instance.
instance = NEW lcl_cute_tab_helper( ).
instance->set_source( source_info ).
instance->create( ).
ENDMETHOD.
METHOD create.
struc_origin_descr = CAST cl_abap_structdescr( cl_abap_structdescr=>describe_by_name( source_information->header-tabname ) ).
"Needed to save data
table_origin_descr = cl_abap_tabledescr=>create(
p_line_type = struc_origin_descr
p_table_kind = cl_abap_tabledescr=>tablekind_std
p_unique = abap_false ).
CREATE DATA table_origin_data TYPE HANDLE table_origin_descr.
"Adapt editable structure
components = struc_origin_descr->get_components( ).
APPEND VALUE #( name = '_COLOR_' type = CAST cl_abap_datadescr( cl_abap_structdescr=>describe_by_name( 'LVC_T_SCOL' ) ) )
TO components.
struc_edit_descr = cl_abap_structdescr=>create( components ).
table_edit_descr = cl_abap_tabledescr=>create(
p_line_type = struc_edit_descr
p_table_kind = cl_abap_tabledescr=>tablekind_std
p_unique = abap_false ).
CREATE DATA table_edit_data TYPE HANDLE table_edit_descr.
ENDMETHOD.
METHOD set_components.
ENDMETHOD.
METHOD get_components.
ENDMETHOD.
METHOD get_data_reference_edit.
dataref = table_edit_data.
ENDMETHOD.
METHOD get_data_reference_origin.
dataref = table_origin_data.
ENDMETHOD.
METHOD set_source.
source_information = source_info.
ENDMETHOD.
METHOD get_field_catalog.
DATA element_descr TYPE REF TO cl_abap_elemdescr.
DATA field_descr TYPE dfies.
* data(view_components) = struc_edit_descr->get_included_view( ).
LOOP AT components INTO DATA(component).
TRY.
element_descr ?= component-type.
field_descr = element_descr->get_ddic_field( ).
CHECK field_descr-datatype <> 'CLNT'.
APPEND INITIAL LINE TO fcat ASSIGNING FIELD-SYMBOL(<field>).
MOVE-CORRESPONDING field_descr TO <field>.
<field>-fieldname = component-name.
<field>-reptext = field_descr-fieldname.
<field>-scrtext_s = field_descr-fieldname.
<field>-scrtext_m = field_descr-fieldname.
<field>-scrtext_l = field_descr-fieldname.
<field>-ref_table = source_information->header-tabname.
<field>-edit = abap_true.
CATCH cx_sy_move_cast_error.
CONTINUE.
ENDTRY.
ENDLOOP.
ENDMETHOD.
ENDCLASS.
INTERFACE lif_cute.
METHODS edit.
METHODS save.
METHODS check.
METHODS read.
METHODS map_edit_to_origin.
METHODS map_origin_to_edit.
METHODS set_source
IMPORTING
source_info TYPE REF TO lcl_cute_source_information.
DATA source_information TYPE REF TO lcl_cute_source_information.
DATA table_helper TYPE REF TO lcl_cute_tab_helper.
ENDINTERFACE.
CLASS lcx_cute DEFINITION INHERITING FROM cx_static_check. ENDCLASS.
CLASS lcx_cute_unsupported_category DEFINITION INHERITING FROM lcx_cute. ENDCLASS.
CLASS lcl_cute_table DEFINITION.
PUBLIC SECTION.
INTERFACES lif_cute.
PRIVATE SECTION.
DATA grid TYPE REF TO cl_gui_alv_grid.
METHODS edit_grid.
METHODS grid_excluded_functions
RETURNING
VALUE(functions) TYPE ui_functions.
METHODS handle_data_changed
FOR EVENT data_changed OF cl_gui_alv_grid
IMPORTING
er_data_changed
e_ucomm
e_onf4
e_onf4_after
e_onf4_before.
METHODS handle_toolbar
FOR EVENT toolbar OF cl_gui_alv_grid
IMPORTING
e_object
e_interactive.
METHODS handle_user_command
FOR EVENT user_command OF cl_gui_alv_grid
IMPORTING
e_ucomm.
ENDCLASS.
CLASS lcl_cute_table IMPLEMENTATION.
METHOD lif_cute~edit.
lif_cute~table_helper = lcl_cute_tab_helper=>get_instance( lif_cute~source_information ).
lif_cute~read( ).
edit_grid( ).
ENDMETHOD.
METHOD lif_cute~set_source.
lif_cute~source_information = source_info.
ENDMETHOD.
METHOD lif_cute~read.
FIELD-SYMBOLS <table> TYPE table.
DATA(tabref) = lif_cute~table_helper->get_data_reference_origin( ).
ASSIGN tabref->* TO <table>.
SELECT * FROM (lif_cute~source_information->header-tabname)
INTO TABLE <table>.
lif_cute~map_origin_to_edit( ).
ENDMETHOD.
METHOD lif_cute~save.
FIELD-SYMBOLS <origin_data> TYPE table.
lif_cute~map_edit_to_origin( ).
DATA(origin_data) = lif_cute~table_helper->get_data_reference_origin( ).
ASSIGN origin_data->* TO <origin_data>.
MODIFY (lif_cute~source_information->header-tabname)
FROM TABLE <origin_data>.
IF sy-subrc = 0.
MESSAGE 'data has been saved.'(svs) TYPE 'S'.
ELSE.
MESSAGE 'Error saving data... ;('(sve) TYPE 'I'.
ENDIF.
ENDMETHOD.
METHOD lif_cute~check.
ENDMETHOD.
METHOD edit_grid.
FIELD-SYMBOLS <edit_data> TYPE table.
DATA(edit_data) = lif_cute~table_helper->get_data_reference_edit( ).
ASSIGN edit_data->* TO <edit_data>.
grid = NEW #(
i_parent = cl_gui_container=>screen0
i_appl_events = ' ' ).
grid->register_edit_event( cl_gui_alv_grid=>mc_evt_enter ).
grid->set_ready_for_input( 1 ).
SET HANDLER handle_data_changed FOR grid.
SET HANDLER handle_user_command FOR grid.
SET HANDLER handle_toolbar FOR grid.
DATA layout TYPE lvc_s_layo.
DATA(fcat) = lif_cute~table_helper->get_field_catalog( ).
grid->set_table_for_first_display(
EXPORTING
is_variant = VALUE #( handle = 'GRID' report = sy-repid username = sy-uname )
i_save = 'A'
i_default = abap_true
is_layout = layout
it_toolbar_excluding = grid_excluded_functions( )
CHANGING
it_outtab = <edit_data>
it_fieldcatalog = fcat
EXCEPTIONS
invalid_parameter_combination = 1
program_error = 2
too_many_lines = 3
OTHERS = 4 ).
IF sy-subrc = 0.
grid->set_toolbar_interactive( ).
WRITE space.
ENDIF.
ENDMETHOD.
METHOD grid_excluded_functions.
APPEND cl_gui_alv_grid=>mc_mb_view TO functions.
APPEND cl_gui_alv_grid=>mc_fc_reprep TO functions.
APPEND cl_gui_alv_grid=>mc_fc_maximum TO functions.
APPEND cl_gui_alv_grid=>mc_fc_minimum TO functions.
APPEND cl_gui_alv_grid=>mc_mb_sum TO functions.
APPEND cl_gui_alv_grid=>mc_mb_subtot TO functions.
APPEND cl_gui_alv_grid=>mc_fc_graph TO functions.
ENDMETHOD.
METHOD lif_cute~map_edit_to_origin.
DATA(origin_data) = lif_cute~table_helper->get_data_reference_origin( ).
DATA(edit_data) = lif_cute~table_helper->get_data_reference_edit( ).
FIELD-SYMBOLS <origin_data> TYPE table.
FIELD-SYMBOLS <edit_data> TYPE table.
ASSIGN origin_data->* TO <origin_data>.
ASSIGN edit_data->* TO <edit_data>.
<origin_data> = CORRESPONDING #( <edit_data> ).
ENDMETHOD.
METHOD lif_cute~map_origin_to_edit.
DATA(origin_data) = lif_cute~table_helper->get_data_reference_origin( ).
DATA(edit_data) = lif_cute~table_helper->get_data_reference_edit( ).
FIELD-SYMBOLS <origin_data> TYPE table.
FIELD-SYMBOLS <edit_data> TYPE table.
ASSIGN origin_data->* TO <origin_data>.
ASSIGN edit_data->* TO <edit_data>.
<edit_data> = CORRESPONDING #( <origin_data> ).
ENDMETHOD.
METHOD handle_data_changed.
ENDMETHOD.
METHOD handle_toolbar.
DATA button TYPE stb_button.
CLEAR button.
button-butn_type = 3. "Separator
APPEND button TO e_object->mt_toolbar.
"add save button
CLEAR button.
button-function = 'SAVE'.
button-icon = icon_system_save.
button-quickinfo = 'Save data'(svq).
button-butn_type = '0'. "normal Button
button-disabled = ' '.
APPEND button TO e_object->mt_toolbar.
ENDMETHOD.
METHOD handle_user_command.
CASE e_ucomm.
WHEN 'SAVE'.
lif_cute~save( ).
WHEN OTHERS.
ENDCASE.
ENDMETHOD.
ENDCLASS.
CLASS lcl_cute_main DEFINITION.
PUBLIC SECTION.
CLASS-METHODS get_instance
IMPORTING
source TYPE tabname16
RETURNING
VALUE(instance) TYPE REF TO lif_cute
RAISING
lcx_cute.
PROTECTED SECTION.
ENDCLASS.
CLASS lcl_cute_main IMPLEMENTATION.
METHOD get_instance.
DATA(source_info) = lcl_cute_source_information=>get_instance( source ).
CASE source_info->header-tabclass.
WHEN 'TRANSP'.
instance = NEW lcl_cute_table( ).
instance->set_source( source_info ).
WHEN 'VIEW'.
WHEN OTHERS.
RAISE EXCEPTION TYPE lcx_cute_unsupported_category.
ENDCASE.
ENDMETHOD.
ENDCLASS.
START-OF-SELECTION.
TRY.
DATA(cute) = lcl_cute_main=>get_instance( p_table ).
cute->edit( ).
CATCH lcx_cute.
MESSAGE 'error' TYPE 'I'.
ENDTRY.
```
|
I found vulnerabilities in the line:
```abap
SELECT * FROM (lif_cute~source_information->header-tabname)
```
Explanation: Potential dangerous statement Dynamic SQL.
```abap
MODIFY (lif_cute~source_information->header-tabname)
```
Explanation: Modify only own DB tables | Potential dangerous statement Dynamic SQL.
Suggested fix:
```abap
REPORT zcute_main.
PARAMETERS p_table TYPE typename DEFAULT 'ZCUTE_TEST'.
PARAMETERS p_edit TYPE flag RADIOBUTTON GROUP m DEFAULT 'X' USER-COMMAND onli.
PARAMETERS p_show TYPE flag RADIOBUTTON GROUP m .
CLASS lcl_main DEFINITION.
PUBLIC SECTION.
METHODS pbo
IMPORTING
edit TYPE flag.
METHODS pai
IMPORTING
ucomm TYPE syucomm.
METHODS set_status.
METHODS ask_save_data
RETURNING
VALUE(result) TYPE flag.
PRIVATE SECTION.
DATA cc TYPE REF TO cl_gui_custom_container.
DATA cute TYPE REF TO zif_cute.
ENDCLASS.
CLASS lcl_main IMPLEMENTATION.
METHOD pbo.
set_status( ).
TRY.
cute = zcl_cute_main=>get_instance( p_table ).
IF cc IS INITIAL.
cc = NEW #( container_name = 'CC' ).
ENDIF.
cute->set_container( cc ).
IF edit = abap_true.
cute->edit( ).
ELSE.
cute->show( ).
ENDIF.
cl_gui_container=>set_focus( cc ).
CATCH zcx_cute INTO DATA(error).
MESSAGE error TYPE 'E' DISPLAY LIKE 'I'.
ENDTRY.
ENDMETHOD.
METHOD pai.
CASE sy-ucomm.
WHEN 'BACK' OR 'HOME' OR 'CANCEL'.
IF cute->check_input( ) = abap_false.
MESSAGE 'input error' TYPE 'S'.
ENDIF.
IF cute->check_unsaved_data( ) = abap_true.
DATA(answer) = ask_save_data( ).
CASE answer.
WHEN '1'.
cute->save( ).
SET SCREEN 0.
LEAVE SCREEN.
WHEN '2'.
SET SCREEN 0.
LEAVE SCREEN.
WHEN 'A'.
RETURN.
ENDCASE.
ELSE.
SET SCREEN 0.
LEAVE SCREEN.
ENDIF.
WHEN OTHERS.
ENDCASE.
ENDMETHOD.
METHOD ask_save_data.
DATA answer TYPE c LENGTH 1.
CALL FUNCTION 'POPUP_TO_CONFIRM'
EXPORTING
titlebar = 'unsaved data'(001)
text_question = 'Save data before leaving?'(002)
text_button_1 = 'Yes, please'(yes)
icon_button_1 = 'ICON_SYSTEM_SAVE'
text_button_2 = 'No, thanks'(ano)
icon_button_2 = 'ICON_SYSTEM_BACK'
default_button = '1'
display_cancel_button = 'X'
start_column = 25
start_row = 6
popup_type = 'ICON_MESSAGE_QUESTION'
IMPORTING
answer = answer
EXCEPTIONS
text_not_found = 1
OTHERS = 2.
IF sy-subrc = 0.
result = answer.
ENDIF.
ENDMETHOD.
METHOD set_status.
SET PF-STATUS '100'.
IF p_edit = abap_true.
SET TITLEBAR 'EDIT' WITH p_table.
ELSE.
SET TITLEBAR 'SHOW' WITH p_table.
ENDIF.
ENDMETHOD.
ENDCLASS.
DATA main TYPE REF TO lcl_main.
START-OF-SELECTION.
CALL SCREEN 100.
MODULE status_0100 OUTPUT.
CHECK main IS INITIAL.
main = NEW #( ).
main->pbo( p_edit ).
ENDMODULE.
MODULE user_command_0100 INPUT.
main->pai( sy-ucomm ).
ENDMODULE.
```
| 2,816 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
class ZCL_ABAPGIT_USER_EXIT definition
public
final
create public .
public section.
interfaces ZIF_ABAPGIT_EXIT .
protected section.
private section.
ENDCLASS.
CLASS ZCL_ABAPGIT_USER_EXIT IMPLEMENTATION.
method ZIF_ABAPGIT_EXIT~ADJUST_DISPLAY_COMMIT_URL.
return.
endmethod.
method ZIF_ABAPGIT_EXIT~ADJUST_DISPLAY_FILENAME.
return.
endmethod.
method ZIF_ABAPGIT_EXIT~ALLOW_SAP_OBJECTS.
return.
endmethod.
method ZIF_ABAPGIT_EXIT~CHANGE_LOCAL_HOST.
return.
endmethod.
method ZIF_ABAPGIT_EXIT~CHANGE_PROXY_AUTHENTICATION.
return.
endmethod.
method ZIF_ABAPGIT_EXIT~CHANGE_PROXY_PORT.
return.
endmethod.
method ZIF_ABAPGIT_EXIT~CHANGE_PROXY_URL.
return.
endmethod.
method zif_abapgit_exit~change_supported_data_objects.
return.
endmethod.
method ZIF_ABAPGIT_EXIT~CHANGE_SUPPORTED_OBJECT_TYPES.
constants lc_tabname type c length 30 value '/NEPTUNE/ATY' ##no_text.
constants lc_fieldname type c length 30 value 'OBJECT_TYPE' ##no_text.
data lv_tabname type dd02l-tabname.
data lt_ref type ref to data.
field-symbols: <lt_standard_table> type standard table.
field-symbols: <ls_line> type any.
field-symbols: <lv_field> type any.
select single tabname from dd02l into lv_tabname
where tabname = lc_tabname.
check sy-subrc = 0.
create data lt_ref type standard table of (lc_tabname) with non-unique default key.
assign lt_ref->* to <lt_standard_table>.
select *
from (lc_tabname)
into table <lt_standard_table>.
check sy-subrc = 0 and <lt_standard_table> is not initial.
loop at <lt_standard_table> assigning <ls_line>.
assign component lc_fieldname of structure <ls_line> to <lv_field> casting type tadir-object.
if sy-subrc = 0.
append <lv_field> to ct_types.
endif.
endloop.
endmethod.
method zif_abapgit_exit~change_tadir.
data: lt_neptadir type /neptune/if_artifact_type=>ty_t_lcl_tadir.
data lt_api type standard table of /neptune/api.
data ls_api like line of lt_api.
data lt_app type standard table of /neptune/_app.
data ls_app like line of lt_app.
field-symbols <fs_tadir> like line of ct_tadir.
field-symbols <fs_neptadir> like line of lt_neptadir.
**********************************************************************
* break andrec.
check iv_package = '$NEPTUNE_GIT_TESTING'.
try.
" Ongoing from DXP 23 fetch wie tadir framework (all artifacts can be assigned to a devclass)
call method ('/NEPTUNE/CL_TADIR')=>('GET_TADIR_FOR_DEVCLASS') ##CALLED
* call method /neptune/cl_tadir=>get_tadir_for_devclass
exporting
iv_devclass = iv_package
importing
et_tadir = lt_neptadir.
catch cx_sy_dyn_call_illegal_class
cx_sy_dyn_call_illegal_method.
refresh lt_neptadir.
" From version bellow DXP 23 we only support applications and apis
select *
from /neptune/api
into corresponding fields of table lt_api
where devclass = iv_package.
if sy-subrc = 0.
loop at lt_api into ls_api.
append initial line to lt_neptadir assigning <fs_neptadir>.
if sy-subrc = 0.
<fs_neptadir>-artifact_type = 'API'.
<fs_neptadir>-key_mandt = '000'.
<fs_neptadir>-key1 = ls_api-name.
<fs_neptadir>-key1 = ls_api-apiid.
* <fs_neptadir>-devclass = ls_api-devclass.
<fs_neptadir>-artifact_name = ls_api-name.
<fs_neptadir>-object_type = 'ZN02'. " API
endif.
endloop.
endif.
select *
from /neptune/_app
into corresponding fields of table lt_app
where devclass = iv_package.
if sy-subrc = 0.
loop at lt_app into ls_app.
append initial line to lt_neptadir assigning <fs_neptadir>.
if sy-subrc = 0.
<fs_neptadir>-artifact_type = 'APP'.
<fs_neptadir>-key_mandt = '000'.
<fs_neptadir>-key1 = ls_app-applid.
<fs_neptadir>-devclass = ls_app-devclass.
<fs_neptadir>-artifact_name = ls_app-applid.
<fs_neptadir>-object_type = 'ZN01'. " APP
endif.
endloop.
endif.
endtry.
loop at lt_neptadir assigning <fs_neptadir>.
append initial line to ct_tadir assigning <fs_tadir>.
if sy-subrc = 0.
<fs_tadir>-pgmid = 'R3TR'.
<fs_tadir>-object = <fs_neptadir>-object_type.
* if <fs_neptadir>-object_type ne 'ZN05'.
<fs_tadir>-obj_name = <fs_neptadir>-key1.
* else.
* <fs_tadir>-obj_name = <fs_neptadir>-artifact_name.
* endif.
<fs_tadir>-devclass = iv_package.
<fs_tadir>-path = '/src/' .
<fs_tadir>-srcsystem = sy-sysid.
endif.
endloop.
endmethod.
method ZIF_ABAPGIT_EXIT~CREATE_HTTP_CLIENT.
return.
endmethod.
method ZIF_ABAPGIT_EXIT~CUSTOM_SERIALIZE_ABAP_CLIF.
return.
endmethod.
method ZIF_ABAPGIT_EXIT~DESERIALIZE_POSTPROCESS.
return.
endmethod.
method ZIF_ABAPGIT_EXIT~DETERMINE_TRANSPORT_REQUEST.
return.
endmethod.
method ZIF_ABAPGIT_EXIT~ENHANCE_REPO_TOOLBAR.
return.
endmethod.
method ZIF_ABAPGIT_EXIT~GET_CI_TESTS.
return.
endmethod.
method ZIF_ABAPGIT_EXIT~GET_SSL_ID.
return.
endmethod.
method ZIF_ABAPGIT_EXIT~HTTP_CLIENT.
return.
endmethod.
method ZIF_ABAPGIT_EXIT~ON_EVENT.
return.
endmethod.
method ZIF_ABAPGIT_EXIT~PRE_CALCULATE_REPO_STATUS.
return.
endmethod.
method ZIF_ABAPGIT_EXIT~SERIALIZE_POSTPROCESS.
return.
endmethod.
method ZIF_ABAPGIT_EXIT~VALIDATE_BEFORE_PUSH.
return.
endmethod.
method ZIF_ABAPGIT_EXIT~WALL_MESSAGE_LIST.
return.
endmethod.
method ZIF_ABAPGIT_EXIT~WALL_MESSAGE_REPO.
return.
endmethod.
ENDCLASS.
```
|
I found vulnerabilities in the line:
```abap
select * * <-- There is a problem here
from (lc_tabname)
```
Explanation: Potential dangerous statement Dynamic SQL.
Suggested fix:
```abap
class zcl_abapgit_user_exit definition
public
final
create public .
public section.
interfaces zif_abapgit_exit .
protected section.
private section.
endclass.
class zcl_abapgit_user_exit implementation.
method zif_abapgit_exit~adjust_display_commit_url.
return.
endmethod.
method zif_abapgit_exit~adjust_display_filename.
return.
endmethod.
method zif_abapgit_exit~allow_sap_objects.
return.
endmethod.
method zif_abapgit_exit~change_local_host.
return.
endmethod.
method zif_abapgit_exit~change_proxy_authentication.
return.
endmethod.
method zif_abapgit_exit~change_proxy_port.
return.
endmethod.
method zif_abapgit_exit~change_proxy_url.
return.
endmethod.
method zif_abapgit_exit~change_supported_data_objects.
return.
endmethod.
method zif_abapgit_exit~change_supported_object_types.
data: lt_neptune_types type /neptune/cl_abapgit_user_exit=>ty_object_types_tt,
ls_neptune_types like line of lt_neptune_types.
data ls_types like line of ct_types.
lt_neptune_types = /neptune/cl_abapgit_user_exit=>change_supported_object_types( ).
loop at lt_neptune_types into ls_neptune_types.
ls_types = ls_neptune_types.
append ls_types to ct_types.
endloop.
endmethod.
method zif_abapgit_exit~change_tadir.
data: lt_neptune_tadir type /neptune/cl_abapgit_user_exit=>ty_tadir_tt,
ls_neptune_tadir like line of lt_neptune_tadir.
data ls_tadir like line of ct_tadir.
lt_neptune_tadir = /neptune/cl_abapgit_user_exit=>change_tadir( iv_package = iv_package ).
loop at lt_neptune_tadir into ls_neptune_tadir.
move-corresponding ls_neptune_tadir to ls_tadir.
append ls_tadir to ct_tadir.
endloop.
endmethod.
method zif_abapgit_exit~create_http_client.
return.
endmethod.
method zif_abapgit_exit~custom_serialize_abap_clif.
return.
endmethod.
method zif_abapgit_exit~deserialize_postprocess.
return.
endmethod.
method zif_abapgit_exit~determine_transport_request.
return.
endmethod.
method zif_abapgit_exit~enhance_repo_toolbar.
return.
endmethod.
method zif_abapgit_exit~get_ci_tests.
return.
endmethod.
method zif_abapgit_exit~get_ssl_id.
return.
endmethod.
method zif_abapgit_exit~http_client.
return.
endmethod.
method zif_abapgit_exit~on_event.
return.
endmethod.
method zif_abapgit_exit~pre_calculate_repo_status.
return.
endmethod.
method zif_abapgit_exit~serialize_postprocess.
return.
endmethod.
method zif_abapgit_exit~validate_before_push.
return.
endmethod.
method zif_abapgit_exit~wall_message_list.
return.
endmethod.
method zif_abapgit_exit~wall_message_repo.
return.
endmethod.
endclass.
```
| 2,817 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
METHOD insert_program.
CALL FUNCTION 'RPY_PROGRAM_INSERT'
EXPORTING
development_class = iv_package
program_name = is_progdir-name
program_type = is_progdir-subc
title_string = iv_title
save_inactive = 'I'
suppress_dialog = abap_true
TABLES
source_extended = it_source
EXCEPTIONS
already_exists = 1
cancelled = 2
name_not_allowed = 3
permission_error = 4
OTHERS = 5.
IF sy-subrc = 3.
" For cases that standard function does not handle (like FUGR),
" we save active and inactive version of source with the given PROGRAM TYPE.
" Without the active version, the code will not be visible in case of activation errors.
INSERT REPORT is_progdir-name
FROM it_source
STATE 'A'
PROGRAM TYPE is_progdir-subc.
INSERT REPORT is_progdir-name
FROM it_source
STATE 'I'
PROGRAM TYPE is_progdir-subc.
IF sy-subrc <> 0.
zcx_abapgit_exception=>raise( 'Error from INSERT REPORT .. PROGRAM TYPE' ).
ENDIF.
ELSEIF sy-subrc > 0.
zcx_abapgit_exception=>raise_t100( ).
ENDIF.
ENDMETHOD.
```
|
I found vulnerabilities in the line:
```abap
INSERT REPORT is_progdir-name * <-- There is a problem here
FROM it_source
```
Explanation: Potential dangerous statement INSERT REPORT.
```abap
PROGRAM TYPE is_progdir-subc.
INSERT REPORT is_progdir-name * <-- There is a problem here
FROM it_source
```
Explanation: Potential dangerous statement INSERT REPORT.
Suggested fix:
```abap
METHOD insert_program.
TRY.
CALL FUNCTION 'RPY_PROGRAM_INSERT'
EXPORTING
development_class = iv_package
program_name = is_progdir-name
program_type = is_progdir-subc
title_string = iv_title
save_inactive = c_state-inactive
suppress_dialog = abap_true
uccheck = is_progdir-uccheck
TABLES
source_extended = it_source
EXCEPTIONS
already_exists = 1
cancelled = 2
name_not_allowed = 3
permission_error = 4
OTHERS = 5.
CATCH cx_sy_dyn_call_param_not_found.
CALL FUNCTION 'RPY_PROGRAM_INSERT'
EXPORTING
development_class = iv_package
program_name = is_progdir-name
program_type = is_progdir-subc
title_string = iv_title
save_inactive = c_state-inactive
suppress_dialog = abap_true
TABLES
source_extended = it_source
EXCEPTIONS
already_exists = 1
cancelled = 2
name_not_allowed = 3
permission_error = 4
OTHERS = 5.
ENDTRY.
IF sy-subrc = 3.
zcl_abapinst_factory=>get_sap_report( )->insert_report(
iv_name = is_progdir-name
iv_package = iv_package
it_source = it_source
iv_state = c_state-active
iv_version = is_progdir-uccheck
iv_program_type = is_progdir-subc ).
zcl_abapinst_factory=>get_sap_report( )->insert_report(
iv_name = is_progdir-name
iv_package = iv_package
it_source = it_source
iv_state = c_state-inactive
iv_version = is_progdir-uccheck
iv_program_type = is_progdir-subc ).
ELSEIF sy-subrc > 0.
zcx_abapgit_exception=>raise_t100( ).
ENDIF.
ENDMETHOD.
```
| 2,818 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
METHOD create_report.
INSERT REPORT iv_program FROM it_source EXTENSION TYPE iv_extension STATE iv_version PROGRAM TYPE iv_program_type.
ASSERT sy-subrc = 0.
ENDMETHOD.
```
|
I found vulnerabilities in the line:
```abap
INSERT REPORT iv_program FROM it_source EXTENSION TYPE iv_extension STATE iv_version PROGRAM TYPE iv_program_type.
```
Explanation: Potential dangerous statement INSERT REPORT.
Suggested fix:
```abap
METHOD create_report.
zcl_abapinst_factory=>get_sap_report( )->insert_report(
iv_name = iv_program
iv_package = iv_package
it_source = it_source
iv_state = iv_state
iv_version = iv_version
iv_program_type = iv_program_type
iv_extension_type = iv_extension ).
ENDMETHOD.
```
| 2,819 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
METHOD delete_report.
DELETE REPORT iv_program ##SUBRC_OK.
ENDMETHOD.
```
|
I found vulnerabilities in the line:
```abap
DELETE REPORT iv_program ##SUBRC_OK.
```
Explanation: Potential dangerous statement DELETE REPORT.
Suggested fix:
```abap
METHOD delete_report.
zcl_abapinst_factory=>get_sap_report( )->delete_report( iv_program ).
ENDMETHOD.
```
| 2,820 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
METHOD update_report.
DATA: lt_old TYPE string_table.
READ REPORT iv_program INTO lt_old.
IF sy-subrc <> 0.
zcx_abapgit_exception=>raise( |Fatal error. Include { iv_program } should have been created previously!| ).
ENDIF.
IF lt_old <> it_source.
INSERT REPORT iv_program FROM it_source.
ASSERT sy-subrc = 0.
rv_updated = abap_true.
ELSE.
rv_updated = abap_false.
ENDIF.
ENDMETHOD.
```
|
I found vulnerabilities in the line:
```abap
INSERT REPORT iv_program FROM it_source.
```
Explanation: Potential dangerous statement INSERT REPORT.
```abap
INSERT REPORT iv_program FROM it_source.
```
Explanation: Potential dangerous statement INSERT REPORT.
Suggested fix:
```abap
METHOD update_report.
DATA lv_type TYPE c LENGTH 1.
lv_type = zcl_abapgit_oo_base=>c_include_program_type.
IF iv_program+30 = srext_ext_class_pool.
lv_type = zcl_abapgit_oo_base=>c_cp_program_type.
ENDIF.
rv_updated = zcl_abapinst_factory=>get_sap_report( )->update_report(
iv_name = iv_program
iv_package = iv_package
iv_version = iv_version
it_source = it_source
iv_program_type = lv_type ).
ENDMETHOD.
```
| 2,821 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
METHOD deserialize_functions.
DATA: lv_include TYPE rs38l-include,
lv_area TYPE rs38l-area,
lv_group TYPE rs38l-area,
lv_namespace TYPE rs38l-namespace,
lt_source TYPE TABLE OF abaptxt255,
lv_msg TYPE string,
lx_error TYPE REF TO zcx_abapgit_exception.
FIELD-SYMBOLS: <ls_func> LIKE LINE OF it_functions.
LOOP AT it_functions ASSIGNING <ls_func>.
lt_source = zif_abapgit_object~mo_files->read_abap( iv_extra = <ls_func>-funcname ).
lv_area = ms_item-obj_name.
CALL FUNCTION 'FUNCTION_INCLUDE_SPLIT'
EXPORTING
complete_area = lv_area
IMPORTING
namespace = lv_namespace
group = lv_group
EXCEPTIONS
OTHERS = 12.
IF sy-subrc <> 0.
MESSAGE ID sy-msgid TYPE 'S' NUMBER sy-msgno WITH sy-msgv1 sy-msgv2 sy-msgv3 sy-msgv4 INTO lv_msg.
ii_log->add_error( iv_msg = |Function module { <ls_func>-funcname }: { lv_msg }|
is_item = ms_item ).
CONTINUE. "with next function module
ENDIF.
CALL FUNCTION 'FUNCTION_EXISTS'
EXPORTING
funcname = <ls_func>-funcname
IMPORTING
include = lv_include
EXCEPTIONS
function_not_exist = 1.
IF sy-subrc = 0.
* delete the function module to make sure the parameters are updated
* havent found a nice way to update the paramters
CALL FUNCTION 'FUNCTION_DELETE'
EXPORTING
funcname = <ls_func>-funcname
suppress_success_message = abap_true
EXCEPTIONS
error_message = 1
OTHERS = 2.
IF sy-subrc <> 0.
MESSAGE ID sy-msgid TYPE 'S' NUMBER sy-msgno WITH sy-msgv1 sy-msgv2 sy-msgv3 sy-msgv4 INTO lv_msg.
ii_log->add_error( iv_msg = |Function module { <ls_func>-funcname }: { lv_msg }|
is_item = ms_item ).
CONTINUE. "with next function module
ENDIF.
ENDIF.
TRY.
check_rfc_parameters( <ls_func> ).
CATCH zcx_abapgit_exception INTO lx_error.
ii_log->add_error(
iv_msg = |Function module { <ls_func>-funcname }: { lx_error->get_text( ) }|
is_item = ms_item ).
CONTINUE. "with next function module
ENDTRY.
CALL FUNCTION 'RS_FUNCTIONMODULE_INSERT'
EXPORTING
funcname = <ls_func>-funcname
function_pool = lv_group
interface_global = <ls_func>-global_flag
remote_call = <ls_func>-remote_call
short_text = <ls_func>-short_text
update_task = <ls_func>-update_task
exception_class = <ls_func>-exception_classes
namespace = lv_namespace
remote_basxml_supported = <ls_func>-remote_basxml
corrnum = iv_transport
IMPORTING
function_include = lv_include
TABLES
import_parameter = <ls_func>-import
export_parameter = <ls_func>-export
tables_parameter = <ls_func>-tables
changing_parameter = <ls_func>-changing
exception_list = <ls_func>-exception
parameter_docu = <ls_func>-documentation
EXCEPTIONS
double_task = 1
error_message = 2
function_already_exists = 3
invalid_function_pool = 4
invalid_name = 5
too_many_functions = 6
no_modify_permission = 7
no_show_permission = 8
enqueue_system_failure = 9
canceled_in_corr = 10
OTHERS = 11.
IF sy-subrc <> 0.
MESSAGE ID sy-msgid TYPE 'S' NUMBER sy-msgno WITH sy-msgv1 sy-msgv2 sy-msgv3 sy-msgv4 INTO lv_msg.
ii_log->add_error( iv_msg = |Function module { <ls_func>-funcname }: { lv_msg }|
is_item = ms_item ).
CONTINUE. "with next function module
ENDIF.
INSERT REPORT lv_include FROM lt_source.
ii_log->add_success( iv_msg = |Function module { <ls_func>-funcname } imported|
is_item = ms_item ).
ENDLOOP.
ENDMETHOD.
```
|
I found vulnerabilities in the line:
```abap
INSERT REPORT lv_include FROM lt_source.
```
Explanation: Potential dangerous statement INSERT REPORT.
Suggested fix:
```abap
METHOD deserialize_functions.
DATA: lv_include TYPE rs38l-include,
lv_area TYPE rs38l-area,
lv_group TYPE rs38l-area,
lv_namespace TYPE rs38l-namespace,
lt_source TYPE TABLE OF abaptxt255,
lv_msg TYPE string,
lx_error TYPE REF TO zcx_abapgit_exception.
FIELD-SYMBOLS: <ls_func> LIKE LINE OF it_functions.
LOOP AT it_functions ASSIGNING <ls_func>.
lt_source = zif_abapgit_object~mo_files->read_abap( iv_extra = <ls_func>-funcname ).
lv_area = ms_item-obj_name.
CALL FUNCTION 'FUNCTION_INCLUDE_SPLIT'
EXPORTING
complete_area = lv_area
IMPORTING
namespace = lv_namespace
group = lv_group
EXCEPTIONS
OTHERS = 12.
IF sy-subrc <> 0.
MESSAGE ID sy-msgid TYPE 'S' NUMBER sy-msgno WITH sy-msgv1 sy-msgv2 sy-msgv3 sy-msgv4 INTO lv_msg.
ii_log->add_error( iv_msg = |Function module { <ls_func>-funcname }: { lv_msg }|
is_item = ms_item ).
CONTINUE.
ENDIF.
IF zcl_abapinst_factory=>get_function_module( )->function_exists( <ls_func>-funcname ) = abap_true.
CALL FUNCTION 'FUNCTION_DELETE'
EXPORTING
funcname = <ls_func>-funcname
suppress_success_message = abap_true
EXCEPTIONS
error_message = 1
OTHERS = 2.
IF sy-subrc <> 0.
MESSAGE ID sy-msgid TYPE 'S' NUMBER sy-msgno WITH sy-msgv1 sy-msgv2 sy-msgv3 sy-msgv4 INTO lv_msg.
ii_log->add_error( iv_msg = |Function module { <ls_func>-funcname }: { lv_msg }|
is_item = ms_item ).
CONTINUE.
ENDIF.
ENDIF.
TRY.
check_rfc_parameters( <ls_func> ).
CATCH zcx_abapgit_exception INTO lx_error.
ii_log->add_error(
iv_msg = |Function module { <ls_func>-funcname }: { lx_error->get_text( ) }|
is_item = ms_item ).
CONTINUE.
ENDTRY.
CALL FUNCTION 'RS_FUNCTIONMODULE_INSERT'
EXPORTING
funcname = <ls_func>-funcname
function_pool = lv_group
interface_global = <ls_func>-global_flag
remote_call = <ls_func>-remote_call
short_text = <ls_func>-short_text
update_task = <ls_func>-update_task
exception_class = <ls_func>-exception_classes
namespace = lv_namespace
remote_basxml_supported = <ls_func>-remote_basxml
corrnum = iv_transport
IMPORTING
function_include = lv_include
TABLES
import_parameter = <ls_func>-import
export_parameter = <ls_func>-export
tables_parameter = <ls_func>-tables
changing_parameter = <ls_func>-changing
exception_list = <ls_func>-exception
parameter_docu = <ls_func>-documentation
EXCEPTIONS
double_task = 1
error_message = 2
function_already_exists = 3
invalid_function_pool = 4
invalid_name = 5
too_many_functions = 6
no_modify_permission = 7
no_show_permission = 8
enqueue_system_failure = 9
canceled_in_corr = 10
OTHERS = 11.
IF sy-subrc <> 0.
MESSAGE ID sy-msgid TYPE 'S' NUMBER sy-msgno WITH sy-msgv1 sy-msgv2 sy-msgv3 sy-msgv4 INTO lv_msg.
ii_log->add_error( iv_msg = |Function module { <ls_func>-funcname }: { lv_msg }|
is_item = ms_item ).
CONTINUE.
ENDIF.
zcl_abapinst_factory=>get_sap_report( )->insert_report(
iv_name = lv_include
iv_package = iv_package
iv_version = iv_version
it_source = lt_source ).
ii_log->add_success( iv_msg = |Function module { <ls_func>-funcname } imported|
is_item = ms_item ).
ENDLOOP.
ENDMETHOD.
```
| 2,822 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
METHOD deserialize_with_ext.
" Special treatment for extensions
" If the program name exceeds 30 characters it is not a usual ABAP program but might be
" some extension, which requires the internal addition EXTENSION TYPE
" https://help.sap.com/doc/abapdocu_755_index_htm/7.55/en-US/index.htm?file=abapinsert_report_internal.htm
" This e.g. occurs in case of transportable Code Inspector variants (ending with ===VC)
INSERT REPORT is_progdir-name
FROM it_source
STATE 'I'
EXTENSION TYPE is_progdir-name+30
PROGRAM TYPE is_progdir-subc.
IF sy-subrc <> 0.
zcx_abapgit_exception=>raise( 'Error from INSERT REPORT .. EXTENSION TYPE' ).
ENDIF.
CALL FUNCTION 'UPDATE_PROGDIR'
EXPORTING
i_progdir = is_progdir
i_progname = is_progdir-name
i_state = 'I'
EXCEPTIONS
not_executed = 1
OTHERS = 2.
IF sy-subrc <> 0.
zcx_abapgit_exception=>raise( 'Error updating program directory' ).
ENDIF.
zcl_abapgit_objects_activation=>add(
iv_type = 'REPS'
iv_name = is_progdir-name ).
ENDMETHOD.
```
|
I found vulnerabilities in the line:
```abap
INSERT REPORT is_progdir-name
```
Explanation: Potential dangerous statement INSERT REPORT.
Suggested fix:
```abap
METHOD deserialize_with_ext.
zcl_abapinst_factory=>get_sap_report( )->insert_report(
iv_name = is_progdir-name
iv_package = iv_package
it_source = it_source
iv_state = 'I'
iv_version = is_progdir-uccheck
iv_program_type = is_progdir-subc
iv_extension_type = is_progdir-name+30 ).
zcl_abapinst_factory=>get_sap_report( )->update_progdir(
is_progdir = is_progdir
iv_state = 'I'
iv_package = iv_package ).
zcl_abapgit_objects_activation=>add(
iv_type = 'REPS'
iv_name = is_progdir-name ).
ENDMETHOD.
```
| 2,823 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
CLASS lcl_app IMPLEMENTATION.
METHOD main.
DATA(app) = NEW lcl_app( ).
app->main_2( ).
ENDMETHOD.
METHOD main_2.
DATA shrinker TYPE REF TO zcl_shrinker.
DATA(include_does_not_exist) = CONV string( 'Include &1 does not exist. Create it manually as empty.'(001) ).
SELECT SINGLE * FROM trdir WHERE name = @p_def INTO @DATA(trdir_def).
IF sy-subrc <> 0.
RAISE EXCEPTION TYPE zcx_shrinker EXPORTING text = include_does_not_exist msgv1 = p_def.
ENDIF.
SELECT SINGLE * FROM trdir WHERE name = @p_imp INTO @DATA(trdir_imp).
IF sy-subrc <> 0.
RAISE EXCEPTION TYPE zcx_shrinker EXPORTING text = include_does_not_exist msgv1 = p_def.
ENDIF.
"**********************************************************************
"* Copy database tables
"**********************************************************************
objects_to_copy = VALUE #(
( object = 'TABL' source_obj_name = 'ZSHRINKER_GTT_EC' target_obj_name = p_tab_ec )
( object = 'TABL' source_obj_name = 'ZSHRINKER_GTT_IN' target_obj_name = p_tab_in )
( object = 'TABL' source_obj_name = 'ZSHRINKER_GTT_MP' target_obj_name = p_tab_mp ) ).
shrinker = zcl_shrinker=>create( ).
shrinker->copy_objects(
EXPORTING
source_package = p_frdevc
target_package = p_todevc
user_exit = me
objects = objects_to_copy ).
"**********************************************************************
"* Classes and interfaces all together in DEF and IMP includes
"**********************************************************************
shrinker = zcl_shrinker=>create( ).
DATA(abap_code) = shrinker->get_one_abap_code(
package_range = VALUE #( ( sign = 'I' option = 'EQ' low = p_frdevc ) )
range_of_obj_type = VALUE #( sign = 'I' option = 'EQ' ( low = 'CLAS' ) ( low = 'INTF' ) ( low = 'PROG' ) )
global_replacements = VALUE #( ( posix_regex = '\<Z(.._SHRINKER\w*)' with = 'L$1' start_of_abap_word = abap_true member_interface_prefix = abap_true )
( LINES OF VALUE #( FOR <object_to_copy> IN objects_to_copy
( posix_regex = <object_to_copy>-source_obj_name with = <object_to_copy>-target_obj_name ) ) ) ) ).
DATA(header_lines) = VALUE string_table(
( `********************************************************************************` )
( `* ` )
( `* LICENSE and NOTICE ` )
( `* ` )
( |* See include program { p_licens WIDTH = 30 } | )
( `* ` )
( `********************************************************************************` ) ).
INSERT LINES OF header_lines
INTO abap_code-def_abap_source_code
INDEX 1.
INSERT LINES OF header_lines
INTO abap_code-imp_abap_source_code
INDEX 1.
DATA(syntax_check) = shrinker->syntax_check( VALUE #(
( `REPORT.` )
( LINES OF abap_code-def_abap_source_code )
( LINES OF abap_code-imp_abap_source_code ) ) ).
IF syntax_check-mess IS NOT INITIAL.
RAISE EXCEPTION TYPE zcx_shrinker EXPORTING text = 'Syntax error &1'(001) msgv1 = syntax_check-mess.
ENDIF.
INSERT REPORT p_def FROM abap_code-def_abap_source_code DIRECTORY ENTRY trdir_def.
INSERT REPORT p_imp FROM abap_code-imp_abap_source_code DIRECTORY ENTRY trdir_imp.
COMMIT WORK.
ENDMETHOD.
METHOD zif_shrinker_user_exit_abapgit~is_to_be_deserialized.
IF line_exists( objects_to_copy[ object = object
target_obj_name = obj_name ] ).
result = abap_true.
ENDIF.
ENDMETHOD.
ENDCLASS.
```
|
I found vulnerabilities in the line:
```abap
INSERT REPORT p_def FROM abap_code-def_abap_source_code DIRECTORY ENTRY trdir_def.
```
Explanation: Potential dangerous statement INSERT REPORT.
Suggested fix:
```abap
CLASS lcl_app IMPLEMENTATION.
METHOD main.
DATA(app) = NEW lcl_app( ).
app->main_2( ).
ENDMETHOD.
METHOD main_2.
header_lines = VALUE #(
( `********************************************************************************` )
( `* ` )
( `* LICENSE and NOTICE ` )
( `* ` )
( |* See include program { p_licens WIDTH = 30 } | )
( `* ` )
( `********************************************************************************` ) ).
IF p_tab_ec IS NOT INITIAL.
INSERT VALUE #( object = 'TABL' source_obj_name = 'ZSHRINKER_GTT_EC' target_obj_name = p_tab_ec )
INTO TABLE objects_to_copy.
ENDIF.
IF p_tab_in IS NOT INITIAL.
INSERT VALUE #( object = 'TABL' source_obj_name = 'ZSHRINKER_GTT_IN' target_obj_name = p_tab_in )
INTO TABLE objects_to_copy.
ENDIF.
IF p_tab_mp IS NOT INITIAL.
INSERT VALUE #( object = 'TABL' source_obj_name = 'ZSHRINKER_GTT_MP' target_obj_name = p_tab_mp )
INTO TABLE objects_to_copy.
ENDIF.
IF p_cl_dci IS NOT INITIAL.
INSERT VALUE #( object = 'CLAS' source_obj_name = 'ZCL_SHRINKER_DDIC_CLASS_INTERF' target_obj_name = p_cl_dci )
INTO TABLE objects_to_copy.
ENDIF.
IF p_cl_ap IS NOT INITIAL.
INSERT VALUE #( object = 'CLAS' source_obj_name = 'ZCL_SHRINKER_ANY_PROGRAM' target_obj_name = p_cl_ap )
INTO TABLE objects_to_copy.
ENDIF.
IF p_cl_as IS NOT INITIAL.
INSERT VALUE #( object = 'CLAS' source_obj_name = 'ZCL_SHRINKER_ABAP_SCAN' target_obj_name = p_cl_as )
INTO TABLE objects_to_copy.
ENDIF.
IF p_cl_uti IS NOT INITIAL.
INSERT VALUE #( object = 'CLAS' source_obj_name = 'ZCL_SHRINKER_UTILS' target_obj_name = p_cl_uti )
INTO TABLE objects_to_copy.
ENDIF.
IF p_cx IS NOT INITIAL.
INSERT VALUE #( object = 'CLAS' source_obj_name = 'ZCX_SHRINKER' target_obj_name = p_cx )
INTO TABLE objects_to_copy.
ENDIF.
IF p_if_aca IS NOT INITIAL.
INSERT VALUE #( object = 'INTF' source_obj_name = 'ZIF_SHRINKER_ABAP_CODE_ADAPTER' target_obj_name = p_if_aca )
INTO TABLE objects_to_copy.
ENDIF.
IF p_if_uea IS NOT INITIAL.
INSERT VALUE #( object = 'INTF' source_obj_name = 'ZIF_SHRINKER_USER_EXIT_ABAPGIT' target_obj_name = p_if_uea )
INTO TABLE objects_to_copy.
ENDIF.
DATA(shrinker_copy_objects) = zcl_shrinker_copy_objects=>create( me ).
shrinker_copy_objects->run(
source_package = p_frdevc
target_package = p_todevc
user_exit = me
objects = objects_to_copy ).
ENDMETHOD.
METHOD zif_shrinker_abap_code_adapter~adapt_source_code.
LOOP AT other_source_units REFERENCE INTO DATA(source_unit).
INSERT LINES OF header_lines INTO source_unit->abap_source_code INDEX 1.
ENDLOOP.
ENDMETHOD.
METHOD zif_shrinker_abap_code_adapter~adapt_source_code_before_rep_i.
ENDMETHOD.
METHOD zif_shrinker_user_exit_abapgit~is_to_be_deserialized.
IF line_exists( objects_to_copy[ object = object
target_obj_name = obj_name ] ).
result = abap_true.
ENDIF.
ENDMETHOD.
ENDCLASS.
```
| 2,824 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
CLASS zcl_zabap_table_edit_tab_data IMPLEMENTATION.
METHOD constructor.
config = configuration.
table-fields = NEW #( table_name = config-table_name ). "TODO as interface
table-locker = NEW #( table_name = config-table_name ). "TODO as interface
table-comparator = NEW #( table_name = config-table_name ). "TODO as interface
"---TEXT TABLE---
table-text_table = zcl_zabap_table_edit_factory=>get_text_table( CORRESPONDING #( me->config ) ).
table-text_table->append_additional_fields( CHANGING additional_fields = table-additional_fields ).
* "---MAINTANANCE VIEW---
* setup_maintenance_view( ).
setup_grid( ).
"---EXTENSION CALL---
config-ext-data->additional_fields( CHANGING additional_fields = table-additional_fields ).
prepare_initial_data( ).
table-db = zcl_zabap_table_edit_factory=>get_db( ).
ENDMETHOD.
METHOD setup_grid.
grid = NEW cl_gui_alv_grid( zcl_zabap_screen_with_containe=>get_container( ) ).
grid->register_edit_event( cl_gui_alv_grid=>mc_evt_modified ). "Allows to catch edit events
grid->register_edit_event( cl_gui_alv_grid=>mc_evt_enter ). "Allows also to catch Enter
SET HANDLER on_data_changed FOR grid.
SET HANDLER config-ext-data->on_data_changed FOR grid.
SET HANDLER config-ext-data->on_data_changed_finished FOR grid.
"---EXTENSION CALL---
config-ext-config->grid_setup( CHANGING grid = grid ).
ENDMETHOD.
METHOD setup_maintenance_view.
"TODO
* text_table = NEW zcl_zabap_table_edit_text_tab( original_table = table_name change_doc_type = change_doc_type ).
* text_table->append_additional_fields( CHANGING additional_fields = additional_fields ).
ENDMETHOD.
METHOD prepare_initial_data.
"TODO maint view?
CREATE DATA table-initial_data TYPE TABLE OF (config-table_name).
assign_to_table_fs table-initial_data->* <initial_data>.
table-fields->get_table_with_add_fields( EXPORTING additional_fields = table-additional_fields IMPORTING table = DATA(table_descr) ).
CREATE DATA table-modified_data_ext TYPE HANDLE table_descr.
DATA(execute_default_select) = abap_true.
"---EXTENSION CALL---
config-ext-data->default_select( CHANGING execute = execute_default_select ).
IF execute_default_select = abap_true.
SELECT * FROM (config-table_name) INTO TABLE @<initial_data> ORDER BY PRIMARY KEY.
"TODO maintenance view
ENDIF.
"---EXTENSION CALL---
config-ext-data->initial_data( CHANGING initial_data = table-initial_data ).
ENDMETHOD.
METHOD lock_table.
IF table-locker->lock_table( IMPORTING error_message = error_message ) = abap_false.
RETURN.
ENDIF.
"---TEXT TABLE---
IF table-text_table->lock_table( IMPORTING error_message = error_message ) = abap_false.
table-locker->unlock_table( ).
RETURN.
ENDIF.
locked = abap_true.
ENDMETHOD.
METHOD unlock_table.
table-locker->unlock_table( ).
table-text_table->unlock_table( ).
ENDMETHOD.
METHOD reset_grid.
was_data_changed = abap_false.
"You have declare <fs> type table, and assign dynamic table, because you can't just use corresponding with table-initial_data->* :(
assign_to_table_fs table-initial_data->* <initial_data>.
assign_to_table_fs table-modified_data_ext->* <modified_data_ext>.
<modified_data_ext> = CORRESPONDING #( <initial_data> ).
"---TEXT TABLE---
table-text_table->update_text_elements( CHANGING extended = table-modified_data_ext ).
table-fields->set_edit_mode( in_edit_mode ).
DATA(fc) = table-fields->get_fc_with_add_fields( table-additional_fields ).
"---EXTENSION CALL---
config-ext-data->refresh_grid( EXPORTING in_edit_mode = in_edit_mode
CHANGING field_catalogue = fc initial_data = table-initial_data modified_data_ext = table-modified_data_ext ).
DATA(field_cat) = CORRESPONDING lvc_t_fcat( fc ).
grid->set_table_for_first_display( EXPORTING is_variant = VALUE #( report = config-table_name handle = 'BASE' username = sy-uname )
is_layout = VALUE #( sel_mode = 'A' ) i_save = 'A'
CHANGING it_outtab = <modified_data_ext> it_fieldcatalog = field_cat ).
ENDMETHOD.
METHOD validate.
grid->check_changed_data( IMPORTING e_valid = DATA(valid) ).
IF valid = abap_false.
result = zcl_zabap_table_edit_globals=>c_validation-incorrect_values.
RETURN.
ENDIF.
table-comparator->update_mandant( table-modified_data_ext ).
DATA(modified_data) = get_modified_data_no_ext( ).
table-comparator->compare_tables( EXPORTING initial_data = table-initial_data modified_data = modified_data
IMPORTING duplicates = compared-duplicates inserted = compared-inserted deleted = compared-deleted
before_modified = compared-before_modified modified = compared-modified ).
assign_to_table_fs compared-duplicates->* <duplicates>.
IF lines( <duplicates> ) > 0.
result = zcl_zabap_table_edit_globals=>c_validation-duplicates.
RETURN.
ENDIF.
result = zcl_zabap_table_edit_globals=>c_validation-ok.
"---EXTENSION CALL---
config-ext-data->additional_validation( CHANGING result = result all_modified_data = modified_data compared = compared ).
ENDMETHOD.
METHOD save_data.
TRY.
"---EXTENSION CALL---
config-ext-data->before_save( CHANGING compared = compared ).
assign_to_table_fs compared-modified->* <modified>.
assign_to_table_fs compared-inserted->* <inserted>.
assign_to_table_fs compared-deleted->* <deleted>.
"Actual db changes
table-db->delete_data( table = config-table_name table_data = <deleted> ).
IF table-fields->key_fields_only = abap_true.
"^Can't use modify if all fields are key fields. Also in this case it's impossible to have modified entries.
table-db->insert_data( table = config-table_name table_data = <inserted> ).
ELSE.
table-db->modify_data( table = config-table_name table_data = <modified> ).
table-db->modify_data( table = config-table_name table_data = <inserted> ).
ENDIF.
"Change doc creation
IF config-change_doc_type <> space.
create_change_doc( compared ).
ENDIF.
"---TEXT TABLE---
table-text_table->save( initial = table-initial_data extended = table-modified_data_ext ).
"Commmit all and check for errors
COMMIT WORK AND WAIT.
IF sy-subrc <> 0.
RAISE EXCEPTION TYPE zcx_zabap_table_edit EXPORTING custom_message = |SAP LUW commit returned { sy-subrc }|.
ENDIF.
"---EXTENSION CALL---
config-ext-data->after_save( CHANGING compared = compared ).
prepare_initial_data( ).
sucess = abap_true.
CATCH zcx_zabap_table_edit INTO DATA(zcx).
sucess = abap_false.
ROLLBACK WORK.
erorr_message = zcx->get_text( ).
ENDTRY.
ENDMETHOD.
METHOD create_change_doc.
DATA(cd) = ZCL_ZABAP_TABLE_EDIT_FACTORY=>get_change_doc( objectclass = CONV #( config-table_name ) objectid = CONV #( config-table_name ) ).
cd->open( ).
cd->change_multi( force_cd_on_all_fields = COND #( WHEN config-change_doc_type = 'F' THEN abap_true ELSE abap_false )
table_name = config-table_name
deleted = cd->create_table_with_indicator( table_name = config-table_name original_table = compared-deleted indicator = 'D' )
inserted = cd->create_table_with_indicator( table_name = config-table_name original_table = compared-deleted indicator = 'I' )
before_modified = cd->create_table_with_indicator( table_name = config-table_name original_table = compared-deleted indicator = 'U' )
modified = cd->create_table_with_indicator( table_name = config-table_name original_table = compared-deleted ) ).
"Some SAP magic to get initial t-code
DATA: original_tcode TYPE sytcode.
CALL 'GET_PARAM_TCOD' ID 'PTCOD' FIELD original_tcode.
cd->close( tcode = original_tcode ).
ENDMETHOD.
METHOD on_data_changed.
was_data_changed = abap_true.
ENDMETHOD.
METHOD get_modified_data_no_ext.
CREATE DATA modified_data TYPE TABLE OF (config-table_name).
assign_to_table_fs modified_data->* <modified_data>.
assign_to_table_fs table-modified_data_ext->* <modified_data_ext>.
<modified_data> = CORRESPONDING #( <modified_data_ext> ).
ENDMETHOD.
METHOD get_selected_row_index.
grid->get_selected_rows( IMPORTING et_index_rows = DATA(selected_rows) ).
IF lines( selected_rows ) = 1.
index = selected_rows[ 1 ]-index.
RETURN.
ENDIF.
grid->get_selected_cells( IMPORTING et_cell = DATA(selected_cells) ).
IF lines( selected_cells ) = 1.
index = selected_cells[ 1 ]-row_id.
RETURN.
ENDIF.
ENDMETHOD.
METHOD get_selected_row_key.
DATA(selected) = get_selected_row_index( ).
IF selected = 0.
RETURN.
ENDIF.
"Build and fill tabkey of selected record
assign_to_table_fs table-modified_data_ext->* <modified_data_ext>.
"Create key struct to cast to cdtabkey - needed to extract just key fields
table-fields->get_keys_structure( EXPORTING include_index_field = abap_false IMPORTING struct = DATA(key_struct) ).
DATA key_line TYPE REF TO data.
CREATE DATA key_line TYPE HANDLE key_struct.
FIELD-SYMBOLS <key_line> TYPE any.
ASSIGN key_line->* TO <key_line>.
"TODO check with decimals
<key_line> = CORRESPONDING #( <modified_data_ext>[ selected ] ).
tabkey = <key_line>.
* DATA cdtabkeylo TYPE cdtabkeylo.
* cdtabkeylo = <key_line>.
* "Can't assign directly to string
* tabkey = cdtabkeylo.
ENDMETHOD.
ENDCLASS.
```
|
I found vulnerabilities in the line:
```abap
CALL 'GET_PARAM_TCOD' ID 'PTCOD' FIELD original_tcode.
```
Explanation: Potential dangerous statement KERNEL CALL.
Suggested fix:
```abap
CLASS zcl_zabap_table_edit_tab_data IMPLEMENTATION.
METHOD constructor.
config = configuration.
table-fields = NEW #( table_name = config-table_name ).
table-locker = NEW #( table_name = config-table_name ).
table-comparator = NEW #( table_name = config-table_name ).
table-text_table = zcl_zabap_table_edit_factory=>get_text_table( CORRESPONDING #( me->config ) ).
table-text_table->append_additional_fields( CHANGING additional_fields = table-additional_fields ).
me->grid = grid.
setup_grid( ).
config-ext-data->additional_fields( CHANGING additional_fields = table-additional_fields ).
prepare_initial_data( ).
table-db = zcl_zabap_table_edit_factory=>get_db( ).
ENDMETHOD.
METHOD create_change_doc.
DATA(cd) = zcl_zabap_table_edit_factory=>get_change_doc( objectclass = CONV #( config-table_name ) objectid = CONV #( config-table_name ) ).
cd->open( ).
cd->change_multi( force_cd_on_all_fields = COND #( WHEN config-change_doc_type = 'F' THEN abap_true ELSE abap_false )
table_name = config-table_name
deleted = cd->create_table_with_indicator( table_name = config-table_name original_table = compared-deleted indicator = 'D' )
inserted = cd->create_table_with_indicator( table_name = config-table_name original_table = compared-inserted indicator = 'I' )
before_modified = cd->create_table_with_indicator( table_name = config-table_name original_table = compared-before_modified indicator = 'U' )
modified = cd->create_table_with_indicator( table_name = config-table_name original_table = compared-modified ) ).
DATA: original_tcode TYPE sytcode.
CALL 'GET_PARAM_TCOD' ID 'PTCOD' FIELD original_tcode.
cd->close( tcode = original_tcode ).
ENDMETHOD.
METHOD get_modified_data_no_ext.
CREATE DATA modified_data TYPE TABLE OF (config-table_name).
assign_to_table_fs modified_data->* <modified_data>.
assign_to_table_fs table-modified_data_ext->* <modified_data_ext>.
<modified_data> = CORRESPONDING #( <modified_data_ext> ).
ENDMETHOD.
METHOD get_selected_row_index.
grid->get_selected_rows( IMPORTING et_index_rows = DATA(selected_rows) ).
IF lines( selected_rows ) = 1.
index = selected_rows[ 1 ]-index.
RETURN.
ENDIF.
grid->get_selected_cells( IMPORTING et_cell = DATA(selected_cells) ).
IF lines( selected_cells ) = 1.
index = selected_cells[ 1 ]-row_id.
RETURN.
ENDIF.
ENDMETHOD.
METHOD on_data_changed.
was_data_changed = abap_true.
ENDMETHOD.
METHOD prepare_initial_data.
CREATE DATA table-initial_data TYPE TABLE OF (config-table_name).
assign_to_table_fs table-initial_data->* <initial_data>.
table-fields->get_base_with_add_fields( EXPORTING additional_fields = table-additional_fields IMPORTING table = DATA(table_descr) ).
CREATE DATA table-modified_data_ext TYPE HANDLE table_descr.
DATA(execute_default_select) = abap_true.
config-ext-data->default_select( CHANGING execute = execute_default_select ).
IF execute_default_select = abap_true.
SELECT * FROM (config-table_name) INTO TABLE @<initial_data> ORDER BY PRIMARY KEY.
ENDIF.
config-ext-data->initial_data( CHANGING initial_data = table-initial_data ).
ENDMETHOD.
METHOD setup_grid.
grid->register_edit_event( cl_gui_alv_grid=>mc_evt_modified ).
grid->register_edit_event( cl_gui_alv_grid=>mc_evt_enter ).
SET HANDLER on_data_changed FOR grid.
SET HANDLER config-ext-data->on_data_changed FOR grid.
SET HANDLER config-ext-data->on_data_changed_finished FOR grid.
config-ext-config->grid_setup( CHANGING grid = grid ).
ENDMETHOD.
METHOD zif_zabap_table_edit_tab_data~get_selected_row_key.
DATA(selected) = get_selected_row_index( ).
IF selected = 0.
RETURN.
ENDIF.
assign_to_table_fs table-modified_data_ext->* <modified_data_ext>.
table-fields->get_keys_structure( EXPORTING include_index_field = abap_false IMPORTING struct = DATA(key_struct) ).
DATA key_line TYPE REF TO data.
CREATE DATA key_line TYPE HANDLE key_struct.
FIELD-SYMBOLS <key_line> TYPE any.
ASSIGN key_line->* TO <key_line>.
<key_line> = CORRESPONDING #( <modified_data_ext>[ selected ] ).
tabkey = <key_line>.
ENDMETHOD.
METHOD zif_zabap_table_edit_tab_data~lock_table.
IF table-locker->lock_table( IMPORTING error_message = error_message ) = abap_false.
RETURN.
ENDIF.
IF table-text_table->lock_table( IMPORTING error_message = error_message ) = abap_false.
table-locker->unlock_table( ).
RETURN.
ENDIF.
locked = abap_true.
ENDMETHOD.
METHOD zif_zabap_table_edit_tab_data~reset_grid.
was_data_changed = abap_false.
assign_to_table_fs table-initial_data->* <initial_data>.
assign_to_table_fs table-modified_data_ext->* <modified_data_ext>.
<modified_data_ext> = CORRESPONDING #( <initial_data> ).
table-text_table->update_text_elements( CHANGING extended = table-modified_data_ext ).
table-fields->set_edit_mode( in_edit_mode ).
DATA(fc) = table-fields->get_fc_with_add_fields( table-additional_fields ).
config-ext-data->refresh_grid( EXPORTING in_edit_mode = in_edit_mode
CHANGING field_catalogue = fc initial_data = table-initial_data modified_data_ext = table-modified_data_ext ).
DATA(field_cat) = CORRESPONDING lvc_t_fcat( fc ).
grid->set_table_for_first_display( EXPORTING is_variant = VALUE #( report = config-table_name handle = 'BASE' username = sy-uname )
is_layout = VALUE #( sel_mode = 'A' ) i_save = 'A'
CHANGING it_outtab = <modified_data_ext> it_fieldcatalog = field_cat ).
ENDMETHOD.
METHOD zif_zabap_table_edit_tab_data~save_data.
TRY.
config-ext-data->before_save( CHANGING compared = compared ).
assign_to_table_fs compared-modified->* <modified>.
assign_to_table_fs compared-inserted->* <inserted>.
assign_to_table_fs compared-deleted->* <deleted>.
table-db->delete_data( table = config-table_name table_data = <deleted> ).
IF table-fields->key_fields_only = abap_true.
table-db->insert_data( table = config-table_name table_data = <inserted> ).
ELSE.
table-db->modify_data( table = config-table_name table_data = <modified> ).
table-db->modify_data( table = config-table_name table_data = <inserted> ).
ENDIF.
IF config-change_doc_type <> space.
create_change_doc( compared ).
ENDIF.
table-text_table->save( initial = table-initial_data extended = table-modified_data_ext ).
COMMIT WORK AND WAIT.
IF sy-subrc <> 0.
MESSAGE e014(zabap_table_edit) WITH sy-subrc INTO DATA(msg).
RAISE EXCEPTION TYPE zcx_zabap_table_edit EXPORTING custom_message = msg.
ENDIF.
config-ext-data->after_save( CHANGING compared = compared ).
prepare_initial_data( ).
sucess = abap_true.
CATCH zcx_zabap_table_edit INTO DATA(zcx).
sucess = abap_false.
ROLLBACK WORK.
erorr_message = zcx->get_text( ).
ENDTRY.
ENDMETHOD.
METHOD zif_zabap_table_edit_tab_data~unlock_table.
table-locker->unlock_table( ).
table-text_table->unlock_table( ).
ENDMETHOD.
METHOD zif_zabap_table_edit_tab_data~validate.
grid->check_changed_data( IMPORTING e_valid = DATA(valid) ).
IF valid = abap_false.
result = zcl_zabap_table_edit_globals=>c_validation-incorrect_values.
RETURN.
ENDIF.
table-comparator->update_mandant( table-modified_data_ext ).
DATA(modified_data) = get_modified_data_no_ext( ).
table-comparator->compare_tables( EXPORTING initial_data = table-initial_data modified_data = modified_data
IMPORTING duplicates = compared-duplicates inserted = compared-inserted deleted = compared-deleted
before_modified = compared-before_modified modified = compared-modified ).
assign_to_table_fs compared-duplicates->* <duplicates>.
IF lines( <duplicates> ) > 0.
result = zcl_zabap_table_edit_globals=>c_validation-duplicates.
RETURN.
ENDIF.
result = zcl_zabap_table_edit_globals=>c_validation-ok.
config-ext-data->additional_validation( CHANGING result = result all_modified_data = modified_data compared = compared ).
ENDMETHOD.
ENDCLASS.
```
| 2,825 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
CLASS zcl_translatable_program IMPLEMENTATION.
METHOD constructor.
program_name = program.
ENDMETHOD.
METHOD zif_translatable~read_language.
DATA textpool TYPE STANDARD TABLE OF textpool WITH EMPTY KEY.
READ TEXTPOOL program_name INTO textpool LANGUAGE sap_lang.
LOOP AT textpool REFERENCE INTO DATA(textpool_text).
DATA(program_text) = get_text( get_text_id( id = textpool_text->id key = textpool_text->key ) ).
modify_translation( EXPORTING sap_lang = sap_lang content = textpool_text->entry CHANGING translations = program_text->translations ).
ENDLOOP.
ENDMETHOD.
METHOD zif_translatable~get_all_texts.
texts = me->texts.
ENDMETHOD.
METHOD get_text_id.
text_id = |{ id }\|{ key }|.
ENDMETHOD.
METHOD parse_text_id.
SPLIT text_id AT '|' INTO id key.
ENDMETHOD.
METHOD zif_translatable~modify_texts.
LOOP AT new_texts REFERENCE INTO DATA(new_text).
DATA(program_text) = get_text( new_text->text_id ).
LOOP AT new_text->translations REFERENCE INTO DATA(new_translation).
modify_translation( EXPORTING sap_lang = new_translation->sap_lang content = new_translation->content
CHANGING translations = program_text->translations ).
ENDLOOP.
ENDLOOP.
ENDMETHOD.
METHOD zif_translatable~save_modified_texts.
DATA textpool TYPE STANDARD TABLE OF textpool WITH EMPTY KEY.
LOOP AT texts REFERENCE INTO DATA(text).
parse_text_id( EXPORTING text_id = text->text_id IMPORTING id = DATA(id) key = DATA(key) ).
LOOP AT text->translations REFERENCE INTO DATA(translation) WHERE sap_lang = sap_lang.
APPEND VALUE #( id = id key = key entry = translation->content ) TO textpool.
ENDLOOP.
ENDLOOP.
INSERT TEXTPOOL program_name FROM textpool LANGUAGE sap_lang.
ENDMETHOD.
METHOD get_text.
text = REF #( texts[ KEY id_only text_id = text_id ] OPTIONAL ).
IF NOT text IS BOUND.
INSERT VALUE #( object_type = c_kind object_name = program_name text_id = text_id ) INTO TABLE texts REFERENCE INTO text.
ENDIF.
ENDMETHOD.
METHOD modify_translation.
DATA(translation) = REF #( translations[ sap_lang = sap_lang ] OPTIONAL ).
IF NOT translation IS BOUND.
INSERT VALUE #( sap_lang = sap_lang ) INTO TABLE translations REFERENCE INTO translation.
ENDIF.
translation->content = content.
ENDMETHOD.
ENDCLASS.
```
|
I found vulnerabilities in the line:
```abap
INSERT TEXTPOOL program_name FROM textpool LANGUAGE sap_lang.
```
Explanation: Potential dangerous statement INSERT TEXTPOOL.
Suggested fix:
```abap
CLASS zcl_translatable_program IMPLEMENTATION.
METHOD constructor.
zif_translatable~object_name = program.
zif_translatable~object_type = zcl_translation_globals=>c_object_type-program.
textpool = zcl_translation_factory=>create_translatable_sub( object_name = program
subcomponent = zcl_translation_globals=>c_subcomponent-textpool ).
ENDMETHOD.
METHOD zif_translatable~read_language.
textpool->zif_translatable~read_language( sap_lang ).
ENDMETHOD.
METHOD zif_translatable~get_all_texts.
APPEND LINES OF textpool->zif_translatable~get_all_texts( ) TO texts.
ENDMETHOD.
METHOD get_text_sub_type.
SPLIT text_id AT '|' INTO sub_type DATA(dummy).
ENDMETHOD.
METHOD zif_translatable~modify_texts.
LOOP AT new_texts REFERENCE INTO DATA(new_text).
CASE get_text_sub_type( new_text->text_id ).
WHEN textpool->sub_type.
textpool->modify_text( new_text->* ).
WHEN OTHERS.
ENDCASE.
ENDLOOP.
ENDMETHOD.
METHOD zif_translatable~save_modified_texts.
textpool->zif_translatable~save_modified_texts( sap_lang ).
ENDMETHOD.
ENDCLASS.
```
| 2,826 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
CLASS zcl_translatable_menu_el IMPLEMENTATION.
METHOD constructor.
zif_translatable~object_name = program.
zif_translatable~object_type = zcl_translation_globals=>c_object_type-program.
sub_type = zcl_translation_globals=>c_subcomponent-menu_texts.
ENDMETHOD.
METHOD zif_translatable~read_language.
SELECT obj_type, obj_code, sub_code, texttype, text FROM rsmptexts
WHERE progname = @zif_translatable~object_name AND sprsl = @sap_lang
INTO TABLE @DATA(menu_texts).
LOOP AT menu_texts REFERENCE INTO DATA(menu_text).
DATA(program_text) = get_text( get_text_id( obj_type = menu_text->obj_type obj_code = menu_text->obj_code
sub_code = menu_text->sub_code texttype = menu_text->texttype ) ).
modify_translation( EXPORTING sap_lang = sap_lang content = CONV #( menu_text->text ) CHANGING translations = program_text->translations ).
ENDLOOP.
ENDMETHOD.
METHOD zif_translatable~get_all_texts.
texts = me->texts.
ENDMETHOD.
METHOD get_text_id.
text_id = |{ sub_type }\|{ obj_type }\|{ obj_code }\|{ sub_code }\|{ texttype }|.
ENDMETHOD.
METHOD parse_text_id.
SPLIT text_id AT '|' INTO sub_type obj_type obj_code sub_code texttype.
ENDMETHOD.
METHOD zif_translatable~modify_texts.
LOOP AT new_texts REFERENCE INTO DATA(new_text) USING KEY text_id
WHERE object_type = zif_translatable~object_type AND object_name = zif_translatable~object_name.
parse_text_id( EXPORTING text_id = new_text->text_id IMPORTING sub_type = DATA(text_sub_type) ).
IF text_sub_type <> sub_type.
CONTINUE.
ENDIF.
DATA(program_text) = get_text( new_text->text_id ).
LOOP AT new_text->translations REFERENCE INTO DATA(new_translation).
modify_translation( EXPORTING sap_lang = new_translation->sap_lang content = new_translation->content
CHANGING translations = program_text->translations ).
ENDLOOP.
ENDLOOP.
ENDMETHOD.
METHOD zif_translatable~save_modified_texts.
DATA rsmptexts_table TYPE STANDARD TABLE OF rsmptexts WITH EMPTY KEY.
DATA(lxe_type_texts) = abap_false.
DATA(lxe_type_tech) = abap_false.
LOOP AT texts REFERENCE INTO DATA(text).
parse_text_id( EXPORTING text_id = text->text_id IMPORTING obj_type = DATA(obj_type) obj_code = DATA(obj_code)
sub_code = DATA(sub_code) texttype = DATA(texttype) ).
LOOP AT text->translations REFERENCE INTO DATA(translation) WHERE sap_lang = sap_lang.
APPEND VALUE #( progname = zif_translatable~object_name sprsl = sap_lang obj_type = obj_type obj_code = obj_code
sub_code = sub_code texttype = texttype text = CONV #( translation->content ) ) TO rsmptexts_table.
ENDLOOP.
"Got this logic from ST05 trace when translating menu elements
lxe_type_tech = xsdbool( ( obj_type <> 'T' AND texttype = 'T' ) OR lxe_type_tech = abap_true ).
lxe_type_texts = xsdbool( ( obj_type = 'T' OR texttype <> 'T' ) OR lxe_type_texts = abap_true ).
ENDLOOP.
MODIFY rsmptexts FROM TABLE @rsmptexts_table.
update_lxe_log( sap_lang = sap_lang lxe_type_texts = lxe_type_texts lxe_type_tech = lxe_type_tech ).
ENDMETHOD.
METHOD get_text.
text = REF #( texts[ KEY id_only text_id = text_id ] OPTIONAL ).
IF NOT text IS BOUND.
INSERT VALUE #( object_type = zif_translatable~object_type object_name = zif_translatable~object_name
text_id = text_id ) INTO TABLE texts REFERENCE INTO text.
ENDIF.
ENDMETHOD.
METHOD modify_translation.
DATA(translation) = REF #( translations[ sap_lang = sap_lang ] OPTIONAL ).
IF NOT translation IS BOUND.
INSERT VALUE #( sap_lang = sap_lang ) INTO TABLE translations REFERENCE INTO translation.
ENDIF.
translation->content = content.
ENDMETHOD.
METHOD update_lxe_log.
DATA lxe_log_table TYPE STANDARD TABLE OF lxe_log WITH EMPTY KEY.
SELECT SINGLE custmnr FROM lxe_custmnr INTO @DATA(custmnr).
GET TIME.
IF lxe_type_texts = abap_true.
APPEND VALUE #( custmnr = custmnr objname = zif_translatable~object_name objtype = c_lxe_type-texts targlng = sap_lang
uname = sy-uname udate = sy-datum utime = sy-uzeit ) TO lxe_log_table.
ENDIF.
IF lxe_type_tech = abap_true.
APPEND VALUE #( custmnr = custmnr objname = zif_translatable~object_name objtype = c_lxe_type-tech targlng = sap_lang
uname = sy-uname udate = sy-datum utime = sy-uzeit ) TO lxe_log_table.
ENDIF.
MODIFY lxe_log FROM TABLE @lxe_log_table.
ENDMETHOD.
ENDCLASS.
```
|
I found vulnerabilities in the line:
```abap
MODIFY lxe_log FROM TABLE @lxe_log_table.
```
Explanation: Modify only own DB tables.
Suggested fix:
```abap
CLASS ZCL_TRANSLATABLE_MENU_EL IMPLEMENTATION.
METHOD constructor.
zif_translatable~object_name = program.
zif_translatable~object_type = zcl_translation_globals=>c_object_type-program.
sub_type = zcl_translation_globals=>c_subcomponent-menu_texts.
ENDMETHOD.
METHOD get_text.
text = REF #( texts[ KEY id_only text_id = text_id ] OPTIONAL ).
IF NOT text IS BOUND.
INSERT VALUE #( object_type = zif_translatable~object_type object_name = zif_translatable~object_name
text_id = text_id ) INTO TABLE texts REFERENCE INTO text.
ENDIF.
ENDMETHOD.
METHOD get_text_id.
text_id = |{ sub_type }\|{ parsed-obj_type }\|{ parsed-obj_code }\|{ parsed-sub_code }\|{ parsed-texttype }|.
ENDMETHOD.
METHOD modify_translation.
DATA(translation) = REF #( translations[ sap_lang = sap_lang ] OPTIONAL ).
IF NOT translation IS BOUND.
INSERT VALUE #( sap_lang = sap_lang ) INTO TABLE translations REFERENCE INTO translation.
ENDIF.
translation->content = content.
ENDMETHOD.
METHOD parse_text_id.
SPLIT text_id AT '|' INTO parsed-sub_type parsed-obj_type parsed-obj_code parsed-sub_code parsed-texttype.
ENDMETHOD.
METHOD zif_translatable~get_all_texts.
texts = me->texts.
ENDMETHOD.
METHOD zif_translatable~modify_texts.
LOOP AT new_texts REFERENCE INTO DATA(new_text) USING KEY text_id
WHERE object_type = zif_translatable~object_type AND object_name = zif_translatable~object_name.
DATA(parsed) = parse_text_id( new_text->text_id ).
IF parsed-sub_type <> sub_type.
CONTINUE.
ENDIF.
DATA(program_text) = get_text( new_text->text_id ).
LOOP AT new_text->translations REFERENCE INTO DATA(new_translation).
modify_translation( EXPORTING sap_lang = new_translation->sap_lang content = new_translation->content
CHANGING translations = program_text->translations ).
ENDLOOP.
ENDLOOP.
ENDMETHOD.
METHOD zif_translatable~read_language.
SELECT obj_type, obj_code, sub_code, texttype, text FROM rsmptexts
WHERE progname = @zif_translatable~object_name AND sprsl = @sap_lang
INTO TABLE @DATA(menu_texts).
LOOP AT menu_texts REFERENCE INTO DATA(menu_text).
DATA(program_text) = get_text( get_text_id( VALUE #( sub_type = sub_type obj_type = menu_text->obj_type obj_code = menu_text->obj_code
sub_code = menu_text->sub_code texttype = menu_text->texttype ) ) ).
modify_translation( EXPORTING sap_lang = sap_lang content = CONV #( menu_text->text ) CHANGING translations = program_text->translations ).
ENDLOOP.
ENDMETHOD.
METHOD zif_translatable~save_modified_texts.
DATA(lxe_log) = zcl_translation_factory=>get_lxe_log( ).
DATA lxe_log_table TYPE lxe_log->tt_lxe_log.
DATA rsmptexts_table TYPE STANDARD TABLE OF rsmptexts WITH EMPTY KEY.
LOOP AT texts REFERENCE INTO DATA(text).
DATA(parsed) = parse_text_id( text->text_id ).
LOOP AT text->translations REFERENCE INTO DATA(translation) WHERE sap_lang = sap_lang.
APPEND VALUE #( progname = zif_translatable~object_name sprsl = sap_lang obj_type = parsed-obj_type obj_code = parsed-obj_code
sub_code = parsed-sub_code texttype = parsed-texttype text = CONV #( translation->content ) ) TO rsmptexts_table.
IF parsed-obj_type <> 'T' AND parsed-texttype = 'T'.
APPEND VALUE #( objname = zif_translatable~object_name objtype = c_lxe_type-tech targlng = sap_lang ) TO lxe_log_table.
ELSE.
APPEND VALUE #( objname = zif_translatable~object_name objtype = c_lxe_type-texts targlng = sap_lang ) TO lxe_log_table.
ENDIF.
ENDLOOP.
ENDLOOP.
MODIFY rsmptexts FROM TABLE @rsmptexts_table.
lxe_log->update_lxe_log( lxe_log_table ).
ENDMETHOD.
ENDCLASS.
```
| 2,827 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
method _EXECUTE_DELETE.
IF iv_where IS NOT INITIAL.
DELETE FROM (iv_table_name)
WHERE (iv_where).
ELSE.
DELETE FROM (iv_table_name).
ENDIF.
rv_subrc = sy-subrc.
endmethod.
```
|
I found vulnerabilities in the line:
```abap
DELETE FROM (iv_table_name)
```
Explanation: Modify only own DB tables | Potential dangerous statement Dynamic SQL.
```abap
DELETE FROM (iv_table_name).
```
Explanation: Modify only own DB tables | Potential dangerous statement Dynamic SQL.
Suggested fix:
```abap
METHOD _execute_delete.
DATA: lx_exception TYPE REF TO cx_root.
TRY.
IF iv_where IS NOT INITIAL.
DELETE FROM (iv_table_name)
WHERE (iv_where).
ELSE.
DELETE FROM (iv_table_name).
ENDIF.
rv_subrc = sy-subrc.
CATCH cx_root INTO lx_exception.
zcl_zosql_utils=>raise_from_any_exception( lx_exception ).
ENDTRY.
ENDMETHOD.
```
| 2,828 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
METHOD _execute_select.
DATA: lv_order_by_primary_key TYPE abap_bool.
lv_order_by_primary_key = _if_order_by_primary_key( iv_order_by ).
IF iv_new_syntax = abap_true.
" Dynamic call for backward compatibility with older versions
CALL METHOD ('ZCL_ZOSQL_UTILS_740')=>('EXECUTE_SELECT_740')
EXPORTING
iv_select = iv_select
iv_from = iv_from
iv_where = iv_where
iv_group_by = iv_group_by
iv_having = iv_having
iv_order_by = iv_order_by
iv_distinct = iv_distinct
it_for_all_entries_table = it_for_all_entries_table
is_dynamic_struct_with_params = is_dynamic_struct_with_params
iv_do_into_corresponding = iv_do_into_corresponding
iv_number_of_rows_to_select = iv_number_of_rows_to_select
IMPORTING
et_result_table = et_result_table.
RETURN.
ENDIF.
IF it_for_all_entries_table IS NOT INITIAL.
IF iv_order_by IS NOT INITIAL.
MESSAGE e051 INTO zcl_zosql_utils=>dummy.
zcl_zosql_utils=>raise_exception_from_sy_msg( ).
ENDIF.
IF iv_group_by IS NOT INITIAL.
MESSAGE e052 INTO zcl_zosql_utils=>dummy.
zcl_zosql_utils=>raise_exception_from_sy_msg( ).
ENDIF.
IF iv_distinct = abap_true.
IF iv_do_into_corresponding = abap_true.
SELECT DISTINCT (iv_select)
FROM (iv_from)
INTO CORRESPONDING FIELDS OF TABLE et_result_table
UP TO iv_number_of_rows_to_select ROWS
FOR ALL ENTRIES IN it_for_all_entries_table
WHERE (iv_where).
ELSE.
SELECT DISTINCT (iv_select)
FROM (iv_from)
INTO TABLE et_result_table
UP TO iv_number_of_rows_to_select ROWS
FOR ALL ENTRIES IN it_for_all_entries_table
WHERE (iv_where).
ENDIF.
ELSE.
IF iv_do_into_corresponding = abap_true.
SELECT (iv_select)
FROM (iv_from)
INTO CORRESPONDING FIELDS OF TABLE et_result_table
UP TO iv_number_of_rows_to_select ROWS
FOR ALL ENTRIES IN it_for_all_entries_table
WHERE (iv_where).
ELSE.
SELECT (iv_select)
FROM (iv_from)
INTO TABLE et_result_table
UP TO iv_number_of_rows_to_select ROWS
FOR ALL ENTRIES IN it_for_all_entries_table
WHERE (iv_where).
ENDIF.
ENDIF.
ELSE.
IF iv_distinct = abap_true.
IF iv_do_into_corresponding = abap_true.
IF lv_order_by_primary_key = abap_true.
SELECT DISTINCT (iv_select)
FROM (iv_from)
INTO CORRESPONDING FIELDS OF TABLE et_result_table
UP TO iv_number_of_rows_to_select ROWS
WHERE (iv_where)
GROUP BY (iv_group_by)
HAVING (iv_having)
ORDER BY PRIMARY KEY.
ELSE.
SELECT DISTINCT (iv_select)
FROM (iv_from)
INTO CORRESPONDING FIELDS OF TABLE et_result_table
UP TO iv_number_of_rows_to_select ROWS
WHERE (iv_where)
GROUP BY (iv_group_by)
HAVING (iv_having)
ORDER BY (iv_order_by).
ENDIF.
ELSE.
IF lv_order_by_primary_key = abap_true.
SELECT DISTINCT (iv_select)
FROM (iv_from)
INTO TABLE et_result_table
UP TO iv_number_of_rows_to_select ROWS
WHERE (iv_where)
GROUP BY (iv_group_by)
HAVING (iv_having)
ORDER BY PRIMARY KEY.
ELSE.
SELECT DISTINCT (iv_select)
FROM (iv_from)
INTO TABLE et_result_table
UP TO iv_number_of_rows_to_select ROWS
WHERE (iv_where)
GROUP BY (iv_group_by)
HAVING (iv_having)
ORDER BY (iv_order_by).
ENDIF.
ENDIF.
ELSE.
IF iv_do_into_corresponding = abap_true.
IF lv_order_by_primary_key = abap_true.
SELECT (iv_select)
FROM (iv_from)
INTO CORRESPONDING FIELDS OF TABLE et_result_table
UP TO iv_number_of_rows_to_select ROWS
WHERE (iv_where)
GROUP BY (iv_group_by)
HAVING (iv_having)
ORDER BY PRIMARY KEY.
ELSE.
SELECT (iv_select)
FROM (iv_from)
INTO CORRESPONDING FIELDS OF TABLE et_result_table
UP TO iv_number_of_rows_to_select ROWS
WHERE (iv_where)
GROUP BY (iv_group_by)
HAVING (iv_having)
ORDER BY (iv_order_by).
ENDIF.
ELSE.
IF lv_order_by_primary_key = abap_true.
SELECT (iv_select)
FROM (iv_from)
INTO TABLE et_result_table
UP TO iv_number_of_rows_to_select ROWS
WHERE (iv_where)
GROUP BY (iv_group_by)
HAVING (iv_having)
ORDER BY PRIMARY KEY.
ELSE.
SELECT (iv_select)
FROM (iv_from)
INTO TABLE et_result_table
UP TO iv_number_of_rows_to_select ROWS
WHERE (iv_where)
GROUP BY (iv_group_by)
HAVING (iv_having)
ORDER BY (iv_order_by).
ENDIF.
ENDIF.
ENDIF.
ENDIF.
ENDMETHOD.
```
|
I found vulnerabilities in the line:
```abap
IF iv_do_into_corresponding = abap_true.
SELECT DISTINCT (iv_select) * <-- There is a problem here
FROM (iv_from)
```
Explanation: Potential dangerous statement Dynamic SQL.
```abap
WHERE (iv_where).
ELSE.
SELECT DISTINCT (iv_select) * <-- There is a problem here
FROM (iv_from)
INTO TABLE et_result_table
```
Explanation: Potential dangerous statement Dynamic SQL.
```abap
IF iv_do_into_corresponding = abap_true.
SELECT (iv_select) * <-- There is a problem here
FROM (iv_from)
```
Explanation: Potential dangerous statement Dynamic SQL.
```abap
WHERE (iv_where).
ELSE.
SELECT (iv_select) * <-- There is a problem here
FROM (iv_from)
INTO TABLE et_result_table
```
Explanation: Potential dangerous statement Dynamic SQL.
```abap
IF lv_order_by_primary_key = abap_true.
SELECT DISTINCT (iv_select) * <-- There is a problem here
FROM (iv_from)
INTO CORRESPONDING FIELDS OF TABLE et_result_table
```
Explanation: Potential dangerous statement Dynamic SQL.
```abap
ORDER BY PRIMARY KEY.
ELSE.
SELECT DISTINCT (iv_select) * <-- There is a problem here
FROM (iv_from)
INTO CORRESPONDING FIELDS OF TABLE et_result_table
```
Explanation: Potential dangerous statement Dynamic SQL.
```abap
ELSE.
IF lv_order_by_primary_key = abap_true.
SELECT DISTINCT (iv_select) * <-- There is a problem here
FROM (iv_from)
INTO TABLE et_result_table
```
Explanation: Potential dangerous statement Dynamic SQL.
```abap
ORDER BY PRIMARY KEY.
ELSE.
SELECT DISTINCT (iv_select) * <-- There is a problem here
FROM (iv_from)
INTO TABLE et_result_table
```
Explanation: Potential dangerous statement Dynamic SQL.
Suggested fix:
```abap
METHOD _execute_select.
DATA: lv_order_by_primary_key TYPE abap_bool,
lx_exception TYPE REF TO cx_root.
lv_order_by_primary_key = _if_order_by_primary_key( iv_order_by ).
TRY.
IF iv_new_syntax = abap_true.
CALL METHOD ('ZCL_ZOSQL_UTILS_740')=>('EXECUTE_SELECT_740')
EXPORTING
iv_select = iv_select
iv_from = iv_from
iv_where = iv_where
iv_group_by = iv_group_by
iv_having = iv_having
iv_order_by = iv_order_by
iv_distinct = iv_distinct
it_for_all_entries_table = it_for_all_entries_table
is_dynamic_struct_with_params = is_dynamic_struct_with_params
iv_do_into_corresponding = iv_do_into_corresponding
iv_number_of_rows_to_select = iv_number_of_rows_to_select
IMPORTING
et_result_table = et_result_table.
RETURN.
ENDIF.
IF it_for_all_entries_table IS NOT INITIAL.
IF iv_order_by IS NOT INITIAL.
MESSAGE e051 INTO zcl_zosql_utils=>dummy.
zcl_zosql_utils=>raise_exception_from_sy_msg( ).
ENDIF.
IF iv_group_by IS NOT INITIAL.
MESSAGE e052 INTO zcl_zosql_utils=>dummy.
zcl_zosql_utils=>raise_exception_from_sy_msg( ).
ENDIF.
IF iv_distinct = abap_true.
IF iv_do_into_corresponding = abap_true.
SELECT DISTINCT (iv_select)
FROM (iv_from)
INTO CORRESPONDING FIELDS OF TABLE et_result_table
UP TO iv_number_of_rows_to_select ROWS
FOR ALL ENTRIES IN it_for_all_entries_table
WHERE (iv_where).
ELSE.
SELECT DISTINCT (iv_select)
FROM (iv_from)
INTO TABLE et_result_table
UP TO iv_number_of_rows_to_select ROWS
FOR ALL ENTRIES IN it_for_all_entries_table
WHERE (iv_where).
ENDIF.
ELSE.
IF iv_do_into_corresponding = abap_true.
SELECT (iv_select)
FROM (iv_from)
INTO CORRESPONDING FIELDS OF TABLE et_result_table
UP TO iv_number_of_rows_to_select ROWS
FOR ALL ENTRIES IN it_for_all_entries_table
WHERE (iv_where).
ELSE.
SELECT (iv_select)
FROM (iv_from)
INTO TABLE et_result_table
UP TO iv_number_of_rows_to_select ROWS
FOR ALL ENTRIES IN it_for_all_entries_table
WHERE (iv_where).
ENDIF.
ENDIF.
ELSE.
IF iv_distinct = abap_true.
IF iv_do_into_corresponding = abap_true.
IF lv_order_by_primary_key = abap_true.
SELECT DISTINCT (iv_select)
FROM (iv_from)
INTO CORRESPONDING FIELDS OF TABLE et_result_table
UP TO iv_number_of_rows_to_select ROWS
WHERE (iv_where)
GROUP BY (iv_group_by)
HAVING (iv_having)
ORDER BY PRIMARY KEY.
ELSE.
SELECT DISTINCT (iv_select)
FROM (iv_from)
INTO CORRESPONDING FIELDS OF TABLE et_result_table
UP TO iv_number_of_rows_to_select ROWS
WHERE (iv_where)
GROUP BY (iv_group_by)
HAVING (iv_having)
ORDER BY (iv_order_by).
ENDIF.
ELSE.
IF lv_order_by_primary_key = abap_true.
SELECT DISTINCT (iv_select)
FROM (iv_from)
INTO TABLE et_result_table
UP TO iv_number_of_rows_to_select ROWS
WHERE (iv_where)
GROUP BY (iv_group_by)
HAVING (iv_having)
ORDER BY PRIMARY KEY.
ELSE.
SELECT DISTINCT (iv_select)
FROM (iv_from)
INTO TABLE et_result_table
UP TO iv_number_of_rows_to_select ROWS
WHERE (iv_where)
GROUP BY (iv_group_by)
HAVING (iv_having)
ORDER BY (iv_order_by).
ENDIF.
ENDIF.
ELSE.
IF iv_do_into_corresponding = abap_true.
IF lv_order_by_primary_key = abap_true.
SELECT (iv_select)
FROM (iv_from)
INTO CORRESPONDING FIELDS OF TABLE et_result_table
UP TO iv_number_of_rows_to_select ROWS
WHERE (iv_where)
GROUP BY (iv_group_by)
HAVING (iv_having)
ORDER BY PRIMARY KEY.
ELSE.
SELECT (iv_select)
FROM (iv_from)
INTO CORRESPONDING FIELDS OF TABLE et_result_table
UP TO iv_number_of_rows_to_select ROWS
WHERE (iv_where)
GROUP BY (iv_group_by)
HAVING (iv_having)
ORDER BY (iv_order_by).
ENDIF.
ELSE.
IF lv_order_by_primary_key = abap_true.
SELECT (iv_select)
FROM (iv_from)
INTO TABLE et_result_table
UP TO iv_number_of_rows_to_select ROWS
WHERE (iv_where)
GROUP BY (iv_group_by)
HAVING (iv_having)
ORDER BY PRIMARY KEY.
ELSE.
SELECT (iv_select)
FROM (iv_from)
INTO TABLE et_result_table
UP TO iv_number_of_rows_to_select ROWS
WHERE (iv_where)
GROUP BY (iv_group_by)
HAVING (iv_having)
ORDER BY (iv_order_by).
ENDIF.
ENDIF.
ENDIF.
ENDIF.
CATCH cx_root INTO lx_exception.
zcl_zosql_utils=>raise_from_any_exception( lx_exception ).
ENDTRY.
ENDMETHOD.
```
| 2,829 |
Find vulnerabilities in this ABAP code snippet.
|
```abap
method _EXECUTE_UPDATE.
IF iv_where IS NOT INITIAL.
UPDATE (iv_table_name)
SET (iv_set_statement)
WHERE (iv_where).
ELSE.
UPDATE (iv_table_name)
SET (iv_set_statement).
ENDIF.
rv_subrc = sy-subrc.
endmethod.
```
|
I found vulnerabilities in the line:
```abap
IF iv_where IS NOT INITIAL.
UPDATE (iv_table_name) * <-- There is a problem here
SET (iv_set_statement)
```
Explanation: Modify only own DB tables | Potential dangerous statement Dynamic SQL.
```abap
ELSE.
UPDATE (iv_table_name) * <-- There is a problem here
SET (iv_set_statement).
```
Explanation: Modify only own DB tables | Potential dangerous statement Dynamic SQL.
Suggested fix:
```abap
METHOD _execute_update.
DATA: lx_exception TYPE REF TO cx_root.
TRY.
IF iv_where IS NOT INITIAL.
UPDATE (iv_table_name)
SET (iv_set_statement)
WHERE (iv_where).
ELSE.
UPDATE (iv_table_name)
SET (iv_set_statement).
ENDIF.
rv_subrc = sy-subrc.
CATCH cx_root INTO lx_exception.
zcl_zosql_utils=>raise_from_any_exception( lx_exception ).
ENDTRY.
ENDMETHOD.
```
| 2,830 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.