webinterface.git

1) <?php

2) 

3) /*
4) This file belongs to the Webinterface of schokokeks.org Hosting
5) 

6) Written by schokokeks.org Hosting, namely

7)   Bernd Wurst <bernd@schokokeks.org>
8)   Hanno Böck <hanno@schokokeks.org>
9) 

10) This code is published under a 0BSD license.

11) 
12) Nevertheless, in case you use a significant part of this code, we ask (but not require, see the license) that you keep the authors' names in place and return your changes to the public. We would be especially happy if you tell us what you're going to do with this code.
13) */

14) 

15) require_once('inc/error.php');

16) require_once('inc/base.php');

17) require_once('vendor/autoload.php');

18) 

19) function gen_pw_hash($password)
20) {

21)     /* For yescrypt, a 128 bit salt in non-standard base64 is
22)        needed. We just need random data with valid encoding. */
23)     $salt = base64_encode(random_bytes(16));
24)     $salt = rtrim($salt, "=");
25)     $salt = strtr($salt, "AQgw+/01", "./01AQgw");
26)     $pwhash = crypt($password, '$y$j9T$' . $salt);

27)     if (strlen($pwhash) < 13) {
28)         /* returns a string shorter than 13 chars on failure */
29)         system_failure("Failed to calculate password hash!");
30)     }
31)     return $pwhash;
32) }
33) 

34) 
35) function legacy_pw_verify($password, $hash)
36) {
37)     /* Supports legacy SHA1/SHA256 hashes without salt,
38)        for new use cases use password_verify() instead */
39)     if ($hash[0] == '$') {
40)         return password_verify($password, $hash);
41)     } elseif (strlen($hash) == 40) {
42)         return hash_equals(sha1($password), $hash);
43)     } elseif (strlen($hash) == 64) {
44)         return hash_equals(hash("sha256", $password), $hash);
45)     }
46)     return false;
47) }
48) 
49) 

50) function strong_password($password, $user = [])

51) {

52)     $pwcheck = config('pwcheck');
53)     $result = null;
54)     if ($pwcheck) {
55)         DEBUG($pwcheck);

56)         $req = curl_init($pwcheck);

57)         curl_setopt($req, CURLOPT_RETURNTRANSFER, 1);
58)         curl_setopt($req, CURLOPT_SSL_VERIFYPEER, 1);
59)         curl_setopt($req, CURLOPT_SSL_VERIFYSTATUS, 1);
60)         curl_setopt($req, CURLOPT_CONNECTTIMEOUT, 5);
61)         curl_setopt($req, CURLOPT_TIMEOUT, 5);
62)         curl_setopt($req, CURLOPT_FOLLOWLOCATION, 0);

63)         curl_setopt($req, CURLOPT_POST, 1);

64)         curl_setopt($req, CURLOPT_POSTFIELDS, "password=" . urlencode($password));

65)         $result = chop(curl_exec($req));
66)         DEBUG($result);
67)     }
68)     if ($result === 'good') {
69)         return true;
70)     } elseif ($result === 'bad') {

71)         return "Unsere Überprüfung hat ergeben, dass dieses Passwort in bisher veröffentlichten Passwortlisten enthalten ist. Es wird daher nicht akzeptiert.";

72)     }

73)     // Kein Online-Check eingerichtet oder der request war nicht erfolgreich
74)     DEBUG('using Zxcvbn for password check!');
75)     $passwordchecker = new ZxcvbnPhp\Zxcvbn();

76)     if ($user) {
77)         $strength = $passwordchecker->passwordStrength($password, $user);
78)     } else {
79)         $strength = $passwordchecker->passwordStrength($password);
80)     }

81)     DEBUG('password strength: ' . $strength['score']);

82)     if ($strength['score'] < 2) {
83)         return "Das Passwort ist zu einfach!";

84)     }
85)     return true;

86) }
87) 
88) 

89) function filter_input_general($input)

90) {

91)     if ($input === null) {
92)         return null;
93)     }

94)     $input = (string) $input;

