add 2 lua scripts

diff --git a/make/libraries.mk b/make/libraries.mk
index dfb52fd10b9e40f7f2a34561ab7a49a62e9990fb..51e64452e1346e50c79eb39ef91830f24e0ff298 100755 (executable)
--- a/make/libraries.mk
+++ b/make/libraries.mk
@@ -1328,18 +1328,19 @@ $(D)/lua: $(D)/libncurses $(ARCHIVE)/lua-$(LUA_VER).tar.gz | $(TARGETPREFIX)
                $(PATCH)/lua-04-lua-lvm.c.patch; \
                sed -i 's/^V=.*/V= $(LUA_ABIVER)/' etc/lua.pc && \
                sed -i 's/^R=.*/R= $(LUA_VER)/' etc/lua.pc; \
-               $(MAKE) linux PKG_VERSION=$(LUA_VER) CC=$(TARGET)-gcc LD=$(TARGET)-ld AR="$(TARGET)-ar rcu" RANLIB=$(TARGET)-ranlib LDFLAGS="-L$(TARGETPREFIX)/lib"; \
+               $(MAKE) linux PKG_VERSION=$(LUA_VER) CC=$(TARGET)-gcc LD=$(TARGET)-ld AR="$(TARGET)-ar rc" RANLIB=$(TARGET)-ranlib LDFLAGS="-L$(TARGETPREFIX)/lib"; \
                $(MAKE) install INSTALL_TOP=$(TARGETPREFIX)
        install -m 0755 -D $(BUILD_TMP)/lua-$(LUA_VER)/src/liblua.so.$(LUA_VER) $(TARGETPREFIX)/lib/liblua.so.$(LUA_VER)
        cd $(TARGETPREFIX)/lib; ln -sf liblua.so.$(LUA_VER) $(TARGETPREFIX)/lib/liblua.so
        mkdir -p $(TARGETPREFIX)/share/lua/$(LUA_ABIVER)
