귀하의 언어로 코드를 작성하여 더 이상 프로그래밍 언어라는 기준을 만족시키지 않도록 하십시오.

다음과 같은 경우 언어는 프로그래밍 언어의 기준 (이 문제에 대한 단순화 된 버전)을 충족합니다.

• 어떤 식 으로든 양의 정수 튜플을 나타내는 사용자 입력을 읽을 수 있습니다.
• 입력에 따라 적어도 두 가지 가능한 결과를 출력 할 수 있습니다.
• 두 개의 양의 정수를 가져와 더할 수 있으며 결과는 출력에 영향을 줄 수 있습니다.
• 양의 정수를 취할 수 있고 소수인지 여부를 판별 할 수 있습니다 (결과가 출력에 영향을 줄 수 있음).
• 이 챌린지의 목적 상 , 일반적인 챌린지에 대해 허용 된 출력 방법 이 아닌 모든 종류의 출력 은 무시됩니다. 따라서 프로그램에서 음악을 재생할 수 있는지 또는 HTTP를 통해 게시 할 수 있는지 여부는 중요하지 않습니다.
• 업데이트 : 허용되는 출력 방법 중 하나를 선택하고 다른 모든 방법을 무시할 수도 있습니다. 그러나 다음 기준의 모든 곳에서 동일한 정의를 사용해야합니다. 또한 프로그램에서 둘 이상의 출력 방법을 비활성화 할 수 있다면 더 많은 찬사를받을 가치가 있습니다.

출력을 할 수 없게하거나 모든 루프 구성을 비활성화하는 등의 예는 우선 순위 테스트를 수행 할 수없고 사용자가 다시 사용할 수 없는지 확인합니다.

새 코드를 삽입 할 장소를 남겨 두어야합니다. 기본적으로 코드의 끝에 있습니다. 우리가 고려하는 경우 당신의 대답에 그 자리에 소스 코드를 넣고 완전한 프로그램으로 전체 코드를 실행하는 새로운 언어의 통역을, 그 언어는 기준을 만족해서는 안된다.

그러나 삽입 된 코드는 기준을 만족하는 언어 와 같은 방식으로 실행되어야 합니다.

• 삽입 된 코드는 문법적 으로 형광펜을 작성하려는 사람의 관점에서 일반적으로 기준을 만족 하는 것과 문법적으로 동일해야합니다 (예 : 다음 기준 의 코드 블록 ). 따라서 문자열, 주석 등이 될 수 없습니다.
• 삽입 된 코드는 실제로 기준을 충족시키는 방식으로 실행되어야합니다. 따라서 사용하지 않는 함수 또는 sizeofC에있을 수 없으며 코드에서 기능하지 않은 부분 만 실행할 수 없으며 무한 루프 뒤에 넣을 수 없습니다.
• 이 방법으로 생성 된 문법적으로 올바른 프로그램의 수를 제한 할 수 없습니다. 사용중인 언어의 길이 제한과 같은 것이 이미 있으면이 제한을 제거하더라도 기준을 충족하지 않아야합니다.
• 입력 / 출력의 내용을 수정하거나 "사용"할 수는 없지만 액세스 할 수는 없습니다.
• 이러한 기준은 일반적으로 명시적인 I / O가없는 언어에만 적용됩니다.
  • 코드 블록이 일반적으로 사용중인 언어로 사용자 입력을 직접 / 명시 적으로 얻을 수없는 경우 코드는 사용자 입력 (임의의 길이 정보를 포함하는)을 삽입 된 코드로 리디렉션해야합니다.
  • 코드 블록이 일반적으로 사용중인 언어로 직접 / 명시 적으로 출력 할 수없는 경우 코드는 삽입 된 코드의 반환 값을 인쇄해야합니다.
  • 반환 된 값을 인쇄하고 사용중인 언어로 입력 한 경우 반환 된 유형은 실제로 가능한 두 가지 값을 가질 수 있어야합니다. 예를 들어, 유형을 사용 struct {}하거나 struct {private:int x;}C ++에서 사용할 수 없습니다 .

이것은 인기 콘테스트입니다. 가장 높은 투표 유효 답변 (아무도 오류를 발견하지 않았거나 모든 오류가 수정되었습니다)가 이깁니다.

설명

