Kendi dilinizde bazı kodlar yazmaya çalışın ve bir programlama dili olma ölçütümüzü artık karşılamamasını sağlayın .

Bir dil, eğer bir programlama dili olma kriterlerimizi (bu zorluk için basitleştirilmiş versiyon) yerine getirir:

• Pozitif tamsayı tekillerini temsil eden kullanıcı girdisini bir şekilde okuyabilir.
• Girdiye bağlı olarak en az iki farklı sonuç verebilir.
• İki pozitif tamsayı alabilir ve bunları ekleyebilir (ve sonuç çıktıyı etkileyebilir).
• Olumlu bir tamsayı alabilir ve bunun birinci sınıf olup olmadığına karar verebilir (ve sonuç çıktıyı etkileyebilir).
• Bu zorluğun amacı için, normal bir zorlama için izin verilen bir çıktı yöntemi olmayan her türlü çıktı göz ardı edilir. Bu nedenle, programın bir parça müzik de çalabileceği ya da HTTP vb. Yoluyla yayınlayabileceği önemli değil.
• Güncelleme: İzin verilen çıktı yöntemlerinden birini veya bazılarını seçebilir ve diğerlerini göz ardı edebilirsiniz. Fakat aynı tanımı her yerde aşağıdaki kriterlerde kullanmalısınız. Ve eğer programınız birden fazla çıktı yöntemini devre dışı bırakabilirse - bu daha fazla yükseltme gerektirir.

Çıktı yapamama veya tüm döngü yapılarını devre dışı bırakma gibi örnekler, böylece primalite testi yapamaz ve kullanıcının bunları tekrar etkinleştiremeyeceğinden emin olmaz.

Yeni kod eklemek için bir yer bırakmalısınız. Varsayılan olarak, kodunuzun sonunda. Kaynak kodu cevabınızdaki o yere koyup tam kodu eksiksiz bir program olarak çalıştırmayı düşünürsek , bu dilin ölçütleri karşılamaması gerekir.

Ancak eklenen kod , kriterleri karşılayan bir dil gibi yürütülmelidir :

• Girilen kod , sözdizimi vurgulayıcı yazmak isteyenler açısından, genel olarak kriterleri karşılayan bir şeyle aynı olmalıdır ( aşağıdaki kriterlerde bir kod bloğudur ). Bu yüzden bir dize, yorum, vb olamaz.
• Girilen kod, kriterleri yerine getirmesi gerektiği şekilde gerçekleştirilmelidir. Bu yüzden kullanılmayan bir fonksiyonda veya sizeofC'de olamaz, kodda sadece işlevsel olmayan bir parçayı çalıştıramazsınız ve sonsuz bir döngüden sonra koyamazsınız, vb.
• Bu yolla oluşturulan olası gramersel olarak doğru programların sayısını sınırlandıramazsınız. Kullanmakta olduğunuz dilde zaten bir uzunluk sınırı gibi bir şey varsa, bu sınır kaldırılsa bile ölçütleri karşılamamalıdır.
• Giriş / çıkış içeriğini değiştiremez veya "kullanamazsınız", ancak bunlara erişilmesini engelleyebilirsiniz.
• Bu ölçütler genellikle yalnızca açık G / Ç olmayan diller için geçerlidir:
  • Eğer bir kod bloğu genellikle kullandığınız dilde doğrudan / açıkça kullanıcı girişi yapamıyorsa, kodunuz kullanıcı kodunu (rastgele uzunluk bilgisi içeren) eklenen koda yönlendirmelidir.
  • Bir kod bloğu genellikle kullandığınız dilde doğrudan / açıkça çıktı veremiyorsa, kodunuz eklenen kodun döndürülen değerini yazdırmalıdır.
  • Döndürülen değeri yazdırmanız ve kullandığınız dilde yazmanız durumunda, döndürülen türün pratikte 2 farklı olası değeri olması gerekir. Örneğin, türü struct {}veya struct {private:int x;}C ++ kullanamazsınız .

Bu popülerlik yarışması. En yüksek oy alan geçerli cevap (yani kimse hata görmedi ya da tüm hatalar düzeltildi) kazandı.

Açıklamalar