-       cp -a $(GIT_PLUGINS)/scripts-lua/share/lua/$(LUA_ABIVER)/n_gui.lua $(TARGETPREFIX)/share/lua/$(LUA_ABIVER)
-       cp -a $(GIT_PLUGINS)/scripts-lua/share/lua/$(LUA_ABIVER)/n_helpers.lua $(TARGETPREFIX)/share/lua/$(LUA_ABIVER)
+       install -m 0644 $(GIT_PLUGINS)/scripts-lua/share/lua/$(LUA_ABIVER)/n_gui.lua $(TARGETPREFIX)/share/lua/$(LUA_ABIVER)/
+       install -m 0644 $(GIT_PLUGINS)/scripts-lua/share/lua/$(LUA_ABIVER)/n_helpers.lua $(TARGETPREFIX)/share/lua/$(LUA_ABIVER)/
+       install -m 0644 $(SCRIPTS)/share/lua/* $(TARGETPREFIX)/share/lua/$(LUA_ABIVER)/
        install -m 0644 -D $(BUILD_TMP)/lua-$(LUA_VER)/etc/lua.pc $(PKG_CONFIG_PATH)/lua.pc
        $(REWRITE_PKGCONF) $(PKG_CONFIG_PATH)/lua.pc
        rm -rf $(TARGETPREFIX)/bin/lua
        rm -rf $(TARGETPREFIX)/bin/luac
-       rm -rf $(TARGETPREFIX)/share/lua/1
+       rm -rf $(TARGETPREFIX)/share/lua/2
        $(REMOVE)/lua-$(LUA_VER)
        $(TOUCH)
 

diff --git a/scripts/share/lua/AES.lua b/scripts/share/lua/AES.lua
new file mode 100644 (file)
index 0000000..0b00eec
--- /dev/null
+++ b/scripts/share/lua/AES.lua
@@ -0,0 +1,389 @@
+--[[
+       Copyright 2019 Tyler Richard Hoyer
+       Heavily modified by Hendi in 2025 (fix algorithms to be AES-compliant, add CBC encryption)
+
+       Licensed under the Apache License, Version 2.0 (the "License");
+       you may not use this file except in compliance with the License.
+       You may obtain a copy of the License at
+
+               http://www.apache.org/licenses/LICENSE-2.0
+
+       Unless required by applicable law or agreed to in writing, software
+       distributed under the License is distributed on an "AS IS" BASIS,
+       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+       See the License for the specific language governing permissions and
+       limitations under the License.
+]]
+
+local GF8x2 = {
+[0]=0x00,0x02,0x04,0x06,0x08,0x0a,0x0c,0x0e,0x10,0x12,0x14,0x16,0x18,0x1a,0x1c,0x1e,
+       0x20,0x22,0x24,0x26,0x28,0x2a,0x2c,0x2e,0x30,0x32,0x34,0x36,0x38,0x3a,0x3c,0x3e,
+       0x40,0x42,0x44,0x46,0x48,0x4a,0x4c,0x4e,0x50,0x52,0x54,0x56,0x58,0x5a,0x5c,0x5e,
+       0x60,0x62,0x64,0x66,0x68,0x6a,0x6c,0x6e,0x70,0x72,0x74,0x76,0x78,0x7a,0x7c,0x7e,
+       0x80,0x82,0x84,0x86,0x88,0x8a,0x8c,0x8e,0x90,0x92,0x94,0x96,0x98,0x9a,0x9c,0x9e,
+       0xa0,0xa2,0xa4,0xa6,0xa8,0xaa,0xac,0xae,0xb0,0xb2,0xb4,0xb6,0xb8,0xba,0xbc,0xbe,
+       0xc0,0xc2,0xc4,0xc6,0xc8,0xca,0xcc,0xce,0xd0,0xd2,0xd4,0xd6,0xd8,0xda,0xdc,0xde,
+       0xe0,0xe2,0xe4,0xe6,0xe8,0xea,0xec,0xee,0xf0,0xf2,0xf4,0xf6,0xf8,0xfa,0xfc,0xfe,
+       0x1b,0x19,0x1f,0x1d,0x13,0x11,0x17,0x15,0x0b,0x09,0x0f,0x0d,0x03,0x01,0x07,0x05,
+       0x3b,0x39,0x3f,0x3d,0x33,0x31,0x37,0x35,0x2b,0x29,0x2f,0x2d,0x23,0x21,0x27,0x25,
+       0x5b,0x59,0x5f,0x5d,0x53,0x51,0x57,0x55,0x4b,0x49,0x4f,0x4d,0x43,0x41,0x47,0x45,
+       0x7b,0x79,0x7f,0x7d,0x73,0x71,0x77,0x75,0x6b,0x69,0x6f,0x6d,0x63,0x61,0x67,0x65,
+       0x9b,0x99,0x9f,0x9d,0x93,0x91,0x97,0x95,0x8b,0x89,0x8f,0x8d,0x83,0x81,0x87,0x85,
+       0xbb,0xb9,0xbf,0xbd,0xb3,0xb1,0xb7,0xb5,0xab,0xa9,0xaf,0xad,0xa3,0xa1,0xa7,0xa5,
+       0xdb,0xd9,0xdf,0xdd,0xd3,0xd1,0xd7,0xd5,0xcb,0xc9,0xcf,0xcd,0xc3,0xc1,0xc7,0xc5,
+       0xfb,0xf9,0xff,0xfd,0xf3,0xf1,0xf7,0xf5,0xeb,0xe9,0xef,0xed,0xe3,0xe1,0xe7,0xe5
+}
+
+local GF8x3 = {
+[0]=0x00,0x03,0x06,0x05,0x0c,0x0f,0x0a,0x09,0x18,0x1b,0x1e,0x1d,0x14,0x17,0x12,0x11,
+       0x30,0x33,0x36,0x35,0x3c,0x3f,0x3a,0x39,0x28,0x2b,0x2e,0x2d,0x24,0x27,0x22,0x21,
+       0x60,0x63,0x66,0x65,0x6c,0x6f,0x6a,0x69,0x78,0x7b,0x7e,0x7d,0x74,0x77,0x72,0x71,
+       0x50,0x53,0x56,0x55,0x5c,0x5f,0x5a,0x59,0x48,0x4b,0x4e,0x4d,0x44,0x47,0x42,0x41,
+       0xc0,0xc3,0xc6,0xc5,0xcc,0xcf,0xca,0xc9,0xd8,0xdb,0xde,0xdd,0xd4,0xd7,0xd2,0xd1,
+       0xf0,0xf3,0xf6,0xf5,0xfc,0xff,0xfa,0xf9,0xe8,0xeb,0xee,0xed,0xe4,0xe7,0xe2,0xe1,
+       0xa0,0xa3,0xa6,0xa5,0xac,0xaf,0xaa,0xa9,0xb8,0xbb,0xbe,0xbd,0xb4,0xb7,0xb2,0xb1,
+       0x90,0x93,0x96,0x95,0x9c,0x9f,0x9a,0x99,0x88,0x8b,0x8e,0x8d,0x84,0x87,0x82,0x81,
+       0x9b,0x98,0x9d,0x9e,0x97,0x94,0x91,0x92,0x83,0x80,0x85,0x86,0x8f,0x8c,0x89,0x8a,
+       0xab,0xa8,0xad,0xae,0xa7,0xa4,0xa1,0xa2,0xb3,0xb0,0xb5,0xb6,0xbf,0xbc,0xb9,0xba,
+       0xfb,0xf8,0xfd,0xfe,0xf7,0xf4,0xf1,0xf2,0xe3,0xe0,0xe5,0xe6,0xef,0xec,0xe9,0xea,
+       0xcb,0xc8,0xcd,0xce,0xc7,0xc4,0xc1,0xc2,0xd3,0xd0,0xd5,0xd6,0xdf,0xdc,0xd9,0xda,
+       0x5b,0x58,0x5d,0x5e,0x57,0x54,0x51,0x52,0x43,0x40,0x45,0x46,0x4f,0x4c,0x49,0x4a,
+       0x6b,0x68,0x6d,0x6e,0x67,0x64,0x61,0x62,0x73,0x70,0x75,0x76,0x7f,0x7c,0x79,0x7a,
+       0x3b,0x38,0x3d,0x3e,0x37,0x34,0x31,0x32,0x23,0x20,0x25,0x26,0x2f,0x2c,0x29,0x2a,
+       0x0b,0x08,0x0d,0x0e,0x07,0x04,0x01,0x02,0x13,0x10,0x15,0x16,0x1f,0x1c,0x19,0x1a
+}
+
+local GF8x9 = {
+[0]=0x00,0x09,0x12,0x1b,0x24,0x2d,0x36,0x3f,0x48,0x41,0x5a,0x53,0x6c,0x65,0x7e,0x77,
+       0x90,0x99,0x82,0x8b,0xb4,0xbd,0xa6,0xaf,0xd8,0xd1,0xca,0xc3,0xfc,0xf5,0xee,0xe7,
+       0x3b,0x32,0x29,0x20,0x1f,0x16,0x0d,0x04,0x73,0x7a,0x61,0x68,0x57,0x5e,0x45,0x4c,
+       0xab,0xa2,0xb9,0xb0,0x8f,0x86,0x9d,0x94,0xe3,0xea,0xf1,0xf8,0xc7,0xce,0xd5,0xdc,
+       0x76,0x7f,0x64,0x6d,0x52,0x5b,0x40,0x49,0x3e,0x37,0x2c,0x25,0x1a,0x13,0x08,0x01,
+       0xe6,0xef,0xf4,0xfd,0xc2,0xcb,0xd0,0xd9,0xae,0xa7,0xbc,0xb5,0x8a,0x83,0x98,0x91,
+       0x4d,0x44,0x5f,0x56,0x69,0x60,0x7b,0x72,0x05,0x0c,0x17,0x1e,0x21,0x28,0x33,0x3a,
+       0xdd,0xd4,0xcf,0xc6,0xf9,0xf0,0xeb,0xe2,0x95,0x9c,0x87,0x8e,0xb1,0xb8,0xa3,0xaa,
+       0xec,0xe5,0xfe,0xf7,0xc8,0xc1,0xda,0xd3,0xa4,0xad,0xb6,0xbf,0x80,0x89,0x92,0x9b,
+       0x7c,0x75,0x6e,0x67,0x58,0x51,0x4a,0x43,0x34,0x3d,0x26,0x2f,0x10,0x19,0x02,0x0b,
+       0xd7,0xde,0xc5,0xcc,0xf3,0xfa,0xe1,0xe8,0x9f,0x96,0x8d,0x84,0xbb,0xb2,0xa9,0xa0,
+       0x47,0x4e,0x55,0x5c,0x63,0x6a,0x71,0x78,0x0f,0x06,0x1d,0x14,0x2b,0x22,0x39,0x30,
+       0x9a,0x93,0x88,0x81,0xbe,0xb7,0xac,0xa5,0xd2,0xdb,0xc0,0xc9,0xf6,0xff,0xe4,0xed,
+       0x0a,0x03,0x18,0x11,0x2e,0x27,0x3c,0x35,0x42,0x4b,0x50,0x59,0x66,0x6f,0x74,0x7d,
+       0xa1,0xa8,0xb3,0xba,0x85,0x8c,0x97,0x9e,0xe9,0xe0,0xfb,0xf2,0xcd,0xc4,0xdf,0xd6,
+       0x31,0x38,0x23,0x2a,0x15,0x1c,0x07,0x0e,0x79,0x70,0x6b,0x62,0x5d,0x54,0x4f,0x46
+}
+
+local GF8x11 = {
+[0]=0x00,0x0b,0x16,0x1d,0x2c,0x27,0x3a,0x31,0x58,0x53,0x4e,0x45,0x74,0x7f,0x62,0x69,
+       0xb0,0xbb,0xa6,0xad,0x9c,0x97,0x8a,0x81,0xe8,0xe3,0xfe,0xf5,0xc4,0xcf,0xd2,0xd9,
+       0x7b,0x70,0x6d,0x66,0x57,0x5c,0x41,0x4a,0x23,0x28,0x35,0x3e,0x0f,0x04,0x19,0x12,
+       0xcb,0xc0,0xdd,0xd6,0xe7,0xec,0xf1,0xfa,0x93,0x98,0x85,0x8e,0xbf,0xb4,0xa9,0xa2,
+       0xf6,0xfd,0xe0,0xeb,0xda,0xd1,0xcc,0xc7,0xae,0xa5,0xb8,0xb3,0x82,0x89,0x94,0x9f,
+       0x46,0x4d,0x50,0x5b,0x6a,0x61,0x7c,0x77,0x1e,0x15,0x08,0x03,0x32,0x39,0x24,0x2f,
+       0x8d,0x86,0x9b,0x90,0xa1,0xaa,0xb7,0xbc,0xd5,0xde,0xc3,0xc8,0xf9,0xf2,0xef,0xe4,
+       0x3d,0x36,0x2b,0x20,0x11,0x1a,0x07,0x0c,0x65,0x6e,0x73,0x78,0x49,0x42,0x5f,0x54,
+       0xf7,0xfc,0xe1,0xea,0xdb,0xd0,0xcd,0xc6,0xaf,0xa4,0xb9,0xb2,0x83,0x88,0x95,0x9e,
+       0x47,0x4c,0x51,0x5a,0x6b,0x60,0x7d,0x76,0x1f,0x14,0x09,0x02,0x33,0x38,0x25,0x2e,
+       0x8c,0x87,0x9a,0x91,0xa0,0xab,0xb6,0xbd,0xd4,0xdf,0xc2,0xc9,0xf8,0xf3,0xee,0xe5,
+       0x3c,0x37,0x2a,0x21,0x10,0x1b,0x06,0x0d,0x64,0x6f,0x72,0x79,0x48,0x43,0x5e,0x55,
+       0x01,0x0a,0x17,0x1c,0x2d,0x26,0x3b,0x30,0x59,0x52,0x4f,0x44,0x75,0x7e,0x63,0x68,
+       0xb1,0xba,0xa7,0xac,0x9d,0x96,0x8b,0x80,0xe9,0xe2,0xff,0xf4,0xc5,0xce,0xd3,0xd8,
+       0x7a,0x71,0x6c,0x67,0x56,0x5d,0x40,0x4b,0x22,0x29,0x34,0x3f,0x0e,0x05,0x18,0x13,
+       0xca,0xc1,0xdc,0xd7,0xe6,0xed,0xf0,0xfb,0x92,0x99,0x84,0x8f,0xbe,0xb5,0xa8,0xa3
+}
+
+local GF8x13 = {
+[0]=0x00,0x0d,0x1a,0x17,0x34,0x39,0x2e,0x23,0x68,0x65,0x72,0x7f,0x5c,0x51,0x46,0x4b,
+       0xd0,0xdd,0xca,0xc7,0xe4,0xe9,0xfe,0xf3,0xb8,0xb5,0xa2,0xaf,0x8c,0x81,0x96,0x9b,
+       0xbb,0xb6,0xa1,0xac,0x8f,0x82,0x95,0x98,0xd3,0xde,0xc9,0xc4,0xe7,0xea,0xfd,0xf0,
+       0x6b,0x66,0x71,0x7c,0x5f,0x52,0x45,0x48,0x03,0x0e,0x19,0x14,0x37,0x3a,0x2d,0x20,
+       0x6d,0x60,0x77,0x7a,0x59,0x54,0x43,0x4e,0x05,0x08,0x1f,0x12,0x31,0x3c,0x2b,0x26,
+       0xbd,0xb0,0xa7,0xaa,0x89,0x84,0x93,0x9e,0xd5,0xd8,0xcf,0xc2,0xe1,0xec,0xfb,0xf6,
+       0xd6,0xdb,0xcc,0xc1,0xe2,0xef,0xf8,0xf5,0xbe,0xb3,0xa4,0xa9,0x8a,0x87,0x90,0x9d,
+       0x06,0x0b,0x1c,0x11,0x32,0x3f,0x28,0x25,0x6e,0x63,0x74,0x79,0x5a,0x57,0x40,0x4d,
+       0xda,0xd7,0xc0,0xcd,0xee,0xe3,0xf4,0xf9,0xb2,0xbf,0xa8,0xa5,0x86,0x8b,0x9c,0x91,
+       0x0a,0x07,0x10,0x1d,0x3e,0x33,0x24,0x29,0x62,0x6f,0x78,0x75,0x56,0x5b,0x4c,0x41,
+       0x61,0x6c,0x7b,0x76,0x55,0x58,0x4f,0x42,0x09,0x04,0x13,0x1e,0x3d,0x30,0x27,0x2a,
+       0xb1,0xbc,0xab,0xa6,0x85,0x88,0x9f,0x92,0xd9,0xd4,0xc3,0xce,0xed,0xe0,0xf7,0xfa,
+       0xb7,0xba,0xad,0xa0,0x83,0x8e,0x99,0x94,0xdf,0xd2,0xc5,0xc8,0xeb,0xe6,0xf1,0xfc,
+       0x67,0x6a,0x7d,0x70,0x53,0x5e,0x49,0x44,0x0f,0x02,0x15,0x18,0x3b,0x36,0x21,0x2c,
+       0x0c,0x01,0x16,0x1b,0x38,0x35,0x22,0x2f,0x64,0x69,0x7e,0x73,0x50,0x5d,0x4a,0x47,
+       0xdc,0xd1,0xc6,0xcb,0xe8,0xe5,0xf2,0xff,0xb4,0xb9,0xae,0xa3,0x80,0x8d,0x9a,0x97
+}
+
+local GF8x14 = {
+[0]=0x00,0x0e,0x1c,0x12,0x38,0x36,0x24,0x2a,0x70,0x7e,0x6c,0x62,0x48,0x46,0x54,0x5a,
+       0xe0,0xee,0xfc,0xf2,0xd8,0xd6,0xc4,0xca,0x90,0x9e,0x8c,0x82,0xa8,0xa6,0xb4,0xba,
+       0xdb,0xd5,0xc7,0xc9,0xe3,0xed,0xff,0xf1,0xab,0xa5,0xb7,0xb9,0x93,0x9d,0x8f,0x81,
+       0x3b,0x35,0x27,0x29,0x03,0x0d,0x1f,0x11,0x4b,0x45,0x57,0x59,0x73,0x7d,0x6f,0x61,
+       0xad,0xa3,0xb1,0xbf,0x95,0x9b,0x89,0x87,0xdd,0xd3,0xc1,0xcf,0xe5,0xeb,0xf9,0xf7,
+       0x4d,0x43,0x51,0x5f,0x75,0x7b,0x69,0x67,0x3d,0x33,0x21,0x2f,0x05,0x0b,0x19,0x17,
+       0x76,0x78,0x6a,0x64,0x4e,0x40,0x52,0x5c,0x06,0x08,0x1a,0x14,0x3e,0x30,0x22,0x2c,
+       0x96,0x98,0x8a,0x84,0xae,0xa0,0xb2,0xbc,0xe6,0xe8,0xfa,0xf4,0xde,0xd0,0xc2,0xcc,
+       0x41,0x4f,0x5d,0x53,0x79,0x77,0x65,0x6b,0x31,0x3f,0x2d,0x23,0x09,0x07,0x15,0x1b,
+       0xa1,0xaf,0xbd,0xb3,0x99,0x97,0x85,0x8b,0xd1,0xdf,0xcd,0xc3,0xe9,0xe7,0xf5,0xfb,
+       0x9a,0x94,0x86,0x88,0xa2,0xac,0xbe,0xb0,0xea,0xe4,0xf6,0xf8,0xd2,0xdc,0xce,0xc0,
+       0x7a,0x74,0x66,0x68,0x42,0x4c,0x5e,0x50,0x0a,0x04,0x16,0x18,0x32,0x3c,0x2e,0x20,
+       0xec,0xe2,0xf0,0xfe,0xd4,0xda,0xc8,0xc6,0x9c,0x92,0x80,0x8e,0xa4,0xaa,0xb8,0xb6,
+       0x0c,0x02,0x10,0x1e,0x34,0x3a,0x28,0x26,0x7c,0x72,0x60,0x6e,0x44,0x4a,0x58,0x56,
+       0x37,0x39,0x2b,0x25,0x0f,0x01,0x13,0x1d,0x47,0x49,0x5b,0x55,0x7f,0x71,0x63,0x6d,
+       0xd7,0xd9,0xcb,0xc5,0xef,0xe1,0xf3,0xfd,0xa7,0xa9,0xbb,0xb5,0x9f,0x91,0x83,0x8d
+}
+
+local s = {
+[0]=0x63,0x7C,0x77,0x7B,0xF2,0x6B,0x6F,0xC5,0x30,0x01,0x67,0x2B,0xFE,0xD7,0xAB,0x76,
+       0xCA,0x82,0xC9,0x7D,0xFA,0x59,0x47,0xF0,0xAD,0xD4,0xA2,0xAF,0x9C,0xA4,0x72,0xC0,
+       0xB7,0xFD,0x93,0x26,0x36,0x3F,0xF7,0xCC,0x34,0xA5,0xE5,0xF1,0x71,0xD8,0x31,0x15,
+       0x04,0xC7,0x23,0xC3,0x18,0x96,0x05,0x9A,0x07,0x12,0x80,0xE2,0xEB,0x27,0xB2,0x75,
+       0x09,0x83,0x2C,0x1A,0x1B,0x6E,0x5A,0xA0,0x52,0x3B,0xD6,0xB3,0x29,0xE3,0x2F,0x84,
+       0x53,0xD1,0x00,0xED,0x20,0xFC,0xB1,0x5B,0x6A,0xCB,0xBE,0x39,0x4A,0x4C,0x58,0xCF,
+       0xD0,0xEF,0xAA,0xFB,0x43,0x4D,0x33,0x85,0x45,0xF9,0x02,0x7F,0x50,0x3C,0x9F,0xA8,
+       0x51,0xA3,0x40,0x8F,0x92,0x9D,0x38,0xF5,0xBC,0xB6,0xDA,0x21,0x10,0xFF,0xF3,0xD2,
+       0xCD,0x0C,0x13,0xEC,0x5F,0x97,0x44,0x17,0xC4,0xA7,0x7E,0x3D,0x64,0x5D,0x19,0x73,
+       0x60,0x81,0x4F,0xDC,0x22,0x2A,0x90,0x88,0x46,0xEE,0xB8,0x14,0xDE,0x5E,0x0B,0xDB,
+       0xE0,0x32,0x3A,0x0A,0x49,0x06,0x24,0x5C,0xC2,0xD3,0xAC,0x62,0x91,0x95,0xE4,0x79,
+       0xE7,0xC8,0x37,0x6D,0x8D,0xD5,0x4E,0xA9,0x6C,0x56,0xF4,0xEA,0x65,0x7A,0xAE,0x08,
+       0xBA,0x78,0x25,0x2E,0x1C,0xA6,0xB4,0xC6,0xE8,0xDD,0x74,0x1F,0x4B,0xBD,0x8B,0x8A,
+       0x70,0x3E,0xB5,0x66,0x48,0x03,0xF6,0x0E,0x61,0x35,0x57,0xB9,0x86,0xC1,0x1D,0x9E,
+       0xE1,0xF8,0x98,0x11,0x69,0xD9,0x8E,0x94,0x9B,0x1E,0x87,0xE9,0xCE,0x55,0x28,0xDF,
+       0x8C,0xA1,0x89,0x0D,0xBF,0xE6,0x42,0x68,0x41,0x99,0x2D,0x0F,0xB0,0x54,0xBB,0x16
+}
+
+local si = {
+[0]=0x52,0x09,0x6A,0xD5,0x30,0x36,0xA5,0x38,0xBF,0x40,0xA3,0x9E,0x81,0xF3,0xD7,0xFB,
+       0x7C,0xE3,0x39,0x82,0x9B,0x2F,0xFF,0x87,0x34,0x8E,0x43,0x44,0xC4,0xDE,0xE9,0xCB,
+       0x54,0x7B,0x94,0x32,0xA6,0xC2,0x23,0x3D,0xEE,0x4C,0x95,0x0B,0x42,0xFA,0xC3,0x4E,
+       0x08,0x2E,0xA1,0x66,0x28,0xD9,0x24,0xB2,0x76,0x5B,0xA2,0x49,0x6D,0x8B,0xD1,0x25,
+       0x72,0xF8,0xF6,0x64,0x86,0x68,0x98,0x16,0xD4,0xA4,0x5C,0xCC,0x5D,0x65,0xB6,0x92,
+       0x6C,0x70,0x48,0x50,0xFD,0xED,0xB9,0xDA,0x5E,0x15,0x46,0x57,0xA7,0x8D,0x9D,0x84,
+       0x90,0xD8,0xAB,0x00,0x8C,0xBC,0xD3,0x0A,0xF7,0xE4,0x58,0x05,0xB8,0xB3,0x45,0x06,
+       0xD0,0x2C,0x1E,0x8F,0xCA,0x3F,0x0F,0x02,0xC1,0xAF,0xBD,0x03,0x01,0x13,0x8A,0x6B,
+       0x3A,0x91,0x11,0x41,0x4F,0x67,0xDC,0xEA,0x97,0xF2,0xCF,0xCE,0xF0,0xB4,0xE6,0x73,
+       0x96,0xAC,0x74,0x22,0xE7,0xAD,0x35,0x85,0xE2,0xF9,0x37,0xE8,0x1C,0x75,0xDF,0x6E,
+       0x47,0xF1,0x1A,0x71,0x1D,0x29,0xC5,0x89,0x6F,0xB7,0x62,0x0E,0xAA,0x18,0xBE,0x1B,
+       0xFC,0x56,0x3E,0x4B,0xC6,0xD2,0x79,0x20,0x9A,0xDB,0xC0,0xFE,0x78,0xCD,0x5A,0xF4,
+       0x1F,0xDD,0xA8,0x33,0x88,0x07,0xC7,0x31,0xB1,0x12,0x10,0x59,0x27,0x80,0xEC,0x5F,
+       0x60,0x51,0x7F,0xA9,0x19,0xB5,0x4A,0x0D,0x2D,0xE5,0x7A,0x9F,0x93,0xC9,0x9C,0xEF,
+       0xA0,0xE0,0x3B,0x4D,0xAE,0x2A,0xF5,0xB0,0xC8,0xEB,0xBB,0x3C,0x83,0x53,0x99,0x61,
+       0x17,0x2B,0x04,0x7E,0xBA,0x77,0xD6,0x26,0xE1,0x69,0x14,0x63,0x55,0x21,0x0C,0x7D
+}
+
+local rcon = {
+       0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x1B,0x36,0x6C,0xD8,0xAB,0x4D
+}
+
+local xor4 = {
+[0]=0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,
+       1,0,3,2,5,4,7,6,9,8,11,10,13,12,15,14,
+       2,3,0,1,6,7,4,5,10,11,8,9,14,15,12,13,
+       3,2,1,0,7,6,5,4,11,10,9,8,15,14,13,12,
+       4,5,6,7,0,1,2,3,12,13,14,15,8,9,10,11,
+       5,4,7,6,1,0,3,2,13,12,15,14,9,8,11,10,
+       6,7,4,5,2,3,0,1,14,15,12,13,10,11,8,9,
+       7,6,5,4,3,2,1,0,15,14,13,12,11,10,9,8,
+       8,9,10,11,12,13,14,15,0,1,2,3,4,5,6,7,
+       9,8,11,10,13,12,15,14,1,0,3,2,5,4,7,6,
+       10,11,8,9,14,15,12,13,2,3,0,1,6,7,4,5,
+       11,10,9,8,15,14,13,12,3,2,1,0,7,6,5,4,
+       12,13,14,15,8,9,10,11,4,5,6,7,0,1,2,3,
+       13,12,15,14,9,8,11,10,5,4,7,6,1,0,3,2,
+       14,15,12,13,10,11,8,9,6,7,4,5,2,3,0,1,
+       15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0,
+}
+
+local function xor8(a, b)
+       local al = a % 16
+       local bl = b % 16
+       return 16 * xor4[a - al + (b - bl) / 16] + xor4[16 * al + bl]
+end
+
+local function addRoundKey(state, key)
+       for i = 1, 16 do
+               state[i] = xor8(state[i], key[i])
+       end
+end
+
+local function subBytes(state, s_box)
+       for i = 1, 16 do
+               state[i] = s_box[state[i]]
+       end
+end
+
+local function shiftRows(state)
+       state[2], state[6], state[10], state[14] =
+       state[6], state[10], state[14], state[2]
+
+       state[3], state[7], state[11], state[15] =
+       state[11], state[15], state[3], state[7]
+
+       state[4], state[8], state[12], state[16] =
+       state[16], state[4], state[8], state[12]
+end
+
+local function inv_shiftRows(state)
+       state[6], state[10], state[14], state[2] =
+       state[2], state[6], state[10], state[14]
+
+       state[11], state[15], state[3], state[7] =
+       state[3], state[7], state[11], state[15]
+
+       state[16], state[4], state[8], state[12] =
+       state[4], state[8], state[12], state[16]
+end
+
+local function mixColumns(state)
+       for i = 0, 3 do
+               local cur = i*4+1
+               local a, b, c, d = state[cur], state[cur + 1], state[cur + 2], state[cur + 3]
+               state[cur + 0] = xor8(xor8(xor8(GF8x2[a], GF8x3[b]), c), d)
+               state[cur + 1] = xor8(xor8(xor8(a, GF8x2[b]), GF8x3[c]), d)
+               state[cur + 2] = xor8(xor8(xor8(a, b), GF8x2[c]), GF8x3[d])
+               state[cur + 3] = xor8(xor8(xor8(GF8x3[a], b), c), GF8x2[d])
+       end
+end
+
+local function inv_mixColumns(state)
+       for i = 0, 3 do
+               local cur = i*4+1
+               local a, b, c, d = state[cur], state[cur + 1], state[cur + 2], state[cur + 3]
+               state[cur + 0] = xor8(xor8(xor8(GF8x14[a], GF8x11[b]), GF8x13[c]), GF8x9[d])
+               state[cur + 1] = xor8(xor8(xor8(GF8x9[a], GF8x14[b]), GF8x11[c]), GF8x13[d])
+               state[cur + 2] = xor8(xor8(xor8(GF8x13[a], GF8x9[b]), GF8x14[c]), GF8x11[d])
+               state[cur + 3] = xor8(xor8(xor8(GF8x11[a], GF8x13[b]), GF8x9[c]), GF8x14[d])
+       end
+end
+
+local function RotWord(word)
+       return { word[2], word[3], word[4], word[1] }
+end
+local function SubWord(word)
+       return { s[word[1]], s[word[2]], s[word[3]], s[word[4]] }
+end
+
+local Nk = 8   -- AES-256: 8 words (32 bytes)
+local Nr = 14  -- number of rounds
+local Nwords = 4 * (Nr + 1)
+local function schedule256(key)
+       -- key: array of 32 bytes
+       local W = {}  -- array of words: W[1..Nwords], each word = 4-byte table
+
+       for i = 1, Nk do
+               W[i] = { key[(i-1)*4+1], key[(i-1)*4+2], key[(i-1)*4+3], key[(i-1)*4+4] }
+       end
+
+       for i = Nk+1, Nwords do
+               local temp = { table.unpack(W[i-1]) }
+               if (i-1) % 8 == 0 then
+                       temp = SubWord(RotWord(temp))
+                       temp[1] = xor8(temp[1], rcon[(i-1)/8])
+               elseif (i-1) % 8 == 4 then
+                       temp = SubWord(temp)
+               end
+
+               W[i] = {
+                       xor8(W[i-8][1], temp[1]),
+                       xor8(W[i-8][2], temp[2]),
+                       xor8(W[i-8][3], temp[3]),
+                       xor8(W[i-8][4], temp[4])
+               }
+       end
+
+       -- flatten into round keys
+       local roundKeys = {}
+       for round = 0, Nr do
+               local rk = {}
+               for w = 1, 4 do
+                       local word = W[round*4 + w]
+                       for b = 1, 4 do
+                               table.insert(rk, word[b])
+                       end
+               end
+               roundKeys[round] = rk
+       end
+
+       return roundKeys
+end
+
+local function chunks(text, i)
+       local first = i * 16 + 1
+       if first > #text then
+               return
+       end
+       i = i + 1
+
+       local chunk = {text:byte(first, first + 15)}
+       for j = #chunk + 1, 16 do
+               chunk[j] = 0
+       end
+
+       return i, chunk
+end
+
+local function encrypt(state, roundKeys)
+       addRoundKey(state, roundKeys[0])
+       for round = 1, 13 do
+               subBytes(state, s)
+               shiftRows(state)
+               mixColumns(state)
+               addRoundKey(state, roundKeys[round])
+       end
+       subBytes(state, s)
+       shiftRows(state)
+       addRoundKey(state, roundKeys[14])
+end
+
+local function decrypt(state, roundKeys)
+       addRoundKey(state, roundKeys[14])
+       inv_shiftRows(state)
+       subBytes(state, si)
+       for round = 13, 1, -1 do
+               addRoundKey(state, roundKeys[round])
+               inv_mixColumns(state)
+               inv_shiftRows(state)
+               subBytes(state, si)
+       end
+       addRoundKey(state, roundKeys[0])
+end
+
+local function ECB_256(method, key, originaltext)
+       local text = {}
+       local roundKeys = schedule256(key)
+       for chunk, state in chunks, originaltext, 0 do
+               method(state, roundKeys)
+               text[chunk] = string.char(table.unpack(state))
+       end
+       return table.concat(text)
+end
+
+local function xor_block(a, b)
+       -- XORs block a with block b, byte-by-byte (modifies a)
+       for i = 1, 16 do
+               a[i] = xor8(a[i], b[i])
+       end
+end
+
+local function CBC_256_encrypt(key, iv, originaltext)
+       local roundKeys = schedule256(key)
+
+       -- copy IV
+       local prev = {table.unpack(iv)}
+
+       local out = {}
+       for chunk, state in chunks, originaltext, 0 do
+               xor_block(state, prev)
+               encrypt(state, roundKeys)
+
+               out[chunk] = string.char(table.unpack(state))
+
+               -- next prev = this ciphertext block
+               prev = {table.unpack(state)}
+       end
+
+       return table.concat(out)
+end
+
+return {
+       encrypt = encrypt;
+       decrypt = decrypt;
+       ECB_256 = ECB_256;
+       CBC_256_encrypt = CBC_256_encrypt;
+}

diff --git a/scripts/share/lua/base64.lua b/scripts/share/lua/base64.lua
new file mode 100644 (file)
index 0000000..32de332
--- /dev/null
+++ b/scripts/share/lua/base64.lua
@@ -0,0 +1,201 @@
+--[[
+
+ base64 -- v1.5.3 public domain Lua base64 encoder/decoder
+ no warranty implied; use at your own risk
+
+ Needs bit32.extract function. If not present it's implemented using BitOp
+ or Lua 5.3 native bit operators. For Lua 5.1 fallbacks to pure Lua
+ implementation inspired by Rici Lake's post:
+   http://ricilake.blogspot.co.uk/2007/10/iterating-bits-in-lua.html
+
+ author: Ilya Kolbin (iskolbin@gmail.com)
+ url: github.com/iskolbin/lbase64
+
+ COMPATIBILITY
+
+ Lua 5.1+, LuaJIT
+
+ LICENSE
+
+ See end of file for license information.
+
+--]]
+
+
+local base64 = {}
+
+local extract = _G.bit32 and _G.bit32.extract -- Lua 5.2/Lua 5.3 in compatibility mode
+if not extract then
+       if _G.bit then -- LuaJIT
+               local shl, shr, band = _G.bit.lshift, _G.bit.rshift, _G.bit.band
+               extract = function( v, from, width )
+                       return band( shr( v, from ), shl( 1, width ) - 1 )
+               end
+       elseif _G._VERSION == "Lua 5.1" then
+               extract = function( v, from, width )
+                       local w = 0
+                       local flag = 2^from
+                       for i = 0, width-1 do
+                               local flag2 = flag + flag
+                               if v % flag2 >= flag then
+                                       w = w + 2^i
+                               end
+                               flag = flag2
+                       end
+                       return w
+               end
+       else -- Lua 5.3+
+               extract = load[[return function( v, from, width )
+                       return ( v >> from ) & ((1 << width) - 1)
+               end]]()
+       end
+end
+
+
+function base64.makeencoder( s62, s63, spad )
+       local encoder = {}
+       for b64code, char in pairs{[0]='A','B','C','D','E','F','G','H','I','J',
+               'K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y',
+               'Z','a','b','c','d','e','f','g','h','i','j','k','l','m','n',
+               'o','p','q','r','s','t','u','v','w','x','y','z','0','1','2',
+               '3','4','5','6','7','8','9',s62 or '+',s63 or'/',spad or'='} do
+               encoder[b64code] = char:byte()
+       end
+       return encoder
+end
+
+function base64.makedecoder( s62, s63, spad )
+       local decoder = {}
+       for b64code, charcode in pairs( base64.makeencoder( s62, s63, spad )) do
+               decoder[charcode] = b64code
+       end
+       return decoder
+end
+
+local DEFAULT_ENCODER = base64.makeencoder()
+local DEFAULT_DECODER = base64.makedecoder()
+
+local char, concat = string.char, table.concat
+
+function base64.encode( str, encoder, usecaching )
+       encoder = encoder or DEFAULT_ENCODER
+       local t, k, n = {}, 1, #str
+       local lastn = n % 3
+       local cache = {}
+       for i = 1, n-lastn, 3 do
+               local a, b, c = str:byte( i, i+2 )
+               local v = a*0x10000 + b*0x100 + c
+               local s
+               if usecaching then
+                       s = cache[v]
+                       if not s then
+                               s = char(encoder[extract(v,18,6)], encoder[extract(v,12,6)], encoder[extract(v,6,6)], encoder[extract(v,0,6)])
+                               cache[v] = s
+                       end
+               else
+                       s = char(encoder[extract(v,18,6)], encoder[extract(v,12,6)], encoder[extract(v,6,6)], encoder[extract(v,0,6)])
+               end
+               t[k] = s
+               k = k + 1
+       end
+       if lastn == 2 then
+               local a, b = str:byte( n-1, n )
+               local v = a*0x10000 + b*0x100
+               t[k] = char(encoder[extract(v,18,6)], encoder[extract(v,12,6)], encoder[extract(v,6,6)], encoder[64])
+       elseif lastn == 1 then
+               local v = str:byte( n )*0x10000
+               t[k] = char(encoder[extract(v,18,6)], encoder[extract(v,12,6)], encoder[64], encoder[64])
+       end
+       return concat( t )
+end
+
+function base64.decode( b64, decoder, usecaching )
+       decoder = decoder or DEFAULT_DECODER
+       local pattern = '[^%w%+%/%=]'
+       if decoder then
+               local s62, s63
+               for charcode, b64code in pairs( decoder ) do
+                       if b64code == 62 then s62 = charcode
+                       elseif b64code == 63 then s63 = charcode
+                       end
+               end
+               pattern = ('[^%%w%%%s%%%s%%=]'):format( char(s62), char(s63) )
+       end
+       b64 = b64:gsub( pattern, '' )
+       local cache = usecaching and {}
+       local t, k = {}, 1
+       local n = #b64
+       local padding = b64:sub(-2) == '==' and 2 or b64:sub(-1) == '=' and 1 or 0
+       for i = 1, padding > 0 and n-4 or n, 4 do
+               local a, b, c, d = b64:byte( i, i+3 )
+               local s
+               if usecaching then
+                       local v0 = a*0x1000000 + b*0x10000 + c*0x100 + d
+                       s = cache[v0]
+                       if not s then
+                               local v = decoder[a]*0x40000 + decoder[b]*0x1000 + decoder[c]*0x40 + decoder[d]
+                               s = char( extract(v,16,8), extract(v,8,8), extract(v,0,8))
+                               cache[v0] = s
+                       end
+               else
+                       local v = decoder[a]*0x40000 + decoder[b]*0x1000 + decoder[c]*0x40 + decoder[d]
+                       s = char( extract(v,16,8), extract(v,8,8), extract(v,0,8))
+               end
+               t[k] = s
+               k = k + 1
+       end
+       if padding == 1 then
+               local a, b, c = b64:byte( n-3, n-1 )
+               local v = decoder[a]*0x40000 + decoder[b]*0x1000 + decoder[c]*0x40
+               t[k] = char( extract(v,16,8), extract(v,8,8))
+       elseif padding == 2 then
+               local a, b = b64:byte( n-3, n-2 )
+               local v = decoder[a]*0x40000 + decoder[b]*0x1000
+               t[k] = char( extract(v,16,8))
+       end
+       return concat( t )
+end
+
+return base64
+
+--[[
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2018 Ilya Kolbin
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------
+--]]