Défi:

Dans le langage de programmation de votre choix, éteignez la machine sur laquelle votre code a été exécuté.

Règles

• Pas d'arrêt par épuisement des ressources (par exemple: bombe à la fourche pour forcer l'arrêt)
• Vous êtes autorisé à écrire du code qui ne fonctionne que dans un environnement / système d'exploitation spécifique, si vous le souhaitez.
• Les échappatoires standard sont interdites

C'est du code-golf , donc le plus petit nombre d'octets gagne!

Assembly (x86 / x64, Linux, en tant que) , 22 21 19 octets

mov  $0x58,       %al  # 2 bytes: b0 58
mov  $0xfee1dead, %ebx # 5 bytes: bb ad de e1 fe
mov  $0x28121969, %ecx # 5 bytes: b9 69 19 12 28
mov  $0x4321fedc, %edx # 5 bytes: ba dc fe 21 43
int  $0x80             # 2 bytes: cd 80

Doit être exécuté en tant que root.

Cela équivaut à appuyer sur le bouton d'alimentation et n'est pas un moyen sûr d'éteindre votre PC. Assurez-vous de fermer toutes les applications ouvertes et d’exécuter syncpour vider tous les tampons du système de fichiers avant d’exécuter ce programme, afin de minimiser au minimum le risque de corruption du fichier.

Essai

$ as -o poweroff.o poweroff.s
$ ld -o poweroff   poweroff.o
ld: warning: cannot find entry symbol _start; defaulting to 0000000000400078
$ sudo sh -c 'sync && ./poweroff'
root's password:

Suivi par les ténèbres.

Comment ça fonctionne

int $0x80invoque une interruption logicielle. Il fonctionne à la fois sur x86 et x64, mais est obsolète depuis plus de dix ans et ne devrait pas être utilisé dans le code de production. Le code x64 devrait utiliser à la syscallplace. x86 devrait l’utiliser sysenter, mais c’est trop lourd pour le code golf.

L'action résultant de l'appel système dépend des registres EAX-EDX, ESI et EDI. La référence Linux Syscall montre tous les appels système disponibles via int $0x80.

Lorsque EAX contient 0x58 (88) , un redémarrage est appelé, ce qui peut également être utilisé pour éteindre, mettre en veille ou pour mettre en veille prolongée l'ordinateur, ainsi que pour changer de noyau et désactiver ou activer le combo Ctrl-Alt-Suppr .

Au début du programme - et en compilant avec asou gcc -nostdlib, nous pouvons nous assurer que nous en sommes réellement au début du programme - la plupart des registres sont mis à 0 . Cela inclut EAX. Nous pouvons donc utiliser mov $0x58, %alpour définir les 8 bits inférieurs de EAX sur 0x58 , fixant ainsi EAX lui-même sur 0x58 . Cela économise deux octets sur la mise à zéro manuelle du registre avec xor %eax, %eaxet un de plus sur le directement mov $0x58, %eaxqui code 0x58 sur 32 bits.

Les deux premiers arguments pour redémarrer sont des nombres magiques, supposés empêcher les redémarrages accidentels, et sont lus à partir des registres EBX et ECX. À moins que ces nombres ne soient égaux à certaines constantes, le redémarrage refuse d'effectuer toute action.

• Le premier nombre magique doit être égal à 0xfee1dead ( sensation de mort ), faisant probablement référence à la mise hors tension / à la mort du PC.

• Le deuxième nombre magique peut être égal à quatre constantes différentes, bien que les trois dernières ne fonctionnent pas dans les anciennes versions de Linux. Tous semblent se référer à la mise sous tension / à la naissance du PC.

  • 0x28121969 représente l'anniversaire de Linus Torvalds (28 décembre 1969).

  • 0x05121996 représente l'anniversaire de Patricia Torvalds (5 décembre 1996).

  • 0x16041998 représente l'anniversaire de Daniela Torvalds (16 avril 1998).

  • 0x20112000 représente l'anniversaire de Celeste Torvalds (20 novembre 2000).

  Patricia, Daniela et Celeste Torvalds sont les trois filles de Linus Torvalds.

• Le registre EDX sélectionne le type de "redémarrage" souhaité. 0x4321fedc est RB_POWER_OFF , éteint le PC et l'éteint.

• Enfin, la valeur du registre ESI est ignorée pour RB_POWER_OFF ; la valeur du registre EDI est entièrement ignorée lors du redémarrage .

Version alternative, x 64 uniquement, 19 octets

Sur x64, nous pouvons utiliser un appel système approprié pour le même nombre d'octets.

