56c064 | 2008-07-31 | Martin Stjernholm | | /* -*- c -*-
|| This file is part of Pike. For copyright information see COPYRIGHT.
|| Pike is distributed under GPL, LGPL and MPL. See the file COPYING
|| for more information.
*/
|
6d1a54 | 2003-03-13 | Niels Möller | |
#include "global.h"
#include "interpret.h"
#include "svalue.h"
|
602fe6 | 2004-02-21 | Martin Nilsson | | #include "threads.h"
|
6d1a54 | 2003-03-13 | Niels Möller | |
/* For this_object() */
#include "object.h"
#include "module_support.h"
|
d668ac | 2013-03-12 | Arne Goedeke | | #include "pike_memory.h"
|
6d1a54 | 2003-03-13 | Niels Möller | |
#include "nettle_config.h"
#ifdef HAVE_LIBNETTLE
|
56c064 | 2008-07-31 | Martin Stjernholm | | DECLARATIONS
|
6d1a54 | 2003-03-13 | Niels Möller | | #include "nettle.h"
#include <nettle/md5.h>
|
5c36c8 | 2003-08-26 | Martin Nilsson | | #ifdef HAVE_NETTLE_MD4_INIT
|
40f88a | 2003-08-01 | Martin Nilsson | | #include <nettle/md4.h>
|
5c36c8 | 2003-08-26 | Martin Nilsson | | #include <nettle/md2.h>
|
40f88a | 2003-08-01 | Martin Nilsson | | #endif
|
6d1a54 | 2003-03-13 | Niels Möller | | #include <nettle/sha.h>
|
0e29b6 | 2013-11-14 | Martin Nilsson | | #ifdef HAVE_NETTLE_SHA3_H
#include <nettle/sha3.h>
#endif
|
ae4500 | 2013-11-30 | Martin Nilsson | | #ifdef HAVE_NETTLE_RIPEMD160_H
#include <nettle/ripemd160.h>
#endif
#ifdef HAVE_NETTLE_GOSTHASH94_H
#include <nettle/gosthash94.h>
#endif
|
6d1a54 | 2003-03-13 | Niels Möller | | #include <nettle/nettle-meta.h>
#include <stdio.h>
#include <stdarg.h>
|
5a20f9 | 2004-04-28 | Martin Nilsson | | #include "fdlib.h"
|
7a3882 | 2004-04-30 | Martin Nilsson | |
|
6d1a54 | 2003-03-13 | Niels Möller | | #if 0
static void
werror(const char *format, ...)
{
va_list args;
va_start(args, format);
vfprintf(stderr, format, args);
va_end(args);
}
#else
#define werror(x)
#endif
|
411a28 | 2003-03-18 | Niels Möller | | /*! @module Nettle */
|
de38b7 | 2013-10-05 | Henrik Grubbström (Grubba) | | /*! @class Hash
|
cd2648 | 2003-03-18 | Niels Möller | | *!
*! Represents information about a hash algorithm, such as
*! name, digest size, and internal block size.
*/
|
de38b7 | 2013-10-05 | Henrik Grubbström (Grubba) | | PIKECLASS Hash
|
6d1a54 | 2003-03-13 | Niels Möller | | {
|
eb4472 | 2013-10-05 | Henrik Grubbström (Grubba) | | /*! @decl inherit __builtin.Nettle.Hash
*/
INHERIT "__builtin.Nettle.Hash";
|
6d1a54 | 2003-03-13 | Niels Möller | | CVAR const struct nettle_hash *meta;
|
3aae35 | 2013-05-19 | Martin Nilsson | | /*! @decl string(0..255) name(void)
|
cd2648 | 2003-03-18 | Niels Möller | | *!
*! Returns a human readable name for the algorithm.
*/
|
3aae35 | 2013-05-19 | Martin Nilsson | | PIKEFUN string(0..255) name()
|
1a2b71 | 2004-02-14 | Martin Nilsson | | optflags OPT_TRY_OPTIMIZE;
|
6d1a54 | 2003-03-13 | Niels Möller | | {
if (!THIS->meta)
|
de38b7 | 2013-10-05 | Henrik Grubbström (Grubba) | | Pike_error("Hash not properly initialized.\n");
|
6d1a54 | 2003-03-13 | Niels Möller | |
|
3f286d | 2003-11-29 | Martin Nilsson | | push_text(THIS->meta->name);
|
6d1a54 | 2003-03-13 | Niels Möller | | }
|
3aae35 | 2013-05-19 | Martin Nilsson | | /*! @decl int(0..) digest_size(void)
|
cd2648 | 2003-03-18 | Niels Möller | | *!
*! Returns the size of a hash digests.
*/
|
3aae35 | 2013-05-19 | Martin Nilsson | | PIKEFUN int(0..) digest_size()
|
1a2b71 | 2004-02-14 | Martin Nilsson | | optflags OPT_TRY_OPTIMIZE;
|
6d1a54 | 2003-03-13 | Niels Möller | | {
if (!THIS->meta)
|
de38b7 | 2013-10-05 | Henrik Grubbström (Grubba) | | Pike_error("Hash not properly initialized.\n");
|
6d1a54 | 2003-03-13 | Niels Möller | |
push_int(THIS->meta->digest_size);
}
|
3aae35 | 2013-05-19 | Martin Nilsson | | /*! @decl int(0..) block_size(void)
|
cd2648 | 2003-03-18 | Niels Möller | | *!
|
f1c9f4 | 2003-08-05 | Martin Nilsson | | *! Returns the internal block size of the hash algorithm.
|
cd2648 | 2003-03-18 | Niels Möller | | */
|
3aae35 | 2013-05-19 | Martin Nilsson | | PIKEFUN int(0..) block_size()
|
1a2b71 | 2004-02-14 | Martin Nilsson | | optflags OPT_TRY_OPTIMIZE;
|
6d1a54 | 2003-03-13 | Niels Möller | | {
if (!THIS->meta)
|
de38b7 | 2013-10-05 | Henrik Grubbström (Grubba) | | Pike_error("Hash not properly initialized.\n");
|
6d1a54 | 2003-03-13 | Niels Möller | |
push_int(THIS->meta->block_size);
}
|
951225 | 2004-04-28 | Martin Nilsson | |
|
89d2bf | 2013-12-08 | Henrik Grubbström (Grubba) | | /*! @decl string(0..255) hash(string(0..255) data)
|
951225 | 2004-04-28 | Martin Nilsson | | *!
*! Works as a (faster) shortcut for
|
de38b7 | 2013-10-05 | Henrik Grubbström (Grubba) | | *! @expr{State()->update(data)->digest()@}, where State is
*! the hash state class corresponding to this Hash.
|
951225 | 2004-04-28 | Martin Nilsson | | *!
*! @seealso
|
de38b7 | 2013-10-05 | Henrik Grubbström (Grubba) | | *! @[State()->update()] and @[State()->digest()].
|
951225 | 2004-04-28 | Martin Nilsson | | */
|
89d2bf | 2013-12-08 | Henrik Grubbström (Grubba) | | PIKEFUN string(0..255) hash(string(0..255) in)
|
951225 | 2004-04-28 | Martin Nilsson | | optflags OPT_TRY_OPTIMIZE;
{
void *ctx;
struct pike_string *out;
unsigned digest_length;
|
5a20f9 | 2004-04-28 | Martin Nilsson | | const struct nettle_hash *meta = THIS->meta;
|
951225 | 2004-04-28 | Martin Nilsson | |
|
5a20f9 | 2004-04-28 | Martin Nilsson | | if (!meta)
|
de38b7 | 2013-10-05 | Henrik Grubbström (Grubba) | | Pike_error("Hash not properly initialized.\n");
|
951225 | 2004-04-28 | Martin Nilsson | | NO_WIDE_STRING(in);
|
5a20f9 | 2004-04-28 | Martin Nilsson | | ctx = (void *)alloca(meta->context_size);
|
951225 | 2004-04-28 | Martin Nilsson | | if(!ctx)
|
8a3e56 | 2004-05-19 | Martin Nilsson | | SIMPLE_OUT_OF_MEMORY_ERROR("hash", meta->context_size);
|
951225 | 2004-04-28 | Martin Nilsson | |
|
e8be7c | 2010-11-14 | Jonas Walldén | | /* Only thread this block for significant data size */
if (in->len > THREADS_ALLOW_THRESHOLD) {
THREADS_ALLOW();
meta->init(ctx);
meta->update(ctx, in->len, (const uint8_t *)in->str);
THREADS_DISALLOW();
} else {
meta->init(ctx);
meta->update(ctx, in->len, (const uint8_t *)in->str);
}
|
951225 | 2004-04-28 | Martin Nilsson | |
|
5a20f9 | 2004-04-28 | Martin Nilsson | | digest_length = meta->digest_size;
|
951225 | 2004-04-28 | Martin Nilsson | | out = begin_shared_string(digest_length);
|
20e2ef | 2005-12-12 | Martin Nilsson | | meta->digest(ctx, digest_length, (uint8_t *)out->str);
|
5a20f9 | 2004-04-28 | Martin Nilsson | |
pop_n_elems(args);
push_string(end_shared_string(out));
}
|
99f984 | 2013-06-09 | Martin Nilsson | | int is_stdio_file(struct object *o)
{
struct program *p = o->prog;
INT32 i = p->num_inherits;
while( i-- )
{
if( p->inherits[i].prog->id == PROG_STDIO_FD_ID ||
p->inherits[i].prog->id == PROG_STDIO_FD_REF_ID )
return 1;
}
return 0;
}
|
3aae35 | 2013-05-19 | Martin Nilsson | | /*! @decl string(0..255) hash(Stdio.File file, void|int bytes)
|
5a20f9 | 2004-04-28 | Martin Nilsson | | *!
*! Works as a (faster) shortcut for
|
de38b7 | 2013-10-05 | Henrik Grubbström (Grubba) | | *! @expr{State()->update(Stdio.read_file(file))->digest()@},
*! where State is the hash state class corresponding to this
*! Hash.
|
5a20f9 | 2004-04-28 | Martin Nilsson | | *!
|
7a3882 | 2004-04-30 | Martin Nilsson | | *! @param bytes
*! The number of bytes of the file object @[file] that should be
*! hashed. Negative numbers are ignored and the whole file is
*! hashed.
*!
|
5a20f9 | 2004-04-28 | Martin Nilsson | | *! @seealso
|
de38b7 | 2013-10-05 | Henrik Grubbström (Grubba) | | *! @[Stdio.File], @[State()->update()] and
*! @[State()->digest()].
|
5a20f9 | 2004-04-28 | Martin Nilsson | | */
|
3aae35 | 2013-05-19 | Martin Nilsson | | PIKEFUN string(0..255) hash(object in, void|int bytes)
|
5a20f9 | 2004-04-28 | Martin Nilsson | | optflags OPT_EXTERNAL_DEPEND;
{
void *ctx;
|
fe11b9 | 2004-04-29 | Martin Nilsson | | int len, fd;
|
5a20f9 | 2004-04-28 | Martin Nilsson | | char *read_buffer;
PIKE_STAT_T st;
struct pike_string *out;
const struct nettle_hash *meta = THIS->meta;
if (!meta)
Pike_error("HashInfo not properly initialized.\n");
|
99f984 | 2013-06-09 | Martin Nilsson | | if (!is_stdio_file(in))
Pike_error("Object not Fd or Fd_ref, or subclass.\n");
|
5a20f9 | 2004-04-28 | Martin Nilsson | |
|
beebe6 | 2013-06-09 | Martin Nilsson | | apply(in, "query_fd", 0);
|
fe11b9 | 2004-04-29 | Martin Nilsson | | fd = Pike_sp[-1].u.integer;
|
5a20f9 | 2004-04-28 | Martin Nilsson | | pop_stack();
if (fd_fstat(fd, &st)<0)
Pike_error("File not found!\n");
if (!S_ISREG(st.st_mode))
Pike_error("Non-regular file.\n");
ctx = (void *)alloca(meta->context_size);
if (!ctx)
|
8a3e56 | 2004-05-19 | Martin Nilsson | | SIMPLE_OUT_OF_MEMORY_ERROR("hash", meta->context_size);
|
5a20f9 | 2004-04-28 | Martin Nilsson | |
|
337f33 | 2004-04-28 | Martin Nilsson | | read_buffer=(char *)malloc(8192);
if (!read_buffer)
|
8a3e56 | 2004-05-19 | Martin Nilsson | | SIMPLE_OUT_OF_MEMORY_ERROR("hash", 8192);
|
337f33 | 2004-04-28 | Martin Nilsson | |
|
5a20f9 | 2004-04-28 | Martin Nilsson | | THREADS_ALLOW();
meta->init(ctx);
|
7a3882 | 2004-04-30 | Martin Nilsson | | if(args==2 && bytes->u.integer>-1) {
int bytes_left = bytes->u.integer;
int read_bytes = MINIMUM(8192, bytes_left);
while(read_bytes>0 && (len=fd_read(fd, read_buffer, read_bytes))>0) {
|
20e2ef | 2005-12-12 | Martin Nilsson | | meta->update(ctx, len, (const uint8_t *)read_buffer);
|
7a3882 | 2004-04-30 | Martin Nilsson | | bytes_left -= read_bytes;
read_bytes = MINIMUM(8192, bytes_left);
}
}
else
while((len=fd_read(fd, read_buffer, 8192))>0)
|
20e2ef | 2005-12-12 | Martin Nilsson | | meta->update(ctx, len, (const uint8_t *)read_buffer);
|
337f33 | 2004-04-28 | Martin Nilsson | |
free(read_buffer);
|
5a20f9 | 2004-04-28 | Martin Nilsson | |
|
d51d79 | 2010-06-21 | Martin Stjernholm | | THREADS_DISALLOW();
|
5a20f9 | 2004-04-28 | Martin Nilsson | | out = begin_shared_string(meta->digest_size);
|
20e2ef | 2005-12-12 | Martin Nilsson | | meta->digest(ctx, meta->digest_size, (uint8_t *)out->str);
|
951225 | 2004-04-28 | Martin Nilsson | |
pop_n_elems(args);
push_string(end_shared_string(out));
}
|
551b7c | 2013-03-07 | Henrik Grubbström (Grubba) | | /* NOTE: This is NOT the MIME base64 table! */
|
89d2bf | 2013-12-08 | Henrik Grubbström (Grubba) | | static const char b64tab[64] =
"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
|
551b7c | 2013-03-07 | Henrik Grubbström (Grubba) | |
static inline void b64enc(char *dest, int a, int b, int c, int sz)
{
unsigned int bitbuf = a | (b << 8) | (c << 16);
while (sz--) {
*(dest++) = b64tab[bitbuf & 63];
bitbuf >>= 6;
}
}
|
89d2bf | 2013-12-08 | Henrik Grubbström (Grubba) | | /*! @decl string(0..127) crypt_hash(string(0..255) password, @
*! string(0..255) salt, int rounds)
|
551b7c | 2013-03-07 | Henrik Grubbström (Grubba) | | *!
*! Password hashing function in @[crypt_md5()]-style.
*!
*! Implements the algorithm described in
*! @url{http://www.akkadia.org/drepper/SHA-crypt.txt@}.
*!
*! This is the algorithm used by @tt{crypt(2)@} in
*! methods @tt{$5$@} (SHA256) and @tt{$6$@} (SHA512).
*!
|
954c06 | 2013-08-15 | Martin Nilsson | | *! The @[password] memory will be cleared before released.
*!
|
551b7c | 2013-03-07 | Henrik Grubbström (Grubba) | | *! @seealso
*! @[crypt_md5()]
*/
|
89d2bf | 2013-12-08 | Henrik Grubbström (Grubba) | | PIKEFUN string(0..127) crypt_hash(string(0..255) password,
string(0..255) salt, int rounds)
|
551b7c | 2013-03-07 | Henrik Grubbström (Grubba) | | {
struct pike_string *res;
const struct nettle_hash *meta = THIS->meta;
void *ctx;
uint8_t *abcbuf;
uint8_t *dpbuf;
uint8_t *dsbuf;
|
3aae35 | 2013-05-19 | Martin Nilsson | | unsigned char *p;
unsigned char *s;
|
551b7c | 2013-03-07 | Henrik Grubbström (Grubba) | | int plen;
int slen;
int dsz = meta->digest_size;
int i;
int r;
int a, b, c;
if (!rounds) rounds = 5000;
if (rounds < 1000) rounds = 1000;
if (rounds > 999999999) rounds = 999999999;
NO_WIDE_STRING(password);
NO_WIDE_STRING(salt);
|
da892a | 2013-08-09 | Arne Goedeke | | password->flags |= STRING_CLEAR_ON_EXIT;
|
551b7c | 2013-03-07 | Henrik Grubbström (Grubba) | | ctx = (void *)alloca(meta->context_size);
if (!ctx)
SIMPLE_OUT_OF_MEMORY_ERROR("crypt_hash", meta->context_size);
abcbuf = (uint8_t *)alloca(meta->digest_size * 3);
if (!abcbuf)
SIMPLE_OUT_OF_MEMORY_ERROR("crypt_hash", meta->digest_size * 3);
dpbuf = abcbuf + meta->digest_size;
dsbuf = dpbuf + meta->digest_size;
/* NB: We use these to allow the compiler to
* avoid dereferencing at every step.
*/
|
3aae35 | 2013-05-19 | Martin Nilsson | | p = (unsigned char*)password->str;
|
551b7c | 2013-03-07 | Henrik Grubbström (Grubba) | | plen = password->len;
|
3aae35 | 2013-05-19 | Martin Nilsson | | s = (unsigned char*)salt->str;
|
551b7c | 2013-03-07 | Henrik Grubbström (Grubba) | | slen = salt->len;
if (slen > 16) slen = 16;
dsz = meta->digest_size;
/* NB: We allocate the result here to avoid throwing away all the work
* on out of memory at the end.
*/
if (dsz == 32) {
/* 4 * (30/3) + 3 */
res = begin_shared_string(43);
} else if (dsz == 64) {
/* 4 * (63/3) + 2 */
res = begin_shared_string(86);
} else {
Pike_error("crypt_hash() not supported for this digest size yet (%d).\n",
dsz);
}
THREADS_ALLOW();
/* NB: Comments refer to http://www.akkadia.org/drepper/SHA-crypt.txt */
meta->init(ctx); /* 4 */
meta->update(ctx, plen, p); /* 5 */
meta->update(ctx, slen, s); /* 6 */
meta->update(ctx, plen, p); /* 7 */
meta->digest(ctx, dsz, abcbuf); /* 8 */
meta->init(ctx); /* 1 */
meta->update(ctx, plen, p); /* 2 */
meta->update(ctx, slen, s); /* 3 */
for (i = 0; i + dsz < plen; i += dsz) { /* 9 */
meta->update(ctx, dsz, abcbuf);
}
meta->update(ctx, plen - i, abcbuf); /* 10 */
for (i = 1; i < plen; i <<= 1) { /* 11 */
if (plen & i) {
meta->update(ctx, dsz, abcbuf);
} else {
meta->update(ctx, plen, p);
}
}
meta->digest(ctx, dsz, abcbuf); /* 12 */
meta->init(ctx); /* 13 */
for (i = 0; i < plen; i++) { /* 14 */
meta->update(ctx, plen, p);
}
meta->digest(ctx, dsz, dpbuf); /* 15 */
/* Sequence P is implicit. */ /* 16 */
meta->init(ctx); /* 17 */
for(i = 0; i < 16 + abcbuf[0]; i++) { /* 18 */
meta->update(ctx, slen, s);
}
meta->digest(ctx, dsz, dsbuf); /* 19 */
/* Sequence S is implicit. */ /* 20 */
for (r = 0; r < rounds; r++) { /* 21 */
meta->init(ctx); /* a */
if (r & 1) { /* b */
for (i = 0; i + dsz < plen; i += dsz) {
meta->update(ctx, dsz, dpbuf);
}
meta->update(ctx, plen - i, dpbuf);
} else {
meta->update(ctx, dsz, abcbuf); /* c */
}
if (r % 3) { /* d */
for (i = 0; i + dsz < slen; i += dsz) {
meta->update(ctx, dsz, dsbuf);
}
meta->update(ctx, slen - i, dsbuf);
}
if (r % 7) { /* e */
for (i = 0; i + dsz < plen; i += dsz) {
meta->update(ctx, dsz, dpbuf);
}
meta->update(ctx, plen - i, dpbuf);
}
if (r & 1) { /* f */
meta->update(ctx, dsz, abcbuf);
} else { /* g */
for (i = 0; i + dsz < plen; i += dsz) {
meta->update(ctx, dsz, dpbuf);
}
meta->update(ctx, plen - i, dpbuf);
}
meta->digest(ctx, dsz, abcbuf); /* h */
}
THREADS_DISALLOW();
/* And now time for some pointless shuffling of the result.
* Note that the shuffling is slightly different between
* the two cases.
*
* This is followed by a custom base64-style encoding.
*/
c = 0;
b = dsz/3;
a = 2*b;
if (dsz == 32) {
for (i = 0, r = 0; i + 3 < dsz; i+=3, r+=4) {
int t;
b64enc(res->str + r, abcbuf[a], abcbuf[b], abcbuf[c], 4);
t = a+1;
a = b+1;
b = c+1;
c = t;
}
b64enc(res->str + r, abcbuf[30], abcbuf[31], 0, 3);
} else {
for (i = 0, r = 0; i + 3 < dsz; i+=3, r+=4) {
int t;
b64enc(res->str + r, abcbuf[a], abcbuf[b], abcbuf[c], 4);
t = a+1;
a = c+1;
c = b+1;
b = t;
}
b64enc(res->str + r, abcbuf[63], 0, 0, 2);
}
push_string(end_shared_string(res)); /* 22e */
/* Clean intermediate values. */
MEMSET(ctx, 0, meta->context_size);
MEMSET(abcbuf, 0, 3*dsz);
}
|
6d1a54 | 2003-03-13 | Niels Möller | | INIT
{
|
de38b7 | 2013-10-05 | Henrik Grubbström (Grubba) | | werror("Hash->INIT\n");
|
6d1a54 | 2003-03-13 | Niels Möller | | THIS->meta = NULL;
}
|
de38b7 | 2013-10-05 | Henrik Grubbström (Grubba) | | /*! @class State
*!
*! Base class for hashing contexts.
*/
PIKECLASS State
program_flags PROGRAM_USES_PARENT|PROGRAM_NEEDS_PARENT;
{
|
fc0a7a | 2013-10-05 | Henrik Grubbström (Grubba) | | DOCSTART() @decl inherit Hash::State
DOCEND()
|
411a28 | 2003-03-18 | Niels Möller | |
|
de38b7 | 2013-10-05 | Henrik Grubbström (Grubba) | | EXTRA
{
/* Perform an inherit of the State class (if any) that our parent
* may contain via its inherit of __builtin.Nettle.Hash.
*/
struct program *parent_prog = Pike_compiler->previous->new_program;
struct object *parent_obj = Pike_compiler->previous->fake_object;
int parent_State_fun_num =
really_low_find_shared_string_identifier(MK_STRING("State"),
parent_prog,
SEE_PROTECTED|SEE_PRIVATE);
if (parent_State_fun_num >= 0) {
struct program *parent_State_prog =
low_program_from_function(parent_obj, parent_State_fun_num);
if (parent_State_prog) {
low_inherit(parent_State_prog, 0,
parent_State_fun_num +
parent_prog->inherits[1].identifier_level,
1 + 42, 0, NULL);
}
}
}
|
6d1a54 | 2003-03-13 | Niels Möller | |
|
de38b7 | 2013-10-05 | Henrik Grubbström (Grubba) | | #define GET_META(o) \
( ((struct Hash_struct *)parent_storage(1))->meta )
|
6d1a54 | 2003-03-13 | Niels Möller | |
|
de38b7 | 2013-10-05 | Henrik Grubbström (Grubba) | | CVAR void *ctx;
|
6d1a54 | 2003-03-13 | Niels Möller | |
|
de38b7 | 2013-10-05 | Henrik Grubbström (Grubba) | | /* FIXME: Create should copy state from the other object, if
* provided. */
|
6d1a54 | 2003-03-13 | Niels Möller | |
|
de38b7 | 2013-10-05 | Henrik Grubbström (Grubba) | | /*! @decl State update(string(0..255) data)
*!
*! Hashes more data.
*!
*! @returns
*! Returns @expr{this@} in order to simplify chaining
*! of function calls.
*/
PIKEFUN object update(string(0..255) data)
optflags OPT_SIDE_EFFECT;
|
75e487 | 2013-12-15 | Henrik Grubbström (Grubba) | | rawtype tFunc(tStr8, tObjImpl_HASH_STATE);
|
6d1a54 | 2003-03-13 | Niels Möller | | {
|
766bc8 | 2004-10-16 | Marcus Agehall | | void *ctx = THIS->ctx;
|
911963 | 2003-05-07 | Henrik Grubbström (Grubba) | | const struct nettle_hash *meta =
GET_META(Pike_fp->current_object);
|
6d1a54 | 2003-03-13 | Niels Möller | |
|
03123d | 2004-02-21 | Martin Nilsson | | if (!ctx || !meta)
|
de38b7 | 2013-10-05 | Henrik Grubbström (Grubba) | | Pike_error("State not properly initialized.\n");
|
6d1a54 | 2003-03-13 | Niels Möller | |
NO_WIDE_STRING(data);
|
e8be7c | 2010-11-14 | Jonas Walldén | |
/* Only thread this block for significant data size */
if (data->len > THREADS_ALLOW_THRESHOLD) {
THREADS_ALLOW();
meta->update(ctx, data->len, (const uint8_t *)data->str);
THREADS_DISALLOW();
} else {
meta->update(ctx, data->len, (const uint8_t *)data->str);
}
|
6d1a54 | 2003-03-13 | Niels Möller | |
push_object(this_object());
}
|
de38b7 | 2013-10-05 | Henrik Grubbström (Grubba) | | /*! @decl string(0..255) digest(int|void length)
*!
*! Generates a digest, and resets the hashing contents.
*!
*! @param length
*! If the length argument is provided, the digest is truncated
*! to the given length.
*!
*! @returns
*! The digest.
*/
|
3aae35 | 2013-05-19 | Martin Nilsson | | PIKEFUN string(0..255) digest(int|void arg)
|
6d1a54 | 2003-03-13 | Niels Möller | | {
const struct nettle_hash *meta;
struct pike_string *digest;
unsigned length;
|
911963 | 2003-05-07 | Henrik Grubbström (Grubba) | | meta = GET_META(Pike_fp->current_object);
|
de38b7 | 2013-10-05 | Henrik Grubbström (Grubba) | |
if (!THIS->ctx || !meta)
Pike_error("State not properly initialized.\n");
|
6d1a54 | 2003-03-13 | Niels Möller | | if (!arg)
length = meta->digest_size;
else
{
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | if (TYPEOF(*arg) != PIKE_T_INT)
|
f1c9f4 | 2003-08-05 | Martin Nilsson | | Pike_error("Bad argument type.\n");
if (arg->u.integer < 0)
Pike_error("Invalid length, must be positive.\n");
|
61e14b | 2004-01-23 | Martin Nilsson | | if ((unsigned)arg->u.integer > meta->digest_size)
|
f1c9f4 | 2003-08-05 | Martin Nilsson | | Pike_error("Unsupported digest length.\n");
|
6d1a54 | 2003-03-13 | Niels Möller | |
length = arg->u.integer;
}
digest = begin_shared_string(length);
|
20e2ef | 2005-12-12 | Martin Nilsson | | meta->digest(THIS->ctx, length, (uint8_t *)digest->str);
|
6d1a54 | 2003-03-13 | Niels Möller | | push_string(end_shared_string(digest));
}
|
ac1465 | 2003-07-29 | Martin Nilsson | |
|
de38b7 | 2013-10-05 | Henrik Grubbström (Grubba) | | INIT
|
6d1a54 | 2003-03-13 | Niels Möller | | {
|
de38b7 | 2013-10-05 | Henrik Grubbström (Grubba) | | werror("State->INIT\n");
|
6d1a54 | 2003-03-13 | Niels Möller | | THIS->ctx = NULL;
}
|
22038d | 2008-05-30 | Martin Nilsson | |
|
de38b7 | 2013-10-05 | Henrik Grubbström (Grubba) | | EXIT
|
6d1a54 | 2003-03-13 | Niels Möller | | {
|
de38b7 | 2013-10-05 | Henrik Grubbström (Grubba) | | werror("State->EXIT\n");
if (THIS->ctx)
|
6d1a54 | 2003-03-13 | Niels Möller | | {
|
911963 | 2003-05-07 | Henrik Grubbström (Grubba) | | const struct nettle_hash *meta =
GET_META(Pike_fp->current_object);
|
de38b7 | 2013-10-05 | Henrik Grubbström (Grubba) | | if (meta) {
memset(THIS->ctx, 0, meta->context_size);
}
|
6d1a54 | 2003-03-13 | Niels Möller | | }
}
|
de38b7 | 2013-10-05 | Henrik Grubbström (Grubba) | | }
/*! @endclass State */
|
6d1a54 | 2003-03-13 | Niels Möller | | }
|
de38b7 | 2013-10-05 | Henrik Grubbström (Grubba) | | /*! @endclass Hash */
/* The algorithm objects can be overloaded in pike. */
|
411a28 | 2003-03-18 | Niels Möller | |
|
88064b | 2011-12-20 | Henrik Grubbström (Grubba) | | #cmod_define TOSTR(DEF) #DEF
|
6d1a54 | 2003-03-13 | Niels Möller | |
|
88064b | 2011-12-20 | Henrik Grubbström (Grubba) | | #cmod_define PIKE_NAME MD5
#cmod_define NETTLE_NAME md5
#cmod_include "hash.H"
#cmod_undef PIKE_NAME
#cmod_undef NETTLE_NAME
|
6d1a54 | 2003-03-13 | Niels Möller | |
|
5c36c8 | 2003-08-26 | Martin Nilsson | | #ifdef HAVE_NETTLE_MD4_INIT
|
40f88a | 2003-08-01 | Martin Nilsson | |
|
88064b | 2011-12-20 | Henrik Grubbström (Grubba) | | #cmod_define PIKE_NAME MD4
#cmod_define NETTLE_NAME md4
#cmod_include "hash.H"
#cmod_undef PIKE_NAME
#cmod_undef NETTLE_NAME
|
5c36c8 | 2003-08-26 | Martin Nilsson | |
|
88064b | 2011-12-20 | Henrik Grubbström (Grubba) | | #cmod_define PIKE_NAME MD2
#cmod_define NETTLE_NAME md2
#cmod_include "hash.H"
#cmod_undef PIKE_NAME
#cmod_undef NETTLE_NAME
|
5c36c8 | 2003-08-26 | Martin Nilsson | |
#endif /* HAVE_NETTLE_MD4_INIT */
|
40f88a | 2003-08-01 | Martin Nilsson | |
|
88064b | 2011-12-20 | Henrik Grubbström (Grubba) | | #cmod_define PIKE_NAME SHA1
#cmod_define NETTLE_NAME sha1
#cmod_include "hash.H"
#cmod_undef PIKE_NAME
#cmod_undef NETTLE_NAME
|
c157ac | 2013-11-27 | Arne Goedeke | | #ifdef HAVE_NETTLE_SHA224_INIT
|
0c3c90 | 2013-11-19 | Martin Nilsson | | #cmod_define PIKE_NAME SHA224
#cmod_define NETTLE_NAME sha224
#cmod_include "hash.H"
#cmod_undef PIKE_NAME
#cmod_undef NETTLE_NAME
|
c157ac | 2013-11-27 | Arne Goedeke | | #endif
|
88064b | 2011-12-20 | Henrik Grubbström (Grubba) | | #cmod_define PIKE_NAME SHA256
#cmod_define NETTLE_NAME sha256
#cmod_include "hash.H"
#cmod_undef PIKE_NAME
#cmod_undef NETTLE_NAME
|
098077 | 2003-07-29 | Martin Nilsson | |
|
1ebab8 | 2011-12-20 | Henrik Grubbström (Grubba) | | #ifdef SHA384_DIGEST_SIZE
#cmod_define PIKE_NAME SHA384
#cmod_define NETTLE_NAME sha384
#cmod_include "hash.H"
#cmod_undef PIKE_NAME
#cmod_undef NETTLE_NAME
#endif /* SHA384_DIGEST_SIZE */
#ifdef SHA512_DIGEST_SIZE
#cmod_define PIKE_NAME SHA512
#cmod_define NETTLE_NAME sha512
#cmod_include "hash.H"
#cmod_undef PIKE_NAME
#cmod_undef NETTLE_NAME
#endif /* SHA512_DIGEST_SIZE */
|
0e29b6 | 2013-11-14 | Martin Nilsson | | #ifdef HAVE_NETTLE_SHA3_H
#cmod_define PIKE_NAME SHA3_224
#cmod_define NETTLE_NAME sha3_224
#cmod_include "hash.H"
#cmod_undef PIKE_NAME
#cmod_undef NETTLE_NAME
#cmod_define PIKE_NAME SHA3_256
#cmod_define NETTLE_NAME sha3_256
#cmod_include "hash.H"
#cmod_undef PIKE_NAME
#cmod_undef NETTLE_NAME
#cmod_define PIKE_NAME SHA3_384
#cmod_define NETTLE_NAME sha3_384
#cmod_include "hash.H"
#cmod_undef PIKE_NAME
#cmod_undef NETTLE_NAME
#cmod_define PIKE_NAME SHA3_512
#cmod_define NETTLE_NAME sha3_512
#cmod_include "hash.H"
#cmod_undef PIKE_NAME
#cmod_undef NETTLE_NAME
#endif /* HAVE_NETTLE_SHA3_H */
|
ae4500 | 2013-11-30 | Martin Nilsson | | #ifdef HAVE_NETTLE_RIPEMD160_H
#cmod_define PIKE_NAME RIPEMD160
#cmod_define NETTLE_NAME ripemd160
#cmod_include "hash.H"
#cmod_undef PIKE_NAME
#cmod_undef NETTLE_NAME
#endif
#ifdef HAVE_NETTLE_GOSTHASH94_H
#cmod_define PIKE_NAME GOST94
#cmod_define NETTLE_NAME gosthash94
#cmod_include "hash.H"
#cmod_undef PIKE_NAME
#cmod_undef NETTLE_NAME
#endif
|
411a28 | 2003-03-18 | Niels Möller | | /*! @endmodule Nettle */
|
6d1a54 | 2003-03-13 | Niels Möller | |
void
hash_init(void)
{
werror("Nettle, hash init\n");
INIT;
}
void
hash_exit(void)
{
werror("Nettle, hash exit\n");
EXIT;
}
#endif /* HAVE_LIBNETTLE */
|