Comportement indéfini a tué mon chat

Il est bien connu qu'un comportement non défini peut tuer votre chat ^{[citation nécessaire]} .
Mais peut-il?

Ta tâche

1. Ecrivez un programme qui appelle un comportement indéfini.
2. Décrivez un scénario qui commence avec l'exécution du programme ci-dessus et qui aurait pour conséquence qu'un Felis catus mette fin à sa vie alors qu'il appartenait à vous, à la suite de l'UB susmentionné.
3. Estimez la probabilité pour chaque étape du scénario.
4. Calculez la probabilité totale qu'une seule exécution du programme tue votre chat.

Règles

1. C'est un concours de popularité , soyez donc créatif si vous le pouvez.
2. Il s’agit d’un défi lié à la programmation; la chaîne d’événements devrait donc se situer principalement dans l’ordinateur, et non dans le monde réel (bien sûr, si vous devez atteindre le monde réel si c’est là où se trouve votre chat).
3. Si vous choisissez une langue qui n'a pas de comportement indéfini, utilisez quelque chose de similaire.
4. Aucun animal ne peut être blessé dans la production de votre réponse.

Notation

Nombre de votes plus la probabilité totale du scénario (qui ne peut pas dépasser 1).

Exemple en C:

main(){printf();}

Scénario:

1. printfappelé avec des ordures de la pile - comportement indéfini. Probabilité: 100%.
2. Le premier paramètre se trouve être la chaîne Your cat is ugly!. Probabilité: (1/256) ¹⁷ = (1.148 * 10 ^-37 )%.
3. Voyant le message, vous prenez votre arme et tirez votre chat. Probabilité: 3%.
4. Le chat meurt. Probabilité: 93%.

Probabilité totale: (3.202 * 10 ^-39 )%.

C

La plupart des réponses à cette question ont mal interprété la question en ce sens qu’elle tue le catprocessus sur un système UNIX. Voici un programme qui peut provoquer la disparition d'une forme de vie biologique de l'espèce Felis Cattus, comme spécifié par la question.

Cet exemple fonctionne sous Windows, mais il peut facilement être porté sur la plupart des systèmes d'exploitation UNIX en le remplaçant iexplore -kpar la commande permettant de lancer un navigateur Web installé.

#include <stdlib.h>
#include <stdio.h>    

int main() {
    char i; // uninitialised
    printf("Redirecting you to a website which will inform you how to properly feed your cat.");
    if (i != 42) {
         system("iexplore -k https://pets.stackexchange.com/questions/tagged/cats+diet");
    } else {
         system("iexplore -k https://cooking.stackexchange.com/questions/tagged/chocolate");
    }
    return 0;
}

Ce programme prétend conseiller l'utilisateur sur le régime alimentaire du chat.

Il démarrera Internet Explorer et dirigera l'utilisateur vers pets stackexchange en énumérant de nombreuses questions utiles sur la façon de nourrir les chats. Cependant, il y a peu de chances (1/256) que cela envoie l'utilisateur à la cuisson en échange de la pile, énumérant plutôt des astuces pour préparer des plats contenant du chocolat, qui est hautement toxique pour les chats . Pour aggraver les choses, il lancera Internet Explorer en mode kiosque (plein écran), ce qui masque la barre d’adresses et est difficile à échapper pour un utilisateur non averti en matière de technologie.

Cette ruse intelligente amènera l'utilisateur à nourrir son chat avec du chocolat, en pensant qu'il s'agit d'un régime alimentaire approprié, le forçant ainsi à le tuer par inadvertance.

Frapper

Selon cela , INT_MIN % -1mai ou ne pas être indéfini (quoi ???) , et pourrait donc causer des problèmes pour tout langage implémenté dans c / c ++.

#!/bin/bash

cat <<< $((2**63%-1))

Le catsera tué tôt si le bashprocessus parent se bloque, ce qui peut arriver ou non.

Sur ma VM, j'obtiens cette sortie:

$ ./schroedinger.sh
./schroedinger.sh: line 3:  7805 Floating point exception(core dumped) cat <<< $((2**63/-1))
$ 

(Je ne comprends pas vraiment la notation pour cette question, mais ici va quand même)

Calculer $((2**63%-1)). Le crash se produit toujours sur la version 4.2.25, mais semble ne tenir que sur certaines versions 3.x. Plus d'incertitude. Je pourrais vous dire la probabilité exacte, mais en raison du principe d’incertitude de Heisenburg, je tomberais alors dans un trou noir. Ou quelque chose. Je pense donc que nous pouvons sans risque affirmer que leur probabilité est d'environ 42%.

C (point de séquence)

