From 29e4a0512331a36c1cde22ed26c6ae059fa20757 Mon Sep 17 00:00:00 2001 From: "Nicolas \"Pixel\" Noble" Date: Thu, 8 Aug 2013 09:23:03 +0200 Subject: Adding libtommath, libtomcrypt and lcrypt, mainly for the bignum support. --- lcrypt/Makefile | 7 + lcrypt/lcrypt.c | 604 ++++++++++++++++++++++++++++++++++++++++++++++++ lcrypt/lcrypt_bits.c | 234 +++++++++++++++++++ lcrypt/lcrypt_ciphers.c | 403 ++++++++++++++++++++++++++++++++ lcrypt/lcrypt_hashes.c | 211 +++++++++++++++++ lcrypt/lcrypt_math.c | 401 ++++++++++++++++++++++++++++++++ 6 files changed, 1860 insertions(+) create mode 100644 lcrypt/Makefile create mode 100644 lcrypt/lcrypt.c create mode 100644 lcrypt/lcrypt_bits.c create mode 100644 lcrypt/lcrypt_ciphers.c create mode 100644 lcrypt/lcrypt_hashes.c create mode 100644 lcrypt/lcrypt_math.c (limited to 'lcrypt') diff --git a/lcrypt/Makefile b/lcrypt/Makefile new file mode 100644 index 0000000..ea1ac3b --- /dev/null +++ b/lcrypt/Makefile @@ -0,0 +1,7 @@ +CFLAGS += -O3 -Wall -DLITTLE_ENDIAN -DLTM_DESC -DLTC_SOURCE -DUSE_LTM -fPIC -I$(TOMCRYPT)/src/headers -I$(LUA)/src -I../src + +lcrypt.o: lcrypt.c lcrypt_ciphers.c lcrypt_hashes.c lcrypt_math.c lcrypt_bits.c + $(CC) $(CFLAGS) -c lcrypt.c -o $@ + +clean: + rm -f lcrypt.o lcrypt.so diff --git a/lcrypt/lcrypt.c b/lcrypt/lcrypt.c new file mode 100644 index 0000000..d757f11 --- /dev/null +++ b/lcrypt/lcrypt.c @@ -0,0 +1,604 @@ +// gcc -Wall -O3 -shared -fPIC -DLITTLE_ENDIAN -DLTM_DESC -DLTC_SOURCE -DUSE_LTM -I/usr/include/tomcrypt -I/usr/include/tommath -lz -lutil -ltomcrypt -ltommath lcrypt.c -o /usr/lib64/lua/5.1/lcrypt.so +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "lua.h" +#include "lauxlib.h" +#include "lualib.h" +#include +#include + +#ifdef USE_NCIPHER + #include "ncipher.h" + extern NFastApp_Connection nfast_conn; + extern NFast_AppHandle nfast_app; +#else + #include +#endif + +#define likely(x) __builtin_expect((x),1) +#define unlikely(x) __builtin_expect((x),0) + +#define ADD_FUNCTION(L,name) { lua_pushstring(L, #name); lua_pushcfunction(L, lcrypt_ ## name); lua_settable(L, -3); } +#define ADD_CONSTANT(L,name) { lua_pushstring(L, #name); lua_pushinteger(L, name); lua_settable(L, -3); } + +static void lcrypt_error(lua_State *L, int err, void *tofree) +{ + if(unlikely(err != CRYPT_OK)) + { + if(tofree != NULL) free(tofree); + lua_pushstring(L, error_to_string(err)); + (void)lua_error(L); + } +} + +static void* lcrypt_malloc(lua_State *L, size_t size) +{ + void *ret = malloc(size); + if(unlikely(ret == NULL)) + { + lua_pushstring(L, "Out of memory"); + (void)lua_error(L); + } + memset(ret, 0, size); + return ret; +} + +#include "lcrypt_ciphers.c" +#include "lcrypt_hashes.c" +#include "lcrypt_math.c" +#include "lcrypt_bits.c" + +static int lcrypt_tohex(lua_State *L) +{ + const char digits[] = "0123456789ABCDEF"; + size_t in_length = 0, spacer_length = 0, prepend_length = 0; + const unsigned char *in; + const char *spacer, *prepend; + int i, j, pos = 0; + if(unlikely(lua_isnil(L, 1))) { lua_pushlstring(L, "", 0); return 1; } + in = (const unsigned char*)luaL_checklstring(L, 1, &in_length); + if(unlikely(in_length == 0)) { lua_pushlstring(L, "", 0); return 1; } + spacer = luaL_optlstring(L, 2, "", &spacer_length); + prepend = luaL_optlstring(L, 3, "", &prepend_length); + char *result = lcrypt_malloc(L, prepend_length + in_length * 2 + (in_length - 1) * spacer_length); + for(j = 0; j < (int)prepend_length; j++) result[pos++] = prepend[j]; + result[pos++] = digits[(*in >> 4) & 0x0f]; + result[pos++] = digits[*in++ & 0x0f]; + for(i = 1; i < (int)in_length; i++) + { + for(j = 0; j < (int)spacer_length; j++) result[pos++] = spacer[j]; + result[pos++] = digits[(*in >> 4) & 0x0f]; + result[pos++] = digits[*in++ & 0x0f]; + } + lua_pushlstring(L, result, pos); + free(result); + return 1; +} + +static int lcrypt_fromhex(lua_State *L) +{ + size_t in_length; + const unsigned char *in = (const unsigned char*)luaL_checklstring(L, 1, &in_length); + unsigned char result[in_length]; + int i, d = -1, e = -1, pos = 0; + for(i = 0; i < (int)in_length; i++) + { + if(d == -1) + { + if(*in >= '0' && *in <= '9') + d = *in - '0'; + else if(*in >= 'A' && *in <= 'F') + d = *in - 'A' + 10; + else if(*in >= 'a' && *in <= 'f') + d = *in - 'a' + 10; + } + else if(e == -1) + { + if(*in >= '0' && *in <= '9') + e = *in - '0'; + else if(*in >= 'A' && *in <= 'F') + e = *in - 'A' + 10; + else if(*in >= 'a' && *in <= 'f') + e = *in - 'a' + 10; + } + if(d >= 0 && e >= 0) + { + result[pos++] = d << 4 | e; + d = e = -1; + } + in++; + } + lua_pushlstring(L, (char*)result, pos); + return 1; +} + +static int lcrypt_compress(lua_State *L) +{ + int err; + size_t inlen; + const unsigned char *in = (const unsigned char*)luaL_checklstring(L, 1, &inlen); + uLongf outlen = compressBound(inlen); + unsigned char *out = lcrypt_malloc(L, outlen); + if(unlikely((err = compress(out, &outlen, in, inlen)) != Z_OK)) + { + free(out); + lua_pushstring(L, zError(err)); + return lua_error(L); + } + lua_pushlstring(L, (char*)out, outlen); + free(out); + return 1; +} + +static int lcrypt_uncompress(lua_State *L) +{ + int i, err; + size_t inlen; + const unsigned char *in = (const unsigned char*)luaL_checklstring(L, 1, &inlen); + uLongf outlen = inlen << 1; + unsigned char *out = NULL; + for(i = 2; i < 16; i++) + { + out = lcrypt_malloc(L, outlen); + if(likely((err = uncompress(out, &outlen, in, inlen)) == Z_OK)) break; + if(unlikely(err != Z_BUF_ERROR)) + { + free(out); + lua_pushstring(L, zError(err)); + return lua_error(L); + } + free(out); + outlen = inlen << i; + } + if(unlikely(err == Z_BUF_ERROR)) + { + free(out); + lua_pushstring(L, zError(err)); + return lua_error(L); + } + lua_pushlstring(L, (char*)out, outlen); + free(out); + return 1; +} + +static int lcrypt_base64_encode(lua_State *L) +{ + size_t inlen; + const unsigned char *in = (const unsigned char*)luaL_checklstring(L, 1, &inlen); + unsigned long outlen = (inlen + 3) * 4 / 3; + unsigned char *out = malloc(outlen); + if(out == NULL) return 0; + lcrypt_error(L, base64_encode(in, inlen, out, &outlen), out); + lua_pushlstring(L, (char*)out, outlen); + free(out); + return 1; +} + +static int lcrypt_base64_decode(lua_State *L) +{ + size_t inlen; + const unsigned char *in = (const unsigned char*)luaL_checklstring(L, 1, &inlen); + unsigned long outlen = inlen * 3 / 4; + unsigned char *out = malloc(outlen); + if(out == NULL) return 0; + lcrypt_error(L, base64_decode(in, inlen, out, &outlen), out); + lua_pushlstring(L, (char*)out, outlen); + free(out); + return 1; +} + +static int lcrypt_xor(lua_State *L) +{ + int i; + size_t a_length, b_length; + const unsigned char *a = (const unsigned char*)luaL_checklstring(L, 1, &a_length); + const unsigned char *b = (const unsigned char*)luaL_checklstring(L, 2, &b_length); + unsigned char *c = NULL; + if(a_length > b_length) + { + size_t temp = a_length; + a_length = b_length; + b_length = temp; + c = (void*)a; a = b; b = c; + } + c = lcrypt_malloc(L, b_length); + for(i = 0; i < a_length; i++) c[i] = a[i] ^ b[i]; + for(; i < b_length; i++) c[i] = b[i]; + lua_pushlstring(L, (char*)c, b_length); + free(c); + return 1; +} + +static int lcrypt_sleep(lua_State *L) +{ + usleep(1000000.0 * luaL_checknumber(L, 1)); + return(0); +} + +static int lcrypt_time(lua_State *L) +{ + double ret; + struct timeval tv; + gettimeofday(&tv, NULL); + ret = (double)tv.tv_sec + (double)tv.tv_usec / 1000000.0; + lua_pushnumber(L, ret); + return(1); +} + +static int lcrypt_random(lua_State *L) +{ + int len = luaL_checkint(L, 1); + #ifdef USE_NCIPHER + M_Command command; + M_Reply reply; + M_Status rc; + memset(&command, 0, sizeof(command)); + memset(&reply, 0, sizeof(reply)); + command.cmd = Cmd_GenerateRandom; + command.args.generaterandom.lenbytes = len; + if(unlikely((rc = NFastApp_Transact(nfast_conn, NULL, &command, &reply, NULL)) != Status_OK)) + { + lua_pushstring(L, NF_Lookup(rc, NF_Status_enumtable)); + (void)lua_error(L); + } + if(unlikely(reply.status != Status_OK)) + { + lua_pushstring(L, NF_Lookup(reply.status, NF_Status_enumtable)); + (void)lua_error(L); + } + if(unlikely(len != reply.reply.generaterandom.data.len)) + { + lua_pushstring(L, "Wrong length returned"); + (void)lua_error(L); + } + lua_pushlstring(L, reply.reply.generaterandom.data.ptr, len); + NFastApp_Free_Reply(nfast_app, NULL, NULL, &reply); + #else + FILE *fp; + char *buffer = lcrypt_malloc(L, len); + if(unlikely((fp = fopen("/dev/urandom", "rb")) == NULL)) + { + lua_pushstring(L, "Unable to open /dev/urandom."); + (void)lua_error(L); + } + if(unlikely(fread(buffer, len, 1, fp) != 1)) + { + fclose(fp); + lua_pushstring(L, "Unable to read /dev/urandom."); + (void)lua_error(L); + } + fclose(fp); + lua_pushlstring(L, buffer, len); + free(buffer); + #endif + return 1; +} + +static FILE *lgetfile(lua_State *L, int index) +{ + FILE **fp = lua_touserdata(L, index); + if(unlikely(fp == NULL)) return NULL; + if(lua_getmetatable(L, index)) + { + lua_getfield(L, LUA_REGISTRYINDEX, LUA_FILEHANDLE); + if(lua_rawequal(L, -1, -2)) + { + lua_pop(L, 2); + return *fp; + } + lua_pop(L, 2); + } + return NULL; +} + +static int lcrypt_tcsetattr(lua_State* L) +{ + struct termios old, new; + FILE *fp = lgetfile(L, 1); + if(unlikely(fp == NULL)) return 0; + if(unlikely(tcgetattr(fileno(fp), &old) != 0)) return 0; + new = old; + new.c_iflag = luaL_optint(L, 2, old.c_iflag); + new.c_oflag = luaL_optint(L, 3, old.c_oflag); + new.c_cflag = luaL_optint(L, 4, old.c_cflag); + new.c_lflag = luaL_optint(L, 5, old.c_lflag); + if(unlikely(tcsetattr(fileno(fp), TCSAFLUSH, &new) != 0)) return 0; + lua_pushinteger(L, new.c_iflag); + lua_pushinteger(L, new.c_oflag); + lua_pushinteger(L, new.c_cflag); + lua_pushinteger(L, new.c_lflag); + return 4; +} + +static int lcrypt_flag_add(lua_State *L) +{ + uint32_t a = luaL_checkint(L, 1); + uint32_t b = luaL_checkint(L, 2); + lua_pushinteger(L, a | b); + return 1; +} + +static int lcrypt_flag_remove(lua_State *L) +{ + uint32_t a = luaL_checkint(L, 1); + uint32_t b = luaL_checkint(L, 2); + lua_pushinteger(L, a & ~b); + return 1; +} + +#ifndef USE_NCIPHER + +typedef struct +{ + int fd; + int pid; + char *command; +} lcrypt_spawn_t; + +static int lcrypt_spawn(lua_State *L) +{ + int fd, pid, argc; + #define MAX_ARGUMENT 128 + const char *command = luaL_checkstring(L, 1); + char *cmd = strdup(command); + char *pos = cmd, *p; + char *argv[MAX_ARGUMENT]; + for(argc = 0; argc < MAX_ARGUMENT-1; argc++) + { + // eat whitespace + while(*pos == ' ' || *pos == '\t' || *pos == '\n' || *pos == '\r') + { + if(*pos == '\\') for(p = pos; *p != '\0'; p++) *p = *(p + 1); + pos++; + } + // start of argument found + argv[argc] = pos; + if(*argv[argc] == '"' || *argv[argc] == '\'') // quoted argument + { + pos++; + while(*pos != *argv[argc] && *pos != '\0') + { + if(*pos == '\\') for(p = pos; *p != '\0'; p++) *p = *(p + 1); + pos++; + } + argv[argc]++; + } + else // non-quoted argument + { + while(*pos != ' ' && *pos != '\t' && *pos != '\n' && *pos != '\r' && *pos != '\0') + { + if(*pos == '\\') for(p = pos; *p != '\0'; p++) *p = *(p + 1); + pos++; + } + } + if(*pos == '\0') break; + *pos++ = '\0'; + } + argv[++argc] = NULL; + + errno = 0; + pid = forkpty(&fd, NULL, NULL, NULL); + if(pid == 0) // child + { + execvp(argv[0], argv); + // if we get here, it's an error! + perror("'unable to spawn process"); + return 0; + } + else if(errno != 0) + { + lua_pushnil(L); + lua_pushstring(L, strerror(errno)); + return 2; + } + else + { + lcrypt_spawn_t *lsp = lua_newuserdata(L, sizeof(lcrypt_spawn_t)); + lsp->fd = fd; + lsp->pid = pid; + lsp->command = cmd; + luaL_getmetatable(L, "LSPAWN"); + (void)lua_setmetatable(L, -2); + return 1; + } +} + +static int lcrypt_spawn_close(lua_State *L) +{ + lcrypt_spawn_t *lsp = (lcrypt_spawn_t*)luaL_checkudata(L, 1, "LSPAWN"); + if(lsp->pid > 0) + { + (void)kill(lsp->pid, SIGQUIT); + lsp->pid = -1; + } + if(lsp->fd >= 0) + { + (void)close(lsp->fd); + lsp->fd = -1; + } + if(lsp->command != NULL) + { + free(lsp->command); + lsp->command = NULL; + } + return 0; +} + +static int lcrypt_spawn_read(lua_State *L) +{ + lcrypt_spawn_t *lsp = (lcrypt_spawn_t*)luaL_checkudata(L, 1, "LSPAWN"); + int count = luaL_optint(L, 2, 4096); + char *buffer; + if(lsp->fd < 0) + { + lua_pushstring(L, "Spawn closed"); + lua_error(L); + return 0; + } + if((buffer = malloc(count)) == NULL) + { + lua_pushnil(L); + lua_pushstring(L, "Unable to allocate memory"); + return 2; + } + count = read(lsp->fd, buffer, count); + if(errno != 0) + { + free(buffer); + lua_pushnil(L); + lua_pushstring(L, strerror(errno)); + return 2; + } + lua_pushlstring(L, buffer, count); + free(buffer); + return 1; +} + +static int lcrypt_spawn_write(lua_State *L) +{ + lcrypt_spawn_t *lsp = (lcrypt_spawn_t*)luaL_checkudata(L, 1, "LSPAWN"); + size_t in_length = 0; + const char* in = luaL_checklstring(L, 2, &in_length); + if(lsp->fd < 0) + { + lua_pushstring(L, "closed"); + lua_error(L); + return 0; + } + write(lsp->fd, in, in_length); + if(errno != 0) + { + lua_pushstring(L, strerror(errno)); + return 1; + } + return 0; +} + +static int lcrypt_spawn_index(lua_State *L) +{ + (void)luaL_checkudata(L, 1, "LSPAWN"); + const char *index = luaL_checkstring(L, 2); + if(strcmp(index, "read") == 0) + lua_pushcfunction(L, lcrypt_spawn_read); + else if(strcmp(index, "write") == 0) + lua_pushcfunction(L, lcrypt_spawn_write); + else if(strcmp(index, "close") == 0) + lua_pushcfunction(L, lcrypt_spawn_close); + else + return 0; + return 1; +} + +static const luaL_Reg lcrypt_spawn_flib[] = +{ + {"__gc", lcrypt_spawn_close}, + {NULL, NULL} +}; + +#endif + +static const luaL_Reg lcryptlib[] = +{ + {"tohex", lcrypt_tohex}, + {"fromhex", lcrypt_fromhex}, + {"compress", lcrypt_compress}, + {"uncompress", lcrypt_uncompress}, + {"base64_encode", lcrypt_base64_encode}, + {"base64_decode", lcrypt_base64_decode}, + {"xor", lcrypt_xor}, + {"sleep", lcrypt_sleep}, + {"time", lcrypt_time}, + {"random", lcrypt_random}, + {"tcsetattr", lcrypt_tcsetattr}, + {"flag_add", lcrypt_flag_add}, + {"flag_remove", lcrypt_flag_remove}, + #ifndef USE_NCIPHER + {"spawn", lcrypt_spawn}, + #endif + {NULL, NULL} +}; + +int luaopen_lcrypt(lua_State *L); +int luaopen_lcrypt(lua_State *L) +{ + luaL_register(L, "lcrypt", lcryptlib); + + #ifndef USE_NCIPHER + (void)luaL_newmetatable(L, "LSPAWN"); + lua_pushliteral(L, "__index"); + lua_pushcfunction(L, lcrypt_spawn_index); + lua_rawset(L, -3); + luaL_register(L, NULL, lcrypt_spawn_flib); + #endif + + lua_getglobal(L, "lcrypt"); + + lcrypt_start_ciphers(L); + lcrypt_start_hashes(L); + lcrypt_start_math(L); + lcrypt_start_bits(L); + + lua_pushstring(L, "iflag"); + lua_newtable(L); + ADD_CONSTANT(L, IGNBRK); ADD_CONSTANT(L, BRKINT); ADD_CONSTANT(L, IGNPAR); ADD_CONSTANT(L, PARMRK); + ADD_CONSTANT(L, INPCK); ADD_CONSTANT(L, ISTRIP); ADD_CONSTANT(L, INLCR); ADD_CONSTANT(L, IGNCR); + ADD_CONSTANT(L, ICRNL); ADD_CONSTANT(L, IXON); ADD_CONSTANT(L, IXANY); ADD_CONSTANT(L, IXOFF); + lua_settable(L, -3); + + lua_pushstring(L, "oflag"); + lua_newtable(L); + #ifdef OLCUC + ADD_CONSTANT(L, OLCUC); + #endif + #ifdef OFILL + ADD_CONSTANT(L, OFILL); + #endif + #ifdef OFDEL + ADD_CONSTANT(L, OFDEL); + #endif + #ifdef NLDLY + ADD_CONSTANT(L, NLDLY); + #endif + #ifdef CRDLY + ADD_CONSTANT(L, CRDLY); + #endif + #ifdef TABDLY + ADD_CONSTANT(L, TABDLY); + #endif + #ifdef BSDLY + ADD_CONSTANT(L, BSDLY); + #endif + #ifdef VTDLY + ADD_CONSTANT(L, VTDLY); + #endif + #ifdef FFDLY + ADD_CONSTANT(L, FFDLY); + #endif + ADD_CONSTANT(L, OPOST); ADD_CONSTANT(L, ONLCR); ADD_CONSTANT(L, OCRNL); ADD_CONSTANT(L, ONOCR); + ADD_CONSTANT(L, ONLRET); + lua_settable(L, -3); + + lua_pushstring(L, "cflag"); + lua_newtable(L); + ADD_CONSTANT(L, CS5); ADD_CONSTANT(L, CS6); ADD_CONSTANT(L, CS7); ADD_CONSTANT(L, CS8); + ADD_CONSTANT(L, CSTOPB); ADD_CONSTANT(L, CREAD); ADD_CONSTANT(L, PARENB); ADD_CONSTANT(L, PARODD); + ADD_CONSTANT(L, HUPCL); ADD_CONSTANT(L, CLOCAL); + lua_settable(L, -3); + + lua_pushstring(L, "lflag"); + lua_newtable(L); + ADD_CONSTANT(L, ISIG); ADD_CONSTANT(L, ICANON); ADD_CONSTANT(L, ECHO); ADD_CONSTANT(L, ECHOE); + ADD_CONSTANT(L, ECHOK); ADD_CONSTANT(L, ECHONL); ADD_CONSTANT(L, NOFLSH); ADD_CONSTANT(L, TOSTOP); + ADD_CONSTANT(L, IEXTEN); + lua_settable(L, -3); + + lua_pop(L, 1); + return 1; +} diff --git a/lcrypt/lcrypt_bits.c b/lcrypt/lcrypt_bits.c new file mode 100644 index 0000000..0ea7851 --- /dev/null +++ b/lcrypt/lcrypt_bits.c @@ -0,0 +1,234 @@ +#include + +static void copy_bits(uint8_t *out, unsigned int out_pos, const uint8_t *in, unsigned int in_pos, unsigned int length) +{ + unsigned int offset, chunk_size; + uint8_t temp, mask; + + // skip untouched out bytes + offset = out_pos / 8; + out += offset; + out_pos -= offset * 8; + + // skip untouched in bytes + offset = in_pos / 8; + in += offset; + in_pos -= offset * 8; + + while(length > 0) + { + chunk_size = (in_pos < out_pos) ? 8 - out_pos : 8 - in_pos; + if(chunk_size == 0) chunk_size = 8; + if(chunk_size > length) chunk_size = length; + + temp = ((*in) << in_pos); + temp >>= out_pos; + mask = 0xff << (8 - chunk_size); + mask = /*0xff ^*/ (mask >> out_pos); + *out |= mask & temp; + + in_pos += chunk_size; + if(in_pos >= 8) + { + in++; + in_pos -= 8; + } + out_pos += chunk_size; + if(out_pos >= 8) + { + out++; + out_pos -= 8; + } + length -= chunk_size; + } +} + +static void reverse_data(uint8_t *a, int len) +{ + int i; + uint8_t temp; + for(i = len / 2 - 1; i >= 0; i--) + { + temp = a[i]; + a[i] = a[len-1-i]; + a[len-1-i] = temp; + } +} + +static uint64_t reverse_bits(uint64_t a, int bits) +{ + int i; + uint64_t b = 0; + for(i = 0; i < bits; i++) + { + b = (b << 1) | (a & 1); + a >>= 1; + } + return b; +} + +static int64_t sign_extend(uint64_t a, int bits) +{ + int64_t sret;; + if((a & (1 << (bits - 1))) != 0) + { + a = ((uint64_t)0xffffffffffffffffLL << bits) | a; + memcpy(&sret, &a, 8); + return sret; + } + return a; +} + +#define B_SKIP 0 +#define B_STR 1 +#define B_INT 2 +#define B_LSB 4 +#define B_LE 8 +#define B_SIGN 16 + +#define BSKIP B_SKIP +#define BSTR B_STR +#define BMSB B_INT +#define BLSB (B_INT|B_LSB) +#define BLE (B_INT|B_LE) +#define BSMSB (B_INT|B_SIGN) +#define BSLSB (B_INT|B_LSB|B_SIGN) +#define BSLE (B_INT|B_LE|B_SIGN) + +#if BYTE_ORDER == LITTLE_ENDIAN + #define BMO BLE + #define BSMO BSLE +#else + #define BMO BMSB + #define BSMO BSMSB +#endif + +static int lcrypt_bget(lua_State *L) +{ + int count = 0, argc = lua_gettop(L); + size_t length; + const unsigned char *in = (const unsigned char*)luaL_checklstring(L, 1, &length); + int i, type, bits, offset = luaL_checkint(L, 2); + length *= 8; + for(i = 3; i <= argc && offset < (int)length; i += 2) + { + type = luaL_checkint(L, i); + if(i+1 > argc) + bits = length; + else + bits = luaL_checkint(L, i+1); + + if(offset + bits > (int)length) bits = length - offset; + if(type == B_SKIP) + { + count--; + } + else if(type == B_STR) + { + int len = (bits + 7) / 8; + uint8_t data[len]; + memset(data, 0, len); + copy_bits(data, 0, in, offset, bits); + lua_pushlstring(L, (char*)data, len); + } + else // integer + { + uint64_t ret = 0; + copy_bits((uint8_t*)&ret, sizeof(ret) * 8 - bits, in, offset, bits); + #if BYTE_ORDER == LITTLE_ENDIAN + reverse_data((uint8_t*)&ret, sizeof(ret)); + #endif + if((type & B_LSB) == B_LSB) ret = reverse_bits(ret, bits); + #if BYTE_ORDER == LITTLE_ENDIAN + if((type & B_LE) == B_LE) reverse_data((uint8_t*)&ret, (bits+7)/8); + #else + if((type & B_LE) == B_LE) reverse_data((uint8_t*)&ret + 8-(bits+7)/8, (bits+7)/8); + #endif + if((type & B_SIGN) == B_SIGN) + lua_pushnumber(L, sign_extend(ret, bits)); + else + lua_pushnumber(L, ret); + } + count++; + offset += bits; + } + return count; +} + +static int lcrypt_bput(lua_State *L) +{ + int argc = lua_gettop(L); + int i, type, bits = 0, offset = 0, len = 0; + size_t length; + for(i = 1; i <= argc; i += 3) + { + type = luaL_checkint(L, i+1); + if(type == B_STR && lua_isnil(L, i+2) == 1) + { + (void)luaL_checklstring(L, i, &length); + bits = (lua_isnil(L, i+2) == 1) ? length * 8 : luaL_checkint(L, i+2); + if(bits > (int)length * 8) bits = length * 8; + } + else + { + bits = luaL_checkint(L, i+2); + } + len += bits; + } + len = (len + 7) / 8; + uint8_t ret[len]; + memset(ret, 0, len); + + for(i = 1; i <= argc; i += 3) + { + type = luaL_checkint(L, i+1); + if(type == B_STR) + { + const uint8_t *in = (const uint8_t *)luaL_checklstring(L, i, &length); + bits = (lua_isnil(L, i+2) == 1) ? length * 8 : luaL_checkint(L, i+2); + if(bits > (int)length * 8) bits = length * 8; + copy_bits(ret, offset, in, 0, bits); + } + else if(type != B_SKIP) // integer + { + uint64_t in; + bits = luaL_checkint(L, i+2); + if((type & B_SIGN) == B_SIGN) + { + int64_t sin = luaL_checknumber(L, i); + memcpy(&in, &sin, 8); + } + else + { + in = luaL_checknumber(L, i); + } + #if BYTE_ORDER == LITTLE_ENDIAN + reverse_data((uint8_t*)&in, sizeof(in)); + #endif + + if((type & B_LSB) == B_LSB) + { + in = reverse_bits(in, 64); + copy_bits(ret, offset, (uint8_t*)&in, 0, bits); + } + else if((type & B_LE) == B_LE) + { + reverse_data((uint8_t*)&in, sizeof(in)); + copy_bits(ret, offset, (uint8_t*)&in, 0, bits); + } + else + copy_bits(ret, offset, (uint8_t*)&in, sizeof(in) * 8 - bits, bits); + } + offset += bits; + } + lua_pushlstring(L, (char*)ret, len); + return 1; +} + +static void lcrypt_start_bits(lua_State *L) +{ + ADD_FUNCTION(L, bget); ADD_FUNCTION(L, bput); + ADD_CONSTANT(L, BSKIP); ADD_CONSTANT(L, BSTR); ADD_CONSTANT(L, BMSB); ADD_CONSTANT(L, BLSB); + ADD_CONSTANT(L, BLE); ADD_CONSTANT(L, BSMSB); ADD_CONSTANT(L, BSLSB); ADD_CONSTANT(L, BSLE); + ADD_CONSTANT(L, BMO); ADD_CONSTANT(L, BSMO); +} diff --git a/lcrypt/lcrypt_ciphers.c b/lcrypt/lcrypt_ciphers.c new file mode 100644 index 0000000..dc8c47b --- /dev/null +++ b/lcrypt/lcrypt_ciphers.c @@ -0,0 +1,403 @@ +static void lcrypt_ivlength(lua_State *L, int cipher, size_t *iv_length) +{ + if(unlikely(*iv_length < (size_t)cipher_descriptor[cipher].block_length)) + { + lua_pushstring(L, "IV wrong length"); + (void)lua_error(L); + } + *iv_length = (size_t)cipher_descriptor[cipher].block_length; +} + +#define LCRYPT_CIPHER_XXX_START(NAME, name) \ +static int lcrypt_cipher_ ## name (lua_State *L) \ +{ \ + symmetric_ ## NAME *skey; \ + int err = CRYPT_OK, *cipher = luaL_checkudata(L, 1, "LCRYPT_CIPHER"); \ + size_t key_length, iv_length; \ + const unsigned char *key = (const unsigned char *)luaL_checklstring(L, 2, &key_length); \ + const unsigned char *iv = (const unsigned char *)luaL_checklstring(L, 3, &iv_length); \ + lcrypt_ivlength(L, *cipher, &iv_length); \ + skey = lua_newuserdata(L, sizeof(symmetric_ ## NAME)); \ + luaL_getmetatable(L, "LCRYPT_CIPHER_" #NAME); \ + (void)lua_setmetatable(L, -2); \ + memset(skey, 0, sizeof(symmetric_ ## NAME)); \ + if(unlikely((err = name ## _start(*cipher, iv, key, (int)key_length, 0, skey)) != CRYPT_OK)) \ + { \ + skey->cipher = -1; \ + lcrypt_error(L, err, NULL); \ + } \ + return 1; \ +} + +#define LCRYPT_CIPHER_XXX_INDEX(NAME, _name) \ +static int lcrypt_cipher_ ## _name ## _index(lua_State *L) \ +{ \ + symmetric_ ## NAME *skey = luaL_checkudata(L, 1, "LCRYPT_CIPHER_" #NAME); \ + if(unlikely(skey->cipher < 0)) return 0; \ + const char *index = luaL_checkstring(L, 2); \ + if(strcmp(index, "type") == 0) { lua_pushstring(L, "LCRYPT_CIPHER_" #NAME); return 1; } \ + if(strcmp(index, "iv") == 0) \ + { \ + unsigned char iv[MAXBLOCKSIZE]; \ + unsigned long length = MAXBLOCKSIZE; \ + lcrypt_error(L, _name ## _getiv(iv, &length, skey), NULL); \ + lua_pushlstring(L, (char*)iv, (size_t)length); \ + return 1; \ + } \ + if(strcmp(index, "block_size") == 0) \ + { \ + lua_pushinteger(L, cipher_descriptor[skey->cipher].block_length); \ + return 1; \ + } \ + if(strcmp(index, "encrypt") == 0) \ + { \ + lua_pushcfunction(L, lcrypt_cipher_ ## _name ## _encrypt); \ + return 1; \ + } \ + if(strcmp(index, "decrypt") == 0) \ + { \ + lua_pushcfunction(L, lcrypt_cipher_ ## _name ## _decrypt); \ + return 1; \ + } \ + if(strcmp(index, "cipher_name") == 0) \ + { \ + lua_pushstring(L, cipher_descriptor[skey->cipher].name); \ + return 1; \ + } \ + if(strcmp(index, "mode_name") == 0) \ + { \ + lua_pushstring(L, #_name); \ + return 1; \ + } \ + return 0; \ +} + +#define LCRYPT_CIPHER_XXX_NEWINDEX(NAME, name) \ +static int lcrypt_cipher_ ## name ## _newindex(lua_State *L) \ +{ \ + symmetric_ ## NAME *skey = luaL_checkudata(L, 1, "LCRYPT_CIPHER_" #NAME); \ + size_t v_length = 0; \ + const char *index = luaL_checkstring(L, 2); \ + const unsigned char *v = (const unsigned char *)luaL_checklstring(L, 3, &v_length); \ + if(unlikely(skey->cipher < 0)) return 0; \ + if(strcmp(index, "iv") == 0) \ + { \ + lcrypt_error(L, name ## _setiv(v, v_length, skey), NULL); \ + } \ + return 0; \ +} + +#define LCRYPT_CIPHER_XXX_GC(NAME, name) \ +static int lcrypt_cipher_ ## name ## _gc(lua_State *L) \ +{ \ + symmetric_ ## NAME *skey = luaL_checkudata(L, 1, "LCRYPT_CIPHER_" #NAME); \ + if(likely(skey->cipher != -1)) lcrypt_error(L, name ## _done(skey), NULL); \ + return 0; \ +} + +#define LCRYPT_CIPHER_XXX_ENCRYPT(NAME, name) \ +static int lcrypt_cipher_ ## name ## _encrypt(lua_State *L) \ +{ \ + symmetric_ ## NAME *skey = luaL_checkudata(L, 1, "LCRYPT_CIPHER_" #NAME); \ + if(likely(skey->cipher >= 0)) \ + { \ + size_t in_length = 0; \ + const unsigned char *in = (const unsigned char *)luaL_checklstring(L, 2, &in_length); \ + int i, block_length = cipher_descriptor[skey->cipher].block_length; \ + int padding_length = in_length + block_length - in_length % block_length; \ +printf("in_length = %d, padding_length = %d\n", in_length, padding_length); \ + unsigned char *out = lcrypt_malloc(L, 2 * (in_length + padding_length)); \ + memcpy(out + in_length + padding_length, in, in_length); \ + memset(out + in_length + padding_length + in_length, padding_length, padding_length); \ + in = out + in_length + padding_length; \ + for(i = 0; i < in_length + padding_length; i += block_length) \ + { \ + lcrypt_error(L, name ## _encrypt(in + i, out + i, block_length, skey), out); \ + } \ + lua_pushlstring(L, (char*)out, in_length + padding_length); \ + free(out); \ + return 1; \ + } \ + return 0; \ +} + +#define LCRYPT_CIPHER_XXX_DECRYPT(NAME, name) \ +static int lcrypt_cipher_ ## name ## _decrypt(lua_State *L) \ +{ \ + symmetric_ ## NAME *skey = luaL_checkudata(L, 1, "LCRYPT_CIPHER_" #NAME); \ + if(likely(skey->cipher >= 0)) \ + { \ + size_t in_length = 0; \ + const unsigned char *in = (const unsigned char *)luaL_checklstring(L, 2, &in_length); \ + unsigned char *out = lcrypt_malloc(L, in_length); \ + lcrypt_error(L, name ## _decrypt(in, out, in_length, skey), out); \ + in_length -= out[in_length - 1]; \ + lua_pushlstring(L, (char*)out, in_length); \ + free(out); \ + return 1; \ + } \ + return 0; \ +} + +#define LCRYPT_CIPHER_XXX(NAME, name) \ + LCRYPT_CIPHER_XXX_START(NAME, name) \ + LCRYPT_CIPHER_XXX_NEWINDEX(NAME, name) \ + LCRYPT_CIPHER_XXX_GC(NAME, name) \ + LCRYPT_CIPHER_XXX_ENCRYPT(NAME, name) \ + LCRYPT_CIPHER_XXX_DECRYPT(NAME, name) \ + LCRYPT_CIPHER_XXX_INDEX(NAME, name) + +static int lcrypt_cipher_ecb(lua_State *L) +{ + int err = CRYPT_OK, *cipher = luaL_checkudata(L, 1, "LCRYPT_CIPHER"); + size_t key_length; + const unsigned char *key = (const unsigned char *)luaL_checklstring(L, 2, &key_length); + symmetric_ECB *skey = lua_newuserdata(L, sizeof(symmetric_ECB)); + memset(skey, 0, sizeof(symmetric_ECB)); + luaL_getmetatable(L, "LCRYPT_CIPHER_ECB"); + (void)lua_setmetatable(L, -2); + if(unlikely((err = ecb_start(*cipher, key, (int)key_length, 0, skey)) != CRYPT_OK)) + { + skey->cipher = -1; + lcrypt_error(L, err, NULL); + } + return 1; +} + +LCRYPT_CIPHER_XXX_ENCRYPT(ECB, ecb) +LCRYPT_CIPHER_XXX_DECRYPT(ECB, ecb) + +static int lcrypt_cipher_ecb_index(lua_State *L) +{ + symmetric_ECB *skey = luaL_checkudata(L, 1, "LCRYPT_CIPHER_ECB"); + const char *index = luaL_checkstring(L, 2); + if(unlikely(skey->cipher < 0)) return 0; + if(strcmp(index, "type") == 0) { lua_pushstring(L, "LCRYPT_CIPHER_ECB"); return 1; } + if(strcmp(index, "encrypt") == 0) + { + lua_pushcfunction(L, lcrypt_cipher_ecb_encrypt); + return 1; + } + if(strcmp(index, "decrypt") == 0) + { + lua_pushcfunction(L, lcrypt_cipher_ecb_decrypt); + return 1; + } + if(strcmp(index, "cipher_name") == 0) + { + lua_pushstring(L, cipher_descriptor[skey->cipher].name); + return 1; + } + if(strcmp(index, "mode_name") == 0) + { + lua_pushstring(L, "ecb"); + return 1; + } + return 0; +} + +static int lcrypt_cipher_ecb_newindex(lua_State *L) +{ + luaL_checkudata(L, 1, "LCRYPT_CIPHER_ECB"); + return 0; +} + +LCRYPT_CIPHER_XXX_GC(ECB, ecb) + +static int lcrypt_cipher_ctr(lua_State *L) +{ + symmetric_CTR *skey; + int err = CRYPT_OK, *cipher = luaL_checkudata(L, 1, "LCRYPT_CIPHER"); + size_t key_length, iv_length; + const unsigned char *key = (const unsigned char *)luaL_checklstring(L, 2, &key_length); + const unsigned char *iv = (const unsigned char *)luaL_checklstring(L, 3, &iv_length); + const char *endian = luaL_optstring(L, 4, "big"); + lcrypt_ivlength(L, *cipher, &iv_length); + skey = lua_newuserdata(L, sizeof(symmetric_CTR)); + memset(skey, 0, sizeof(symmetric_CTR)); + luaL_getmetatable(L, "LCRYPT_CIPHER_CTR"); + (void)lua_setmetatable(L, -2); + if(strcmp(endian, "big") == 0) + { + err = ctr_start(*cipher, iv, key, (int)key_length, 0, CTR_COUNTER_BIG_ENDIAN, skey); + } + else if(strcmp(endian, "little") == 0) + { + err = ctr_start(*cipher, iv, key, (int)key_length, 0, CTR_COUNTER_LITTLE_ENDIAN, skey); + } + else + { + lua_pushstring(L, "Unknown endian"); + (void)lua_error(L); + } + if(unlikely(err != CRYPT_OK)) + { + skey->cipher = -1; + lcrypt_error(L, err, NULL); + } + return 1; +} + +LCRYPT_CIPHER_XXX_ENCRYPT(CTR, ctr) +LCRYPT_CIPHER_XXX_DECRYPT(CTR, ctr) +LCRYPT_CIPHER_XXX_INDEX(CTR, ctr) +LCRYPT_CIPHER_XXX_NEWINDEX(CTR, ctr) +LCRYPT_CIPHER_XXX_GC(CTR, ctr) + +LCRYPT_CIPHER_XXX(CBC, cbc) +LCRYPT_CIPHER_XXX(CFB, cfb) +LCRYPT_CIPHER_XXX(OFB, ofb) + +static int lcrypt_cipher_lrw(lua_State *L) +{ + symmetric_LRW *skey; + int err = CRYPT_OK, *cipher = luaL_checkudata(L, 1, "LCRYPT_CIPHER"); + size_t key_length, iv_length, tweak_length; + const unsigned char *key = (const unsigned char *)luaL_checklstring(L, 2, &key_length); + const unsigned char *iv = (const unsigned char *)luaL_checklstring(L, 3, &iv_length); + const unsigned char *tweak = (const unsigned char *)luaL_checklstring(L, 4, &tweak_length); + if(unlikely(tweak_length != 16)) + { + lua_pushstring(L, "Tweak must be 16 characters"); + (void)lua_error(L); + } + lcrypt_ivlength(L, *cipher, &iv_length); + skey = lua_newuserdata(L, sizeof(symmetric_LRW)); + memset(skey, 0, sizeof(symmetric_LRW)); + luaL_getmetatable(L, "LCRYPT_CIPHER_LRW"); + (void)lua_setmetatable(L, -2); + if(unlikely((err = lrw_start(*cipher, iv, key, (int)key_length, tweak, 0, skey)) != CRYPT_OK)) + { + skey->cipher = -1; + lcrypt_error(L, err, NULL); + } + return 1; +} + +LCRYPT_CIPHER_XXX_ENCRYPT(LRW, lrw) +LCRYPT_CIPHER_XXX_DECRYPT(LRW, lrw) +LCRYPT_CIPHER_XXX_INDEX(LRW, lrw) +LCRYPT_CIPHER_XXX_NEWINDEX(LRW, lrw) +LCRYPT_CIPHER_XXX_GC(LRW, lrw) + +static int lcrypt_cipher_f8(lua_State *L) +{ + symmetric_F8 *skey; + int err = CRYPT_OK, *cipher = luaL_checkudata(L, 1, "LCRYPT_CIPHER"); + size_t key_length, iv_length, salt_length; + const unsigned char *key = (const unsigned char *)luaL_checklstring(L, 2, &key_length); + const unsigned char *iv = (const unsigned char *)luaL_checklstring(L, 3, &iv_length); + const unsigned char *salt = (const unsigned char *)luaL_checklstring(L, 4, &salt_length); + lcrypt_ivlength(L, *cipher, &iv_length); + skey = lua_newuserdata(L, sizeof(symmetric_F8)); + memset(skey, 0, sizeof(symmetric_F8)); + luaL_getmetatable(L, "LCRYPT_CIPHER_F8"); + (void)lua_setmetatable(L, -2); + if(unlikely((err = f8_start(*cipher, iv, key, (int)key_length, salt, salt_length, 0, skey)) != CRYPT_OK)) + { + skey->cipher = -1; + lcrypt_error(L, err, NULL); + } + return 1; +} + +LCRYPT_CIPHER_XXX_ENCRYPT(F8, f8) +LCRYPT_CIPHER_XXX_DECRYPT(F8, f8) +LCRYPT_CIPHER_XXX_INDEX(F8, f8) +LCRYPT_CIPHER_XXX_NEWINDEX(F8, f8) +LCRYPT_CIPHER_XXX_GC(F8, f8) + +#undef LCRYPT_CIPHER_XXX +#undef LCRYPT_CIPHER_XXX_START +#undef LCRYPT_CIPHER_XXX_INDEX +#undef LCRYPT_CIPHER_XXX_NEWINDEX +#undef LCRYPT_CIPHER_XXX_GC + + +static int lcrypt_cipher_key_size(lua_State *L) +{ + int *cipher = luaL_checkudata(L, 1, "LCRYPT_CIPHER"); + int keysize = luaL_checkint(L, 2); + lcrypt_error(L, cipher_descriptor[*cipher].keysize(&keysize), NULL); + lua_pushinteger(L, keysize); + return 1; +} + +static int lcrypt_cipher_index(lua_State *L) +{ + int *cipher = luaL_checkudata(L, 1, "LCRYPT_CIPHER"); + const char *index = luaL_checkstring(L, 2); + + #define RETURN_BLOCK_MODE(name) { if(strcmp(index, #name) == 0) { lua_pushcfunction(L, lcrypt_cipher_ ## name); return 1; } } + RETURN_BLOCK_MODE(ecb); RETURN_BLOCK_MODE(cbc); RETURN_BLOCK_MODE(ctr); RETURN_BLOCK_MODE(cfb); + RETURN_BLOCK_MODE(ofb); RETURN_BLOCK_MODE(f8); + if(cipher_descriptor[*cipher].block_length == 16) RETURN_BLOCK_MODE(lrw); + #undef RETURN_BLOCK_MODE + + if(strcmp(index, "type") == 0) { lua_pushstring(L, "LCRYPT_CIPHER"); return 1; } + if(strcmp(index, "name") == 0) { lua_pushstring(L, cipher_descriptor[*cipher].name); return 1; } + if(strcmp(index, "min_key_length") == 0) { lua_pushinteger(L, cipher_descriptor[*cipher].min_key_length); return 1; } + if(strcmp(index, "max_key_length") == 0) { lua_pushinteger(L, cipher_descriptor[*cipher].max_key_length); return 1; } + if(strcmp(index, "block_length") == 0) { lua_pushinteger(L, cipher_descriptor[*cipher].block_length); return 1; } + if(strcmp(index, "key_size") == 0) { lua_pushcfunction(L, lcrypt_cipher_key_size); return 1; } + if(strcmp(index, "modes") == 0) + { + lua_newtable(L); + #define ADD_MODE(i, name) { lua_pushinteger(L, i); lua_pushstring(L, #name); lua_settable(L, -3); } + ADD_MODE(1, ecb); ADD_MODE(2, cbc); ADD_MODE(3, ctr); ADD_MODE(4, cfb); + ADD_MODE(5, ofb); ADD_MODE(6, f8); + if(cipher_descriptor[*cipher].block_length == 16) ADD_MODE(7, lrw); + #undef ADD_MODE + return 1; + } + + return 0; +} + +static const struct luaL_reg lcrypt_cipher_flib[] = +{ + { "__index", lcrypt_cipher_index }, + { NULL, NULL } +}; + +#define CIPHER_MODE_FLIB(mode) \ +static const struct luaL_reg lcrypt_cipher_ ## mode ## _flib[] = \ +{ \ + { "__index", lcrypt_cipher_ ## mode ## _index }, \ + { "__newindex", lcrypt_cipher_ ## mode ## _newindex }, \ + { "__gc", lcrypt_cipher_ ## mode ## _gc }, \ + { NULL, NULL } \ +}; +CIPHER_MODE_FLIB(ecb); CIPHER_MODE_FLIB(cbc); CIPHER_MODE_FLIB(ctr); +CIPHER_MODE_FLIB(cfb); CIPHER_MODE_FLIB(ofb); CIPHER_MODE_FLIB(f8); +CIPHER_MODE_FLIB(lrw); +#undef CIPHER_MODE_FLIB + +static void lcrypt_start_ciphers(lua_State *L) +{ + (void)luaL_newmetatable(L, "LCRYPT_CIPHER"); (void)luaL_register(L, NULL, lcrypt_cipher_flib); lua_pop(L, 1); + lua_pushstring(L, "ciphers"); + lua_newtable(L); + #define ADD_CIPHER(L,name) \ + { \ + lua_pushstring(L, #name); \ + int *cipher_index = lua_newuserdata(L, sizeof(int)); \ + luaL_getmetatable(L, "LCRYPT_CIPHER"); \ + (void)lua_setmetatable(L, -2); \ + *cipher_index = register_cipher(&name ## _desc); \ + lua_settable(L, -3); \ + } + ADD_CIPHER(L, blowfish); ADD_CIPHER(L, xtea); ADD_CIPHER(L, rc2); ADD_CIPHER(L, rc5); + ADD_CIPHER(L, rc6); ADD_CIPHER(L, saferp); ADD_CIPHER(L, aes); ADD_CIPHER(L, twofish); + ADD_CIPHER(L, des); ADD_CIPHER(L, des3); ADD_CIPHER(L, cast5); ADD_CIPHER(L, noekeon); + ADD_CIPHER(L, skipjack); ADD_CIPHER(L, anubis); ADD_CIPHER(L, khazad); ADD_CIPHER(L, kseed); + ADD_CIPHER(L, kasumi); + #undef ADD_CIPHER + lua_settable(L, -3); + + #define NEW_MODE_TYPE(NAME, name) (void)luaL_newmetatable(L, "LCRYPT_CIPHER_" #NAME); (void)luaL_register(L, NULL, lcrypt_cipher_ ## name ## _flib); lua_pop(L, 1); + NEW_MODE_TYPE(ECB, ecb); NEW_MODE_TYPE(CBC, cbc); NEW_MODE_TYPE(CTR, ctr); + NEW_MODE_TYPE(CFB, cfb); NEW_MODE_TYPE(OFB, ofb); NEW_MODE_TYPE(F8, f8); + NEW_MODE_TYPE(LRW, lrw); + #undef NEW_MODE_TYPE +} diff --git a/lcrypt/lcrypt_hashes.c b/lcrypt/lcrypt_hashes.c new file mode 100644 index 0000000..4eccbfc --- /dev/null +++ b/lcrypt/lcrypt_hashes.c @@ -0,0 +1,211 @@ +typedef struct +{ + int hash; + hash_state state; +} lcrypt_hash; + +static int lcrypt_hash_add(lua_State *L) +{ + lcrypt_hash *h = luaL_checkudata(L, 1, "LCRYPT_HASH_STATE"); + if(likely(h->hash >= 0)) + { + size_t in_length = 0; + const unsigned char *in = (const unsigned char*)luaL_checklstring(L, 2, &in_length); + lcrypt_error(L, hash_descriptor[h->hash].process(&h->state, in, (unsigned long)in_length), NULL); + } + return 0; +} + +static int lcrypt_hash_done(lua_State *L) +{ + lcrypt_hash *h = luaL_checkudata(L, 1, "LCRYPT_HASH_STATE"); + if(likely(h->hash >= 0)) + { + unsigned char out[hash_descriptor[h->hash].hashsize]; + lcrypt_error(L, hash_descriptor[h->hash].done(&h->state, out), NULL); + lua_pushlstring(L, (char*)out, hash_descriptor[h->hash].hashsize); + } + memset(h, 0, sizeof(lcrypt_hash)); + h->hash = -1; + return 1; +} + +static int lcrypt_hash_state_gc(lua_State *L) +{ + lcrypt_hash *h = luaL_checkudata(L, 1, "LCRYPT_HASH_STATE"); + if(likely(h->hash >= 0)) + { + unsigned char out[hash_descriptor[h->hash].hashsize]; + lcrypt_error(L, hash_descriptor[h->hash].done(&h->state, out), NULL); + memset(h, 0, sizeof(lcrypt_hash)); + h->hash = -1; + } + return 0; +} + +static int lcrypt_hash_hash(lua_State *L) +{ + int *hash = luaL_checkudata(L, 1, "LCRYPT_HASH"); + size_t in_length = 0; + const unsigned char *in = (const unsigned char*)luaL_optlstring(L, 2, "", &in_length); + lcrypt_hash *h = lua_newuserdata(L, sizeof(lcrypt_hash)); + luaL_getmetatable(L, "LCRYPT_HASH_STATE"); + (void)lua_setmetatable(L, -2); + h->hash = -1; + lcrypt_error(L, hash_descriptor[*hash].init(&h->state), NULL); + if(in_length > 0) + { + lcrypt_error(L, hash_descriptor[*hash].process(&h->state, in, (unsigned long)in_length), NULL); + } + h->hash = *hash; + return 1; +} + +static int lcrypt_hash_hmac(lua_State *L) +{ + int *hash = luaL_checkudata(L, 1, "LCRYPT_HASH"); + size_t key_length = 0, in_length = 0; + const unsigned char *key = (const unsigned char*)luaL_checklstring(L, 2, &key_length); + const unsigned char *in = (const unsigned char*)luaL_optlstring(L, 3, "", &in_length); + hmac_state *h = lua_newuserdata(L, sizeof(hmac_state)); + luaL_getmetatable(L, "LCRYPT_HMAC_STATE"); + (void)lua_setmetatable(L, -2); + lcrypt_error(L, hmac_init(h, *hash, key, key_length), NULL); + if(in_length > 0) + { + lcrypt_error(L, hmac_process(h, in, (unsigned long)in_length), NULL); + } + return 1; +} + +static int lcrypt_hmac_add(lua_State *L) +{ + hmac_state *h = luaL_checkudata(L, 1, "LCRYPT_HMAC_STATE"); + if(likely(h->hash >= 0)) + { + size_t in_length = 0; + const unsigned char *in = (const unsigned char*)luaL_checklstring(L, 2, &in_length); + lcrypt_error(L, hmac_process(h, in, (unsigned long)in_length), NULL); + } + return 0; +} + +static int lcrypt_hmac_done(lua_State *L) +{ + hmac_state *h = luaL_checkudata(L, 1, "LCRYPT_HMAC_STATE"); + if(likely(h->hash >= 0)) + { + unsigned long out_length = hash_descriptor[h->hash].hashsize; + unsigned char out[out_length]; + lcrypt_error(L, hmac_done(h, out, &out_length), NULL); + lua_pushlstring(L, (char*)out, out_length); + memset(h, 0, sizeof(hmac_state)); + h->hash = -1; + return 1; + } + return 0; +} + +static int lcrypt_hmac_state_gc(lua_State *L) +{ + hmac_state *h = luaL_checkudata(L, 1, "LCRYPT_HMAC_STATE"); + if(likely(h->hash >= 0)) + { + unsigned long out_length = hash_descriptor[h->hash].hashsize; + unsigned char out[out_length]; + lcrypt_error(L, hmac_done(h, out, &out_length), NULL); + memset(h, 0, sizeof(hmac_state)); + h->hash = -1; + } + return 0; +} + +static int lcrypt_hash_index(lua_State *L) +{ + int *h = luaL_checkudata(L, 1, "LCRYPT_HASH"); + const char *index = luaL_checkstring(L, 2); + if(strcmp(index, "type") == 0) { lua_pushstring(L, "LCRYPT_HASH"); return 1; } + if(strcmp(index, "name") == 0) { lua_pushstring(L, hash_descriptor[*h].name); return 1; } + if(strcmp(index, "hash_size") == 0) { lua_pushinteger(L, hash_descriptor[*h].hashsize); return 1; } + if(strcmp(index, "block_size") == 0) { lua_pushinteger(L, hash_descriptor[*h].blocksize); return 1; } + if(strcmp(index, "hash") == 0) { lua_pushcfunction(L, lcrypt_hash_hash); return 1; } + if(strcmp(index, "hmac") == 0) { lua_pushcfunction(L, lcrypt_hash_hmac); return 1; } + return 0; +} + +static int lcrypt_hash_state_index(lua_State *L) +{ + lcrypt_hash *h = luaL_checkudata(L, 1, "LCRYPT_HASH_STATE"); + if(likely(h->hash >= 0)) + { + const char *index = luaL_checkstring(L, 2); + if(strcmp(index, "type") == 0) { lua_pushstring(L, "LCRYPT_HASH_STATE"); return 1; } + if(strcmp(index, "name") == 0) { lua_pushstring(L, hash_descriptor[h->hash].name); return 1; } + if(strcmp(index, "hash_size") == 0) { lua_pushinteger(L, hash_descriptor[h->hash].hashsize); return 1; } + if(strcmp(index, "block_size") == 0) { lua_pushinteger(L, hash_descriptor[h->hash].blocksize); return 1; } + if(strcmp(index, "add") == 0) { lua_pushcfunction(L, lcrypt_hash_add); return 1; } + if(strcmp(index, "done") == 0) { lua_pushcfunction(L, lcrypt_hash_done); return 1; } + } + return 0; +} + +static int lcrypt_hmac_state_index(lua_State *L) +{ + hmac_state *h = luaL_checkudata(L, 1, "LCRYPT_HMAC_STATE"); + if(likely(h->hash >= 0)) + { + const char *index = luaL_checkstring(L, 2); + if(strcmp(index, "type") == 0) { lua_pushstring(L, "LCRYPT_HMAC_STATE"); return 1; } + if(strcmp(index, "hash") == 0) { lua_pushstring(L, hash_descriptor[h->hash].name); return 1; } + if(strcmp(index, "hash_size") == 0) { lua_pushinteger(L, hash_descriptor[h->hash].hashsize); return 1; } + if(strcmp(index, "block_size") == 0) { lua_pushinteger(L, hash_descriptor[h->hash].blocksize); return 1; } + if(strcmp(index, "add") == 0) { lua_pushcfunction(L, lcrypt_hmac_add); return 1; } + if(strcmp(index, "done") == 0) { lua_pushcfunction(L, lcrypt_hmac_done); return 1; } + } + return 0; +} + +static const struct luaL_reg lcrypt_hash_flib[] = +{ + { "__index", lcrypt_hash_index }, + { NULL, NULL } +}; + +static const struct luaL_reg lcrypt_hash_state_flib[] = +{ + { "__index", lcrypt_hash_state_index }, + { "__gc", lcrypt_hash_state_gc }, + { NULL, NULL } +}; + +static const struct luaL_reg lcrypt_hmac_state_flib[] = +{ + { "__index", lcrypt_hmac_state_index }, + { "__gc", lcrypt_hmac_state_gc }, + { NULL, NULL } +}; + +static void lcrypt_start_hashes(lua_State *L) +{ + (void)luaL_newmetatable(L, "LCRYPT_HASH"); (void)luaL_register(L, NULL, lcrypt_hash_flib); lua_pop(L, 1); + lua_pushstring(L, "hashes"); + lua_newtable(L); + #define ADD_HASH(L,name) \ + { \ + lua_pushstring(L, #name); \ + int *hash_index = lua_newuserdata(L, sizeof(int)); \ + luaL_getmetatable(L, "LCRYPT_HASH"); \ + (void)lua_setmetatable(L, -2); \ + *hash_index = register_hash(&name ## _desc); \ + lua_settable(L, -3); \ + } + ADD_HASH(L, whirlpool); ADD_HASH(L, sha512); ADD_HASH(L, sha384); ADD_HASH(L, rmd320); + ADD_HASH(L, sha256); ADD_HASH(L, rmd256); ADD_HASH(L, sha224); ADD_HASH(L, tiger); + ADD_HASH(L, sha1); ADD_HASH(L, rmd160); ADD_HASH(L, rmd128); ADD_HASH(L, md5); + ADD_HASH(L, md4); ADD_HASH(L, md2); + #undef ADD_HASH + lua_settable(L, -3); + + (void)luaL_newmetatable(L, "LCRYPT_HASH_STATE"); (void)luaL_register(L, NULL, lcrypt_hash_state_flib); lua_pop(L, 1); + (void)luaL_newmetatable(L, "LCRYPT_HMAC_STATE"); (void)luaL_register(L, NULL, lcrypt_hmac_state_flib); lua_pop(L, 1); +} diff --git a/lcrypt/lcrypt_math.c b/lcrypt/lcrypt_math.c new file mode 100644 index 0000000..769a3a4 --- /dev/null +++ b/lcrypt/lcrypt_math.c @@ -0,0 +1,401 @@ +#ifdef USE_NCIPHER + typedef sbigint lcrypt_bigint; +#else + typedef void* lcrypt_bigint; +#endif + +static lcrypt_bigint* lcrypt_new_bigint(lua_State *L) +{ + lcrypt_bigint *bi = lua_newuserdata(L, sizeof(lcrypt_bigint)); + luaL_getmetatable(L, "LCRYPT_BIGINT"); + (void)lua_setmetatable(L, -2); + #ifdef USE_NCIPHER + sbigint_create(bi, NULL, 0); + #else + *bi = NULL; + lcrypt_error(L, ltc_mp.init(bi), NULL); + #endif + return bi; +} + +static int lcrypt_bigint_add(lua_State *L) +{ + lcrypt_bigint *bi_a = luaL_checkudata(L, 1, "LCRYPT_BIGINT"); + lcrypt_bigint *bi_b = luaL_checkudata(L, 2, "LCRYPT_BIGINT"); + lcrypt_bigint *bi = lcrypt_new_bigint(L); + #ifdef USE_NCIPHER + if(unlikely(sbigint_add(bi_a, bi_b, bi) != 0)) return 0; + #else + lcrypt_error(L, ltc_mp.add(*bi_a, *bi_b, *bi), NULL); + #endif + return 1; +} + +static int lcrypt_bigint_sub(lua_State *L) +{ + lcrypt_bigint *bi_a = luaL_checkudata(L, 1, "LCRYPT_BIGINT"); + lcrypt_bigint *bi_b = luaL_checkudata(L, 2, "LCRYPT_BIGINT"); + lcrypt_bigint *bi = lcrypt_new_bigint(L); + #ifdef USE_NCIPHER + if(unlikely(sbigint_sub(bi_a, bi_b, bi) != 0)) return 0; + #else + lcrypt_error(L, ltc_mp.sub(*bi_a, *bi_b, *bi), NULL); + #endif + return 1; +} + +static int lcrypt_bigint_mul(lua_State *L) +{ + lcrypt_bigint *bi_a = luaL_checkudata(L, 1, "LCRYPT_BIGINT"); + lcrypt_bigint *bi_b = luaL_checkudata(L, 2, "LCRYPT_BIGINT"); + lcrypt_bigint *bi = lcrypt_new_bigint(L); + #ifdef USE_NCIPHER + if(unlikely(sbigint_mul(bi_a, bi_b, bi) != 0)) return 0; + #else + lcrypt_error(L, ltc_mp.mul(*bi_a, *bi_b, *bi), NULL); + #endif + return 1; +} + +static int lcrypt_bigint_div(lua_State *L) +{ + lcrypt_bigint *bi_a = luaL_checkudata(L, 1, "LCRYPT_BIGINT"); + lcrypt_bigint *bi_b = luaL_checkudata(L, 2, "LCRYPT_BIGINT"); + lcrypt_bigint *bi = lcrypt_new_bigint(L); + #ifdef USE_NCIPHER + if(unlikely(sbigint_divmod(bi_a, bi_b, bi, NULL) != 0)) return 0; + #else + lcrypt_error(L, ltc_mp.mpdiv(*bi_a, *bi_b, *bi, NULL), NULL); + #endif + return 1; +} + +static int lcrypt_bigint_divmod(lua_State *L) +{ + lcrypt_bigint *bi_a = luaL_checkudata(L, 1, "LCRYPT_BIGINT"); + lcrypt_bigint *bi_b = luaL_checkudata(L, 2, "LCRYPT_BIGINT"); + lcrypt_bigint *bi_q = lcrypt_new_bigint(L); + lcrypt_bigint *bi_r = lcrypt_new_bigint(L); + #ifdef USE_NCIPHER + if(unlikely(sbigint_divmod(bi_a, bi_b, bi_q, bi_r) != 0)) return 0; + #else + lcrypt_error(L, ltc_mp.mpdiv(*bi_a, *bi_b, *bi_q, *bi_r), NULL); + #endif + return 2; +} + +static int lcrypt_bigint_mod(lua_State *L) +{ + lcrypt_bigint *bi_a = luaL_checkudata(L, 1, "LCRYPT_BIGINT"); + lcrypt_bigint *bi_b = luaL_checkudata(L, 2, "LCRYPT_BIGINT"); + lcrypt_bigint *bi = lcrypt_new_bigint(L); + #ifdef USE_NCIPHER + if(unlikely(sbigint_divmod(bi_a, bi_b, NULL, bi) != 0)) return 0; + #else + lcrypt_error(L, ltc_mp.mpdiv(*bi_a, *bi_b, NULL, *bi), NULL); + #endif + return 1; +} + +static int lcrypt_bigint_invmod(lua_State *L) +{ + lcrypt_bigint *bi_a = luaL_checkudata(L, 1, "LCRYPT_BIGINT"); + lcrypt_bigint *bi_b = luaL_checkudata(L, 2, "LCRYPT_BIGINT"); + lcrypt_bigint *bi = lcrypt_new_bigint(L); + #ifdef USE_NCIPHER + if(unlikely(sbigint_invmod(bi_a, bi_b, bi) != 0)) return 0; + #else + lcrypt_error(L, ltc_mp.invmod(*bi_a, *bi_b, *bi), NULL); + #endif + return 1; +} + +static int lcrypt_bigint_mulmod(lua_State *L) +{ + lcrypt_bigint *bi_a = luaL_checkudata(L, 1, "LCRYPT_BIGINT"); + lcrypt_bigint *bi_b = luaL_checkudata(L, 2, "LCRYPT_BIGINT"); + lcrypt_bigint *bi_c = luaL_checkudata(L, 3, "LCRYPT_BIGINT"); + lcrypt_bigint *bi = lcrypt_new_bigint(L); + #ifdef USE_NCIPHER + if(unlikely(sbigint_mulmod(bi_a, bi_b, bi_c, bi) != 0)) return 0; + #else + lcrypt_error(L, ltc_mp.mulmod(*bi_a, *bi_b, *bi_c, *bi), NULL); + #endif + return 1; +} + +static int lcrypt_bigint_exptmod(lua_State *L) +{ + lcrypt_bigint *bi_a = luaL_checkudata(L, 1, "LCRYPT_BIGINT"); + lcrypt_bigint *bi_b = luaL_checkudata(L, 2, "LCRYPT_BIGINT"); + lcrypt_bigint *bi_c = luaL_checkudata(L, 3, "LCRYPT_BIGINT"); + lcrypt_bigint *bi = lcrypt_new_bigint(L); + #ifdef USE_NCIPHER + if(unlikely(sbigint_exptmod(bi_a, bi_b, bi_c, bi) != 0)) return 0; + #else + lcrypt_error(L, ltc_mp.exptmod(*bi_a, *bi_b, *bi_c, *bi), NULL); + #endif + return 1; +} + +static int lcrypt_bigint_gcd(lua_State *L) +{ + lcrypt_bigint *bi_a = luaL_checkudata(L, 1, "LCRYPT_BIGINT"); + lcrypt_bigint *bi_b = luaL_checkudata(L, 2, "LCRYPT_BIGINT"); + lcrypt_bigint *bi = lcrypt_new_bigint(L); + #ifdef USE_NCIPHER + if(unlikely(sbigint_gcd(bi_a, bi_b, bi) != 0)) return 0; + #else + lcrypt_error(L, ltc_mp.gcd(*bi_a, *bi_b, *bi), NULL); + #endif + return 1; +} + +static int lcrypt_bigint_lcm(lua_State *L) +{ + lcrypt_bigint *bi_a = luaL_checkudata(L, 1, "LCRYPT_BIGINT"); + lcrypt_bigint *bi_b = luaL_checkudata(L, 2, "LCRYPT_BIGINT"); + lcrypt_bigint *bi = lcrypt_new_bigint(L); + #ifdef USE_NCIPHER + if(unlikely(sbigint_lcm(bi_a, bi_b, bi) != 0)) return 0; + #else + lcrypt_error(L, ltc_mp.lcm(*bi_a, *bi_b, *bi), NULL); + #endif + return 1; +} + +static int lcrypt_bigint_unm(lua_State *L) +{ + lcrypt_bigint *bi_a = luaL_checkudata(L, 1, "LCRYPT_BIGINT"); + lcrypt_bigint *bi = lcrypt_new_bigint(L); + #ifdef USE_NCIPHER + sbigint_copy(bi, bi_a); + bi->sign = (bi_a->sign == SBIGINT_POSITIVE) ? SBIGINT_NEGATIVE : SBIGINT_POSITIVE; + #else + lcrypt_error(L, ltc_mp.neg(*bi_a, *bi), NULL); + #endif + return 1; +} + +static int lcrypt_bigint_eq(lua_State *L) +{ + lcrypt_bigint *bi_a = luaL_checkudata(L, 1, "LCRYPT_BIGINT"); + lcrypt_bigint *bi_b = luaL_checkudata(L, 2, "LCRYPT_BIGINT"); + #ifdef USE_NCIPHER + lua_pushboolean(L, (sbigint_cmp(bi_a, bi_b) == 0) ? 1 : 0); + #else + lua_pushboolean(L, (ltc_mp.compare(*bi_a, *bi_b) == LTC_MP_EQ) ? 1 : 0); + #endif + return 1; +} + +static int lcrypt_bigint_lt(lua_State *L) +{ + lcrypt_bigint *bi_a = luaL_checkudata(L, 1, "LCRYPT_BIGINT"); + lcrypt_bigint *bi_b = luaL_checkudata(L, 2, "LCRYPT_BIGINT"); + #ifdef USE_NCIPHER + lua_pushboolean(L, (sbigint_cmp(bi_a, bi_b) < 0) ? 1 : 0); + #else + lua_pushboolean(L, (ltc_mp.compare(*bi_a, *bi_b) == LTC_MP_LT) ? 1 : 0); + #endif + return 1; +} + +static int lcrypt_bigint_le(lua_State *L) +{ + lcrypt_bigint *bi_a = luaL_checkudata(L, 1, "LCRYPT_BIGINT"); + lcrypt_bigint *bi_b = luaL_checkudata(L, 2, "LCRYPT_BIGINT"); + #ifdef USE_NCIPHER + lua_pushboolean(L, (sbigint_cmp(bi_a, bi_b) <= 0) ? 1 : 0); + #else + lua_pushboolean(L, (ltc_mp.compare(*bi_a, *bi_b) == LTC_MP_GT) ? 0 : 1); + #endif + return 1; +} + +static int lcrypt_bigint_tostring(lua_State *L) +{ + lcrypt_bigint *bi_a = luaL_checkudata(L, 1, "LCRYPT_BIGINT"); + #ifdef USE_NCIPHER + unsigned char out[4097]; + int length = sizeof(out); + sbigint_tostring(bi_a, out + 1, &length); + if(bi_a->sign == SBIGINT_NEGATIVE || (out[1] & 0x80) == 0x80) + { + out[0] = bi_a->sign; + lua_pushlstring(L, (char*)out, length + 1); + } + else + { + lua_pushlstring(L, (char*)out + 1, length); + } + #else + size_t out_length = (size_t)ltc_mp.unsigned_size(*bi_a) + 1; + unsigned char *out = lcrypt_malloc(L, out_length); + out[0] = (ltc_mp.compare_d(*bi_a, 0) == LTC_MP_LT) ? (unsigned char)0x80 : (unsigned char)0x00; + lcrypt_error(L, ltc_mp.unsigned_write(*bi_a, out+1), out); + if(out[0] == 0 && out[1] < 0x7f) + lua_pushlstring(L, (char*)out+1, out_length-1); + else + lua_pushlstring(L, (char*)out, out_length); + free(out); + #endif + return 1; +} + +static int lcrypt_bigint_index(lua_State *L) +{ + lcrypt_bigint *bi = luaL_checkudata(L, 1, "LCRYPT_BIGINT"); + const char *index = luaL_checkstring(L, 2); + #ifdef USE_NCIPHER + if(strcmp(index, "bits") == 0) + { + int len = bi->num.nbytes - 1; + while(len > 0 && bi->num.bytes[len] == 0) len--; + int bits = len * 8; + if(bi->num.bytes[len] & 0x80) bits += 8; + else if(bi->num.bytes[len] & 0x40) bits += 7; + else if(bi->num.bytes[len] & 0x20) bits += 6; + else if(bi->num.bytes[len] & 0x10) bits += 5; + else if(bi->num.bytes[len] & 0x08) bits += 4; + else if(bi->num.bytes[len] & 0x04) bits += 3; + else if(bi->num.bytes[len] & 0x02) bits += 2; + else bits++; + lua_pushinteger(L, bits); + return 1; + } + if(strcmp(index, "isprime") == 0) + { + sbigint c; + int i, prime = 0; + if(unlikely(sbigint_is_prime(bi, &c) != 0)) return 0; + for(i = 0; i < c.num.nbytes; i++) if(c.num.bytes[i] != 0) { prime = 1; break; } + lua_pushboolean(L, prime); + return 1; + } + #else + if(strcmp(index, "bits") == 0) { lua_pushinteger(L, ltc_mp.count_bits(*bi)); return 1; } + if(strcmp(index, "isprime") == 0) + { + int ret = LTC_MP_NO; + lcrypt_error(L, ltc_mp.isprime(*bi, &ret), NULL); + lua_pushboolean(L, (ret == LTC_MP_YES) ? 1 : 0); + return 1; + } + #endif + if(strcmp(index, "add") == 0) { lua_pushcfunction(L, lcrypt_bigint_add); return 1; } + if(strcmp(index, "sub") == 0) { lua_pushcfunction(L, lcrypt_bigint_sub); return 1; } + if(strcmp(index, "mul") == 0) { lua_pushcfunction(L, lcrypt_bigint_mul); return 1; } + if(strcmp(index, "div") == 0) { lua_pushcfunction(L, lcrypt_bigint_divmod); return 1; } + if(strcmp(index, "mod") == 0) { lua_pushcfunction(L, lcrypt_bigint_mod); return 1; } + if(strcmp(index, "gcd") == 0) { lua_pushcfunction(L, lcrypt_bigint_gcd); return 1; } + if(strcmp(index, "lcm") == 0) { lua_pushcfunction(L, lcrypt_bigint_lcm); return 1; } + if(strcmp(index, "invmod") == 0) { lua_pushcfunction(L, lcrypt_bigint_invmod); return 1; } + if(strcmp(index, "mulmod") == 0) { lua_pushcfunction(L, lcrypt_bigint_mulmod); return 1; } + if(strcmp(index, "exptmod") == 0) { lua_pushcfunction(L, lcrypt_bigint_exptmod); return 1; } + return 0; +} + +static int lcrypt_bigint_gc(lua_State *L) +{ + #ifdef USE_NCIPHER + (void)luaL_checkudata(L, 1, "LCRYPT_BIGINT"); + #else + lcrypt_bigint *bi = luaL_checkudata(L, 1, "LCRYPT_BIGINT"); + if(likely(*bi != NULL)) + { + ltc_mp.deinit(*bi); + *bi = NULL; + } + #endif + return 0; +} + +static int lcrypt_bigint_create(lua_State *L) +{ + #ifdef USE_NCIPHER + if(lua_isnumber(L, 1) == 1) + { + long n = luaL_checknumber(L, 1); + lcrypt_bigint *bi = lcrypt_new_bigint(L); + if(n < 0) + { + bi->sign = SBIGINT_NEGATIVE; + n = -n; + } + bi->num.nbytes = 0; + while(n != 0 || bi->num.nbytes % 4 != 0) + { + bi->num.bytes[bi->num.nbytes++] = n & 0xff; + n >>= 8; + } + } + else + { + size_t n_length = 0; + unsigned char *n = (unsigned char*)luaL_optlstring(L, 1, "", &n_length); + lcrypt_bigint *bi = lua_newuserdata(L, sizeof(lcrypt_bigint)); + luaL_getmetatable(L, "LCRYPT_BIGINT"); + (void)lua_setmetatable(L, -2); + sbigint_create(bi, n, n_length); + } + #else + if(lua_isnumber(L, 1) == 1) + { + long n = luaL_checknumber(L, 1); + lcrypt_bigint *bi = lcrypt_new_bigint(L); + if(n < 0) + { + void *temp; + int err = CRYPT_OK; + lcrypt_error(L, ltc_mp.init(&temp), NULL); + if((err = ltc_mp.set_int(temp, -n)) == CRYPT_OK) + { + err = ltc_mp.neg(temp, *bi); + } + ltc_mp.deinit(temp); + lcrypt_error(L, err, NULL); + } + else + { + lcrypt_error(L, ltc_mp.set_int(*bi, n), NULL); + } + } + else + { + size_t n_length = 0; + unsigned char *n = (unsigned char*)luaL_optlstring(L, 1, "", &n_length); + lcrypt_bigint *bi = lcrypt_new_bigint(L); + lcrypt_error(L, ltc_mp.unsigned_read(*bi, n, n_length), NULL); + } + #endif + return 1; +} + +static const struct luaL_reg lcrypt_bigint_flib[] = +{ + { "__index", lcrypt_bigint_index }, + { "__add", lcrypt_bigint_add }, + { "__sub", lcrypt_bigint_sub }, + { "__mul", lcrypt_bigint_mul }, + { "__div", lcrypt_bigint_div }, + { "__mod", lcrypt_bigint_mod }, + { "__unm", lcrypt_bigint_unm }, + { "__eq", lcrypt_bigint_eq }, + { "__lt", lcrypt_bigint_lt }, + { "__le", lcrypt_bigint_le }, + { "__tostring", lcrypt_bigint_tostring }, + { "__gc", lcrypt_bigint_gc }, + { NULL, NULL } +}; + +static void lcrypt_start_math(lua_State *L) +{ + (void)luaL_newmetatable(L, "LCRYPT_BIGINT"); (void)luaL_register(L, NULL, lcrypt_bigint_flib); lua_pop(L, 1); + + #ifndef USE_NCIPHER + ltc_mp = ltm_desc; + #endif + + lua_pushstring(L, "bigint"); lua_pushcfunction(L, lcrypt_bigint_create); lua_settable(L, -3); +} -- cgit v1.2.3