mov     $0xa9,       %al  # 2 bytes: b0 a9
mov     $0xfee1dead, %edi # 5 bytes: bf ad de e1 fe
mov     $0x28121969, %esi # 5 bytes: be 69 19 12 28
mov     $0x4321fedc, %edx # 5 bytes: ba dc fe 21 43
syscall                   # 2 bytes: 0f 05

Les seules différences résident dans l'instruction ( syscallvs int $0x80), la valeur de __NR_REBOOT ( 0xa9 vs 0x58 ) et les registres impliqués.

PowerShell, 13 octets

Stop-Computer

Assez explicite? Ne fonctionne pas sur le noyau PowerShell, il ne fonctionnera donc pas sur PowerShell pour Linux / MacOS (déjà essayé sur TIO :-D).

Bonus Garbage Submission, 12 octets

gcm s*r|iex

Lors de mes tests, cela fonctionne sous Windows 2003 avec PowerShell 2.0. Cela ne fonctionnera pas sur la plupart des versions les plus récentes et pourrait ne pas fonctionner en fonction des modules installés. C'est assez terrible!

Cette recherche dans la liste des commandes pour tout avec le modèle s*r, puis les exécute toutes! Pour être clair, c'est dangereux, ne faites pas ça!

Bien sûr, l’astuce consiste à obtenir une liste de commandes n’ayant aucun paramètre obligatoire, sinon PowerShell demandera une valeur.

Sur ma machine 2003, les 3 commandes retournées sont:

CommandType     Name                                                Definition                                         
-----------     ----                                                ----------                                         
Application     scrnsave.scr                                        C:\WINDOWS\system32\scrnsave.scr                   
Application     ssmarque.scr                                        C:\WINDOWS\system32\ssmarque.scr                   
Cmdlet          Stop-Computer                                       Stop-Computer [[-ComputerName] <String[]>] [[-Cr...

Oui, il lance l’écran de veille, mais non, il n’attend pas qu’il soit terminé avant de se lancer Stop-Computer.

Cette approche peut fonctionner sur les machines les plus récentes, encore une fois en fonction des modules installés, mais le mieux que je pouvais faire sur Windows 2012 et 2016 était de 14 octets :

gcm sto*er|iex

(et oui, bien sûr, la soumission de winbatch fonctionnera dans PowerShell et sera plus courte, mais… ce n'est pas amusant)

Lot, 10 octets

Sur les fenêtres, cela suffirait

shutdown/s

Cela mettra en place un arrêt dans une minute.

Alternativement, comme le souligne @flashbang:

shutdown/p

Cela éteint l'ordinateur immédiatement.

Code machine x86, Lenovo Z510, COM DOS ou chargeur de démarrage, 7 octets

BITS 16

mov ax, (1 << 13) | (7 << 10)
mov dx, 1804h
out dx, ax

Assemblé dans B8 00 3C BA 04 18 EF

J'exploite " Vous êtes autorisé à écrire du code ne fonctionnant que dans un environnement / système d'exploitation spécifique, si vous le souhaitez " au niveau ultime: cela ne fonctionnera que sur Lenovo Z510 ¹ .

Cela écrit SLP_TYPa << 10 | SLP_ENdans le PM1a_CNTregistre ACPI, j’ai vidé ces valeurs des tables ACPI il ya des mois pour obtenir une réponse à propos de l’arrêt (où je donne un peu de contexte au code ci-dessus).

Cela peut être exécuté sous DOS en tant que COM (écrivez simplement les données binaires dans un fichier et changez l'extension en "com") ou en tant que chargeur de démarrage.
Pour ces derniers, écrivez la signature standard et méfiez - vous des problèmes liés aux microprogrammes modernes .

¹ Ce n'est pas tout à fait vrai. Tous les systèmes dotés de la même configuration ACPI seront également arrêtés.

Shell GRUB , 4 octets

Golfé

halt

Commande: stop --no-apm

La commande arrête l'ordinateur. Si l'option --no-apm est spécifiée, aucun appel du BIOS APM n'est effectué. Sinon, l'ordinateur est arrêté à l'aide d'APM.

Prime

Voici une preuve que la coquille Grub est en effet Tur n ing-complet (voir les commentaires):

65C02 code machine, 1 octet

Instruction STP (0xDB):

Le STP arrête l’entrée d’horloge du 65C02, éteignant effectivement le 65C02 jusqu’à ce qu’une réinitialisation matérielle se produise (c’est-à-dire que la broche RES devient basse). Cela met le 65C02 dans un état d'alimentation réduite. Ceci est utile pour les applications (circuits) qui nécessitent une faible consommation d'énergie, mais STP est rarement vu autrement.

(Source: http://www.6502.org/tutorials/65c02opcodes.html )

xxd dump:

00000000: db                                       .

Matlab, 21 octets

system('shutdown -s')

Je n'ai pas essayé cela (fermer tous les programmes pour faire un redémarrage au milieu de la journée n'est pas vraiment tentant), mais ça devrait marcher. . Cela marche...

J'ajouterai une brève explication plus tard, mon ordinateur portable est actuellement éteint.

MATLAB, 11 octets

!shutdown/p

Un peu similaire à l'approche de Stewie Griffin . Cependant, MATLAB a des moyens beaucoup plus courts d’appeler des commandes système; dans ce cas, !est utilisé. Windows n'a pas besoin .exede noms de commande, donc il est également laissé de côté. L' /option est toujours prise en charge (j'utilise Windows 10) et élimine le besoin d'espace. Les alternatives sont:

system shutdown/p % 17 bytes; uses so-called 'command' syntax.
dos shutdown/p    % 14 bytes; the 'dos' command can be used just as well.

SmileBASIC, 14 11 6 octets

OPTION

Déclenche un crash provoquant le redémarrage de la 3DS. J'espère que ça compte.

Fonctionne dans la version la plus récente.

Bash, 7 à 6 octets

init 0

En supposant que le programme est exécuté en tant que root.

Java, 101 98 62 42 octets

()->{Runtime.getRuntime().exec("init 0");}

Comme @Snowman l'a fait remarquer, la question ne précisait pas si un programme complet était nécessaire, cela devrait donc encore être acceptable.

Python 2, 29 octets

import os;os.system('init 0')

Fonctionne sur les systèmes Linux et nécessite des privilèges root.

Pour Windows, 33 octets

import os;os.system('shutdown/p')

C'est peut-être le code le moins intéressant ou le plus utile que j'ai jamais écrit.

Commodore 64, 11 octets

0 sys64738

Ceci est à partir de l'invite BASIC. Ou...

Commodore 64, 6502 assemblage, 3 octets (assemblé), 16 octets (source)

*=8000
JMP $FCE2

TI-Nspire CX CAS, 3 octets

" "+" "

sommant deux chaînes vides.

Sur une version plus ancienne de la calculatrice, le périphérique se bloquerait et le redémarrer (il est impossible d'arrêter un périphérique sans redémarrer en dehors de combinaisons de boutons physiques).

Vidéo de Adriweb

C ++, 51 40 octets

-11 octets grâce à Ingve !

#include<os>
int main(){OS::shutdown();}

Ne fonctionne que dans IncludeOS (v0.10.0-rc.1)

Tester:

$ pwd
/home/simon/IncludeOS/examples/demo_service

$ cat service.cpp
#include<os>
int main(){OS::shutdown();}

$ mkdir build && cd build && cmake .. && make && cd ..
[...]

$ boot build/IncludeOS_example
[...]
================================================================================
================================================================================
 IncludeOS v0.10.0-rc.1-9-g151a2b9
 +--> Running [ IncludeOS minimal example ]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

$

AppleScript, 30 octets

tell app "Finder" to shut down

Fait exactement ce qu'il dit: dit au Finder d'éteindre l'ordinateur.

AutoHotkey, 11 à 10 octets

Enregistré un octet grâce à Gurupad Mamadapur

Shutdown,9

AHK Prend en charge une commande d'arrêt par défaut. Le 9est un drapeau composé de Shutdown=1+ PowerDown=8.

Code machine (x86, chargeur de démarrage) 18 octets

b8 01 53 33 db cd 15 b8 07 53 bb 01 00 b9 03 00 cd 15

Démontage:

mov ax, 0x5301 ; connect to real-mode APM services
xor bx, bx     ; device id 0 - APM BIOS
int 0x15       ; call APM
mov ax, 0x5307 ; set power state
mov bx, 0x0001 ; on all devices
mov cx, 0x0003 ; to Off
int 0x15       ; call APM

Vous pouvez le tester dans le débogueur de Bochs à l'aide des commandes suivantes (après le démarrage de la simulation et la configuration d'un lecteur de disque):

pb 0x7c00
c
setpmem 0x7c00 4 0x335301b8
setpmem 0x7c04 4 0xb815cddb
setpmem 0x7c08 4 0x01bb5307
setpmem 0x7c0c 4 0x0003b900
setpmem 0x7c10 2 0x15cd
c

Ce même code machine fonctionnera également comme un exécutable DOS ( *.COM).

C #, 79 54 53 octets

Cela fonctionne sous Windows.

79 octets :

class _{static void Main(){System.Diagnostics.Process.Start("shutdown","/s");}}

53 octets , grâce à TheLethalCoder:

_=>System.Diagnostics.Process.Start("shutdown","/s");

AutoIt, 11 octets

Shutdown(1)

La fonction d'arrêt obtient la combinaison des codes suivants

0 = Logoff
1 = Shutdown
2 = Reboot
4 = Force
8 = Power down
16= Force if hung
32= Standby
64= Hibernate

Pour éteindre et éteindre, par exemple, le code serait 9 (shutdown + power down = 1 + 8 = 9).

Windows - NativeAPI, 212 octets

Ok ce n'est pas vraiment la version la plus courte. Mais peut-être intéressant pour certains. Cela ne fonctionnera pas sur le sous-système Win32. Cependant, il sera exécuté lorsqu’il sera exécuté dans le contexte de l’API native (comme le fait autochtonesk.exe).

Code

#define WIN32_NO_STATUS
#include <windef.h>
#include <winnt.h>
#include <ntndk.h>
NTSTATUS main() {
RtlAdjustPrivilege(SE_SHUTDOWN_PRIVILEGE,TRUE,FALSE,NULL);
return ZwShutdownSystem(ShutdownPowerOff);
}

Construire

Pour le construire, utilisez l’ build.exeoutil WinDDK (avec un sourcefichier approprié pourNMAKE )

Ou utilisez ces commandes pour compiler et lier:

cl /Gd /D_X86_ /showIncludes /I%DDK_INC_PATH% /I%CRT_INC_PATH% /c main.c
link /verbose /nodefaultlib /subsystem:native /machine:X86 /entry:NtProcessStartup@4 C:\WinDDK\7600.16385.1\lib\win7\i386\nt.lib C:\WinDDK\7600.16385.1\lib\win7\i386\ntdllp.lib C:\WinDDK\7600.16385.1\lib\win7\i386\BufferOverflow.lib .\main.obj 

Remarque: Ceci créera un exécutable natif x86. Changez les bits appropriés si vous voulez construire ceci pour une architecture différente.

Tester

Pour tester un exécutable natif, vous devez l'exécuter avant que le sous-système win32 ne soit chargé. Une méthode courante consiste à ajouter l'exécutable dans la clé de registre suivante:

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\BootExecute

Attention

Dans ce cas, vous devez toutefois disposer d'une option permettant de modifier la ruche de registre du système d'exploitation cible à partir d'un autre système d'exploitation. Puisque vous ne pourrez plus démarrer le système d'exploitation cible!

Je l'ai fait sur une machine virtuelle où je pourrais facilement revenir à un instantané précédent!

Groovy, 23 octets

'shutdown /p'.execute()

La plupart des shells Linux, 15 octets

# echo o>/p*/*ger

On pourrait faire 11 octets de long, si vous vous trouvez dans le /procrépertoire:

# echo o>*ger

Ceci est très simple (sans effets secondaires, comme le démontage de systèmes de fichiers ou les processus de destruction) et plutôt brutal.

Shell Android, 9 octets

reboot -p

AppleScript, 44 octets

tell application "Finder"
shut down
end tell

Je ne sais pas comment fonctionne la syntaxe AppleScript ou quoi que ce soit, alors si quelqu'un sait comment raccourcir la procédure, veuillez l'indiquer.

De plus, je le fais sur mon téléphone à l'école ("piratage"), donc je ne peux pas le tester.

Avec 14 octets en moins (merci à kindall), vous pouvez dire

tell app "Finder" to shut down

J, 14 octets

2!:0'poweroff'

Fonctionne sur les systèmes Linux. 2!:0exécute la chaîne dans /bin/sh.

Clojure, 40 à 39 octets

(.exec(Runtime/getRuntime)"shutdown/s")

-1 octet en changeant le drapeau de -sà /s, ce qui m'a permis de me débarrasser de l'espace.

Fondamentalement, la réponse Java.

C'était amusant de tester. Windows a décidé de mettre à jour le micrologiciel sur ma Surface à la seconde de son arrêt. Bien sûr.

(defn shutdown []
  (.exec (Runtime/getRuntime) "shutdown -s"))

Node.js, 39 octets

Linux

require('child_process').exec('init 0')

AHK, 19 à 15 octets

Run,Shutdown -s

Fonctionne sur les fenêtres uniquement.

C ++, 48 47 (Windows) 46 45 (Linux) octets

Suppression d'un octet grâce à Snowman

#include<cstdlib>
main(){system("shutdown/p");}

Cela devrait arrêter le système pour Windows

#include<cstdlib>
main(){system("poweroff");}

Cela devrait arrêter le système pour Linux