Antecedentes

Ya tenemos un desafío sobre lanzar SIGSEGV , entonces, ¿por qué no un desafío sobre lanzar SIGILL?

¿Qué es SIGILL?

SIGILL es la señal de una instrucción ilegal en el procesador, que ocurre muy raramente. La acción predeterminada después de recibir SIGILL es terminar el programa y escribir un volcado de memoria. La identificación de la señal de SIGILL es 4. Te encuentras con SIGILL muy raramente, y no tengo ni idea de cómo generarlo en tu código, excepto a través de sudo kill -s 4 <pid>.

Reglas

Tendrá root en sus programas, pero si no lo desea por algún motivo, también puede usar un usuario normal. Estoy en una computadora Linux con configuración regional alemana y no sé el texto en inglés que se muestra después de capturar SIGILL, pero creo que es algo así como 'Instrucción ilegal'. El programa más corto que arroja SIGILL gana.

Ensamblador PDP-11 (Sexta edición de UNIX), 1 byte

9

La Instrucción 9 no es una instrucción válida en el PDP-11 (en octal, lo sería 000011, lo que no aparece en la lista de instrucciones (PDF)). El ensamblador PDP-11 que se entrega con UNIX Sixth Edition aparentemente hace eco de todo lo que no entiende en el archivo directamente; en este caso, 9 es un número, por lo que genera una instrucción literal 9. También tiene la propiedad impar (inusual en los lenguajes de ensamblaje hoy en día) de que los archivos comienzan a ejecutarse desde el principio, por lo que no necesitamos ninguna declaración para hacer el programa trabajo.

Puede probar el programa usando este emulador , aunque tendrá que luchar un poco con él para ingresar el programa.

Así es como terminan las cosas una vez que has descubierto cómo usar el sistema de archivos, el editor, el terminal y cosas similares que creías que ya sabías cómo usar:

% a.out
Illegal instruction -- Core dumped

He confirmado con la documentación que esta es una SIGILLseñal genuina (¡e incluso tenía el mismo número de señal, 4, en todo momento!)

C (x86_64, tcc ), 7 bytes

main=6;

Inspirado por esta respuesta .

Pruébalo en línea!

Cómo funciona

El conjunto generado se ve así.

    .globl  main
main:
    .long 6

Tenga en cuenta que TCC no coloca la "función" definida en un segmento de datos .

Después de la compilación, _start apuntará a main como de costumbre. Cuando se ejecuta el programa resultante, espera código en main y encuentra el entero 6 de 32 bits little-endian (!) , Que está codificado como 0x06 0x00 0x00 0x00 . El primer byte, 0x06 , es un código de operación no válido, por lo que el programa termina con SIGILL .

C (x86_64, gcc ), 13 bytes

const main=6;

Pruébalo en línea!

Cómo funciona

Sin el modificador const , el conjunto generado se ve así.

    .globl  main
    .data
main:
    .long   6
    .section    .note.GNU-stack,"",@progbits

El enlazador de GCC trata la última línea como una pista de que el objeto generado no requiere una pila ejecutable. Dado que main se coloca explícitamente en una sección de datos , el código de operación que contiene no es ejecutable, por lo que el programa termina SIGSEGV (error de segmentación).

Al eliminar la segunda o la última línea, el ejecutable generado funcionará según lo previsto. La última línea podría ignorarse con el indicador del compilador -zexecstack(¡ Pruébelo en línea! ), Pero esto cuesta 12 bytes .

Una alternativa más corta es declarar main con el modificador const , lo que resulta en el siguiente ensamblaje.

        .globl  main
        .section    .rodata
main:
        .long   6
        .section    .note.GNU-stack,"",@progbits

Esto funciona sin ningún indicador del compilador. Tenga en cuenta que main=6;escribiría la "función" definida en los datos , pero el modificador constante hace que GCC la escriba en rodata , que (al menos en mi plataforma) puede contener código.

Rápido, 5 bytes

[][0]

Índice de acceso 0 de una matriz vacía. Esto llama fatalError(), que imprime un mensaje de error y se bloquea con un SIGILL. Puedes probarlo aquí .

