使您的语言无法使用


191

尝试用您的语言编写一些代码,并使其不再满足我们成为编程语言的条件

在以下情况下,一种语言可以满足我们作为编程语言的标准(此挑战的简化版本):

  • 它可以通过某种方式读取表示正整数元组的用户输入。
  • 根据输入,它可以输出至少两个不同的可能结果。
  • 它可以取两个正整数并将其相加(结果可能会影响输出)。
  • 它可以取一个正整数,并确定它是否为质数(结果可能会影响输出)。
  • 出于此挑战的目的,将忽略不是正常挑战允许的输出方法的任何类型的输出。因此,程序是否还可以播放音乐或通过HTTP发布等等都无关紧要。
  • 更新:您还可以选择一种或某些允许的输出方法,而忽略其他所有方法。但是您必须在以下条件中的任何地方使用相同的定义。而且,如果您的程序可以禁用不止一种输出方法,则值得进行更多投票。

例如,使其无法输出,或者禁用所有循环构造,这样它将无法进行素数测试并确保用户无法重新启用它们,例如。

您应该留出一个插入新代码的地方。默认情况下,它位于代码的末尾。如果我们考虑将源代码放在您的答案中,然后将完整的代码作为一个完整的程序(一种新语言的解释程序)运行,则该语言应不符合标准。

但插入的代码必须以这样的方式执行满足的标准语言:

  • 从想要编写语法突出显示的人的角度来看,插入的代码在语法上必须与通常满足条件的某些东西(例如,以下条件中的代码块)在语法上相同。因此它不能在字符串,注释等中。
  • 插入的代码必须以符合标准的方式实际执行。因此它不能出现在未使用的函数或sizeofC语言中,您不能仅执行代码中的非功能部分,也不能将其置于无限循环之后,等等。
  • 您不能限制以此方式生成的可能的语法正确程序的数量。如果您所使用的语言中已经存在长度限制之类的内容,则即使取消了此限制,它也不符合条件。
  • 您不能修改或“用完”输入/输出的内容,但是可以防止它们被访问。
  • 这些条件通常仅适用于没有显式I / O的语言:
    • 如果代码块通常无法直接/显式地使用您使用的语言来获取用户输入,则您的代码应将用户输入(包含任意长度的信息)重定向到插入的代码。
    • 如果代码块通常无法直接/显式地使用您使用的语言输出内容,则您的代码应打印出插入代码的返回值。
    • 如果您打印返回的值,并且使用您使用的语言键入了该值,则返回的类型应能够具有2种实际可能的值。例如,您不能使用类型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>


我可以在执行代码之前更改代码吗?另外,我可以在运行给定代码的同时运行其他代码吗?
蓝色

21
我认为这可能会给警察和强盗带来巨大挑战。
DankMemes

6
@DankMemes同意。就目前而言,这太含糊了,大多数答案将因找到解决方法而失效。以此为前提的CnR将会令人愉快。
Mego

3
因此,这似乎意味着在具有显式IO的语言中,完全可以做无聊的事情,例如读取和丢弃stdin的内容。它建立了一个完全不公平的竞争环境,其中某些语言要求您仔细处理所插入代码的IO,而其他语言则允许您对其进行垃圾处理并拒绝所插入代码的IO。
彼得·泰勒

1
我们是否可以使用一开始就无法使用的语言?(例如JavaScript)
12Me21年

Answers:


319

JavaScript Shell

这将使该语言完全不可用。

clear(this);

JavaScript如何具有如此出色的功能来自我销毁,这不是很好吗?


这很简单,clear函数完全清空了一个对象。this指清除所有内容(包括构造函数和函数)的全局对象。


因为这样可以清除所有内容,执行任何操作甚至定义文字也将引发错误,从而使该语言完全无用: * REPL环境不是必需的。使用SpiderMonkey引擎(不是浏览器的外壳),即原始JS引擎。用法示例


4
clear功能似乎是SpiderMonkey-shell的特定附加功能,而不是通用的JavaScript。它肯定不会出现在ES5规范§全局对象的功能属性中。我尝试使用此方法,node并收到“ ReferenceError:未定义清除”。在Chrome和Firefox的控制台中clear,无论传递什么参数,该功能都将清除控制台。还是您所使用的工具符合早于5.1的ECMAScript版本?
Anko

2
您是否可以改为修改语句“ JavaScript如何具有如此出色的功能来销毁自己呢?” JavaScript没有该功能,只有SpiderMonkey实现具有。
安科

