22550936672

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

Build # 22550936672

Build Type

Pull #14924

github

Committed by

web-flow

Commit Message

github-actions: bump actions/download-artifact from 7.0.0 to 8.0.0

Bumps [actions/download-artifact](https://github.com/actions/download-artifact) from 7.0.0 to 8.0.0.
- [Release notes](https://github.com/actions/download-artifact/releases)
- [Commits](https://github.com/actions/download-artifact/compare/37930b1c2...70fc10c6e)

---
updated-dependencies:
- dependency-name: actions/download-artifact
  dependency-version: 8.0.0
  dependency-type: direct:production
  update-type: version-update:semver-major
...

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

Pull Request Pull Request #14924: github-actions: bump actions/download-artifact from 7.0.0 to 8.0.0

Run Details

238036 of 316972 relevant lines covered (75.1%)

2384615.4 hits per line

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

0.0

/src/util-lua-ssh.c

/* Copyright (C) 2014 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.
 */


/**
 * \file
 *
 * \author Mats Klepsland <mats.klepsland@gmail.com>
 *
 */

#include "suricata-common.h"
#include "util-lua-ssh.h"
#include "util-lua.h"
#include "util-lua-common.h"
#include "rust.h"

// #define SSH_MT "suricata:ssh:tx"
static const char ssh_tx[] = "suricata:ssh:tx";

struct LuaTx {
    void *tx; // SSHTransaction
};

static int LuaSshGetTx(lua_State *L)
{
    if (!(LuaStateNeedProto(L, ALPROTO_SSH))) {
        return LuaCallbackError(L, "error: protocol not ssh");
    }
    void *tx = LuaStateGetTX(L);
    if (tx == NULL) {
        return LuaCallbackError(L, "error: no tx available");
    }
    struct LuaTx *ltx = (struct LuaTx *)lua_newuserdata(L, sizeof(*ltx));
    if (ltx == NULL) {
        return LuaCallbackError(L, "error: fail to allocate user data");
    }
    ltx->tx = tx;

    luaL_getmetatable(L, ssh_tx);
    lua_setmetatable(L, -2);

    return 1;
}

static int LuaSshTxGetProto(lua_State *L, uint8_t flags)
{
    const uint8_t *buf = NULL;
    uint32_t b_len = 0;
    struct LuaTx *ltx = luaL_testudata(L, 1, ssh_tx);
    if (ltx == NULL) {
        lua_pushnil(L);
        return 1;
    }
    if (!SCSshTxGetProtocol(ltx->tx, flags, &buf, &b_len)) {
        lua_pushnil(L);
        return 1;
    }
    return LuaPushStringBuffer(L, buf, b_len);
}

static int LuaSshTxGetServerProto(lua_State *L)
{
    return LuaSshTxGetProto(L, STREAM_TOCLIENT);
}

static int LuaSshTxGetClientProto(lua_State *L)
{
    return LuaSshTxGetProto(L, STREAM_TOSERVER);
}

static int LuaSshTxGetSoftware(lua_State *L, uint8_t flags)
{
    const uint8_t *buf = NULL;
    uint32_t b_len = 0;
    struct LuaTx *ltx = luaL_testudata(L, 1, ssh_tx);
    if (ltx == NULL) {
        lua_pushnil(L);
        return 1;
    }
    if (!SCSshTxGetSoftware(ltx->tx, flags, &buf, &b_len)) {
        lua_pushnil(L);
        return 1;
    }
    return LuaPushStringBuffer(L, buf, b_len);
}

static int LuaSshTxGetServerSoftware(lua_State *L)
{
    return LuaSshTxGetSoftware(L, STREAM_TOCLIENT);
}

static int LuaSshTxGetClientSoftware(lua_State *L)
{
    return LuaSshTxGetSoftware(L, STREAM_TOSERVER);
}

static int LuaSshTxGetHassh(lua_State *L, uint8_t flags)
{
    const uint8_t *buf = NULL;
    uint32_t b_len = 0;
    struct LuaTx *ltx = luaL_testudata(L, 1, ssh_tx);
    if (ltx == NULL) {
        lua_pushnil(L);
        return 1;
    }
    if (SCSshTxGetHassh(ltx->tx, flags, &buf, &b_len) != 1) {
        lua_pushnil(L);
        return 1;
    }
    return LuaPushStringBuffer(L, buf, b_len);
}

static int LuaSshTxGetClientHassh(lua_State *L)
{
    return LuaSshTxGetHassh(L, STREAM_TOSERVER);
}

static int LuaSshTxGetServerHassh(lua_State *L)
{
    return LuaSshTxGetHassh(L, STREAM_TOCLIENT);
}

static int LuaSshTxGetHasshString(lua_State *L, uint8_t flags)
{
    const uint8_t *buf = NULL;
    uint32_t b_len = 0;
    struct LuaTx *ltx = luaL_testudata(L, 1, ssh_tx);
    if (ltx == NULL) {
        lua_pushnil(L);
        return 1;
    }
    if (SCSshTxGetHasshString(ltx->tx, flags, &buf, &b_len) != 1) {
        lua_pushnil(L);
        return 1;
    }
    return LuaPushStringBuffer(L, buf, b_len);
}

static int LuaSshTxGetClientHasshString(lua_State *L)
{
    return LuaSshTxGetHasshString(L, STREAM_TOSERVER);
}

static int LuaSshTxGetServerHasshString(lua_State *L)
{
    return LuaSshTxGetHasshString(L, STREAM_TOCLIENT);
}

static const struct luaL_Reg txlib[] = {
    // clang-format off
    { "server_proto", LuaSshTxGetServerProto },
    { "server_software", LuaSshTxGetServerSoftware },
    { "client_proto", LuaSshTxGetClientProto },
    { "client_software", LuaSshTxGetClientSoftware },
    { "client_hassh", LuaSshTxGetClientHassh },
    { "server_hassh", LuaSshTxGetServerHassh },
    { "client_hassh_string", LuaSshTxGetClientHasshString },
    { "server_hassh_string", LuaSshTxGetServerHasshString },
    { NULL, NULL, }
    // clang-format on
};

static int LuaSshEnableHassh(lua_State *L)
{
    SCSshEnableHassh();
    return 1;
}

static const struct luaL_Reg sshlib[] = {
    // clang-format off
    { "get_tx", LuaSshGetTx },
    { "enable_hassh", LuaSshEnableHassh },
    { NULL, NULL,},
    // clang-format on
};

int SCLuaLoadSshLib(lua_State *L)
{
    luaL_newmetatable(L, ssh_tx);
    lua_pushvalue(L, -1);
    lua_setfield(L, -2, "__index");
    luaL_setfuncs(L, txlib, 0);

    luaL_newlib(L, sshlib);
    return 1;
}

1	/* Copyright (C) 2014 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
19	/**
20	* \file
21	*
22	* \author Mats Klepsland <mats.klepsland@gmail.com>
23	*
24	*/
25
26	#include "suricata-common.h"
27	#include "util-lua-ssh.h"
28	#include "util-lua.h"
29	#include "util-lua-common.h"
30	#include "rust.h"
31
32	// #define SSH_MT "suricata:ssh:tx"
33	static const char ssh_tx[] = "suricata:ssh:tx";
34
35	struct LuaTx {
36	void *tx; // SSHTransaction
37	};
38
39	static int LuaSshGetTx(lua_State *L)
40	{	×
41	if (!(LuaStateNeedProto(L, ALPROTO_SSH))) {	×
42	return LuaCallbackError(L, "error: protocol not ssh");	×
43	}	×
44	void *tx = LuaStateGetTX(L);	×
45	if (tx == NULL) {	×
46	return LuaCallbackError(L, "error: no tx available");	×
47	}	×
48	struct LuaTx ltx = (struct LuaTx )lua_newuserdata(L, sizeof(*ltx));	×
49	if (ltx == NULL) {	×
50	return LuaCallbackError(L, "error: fail to allocate user data");	×
51	}	×
52	ltx->tx = tx;	×
53
54	luaL_getmetatable(L, ssh_tx);	×
55	lua_setmetatable(L, -2);	×
56
57	return 1;	×
58	}	×
59
60	static int LuaSshTxGetProto(lua_State *L, uint8_t flags)
61	{	×
62	const uint8_t *buf = NULL;	×
63	uint32_t b_len = 0;	×
64	struct LuaTx *ltx = luaL_testudata(L, 1, ssh_tx);	×
65	if (ltx == NULL) {	×
66	lua_pushnil(L);	×
67	return 1;	×
68	}	×
69	if (!SCSshTxGetProtocol(ltx->tx, flags, &buf, &b_len)) {	×
70	lua_pushnil(L);	×
71	return 1;	×
72	}	×
73	return LuaPushStringBuffer(L, buf, b_len);	×
74	}	×
75
76	static int LuaSshTxGetServerProto(lua_State *L)
77	{	×
78	return LuaSshTxGetProto(L, STREAM_TOCLIENT);	×
79	}	×
80
81	static int LuaSshTxGetClientProto(lua_State *L)
82	{	×
83	return LuaSshTxGetProto(L, STREAM_TOSERVER);	×
84	}	×
85
86	static int LuaSshTxGetSoftware(lua_State *L, uint8_t flags)
87	{	×
88	const uint8_t *buf = NULL;	×
89	uint32_t b_len = 0;	×
90	struct LuaTx *ltx = luaL_testudata(L, 1, ssh_tx);	×
91	if (ltx == NULL) {	×
92	lua_pushnil(L);	×
93	return 1;	×
94	}	×
95	if (!SCSshTxGetSoftware(ltx->tx, flags, &buf, &b_len)) {	×
96	lua_pushnil(L);	×
97	return 1;	×
98	}	×
99	return LuaPushStringBuffer(L, buf, b_len);	×
100	}	×
101
102	static int LuaSshTxGetServerSoftware(lua_State *L)
103	{	×
104	return LuaSshTxGetSoftware(L, STREAM_TOCLIENT);	×
105	}	×
106
107	static int LuaSshTxGetClientSoftware(lua_State *L)
108	{	×
109	return LuaSshTxGetSoftware(L, STREAM_TOSERVER);	×
110	}	×
111
112	static int LuaSshTxGetHassh(lua_State *L, uint8_t flags)
113	{	×
114	const uint8_t *buf = NULL;	×
115	uint32_t b_len = 0;	×
116	struct LuaTx *ltx = luaL_testudata(L, 1, ssh_tx);	×
117	if (ltx == NULL) {	×
118	lua_pushnil(L);	×
119	return 1;	×
120	}	×
121	if (SCSshTxGetHassh(ltx->tx, flags, &buf, &b_len) != 1) {	×
122	lua_pushnil(L);	×
123	return 1;	×
124	}	×
125	return LuaPushStringBuffer(L, buf, b_len);	×
126	}	×
127
128	static int LuaSshTxGetClientHassh(lua_State *L)
129	{	×
130	return LuaSshTxGetHassh(L, STREAM_TOSERVER);	×
131	}	×
132
133	static int LuaSshTxGetServerHassh(lua_State *L)
134	{	×
135	return LuaSshTxGetHassh(L, STREAM_TOCLIENT);	×
136	}	×
137
138	static int LuaSshTxGetHasshString(lua_State *L, uint8_t flags)
139	{	×
140	const uint8_t *buf = NULL;	×
141	uint32_t b_len = 0;	×
142	struct LuaTx *ltx = luaL_testudata(L, 1, ssh_tx);	×
143	if (ltx == NULL) {	×
144	lua_pushnil(L);	×
145	return 1;	×
146	}	×
147	if (SCSshTxGetHasshString(ltx->tx, flags, &buf, &b_len) != 1) {	×
148	lua_pushnil(L);	×
149	return 1;	×
150	}	×
151	return LuaPushStringBuffer(L, buf, b_len);	×
152	}	×
153
154	static int LuaSshTxGetClientHasshString(lua_State *L)
155	{	×
156	return LuaSshTxGetHasshString(L, STREAM_TOSERVER);	×
157	}	×
158
159	static int LuaSshTxGetServerHasshString(lua_State *L)
160	{	×
161	return LuaSshTxGetHasshString(L, STREAM_TOCLIENT);	×
162	}	×
163
164	static const struct luaL_Reg txlib[] = {
165	// clang-format off
166	{ "server_proto", LuaSshTxGetServerProto },
167	{ "server_software", LuaSshTxGetServerSoftware },
168	{ "client_proto", LuaSshTxGetClientProto },
169	{ "client_software", LuaSshTxGetClientSoftware },
170	{ "client_hassh", LuaSshTxGetClientHassh },
171	{ "server_hassh", LuaSshTxGetServerHassh },
172	{ "client_hassh_string", LuaSshTxGetClientHasshString },
173	{ "server_hassh_string", LuaSshTxGetServerHasshString },
174	{ NULL, NULL, }
175	// clang-format on
176	};
177
178	static int LuaSshEnableHassh(lua_State *L)
179	{	×
180	SCSshEnableHassh();	×
181	return 1;	×
182	}	×
183
184	static const struct luaL_Reg sshlib[] = {
185	// clang-format off
186	{ "get_tx", LuaSshGetTx },
187	{ "enable_hassh", LuaSshEnableHassh },
188	{ NULL, NULL,},
189	// clang-format on
190	};
191
192	int SCLuaLoadSshLib(lua_State *L)
193	{	×
194	luaL_newmetatable(L, ssh_tx);	×
195	lua_pushvalue(L, -1);	×
196	lua_setfield(L, -2, "__index");	×
197	luaL_setfuncs(L, txlib, 0);	×
198
199	luaL_newlib(L, sshlib);	×
200	return 1;	×
201	}	×

OISF / suricata / 22550936672

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