lib/libtcplay/io.c

   1 /*
   2  * Copyright (c) 2011 Alex Hornung <alex@alexhornung.com>.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in
  13  *    the documentation and/or other materials provided with the
  14  *    distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  19  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  20  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  22  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  24  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  25  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  26  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #include <sys/types.h>
  31 #if defined(__DragonFly__)
  32 #include <sys/diskslice.h>
  33 #elif defined(__linux__)
  34 #include <linux/fs.h>
  35 #include <sys/ioctl.h>
  36 #endif
  37 #include <sys/uio.h>
  38 #include <sys/select.h>
  39 #include <errno.h>
  40 #include <fcntl.h>
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44 #include <termios.h>
  45 #include <unistd.h>
  46
  47 #include "tcplay.h"
  48
  49 void *
  50 read_to_safe_mem(const char *file, off_t offset, size_t *sz)
  51 {
  52         void *mem = NULL;
  53         ssize_t r = 0;
  54         int fd;
  55
  56         if ((fd = open(file, O_RDONLY)) < 0) {
  57                 tc_log(1, "Error opening file %s\n", file);
  58                 return NULL;
  59         }
  60
  61         if ((mem = alloc_safe_mem(*sz)) == NULL) {
  62                 tc_log(1, "Error allocating memory\n");
  63                 goto out;
  64         }
  65
  66         if ((lseek(fd, offset, SEEK_SET) < 0)) {
  67                 tc_log(1, "Error seeking on file %s\n", file);
  68                 goto m_err;
  69         }
  70
  71         if ((r = read(fd, mem, *sz)) <= 0) {
  72                 tc_log(1, "Error reading from file %s\n", file);
  73                 goto m_err;
  74         }
  75
  76 out:
  77         *sz = r;
  78         close(fd);
  79         return mem;
  80         /* NOT REACHED */
  81
  82 m_err:
  83         free_safe_mem(mem);
  84         close(fd);
  85         return NULL;
  86 }
  87
  88 static size_t get_random_total_bytes = 0;
  89 static size_t get_random_read_bytes = 0;
  90
  91 static
  92 void
  93 get_random_summary(void)
  94 {
  95         float pct_done;
  96
  97         pct_done = (1.0 * get_random_read_bytes) /
  98             (1.0 * get_random_total_bytes) * 100.0;
  99         tc_log(0, "Gathering true randomness, %.0f%% done.\n", pct_done);
 100 }
 101
 102 int
 103 get_random(unsigned char *buf, size_t len)
 104 {
 105         int fd;
 106         ssize_t r;
 107         size_t rd = 0;
 108         size_t sz;
 109         struct timespec ts = { .tv_sec = 0, .tv_nsec = 10000000 }; /* 10 ms */
 110
 111
 112         if ((fd = open("/dev/random", O_RDONLY)) < 0) {
 113                 tc_log(1, "Error opening /dev/random\n");
 114                 return -1;
 115         }
 116
 117         summary_fn = get_random_summary;
 118         get_random_total_bytes = len;
 119
 120         /* Get random data in 16-byte chunks */
 121         sz = 16;
 122         while (rd < len) {
 123                 get_random_read_bytes = rd;
 124
 125                 if ((len - rd) < sz)
 126                         sz = (len - rd);
 127
 128                 if ((r = read(fd, buf+rd, sz)) < 0) {
 129                         tc_log(1, "Error reading from /dev/random(%d): %s\n",
 130                             fd, strerror(errno));
 131                         close(fd);
 132                         summary_fn = NULL;
 133                         return -1;
 134                 }
 135                 rd += r;
 136                 nanosleep(&ts, NULL);
 137         }
 138
 139         close(fd);
 140         summary_fn = NULL;
 141
 142         return 0;
 143 }
 144
 145 static size_t secure_erase_total_bytes = 0;
 146 static size_t secure_erase_erased_bytes = 0;
 147
 148 static
 149 void
 150 secure_erase_summary(void)
 151 {
 152         float pct_done;
 153
 154         pct_done = (1.0 * secure_erase_erased_bytes) /
 155             (1.0 * secure_erase_total_bytes) * 100.0;
 156         tc_log(0, "Securely erasing, %.0f%% done.\n", pct_done);
 157 }
 158
 159 int
 160 secure_erase(const char *dev, size_t bytes, size_t blksz)
 161 {
 162         size_t erased = 0;
 163         int fd_rand, fd;
 164         char buf[ERASE_BUFFER_SIZE];
 165         ssize_t r, w;
 166         size_t sz;
 167
 168         if (blksz > MAX_BLKSZ) {
 169                 tc_log(1, "blksz > MAX_BLKSZ\n");
 170                 return -1;
 171         }
 172
 173         if ((fd_rand = open("/dev/urandom", O_RDONLY)) < 0) {
 174                 tc_log(1, "Error opening /dev/urandom\n");
 175                 return -1;
 176         }
 177
 178         if ((fd = open(dev, O_WRONLY)) < 0) {
 179                 close(fd_rand);
 180                 tc_log(1, "Error opening %s\n", dev);
 181                 return -1;
 182         }
 183
 184         summary_fn = secure_erase_summary;
 185         secure_erase_total_bytes = bytes;
 186
 187         sz = ERASE_BUFFER_SIZE;
 188         while (erased < bytes) {
 189                 secure_erase_erased_bytes = erased;
 190                 /* Switch to block size when not much is remaining */
 191                 if ((bytes - erased) <= ERASE_BUFFER_SIZE)
 192                         sz = blksz;
 193
 194                 if ((r = read(fd_rand, buf, sz)) < 0) {
 195                         tc_log(1, "Error reading from /dev/urandom\n");
 196                         close(fd);
 197                         close(fd_rand);
 198                         summary_fn = NULL;
 199                         return -1;
 200                 }
 201
 202                 if (r < (ssize_t)blksz)
 203                         continue;
 204
 205                 if ((w = write(fd, buf, r)) < 0) {
 206                         tc_log(1, "Error writing to %s\n", dev);
 207                         close(fd);
 208                         close(fd_rand);
 209                         summary_fn = NULL;
 210                         return -1;
 211                 }
 212
 213                 erased += (size_t)w;
 214         }
 215
 216         close(fd);
 217         close(fd_rand);
 218
 219         summary_fn = NULL;
 220
 221         return 0;
 222 }
 223
 224 #if defined(__DragonFly__)
 225 int
 226 get_disk_info(const char *dev, size_t *blocks, size_t *bsize)
 227 {
 228         struct partinfo pinfo;
 229         int fd;
 230
 231         if ((fd = open(dev, O_RDONLY)) < 0) {
 232                 tc_log(1, "Error opening %s\n", dev);
 233                 return -1;
 234         }
 235
 236         memset(&pinfo, 0, sizeof(struct partinfo));
 237
 238         if (ioctl(fd, DIOCGPART, &pinfo) < 0) {
 239                 close(fd);
 240                 return -1;
 241         }
 242
 243         *blocks = pinfo.media_blocks;
 244         *bsize = pinfo.media_blksize;
 245
 246         close(fd);
 247         return 0;
 248 }
 249 #elif defined(__linux__)
 250 int
 251 get_disk_info(const char *dev, size_t *blocks, size_t *bsize)
 252 {
 253         uint64_t nbytes;
 254         int blocksz;
 255         int fd;
 256
 257         if ((fd = open(dev, O_RDONLY)) < 0) {
 258                 tc_log(1, "Error opening %s\n", dev);
 259                 return -1;
 260         }
 261
 262         if ((ioctl(fd, BLKSSZGET, &blocksz)) < 0) {
 263                 close(fd);
 264                 return -1;
 265         }
 266
 267         if ((ioctl(fd, BLKGETSIZE64, &nbytes)) < 0) {
 268                 close(fd);
 269                 return -1;
 270         }
 271
 272         *blocks = (size_t)(nbytes / blocksz);
 273         *bsize = (size_t)(blocksz);
 274
 275         close(fd);
 276         return 0;
 277 }
 278 #endif
 279
 280 int
 281 write_to_disk(const char *dev, off_t offset, size_t blksz, void *mem,
 282     size_t bytes)
 283 {
 284         unsigned char *mem_buf = NULL;
 285         ssize_t w;
 286         size_t sz;
 287         off_t internal_off;
 288         int fd;
 289
 290         /* Align to block sizes */
 291         internal_off = offset % blksz;
 292 #ifdef DEBUG
 293         printf("offset: %"PRIu64", internal offset: %"PRIu64"\n",
 294             (uint64_t)offset, (uint64_t)internal_off);
 295 #endif
 296         offset = (offset/blksz) * blksz;
 297
 298         if ((internal_off + bytes) > blksz) {
 299                 tc_log(1, "This should never happen: internal_off + bytes > "
 300                     "blksz (write_to_disk)\n");
 301                 return -1;
 302         }
 303
 304         if ((bytes < blksz) || (internal_off != 0)) {
 305                 sz = blksz;
 306                 if ((mem_buf = read_to_safe_mem(dev, offset, &sz)) == NULL) {
 307                         tc_log(1, "Error buffering data on "
 308                             "write_to_disk(%s)\n", dev);
 309                         return -1;
 310                 }
 311
 312                 memcpy(mem_buf + internal_off, mem, bytes);
 313         }
 314
 315         if ((fd = open(dev, O_WRONLY)) < 0) {
 316                 tc_log(1, "Error opening device %s\n", dev);
 317                 return -1;
 318         }
 319
 320         if ((lseek(fd, offset, SEEK_SET) < 0)) {
 321                 tc_log(1, "Error seeking on device %s\n", dev);
 322                 close(fd);
 323                 return -1;
 324         }
 325
 326         if ((w = write(fd, (mem_buf != NULL) ? mem_buf : mem, bytes)) <= 0) {
 327                 tc_log(1, "Error writing to device %s\n", dev);
 328                 close(fd);
 329                 return -1;
 330         }
 331
 332         close(fd);
 333
 334         if (mem_buf != NULL)
 335                 free_safe_mem(mem_buf);
 336         return 0;
 337 }
 338
 339 int
 340 read_passphrase(const char *prompt, char *pass, size_t passlen, time_t timeout)
 341 {
 342         struct termios termios_old, termios_new;
 343         struct timeval to;
 344         fd_set fds;
 345         ssize_t n;
 346         int fd, r = 0, cfd = 0, nready;
 347
 348         if ((fd = open("/dev/tty", O_RDONLY)) == -1) {
 349                 fd = STDIN_FILENO;
 350                 cfd = 1;
 351         }
 352
 353         printf(prompt);
 354         fflush(stdout);
 355
 356         memset(pass, 0, passlen);
 357
 358         tcgetattr(fd, &termios_old);
 359         memcpy(&termios_new, &termios_old, sizeof(termios_new));
 360         termios_new.c_lflag &= ~ECHO;
 361         tcsetattr(fd, TCSAFLUSH, &termios_new);
 362
 363         if (timeout > 0) {
 364                 memset(&to, 0, sizeof(to));
 365                 to.tv_sec = timeout;
 366
 367                 FD_ZERO(&fds);
 368                 FD_SET(fd, &fds);
 369                 nready = select(fd + 1, &fds, NULL, NULL, &to);
 370                 if (nready <= 0) {
 371                         r = EINTR;
 372                         goto out;
 373                 }
 374         }
 375
 376         n = read(fd, pass, passlen-1);
 377         if (n > 0) {
 378                 pass[n-1] = '\0'; /* Strip trailing \n */
 379         } else {
 380                 r = EIO;
 381         }
 382
 383 out:
 384         if (cfd)
 385                 close(fd);
 386
 387         tcsetattr(fd, TCSAFLUSH, &termios_old);
 388         putchar('\n');
 389
 390         return r;
 391 }