• 텍스트 형식으로 코드를 수정해서는 안되지만 코드를 해석하거나 컴파일하기 전에 구문을 변경할 수 있습니다.
• 코드가 실행되는 동안 다른 작업을 수행 할 수 있습니다. 그러나 기준을 충족시키지 못하는 이유는 삽입 된 코드 자체 내에 있어야합니다. 다른 스레드의 간섭으로 인해 오류가 발생할 수 있지만 다른 스레드에 의해 종료되지는 않습니다.
• 모든 사양은 기본적으로 모든 내장 기능이 변경 되지 않았지만 실제로 변경 되지 않은 경우 문법적으로 기준을 충족 해야 함을 의미합니다 . 매개 변수를 코드 블록에 올바르게 전달하는 것과 같은 문법 이외의 해결 방법을 찾으면 어떤 식 으로든 사용할 수 없게 만드는 것이 좋습니다.
• 다시 삽입 된 코드는 실제로 실행되어야합니다. 무한 루프 또는 충돌 후 코드 는 "실제로 실행되지 않음"으로 간주되므로 유효하지 않습니다 . 이 답변은 흥미로울 수 있지만이 사이트에는 이미 다른 무한 루프 또는 충돌하는 질문이 있으며 더 적합한 답변을 찾을 수 있습니다. 그렇지 않은 경우 새로운 질문을 고려하십시오. 이러한 질문의 예는 다음과 같습니다.
  • 출력이없는 최단 무한 루프
  • 왜 끝나지 않습니까?
  • '루핑'없는 루프
  • 도전 과제 : 자체적으로 종료되는 코드 작성
  • 말도 안되는 런타임 오류
  • 좋아하는 컴파일러 충돌

리더 보드

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>

자바 스크립트 쉘

언어를 완전히 사용할 수 없게됩니다.

clear(this);

JavaScript가 어떻게 그 자체를 파괴하는 좋은 기능을 가지고있는 것이 좋지 않습니까?

이것은 매우 간단 clear합니다. 함수가 객체를 완전히 비 웁니다. 생성자와 함수를 포함한 모든 것을this 지우는 전역 객체를 말합니다 .

이 웁니다 때문에 모든 것을 , 일을 아무것도 , 심지어 언어가 완전히 쓸모하고, 오류가 발생하는 문자를 정의를 : _{* REPL 환경이 없는 이 필요합니다. 원래 JS 엔진 인 SpiderMonkey 엔진 (브라우저가 아닌 셸)을 사용합니다 .}

에멘탈

;#33!

나는 이것이 코드 골프가 아니라는 것을 알고 있지만 작업에 적합한 도구입니다.

사용자 코드는 다음에 삽입 될 수 있습니다 !.

에멘탈 (Emmental)은 통역사 재 작성을 기반 으로 하는 흥미로운 esolang입니다 . 모든 단일 기호 (내장 기호 포함)는 임의의 Emmental 프로그램으로 재정의 할 수 있습니다. 언어는이 기능을 너무 많이 사용하여 루핑 구문을 제공하지 않습니다. 대신 자체 정의에 나타나는 재귀 명령을 정의합니다.

이 재정의는를 통해 이루어 !지며, 스택에서 문자를 읽은 다음 스택에서 a를 발견 할 때까지 문자열을 읽습니다 ;. 그런 다음 문자는 해당 문자열로 표시되는 프로그램을 의미하도록 재정의됩니다.

즉, ! 자체 프로그램을 빈 프로그램으로 재정 의하여 Emmental의 루핑 기능을 비활성화 할 수 있습니다 . 다른 모든 Emmental 코드는 여전히 완벽하게 실행되며 프로그래밍 언어의 많은 기준이 여전히 충족되지만 더 이상 기호를 재정의하는 것은 불가능합니다. 이 기능이 없으면 (따라서 반복 할 수 없음) Emmental은 더 이상 숫자가 소수인지 테스트 할 수 없습니다.

PHP

메모리 제한을 1로 설정하여 PHP를 완전히 죽일 수 있습니다.

완전히 죽을 것이다.

이 시도:

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

    //code here

메모리가 충분하지 않기 때문에 오류가 발생하지 않아야합니다.

지시문 에 대한 자세한 내용을 읽을 수 있습니다memory_limit

이전 버퍼가 유효하지 않은 경우 출력 버퍼를 사용할 수 있습니다.

<?php
    ob_start();

    //code here

    ob_clear();