1
@Anko SpiderMonkey虽然是JavaScript,但与Firefox捆绑在一起(SpiderMonkey Firefox的JS引擎)。稍后,我将在有空的时候为node.js等编写一个版本
Downgoat

6
我认为您正在将JavaScript(语言)与SpiderMonkey该语言的许多实现之一)混淆。极端的寓言:虽然我可以编写一个疯狂的C 实现,其中所有未定义行为的调用都导致打印《人权宣言》的全文,但我可能无法辩称我对“ UDHR高尔夫”的C提交仅取消引用空指针的“是有效的C解决方案。:)
Anko

8
@Anko作为每个站点规则,一种语言是由其实现定义的。如果答案在问题之前发布的至少一个实现中始终有效,则可以接受。看到这里这里。(所以代码是有效的。但是我不会评论该特定措辞。)
jimmy23013 '02

169

艾门塔尔

;#33!

我知道这不是高尔夫的代码,而是适合工作的正确工具,你知道...

可以在后面插入用户代码!

Emmental是一个有趣的esolang,它基于重写解释器。每个符号(包括内置符号)都可以重新定义为任意Emmental程序。该语言非常依赖此功能,因此不提供任何循环结构。而是定义递归命令,这些命令将出现在它们自己的定义中。

这种重新定义是通过进行的!,它从堆栈中读取一个字符,然后从堆栈中读取一个字符串,直到遇到a为止;。然后将字符重新定义为表示该字符串表示的程序。

这意味着,我们可以通过将! 自身重新定义为空程序来禁用Emmental的循环功能。尽管所有其他的Emmental代码仍然可以完美运行,并且仍然满足编程语言的许多标准,但是无法重新定义任何符号。没有此功能(因此无法循环),Emmental将无法再测试数字是否为质数。


49
禁用语言的单一定义功能:纯天才。这无疑是完成这项工作的正确工具。+1
ETHproductions 2015年

93

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

这将避免删除用于捕获要压缩的输出的自动启动的输出缓冲区的问题。

这也可以防止输出缓冲区被删除或刷新(发送到浏览器)。为了加强这一点,添加了一个输出处理程序,该处理程序始终返回一个空字符串。
运行ob_end_flush(); echo "Hello, world!";不会产生任何结果,但是会以普通形式发送输出ob_start();

感谢@LucasTrzesniewski公开了此问题!


1
由于您可以具有严格的输出缓冲级别,因此第二个级别不起作用。通常,while(ob_get_level()) ob_end_flush();在框架中使用它来刷新所有可能意外打开的输出缓冲区。
Fabian Schmengler,2015年

@fschmengler这将导致自动打开的输出缓冲区出现问题,通常使用gzip压缩输出。反过来会破坏目的。
Ismael Miguel

可以通过以下方法绕过此问题:ob_end_flush(); echo "Hello, world!";
卢卡斯Trzesniewski 2015年

8
为什么我对PHP最终进入投票表顶部并不感到惊讶:)
MonkeyZeus 2015年

47
This shouldn't even throw any error, since there isn't enough memory for that.大声笑在那:)
ETHproductions 2015年

91

实模式下的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

我希望您不要太依赖中断表。


75
先生,如果我可以打扰您几个周期,以便我说完……。–
发光

6
那么,如果我插入的代码的第一条指令是cli,然后修复中断表,然后继续计算一些素数,该怎么办呢?
Nate Eldredge

3
@NateEldredge:下一步是将其余代码监禁到第3圈,而没有蹦床则回到第0圈;我将查看是否能够整理一个有效的示例(另一种可能性是扫描整个地址空间,并全部清除cliinp并且outp仅出于很好的考虑),但是我不知道是否可以这样做
Matteo Italia

2
至少就目前而言,这不会阻止程序直接将其写入屏幕缓冲区(这在DOS下非常普遍)。
杰里·科芬

1
@NateEldredge:规则还不是很清楚,如果您环顾四周,大多数答案实际上都包含对环境的修改,这些修改会在琐碎的指令上产生某种类型的运行时错误(JS clear(this);,PHP中的内存限制,递归Python中的限制,Python中的沙盒环境等),我不会认为这是一个问题。
Matteo Italia

68

爪哇

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,并确保程序无法设置退出代码。