• Kodu metin biçiminde değiştirmemelisiniz, ancak kod yorumlanmadan veya derlenmeden önce sözdizimini değiştirebilirsiniz.
• Kod çalışırken başka şeyler de yapabilirsiniz. Ancak kriterleri karşılamamasının nedeni eklenen kodun kendisinde olmalıdır. Başka bir dişlinin paraziti nedeniyle hata yapabilir, ancak sadece başka bir iplik tarafından öldürülmez.
• Tüm özellikler temel olarak , eğer tüm yerleşik parçalar değişmediyse ve gerçekte yapılmadıysa, kriterleri yerine getirme ihtimalinin yüksek olması gerektiği anlamına gelir . Parametreleri doğru bir şekilde kod bloğuna geçirmek gibi dilbilgisi olmayan herhangi bir geçici çözüm bulursanız sorun değil, ancak bir şekilde kullanılamamasını sağlayın.
• Yine, eklenen kodun gerçekten çalıştırılması gerekir. Sonsuz bir döngü veya çökmeden sonra kod "aslında yürütülmedi" olarak kabul edilir, bu nedenle geçerli değildir . Bu cevaplar ilginç olabilir, ancak zaten bu sitede başka bir sınırsız döngü ya da soru sorulması var ve cevaplamak için daha uygun bir cevap bulabilirsiniz. Değilse, yeni bir soru sormayı düşünün. Bu soruların örnekleri:
  • Çıktı üretmeyen en kısa sonsuz döngü
  • Neden bitmiyor?
  • 'Döngü' olmadan döngü
  • Mücadelesi: Kendiliğinden çıkan bir kod parçası yaz
  • Saçma Çalışma Zamanı Hataları
  • En sevdiğiniz derleyiciyi kilitleyin

Liderler Sıralaması

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 Kabuğu

Bu, dili tamamen kullanılamaz hale getirecek .

clear(this);

JavaScript'in kendisini yok etmek için ne kadar hoş bir işlevi olduğu iyi değil mi?

Bu oldukça basittir, clearişlev bir nesneyi tamamen boşaltır. yapıcılar ve işlevler dahil her şeyithis temizleyen küresel nesneyi ifade eder .

Çünkü bu her şeyi temizler , herhangi bir şey yapmak , hatta bir değişmez tanımlamak bile bir hataya yol _açar , dili tamamen işe yaramaz hale getirir: _{* REPL ortamı gerekli değildir . Orijinal JS motoru olan SpiderMonkey motorunu (kabuk tarayıcı değil) kullanır .}

Emmental

;#33!

Bunun kod golf olmadığını biliyorum, ama iş için doğru araç, bilirsin ...

Kullanıcının kodu, ardından girilebilir !.

Emmental, tercümanı yeniden yazmaya dayanan ilginç bir esolang'dır . Her bir simge (yerleşik olanlar dahil), isteğe bağlı bir Emmental program olarak yeniden tanımlanabilir. Dil, bu özelliğe o kadar güveniyor ki, hiçbir döngü yapısı sağlamıyor. Bunun yerine, kendi tanımlarında görünen özyinelemeli komutları tanımlarsınız.

Bu yeniden tanımlama !, yığıntan bir karakter okuyan ve ardından bir ile karşılaşıncaya kadar yığından bir dize okuyan aracılığıyla gerçekleşir ;. Karakter, daha sonra bu dizeyle temsil edilen programı ifade etmek için yeniden tanımlanır.

Yani, biz yeniden tanımlayarak emmental en döngü özellikleri devre dışı bırakabilirsiniz anlamına gelir ! kendisini boş program olarak. Diğer tüm Emmental kodları hala mükemmel şekilde çalışsa da, bir programlama dilinin kriterlerinin çoğu hala yerine getirilse de, daha fazla sembol tanımlamak mümkün değildir. Bu özellik olmadan (ve bu nedenle döngü yapamadan), Emmental artık bir sayının asal olup olmadığını test edemez.

PHP

Biri hafıza sınırını 1'e ayarlayarak PHP'yi tamamen öldürebilir.

Tamamen ölecek.

Bunu dene:

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

    //code here

Bunun için hiçbir hatayı bile atmamalı, çünkü bunun için yeterli bellek yok.

Direktif hakkında daha fazla bilgi edinebilirsinizmemory_limit

Birincisi geçersizse, biri çıktı arabelleklerini kullanabilir:

<?php
    ob_start();

    //code here

    ob_clear();

Bu herhangi bir çıktıyı tamamen kaldırır. Çıkış arabelleği hala açık olduğundan, koddan sonra yanlışlıkla bırakılan diğer şeyler de gösterilmez.

@Fschmengler fikrini kullanmak :

<?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();

