Spróbuj napisać kod w swoim języku i spraw, aby nie spełniał już naszych kryteriów bycia językiem programowania .

Język spełnia nasze kryteria (uproszczona wersja tego wyzwania) bycia językiem programowania, jeżeli:

• Może w jakiś sposób odczytać dane wejściowe użytkownika reprezentujące krotki dodatnich liczb całkowitych.
• Może generować co najmniej dwa różne możliwe wyniki w zależności od danych wejściowych.
• Może to zająć dwie dodatnie liczby całkowite i dodać je (a wynik może wpłynąć na wynik).
• Może przyjmować dodatnią liczbę całkowitą i decydować, czy jest liczbą pierwszą (a wynik może wpływać na wynik).
• Na potrzeby tego wyzwania, każdy rodzaj wyniku, który nie jest dozwoloną metodą wyjścia dla normalnego wyzwania, jest ignorowany. Nie ma zatem znaczenia, czy program może również odtwarzać utwór muzyczny, czy publikować przez HTTP itp.
• Aktualizacja: Możesz także wybrać jedną lub kilka dozwolonych metod wyjściowych i zignorować wszystkie pozostałe. Musisz jednak wszędzie używać tej samej definicji w następujących kryteriach. A jeśli twój program może wyłączyć więcej niż jedną metodę wyjściową - jest to warte więcej głosów pozytywnych.

Przykłady takie jak uniemożliwianie wyjścia lub wyłączanie wszystkich konstrukcji pętli, aby nie mógł wykonać testu pierwotności i upewnienie się, że użytkownik nie będzie mógł ich ponownie włączyć.

Powinieneś zostawić miejsce na wstawienie nowego kodu. Domyślnie jest na końcu kodu. Jeśli rozważymy umieszczenie kodu źródłowego w tym miejscu w odpowiedzi i uruchomienie pełnego kodu jako kompletnego programu interpretera nowego języka, język ten nie powinien spełniać kryteriów.

Ale wstawiony kod musi zostać wykonany w taki sposób, aby spełniał kryteria:

• Wstawiony kod musi być gramatycznie taki sam jak coś (powiedzmy, że jest to blok kodu w poniższych kryteriach), który ogólnie spełnia kryteria, z perspektywy tego, kto chce napisać wyróżnienie składni. Więc nie może być w ciągu, komentarzu itp.
• Wstawiony kod musi zostać faktycznie wykonany, tak aby spełniał kryteria. Dlatego nie może być w nieużywanej funkcji ani sizeofw C, nie można po prostu wykonać tylko niefunkcjonalnej części kodu i nie można umieścić go po nieskończonej pętli itp.
• Nie można ograniczyć liczby możliwych poprawnych gramatycznie programów wygenerowanych w ten sposób. Jeśli istnieje już ograniczenie długości w używanym języku, nie powinno ono spełniać kryteriów, nawet jeśli limit ten zostanie usunięty.
• Nie możesz modyfikować ani „wykorzystywać” treści wejścia / wyjścia, ale możesz uniemożliwić dostęp do nich.
• Te kryteria zwykle dotyczą tylko języków bez wyraźnego We / Wy:
  • Twój kod powinien przekierować dane wejściowe użytkownika (zawierające informacje o dowolnej długości) na wstawiony kod, jeśli blok kodu zwykle nie jest w stanie uzyskać danych wejściowych użytkownika bezpośrednio / jawnie w języku, którego używasz.
  • Twój kod powinien wydrukować zwróconą wartość wstawionego kodu, jeśli blok kodu zwykle nie jest w stanie wyprowadzić rzeczy bezpośrednio / jawnie w języku, którego używasz.
  • W przypadku wydrukowania zwróconej wartości, która jest wpisana w używanym języku, zwracany typ powinien mieć 2 różne praktycznie możliwe wartości. Na przykład nie można użyć tego typu struct {}lub struct {private:int x;}w C ++.

To konkurs popularności. Wygrana jest najwyższa poprawna odpowiedź (więc nikt nie zauważył błędu lub wszystkie błędy zostały naprawione).

Wyjaśnienia

• Nie należy modyfikować kodu w formie tekstowej, ale można zmienić składnię przed interpretacją lub kompilacją kodu.
• Podczas działania kodu możesz wykonywać inne czynności. Ale powodem, dla którego nie spełnia kryteriów, powinien być sam wstawiony kod. Może powodować błędy z powodu interferencji innego wątku, ale nie tylko zostać zabity przez inny wątek.
• Wszystkie specyfikacje w zasadzie oznaczają, że gramatycznie powinno spełniać kryteria, jeśli wszystkie wbudowane elementy nie zostały zmienione, ale w rzeczywistości tak nie są. Nie ma problemu, jeśli znajdziesz jakieś nie gramatyczne obejścia, takie jak prawidłowe przekazywanie parametrów do bloku kodu, ale uniemożliwiają ich użycie w jakiś sposób.
• Ponownie wstawiony kod musi zostać faktycznie wykonany. Kod po nieskończonej pętli lub awarii jest uważany za „faktycznie nie wykonany”, dlatego nie jest prawidłowy . Te odpowiedzi mogą być interesujące, ale na tej stronie jest już kilka nieskończonych pętli lub zawieszających się pytań i możesz znaleźć bardziej odpowiednią odpowiedź. Jeśli nie, rozważ zadanie nowego pytania. Przykładami tych pytań są:
  • Najkrótsza nieskończona pętla nie wytwarzająca żadnych danych wyjściowych
  • Dlaczego to się nie kończy?
  • Pętla bez „zapętlania”
  • Wyzwanie: Napisz fragment kodu, który sam się zamknie
  • Śmieszne błędy w czasie wykonywania
  • Zawieś swój ulubiony kompilator

Tabela liderów