deadcat.c:

#include <stdio.h>
int main()
{
    int i=3;
    int k=0;
    k=i+(++i);
    if (k==7)
        printf("The cat is fine. k=i+(++i) =%d\n",k);
    else
        printf("Urgent Notice: Your cat has rabies. k=i+(++i) =%d\n",k);
}

Exécution (ou pas):

$ clang -w deadcat.c -o deadcat; ./deadcat
The cat is fine. k=i+(++i) =7
$ gcc deadcat.c -o deadcat; ./deadcat
Urgent Notice: Your cat has rabies. k=i+(++i) =8

Scénario et probabilité

En supposant que 5% des utilisateurs de ce programme utilisent Clang pour compiler du code C (90% avec gcc et 5% avec d'autres compilateurs C):

Probabilité d'obtenir "Le chat va bien". = 0,050
 Probabilité de devenir "Avis urgent: votre chat est atteint de la rage". = 0,950

 Probabilité de réagir à "Votre chat a la rage" en le supprimant = .040
 Probabilité d'ignorer l'avis = .900
 Probabilité de prendre le chat chez le vétérinaire pour un traitement = .060

 Probabilité totale de vie du chat: 0,05 + 0,95 * (0,90 + 0,06) = 0,962
 Probabilité totale de décès du chat: 0,95 * 0,04 = 0,038
 Contrôle: Probabilité totale de vie ou de mort du chat: = 1.000

Explication:

k = i + (++ i) accède et change "i" entre les points de la séquence. La probabilité n'est pas déterminable par le programme; cela dépend du choix du compilateur, qui est fait par l'utilisateur. "Indéfini" ne signifie pas nécessairement "aléatoire".

Voir https://stackoverflow.com/questions/4176328/undefined-behavior-and-sequence-points

C

Histoire

Ma femme a hérité d'un chat de la famille. ^† Malheureusement, je suis très allergique aux animaux. Le chat avait bien dépassé son apogée et aurait dû être euthanasié avant même que nous l'ayons eu, mais elle ne pouvait se résoudre à s'en débarrasser à cause de sa valeur sentimentale. J'éclos un plan pour mettre fin à ma ses souffrances.

Nous allions en vacances prolongées, mais elle ne voulait pas monter à bord du chat chez le vétérinaire. Elle craignait de contracter une maladie ou d'être maltraité. J'ai créé un chargeur automatique de chat afin que nous puissions le laisser à la maison. J'ai écrit le micrologiciel du microcontrôleur en C. Le fichier contenant mainressemblait au code ci-dessous.

Cependant, ma femme est également programmeuse et connaissait mes sentiments pour le chat. Elle a donc insisté sur une révision du code avant d'accepter de le laisser à la maison sans surveillance. Elle avait plusieurs préoccupations, notamment:

• main n'a pas de signature conforme aux normes (pour une implémentation hébergée)
• main ne retourne pas de valeur
• tempTmest utilisé non initialisé car a mallocété appelé au lieu decalloc
• la valeur de retour de mallocne doit pas être exprimée
• le temps du microcontrôleur peut être inexact ou survoler (problème semblable à celui du problème Y2K ou Unix 2038)
• la elapsedTimevariable peut ne pas avoir une plage suffisante

Cela a pris beaucoup de conviction, mais elle a finalement convenu que ces thèses ne posaient pas de problèmes pour diverses raisons (cela ne faisait pas de mal que nous soyons déjà en retard pour notre vol). Comme il n'y avait pas de temps pour les tests en direct, elle a approuvé le code et nous sommes partis en vacances. Lorsque nous sommes revenus quelques semaines plus tard, la souffrance de mon chat était terminée (bien qu'en conséquence, j'en ai maintenant beaucoup plus).

^{† Scénario entièrement fictif, pas de souci.}

Code

#include <time.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

//#include "feedcat.h"
// contains extern void FeedCat(struct tm *);
// implemented in feedcat.c
// stub included here for demonstration only
#include <stdio.h>
// passed by pointer to avoid putting large structure on stack (which is very limited)
void FeedCat(struct tm *amPm)
{
    if(amPm->tm_hour >= 12)
        printf("Feeding cat dinner portion\n");
    else
        printf("Feeding cat breakfast portion\n");
}

// fallback value calculated based on MCU clock rate and average CPI
const uintmax_t FALLBACK_COUNTER_LIMIT = UINTMAX_MAX;

int main (void (*irqVector)(void))
{
    // small stack variables
    // seconds since last feed
    int elapsedTime = 0;
    // fallback fail-safe counter
    uintmax_t loopIterationsSinceFeed = 0;
    // last time cat was fed
    time_t lastFeedingTime;
    // current time
    time_t nowTime;

    // large struct on the heap
    // stores converted calendar time to help determine how much food to
    // dispense (morning vs. evening)
    struct tm * tempTm = (struct tm *)malloc(sizeof(struct tm));

    // assume the cat hasn't been fed for a long time (in case, for instance,
    // the feeder lost power), so make sure it's fed the first time through
    lastFeedingTime = (size_t)(-1);

    while(1)
    {
        // increment fallback counter to protect in case of time loss
        // or other anomaly
        loopIterationsSinceFeed++;

        // get current time, write into to nowTime 
        time(&nowTime);

        // calculate time since last feeding
        elapsedTime = (int)difftime(nowTime, lastFeedingTime);

        // get calendar time, write into tempTm since localtime uses an
        // internal static variable
        memcpy(&tempTm, localtime(&nowTime), sizeof(struct tm));

        // feed the cat if 12 hours have elapsed or if our fallback
        // counter reaches the limit
        if(  elapsedTime >= 12*60*60 || 
             loopIterationsSinceFeed >= FALLBACK_COUNTER_LIMIT)
        {
            // dispense food
            FeedCat(tempTm);

            // update last feeding time
            time(&lastFeedingTime);

            // reset fallback counter
            loopIterationsSinceFeed = 0;
        }
    }
}

Comportement non défini:

Pour ceux qui ne veulent pas chercher l’UB eux-mêmes:

Il y a définitivement un comportement spécifique à la localité, non spécifié et défini par l'implémentation dans ce code, mais cela devrait fonctionner correctement. Le problème se situe dans les lignes de code suivantes:

struct tm * tempTm //... //... memcpy(&tempTm, localtime(&nowTime), sizeof(struct tm));
memcpyécrase le tempTMpointeur au lieu de l’objet qu’il pointe, cassant la pile. Cela écrase, en plus d’autres choses, elapsedTimeet loopIterationsSinceFeed. Voici un exemple d'exécution où j'ai imprimé les valeurs:

pre-smash : elapsedTime=1394210441 loopIterationsSinceFeed=1 post-smash : elapsedTime=65 loopIterationsSinceFeed=0

Probabilité de tuer le chat:

• Compte tenu de l'environnement d'exécution contraint et de la chaîne de construction, le comportement indéfini se produit toujours.
• De même, le comportement indéfini empêche toujours le chargeur de chat de fonctionner comme prévu (ou plutôt de lui permettre de "fonctionner" comme prévu).
• Si le chargeur ne fonctionne pas, il est extrêmement probable que le chat meure. Ce n'est pas un chat qui peut se débrouiller tout seul et j'ai omis de demander au voisin de le surveiller.

J’estime que le chat meurt avec une probabilité de 0,995 .

frapper

Version classique

cat & # This is your cat.
pkill -$RANDOM cat

A l'avantage de tuer tous les chats dans sa gamme.

Notez que le processus est immédiatement arrêté . Le seul moyen de le terminer par un seul appel de pkill est d’envoyer SIGKILL (9).

Donc:

p(SUCCESS) = p(RANDOM == 9) = 0.0275 %

Version quantique

schroedinger=/dev/null             # We'll need this guy.
heisenberg=/dev/urandom            # Also needed, for uncertainty principle.
cat $heisenberg > $schroedinger &  # Steal cat from Heisenberg and give it to Schrödinger.
felix=$!                           # Name cat for future references.
exec 2> $schroedinger              # Send all results to Schrödinger.
kill -SIGSTOP $felix               # Catch Felix and put him into a box.
if (($RANDOM & 1))                 # Flip a coin.
then kill $felix                   # Heads: Kill! Kill! Kill!
fi                                 # By now, Felix can be thought of as both alive and dead.
read -sn 1                         # Wait for somebody to open the box.
kill -SIGCONT $felix               # Let him open it.
if ps p $felix > $schroedinger     # Let Schrödinger check on Felix.
then echo The cat is alive.        # Hooray for tails!
else echo The cat is dead.         # At least, now we know.
fi                                 # This concludes the experiment.
kill -SIGKILL $felix               # Felix is no longer required.

Probabilité de tuer le chat pendant l'expérience: 50%

C

Notez que cela ne fonctionne que sur linux.

main() {
  FILE *f = fopen("skynet", "w");
  srand(time(0));
  while(rand() != rand())
    fputc(rand()%256, f);
  fclose(f);
  system("chmod +x skynet");
  system("./skynet");
}

1. Écrire des données aléatoires dans un fichier et l'invoquer (100%)
2. Des données aléatoires se trouvent être le code source de skynet (1x10 ^ -999999999999999999999999999999999999999999999999999999999, aprox.)
3. Le chat meurt le jour du jugement final (99,999%)

Probabilité totale: 1x10 ^ -999999999999999999999999999999999999999999999999999999999, aprox.

C ++

Votre chat est à la fois mort et vivant jusqu'à ce que vous soyez curieux. Ensuite, vous réalisez qu'il existe une probabilité de 0.5 que votre chat soit mort.

#ifdef WIN32
#pragma warning(disable: 4700)
#endif
#include <random>
#include <iostream>
#include <vector>
#include <climits>
#include <memory>
class Cat
{
public:
    enum class State {DEAD, ALIVE};
    Cat()
    {
        int x; // Uninitialized Variable on Stack
        if (x % 2 == 0) // Is the Uninitialized Variable even? 50-50
        {
            m_dead = State::DEAD;

        }
        else
        {
            m_dead = State::ALIVE;
        }
    };
    operator State() //Check if your Cat is Dead / Alive
    {
        if (m_dead == State::DEAD)
        {
            delete this; //Boom Cat is dead
            std::cout<<"Your Curiosity killed your Cat"<<std::endl;
            return false;
        }
        return m_dead;
    }
private:
    State m_dead;
};

class Schrödinger
{
public:
    Schrödinger(size_t size):m_size(size)
    {
        for(size_t i = 0; i < size; i++)
        {
            cats.push_back(new Cat());
        }
    }
    ~Schrödinger()
    {
    }
    void Curiosity()
    {
        std::default_random_engine generator;
        std::uniform_int_distribution<int> distribution(0,m_size);
        if(*cats[distribution(generator)] == Cat::State::ALIVE)
        {
            std::cout<<"You Cat is alive and still kicking" <<std::endl;
        }
    }
private:
    std::vector<Cat *> cats;
    size_t m_size;
};
int main()
{
    int size;    
    std::cout<<"How Big is Your Example Space ?";
    std::cin>>size;
    Schrödinger your(size);
    your.Curiosity();
    return 0;

}

C

Fonctionne sous Linux.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void f(char x) {
    if(sleep(1)==x) system("killall cat");
}
int main() {
    char x; // uninitialised
    system("cat /dev/urandom &");
    f(x);
    return 0;
}

Probabilité de tuer le chat: 1/256 (Le sleep(1)retourne 0, donc il sera tué si xvaut zéro.)

En prime, il tue tous les chats actuellement en cours d'exécution sur votre système.

Si vous détestez autant les chats, je vous présente:

Le chat mille-pattes (Bash)

echo "Hello World"|cat|cat|cat

Étant donné que, dans The Human Centipede (Première séquence) , les trois chiens du chien centipede sont morts et que deux personnes sur trois du centipède humain sont morts, j'estime que la probabilité de tuer un chat est de 5/6.

JavaScript

~"cat".localeCompare("dead")
  ? "Cat is dead"
  : "Cat is fine"

Exécution:

• Chrome: Résultats en"Cat is fine"
• Firefox: Résultats en"Cat is dead"

Explication:

15.5.4.9 String.prototype.localeCompare (que)

Les deux chaînes sont comparées d'une manière définie par l' implémentation

Citant Glenn Randers-Pehrson, le programme ne permet pas de déterminer la probabilité; cela dépend du choix du navigateur, qui est fait par l'utilisateur.

int foo() {}

void main() {
    int x = foo();
}

La lecture d'une valeur de fonction supposée renvoyer une valeur entraîne un comportement indéfini. Maintenant, il est évident, ^{[citation nécessaire]} que "chaque fois que vous atteignez un comportement indéfini, Dieu tue un chaton." En utilisant ceci nous concluons:

• Probabilité d'atteindre un comportement non défini - 100%
• Probabilité c'est ton chat que Dieu a tué - 1/200 000 000 voir pourquoi
• Donc la probabilité est 0.0000005%

Peut être facilement rallongé par boucle pour exterminer tous les chats du monde.

Java (ramassage des ordures)

Bien que le code puisse appeler System.gc (), cela ne garantit pas que le récupérateur de place collectera tous les objets inutilisés. Ainsi, pour le code suivant, il est imprévisible que le chat soit tué ou non.

public class KillTheCat {
    public static void main(String[] args) throws InterruptedException {
        KillTheCat cat = new KillTheCat();
        cat = null;
        System.gc();
        System.out.println("Cat is still alive.");
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("Cat has been killed.");
        System.exit(0);
    }
}

La probabilité ne peut être calculée.

Notez qu'il y a toujours une chance que le chat soit "relancé" s'il y a un changement de contexte dans le thread GC après sysout et avant System.exit (0), mais j'ai préféré ne pas le couvrir pour garder le concept plus simple.

Quelqu'un a-t-il déjà pensé à tuer (a) cat?

[ $[ $RANDOM % 6 ] == 0 ] && rm /bin/cat || echo Meow

Probabilité de catmourir

Pour la probabilité ... je suppose que nous devons distinguer certains cas:

1. Utilisateur Windows : ne sera probablement pas capable de l'exécuter. Le risque de mourir cats est très faible, on peut supposer qu'il est nul. S'il a installé Cygwin, il comptera comme utilisateur Unix.
2. Utilisateur Unix, fonctionnant sans privilèges root : Tuer le catva échouer.
3. Utilisateur Unix, exécutant avec les privilèges root : chaque appel ne tuera que cats avec une chance sur 1/6, mais il le répètera très probablement jusqu'à ce que quelque chose d'inattendu se produise. Sans perte de généralité, je suppose que catva certainement mourir.

La probabilité globale dépend de la façon dont les utilisateurs sont mélangés et est difficile à déterminer. Mais on peut sûrement dire: Windows est un endroit sûr pour les chatons.

Test d'obéissance aux règles

Aucun animal ne peut être blessé dans la production de votre réponse.

Cela n'a pas tué d'animaux, la réponse est approuvée par l' American Humane Association .

$ file `which cat`
/bin/cat: Mach-O 64-bit executable x86_64

prouve clairement qu’il catn’ya pas d’animal (tant fileque l’on ignore tout type d’héritage de type de fichier caché).

C

Si le nom de votre chat est trop long, il meurt. getsprovoque la mort des chats, ainsi que d'autres problèmes.

#include <stdio.h>
#include <stdbool.h>

/* Stores instances of cats. */
struct cat {
    /* 6 bytes are more than enough. */
    char name[6];

    /* Stores whether your cat is dead. */
    bool dead;
};

int main(void) {
    /* This is your cat. */
    struct cat your_cat;
    /* It lives. */
    your_cat.dead = false;
    /* Determine its name. */
    printf("Your cat name: ");
    gets(your_cat.name);

    /* Output the cat state. */
    const char *state = your_cat.dead ? "dead" : "alive";
    printf("Your cat, %s, is %s.\n", your_cat.name, state);

    return your_cat.dead;
}

Haskell

import Acme.Missiles
import System.IO.Unsafe
main = print (unsafePerformIO launchMissiles, undefined)

Ici, nous appliquons unsafePerformIOà une action qui a des effets secondaires observables . C’est toujours un comportement indéfini, du moins l’ordre des effets. Alors soit le programme tente-t-il d’abord d’essayer d’évaluer undefined(celui-ci, ironiquement, n’est pas un comportement indéfini: il ne doit jamais donner une valeur qui permettrait au programme de continuer avec autre chose), ou il entraînera en fait le sérieux Effets secondaires. Dans ce cas, la chance de survie n’est que de 0,001% .

Probabilité de tuer le chat donc: 49.9995%.

Thue

Puisque la question autorise un langage qui n'a pas de comportement indéfini tant que l'effet est similaire, j'ai choisi Thue pour son non-déterminisme dans le choix de la règle à exécuter lorsqu'il y a plus d'une règle pouvant être appliquée à la règle actuelle. Etat.

Le programme sera introduit dans le contrôleur pour un four à micro-ondes dans lequel se trouve mon chat. La porte du four à micro-ondes est fermée et renforcée par une fermeture à glissière. La sortie du programme déterminera si le four à micro-ondes commence à micro-ondes ou non au chat.

• Si le résultat est 0, nous commencerons l'expérience sur l'effet d'une longue exposition de micro-ondes sur un mammifère vivant (qui est actuellement insuffisamment étudié).
• Si le résultat est 1, nous nous contenterons du fait que le chat vient de perdre l'une de ses 9 vies et de le laisser sortir.

i::=~0
i::=~1
::=
i

La probabilité de tuer le chat dépend de la mise en œuvre de l'interprète, mais supposons qu'elle soit de 50%. La probabilité que le chat meure est alors de 0,5 .

Java

Selon la spécification java.util.Date aura un comportement indéfini. Alors tentez votre chance:

import java.util.Date;

public class App3
{
    public static void main (String args[])
    {
        String aliveOrDead;
        Date d = new Date(-1000,-1000,-1000);
        aliveOrDead = (d.getTime()<0)? "dead" : "alive";
        System.out.println("The cat is:" +aliveOrDead );
    }
}