출력을 완전히 제거합니다. 출력 버퍼가 여전히 열려 있기 때문에 코드 뒤에 실수로 남은 다른 것들도 표시되지 않습니다.

사용 @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();

압축 된 출력을 포착하는 데 사용되는 자동 시작 출력 버퍼를 삭제하는 문제를 피할 수 있습니다.

또한 출력 버퍼가 삭제되거나 플러시되지 않습니다 (브라우저로 전송). 이를 강화하기 위해 항상 빈 문자열을 반환하는 출력 핸들러가 추가됩니다.
running ob_end_flush(); echo "Hello, world!";은 아무 것도 생성하지 않지만 출력을 plain으로 보냅니다 ob_start();.

이 문제 를 알려 주신 @LucasTrzesniewski 에게 감사합니다 !

실제 모드의 x86 기계 코드 (=> 거의 모든 DOS 프로그램)

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

즉

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

인터럽트 테이블에 너무 연결되지 않았기를 바랍니다.

자바

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

편집 : 대응책 이이 거인을 만들고 있습니다 :(

stdin 및 stdout을 널 스트림으로 리디렉션하고 args를 빈 배열로 바꿉니다. 또한 표준 IO가 실제로 숨겨 지도록 막대한 양의 반사 해킹을 사용합니다. 마지막으로 보안 관리자를 설정하여 표준 IO를 다시 만들 수없고 프로그램이 종료 코드를 설정할 수 없도록합니다.

루아

_ENV=""

Lua에는 _ENV모든 전역 변수, 함수, 테이블 등이 저장되는 환경이 있습니다. 빈 문자열로 정의하면 새로운 것을 정의 할 수 없으며 모든 함수와 변수가 지워집니다. 즉, 아무것도 출력하거나 입력을 받거나 거의 아무것도 할 수 없습니다.

셰익스피어 프로그래밍 언어

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에서 프로그램과 함께 다운로드되는 내장 구문 분석기는 스크립트에서 발생할 수있는 작업에 대한 매우 구체적인 규칙을 따릅니다. 이러한 규칙 중 하나는 한 번에 두 문자 만 무대에있을 수 있다는 것입니다. 또한 무대에 없었던 무대에서 캐릭터를 빠져 나가게하면 혼란 스러울 것입니다. 이미 무대에있는 무대에 캐릭터를 추가 할 때도 마찬가지입니다. 파서는 오류를 받으면 다른 어떤 것도하지 않는다. 말 그대로 프로그램과 파서를 완전히 종료 한 다음 모든 것을 다시 시작해야합니다.

PS이 언어의 작동 방식을 모른다면 Google에서 사용하십시오. 그것은 굉장.

잡담

이것이 자격이되는지 확실하지 않습니다.

Smalltalk := Nil.

그러면 전체 런타임 환경이 삭제되어 오브젝트 엔진이 정지됩니다. 이 문제를 해결하는 유일한 방법은 프로세스를 강제로 종료하고 백업에서 다시 시작하는 것입니다.

모르는 사람들에게는 [Visual Works] 스몰 토크 작동 방식이 약간 이상합니다. 미니 OS와 같습니다. 스몰 토크를 시작하면 "메모리 이미지"를 RAM에로드하고 중단 된 지점부터 계속 실행됩니다. 전체 스몰 토크 IDE는 스몰 토크로 작성되며 동적으로 수정 가능합니다.

특히 Smalltalk모든 전역 변수를 포함하는 사전입니다. 특히 새 클래스를 선언 할 때마다 해당 이름의 전역 변수가 만들어져 Class새 클래스 의 객체를 가리 킵니다 . 그래서 설정 Smalltalk에 Nil(기본적으로 널은) 전체 시스템의 모든 클래스를 삭제합니다. GUI 이벤트 핸들러조차도 혼란스러워합니다.

이 변수가 쓰기 가능한 이유를 모르겠습니다. 아마도 전역 변수이기 때문에 내부에 항목으로 존재하기 때문일 수 있습니다. (머리가 아프지 않습니까? 모든 객체에는 클래스가 있고 클래스는 객체이므로 모든 클래스에는 클래스가 있습니까? 클래스의 클래스를 메타 클래스라고하지만 메타 클래스도 객체입니다. 수업 ...)

사전을 널 (null)로 바꾸지 않고 지우는 방식 으로 비슷한 효과를 얻을 수 있습니다. 실제로 시스템의 모든 클래스를 삭제하기 위해 코딩 할 수있는 작업이 많으므로 아무것도 할 수 없습니다. 그러나 실제 스몰 토크 컴파일러는 클래스이기 때문에 언어를 깨뜨리는 것은 전체 IDE를 깨뜨립니다.

하스켈

여기 몇 가지 가능성이 있습니다.

지루한 아이디어 # 1 : main아무것도하지 않도록 정의하십시오 . 이제 다른 코드를 작성하더라도 실행할 수 없습니다. (REPL에서 수동으로 실행하지 않는 한)

지루한 아이디어 # 2 : 공개 내보내기가없는 모듈을 정의하십시오. 이제 다른 코드를 작성하더라도 실행할 수 없습니다.

재미있는 아이디어 : 모든 가져 오기를 비활성화하십시오.

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

이제 함수를 정의 할 수 있습니다 볼 수 있고 할 수 있습니다 실행을 ...하지만 그들은 아무것도 할 수 없습니다. 모든 표준 Haskell 유형 및 기능이 이제 숨겨집니다. (몇 가지를 제외하고 정말 깊이 언어로 하드 와이어).

특히, 어떤 I / O도 수행 할 수 없습니다. 또한 기계 정밀 산술을 수행 할 수 없습니다. (이후 Int, Double등은 지금 정의된다.)

그래도 실제 계산을 수행하는 람다 미적분 함수를 작성할 수 있습니다 . 데이터를 가져 오거나 가져올 수 없습니다. 그러나 물론 Fubar위의 모듈을 호출 하고 대신 I / O를 수행 하는 별도의 별도 모듈을 작성할 수 있습니다 (따라서 코드가 실행되고 작동 함을 증명 함).

몇 가지 미묘한 점들 :

• foo = foo더 이상 가져 오기를 추가하지 못하게하려면 더미 선언이 필요합니다. ( 신고 후에 는 수입품을 볼 수 없습니다 .)

• 이 상황에서 벗어날 수있는 다양한 비표준 Haskell 언어 확장이 있습니다. 그러나 언어 확장은 파일 맨 위에 컴파일러 pragma를 사용하여 켜야 합니다. (또는 컴파일러로의 명령 행 스위치가 있습니다. 실제로 이것을 막을 수는 없습니다!)

추신

예, PostScript는 프로그래밍 언어입니다. 또한 모든 언어 구문이 시스템 정의 함수 인 프로그래밍 언어이며 재정의 될 수 있습니다 ...

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

영어로:

• 빈 1,000 요소 사전을 작성하고 이름을 지정하십시오 Magic.
• 의 모든 키에 대해 빈 정의 ( " ") systemdict를 사용하여에 동일한 키를 추가하십시오 .Magic{}
• Magic사전 스택의 상단으로 밉니다 .

지금부터 모든 PostScript 언어 명령은 아무 것도하지 않도록 정의되어 있습니다. AFAIK, 이 조건에서 벗어날 수 없습니다 .

(기술적으로, 당신은 여전히 실행할 수 있다면. 당신은 단지 그들을 미행하고, 기존의 정의를 "파괴"아니에요 end, 즉 팝업 것입니다 Magic사전 스택을, 해제 그림자 모든 명령을 다시 당신에게 당신의 생명을주는. 그러나 이후 end그 자체도 그림자입니다 ... 지금은 아무것도하지 않습니다.)

모든 명령은 여전히 실행됩니다 . 이제는 아무 것도하지 않도록 정의되었습니다. 어떤 종류의 오류도 발생하지 않으며 아무 일도 일어나지 않을 것입니다. (글쎄, 스택 오버플로가 결국 발생한다고 가정합니다 ...)

Linux / x86 (-64)에서 실행되는 모든 프로그램

이 프로그램은 C 로 작성 되었지만 Linux / x86 (-32 또는 -64)에서 실행중인 모든 프로그램의 실행을 방해 할 수 있습니다. 중단하려는 프로그램의 명령 행 호출 앞에 추가하십시오.

대상 프로그램이 출력을 생성하지 못하도록 디버거 API를 사용합니다. 특히, 프로세스 외부의 세계에 무언가를 전달할 수있는 모든 시스템 호출 ( write물론, 물론 open파일을 만들 kill때 다른 프로세스에 적용될 때 대부분의 소켓 API 가 실패 함) 마치 구현되지 않은 것처럼. _exit허용되지만 종료 코드는 0으로 덮어 씁니다.

이 답변의 이전 버전과 달리 많은 프로그램이 이러한 조건에서 거의 완료 될 때까지 실행할 수 있습니다. 단지 모든 작업이 낭비되는 것입니다. 예를 들어, ./no-syscalls /bin/lsGNU GNU 유틸리티를 사용한다고 가정 ls하면 전체 디렉토리를 읽고 형식을 지정한 다음 write출력을 생성하는 모든 호출이 실패합니다. (하지만 모든 X11 클라이언트와 같이 양방향 통신 채널을 열어야하는 모든 것은 그 시점에서 실패 할 것입니다. 나는 허용 할 수는 socket있지만 send허점을 열지 못할 것으로 생각했습니다.)

동작을 조정하는 몇 가지 명령 줄 옵션이 있습니다.

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

동적으로 연결된 프로그램은 -e모드 에서 동적 링커를 벗어나지 않습니다 . -S분명히 정책에 큰 구멍을 열어 주지만, 아무 것도 작동하지 않는 것에 대해 신음하는 프로그램을 보는 것은 재미있을 수 있습니다.

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

/usr/include/asm*/unistd.h이미 너무 길기 때문에 다른 창에서 열린 상태로 로그 출력을 읽어야 합니다.

안타깝게도, 이것이 사용하는 디버거 인터페이스는 유닉스 구현에서 거의 일관성이 없으며 본질적으로 CPU에 따라 다릅니다. 다른 CPU 아키텍처로 포팅하는 것은 비교적 간단하며 (의 적절한 정의를 추가하십시오 SYSCALL_*_REG) 유닉스로 포팅하는 것이 가능할ptrace 수도 있지만, syscall 화이트리스트를 광범위하게 다루고 분기를 처리해야 할 수도 있습니다 에서 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

나는 이것이 실제로 효과가 있을지 확신하지 못하지만 이론 상으로는 \탈출 캐릭터로 해결해야합니다. 일반적으로 TeX는 파일을 읽고 쓸 수 있으며 이제 논리에 의존하는 것은 쓸 수 없습니다. 따라서 언어는 이제 OP에서 정의한대로 깨졌습니다.

편집 : 주석에서 가져온 다른 kill 명령 (두 코드 모두 실행 해야하는 규칙을 위반 할 수는 있음) :

• \def\fi{}\iffalsesmpl에 의해 닫을 수없는 경우 분기를 만듭니다.
• \catcode13=9%iwillnotexist에 의해 idonotexist 는 끝없는 의견을 만듭니다

할퀴다

는 when [timer v] > (0)에디터에 있다면 당신도 코드를 시작하기 전에, 이는 곧 코드가 초기화 될 때 실행됩니다. 은 when I receive (join[][])오류가 당신이 플래시의 개발자 버전이있는 경우 코드 실행을 일시 중지, 방송 때마다 아무것도 슬로우됩니다. 이 break함수는 클론을 생성하고 브로드 캐스트 오류를 ​​트리거합니다. 모든 단일 클론은 2 초 동안 지속되고 자체 삭제되어 스택에 부담을줍니다. 그리고 모든 클론은에 응답 when [timer v] > (0)하여 break서브 루틴을 실행 하고 타이머를 재설정하여 타이머 코드를 다시 실행합니다. 또한 각 클론은 모든 브로드 캐스트 오류에도 응답합니다. 즉, 평가 당 오류 break수는 클론 수의 제곱입니다. break함수가 가지고 있음을 언급하는 것을 잊었습니까?run without screen refresh체크하여 에디터가 정지, 멈춤 및 지연, 잡기 및 할당 메모리를 유발합니다. 그리고 CPU를 최대한 활용하십시오.

이 실행 중 아무 곳에 나 추가 된 코드는 복제본을 생성 할 수 없으며 (300 복제 제한 초과) 실행중인 컴퓨터를 가열하고 충돌시킵니다. 그리고 더 이상 잡을 것이 없어 질 때까지 메모리를 잡으면 변수가 잘못 작동합니다.

그리고 when [timer v] > (0)블록 을 트리거하기에 너무 많은 지연 이 있더라도 여전히 실행 중 break입니다.

when I receive잠시 전에 발견 한 결함 에 대해 알려주고 아이디어를 제공해 주신 @towerofnix에게 감사드립니다 run without screen refresh. 당신이 이것을 좋아한다면, 여기에 원본이 있습니다 : https://codegolf.stackexchange.com/a/61357/43394

수학 / 볼프람 언어

Mathematica는 명령 이름이 프로그래머가 조작 할 수있는 기호 인 해석 된 언어입니다. 내장 연산자는 삭제할 수 없지만 과부하하거나 기능을 수정할 수 있습니다. 다음은 내부적으로 변수를 할당하는 데 필요한 "With"명령을 뒤섞습니다. 이 변경은 커널이 할당이 완료 될 때까지 평가되지 않은 인수를 보유하지 못하게하고 언어를 완전히 죽입니다.

ClearAttributes["With", HoldAll]

이 명령이 대화식 세션 또는 코드 블록 내에서 실행되면 Mathematica는 추가 할 수 없습니다 1+1(결과 오류 메시지는 페이지 길이이므로 여기에 포함시키지 않습니다).

PHP

나는 그것이 실제로 작동하는지 놀라게하지만, 폐쇄있어 STDOUT하고하는 것은 STDERR모든 출력을 억제합니다. 다시 열리지 않도록 /dev/null파일 설명자 0, 1 및 2를 다시 할당하기 위해 세 번 엽니 다 .

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

// insert program here

이에 대한 자세한 내용 : https://stackoverflow.com/questions/937627/how-to-redirect-stdout-to-a-file-in-php

DOS 배치 (Windows 95 이전 버전)

CTTY

인수없이 발행하면 명령 행이 터미널에서 연결 해제됩니다. 입력을 읽거나 출력을 생성하려는 추가 시도는 아무 것도하지 않습니다.

CTTY를 올바르게 사용하는 방법을 알고 싶은 경우 :

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

조금 더 강력한 배치 파일은 모뎀에 응답하고 CTTY에 전화를 건 모든 것을 연결할 수 있습니다.

공통 리스프

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

여는 괄호가 필요하지 않기를 바랍니다.

이것은 Lisp Reader가 각 인스턴스를 (에 대한 호출로 대체하도록 지시하는 리더 매크로입니다 (lambda (x y) ()).이 함수는 두 개의 인수를 취하고 아무것도 반환하지 않는 함수입니다. 따라서, 예를 들어, 그것은 읽을 것 (foo)같은 foo), 해석 foo변수로 다음에 타의 추종을 불허하는 괄호 오류가 발생 0.

할퀴다

다음은 브라우저와 이론적으로 컴퓨터를 손상시키는 매우 간단한 예입니다.

나는 이것을 약 20 초 동안 그대로 두었다가 2.65 GB의 메모리를 잃어 버렸다. 잠시 후 5GB가 사라졌습니다.

이 기능을 실행하기 전에 Adobe Flash 또는 웹 브라우저를 강제 종료 할 수있는 방법이 있습니다.

^{나는 정말 같은 멋진 대답하고 싶었 clear(this)JS 하나를하지만, 슬프게도 스크래치 그렇게 할 수있는 방법이 없습니다. 스크래치를 사용할 수 없게 만드는 다른 방법을 찾으면 언제든지이 게시물을 업데이트하거나 직접 만드십시오!}

목

::=

끝에 줄 바꿈으로

이 언어는 규칙 세트 정의에 의존하며 a ::=는 규칙 세트의 끝을 나타냅니다. 할 수 없다 아무거나 그것을 할 규칙을 정의하지 않고 thue의를, 그래서 관계없이 이후에 넣어 무엇을 ::=, 아무것도 일어나지 않을 수 있습니다.

대체 답변

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

(문자 앞 A및 인쇄 할 수없는 문자를 포함하여 모든 유니 코드의 모든 문자 등 ). 이 명령 줄 옵션이 필요합니다 -r.

MATLAB

다음 코드는 환경을 완전히 사용할 수 없게 만듭니다 ¹ :

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

이것은 builtin함수와 함수를 재정의하고 clear새로운 익명 함수 핸들을 사용 false하여 함수를 호출 할 때마다 단순히 반환하는 새로운 익명 함수 핸들을 재정의합니다 . builtin기능은 보장이 내장되는 MATLAB에 (일처럼 그와 같은 이름 당신은 MATLAB에서 쓰기 사용자 지정 기능이있는 경우 sum, max, min, 당신이 오버로드 기능을 대신 명확하게이 전화를 할 수있는 등) . 마찬가지로 clear현재 선언 된 모든 변수를 지워서 새로 시작할 수 있습니다. 이러한 기능을 제거하면 프로그램을 다시 시작하지 않으면 MATLAB을 사용할 수 없습니다.

MATLAB R2015a에서 다음 메시지도 표시됩니다.

작업 공간은 나중에 환경에서 사용할 수 있도록 현재 환경에서 선언 된 변수입니다. 이렇게하면 작업 영역이 영구적으로 비활성화되므로 사용자가 시도하고 생성 한 모든 변수가 저장되지 않으므로 MATLAB에서 코드 줄을 실행할 때 진행할 수 없습니다.

^{1 : 아이디어는 원래 아이디어를 발견 한 사용자 Dev-iL 에게 갑니다 .}

///

/\///

///의 유일한 작업은 다음과 같이 반복되는 문자열 대체 /pattern/replacement/입니다.

이 코드는 모든 /문자열을 제거 하므로 반복 문자열 대체를 사용할 수 없으므로 기본적으로 그 이후에 쓰는 모든 내용이 인쇄됩니다 ( /s 제외 ).

여전히 \s를 사용할 수는 있지만 그다지 도움이되지는 않습니다.

베 펀지 -96

'~h

사용자의 코드는 소스에서 처음 세 문자 인 한이 시퀀스 이후 어디에서나 수행 할 수 있습니다.

'명령 (원샷 문자열 모드)의 ASCII 값을 밀어 ~스택 (예 : 126)에, 그리고 h명령은 다음으로 알려진 설정 론적 델타 그 값. Befunge-96에 익숙하지 않은 사용자를 위해 전체적 델타 는 인터프리터가 만나는 모든 명령 바이트 값에 추가되는 오프셋입니다.

델타가 126으로 설정되면 ~소스에서 널 바이트를 통해 생성 할 수있는 유효한 명령은 (문자 입력) 뿐입니다 . 널 바이트 이외의 값은 126보다 큰 값으로 변환되며 해당 값은 유효한 Befunge 명령이 아닙니다.

이것이 프로그래밍 언어로 자격을 갖추지 못한다고 말하는 것이 안전하다고 생각합니다.

우우

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

그런 다음 프로젝트 어딘가에

harmless

무해한 이름을 가진 간단한 매크로이지만 놀랍도록 실망스러운 효과. Boo 컴파일러는 소스를 AST로 구문 분석하고 코드 생성으로 끝나는 다단계 파이프 라인을 사용합니다. (일반적으로 다양한 응용 프로그램에 맞게 재구성 할 수 있습니다.) 사이의 모든 단계는 AST에서 다양한 작업을 수행합니다.

매크로 확장 단계는 매크로가 컴파일러의 맥락에서 실행되는 매크로 확장 단계입니다. 마지막 단락에서 파이프 라인을 재구성 할 수 있다는 점을 기억하십니까? 매크로 확장 중에 파이프 라인을 지우는 매크로를 호출하면 사용자에게 오류가 표시되지 않지만 매크로 확장 후 (코드 생성 포함) 모든 단계가 더 이상 존재하지 않습니다. 결국에는 오류 메시지가 표시되지 않는 성공적인 컴파일처럼 보이는 것이지만 어떤 이유로 바이너리가 생성되지 않습니다! 매크로와 호출을 잘 숨기면 최고의 문제 해결사조차도 벽에 몰아 넣을 수 있습니다.

NGN / APL

NGN / APL은 프리미티브를 재정의 때문에 (다시 정의 할 수 있습니다 ←로) 모든 기본 기능을 ⊢(: 모두를 "통과" ⊢3및 2⊢3제공 3) 언어가 완전히 쓸모 있습니다 :

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

여기에서 시도하십시오.

루비 (29 자)

class Object;def send;end;end

'send'는 루비 내에서 메소드가 호출 될 때마다 그리고 모든 객체가 Object 클래스에서 상속되므로 내부적으로 사용됩니다. 메소드 실행이 중지됩니다.

재미있는 사실 : 이것은 이론적으로 완벽하게 들립니다. 그러나 어떤 이유로 루비 언어를 방해하지 않는 것 같습니다. 이 코드를 실행 한 다음 여전히 개방형 Ruby 환경을 사용할 수있는 이유를 모르겠습니다.

Tcl

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

언어를 제외 if하고 언어에서 모든 키워드를 제거합니다 rename.

위의 코드로 인해 새 코드가 오류가 발생합니다. 따라서 새로 삽입 된 코드가 실제로 "실행"되는지 여부는 논쟁의 여지가 있습니다. 아래는 새 코드를 실행하지만 모든 키워드 ( if및 제외 proc)가 작동 하지 않는 것으로 변경되어 아무 것도 수행하지 않는 버전입니다 .

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

키워드를 삭제하는 대신이 코드는 키워드를 수행하지 않는 기능으로 대체합니다.

(참고 : Tcl에는 키워드가없고 기능 만 있기 때문에 "키워드"를 매우 느슨하게 사용하고 있습니다.)

훈

=<  ~
(your code)

훈은 이상하다. 구문뿐만 아니라 의미 론적으로 다른 프로그래밍 언어와는 완전히 다릅니다. 그러나 Hexagony와 같은 언어와 달리 의도적으로 난해한 것은 아닙니다.

Hoon 은 최소 결합기 기반 VM 인 Nock로 컴파일합니다 . Nock은 멍청하다. 스펙은 340 바이트로 압축 될 수있다. 유일한 수학 연산은 증가하고 있습니다. 원자 (큰 숫자) 또는 셀 (명사 쌍)이라는 명사는 모든 메모리 모델이 불변의 비순환 이진 트리로 배열되어 있습니다. 유일한 출력은식이 줄어드는 명사입니다.

이상한 컴파일 대상으로 인해 Hoon도 이상합니다. 완전히 순수합니다. Hoon은 "컨텍스트"에서 평가되는 Nock 표현식으로 컴파일합니다. 모든 커널과 stdlib는 모든 변수와 함께 컨텍스트에 의해 프로그램에 암시 적으로 전달됩니다.

Hoon을 사용할 수 없게하려면 =<"b의 맥락에서 a를 평가"하는을 사용하면됩니다. 우리는 항상 ~0을 평가 하고 있습니다. 어떤 일이 있어도 b감소하는 값을 변경할 수 없으며 부작용이 없으므로 입력 또는 출력을 수행 할 수 없습니다.

참고 사항 : 실제로 Hoon (순도!)에서 입력하라는 메시지를 표시 할 수 없기 때문에 실제로는 프로그래밍 언어가 아닙니다. 입력은 함수 인수를 통해, 반환 값을 통해 출력됩니다 (또는 ~&printf 디버깅 기능에 더 가깝고 프로그램에 투명 함).

프로그램이 Urbit로 입력을 받으려면 실제로 입력을 받아들이는 함수를 반환하는 프로그램을 작성하고 쉘은 사용자를 대신하여 콜백에 전달합니다.

택시, 2354 바이트

이 작은 프로그램은 단순히 가스가 부족한 Townsburg를 통해 큰 즐거움으로 택시를 운행합니다. 이 후에 실행하는 모든 코드는로 빠르게 오류가 발생합니다 error: out of gas. 그리고 당신이 내가 생각하지 않는 주유소에 도달 할 수 있다고해도 승객이 없기 때문에 돈을 모으지 않았기 때문에 어떤 주유소도 얻을 수 없었습니다.

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

글쎄, 적어도 IE11에서는.

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

문서 쓰기, 전역 변수 쓰기 및 함수에서 복귀를 비활성화합니다.

출력 방법을 놓쳤다면 의견을 말하십시오!

파이썬 2, 엄청나게 큰

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

이 엄청나게 많은 양의 코드는 rexec"ok"목록에 추가 된 많은 새 모듈과 object.__subclasses__()최소한 두 개의 다른 파이썬을 만든 방법을 포함하여 많은 약점이 고정 된 고대 모듈 (파이썬 2.3에서 중단됨) 의 부활입니다. 답변이 잘못되었습니다).

이 코드의 상당 부분 ( 클래스 의 __init__방법 RExec과 전체 ModuleImporter클래스)은 파이썬 표준 라이브러리에서 약간만 수정하면 복사됩니다.