GNU C, 25 bytes

main(){__builtin_trap();}

GNU C (un dialecto específico de C con extensiones) contiene una instrucción para bloquear el programa intencionalmente. La implementación exacta varía de una versión a otra, pero a menudo los desarrolladores intentan implementar el bloqueo lo más barato posible, lo que normalmente implica el uso de una instrucción ilegal.

La versión específica que solía probar es gcc (Ubuntu 5.4.0-6ubuntu1~16.04.4) 5.4.0; sin embargo, este programa causa una SIGILL en una gama bastante amplia de plataformas y, por lo tanto, es bastante portátil. Además, lo hace mediante la ejecución de una instrucción ilegal. Aquí está el código de ensamblaje en el que se compila lo anterior con la configuración de optimización predeterminada:

main:
    pushq %rbp
    movq %rsp, %rbp
    ud2

ud2 es una instrucción que Intel garantiza que siempre permanecerá indefinida.

C (x86_64), 11, 30, 34 o 34 + 15 = 49 bytes

main[]="/";
c=6;main(){((void(*)())&c)();}
main(){int c=6;((void(*)())&c)();}

He presentado un par de soluciones que usan funciones de biblioteca para lanzar a SIGILLtravés de varios medios, pero podría decirse que es trampa, ya que la función de biblioteca resuelve el problema. Aquí hay una gama de soluciones que no utilizan funciones de biblioteca y hacen suposiciones variables sobre dónde el sistema operativo está dispuesto a permitirle ejecutar código no ejecutable. (Las constantes aquí se eligen para x86_64, pero puede cambiarlas para obtener soluciones de trabajo para la mayoría de los otros procesadores que tienen instrucciones ilegales).

06es el byte de código máquina con el número más bajo que no corresponde a una instrucción definida en un procesador x86_64. Entonces, todo lo que tenemos que hacer es ejecutarlo. (Alternativamente, 2Ftambién está indefinido y corresponde a un único carácter ASCII imprimible). Ninguno de estos está garantizado que siempre esté indefinido, pero no están definidos a partir de hoy.

El primer programa aquí se ejecuta 2Fdesde el segmento de datos de solo lectura. La mayoría de los enlazadores no son capaces de producir un salto trabajando desde .texta .rodata(o el equivalente en su sistema operativo) ya que no es algo que nunca sería útil en un programa correctamente segmentada; Todavía no he encontrado un sistema operativo en el que esto funcione. También debería tener en cuenta el hecho de que muchos compiladores quieren que la cadena en cuestión sea una cadena ancha, lo que requeriría un adicionalL; Supongo que cualquier sistema operativo en el que funcione tiene una visión bastante desactualizada de las cosas y, por lo tanto, se está construyendo para un estándar anterior a C94 por defecto. Es posible que no haya ningún lugar donde funcione este programa, pero también es posible que haya algún lugar donde funcione este programa, y ​​por lo tanto lo estoy enumerando en esta colección de posibles respuestas más dudosas a menos dudosas. (Después de publicar esta respuesta, Dennis también mencionó la posibilidad main[]={6}en el chat, que tiene la misma longitud y que no tiene problemas con el ancho de los caracteres, e incluso insinuó el potencial para main=6; No puedo reclamar razonablemente estas respuestas como mía, ya que no pensé en ellos yo mismo).

El segundo programa aquí se ejecuta 06desde el segmento de datos de lectura-escritura. En la mayoría de los sistemas operativos, esto causará una falla de segmentación, ya que los segmentos de datos grabables se consideran un defecto de diseño incorrecto que hace que las vulnerabilidades sean probables. Sin embargo, este no siempre ha sido el caso, por lo que probablemente funcione en una versión suficientemente antigua de Linux, pero no puedo probarlo fácilmente.

El tercer programa se ejecuta 06desde la pila. Nuevamente, esto causa una falla de segmentación hoy en día, porque la pila normalmente se clasifica como no escribible por razones de seguridad. La documentación del enlazador que he visto implica en gran medida que solía ser legal ejecutarlo desde la pila (a diferencia de los dos casos anteriores, hacerlo ocasionalmente es útil), así que aunque no puedo probarlo, estoy bastante seguro de que hay algunos versión de Linux (y probablemente otros sistemas operativos) en la que esto funciona.

