Cố gắng viết một số mã bằng ngôn ngữ của bạn và làm cho nó không thỏa mãn tiêu chí của chúng tôi là ngôn ngữ lập trình nữa.

Một ngôn ngữ đáp ứng các tiêu chí của chúng tôi (phiên bản đơn giản hóa cho thử thách này) là ngôn ngữ lập trình nếu:

• Nó có thể đọc đầu vào của người dùng đại diện cho các bộ số nguyên dương theo một cách nào đó.
• Nó có thể xuất ít nhất hai kết quả khác nhau tùy thuộc vào đầu vào.
• Nó có thể lấy hai số nguyên dương và thêm chúng (và kết quả có thể ảnh hưởng đến đầu ra).
• Nó có thể lấy một số nguyên dương và quyết định xem nó có phải là số nguyên tố hay không (và kết quả có thể ảnh hưởng đến đầu ra).
• Với mục đích của thử thách này, bất kỳ loại đầu ra nào không phải là phương thức đầu ra được phép cho một thử thách thông thường đều bị bỏ qua. Vì vậy, không quan trọng chương trình cũng có thể phát một bản nhạc hay đăng qua HTTP, v.v.
• Cập nhật: Bạn cũng có thể chọn một hoặc một số phương thức đầu ra được phép và bỏ qua tất cả các phương thức khác. Nhưng bạn phải sử dụng định nghĩa tương tự ở mọi nơi trong các tiêu chí sau. Và nếu chương trình của bạn có thể vô hiệu hóa nhiều hơn một phương thức đầu ra - điều đó đáng để nâng cao hơn.

Các ví dụ như làm cho nó không thể xuất hoặc vô hiệu hóa tất cả các cấu trúc vòng lặp để nó không thể thực hiện kiểm tra tính nguyên thủy và đảm bảo người dùng không thể kích hoạt lại chúng.

Bạn nên để một chỗ để chèn mã mới. Theo mặc định, nó nằm ở cuối mã của bạn. Nếu chúng tôi xem xét đưa mã nguồn vào vị trí đó trong câu trả lời của bạn và chạy mã đầy đủ dưới dạng một chương trình hoàn chỉnh, trình thông dịch của một ngôn ngữ mới, ngôn ngữ đó sẽ không đáp ứng các tiêu chí.

Nhưng mã được chèn phải được thực thi theo cách giống như một ngôn ngữ thỏa mãn các tiêu chí:

• Mã được chèn phải về mặt ngữ pháp giống như một cái gì đó (giả sử đó là một khối mã theo các tiêu chí sau) thường đáp ứng các tiêu chí, từ quan điểm của bất kỳ ai muốn viết một cú pháp tô sáng. Vì vậy, nó không thể ở trong một chuỗi, bình luận, vv
• Mã được chèn phải thực sự được thực thi, theo cách nó được cho là thỏa mãn các tiêu chí. Vì vậy, nó không thể ở trong một hàm không được sử dụng hoặc sizeoftrong C, bạn không thể chỉ thực hiện một phần không có chức năng trong mã và bạn không thể đặt nó sau một vòng lặp vô hạn, v.v.
• Bạn không thể giới hạn số lượng chương trình đúng ngữ pháp có thể được tạo theo cách này. Nếu đã có thứ gì đó như giới hạn độ dài trong ngôn ngữ bạn đang sử dụng, thì nó không nên đáp ứng các tiêu chí ngay cả khi giới hạn này được loại bỏ.
• Bạn không thể sửa đổi hoặc "sử dụng hết" nội dung của đầu vào / đầu ra, nhưng bạn có thể ngăn không cho chúng truy cập.
• Các tiêu chí này thường chỉ áp dụng cho các ngôn ngữ mà không có I / O rõ ràng:
  • Mã của bạn nên chuyển hướng đầu vào của người dùng (có chứa thông tin về độ dài tùy ý) sang mã được chèn, nếu một khối mã thường không thể lấy đầu vào của người dùng trực tiếp / rõ ràng bằng ngôn ngữ bạn đang sử dụng.
  • Mã của bạn sẽ in giá trị trả về của mã được chèn, nếu một khối mã thường không thể xuất ra những thứ trực tiếp / rõ ràng bằng ngôn ngữ bạn đang sử dụng.
  • Trong trường hợp bạn in giá trị được trả về và nó được nhập bằng ngôn ngữ bạn đang sử dụng, loại được trả về sẽ có thể có 2 giá trị thực tế có thể khác nhau. Ví dụ: bạn không thể sử dụng loại struct {}hoặc struct {private:int x;}trong C ++.

Đây là cuộc thi phổ biến. Câu trả lời hợp lệ được bình chọn cao nhất (vì vậy không ai phát hiện ra lỗi hoặc tất cả các lỗi đã được sửa) sẽ thắng.

