Conceptos importantes en Kotlin relacionados con procesos, hilos, red y seguridad | Operating systems, scripting, PowerShell and security

Hilos, Kotlin, Procesos, Red, Seguridad

Contenidos

Procesos
Hilos
Red
Seguridad

Procesos

ProcessBuilder: Clase que permite crear y controlar procesos en Kotlin.

import java.io.BufferedReader
import java.io.InputStreamReader

fun main() {
    val processBuilder = ProcessBuilder("ping", "-c", "4", "google.com")
    val process = processBuilder.start()
    
    // Leer la salida del proceso
    val reader = BufferedReader(InputStreamReader(process.inputStream))
    var line: String?
    while (reader.readLine().also { line = it } != null) {
        println(line)
    }
}

import java.io.BufferedReader

import java.io.InputStreamReader

fun main() {

val processBuilder = ProcessBuilder("ping", "-c", "4", "google.com")

val process = processBuilder.start()

// Leer la salida del proceso

val reader = BufferedReader(InputStreamReader(process.inputStream))

var line: String?

while (reader.readLine().also { line = it } != null) {

println(line)

}

Runtime: Clase que permite interactuar con el entorno de ejecución y controlar procesos en tiempo de ejecución.

fun main() {
    val runtime = Runtime.getRuntime()
    val process = runtime.exec("ping -c 4 google.com")
    
    // Leer la salida del proceso
    val reader = BufferedReader(InputStreamReader(process.inputStream))
    var line: String?
    while (reader.readLine().also { line = it } != null) {
        println(line)
    }
}

fun main() {

val runtime = Runtime.getRuntime()

val process = runtime.exec("ping -c 4 google.com")

// Leer la salida del proceso

val reader = BufferedReader(InputStreamReader(process.inputStream))

var line: String?

while (reader.readLine().also { line = it } != null) {

println(line)

}

Process: Representa un proceso en ejecución y proporciona métodos para controlarlo.

fun main() {
    val process = ProcessBuilder("echo", "Hello, World!").start()
    process.waitFor() // Espera a que el proceso termine
}

fun main() {

val process = ProcessBuilder("echo", "Hello, World!").start()

process.waitFor() // Espera a que el proceso termine

}

ProcessHandle: Obtener información sobre procesos en ejecución y controlarlos.

fun main() {
    val process = ProcessBuilder("sleep", "10").start()
    val processHandle = process.toHandle()
    
    println("Process ID: ${processHandle.pid()}")
    println("Is Alive: ${processHandle.isAlive}")
}

fun main() {

val process = ProcessBuilder("sleep", "10").start()

val processHandle = process.toHandle()

println("Process ID: ${processHandle.pid()}")

println("Is Alive: ${processHandle.isAlive}")

}

Hilos

Thread: Clase que permite crear y controlar hilos en Kotlin.

class MiThread : Thread() {
    override fun run() {
        for (i in 1..5) {
            println("Hilo ejecutándose: $i")
            sleep(500)
        }
    }
}

fun main() {
    val hilo = MiThread()
    hilo.start()
}

class MiThread : Thread() {

override fun run() {

for (i in 1..5) {

println("Hilo ejecutándose: $i")

sleep(500)

}

fun main() {

val hilo = MiThread()

hilo.start()

}

Runnable: Interfaz funcional que define un hilo de ejecución en Kotlin.

class MiRunnable : Runnable {
    override fun run() {
        for (i in 1..5) {
            println("Hilo ejecutándose desde Runnable: $i")
            Thread.sleep(500)
        }
    }
}

fun main() {
    val miRunnable = MiRunnable()
    val thread = Thread(miRunnable)
    thread.start()
}

class MiRunnable : Runnable {

override fun run() {

for (i in 1..5) {

println("Hilo ejecutándose desde Runnable: $i")

Thread.sleep(500)

}

fun main() {

val miRunnable = MiRunnable()

val thread = Thread(miRunnable)

thread.start()

}

Coroutine: Mecanismo de concurrencia que permite realizar tareas asíncronas y no bloqueantes en Kotlin.

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        for (i in 1..5) {
            println("Corutina ejecutándose: $i")
            delay(500)
        }
    }
}

import kotlinx.coroutines.*

fun main() = runBlocking {

launch {

for (i in 1..5) {

println("Corutina ejecutándose: $i")

delay(500)

}

ExecutorService: Esta interfaz permite administrar hilos y ejecutar tareas de manera concurrente.

import java.util.concurrent.Executors

fun main() {
    val executor = Executors.newFixedThreadPool(2)
    
    executor.submit {
        for (i in 1..5) {
            println("Tarea 1: $i")
            Thread.sleep(500)
        }
    }
    
    executor.submit {
        for (i in 1..5) {
            println("Tarea 2: $i")
            Thread.sleep(500)
        }
    }
    
    executor.shutdown()
}

import java.util.concurrent.Executors

fun main() {

val executor = Executors.newFixedThreadPool(2)

executor.submit {

for (i in 1..5) {

println("Tarea 1: $i")

Thread.sleep(500)

}

executor.submit {

for (i in 1..5) {

println("Tarea 2: $i")

Thread.sleep(500)

}

executor.shutdown()

}

CompletableFuture: Clase que facilita la programación asincrónica y la combinación de múltiples futuros en Kotlin.

import java.util.concurrent.CompletableFuture

fun main() {
    val future = CompletableFuture.supplyAsync {
        Thread.sleep(500)
        "Resultado de la tarea"
    }

    future.thenAccept {
        println("Resultado: $it")
    }

    // Espera a que el futuro termine
    future.join()
}

import java.util.concurrent.CompletableFuture

fun main() {

val future = CompletableFuture.supplyAsync {

Thread.sleep(500)

"Resultado de la tarea"

}

future.thenAccept {

println("Resultado: $it")

}

// Espera a que el futuro termine

future.join()

}

Red

URL: Clase que permite trabajar con URL y realizar operaciones de red como abrir conexiones HTTP.

import java.net.URL

fun main() {
    val url = URL("http://www.example.com")
    val connection = url.openConnection()
    val inputStream = connection.getInputStream()
    val content = inputStream.bufferedReader().use { it.readText() }
    println(content)
}

import java.net.URL

fun main() {

val url = URL("http://www.example.com")

val connection = url.openConnection()

val inputStream = connection.getInputStream()

val content = inputStream.bufferedReader().use { it.readText() }

println(content)

}

URLConnection: Clase abstracta que establece una conexión a un recurso a través de una URL.

import java.net.URL
import java.net.HttpURLConnection

fun main() {
    val url = URL("http://www.example.com")
    val connection = url.openConnection() as HttpURLConnection
    connection.requestMethod = "GET"
    val inputStream = connection.inputStream
    val content = inputStream.bufferedReader().use { it.readText() }
    println(content)
}

import java.net.URL

import java.net.HttpURLConnection

fun main() {

val url = URL("http://www.example.com")

val connection = url.openConnection() as HttpURLConnection

connection.requestMethod = "GET"

val inputStream = connection.inputStream

val content = inputStream.bufferedReader().use { it.readText() }

println(content)

}

Socket: Clase que representa un socket de red y permite la comunicación entre procesos a través de la red.

import java.net.ServerSocket
import java.net.Socket

fun main() {
    val serverSocket = ServerSocket(1234)
    println("Esperando conexión...")
    val clientSocket = serverSocket.accept()
    println("Conexión aceptada de ${clientSocket.inetAddress}")

    val out = clientSocket.getOutputStream()
    out.write("Hola, cliente!".toByteArray())
    out.flush()
    clientSocket.close()
    serverSocket.close()
}

import java.net.ServerSocket

import java.net.Socket

fun main() {

val serverSocket = ServerSocket(1234)

println("Esperando conexión...")

val clientSocket = serverSocket.accept()

println("Conexión aceptada de ${clientSocket.inetAddress}")

val out = clientSocket.getOutputStream()

out.write("Hola, cliente!".toByteArray())

out.flush()

clientSocket.close()

serverSocket.close()

}

SocketChannel: Una clase para operaciones de socket no bloqueantes en Kotlin.

import java.nio.channels.ServerSocketChannel
import java.nio.channels.SocketChannel

fun main() {
    val serverChannel = ServerSocketChannel.open()
    serverChannel.bind(java.net.InetSocketAddress(1234))
    println("Esperando conexión...")
    val clientChannel = serverChannel.accept()
    println("Conexión aceptada de ${clientChannel.remoteAddress}")

    val buffer = java.nio.ByteBuffer.allocate(1024)
    clientChannel.read(buffer)
    buffer.flip()
    println("Mensaje recibido: ${String(buffer.array(), buffer.position(), buffer.remaining())}")
    clientChannel.close()
    serverChannel.close()
}

import java.nio.channels.ServerSocketChannel

import java.nio.channels.SocketChannel

fun main() {

val serverChannel = ServerSocketChannel.open()

serverChannel.bind(java.net.InetSocketAddress(1234))

println("Esperando conexión...")

val clientChannel = serverChannel.accept()

println("Conexión aceptada de ${clientChannel.remoteAddress}")

val buffer = java.nio.ByteBuffer.allocate(1024)

clientChannel.read(buffer)

buffer.flip()

println("Mensaje recibido: ${String(buffer.array(), buffer.position(), buffer.remaining())}")

clientChannel.close()

serverChannel.close()

}

DatagramSocket: Para trabajar con datagramas y sockets UDP en Kotlin.

import java.net.DatagramPacket
import java.net.DatagramSocket
import java.net.InetAddress

fun main() {
    val socket = DatagramSocket()
    val message = "Hola, UDP!"
    val buffer = message.toByteArray()
    val packet = DatagramPacket(buffer, buffer.size, InetAddress.getByName("localhost"), 1234)
    socket.send(packet)
    socket.close()
}

import java.net.DatagramPacket

import java.net.DatagramSocket

import java.net.InetAddress

fun main() {

val socket = DatagramSocket()

val message = "Hola, UDP!"

val buffer = message.toByteArray()

val packet = DatagramPacket(buffer, buffer.size, InetAddress.getByName("localhost"), 1234)

socket.send(packet)

socket.close()

}

Seguridad

Cipher: Clase que proporciona funcionalidad de cifrado y descifrado para encriptar y desencriptar datos.

import javax.crypto.Cipher
import javax.crypto.KeyGenerator
import javax.crypto.SecretKey

fun main() {
    val keyGen = KeyGenerator.getInstance("AES")
    keyGen.init(128)
    val secretKey = keyGen.generateKey()

    val cipher = Cipher.getInstance("AES")
    cipher.init(Cipher.ENCRYPT_MODE, secretKey)
    val encrypted = cipher.doFinal("Mensaje secreto".toByteArray())

    cipher.init(Cipher.DECRYPT_MODE, secretKey)
    val decrypted = cipher.doFinal(encrypted)

    println("Mensaje desencriptado: ${String(decrypted)}")
}

import javax.crypto.Cipher

import javax.crypto.KeyGenerator

import javax.crypto.SecretKey

fun main() {

val keyGen = KeyGenerator.getInstance("AES")

keyGen.init(128)

val secretKey = keyGen.generateKey()

val cipher = Cipher.getInstance("AES")

cipher.init(Cipher.ENCRYPT_MODE, secretKey)

val encrypted = cipher.doFinal("Mensaje secreto".toByteArray())

cipher.init(Cipher.DECRYPT_MODE, secretKey)

val decrypted = cipher.doFinal(encrypted)

println("Mensaje desencriptado: ${String(decrypted)}")

}

SecureRandom: Clase que genera números aleatorios criptográficamente seguros.

import java.security.SecureRandom

fun main() {
    val secureRandom = SecureRandom()
    val randomNumber = secureRandom.nextInt()
    println("Número aleatorio seguro: $randomNumber")
}

import java.security.SecureRandom

fun main() {

val secureRandom = SecureRandom()

val randomNumber = secureRandom.nextInt()

println("Número aleatorio seguro: $randomNumber")

}

KeyStore: Clase que almacena claves criptográficas y certificados de seguridad.

import java.security.KeyStore
import java.security.KeyStoreException
import java.security.cert.CertificateException
import java.security.cert.CertificateFactory
import java.io.FileInputStream

fun main() {
    val keyStore = KeyStore.getInstance("JKS")
    keyStore.load(FileInputStream("miKeystore.jks"), "password".toCharArray())

    val certificate = keyStore.getCertificate("miAlias")
    println("Certificado: $certificate")
}

import java.security.KeyStore

import java.security.KeyStoreException

import java.security.cert.CertificateException

import java.security.cert.CertificateFactory

import java.io.FileInputStream

fun main() {

val keyStore = KeyStore.getInstance("JKS")

keyStore.load(FileInputStream("miKeystore.jks"), "password".toCharArray())

val certificate = keyStore.getCertificate("miAlias")

println("Certificado: $certificate")

}

KeyPairGenerator: Para generar pares de claves criptográficas (pública y privada) en Kotlin.

import java.security.KeyPairGenerator
import java.security.KeyPair

fun main() {
    val keyPairGen = KeyPairGenerator.getInstance("RSA")
    keyPairGen.initialize(2048)
    val keyPair: KeyPair = keyPairGen.generateKeyPair()
    
    println("Clave pública: ${keyPair.public}")
    println("Clave privada: ${keyPair.private}")
}

import java.security.KeyPairGenerator

import java.security.KeyPair

fun main() {

val keyPairGen = KeyPairGenerator.getInstance("RSA")

keyPairGen.initialize(2048)

val keyPair: KeyPair = keyPairGen.generateKeyPair()

println("Clave pública: ${keyPair.public}")

println("Clave privada: ${keyPair.private}")

}

MessageDigest: Clase que proporciona funciones de resumen criptográfico, como SHA-256 o MD5, para procesar datos.

import java.security.MessageDigest

fun main() {
    val digest = MessageDigest.getInstance("SHA-256")
    val hash = digest.digest("Mensaje a hashear".toByteArray())
    val hexString = hash.joinToString("") { "%02x".format(it) }
    println("Hash SHA-256: $hexString")
}

import java.security.MessageDigest

fun main() {

val digest = MessageDigest.getInstance("SHA-256")

val hash = digest.digest("Mensaje a hashear".toByteArray())

val hexString = hash.joinToString("") { "%02x".format(it) }

println("Hash SHA-256: $hexString")

}

SSLContext: Para configurar conexiones seguras con el protocolo SSL/TLS en Kotlin.

import javax.net.ssl.SSLContext
import javax.net.ssl.TrustManagerFactory
import javax.net.ssl.KeyManagerFactory
import java.security.KeyStore

fun main() {
    val keyStore = KeyStore.getInstance("JKS").apply {
        load(FileInputStream("miKeystore.jks"), "password".toCharArray())
    }

    val keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm())
    keyManagerFactory.init(keyStore, "password".toCharArray())

    val trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())
    trustManagerFactory.init(keyStore)

    val sslContext = SSLContext.getInstance("TLS")
    sslContext.init(keyManagerFactory.keyManagers, trustManagerFactory.trustManagers, null)
    
    println("SSLContext configurado con TLS")
}

import javax.net.ssl.SSLContext

import javax.net.ssl.TrustManagerFactory

import javax.net.ssl.KeyManagerFactory

import java.security.KeyStore

fun main() {

val keyStore = KeyStore.getInstance("JKS").apply {

load(FileInputStream("miKeystore.jks"), "password".toCharArray())

}

val keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm())

keyManagerFactory.init(keyStore, "password".toCharArray())

val trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())

trustManagerFactory.init(keyStore)

val sslContext = SSLContext.getInstance("TLS")

sslContext.init(keyManagerFactory.keyManagers, trustManagerFactory.trustManagers, null)

println("SSLContext configurado con TLS")

}

Conceptos importantes en Kotlin relacionados con procesos, hilos, red y seguridad (Seguridad, Red, Procesos, Kotlin, Hilos)

Procesos

Hilos

Red

Seguridad

LIBRO DE POWERSHELL

LO ÚLTIMO

VÍDEOS