10
+1就我个人而言,我不认为/ proc解决方法是真正的破坏者,因为我不使用Linux,并且我的Unix OS和Windows OS都没有/ proc文件系统。
杰里·耶利米

67
到目前为止,此挑战的摘要:1. JavaScript,12个字符。2. Emmental,6个字符。3. x86,12个字节。4. Python,42个字符。5. Java,2264个字符!为什么我不感到惊讶?
于2015年

34
@ceasedtoturncounterclockwis这是因为Java更安全,所以更难破解:D
Pierre Arlaud 2015年

62

a

_ENV=""

在Lua中,_ENV是所有全局变量,函数,表等都存储在其中的环境。将其定义为空字符串意味着您无法定义任何新内容,并且会擦除所有函数和变量。这意味着您无法输出任何内容,无法接受输入或几乎无法执行任何操作。


1
_ENV=5工作吗?如果是这样,则短一个字符。
immibis 2015年

7
@immibis是的,但这是一场人气竞赛,而不是代码长度竞赛。PS-相信您可以加入Lua的答案。
法拉普

+1为Lua。$ _G = nil $也不会或多或少都一样吗?
Doddy

@Doddy Nope,因为_G只是_ENV的一个副本,您可以使用它来查找变量和类似的内容-它实际上不是环境。但是,您可以执行_G = nil,然后将环境设置为_G,这将具有相同的效果。
TreFox

并非完全正确。如果本地变量中有备份,则可以还原它。您仍然可以定义局部变量,甚至可以调用与字符串相关的函数!
瓦尔

46

莎士比亚编程语言

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。这很棒。


1
那么,它是解析错误还是运行时错误?
Fabian Schmengler,2015年

4
@fschmengler对于解释语言,这基本上是相同的。
nwp 2015年

13
如果我在最后一行之后添加代码,它实际上会执行吗?
Sp3000

@ Sp3000它将肯定会尝试……它将似乎没有任何异常发生……直到解析器崩溃。:)
3.14ed_Piper 2015年

43

短暂聊天

我不确定这是否符合条件:

Smalltalk := Nil.

这将删除整个运行时环境,并挂起对象引擎。解决此问题的唯一方法是强制终止该过程并从备份重新启动。

对于那些不知道的人,[Visual Works] Smalltalk的工作方式有些奇怪。就像一个迷你操作系统。当启动Smalltalk时,您将一个“内存映像”加载到RAM中,并从中断处继续执行。整个Smalltalk IDE用Smalltalk编写,并且可以动态修改。

特别Smalltalk是包含所有全局变量的字典。最特别地,每次声明新类时,都会创建一个具有该名称的全局变量,指向Class新类的对象。因此,设置SmalltalkNil(基本上为null)会删除整个系统中的所有类。甚至GUI事件处理程序也很糟糕。

我不知道为什么这个变量甚至是可写的。可能是因为它是一个全局变量,因此在其内部作为条目存在。(您的头部还疼吗?我是否提到每个对象都有一个类,而类是对象,所以每个类都有一个类?类的类称为元类,但元类也是对象,因此具有一类...)

通过清除字典而不是将其替换为null,可能会达到类似的效果。确实,您可以编写许多代码来删除系统中的所有类,从而无能为力。但是由于实际的Smalltalk编译器也是一个类...破坏语言的任何内容也都会破坏整个IDE,所以...


如果它本身挂起,则无效,但下一个命令不会挂起。但是我很好奇:它是否有一个可以同时将值作为类和作为普通对象的类?一个可以同时具有这些值和这个新类的类?还有一类本身?
jimmy23013

Smalltalk类有点像JavaScript原型。通过足够努力地入侵系统类,您甚至可以将Smalltalk变成一种多继承语言。同样,方法调用是对象,代码块是对象...您可以拦截未定义的方法调用并使它们执行操作...这是一种非常动态的语言。一切都是对象!包括IDE ...
MathematicalOrchid

1
不得不使用nil而不是Nil在Pharo中。
mgarciaisaia

5
另一个是true become: false,但是我认为这在该语言的较新版本中不起作用。您可以通过这种方式杀死SmallTalk / V 286。

15
“我是否提到每个对象都有一个类,而类是对象,那么每个类都有一个类吗?一个类的类称为元类,但是元类也是一个对象,因此具有一个类……”作为一名Pythonista,我的头根本没有受到伤害。相反,我想我会和Smalltalk在一起的。
Blacklight Shining 2015年

40

哈斯克尔

这里有两种可能。

