22 Sep 23:24

57aed45

release/0.1.47

Full Changelog: release/0.1.46...release/0.1.47

COMMANDS.md Documentation by readmeneitor.py

init

Initializer for the LazyOwnShell class.

This method sets up the initial parameters and scripts for an instance of
the LazyOwnShell class. It initializes a dictionary of parameters with default
values and a list of script names that are part of the LazyOwnShell toolkit.

Attributes:
params (dict): A dictionary of parameters with their default values.
scripts (list): A list of script names included in the toolkit.
output (str): An empty string to store output or results.

default

Handles undefined commands, including aliases.

This method checks if a given command (or its alias) exists within the class
by attempting to find a corresponding method. If the command or alias is not
found, it prints an error message.

:param line: The command or alias to be handled.
:type line: str
:return: None

one_cmd

Internal function to execute commands.

This method attempts to execute a given command using onecmd and captures
the output. It sets the output attribute based on whether the command was
executed successfully or an exception occurred.

:param command: The command to be executed.
:type command: str
:return: A message indicating the result of the command execution.
:rtype: str

emptyline

Handle the case where the user enters an empty line.

This method is called when the user submits an empty line of input in
the command-line interface. By default, it provides feedback indicating
that no command was entered.

It is useful for providing user-friendly messages or handling empty input
cases in a custom manner.

License: This function is part of a program released under the GNU General
Public License v3.0 (GPLv3). You can redistribute it and/or modify it
under the terms of the GPLv3, as published by the Free Software Foundation.

Note: This method is called by the cmd library when an empty line is
entered. You can override it in a subclass to change its behavior.

Example:
>>> shell = LazyOwnShell()
>>> shell.emptyline()
You didn't enter any command.

EOF

Handle the end-of-file (EOF) condition.

This method is called when the user sends an end-of-file (EOF) signal
by pressing Ctrl+D. It is typically used to handle cleanup or exit
operations when the user terminates input.

In this implementation, it prints a farewell message and returns True
to indicate that the shell should exit.

Note: This method is a part of the cmd library's command handling
system. You can override it in a subclass to customize its behavior.

Example:
>>> shell = LazyOwnShell()
>>> shell.do_EOF(None)
LazyOwn say Goodbye!
(shell exits)

postloop

Handle operations to perform after exiting the command loop.

This method is called after the command loop terminates, typically used
for performing any final cleanup or displaying messages before the program
exits.

In this implementation, it prints a message indicating that the custom
shell is exiting.

Note: This method is called automatically by the cmd library's command
loop after the loop terminates. You can override it in a subclass to
customize its behavior.

Example:
>>> shell = LazyOwnShell()
>>> shell.cmdloop() # Exits the command loop
Exiting custom LazyOwnShell.

set

Set a parameter value.

This function takes a line of input, splits it into a parameter and a value,
and sets the specified parameter to the given value if the parameter exists.

:param line: A string containing the parameter and value to be set.
Expected format: ' '.
:type line: str
:return: None
:raises: ValueError if the input line does not contain exactly two elements.

show

Show the current parameter values.

This function iterates through the current parameters and their values,
printing each parameter and its associated value.

:param line: This parameter is not used in the function.
:type line: str
:return: None

list

Lists all available scripts in the modules directory.

This method prints a list of available scripts in a formatted manner, arranging
them into columns. It shows each script with sufficient spacing for readability.

:param line: This parameter is not used in the method.
:type line: str
:return: None

run

Runs a specific LazyOwn script.

This method executes a script from the LazyOwn toolkit based on the provided
script name. If the script is not recognized, it prints an error message.
To see available scripts, use the list or help list commands.

:param line: The command line input containing the script name.
:type line: str
:return: None

lazysearch

Runs the internal module modules/lazysearch.py.

This method executes the lazysearch script from the specified path, using
the binary_name parameter from the self.params dictionary. If binary_name
is not set, it prints an error message.

:return: None

lazysearch_gui

Run the internal module located at modules/LazyOwnExplorer.py.

This method executes the LazyOwnExplorer.py script, which is used for graphical user interface (GUI) functionality within the LazyOwn framework.

The function performs the following steps:

Calls self.run_script with LazyOwnExplorer.py to execute the GUI module.

:returns: None

Manual execution:

Ensure that the modules/LazyOwnExplorer.py script is present in the modules directory.
Run the script with:
python3 modules/LazyOwnExplorer.py

Example:
To run LazyOwnExplorer.py directly, execute:
python3 modules/LazyOwnExplorer.py

Note:
- Ensure that the script has the appropriate permissions and dependencies to run.
- Verify that your environment supports GUI operations if using this script in a non-graphical environment.

lazyown

Run the internal module located at modules/lazyown.py.

This method executes the lazyown.py script, which is a core component of the LazyOwn framework.

The function performs the following steps:

Calls self.run_script with lazyown.py to execute the script.

:returns: None

Manual execution:

Ensure that the modules/lazyown.py script is present in the modules directory.
Run the script with:
python3 modules/lazyown.py

Example:
To run lazyown.py directly, execute:
python3 modules/lazyown.py

Note:
- Ensure that the script has the appropriate permissions and dependencies to run.

update_db

Run the internal module located at modules/update_db.sh.

This method executes the update_db.sh script to update the database of binary exploitables from gtofbins.

The function performs the following steps:

Executes the update_db.sh script located in the modules directory using os.system.

:returns: None

Manual execution:

Ensure that the modules/update_db.sh script is present in the modules directory.
Run the script with:
./modules/update_db.sh

Example:
To manually update the database, execute:
./modules/update_db.sh

Note:
- Ensure that the script has execute permissions.
- The script should be run with the necessary privileges if required.

lazynmap

Runs the internal module modules/lazynmap.sh for multiple Nmap scans.

This method executes the lazynmap script, using the current working directory
and the rhost parameter from the self.params dictionary as the target IP.
If rhost is not set, it prints an error message.

:return: None

lazywerkzeugdebug

Run the internal module located at modules/lazywerkzeug.py in debug mode.

This method executes the lazywerkzeug.py script with the specified parameters for remote and local hosts and ports. It is used to test Werkzeug in debug mode.

The function performs the following steps:

Retrieves the rhost, lhost, rport, and lport values from self.params.
Checks if all required parameters are set. If not, prints an error message and returns.
Calls self.run_script with lazywerkzeug.py and the specified parameters.

:param rhost: The remote host address.
:type rhost: str

:param lhost: The local host address.
:type lhost: str

:param rport: The remote port number.
:type rport: int

:param lport: The local port number.
:type lport: int

:returns: None

Manual execution:

Ensure that rhost, lhost, rport, and lport are set in self.params.
The script modules/lazywerkzeug.py should be present in the modules directory.
Run the script with:
python3 modules/lazywerkzeug.py <rhost> <rport> <lhost> <lport>

Example:
To run lazywerkzeug.py with rhost set to "127.0.0.1", rport to 5000, lhost to "localhost", and lport to 8000, set:
self.params["rhost"] = "127.0.0.1"
self.params["rport"] = 5000
self.params["lhost"] = "localhost"
self.params["lport"] = 8000
Then call:
run_lazywerkzeugdebug()

Note:
- Ensure that modules/lazywerkzeug.py has the appropriate permissions and dependencies to run.
- Verify that the specified hosts and ports are correct and available.

lazygath

Run the internal module located at modules/lazygat.sh. to gathering the sistem :)