Làm rõ

• Bạn không nên sửa đổi mã ở dạng văn bản, nhưng có thể thay đổi cú pháp trước khi mã được diễn giải hoặc biên dịch.
• Bạn có thể làm những việc khác trong khi mã đang chạy. Nhưng lý do nó không thỏa mãn các tiêu chí nên nằm trong chính mã được chèn. Nó có thể bị lỗi do sự can thiệp của một luồng khác, nhưng không chỉ bị giết bởi một luồng khác.
• Tất cả các thông số kỹ thuật về cơ bản có nghĩa là nó phải có khả năng đáp ứng các tiêu chí về mặt ngữ pháp nếu tất cả các phần tử tích hợp không thay đổi nhưng thực tế không làm được. Sẽ tốt thôi nếu bạn tìm thấy bất kỳ cách giải quyết phi ngữ pháp nào, chẳng hạn như chuyển các tham số cho khối mã một cách chính xác, nhưng làm cho chúng không thể được sử dụng theo một cách nào đó.
• Một lần nữa, mã được chèn phải được thực thi. Mã sau một vòng lặp vô hạn hoặc sự cố được coi là "không thực sự được thực thi", do đó không hợp lệ . Những câu trả lời đó có thể thú vị, nhưng đã có một số câu hỏi lặp vô hạn hoặc câu hỏi khác trên trang web này và bạn có thể tìm thấy một câu trả lời thích hợp hơn để trả lời. Nếu không, hãy xem xét hỏi một câu hỏi mới. Ví dụ về những câu hỏi đó là:
  • Vòng lặp vô hạn ngắn nhất không tạo ra đầu ra
  • Tại sao nó không kết thúc?
  • Vòng lặp mà không 'vòng lặp'
  • Thách thức: Viết một đoạn mã tự thoát
  • Lỗi thời gian vô lý
  • Sụp đổ trình biên dịch yêu thích của bạn

Bảng xếp hạng

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>

Vỏ JavaScript

Điều này sẽ làm cho ngôn ngữ hoàn toàn không thể sử dụng.

clear(this);

Thật tuyệt khi JavaScript có một chức năng tuyệt vời như vậy để tự hủy?

Điều này khá đơn giản, clearchức năng hoàn toàn làm trống một đối tượng. thisđề cập đến đối tượng toàn cầu xóa tất cả mọi thứ bao gồm các hàm tạo và hàm.

Bởi vì điều này xóa tất cả mọi thứ , làm bất cứ điều gì , thậm chí xác định một nghĩa đen sẽ gây ra lỗi, làm cho ngôn ngữ hoàn toàn vô dụng: _{* Không yêu cầu môi trường REPL . Sử dụng công cụ SpiderMonkey (shell không phải trình duyệt), công cụ JS gốc.}

Emmental

;#33!

Tôi biết đây không phải là môn đánh gôn, nhưng công cụ phù hợp cho công việc, bạn biết đấy ...

Mã người dùng có thể được chèn sau !.

Emmental là một esolang thú vị dựa trên việc viết lại trình thông dịch. Mỗi biểu tượng duy nhất (bao gồm các biểu tượng tích hợp) có thể được xác định lại dưới dạng chương trình Emmental tùy ý. Ngôn ngữ phụ thuộc vào tính năng này đến mức nó không cung cấp bất kỳ cấu trúc lặp nào. Thay vào đó, bạn xác định các lệnh đệ quy xuất hiện trong định nghĩa riêng của chúng.

Định nghĩa lại này xảy ra thông qua !, nó đọc một ký tự từ ngăn xếp và sau đó đọc một chuỗi từ ngăn xếp cho đến khi nó gặp a ;. Ký tự sau đó được xác định lại có nghĩa là chương trình được đại diện bởi chuỗi đó.

Điều đó có nghĩa là, chúng ta có thể vô hiệu hóa các tính năng lặp của Emmental bằng cách xác định lại ! chính nó là chương trình trống. Mặc dù tất cả các mã Emmental khác vẫn chạy hoàn toàn tốt và nhiều tiêu chí của ngôn ngữ lập trình vẫn được đáp ứng, không thể xác định lại bất kỳ ký hiệu nào nữa. Không có tính năng này (và do đó, không thể lặp), Emmental không thể kiểm tra xem một số có phải là số nguyên tố hay không.

PHP

Người ta hoàn toàn có thể giết PHP bằng cách đặt giới hạn bộ nhớ thành 1.

Nó sẽ hoàn toàn chết.

Thử đi:

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

    //code here

Điều này thậm chí không nên ném bất kỳ lỗi nào, vì không có đủ bộ nhớ cho điều đó.

Bạn có thể đọc thêm về memory_limitchỉ thị

Nếu cái trước không hợp lệ, người ta có thể sử dụng bộ đệm đầu ra:

<?php
    ob_start();

    //code here

    ob_clear();

Điều này loại bỏ hoàn toàn bất kỳ đầu ra. Vì bộ đệm đầu ra vẫn mở, một số thứ khác vô tình để lại sau khi mã sẽ không được hiển thị.

Sử dụng ý tưởng của @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();

Điều này sẽ tránh được vấn đề xóa bộ đệm đầu ra tự động, được sử dụng để bắt đầu ra được nén.

Điều này cũng ngăn chặn bộ đệm đầu ra bị xóa hoặc xóa (gửi đến trình duyệt). Để tái phổ biến điều đó, một trình xử lý đầu ra được thêm vào, luôn trả về một chuỗi rỗng.
Chạy ob_end_flush(); echo "Hello, world!";sẽ không tạo ra bất cứ điều gì, nhưng sẽ gửi đầu ra với một đồng bằng ob_start();.

Cảm ơn @LucasTrzesniewski đã phơi bày vấn đề này!

Mã máy x86 ở chế độ thực (=> gần như mọi chương trình DOS)

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

I E

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

Tôi hy vọng bạn không quá gắn bó với bảng ngắt của bạn.

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

Chỉnh sửa: Các biện pháp đối phó đang làm cho người khổng lồ này :(

Chuyển hướng stdin và stdout thành các luồng null và thay thế args bằng một mảng trống. Cũng sử dụng số lượng lớn các bản hack phản chiếu để đảm bảo IO chuẩn thực sự bị ẩn. Cuối cùng, nó đặt trình quản lý bảo mật để đảm bảo IO tiêu chuẩn không thể được tạo lại và điều đó đảm bảo các chương trình không thể đặt mã thoát.

Lua

_ENV=""

Trong Lua, _ENVlà môi trường mà tất cả các biến toàn cục, hàm, bảng, v.v được lưu trữ. Xác định nó chỉ là một chuỗi rỗng có nghĩa là bạn không thể định nghĩa bất cứ điều gì mới, và tất cả các hàm và biến đều bị xóa. Điều này có nghĩa là bạn không thể xuất bất cứ thứ gì, nhập liệu hoặc thực hiện bất kỳ thứ gì.

Ngôn ngữ lập trình Shakespeare

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]

Trong SPL, trình phân tích cú pháp tích hợp được tải xuống cùng với chương trình tuân theo các quy tắc rất cụ thể về những gì có thể xảy ra trong tập lệnh. Một trong những quy tắc như vậy là chỉ có hai nhân vật có thể ở trên sân khấu cùng một lúc. Ngoài ra, làm cho một nhân vật thoát khỏi sân khấu, người không bao giờ trên sân khấu sẽ nhầm lẫn nó. Điều tương tự cũng xảy ra khi thêm một nhân vật vào sân khấu đã ở trên sân khấu. Khi trình phân tích cú pháp nhận được lỗi, nó sẽ từ chối thực hiện BẤT CỨ điều gì khác; bạn thực sự phải tắt hoàn toàn chương trình và trình phân tích cú pháp và sau đó khởi động lại mọi thứ.

PS Nếu bạn không biết làm thế nào ngôn ngữ này hoạt động, Google nó. Thật tuyệt vời.

Smalltalk

Tôi không chắc chắn nếu điều này đủ điều kiện:

Smalltalk := Nil.

Điều này xóa toàn bộ môi trường thời gian chạy, treo động cơ đối tượng. Cách duy nhất để khắc phục điều này là buộc phải chấm dứt quá trình và khởi động lại từ bản sao lưu.

Đối với những người không biết, cách [Công trình trực quan] Smalltalk hoạt động hơi kỳ lạ. Nó giống như một hệ điều hành nhỏ. Khi bạn khởi động Smalltalk, bạn tải "hình ảnh bộ nhớ" vào RAM và nó tiếp tục thực thi từ nơi nó rời đi. Toàn bộ IDE Smalltalk được viết bằng Smalltalk và có thể sửa đổi linh hoạt.

Đặc biệt, Smalltalklà một từ điển chứa tất cả các biến toàn cầu. Đặc biệt nhất, mỗi khi bạn khai báo một lớp mới, một biến toàn cục có tên đó được tạo, trỏ đến Classđối tượng cho lớp mới của bạn. Vì vậy, thiết lập Smalltalkthành Nil(về cơ bản là null) sẽ xóa tất cả các lớp trong toàn bộ hệ thống. Ngay cả các trình xử lý sự kiện GUI cũng gặp sự cố.

Tôi không biết tại sao biến này thậm chí có thể ghi. Có lẽ bởi vì đó là một biến toàn cục, và do đó tồn tại như một mục bên trong chính nó. (Đầu của bạn đã đau chưa? Tôi đã đề cập rằng mọi đối tượng đều có một lớp và các lớp là các đối tượng, vì vậy mỗi lớp có một lớp? Lớp của một lớp được gọi là siêu dữ liệu, nhưng siêu dữ liệu cũng là một đối tượng, do đó có một lớp học...)