Bu, sıkıştırılacak çıktıyı yakalamak için kullanılan otomatik olarak başlatılan çıktı tamponunu silme sorununu önleyecektir.

Bu ayrıca çıktı tamponunun silinmesini veya temizlenmesini (tarayıcıya gönderilmesini) önler. Bunu tekrar anlamak için, her zaman boş bir dize döndüren bir çıktı işleyicisi eklenir.
Koşmak ob_end_flush(); echo "Hello, world!";hiçbir şey üretmeyecek, ancak çıktıyı düz bir şekilde gönderecektir ob_start();.

@LucasTrzesniewski'ye , bu sorunu açıkladığı için teşekkür ederiz !

Gerçek modda x86 makine kodu (=> hemen hemen her DOS programı)

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

yani

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

Umarım kesme masanıza fazla bağlı değildiniz.

Java

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
    }
}

Düzenleme: Karşı önlemler bu devi yapıyor :(

Stdin ve stdout öğelerini null akışlarına yönlendirir ve argsları boş bir diziyle değiştirir. Ayrıca, standart IO'nun gerçekten gizlendiğinden emin olmak için muazzam miktarda yansıma kesmesi kullanır. Son olarak, standart IO'nun yeniden oluşturulamayacağından ve programların çıkış kodunu ayarlayamayacağından emin olmak için bir güvenlik yöneticisi ayarlar.

Lua

_ENV=""

Lua'da, _ENVtüm global değişkenlerin, fonksiyonların, tabloların vb. Depolandığı ortamdır. Onu boş bir dize olarak tanımlamak, yeni bir şey tanımlayamayacağınız ve tüm fonksiyon ve değişkenlerin silineceği anlamına gelir. Bu, hiçbir şey çıkarıp giremediğiniz, giriş yapamayacağınız veya hemen hemen hiçbir şey yapamayacağınız anlamına gelir.

Shakespeare Programlama Dili

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]

SPL'de, programla indirilen yerleşik çözümleyici, komut dosyasında neler olabileceğine dair çok özel kurallar izler. Bu kurallardan biri, bir kerede yalnızca iki karakterin sahnede olabileceğidir. Ayrıca, hiçbir zaman sahnede olmayan sahneden bir karakter çıkması onun kafasını karıştırır. Aynı şey, zaten sahnede olan sahneye bir karakter eklemek için de geçerli. Çözümleyici bir hata aldığında, başka bir şey yapmayı reddeder; kelimenin tam anlamıyla programı ve ayrıştırıcıyı tamamen kapatmanız ve ardından her şeyi yeniden başlatmanız gerekir.

PS Bu dilin nasıl çalıştığı hakkında hiçbir fikriniz yoksa, Google. Bu harika.

Smalltalk

Bunun uygun olup olmadığından emin değilim:

Smalltalk := Nil.

Bu, nesne motorunu asarak çalışma zamanı ortamının tamamını siler. Bunu düzeltmenin tek yolu zorla işlemi sonlandırmak ve yedeklemeden yeniden başlatmaktır.

Bilmeyenler için, [Visual Works] Smalltalk'ın çalışma şekli biraz tuhaf. Mini işletim sistemi gibi. Smalltalk'ı başlattığınızda, RAM'e bir "hafıza görüntüsü" yüklersiniz ve kaldığı yerden çalışmaya devam eder. Smalltalk IDE'nin tamamı Smalltalk dilinde yazılmıştır ve dinamik olarak değiştirilebilir.

Özellikle, Smalltalktüm global değişkenleri içeren bir sözlüktür. En önemlisi, yeni bir sınıf ilan ettiğinizde Class, yeni sınıfınızın nesnesine işaret eden, bu isimde bir global değişken yaratılır . Yani ayar Smalltalkiçin Nil(temelde null) Bütün sistemde tüm sınıfları siler. GUI olay işleyicileri bile bozuluyor.

Bu değişkenin neden yazılabilir olduğu konusunda hiçbir fikrim yok. Muhtemelen küresel bir değişken olduğundan ve bu nedenle kendi içinde bir girdi olarak var olduğundan. (Başın henüz ağrıyor mu? Her nesnenin bir sınıfı olduğunu ve sınıfların nesneler olduğunu, bu yüzden her sınıfın bir sınıfı olduğunu söylemiş miydim? Bir sınıf...)