无聊的想法#1:定义main什么都不做。现在,无论您编写什么其他代码,它都将永远无法执行。(除非您从REPL手动运行它。)

无聊的想法2:定义一个没有公共出口的模块。现在,无论您编写什么其他代码,它都将永远无法执行。

有趣的主意:禁用所有导入。

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

现在,您可以定义哪些功能可见的,可以运行...但他们也无能为力。现在,所有标准的Haskell类型和功能都已隐藏。(除了一些确实与语言紧密联系的东西。)

最特别的是,您无法执行任何I / O。您也不能执行机器精度算术。(因为IntDouble等等现在未定义。)

您仍然可以编写可以执行某些实际计算的lambda-calculus函数。您只是无法将任何数据输入或输出。但是您当然可以编写另一个单独的模块,该Fubar模块调用上面的模块并代表它执行I / O(从而证明代码确实可以执行并且可以完成工作)。

一些细微之处:

  • foo = foo需要使用伪声明来防止任何人添加其他导入。(导入不能声明出现。)

  • 有各种非标准的Haskell语言扩展,可以使您摆脱这种情况。但是必须使用文件顶部的编译器编译指示来打开语言扩展。(或者通过命令行切换到编译器。我真的不能阻止它!)


-0.1使用foobar,您使用的拼写有一些...意想不到的含义。
wizzwizz4 2015年

@ wizzwizz4我很确定“ foobar”只是为了避免审查程序而设置的“ fubar”。这就是为什么我倾向于在编程示例中避免使用它。
jpmc26 2016年

3
@ jpmc26实际上,它有着悠久而杰出的历史,它经历了一个MIT模型培训小组,在被编入文档之前被一本编程书籍所普及,然后被引入流行文化。我很确定这是一个巧合。
wizzwizz4 '16

这两个“无聊的想法”都是无效的,因为实际上并未执行用户代码。(尽管“有趣的想法”似乎是有效的)
pppery

40

后记

是的,PostScript是一种编程语言。此外,它是一种编程语言,其中所有语言构造都是系统定义的函数,可以重新定义 ...

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

用英语:

  • 创建一个空的1000元素字典并将其命名Magic
  • 对于中的每个键systemdict,将相同的键添加到Magic,并使用空定义(“ {}”)。
  • Magic入词典堆栈的顶部。

从现在开始,每个PostScript语言命令都定义为不执行任何操作。AFAIK,不可能逃脱这种情况。

(从技术上讲,您不是在“破坏”旧定义,而是在阴影化它们。如果仍然可以执行end,则会Magic从词典堆栈中弹出,取消所有命令的阴影,使您的生活恢复原状。但是,由于end本身也被遮盖住了...它现在什么也不做。)

请注意,所有命令仍将执行 ...只是现在将它们定义为不执行任何操作。您不会得到任何类型的错误,只是什么也不会发生。(嗯,我想最终会发生堆栈溢出...)


这实际上有点可笑...而且也很可怕...
Gryphon

34

在Linux / x86(-64)下执行的任何程序

该程序是 C语言编写的,但是它可能会中断在Linux / x86(-32或-64)下运行的任何程序的执行。您可以将其放在要破坏的程序的命令行调用之前。

它使用调试器API防止目标程序产生任何输出。具体来说,所有可以与进程外的世界进行通信的系统调用(write当然,最明显的是,当然,而且open在创建文件时,套接字API的大部分(kill应用于其他进程时……))都会失败。好像它们没有实现。_exit允许,但退出代码被零覆盖。

与该答案的上一版本不同,在这些条件下,许多程序几乎可以运行完毕。只是他们所有的工作都浪费了。例如,如果您这样做./no-syscalls /bin/ls(假设使用GNU coreutils 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在另一个窗口中打开时读取日志输出,因为这已经足够长了。

可悲的是,此调试器接口在Unix实现中仅保持弱一致性,并且本质上是特定于CPU的。将其移植到其他CPU体系结构相对简单(只需添加的适当定义SYSCALL_*_REG),并且可能将其移植到具有的任何Unix上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));
    }
  }
}

1
“目标可以读取其命令行参数,执行纯计算并产生8位退出状态,但是将无法分配内存或执行I / O” —我不知道,我认为您仍然符合这四个条件。整数可以从命令行参数解释;出口状态可用于简单输出;添加不受阻碍;素性测试所需要的就是进行纯计算,一点堆栈空间和一个循环的能力。
Blacklight Shining 2015年