Bạn có thể có thể đạt được hiệu ứng tương tự bằng cách xóa từ điển thay vì thay thế bằng null. Thật vậy, có bất kỳ số lượng nào bạn có thể mã để xóa tất cả các lớp trong hệ thống, khiến bạn không thể làm gì. Nhưng vì trình biên dịch Smalltalk thực tế cũng là một lớp ... bất cứ thứ gì phá vỡ ngôn ngữ cũng sẽ phá vỡ toàn bộ IDE, vì vậy ...

Haskell

Có một vài khả năng ở đây.

Ý tưởng nhàm chán # 1: Xác định mainkhông làm gì cả. Bây giờ cho dù bạn viết mã nào khác, nó không bao giờ có thể thực thi được. (Trừ khi bạn tự chạy nó từ REPL.)

Ý tưởng nhàm chán # 2: Xác định một mô-đun không có xuất khẩu công khai. Bây giờ không có vấn đề gì viết mã của bạn, nó không bao giờ có thể thực thi.

Ý tưởng thú vị: Vô hiệu hóa tất cả hàng nhập khẩu.

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

Bây giờ bạn có thể xác định các chức năng mà là nhìn thấy và có thể được chạy ... nhưng họ không thể làm bất cứ điều gì. Tất cả các loại và chức năng Haskell tiêu chuẩn hiện đang bị ẩn. (Ngoại trừ một vài điều thực sự khó kết nối với ngôn ngữ.)

Đặc biệt nhất, bạn không thể thực hiện bất kỳ I / O nào. Bạn cũng không thể làm số học chính xác máy. (Vì Int, Doublev.v. hiện không xác định.)

Bạn vẫn có thể viết các hàm lambda-tính toán thực hiện một số tính toán thực sự. Bạn không thể lấy bất kỳ dữ liệu nào vào hoặc ra. Nhưng tất nhiên bạn có thể viết một mô-đun khác, riêng biệt gọi Fubarmô-đun ở trên và thực hiện I / O thay mặt cho nó (do đó chứng minh rằng mã thực thi và thực hiện công cụ).

Một số tinh tế:

• foo = fooTuyên bố giả là cần thiết để ngăn chặn bất kỳ ai thêm nhập khẩu bổ sung. (Nhập khẩu không thể xuất hiện sau khi khai báo.)

• Có nhiều phần mở rộng ngôn ngữ Haskell không chuẩn sẽ cho phép bạn thoát khỏi tình huống này. Nhưng các phần mở rộng ngôn ngữ phải được bật với một pragma trình biên dịch ở đầu tệp. (Hoặc với một chuyển đổi dòng lệnh sang trình biên dịch. Tôi thực sự không thể ngăn chặn điều đó!)

PostScript

Vâng, PostScript là một ngôn ngữ lập trình. Hơn nữa, đây là ngôn ngữ lập trình trong đó tất cả các cấu trúc ngôn ngữ là các hàm do hệ thống xác định, có thể được định nghĩa lại ...

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

Bằng tiếng Anh:

• Tạo một từ điển 1.000 phần tử trống và đặt tên cho nó Magic.
• Đối với mỗi khóa trong systemdict, thêm cùng một khóa vào Magic, với định nghĩa trống (" {}").
• Đẩy Magiclên trên cùng của ngăn xếp từ điển.

Từ thời điểm này, mọi lệnh ngôn ngữ PostScript được xác định là không làm gì cả. AFAIK, không thể thoát khỏi tình trạng này.

(Về mặt kỹ thuật, bạn không "phá hủy" các định nghĩa cũ, bạn chỉ đang che giấu chúng. Nếu bạn vẫn có thể thực thi end, điều đó sẽ bật Magicra khỏi ngăn xếp từ điển, bỏ bóng tất cả các lệnh và mang lại cho bạn cuộc sống. endbản thân nó cũng bị che khuất ... bây giờ nó sẽ không làm gì cả.)

Lưu ý rằng tất cả các lệnh sẽ vẫn thực thi ... chỉ là bây giờ chúng được xác định là không làm gì cả. Bạn sẽ không nhận được bất kỳ lỗi nào, chỉ là sẽ không có gì xảy ra. (Chà, tôi cho rằng việc tràn stack sẽ xảy ra cuối cùng ...)

Bất kỳ chương trình thực thi nào trong Linux / x86 (-64)

Chương trình này được viết bằng C, nhưng nó có thể phá vỡ sự thực thi của bất kỳ chương trình nào chạy trong Linux / x86 (-32 hoặc -64). Bạn đưa nó vào lệnh gọi dòng lệnh của chương trình bạn muốn ngắt.