This method executes the lazygat.sh script located in the `modul...

Assets 2

14 Sep 21:31

clcthulhu

release/0.1.46

d49e2db

release/0.1.46

Full Changelog: release/0.1.45...release/0.1.46

COMMANDS.md Documentation by readmeneitor.py

init

Initializer for the LazyOwnShell class.

default

Handles undefined commands, including aliases.

This method checks if a given command (or its alias) exists within the class
by attempting to find a corresponding method. If the command or alias is not
found, it prints an error message.

:param line: The command or alias to be handled.
:type line: str
:return: None

one_cmd

Internal function to execute commands.

This method attempts to execute a given command using onecmd and captures
the output. It sets the output attribute based on whether the command was
executed successfully or an exception occurred.

:param command: The command to be executed.
:type command: str
:return: A message indicating the result of the command execution.
:rtype: str

emptyline

Handle the case where the user enters an empty line.

This method is called when the user submits an empty line of input in
the command-line interface. By default, it provides feedback indicating
that no command was entered.

It is useful for providing user-friendly messages or handling empty input
cases in a custom manner.

Note: This method is called by the cmd library when an empty line is
entered. You can override it in a subclass to change its behavior.

Example:
>>> shell = LazyOwnShell()
>>> shell.emptyline()
You didn't enter any command.

EOF

Handle the end-of-file (EOF) condition.

This method is called when the user sends an end-of-file (EOF) signal
by pressing Ctrl+D. It is typically used to handle cleanup or exit
operations when the user terminates input.

In this implementation, it prints a farewell message and returns True
to indicate that the shell should exit.

Note: This method is a part of the cmd library's command handling
system. You can override it in a subclass to customize its behavior.

Example:
>>> shell = LazyOwnShell()
>>> shell.do_EOF(None)
LazyOwn say Goodbye!
(shell exits)

postloop

Handle operations to perform after exiting the command loop.

This method is called after the command loop terminates, typically used
for performing any final cleanup or displaying messages before the program
exits.

In this implementation, it prints a message indicating that the custom
shell is exiting.

Note: This method is called automatically by the cmd library's command
loop after the loop terminates. You can override it in a subclass to
customize its behavior.

Example:
>>> shell = LazyOwnShell()
>>> shell.cmdloop() # Exits the command loop
Exiting custom LazyOwnShell.

set

Set a parameter value.

This function takes a line of input, splits it into a parameter and a value,
and sets the specified parameter to the given value if the parameter exists.

:param line: A string containing the parameter and value to be set.
Expected format: ' '.
:type line: str
:return: None
:raises: ValueError if the input line does not contain exactly two elements.

show

Show the current parameter values.

This function iterates through the current parameters and their values,
printing each parameter and its associated value.

:param line: This parameter is not used in the function.
:type line: str
:return: None

list

Lists all available scripts in the modules directory.

This method prints a list of available scripts in a formatted manner, arranging
them into columns. It shows each script with sufficient spacing for readability.

:param line: This parameter is not used in the method.
:type line: str
:return: None

run

Runs a specific LazyOwn script.

:param line: The command line input containing the script name.
:type line: str
:return: None

lazysearch

Runs the internal module modules/lazysearch.py.

This method executes the lazysearch script from the specified path, using
the binary_name parameter from the self.params dictionary. If binary_name
is not set, it prints an error message.

:return: None

lazysearch_gui

Run the internal module located at modules/LazyOwnExplorer.py.

This method executes the LazyOwnExplorer.py script, which is used for graphical user interface (GUI) functionality within the LazyOwn framework.

The function performs the following steps:

Calls self.run_script with LazyOwnExplorer.py to execute the GUI module.

:returns: None

Manual execution:

Ensure that the modules/LazyOwnExplorer.py script is present in the modules directory.
Run the script with:
python3 modules/LazyOwnExplorer.py

Example:
To run LazyOwnExplorer.py directly, execute:
python3 modules/LazyOwnExplorer.py

Note:
- Ensure that the script has the appropriate permissions and dependencies to run.
- Verify that your environment supports GUI operations if using this script in a non-graphical environment.

lazyown

Run the internal module located at modules/lazyown.py.

This method executes the lazyown.py script, which is a core component of the LazyOwn framework.

The function performs the following steps:

Calls self.run_script with lazyown.py to execute the script.

:returns: None

Manual execution:

Ensure that the modules/lazyown.py script is present in the modules directory.
Run the script with:
python3 modules/lazyown.py

Example:
To run lazyown.py directly, execute:
python3 modules/lazyown.py

Note:
- Ensure that the script has the appropriate permissions and dependencies to run.

update_db

Run the internal module located at modules/update_db.sh.

This method executes the update_db.sh script to update the database of binary exploitables from gtofbins.

The function performs the following steps:

Executes the update_db.sh script located in the modules directory using os.system.

:returns: None

Manual execution:

Ensure that the modules/update_db.sh script is present in the modules directory.
Run the script with:
./modules/update_db.sh

Example:
To manually update the database, execute:
./modules/update_db.sh

Note:
- Ensure that the script has execute permissions.
- The script should be run with the necessary privileges if required.

lazynmap

Runs the internal module modules/lazynmap.sh for multiple Nmap scans.

:return: None

lazywerkzeugdebug

Run the internal module located at modules/lazywerkzeug.py in debug mode.

This method executes the lazywerkzeug.py script with the specified parameters for remote and local hosts and ports. It is used to test Werkzeug in debug mode.

The function performs the following steps:

Retrieves the rhost, lhost, rport, and lport values from self.params.
Checks if all required parameters are set. If not, prints an error message and returns.
Calls self.run_script with lazywerkzeug.py and the specified parameters.

:param rhost: The remote host address.
:type rhost: str

:param lhost: The local host address.
:type lhost: str

:param rport: The remote port number.
:type rport: int

:param lport: The local port number.
:type lport: int

:returns: None

Manual execution:

Ensure that rhost, lhost, rport, and lport are set in self.params.
The script modules/lazywerkzeug.py should be present in the modules directory.
Run the script with:
python3 modules/lazywerkzeug.py <rhost> <rport> <lhost> <lport>

Note:
- Ensure that modules/lazywerkzeug.py has the appropriate permissions and dependencies to run.
- Verify that the specified hosts and ports are correct and available.

lazygath

Run the internal module located at modules/lazygat.sh. to gathering the sistem :)

This method executes the lazygat.sh script located in the `modul...

Assets 2

14 Sep 08:01

clcthulhu

release/0.1.45

7618121

release/0.1.45

Full Changelog: release/0.1.44...release/0.1.45

COMMANDS.md Documentation by readmeneitor.py

init

Initializer for the LazyOwnShell class.

default

Handles undefined commands, including aliases.

This method checks if a given command (or its alias) exists within the class
by attempting to find a corresponding method. If the command or alias is not
found, it prints an error message.

:param line: The command or alias to be handled.
:type line: str
:return: None

one_cmd

Internal function to execute commands.

This method attempts to execute a given command using onecmd and captures
the output. It sets the output attribute based on whether the command was
executed successfully or an exception occurred.

:param command: The command to be executed.
:type command: str
:return: A message indicating the result of the command execution.
:rtype: str

emptyline

Handle the case where the user enters an empty line.

This method is called when the user submits an empty line of input in
the command-line interface. By default, it provides feedback indicating
that no command was entered.

It is useful for providing user-friendly messages or handling empty input
cases in a custom manner.

Note: This method is called by the cmd library when an empty line is
entered. You can override it in a subclass to change its behavior.

Example:
>>> shell = LazyOwnShell()
>>> shell.emptyline()
You didn't enter any command.

EOF

Handle the end-of-file (EOF) condition.

This method is called when the user sends an end-of-file (EOF) signal
by pressing Ctrl+D. It is typically used to handle cleanup or exit
operations when the user terminates input.

In this implementation, it prints a farewell message and returns True
to indicate that the shell should exit.

Note: This method is a part of the cmd library's command handling
system. You can override it in a subclass to customize its behavior.

Example:
>>> shell = LazyOwnShell()
>>> shell.do_EOF(None)
LazyOwn say Goodbye!
(shell exits)

postloop

Handle operations to perform after exiting the command loop.

This method is called after the command loop terminates, typically used
for performing any final cleanup or displaying messages before the program
exits.

In this implementation, it prints a message indicating that the custom
shell is exiting.

Note: This method is called automatically by the cmd library's command
loop after the loop terminates. You can override it in a subclass to
customize its behavior.

Example:
>>> shell = LazyOwnShell()
>>> shell.cmdloop() # Exits the command loop
Exiting custom LazyOwnShell.

set

Set a parameter value.

This function takes a line of input, splits it into a parameter and a value,
and sets the specified parameter to the given value if the parameter exists.

:param line: A string containing the parameter and value to be set.
Expected format: ' '.
:type line: str
:return: None
:raises: ValueError if the input line does not contain exactly two elements.

show

Show the current parameter values.

This function iterates through the current parameters and their values,
printing each parameter and its associated value.

:param line: This parameter is not used in the function.
:type line: str
:return: None

list

Lists all available scripts in the modules directory.

This method prints a list of available scripts in a formatted manner, arranging
them into columns. It shows each script with sufficient spacing for readability.

:param line: This parameter is not used in the method.
:type line: str
:return: None

run

Runs a specific LazyOwn script.

:param line: The command line input containing the script name.
:type line: str
:return: None

lazysearch

Runs the internal module modules/lazysearch.py.