95)     $filtered = preg_replace('/[\x00-\x09\x0b-\x0c\x0e-\x1f]/', '', $input);
96)     if ($filtered !== $input) {
97)         system_failure("Ihre Daten enthielten ungültige Zeichen!");
98)         logger(LOG_WARNING, 'inc/security', 'filter_input_general', 'Ungültige Daten!');
99)     }
100)     return $filtered;

101) }
102) 

103) function filter_input_oneline($input)

104) {

105)     if ($input === null) {
106)         return null;
107)     }

108)     $input = (string) $input;

109)     $filtered = preg_replace('/[\x00-\x1f]/', '', $input);
110)     if ($filtered !== $input) {

111)         system_failure("Ihre Daten enthielten ungültige Zeichen!");

112)         logger(LOG_WARNING, 'inc/security', 'filter_input_oneline', 'Ungültige Daten!');

113)     }

114)     return $filtered;

115) }
116) 
117) 

118) function filter_output_html($data)
119) {

120)     if (!$data) {

121)         return "";
122)     }

123)     return htmlspecialchars($data, ENT_QUOTES);
124) }
125) 
126) 

127) function verify_input_ascii($data)
128) {

129)     $data = (string) $data;

130)     $filtered = filter_var($data, FILTER_UNSAFE_RAW, FILTER_FLAG_STRIP_LOW | FILTER_FLAG_STRIP_HIGH);
131)     if ($filtered != $data) {

132)         logger(LOG_WARNING, 'inc/security', 'verify_input_ascii', 'Ungültige Daten: ' . $data);

133)         system_failure("Ihre Eingabe enthielt ungültige Zeichen");
134)     }
135)     return $filtered;
136) }
137) 
138) 
139) function verify_input_identifier($data)
140) {

141)     $data = (string) $data;

142)     if ($data === "") {
143)         system_failure("Leerer Bezeichner");
144)     }
145)     $filtered = preg_replace("/[^[:alnum:]\_\.\-]/", "", $data);
146)     if ($filtered !== $data) {

147)         logger(LOG_WARNING, 'inc/security', 'verify_input_identifier', 'Ungültige Daten: ' . $data);

148)         system_failure("Ihre Daten enthielten ungültige Zeichen!");
149)     }
150)     return $filtered;
151) }
152) 

153) 

154) function filter_input_username($input)

155) {

156)     $username = preg_replace("/[^[:alnum:]\_\.\+\-]/", "", $input);

157)     if ($username === "") {
158)         system_failure("Leerer Benutzername!");
159)     }
160)     return $username;

161) }
162) 

163) function verify_input_username($input)

164) {

165)     if (filter_input_username($input) != $input) {

166)         logger(LOG_WARNING, 'inc/security', 'verify_input_username', 'Ungültige Daten: ' . $input);

167)         system_failure("Ihre Daten enthielten ungültige Zeichen!");
168)     }

169) }
170) 

171) 
172) 

173) function filter_input_hostname($input, $wildcard = false)

174) {

175)     DEBUG('filter_input_hostname("' . $input . '", $wildcard=' . $wildcard . ')');

176)     $input = strtolower($input);

177)     $input = trim($input, "\t\n\r\x00 .");

178)     if (preg_replace("/[^.]_/", "", $input) != $input) {
179)         system_failure("Der Unterstrich ist nur als erstes Zeichen eines Hostnames erlaubt.");
180)     }

181)     if (preg_replace("/[^[:alnum:]_*\.\-]/u", "", $input) != $input) {

182)         system_failure("Ihre Daten enthielten ungültige Zeichen!");
183)     }
184)     if (preg_match("/^.+\*/", $input)) {
185)         system_failure("Ihre Daten enthielten ungültige Zeichen (Wildcard-Stern muss ganz vorne stehen)!");
186)     }

187)     if (!$wildcard && preg_replace("/^\*/", "", $input) != $input) {

188)         system_failure("Ihre Daten enthielten ungültige Zeichen (Keine Wildcards erlaubt)!");
189)     }
190)     if (strstr($input, '..')) {
191)         system_failure("Ungültiger Hostname");
192)     }
193)     return $input;

