static void crypt_all(int count)
{
SHA512_CTX ctx;
SHA384_Init( &ctx );
SHA384_Update( &ctx, ipad, PAD_SIZE );
SHA384_Update( &ctx, cursalt, strlen( (char*) cursalt) );
SHA384_Final( (unsigned char*) crypt_key, &ctx);
SHA384_Init( &ctx );
SHA384_Update( &ctx, opad, PAD_SIZE );
SHA384_Update( &ctx, crypt_key, BINARY_SIZE);
SHA384_Final( (unsigned char*) crypt_key, &ctx);
}
static mrb_value
sha384_reset(mrb_state *mrb, mrb_value self)
{
SHA384_CTX *ctx = (SHA384_CTX*)DATA_PTR(self);
SHA384_Init(ctx);
return self;
}
int32_t psSha384Init(psSha384_t *sha384)
{
if (SHA384_Init(sha384) != 1) {
return PS_FAIL;
}
return PS_SUCCESS;
}
int
ds_sha384_hash_is_equal(u_char * name_n,
u_char * rrdata,
size_t rrdatalen,
u_char * ds_hash,
size_t ds_hash_len)
{
u_char ds_digest[SHA384_DIGEST_LENGTH];
size_t namelen;
SHA512_CTX c;
size_t l_index;
u_char qc_name_n[NS_MAXCDNAME];
if (rrdata == NULL || ds_hash_len != SHA384_DIGEST_LENGTH)
return 0;
namelen = wire_name_length(name_n);
memcpy(qc_name_n, name_n, namelen);
l_index = 0;
lower_name(qc_name_n, &l_index);
memset(ds_digest, 0, SHA384_DIGEST_LENGTH);
SHA384_Init(&c);
SHA384_Update(&c, qc_name_n, namelen);
SHA384_Update(&c, rrdata, rrdatalen);
SHA384_Final(ds_digest, &c);
if (!memcmp(ds_digest, ds_hash, SHA384_DIGEST_LENGTH))
return 1;
return 0;
}
static int hash_ssha384(
const struct berval *scheme,
const struct berval *passwd,
struct berval *hash,
const char **text )
{
SHA384_CTX ct;
unsigned char hash384[SHA384_DIGEST_LENGTH];
char saltdata[SHA2_SALT_SIZE];
struct berval digest;
struct berval salt;
digest.bv_val = (char *) hash384;
digest.bv_len = sizeof(hash384);
salt.bv_val = saltdata;
salt.bv_len = sizeof(saltdata);
if (lutil_entropy((unsigned char *)salt.bv_val, salt.bv_len) < 0) {
return LUTIL_PASSWD_ERR;
}
SHA384_Init(&ct);
SHA384_Update(&ct, (const uint8_t*)passwd->bv_val, passwd->bv_len);
SHA384_Update(&ct, (const uint8_t*)salt.bv_val, salt.bv_len);
SHA384_Final(hash384, &ct);
return lutil_passwd_string64(scheme, &digest, hash, &salt);
}
static void
int_sha384_reset(PX_MD *h)
{
SHA384_CTX *ctx = (SHA384_CTX *) h->p.ptr;
SHA384_Init(ctx);
}
/*! \brief Compute SHA384 checksum */
void compute_sha384(char *dst, u_int8_t *src, int src_len)
{
SHA384_CTX ctx384;
SHA384_Init(&ctx384);
SHA384_Update(&ctx384, src, src_len);
SHA384_End(&ctx384, dst);
}
uint8_t *SHA384(const uint8_t *data, size_t len, uint8_t *out) {
SHA512_CTX ctx;
SHA384_Init(&ctx);
SHA384_Update(&ctx, data, len);
SHA384_Final(out, &ctx);
OPENSSL_cleanse(&ctx, sizeof(ctx));
return out;
}
R_API void r_hash_do_begin(RHash *ctx, int flags) {
CHKFLAG (flags, R_HASH_MD5) MD5Init (&ctx->md5);
CHKFLAG (flags, R_HASH_SHA1) SHA1_Init (&ctx->sha1);
CHKFLAG (flags, R_HASH_SHA256) SHA256_Init (&ctx->sha256);
CHKFLAG (flags, R_HASH_SHA384) SHA384_Init (&ctx->sha384);
CHKFLAG (flags, R_HASH_SHA512) SHA512_Init (&ctx->sha512);
ctx->rst = 0;
}
/* Compute SHA384 hash on in and store the hex string result in out.
*/
void
sha384(unsigned char *out, unsigned char *in, size_t size)
{
SHA384_CTX sha384_ctx;
SHA384_Init(&sha384_ctx);
SHA384_Update(&sha384_ctx, (const uint8_t*)in, size);
SHA384_Final(out, &sha384_ctx);
}
/*! \brief Compute SHA384 checksum */
void compute_sha384(char *dst, u_int8_t *src, int src_len)
{
SHA384_CTX ctx384;
char buf[96];
SHA384_Init(&ctx384);
SHA384_Update(&ctx384, src, src_len);
SHA384_End(&ctx384, buf);
strncpy(dst, buf, 96);
}
R_API ut8 *r_hash_do_sha384(RHash *ctx, const ut8 *input, int len) {
if (len<0) return NULL;
if (ctx->rst)
SHA384_Init (&ctx->sha384);
SHA384_Update (&ctx->sha384, input, len);
if (ctx->rst || len == 0)
SHA384_Final (ctx->digest, &ctx->sha384);
return ctx->digest;
}
static void sha384_init(ops_hash_t *hash)
{
if (debug)
{
fprintf(stderr,"***\n***\nsha384_init\n***\n");
}
assert(!hash->data);
hash->data=malloc(sizeof(SHA512_CTX));
SHA384_Init(hash->data);
}
static int partial_hash_sha384(uint8_t *data_in, uint8_t *data_out)
{
SHA512_CTX ctx;
if (!SHA384_Init(&ctx))
return -EFAULT;
SHA512_Transform(&ctx, data_in);
rte_memcpy(data_out, &ctx, SHA512_DIGEST_LENGTH);
return 0;
}
Digest Buffer::getSHA384() const
{
unsigned char digest[48]={0};
SHA384_CTX context;
SHA384_Init(&context);
SHA384_Update(&context, (unsigned char *)m_data, m_length);
SHA384_Final(digest, &context);
return Digest(digest,48);
}
void reset()
{
switch (name_) {
case N_SHA1: SHA1_Init(&ctx_.sha1); break;
case N_SHA224: SHA224_Init(&ctx_.sha256); break;
case N_SHA256: SHA256_Init(&ctx_.sha256); break;
case N_SHA384: SHA384_Init(&ctx_.sha512); break;
case N_SHA512: SHA512_Init(&ctx_.sha512); break;
default:
throw cybozu::Exception("crypto:Hash:rset") << name_;
}
}
static void crypt_all(int count)
{
int index = 0;
#ifdef _OPENMP
#pragma omp parallel for
for (index = 0; index < count; index++)
#endif
{
SHA512_CTX ctx;
SHA384_Init( &ctx );
SHA384_Update( &ctx, ipad[index], PAD_SIZE );
SHA384_Update( &ctx, cursalt, strlen( (char*) cursalt) );
SHA384_Final( (unsigned char*) crypt_key[index], &ctx);
SHA384_Init( &ctx );
SHA384_Update( &ctx, opad[index], PAD_SIZE );
SHA384_Update( &ctx, crypt_key[index], BINARY_SIZE);
SHA384_Final( (unsigned char*) crypt_key[index], &ctx);
}
}
unsigned char *SHA384(const unsigned char *d, size_t n, unsigned char *md)
{
SHA512_CTX c;
static unsigned char m[SHA384_DIGEST_LENGTH];
if (md == NULL) md=m;
SHA384_Init(&c);
SHA384_Update(&c,d,n);
SHA384_Final(md,&c);
OPENSSL_cleanse(&c,sizeof(c));
return(md);
}
static int hash_init( SRP_HashAlgorithm alg, HashCTX *c )
{
switch (alg)
{
case SRP_SHA1 : return SHA1_Init( &c->sha );
case SRP_SHA224: return SHA224_Init( &c->sha256 );
case SRP_SHA256: return SHA256_Init( &c->sha256 );
case SRP_SHA384: return SHA384_Init( &c->sha512 );
case SRP_SHA512: return SHA512_Init( &c->sha512 );
default:
return -1;
}
}
/*
* SHA384
*/
static int
sha384_init(__ops_hash_t *hash)
{
if (hash->data) {
(void) fprintf(stderr, "sha384_init: hash data non-null\n");
}
if ((hash->data = calloc(1, sizeof(SHA512_CTX))) == NULL) {
(void) fprintf(stderr, "sha384_init: bad alloc\n");
return 0;
}
SHA384_Init(hash->data);
return 1;
}
void hash(char *string, char *result) {
unsigned char hash[SHA384_DIGEST_LENGTH];
int i = 0;
SHA384_CTX handler;
SHA384_Init(&handler);
SHA384_Update(&handler, string, strlen(string));
SHA384_Final(hash, &handler);
memset(result, '\0', strlen(result));
for (i = 0; i < SHA384_DIGEST_LENGTH; i++) {
sprintf(result, "%s%02x", result, hash[i]);
};
}
static void set_key(char *key, int index)
{
int len;
#ifdef SIMD_COEF_64
ARCH_WORD_64 *ipadp = (ARCH_WORD_64*)&ipad[GETPOS(7, index)];
ARCH_WORD_64 *opadp = (ARCH_WORD_64*)&opad[GETPOS(7, index)];
const ARCH_WORD_64 *keyp = (ARCH_WORD_64*)key;
ARCH_WORD_64 temp;
len = strlen(key);
memcpy(saved_plain[index], key, len);
saved_plain[index][len] = 0;
#if PAD_SIZE < PLAINTEXT_LENGTH
if (len > PAD_SIZE) {
unsigned char k0[BINARY_SIZE];
SHA512_CTX ctx;
int i;
SHA384_Init(&ctx);
SHA384_Update(&ctx, key, len);
SHA384_Final(k0, &ctx);
keyp = (ARCH_WORD_64*)k0;
for(i = 0; i < BINARY_SIZE / 8; i++, ipadp += SIMD_COEF_64, opadp += SIMD_COEF_64)
{
temp = JOHNSWAP64(*keyp++);
*ipadp ^= temp;
*opadp ^= temp;
}
}
else
#endif
while(((temp = JOHNSWAP64(*keyp++)) & 0xff00000000000000)) {
if (!(temp & 0x00ff000000000000) || !(temp & 0x0000ff0000000000))
{
((unsigned short*)ipadp)[3] ^=
(unsigned short)(temp >> 48);
((unsigned short*)opadp)[3] ^=
(unsigned short)(temp >> 48);
break;
}
if (!(temp & 0x00ff00000000) || !(temp & 0x0000ff000000))
{
((ARCH_WORD_32*)ipadp)[1] ^=
(ARCH_WORD_32)(temp >> 32);
((ARCH_WORD_32*)opadp)[1] ^=
(ARCH_WORD_32)(temp >> 32);
break;
}
uint8_t *SHA384(const uint8_t *data, size_t len, uint8_t *out) {
SHA512_CTX ctx;
static uint8_t buf[SHA384_DIGEST_LENGTH];
/* TODO(fork): remove this static buffer. */
if (out == NULL) {
out = buf;
}
SHA384_Init(&ctx);
SHA512_Update(&ctx, data, len);
SHA512_Final(out, &ctx);
OPENSSL_cleanse(&ctx, sizeof(ctx));
return out;
}
/* Begin SHA384 HMAC functions
*/
static void
hmac_sha384_init(hmac_sha384_ctx *ctx, const char *key, const int key_len)
{
unsigned char final_key[MAX_DIGEST_BLOCK_LEN] = {0};
int final_len = key_len;
if(key_len > MAX_DIGEST_BLOCK_LEN)
final_len = MAX_DIGEST_BLOCK_LEN;
/* When we eventually support arbitrary key sizes, take the digest
* of the key with: sha384(final_key, init_key, final_len);
*/
memcpy(final_key, key, final_len);
pad_init(ctx->block_inner_pad, ctx->block_outer_pad, final_key, final_len);
SHA384_Init(&ctx->ctx_inside);
SHA384_Update(&ctx->ctx_inside, ctx->block_inner_pad, SHA384_BLOCK_LEN);
SHA384_Init(&ctx->ctx_outside);
SHA384_Update(&ctx->ctx_outside, ctx->block_outer_pad, SHA384_BLOCK_LEN);
return;
}
void digidoc::Digest::reset()
{
int result = 1;
switch(d->method)
{
case NID_sha1: result = SHA1_Init(&d->sha1); break;
case NID_sha224: result = SHA224_Init(&d->sha256); break;
case NID_sha256: result = SHA256_Init(&d->sha256); break;
case NID_sha384: result = SHA384_Init(&d->sha512); break;
case NID_sha512: result = SHA512_Init(&d->sha512); break;
default: break;
}
d->digest.clear();
if(result != 1)
THROW_IOEXCEPTION("Failed to initialize %s digest calculator: %s", getName().c_str(), ERR_reason_error_string(ERR_get_error()));
}
static mrb_value
sha384_initialize(mrb_state *mrb, mrb_value self)
{
char *str;
int len;
SHA384_CTX *ctx = (SHA384_CTX*)mrb_malloc(mrb, sizeof(SHA384_CTX));
SHA384_Init(ctx);
DATA_TYPE(self) = &sha384_type;
DATA_PTR(self) = ctx;
if (mrb_get_args(mrb, "|s", &str, &len) == 1) {
SHA384_Update(ctx, (const u_int8_t *)str, len);
}
return self;
}
core::data sha2::digest384(core::data const& da)
{
core::data tmp = da.shadow();
SHA512_CTX ctx;
SHA384_Init(&ctx);
while (tmp.length())
{
SHA384_Update(&ctx, tmp.bytes(), tmp.limit(SHA384_DIGEST_LENGTH));
tmp.offset(tmp.limit(SHA384_DIGEST_LENGTH));
}
core::data ret(SHA384_DIGEST_LENGTH);
SHA384_Final((byte*)ret.bytes(), &ctx);
return ret;
}
static int hash_sha384(
const struct berval *scheme,
const struct berval *passwd,
struct berval *hash,
const char **text )
{
SHA384_CTX ct;
unsigned char hash384[SHA384_DIGEST_LENGTH];
struct berval digest;
digest.bv_val = (char *) hash384;
digest.bv_len = sizeof(hash384);
SHA384_Init(&ct);
SHA384_Update(&ct, (const uint8_t*)passwd->bv_val, passwd->bv_len);
SHA384_Final(hash384, &ct);
return lutil_passwd_string64(scheme, &digest, hash, NULL);
}
static void SHA384_File(FILE *file, unsigned char **output, int *outlength)
{
*output = new unsigned char[SHA384_DIGEST_LENGTH];
*outlength = SHA384_DIGEST_LENGTH;
SHA512_CTX c;
int i;
unsigned char buf[SHA384_FILE_BUFFER_SIZE];
SHA384_Init(&c);
for (;;)
{
i = fread(buf,1,SHA384_FILE_BUFFER_SIZE,file);
if(i <= 0)
break;
SHA384_Update(&c,buf,(unsigned long)i);
}
SHA384_Final(*output, &c);
}
static void _wi_sha2_ctx_init(wi_sha2_bits_t bits, _wi_sha2_ctx_t *ctx) {
ctx->bits = bits;
#ifdef WI_SHA2_OPENSSL
switch(ctx->bits) {
case WI_SHA2_224:
SHA224_Init(&ctx->openssl_256_ctx);
break;
case WI_SHA2_256:
SHA256_Init(&ctx->openssl_256_ctx);
break;
case WI_SHA2_384:
SHA384_Init(&ctx->openssl_512_ctx);
break;
case WI_SHA2_512:
SHA512_Init(&ctx->openssl_512_ctx);
break;
}
#endif
#ifdef WI_SHA2_COMMONCRYPTO
switch(ctx->bits) {
case WI_SHA2_224:
CC_SHA224_Init(&ctx->commondigest_256_ctx);
break;
case WI_SHA2_256:
CC_SHA256_Init(&ctx->commondigest_256_ctx);
break;
case WI_SHA2_384:
CC_SHA384_Init(&ctx->commondigest_512_ctx);
break;
case WI_SHA2_512:
CC_SHA512_Init(&ctx->commondigest_512_ctx);
break;
}
#endif
}