This method executes the lazysearch script from the specified path, using
the binary_name parameter from the self.params dictionary. If binary_name
is not set, it prints an error message.

:return: None

lazysearch_gui

Run the internal module located at modules/LazyOwnExplorer.py.

This method executes the LazyOwnExplorer.py script, which is used for graphical user interface (GUI) functionality within the LazyOwn framework.

The function performs the following steps:

Calls self.run_script with LazyOwnExplorer.py to execute the GUI module.

:returns: None

Manual execution:

Ensure that the modules/LazyOwnExplorer.py script is present in the modules directory.
Run the script with:
python3 modules/LazyOwnExplorer.py

Example:
To run LazyOwnExplorer.py directly, execute:
python3 modules/LazyOwnExplorer.py

Note:
- Ensure that the script has the appropriate permissions and dependencies to run.
- Verify that your environment supports GUI operations if using this script in a non-graphical environment.

lazyown

Run the internal module located at modules/lazyown.py.

This method executes the lazyown.py script, which is a core component of the LazyOwn framework.

The function performs the following steps:

Calls self.run_script with lazyown.py to execute the script.

:returns: None

Manual execution:

Ensure that the modules/lazyown.py script is present in the modules directory.
Run the script with:
python3 modules/lazyown.py

Example:
To run lazyown.py directly, execute:
python3 modules/lazyown.py

Note:
- Ensure that the script has the appropriate permissions and dependencies to run.

update_db

Run the internal module located at modules/update_db.sh.

This method executes the update_db.sh script to update the database of binary exploitables from gtofbins.

The function performs the following steps:

Executes the update_db.sh script located in the modules directory using os.system.

:returns: None

Manual execution:

Ensure that the modules/update_db.sh script is present in the modules directory.
Run the script with:
./modules/update_db.sh

Example:
To manually update the database, execute:
./modules/update_db.sh

Note:
- Ensure that the script has execute permissions.
- The script should be run with the necessary privileges if required.

lazynmap

Runs the internal module modules/lazynmap.sh for multiple Nmap scans.

:return: None

lazywerkzeugdebug

Run the internal module located at modules/lazywerkzeug.py in debug mode.

This method executes the lazywerkzeug.py script with the specified parameters for remote and local hosts and ports. It is used to test Werkzeug in debug mode.

The function performs the following steps:

Retrieves the rhost, lhost, rport, and lport values from self.params.
Checks if all required parameters are set. If not, prints an error message and returns.
Calls self.run_script with lazywerkzeug.py and the specified parameters.

:param rhost: The remote host address.
:type rhost: str

:param lhost: The local host address.
:type lhost: str

:param rport: The remote port number.
:type rport: int

:param lport: The local port number.
:type lport: int

:returns: None

Manual execution:

Ensure that rhost, lhost, rport, and lport are set in self.params.
The script modules/lazywerkzeug.py should be present in the modules directory.
Run the script with:
python3 modules/lazywerkzeug.py <rhost> <rport> <lhost> <lport>

Note:
- Ensure that modules/lazywerkzeug.py has the appropriate permissions and dependencies to run.
- Verify that the specified hosts and ports are correct and available.

lazygath

Run the internal module located at modules/lazygat.sh. to gathering the sistem :)

This method executes the lazygat.sh script located in the `modul...

Assets 2

14 Sep 06:12

clcthulhu

release/0.1.44

e9102b1

release/0.1.44

Full Changelog: release/0.1.43...release/0.1.44

COMMANDS.md Documentation by readmeneitor.py

init

Initializer for the LazyOwnShell class.

default

Handles undefined commands, including aliases.

This method checks if a given command (or its alias) exists within the class
by attempting to find a corresponding method. If the command or alias is not
found, it prints an error message.

:param line: The command or alias to be handled.
:type line: str
:return: None

one_cmd

Internal function to execute commands.

This method attempts to execute a given command using onecmd and captures
the output. It sets the output attribute based on whether the command was
executed successfully or an exception occurred.

:param command: The command to be executed.
:type command: str
:return: A message indicating the result of the command execution.
:rtype: str

emptyline

Handle the case where the user enters an empty line.

This method is called when the user submits an empty line of input in
the command-line interface. By default, it provides feedback indicating
that no command was entered.

It is useful for providing user-friendly messages or handling empty input
cases in a custom manner.

Note: This method is called by the cmd library when an empty line is
entered. You can override it in a subclass to change its behavior.

Example:
>>> shell = LazyOwnShell()
>>> shell.emptyline()
You didn't enter any command.

EOF

Handle the end-of-file (EOF) condition.

This method is called when the user sends an end-of-file (EOF) signal
by pressing Ctrl+D. It is typically used to handle cleanup or exit
operations when the user terminates input.

In this implementation, it prints a farewell message and returns True
to indicate that the shell should exit.

Note: This method is a part of the cmd library's command handling
system. You can override it in a subclass to customize its behavior.

Example:
>>> shell = LazyOwnShell()
>>> shell.do_EOF(None)
LazyOwn say Goodbye!
(shell exits)

postloop

Handle operations to perform after exiting the command loop.

This method is called after the command loop terminates, typically used
for performing any final cleanup or displaying messages before the program
exits.

In this implementation, it prints a message indicating that the custom
shell is exiting.

Note: This method is called automatically by the cmd library's command
loop after the loop terminates. You can override it in a subclass to
customize its behavior.

Example:
>>> shell = LazyOwnShell()
>>> shell.cmdloop() # Exits the command loop
Exiting custom LazyOwnShell.

set

Set a parameter value.

This function takes a line of input, splits it into a parameter and a value,
and sets the specified parameter to the given value if the parameter exists.

:param line: A string containing the parameter and value to be set.
Expected format: ' '.
:type line: str
:return: None
:raises: ValueError if the input line does not contain exactly two elements.

show

Show the current parameter values.

This function iterates through the current parameters and their values,
printing each parameter and its associated value.

:param line: This parameter is not used in the function.
:type line: str
:return: None

list

Lists all available scripts in the modules directory.

This method prints a list of available scripts in a formatted manner, arranging
them into columns. It shows each script with sufficient spacing for readability.

:param line: This parameter is not used in the method.
:type line: str
:return: None

run

Runs a specific LazyOwn script.

:param line: The command line input containing the script name.
:type line: str
:return: None

lazysearch

Runs the internal module modules/lazysearch.py.

This method executes the lazysearch script from the specified path, using
the binary_name parameter from the self.params dictionary. If binary_name
is not set, it prints an error message.

:return: None

lazysearch_gui

Run the internal module located at modules/LazyOwnExplorer.py.

This method executes the LazyOwnExplorer.py script, which is used for graphical user interface (GUI) functionality within the LazyOwn framework.

The function performs the following steps:

Calls self.run_script with LazyOwnExplorer.py to execute the GUI module.

:returns: None

Manual execution:

Ensure that the modules/LazyOwnExplorer.py script is present in the modules directory.
Run the script with:
python3 modules/LazyOwnExplorer.py

Example:
To run LazyOwnExplorer.py directly, execute:
python3 modules/LazyOwnExplorer.py

Note:
- Ensure that the script has the appropriate permissions and dependencies to run.
- Verify that your environment supports GUI operations if using this script in a non-graphical environment.

lazyown

Run the internal module located at modules/lazyown.py.

This method executes the lazyown.py script, which is a core component of the LazyOwn framework.

The function performs the following steps:

Calls self.run_script with lazyown.py to execute the script.

:returns: None

Manual execution:

Ensure that the modules/lazyown.py script is present in the modules directory.
Run the script with:
python3 modules/lazyown.py

Example:
To run lazyown.py directly, execute:
python3 modules/lazyown.py

Note:
- Ensure that the script has the appropriate permissions and dependencies to run.

update_db

Run the internal module located at modules/update_db.sh.

This method executes the update_db.sh script to update the database of binary exploitables from gtofbins.

The function performs the following steps:

Executes the update_db.sh script located in the modules directory using os.system.

:returns: None

Manual execution:

Ensure that the modules/update_db.sh script is present in the modules directory.
Run the script with:
./modules/update_db.sh

Example:
To manually update the database, execute:
./modules/update_db.sh

Note:
- Ensure that the script has execute permissions.
- The script should be run with the necessary privileges if required.

lazynmap

Runs the internal module modules/lazynmap.sh for multiple Nmap scans.

:return: None

lazywerkzeugdebug

Run the internal module located at modules/lazywerkzeug.py in debug mode.

This method executes the lazywerkzeug.py script with the specified parameters for remote and local hosts and ports. It is used to test Werkzeug in debug mode.

The function performs the following steps:

Retrieves the rhost, lhost, rport, and lport values from self.params.
Checks if all required parameters are set. If not, prints an error message and returns.
Calls self.run_script with lazywerkzeug.py and the specified parameters.

:param rhost: The remote host address.
:type rhost: str

:param lhost: The local host address.
:type lhost: str

:param rport: The remote port number.
:type rport: int

:param lport: The local port number.
:type lport: int

:returns: None

Manual execution:

Ensure that rhost, lhost, rport, and lport are set in self.params.
The script modules/lazywerkzeug.py should be present in the modules directory.
Run the script with:
python3 modules/lazywerkzeug.py <rhost> <rport> <lhost> <lport>

Note:
- Ensure that modules/lazywerkzeug.py has the appropriate permissions and dependencies to run.
- Verify that the specified hosts and ports are correct and available.

lazygath

Run the internal module located at modules/lazygat.sh. to gathering the sistem :)

This method executes the lazygat.sh script located in the `modul...

Assets 2

12 Sep 06:39

clcthulhu

release/0.1.43

dcb1dd4

release/0.1.43

Full Changelog: release/0.1.42...release/0.1.43

COMMANDS.md Documentation by readmeneitor.py

init

Initializer for the LazyOwnShell class.

default

Handles undefined commands, including aliases.

This method checks if a given command (or its alias) exists within the class
by attempting to find a corresponding method. If the command or alias is not
found, it prints an error message.

:param line: The command or alias to be handled.
:type line: str
:return: None

one_cmd

Internal function to execute commands.

This method attempts to execute a given command using onecmd and captures
the output. It sets the output attribute based on whether the command was
executed successfully or an exception occurred.

:param command: The command to be executed.
:type command: str
:return: A message indicating the result of the command execution.
:rtype: str

emptyline

Handle the case where the user enters an empty line.

This method is called when the user submits an empty line of input in
the command-line interface. By default, it provides feedback indicating
that no command was entered.

It is useful for providing user-friendly messages or handling empty input
cases in a custom manner.

Note: This method is called by the cmd library when an empty line is
entered. You can override it in a subclass to change its behavior.

Example:
>>> shell = LazyOwnShell()
>>> shell.emptyline()
You didn't enter any command.

EOF

Handle the end-of-file (EOF) condition.

This method is called when the user sends an end-of-file (EOF) signal
by pressing Ctrl+D. It is typically used to handle cleanup or exit
operations when the user terminates input.

In this implementation, it prints a farewell message and returns True
to indicate that the shell should exit.

Note: This method is a part of the cmd library's command handling
system. You can override it in a subclass to customize its behavior.

Example:
>>> shell = LazyOwnShell()
>>> shell.do_EOF(None)
LazyOwn say Goodbye!
(shell exits)

postloop

Handle operations to perform after exiting the command loop.

This method is called after the command loop terminates, typically used
for performing any final cleanup or displaying messages before the program
exits.

In this implementation, it prints a message indicating that the custom
shell is exiting.

Note: This method is called automatically by the cmd library's command
loop after the loop terminates. You can override it in a subclass to
customize its behavior.

Example:
>>> shell = LazyOwnShell()
>>> shell.cmdloop() # Exits the command loop
Exiting custom LazyOwnShell.

set

Set a parameter value.

This function takes a line of input, splits it into a parameter and a value,
and sets the specified parameter to the given value if the parameter exists.

:param line: A string containing the parameter and value to be set.
Expected format: ' '.
:type line: str
:return: None
:raises: ValueError if the input line does not contain exactly two elements.

show

Show the current parameter values.

This function iterates through the current parameters and their values,
printing each parameter and its associated value.

:param line: This parameter is not used in the function.
:type line: str
:return: None

list

Lists all available scripts in the modules directory.

This method prints a list of available scripts in a formatted manner, arranging
them into columns. It shows each script with sufficient spacing for readability.

:param line: This parameter is not used in the method.
:type line: str
:return: None

run

Runs a specific LazyOwn script.

:param line: The command line input containing the script name.
:type line: str
:return: None

lazysearch

Runs the internal module modules/lazysearch.py.

This method executes the lazysearch script from the specified path, using
the binary_name parameter from the self.params dictionary. If binary_name
is not set, it prints an error message.

:return: None

lazysearch_gui

Run the internal module located at modules/LazyOwnExplorer.py.

This method executes the LazyOwnExplorer.py script, which is used for graphical user interface (GUI) functionality within the LazyOwn framework.

The function performs the following steps:

Calls self.run_script with LazyOwnExplorer.py to execute the GUI module.

:returns: None

Manual execution:

Ensure that the modules/LazyOwnExplorer.py script is present in the modules directory.
Run the script with:
python3 modules/LazyOwnExplorer.py

Example:
To run LazyOwnExplorer.py directly, execute:
python3 modules/LazyOwnExplorer.py

Note:
- Ensure that the script has the appropriate permissions and dependencies to run.
- Verify that your environment supports GUI operations if using this script in a non-graphical environment.

lazyown

Run the internal module located at modules/lazyown.py.

This method executes the lazyown.py script, which is a core component of the LazyOwn framework.

The function performs the following steps:

Calls self.run_script with lazyown.py to execute the script.

:returns: None

Manual execution:

Ensure that the modules/lazyown.py script is present in the modules directory.
Run the script with:
python3 modules/lazyown.py

Example:
To run lazyown.py directly, execute:
python3 modules/lazyown.py

Note:
- Ensure that the script has the appropriate permissions and dependencies to run.

update_db

Run the internal module located at modules/update_db.sh.

This method executes the update_db.sh script to update the database of binary exploitables from gtofbins.

The function performs the following steps:

Executes the update_db.sh script located in the modules directory using os.system.

:returns: None

Manual execution:

Ensure that the modules/update_db.sh script is present in the modules directory.
Run the script with:
./modules/update_db.sh

Example:
To manually update the database, execute:
./modules/update_db.sh

Note:
- Ensure that the script has execute permissions.
- The script should be run with the necessary privileges if required.

lazynmap

Runs the internal module modules/lazynmap.sh for multiple Nmap scans.

:return: None

lazywerkzeugdebug

Run the internal module located at modules/lazywerkzeug.py in debug mode.

This method executes the lazywerkzeug.py script with the specified parameters for remote and local hosts and ports. It is used to test Werkzeug in debug mode.

The function performs the following steps:

Retrieves the rhost, lhost, rport, and lport values from self.params.
Checks if all required parameters are set. If not, prints an error message and returns.
Calls self.run_script with lazywerkzeug.py and the specified parameters.

:param rhost: The remote host address.
:type rhost: str

:param lhost: The local host address.
:type lhost: str

:param rport: The remote port number.
:type rport: int

:param lport: The local port number.
:type lport: int

:returns: None

Manual execution:

Ensure that rhost, lhost, rport, and lport are set in self.params.
The script modules/lazywerkzeug.py should be present in the modules directory.
Run the script with:
python3 modules/lazywerkzeug.py <rhost> <rport> <lhost> <lport>

Note:
- Ensure that modules/lazywerkzeug.py has the appropriate permissions and dependencies to run.
- Verify that the specified hosts and ports are correct and available.

lazygath

Run the internal module located at modules/lazygat.sh. to gathering the sistem :)