Nó sử dụng API trình gỡ lỗi để ngăn chương trình đích tạo ra bất kỳ đầu ra nào. Cụ thể, tất cả các cuộc gọi hệ thống có thể giao tiếp với thế giới bên ngoài quy trình (tất nhiên write, rõ ràng nhất là openkhi tạo tệp, phần lớn API ổ cắm, killkhi được áp dụng cho quy trình khác, ...) sẽ thất bại như thể họ đã không thực hiện được. _exitđược cho phép, nhưng mã thoát được ghi đè bằng 0.

Không giống như phiên bản trước của câu trả lời này, nhiều chương trình có thể chạy gần hoàn thành trong các điều kiện này; chỉ là tất cả công việc của họ bị lãng phí. Chẳng hạn, nếu bạn làm ./no-syscalls /bin/ls(giả sử GNU coreutils ls), nó sẽ đọc toàn bộ thư mục và định dạng nó, và sau đó tất cả các writelệnh gọi để tạo đầu ra đều thất bại. (Bất cứ điều gì cần mở kênh liên lạc hai chiều, tuy nhiên, chẳng hạn như tất cả các máy khách X11, sẽ thất bại tại thời điểm đó. Tôi nghĩ về việc cho phép socketnhưng không send, nhưng dường như quá có khả năng mở sơ hở.)

Có một số tùy chọn dòng lệnh để điều chỉnh hành vi;

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

Các chương trình được liên kết động thậm chí sẽ không thoát khỏi trình liên kết động trong -echế độ. -Srõ ràng mở ra một lỗ hổng lớn trong chính sách, nhưng thật thú vị khi xem các chương trình than vãn về việc không có gì hoạt động, ví dụ

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

Bạn phải đọc đầu ra nhật ký với /usr/include/asm*/unistd.hmở trong một cửa sổ khác, vì điều này đã khá đủ dài.

Đáng buồn thay, các giao diện trình gỡ lỗi mà việc sử dụng này chỉ nhất quán yếu trong các triển khai Unix và về bản chất là dành riêng cho CPU. Việc chuyển nó sang các kiến ​​trúc CPU khác sẽ tương đối đơn giản (chỉ cần thêm các định nghĩa phù hợp SYSCALL_*_REG) và có thể chuyển nó sang bất kỳ Unix nào có ptrace, nhưng bạn có thể cần phải xử lý rộng rãi danh sách trắng của tòa nhà chọc trời cũng như xử lý các phân kỳ trong 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

Tôi không chắc điều này sẽ thực sự hoạt động, nhưng trên lý thuyết, điều này sẽ phá vỡ \khi nhân vật thoát ra khiến bạn không có cách nào khắc phục nó. Thông thường TeX có thể đọc và ghi tệp, bây giờ nó không thể viết bất cứ điều gì phụ thuộc vào logic. Do đó, ngôn ngữ hiện bị hỏng theo định nghĩa của OP.

EDIT: Các lệnh kill khác được lấy từ các bình luận (mặc dù cả hai đều có thể vi phạm quy tắc bắt buộc phải thực thi):

• \def\fi{}\iffalsebởi smpl tạo ra một không thể đóng nếu nhánh
• \catcode13=9%bởi iwillnotexist idonotexist tạo ra một bình luận không bao giờ kết thúc

Vết trầy

Các when [timer v] > (0)sẽ chạy càng sớm càng mã được khởi tạo, mà nếu bạn đang ở trong trình soạn thảo là trước khi bạn thậm chí bắt đầu mã. Điều when I receive (join[][])này sẽ khiến một lỗi được đưa ra mỗi khi phát sóng bất cứ thứ gì, tạm dừng thực thi mã nếu bạn có phiên bản Flash dành cho nhà phát triển. Các breakchức năng sẽ tạo ra bản sao, và kích hoạt các lỗi phát sóng. Mỗi bản sao duy nhất sẽ tồn tại hai giây sau đó tự xóa, gây căng thẳng cho ngăn xếp. Và mọi bản sao sẽ đáp ứng when [timer v] > (0), chạy breakchương trình con và đặt lại bộ định thời, khiến mã hẹn giờ được chạy lại. Ngoài ra, mỗi bản sao cũng sẽ đáp ứng với mọi lỗi phát sóng, có nghĩa là số lỗi trên mỗi đánh giá breaklà số lượng bản sao bình phương. Tôi đã quên đề cập rằng breakchức năng córun without screen refreshđã kiểm tra, làm cho trình soạn thảo bị đóng băng, giật và lag, cũng như lấy và phân bổ bộ nhớ. Và tối đa hóa CPU.

