src/blake2/b2sum.c

   1 /*
   2    BLAKE2 reference source code package - b2sum tool
   3
   4    Copyright 2012, Samuel Neves <sneves@dei.uc.pt>.  You may use this under the
   5    terms of the CC0, the OpenSSL Licence, or the Apache Public License 2.0, at
   6    your option.  The terms of these licenses can be found at:
   7
   8    - CC0 1.0 Universal : https://creativecommons.org/publicdomain/zero/1.0
   9    - OpenSSL license   : https://www.openssl.org/source/license.html
  10    - Apache 2.0        : https://www.apache.org/licenses/LICENSE-2.0
  11
  12    More information about the BLAKE2 hash function can be found at
  13    https://blake2.net.
  14 */
  15
  16 #ifdef HAVE_CONFIG_H
  17 # include <config.h>
  18 #endif
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22
  23 #include "blake2.h"
  24
  25 #if 0
  26 /* This will help compatibility with coreutils */
  27 int blake2s_stream( FILE *stream, void *resstream, size_t outbytes )
  28 {
  29   int ret = -1;
  30   size_t sum, n;
  31   blake2s_state S[1];
  32   static const size_t buffer_length = 32768;
  33   uint8_t *buffer = ( uint8_t * )malloc( buffer_length );
  34
  35   if( !buffer ) return -1;
  36
  37   blake2s_init( S, outbytes );
  38
  39   while( 1 )
  40   {
  41     sum = 0;
  42
  43     while( 1 )
  44     {
  45       n = fread( buffer + sum, 1, buffer_length - sum, stream );
  46       sum += n;
  47
  48       if( buffer_length == sum )
  49         break;
  50
  51       if( 0 == n )
  52       {
  53         if( ferror( stream ) )
  54           goto cleanup_buffer;
  55
  56         goto final_process;
  57       }
  58
  59       if( feof( stream ) )
  60         goto final_process;
  61     }
  62
  63     blake2s_update( S, buffer, buffer_length );
  64   }
  65
  66 final_process:;
  67
  68   if( sum > 0 ) blake2s_update( S, buffer, sum );
  69
  70   blake2s_final( S, resstream, outbytes );
  71   ret = 0;
  72 cleanup_buffer:
  73   free( buffer );
  74   return ret;
  75 }
  76 #endif
  77
  78 int blake2b_stream( FILE *stream, void *resstream, size_t outbytes )
  79 {
  80   int ret = -1;
  81   size_t sum, n;
  82   blake2b_state S[1];
  83   static const size_t buffer_length = 32768;
  84   uint8_t *buffer = ( uint8_t * )malloc( buffer_length );
  85
  86   if( !buffer ) return -1;
  87
  88   blake2b_init( S, outbytes );
  89
  90   while( 1 )
  91   {
  92     sum = 0;
  93
  94     while( 1 )
  95     {
  96       n = fread( buffer + sum, 1, buffer_length - sum, stream );
  97       sum += n;
  98
  99       if( buffer_length == sum )
 100         break;
 101
 102       if( 0 == n )
 103       {
 104         if( ferror( stream ) )
 105           goto cleanup_buffer;
 106
 107         goto final_process;
 108       }
 109
 110       if( feof( stream ) )
 111         goto final_process;
 112     }
 113
 114     blake2b_update( S, buffer, buffer_length );
 115   }
 116
 117 final_process:;
 118
 119   if( sum > 0 ) blake2b_update( S, buffer, sum );
 120
 121   blake2b_final( S, resstream, outbytes );
 122   ret = 0;
 123 cleanup_buffer:
 124   free( buffer );
 125   return ret;
 126 }
 127
 128 #if 0
 129
 130 #include <errno.h>
 131 #include <getopt.h>
 132 #include <string.h>
 133 #include <unistd.h>
 134
 135 int blake2sp_stream( FILE *stream, void *resstream, size_t outbytes )
 136 {
 137   int ret = -1;
 138   size_t sum, n;
 139   blake2sp_state S[1];
 140   static const size_t buffer_length = 16 * ( 1UL << 20 );
 141   uint8_t *buffer = ( uint8_t * )malloc( buffer_length );
 142
 143   if( !buffer ) return -1;
 144
 145   blake2sp_init( S, outbytes );
 146
 147   while( 1 )
 148   {
 149     sum = 0;
 150
 151     while( 1 )
 152     {
 153       n = fread( buffer + sum, 1, buffer_length - sum, stream );
 154       sum += n;
 155
 156       if( buffer_length == sum )
 157         break;
 158
 159       if( 0 == n )
 160       {
 161         if( ferror( stream ) )
 162           goto cleanup_buffer;
 163
 164         goto final_process;
 165       }
 166
 167       if( feof( stream ) )
 168         goto final_process;
 169     }
 170
 171     blake2sp_update( S, buffer, buffer_length );
 172   }
 173
 174 final_process:;
 175
 176   if( sum > 0 ) blake2sp_update( S, buffer, sum );
 177
 178   blake2sp_final( S, resstream, outbytes );
 179   ret = 0;
 180 cleanup_buffer:
 181   free( buffer );
 182   return ret;
 183 }
 184
 185
 186 int blake2bp_stream( FILE *stream, void *resstream, size_t outbytes )
 187 {
 188   int ret = -1;
 189   size_t sum, n;
 190   blake2bp_state S[1];
 191   static const size_t buffer_length = 16 * ( 1UL << 20 );
 192   uint8_t *buffer = ( uint8_t * )malloc( buffer_length );
 193
 194   if( !buffer ) return -1;
 195
 196   blake2bp_init( S, outbytes );
 197
 198   while( 1 )
 199   {
 200     sum = 0;
 201
 202     while( 1 )
 203     {
 204       n = fread( buffer + sum, 1, buffer_length - sum, stream );
 205       sum += n;
 206
 207       if( buffer_length == sum )
 208         break;
 209
 210       if( 0 == n )
 211       {
 212         if( ferror( stream ) )
 213           goto cleanup_buffer;
 214
 215         goto final_process;
 216       }
 217
 218       if( feof( stream ) )
 219         goto final_process;
 220     }
 221
 222     blake2bp_update( S, buffer, buffer_length );
 223   }
 224
 225 final_process:;
 226
 227   if( sum > 0 ) blake2bp_update( S, buffer, sum );
 228
 229   blake2bp_final( S, resstream, outbytes );
 230   ret = 0;
 231 cleanup_buffer:
 232   free( buffer );
 233   return ret;
 234 }
 235
 236 typedef int ( *blake2fn )( FILE *, void *, size_t );
 237
 238
 239 static void usage( char **argv, int errcode )
 240 {
 241   FILE *out = errcode ? stderr : stdout;
 242   fprintf( out, "Usage: %s [OPTION]... [FILE]...\n", argv[0] );
 243   fprintf( out, "\n" );
 244   fprintf( out, "With no FILE, or when FILE is -, read standard input.\n" );
 245   fprintf( out, "\n" );
 246   fprintf( out, "  -a <algo>    hash algorithm (blake2b is default): \n"
 247                 "               [blake2b|blake2s|blake2bp|blake2sp]\n" );
 248   fprintf( out, "  -l <length>  digest length in bits, must not exceed the maximum for\n"
 249                 "               the selected algorithm and must be a multiple of 8\n" );
 250   fprintf( out, "  --tag        create a BSD-style checksum\n" );
 251   fprintf( out, "  --help       display this help and exit\n" );
 252   exit( errcode );
 253 }
 254
 255
 256 int main( int argc, char **argv )
 257 {
 258   blake2fn blake2_stream = blake2b_stream;
 259   unsigned long maxbytes = BLAKE2B_OUTBYTES;
 260   const char *algorithm = "BLAKE2b";
 261   unsigned long outbytes = 0;
 262   unsigned char hash[BLAKE2B_OUTBYTES] = {0};
 263   bool bsdstyle = false;
 264   int c, i;
 265   opterr = 1;
 266
 267   while( 1 )
 268   {
 269     int option_index = 0;
 270     char *end = nullptr;
 271     unsigned long outbits;
 272     static struct option long_options[] = {
 273       { "help",  no_argument, 0,  0  },
 274       { "tag",   no_argument, 0,  0  },
 275       { nullptr, 0, nullptr, 0 }
 276     };
 277
 278     c = getopt_long( argc, argv, "a:l:", long_options, &option_index );
 279     if( c == -1 ) break;
 280     switch( c )
 281     {
 282     case 'a':
 283       if( 0 == strcmp( optarg, "blake2b" ) )
 284       {
 285         blake2_stream = blake2b_stream;
 286         maxbytes = BLAKE2B_OUTBYTES;
 287         algorithm = "BLAKE2b";
 288       }
 289       else if ( 0 == strcmp( optarg, "blake2s" ) )
 290       {
 291         blake2_stream = blake2s_stream;
 292         maxbytes = BLAKE2S_OUTBYTES;
 293         algorithm = "BLAKE2s";
 294       }
 295       else if ( 0 == strcmp( optarg, "blake2bp" ) )
 296       {
 297         blake2_stream = blake2bp_stream;
 298         maxbytes = BLAKE2B_OUTBYTES;
 299         algorithm = "BLAKE2bp";
 300       }
 301       else if ( 0 == strcmp( optarg, "blake2sp" ) )
 302       {
 303         blake2_stream = blake2sp_stream;
 304         maxbytes = BLAKE2S_OUTBYTES;
 305         algorithm = "BLAKE2sp";
 306       }
 307       else
 308       {
 309         printf( "Invalid function name: `%s'\n", optarg );
 310         usage( argv, 111 );
 311       }
 312
 313       break;
 314
 315     case 'l':
 316       outbits = strtoul(optarg, &end, 10);
 317       if( !end || *end != '\0' || outbits % 8 != 0)
 318       {
 319         printf( "Invalid length argument: `%s'\n", optarg);
 320         usage( argv, 111 );
 321       }
 322       outbytes = outbits / 8;
 323       break;
 324
 325     case 0:
 326       if( 0 == strcmp( "help", long_options[option_index].name ) )
 327         usage( argv, 0 );
 328       else if( 0 == strcmp( "tag", long_options[option_index].name ) )
 329         bsdstyle = true;
 330       break;
 331
 332     case '?':
 333       usage( argv, 1 );
 334       break;
 335     }
 336   }
 337
 338   if(outbytes > maxbytes)
 339   {
 340     printf( "Invalid length argument: %lu\n", outbytes * 8 );
 341     printf( "Maximum digest length for %s is %lu\n", algorithm, maxbytes * 8 );
 342     usage( argv, 111 );
 343   }
 344   else if( outbytes == 0 )
 345     outbytes = maxbytes;
 346
 347   if( optind == argc )
 348     argv[argc++] = (char *) "-";
 349
 350   for( i = optind; i < argc; ++i )
 351   {
 352     FILE *f = nullptr;
 353     if( argv[i][0] == '-' && argv[i][1] == '\0' )
 354       f = stdin;
 355     else
 356       f = fopen( argv[i], "rb" );
 357
 358     if( !f )
 359     {
 360       fprintf( stderr, "Could not open `%s': %s\n", argv[i], strerror( errno ) );
 361       continue;
 362     }
 363
 364     if( blake2_stream( f, hash, outbytes ) < 0 )
 365     {
 366       fprintf( stderr, "Failed to hash `%s'\n", argv[i] );
 367     }
 368     else
 369     {
 370       size_t j;
 371       if( bsdstyle )
 372       {
 373         if( outbytes < maxbytes )
 374           printf( "%s-%lu (%s) = ", algorithm, outbytes * 8, argv[i] );
 375         else
 376           printf( "%s (%s) = ", algorithm, argv[i] );
 377       }
 378
 379       for( j = 0; j < outbytes; ++j )
 380         printf( "%02x", hash[j] );
 381
 382       if( bsdstyle )
 383         printf( "\n" );
 384       else
 385         printf( "  %s\n", argv[i] );
 386     }
 387
 388     if( f == stdin )
 389       clearerr( f );
 390     else if( fclose( f ) != 0 )
 391       fprintf( stderr, "Could not close `%s': %s\n", argv[i], strerror( errno ) );
 392   }
 393
 394   return 0;
 395 }
 396 #endif