tfc_skein.c

   1 /*
   2  * tfcrypt -- high security Threefish encryption tool.
   3  *
   4  * tfcrypt is copyrighted:
   5  * Copyright (C) 2012-2018 Andrey Rys. All rights reserved.
   6  *
   7  * tfcrypt is licensed to you under the terms of std. MIT/X11 license:
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining
  10  * a copy of this software and associated documentation files (the
  11  * "Software"), to deal in the Software without restriction, including
  12  * without limitation the rights to use, copy, modify, merge, publish,
  13  * distribute, sublicense, and/or sell copies of the Software, and to
  14  * permit persons to whom the Software is furnished to do so, subject to
  15  * the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be
  18  * included in all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  23  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  24  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  25  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  26  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27  */
  28
  29 #include "tfcrypt.h"
  30 #include "tfcore.h"
  31
  32 void skein(void *hash, size_t bits, const void *key, const void *data, size_t szdata)
  33 {
  34         struct skein sk;
  35
  36         if (key) skein_init_key(&sk, key, bits);
  37         else skein_init(&sk, bits);
  38         skein_update(&sk, data, szdata);
  39         skein_final(hash, &sk);
  40 }
  41
  42 void tf_key_tweak_compat(void *key)
  43 {
  44         TF_UNIT_TYPE *ukey = key, c = THREEFISH_CONST;
  45         size_t x;
  46
  47         for (x = 0; x < TF_NR_BLOCK_UNITS; x++) c ^= ukey[x];
  48         ukey[x] = c;
  49         ukey[TF_TWEAK_WORD3] = ukey[TF_TWEAK_WORD1] ^ ukey[TF_TWEAK_WORD2];
  50 }
  51
  52 tfc_yesno skeinfd(void *hash, size_t bits, const void *key, int fd, tfc_fsize offset, tfc_fsize readto)
  53 {
  54         static tfc_byte skblk[TFC_BLKSIZE];
  55
  56         struct skein sk;
  57         tfc_byte *pblk;
  58         size_t ldone, lblock, lrem, lio;
  59         tfc_fsize total = 0;
  60         tfc_yesno stop;
  61
  62         if (ctr_mode == TFC_MODE_SKSUM) total_processed_src = total_processed_dst = delta_processed = 0;
  63
  64         if (fd == -1) goto _fail;
  65         if (fd > 2) {
  66                 if (readto == NOFSIZE) {
  67                         readto = tfc_fdsize(fd);
  68                         if (readto == NOFSIZE) goto _fail;
  69                 }
  70                 if (offset != 0 && offset != NOFSIZE) {
  71                         if (lseek(fd, (off_t)offset, SEEK_SET) == -1) {
  72                                 if (ignore_seek_errors == NO) goto _fail;
  73                         }
  74                 }
  75         }
  76
  77         if (key) skein_init_key(&sk, key, bits);
  78         else skein_init(&sk, bits);
  79
  80         errno = 0;
  81         stop = NO;
  82         while (1) {
  83                 if (stop) break;
  84                 pblk = skblk;
  85                 lblock = lrem = blk_len_adj(readto, total, TFC_BLKSIZE);
  86                 ldone = 0;
  87                 if (error_action == TFC_ERRACT_SYNC) rdpos = tfc_fdgetpos(fd);
  88 _again:         lio = xread(fd, pblk, lrem);
  89                 if (lio == 0) stop = YES;
  90                 if (lio != NOSIZE) ldone += lio;
  91                 else {
  92                         if (errno != EIO && catch_all_errors != YES) goto _fail;
  93                         switch (error_action) {
  94                                 case TFC_ERRACT_CONT: xerror(YES, NO, NO, "skeinfd: %d", fd); goto _again; break;
  95                                 case TFC_ERRACT_SYNC:
  96                                 case TFC_ERRACT_LSYNC:
  97                                         xerror(YES, NO, NO, "skeinfd: %d", fd);
  98                                         lio = lrem = ldone = lblock;
  99                                         total += lio;
 100                                         memset(skblk, 0, lio);
 101                                         if (rdpos == NOFSIZE) lseek(fd, lio, SEEK_CUR);
 102                                         else lseek(fd, rdpos + lio, SEEK_SET);
 103                                         break;
 104                                 default: goto _fail; break;
 105                         }
 106                 }
 107                 if (lio && lio < lrem) {
 108                         pblk += lio;
 109                         lrem -= lio;
 110                         goto _again;
 111                 }
 112                 total += ldone;
 113                 if (ctr_mode == TFC_MODE_SKSUM) {
 114                         total_processed_src = total_processed_dst = total;
 115                         delta_processed += ldone;
 116                 }
 117                 skein_update(&sk, skblk, ldone);
 118                 if (readto != NOFSIZE && total >= readto) break;
 119         }
 120
 121         if (fd > 2) lseek(fd, (off_t)readto, SEEK_SET);
 122
 123         skein_final(hash, &sk);
 124         if (ctr_mode == TFC_MODE_SKSUM) {
 125                 if (verbose || status_timer) print_crypt_status(-1);
 126                 total_processed_src = total_processed_dst = delta_processed = 0;
 127         }
 128         memset(skblk, 0, TFC_BLKSIZE);
 129         return YES;
 130
 131 _fail:
 132         memset(&sk, 0, sizeof(struct skein));
 133         memset(hash, 0, SKEIN_DIGEST_SIZE);
 134         memset(skblk, 0, TFC_BLKSIZE);
 135         return NO;
 136 }
 137
 138 void do_sksum(char *spec, char **fargv)
 139 {
 140         static char sksblk[TFC_BLKSIZE / 2], tmp[TFC_TMPSIZE];
 141         tfc_byte hash[SKEIN_DIGEST_SIZE];
 142         int fd = -1;
 143         int x = 0, xx;
 144         size_t bits;
 145
 146         if (macbits < TF_MAX_BITS) {
 147                 bits = macbits;
 148                 goto _dothat;
 149         }
 150
 151         if (!strcmp(spec, "sksum")) {
 152                 bits = TF_MAX_BITS;
 153                 goto _dothat;
 154         }
 155
 156         if ((sscanf(spec, "sk%zusum", &bits) < 1)) {
 157                 bits = TF_MAX_BITS;
 158         }
 159
 160         if (bits < 8 || bits > TF_MAX_BITS) {
 161                 xerror(NO, YES, YES,
 162                 "%u: invalid bits number specified!\n"
 163                 "tfcrypt supports from 8 to %u bits, divisible by 8.",
 164                 bits, TFC_U(TF_MAX_BITS));
 165         }
 166
 167         if (!bits || bits % 8) {
 168                 xerror(NO, YES, YES,
 169                 "%u: invalid bits number specified!\n"
 170                 "Number of bits must start from 8 and be divisible by 8.",
 171                 bits, TFC_U(TF_MAX_BITS));
 172         }
 173
 174 _dothat:
 175         do_edcrypt = TFC_DO_PLAIN;
 176         ctr_mode = TFC_MODE_SKSUM;
 177
 178         for (x = 1; x < NSIG; x++) signal(x, SIG_IGN);
 179         memset(&sigact, 0, sizeof(sigact));
 180         sigact.sa_flags = SA_RESTART;
 181         sigact.sa_handler = print_crypt_status;
 182         sigaction(SIGUSR1, &sigact, NULL);
 183         sigaction(SIGTSTP, &sigact, NULL);
 184         sigaction(SIGALRM, &sigact, NULL);
 185         sigact.sa_handler = change_status_width;
 186         sigaction(SIGQUIT, &sigact, NULL);
 187         sigact.sa_handler = change_status_timer;
 188         sigaction(SIGUSR2, &sigact, NULL);
 189         sigact.sa_handler = exit_sigterm;
 190         sigaction(SIGINT, &sigact, NULL);
 191         sigaction(SIGTERM, &sigact, NULL);
 192         memset(&sigact, 0, sizeof(struct sigaction));
 193
 194         tfc_getcurtime(&delta_time);
 195
 196         if (sksum_hashlist_file) {
 197                 FILE *f;
 198                 char *s, *d, *t, *shash, *fname;
 199                 int failed = 0, totaltested = 0;
 200
 201                 if (!strcmp(sksum_hashlist_file, "-")) f = stdin;
 202                 else f = fopen(sksum_hashlist_file, "r");
 203                 if (!f) xerror(NO, NO, YES, "%s", sksum_hashlist_file);
 204
 205                 while (1) {
 206                         memset(sksblk, 0, sizeof(sksblk));
 207                         x = xfgets(sksblk, sizeof(sksblk), f);
 208                         if (x == 0) break;
 209
 210                         s = d = sksblk; t = NULL;
 211                         shash = fname = NULL;
 212                         while ((s = strtok_r(d, "\t", &t))) {
 213                                 if (d) d = NULL;
 214
 215                                 if (!shash) shash = s;
 216                                 else if (shash && !fname) fname = s;
 217                         }
 218
 219                         if (!shash || !fname) {
 220                                 xerror(YES, NO, YES, "invalid string %s", sksblk);
 221                                 exitcode = 2;
 222                                 continue;
 223                         }
 224
 225                         s = strchr(shash, ' ');
 226                         if (s && s[1] == ' ') *s = 0;
 227
 228                         fd = open(fname, O_RDONLY | O_LARGEFILE);
 229                         if (fd == -1) {
 230                                 xerror(YES, NO, YES, "%s", fname);
 231                                 exitcode = 1;
 232                                 continue;
 233                         }
 234
 235                         if (status_timer) setup_next_alarm(status_timer);
 236                         if (skeinfd(hash, bits, mackey_opt ? mackey : NULL, fd, iseek, maxlen) != YES) {
 237                                 xerror(YES, NO, YES, "%s", fname);
 238                                 exitcode = 1;
 239                                 continue;
 240                         }
 241                         xclose(fd);
 242                         if (sksum_turns > 1) {
 243                                 size_t y;
 244                                 for (y = 0; y < sksum_turns; y++)
 245                                         skein(hash, bits, mackey_opt ? mackey : NULL, hash, TF_FROM_BITS(bits));
 246                         }
 247                         if (isbase64(shash)) base64_decode(tmp, sizeof(tmp), shash, strlen(shash));
 248                         else hex2bin(tmp, shash);
 249
 250                         if (!memcmp(hash, tmp, TF_FROM_BITS(bits))) {
 251                                 tfc_say("%s: OK", fname);
 252                         }
 253                         else {
 254                                 tfc_say("%s: FAILED", fname);
 255                                 failed++;
 256                         }
 257                         memset(tmp, 0, sizeof(tmp));
 258                         memset(sksblk, 0, sizeof(sksblk));
 259                         totaltested++;
 260                 }
 261
 262                 fclose(f);
 263                 if (failed) {
 264                         tfc_esay("%s: WARNING: %u of %u computed checksums did NOT match",
 265                                 progname, failed, totaltested);
 266                         exitcode = 1;
 267                 }
 268                 xexit(exitcode);
 269         }
 270
 271         for (xx = 0; fargv[xx]; xx++);
 272         if (xx == 0) {
 273                 fd = 0;
 274                 x = 0;
 275                 goto _dohash;
 276         }
 277
 278         for (x = 0; fargv[x] && xx; x++) {
 279                 if (!strcmp(fargv[x], "-")) fd = 0;
 280                 else fd = open(fargv[x], O_RDONLY | O_LARGEFILE);
 281                 if (fd == -1) {
 282                         xerror(YES, NO, YES, "%s", fargv[x]);
 283                         exitcode = 1;
 284                         continue;
 285                 }
 286
 287 _dohash:        if (status_timer) setup_next_alarm(status_timer);
 288                 if (skeinfd(hash, bits, mackey_opt ? mackey : NULL, fd, iseek, maxlen) != YES) {
 289                         xerror(YES, NO, YES, "%s", fargv[x]);
 290                         exitcode = 1;
 291                         continue;
 292                 }
 293                 xclose(fd);
 294                 if (sksum_turns > 1) {
 295                         size_t y;
 296                         for (y = 0; y < sksum_turns; y++) skein(hash, bits, mackey_opt ? mackey : NULL, hash, TF_FROM_BITS(bits));
 297                 }
 298                 if (do_outfmt == TFC_OUTFMT_B64) tfc_printbase64(stdout, hash, TF_FROM_BITS(bits), 0);
 299                 else if (do_outfmt == TFC_OUTFMT_RAW) xwrite(1, hash, TF_FROM_BITS(bits));
 300                 else mhexdump(hash, TF_FROM_BITS(bits), TF_FROM_BITS(bits), 0);
 301                 if (do_outfmt != TFC_OUTFMT_RAW) {
 302                         if (quiet == NO || xx > 1) tfc_say("\t%s", fargv[x] ? fargv[x] : "-");
 303                         else tfc_say("\n");
 304                 }
 305         }
 306
 307         memset(hash, 0, SKEIN_DIGEST_SIZE);
 308         xexit(exitcode);
 309 }