Line data    Source code

       1             : #include "fd_blake3.h"
       2             : #include "blake3_impl.h"
       3             : #include "blake3_dispatch.c"
       4             : #include "blake3.c"
       5             : 
       6             : ulong
       7          21 : fd_blake3_align( void ) {
       8          21 :   return FD_BLAKE3_ALIGN;
       9          21 : }
      10             : 
      11             : ulong
      12           6 : fd_blake3_footprint( void ) {
      13           6 :   return FD_BLAKE3_FOOTPRINT;
      14           6 : }
      15             : 
      16             : void *
      17           9 : fd_blake3_new( void * shmem ) {
      18           9 :   fd_blake3_t * sha = (fd_blake3_t *)shmem;
      19             : 
      20           9 :   if( FD_UNLIKELY( !shmem ) ) {
      21           3 :     FD_LOG_WARNING(( "NULL shmem" ));
      22           3 :     return NULL;
      23           3 :   }
      24             : 
      25           6 :   if( FD_UNLIKELY( !fd_ulong_is_aligned( (ulong)shmem, fd_blake3_align() ) ) ) {
      26           3 :     FD_LOG_WARNING(( "misaligned shmem" ));
      27           3 :     return NULL;
      28           3 :   }
      29             : 
      30           3 :   ulong footprint = fd_blake3_footprint();
      31             : 
      32           3 :   fd_memset( sha, 0, footprint );
      33             : 
      34           3 :   FD_COMPILER_MFENCE();
      35           3 :   FD_VOLATILE( sha->magic ) = FD_BLAKE3_MAGIC;
      36           3 :   FD_COMPILER_MFENCE();
      37             : 
      38           3 :   return (void *)sha;
      39           6 : }
      40             : 
      41             : fd_blake3_t *
      42           9 : fd_blake3_join( void * shsha ) {
      43             : 
      44           9 :   if( FD_UNLIKELY( !shsha ) ) {
      45           3 :     FD_LOG_WARNING(( "NULL shsha" ));
      46           3 :     return NULL;
      47           3 :   }
      48             : 
      49           6 :   if( FD_UNLIKELY( !fd_ulong_is_aligned( (ulong)shsha, fd_blake3_align() ) ) ) {
      50           3 :     FD_LOG_WARNING(( "misaligned shsha" ));
      51           3 :     return NULL;
      52           3 :   }
      53             : 
      54           3 :   fd_blake3_t * sha = (fd_blake3_t *)shsha;
      55             : 
      56           3 :   if( FD_UNLIKELY( sha->magic!=FD_BLAKE3_MAGIC ) ) {
      57           0 :     FD_LOG_WARNING(( "bad magic" ));
      58           0 :     return NULL;
      59           0 :   }
      60             : 
      61           3 :   return sha;
      62           3 : }
      63             : 
      64             : void *
      65           6 : fd_blake3_leave( fd_blake3_t * sha ) {
      66             : 
      67           6 :   if( FD_UNLIKELY( !sha ) ) {
      68           3 :     FD_LOG_WARNING(( "NULL sha" ));
      69           3 :     return NULL;
      70           3 :   }
      71             : 
      72           3 :   return (void *)sha;
      73           6 : }
      74             : 
      75             : void *
      76           9 : fd_blake3_delete( void * shsha ) {
      77             : 
      78           9 :   if( FD_UNLIKELY( !shsha ) ) {
      79           3 :     FD_LOG_WARNING(( "NULL shsha" ));
      80           3 :     return NULL;
      81           3 :   }
      82             : 
      83           6 :   if( FD_UNLIKELY( !fd_ulong_is_aligned( (ulong)shsha, fd_blake3_align() ) ) ) {
      84           3 :     FD_LOG_WARNING(( "misaligned shsha" ));
      85           3 :     return NULL;
      86           3 :   }
      87             : 
      88           3 :   fd_blake3_t * sha = (fd_blake3_t *)shsha;
      89             : 
      90           3 :   if( FD_UNLIKELY( sha->magic!=FD_BLAKE3_MAGIC ) ) {
      91           0 :     FD_LOG_WARNING(( "bad magic" ));
      92           0 :     return NULL;
      93           0 :   }
      94             : 
      95           3 :   FD_COMPILER_MFENCE();
      96           3 :   FD_VOLATILE( sha->magic ) = 0UL;
      97           3 :   FD_COMPILER_MFENCE();
      98             : 
      99           3 :   return (void *)sha;
     100           3 : }
     101             : 
     102             : /* The implementation below is a wrapper around the BLAKE3 reference
     103             :    implementation (CC0-1.0 and Apache-2.0 licensed).  See in particular:
     104             : 
     105             :    https://github.com/BLAKE3-team/BLAKE3/tree/master/c
     106             : 
     107             :    We bring in the portable implementation of BLAKE3 and the AVX2
     108             :    implementation.  There is room for improvement in these implementations In
     109             :    particular:
     110             : 
     111             :     - Using fd_memset, fd_memcpy where reference implementation uses memset, memcpy
     112             :     - Reduction in the number of memset(s) and memcpy(s)
     113             :     - Better AVX2 routines
     114             : 
     115             :    It is also straightforward to replace or improve these implementations with
     116             :    HPC implementations that target specific machine capabilities without
     117             :    requiring any changes to caller code. */
     118             : 
     119             : fd_blake3_t *
     120    25417488 : fd_blake3_init( fd_blake3_t * sha ) {
     121    25417488 :   fd_blake3_hasher_init( &sha->hasher );
     122    25417488 :   return sha;
     123    25417488 : }
     124             : 
     125             : fd_blake3_t *
     126             : fd_blake3_append( fd_blake3_t * sha,
     127             :                   void const *  data,
     128    25417674 :                   ulong         sz ) {
     129    25417674 :   fd_blake3_hasher_update( &sha->hasher, data, sz);
     130    25417674 :   return sha;
     131    25417674 : }
     132             : 
     133             : void *
     134             : fd_blake3_fini( fd_blake3_t * sha,
     135    25417488 :                 void *        hash ) {
     136    25417488 :   fd_blake3_hasher_finalize( &sha->hasher, (uchar *) hash, 32 );
     137    25417488 :   return hash;
     138    25417488 : }
     139             : 
     140             : void *
     141             : fd_blake3_fini_512( fd_blake3_t * sha,
     142           0 :                     void *        hash ) {
     143           0 :   fd_blake3_hasher_finalize( &sha->hasher, (uchar *) hash, 64 );
     144           0 :   return hash;
     145           0 : }
     146             : 
     147             : void *
     148             : fd_blake3_fini_varlen( fd_blake3_t * sha,
     149             :                        void *        hash,
     150           0 :                        ulong         hash_len ) {
     151           0 :   fd_blake3_hasher_finalize( &sha->hasher, (uchar *) hash, hash_len );
     152           0 :   return hash;
     153           0 : }