CÓDIGO PARA MANIPULAR EL FLUJO DE ANCHO DE BANDA DE INTERNET EN WINDOWS, UBUNTU y CÓMO SE PUEDE MANIPULAR LOS HILOS DEL TECLADO EN WINDOWS, UBUNTU

1. UNIVERSIDAD TECNOLÓGICA BOLIVIANA
INGENIERÍA DE SISTEMAS
PRACTICA DE INVESTIGACIÓN
ESTUDIANTES: RAUL TARQUINO VASQUEZ
ABRAHAM JULIAN MAMANI MAMANI
MARCO ANTONIO VERGARA CONDE
CARLOS CALEB USQUIANO AVENDAÑO
MATERIA: ADMINISTRACION DE SISTEMAS OPERATIVOS
SIGLA: SIS-312
PARALELO: “B”
TURNO: MAÑANA
DOCENTE: Lic. JUAN MARIO EGUIVAR GUERRA
LA PAZ-BOLIVIA
I-2024

2. CÓDIGO PARA MANIPULAR EL FLUJO DE ANCHO DE BANDA DE INTERNET
EN WINDOWS
Para manipular el flujo de ancho de banda de Internet en un sistema operativo
Windows, se puede utilizar una variedad de técnicas y herramientas, tanto a nivel
de programación como a través de software de terceros. Sin embargo, una forma
común de hacerlo programáticamente es mediante el uso de políticas de grupo
(Group Policy) o mediante programación con PowerShell o C#. Aquí te mostraré un
ejemplo básico utilizando PowerShell para limitar el ancho de banda de descarga
en Windows.
PowerShell Script para Limitar el Ancho de Banda
Este script usa el módulo QoS (Quality of Service) de Windows para crear una
política que limite el ancho de banda de red. Asegúrate de ejecutar PowerShell como
administrador para poder aplicar estos cambios.
# Define el límite de ancho de banda en Mbps
$bandwidthLimit = 10
# Crea una nueva política de QoS
New-NetQosPolicy -Name "LimitarAnchoDeBanda" -
AppPathNameMatchCondition "chrome.exe" -IPProtocolMatchCondition TCP -
NetworkProfile All -ThrottleRateActionBitsPerSecond ($bandwidthLimit * 1MB)
# Lista las políticas de QoS existentes para verificar
Get-NetQosPolicy
Explicación del Código
• New-NetQosPolicy: Este cmdlet crea una nueva política de QoS. Puedes
cambiar el nombre de la política y las condiciones según tus necesidades.
• AppPathNameMatchCondition: Especifica la aplicación a la que se aplicará
la política. En este caso, es "chrome.exe", pero puedes cambiarlo por
cualquier ejecutable.

3. • IPProtocolMatchCondition: Define el protocolo; en este caso, se utiliza
TCP, común para la mayoría de las aplicaciones de Internet.
• NetworkProfile: Aplica la política a todos los perfiles de red.
• ThrottleRateActionBitsPerSecond: Establece el límite de ancho de banda
en bits por segundo. Aquí se multiplica el límite deseado en Mbps por 1MB
(Megabyte en bits).
Consideraciones
• Este script es un ejemplo básico y puede necesitar ajustes según el entorno
y los requisitos específicos.
• Cambiar la configuración de red puede afectar la conectividad y el
rendimiento de las aplicaciones. Úsalo con precaución.
• Es posible que necesites ajustar los permisos de ejecución de scripts en
PowerShell usando Set-ExecutionPolicy si encuentras restricciones.
CÓDIGO PARA MANIPULAR EL FLUJO DE ANCHO DE BANDA DE INTERNET
EN UBUNTU
Para manipular el flujo de ancho de banda en sistemas operativos basados en
Ubuntu, se utilizar la herramienta tc (Traffic Control), que forma parte del paquete
iproute2. Esta herramienta permite gestionar con precisión el ancho de banda a nivel
de red. A continuación, un ejemplo básico de cómo configurar un límite de ancho de
banda utilizando tc.
Script para Limitar el Ancho de Banda con tc en Ubuntu
Antes de comenzar, asegúrate de tener instalado iproute2. Puedes instalarlo
ejecutando:
sudo apt-get install iproute2
Script básico para limitar el ancho de banda de salida a una velocidad específica
para una interfaz de red.

