¿Estas a favor o en contra de las CBDC?

¿Por que?

Hola,

supongo que creiste que hiciste un post nuevo. Lo que hiciste fue responder a un mensaje viejo. Para crear un post nuevo, entra al foro desde foro.elhacker.net, entra a algun subforo (una pestaña que encaje con tu pregunta) y al final de todo, abajo, hay un boton llamado "Nuevo tema".

Respecto a tu pregunta, cambia la contraseña del correo, y cuando Google te pregunte si quieres cerrar sesion en los demas dispositivos, le dices que si.

Crea una contraseña robusta.

esta herramienta: https://www.random.org/strings/

puedes utilizarla para crearla si eres muy poco creativo como yo xd.

si tienes poca memoria, como yo, anotala en algun sitio que sepas que esta bien oculto y ya esta.

Saludos.

RayR si, utilizaba la opcion -O. La quite y seguia generando el mismo codigo (solo que sin optimizar).

Me parece curiosisimo que GCC se atreva a resolver una direccion como 0, aunque igual estoy haciendo algo mal yo (seguramente) y eso lo hace como medida de seguridad para que mas bien falle antes de tener un comportamiento no deseado.

El codigo es tal cual como mostre... lo que mas bien creo que genera el problema es que estoy generando codigo "independiente". Por un momento pense en ver si era LD lo que estaba resolviendo las direcciones a 0, pero luego compile el codigo a ASM y lo que vi fue precisamente eso... resoluciones a 0 u omisiones por completo del codigo en cuestion.

En fin... al final me fui por otra manera de hacer lo mismo. En terminos de costo/beneficio no me costaba nada hallar otra forma de hacer lo mismo. No se si eso es muy o muy poco hacker de mi parte XD De igual forma gracias por su ayuda.

BloodSharp gracias por la sugerencia pero si, tendria que ser en C puro. De igual forma no podria ser una funcion lambda. Tendria que ser una funcion anidada "practicamente" a bajo nivel.

Es decir, que

int foo()
{
    // ...
    int subf()
    {
        return 0;
    }
    // ...
    subf();
    // ...
}

se compile a

foo:
; ...
subf:
mov rax, 0
ret
; ...
call subf
; ...
ret

RayR realmente era una forma de hacer lo que pretendia hacer. Ya halle otra manera, al final no me fue necesario usar funciones anidadas.

Mi problema vino con problematicas al generar codigo PIC con GCC justamente. da problemas cuando utilizas punteros a funciones e iba a intentar implementar la funcion como anidada a ver si asi el compilador cargaba el desplazamiento.

Por alguna razon, al hacer:

int (*__ptr__foo)();
__ptr__foo = &foo;

al intentar hacer cosas con __ptr__foo me di cuenta que el compilador simplemente omite las lineas que lo incluyen. Es decir, si hago algo como:

int (*__ptr__foo)();
__ptr__foo = &foo;
mostrar(__ptr__foo);

(mostrar seria una funcion hipotetica. Para poner mejor en contexto cabe mencionar que no estoy enlazando ninguna libreria estandar o no estandar)

lo que me muestra es:


es decir, o no lo incluye, o cuando se le requiere lo "optimiza" como 0.

la verdad no se por que ocurre.

lo que hice para solucionarlo fue un poco sucio. Cree una funcion llamada get_ptr:

void *get_ptr()
{
    return __ptr__foo;
}

que se compila a:

get_ptr:
mov rax, 0
ret

