22550934724

Committed 01 Mar 2026 07:34PM UTC coverage: 75.853% (+2.2%) from 73.687%

Build # 22550934724

Build Type

Pull #14923

github

Committed by

web-flow

Commit Message

github-actions: bump github/codeql-action from 4.32.3 to 4.32.4

Bumps [github/codeql-action](https://github.com/github/codeql-action) from 4.32.3 to 4.32.4.
- [Release notes](https://github.com/github/codeql-action/releases)
- [Commits](https://github.com/github/codeql-action/compare/v4.32.3...v4.32.4)

---
updated-dependencies:
- dependency-name: github/codeql-action
  dependency-version: 4.32.4
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

Pull Request Pull Request #14923: github-actions: bump github/codeql-action from 4.32.3 to 4.32.4

Run Details

240804 of 317461 relevant lines covered (75.85%)

2441195.36 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/util-lua-base64lib.c

/* Copyright (C) 2025 Open Information Security Foundation
 *
 * You can copy, redistribute or modify this Program under the terms of
 * the GNU General Public License version 2 as published by the Free
 * Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * version 2 along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */

#include "suricata-common.h"
#include "util-lua-base64lib.h"
#include "util-validate.h"
#include "lauxlib.h"
#include "rust.h"

static int LuaBase64Encode(lua_State *L, SCBase64Mode mode)
{
    size_t input_len;
    const char *input = luaL_checklstring(L, 1, &input_len);
    size_t out_len = SCBase64EncodeBufferSize(input_len);
    char *output = SCCalloc(out_len + 1, sizeof(char));
    if (output == NULL) {
        return luaL_error(L, "malloc");
    }
    if (SCBase64EncodeWithMode((uint8_t *)input, (unsigned long)input_len, (u_char *)output,
                (unsigned long *)&out_len, mode) != 0) {
        SCFree(output);
        return luaL_error(L, "base64 encoding failed");
    }
    lua_pushstring(L, (const char *)output);
    SCFree(output);

    return 1;
}

static int LuaBase64EncodeStandard(lua_State *L)
{
    return LuaBase64Encode(L, SCBase64ModeStrict);
}

static int LuaBase64EncodeStandardNoPad(lua_State *L)
{
    return LuaBase64Encode(L, SCBase64ModeNoPad);
}

static int LuaBase64Decode(lua_State *L, SCBase64Mode mode)
{
    size_t input_len;
    const char *input = luaL_checklstring(L, 1, &input_len);
    char *output = SCCalloc(input_len, sizeof(char));
    if (output == NULL) {
        return luaL_error(L, "malloc");
    }
    uint32_t n = SCBase64Decode((uint8_t *)input, (uintptr_t)input_len, mode, (uint8_t *)output);
    if (n == 0) {
        SCFree(output);
        return luaL_error(L, "base64 decoding failed");
    }
    DEBUG_VALIDATE_BUG_ON(n > input_len);
    output[n] = '\0';
    lua_pushstring(L, (const char *)output);
    SCFree(output);

    return 1;
}

static int LuaBase64DecodeStandard(lua_State *L)
{
    return LuaBase64Decode(L, SCBase64ModeStrict);
}

static int LuaBase64DecodeStandardNoPad(lua_State *L)
{
    return LuaBase64Decode(L, SCBase64ModeNoPad);
}

static int LuaBase64DecodeStandardPadOpt(lua_State *L)
{
    return LuaBase64Decode(L, SCBase64ModePadOpt);
}

static int LuaBase64DecodeRFC2045(lua_State *L)
{
    return LuaBase64Decode(L, SCBase64ModeRFC2045);
}

static int LuaBase64DecodeRFC4648(lua_State *L)
{
    return LuaBase64Decode(L, SCBase64ModeRFC4648);
}

static const struct luaL_Reg base64lib[] = {
    // clang-format off
    { "encode", LuaBase64EncodeStandard },
    { "encode_nopad", LuaBase64EncodeStandardNoPad },
    { "decode", LuaBase64DecodeStandard },
    { "decode_nopad", LuaBase64DecodeStandardNoPad },
    { "decode_padopt", LuaBase64DecodeStandardPadOpt },
    { "decode_rfc2045", LuaBase64DecodeRFC2045 },
    { "decode_rfc4648", LuaBase64DecodeRFC4648 },
    { NULL, NULL },
    // clang-format on
};

int SCLuaLoadBase64Lib(lua_State *L)
{
    luaL_newlib(L, base64lib);

    return 1;
}

1	/* Copyright (C) 2025 Open Information Security Foundation
2	*
3	* You can copy, redistribute or modify this Program under the terms of
4	* the GNU General Public License version 2 as published by the Free
5	* Software Foundation.
6	*
7	* This program is distributed in the hope that it will be useful,
8	* but WITHOUT ANY WARRANTY; without even the implied warranty of
9	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10	* GNU General Public License for more details.
11	*
12	* You should have received a copy of the GNU General Public License
13	* version 2 along with this program; if not, write to the Free Software
14	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
15	* 02110-1301, USA.
16	*/
17
18	#include "suricata-common.h"
19	#include "util-lua-base64lib.h"
20	#include "util-validate.h"
21	#include "lauxlib.h"
22	#include "rust.h"
23
24	static int LuaBase64Encode(lua_State *L, SCBase64Mode mode)
25	{	×
26	size_t input_len;	×
27	const char *input = luaL_checklstring(L, 1, &input_len);	×
28	size_t out_len = SCBase64EncodeBufferSize(input_len);	×
29	char *output = SCCalloc(out_len + 1, sizeof(char));	×
30	if (output == NULL) {	×
31	return luaL_error(L, "malloc");	×
32	}	×
33	if (SCBase64EncodeWithMode((uint8_t )input, (unsigned long)input_len, (u_char )output,	×
34	(unsigned long *)&out_len, mode) != 0) {	×
35	SCFree(output);	×
36	return luaL_error(L, "base64 encoding failed");	×
37	}	×
38	lua_pushstring(L, (const char *)output);	×
39	SCFree(output);	×
40
41	return 1;	×
42	}	×
43
44	static int LuaBase64EncodeStandard(lua_State *L)
45	{	×
46	return LuaBase64Encode(L, SCBase64ModeStrict);	×
47	}	×
48
49	static int LuaBase64EncodeStandardNoPad(lua_State *L)
50	{	×
51	return LuaBase64Encode(L, SCBase64ModeNoPad);	×
52	}	×
53
54	static int LuaBase64Decode(lua_State *L, SCBase64Mode mode)
55	{	×
56	size_t input_len;	×
57	const char *input = luaL_checklstring(L, 1, &input_len);	×
58	char *output = SCCalloc(input_len, sizeof(char));	×
59	if (output == NULL) {	×
60	return luaL_error(L, "malloc");	×
61	}	×
62	uint32_t n = SCBase64Decode((uint8_t )input, (uintptr_t)input_len, mode, (uint8_t )output);	×
63	if (n == 0) {	×
64	SCFree(output);	×
65	return luaL_error(L, "base64 decoding failed");	×
66	}	×
67	DEBUG_VALIDATE_BUG_ON(n > input_len);	×
68	output[n] = '\0';	×
69	lua_pushstring(L, (const char *)output);	×
70	SCFree(output);	×
71
72	return 1;	×
73	}	×
74
75	static int LuaBase64DecodeStandard(lua_State *L)
76	{	×
77	return LuaBase64Decode(L, SCBase64ModeStrict);	×
78	}	×
79
80	static int LuaBase64DecodeStandardNoPad(lua_State *L)
81	{	×
82	return LuaBase64Decode(L, SCBase64ModeNoPad);	×
83	}	×
84
85	static int LuaBase64DecodeStandardPadOpt(lua_State *L)
86	{	×
87	return LuaBase64Decode(L, SCBase64ModePadOpt);	×
88	}	×
89
90	static int LuaBase64DecodeRFC2045(lua_State *L)
91	{	×
92	return LuaBase64Decode(L, SCBase64ModeRFC2045);	×
93	}	×
94
95	static int LuaBase64DecodeRFC4648(lua_State *L)
96	{	×
97	return LuaBase64Decode(L, SCBase64ModeRFC4648);	×
98	}	×
99
100	static const struct luaL_Reg base64lib[] = {
101	// clang-format off
102	{ "encode", LuaBase64EncodeStandard },
103	{ "encode_nopad", LuaBase64EncodeStandardNoPad },
104	{ "decode", LuaBase64DecodeStandard },
105	{ "decode_nopad", LuaBase64DecodeStandardNoPad },
106	{ "decode_padopt", LuaBase64DecodeStandardPadOpt },
107	{ "decode_rfc2045", LuaBase64DecodeRFC2045 },
108	{ "decode_rfc4648", LuaBase64DecodeRFC4648 },
109	{ NULL, NULL },
110	// clang-format on
111	};
112
113	int SCLuaLoadBase64Lib(lua_State *L)
114	{	×
115	luaL_newlib(L, base64lib);	×
116
117	return 1;	×
118	}	×

OISF / suricata / 22550934724

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous