Preparation of Papers for IEEE OPEN JOURNAL
160005103
160005112
Development of a Cross-Platform Client-Server
System for Remote Monitoring
First J. Fernandez, Second E. Beltran, Students of University of los Llanos
Abstract This document presents the design and development of a cross-platform client-server application created in Go, aimed
at enabling remote server monitoring and command execution. The solution is divided into two components: the server, which runs
on a Linux environment and awaits incoming connections, and the client, which operates on Windows and establishes the
connection. Communication between the two is established through TCP sockets, with authentication secured using SHA-256
hashing. The system allows for the execution of remote commands and generates real-time performance reports that include CPU,
memory, and disk usage. It is structured to maintain a reliable and stable connection with only one client at a time, ensuring
consistent performance and secure communication during remote sessions. Thanks to Go’s powerful standard library and support
for concurrency, the system remains both efficient and easy to maintain. Its modular design also offers flexibility, making it suitable
for diverse operational contexts and administrative needs, and highlighting its value as a secure remote management tool.
Keywords: Socket, Go, Debian, Linux, System Monitoring, Remote Management
generate real-time useful reports, highlighting the
importance of robust and adaptable designs in distributed
I. INTRODUCTION1 systems [1].
In a related context, Casas Arévalo and Valencia Ortiz [2]
Remote system supervision and control have become developed a remote monitoring system for GNU/Linux
essential in today’s IT landscape, especially when direct servers, using mobile devices as the access medium. This
physical access to servers is limited or not possible. As project relied on the implementation of technologies like
infrastructure grows in complexity and the demand for WAP to ensure accessibility and efficient server supervision
operational efficiency increases, having secure and effective from remote locations. Their approach underscores the
remote management tools is critical for maintaining system importance of having tools that simplify distributed system
functionality and responsiveness. management and enhance responsiveness to critical
This project presents the development of a system that administration needs.
facilitates remote interaction with servers, allowing users to
execute commands and obtain reports on the system's status II. EXECUTION ENVIRONMENT
without requiring physical access. The solution is designed
under a TCP-based client-server architecture, with SHA-
The server component is hosted on an optimized Linux
256-based authentication mechanisms, implemented in Go,
distribution configured to accept incoming connections on a
and functionalities focused on remote command execution designated port. Although the system's architecture allows
and periodic report generation. A similar approach was for concurrent processing, the current implementation
documented by Ruiz del Moral Medina (2015) in the context supports only a single active client connection at a time. This
of monitoring computer labs. His work explored client- design choice helps maintain a responsive and stable link
server architectures and specialized tools to manage between the client and server while minimizing the risk of
technological resources and overload or conflicts. The client, which operates on
Windows, requires the server’s IP address, port, and user
1 credentials to establish the connection. Both modules have
been tested within a local network and simulated remote
2
160005103
160005112
conditions to confirm system reliability and proper Actors
functionality.
● System Administrator: Responsible for installing
III. SYSTEM ARCHITECTURE and configuring the software, as well as managing
permissions and security.
The system follows a client-server architecture developed ● Remote User: Utilizes the software to remotely
using Go. In this configuration, the server runs on a Linux connect to the system, monitor its status, and
machine and the client operates under Windows. execute commands.
Communication is established through TCP sockets,
enabling real-time data transmission. The server handles
TCP connections, authenticates users via SHA-256 hashed Use Cases
credentials, and executes the commands issued by clients.
Meanwhile, the client acts as the user interface, sending ● Software Installation and Configuration: The
commands and displaying periodic system reports retrieved system administrator installs and configures the
from the server. software on the server and clients.
● Remote Connection and Authentication: The
Figure 1 illustrates the design and use cases of the system in remote user connects to the server using the
a diagram. software and authenticates to gain access to the
system.
● System Monitoring: The remote user uses the
software to monitor the system's status, including
CPU, memory, and disk usage.
● Remote Command Execution: The remote user
uses the software to execute commands on the
remote system.
● Permission and Security Management: The
system administrator manages permissions and
security to ensure that only authorized users can
access the system and execute commands.
Functional Requirements
● Compatibility with Unix and Windows: The
software must be compatible with both Unix and
Windows systems.
● Secure Remote Connection: The software must
Fig. 1. Use case diagram provide a secure remote connection using
encryption and authentication protocols.
● System Monitoring: The software must provide
information about the system's status, including
CPU, memory, and disk usage.
The use case diagram represents the interaction between the ● Remote Command Execution: The software must
actors and the use cases in the remote monitoring and allow the execution of commands on the remote
command execution software project. system.
● Permission and Security Management: The
software must provide permission and security
3
160005103
160005112
management to ensure only authorized users can for goroutines made it easier to manage multiple
access the system and execute commands. TCP connections, while its portability allowed the
client to run on Windows and the server on Linux.
Non-Functional Requirements
Libraries and Packages in Go
● Stability and Reliability: The software must be
stable and reliable to guarantee remote connection ● bufio: Efficient handling of input/output through
and command execution. buffers. Useful for reading/writing large data.
● Performance and Responsiveness: The software ● bytes: Manipulation of byte slices, such as
must perform reliably and remain responsive searching, comparing, and modifications.
during remote connection and command execution, ● crypto/sha256: Implementation of the SHA-256
even under limited operational conditions. hashing algorithm for cryptography.
● Usability and Accessibility: The software must be ● fmt: String formatting and standard input/output
easy to use and accessible for remote users. operations.
● Security and Privacy: The software must ensure ● io: Interfaces and functions for handling data
the security and privacy of data and remote streams (reading/writing).
connections. ● log: Formatted message logging, useful for
debugging.
● net: Networking functionalities like TCP/IP, UDP,
and name resolution.
● os: Interactions with the operating system, such as
files, processes, and environment variables.
● os/exec: Execution of external commands from Go
programs.
● os/user: Retrieval of information about operating
system users.
● strconv: Conversion between strings and basic
types (integers, floats, etc.).
● strings: String manipulation, such as searching,
splitting, and replacing.
● sync: Tools for synchronization between
goroutines, such as mutexes and wait groups.
● time: Handling of time and dates, including
duration measurement and timers.
Fig. 2. Deployment diagram. SHA-256: Within this project, SHA-256 serves as a secure
method for authenticating users by protecting their login
Technologies used credentials. When a user tries to establish a connection with
the server, their password is transformed into a hash using
For the development of the client-server system, various the SHA-256 algorithm. This hashed value is then matched
tools were utilized to achieve the most optimal against a stored hash on the server to confirm the user's
implementation possible. Among the tools used are the identity. By never transmitting the actual password in plain
following: text, this method significantly improves the system's security
and helps prevent unauthorized access caused by data
● Go (Golang): This was the language chosen for interception.
the system due to its standard libraries for
networking, file handling, and security. Its support
4
160005103
160005112
Linux Distribution (Debian): The server-side component V. RESULTS
of the system was developed and deployed on Debian, a
stable and widely adopted Linux distribution in server Below we show the result of running the server.
environments. Tools provided by the system, such as /proc,
were used to gather real-time information about resource
consumption and system performance.
IV. PERFORMANCE PARAMETERS
The system's expected performance has been outlined
Fig. 3. Server execution.
through a series of reference parameters intended for future
validation. These include:
The image shows a terminal window where a server in Go
is being executed. The user "fernando" runs the command
● Response Time: Basic commands should be
`go run server.go` in the project directory. The server is
processed in under 100 milliseconds under typical listening on port 2024 and confirms that it has received a
network conditions. connection from the IP address 192.168.1.6, authenticating
● Server Resource Usage: During regular operation, the client "fernando." It then indicates that it is waiting for
CPU usage should remain below 10%, and more connections.
memory usage should not exceed 100 MB.
● Responsiveness: The application should remain
stable and responsive during remote command
execution and automated report generation, even Below we show the result of running the client.
when used by a single client over a standard
network
● Report Generation Efficiency: Reports detailing
CPU, memory, and disk usage should be produced
within 5 seconds during normal operating
conditions.
● Network Latency Tolerance: The system must
maintain proper functionality with up to 200
milliseconds of network delay between client and
server.
● Security: Authentication must be secured through
Fig. 4. Client execution.
SHA-256 hashing, ensuring protection against
unauthorized access. The image shows a Windows terminal window where a Go
● Bandwidth Consumption: Communication program is being executed. The user "fernando" enters their
between client and server should be optimized to credentials to connect to a server at the IP address
ensure that a full report exchange does not exceed 192.168.1.12, using the command `go run .\ClientTCP.go`.
500 KB.
Although practical tests to measure these parameters were
not conducted during the project implementation, these
standards have been defined as theoretical objectives for
validating the system in future tests. They are recommended
as a basis for evaluating the system's performance, security,
and responsiveness in real operational scenarios.
5
160005103
160005112
REFERENCES
[1] F. Ruiz del Moral Medina, Análisis, diseño e implementación de un
sistema de monitorización y uso de aulas informáticas, Trabajo de
Fin de Grado, Universidad Carlos III de Madrid, 2015.
[2] C. Casas Arévalo and J. C. Valencia Ortiz, Diseño e implementación
de una aplicación para monitoreo remoto de un servidor GNU/Linux
por medio de dispositivos móviles, Universidad de San Buenaventura,
Bogotá, Colombia, 2010.
Fig. 6. Resource Utilization Reports from Client
Application.
The image shows a terminal session on a Linux server
where a Go-based system generates automatic resource
reports at fixed time intervals. The report includes
information about disk usage (/dev/sda2), memory statistics
(used, free, and available), and CPU usage percentages. The
report is generated automatically without user input and is
displayed simultaneously on both the server and client
sides, allowing for real-time monitoring of system
performance.
VI. CONCLUSIONS
The development of this cross-platform client-server system
demonstrates the feasibility of implementing a secure and
efficient solution for remote server monitoring. The choice
of Go as the programming language facilitated the
implementation of secure SHA-256-based authentication,
remote command execution, and the regular generation of
server resource reports.
The proposed architecture, built on a TCP connection,
ensured reliability and efficiency in data transfer between the
client and the server. Additionally, the system's modular
structure offers flexibility to adapt to different operating
environments and user requirements, even though the
current version supports only one active connection at a
time.
