You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
132 lines
3.5 KiB
132 lines
3.5 KiB
const ffi = require('ffi');
|
|
const struct = require('ref-struct');
|
|
const ref = require('ref');
|
|
|
|
const Salt = struct({
|
|
'type': 'char',
|
|
'size': 'int',
|
|
'body': 'pointer',
|
|
});
|
|
const PSalt = ref.refType(Salt);
|
|
|
|
const Context = struct({
|
|
'algo': 'char',
|
|
'salt': Salt,
|
|
});
|
|
const PContext = ref.refType(Context);
|
|
const PLong = ref.refType(ref.types.long);
|
|
|
|
const lib = ffi.Library('libkhash', {
|
|
'khash_new_context': ['int', ['char', 'char', 'string', 'long', PContext]],
|
|
'khash_free_context': ['int', [PContext]],
|
|
'khash_clone_context': ['int', [PContext, PContext]],
|
|
|
|
'khash_length': ['int', [PContext, 'string', 'long', PLong]],
|
|
'khash_do': ['int', [PContext, 'string', 'long', 'string', 'long']],
|
|
});
|
|
|
|
const ctx_create = (algo, salt, salt_ref, salt_sz) => {
|
|
let ctx_ptr = ref.alloc(Context);
|
|
lib.khash_new_context(algo, salt, salt_ref, salt_sz, ctx_ptr);
|
|
return ctx_ptr;
|
|
};
|
|
const ctx_free = (ptr) => {
|
|
lib.khash_free_context(ptr);
|
|
return ptr.deref();
|
|
};
|
|
const ctx_clone = (src) => {
|
|
let dst = ref.alloc(Context);
|
|
lib.khash_clone_context(src,dst);
|
|
return dst;
|
|
};
|
|
const khash_length = (ctx, jsstring) => {
|
|
let string = ref.allocCString(jsstring);
|
|
let len = ref.alloc('long');
|
|
lib.khash_length(ctx, string, string.length, len);
|
|
return len.deref();
|
|
};
|
|
const khash_do = (ctx, jsstring, len) => {
|
|
let string = ref.allocCString(jsstring);
|
|
let buffer = Buffer.alloc(len+1);
|
|
lib.khash_do(ctx,string,string.length,buffer,len);
|
|
return ref.readCString(buffer,0);
|
|
};
|
|
|
|
const get_salt_type = (salt) => {
|
|
if (salt && salt.tag) {
|
|
switch(salt.tag)
|
|
{
|
|
case '__NONE':
|
|
return Kana.SALT_NONE;
|
|
case '__RANDOM':
|
|
return Kana.SALT_RANDOM;
|
|
case '__SPECIFIC':
|
|
return Kana.SALT_SPECIFIC;
|
|
default:
|
|
return Kana.SALT_DEFAULT;
|
|
}
|
|
}
|
|
else return Kana.SALT_DEFAULT;
|
|
};
|
|
|
|
/// Create a new kana-hash context.
|
|
/// This context must be disposed of correctly either by calling `finish()` or `once()`.
|
|
/// `algo` is expected to be one of the `Kana.ALGO_*` constants, or `undefined`.
|
|
/// `salt` is expected to be either an object of `Salt` or `undefined`.
|
|
function Kana(algo, salt)
|
|
{
|
|
if(algo && algo.ctx) {
|
|
this.ctx = algo.ctx;
|
|
} else {
|
|
const stype = get_salt_type(salt);
|
|
const fbuffer = salt ? salt.buffer || null : null;
|
|
this.ctx = ctx_create(algo || 0, stype, fbuffer, fbuffer ? fbuffer.length : 0);
|
|
}
|
|
}
|
|
const K = Kana.prototype;
|
|
|
|
/// Free the associated context.
|
|
/// The object is no longer valid after this call.
|
|
K.finish = function() {
|
|
ctx_free(this.ctx);
|
|
this.ctx = null;
|
|
};
|
|
|
|
/// Compute the kana-hash for `string` and then free the associated context.
|
|
K.once = function(string) {
|
|
let len = khash_length(this.ctx, string);
|
|
return khash_do(this.ctx, string, len);
|
|
};
|
|
|
|
/// Compute the kana-hash for `string`.
|
|
K.hash = function(string) {
|
|
const ctx = ctx_clone(this.ctx);
|
|
let len = khash_length(ctx, string);
|
|
return khash_do(ctx, string, len);
|
|
};
|
|
|
|
/// Clone this kana-hash context.
|
|
K.clone = function() {
|
|
const ctx = ctx_clone(this.ctx);
|
|
return new Kana({ctx: ctx});
|
|
};
|
|
|
|
/// The default algorithm used. (sha256 truncated.)
|
|
Kana.ALGO_DEFAULT = 0;
|
|
/// CRC32 algorithm.
|
|
Kana.ALGO_CRC32 = 1;
|
|
/// CRC64 algorithm.
|
|
Kana.ALGO_CRC64 = 2;
|
|
/// SHA256 algorithm.
|
|
Kana.ALGO_SHA256 = 3;
|
|
/// SHA256 truncated to 64-bits.
|
|
Kana.ALGO_SHA256_TRUNCATED = 4;
|
|
|
|
// You don't need to reference these directly, use the `Salt` module instead.
|
|
Kana.SALT_NONE = 0;
|
|
Kana.SALT_DEFAULT = 1;
|
|
Kana.SALT_SPECIFIC = 2;
|
|
Kana.SALT_RANDOM = 3;
|
|
|
|
module.exports = Kana;
|