Muhtemelen benzer bir etkiyi , null ile değiştirmek yerine sözlüğü temizleyerek de elde edebilirsiniz . Aslında, sistemdeki tüm sınıfları silmek için kodlayabileceğiniz birçok şey var ve sizi hiçbir şey yapamıyor. Ama asıl Smalltalk derleyicisi de bir sınıf olduğu için ... dili bozan herhangi bir şey aynı zamanda tüm IDE'yi de bozuyor, yani ...

Haskell

Burada birkaç olasılık var.

Sıkıcı fikir # 1: mainHiçbir şey yapmamak için tanımlayın . Şimdi hangi kodu yazdığınız önemli değil, hiçbir zaman çalıştırılamıyor. (El ile REPL'den çalıştırmazsanız.)

Sondaj fikri # 2: Kamuya ihracatı olmayan bir modül tanımlayın. Şimdi yazdığınız kodun ne olduğu önemli değil, asla yürütülemez.

İlginç fikir: Tüm ithalatı devre dışı bırakın.

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

Şimdi fonksiyonlar tespit vardır görünür ve olabilir çalıştırılabilir ... ama bir şey yapamaz. Tüm standart Haskell tipleri ve fonksiyonları artık gizlenmiştir. (Birkaç şey dışında , dilin içine gerçekten çok sıkı bağlanmış.)

En önemlisi, herhangi bir G / Ç gerçekleştiremezsiniz. Ayrıca makine hassas aritmetiği de yapamazsınız. (Yana Int, Doublevb şimdi tanımsız.)

Sen edebilirsiniz rağmen hala bazı gerçek hesaplama gerçekleştirmek do lambda-hesap işlevlerini yazın. Sadece hiçbir şeyin içine giremez veya çıkamazsınız. Ancak elbette Fubaryukarıdaki modülü çağıran ve adına G / Ç yapan başka, ayrı bir modül yazabilirsiniz (böylece kodun çalıştığını ve bir şeyler yaptığını kanıtlarsınız).

Bazı incelikler:

• Sahte foo = foobildirim, herhangi bir kimsenin ek ithalat eklemesini önlemek için gereklidir. (İthalat, bildirimlerden sonra görünemez .)

• Bu durumdan çıkmanızı sağlayacak standart dışı çeşitli Haskell dil uzantıları vardır. Ancak, dil uzantılarının dosyanın üstündeki derleyici pragma ile açılması gerekir . (Veya derleyiciye bir komut satırı düğmesiyle. Bunu gerçekten engelleyemiyorum!)

PostScript

Evet, PostScript bir programlama dilidir. Dahası, tüm dil yapılarının sistem tarafından tanımlanmış fonksiyonlar olduğu ve yeniden tanımlanabilen bir programlama dilidir ...

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

İngilizcede:

• Boş bir 1000 elemanlı sözlük oluşturun ve adlandırın Magic.
• Girilen her anahtar için boş bir tanımla (" ") systemdictaynı anahtarı ekleyin .Magic{}
• MagicSözlük yığınının üstüne itin .

Bu andan itibaren, her PostScript dili komutu hiçbir şey yapmamak için tanımlanmıştır. AFAIK, bu durumdan kaçmak mümkün değil .

(Teknik olarak, eski tanımları "yok etmiyorsunuz", sadece onları gölgeliyorsunuz. Hâlâ enduygulayabiliyorsanız, bu Magicsözlük yığınını ortaya çıkarır, tüm komutları kaldırır ve hayatınızı geri verir. endkendisi de gölgelidir ... şimdi hiçbir şey yapmaz.)

Tüm komutlar hala unutmayın yürütmek ... sadece şimdi onlar hiçbir şey yapmak tanımlanır ediyor. Herhangi bir hata almazsınız, sadece hiçbir şey olmayacak. (Eh, sanırım sonunda yığın taşması olacak ...)

Linux / x86 (-64) altında çalışan herhangi bir program

Bu program C ile yazılmıştır , ancak Linux / x86 (-32 veya -64) altında çalışan herhangi bir programın çalışmasını engelleyebilir. Bozmak istediğiniz programın komut satırı çağrısına hazırlarsınız.

Hedef programın herhangi bir çıktı üretmesini önlemek için hata ayıklayıcı API'sini kullanır. Özellikle, (çoğu belli ki süreçte dış dünyaya şey iletişim kurabilir sistem çağrıları her writeelbette, ama aynı zamanda openbir dosya, soket API toplu oluştururken, killbaşka bir işlem uygulandığında, ...) başarısız olur uygulanmamışlarmış gibi. _exitizin verilir, ancak çıkış kodunun üzerine sıfır yazılır.