Bất kỳ mã nào được thêm vào bất cứ nơi nào có hoạt động này sẽ thấy bản thân không thể tạo bản sao (vượt quá giới hạn 300 bản sao) cũng như làm nóng và làm hỏng máy tính đang chạy nó. Và lấy bộ nhớ cho đến khi không còn gì để lấy, để lại các biến số sai.

Và, sau khi có quá nhiều độ trễ để kích hoạt when [timer v] > (0)khối, nó vẫn sẽ chạy break.

Cảm ơn @towerofnix đã nhắc nhở tôi về when I receivetrục trặc mà tôi đã tìm thấy một lúc trước và cho tôi ý tưởng run without screen refresh. Nếu bạn thích điều này, đây là bản gốc: https://codegolf.stackexchange.com/a/61357/43394

Ngôn ngữ toán học / Wolfram

Mathematica là một ngôn ngữ được giải thích trong đó tên lệnh là các ký hiệu có thể được lập trình viên thao tác. Bạn không thể xóa các toán tử tích hợp, nhưng bạn có thể quá tải chúng hoặc sửa đổi chức năng của chúng. Việc sau đây làm xáo trộn lệnh "With", cần thiết để gán cho các biến ngay cả trong nội bộ. Thay đổi này ngăn hạt nhân giữ các đối số không được đánh giá cho đến khi hoàn thành nhiệm vụ và nó giết chết ngôn ngữ.

ClearAttributes["With", HoldAll]

Nếu lệnh này được chạy trong một phiên tương tác hoặc trong một khối mã, Mathicala thậm chí sẽ không thể thêm 1+1(thông báo lỗi kết quả là khoảng một trang dài vì vậy tôi sẽ không đưa nó vào đây).

PHP

Tôi cho rằng nó thực sự hoạt động, nhưng đóng STDOUTvà STDERRtriệt tiêu tất cả đầu ra. Để chắc chắn rằng chúng sẽ không được mở lại, chúng tôi mở /dev/nullba lần để gán lại các mô tả tệp 0, 1 và 2:

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

// insert program here

Thêm về điều đó: https://stackoverflow.com/questions/937627/how-to-redirect-stdout-to-a-file-in-php

Tôi tin rằng lô DOS (trước Windows 95)

CTTY

Do không có đối số, điều này ngắt kết nối dòng lệnh khỏi thiết bị đầu cuối. Bất kỳ nỗ lực nào nữa để đọc đầu vào hoặc tạo đầu ra không làm gì cả.

Trong trường hợp bạn muốn biết cách sử dụng CTTY chính xác:

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

Một tệp bó mạnh hơn một chút thậm chí có thể trả lời modem và kết nối bất cứ thứ gì được quay vào CTTY.

Lisp thường gặp

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

Tôi hy vọng bạn không cần những dấu ngoặc đơn mở.

Đây là một macro người đọc yêu cầu Lisp Reader thay thế từng phiên bản (bằng một lệnh gọi đến (lambda (x y) ()), một hàm có hai đối số và không trả về gì. Vì vậy, ví dụ, nó sẽ đọc (foo)như foo), diễn giải foonhư một biến và sau đó đưa ra một lỗi ngoặc đơn chưa từng có 0.

Vết trầy

Đây là một ví dụ khá đơn giản sẽ làm sập trình duyệt của bạn (và trên lý thuyết là máy tính của bạn):

Tôi đã để nó chạy trong khoảng hai mươi giây, sau đó mất 2,65 GB bộ nhớ cho Scratch. Chỉ một lát sau và 5 GB đã biến mất.

Tôi thực sự khuyên bạn nên có một cách để buộc Adobe Flash hoặc trình duyệt web của bạn trước khi chạy cái này!

^{Tôi thực sự muốn đưa ra một câu trả lời tuyệt vời như câu trả lời của clear(this)JS nhưng thật đáng buồn là Scratch không có cách nào để làm điều đó. Vui lòng cập nhật bài đăng này (hoặc tự tạo) nếu bạn KHÔNG tìm cách khác để làm cho Scratch không thể sử dụng được!}

Thứ ba

::=

Với một dòng mới ở cuối

Ngôn ngữ thue dựa vào việc xác định các quy tắc và ::=biểu thị sự kết thúc của quy tắc. Không thể thực hiện BẤT CỨ điều gì trong thue mà không xác định các quy tắc làm điều đó, vì vậy bất kể bạn đặt gì sau đó ::=, không có gì có thể xảy ra.

Câu trả lời thay thế

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

(v.v. đối với mọi ký tự trong tất cả Unicode bao gồm cả các Aký tự trước ký tự và ký tự không in được). Điều này đòi hỏi tùy chọn dòng lệnh -r.

MATLAB

Đoạn mã sau đây làm cho môi trường hoàn toàn không sử dụng được ¹ :

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