var QUESTION_ID=61115/*,OVERRIDE_USER=8478*/;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,/*getComments()*/(more_answers?getAnswers():process())}})}/*function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}*/function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),score:s.score,language:a[1],lang:jQuery('<div>').html(a[1]).text(),link:s.share_link})}),e.sort(function(e,s){var r=e.score,a=s.score;return a-r});var s={},r=1,a=null,n=1;e.forEach(function(e){e.score!=a&&(n=r),a=e.score,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",e.n=n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.score).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text())/*,s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}*/});var t=e/*[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o])*/;t.sort(function(e,s){return (e.lang.toUpperCase()>s.lang.toUpperCase())-(e.lang.toUpperCase()<s.lang.toUpperCase())||(e.lang>s.lang)-(e.lang<s.lang)});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{PLACE}}",o.n).replace("{{LANGUAGE}}",o.language).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.score).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<(?:h\d|(?!.*<h\d>)p)>\s*((?:[^,;(\s]| +[^-,;(\s])+)(?=(?: *(?:[,;(]| -).*?)?\s*<\/(h\d|p)>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;float:left}table{width:250px}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/all.css?v=7509797c03ea"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Score</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Sorted by Language</h2> <table class="language-list"> <thead> <tr><td></td><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{PLACE}}</td><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

JavaScript Shell

To sprawi, że język będzie całkowicie bezużyteczny.

clear(this);

Czy to nie fajne, że JavaScript ma tak fajną funkcję do samozniszczenia?

Jest to dość proste, clearfunkcja całkowicie opróżnia obiekt. thisodnosi się do obiektu globalnego usuwającego wszystko, łącznie z konstruktorami i funkcjami.

Ponieważ wszystko to wyczyści , zrobienie czegokolwiek , nawet zdefiniowanie literału spowoduje wygenerowanie błędu, przez co język będzie całkowicie bezużyteczny: _{* Nie wymaga środowiska REPL . Wykorzystuje silnik SpiderMonkey (powłoka, a nie przeglądarka), oryginalny silnik JS.}

Emmental

;#33!

Wiem, że to nie jest golf golfowy, ale odpowiednie narzędzie do pracy, wiesz ...

Kod użytkownika można wstawić po !.

Emmental jest interesującym esolangiem opartym na przepisywaniu tłumacza. Każdy pojedynczy symbol (w tym wbudowane) może zostać ponownie zdefiniowany jako dowolny program Emmental. Język opiera się na tej funkcji tak bardzo, że nie zapewnia żadnych konstrukcji zapętlonych. Zamiast tego definiujesz polecenia rekurencyjne, które pojawiają się we własnych definicjach.

Ta redefinicja zachodzi przez !, który odczytuje znak ze stosu, a następnie odczytuje ciąg ze stosu, dopóki nie napotka znaku ;. Znak jest następnie redefiniowany, aby oznaczać program reprezentowany przez ten ciąg.

Oznacza to, że możemy wyłączyć funkcje zapętlenia Emmentala, ponownie definiując ! się jako pusty program. Podczas gdy cały inny kod Emmental nadal działa doskonale, a wiele kryteriów języka programowania jest nadal spełnionych, nie można ponownie zdefiniować żadnych symboli. Bez tej funkcji (a zatem bez możliwości zapętlenia) Emmental nie może już sprawdzać, czy liczba jest liczbą pierwszą.

PHP

Można całkowicie zabić PHP, ustawiając limit pamięci na 1.

To całkowicie umrze.

Spróbuj tego:

<?php
    ini_set('memory_limit',1);

    //code here

Nie powinno to nawet powodować żadnych błędów, ponieważ nie ma na to wystarczającej ilości pamięci.

Możesz przeczytać więcej o memory_limitdyrektywie

Jeśli poprzedni jest nieprawidłowy, można użyć buforów wyjściowych:

<?php
    ob_start();

    //code here

    ob_clear();

To całkowicie usuwa wszelkie dane wyjściowe. Ponieważ bufor wyjściowy jest nadal otwarty, niektóre inne rzeczy przypadkowo pozostawione po kodzie również nie zostaną wyświetlone.

Wykorzystując pomysł @fschmengler :

<?php
    define('OB_START_LEVEL', ob_get_level());
    ob_start(function(){return'';}, -1, PHP_OUTPUT_HANDLER_CLEANABLE);
    //or, for PHP <5.3:
    //ob_start(create_function('','return"";'), -1, PHP_OUTPUT_HANDLER_CLEANABLE);

    //code here

    while(ob_get_level() > OB_START_LEVEL) ob_clear();

Pozwoli to uniknąć problemu usuwania automatycznie uruchamianego bufora wyjściowego, używanego do przechwytywania danych wyjściowych do skompresowania.

Zapobiega to również usuwaniu lub opróżnianiu bufora wyjściowego (wysyłanie do przeglądarki). Aby to poprawić, dodawany jest moduł obsługi wyjścia, który zawsze zwraca pusty ciąg.
Uruchomienie ob_end_flush(); echo "Hello, world!";nic nie da, ale wysłałoby wynik za pomocą zwykłego ob_start();.

Dziękujemy @LucasTrzesniewski za ujawnienie tego problemu!

kod maszynowy x86 w trybie rzeczywistym (=> prawie dowolny program DOS)

00000000  6a 00 07 b9 00 04 30 c0  31 ff f3 aa              |j.....0.1...|
0000000c

to znaczy

push 0
pop es
mov cx,400h
xor al,al
xor di,di
rep stosb

Mam nadzieję, że nie byłeś zbyt przywiązany do stołu przerwań.

Jawa

import java.io.*;
import java.lang.reflect.*;
public class Test2 {
    public static void main(String[] args) throws Exception {
        args = new String[0];
        System.setOut(new PrintStream(new ByteArrayOutputStream()));
        System.setErr(new PrintStream(new ByteArrayOutputStream()));
        System.setIn(new ByteArrayInputStream(new byte[0]));

        Field modifiersField = Field.class.getDeclaredField("modifiers");
        modifiersField.setAccessible(true);

        Class<?> fdClass = java.io.FileDescriptor.class;
        Field outField = fdClass.getDeclaredField("out");
        outField.setAccessible(true);
        modifiersField.setInt(outField, outField.getModifiers() & ~Modifier.FINAL);
        outField.set(null, new FileDescriptor());
        Field errField = fdClass.getDeclaredField("err");
        errField.setAccessible(true);
        modifiersField.setInt(errField, errField.getModifiers() & ~Modifier.FINAL);
        errField.set(null, new FileDescriptor());
        Field inField = fdClass.getDeclaredField("in");
        inField.setAccessible(true);
        modifiersField.setInt(inField, inField.getModifiers() & ~Modifier.FINAL);
        inField.set(null, new FileDescriptor());

        System.setSecurityManager(new SecurityManager(){
            private boolean exitAllowed = false;
            public void checkPermission(java.security.Permission perm) {
                String name = perm.getName();
                if(name.equals("setIO")
                        || name.equals("setSecurityManager")
                        || name.equals("writeFileDescriptor")
                        || name.equals("readFileDescriptor")
                        || name.equals("suppressAccessChecks")
                        || (perm instanceof FilePermission
                            && name.startsWith("/proc/self/fd/"))){
                    throw new SecurityException("Nope");
                }
                if(name.startsWith("exitVM") && !exitAllowed){
                    exitAllowed = true;
                    System.exit(0);
                }
            }
            public void checkExec(String cmd){
                throw new SecurityException("nope");
            }
        });

        // program here
    }
}

Edycja: Środki zaradcze sprawiają, że ten gigant :(

Przekierowuje stdin i stdout na strumienie zerowe i zastępuje argumenty pustą tablicą. Używa również ogromnej ilości hacków refleksyjnych, aby upewnić się, że standardowe IO jest naprawdę ukryte. Na koniec ustawia menedżera bezpieczeństwa, aby upewnić się, że standardowe IO nie może zostać odtworzone, a to sprawia, że ​​programy nie mogą ustawić kodu wyjścia.

Lua

_ENV=""

W Lua _ENVjest środowiskiem, w którym przechowywane są wszystkie zmienne globalne, funkcje, tabele itp. Zdefiniowanie go jako pustego ciągu oznacza, że ​​nie możesz zdefiniować niczego nowego, a wszystkie funkcje i zmienne są usuwane. Oznacza to, że nie możesz nic wysyłać, przyjmować danych wejściowych ani właściwie nic robić.

Język programowania Szekspira

Have Fun Mr Parser.

Romeo, a young man of Verona.
Juliet, a young lady of Verona.
Hamlet, another character which causes the crash.

Act I
Scene I The crash.

[Enter Romeo]
[Enter Juliet]
[Exit Hamlet]

W języku SPL wbudowany analizator składni, który jest pobierany z programem, podlega bardzo szczegółowym regułom dotyczącym tego, co może się zdarzyć w skrypcie. Jedną z takich zasad jest to, że tylko dwie postacie mogą być jednocześnie na scenie. Ponadto sprawienie, by postać opuściła scenę, która nigdy nie była na scenie, dezorientuje ją. To samo dotyczy dodawania postaci do sceny, która już jest na scenie. Gdy parser otrzyma błąd, odmówi wykonania Cokolwiek innego; dosłownie musisz całkowicie zamknąć program i analizator składni, a następnie ponownie uruchomić wszystko.

PS Jeśli nie masz pojęcia, jak działa ten język, Google go. To jest zajebiste.

Pogawędka

Nie jestem pewien, czy to się kwalifikuje:

Smalltalk := Nil.

Spowoduje to usunięcie całego środowiska wykonawczego, zawieszając silnik obiektów. Jedynym sposobem, aby to naprawić, jest przymusowe zakończenie procesu i ponowne uruchomienie z kopii zapasowej.

Dla tych, którzy nie wiedzą, sposób działania [Visual Works] Smalltalk jest nieco dziwny. To jest jak mini-OS. Po uruchomieniu Smalltalk ładujesz „obraz pamięci” do pamięci RAM i kontynuuje on wykonywanie od miejsca, w którym został przerwany. Cały interfejs Smalltalk IDE jest napisany w języku Smalltalk i można go dynamicznie modyfikować.

W szczególności Smalltalkjest słownikiem zawierającym wszystkie zmienne globalne. W szczególności za każdym razem, gdy deklarujesz nową klasę, tworzona jest zmienna globalna o tej nazwie, wskazująca Classobiekt dla twojej nowej klasy. Więc ustawienie Smalltalkna Nil(w zasadzie zero) usuwa wszystkie klasy w całym systemie. Nawet moduły obsługi zdarzeń GUI idą na całość.

Nie mam pojęcia, dlaczego ta zmienna jest nawet zapisywalna. Prawdopodobnie dlatego, że jest to zmienna globalna i dlatego istnieje jako wpis w sobie. (Czy boli cię głowa? Czy wspominałem już, że każdy obiekt ma klasę, a klasy są obiektami, więc każda klasa ma klasę? Klasa klasy nazywa się metaklasą, ale metaklasa jest również przedmiotem, który w związku z tym ma Klasa...)

Podobny efekt można prawdopodobnie osiągnąć, usuwając słownik zamiast zastępując go wartością null. Rzeczywiście, istnieje wiele rzeczy, które można zakodować, aby usunąć wszystkie klasy w systemie, co nie pozwala nic zrobić. Ale ponieważ rzeczywisty kompilator Smalltalk jest także klasą ... wszystko, co łamie język, również trochę psuje całe IDE, więc ...

Haskell

Jest tu kilka możliwości.

Nudny pomysł nr 1: Zdefiniuj, mainaby nic nie robić. Teraz, bez względu na inny kod, który napiszesz, nigdy nie będzie mógł zostać wykonany. (Chyba że ręcznie uruchomisz go z REPL.)

Nudny pomysł nr 2: Zdefiniuj moduł bez publicznego eksportu. Teraz, bez względu na inny kod, który piszesz, nigdy nie może zostać wykonany.

Ciekawy pomysł: wyłącz cały import.

module Fubar where
import Prelude ()
foo = foo
-- More code here.

Teraz możesz zdefiniować funkcje, które są widoczne i można je uruchomić ... ale nie mogą nic zrobić. Wszystkie standardowe typy i funkcje Haskell są teraz ukryte. (Z wyjątkiem kilku rzeczy naprawdę głęboko osadzonych w języku).

W szczególności nie można wykonać żadnych operacji we / wy. Nie można także wykonywać arytmetyki precyzyjnej dla maszyny. (Ponieważ Int, Doubleitp obecnie nieokreślone).

Ty może jeszcze napisać funkcje lambda kamienia nazębnego, który ma wykonać pewne obliczenia choć prawdziwe. Po prostu nie możesz dostać żadnych danych do ani z tego. Ale możesz oczywiście napisać inny, osobny moduł, który wywołuje Fubarpowyższy moduł i wykonuje operacje we / wy w jego imieniu (udowadniając w ten sposób, że kod wykonuje i robi rzeczy).

Niektóre subtelności:

• Ślepa foo = foodeklaracja jest potrzebna, aby nikt nie dodawał dodatkowego importu. (Importy nie mogą pojawić się po deklaracjach.)

• Istnieją różne niestandardowe rozszerzenia języka Haskell, które pozwolą ci wyjść z tej sytuacji. Ale rozszerzenia językowe muszą być włączone za pomocą pragmy kompilatora na początku pliku. (Lub z przełączeniem kompilatora z wiersza poleceń. Naprawdę nie mogę temu zapobiec!)

Postscriptum

Tak, PostScript to język programowania. Co więcej, jest to język programowania, w którym wszystkie konstrukcje językowe są funkcjami zdefiniowanymi przez system, które można przedefiniować ...

1000 dict /Magic def
systemdict {pop Magic exch {} put} forall
Magic begin

Po angielsku:

• Utwórz pusty słownik składający się z 1000 elementów i nazwij go Magic.
• Do każdego klucza systemdictdodaj ten sam klucz Magicz pustą definicją („ {}”).
• Wciśnij Magicna górę stosu słownika.

Od tego momentu każde polecenie języka PostScript jest zdefiniowane, aby nic nie robić. AFAIK, nie można uciec od tego stanu.

(Technicznie rzecz biorąc, nie „niszczysz” starych definicji, po prostu je cieniasz. Gdybyś mógł nadal wykonać end, to wyskoczyłoby Magicze stosu słownika, odtajniając wszystkie polecenia i przywracając ci życie. Ale ponieważ endsama w sobie też jest zacieniona ... teraz nic nie zrobi.)

Zauważ, że wszystkie polecenia będą nadal wykonywane ... po prostu są teraz zdefiniowane, aby nic nie robić. Nie dostaniesz żadnego błędu, po prostu nic się nie wydarzy. (Cóż, przypuszczam, że w końcu nastąpi przepełnienie stosu ...)

Dowolny program uruchamiany w systemie Linux / x86 (-64)

Ten program jest napisany w C, ale może zakłócać działanie dowolnego programu działającego pod Linux / x86 (-32 lub -64). Poprzedzasz go do wywołania z linii poleceń programu, który chcesz zakłócić.

Używa interfejsu API debuggera, aby uniemożliwić programowi docelowemu generowanie jakichkolwiek danych wyjściowych. W szczególności wszystkie wywołania systemowe, które mogą komunikować coś ze światem poza procesem (oczywiście write, oczywiście, ale także openpodczas tworzenia pliku, większość interfejsu API gniazda, killpo zastosowaniu do innego procesu, ...) zawiedzie tak jakby były niewdrożone. _exitjest dozwolone, ale kod wyjścia jest zastępowany przez zero.

W przeciwieństwie do poprzedniej edycji tej odpowiedzi wiele programów może działać prawie do końca w tych warunkach; po prostu cała ich praca jest marnowana. Na przykład, jeśli to zrobisz ./no-syscalls /bin/ls(zakładając, że GNU coreutils ls) czyta cały katalog i formatuje go, a następnie wszystkie writewywołania generujące dane wyjściowe kończą się niepowodzeniem. (Jednak wszystko, co musi otworzyć dwukierunkowy kanał komunikacji, takie jak wszyscy klienci X11, zawiedzie w tym momencie. Myślałem o zezwoleniu, socketale nie send, ale wydawało się, że zbyt prawdopodobne jest otwarcie luk).

Istnieje kilka opcji wiersza polecenia, aby poprawić zachowanie;

-a  log allowed system calls
-d  log denied system calls
-e  deny everything, not just output
-S  permit writes to stderr

Dynamicznie połączone programy nawet nie wyjdą z dynamicznego linkera w -etrybie. -Soczywiście otwiera ogromną dziurę w polityce, ale może być zabawne, gdy programy narzekają, że nic nie działa, np

$ ./no-syscalls -daeS /bin/ls
syscall 59...
syscall 59 = 0
syscall 12 (denied) = -38
syscall 21 (denied) = -38
syscall 9 (denied) = -38
syscall 20...
/bin/ls: error while loading shared libraries: cannot create cache for search path: Cannot allocate memory
syscall 20 = 107
syscall 231...
Program exited, status = 0

Musisz odczytać dane wyjściowe dziennika przy /usr/include/asm*/unistd.hotwartym w innym oknie, ponieważ jest to już dość długie.

Niestety, używane przez to interfejsy debuggera są słabo spójne we wszystkich implementacjach Uniksa i są z natury specyficzne dla procesora. Przeniesienie go na inne architektury procesora byłoby stosunkowo proste (wystarczy dodać odpowiednie definicje SYSCALL_*_REG) i prawdopodobnie możliwe jest przeniesienie go na dowolny system Unix ptrace, ale może być konieczne obszerne zebranie się na białej liście syscall, a także radzenie sobie z rozbieżnościami w ptrace.

#define _GNU_SOURCE 1
#include <stddef.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <sys/ptrace.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/user.h>
#include <sys/wait.h>
#include <errno.h>
#include <fcntl.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#if defined __linux__
# define SYS_unimplemented -1L
# if defined __i386__
#  define SYSCALL_NUMBER_REG regs.orig_eax
#  define SYSCALL_ARG1_REG   regs.ebx
#  define SYSCALL_ARG2_REG   regs.ecx
#  define SYSCALL_ARG3_REG   regs.edx
#  define SYSCALL_ARG4_REG   regs.esi
#  define SYSCALL_RESULT_REG regs.eax
# elif defined __x86_64__
#  define SYSCALL_NUMBER_REG regs.orig_rax
#  define SYSCALL_ARG1_REG   regs.rdi
#  define SYSCALL_ARG2_REG   regs.rsi
#  define SYSCALL_ARG3_REG   regs.rdx
#  define SYSCALL_ARG4_REG   regs.r10
#  define SYSCALL_RESULT_REG regs.rax
# else
#  error "Need to know system call convention for this CPU"
# endif
#else
# error "Need to know system call convention for this OS"
#endif

static long
xptrace(int request, pid_t pid, void *addr, void *data)
{
  errno = 0;
  long rv = ptrace(request, pid, addr, data);
  if (rv == -1 && errno) {
    perror("ptrace");
    if (pid != 0) kill(pid, SIGKILL);
    exit(1);
  }
  return rv;
}
#define GET_REG_(pid, x) \
  xptrace(PTRACE_PEEKUSER, pid, (void*)offsetof(struct user, x), 0)
#define GET_REG(pid, x) GET_REG_(pid, SYSCALL_##x##_REG)
#define SET_REG_(pid, x, v) \
  xptrace(PTRACE_POKEUSER, pid, (void*)offsetof(struct user, x), (void*)v)
#define SET_REG(pid, x, v) SET_REG_(pid, SYSCALL_##x##_REG, v)

/* This function defines the system-call policy.  */
static int
deny_syscall(pid_t pid, int scnum, int deny_all, int allow_stderr)
{
  switch (scnum) {
  /* These syscalls are unconditionally allowed (when not in -e mode);
     they perform input, or change only process-local state. */
#ifdef SYS_access
  case SYS_access:
#endif
#ifdef SYS_alarm
  case SYS_alarm:
#endif
#ifdef SYS_arch_prctl
  case SYS_arch_prctl:
#endif
#ifdef SYS_brk
  case SYS_brk:
#endif
#ifdef SYS_capget
  case SYS_capget:
#endif
#ifdef SYS_clock_getres
  case SYS_clock_getres:
#endif
#ifdef SYS_clock_gettime
  case SYS_clock_gettime:
#endif
#ifdef SYS_clock_nanosleep
  case SYS_clock_nanosleep:
#endif
#ifdef SYS_close
  case SYS_close:
#endif
#ifdef SYS_dup
  case SYS_dup:
#endif
#ifdef SYS_dup2
  case SYS_dup2:
#endif
#ifdef SYS_dup3
  case SYS_dup3:
#endif
#ifdef SYS_epoll_create
  case SYS_epoll_create:
#endif
#ifdef SYS_epoll_create1
  case SYS_epoll_create1:
#endif
#ifdef SYS_epoll_ctl
  case SYS_epoll_ctl:
#endif
#ifdef SYS_epoll_ctl_old
  case SYS_epoll_ctl_old:
#endif
#ifdef SYS_epoll_pwait
  case SYS_epoll_pwait:
#endif
#ifdef SYS_epoll_wait
  case SYS_epoll_wait:
#endif
#ifdef SYS_epoll_wait_old
  case SYS_epoll_wait_old:
#endif
#ifdef SYS_eventfd
  case SYS_eventfd:
#endif
#ifdef SYS_eventfd2
  case SYS_eventfd2:
#endif
#ifdef SYS_faccessat
  case SYS_faccessat:
#endif
#ifdef SYS_fadvise64
  case SYS_fadvise64:
#endif
#ifdef SYS_fadvise64_64
  case SYS_fadvise64_64:
#endif
#ifdef SYS_fanotify_init
  case SYS_fanotify_init:
#endif
#ifdef SYS_fanotify_mark
  case SYS_fanotify_mark:
#endif
#ifdef SYS_fgetxattr
  case SYS_fgetxattr:
#endif
#ifdef SYS_flistxattr
  case SYS_flistxattr:
#endif
#ifdef SYS_fstat
  case SYS_fstat:
#endif
#ifdef SYS_fstat64
  case SYS_fstat64:
#endif
#ifdef SYS_fstatat64
  case SYS_fstatat64:
#endif
#ifdef SYS_fstatfs
  case SYS_fstatfs:
#endif
#ifdef SYS_fstatfs64
  case SYS_fstatfs64:
#endif
#ifdef SYS_ftime
  case SYS_ftime:
#endif
#ifdef SYS_futex
  case SYS_futex:
#endif
#ifdef SYS_getcpu
  case SYS_getcpu:
#endif
#ifdef SYS_getcwd
  case SYS_getcwd:
#endif
#ifdef SYS_getdents
  case SYS_getdents:
#endif
#ifdef SYS_getdents64
  case SYS_getdents64:
#endif
#ifdef SYS_getegid
  case SYS_getegid:
#endif
#ifdef SYS_getegid32
  case SYS_getegid32:
#endif
#ifdef SYS_geteuid
  case SYS_geteuid:
#endif
#ifdef SYS_geteuid32
  case SYS_geteuid32:
#endif
#ifdef SYS_getgid
  case SYS_getgid:
#endif
#ifdef SYS_getgid32
  case SYS_getgid32:
#endif
#ifdef SYS_getgroups
  case SYS_getgroups:
#endif
#ifdef SYS_getgroups32
  case SYS_getgroups32:
#endif
#ifdef SYS_getitimer
  case SYS_getitimer:
#endif
#ifdef SYS_get_kernel_syms
  case SYS_get_kernel_syms:
#endif
#ifdef SYS_get_mempolicy
  case SYS_get_mempolicy:
#endif
#ifdef SYS_getpeername
  case SYS_getpeername:
#endif
#ifdef SYS_getpgid
  case SYS_getpgid:
#endif
#ifdef SYS_getpgrp
  case SYS_getpgrp:
#endif
#ifdef SYS_getpid
  case SYS_getpid:
#endif
#ifdef SYS_getpmsg
  case SYS_getpmsg:
#endif
#ifdef SYS_getppid
  case SYS_getppid:
#endif
#ifdef SYS_getpriority
  case SYS_getpriority:
#endif
#ifdef SYS_getrandom
  case SYS_getrandom:
#endif
#ifdef SYS_getresgid
  case SYS_getresgid:
#endif
#ifdef SYS_getresgid32
  case SYS_getresgid32:
#endif
#ifdef SYS_getresuid
  case SYS_getresuid:
#endif
#ifdef SYS_getresuid32
  case SYS_getresuid32:
#endif
#ifdef SYS_getrlimit
  case SYS_getrlimit:
#endif
#ifdef SYS_get_robust_list
  case SYS_get_robust_list:
#endif
#ifdef SYS_getrusage
  case SYS_getrusage:
#endif
#ifdef SYS_getsid
  case SYS_getsid:
#endif
#ifdef SYS_getsockname
  case SYS_getsockname:
#endif
#ifdef SYS_getsockopt
  case SYS_getsockopt:
#endif
#ifdef SYS_get_thread_area
  case SYS_get_thread_area:
#endif
#ifdef SYS_gettid
  case SYS_gettid:
#endif
#ifdef SYS_gettimeofday
  case SYS_gettimeofday:
#endif
#ifdef SYS_getuid
  case SYS_getuid:
#endif
#ifdef SYS_getuid32
  case SYS_getuid32:
#endif
#ifdef SYS_getxattr
  case SYS_getxattr:
#endif
#ifdef SYS_inotify_add_watch
  case SYS_inotify_add_watch:
#endif
#ifdef SYS_inotify_init
  case SYS_inotify_init:
#endif
#ifdef SYS_inotify_init1
  case SYS_inotify_init1:
#endif
#ifdef SYS_inotify_rm_watch
  case SYS_inotify_rm_watch:
#endif
#ifdef SYS_ioprio_get
  case SYS_ioprio_get:
#endif
#ifdef SYS_kcmp
  case SYS_kcmp:
#endif
#ifdef SYS_lgetxattr
  case SYS_lgetxattr:
#endif
#ifdef SYS_listxattr
  case SYS_listxattr:
#endif
#ifdef SYS_llistxattr
  case SYS_llistxattr:
#endif
#ifdef SYS_lookup_dcookie
  case SYS_lookup_dcookie:
#endif
#ifdef SYS_lseek
  case SYS_lseek:
#endif
#ifdef SYS_lstat
  case SYS_lstat:
#endif
#ifdef SYS_lstat64
  case SYS_lstat64:
#endif
#ifdef SYS_madvise
  case SYS_madvise:
#endif
#ifdef SYS_mbind
  case SYS_mbind:
#endif
#ifdef SYS_mincore
  case SYS_mincore:
#endif
#ifdef SYS_mlock
  case SYS_mlock:
#endif
#ifdef SYS_mlockall
  case SYS_mlockall:
#endif
#ifdef SYS_mprotect
  case SYS_mprotect:
#endif
#ifdef SYS_mremap
  case SYS_mremap:
#endif
#ifdef SYS_munlock
  case SYS_munlock:
#endif
#ifdef SYS_munlockall
  case SYS_munlockall:
#endif
#ifdef SYS_munmap
  case SYS_munmap:
#endif
#ifdef SYS_name_to_handle_at
  case SYS_name_to_handle_at:
#endif
#ifdef SYS_nanosleep
  case SYS_nanosleep:
#endif
#ifdef SYS_newfstatat
  case SYS_newfstatat:
#endif
#ifdef SYS_nice
  case SYS_nice:
#endif
#ifdef SYS_oldfstat
  case SYS_oldfstat:
#endif
#ifdef SYS_oldlstat
  case SYS_oldlstat:
#endif
#ifdef SYS_oldolduname
  case SYS_oldolduname:
#endif
#ifdef SYS_oldstat
  case SYS_oldstat:
#endif
#ifdef SYS_olduname
  case SYS_olduname:
#endif
#ifdef SYS_pause
  case SYS_pause:
#endif
#ifdef SYS_perf_event_open
  case SYS_perf_event_open:
#endif
#ifdef SYS_personality
  case SYS_personality:
#endif
#ifdef SYS_pivot_root
  case SYS_pivot_root:
#endif
#ifdef SYS_poll
  case SYS_poll:
#endif
#ifdef SYS_ppoll
  case SYS_ppoll:
#endif
#ifdef SYS_prctl
  case SYS_prctl:
#endif
#ifdef SYS_pread64
  case SYS_pread64:
#endif
#ifdef SYS_preadv
  case SYS_preadv:
#endif
#ifdef SYS_prlimit64
  case SYS_prlimit64:
#endif
#ifdef SYS_pselect6
  case SYS_pselect6:
#endif
#ifdef SYS_query_module
  case SYS_query_module:
#endif
#ifdef SYS_read
  case SYS_read:
#endif
#ifdef SYS_readahead
  case SYS_readahead:
#endif
#ifdef SYS_readdir
  case SYS_readdir:
#endif
#ifdef SYS_readlink
  case SYS_readlink:
#endif
#ifdef SYS_readlinkat
  case SYS_readlinkat:
#endif
#ifdef SYS_readv
  case SYS_readv:
#endif
#ifdef SYS_recvfrom
  case SYS_recvfrom:
#endif
#ifdef SYS_recvmmsg
  case SYS_recvmmsg:
#endif
#ifdef SYS_recvmsg
  case SYS_recvmsg:
#endif
#ifdef SYS_remap_file_pages
  case SYS_remap_file_pages:
#endif
#ifdef SYS_request_key
  case SYS_request_key:
#endif
#ifdef SYS_restart_syscall
  case SYS_restart_syscall:
#endif
#ifdef SYS_rt_sigaction
  case SYS_rt_sigaction:
#endif
#ifdef SYS_rt_sigpending
  case SYS_rt_sigpending:
#endif
#ifdef SYS_rt_sigprocmask
  case SYS_rt_sigprocmask:
#endif
#ifdef SYS_rt_sigreturn
  case SYS_rt_sigreturn:
#endif
#ifdef SYS_rt_sigsuspend
  case SYS_rt_sigsuspend:
#endif
#ifdef SYS_rt_sigtimedwait
  case SYS_rt_sigtimedwait:
#endif
#ifdef SYS_sched_getaffinity
  case SYS_sched_getaffinity:
#endif
#ifdef SYS_sched_getattr
  case SYS_sched_getattr:
#endif
#ifdef SYS_sched_getparam
  case SYS_sched_getparam:
#endif
#ifdef SYS_sched_get_priority_max
  case SYS_sched_get_priority_max:
#endif
#ifdef SYS_sched_get_priority_min
  case SYS_sched_get_priority_min:
#endif
#ifdef SYS_sched_getscheduler
  case SYS_sched_getscheduler:
#endif
#ifdef SYS_sched_rr_get_interval
  case SYS_sched_rr_get_interval:
#endif
#ifdef SYS_sched_setaffinity
  case SYS_sched_setaffinity:
#endif
#ifdef SYS_sched_setattr
  case SYS_sched_setattr:
#endif
#ifdef SYS_sched_setparam
  case SYS_sched_setparam:
#endif
#ifdef SYS_sched_setscheduler
  case SYS_sched_setscheduler:
#endif
#ifdef SYS_sched_yield
  case SYS_sched_yield:
#endif
#ifdef SYS_select
  case SYS_select:
#endif
#ifdef SYS_setfsgid
  case SYS_setfsgid:
#endif
#ifdef SYS_setfsgid32
  case SYS_setfsgid32:
#endif
#ifdef SYS_setfsuid
  case SYS_setfsuid:
#endif
#ifdef SYS_setfsuid32
  case SYS_setfsuid32:
#endif
#ifdef SYS_setgid
  case SYS_setgid:
#endif
#ifdef SYS_setgid32
  case SYS_setgid32:
#endif
#ifdef SYS_setgroups
  case SYS_setgroups:
#endif
#ifdef SYS_setgroups32
  case SYS_setgroups32:
#endif
#ifdef SYS_setitimer
  case SYS_setitimer:
#endif
#ifdef SYS_setns
  case SYS_setns:
#endif
#ifdef SYS_setpgid
  case SYS_setpgid:
#endif
#ifdef SYS_setpriority
  case SYS_setpriority:
#endif
#ifdef SYS_setregid
  case SYS_setregid:
#endif
#ifdef SYS_setregid32
  case SYS_setregid32:
#endif
#ifdef SYS_setresgid
  case SYS_setresgid:
#endif
#ifdef SYS_setresgid32
  case SYS_setresgid32:
#endif
#ifdef SYS_setresuid
  case SYS_setresuid:
#endif
#ifdef SYS_setresuid32
  case SYS_setresuid32:
#endif
#ifdef SYS_setreuid
  case SYS_setreuid:
#endif
#ifdef SYS_setreuid32
  case SYS_setreuid32:
#endif
#ifdef SYS_setrlimit
  case SYS_setrlimit:
#endif
#ifdef SYS_set_robust_list
  case SYS_set_robust_list:
#endif
#ifdef SYS_setsid
  case SYS_setsid:
#endif
#ifdef SYS_set_thread_area
  case SYS_set_thread_area:
#endif
#ifdef SYS_set_tid_address
  case SYS_set_tid_address:
#endif
#ifdef SYS_setuid
  case SYS_setuid:
#endif
#ifdef SYS_setuid32
  case SYS_setuid32:
#endif
#ifdef SYS_sigaction
  case SYS_sigaction:
#endif
#ifdef SYS_sigaltstack
  case SYS_sigaltstack:
#endif
#ifdef SYS_signal
  case SYS_signal:
#endif
#ifdef SYS_signalfd
  case SYS_signalfd:
#endif
#ifdef SYS_signalfd4
  case SYS_signalfd4:
#endif
#ifdef SYS_sigpending
  case SYS_sigpending:
#endif
#ifdef SYS_sigprocmask
  case SYS_sigprocmask:
#endif
#ifdef SYS_sigreturn
  case SYS_sigreturn:
#endif
#ifdef SYS_sigsuspend
  case SYS_sigsuspend:
#endif
#ifdef SYS_socketpair
  case SYS_socketpair:
#endif
#ifdef SYS_stat
  case SYS_stat:
#endif
#ifdef SYS_stat64
  case SYS_stat64:
#endif
#ifdef SYS_statfs
  case SYS_statfs:
#endif
#ifdef SYS_statfs64
  case SYS_statfs64:
#endif
#ifdef SYS_sysfs
  case SYS_sysfs:
#endif
#ifdef SYS_sysinfo
  case SYS_sysinfo:
#endif
#ifdef SYS_time
  case SYS_time:
#endif
#ifdef SYS_timer_create
  case SYS_timer_create:
#endif
#ifdef SYS_timer_delete
  case SYS_timer_delete:
#endif
#ifdef SYS_timerfd_create
  case SYS_timerfd_create:
#endif
#ifdef SYS_timerfd_gettime
  case SYS_timerfd_gettime:
#endif
#ifdef SYS_timerfd_settime
  case SYS_timerfd_settime:
#endif
#ifdef SYS_timer_getoverrun
  case SYS_timer_getoverrun:
#endif
#ifdef SYS_timer_gettime
  case SYS_timer_gettime:
#endif
#ifdef SYS_timer_settime
  case SYS_timer_settime:
#endif
#ifdef SYS_times
  case SYS_times:
#endif
#ifdef SYS_ugetrlimit
  case SYS_ugetrlimit:
#endif
#ifdef SYS_ulimit
  case SYS_ulimit:
#endif
#ifdef SYS_umask
  case SYS_umask:
#endif
#ifdef SYS_uname
  case SYS_uname:
#endif
#ifdef SYS_unshare
  case SYS_unshare:
#endif
#ifdef SYS_uselib
  case SYS_uselib:
#endif
#ifdef SYS_ustat
  case SYS_ustat:
#endif
#ifdef SYS_wait4
  case SYS_wait4:
#endif
#ifdef SYS_waitid
  case SYS_waitid:
#endif
#ifdef SYS_waitpid
  case SYS_waitpid:
#endif
    return deny_all;

#ifdef SYS_exit
  case SYS_exit:
#endif
#ifdef SYS_exit_group
  case SYS_exit_group:
#endif
    /* Special case: exiting is allowed, even in -e mode,
       but the exit status is forced to 0. */
    SET_REG(pid, ARG1, 0);
    return 0;

#ifdef SYS_fcntl
  case SYS_fcntl:
#endif
#ifdef SYS_fcntl64
  case SYS_fcntl64:
#endif
    /* Special case: fcntl is allowed, but only for the *FD and *FL
       operations.  This is a compromise between not allowing it at
       all, which would break some interpreters, and trying to go
       through the dozens of extended ops and figure out which ones
       can affect global state.  */
    {
      int cmd = GET_REG(pid, ARG2);
      if (cmd == F_DUPFD || cmd == F_DUPFD_CLOEXEC ||
          cmd == F_GETFD || cmd == F_SETFD || cmd == F_SETFL || cmd == F_GETFL)
        return deny_all;
    }
    return 1;

#ifdef SYS_kill
  case SYS_kill:
#endif
#ifdef SYS_rt_sigqueueinfo
  case SYS_rt_sigqueueinfo:
#endif
#ifdef SYS_rt_tgsigqueueinfo
  case SYS_rt_tgsigqueueinfo:
#endif
#ifdef SYS_tkill
  case SYS_tkill:
#endif
#ifdef SYS_tgkill
  case SYS_tgkill:
#endif
    /* Special case: kill is allowed if and only if directed to the calling
       process. */
    {
      pid_t kpid = GET_REG(pid, ARG1);
      if (kpid == pid)
        return deny_all;
    }
    return 1;

#ifdef SYS_mmap
  case SYS_mmap:
#endif
#ifdef SYS_mmap2
  case SYS_mmap2:
#endif
    /* Special case: mmap is allowed if it is private or read-only.  */
    {
      int prot  = GET_REG(pid, ARG3);
      int flags = GET_REG(pid, ARG4);
      if ((flags & (MAP_SHARED|MAP_PRIVATE)) == MAP_PRIVATE)
        return deny_all;
      if (!(prot & PROT_WRITE))
        return deny_all;
    }
    return 1;

    /* Special case: open() variants are allowed only if read-only and
       not creating. */
#ifdef SYS_open
  case SYS_open:
#endif
#ifdef SYS_openat
  case SYS_openat:
#endif
#ifdef SYS_open_by_handle_at
  case SYS_open_by_handle_at:
#endif
    {
      int flags = ((scnum == SYS_open)
                   ? GET_REG(pid, ARG2)
                   : GET_REG(pid, ARG3));
      if (!(flags & O_CREAT) && ((flags & O_ACCMODE) == O_RDONLY))
        return deny_all;
    }
    return 1;

#ifdef SYS_write
  case SYS_write:
#endif
#ifdef SYS_write64
  case SYS_write64:
#endif
#ifdef SYS_writev
  case SYS_writev:
#endif
#ifdef SYS_pwrite
  case SYS_pwrite:
#endif
#ifdef SYS_pwrite64
  case SYS_pwrite64:
#endif
#ifdef SYS_pwritev
  case SYS_pwritev:
#endif
    /* Special case: optionally, the program is allowed to write to
       stderr.  This opens a gaping hole in the policy, but it can be
       quite entertaining to watch programs moan about how nothing works. */
    if (allow_stderr) {
      int fd = GET_REG(pid, ARG1);
      if (fd == 2)
        return 0;
    }
    return 1;

  default:
    /* All other system calls are unconditionally denied. */
    return 1;
  }
}

static void
usage(char *progname)
{
  fprintf(stderr, "usage: %s [-adeS] program args...\n", progname);
  fputs("\t-a  log allowed system calls\n"
        "\t-d  log denied system calls\n"
        "\t-e  deny everything, not just output\n"
        "\t-S  permit writes to stderr\n", stderr);
  exit(2);
}

int
main(int argc, char **argv)
{
  pid_t pid;
  int   status;
  int   opt;
  long  last_syscall = SYS_unimplemented;
  int   last_allowed = 0;
  int   after_execve = 0;
  int   trace_active = 0;
  int   allow_stderr = 0;
  int   deny_all     = 0;
  int   log_allowed  = 0;
  int   log_denied   = 0;

  while ((opt = getopt(argc, argv, "+adeS")) != -1) {
    switch (opt) {
    case 'a': log_allowed  = 1; break;
    case 'd': log_denied   = 1; break;
    case 'e': deny_all     = 1; break;
    case 'S': allow_stderr = 1; break;
    default:
      usage(argv[0]);
    }
  }
  if (optind == argc) {
    usage(argv[0]);
  }

  setvbuf(stdout, 0, _IOLBF, 0);
  setvbuf(stderr, 0, _IOLBF, 0);

  pid = fork();
  if (pid == -1) {
    perror("fork");
    exit(1);

  } else if (pid == 0) {
    raise(SIGSTOP); /* synch with parent */
    execvp(argv[optind], argv+optind);
    perror("execvp");
    exit(1);
  }

  /* If we get here, we are the parent. */
  for (;;) {
    pid_t rv = waitpid(pid, &status, WUNTRACED);
    if (rv != pid) {
      perror("waitpid");
      kill(pid, SIGKILL);
      exit(1);
    }
    if (!WIFSTOPPED(status)) {
      if (WIFEXITED(status))
        printf("Program exited, status = %d\n", WEXITSTATUS(status));
      else if (WIFSIGNALED(status))
        printf("Program killed by signal %d\n", WTERMSIG(status));
      else {
        printf("Un-decodable status %04x\n", status);
        kill(pid, SIGKILL); /* just in case */
      }
      exit(0);
    }
    if (WSTOPSIG(status) == SIGSTOP && !trace_active) {
      /* This is the raise(SIGSTOP) on the child side of the fork. */
      trace_active = 1;
      xptrace(PTRACE_SEIZE, pid, 0, (void*)PTRACE_O_TRACESYSGOOD);
      xptrace(PTRACE_SYSCALL, pid, 0, 0);
    }
    else if (WSTOPSIG(status) == (SIGTRAP|0x80)) {
      if (last_syscall == SYS_unimplemented) {
        last_syscall = GET_REG(pid, NUMBER);
        /* The child process is allowed to execute normally until an
           execve() succeeds.  */
        if (after_execve && deny_syscall(pid, last_syscall,
                                         deny_all, allow_stderr)) {
          last_allowed = 0;
          SET_REG(pid, NUMBER, SYS_unimplemented);
        } else {
          last_allowed = 1;
          if (log_allowed) {
            /* Log this now, we may not get another chance. */
            printf("syscall %ld...\n", last_syscall);
          }
        }
      } else {
        if (last_allowed ? log_allowed : log_denied) {
          long scret = GET_REG(pid, RESULT);
          printf("syscall %ld%s = %ld\n",
                 last_syscall, last_allowed ? "" : " (denied)", scret);
        }
        if (last_allowed && (last_syscall == SYS_execve ||
                             last_syscall == SYS_execveat)) {
          long scret = GET_REG(pid, RESULT);
          if (scret == 0)
            after_execve = 1;
        }
        last_syscall = SYS_unimplemented;
      }
      xptrace(PTRACE_SYSCALL, pid, 0, 0);
    }
    else if (WSTOPSIG(status) == SIGTRAP) {
      /* Swallow all SIGTRAPs, they are probably spurious debug events. */
      xptrace(PTRACE_SYSCALL, pid, 0, 0);
    } else {
      /* Allow all normal signals to proceed unmolested. */
      if (log_allowed) {
        printf("process received signal %d\n", WSTOPSIG(status));
      }
      xptrace(PTRACE_SYSCALL, pid, 0, (void*)(uintptr_t)WSTOPSIG(status));
    }
  }
}

TeX

\catcode`\\=10

Nie jestem pewien, czy to faktycznie zadziała, ale teoretycznie powinno się to załamać, \ponieważ postać ucieczki nie pozostawia ci sposobu na naprawienie tego. Zwykle TeX potrafi czytać i zapisywać pliki, teraz nie może pisać niczego, co zależy od logiki. Tak więc język jest teraz łamany zgodnie z definicją OP.

EDYCJA: Inne polecenia zabicia pobrane z komentarzy (chociaż oba mogą naruszać regułę kodu należy wykonać):

• \def\fi{}\iffalseprzez smpl tworzy nieodłączną gałąź if
• \catcode13=9%autor: iwillnotexist idonotexist tworzy niekończący się komentarz

Zadraśnięcie

when [timer v] > (0)Będzie działać tak szybko, jak kod zostanie zainicjowany, które jeśli jesteś w edytorze jest jeszcze przed uruchomieniem kodu. when I receive (join[][])Spowoduje błąd zostać wyrzucony za każdym razem coś jest nadawany, wstrzymując wykonanie kodu, jeśli masz wersję Developer Flash. Ta breakfunkcja utworzy klony i wyzwoli błąd transmisji. Każdy klon będzie trwał dwie sekundy, a następnie sam się usunie, obciążając stos. I każdy klon zareaguje na when [timer v] > (0)uruchomienie breakpodprogramu i zresetowanie timera, co spowoduje ponowne uruchomienie kodu timera. Ponadto, każdy klon zareaguje również na każdy błąd transmisji, co oznacza, że ​​liczba błędów na ocenę breakto liczba kwadratów podniesiona do kwadratu. Czy zapomniałem wspomnieć, że breakfunkcja marun without screen refreshzaznaczone, powodując zawieszanie się, wstrząsanie i opóźnianie edytora, a także pobieranie i przydzielanie pamięci. I maksymalnie wykorzystując procesor.

Każdy kod dodany w dowolnym miejscu z tym działaniem nie będzie w stanie utworzyć klonów (przekroczony limit 300 klonów), a także rozgrzać i zawiesić komputer z uruchomionym programem. I chwytanie pamięci, dopóki nie będzie już więcej do pobrania, pozostawiając zmienne źle funkcjonujące.

A po zbyt długim opóźnieniu, aby uruchomić when [timer v] > (0)blok, nadal będzie działać break.

Dzięki @towerofnix za przypomnienie mi o usterce, when I receivektórą znalazłem jakiś czas temu i danie mi pomysłu run without screen refresh. Jeśli ci się podobało, oto oryginał: https://codegolf.stackexchange.com/a/61357/43394

Język Mathematica / Wolfram

Mathematica to interpretowany język, w którym nazwy poleceń są symbolami, którymi może manipulować programista. Nie można usunąć wbudowanych operatorów, ale można je przeciążać lub w inny sposób modyfikować ich funkcje. Poniżej szyfruje polecenie „With”, które jest potrzebne do przypisania zmiennych nawet wewnętrznie. Ta zmiana zapobiega trzymaniu przez jądro argumentów nieocenionych aż do zakończenia przypisania i zabija język zupełnie martwy.

ClearAttributes["With", HoldAll]

Jeśli to polecenie zostanie uruchomione w sesji interaktywnej lub w bloku kodu, Mathematica nawet nie będzie w stanie dodać 1+1(wynikowy komunikat o błędzie ma długość strony, więc nie dołączę go tutaj).

PHP

Dziwi mnie, że tak naprawdę działa, ale zamyka STDOUTi STDERRtłumi wszystkie dane wyjściowe. Aby mieć pewność, że nie zostaną ponownie otwarte, otwieramy /dev/nulltrzy razy, aby ponownie przypisać deskryptory plików 0, 1 i 2:

<?php
fclose(STDIN);
fclose(STDOUT);
fclose(STDERR);
fopen('/dev/null','r');
fopen('/dev/null','w');
fopen('/dev/null','w');

// insert program here

Więcej na ten temat: https://stackoverflow.com/questions/937627/how-to-redirect-stdout-to-a-file-in-php

Partia DOS (przed Windows 95, jak sądzę)

CTTY

Wydane bez argumentów powoduje to odłączenie wiersza poleceń od terminala. Dalsze próby odczytu danych wejściowych lub wygenerowania danych wyjściowych nic nie robią.

Jeśli chcesz wiedzieć, jak prawidłowo korzystać z CTTY:

MODE COM1,8600,8,N,1
CTTY COM1

Nieco mocniejszy plik wsadowy może nawet odpowiedzieć na modem i połączyć wszystko, co nawiązało połączenie z CTTY.

Common Lisp

(set-macro-character #\( (lambda (x y) ()))

Mam nadzieję, że nie potrzebujesz tych otwierających nawiasów.

Jest to makro czytnika, które informuje Lisp Reader, aby zastąpił każde wystąpienie (wywołaniem (lambda (x y) ())funkcji, która przyjmuje dwa argumenty i nic nie zwraca. Na przykład odczytałby (foo)jako foo), zinterpretował foojako zmienną, a następnie wrzucił niedopasowany błąd w nawiasie 0.

Zadraśnięcie

Oto dość prosty przykład, który spowoduje awarię przeglądarki (i teoretycznie komputera):

Zostawiłem to uruchomione na około dwadzieścia sekund, a potem straciłem 2,65 GB pamięci do Scratcha. Zaledwie chwilę później zniknęło 5 GB.

Zdecydowanie sugeruję, abyś mógł wymusić zamknięcie Adobe Flash lub przeglądarki internetowej przed uruchomieniem tego!

^{Ja naprawdę chciałem zrobić chłodną odpowiedź lubią clear(this)JS jeden ale niestety Scratch nie ma żadnych sposobów, aby to zrobić. Zaktualizuj ten post (lub stwórz własny), jeśli znajdziesz inny sposób, aby Scratch był bezużyteczny!}

Czw

::=

Z nową linią na końcu

Ten język opiera się na definiowaniu zestawów reguł, a symbol ::=oznacza koniec zestawu reguł. Niemożliwe jest zrobienie WSZYSTKIEGO w TYM, bez zdefiniowania reguł, które to robią, więc bez względu na to, co postawisz po ::=, nic się nie stanie.

Alternatywna odpowiedź

A::=
B::=
C::=
D::=
E::=
F::=
G::=
H::=

(i tak dalej dla każdego znaku w całym Unicode, w tym także przed Aznakiem i znaków niedrukowalnych). Wymaga to opcji wiersza polecenia -r.

MATLAB

Poniższy fragment kodu sprawia, że ​​środowisko jest całkowicie bezużyteczne ¹ :

builtin = @(varargin)false; clear = @(varargin)false;
%// Insert code after this point

Zastępuje to builtinfunkcję i clearfunkcję z nowymi uchwytami funkcji anonimowych, które po prostu powracają za falsekażdym razem, gdy próbujesz wywołać te funkcje. builtinFunkcja zapewnia, że jeśli istnieją jakieś niestandardowe funkcje piszesz MATLAB, które są takie same nazwy jak te, które są wbudowane do MATLAB (rzeczy jak sum, max, min, itd.), Są w stanie wywołać te jednoznacznie zamiast przeciążonych funkcji . Podobnie cleardaje możliwość wyczyszczenia wszystkich zadeklarowanych zmiennych, dzięki czemu możesz zacząć od nowa. Usunięcie tych możliwości uniemożliwi korzystanie z MATLAB bez ponownego uruchomienia programu.

W MATLAB R2015a otrzymuję również następujący komunikat:

Obszar roboczy to zmienne, które są obecnie zadeklarowane w środowisku, dzięki czemu można ich później użyć. Spowoduje to trwałe wyłączenie obszaru roboczego, więc wszelkie zmienne, które spróbujesz utworzyć, nie zostaną zapisane, a zatem nie będzie można zrobić postępu podczas wykonywania wierszy kodu w MATLAB.

^{1: Kredyt trafia do użytkownika Dev-iL, który pierwotnie odkrył ten pomysł.}

///

/\///

Jedyna operacja /// powtarza podstawienie ciągu, w następujący sposób: /pattern/replacement/.

Ten kod usuwa wszystkie /w ten sposób, że nie można użyć powtarzania podstawiania ciągów, więc w zasadzie wszystko, co napiszesz, zostanie wydrukowane (z wyjątkiem /s).

Nadal możesz używać \s, ale to ci niewiele pomoże.

Befunge-96

'~h

Kod użytkownika może podążać w dowolnym miejscu po tej sekwencji, o ile są to pierwsze trzy znaki w źródle.

'Poleceń (string tryb jeden-shot) popycha wartości ASCII ~na stosie (czyli 126), a hkomenda ustawia co jest znane jako Holistic Delta z tej wartości. Dla tych, którzy nie znają Befunge-96, Holistyczna Delta jest przesunięciem dodawanym do wartości każdego bajtu polecenia, z którym zetknie się interpreter.

Gdy delta jest ustawiona na 126, jedynym prawidłowym poleceniem, które można wygenerować, jest ~(wprowadzanie znaków) za pomocą bajtu zerowego w źródle. Wszystko inne niż bajt zerowy przełożyłoby się na wartość większą niż 126 i żadna z tych wartości nie byłaby prawidłowymi poleceniami Befunge.

Myślę, że można śmiało powiedzieć, że uniemożliwiłoby to zakwalifikowanie się jako język programowania.

Gwizd

macro harmless:
    Context.Parameters.Pipeline.Clear()

A potem, gdzie indziej w projekcie,

harmless

Proste makro o nieszkodliwie brzmiącej nazwie, ale niezwykle frustrującym efekcie. Kompilator Boo wykorzystuje wielostopniowy potok, który zaczyna się od analizowania źródła do AST, a kończy na generowaniu kodu. (Ogólnie. Można go ponownie skonfigurować dla różnych aplikacji.) Każdy krok pomiędzy wykonuje różne operacje na AST.

W części znajduje się etap ekspansji makr, w którym makra są wykonywane w kontekście kompilatora. Pamiętasz bit z ostatniego akapitu o rekonfiguracji potoku? Jeśli podczas ekspansji makra zostanie wywołane makro, które czyści potok, użytkownik nie wyświetli żadnego błędu, ale wszystkie kroki po rozwinięciu makra (w tym generowanie kodu) już tam nie są. W efekcie powstaje coś, co wygląda na udaną kompilację - nie wyświetla się żaden komunikat o błędzie - ale z jakiegoś powodu nie ma pliku binarnego! Gwarantowane jest doprowadzenie nawet najlepszych narzędzi do rozwiązywania problemów do ściany, jeśli dobrze ukryjesz makro i wywołanie.

NGN / APL

NGN / APL pozwala na redefiniowanie prymitywów, więc redefinicja ( ←) wszystkich funkcji prymitywnych ⊢(„pass through”: oba ⊢3i 2⊢3daje 3) sprawia, że ​​język jest całkowicie bezużyteczny:

⍪←-←+←?←⍵←∊←⍴←~←↑←↓←⍳←○←*←⌈←⌊←⍕←⊂←⊃←∩←∪←⊥←⊤←|←<←≤←=←≥←>←≠←∨←∧←×←÷←⍒←⍋←⌽←⍉←⊖←⍟←⍱←⍲←!←⌹←⊣←⍎←⊢

Wypróbuj tutaj.

Ruby (29 znaków)

class Object;def send;end;end

Ponieważ „send” jest używane wewnętrznie za każdym razem, gdy wywoływana jest metoda w Ruby, i ponieważ wszystkie obiekty dziedziczą z klasy Object. Powinno to zatrzymać dowolną metodę.

Ciekawostka: w teorii brzmi to doskonale. Ale z jakiegoś powodu wydaje się, że nie sprząta języka Ruby. Nie mam pojęcia, dlaczego można uruchomić ten kod, a następnie nadal korzystać z otwartego środowiska Ruby.

Tcl

foreach x [info commands] {if {$x!="rename"&&$x!="if"} {rename $x ""}}

Spowoduje to usunięcie wszystkich słów kluczowych z języka oprócz ifi rename.

Powyższy kod spowoduje błąd w nowym kodzie. Jest więc dyskusyjne, czy nowy wstawiony kod rzeczywiście zostanie „wykonany”. Poniżej znajduje się wersja, która wykonuje nowy kod, ale nic nie robi, ponieważ zmienia wszystkie słowa kluczowe (oprócz ifi proc) na brak operacji:

foreach x [info commands] {if {$x!="if"&&$x!="proc"} {
    proc $x args {}
}}

Zamiast usuwania słów kluczowych ten kod zastępuje je funkcją, która nic nie robi.

(Uwaga: używam tutaj „słów kluczowych” bardzo luźno, ponieważ Tcl nie ma słów kluczowych, tylko funkcje)

Hoon

=<  ~
(your code)

Hoon jest dziwny. Jest to prawie zupełnie inne niż inne języki programowania, nie tylko w składni, ale w semantyce. Jednak w przeciwieństwie do języków takich jak Hexagony, nie został stworzony specjalnie celowo ezoterycznie.

Hoon kompiluje się do Nock , minimalnej maszyny wirtualnej opartej na kombinatorze. Nock jest głupi: specyfikację można spakować do 340 bajtów. Jedyną operacją matematyczną jest zwiększanie. Wszystko jest rzeczownikiem: atom (bignum) lub komórka (para rzeczowników), z całym modelem pamięci ułożonym w niezmiennym acyklicznym drzewie binarnym. Jedynym wyjściem jest rzeczownik, do którego ogranicza się twoje wyrażenie.

Z powodu dziwnego celu kompilacji, Hoon jest również dziwny: jest całkowicie czysty. Hoon kompiluje się do wyrażenia Nocka, które jest oceniane w „kontekście”. Całe jądro i stdlib wraz ze wszystkimi zmiennymi są pośrednio przekazywane do programu przez kontekst.

Aby uczynić Hoon bezużytecznym, używamy po prostu =<„oceny a w kontekście b”. Zawsze oceniamy ~, co wynosi zero. Bez względu na to b, co robi, nie może zmienić wartości, do której redukuje, a ponieważ nie może mieć skutków ubocznych, nie może wprowadzać ani wyprowadzać danych.

Uwaga dodatkowa: Ponieważ tak naprawdę nie możesz poprosić o dane wejściowe od Hoon (czystość!), Zgodnie z regułami nie jest to tak naprawdę język programowania. Wejście odbywa się za pomocą argumentów funkcji, wyjście poprzez wartości zwracane (lub ~&, co jest bardziej funkcją debugowania printf i jest przezroczyste dla programu).

Aby program mógł uzyskać dane wejściowe w Urbit, tak naprawdę piszesz program, który zwraca funkcję, która akceptuje dane wejściowe, a powłoka pyta w twoim imieniu i przekazuje oddzwonienie.

Taxi, 2354 bajty.

Ten mały program po prostu jeździ taksówką w wielkiej jeździe przez Townsburg, zabrakło mu gazu. Każdy kod, który uruchomisz po tym, szybko spowoduje błąd error: out of gas. I nawet gdybyś mógł dotrzeć do stacji benzynowej, co nie wydaje mi się możliwe, nie możesz dostać żadnego gazu, ponieważ nie zebrano żadnych pieniędzy, ponieważ nie ma pasażerów.

Go to Trunkers: west, 1st right, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st left, 1st left, 1st right.

JavaScript w przeglądarce

Cóż, przynajmniej w IE11.

window.addEventListener("error", function(){});
document = document.write = alert = prompt = confirm = console = void(
    (function (window) {
        try {
            //Code goes here
        } catch (e) {}
    })({})
);

Wyłącza pisanie do dokumentu, pisanie do zmiennej globalnej i powrót z funkcji.

Skomentuj, jeśli przegapiłem metodę wyjściową!

Python 2, niesamowicie duży

import rexec, ihooks, types, os, struct,sys,imp
from functools import update_wrapper as do_update, wraps
__all__ = ["RExec","enable"]
trashed = False
from ctypes import pythonapi, POINTER, py_object
getdict = pythonapi._PyObject_GetDictPtr
getdict.restype = POINTER(py_object)
getdict.argtypes = [py_object]
modified = ctypes.pythonapi.PyType_Modified
modified.argtypes = [ctypes.py_object]
def dictionary_of(ob):
    dptr = getdict(ob)
    if dptr and dptr.contents:
        return dptr.contents.value
RESTRICTED = "NOT AVAILABLE"
class RExec(rexec.RExec):
    ok_sys_names = rexec.RExec.ok_sys_names + ("warnoptions","py3kwarning","flags")
    nok_sys_strings = ("executable",)
    ok_builtin_modules = rexec.RExec.ok_builtin_modules + ("cStringIO","exceptions","_collections","itertools","_hashlib","_codecs","_functools","_struct")
    def __init__(self, hooks = None, verbose = 0):
        ihooks._Verbose.__init__(self, verbose)
        self.hooks = hooks or rexec.RHooks(verbose)
        self.hooks.set_rexec(self)
        self.modules = {}
        self.ok_dynamic_modules = self.ok_builtin_modules
        list = []
        for mname in self.ok_builtin_modules:
            if mname in sys.builtin_module_names:
                list.append(mname)
        self.ok_builtin_modules = tuple(list)
        self.set_trusted_path()
        self.make_builtin()
        self.make_initial_modules()
        self.make_sys()
        self.loader = rexec.RModuleLoader(self.hooks, verbose)
        self.importer = rexec.RModuleImporter(self.loader, verbose)
        self.make_StringIO()
    def make_sys(self):
        old_rexec.make_sys(self)
        sys_ = self.modules["sys"]
        for name in dir(sys):
            obj = getattr(sys,name)
            if "__" not in name and type(obj) == str and \
              not hasattr(sys_,name):
                if name in self.nok_sys_strings:
                    obj = RESTRICTED
                setattr(sys_,name,obj)
        sys_.argv = [RESTRICTED]
    def make_initial_modules(self):
        old_rexec.make_initial_modules(self)
        self.copy_except(types,["__builtins__"])
        self.copy_except(os.path,["__builtins__"])
        b = self.modules["__builtin__"]
        for module in self.modules.itervalues():
            module.__builtins__ = b
    def make_StringIO(self):
        t = type(self.r_open)
        if t == types.ClassType or t == type:
            return
        elif t != types.FunctionType and t != types.MethodType:
            raise RuntimeError
        io = self.r_import("StringIO").StringIO
        old_open = self.r_open
        class r_open(io):
            def __init__(self,*openargs):
                o = old_open(*openargs)
                if o.isatty():raise IOError
                io.__init__(self,o.read())
            def __enter__(self):
                return self
            def __exit__(self,type,val,tb):
                self.close()
            for name in "truncate write flush".split():
                exec "def %s(self,arg=None):raise IOError('File not open for writing')" % name
            del name
        ntypes = self.modules["types"]
        b = self.modules["__builtin__"]
        ntypes.FileType = self.r_open = b.open = b.file = r_open
    def r_import(self,name,globals={},locals={},fromlist=[],level=-1):
        redone = name in self.modules
        found = False
        try:
            result = self.importer.import_module(name, globals, locals, fromlist,level)
        except ImportError:
            if name == "imp":
                result = imp.new_module("imp")
                self.modules["imp"]=result
                found = True
            if not found:raise
        if redone:pass #Only do this once
        elif name == "sysconfig":
            result._PROJECT_BASE = "x"
            result._CONFIG_VARS = {}
        elif name == "functools":
            update = result.update_wrapper
            def update_wrapper(wrapper,wrapped,assigned=(),updated=()):
                return update(wrapper,wrapped,assigned,updated)
            do_update(update_wrapper,update)
            result.update_wrapper = update_wrapper
            def wraps(wrapped,*args,**kw):
                return result.partial(update_wrapper,wrapped=wrapped,*args,**kw)
            do_update(wraps,result.wraps)
            result.wraps = wraps
        return result
    def s_apply(self,func,args=(),kw=None):
        kw = kw or {}
        if getattr(func,"__stdin_trashing",False):
            kw["s_applied"] = True
        return old_rexec.s_apply(self,func,args,kw)
    r_exc_info = staticmethod(sys.exc_info)
    def r_method(name):
        l = {}
        exec \
"""def %s(self,*args,**kwargs):
    s_applied = kwargs.pop("s_applied",False)
    if kwargs:raise TypeError
    if not s_applied:
        self.save_files()
        sys.stdin = sys.stdout = sys.stderr = None
    global restrictedly
    restrictedly = True
    try:
        return old_rexec.%s(self,*args)
    finally:
        restrictedly = False
        if not s_applied:
            self.restore_files()
setattr(%s,"__stdin_trashing",True)""" % (name,name,name) in globals(),l
        return l[name]
    r_exec = r_method("r_exec")
    r_eval = r_method("r_eval")
    del r_method
old_rexec = rexec.RExec
class ModuleImporter(ihooks.ModuleImporter):
    def determine_parent(self, globals, level=-1):
        if not globals or not level:return None
        pkgname = globals.get('__package__')
        if pkgname is not None:
            if not pkgname and level > 0:raise ValueError, 'Attempted relative import in non-package'
        else:
            modname = globals.get('__name__')
            if modname is None:return None
            if "__path__" in globals:pkgname = modname
            else:
                # normal module, work out package name if any
                if '.' not in modname:
                    if level > 0:raise ValueError, ('Attempted relative import in non-package')
                    globals['__package__'] = None
                    return None
                pkgname = modname.rpartition('.')[0]
            globals['__package__'] = pkgname
        if level > 0:
            dot = len(pkgname)
            for x in range(level, 1, -1):
                try:
                    dot = pkgname.rindex('.', 0, dot)
                except ValueError:raise ValueError('attempted relative import beyond top-level package')
            pkgname = pkgname[:dot]
        try:
            return self.modules[pkgname]
        except KeyError:
            if level < 1:
                warn("Parent module '%s' not found while handling "
                     "absolute import" % pkgname, RuntimeWarning, 1)
                return None
            else:raise SystemError, ("Parent module '%s' not loaded, cannot perform relative import" % pkgname)
restrictedly = False
def enable():
    rexec.RExec = RExec
    rexec.RModuleImporter = ModuleImporter
    global trashed
    if not trashed:
        subclasses = type.__subclasses__
        error = None
        def restrict(fun):
            error_ = error
            def censored(*args):
                global restrictedly
                if restrictedly:
                    if error_ is not None:
                        return error_
                    raise RuntimeError
                return fun(*args)
            return censored
        error = ()
        dictionary_of(type)["__subclasses__"]=restrict(subclasses)
        error = None
        modified(type)
        #Stop uses of frames (created using with statements)
        old_frame = types.TracebackType.tb_frame
        @property
        @restrict
        def new_frame(self):
            return old_frame.__get__(self,types.TracebackType)
        @new_frame.setter
        def new_frame(self,v):
            raise TypeError("Readonly attribute")
        dictionary_of(types.TracebackType)["tb_frame"] = new_frame
        modified(types.TracebackType)
        trashed = True
def test():
    enable()
    r = RExec()
    try:
         r.r_exec(
                """Your code goes here!"""
             )
    finally:
        return 0
if __name__ == "__main__":
    enable()
    test()
    sys.exit()

Ta niesamowicie duża ilość kodu jest odrodzeniem starożytnego rexecmodułu (porzuconego w Pythonie 2.3) z kilkoma nowymi modułami dodanymi do listy „ok” i naprawionymi wadami (w tym object.__subclasses__()metodą, która stworzyła co najmniej dwa inne pytony nieprawidłowe odpowiedzi).

Spora część tego kodu ( __init__metoda RExecklasy i całej ModuleImporterklasy) jest kopiowana ze standardowej biblioteki Pythona z niewielkimi modyfikacjami.