This method executes the lazygat.sh script located in the `modul...

Assets 2

10 Sep 05:42

clcthulhu

release/0.1.42

dda521e

release/0.1.42

Full Changelog: release/0.1.40...release/0.1.42

COMMANDS.md Documentation by readmeneitor.py

init

Initializer for the LazyOwnShell class.

default

Handles undefined commands, including aliases.

This method checks if a given command (or its alias) exists within the class
by attempting to find a corresponding method. If the command or alias is not
found, it prints an error message.

:param line: The command or alias to be handled.
:type line: str
:return: None

one_cmd

Internal function to execute commands.

This method attempts to execute a given command using onecmd and captures
the output. It sets the output attribute based on whether the command was
executed successfully or an exception occurred.

:param command: The command to be executed.
:type command: str
:return: A message indicating the result of the command execution.
:rtype: str

emptyline

Handle the case where the user enters an empty line.

This method is called when the user submits an empty line of input in
the command-line interface. By default, it provides feedback indicating
that no command was entered.

It is useful for providing user-friendly messages or handling empty input
cases in a custom manner.

Note: This method is called by the cmd library when an empty line is
entered. You can override it in a subclass to change its behavior.

Example:
>>> shell = LazyOwnShell()
>>> shell.emptyline()
You didn't enter any command.

EOF

Handle the end-of-file (EOF) condition.

This method is called when the user sends an end-of-file (EOF) signal
by pressing Ctrl+D. It is typically used to handle cleanup or exit
operations when the user terminates input.

In this implementation, it prints a farewell message and returns True
to indicate that the shell should exit.

Note: This method is a part of the cmd library's command handling
system. You can override it in a subclass to customize its behavior.

Example:
>>> shell = LazyOwnShell()
>>> shell.do_EOF(None)
LazyOwn say Goodbye!
(shell exits)

postloop

Handle operations to perform after exiting the command loop.

This method is called after the command loop terminates, typically used
for performing any final cleanup or displaying messages before the program
exits.

In this implementation, it prints a message indicating that the custom
shell is exiting.

Note: This method is called automatically by the cmd library's command
loop after the loop terminates. You can override it in a subclass to
customize its behavior.

Example:
>>> shell = LazyOwnShell()
>>> shell.cmdloop() # Exits the command loop
Exiting custom LazyOwnShell.

set

Set a parameter value.

This function takes a line of input, splits it into a parameter and a value,
and sets the specified parameter to the given value if the parameter exists.

:param line: A string containing the parameter and value to be set.
Expected format: ' '.
:type line: str
:return: None
:raises: ValueError if the input line does not contain exactly two elements.

show

Show the current parameter values.

This function iterates through the current parameters and their values,
printing each parameter and its associated value.

:param line: This parameter is not used in the function.
:type line: str
:return: None

list

Lists all available scripts in the modules directory.

This method prints a list of available scripts in a formatted manner, arranging
them into columns. It shows each script with sufficient spacing for readability.

:param line: This parameter is not used in the method.
:type line: str
:return: None

run

Runs a specific LazyOwn script.

:param line: The command line input containing the script name.
:type line: str
:return: None

lazysearch

Runs the internal module modules/lazysearch.py.

This method executes the lazysearch script from the specified path, using
the binary_name parameter from the self.params dictionary. If binary_name
is not set, it prints an error message.

:return: None

lazysearch_gui

Run the internal module located at modules/LazyOwnExplorer.py.

This method executes the LazyOwnExplorer.py script, which is used for graphical user interface (GUI) functionality within the LazyOwn framework.

The function performs the following steps:

Calls self.run_script with LazyOwnExplorer.py to execute the GUI module.

:returns: None

Manual execution:

Ensure that the modules/LazyOwnExplorer.py script is present in the modules directory.
Run the script with:
python3 modules/LazyOwnExplorer.py

Example:
To run LazyOwnExplorer.py directly, execute:
python3 modules/LazyOwnExplorer.py

Note:
- Ensure that the script has the appropriate permissions and dependencies to run.
- Verify that your environment supports GUI operations if using this script in a non-graphical environment.

lazyown

Run the internal module located at modules/lazyown.py.

This method executes the lazyown.py script, which is a core component of the LazyOwn framework.

The function performs the following steps:

Calls self.run_script with lazyown.py to execute the script.

:returns: None

Manual execution:

Ensure that the modules/lazyown.py script is present in the modules directory.
Run the script with:
python3 modules/lazyown.py

Example:
To run lazyown.py directly, execute:
python3 modules/lazyown.py

Note:
- Ensure that the script has the appropriate permissions and dependencies to run.

update_db

Run the internal module located at modules/update_db.sh.

This method executes the update_db.sh script to update the database of binary exploitables from gtofbins.

The function performs the following steps:

Executes the update_db.sh script located in the modules directory using os.system.

:returns: None

Manual execution:

Ensure that the modules/update_db.sh script is present in the modules directory.
Run the script with:
./modules/update_db.sh

Example:
To manually update the database, execute:
./modules/update_db.sh

Note:
- Ensure that the script has execute permissions.
- The script should be run with the necessary privileges if required.

lazynmap

Runs the internal module modules/lazynmap.sh for multiple Nmap scans.

:return: None

lazywerkzeugdebug

Run the internal module located at modules/lazywerkzeug.py in debug mode.

This method executes the lazywerkzeug.py script with the specified parameters for remote and local hosts and ports. It is used to test Werkzeug in debug mode.

The function performs the following steps:

Retrieves the rhost, lhost, rport, and lport values from self.params.
Checks if all required parameters are set. If not, prints an error message and returns.
Calls self.run_script with lazywerkzeug.py and the specified parameters.

:param rhost: The remote host address.
:type rhost: str

:param lhost: The local host address.
:type lhost: str

:param rport: The remote port number.
:type rport: int

:param lport: The local port number.
:type lport: int

:returns: None

Manual execution:

Ensure that rhost, lhost, rport, and lport are set in self.params.
The script modules/lazywerkzeug.py should be present in the modules directory.
Run the script with:
python3 modules/lazywerkzeug.py <rhost> <rport> <lhost> <lport>

Note:
- Ensure that modules/lazywerkzeug.py has the appropriate permissions and dependencies to run.
- Verify that the specified hosts and ports are correct and available.

lazygath

Run the internal module located at modules/lazygat.sh. to gathering the sistem :)

This method executes the lazygat.sh script located in the `modul...

Assets 2

09 Sep 12:37

clcthulhu

release/0.1.40

405fea1

release/0.1.40

Full Changelog: release/0.1.39...release/0.1.40

COMMANDS.md Documentation by readmeneitor.py

init

Initializer for the LazyOwnShell class.

default

Handles undefined commands, including aliases.

This method checks if a given command (or its alias) exists within the class
by attempting to find a corresponding method. If the command or alias is not
found, it prints an error message.

:param line: The command or alias to be handled.
:type line: str
:return: None

one_cmd

Internal function to execute commands.

This method attempts to execute a given command using onecmd and captures
the output. It sets the output attribute based on whether the command was
executed successfully or an exception occurred.

:param command: The command to be executed.
:type command: str
:return: A message indicating the result of the command execution.
:rtype: str

emptyline

Handle the case where the user enters an empty line.

This method is called when the user submits an empty line of input in
the command-line interface. By default, it provides feedback indicating
that no command was entered.

It is useful for providing user-friendly messages or handling empty input
cases in a custom manner.

Note: This method is called by the cmd library when an empty line is
entered. You can override it in a subclass to change its behavior.

Example:
>>> shell = LazyOwnShell()
>>> shell.emptyline()
You didn't enter any command.

EOF

Handle the end-of-file (EOF) condition.

This method is called when the user sends an end-of-file (EOF) signal
by pressing Ctrl+D. It is typically used to handle cleanup or exit
operations when the user terminates input.

In this implementation, it prints a farewell message and returns True
to indicate that the shell should exit.

Note: This method is a part of the cmd library's command handling
system. You can override it in a subclass to customize its behavior.

Example:
>>> shell = LazyOwnShell()
>>> shell.do_EOF(None)
LazyOwn say Goodbye!
(shell exits)

postloop

Handle operations to perform after exiting the command loop.

This method is called after the command loop terminates, typically used
for performing any final cleanup or displaying messages before the program
exits.

In this implementation, it prints a message indicating that the custom
shell is exiting.

Note: This method is called automatically by the cmd library's command
loop after the loop terminates. You can override it in a subclass to
customize its behavior.

Example:
>>> shell = LazyOwnShell()
>>> shell.cmdloop() # Exits the command loop
Exiting custom LazyOwnShell.

set

Set a parameter value.

This function takes a line of input, splits it into a parameter and a value,
and sets the specified parameter to the given value if the parameter exists.

:param line: A string containing the parameter and value to be set.
Expected format: ' '.
:type line: str
:return: None
:raises: ValueError if the input line does not contain exactly two elements.

show

Show the current parameter values.

This function iterates through the current parameters and their values,
printing each parameter and its associated value.

:param line: This parameter is not used in the function.
:type line: str
:return: None

list

Lists all available scripts in the modules directory.

This method prints a list of available scripts in a formatted manner, arranging
them into columns. It shows each script with sufficient spacing for readability.

:param line: This parameter is not used in the method.
:type line: str
:return: None

run

Runs a specific LazyOwn script.

:param line: The command line input containing the script name.
:type line: str
:return: None

lazysearch

Runs the internal module modules/lazysearch.py.