Điều này ghi đè builtinchức năng và clearchức năng với các hàm xử lý ẩn danh mới chỉ trả về falsemỗi khi bạn thử và gọi các hàm này. Các builtinchức năng đảm bảo rằng nếu có bất kỳ chức năng tùy chỉnh bạn viết trong MATLAB có tên giống như những người được tích hợp để MATLAB (những thứ như sum, max, min, vv), bạn có thể gọi những rõ ràng thay vì các chức năng quá tải . Tương tự, clearcung cấp cho bạn khả năng xóa tất cả các biến hiện đang được khai báo để bạn có thể bắt đầu lại. Bằng cách loại bỏ các khả năng này, không có cách nào bạn có thể sử dụng MATLAB trừ khi bạn khởi động lại chương trình.

Trong MATLAB R2015a, tôi cũng nhận được thông báo sau:

Workspace là các biến hiện được khai báo trong môi trường để bạn có thể sử dụng chúng cho lần sau. Điều này sẽ vô hiệu hóa vĩnh viễn Workspace, do đó, bất kỳ biến nào bạn thử và tạo sẽ không được lưu và do đó không thể thực hiện được tiến trình nào khi thực hiện các dòng mã trong MATLAB.

^{1: Tín dụng cho người dùng Dev-iL , người đầu tiên phát hiện ra ý tưởng.}

///

/\///

Hoạt động duy nhất trong /// là lặp lại chuỗi thay thế, như thế này : /pattern/replacement/.

Mã này loại bỏ mọi /, theo cách mà bạn không thể sử dụng thay thế chuỗi lặp đi lặp lại, vì vậy về cơ bản mọi thứ bạn viết sau đó sẽ được in (ngoại trừ /s).

Bạn vẫn có thể sử dụng \s, nhưng điều đó sẽ không giúp bạn nhiều.

Befunge-96

'~h

Mã người dùng có thể theo bất cứ nơi nào sau chuỗi này, miễn là đây là ba ký tự đầu tiên trong nguồn.

Các 'lệnh (one-shot chuỗi mode) đẩy giá trị ASCII của ~vào stack (tức là 126), và các hlệnh sau đó tập hợp những gì được gọi là Delta Holistic với giá trị đó. Đối với những người không quen thuộc với Befunge-96, Holistic Delta là phần bù được thêm vào giá trị của mỗi byte lệnh mà trình thông dịch gặp phải.

Khi delta được đặt thành 126, lệnh hợp lệ duy nhất có thể được tạo là ~(nhập ký tự), thông qua một byte null trong nguồn. Bất cứ điều gì khác ngoài byte rỗng sẽ chuyển thành giá trị lớn hơn 126 và không có giá trị nào trong số đó là các lệnh Befunge hợp lệ.

Tôi nghĩ thật an toàn khi nói rằng điều này sẽ khiến nó không đủ điều kiện để đủ điều kiện là ngôn ngữ lập trình.

Boo

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

Và sau đó, ở một nơi khác trong dự án,

harmless

Một macro đơn giản với một cái tên nghe có vẻ vô hại, nhưng một hiệu ứng bực bội đáng kinh ngạc. Trình biên dịch Boo sử dụng một đường dẫn gồm nhiều bước bắt đầu bằng việc phân tích nguồn vào AST và kết thúc bằng việc tạo mã. (Nói chung. Nó có thể được cấu hình lại cho các ứng dụng khác nhau.) Mỗi ​​bước ở giữa thực hiện các hoạt động khác nhau trên AST.

Một phần là giai đoạn mở rộng vĩ mô, trong đó các macro được thực thi trong ngữ cảnh của trình biên dịch. Nhớ bit trong đoạn cuối, về đường ống được cấu hình lại? Nếu trong quá trình mở rộng macro, bạn gọi macro xóa đường ống, sẽ không có lỗi nào được hiển thị cho người dùng, nhưng tất cả các bước sau khi mở rộng macro (bao gồm cả tạo mã) không còn ở đó nữa. Vì vậy, bạn kết thúc với một cái gì đó trông giống như một bản biên dịch thành công - không có thông báo lỗi nào được hiển thị - nhưng vì một số lý do, không có nhị phân nào được tạo ra! Đảm bảo lái xe ngay cả những người khắc phục sự cố tốt nhất lên tường, nếu bạn che giấu macro và lời gọi tốt.

NGN / APL

NGN / APL cho phép xác định lại các nguyên thủy, do đó, việc xác định lại ( ←) tất cả các hàm nguyên thủy thành ⊢("chuyển qua": cả hai ⊢3và 2⊢3cho 3) làm cho ngôn ngữ hoàn toàn vô dụng:

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

Hãy thử nó ở đây.

Ruby (29 ký tự)

class Object;def send;end;end

Vì 'gửi' được sử dụng nội bộ bất cứ khi nào một phương thức được gọi trong Ruby và vì tất cả các đối tượng kế thừa từ lớp Object. Điều này sẽ dừng bất kỳ phương pháp đang được chạy.