Bu cevabın önceki baskısından farklı olarak, birçok program bu koşullar altında neredeyse tamamlanmaya çalışabilir; Sadece bütün işlerini boşa harcıyor. Örneğin, ./no-syscalls /bin/ls(GNU coreutils varsayarak ls) varsa, tüm dizini okur ve biçimlendirir ve ardından writeçıktı üretmek için tüm çağrılar başarısız olur. (Tüm X11 müşterileri gibi, iki yönlü bir iletişim kanalı açması gereken herhangi bir şey, bu noktada başarısız olur. Buna izin vermeyi düşünmüştüm , ancak socketdeğil send, ancak boşlukları açma olasılığı çok düşük görünüyordu.)

Davranışı düzeltmek için birkaç komut satırı seçeneği vardır;

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

Dinamik olarak bağlanmış programlar -emoddaki dinamik linkerden bile çıkamayacak . -SAçıkçası, politikada büyük bir delik açıyor, ancak programların işe yaramayacağı konusunda inilti izlemesini eğlendirmek eğlenceli olabilir.

$ ./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

Günlük çıktısını /usr/include/asm*/unistd.hbaşka bir pencerede aç ile okumak zorundasınız , çünkü bu zaten yeterince uzun.

Ne yazık ki, bu hata ayıklayıcının kullandığı arabirimler yalnızca Unix uygulamaları arasında çok az tutarlı ve içsel olarak CPU'ya özgü. Başka CPU mimarilerine (sadece uygun tanımları ekleyiniz SYSCALL_*_REG) taşımak oldukça kolay olacaktır ve muhtemelen sahip olduğu herhangi bir Unix'e yerleştirmek mümkündürptrace , ancak farklılıklar ile başa çıkmanın yanı sıra kapsamlı bir şekilde syscall beyaz listesiyle uğraşmanız gerekebilir. içinde 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

Bunun gerçekten işe yarayacağından emin değilim, ama teoride bu, \onu düzeltmenin bir yolu bırakmadan kaçış karakteri olarak kırılmalıdır . Normalde TeX dosyaları okuyabilir ve yazabilir, şimdi mantığa bağlı hiçbir şey yazamaz. Böylece dil artık OP tarafından tanımlandığı şekilde bozuldu.

EDIT: Yorumlardan alınan diğer öldürme komutları (her ikisi de yapılması gereken kod kuralını ihlal etse de):

• \def\fi{}\iffalsetarafından smple dalı eğer bir un kapatılabilir yaratır
• \catcode13=9%Yazan iwillnotexist idonotexist tarafından hiç bitmeyen bir yorum

Çizik

when [timer v] > (0)Eğer editörü iseniz bile kodu başlamadan önce hangi kısa sürede kodu ayarlandı olarak çalışacaktır. when I receive (join[][])Bir hata Flash'ın Geliştirici sürümü varsa kod yürütülmesine duraklatma, yayın her zaman bir şey atılmasına neden olur. breakFonksiyon klonlar oluşturmak ve yayın hatası tetikleyecektir. Her bir klon iki saniye sürecek, sonra kendini silecek ve istifin üzerine baskı yapacak. Ve her klon alt rutini when [timer v] > (0)çalıştırarak breakve zamanlayıcı kodunun tekrar çalıştırılmasına neden olan zamanlayıcıyı sıfırlayarak cevap verecektir . Ayrıca, her bir klon, her yayın hatasını da cevaplayacaktır, yani değerlendirme başına yapılan hataların sayısı breakkare sayılan klonların sayısıdır. breakİşlevin olduğunu söylemeyi unuttumrun without screen refresheditörün donmasına, sarsılmasına ve gecikmesine ve ayrıca kapma ve hafıza ayırmalarına neden oldu. Ve CPU'yu maksimuma çıkarmak.

Bu çalıştırma ile herhangi bir yere eklenen herhangi bir kod, kendisini çalıştıran bilgisayarı ısıtıp çökertmenin yanı sıra klonlar (300 klon sınırı aşılmış) oluşturamadığını görecektir. Ve kapacak başka bir şey kalmayıncaya kadar hafızayı kapmak, değişkenlerin yanlış çalışmasını sağlamak.

Ve, when [timer v] > (0)bloğu tetiklemek için çok fazla gecikmeden sonra , hala çalışıyor olacak break.