This method executes the lazysearch script from the specified path, using
the binary_name parameter from the self.params dictionary. If binary_name
is not set, it prints an error message.

:return: None

lazysearch_gui

Run the internal module located at modules/LazyOwnExplorer.py.

This method executes the LazyOwnExplorer.py script, which is used for graphical user interface (GUI) functionality within the LazyOwn framework.

The function performs the following steps:

Calls self.run_script with LazyOwnExplorer.py to execute the GUI module.

:returns: None

Manual execution:

Ensure that the modules/LazyOwnExplorer.py script is present in the modules directory.
Run the script with:
python3 modules/LazyOwnExplorer.py

Example:
To run LazyOwnExplorer.py directly, execute:
python3 modules/LazyOwnExplorer.py

Note:
- Ensure that the script has the appropriate permissions and dependencies to run.
- Verify that your environment supports GUI operations if using this script in a non-graphical environment.

lazyown

Run the internal module located at modules/lazyown.py.

This method executes the lazyown.py script, which is a core component of the LazyOwn framework.

The function performs the following steps:

Calls self.run_script with lazyown.py to execute the script.

:returns: None

Manual execution:

Ensure that the modules/lazyown.py script is present in the modules directory.
Run the script with:
python3 modules/lazyown.py

Example:
To run lazyown.py directly, execute:
python3 modules/lazyown.py

Note:
- Ensure that the script has the appropriate permissions and dependencies to run.

update_db

Run the internal module located at modules/update_db.sh.

This method executes the update_db.sh script to update the database of binary exploitables from gtofbins.

The function performs the following steps:

Executes the update_db.sh script located in the modules directory using os.system.

:returns: None

Manual execution:

Ensure that the modules/update_db.sh script is present in the modules directory.
Run the script with:
./modules/update_db.sh

Example:
To manually update the database, execute:
./modules/update_db.sh

Note:
- Ensure that the script has execute permissions.
- The script should be run with the necessary privileges if required.

lazynmap

Runs the internal module modules/lazynmap.sh for multiple Nmap scans.

:return: None

lazywerkzeugdebug

Run the internal module located at modules/lazywerkzeug.py in debug mode.

This method executes the lazywerkzeug.py script with the specified parameters for remote and local hosts and ports. It is used to test Werkzeug in debug mode.

The function performs the following steps:

Retrieves the rhost, lhost, rport, and lport values from self.params.
Checks if all required parameters are set. If not, prints an error message and returns.
Calls self.run_script with lazywerkzeug.py and the specified parameters.

:param rhost: The remote host address.
:type rhost: str

:param lhost: The local host address.
:type lhost: str

:param rport: The remote port number.
:type rport: int

:param lport: The local port number.
:type lport: int

:returns: None

Manual execution:

Ensure that rhost, lhost, rport, and lport are set in self.params.
The script modules/lazywerkzeug.py should be present in the modules directory.
Run the script with:
python3 modules/lazywerkzeug.py <rhost> <rport> <lhost> <lport>

Note:
- Ensure that modules/lazywerkzeug.py has the appropriate permissions and dependencies to run.
- Verify that the specified hosts and ports are correct and available.

lazygath

Run the internal module located at modules/lazygat.sh. to gathering the sistem :)

This method executes the lazygat.sh script located in the `modul...

Assets 2

08 Sep 07:48

clcthulhu

release/0.1.39

634f675

release/0.1.39

Full Changelog: release/0.1.38...release/0.1.39

COMMANDS.md Documentation by readmeneitor.py

init

Initializer for the LazyOwnShell class.

default

Handles undefined commands, including aliases.

This method checks if a given command (or its alias) exists within the class
by attempting to find a corresponding method. If the command or alias is not
found, it prints an error message.

:param line: The command or alias to be handled.
:type line: str
:return: None

one_cmd

Internal function to execute commands.

This method attempts to execute a given command using onecmd and captures
the output. It sets the output attribute based on whether the command was
executed successfully or an exception occurred.

:param command: The command to be executed.
:type command: str
:return: A message indicating the result of the command execution.
:rtype: str

emptyline

Handle the case where the user enters an empty line.

This method is called when the user submits an empty line of input in
the command-line interface. By default, it provides feedback indicating
that no command was entered.

It is useful for providing user-friendly messages or handling empty input
cases in a custom manner.

Note: This method is called by the cmd library when an empty line is
entered. You can override it in a subclass to change its behavior.

Example:
>>> shell = LazyOwnShell()
>>> shell.emptyline()
You didn't enter any command.

EOF

Handle the end-of-file (EOF) condition.

This method is called when the user sends an end-of-file (EOF) signal
by pressing Ctrl+D. It is typically used to handle cleanup or exit
operations when the user terminates input.

In this implementation, it prints a farewell message and returns True
to indicate that the shell should exit.

Note: This method is a part of the cmd library's command handling
system. You can override it in a subclass to customize its behavior.

Example:
>>> shell = LazyOwnShell()
>>> shell.do_EOF(None)
LazyOwn say Goodbye!
(shell exits)

postloop

Handle operations to perform after exiting the command loop.

This method is called after the command loop terminates, typically used
for performing any final cleanup or displaying messages before the program
exits.

In this implementation, it prints a message indicating that the custom
shell is exiting.

Note: This method is called automatically by the cmd library's command
loop after the loop terminates. You can override it in a subclass to
customize its behavior.

Example:
>>> shell = LazyOwnShell()
>>> shell.cmdloop() # Exits the command loop
Exiting custom LazyOwnShell.

set

Set a parameter value.

This function takes a line of input, splits it into a parameter and a value,
and sets the specified parameter to the given value if the parameter exists.

:param line: A string containing the parameter and value to be set.
Expected format: ' '.
:type line: str
:return: None
:raises: ValueError if the input line does not contain exactly two elements.

show

Show the current parameter values.

This function iterates through the current parameters and their values,
printing each parameter and its associated value.

:param line: This parameter is not used in the function.
:type line: str
:return: None

list

Lists all available scripts in the modules directory.

This method prints a list of available scripts in a formatted manner, arranging
them into columns. It shows each script with sufficient spacing for readability.

:param line: This parameter is not used in the method.
:type line: str
:return: None

run

Runs a specific LazyOwn script.

:param line: The command line input containing the script name.
:type line: str
:return: None

lazysearch

Runs the internal module modules/lazysearch.py.

This method executes the lazysearch script from the specified path, using
the binary_name parameter from the self.params dictionary. If binary_name
is not set, it prints an error message.

:return: None

lazysearch_gui

Run the internal module located at modules/LazyOwnExplorer.py.

This method executes the LazyOwnExplorer.py script, which is used for graphical user interface (GUI) functionality within the LazyOwn framework.

The function performs the following steps:

Calls self.run_script with LazyOwnExplorer.py to execute the GUI module.

:returns: None

Manual execution:

Ensure that the modules/LazyOwnExplorer.py script is present in the modules directory.
Run the script with:
python3 modules/LazyOwnExplorer.py

Example:
To run LazyOwnExplorer.py directly, execute:
python3 modules/LazyOwnExplorer.py

Note:
- Ensure that the script has the appropriate permissions and dependencies to run.
- Verify that your environment supports GUI operations if using this script in a non-graphical environment.

lazyown

Run the internal module located at modules/lazyown.py.

This method executes the lazyown.py script, which is a core component of the LazyOwn framework.

The function performs the following steps:

Calls self.run_script with lazyown.py to execute the script.

:returns: None

Manual execution:

Ensure that the modules/lazyown.py script is present in the modules directory.
Run the script with:
python3 modules/lazyown.py

Example:
To run lazyown.py directly, execute:
python3 modules/lazyown.py

Note:
- Ensure that the script has the appropriate permissions and dependencies to run.

update_db

Run the internal module located at modules/update_db.sh.

This method executes the update_db.sh script to update the database of binary exploitables from gtofbins.

The function performs the following steps:

Executes the update_db.sh script located in the modules directory using os.system.

:returns: None

Manual execution:

Ensure that the modules/update_db.sh script is present in the modules directory.
Run the script with:
./modules/update_db.sh

Example:
To manually update the database, execute:
./modules/update_db.sh

Note:
- Ensure that the script has execute permissions.
- The script should be run with the necessary privileges if required.

lazynmap

Runs the internal module modules/lazynmap.sh for multiple Nmap scans.

:return: None

lazywerkzeugdebug

Run the internal module located at modules/lazywerkzeug.py in debug mode.

This method executes the lazywerkzeug.py script with the specified parameters for remote and local hosts and ports. It is used to test Werkzeug in debug mode.

The function performs the following steps:

Retrieves the rhost, lhost, rport, and lport values from self.params.
Checks if all required parameters are set. If not, prints an error message and returns.
Calls self.run_script with lazywerkzeug.py and the specified parameters.

:param rhost: The remote host address.
:type rhost: str

:param lhost: The local host address.
:type lhost: str

:param rport: The remote port number.
:type rport: int

:param lport: The local port number.
:type lport: int

:returns: None

Manual execution:

Ensure that rhost, lhost, rport, and lport are set in self.params.
The script modules/lazywerkzeug.py should be present in the modules directory.
Run the script with:
python3 modules/lazywerkzeug.py <rhost> <rport> <lhost> <lport>

Note:
- Ensure that modules/lazywerkzeug.py has the appropriate permissions and dependencies to run.
- Verify that the specified hosts and ports are correct and available.

lazygath

Run the internal module located at modules/lazygat.sh. to gathering the sistem :)

This method executes the lazygat.sh script located in the `modul...

