1

160005010
160005017
160005020

Development of a Cross-Platform Client-Server

System for Remote Monitoring
First J. Delgado, Second D. Machado, and Third J. Morales, Students of University of los Llanos

Abstract This document presents the design and implementation of a cross-platform client-server system developed in Go,
which performs various tasks remotely, such as monitoring and command execution. This is achieved through the connection of
two modules: one on Linux, which sets up a server and awaits a remote connection, and another on Windows, which connects to
the remote server. The system uses TCP sockets to establish communication between both modules and employs SHA-256-based
user authentication to generate reports on the status of server resources such as memory, CPU, and disk. Additionally, the client
can execute commands on the server remotely, with results transmitted in real time. ****AÑADIR RESULTADOS****

Keywords: Sockets

I. INTRODUCTION1 II. ENTORNO DE EJECUCIÓN

Remote system management and monitoring have

become critical aspects within the field of information
technology, especially in scenarios where physical access to III. SYSTEM ARCHITECTURE
servers is not feasible or is restricted. With the increasing The architecture of the proposed system follows a
complexity of technological infrastructures and the need to client-server model, which was developed in Go. In this
maximize operational efficiency, it is essential to have tools setup, the server runs in a Linux environment, while the
that enable the secure and efficient supervision of resources client runs on Windows. Both modules are designed to
and execution of tasks remotely. communicate remotely via sockets, ensuring an efficient
This project presents the development of a system that exchange of data in real time.
facilitates remote interaction with servers, allowing users to The server, operating in the Linux environment, is
execute commands and obtain reports on the system's status responsible for managing TCP connections, authenticating
without requiring physical access. The solution is designed users using passwords encrypted with SHA-256, and
under a TCP-based client-server architecture, with processing commands sent by the clients. Meanwhile, the
SHA-256-based authentication mechanisms, implemented client, designed to run on Windows systems, communicates
in Go, and functionalities focused on remote command with the server through TCP sockets. It serves as the main
execution and periodic report generation. user interface, allowing users to send commands and
A similar approach was documented by Ruiz del Moral receive reports.
Medina (2015) in the context of monitoring computer labs. Figure 1 illustrates the design and use cases of the system
His work explored client-server architectures and in a diagram.
specialized tools to manage technological resources and
generate real-time useful reports, highlighting the
importance of robust and adaptable designs in distributed
systems [1].
In a related context, Casas Arévalo and Valencia Ortiz [2]
developed a remote monitoring system for GNU/Linux
servers, using mobile devices as the access medium. This
project relied on the implementation of technologies like
WAP to ensure accessibility and efficient server supervision
from remote locations. Their approach underscores the
importance of having tools that simplify distributed system
management and enhance responsiveness to critical
administration needs.

Fig. 1. Use case diagram

1
The use case diagram represents the interaction between the Non-Functional Requirements
actors and the use cases in the remote monitoring and
command execution software project. ● Stability and Reliability: The software must be
stable and reliable to guarantee remote connection
Actors and command execution.
● Performance and Scalability: The software must
● System Administrator: Responsible for installing perform well and be scalable to handle a large
and configuring the software, as well as managing number of remote connections and commands.
permissions and security. ● Usability and Accessibility: The software must be
● Remote User: Utilizes the software to remotely easy to use and accessible for remote users.
connect to the system, monitor its status, and ● Security and Privacy: The software must ensure
execute commands. the security and privacy of data and remote
connections.
Use Cases

● Software Installation and Configuration: The

system administrator installs and configures the
software on the server and clients.
● Remote Connection and Authentication: The
remote user connects to the server using the
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. Fig. 2. Deployment diagram.

Technologies used
Functional Requirements
For the development of the client-server system, various
● Compatibility with Unix and Windows: The
tools were utilized to achieve the most optimal
software must be compatible with both Unix and
implementation possible. Among the tools used are the
Windows systems.
following:
● Secure Remote Connection: The software must
provide a secure remote connection using
● Go (Golang): This was the language chosen for
encryption and authentication protocols.
the system due to its standard libraries for
● System Monitoring: The software must provide
networking, file handling, and security. Its support
information about the system's status, including
for goroutines made it easier to manage multiple
CPU, memory, and disk usage.
TCP connections, while its portability allowed the
● Remote Command Execution: The software must
client to run on Windows and the server on Linux.
allow the execution of commands on the remote
system.
Libraries and Packages in Go
● Permission and Security Management: The
software must provide permission and security
● bufio: Efficient handling of input/output through
management to ensure only authorized users can
buffers. Useful for reading/writing large data.
access the system and execute commands.
● bytes: Manipulation of byte slices, such as
searching, comparing, and modifications.
● crypto/sha256: Implementation of the SHA-256
hashing algorithm for cryptography.
 3
160005010
160005017
160005020

● fmt: String formatting and standard input/output ● Scalability: The system is expected to handle at
operations. least 50 simultaneous connections without
● io: Interfaces and functions for handling data significant performance degradation.
streams (reading/writing). ● Report Generation Efficiency: Reports on
● log: Formatted message logging, useful for memory, CPU, and disk usage should be generated
debugging. in less than 5 seconds under normal load.
● net: Networking functionalities like TCP/IP, UDP, ● Network Latency Tolerance: The system should
and name resolution. continue to operate functionally with a latency of
● os: Interactions with the operating system, such as up to 200 ms between the client and the server.
files, processes, and environment variables. ● Security: The system must ensure robust
● os/exec: Execution of external commands from Go authentication based on SHA-256, protecting
programs. against unauthorized access attempts.
● os/user: Retrieval of information about operating ● Bandwidth Consumption: Data exchange
system users. between the client and server should be optimized
● strconv: Conversion between strings and basic to stay below 500 KB per complete report.
types (integers, floats, etc.).
● strings: String manipulation, such as searching, Although practical tests to measure these parameters were
splitting, and replacing. not conducted during the project implementation, these
● sync: Tools for synchronization between standards have been defined as theoretical objectives for
goroutines, such as mutexes and wait groups. validating the system in future tests. They are recommended
● time: Handling of time and dates, including as a basis for evaluating the system's performance, security,
duration measurement and timers. and scalability in real operational scenarios.

V. RESULTS
SHA-256: In the context of this project, SHA-256 is used ***ACÁ TOCA PONER PANTALLAZOS DEL
as a secure authentication mechanism to protect user PROYECTO FUNCIONANDO Y HACER UNA BREVE
credentials. When a user attempts to connect to the server, DESCRIPCIÓN DE CADA UNO
the password provided by the user is converted into a hash
value using SHA-256. This hash is then compared with the VI. CONCLUSIONS
hash stored on the server to verify the authenticity of the
user. This approach ensures that the password itself is never REFERENCES
transmitted in plain text, enhancing the security of the
[1] F. Ruiz del Moral Medina, Análisis, diseño e implementación de un
system by preventing unauthorized access through the sistema de monitorización y uso de aulas informáticas, Trabajo de
interception of sensitive data. 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
Linux Distribution (Debian): The server was developed
por medio de dispositivos móviles, Universidad de San Buenaventura,
and executed on Debian, a stable and widely used Bogotá, Colombia, 2010.
distribution in server environments. System tools like /proc
were integrated to provide real-time statistics on resource
usage.

IV. PERFORMANCE PARAMETERS

The following performance parameters have been defined

as expected standards to evaluate the system's performance
in future validations:

● Response Time: The system should respond to

basic commands in less than 100 ms under
standard network conditions.
● Server Resource Usage: CPU usage should not
exceed 10% during standard operation, and
memory consumption should remain below 100
MB.