@Towerofnix'e when I receivebir süre önce bulduğum aksaklığı hatırlattığı ve bana fikir verdiği için teşekkür ederim run without screen refresh. Bunu beğendiyseniz, işte orijinal: https://codegolf.stackexchange.com/a/61357/43394

Mathematica / Wolfram Dili

Mathematica, komut adlarının programcı tarafından manipüle edilebilecek semboller olduğu yorumlanmış bir dildir. Dahili operatörleri silemezsiniz, ancak bunları aşırı yükleyebilir veya fonksiyonlarını başka bir şekilde değiştirebilirsiniz. Aşağıdaki değişkenler içinde bile dahili olarak atamak için gerekli olan "With" komutunu karıştırır. Bu değişiklik, çekirdeğin, atama tamamlanıncaya kadar bağımsız olarak argümanları tutmasını engeller ve dili tamamen ölü bir şekilde öldürür.

ClearAttributes["With", HoldAll]

Bu komut etkileşimli bir oturumda veya bir kod bloğunda çalıştırılırsa, Mathematica ekleyemez 1+1(sonuçta oluşan hata mesajı bir sayfa kadardır, bu yüzden buraya eklemeyeceğim).

PHP

Ben aslında işe yaradığını sürpriz ama kapatıyorum STDOUTve STDERRtüm çıktıyı bastırır. Tekrar açılmayacaklarından emin olmak /dev/nulliçin, dosya tanımlayıcıları 0, 1 ve 2'yi yeniden atamak için üç kez açıyoruz :

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

// insert program here

Daha fazlası için: https://stackoverflow.com/questions/937627/how-to-redirect-stdout-to-a-file-in-php

DOS toplu iş öncesi (Windows 95 öncesi inanıyorum)

CTTY

Argüman olmadan verilen, komut satırını terminalden ayırır. Girdi okuma veya çıktı üretme girişimleri hiçbir şey yapmaz.

CTTY'nin nasıl doğru kullanıldığını bilmek istemeniz durumunda:

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

Biraz daha güçlü bir toplu iş dosyası modeme cevap verebilir ve aranan her şeyi CTTY'ye bağlayabilir.

Ortak Lisp

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

Umarım açılış parantezlerine ihtiyacınız yoktu.

Bu, Lisp Reader'a (bir çağrının her örneğini (lambda (x y) ())iki argüman alan ve hiçbir şey döndürmeyen bir işlevle değiştirmesini söyleyen bir okuyucu makrosudur . Yani, örneğin, bu okurdu (foo)olarak foo), yorumlamak foobir değişken olarak ve daha sonra üzerinde eşsiz bir parantez hatası atmak 0.

Çizik

İşte tarayıcınızı çökertecek oldukça basit bir örnek (ve teoride bilgisayarınızı):

Bu çalışmayı yaklaşık yirmi saniye bıraktım, sonra Scratch'a 2,65 GB hafıza kaybettim. Sadece bir dakika sonra ve 5 GB gitti.

Bunu çalıştırmadan önce Adobe Flash veya web tarayıcınızdan çıkmaya zorlamak için bir yönteminiz olduğunu şiddetle tavsiye ederim!

