1 /* $OpenBSD: util.c,v 1.63 2006/11/24 13:52:14 reyk Exp $ */ 2 /* $EOM: util.c,v 1.23 2000/11/23 12:22:08 niklas Exp $ */ 3 4 /* 5 * Copyright (c) 1998, 1999, 2001 Niklas Hallqvist. All rights reserved. 6 * Copyright (c) 2000, 2001, 2004 H�kan Olsson. All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 /* 30 * This code was written under funding by Ericsson Radio Systems. 31 */ 32 33 #include <sys/types.h> 34 #include <sys/socket.h> 35 #include <sys/stat.h> 36 #include <netinet/in.h> 37 #include <arpa/inet.h> 38 #include <limits.h> 39 #include <netdb.h> 40 #include <stdlib.h> 41 #include <string.h> 42 #include <unistd.h> 43 #include <errno.h> 44 #include <ifaddrs.h> 45 #include <net/route.h> 46 #include <net/if.h> 47 48 #include "log.h" 49 #include "message.h" 50 #include "monitor.h" 51 #include "sysdep.h" 52 #include "transport.h" 53 #include "util.h" 54 55 /* 56 * Set if -N is given, allowing name lookups to be done, possibly stalling 57 * the daemon for quite a while. 58 */ 59 int allow_name_lookups = 0; 60 61 #if defined(INSECURE_RAND) 62 /* 63 * This is set to true in case of regression-test mode, when it will 64 * cause predictable random numbers be generated. 65 */ 66 int regrand = 0; 67 #endif 68 69 /* 70 * XXX These might be turned into inlines or macros, maybe even 71 * machine-dependent ones, for performance reasons. 72 */ 73 u_int16_t 74 decode_16(u_int8_t *cp) 75 { 76 return cp[0] << 8 | cp[1]; 77 } 78 79 u_int32_t 80 decode_32(u_int8_t *cp) 81 { 82 return cp[0] << 24 | cp[1] << 16 | cp[2] << 8 | cp[3]; 83 } 84 85 void 86 encode_16(u_int8_t *cp, u_int16_t x) 87 { 88 *cp++ = x >> 8; 89 *cp = x & 0xff; 90 } 91 92 void 93 encode_32(u_int8_t *cp, u_int32_t x) 94 { 95 *cp++ = x >> 24; 96 *cp++ = (x >> 16) & 0xff; 97 *cp++ = (x >> 8) & 0xff; 98 *cp = x & 0xff; 99 } 100 101 /* Check a buffer for all zeroes. */ 102 int 103 zero_test(const u_int8_t *p, size_t sz) 104 { 105 while (sz-- > 0) 106 if (*p++ != 0) 107 return 0; 108 return 1; 109 } 110 111 /* 112 * Generate 32 bits of random data. If compiled with INSECURE_RAND 113 * and -r option is specified, then return deterministic data. 114 */ 115 u_int32_t 116 rand_32(void) 117 { 118 #if !defined(INSECURE_RAND) 119 return arc4random(); 120 #else 121 if (regrand) 122 return random(); 123 else 124 return arc4random(); 125 #endif 126 } 127 128 /* 129 * Generate a random data, len bytes long. 130 */ 131 u_int8_t * 132 getrandom(u_int8_t *buf, size_t len) 133 { 134 u_int32_t tmp = 0; 135 size_t i; 136 137 for (i = 0; i < len; i++) { 138 if (i % sizeof tmp == 0) 139 tmp = rand_32(); 140 141 buf[i] = tmp & 0xff; 142 tmp >>= 8; 143 } 144 145 return buf; 146 } 147 148 static __inline int 149 hex2nibble(char c) 150 { 151 if (c >= '0' && c <= '9') 152 return c - '0'; 153 if (c >= 'a' && c <= 'f') 154 return c - 'a' + 10; 155 if (c >= 'A' && c <= 'F') 156 return c - 'A' + 10; 157 return -1; 158 } 159 160 /* 161 * Convert hexadecimal string in S to raw binary buffer at BUF sized SZ 162 * bytes. Return 0 if everything is OK, -1 otherwise. 163 */ 164 int 165 hex2raw(char *s, u_int8_t *buf, size_t sz) 166 { 167 u_int8_t *bp; 168 char *p; 169 int tmp; 170 171 if (strlen(s) > sz * 2) 172 return -1; 173 for (p = s + strlen(s) - 1, bp = &buf[sz - 1]; bp >= buf; bp--) { 174 *bp = 0; 175 if (p >= s) { 176 tmp = hex2nibble(*p--); 177 if (tmp == -1) 178 return -1; 179 *bp = tmp; 180 } 181 if (p >= s) { 182 tmp = hex2nibble(*p--); 183 if (tmp == -1) 184 return -1; 185 *bp |= tmp << 4; 186 } 187 } 188 return 0; 189 } 190 191 /* 192 * Convert raw binary buffer to a newly allocated hexadecimal string. Returns 193 * NULL if an error occurred. It is the caller's responsibility to free the 194 * returned string. 195 */ 196 char * 197 raw2hex(u_int8_t *buf, size_t sz) 198 { 199 char *s; 200 size_t i; 201 202 if ((s = (char *)malloc(sz * 2 + 1)) == NULL) { 203 log_error("raw2hex: malloc (%lu) failed", (unsigned long)sz * 2 + 1); 204 return NULL; 205 } 206 207 for (i = 0; i < sz; i++) 208 snprintf(s + (2 * i), 2 * (sz - i) + 1, "%02x", buf[i]); 209 210 s[sz * 2] = '\0'; 211 return s; 212 } 213 214 in_port_t 215 text2port(char *port_str) 216 { 217 char *port_str_end; 218 long port_long; 219 struct servent *service; 220 221 port_long = strtol(port_str, &port_str_end, 0); 222 if (port_str == port_str_end) { 223 service = getservbyname(port_str, "udp"); 224 if (!service) { 225 log_print("text2port: service \"%s\" unknown", 226 port_str); 227 return 0; 228 } 229 return ntohs(service->s_port); 230 } else if (port_long < 1 || port_long > (long)USHRT_MAX) { 231 log_print("text2port: port %ld out of range", port_long); 232 return 0; 233 } 234 return port_long; 235 } 236 237 int 238 text2sockaddr(char *address, char *port, struct sockaddr **sa, sa_family_t af, 239 int netmask) 240 { 241 struct addrinfo *ai, hints; 242 struct sockaddr_storage tmp_sas; 243 struct ifaddrs *ifap, *ifa = NULL, *llifa = NULL; 244 char *np = address; 245 char ifname[IFNAMSIZ]; 246 u_char buf[BUFSIZ]; 247 struct rt_msghdr *rtm; 248 struct sockaddr *sa2; 249 struct sockaddr_in *sin; 250 struct sockaddr_in6 *sin6; 251 int fd = 0, seq, len, b; 252 pid_t pid; 253 254 bzero(&hints, sizeof hints); 255 if (!allow_name_lookups) 256 hints.ai_flags = AI_NUMERICHOST; 257 hints.ai_family = PF_UNSPEC; 258 hints.ai_socktype = SOCK_DGRAM; 259 hints.ai_protocol = IPPROTO_UDP; 260 261 if (getaddrinfo(address, port, &hints, &ai)) { 262 /* 263 * If the 'default' keyword is used, do a route lookup for 264 * the default route, and use the interface associated with 265 * it to select a source address. 266 */ 267 if (!strcmp(address, "default")) { 268 fd = socket(PF_ROUTE, SOCK_RAW, af); 269 270 bzero(buf, sizeof(buf)); 271 272 rtm = (struct rt_msghdr *)buf; 273 rtm->rtm_version = RTM_VERSION; 274 rtm->rtm_type = RTM_GET; 275 rtm->rtm_flags = RTF_UP; 276 rtm->rtm_addrs = RTA_DST; 277 rtm->rtm_seq = seq = arc4random(); 278 279 /* default destination */ 280 sa2 = (struct sockaddr *)(rtm + 1); 281 switch (af) { 282 case AF_INET: { 283 sin = (struct sockaddr_in *)sa2; 284 sin->sin_len = sizeof(*sin); 285 sin->sin_family = af; 286 break; 287 } 288 case AF_INET6: { 289 sin6 = (struct sockaddr_in6 *)sa2; 290 sin6->sin6_len = sizeof(*sin6); 291 sin6->sin6_family = af; 292 break; 293 } 294 default: 295 close(fd); 296 return -1; 297 } 298 rtm->rtm_addrs |= RTA_NETMASK|RTA_IFP|RTA_IFA; 299 rtm->rtm_msglen = sizeof(*rtm) + sizeof(*sa2); 300 301 if ((b = write(fd, buf, rtm->rtm_msglen)) < 0) { 302 close(fd); 303 return -1; 304 } 305 306 pid = getpid(); 307 308 while ((len = read(fd, buf, sizeof(buf))) > 0) { 309 if (len < sizeof(*rtm)) { 310 close(fd); 311 return -1; 312 } 313 314 if (rtm->rtm_type == RTM_GET && 315 rtm->rtm_pid == pid && 316 rtm->rtm_seq == seq) { 317 if (rtm->rtm_errno) { 318 close(fd); 319 return -1; 320 } 321 break; 322 } 323 } 324 close(fd); 325 326 if ((rtm->rtm_addrs & (RTA_DST|RTA_GATEWAY)) == 327 (RTA_DST|RTA_GATEWAY)) { 328 np = if_indextoname(rtm->rtm_index, ifname); 329 if (np == NULL) 330 return -1; 331 } 332 } 333 334 if (getifaddrs(&ifap) != 0) 335 return -1; 336 337 switch (af) { 338 default: 339 case AF_INET: 340 for (ifa = ifap; ifa; ifa = ifa->ifa_next) 341 if (!strcmp(ifa->ifa_name, np) && 342 ifa->ifa_addr != NULL && 343 ifa->ifa_addr->sa_family == AF_INET) 344 break; 345 break; 346 case AF_INET6: 347 for (ifa = ifap; ifa; ifa = ifa->ifa_next) { 348 if (!strcmp(ifa->ifa_name, np) && 349 ifa->ifa_addr != NULL && 350 ifa->ifa_addr->sa_family == AF_INET6) { 351 if (IN6_IS_ADDR_LINKLOCAL( 352 &((struct sockaddr_in6 *) 353 ifa->ifa_addr)->sin6_addr) && 354 llifa == NULL) 355 llifa = ifa; 356 else 357 break; 358 } 359 } 360 if (ifa == NULL) { 361 ifa = llifa; 362 } 363 break; 364 } 365 366 if (ifa) { 367 if (netmask) 368 memcpy(&tmp_sas, ifa->ifa_netmask, 369 SA_LEN(ifa->ifa_netmask)); 370 else 371 memcpy(&tmp_sas, ifa->ifa_addr, 372 SA_LEN(ifa->ifa_addr)); 373 freeifaddrs(ifap); 374 } else { 375 freeifaddrs(ifap); 376 return -1; 377 } 378 } else { 379 memcpy(&tmp_sas, ai->ai_addr, SA_LEN(ai->ai_addr)); 380 freeaddrinfo(ai); 381 } 382 383 *sa = malloc(SA_LEN((struct sockaddr *)&tmp_sas)); 384 if (!*sa) 385 return -1; 386 387 memcpy(*sa, &tmp_sas, SA_LEN((struct sockaddr *)&tmp_sas)); 388 return 0; 389 } 390 391 /* 392 * Convert a sockaddr to text. With zflag non-zero fill out with zeroes, 393 * i.e 10.0.0.10 --> "010.000.000.010" 394 */ 395 int 396 sockaddr2text(struct sockaddr *sa, char **address, int zflag) 397 { 398 char buf[NI_MAXHOST], *token, *bstart, *ep; 399 int addrlen, i, j; 400 long val; 401 402 if (getnameinfo(sa, SA_LEN(sa), buf, sizeof buf, 0, 0, 403 allow_name_lookups ? 0 : NI_NUMERICHOST)) 404 return -1; 405 406 if (zflag == 0) { 407 *address = strdup(buf); 408 if (!*address) 409 return -1; 410 } else 411 switch (sa->sa_family) { 412 case AF_INET: 413 addrlen = sizeof "000.000.000.000"; 414 *address = malloc(addrlen); 415 if (!*address) 416 return -1; 417 buf[addrlen] = '\0'; 418 bstart = buf; 419 **address = '\0'; 420 while ((token = strsep(&bstart, ".")) != NULL) { 421 if (strlen(*address) > 12) { 422 free(*address); 423 return -1; 424 } 425 val = strtol(token, &ep, 10); 426 if (ep == token || val < (long)0 || 427 val > (long)UCHAR_MAX) { 428 free(*address); 429 return -1; 430 } 431 snprintf(*address + strlen(*address), 432 addrlen - strlen(*address), "%03ld", val); 433 if (bstart) 434 strlcat(*address, ".", addrlen); 435 } 436 break; 437 438 case AF_INET6: 439 /* 440 * XXX In the algorithm below there are some magic 441 * numbers we probably could give explaining names. 442 */ 443 addrlen = 444 sizeof "0000:0000:0000:0000:0000:0000:0000:0000"; 445 *address = malloc(addrlen); 446 if (!*address) 447 return -1; 448 449 for (i = 0, j = 0; i < 8; i++) { 450 snprintf((*address) + j, addrlen - j, 451 "%02x%02x", 452 ((struct sockaddr_in6 *)sa)->sin6_addr.s6_addr[2*i], 453 ((struct sockaddr_in6 *)sa)->sin6_addr.s6_addr[2*i + 1]); 454 j += 4; 455 (*address)[j] = 456 (j < (addrlen - 1)) ? ':' : '\0'; 457 j++; 458 } 459 break; 460 461 default: 462 *address = strdup("<error>"); 463 if (!*address) 464 return -1; 465 } 466 467 return 0; 468 } 469 470 /* 471 * sockaddr_addrlen and sockaddr_addrdata return the relevant sockaddr info 472 * depending on address family. Useful to keep other code shorter(/clearer?). 473 */ 474 int 475 sockaddr_addrlen(struct sockaddr *sa) 476 { 477 switch (sa->sa_family) { 478 case AF_INET6: 479 return sizeof((struct sockaddr_in6 *)sa)->sin6_addr.s6_addr; 480 case AF_INET: 481 return sizeof((struct sockaddr_in *)sa)->sin_addr.s_addr; 482 default: 483 log_print("sockaddr_addrlen: unsupported protocol family %d", 484 sa->sa_family); 485 return 0; 486 } 487 } 488 489 u_int8_t * 490 sockaddr_addrdata(struct sockaddr *sa) 491 { 492 switch (sa->sa_family) { 493 case AF_INET6: 494 return (u_int8_t *)&((struct sockaddr_in6 *)sa)->sin6_addr.s6_addr; 495 case AF_INET: 496 return (u_int8_t *)&((struct sockaddr_in *)sa)->sin_addr.s_addr; 497 default: 498 log_print("sockaddr_addrdata: unsupported protocol family %d", 499 sa->sa_family); 500 return 0; 501 } 502 } 503 504 in_port_t 505 sockaddr_port(struct sockaddr *sa) 506 { 507 switch (sa->sa_family) { 508 case AF_INET6: 509 return ((struct sockaddr_in6 *)sa)->sin6_port; 510 case AF_INET: 511 return ((struct sockaddr_in *)sa)->sin_port; 512 default: 513 log_print("sockaddr_port: unsupported protocol family %d", 514 sa->sa_family); 515 return 0; 516 } 517 } 518 519 /* Utility function used to set the port of a sockaddr. */ 520 void 521 sockaddr_set_port(struct sockaddr *sa, in_port_t port) 522 { 523 switch (sa->sa_family) { 524 case AF_INET: 525 ((struct sockaddr_in *)sa)->sin_port = htons (port); 526 break; 527 528 case AF_INET6: 529 ((struct sockaddr_in6 *)sa)->sin6_port = htons (port); 530 break; 531 } 532 } 533 534 /* 535 * Convert network address to text. The network address does not need 536 * to be properly aligned. 537 */ 538 void 539 util_ntoa(char **buf, int af, u_int8_t *addr) 540 { 541 struct sockaddr_storage from; 542 struct sockaddr *sfrom = (struct sockaddr *) & from; 543 socklen_t fromlen = sizeof from; 544 545 bzero(&from, fromlen); 546 sfrom->sa_family = af; 547 548 switch (af) { 549 case AF_INET: 550 sfrom->sa_len = sizeof(struct sockaddr_in); 551 break; 552 case AF_INET6: 553 sfrom->sa_len = sizeof(struct sockaddr_in6); 554 break; 555 } 556 557 memcpy(sockaddr_addrdata(sfrom), addr, sockaddr_addrlen(sfrom)); 558 559 if (sockaddr2text(sfrom, buf, 0)) { 560 log_print("util_ntoa: could not make printable address out " 561 "of sockaddr %p", sfrom); 562 *buf = 0; 563 } 564 } 565 566 /* 567 * Perform sanity check on files containing secret information. 568 * Returns -1 on failure, 0 otherwise. 569 * Also, if FILE_SIZE is a not a null pointer, store file size here. 570 */ 571 572 int 573 check_file_secrecy_fd(int fd, char *name, size_t *file_size) 574 { 575 struct stat st; 576 577 if (fstat(fd, &st) == -1) { 578 log_error("check_file_secrecy: stat (\"%s\") failed", name); 579 return -1; 580 } 581 if (st.st_uid != 0 && st.st_uid != getuid()) { 582 log_print("check_file_secrecy_fd: " 583 "not loading %s - file owner is not process user", name); 584 errno = EPERM; 585 return -1; 586 } 587 if ((st.st_mode & (S_IRWXG | S_IRWXO)) != 0) { 588 log_print("check_file_secrecy_fd: not loading %s - too open " 589 "permissions", name); 590 errno = EPERM; 591 return -1; 592 } 593 if (file_size) 594 *file_size = (size_t)st.st_size; 595 596 return 0; 597 } 598 599 /* Calculate timeout. Returns -1 on error. */ 600 long 601 get_timeout(struct timeval *timeout) 602 { 603 struct timeval now, result; 604 605 if (gettimeofday(&now, NULL) < 0) 606 return -1; 607 608 timersub(timeout, &now, &result); 609 610 return result.tv_sec; 611 } 612 613 614 /* Special for compiling with Boehms GC. See Makefile and sysdep.h */ 615 #if defined (USE_BOEHM_GC) 616 char * 617 gc_strdup(const char *x) 618 { 619 char *strcpy(char *,const char *); 620 char *y = malloc(strlen(x) + 1); 621 return strcpy(y,x); 622 } 623 #endif 624 625 int 626 expand_string(char *label, size_t len, const char *srch, const char *repl) 627 { 628 char *tmp; 629 char *p, *q; 630 631 if ((tmp = calloc(1, len)) == NULL) { 632 log_error("expand_string: calloc"); 633 return (-1); 634 } 635 p = q = label; 636 while ((q = strstr(p, srch)) != NULL) { 637 *q = '\0'; 638 if ((strlcat(tmp, p, len) >= len) || 639 (strlcat(tmp, repl, len) >= len)) { 640 log_print("expand_string: string too long"); 641 return (-1); 642 } 643 q += strlen(srch); 644 p = q; 645 } 646 if (strlcat(tmp, p, len) >= len) { 647 log_print("expand_string: string too long"); 648 return (-1); 649 } 650 strlcpy(label, tmp, len); /* always fits */ 651 free(tmp); 652 653 return (0); 654 } 655