Assets 2

05 Sep 05:34

clcthulhu

release/0.1.38

c04b9ee

release/0.1.38

Full Changelog: release/0.1.25...release/0.1.38

COMMANDS.md Documentation by readmeneitor.py

init

Initializer for the LazyOwnShell class.

default

Handles undefined commands, including aliases.

This method checks if a given command (or its alias) exists within the class
by attempting to find a corresponding method. If the command or alias is not
found, it prints an error message.

:param line: The command or alias to be handled.
:type line: str
:return: None

one_cmd

Internal function to execute commands.

This method attempts to execute a given command using onecmd and captures
the output. It sets the output attribute based on whether the command was
executed successfully or an exception occurred.

:param command: The command to be executed.
:type command: str
:return: A message indicating the result of the command execution.
:rtype: str

emptyline

Handle the case where the user enters an empty line.

This method is called when the user submits an empty line of input in
the command-line interface. By default, it provides feedback indicating
that no command was entered.

It is useful for providing user-friendly messages or handling empty input
cases in a custom manner.

Note: This method is called by the cmd library when an empty line is
entered. You can override it in a subclass to change its behavior.

Example:
>>> shell = LazyOwnShell()
>>> shell.emptyline()
You didn't enter any command.

EOF

Handle the end-of-file (EOF) condition.

This method is called when the user sends an end-of-file (EOF) signal
by pressing Ctrl+D. It is typically used to handle cleanup or exit
operations when the user terminates input.

In this implementation, it prints a farewell message and returns True
to indicate that the shell should exit.

Note: This method is a part of the cmd library's command handling
system. You can override it in a subclass to customize its behavior.

Example:
>>> shell = LazyOwnShell()
>>> shell.do_EOF(None)
LazyOwn say Goodbye!
(shell exits)

postloop

Handle operations to perform after exiting the command loop.

This method is called after the command loop terminates, typically used
for performing any final cleanup or displaying messages before the program
exits.

In this implementation, it prints a message indicating that the custom
shell is exiting.

Note: This method is called automatically by the cmd library's command
loop after the loop terminates. You can override it in a subclass to
customize its behavior.

Example:
>>> shell = LazyOwnShell()
>>> shell.cmdloop() # Exits the command loop
Exiting custom LazyOwnShell.

set

Set a parameter value.

This function takes a line of input, splits it into a parameter and a value,
and sets the specified parameter to the given value if the parameter exists.

:param line: A string containing the parameter and value to be set.
Expected format: ' '.
:type line: str
:return: None
:raises: ValueError if the input line does not contain exactly two elements.

show

Show the current parameter values.

This function iterates through the current parameters and their values,
printing each parameter and its associated value.

:param line: This parameter is not used in the function.
:type line: str
:return: None

list

Lists all available scripts in the modules directory.

This method prints a list of available scripts in a formatted manner, arranging
them into columns. It shows each script with sufficient spacing for readability.

:param line: This parameter is not used in the method.
:type line: str
:return: None

run

Runs a specific LazyOwn script.

:param line: The command line input containing the script name.
:type line: str
:return: None

lazysearch

Runs the internal module modules/lazysearch.py.

This method executes the lazysearch script from the specified path, using
the binary_name parameter from the self.params dictionary. If binary_name
is not set, it prints an error message.

:return: None

lazysearch_gui

Run the internal module located at modules/LazyOwnExplorer.py.

This method executes the LazyOwnExplorer.py script, which is used for graphical user interface (GUI) functionality within the LazyOwn framework.

The function performs the following steps:

Calls self.run_script with LazyOwnExplorer.py to execute the GUI module.

:returns: None

Manual execution:

Ensure that the modules/LazyOwnExplorer.py script is present in the modules directory.
Run the script with:
python3 modules/LazyOwnExplorer.py

Example:
To run LazyOwnExplorer.py directly, execute:
python3 modules/LazyOwnExplorer.py

Note:
- Ensure that the script has the appropriate permissions and dependencies to run.
- Verify that your environment supports GUI operations if using this script in a non-graphical environment.

lazyown

Run the internal module located at modules/lazyown.py.

This method executes the lazyown.py script, which is a core component of the LazyOwn framework.

The function performs the following steps:

Calls self.run_script with lazyown.py to execute the script.

:returns: None

Manual execution:

Ensure that the modules/lazyown.py script is present in the modules directory.
Run the script with:
python3 modules/lazyown.py

Example:
To run lazyown.py directly, execute:
python3 modules/lazyown.py

Note:
- Ensure that the script has the appropriate permissions and dependencies to run.

update_db

Run the internal module located at modules/update_db.sh.

This method executes the update_db.sh script to update the database of binary exploitables from gtofbins.

The function performs the following steps:

Executes the update_db.sh script located in the modules directory using os.system.

:returns: None

Manual execution:

Ensure that the modules/update_db.sh script is present in the modules directory.
Run the script with:
./modules/update_db.sh

Example:
To manually update the database, execute:
./modules/update_db.sh

Note:
- Ensure that the script has execute permissions.
- The script should be run with the necessary privileges if required.

lazynmap

Runs the internal module modules/lazynmap.sh for multiple Nmap scans.

:return: None

lazywerkzeugdebug

Run the internal module located at modules/lazywerkzeug.py in debug mode.

This method executes the lazywerkzeug.py script with the specified parameters for remote and local hosts and ports. It is used to test Werkzeug in debug mode.

The function performs the following steps:

Retrieves the rhost, lhost, rport, and lport values from self.params.
Checks if all required parameters are set. If not, prints an error message and returns.
Calls self.run_script with lazywerkzeug.py and the specified parameters.

:param rhost: The remote host address.
:type rhost: str

:param lhost: The local host address.
:type lhost: str

:param rport: The remote port number.
:type rport: int

:param lport: The local port number.
:type lport: int

:returns: None

Manual execution:

Ensure that rhost, lhost, rport, and lport are set in self.params.
The script modules/lazywerkzeug.py should be present in the modules directory.
Run the script with:
python3 modules/lazywerkzeug.py <rhost> <rport> <lhost> <lport>

Note:
- Ensure that modules/lazywerkzeug.py has the appropriate permissions and dependencies to run.
- Verify that the specified hosts and ports are correct and available.

lazygath

Run the internal module located at modules/lazygat.sh. to gathering the sistem :)

