bool OpensslManager::HashString(Openssl_Hash algorithm, unsigned char *input, int size, unsigned char *output, int *outlength)
{
switch(algorithm)
{
case Openssl_Hash_MD5:
MD5(input, size, output);
*outlength = MD5_DIGEST_LENGTH;
return true;
case Openssl_Hash_MD4:
MD4(input, size, output);
*outlength = MD4_DIGEST_LENGTH;
return true;
case Openssl_Hash_MD2:
MD2(input, size, output);
*outlength = MD2_DIGEST_LENGTH;
return true;
case Openssl_Hash_SHA:
SHA(input, size, output);
*outlength = SHA_DIGEST_LENGTH;
return true;
case Openssl_Hash_SHA1:
SHA1(input, size, output);
*outlength = SHA_DIGEST_LENGTH;
return true;
case Openssl_Hash_SHA224:
SHA224(input, size, output);
*outlength = SHA224_DIGEST_LENGTH;
return true;
case Openssl_Hash_SHA256:
SHA256(input, size, output);
*outlength = SHA256_DIGEST_LENGTH;
return true;
case Openssl_Hash_SHA384:
SHA384(input, size, output);
*outlength = SHA384_DIGEST_LENGTH;
return true;
case Openssl_Hash_SHA512:
SHA512(input, size, output);
*outlength = SHA512_DIGEST_LENGTH;
return true;
case Openssl_Hash_RIPEMD160:
RIPEMD160(input, size, output);
*outlength = RIPEMD160_DIGEST_LENGTH;
return true;
}
return false;
}
static ErlDrvSSizeT sha_drv_control(ErlDrvData handle,
unsigned int command,
char *buf, ErlDrvSizeT len,
char **rbuf, ErlDrvSizeT rlen)
{
ErlDrvBinary *b = NULL;
switch (command) {
#ifdef HAVE_MD2
case 2:
rlen = MD2_DIGEST_LENGTH;
b = driver_alloc_binary(rlen);
if (b) MD2((unsigned char*)buf, len, (unsigned char*)b->orig_bytes);
break;
#endif
case 224:
rlen = SHA224_DIGEST_LENGTH;
b = driver_alloc_binary(rlen);
if (b) SHA224((unsigned char*)buf, len, (unsigned char*)b->orig_bytes);
break;
case 256:
rlen = SHA256_DIGEST_LENGTH;
b = driver_alloc_binary(rlen);
if (b) SHA256((unsigned char*)buf, len, (unsigned char*)b->orig_bytes);
break;
case 384:
rlen = SHA384_DIGEST_LENGTH;
b = driver_alloc_binary(rlen);
if (b) SHA384((unsigned char*)buf, len, (unsigned char*)b->orig_bytes);
break;
case 512:
rlen = SHA512_DIGEST_LENGTH;
b = driver_alloc_binary(rlen);
if (b) SHA512((unsigned char*)buf, len, (unsigned char*)b->orig_bytes);
break;
};
if (b) {
*rbuf = (char *)b;
} else {
*rbuf = NULL;
rlen = 0;
};
return rlen;
}
void Hash::MD2_Generate(FILE *hashfile)
{
MD2(hashfile,digest);
}
int main(int argc, char **argv) {
const size_t n = 42, m = 87;
matrix<std::pair<size_t, size_t> > M(n, m);
size_t i, j;
// Confirm sizes make sense.
assert(M.size1() == n);
assert(M.size2() == m);
// Confirm storing values works.
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
M(i, j) = std::make_pair<size_t, size_t>(i, j);
// Confirm retrieving values in another order works.
for (i = n; 0 < i--;) {
for (j = m; 0 < j--;) {
assert(M(i, j).first == i);
assert(M(i, j).second == j);
}
}
// Confirm copying works.
matrix<std::pair<size_t, size_t> > N = M;
assert(N.size1() == n);
assert(N.size2() == m);
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
assert(N(i, j).first == i);
assert(N(i, j).second == j);
}
}
// Confirm assigning works.
M = matrix<std::pair<size_t, size_t> >(1, 1);
assert(M.size1() == 1);
assert(M.size2() == 1);
M(0, 0) = std::make_pair<size_t, size_t>(123456789, 8);
assert(M(0, 0).first == 123456789);
assert(M(0, 0).second == 8);
// Confirm it did not affect the copy.
assert(N.size1() == n);
assert(N.size2() == m);
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
assert(N(i, j).first == i);
assert(N(i, j).second == j);
}
}
// Confirm MatrixD = matrix<double> by confirming the pointer
// types are compatible.
matrix<double> MD0(42, 42);
MatrixD &MD1 = MD0;
assert(&MD1 == &MD0);
// Confirm overflow detection.
try {
const size_t size_max = std::numeric_limits<size_t>::max();
MatrixD MD2(size_max, size_max);
} catch (std::bad_alloc &ba) {
}
return 0;
}
void f_hash(void)
{
const char *algo;
const char *data;
char *res;
algo = (sp - 1)->u.string;
data = sp->u.string;
/* MD2 Digest */
if (strcasecmp(algo, (const char *)"md2") == 0)
{
unsigned char md[MD2_DIGEST_LENGTH];
MD2((unsigned char *)data, strlen(data), md);
res = hexdump(md, MD2_DIGEST_LENGTH);
}
/* MD4 Digest */
else if (strcasecmp(algo, (const char *)"md4") == 0)
{
unsigned char md[MD4_DIGEST_LENGTH];
MD4((unsigned char *)data, strlen(data), md);
res = hexdump(md, MD4_DIGEST_LENGTH);
}
/* MD5 Digest */
else if (strcasecmp(algo, (const char *)"md5") == 0)
{
unsigned char md[MD5_DIGEST_LENGTH];
MD5((unsigned char *)data, strlen(data), md);
res = hexdump(md, MD5_DIGEST_LENGTH);
}
/* MDC2 Digest */
else if (strcasecmp(algo, (const char *)"mdc2") == 0)
{
unsigned char md[MDC2_DIGEST_LENGTH];
MDC2((unsigned char *)data, strlen(data), md);
res = hexdump(md, MDC2_DIGEST_LENGTH);
}
/* RIPEMD160 Digest */
else if (strcasecmp(algo, (const char *)"ripemd160") == 0)
{
unsigned char md[RIPEMD160_DIGEST_LENGTH];
RIPEMD160((unsigned char *)data, strlen(data), md);
res = hexdump(md, RIPEMD160_DIGEST_LENGTH);
}
/* SHA1 Digest */
else if (strcasecmp(algo, (const char *)"sha1") == 0)
{
unsigned char md[SHA_DIGEST_LENGTH];
SHA1((unsigned char *)data, strlen(data), md);
res = hexdump(md, SHA_DIGEST_LENGTH);
}
else
{
pop_stack();
res = malloc(29 + strlen(algo));
sprintf(res, "hash() unknown hash type: %s.\n", algo);
error(res);
}
/* Pop the arguments off the stack and push the result */
free_string_svalue(sp--);
free_string_svalue(sp);
sp->subtype = STRING_MALLOC;
sp->u.string = res;
}
