lib/security: hard_lockdown flag to stop runtime disable of signed boot
[petitboot] / ui / ncurses / console-codes.c
1 /*
2  *  Copyright (C) 2017 IBM Corporation
3  *
4  *  This program is free software; you can redistribute it and/or modify
5  *  it under the terms of the GNU General Public License as published by
6  *  the Free Software Foundation; version 2 of the License.
7  *
8  *  This program is distributed in the hope that it will be useful,
9  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
10  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11  *  GNU General Public License for more details.
12  *
13  */
14
15 #if defined(HAVE_CONFIG_H)
16 #include "config.h"
17 #endif
18
19 #include <ctype.h>
20 #include <errno.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <stdbool.h>
24
25 #include "talloc/talloc.h"
26
27 #ifndef PETITBOOT_TEST
28 #include "log/log.h"
29 #include "nc-scr.h"
30 #endif
31
32 #include "console-codes.h"
33
34 #define ESC_CHAR                        033
35 #define CSI_CHAR                        '['
36 #define INTER_CHAR_START                040
37 #define INTER_CHAR_END                  057
38 #define ESC_SEQUENCE_FINAL_START        060
39 #define ESC_SEQUENCE_FINAL_END          0176
40 #define CTRL_SEQUENCE_FINAL_START       0100
41 #define CTRL_SEQUENCE_FINAL_END         0176
42 #define DEC_PARAMETER                   077
43
44 enum console_sequence_state {
45         CONSOLE_STATE_START,
46         CONSOLE_STATE_ESC_SEQ,
47         CONSOLE_STATE_CTRL_SEQ_START,
48         CONSOLE_STATE_CTRL_SEQ,
49         CONSOLE_STATE_DONE,
50         CONSOLE_STATE_CONFUSED,
51 };
52
53 static inline bool is_intermediate(signed char c)
54 {
55         return c > INTER_CHAR_START && c < INTER_CHAR_END;
56 }
57
58 static inline bool is_parameter(signed char c)
59 {
60         return (c >= 060 && c <= 071) || c == 073;
61 }
62
63 static inline bool is_escape_final(signed char c)
64 {
65         return c >= ESC_SEQUENCE_FINAL_START && c < ESC_SEQUENCE_FINAL_END;
66 }
67
68 static inline bool is_control_final(signed char c)
69 {
70         return c >= CTRL_SEQUENCE_FINAL_START && c <= CTRL_SEQUENCE_FINAL_END;
71 }
72
73 static char console_sequence_getch(char **sequence)
74 {
75         signed char c = getch();
76
77         if (c != ERR)
78                 *sequence = talloc_asprintf_append(*sequence, "%c", c);
79         return c;
80 }
81
82 /*
83  * Catch terminal control sequences that have accidentally been sent to
84  * Petitboot. These are of the form
85  *      ESC I .. I F
86  * where I is an Intermediate Character and F is a Final Character, eg:
87  *      ESC ^ [ ? 1 ; 0 c
88  * or   ESC # 6
89  *
90  * This is based off the definitions provided by
91  * https://vt100.net/docs/vt100-ug/contents.html
92  */
93 char *handle_control_sequence(void *ctx, signed char start)
94 {
95         enum console_sequence_state state = CONSOLE_STATE_START;
96         bool in_sequence = true;
97         signed char c;
98         char *seq;
99
100         if (start != ESC_CHAR) {
101                 pb_log("%s: Called with non-escape character: 0%o\n",
102                                 __func__, start);
103                 return NULL;
104         }
105
106         seq = talloc_asprintf(ctx, "%c", start);
107
108         while (in_sequence) {
109                 switch (state) {
110                 case CONSOLE_STATE_START:
111                         c = console_sequence_getch(&seq);
112                         if (c == CSI_CHAR)
113                                 state = CONSOLE_STATE_CTRL_SEQ_START;
114                         else if (is_intermediate(c))
115                                 state = CONSOLE_STATE_ESC_SEQ;
116                         else if (is_escape_final(c))
117                                 state = CONSOLE_STATE_DONE;
118                         else if (c != ERR) {
119                                 /* wait on c == ERR */
120                                 pb_debug("Unexpected start: \\x%x\n", c);
121                                 state = CONSOLE_STATE_CONFUSED;
122                         }
123                         break;
124                 case CONSOLE_STATE_ESC_SEQ:
125                         c = console_sequence_getch(&seq);
126                         if (is_intermediate(c))
127                                 state = CONSOLE_STATE_ESC_SEQ;
128                         else if (is_escape_final(c))
129                                 state = CONSOLE_STATE_DONE;
130                         else if (c != ERR) {
131                                 /* wait on c == ERR */
132                                 pb_debug("Unexpected character after intermediate: \\x%x\n",
133                                                 c);
134                                 state = CONSOLE_STATE_CONFUSED;
135                         }
136                         break;
137                 case CONSOLE_STATE_CTRL_SEQ_START:
138                         c = console_sequence_getch(&seq);
139                         if (is_intermediate(c) || is_parameter(c) ||
140                                         c == DEC_PARAMETER)
141                                 state = CONSOLE_STATE_CTRL_SEQ;
142                         else if (is_control_final(c))
143                                 state = CONSOLE_STATE_DONE;
144                         else if (c != ERR) {
145                                 /* wait on c == ERR */
146                                 pb_debug("Unexpected character in param string:  \\x%x\n",
147                                                 c);
148                                 state = CONSOLE_STATE_CONFUSED;
149                         }
150                         break;
151                 case CONSOLE_STATE_CTRL_SEQ:
152                         c = console_sequence_getch(&seq);
153                         if (is_intermediate(c) || is_parameter(c))
154                                 state = CONSOLE_STATE_CTRL_SEQ;
155                         else if (is_control_final(c))
156                                 state = CONSOLE_STATE_DONE;
157                         else if (c != ERR) {
158                                 /* wait on c == ERR */
159                                 pb_debug("Unexpected character in param string:  \\x%x\n",
160                                                 c);
161                                 state = CONSOLE_STATE_CONFUSED;
162                         }
163                         break;
164                 case CONSOLE_STATE_DONE:
165                         in_sequence = false;
166                         break;
167                 case CONSOLE_STATE_CONFUSED:
168                         /* fall-through */
169                 default:
170                         pb_debug("We got lost interpreting a control sequence!\n");
171                         seq = talloc_asprintf_append(seq, "...");
172                         in_sequence = false;
173                         break;
174                 };
175         }
176
177         return seq;
178 }