hashcat/deps/unrar/blake2sp.cpp

/*
   BLAKE2 reference source code package - reference C implementations

   Written in 2012 by Samuel Neves <sneves@dei.uc.pt>

   To the extent possible under law, the author(s) have dedicated all copyright
   and related and neighboring rights to this software to the public domain
   worldwide. This software is distributed without any warranty.

   You should have received a copy of the CC0 Public Domain Dedication along with
   this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
*/

#define PARALLELISM_DEGREE 8

void blake2sp_init( blake2sp_state *S )
{
  memset( S->buf, 0, sizeof( S->buf ) );
  S->buflen = 0;

  blake2s_init_param( &S->R, 0, 1 ); // Init root.

  for( uint i = 0; i < PARALLELISM_DEGREE; ++i )
    blake2s_init_param( &S->S[i], i, 0 ); // Init leaf.

  S->R.last_node = 1;
  S->S[PARALLELISM_DEGREE - 1].last_node = 1;
}


struct Blake2ThreadData
{
  void Update();
  blake2s_state *S;
  const byte *in;
  size_t inlen;
};


void Blake2ThreadData::Update()
{
  size_t inlen__ = inlen;
  const byte *in__ = ( const byte * )in;

  while( inlen__ >= PARALLELISM_DEGREE * BLAKE2S_BLOCKBYTES )
  {
#ifdef USE_SSE
    // We gain 5% in i7 SSE mode by prefetching next data block.
    if (_SSE_Version>=SSE_SSE && inlen__ >= 2 * PARALLELISM_DEGREE * BLAKE2S_BLOCKBYTES)
      _mm_prefetch((char*)(in__ +  PARALLELISM_DEGREE * BLAKE2S_BLOCKBYTES), _MM_HINT_T0);
#endif
    blake2s_update( S, in__, BLAKE2S_BLOCKBYTES );
    in__ += PARALLELISM_DEGREE * BLAKE2S_BLOCKBYTES;
    inlen__ -= PARALLELISM_DEGREE * BLAKE2S_BLOCKBYTES;
  }
}

#ifdef RAR_SMP
THREAD_PROC(Blake2Thread)
{
  Blake2ThreadData *td=(Blake2ThreadData *)Data;
  td->Update();
}
#endif


void blake2sp_update( blake2sp_state *S, const byte *in, size_t inlen )
{
  size_t left = S->buflen;
  size_t fill = sizeof( S->buf ) - left;

  if( left && inlen >= fill )
  {
    memcpy( S->buf + left, in, fill );

    for( size_t i = 0; i < PARALLELISM_DEGREE; ++i )
      blake2s_update( &S->S[i], S->buf + i * BLAKE2S_BLOCKBYTES, BLAKE2S_BLOCKBYTES );

    in += fill;
    inlen -= fill;
    left = 0;
  }

  Blake2ThreadData btd_array[PARALLELISM_DEGREE];

#ifdef RAR_SMP
  uint ThreadNumber = inlen < 0x1000 ? 1 : S->MaxThreads;
  
  if (ThreadNumber==6 || ThreadNumber==7) // 6 and 7 threads work slower than 4 here.
    ThreadNumber=4;
#else
  uint ThreadNumber=1;
#endif

  for (size_t id__=0;id__<PARALLELISM_DEGREE;)
  {
    for (uint Thread=0;Thread<ThreadNumber && id__<PARALLELISM_DEGREE;Thread++)
    {
      Blake2ThreadData *btd=btd_array+Thread;

      btd->inlen = inlen;
      btd->in = in + id__ * BLAKE2S_BLOCKBYTES;
      btd->S = &S->S[id__];
  
#ifdef RAR_SMP
      if (ThreadNumber>1)
        S->ThPool->AddTask(Blake2Thread,(void*)btd);
      else
        btd->Update();
#else
      btd->Update();
#endif
      id__++;
    }
#ifdef RAR_SMP
    if (S->ThPool!=NULL) // Can be NULL in -mt1 mode.
      S->ThPool->WaitDone();
#endif // RAR_SMP
  }

  in += inlen - inlen % ( PARALLELISM_DEGREE * BLAKE2S_BLOCKBYTES );
  inlen %= PARALLELISM_DEGREE * BLAKE2S_BLOCKBYTES;

  if( inlen > 0 )
    memcpy( S->buf + left, in, (size_t)inlen );

  S->buflen = left + (size_t)inlen;
}


void blake2sp_final( blake2sp_state *S, byte *digest )
{
  byte hash[PARALLELISM_DEGREE][BLAKE2S_OUTBYTES];

  for( size_t i = 0; i < PARALLELISM_DEGREE; ++i )
  {
    if( S->buflen > i * BLAKE2S_BLOCKBYTES )
    {
      size_t left = S->buflen - i * BLAKE2S_BLOCKBYTES;

      if( left > BLAKE2S_BLOCKBYTES ) left = BLAKE2S_BLOCKBYTES;

      blake2s_update( &S->S[i], S->buf + i * BLAKE2S_BLOCKBYTES, left );
    }

    blake2s_final( &S->S[i], hash[i] );
  }

  for( size_t i = 0; i < PARALLELISM_DEGREE; ++i )
    blake2s_update( &S->R, hash[i], BLAKE2S_OUTBYTES );

  blake2s_final( &S->R, digest );
}