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           0 : fd_blake3_align( void ) {
       8           0 :   return FD_BLAKE3_ALIGN;
       9           0 : }
      10             : 
      11             : ulong
      12           0 : fd_blake3_footprint( void ) {
      13           0 :   return FD_BLAKE3_FOOTPRINT;
      14           0 : }
      15             : 
      16             : void *
      17           0 : fd_blake3_new( void * shmem ) {
      18           0 :   fd_blake3_t * sha = (fd_blake3_t *)shmem;
      19             : 
      20           0 :   if( FD_UNLIKELY( !shmem ) ) {
      21           0 :     FD_LOG_WARNING(( "NULL shmem" ));
      22           0 :     return NULL;
      23           0 :   }
      24             : 
      25           0 :   if( FD_UNLIKELY( !fd_ulong_is_aligned( (ulong)shmem, fd_blake3_align() ) ) ) {
      26           0 :     FD_LOG_WARNING(( "misaligned shmem" ));
      27           0 :     return NULL;
      28           0 :   }
      29             : 
      30           0 :   ulong footprint = fd_blake3_footprint();
      31             : 
      32           0 :   fd_memset( sha, 0, footprint );
      33             : 
      34           0 :   FD_COMPILER_MFENCE();
      35           0 :   FD_VOLATILE( sha->magic ) = FD_BLAKE3_MAGIC;
      36           0 :   FD_COMPILER_MFENCE();
      37             : 
      38           0 :   return (void *)sha;
      39           0 : }
      40             : 
      41             : fd_blake3_t *
      42           0 : fd_blake3_join( void * shsha ) {
      43             : 
      44           0 :   if( FD_UNLIKELY( !shsha ) ) {
      45           0 :     FD_LOG_WARNING(( "NULL shsha" ));
      46           0 :     return NULL;
      47           0 :   }
      48             : 
      49           0 :   if( FD_UNLIKELY( !fd_ulong_is_aligned( (ulong)shsha, fd_blake3_align() ) ) ) {
      50           0 :     FD_LOG_WARNING(( "misaligned shsha" ));
      51           0 :     return NULL;
      52           0 :   }
      53             : 
      54           0 :   fd_blake3_t * sha = (fd_blake3_t *)shsha;
      55             : 
      56           0 :   if( FD_UNLIKELY( sha->magic!=FD_BLAKE3_MAGIC ) ) {
      57           0 :     FD_LOG_WARNING(( "bad magic" ));
      58           0 :     return NULL;
      59           0 :   }
      60             : 
      61           0 :   return sha;
      62           0 : }
      63             : 
      64             : void *
      65           0 : fd_blake3_leave( fd_blake3_t * sha ) {
      66             : 
      67           0 :   if( FD_UNLIKELY( !sha ) ) {
      68           0 :     FD_LOG_WARNING(( "NULL sha" ));
      69           0 :     return NULL;
      70           0 :   }
      71             : 
      72           0 :   return (void *)sha;
      73           0 : }
      74             : 
      75             : void *
      76           0 : fd_blake3_delete( void * shsha ) {
      77             : 
      78           0 :   if( FD_UNLIKELY( !shsha ) ) {
      79           0 :     FD_LOG_WARNING(( "NULL shsha" ));
      80           0 :     return NULL;
      81           0 :   }
      82             : 
      83           0 :   if( FD_UNLIKELY( !fd_ulong_is_aligned( (ulong)shsha, fd_blake3_align() ) ) ) {
      84           0 :     FD_LOG_WARNING(( "misaligned shsha" ));
      85           0 :     return NULL;
      86           0 :   }
      87             : 
      88           0 :   fd_blake3_t * sha = (fd_blake3_t *)shsha;
      89             : 
      90           0 :   if( FD_UNLIKELY( sha->magic!=FD_BLAKE3_MAGIC ) ) {
      91           0 :     FD_LOG_WARNING(( "bad magic" ));
      92           0 :     return NULL;
      93           0 :   }
      94             : 
      95           0 :   FD_COMPILER_MFENCE();
      96           0 :   FD_VOLATILE( sha->magic ) = 0UL;
      97           0 :   FD_COMPILER_MFENCE();
      98             : 
      99           0 :   return (void *)sha;
     100           0 : }
     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          33 : fd_blake3_init( fd_blake3_t * sha ) {
     121          33 :   blake3_hasher_init( &sha->hasher );
     122          33 :   return sha;
     123          33 : }
     124             : 
     125             : fd_blake3_t *
     126             : fd_blake3_append( fd_blake3_t * sha,
     127             :                   void const *  data,
     128          18 :                   ulong         sz ) {
     129          18 :   blake3_hasher_update( &sha->hasher, data, sz);
     130          18 :   return sha;
     131          18 : }
     132             : 
     133             : void *
     134             : fd_blake3_fini( fd_blake3_t * sha,
     135          15 :                 void *        hash ) {
     136          15 :   blake3_hasher_finalize( &sha->hasher, (uchar *) hash, 32 );
     137          15 :   return hash;
     138          15 : }
     139             : 
     140             : void *
     141             : fd_blake3_fini_512( fd_blake3_t * sha,
     142           0 :                     void *        hash ) {
     143           0 :   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 :   blake3_hasher_finalize( &sha->hasher, (uchar *) hash, hash_len );
     152           0 :   return hash;
     153           0 : }