(porque como digo, siempre interpreta punteros a funciones (locales, ojo, es decir, dentro del scope. Porque luego puedo apuntar a alguna API o syscall y la ejecuta con exito)

y lo que hice fue un programa que carga el .asm en memoria y reemplaza

get_ptr:
mov rax, 0
ret

por

get_ptr:
mov rax, foo
ret

ya se, una solucion medio barata pero no se me ocurre otra cosa

Comento el contexto por si a alguien le interesara aconsejar alguna practica mas eficiente/limpia o cualquier otro bonito adjetivo xd

Hola,

¿Existe alguna forma en la que pueda anidar funciones en el lenguaje C?

Tengo entendido que no... Pero si alguien conoce al menos algo que tenga el mismo resultado que:

int foo()
{
    // ...
    int subf()
    {
        return 0;
    }
    // ...
    subf();
    // ...
}

lo agradeceria. Un saludo

Hola,

me acabo de dar cuenta que tengo un directorio llamado /gnu en mi directorio raiz.

¿Alguien sabe que es exactamente?

Busque en internet y no entendi muy bien que es exactamente lo que almacena este directorio pero entiendo que tiene que ver con Guix (que hasta ahora no me entero de que es xd).

la cuestion no es que es Guix, sino por que lo tengo. nunca lo instale. El directorio aparecio de la nada y ocupa el 50% de todo mi disco. Raro.

En fin, ¿Alguna idea de que es? Comienzo a pensar que es un troyano ransomware encriptandolo todo porque curiosamente lo que hay son archivos con nombres cripticos.

EDIT

Resulta que ocupaba la mitad del disco porque estaba montado en el disco xdddd error mio

efectivamente se debia a Guix. Ya lo desinstale y lo resolvio, sin embargo me sigo preguntando por que estaba Guix ahi si nunca lo instale en el pasado.

Gracias de antemano por la ayuda y un saludo.

¿Estas seguro de que no cambiaron el link?

De otro modo es dificil tener idea de como tienes ese resultado.

Deberias intentar descargarla desde otro lado, porque en este caso probablemente cambiaron el link.

Eso, o estas presionando el boton equivocado.

Fijate en donde esta y como es el boton que diga "Donwload" o "Descarga". Tal vez lo movieron y estas dando click a alguna publicidad en vez de al archivo para la descarga.

MOD: Removido cita de spam

Gracias por sus respuestas, MCKSys Argentina y BloodSharp, pero sigo preguntandome que tiene de ventajoso utilizar la sintaxis de at&t. No se por que uno se molestaria en usarla ademas de simplemente formar parte de la cultura de UNIX (mas bien GNU), la cual considero increible por cierto.

xd

¿Lo usual? ¿O sea, lo dices por lo que dijiste sobre el depurador ahi?

No...

No estoy utilizando depuradores.

este codigo:

unsigned int strlen(void)
{
    return 0;
}
 
int main()
{
    return strlen();
}

si se compila con

wcc386 main.c -s -w9 -e25 -oa -d0 -5 -bt=nt

y luego se procesa el codigo objeto con objconv para que me muestre el codigo en formato de nasm:

objconv -fnasm main.obj -o main.asm

resulta:

global strlen
global main
global _cstart_
 
_cstart_:
 
call main
ret
 
strlen:
mov eax, 0
ret
 
main:
call strlen
ret

el codigo resultante es PIC. No es necesario que sea PIC, pero hay funciones que requiero que sean PIC, porque se implementan en diferentes direcciones. No quiero especificar para no confundir, pero ese seria el objetivo.

Hasta ese punto que mostre no hay problema el problema viene cuando quiero hacer el codigo compatible con sistemas de 64 bits.

El codigo no tiene que ser portable e implemento nuestras propias funciones estandar. No quiero usar las que proporciona GCC.

es decir, entiendo que el prototipo de strlen para el C estandar es:

size_t strlen ( const char * str );

pero no quiero tener nada que ver con el "C estandar", sino lo que ofrece el compilador de WATCOM C, que es que ni compila ni enlaza librerias sin pedirselo.

NOTA en el link que adjuntaste se habla de la API de Windows, en este caso, a pesar de que que hablo de WATCOM, no tiene nada que ver con Windows especificamente. Aunque sin duda el alineamiento es un tema que se debe tomar en cuenta.

---

Eternal Idol

Ya lo solucione.

---

Para quien se pregunte como:

Los procedimientos que implementaran estrictamente codigo ensamblador, los implemente en archivos distintos. Los compile con NASM y los enlace con LD junto al codigo en C.

Por otra parte, para decirle a GCC "que no enlace nada" y ademas que no incluya funciones inesperadas:

gcc -pie -nostdlib -nostartfiles -fno-stack-protector main.c -c -O -o main.obj

ADVERTENCIA

Como se puede notar, la necesidad implica saltarse la proteccion del stack (para no incluir funciones "inesperadas").

Esto puede suponer riesgos de SO, obviamente.

Un saludo.

Hola,

Me gustaria preguntar algo que aunque pueda parecer banal, la he tenido en la cabeza desde hace años.

¿A que se debe la sintaxis de at&t de ensamblador?

Mas bien, ¿Que ventaja tiene sobre las demas, ademas de verse como un plato spaghetti y ser innecesariamente incomodo de leer?

Gracias de antemano y perdon por el tono quejon : D