4. #!/bin/bash
# Define la interfaz de red (por ejemplo, eth0, wlan0)
IFACE="eth0"
# Define el límite de ancho de banda en kbps (kilobits por segundo)
BANDWIDTH=1000
# Limpia las reglas existentes
tc qdisc del dev $IFACE root
# Añade la raíz qdisc (colas disciplinarias)
tc qdisc add dev $IFACE root handle 1: htb default 11
# Añade la clase principal
tc class add dev $IFACE parent 1: classid 1:1 htb rate ${BANDWIDTH}kbps
# Añade una clase secundaria para manejar el tráfico
tc class add dev $IFACE parent 1:1 classid 1:11 htb rate ${BANDWIDTH}kbps
# Filtra todo el tráfico a través de la clase secundaria
tc filter add dev $IFACE protocol ip parent 1:0 prio 1 u32 match ip src 0.0.0.0/0
flowid 1:11
Explicación del Código
1. Limpieza de reglas: Primero se eliminan todas las reglas anteriores
aplicadas a la interfaz para evitar conflictos.
2. Creación de qdisc (cola disciplinaria): Se añade una nueva qdisc con tipo
htb (Hierarchical Token Bucket), que es útil para limitar el ancho de banda.

5. 3. Creación de clases: Se crean clases que especifican cómo se deben
manejar los paquetes. La clase principal y la clase secundaria tienen
asignada la misma tasa de ancho de banda.
4. Filtro: Se añade un filtro que dirige todo el tráfico de la interfaz especificada
a través de la clase creada.
Uso
Para ejecutar este script, guárdalo como limit_bandwidth.sh, dale permisos de
ejecución con chmod +x limit_bandwidth.sh, y ejecútalo como superusuario:
sudo ./limit_bandwidth.sh
Consideraciones
• Modificaciones según necesidades: Puedes ajustar los parámetros como
la interfaz de red y la tasa de ancho de banda según tus necesidades
específicas.
• Impacto en la red: Ajustar el ancho de banda puede afectar
significativamente el rendimiento de tu red, especialmente si configuras
límites muy bajos.
• Monitorización: Es posible que desees monitorear el tráfico para ajustar
las configuraciones basadas en el uso real y la carga de la red.
CÓMO SE PUEDE MANIPULAR LOS HILOS DEL TECLADO EN WINDOWS
Manipular los hilos de entrada del teclado en Windows generalmente implica
interactuar con mensajes del sistema operativo relacionados con la entrada del
teclado o utilizar ganchos (hooks) para interceptar y posiblemente modificar estas
entradas antes de que sean procesadas por el sistema operativo o por
aplicaciones. Esto se puede hacer a través de la programación en lenguajes como
C++ o C#, que ofrecen acceso a las APIs de Windows para este propósito.
Usando Ganchos de Teclado (Keyboard Hooks)
Una de las maneras más comunes de manipular los hilos del teclado en Windows
es mediante el uso de ganchos. Los ganchos de teclado permiten interceptar
eventos de teclado antes de que lleguen a la aplicación. Aquí te explico cómo
puedes hacerlo usando C# con un proyecto de Windows Forms.
Requisitos:

6. Visual Studio o un entorno de desarrollo compatible con C#.
Un nuevo proyecto de Windows Forms en C#.
Ejemplo Básico de Gancho de Teclado Global
Aquí hay un ejemplo simple de cómo configurar un gancho de teclado global en
C#:
using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Windows.Forms;
public class KeyboardHook
{
private const int WH_KEYBOARD_LL = 13;
private const int WM_KEYDOWN = 0x0100;
private static LowLevelKeyboardProc _proc = HookCallback;
private static IntPtr _hookID = IntPtr.Zero;
public static void Main()
{
_hookID = SetHook(_proc);
Application.Run();
UnhookWindowsHookEx(_hookID);
}
private static IntPtr SetHook(LowLevelKeyboardProc proc)
{
using (Process curProcess = Process.GetCurrentProcess())
using (ProcessModule curModule = curProcess.MainModule)
{
return SetWindowsHookEx(WH_KEYBOARD_LL, proc,
GetModuleHandle(curModule.ModuleName), 0);
}
}
private delegate IntPtr LowLevelKeyboardProc(
int nCode, IntPtr wParam, IntPtr lParam);
private static IntPtr HookCallback(
int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN)
{
int vkCode = Marshal.ReadInt32(lParam);

7. Console.WriteLine((Keys)vkCode);
// Aquí puedes manipular la entrada o bloquear teclas específicas
}
return CallNextHookEx(_hookID, nCode, wParam, lParam);
}
[DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
private static extern IntPtr SetWindowsHookEx(int idHook,
LowLevelKeyboardProc lpfn, IntPtr hMod, uint dwThreadId);
[DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool UnhookWindowsHookEx(IntPtr hhk);
[DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode,
IntPtr wParam, IntPtr lParam);
[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
private static extern IntPtr GetModuleHandle(string lpModuleName);
}
Explicación:
1. SetHook: Configura el gancho de teclado.
2. HookCallback: Esta es la función de callback que se llama cada vez que se
presiona una tecla. Aquí es donde puedes interceptar y manipular entradas
de teclado.
3. UnhookWindowsHookEx: Elimina el gancho cuando la aplicación se cierra o
no se necesita más.
Consideraciones:
• Los ganchos globales pueden afectar el rendimiento del sistema si no se
usan cuidadosamente.
• Debes asegurarte de que cualquier manipulación del teclado no interfiera
con la accesibilidad o la usabilidad para el usuario final.
CÓMO SE PUEDE MANIPULAR LOS HILOS DEL TECLADO EN UBUNTU
En Ubuntu y otros sistemas basados en Linux, manipular los hilos del teclado
generalmente implica capturar e interactuar con eventos de teclado a un nivel
bajo. Para lograr esto, puedes usar diversas herramientas y técnicas, incluyendo
el uso de librerías como evdev en Python, que es una interfaz directa a los

8. dispositivos de entrada en Linux. Aquí te mostraré cómo puedes utilizar evdev
para leer y manipular eventos del teclado.
Uso de evdev en Python
Primero, necesitarás instalar la librería evdev. Puedes hacerlo ejecutando el
siguiente comando en tu terminal:
sudo apt-get install python3-evdev
Una vez instalada, puedes escribir un script en Python para escuchar eventos de
teclado y manipular la respuesta del sistema a dichos eventos si así lo deseas.
Ejemplo Básico de Captura de Eventos de Teclado
Aquí te dejo un ejemplo básico de cómo usar evdev para leer eventos del teclado
y reaccionar a ellos:
from evdev import InputDevice, categorize, ecodes
# Encuentra el dispositivo de teclado adecuado
def find_keyboard_device():
from evdev import list_devices
devices = [InputDevice(path) for path in list_devices()]
for device in devices:
if "keyboard" in device.name.lower():
return device
return None
# Configura el dispositivo
keyboard = find_keyboard_device()
if not keyboard:
print("Dispositivo de teclado no encontrado.")
exit(1)
keyboard.grab() # Toma control del dispositivo para capturar todos los eventos
try:
print("Escuchando eventos del teclado...")
for event in keyboard.read_loop():
if event.type == ecodes.EV_KEY:
key_event = categorize(event)
if key_event.keystate == key_event.key_down:
print(f"Tecla presionada: {key_event.keycode}")

9. # Aquí puedes decidir manipular el evento o realizar acciones
específicas
finally:
keyboard.ungrab()
Explicación del Código:
1. find_keyboard_device(): Función que detecta y selecciona el dispositivo de
teclado entre los dispositivos de entrada disponibles.
2. keyboard.grab(): Esto asegura que todos los eventos de teclado sean
capturados por este script, evitando que otras aplicaciones reciban estos
eventos mientras se ejecuta el script.
3. read_loop(): Un bucle infinito que escucha continuamente los eventos de
teclado.
4. categorize(event): Categoriza los eventos de entrada para facilitar su
manejo.
Consideraciones:
• Privilegios: Necesitarás privilegios de superusuario para ejecutar este script,
ya que toma control exclusivo del dispositivo de teclado.
• Impacto: Capturar eventos de teclado puede interferir con la operación
normal del sistema si no se maneja cuidadosamente.
• Seguridad: Ten en cuenta las implicaciones de seguridad al interceptar la
entrada del teclado.