194) }
195) 

196) function verify_input_hostname($input, $wildcard = false)

197) {

198)     if (filter_input_hostname($input, $wildcard) != $input) {

199)         logger(LOG_WARNING, 'inc/security', 'verify_input_hostname', 'Ungültige Daten: ' . $input);

200)         system_failure("Ihre Daten enthielten ungültige Zeichen!");
201)     }

202) }
203) 
204) 

205) function verify_input_hostname_utf8($input)
206) {
207)     $puny = idn_to_ascii($input, IDNA_DEFAULT, INTL_IDNA_VARIANT_UTS46);
208)     if ($puny === false) {

209)         system_failure("Ungültiger Hostname! idn " . $input);

210)     }
211)     $filter = filter_var($puny, FILTER_VALIDATE_DOMAIN, FILTER_FLAG_HOSTNAME);

212)     if ($filter !== $puny) {

213)         system_failure("Ungültiger Hostname! filter " . $input);

214)     }
215) }
216) 
217) 

218) function verify_input_ipv4($input)

219) {

220)     if (!preg_match("/^([1-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(\.([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3}$/", $input)) {

221)         system_failure('Keine IP-Adresse');
222)     }

223) }
224) 
225) 

226) function verify_input_ipv6($input)

227) {

228)     // ripped from Perl module Net-IPv6Addr v0.2

229)     if (!preg_match("/^(([0-9a-f]{1,4}:){7}[0-9a-f]{1,4}|[0-9a-f]{0,4}::|:(?::[a-f0-9]{1,4}){1,6}|(?:[a-f0-9]{1,4}:){1,6}:|(?:[a-f0-9]{1,4}:)(?::[a-f0-9]{1,4}){1,6}|(?:[a-f0-9]{1,4}:){2}(?::[a-f0-9]{1,4}){1,5}|(?:[a-f0-9]{1,4}:){3}(?::[a-f0-9]{1,4}){1,4}|(?:[a-f0-9]{1,4}:){4}(?::[a-f0-9]{1,4}){1,3}|(?:[a-f0-9]{1,4}:){5}(?::[a-f0-9]{1,4}){1,2}|(?:[a-f0-9]{1,4}:){6}(?::[a-f0-9]{1,4}))$/i", $input)) {

230)         system_failure("Ungültige IPv6-Adresse");
231)     }

232) }

233) 

234) function verify_input_recorddata($input)

235) {

236)     if (is_string($input) && (strstr($input, "\\") || strstr($input, '"'))) {

237)         system_failure("Ungültige Zeichen");
238)     }

239) }

240) 

241) function filter_quotes($input)

242) {

243)     return preg_replace('/["\'`]/', '', $input);

244) }
245) 

246) 
247) 

248) function filter_shell($input)

249) {

250)     return preg_replace('/[^-[:alnum:]\_\.\+ßäöüÄÖÜ/%§=]/', '', $input);

251) }
252) 

253) function verify_shell($input)

254) {

255)     if (filter_shell($input) != $input) {
256)         system_failure("Ihre Daten enthielten ungültige Zeichen!");
257)     }

258) }

259) 

260) 

261) function filter_ssh_key($key, &$fphash = "")

262) {

263)     $filtered = trim(str_replace(["\r", "\n"], ' ', $key));
264)     $keyparts = explode(" ", $filtered);

265) 

266)     if ((count($keyparts) > 3) || (count($keyparts) < 2)) {
267)         system_failure("Ungültiger SSH-Key!");
268)     }

269) 

270)     if (preg_match("/^[a-z0-9]+-[a-z0-9-]+$/", $keyparts[0]) === 0) {
271)         system_failure("Ungültiger SSH-Key!");
272)     }

273) 

274)     if (base64_decode($keyparts[1], 1) == false) {
275)         system_failure("Ungültiger SSH-Key!");
276)     }

277) 