Finalmente, si le da -Wl,-z,execstack(penalización de 15 bytes) a gcc(si usa GNU ldcomo parte del backend), desactivará explícitamente la protección de la pila ejecutable, permitiendo que el tercer programa funcione y dé una señal de operación ilegal como se esperaba. Yo he probado y verificado esta versión 49 bytes para trabajar. (Dennis menciona en el chat que aparentemente esta opción funciona main=6, lo que daría un puntaje de 6 + 15. Estoy bastante sorprendido de que esto funcione, dado que el 6 descaradamente no está en la pila; la opción de enlace aparentemente hace más de su nombre lo sugiere.)

GNU como (x86_64), 3 bytes

ud2

$ xxd sigill.S

00000000: 7564 32                                  ud2

$ as --64 sigill.S -o sigill.o; ld -S sigill.o -o sigill

sigill.S: Assembler messages:
sigill.S: Warning: end of file not at end of a line; newline inserted
ld: warning: cannot find entry symbol _start; defaulting to 0000000000400078

$ ./sigill

Illegal instruction

$ objdump -d sigill

sigill:     file format elf64-x86-64

Disassembly of section .text:

0000000000400078 <__bss_start-0x200002>:>
  400078:       0f 0b                   ud2

Bash en Raspbian en QEMU, 4 (1?) Bytes

No es mi trabajo Simplemente informo el trabajo de otro. Ni siquiera estoy en condiciones de probar el reclamo. Dado que una parte crucial de este desafío parece ser encontrar un entorno en el que se eleve y capture esta señal, no incluyo el tamaño de QEMU, Raspbian o bash.

El 27 de febrero de 2013, 8:49 pm, el usuario emlhalac informó " Obteniendo 'instrucciones ilegales' al intentar chroot " en el foro Raspberry Pi.

ping

productor

qemu: uncaught target signal 4 (Illegal instruction) - core dumped
Illegal instruction (core dumped)

Imagino comandos mucho más cortos producirán esta salida, por ejemplo, tr.

EDITAR: Basado en el comentario de @ fluffy , redujo el límite inferior conjeturado en la longitud de entrada a "1?".

Archivo COM x86 MS-DOS, 2 bytes

EDITAR: Como se señaló en los comentarios, el DOS en sí no atrapará la excepción de la CPU y simplemente se bloqueará (no solo la aplicación, todo el sistema operativo). Ejecutar en un sistema operativo basado en NT de 32 bits como Windows XP, de hecho, activará una señal de instrucción ilegal.

0F 0B

De la documentación :

Genera un código de operación no válido. Esta instrucción se proporciona para pruebas de software para generar explícitamente un código de operación no válido.

Lo cual se explica por sí mismo. Guardar como un archivo .com y ejecutar en cualquier emulador de DOS Los emuladores de DOS simplemente se bloquean. Ejecutar en Windows XP, Vista o 7 de 32 bits.

C (Windows de 32 bits), 34 bytes

f(i){(&i)[-1]-=9;}main(){f(2831);}

Esto solo funciona si se compila sin optimizaciones (de lo contrario, el código ilegal en la ffunción está "optimizado").

El desmontaje de la mainfunción se ve así:

68 0f 0b 00 00    push 0b0f
e8 a1 d3 ff ff    call _f
...

Podemos ver que usa una pushinstrucción con un valor literal 0b0f(little-endian, por lo que sus bytes se intercambian). La callinstrucción empuja una dirección de retorno (de la ...instrucción), que se encuentra en la pila cerca del parámetro de la función. Al usar un [-1]desplazamiento, la función anula la dirección de retorno, por lo que señala 9 bytes antes, donde están los bytes 0f 0b.

Estos bytes provocan una excepción de "instrucción indefinida", como se diseñó.

Java, 50 43 24 bytes

a->a.exec("kill -4 $$");