^{Ben gerçekten böyle serin bir cevap yapmak istedi clear(this)JS biri ama ne yazık ki Çizilmeye bunu yapmak için herhangi yollarını yoktur. Eğer Scratch'ı kullanılamaz hale getirmenin başka bir yolunu bulursanız, bu yazıyı güncellemekten çekinmeyin (veya kendinizinkini yapın)!}

Thue

::=

Sonunda yeni bir satırla

Bu dil, kural setlerini tanımlamaya dayanır ::=ve kural setinin sonunu gösterir. Bunu yapmak için kurallar tanımlamaksızın SADECE BİR ŞEY yapmak imkansızdır , bundan sonra ne koyduğunuza bakmaksızın ::=hiçbir şey olamaz.

Alternatif cevap

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

(ve benzeri Aolmayan ve yazdırılamayan karakterlerden önce olanlar dahil, tüm Unicode'daki her karakter için ). Bu komut satırı seçeneğini gerektirir -r.

MATLAB

Aşağıdaki kod parçası, ortamı tamamen kullanılamaz hale getirir ¹ :

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

Bu, builtinişlevi ve bu clearişlevleri falseher denediğinizde ve çağırdığınızda basitçe döndüren yeni adsız işlev tutamaçlarıyla işlevi geçersiz kılar . builtinFonksiyonu, kazandaki yerleşik olduğu MATLAB'a (şeyler gibi aynı adı sen MATLAB'te yazma herhangi bir özel fonksiyonlar varsa sum, max, min, sen aşırı fonksiyonları yerine açık bir şekilde bu çağrı edebiliyoruz, vs.) . Benzer şekilde, clearşu anda bildirilen tüm değişkenleri temizleme becerisi sunar, böylece yeniden başlayabilirsiniz. Bu yetenekleri kaldırarak, programı yeniden başlatmadığınız sürece MATLAB'ı kullanmanın bir yolu yoktur.

MATLAB R2015a'da ayrıca şu mesajı alıyorum:

Çalışma Alanı, daha sonra bunları kullanabilmeniz için şu anda ortamda bildirilen değişkenlerdir. Bu, Çalışma Alanını kalıcı olarak devre dışı bırakır, böylece denediğiniz ve oluşturduğunuz herhangi bir değişken kaydedilmez ve bu nedenle MATLAB'da kod satırlarını çalıştırırken hiçbir ilerleme kaydedilmez.

^{1: Credit, bu fikri ilk keşfeden kullanıcı Dev-iL'e gider .}

///

/\///

/// tek işlem bu gibi dizge ikame tekrarlanır: /pattern/replacement/.

Bu kod /, her biri kaldırır , bu şekilde tekrarlanan dize değişimini kullanamazsınız, temelde bundan sonra yazdığınız her şey ( /s hariç ) yazdırılacaktır .

Hala \s kullanabilirsiniz , ancak bu size pek yardımcı olmaz.

Befunge-96

'~h

Kullanıcının kodu, bu diziden sonra herhangi bir yerde, bunlar kaynağın ilk üç karakteri olduğu sürece takip edebilir.

'Komut (tek seferlik dize modu) ASCII değerini iter ~yığını (yani 126) üzerine ve hkomut sonra olarak bilinen setleri Bütünsel Delta bu değerle. Befunge-96'ya aşina olmayanlar için, Bütünsel Delta , tercümanın karşılaştığı her komut baytının değerine eklenen bir kaymadır .

Delta 126 olarak ayarlandığında, üretilebilecek tek geçerli komut ~, kaynaktaki boş bir bayt aracılığıyla (karakter girişi) 'dir. Boş bir bayttan başka bir şey 126'dan büyük bir değere çevrilir ve bu değerlerin hiçbiri geçerli Befunge komutları olmazdı.

Bunun bir programlama dili olarak nitelendirilmeyi uygun kılmayacağını söylemek güvenli olduğunu düşünüyorum.

Boo

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

Ve sonra, projede başka bir yerde,

harmless

Zararsız bir isim olan basit bir makro, ama inanılmaz derecede sinir bozucu bir etki. Boo derleyicisi, bir AST'ye ayrıştırma kaynağıyla başlayan ve kod oluşturma ile biten çok adımlı bir boru hattı kullanır. (Genellikle. Çeşitli uygulamalar için yeniden yapılandırılabilir.) AST arasındaki her adım, çeşitli işlemleri gerçekleştirir.

Kısmen, makroların derleyici bağlamında yürütüldüğü makro genişleme aşamasıdır. Son paragraftaki bit'i, boru hattının yeniden yapılandırılabilir olmasıyla ilgili hatırlıyor musunuz? Makro genişletme sırasında, boru hattını temizleyen bir makro çağırırsanız, kullanıcıya hiçbir hata gösterilmez, ancak makro genişletmeden sonraki tüm adımlar (kod oluşturma dahil) artık orada değildir. Yani bir şey ile sonuna görünüyor görüntülenen hata mesajlarının - - Başarılı derleme gibi ama nedense üretilen hiçbir ikili var! Makroyu ve çağrıyı iyi gizlerseniz, duvardaki en iyi sorun gidericileri bile sürdürebilirsiniz.

NGN / APL

NGN / APL ilkelleri yeniden tanımlıyor, bu nedenle (yeniden tanımlıyor verir ←kadar) bütün ilkel fonksiyonları ⊢(: Her iki "geçiş" için ⊢3ve 2⊢3verir 3) dili tamamen yararsız hale getirir:

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

Burada dene.

Yakut (29 karakter)

class Object;def send;end;end

'Gönder' olarak Ruby'de bir yöntem çağrıldığında dahili olarak kullanılır ve tüm nesneler Object sınıfından miras alır. Bu, çalışmakta olan herhangi bir yöntemi durdurmalıdır.

Eğlenceli Gerçek: Bu teoride mükemmel ses. Fakat bazı nedenlerden dolayı Ruby dilini engellememek gibi görünüyor. Bu kodu çalıştırmanın neden mümkün olduğunu bilmiyorum ve daha sonra hala açık bir Ruby ortamı kullanıyor.

Tcl

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

Bu hariç dilinden tüm anahtar kelimeleri kaldırır ifve rename.

Yukarıdaki kod herhangi bir yeni kodun hata vermesine neden olur. Bu nedenle, eklenen yeni kodun gerçekten "çalıştırılmasının" yapılması tartışmalı. Aşağıda yeni kod yürüten, ancak hiçbir işlem yapılmayan tüm anahtar sözcükleri ( ifve hariç proc) değiştirdiği için hiçbir şey yapmayan bir sürüm bulunmaktadır :

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

Anahtar kelimeleri silmek yerine, bu kod onları hiçbir şey yapmayan bir işlevle değiştirir.

(Not: Burada "anahtar sözcükleri" çok gevşek kullanıyorum çünkü Tcl'nin anahtar kelimeleri yok, sadece işlevleri var)

kaba herif

=<  ~
(your code)

Hoon gariptir. Tamamen tamamen diğer programlama dillerinden farklı olarak, sadece sözdiziminde değil anlambilimde. Hexagony gibi dillerin aksine, bilerek ezoterik olmadı.

Hoon , minimal bir birleştirici tabanlı VM olan Nock'a derlenir . Nock aptalcadır: Spesifikasyon 340 byte'a çıkarılabilir. Tek matematik işlemi artmaktadır. Her şey bir isimdir: bir atom (bignum) veya bir hücre (isim çifti), tüm bellek modeli değişmez bir asiklik ikili ağaçta düzenlenmiştir. Tek çıktı, ifadenizin indirgeme yaptığı isimdir.

Garip derleme hedefi nedeniyle, Hoon da garip: Tamamen saf. Hoon, "bağlam" üzerinde değerlendirilen bir Nock ifadesine kadar derler. Tüm değişkenler ile birlikte tüm çekirdek ve stdlib, içerik tarafından programa dolaylı olarak iletilir.

Hoon'u kullanılamaz yapmak için sadece =<"b bağlamında değerlendir" olan kullandık . Her zaman ~sıfırdır, değerlendiririz . Ne olursa olsun b, düşürdüğü değeri değiştiremez ve yan etkisi olamayacağı için giriş veya çıkış yapamaz.

Not: Aslında Hoon'dan giriş isteyip istemediğinizden (saflık!), Kurallara göre aslında bir programlama dili değildir. Girdi, işlev argümanları aracılığıyla, geri dönüş değerleri aracılığıyla çıktı (veya ~&daha çok printf hata ayıklama özelliği olan ve program için şeffaf olan).

Bir programın Urbit'te giriş yapması için, aslında girişi kabul eden bir işlev döndüren bir program yazıyorsunuz ve kabuk sizin adınıza sorar ve geri aramaya geçer.

Taksi, 2354 bayt.

Bu küçük program taksiyi Townsburg üzerinden büyük bir neşeyle çalıştırıyor, gaz tükeniyor. Bundan sonra çalıştırdığınız herhangi bir kod hızla hata verir error: out of gas. Ve mümkün olmadığını düşündüğüm bir benzin istasyonuna ulaşabilseniz bile, hiçbir para toplanmadığından, yolcu olmadığı için herhangi bir gaz alamadınız.

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.

Tarayıcıda JavaScript

En azından IE11’de.

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

Belgeye yazmayı, genel değişkene yazmayı ve işlevden geri dönmeyi devre dışı bırakır.

Çıktı yöntemini kaçırdıysam yorum yap!

Python 2, delicesine büyük

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()

Bu delice büyük miktarda kod, eski rexecmodülün (python 2.3'te terk edilmiş) yeniden canlandırılması , "tamam" listesine eklenmiş bir sürü yeni modül ve sabit bir dizi zayıflığın ( object.__subclasses__()en az iki diğer pitonu içeren yöntem dahil) yeniden canlandırılmasıdır. cevaplar geçersiz).

Bu kodun bir kısmı ( sınıfın ve tüm sınıfın __init__metodu ) python standart kütüphanesinden küçük değişikliklerle kopyalanır.RExecModuleImporter