This method executes the lazygat.sh script located in the `modul...

Assets 2

26 Aug 06:23

clcthulhu

release/0.1.25

dff7e0a

release/0.1.25

Full Changelog: release/0.1.1...release/0.1.25

LazyOwn

██╗      █████╗ ███████╗██╗   ██╗ ██████╗ ██╗    ██╗███╗   ██╗
██║     ██╔══██╗╚══███╔╝╚██╗ ██╔╝██╔═══██╗██║    ██║████╗  ██║
██║     ███████║  ███╔╝  ╚████╔╝ ██║   ██║██║ █╗ ██║██╔██╗ ██║
██║     ██╔══██║ ███╔╝    ╚██╔╝  ██║   ██║██║███╗██║██║╚██╗██║
███████╗██║  ██║███████╗   ██║   ╚██████╔╝╚███╔███╔╝██║ ╚████║
╚══════╝╚═╝  ╚═╝╚══════╝   ╚═╝    ╚═════╝  ╚══╝╚══╝ ╚═╝  ╚═══╝

LazyOwn Framework is a powerful and versatile security framework designed to automate and streamline pentesting and vulnerability analysis tasks. This interactive environment combines multiple tools and scripts, making it easier for cybersecurity professionals to work through various stages of the security assessment lifecycle. With an intuitive command-line interface, LazyOwn allows users to configure specific parameters, execute custom scripts, and obtain real-time results, all from a single platform.

Key Features:

Interactive Interface:

Interactive shell with user-friendly commands for configuring and running scripts.
Ability to display and adjust custom parameters applicable to different scripts.
Task Automation:

Automates common pentesting tasks such as vulnerability scanning, web application fuzzing, brute force attacks, and more.
Integration with popular tools and custom scripts for comprehensive testing coverage on Parrot Sec.
Real-Time Visualization:

Real-time output display of script execution, allowing users to see results instantly and react swiftly.
Modularity and Extensibility:

Designed to be extensible, enabling users to easily add and customize scripts.
Supports multiple scripting languages, including Python and Bash.
Flexible Configuration:

Ability to set specific parameters like IP addresses, API keys, HTTP methods, request data, and more, providing complete control over executed scripts.
Typical Use:

Parameter Configuration:

Users can set required parameters using commands like set target_ip 192.168.1.1 to define the target IP address.
Script Execution:

Execute predefined scripts for various tasks, such as run lazygptcli to interact with GPT using a configured prompt and API key.
Results Visualization:

Script results are displayed in the console in real-time, providing immediate feedback on progress and findings.
Additional Modules:

LazyOwn includes various specialized modules such as:

lazyownrat and lazyownratcli: For running remote access tools with configurable parameters.
lazyftpsniff and lazysniff: For network sniffing on specified interfaces.
lazysearch_bot and lazygptcli: For interacting with search APIs and GPT-based tools.
lazyhoneypot: For setting up email-based honeypots.
lazynetbios: For NetBIOS enumeration across IP ranges.
lazywerkzeugdebug: For testing Werkzeug in debug mode.
Background:

Originally designed to automate the search and analysis of binaries with special permissions on Linux and Windows systems, LazyOwn has evolved to encompass a broader range of functionalities. The project includes scripts that extract information from GTFOBins, analyze binaries on the system, and generate options based on the collected data.

LazyOwn on Reddit

Revolutionize Your Pentesting with LazyOwn: Automate the intrusion on Linux, MAC OSX, and Windows VICTIMS

https://www.reddit.com/r/LazyOwn/

LazyOwn_.Transform.Pentesting.with.Automation.mp4

Discover LazyOwn, the ultimate solution for automating the pentesting workflow to attack Linux, MacOSX and Windows systems. Our powerful tool simplifies pentesting, making it more efficient and effective. Watch this video to learn how LazyOwn can streamline your security assessments and enhance your cybersecurity toolkit.

LazyOwn> set rhost 192.168.1.1
[SET] rhost set to 192.168.1.1
LazyOwn> run lazynmap
[INFO] Running Nmap scan on 192.168.1.1
...

LazyOwn is ideal for cybersecurity professionals seeking a centralized and automated solution for their pentesting needs, saving time and enhancing efficiency in identifying and exploiting vulnerabilities.

Requisitos

Python 3.x
Módulos de Python:
- python-libnmap
- pwn
- groq
- PyPDF2
- docx
- python-docx
- olefile
- exifread
- pycryptodome
- impacket
- pandas
- colorama
- tabulate
- pyarrow
- keyboard
- flask-unsign
- name-that-hash
- certipy-ad
- ast
subprocess (incluido en la biblioteca estándar de Python)
platform (incluido en la biblioteca estándar de Python)
tkinter (Opcional para el GUI)
numpy (Opcional para el GUI)

Instalación

Clona el repositorio:

git clone https://github.com/grisuno/LazyOwn.git
cd LazyOwn

Instala las dependencias de Python:

./install.sh

Uso

./run or ./fast_run_as_r00t.sh 

./run --help
    [;,;] LazyOwn release/0.1.20
    Uso: ./run [opciones]
    Opciones:
      --help         Muestra esta ayuda
      -v             Muestra la version
      -c             Ejecuta un comando del LazyOwn ej: ping
      --no-banner    No muestra el Banner
      -s             Run as r00t 

./fast_run_as_r00t.sh --vpn 1 (the number id of your file in vpn directory)

Use set <parameter> <value> to configure parameters.
Use show to display the current parameter values.
Use run <script_name> to execute a script with the set parameters.
Use exit to exit the CLI.

Once the shell is running, you can use the following commands:

list: Lists all LazyOwn Modules.
set <parameter> <value>: Sets the value of a parameter. For example, set rhost 192.168.1.1.
show: Displays the current values of all parameters.
run <script>: Executes a specific script available in the framework.
Available Scripts

┌─[LazyOwn👽192.168.1.92 ~/home/gris/tools/LazyOwn][10.10.11.29][http://lantern.htb/]
└╼ $ ls
    [+] Available scripts to run: [👽]
    [+] lazysearch                lazysearch_gui            lazyown                 [👽]
    [+] update_db                 lazynmap                  lazyaslrcheck           [👽]
    [+] lazynmapdiscovery         lazygptcli                lazyburpfuzzer          [👽]
    [+] lazymetaextract0r         lazyreverse_shell         lazyattack              [👽]
    [+] lazyownratcli             lazyownrat                lazygath                [👽]
    [+] lazysniff                 lazynetbios               lazybotnet              [👽]
    [+] lazybotcli                lazyhoneypot              lazysearch_bot          [👽]
    [+] lazylfi2rce               lazylogpoisoning          lazymsfvenom            [👽]
    [+] lazypathhijacking         lazyarpspoofing           lazyftpsniff            [👽]
    [+] lazyssh77enum             lazywerkzeugdebug       [👽]
┌─[LazyOwn👽192.168.1.92 ~/home/gris/tools/LazyOwn][10.10.11.29][http://lantern.htb/]
└╼ $ 
        
┌─[LazyOwn👽192.168.1.92 ~/home/gris/tools/LazyOwn][10.10.11.29][http://lantern.htb/]
└╼ $ ?

Documented commands (type help <topic>):
========================================
EOF                dnsmap              ldapdomaindump       searchhash      
acknowledgearp     download_exploit    list                 seo             
acknowledgeicmp    download_resources  lynis                sessionssh      
addhosts           encode              medusa               sessionsshstrace
alias              encoderpayload      msf                  set             
apropos            encrypt             nbtscan              set_proxychains 
arpscan            enum4linux          nikto                sh              
asprevbase64       exit                nmapscript           shellcode       
banner             finalrecon          nmapscripthelp       show            
base64decode       find                openssl_sclient      skipfish        
base64encode       fixel               payload              smbclient       
bloodhound         fixperm             ping                 smbmap          
chisel             ftp                 portdiscover         smbserver       
clean              getcap              ports                smtpuserenum    
clock              getnpusers          portservicediscover  snmpcheck       
cme                getseclist          proxy                socat           
conptyshell        gobuster            psexec               sqlmap          
cp                 gospider            pwd                  ss              
cports             grisun0             pwncatcs             ssh             
createcookie       hashcat             py3ttyup             sshd            
createcre...

Assets 2

Releases: grisuno/LazyOwn

release/0.1.47

COMMANDS.md Documentation by readmeneitor.py

init

default

one_cmd

emptyline

EOF

postloop

set

show

list

run

lazysearch

lazysearch_gui

lazyown

update_db

lazynmap

lazywerkzeugdebug

lazygath

release/0.1.46

COMMANDS.md Documentation by readmeneitor.py

init

default

one_cmd

emptyline

EOF

postloop

set

show

list

run

lazysearch

lazysearch_gui

lazyown

update_db

lazynmap

lazywerkzeugdebug

lazygath

release/0.1.45

COMMANDS.md Documentation by readmeneitor.py

init

default

one_cmd

emptyline

EOF

postloop

set

show

list

run

lazysearch

lazysearch_gui

lazyown

update_db

lazynmap

lazywerkzeugdebug

lazygath

release/0.1.44

COMMANDS.md Documentation by readmeneitor.py

init

default

one_cmd

emptyline

EOF

postloop

set

show

list

run

lazysearch

lazysearch_gui

lazyown

update_db

lazynmap

lazywerkzeugdebug

lazygath

release/0.1.43

COMMANDS.md Documentation by readmeneitor.py

init