Este es un java.util.function.Consumer<Runtime>¹ cuyo comando es robado de la respuesta de fluffy . Funciona porque debes llamarlo como whateverNameYouGiveIt.accept(Runtime.getRuntime())!

Tenga en cuenta que esto creará un nuevo proceso y hará que arroje un SIGILL en lugar de arrojar un SIGILL.

^{1 - Técnicamente, también puede ser un java.util.function.Function<Runtime, Process>porque Runtime#exec(String)devuelve un java.lang.Processque puede usarse para controlar el proceso que acaba de crear ejecutando un comando de shell.}

En aras de hacer algo más impresionante en un lenguaje tan detallado, aquí hay un bono 72 60 48 bytes:

a->for(int b=0;;b++)a.exec("sudo kill -s 4 "+b);

Este es otro Consumer<Runtime>que pasa por TODOS los procesos (incluido él mismo), haciendo que cada uno de ellos arroje un SIGILL. Mejor prepararse para un choque violento.

Y otra bonificación (a Consumer<ANYTHING_GOES>), que al menos pretende lanzar un SIGILL en 20 bytes:

a->System.exit(132);

Perl, 9 bytes

kill+4,$$

Simplemente llama a la función de biblioteca apropiada para señalar un proceso y hace que el programa se señale a sí mismo SIGILL. Aquí no hay instrucciones ilegales reales, pero produce el resultado apropiado. (Creo que esto hace que el desafío sea bastante barato, pero si algo está permitido, esta es la laguna que usarías ...)

Lenguaje de ensamblador unificado ARM (UAL), 3 bytes

nop

Por ejemplo:

$ as ill.s -o ill.o
$ ld ill.o -o ill
ld: warning: cannot find entry symbol _start; defaulting to 00010054
$ ./ill 
Illegal instruction

Después de ejecutar nop, el procesador interpreta la .ARM.attributessección como código y encuentra una instrucción ilegal en algún lugar:

$ objdump -D ill

ill:     file format elf32-littlearm


Disassembly of section .text:

00010054 <__bss_end__-0x10004>:
   10054:       e1a00000        nop                     ; (mov r0, r0)

Disassembly of section .ARM.attributes:

00000000 <.ARM.attributes>:
   0:   00001341        andeq   r1, r0, r1, asr #6
   4:   61656100        cmnvs   r5, r0, lsl #2
   8:   01006962        tsteq   r0, r2, ror #18
   c:   00000009        andeq   r0, r0, r9
  10:   01080106        tsteq   r8, r6, lsl #2

Probado en una Raspberry Pi 3.

Microsoft C (Visual Studio 2005 en adelante), 16 bytes

main(){__ud2();}

No puedo probar esto fácilmente, pero de acuerdo con la documentación , debería producir una instrucción ilegal al intentar ejecutar intencionalmente una instrucción solo del núcleo desde un programa en modo de usuario. (Tenga en cuenta que debido a que la instrucción ilegal bloquea el programa, no tenemos que intentar regresar main, lo que significa que esta mainfunción de estilo K&R es válida. Visual Studio nunca haber pasado de C89 normalmente es algo malo, pero entró útil aquí.)

Rubí, 13 bytes

`kill -4 #$$`

Supongo que es seguro asumir que estamos ejecutando esto desde un shell * nix. Los literales de retroceso ejecutan el comando de shell dado. $$es el proceso de Ruby en ejecución y #es para la interpolación de cadenas.

Sin llamar al shell directamente:

Rubí, 17 bytes

Process.kill 4,$$

Cualquier shell (sh, bash, csh, etc.), cualquier POSIX (10 bytes)

Respuesta trivial pero no había visto a nadie publicarlo.

kill -4 $$

Solo envía SIGILL al proceso actual. Ejemplo de salida en OSX:

bash-3.2$ kill -4 $$
Illegal instruction: 4

Código de máquina ELF + x86, 45 bytes

Este debería ser el programa ejecutable más pequeño en una máquina Unix que arroja SIGILL (debido a que Linux no reconoce el ejecutable si se hace más pequeño).

Compilar con nasm -f bin -o a.out tiny_sigill.asm, probado en una máquina virtual x64.

Binario real de 45 bytes:

0000000 457f 464c 0001 0000 0000 0000 0000 0001

0000020 0002 0003 0020 0001 0020 0001 0004 0000

0000040 0b0f c031 cd40 0080 0034 0020 0001

Listado de ensamblaje (ver fuente a continuación):

;tiny_sigill.asm      
BITS 32


            org     0x00010000

            db      0x7F, "ELF"             ; e_ident
            dd      1                                       ; p_type
            dd      0                                       ; p_offset
            dd      $$                                      ; p_vaddr 
            dw      2                       ; e_type        ; p_paddr
            dw      3                       ; e_machine
            dd      _start                  ; e_version     ; p_filesz
            dd      _start                  ; e_entry       ; p_memsz
            dd      4                       ; e_phoff       ; p_flags


_start:
                ud2                             ; e_shoff       ; p_align
                xor     eax, eax
                inc     eax                     ; e_flags
                int     0x80
                db      0
                dw      0x34                    ; e_ehsize
                dw      0x20                    ; e_phentsize
                db      1                       ; e_phnum
                                                ; e_shentsize
                                                ; e_shnum
                                                ; e_shstrndx

  filesize      equ     $ - $$

Descargo de responsabilidad: código del siguiente tutorial sobre cómo escribir el programa de ensamblaje más pequeño para devolver un número, pero usando opcode ud2 en lugar de mov: http://www.muppetlabs.com/~breadbox/software/tiny/teensy.html

AutoIt , 93 bytes

Usando el ensamblaje en línea del ensamblador plano

#include<AssembleIt.au3>
Func W()
_("use32")
_("ud2")
_("ret")
EndFunc
_AssembleIt("int","W")

Cuando se ejecuta en modo interactivo SciTE, se bloqueará inmediatamente. El depurador de Windows debería aparecer por una fracción de segundo. La salida de la consola será algo como esto:

--> Press Ctrl+Alt+Break to Restart or Ctrl+Break to Stop
0x0F0BC3
!>14:27:09 AutoIt3.exe ended.rc:-1073741795

¿Dónde -1073741795está el código de error indefinido lanzado por WinAPI? Este puede ser cualquier número negativo.

Similar usando mi propio ensamblador LASM :

#include<LASM.au3>
$_=LASM_ASMToMemory("ud2"&@CRLF&"ret 16")
LASM_CallMemory($_,0,0,0,0)

NASM, 25 bytes

No sé cómo funciona esto, solo que lo hace específicamente en mi computadora (Linux x86_64).

global start
start:
jmp 0

Compilar y ejecutar como:

$ nasm -f elf64 ill.asm && ld ill.o && ./a.out
ld: warning: cannot find entry symbol _start; defaulting to 0000000000400080
Illegal instruction

Conjunto hexagonal TI-83, 2 bytes

PROGRAM:I
:AsmPrgmED77

Corre como Asm(prgmI). Ejecuta el código de operación ilegal 0xed77. Cuento cada par de dígitos hexadecimales como un byte.

Python, 32 bytes

from os import*;kill(getpid(),4)

x86 .COM, 1 byte

c

ARPLcausas #UDen modo de 16 bits

Shell de Linux, 9 bytes

kill -4 0

Envía SIGILLal proceso con PID 0. No sé qué proceso tiene PID 0, pero siempre existe.

Pruébalo en línea!

GNU C, 24 19 18 bytes

^{-4 gracias a Dennis
-1 gracias a ceilingcat}

main(){goto*&"'";}

Pruébalo en línea! Esto supone ASCII y x86_64. Intenta ejecutar el código de la máquina 27, que ... es ilegal.

shortC , 10 5 4 bytes

AV"'

Equivalente al código GNU C anterior. Pruébalo en línea!

MachineCode en x86_64, 2 1 bytes

7

Pruébalo en línea!

Simplemente llama a la instrucción x86_64 0x07(ceilingcat sugiere 0x07 en lugar de 0x27)