278)     if ((count($keyparts) === 3) && (preg_match("/^[a-zA-Z0-9@._-]+$/", $keyparts[2]) === 0)) {

279)         system_failure("Ungültige Zeichen im Kommentar des SSH-Keys!");
280)     }

281) 

282)     if ($keyparts[0] == "ssh-dss") {
283)         system_failure("DSA-Keys werden nicht unterstützt!");
284)     }
285) 

286)     if (count($keyparts) === 2) {

287)         $fkey = $keyparts[0] . " " . $keyparts[1];

288)     } else {

289)         $fkey = $keyparts[0] . " " . $keyparts[1] . " " . $keyparts[2];

290)     }

291) 

292)     $descr = [
293)         0 => ["pipe", "r"],
294)         1 => ["pipe", "w"],
295)         2 => ["pipe", "w"],
296)     ];
297)     $sshcmd = proc_open("ssh-keygen -l -f -", $descr, $pipes, null, null);

298)     fwrite($pipes[0], $fkey);

299)     fclose($pipes[0]);
300)     $fphash = fread($pipes[1], 1024);

301)     if (proc_close($sshcmd) !== 0) {
302)         system_failure("Ungültiger SSH-Key laut ssh-keygen!");
303)     }
304) 

305)     $fphash = explode(" ", $fphash)[1];
306)     if ((strlen($fphash) != 50) || (substr($fphash, 0, 7) != "SHA256:")) {
307)         system_failure("Interner Fehler: Fingerprint im falschen Format");
308)     }
309)     $fphash = substr($fphash, 7);
310) 

311)     return $fkey;

312) }
313) 

314) 

315) function check_path($input)

316) {

317)     DEBUG("checking {$input} for valid path name");

318)     if ($input != filter_output_html($input)) {

319)         logger(LOG_WARNING, 'inc/security', 'check_path', 'HTML-Krams im Pfad: ' . $input);

320)         DEBUG("HTML-Krams im Pfad");
321)         return false;
322)     }
323)     $components = explode("/", $input);
324)     foreach ($components as $item) {
325)         if ($item == '..') {

326)             logger(LOG_WARNING, 'inc/security', 'check_path', '»..« im Pfad: ' . $input);

327)             DEBUG("»..« im Pfad");
328)             return false;
329)         }

330)         if (strlen($item) > 255) {
331)             return false;
332)         }
333)     }
334)     if (strlen($input) > 2048) {
335)         return false;

336)     }

337)     return (preg_match('/^[ A-Za-z0-9.@\/_-]*$/', $input) == 1);

338) }
339) 
340) 

341) function in_homedir($path)
342) {

343)     DEBUG("Prüfe »{$path}«");

344)     if (!check_path($path)) {

345)         DEBUG('Kein Pfad');
346)         return false;
347)     }

348)     if (!isset($_SESSION['userinfo']['homedir'])) {

349)         DEBUG("Kann homedir nicht ermitteln");
350)         return false;
351)     }

352)     return strncmp($_SESSION['userinfo']['homedir'], $path, strlen($_SESSION['userinfo']['homedir'])) == 0;

353) }
354) 

355) function check_date($input)

356) {

357)     return (bool) preg_match("/[0-9]{4}-(0?[1-9]|10|11|12)-([012]?[0-9]|30|31)/", $input);

358) }
359) 

360) 

361) function check_emailaddr($input)

362) {

363)     return (bool) filter_var($input, FILTER_VALIDATE_EMAIL) == $input;

364) }
365) 

366) function check_domain($input)

367) {

368)     return (bool) preg_match("/^[a-z0-9\.\-]+\.[a-z\-]{2,63}$/i", $input);

369) }

370) 
371) function check_input_types($input, $types)
372) {
373)     foreach ($types as $key => $type) {
374)         if (!array_key_exists($key, $input)) {
375)             system_failure("Interner Fehler bei Eingabevariablen");
376)         }
377)         if ($type === 'int') {

378)             if ($input[$key] !== (string) (int) $input[$key]) {