Sự thật thú vị: Đây là âm thanh hoàn hảo trong lý thuyết. Nhưng nó xuất hiện, vì một số lý do, không làm hỏng ngôn ngữ Ruby. Tôi không biết tại sao có thể chạy mã này và sau đó vẫn sử dụng môi trường Ruby mở.

Tcl

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

Điều này loại bỏ tất cả các từ khóa từ ngôn ngữ ngoại trừ ifvà rename.

Đoạn mã trên sẽ khiến bất kỳ mã mới nào bị lỗi. Vì vậy, thật đáng tranh luận nếu mã được chèn mới thực sự được "thực thi". Dưới đây là phiên bản thực thi mã mới nhưng không làm gì cả vì nó thay đổi tất cả các từ khóa (ngoại trừ ifvà proc) thành không hoạt động:

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

Thay vì xóa từ khóa, mã này thay thế chúng bằng một hàm không có gì.

(Lưu ý: Tôi đang sử dụng "từ khóa" rất lỏng lẻo ở đây vì Tcl không có từ khóa, chỉ có chức năng)

Hoon

=<  ~
(your code)

Hoon là một số lẻ. Nó hoàn toàn không giống với các ngôn ngữ lập trình khác, không chỉ về cú pháp mà cả về ngữ nghĩa. Tuy nhiên, không giống như các ngôn ngữ như Hexagony, nó không được tạo ra là bí truyền.

Hoon biên dịch thành Nock , một VM dựa trên tổ hợp tối thiểu. Nock là ngu ngốc: thông số kỹ thuật có thể được nén thành 340 byte. Các phép toán duy nhất là tăng dần. Tất cả mọi thứ là một danh từ: một nguyên tử (bignum) hoặc một tế bào (cặp danh từ), với toàn bộ mô hình bộ nhớ được sắp xếp trong một cây nhị phân tuần hoàn bất biến. Đầu ra duy nhất là danh từ mà biểu thức của bạn giảm xuống.

Vì mục tiêu biên dịch kỳ lạ, Hoon cũng kỳ lạ: nó hoàn toàn thuần khiết. Hoon biên dịch thành biểu thức Nock được đánh giá trên "bối cảnh". Toàn bộ kernel và stdlib, cùng với tất cả các biến, được truyền hoàn toàn cho chương trình theo ngữ cảnh.

Để làm cho Hoon không sử dụng được, chúng ta chỉ cần sử dụng =<, đó là "đánh giá a trong bối cảnh của b". Chúng tôi luôn luôn đánh giá ~, đó là con số không. Bất kể là gì b, nó không thể thay đổi giá trị mà nó giảm xuống và vì nó không thể có tác dụng phụ nên nó không thể làm đầu vào hoặc đầu ra.

Lưu ý bên lề: Vì bạn thực sự không thể nhắc nhập liệu từ Hoon (độ tinh khiết!), Theo quy tắc, đây không thực sự là ngôn ngữ lập trình. Đầu vào là thông qua các đối số chức năng, đầu ra thông qua các giá trị trả về (hoặc ~&, nhiều tính năng gỡ lỗi printf và trong suốt đối với chương trình).

Để một chương trình nhận đầu vào bằng Urbit, bạn thực sự viết một chương trình trả về một hàm chấp nhận đầu vào và shell thay mặt bạn hỏi và chuyển đến cuộc gọi lại.

Taxi, 2354 byte.

Chương trình nhỏ này chỉ đơn giản là chạy taxi trong một joyride lớn thông qua Townsburg, hết xăng. Bất kỳ mã nào bạn chạy sau này sẽ nhanh chóng bị lỗi error: out of gas. Và ngay cả khi bạn có thể đến trạm xăng, điều mà tôi không thể nghĩ là có thể, bạn không thể lấy bất kỳ loại xăng nào, vì không có tiền được thu thập, vì không có hành khách.

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 trong trình duyệt

Chà, ít nhất là trong IE11.

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

Vô hiệu hóa ghi vào tài liệu, ghi vào biến toàn cục và trở về từ hàm.

Nhận xét nếu tôi bỏ lỡ một phương thức đầu ra!

Python 2, cực kỳ lớn

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

Số lượng mã cực lớn này là sự hồi sinh của rexecmô-đun cổ (bị bỏ rơi trong python 2.3) với một loạt các mô-đun mới được thêm vào danh sách "ok" và một loạt các điểm yếu được khắc phục (bao gồm cả object.__subclasses__()phương pháp đã tạo ra ít nhất hai con trăn khác câu trả lời không hợp lệ).

Khá một chút mã này ( __init__phương thức của RExeclớp và toàn bộ ModuleImporterlớp) được sao chép từ thư viện chuẩn python với các sửa đổi nhỏ.