https://www.stadtwerk-am-see.de/de/static/js/HRSysLib/Security/parameter.js?nc=1790327236423

1/** **************************************************************************
2// Firma:        Hehner Reus Systems GmbH
3// Projekt:      com.cerno.basis
4// Datei:        parameter
5// Erstellung:   06.05.2025
6// Verwendung:   Diverse Funktionen für das Absichern von HTTP-Input und 
7//               verschiedenem Output (HTML, JSON, CSV, etc.).
8//
9// $Id: parameter.js,v 1.1 2025/06/12 13:40:42 lpo Exp $
10// $Author: lpo $
11//
12/**************************************************************************** */
13
14"use strict";
15
16/**
17 * Diverse Funktionen für das Absichern von HTTP-Input und verschiedenem Output (HTML, JSON, CSV, etc.).
18 */
19class HRParam
20{
21   /**
22    * Methode übersetzt Unicode-HTML-Entitäten in Name-Entitäten.
23    * Bisher wird nur die ′ zurück in ′ übersetzt.
24    * Weitere werden aber bestimmt folgen.
25    * 
26    * @param wert Der Wert deren Unicode-Entitäten gewandelt werden sollen.
27    * @return Die Umgewandelte Zeichenkette.
28    */
29   static convertHTMLUnicodeEntitaeten(value)
30   {
31      if (!value)
32         return value;
33      
34      return value.replaceAll("′", "′");
35   }
36   
37   /**
38    * Methode wird hauptsächlich für das Übernehmen von Benutzereingaben aus
39    * dem Request verwendet. Die Funktion verwendet dabei eine Positivliste.
40    * Nur erlaubte Zeichen werden in die Zielzeichenkette übernommen. 
41    * Alle Benutzereingaben muessen zentral durch diese Methode geschleusst
42    * werden. Sonst vergesse ich an anderer Stelle nachher noch einen Check!!!
43    * Wird in preventSQLInjection true übergeben, so werden auch
44    * '\', '\'' und '"' durch einen vorangestellten '\' entschärft, um
45    * auch bei dynamischem SQL (also ohne PreparedStatements) Schweinerein 
46    * der Form: "...brabra';drop database;" zu verhindern.
47    *
48    * @param  value Der Orginalwert aus der Benutzereingabe. Kann Schweinereien
49    * enthalten.
50    * @param level Bestimmt, was (zusätzlich zum Positivfilter alle Eingaben) mit den 
51    * Zeichen '"', '\', ''' und '#' geschehen soll (s. a. {@link SecurityLevel}).
52    * @return Der hoffentlich "entschärfte" String.
53    */
54   static disarmHttpInput(value, level)
55   {
56      
57      if (!value || value.trim() === '')
58          return '';
59      
60      if (!level)
61          level = SecurityLevel.Normal;
62      
63      let result = '';
64      value = this.convertHTMLUnicodeEntitaeten(value);
65      const length = value.length;
66      
67      for (let i = 0; i < length; i++)
68      {
69          const c = value.charAt(i);
70          const code = value.charCodeAt(i);
71          
72          switch (c)
73          {
74              case '\\':
75                  if (level === SecurityLevel.Normal)
76                      result += '\\\\';
77                  else if (level === SecurityLevel.Low)
78                      result += '\\';
79                  break;
80              case '\'':
81                  if (level === SecurityLevel.Normal)
82                      result += "\\'";
83                  else if (level === SecurityLevel.Low)
84                      result += "'";
85                  break;
86              case '"':
87                  if (level === SecurityLevel.Normal)
88                      result += '\\"';
89                  else if (level === SecurityLevel.Low)
90                      result += '"';
91                  break;
92              case '#':
93                  if (level === SecurityLevel.Low)
94                      result += '#';
95                  break;
96              case '\t':
97                  if (level === SecurityLevel.Low)
98                      result += '\t';
99                  break;
100              case '&':
101              case '!':
102              case '§':
103              case '$':
104              case '/':
105              case '(':
106              case ')':
107              case '=':
108              case '?':
109              case '`':
110              case '*':
111              case '~':
112              case '_':
113              case ':':
114              case ';':
115              case '<':
116              case '|':
117              case '{':
118              case '}':
119              case '[':
120              case ']':
121              case '>':
122              case '-':
123              case '.':
124              case ',':
125              case '+':
126              case '@':
127              case ' ':
128              case '²':
129              case '³':
130              case '°':
131              case '€':
132              case '\n':
133              case '%':
134              case '^':
135              case '»':
136              case '«':
137                  result += c;
138                  break;
139              default:
140                  switch (code)
141                  {
142                      case 150:
143                          result += '-';
144                          break;
145                      case 164:
146                          result += c;
147                          break;
148                      case 128:
149                          result += '&euro;';
150                          break;
151                      case 132:
152                          result += '&bdquo;';
153                          break;
154                      case 147:
155                          result += '&ldquo;';
156                          break;
157                      case 148:
158                          result += '&rdquo;';
159                          break;
160                      default:
161                          if (/^[a-zA-Z0-9]$/.test(c))
162                              result += c;
163                  }
164          }
165      }
166      
167      return result;
168   }
169   
170   /**
171    * Wandelt Umlaute im übergebenen String in die entsprechenden HTML-Quotes um.
172    * 
173    * @param html Der Orginalstring mit Umlauten.
174    * @return Das Ergebnis mit den HTML-Quote Entsprechungen für die Umlaute.
175    */
176   static disarmHtmlOutput(html, level)
177   {
178      if (!html || html.trim() === '')
179          return '';
180      
181      if (!level)
182          level = SecurityLevel.Normal;
183      
184      if (level !== SecurityLevel.Low)
185      {
186          html = html.replaceAll('\\\\\'', '&quot;');
187          html = html.replaceAll('\\\\"', '&prime;');
188      }
189      
190      let result = '';
191      const length = html.length;
192      
193      for (let i = 0; i < length; i++)
194      {
195          const c = html.charAt(i);
196          const code = html.charCodeAt(i);
197          
198          switch (code)
199          {
200              case 128:
201              case 8364:
202                  result += '&euro;';
203                  break;
204              case 132:
205              case 8222:
206                  result += '&bdquo;';
207                  break;
208              case 147:
209              case 8220:
210                  result += '&ldquo;';
211                  break;
212              case 148:
213              case 8221:
214                  result += '&rdquo;';
215                  break;
216              case 8216:
217                  result += '&lsquo;';
218                  break;
219              case 8217:
220                  result += '&rsquo;';
221                  break;
222              case 8218:
223                  result += '&sbquo;';
224                  break;
225              case 8211:
226                  result += '&ndash;';
227                  break;
228              case 8212:
229                  result += '&mdash;';
230                  break;
231              case 180:
232                  result += '&acute;';
233                  break;
234              case 8242:
235                  result += '&prime;';
236                  break;
237              default:
238                  switch (c)
239                  {
240                      case 'ä':
241                         result += '&auml;';
242                         break;
243                      case 'ö': 
244                         result += '&ouml;';
245                         break;
246                      case 'ü': 
247                         result += '&uuml;'; 
248                         break;
249                      case 'Ä': 
250                         result += '&Auml;';
251                         break;
252                      case 'Ö': 
253                         result += '&Ouml;';
254                         break;
255                      case 'Ü': 
256                         result += '&Uuml;';
257                         break;
258                      case 'ß': 
259                         result += '&szlig;';

260                         break;
261                      case '»': 
262                         result += '»';
263                         break;
264                      case '«': 
265                         result += '«';
266                         break;
267                      case '\u00A0': 
268                         result += ' ';
269                         break;
270                      case "'":
271                          if (level !== SecurityLevel.Low)
272                              result += '′';
273                          else
274                              result += c;
275                          break;
276                      case '"':
277                          if (level !== SecurityLevel.Low)
278                              result += '"';
279                          else
280                              result += c;
281                          break;
282                      case '<':
283                          if (level !== SecurityLevel.Low)
284                              result += '&lt;';
285                          else
286                              result += c;
287                          break;
288                      case '>':
289                          if (level !== SecurityLevel.Low)
290                              result += '&gt;';
291                          else
292                              result += c;
293                          break;
294                      default:
295                          result += c;
296                  }
297          }
298      }
299      
300      return result;
301  }
302}