curl -L -X POST "https://www.hasarservicios.com.ar/YOUR_CHANNEL_UID.blic" -H "Authorization: ••••••"
Atención: estos ejemplos pueden exponer el token de acceso si se ejecutan directamente en navegadores públicos o sin capa intermedia de seguridad.
Recomendado solo para entornos controlados o backends.
📡 Solicitud HTTP sin librerías
POST /YOUR_CHANNEL_UID.blic HTTP/1.1
Host: www.hasarservicios.com.ar
Authorization: ••••••
💻 JavaScript con Fetch API
fetch("https://www.hasarservicios.com.ar/YOUR_CHANNEL_UID.blic", {
method: "POST",
headers: {
"Authorization": "••••••"
}
})
.then(response => {
if (!response.ok) throw new Error("Error en la solicitud: " + response.status);
return response.text();
})
.then(data => {
console.log(data);
})
.catch(error => {
console.error("Error:", error);
});
📦 JavaScript con Axios
axios.post("https://www.hasarservicios.com.ar/YOUR_CHANNEL_UID.blic", null, {
headers: {
"Authorization": "••••••"
}
})
.then(response => {
console.log(response.data);
})
.catch(error => {
console.error("Error:", error);
});
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://www.hasarservicios.com.ar/YOUR_CHANNEL_UID.blic");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
var options = new RestClientOptions("https://www.hasarservicios.com.ar")
{
MaxTimeout = -1,
};
var client = new RestClient(options);
var request = new RestRequest("/YOUR_CHANNEL_UID.blic", Method.Post);
request.AddHeader("Authorization", "••••••");
RestResponse response = await client.ExecuteAsync(request);
Console.WriteLine(response.Content);
import httpx
import asyncio
async def send_request():
url = "https://www.hasarservicios.com.ar/YOUR_CHANNEL_UID.blic"
headers = {
"Authorization": "••••••"
}
async with httpx.AsyncClient() as client:
response = await client.post(url, headers=headers)
response.raise_for_status() # Equivalente a EnsureSuccessStatusCode
print(response.text)
asyncio.run(send_request())
OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = RequestBody.create(mediaType, "");
Request request = new Request.Builder()
.url("https://www.hasarservicios.com.ar/YOUR_CHANNEL_UID.blic")
.method("POST", body)
.addHeader("Authorization", "••••••")
.build();
Response response = client.newCall(request).execute();
package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "https://www.hasarservicios.com.ar/YOUR_CHANNEL_UID.blic"
method := "POST"
client := &http.Client {
}
req, err := http.NewRequest(method, url, nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "••••••")
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()
body, err := io.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
Este ejemplo utiliza reqwest con tokio para ejecutar solicitudes HTTP POST desde una aplicación en Rust.
🔧 Dependencias requeridas
[dependencies]
tokio = { version = "1", features = ["full"] }
reqwest = { version = "0.11", features = ["json", "blocking"] }
📦 Código en Rust
use reqwest::Client;
use std::error::Error;
#[tokio::main]
async fn main() -> Result<(), Box> {
let client = Client::new();
let res = client.post("https://www.hasarservicios.com.ar/YOUR_CHANNEL_UID.blic")
.header("Authorization", "••••••")
.send()
.await?;
let body = res.text().await?;
println!("Respuesta: {}", body);
Ok(())
}
Este ejemplo muestra cómo realizar una solicitud HTTP POST usando sockets TCP en C puro, sin librerías externas. Solo funciona en conexiones HTTP (puerto 80). No incluye TLS/HTTPS.
💡 Ejemplo educativo en lenguaje C
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <netdb.h>
#include <arpa/inet.h>
int main() {
const char *host = "www.hasarservicios.com.ar";
const int port = 80; // Solo HTTP
const char *endpoint = "/YOUR_CHANNEL_UID.blic";
const char *auth = "••••••";
char request[1024];
snprintf(request, sizeof(request),
"POST %s HTTP/1.1\r\n"
"Host: %s\r\n"
"Authorization: %s\r\n"
"Content-Length: 0\r\n"
"Connection: close\r\n"
"\r\n",
endpoint, host, auth
);
struct hostent *server = gethostbyname(host);
if (!server) {
fprintf(stderr, "No se pudo resolver host\n");
return 1;
}
int sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0) {
perror("socket");
return 1;
}
struct sockaddr_in serv_addr;
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(port);
memcpy(&serv_addr.sin_addr.s_addr, server->h_addr, server->h_length);
if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
perror("connect");
return 1;
}
send(sock, request, strlen(request), 0);
char buffer[2048];
int n;
while ((n = read(sock, buffer, sizeof(buffer) - 1)) > 0) {
buffer[n] = 0;
printf("%s", buffer);
}
close(sock);
return 0;
}
¿Y HTTPS? Para conexiones seguras, se recomienda usar libcurl, OpenSSL o bibliotecas de alto nivel.
Este ejemplo es puramente ilustrativo. Si estás escribiendo peticiones HTTP en Assembly... probablemente seas tú el sistema operativo.
💾 Código (es un chiste... ¿o no?)
section .data
; Datos
url db "https://www.hasarservicios.com.ar/YOUR_SOUL.blic", 0
method db "POST", 0
token db "Authorization: Bearer ", 0x1F, 0x47, 0x4F, 0x44, 0 ; Bearer ....0xtoken_bytes....
payload db '{"data": "', 0xDE, 0xAD, 0xBE, 0xEF, '"}', 0 ; Payload
content_type db "Content-Type: application/json", 0
user_agent db "User-Agent: geek. curl/7.79.1 (x86_64-pc-linux-gnu) Libcurl/7.79.1 OpenSSL/1.1.1l", 0
; Mensajes de error
error_socket db "[0x00000666] Falló al invocar el socket. ¿Acaso el kernel te odia?", 0
error_connect db "[0x00000777] No se pudo conectar. ¿Seguro que el DNS no es un mito?", 0
error_write db "[0x0000AAAA] El servidor se comió tu request. RIP.", 0
section .text
global _start
_start:
; === Paso 1: Abrir un socket ===
mov rax, 41 ; syscall: socket(AF_INET, SOCK_STREAM, 0)
mov rdi, 2 ; AF_INET (IPv4)
mov rsi, 1 ; SOCK_STREAM (TCP)
xor rdx, rdx ; protocolo 0 (como tu esperanza)
syscall
cmp rax, 0
jl .fail_socket ; Si el socket es negativo, algo salió mal (como tu vida)
mov r15, rax ; Guardar el file descriptor del socket en r15 (tu único amigo)
; === Paso 2: Conectar al servidor
; Estructura sockaddr_in (manual a mano, porque en ASM no hay atajos)
push 0 ; IP: 0.0.0.0 (¿o era 127.0.0.1? Nadie lo sabe)
push word 0x5000 ; Puerto 80 (¡en network byte order!)
push word 2 ; AF_INET
mov rsi, rsp ; Puntero a la estructura
mov rax, 42 ; syscall: connect
mov rdi, r15 ; File descriptor del socket
mov rdx, 16 ; Tamaño de sockaddr_in
syscall
cmp rax, 0
jl .fail_connect ; Si connect falla, el servidor te rechazó (como todas)
; === Paso 3: Escribir el request HTTP ===
; Construir el request manualmente (porque no hay libcurl en el mundo)
sub rsp, 1024 ; Espacio en el stack para el request (sí, esto es frágil como la cordura)
mov r14, rsp ; Guardar el puntero al request
; Formato del request
mov rdi, r14
lea rsi, [rel method]
call .strcpy ; Copiar "POST"
mov byte [rdi], ' ' ; Añadir espacio
inc rdi
lea rsi, [rel url]
call .strcpy ; Copiar la URL (¿o era un URN? ¿Quién sabe?)
mov dword [rdi], 0x48545450 ; "HTTP" en little-endian-tonic (¿o era "PTTH"?)
add rdi, 4
; ... (aquí irían más partes del request, pero mejor lo dejamos así para te atiendan los paramédicos)
; === Paso 4: Enviar el request (y rezar) ===
mov rax, 1 ; syscall: write
mov rdi, r15 ; File descriptor del socket
mov rsi, r14 ; Puntero al request
mov rdx, 1024 ; Tamaño del buffer (¿o era 1023? ¡Nadie lo comprobó!)
syscall
cmp rax, 0
jl .fail_write ; Si write falla, el servidor te ignoró (como tu futura ex)
; === Paso 5: Cerrar el socket (y tu dignidad) ===
mov rax, 3 ; syscall: close
mov rdi, r15
syscall
; Salir con estilo (exit code 0, porque eres un optimista)
mov rax, 60
xor rdi, rdi
syscall
; === Subsistemas (funciones auxiliares) ===
.strcpy:
; Copia una string de rsi a rdi (hasta encontrar un null)
lodsb
stosb
test al, al
jnz .strcpy
ret
; === Manejo de errores (más oscuro que tu futuro) ===
.fail_socket:
mov rsi, error_socket
call .panic
.fail_connect:
mov rsi, error_connect
call .panic
.fail_write:
mov rsi, error_write
call .panic
.panic:
; Imprimir un mensaje de error y morir (como un segmentation fault)
mov rax, 1 ; syscall: write
mov rdi, 2 ; stderr (el abismo te observa)
mov rdx, 64 ; Longitud arbitraria (¿quién cuenta?)
syscall
; Salir con error (como el código en producción)
mov rax, 60
mov rdi, 1
syscall
Disclaimer: No intentes esto en producción. Tu DBA llorará. Tu jefe te mirará raro. Y tu alma se fragmentará como heap sin compactar.