C++ (Cpp) SHA512の例、cryptopp::SHA512 C++ (Cpp)の例

コード例 #1

0

ファイルを表示

ファイル: tools.cpp プロジェクト: AhmedWaly/CastOnly

std::string transformToSHA512(std::string plainText, bool upperCase)
{
	// Crypto++ SHA512 object
	CryptoPP::SHA512 hash;

	// Use native byte instead of casting chars
	byte digest[CryptoPP::SHA512::DIGESTSIZE];

	// Do the actual calculation, require a byte value so we need a cast
	hash.CalculateDigest(digest, (const byte*)plainText.c_str(), plainText.length());

	// Crypto++ HexEncoder object
	CryptoPP::HexEncoder encoder;

	// Our output
	std::string output;

	// Drop internal hex encoder and use this, returns uppercase by default
	encoder.Attach(new CryptoPP::StringSink(output));
	encoder.Put(digest, sizeof(digest));
	encoder.MessageEnd();

	// Make sure we want uppercase
	if(upperCase)
		return output;

	// Convert to lowercase if needed
	return asLowerCaseString(output);
}

コード例 #2

0

ファイルを表示

ファイル: digest_file_pair.cpp プロジェクト: cpeltz/hikari

void DigestFilePair::calculate( const fs::path file ) {
	fs::ifstream file_stream( file );
	CryptoPP::FileSource fsource( file_stream, true );
	CryptoPP::SHA512 sha;
	byte digest[sha.DigestSize()];
	byte *data = new byte[ fsource.MaxRetrievable() ];
	size_t size = fsource.Get( data, fsource.MaxRetrievable() );
	sha.CalculateDigest( digest, data, size );
	std::stringstream ss;
	for(int i = 0; i < sha.DigestSize(); i++)
		ss << std::hex << std::setw(2) << std::setfill('0') << (int) digest[i];
	delete[] data;
	_digest = ss.str();
	_file = file;
}

コード例 #3

0

ファイルを表示

ファイル: util.cpp プロジェクト: benjaminhkaiser/SKB-Protocol

std::string makeHash(const std::string& input)
{
	CryptoPP::SHA512 hash;
	byte digest[ CryptoPP::SHA512::DIGESTSIZE ];

	hash.CalculateDigest( digest, (byte*) input.c_str(), input.length() );

	CryptoPP::HexEncoder encoder;
	std::string output;
	encoder.Attach( new CryptoPP::StringSink( output ) );
	encoder.Put( digest, sizeof(digest) );
	encoder.MessageEnd();

	return output;
}

コード例 #4

0

ファイルを表示

ファイル: stringutil.cpp プロジェクト: scottbuettner/tehrpg

	std::string hash_sha512(std::string input)
	{
		CryptoPP::SHA512 sha;
		unsigned char* buffer = new unsigned char[sha.DigestSize()];
		unsigned char* inputbytes = new unsigned char[input.size()];
		memcpy(inputbytes, input.c_str(), input.size());
		sha.CalculateDigest(buffer, inputbytes, input.size());
		char* hashedbytes = new char[sha.DigestSize()];
		memcpy(hashedbytes, buffer, sha.DigestSize());
		std::string hashed(hashedbytes, sha.DigestSize());
		delete[] buffer;
		delete[] inputbytes;
		delete[] hashedbytes;
		return hashed;
	}

コード例 #5

0

ファイルを表示

ファイル: EncryptionUtils.cpp プロジェクト: vtcex/BitcoinArmory

SecureBinaryData KdfRomix::DeriveKey_OneIter(SecureBinaryData const & password)
{
   static CryptoPP::SHA512 sha512;

   // Concatenate the salt/IV to the password
   SecureBinaryData saltedPassword = password + salt_; 
   
   // Prepare the lookup table
   lookupTable_.resize(memoryReqtBytes_);
   lookupTable_.fill(0);
   uint32_t const HSZ = hashOutputBytes_;
   uint8_t* frontOfLUT = lookupTable_.getPtr();
   uint8_t* nextRead  = NULL;
   uint8_t* nextWrite = NULL;

   // First hash to seed the lookup table, input is variable length anyway
   sha512.CalculateDigest(frontOfLUT, 
                          saltedPassword.getPtr(), 
                          saltedPassword.getSize());

   // Compute <sequenceCount_> consecutive hashes of the passphrase
   // Every iteration is stored in the next 64-bytes in the Lookup table
   for(uint32_t nByte=0; nByte<memoryReqtBytes_-HSZ; nByte+=HSZ)
   {
      // Compute hash of slot i, put result in slot i+1
      nextRead  = frontOfLUT + nByte;
      nextWrite = nextRead + hashOutputBytes_;
      sha512.CalculateDigest(nextWrite, nextRead, hashOutputBytes_);
   }

   // LookupTable should be complete, now start lookup sequence.
   // Start with the last hash from the previous step
   SecureBinaryData X(frontOfLUT + memoryReqtBytes_ - HSZ, HSZ);
   SecureBinaryData Y(HSZ);

   // We "integerize" a hash value by taking the last 4 bytes of
   // as a uint32_t, and take modulo sequenceCount
   uint64_t* X64ptr = (uint64_t*)(X.getPtr());
   uint64_t* Y64ptr = (uint64_t*)(Y.getPtr());
   uint64_t* V64ptr = NULL;
   uint32_t newIndex;
   uint32_t const nXorOps = HSZ/sizeof(uint64_t);

   // Pure ROMix would use sequenceCount_ for the number of lookups.
   // We divide by 2 to reduce computation time RELATIVE to the memory usage
   // This still provides suffient LUT operations, but allows us to use more
   // memory in the same amount of time (and this is the justification for
   // the scrypt algorithm -- it is basically ROMix, modified for more 
   // flexibility in controlling compute-time vs memory-usage).
   uint32_t const nLookups = sequenceCount_ / 2;
   for(uint32_t nSeq=0; nSeq<nLookups; nSeq++)
   {
      // Interpret last 4 bytes of last result (mod seqCt) as next LUT index
      newIndex = *(uint32_t*)(X.getPtr()+HSZ-4) % sequenceCount_;

      // V represents the hash result at <newIndex>
      V64ptr = (uint64_t*)(frontOfLUT + HSZ*newIndex);

      // xor X with V, and store the result in X
      for(int i=0; i<nXorOps; i++)
         *(Y64ptr+i) = *(X64ptr+i) ^ *(V64ptr+i);

      // Hash the xor'd data to get the next index for lookup
      sha512.CalculateDigest(X.getPtr(), Y.getPtr(), HSZ);
   }
   // Truncate the final result to get the final key
   lookupTable_.destroy();
   return X.getSliceCopy(0,kdfOutputBytes_);
}

コード例 #6

0

ファイルを表示

ファイル: hash.cpp プロジェクト: JacobBarthelmeh/supercop

int crypto_hash(unsigned char *out,const unsigned char *in,unsigned long long inlen)
{
	CryptoPP::SHA512 sha;
	sha.CalculateDigest(out, in, inlen);
	return 0;
}

コード例 #7

0

ファイルを表示

ファイル: crypto.cpp プロジェクト: Florz/smartRNS_UDP_updater

void sha512(byte* digest, string arg)
{
    CryptoPP::SHA512 hashfun;
    hashfun.CalculateDigest(digest, (byte*) arg.c_str(), arg.length());
}

コード例 #8

0

ファイルを表示