1
@BlacklightShining我认为相对于正常行为而言,这实现了很大的限制,即使您仍然可以编写一个主要的测试器,也可以接受,但是-DNO_EXIT模式适用于那些感觉与您一样的人。在那种模式下不可能有有意义的输出。
zwol15年

1
@BlacklightShining我考虑了一下,基本上从零开始重写了该程序。现在它的功能相当聪明,而且(我希望)甚至可以最严格地理解这一挑战。
zwol

2
@Joshua这很聪明,很难阻止使用这种方法(因为程序只是在修改自己的内存),但是它目前不在“允许的输出方法”列表中。
zwol

6
@JesseTG您熟悉strace吗?
zwol

30

TeX

\catcode`\\=10

我不确定这是否会真正起作用,但从理论上讲,这应该会\以转义符的形式出现,使您无法修复它。通常,TeX可以读取和写入文件,现在它不能写入任何依赖于逻辑的内容。因此,该语言现在已按照OP的定义被破坏。

编辑: 其他从注释中删除的kill命令(尽管两者都可能违反了必须执行的代码规则):


3
更好的版本:\def\fi{}\iffalse。我无法对此发表答案,因为它要求至少从该站点获得10个代表,但这也将不再允许输出。
user530873

1
@smpl您仍然可以重新定义\fi其原始含义,对吗?因此,该语言不会受到任何破坏。
头足类动物2015年

1
@Cephalopod \fi是TeX原语。没有,您现在还不能重新定义任何内容\iffalse
user530873

1
@smpl嗯,我明白了。非常聪明。
头足类动物2015年

1
+1。我刚开始用TeXBook进行自学,当我意识到\catcode13=9%会完全破坏该语言时(之后的所有内容都%被注释,换行符(ASCII char 13)被忽略,因此注释扩展到无穷大),我想在这里发布它。但是这里已经有一个稍长的命令。
Iwillnotexist Idonotexist

29

打破划痕图像
when [timer v] > (0)代码将在代码初始化后立即运行,如果您在编辑器中,则该代码甚至在您启动代码之前运行。这样做when I receive (join[][])会导致每次广播的内容都引发错误,如果您使用的是Flash开发人员版本,则会暂停执行代码。该break函数将创建克隆,并触发广播错误。每个克隆将持续两秒钟,然后删除自身,使堆栈承受压力。每个克隆都将响应when [timer v] > (0),运行break子例程并重置计时器,这将导致计时器代码再次运行。同样,每个克隆也将响应每个广播错误,这意味着每次评估的错误break数是克隆数的平方。我是否忘了提到该break功能具有run without screen refresh检查,导致编辑器冻结,颠簸和滞后,以及抓取和分配内存。并最大化CPU。

任何在此运行时添加到任何地方的代码都将发现自己无法创建克隆(超过了300个克隆限制),并且无法使运行它的计算机升温并使其崩溃。抓取内存,直到没有更多要抓取的地方,从而使变量行为异常。

而且,在触发when [timer v] > (0)块的延迟过长之后,它仍然会运行break

感谢@towerofnix提醒我when I receive一段时间后发现的故障,并给了我想法run without screen refresh。如果您喜欢这个,这里是原始内容:https : //codegolf.stackexchange.com/a/61357/43394


+1在其中运行原子块(无需屏幕刷新即可运行)可能也很有趣stop this script:P
Florrie 2015年

该“ when I receive故障” 如何工作?
Scimonster

@Scimonster when I receive帽子块仅设计为从下拉列表中获取输入。该join[][]块返回该when I recieve块不旨在接受的数据类型。每次广播某些内容时,所有帽子块都会检查并评估该块的返回值,从而引发incorrect type错误。
wizzwizz4 2015年

我懂了。尽管您必须修改JSON文件才能真正将代码join块放入其中。
Scimonster,2015年

1
@ppperry它取决于忽略错误的Flash版本- 确实存在。极端地讲,“足够小n”可以用来表示(n-1)对正数n<3 起作用,但是由于这是基于算法的,因此好的算法应该能够n足够大,从而可以忽略该论点。我不确定是更快还是更慢的机器会使其更有用。但是,我同意可以解决此问题。这不是警察和强盗,但无论如何都做得很好。
wizzwizz4

27

Mathematica / Wolfram语言

Mathematica是一种解释性语言,其中命令名是可以由程序员操作的符号。您不能删除内置运算符,但是可以重载它们或以其他方式修改其功能。以下代码对“ With”命令进行了加扰,即使在内部也要对变量进行分配。此更改可防止内核在赋值完成之前保留未评估的参数,并杀死该语言。

ClearAttributes["With", HoldAll]

如果此命令在交互式会话中或代码块中运行,则Mathematica甚至无法添加1+1(生成的错误消息大约需要一页,因此在此不再赘述)。


26

的PHP

我很惊讶它确实有效,但是关闭STDOUTSTDERR抑制了所有输出。为确保它们不会再次打开,我们打开了/dev/null3次以重新分配文件描述符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


还有其他有效的输出形式,包括写入文件和使用程序的退出代码。请参阅规范相关项目符号中的链接。
马丁·恩德

1
确切允许的内容和不明显的内容对我而言并不明显。例如,在标签Wiki中,我没有发现有关文件和退出代码的任何信息。但是,如果允许,我认为我无法将其转变为有效的提交方式。
Fabian Schmengler,2015年

编辑了问题,以仅禁用一种输出形式。
jimmy23013

20
@ jimmy23013什么?这完全解决了问题的要点。
hobbs 2015年

5
@ jimmy23013如果仅禁用一种输出形式是有效的,那么即使该语言无需退出代码即可完全使用,我也只需要抑制程序的退出代码(如Martin所建议的那样)?
杰里·耶利米

24

DOS批处理(我相信在Windows 95之前)

CTTY

发出不带参数的命令,这会断开命令行与终端的连接。读取输入或生成输出的任何进一步尝试均无济于事。

如果您想知道如何正确使用CTTY:

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

稍微强大一点的批处理文件甚至可以应答调制解调器,并将拨入CTTY的所有内容连接起来。


23

普通口齿不清

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

希望您不需要这些括号。

这是一个reader宏,它告诉Lisp Reader将对的每个实例替换为(对的调用(lambda (x y) ()),该函数接受两个参数且不返回任何内容。因此,例如,它将读取(foo)foo),解释foo为变量,然后在上引发不匹配的括号错误0


2
也请解释)为易碎物品!这样,错误将更少。
wizzwizz4 2016年

7
我喜欢这个。“ lisp依赖什么?一个字符?如果发生了什么…… 这将是可耻的……”这与在TeX中重新定义`\`的逻辑相同。
felixphew

23

这是一个非常简单的示例,它将使您的浏览器(理论上也将导致计算机)崩溃:

即时崩溃

我让它运行了大约二十秒钟,然后为Scratch丢失了2.65 GB的内存。片刻之后,5 GB消失了。

我极力建议您在运行此方法之前可以强制退出Adobe Flash或Web浏览器!


真的很想像clear(this)JS 一样做出很酷的回答,但可悲的是Scratch没有任何方法可以做到这一点。如果您确实找到另一种使Scratch无法使用的方法,请随时更新此帖子(或创建您自己的帖子)!


2
您在哪里添加用户代码,它实际上执行了吗?
jimmy23013 2015年

用户代码?只要插入此代码段,就在项目中的任何位置。它在初次运行后0.3秒执行一次,然后每0.3秒执行一次(除了它还会不停地重新运行脚本,这使Scratch非常慢)。如果我用更好,更强大的崩溃程序更新此帖子,可以吗?
Florrie

5
有人在使用Scratch ... d:-D耶!!!
wizzwizz4 2015年

@towerofnix顺便说一下,我已经在这里进行了改进/彻底修改/重新创建了此代码:codegolf.stackexchange.com/a/61490/43394我的并不依赖于麦克风。
wizzwizz4 2015年

1
@ wizzwizz4是的,你的比我的要好得多。请去投票了
弗洛里

20

ue

::=

以换行符结尾

轮流语言依赖于定义规则集,而a ::=表示规则集的结尾。如果没有定义执行规则,就不可能在星期四中做任何事情,因此,不管您放置了::=什么,都不会发生任何事情。

替代答案

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

(以此类推,对于所有Unicode中的每个字符,包括该A字符之前的字符和不可打印的字符)。这需要命令行选项-r


我想文字与满足标准的内容(例如规则集)在语法上不一样。
jimmy23013

16

的MATLAB

以下代码使环境完全不可用1

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

这将覆盖该builtin函数和clear具有新匿名函数句柄的函数,这些匿名句柄在false您每次尝试调用这些函数时都会简单地返回。该builtin功能可确保如果有你在MATLAB编写任何自定义的功能是相同的名称作为那些内置于MATLAB(喜欢的事物summaxmin等),你可以明确地改为调用的重载函数,这些。同样,clear您可以清除当前已声明的所有变量,以便重新开始。通过删除这些功能,除非重新启动程序,否则无法使用MATLAB。

在MATLAB R2015a中,我还收到以下消息:

在此处输入图片说明

工作区是环境中当前声明的变量,以便您以后可以使用它们。这将永久禁用工作区,因此您尝试创建的任何变量将不会保存,因此在MATLAB中执行代码行时无法取得任何进展。

1:感谢最初发现该想法的用户Dev-iL


2
在R2014b中,您可以feval('clear')进行修复。或:s=str2func('clear'); s()
Stewie Griffin

13

///

/\///

///中唯一的操作是重复的字符串替换,如下所示:/pattern/replacement/

这段代码会删除every /,这样您就不能使用重复的字符串替换,因此基本上您之后写的所有内容都会被打印出来(/s 除外)。

您仍然可以使用\s,但这并不能帮助您。


我一直想知道是否有可能编写一段///代码,该代码保证可以擦除所有内容,从而在不打印任何内容的情况下停止运行。似乎不可能,但是我还没有想到不可能的证明。
Tanner Swett

12

Befunge-96

'~h

只要是源代码中的前三个字符,该序列之后的任何地方都可以跟随用户的代码。

'命令(单次字符串模式)将的ASCII值压~入堆栈(即126),然后该h命令使用该值设置所谓的整体增量。对于不熟悉Befunge-96的用户,“ 整体增量”是一个偏移量,该偏移量被添加到解释器遇到的每个命令字节的值中。

一旦将增量设置为126,就可以~通过源中的空字节生成唯一有效的命令(字符输入)。空字节以外的任何内容都将转换为大于126的值,并且这些值都不是有效的Befunge命令。

我认为可以肯定地说,这将使其没有资格成为编程语言。


11

o

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

然后,在项目的其他地方,

harmless

一个简单的宏,名称听起来无害,但效果令人惊讶。Boo编译器使用多步骤管道,该管道从将源解析为AST到代码生成结束。(通常。可以为各种应用程序重新配置。)之间的每个步骤都对AST执行各种操作。

在宏扩展阶段中,宏在编译器的上下文中执行。还记得最后一段中有关可重新配置管道的内容吗?如果在宏扩展过程中调用一个清除管道的宏,则不会向用户显示错误,但是宏扩展之后的所有步骤(包括代码生成)将不再存在。因此,最终得到的结果看起来像是成功的编译-没有显示错误消息-但由于某种原因,没有二进制文件产生!如果您很好地隐藏了宏和调用,则即使是最好的疑难解答人员也可以保证。


该答案无效,因为用户代码永远不会执行。
2015年

@ppperry:确实可以做到:宏可以作为用户代码的一部分编写,并在编译器内部执行。
梅森惠勒2015年

您必须为需要使boo符合条件的每个程序或程序集中键入的一组字符定义一个宏。
2015年

@ppperry:是的,调用宏(在代码中的任何地方)是导致编译器中断并满足条件的原因。如果您想说的要比这更深入,那么您必须更加清楚一点,因为我看不出问题出在哪里。
梅森惠勒2015年

2
@slebetman:当您有一个REPL或在编译时执行用户代码的宏时,两者之间的区别变得非常模糊。
梅森惠勒2015年

10

NGN / APL

NGN / APL允许重新定义原语,因此,将所有原语功能重新定义为()(均通过⊢32⊢3给出3)会使该语言完全无用:

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

在这里尝试。


1
现在为-1,但这似乎很有希望!也许如果您重新定义了所有原语……
Blacklight Shining

@BlacklightShining你去了。
2015年

8

Ruby(29个字符)

class Object;def send;end;end

每当在Ruby中调用方法时,由于所有对象都从Object类继承,因此在内部使用as'send'。这应该停止运行任何方法。

有趣的事实:从理论上讲,这是完全合理的。但是出于某种原因,它似乎并没有妨碍Ruby语言。我不知道为什么可以运行此代码,然后仍然使用开放的Ruby环境。


实际上,这在Pry Ruby shell中有效。
费利克斯Saparelli

您是说它按“此操作破坏了它”的方式工作还是像“此后仍然起作用”?只是,我确实提到了第二种情况,即普通的旧irb案
-AJFaraday

1
我的意思是它打破了撬。它不会破坏IRB,也不会破坏在.rb文件中的运行,但是会破坏Pry。
费利克斯Saparelli

有趣。我猜想send方法上有一些保护无法正常工作。
AJFaraday

8

Tcl

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

这将从语言中删除所有关键字,除了ifrename

上面的代码将导致任何新代码出错。因此,如果新插入的代码实际上被“执行”,则值得商bat。以下是一个执行新代码但不执行任何操作的版本,因为它将所有关键字(if和除外proc)更改为空操作:

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

该代码不是删除关键字,而是用不执行任何操作的函数替换它们。

(注意:我在这里非常宽松地使用“关键字”,因为Tcl没有关键字,只有功能)


1
我认为您可以通过重命名ifrename循环后使其变得更好。在第二个版本中,您还应该proc例外。
jimmy23013

@ jimmy23013嗯..从技术上来说您应该是对的,但是即使当前代码proc出现在列表中,该代码段也可以与tcl的当前版本一起使用puts。从技术上讲,代码也可以在没有rename内置命令的情况下工作,但是内置命令似乎受到了保护。不知道发生了什么,但是代码已经过测试,可以按广告说明工作。
slebetman

@ jimmy23013:好的。现在,无需调用即可使用代码rename。就我而言,这是脑力劳动-我忘记排除在外proc
slebetman

我决定不重命名,if因为if如果您想生成输出,那么独自完成工作几乎没有用。
slebetman

当然,您不需要重命名它们。但这不是代码高尔夫球。我只是想重命名它们可能(或可能不会)使此答案看起来更好。
jimmy23013 2015年

7

=<  ~
(your code)

Hoon很奇怪。它几乎完全不同于其他编程语言,不仅在语法上,而且在语义上。但是,与六边形之类的语言不同,它并不是故意过深的。

Hoon编译为Nock,这是一个基于最小组合器的VM。Nock是愚蠢的:规范可以压缩为340个字节。唯一的数学运算是递增。一切都是一个名词:一个原子(bignum)或一个单元格(一对名词),整个内存模型排列在一个不变的无环二叉树中。唯一的输出是您的表达式简化为的名词。

由于编译目标很奇怪,Hoon也很奇怪:它是完全纯净的。Hoon向下编译为在“上下文”中求值的Nock表达式。整个内核和stdlib以及所有变量都由上下文隐式传递给程序。

为了使Hoon无法使用=<,我们仅使用,即“在b的上下文中评估a”。我们一直在评估~,该值为零。不管做什么b,它都不能更改它减小到的值,并且由于它没有副作用,所以它不能进行输入或输出。

旁注:由于您实际上无法提示输入Hoon(纯度!),因此根据规则,它实际上不是编程语言。输入是通过函数参数,输出是通过返回值(或~&,它是printf调试功能的一部分,对程序是透明的)。

为了使程序在Urbit中获得输入,您实际上编写了一个程序,该程序返回一个接受输入的函数,然后Shell代表您进行询问并传递给回调。


3
不过,按照我们的标准绝对是一种编程语言
2016年

7

出租车,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.

6

浏览器中的JavaScript

好吧,至少在IE11中。

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

禁止写文档,写全局变量和从函数返回。

如果我错过了输出方法,请发表评论!


异常仍将显示在控制台中。您可以通过做这些事来解决window.addEventListener('error',function(){});
Ismael Miguel 2015年

@IsmaelMiguel现在,我不能承担所有的功劳!d
;-D

4
这严重吗?这根本没有任何意义:document应该仍然可以从插入的代码的外部作用域中访问它,并且直到插入的代码完成执行后才应该替换它。
彼得·泰勒

@PeterTaylor :-(你的逻辑打破了我的理论。
wizzwizz4


6

Python 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模块(在python 2.3中放弃)的复兴,在“ ok”列表中添加了一堆新模块,并修复了许多弱点(包括object.__subclasses__()使至少两个其他python成为一体的方法)答案无效)。

这些代码(类的__init__方法RExec和整个ModuleImporter类)中的相当一部分是从python标准库中复制的,并做了一些小的修改。


2
0.o WH ...你会怎么

8064 bytes顺便说一句
2016年

@cat并不是说这是代码高尔夫。我大概可以打出至少1000个字节。
pppery

当然,但你说“疯狂大”,所以我想我会注意到它
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.