Try to write some code in your language and make it not satisfying our criteria of being a programming language any more.

A language satisfies our criteria (simplified version for this challenge) of being a programming language if:

• It can read user input representing tuples of positive integers in some way.
• It can output at least two different possible results depending on the input.
• It can take two positive integers and add them (and the result can affect the output).
• It can take a positive integer and decide whether it is a prime (and the result can affect the output).
• For the purpose of this challenge, any kind of output that isn't an allowed output method for a normal challenge is ignored. So it doesn't matter whether the program can also play a piece of music, or posting via HTTP, etc.
• Update: You can also choose one or some of the allowed output methods, and ignore all the others. But you must use the same definition everywhere in the following criteria. And if your program can disable more than one output methods — that worths more upvotes.

Examples like making it not able to output, or disabling all the loop constructs so it won't be able to do primality test and making sure the user cannot re-enable them.

You should leave a place for inserting new code. By default, it is at the end of your code. If we consider putting the source code in that place in your answer and running the full code as a complete program the interpreter of a new language, that language should not satisfy the criteria.

But the inserted code must be executed in such a way like a language satisfying the criteria:

• The inserted code must be grammatically the same as something (say it's a code block in the following criteria) that generally do satisfy the criteria, from the perspective of whoever wants to write a syntax highlighter. So it cannot be in a string, comment, etc.
• The inserted code must be actually executed, in a way it is supposed to satisfy the criteria. So it cannot be in an unused function or sizeof in C, you cannot just execute only a non-functional part in the code, and you cannot put it after an infinite loop, etc.
• You can't limit the number of possible grammatically correct programs generated this way. If there is already something like a length limit in the language you are using, it shouldn't satisfy the criteria even if this limit is removed.
• You can't modify or "use up" the content of input / output, but you can prevent them from being accessed.
• These criteria usually only applies to languages without explicit I/O:
• Your code should redirect the user input (that contains informations of arbitrary length) to the inserted code, if a code block isn't usually able to get the user input directly / explicitly in the language you are using.
• Your code should print the returned value of the inserted code, if a code block isn't usually able to output things directly / explicitly in the language you are using.
• In case you print the returned value, and it is typed in the language you are using, the returned type should be able to have 2 different practically possible values. For example, you cannot use the type struct {} or struct {private:int x;} in C++.

This is popularity-contest. The highest voted valid answer (so nobody spotted an error or all errors are fixed) wins.

## Clarifications

• You shouldn't modify the code in the text form, but can change the syntax before the code is interpreted or compiled.
• You can do other things while the code is running. But the reason that it doesn't satisfy the criteria should be within the inserted code itself. It can error because of the interference of another thread, but not just be killed by another thread.
• All the specs basically means it should be grammatically likely satisfying the criteria if all the built-ins were not changed but not actually do. It's fine if you find any non-grammatical workarounds, such as passing the parameters to the code block correctly, but make them not able to be used in some way.
• Again, the inserted code must be actually executed. Code after an infinite loop or crashing is considered "not actually executed", thus not valid. Those answers might be interesting, but there are already some other infinite loop or crashing questions on this site, and you may find a more appropriate one to answer. If not, consider asking a new question. Examples of those questions are:

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>

• Am I allowed to change the code before executing it? Also, can I run other code whilst I am running the code given? – Blue Oct 18 '15 at 12:30
• This could have made a really great cops and robbers challenge I think. – DankMemes Oct 18 '15 at 23:07
• @DankMemes Agreed. As it stands, it's much too vague, and most answers would be invalidated by finding a workaround. CnR with this premise would be delightful. – Mego Oct 18 '15 at 23:54
• So then it seems to be saying that in languages with explicit IO it's permissible to do completely boring things like reading and discarding the contents of stdin. It sets up a completely unfair playing field where some languages require you to carefully handle the IO for the inserted code, and other languages allow you to trash it and deny IO to the inserted code. – Peter Taylor Oct 19 '15 at 12:28
• Are we allowed to use a language that's already unusable to begin with? (JavaScript for example) – 12Me21 Oct 17 '17 at 14:23

# JavaScript Shell

This will make the language completely unusable.

clear(this);


Isn't it nice how JavaScript has such a nice function to destroy itself?

This is pretty simple, the clear function completely empty an object. this refers to the global object clearing out everything including constructors and functions.

Because this clears everything, doing anything, even defining a literal will throw an error, making the language completely useless: *REPL environment not required. Uses the SpiderMonkey engine (shell not browser), the original JS engine.

• That clear function seems to be a SpiderMonkey-shell-specific addition, not a generic JavaScript thing. It certainly doesn't appear in the ES5 spec § Function Properties of the Global Object. I tried this with node and got a "ReferenceError: clear is not defined". In Chrome's and Firefox's console, the clear function just clears the console, regardless of what arguments it is passed. Or perhaps the tool you used complied to a version of ECMAScript older than 5.1? – Anko Jan 22 '16 at 1:01
• Could you instead amend the statement “Isn't it nice how JavaScript has such a nice function to destroy itself”? JavaScript doesn't have that function, only the SpiderMonkey implementation does. – Anko Jan 22 '16 at 1:12
• @Anko SpiderMonkey is JavaScript though, it comes bundled with Firefox (SpiderMonkey is Firefox's JS engine). I'll write up a version for node.js, etc. later, when I have time – Downgoat Jan 22 '16 at 1:15
• I think you're confusing JavaScript (the language) with SpiderMonkey (one of the many implementations of the language). Extreme allegory: While I could write a crazy implementation of C in which all invocations of undefined behaviour result in printing the full text of the Declaration of Human Rights, I probably wouldn't be able to argue that my C submission to "golf the UDHR" that just dereferences a null pointer is a valid C solution. :) – Anko Jan 22 '16 at 1:42
• @Anko As a per site rule, a language is defined by its implementation. If an answer works consistently in at least one implementation that was published before the question, then it is acceptable. See here and here. (So the code is valid. But I'll not comment on that specific wording.) – jimmy23013 Feb 23 '16 at 1:21

## Emmental

;#33!


I know this isn't code golf, but the right tool for the job, you know...

The user's code can be inserted after the !.

Emmental is an interesting esolang which is based on rewriting the interpreter. Every single symbol (including the built-in ones) can be redefined as an arbitrary Emmental program. The language relies on this feature so much that it doesn't provide any looping constructs. Instead, you define recursive commands which appear in their own definitions.

This redefinition happens via !, which reads a character from the stack, and then reads a string from the stack until it encounters a ;. The character is then redefined to mean the program represented by that string.

That means, we can disable Emmental's looping features by redefining ! itself as the empty program. While all other Emmental code still runs perfectly fine, and many of the criteria of a programming language are still fulfilled, it is impossible to redefine any more symbols. Without this feature (and therefore, without being able to loop), Emmental can no longer test whether a number is prime.

• Disabling the single defining feature of the language: pure genius. This certainly is the right tool for the job. +1 – ETHproductions Oct 18 '15 at 16:49

# PHP

One can completely kill PHP by setting the memory limit to 1.

It will completely die.

Try this:

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

//code here


This shouldn't even throw any error, since there isn't enough memory for that.

You can read more about the memory_limit directive

If the previous one is invalid, one can use output buffers:

<?php
ob_start();

//code here

ob_clear();


This completely removes any output. Since the output buffer is still open, some other things accidentally left after the code won't be shown as well.

Using @fschmengler's idea:

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


This will avoid the problem of deleting the automatically started output buffer, used to catch the output to be compressed.

This also prevents that the output buffer is deleted or flushed (sent to the browser). To re-inforce that, an output handler is added, that always returns an empty string.
Running ob_end_flush(); echo "Hello, world!"; won't produce anything, but would send the output with a plain ob_start();.

Thanks to @LucasTrzesniewski for exposing this issue!

• Since you can have severel levels of output buffering, the second one does not work. Often, while(ob_get_level()) ob_end_flush(); is used in frameworks to flush all output buffers that may have been left open accidently. – Fabian Schmengler Oct 18 '15 at 18:35
• @fschmengler That will cause problems with automatically opened output buffers, usually used to compress the output using gzip. Which in turn will defeat the purpose. – Ismael Miguel Oct 18 '15 at 18:38
• This can be bypassed with: ob_end_flush(); echo "Hello, world!"; – Lucas Trzesniewski Oct 20 '15 at 19:54
• Why am I not surprised that PHP ended up towards the top of the vote-chart :) – MonkeyZeus Oct 20 '15 at 20:47
• This shouldn't even throw any error, since there isn't enough memory for that. LOL'ed at that :) – ETHproductions Oct 28 '15 at 16:21

# x86 machine code in real mode (=> almost any DOS program)

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


I hope you weren't too attached to your interrupt table.

• Sir, if I may interrupt you for a few cycles so I may fini.... – Luminous Oct 20 '15 at 12:57
• So what if the first instruction of my inserted code is cli, and then I fix the interrupt table, and go on to compute some primes, etc? – Nate Eldredge Oct 21 '15 at 16:22
• @NateEldredge: the next step is to jail the rest of the code to ring 3 with no trampoline back to ring 0; I'll see if I manage to put together a working example (another possibility would be to scan the whole address space and NOP-out all the cli (and inp and outp just for good measure), but I don't know if that would be allowed by the rules. – Matteo Italia Oct 21 '15 at 19:19
• At least as it stands, this won't stop a program from writing directly to the screen buffer (which was pretty common under DOS). – Jerry Coffin Oct 21 '15 at 20:28
• @NateEldredge: the rules aren't really clear on this, and if you look around most answers actually consist in modifications to the environment that generate a runtime error of some type on trivial instructions (the JS clear(this);, the memory limit in PHP, the recursion limit in Python, the sandboxed environment in Python and many others), I wouldn't see this as a problem. – Matteo Italia Oct 22 '15 at 5:54

# 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("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
}
}


Edit: Counter-countermeasures are making this giant :(

Redirects stdin and stdout to null streams and replaces args with an empty array. Also uses enormous amounts of reflection hacks to make sure the standard IO is truly hidden. Finally, it sets a security manager to make sure the standard IO can't be recreated and that makes sure programs can't set the exit code.

• Negative. – Mego Oct 18 '15 at 15:42
• Playing with reflection is almost always reversible. – Mego Oct 18 '15 at 17:10
• +1 Personally I don't consider the /proc workarounds as real deal breakers because I don't use Linux and neither my Unix OS not my Windows OS has a /proc filesystem. – Jerry Jeremiah Oct 19 '15 at 18:46
• Summary of this challenge so far: 1. JavaScript, 12 chars. 2. Emmental, 6 chars. 3. x86, 12 bytes. 4. Python, 42 chars. 5. Java, 2264 chars! Why am I not surprised? – ceased to turn counterclockwis Oct 21 '15 at 20:20
• @ceasedtoturncounterclockwis It's because java is more secure so it's harder to break :D – Pierre Arlaud Oct 22 '15 at 12:45

## Lua

_ENV=""


In Lua, _ENV is the environment that all global variables, functions, tables, etc are stored in. Defining it to just be an empty string means you can't define anything new, and all functions and variables are wiped. This means you can not output anything, take in input, or pretty much do anything.

• Does _ENV=5 work? If so, it's one character shorter. – user253751 Oct 22 '15 at 0:54
• @immibis True, but this is a popularity contest, not a code length contest. PS - Trust you to home in on the Lua answer. – Pharap Oct 22 '15 at 1:08
• +1 for Lua. Doesn't $_G=nil$ do more or less the same as well? – Doddy Oct 23 '15 at 7:19
• @Doddy Nope, because _G is just a copy of _ENV you can use to look up variables and stuff like that - it isn't actually the environment. You could, however, do _G=nil and then set the environment to _G, and that would have the same effect. – TreFox Oct 23 '15 at 10:48
• Not entirely true. If you have a backup somewhere in local variable, you can restore it. And you can still define local variables and even call string-related functions! – val says Reinstate Monica Jun 10 at 19:57

Shakespeare Programming Language

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]


In SPL, the built in parser which is downloaded with the program follows very specific rules as to what can happen in the script. One of such rules is that only two characters can be on stage at once. Also, making a character exit the stage who was never on stage will confuse it. The same goes for adding a character to the stage who is already on stage. When the parser receives an error, it will refuse to do ANYTHING else; you literally have to completely shutdown the program and the parser and then start up everything again.

P.S. If you have no idea how this language works, Google it. It's awesome.

• So, is it a parse error or a runtime error? – Fabian Schmengler Oct 22 '15 at 13:30
• @fschmengler That is basically the same thing for interpreted languages. – nwp Oct 23 '15 at 11:55
• If I add code after the last line, will it actually execute though? – Sp3000 Oct 23 '15 at 12:48
• @Sp3000 It will certainly try......it will appear as though nothing out of the ordinary has happened...until the parser crashes. :) – 3.14ed_Piper Nov 2 '15 at 14:16

# Smalltalk

I'm not sure if this qualifies:

Smalltalk := Nil.


This deletes the entire run-time environment, hanging the object engine. The only way to fix this is to forcibly terminate the process and restart from backup.

For those that don't know, the way [Visual Works] Smalltalk works is slightly weird. It's like a mini-OS. When you start Smalltalk, you load a "memory image" into RAM, and it continues executing from where it left off. The entire Smalltalk IDE is written in Smalltalk and is dynamically modifiable.

In particular, Smalltalk is a dictionary containing all global variables. Most particularly, every time you declare a new class, a global variable with that name is created, pointing to the Class object for your new class. So setting Smalltalk to Nil (basically null) deletes all classes in the entire system. Even the GUI event handlers go poof.

I have no idea why this variable is even writable. Probably because it's a global variable, and therefore exists as an entry inside itself. (Does your head hurt yet? Did I mention that every object has a class, and classes are objects, so every class has a class? The class of a class is called a metaclass, but a metaclass is also an object, which therefore has a class...)

You could probably achieve a similar effect by clearing the dictionary rather than replacing it with null. Indeed, there's any number of things you could code to delete all the classes in the system, leaving you unable to do anything. But since the actual Smalltalk compiler is also a class... anything that breaks the language also kinda breaks the entire IDE, so...

• It is invalid if it hangs itself, but not the next command. But I'm curious: Does it have a class that can have both values being a class and being an ordinary object? And a class that can have both of those values and this new class? And a class of itself? – jimmy23013 Oct 20 '15 at 11:19
• A Smalltalk class is vaguely like a JavaScript prototype. By hacking the system classes hard enough, you can even turn Smalltalk into a multiple-inheritance language. Also, method calls are objects, code blocks are objects... you can intercept undefined method calls and make them do stuff... it's a very dynamic language. Everything is an object! Including the IDE... – MathematicalOrchid Oct 20 '15 at 11:28
• Had to use nil instead of Nil in Pharo. – mgarciaisaia Oct 20 '15 at 17:40
• Another one is true become: false, but I think this doesn't work in newer versions of the language. You could kill SmallTalk/V 286 this way. – user15259 Oct 20 '15 at 18:13
• “Did I mention that every object has a class, and classes are objects, so every class has a class? The class of a class is called a metaclass, but a metaclass is also an object, which therefore has a class...” As a Pythonista, my head doesn't hurt at all. On the contrary, I think I'd feel right at home with Smalltalk. – Blacklight Shining Oct 21 '15 at 19:24

There are a couple of possibilities here.

Boring idea #1: Define main to do nothing. Now no matter what other code you write, it can never execute. (Unless you manually run it from the REPL.)

Boring idea #2: Define a module with no public exports. Now no matter what other code your write, it can never execute.

Interesting idea: Disable all imports.

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


Now you can define functions which are visible and can be run... but they can't do anything. All standard Haskell types and functions are now hidden. (With the exception of a few things really deeply hard-wired into the language.)

Most particularly, you cannot perform any I/O whatsoever. You also cannot do machine-precision arithmetic. (Since Int, Double, etc are now undefined.)

You can still write lambda-calculus functions that do perform some real computation though. You just can't get any data into or out of the thing. But you could of course write another, separate module that calls the Fubar module above and does I/O on its behalf (thus proving that the code does execute and does do stuff).

Some subtleties:

• The dummy foo = foo declaration is needed to prevent anybody adding additional imports. (Imports cannot appear after declarations.)

• There are various non-standard Haskell language extensions that would enable you to climb out of this situation. But language extensions have to be switched on with a compiler pragma at the top of the file. (Or with a command-line switch to the compiler. I can't really prevent that one!)

• -0.1 Use foobar, the spelling you used has some... unintended connotations. – wizzwizz4 Dec 12 '15 at 9:27
• @wizzwizz4 I'm pretty sure "foobar" is just "fubar" prettied up to avoid censors. That's why I tend to avoid it in programming examples. – jpmc26 Feb 15 '16 at 7:17
• @jpmc26 It actually has a long and distinguished history, going through an MIT model trains group, being popularised in a programming book before being incorporated into documentation, then being brought into popular culture. I'm pretty sure it's a coincidence. – wizzwizz4 Feb 15 '16 at 9:04
• Both "boring ideas" are invalid because the user code isn't actually executed. (The "interesting idea" seems to be valid, though) – pppery Aug 31 at 17:43

# PostScript

Yes, PostScript is a programming language. Moreover, it's a programming language where all language constructs are system-defined functions, which can be redefined...

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


In English:

• Create an empty 1,000-element dictionary and name it Magic.
• For every key in systemdict, add the same key to Magic, with an empty definition ("{}").
• Push Magic onto the top of the dictionary stack.

From this moment on, every PostScript language command is defined to do nothing. AFAIK, it is impossible to escape from this condition.

(Technically, you're not "destroying" the old definitions, you're just shadowing them. If you could still execute end, that would pop Magic off the dictionary stack, un-shadowing all the commands and giving you your life back. But since end itself is also shadowed... it will do nothing now.)

Note that all commands will still execute... it's just that now they are defined to do nothing. You won't get any kind of error, it's just that nothing will happen. (Well, I suppose stack overflow will happen eventually...)

• This is actually kinda funny... and also scary... – Gryphon - Reinstate Monica Jul 10 '17 at 23:45

# Any program executing under Linux/x86(-64)

This program is written in C, but it can disrupt execution of any program running under Linux/x86 (-32 or -64). You prepend it to the command-line invocation of the program you want to disrupt.

It uses the debugger API to prevent the target program from producing any output. Specifically, all of the system calls that can communicate something to the world outside the process (most obviously write, of course, but also open when creating a file, the bulk of the socket API, kill when applied to another process, ...) will fail as if they were unimplemented. _exit is allowed, but the exit code is overwritten with a zero.

Unlike the previous edition of this answer, many programs can run nearly to completion under these conditions; it's just that all their work is wasted. For instance, if you do ./no-syscalls /bin/ls (assuming GNU coreutils ls) it reads the whole directory and formats it, and then all the write calls to produce output fail. (Anything that needs to open a bidirectional communication channel, though, such as all X11 clients, will fail at that point. I thought about allowing socket but not send, but it seemed too likely to open loopholes.)

There are several command-line options to tweak the behavior;

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


Dynamically linked programs will not even get out of the dynamic linker in -e mode. -S obviously opens a huge hole in the policy, but it can be entertaining to watch programs moan about nothing working, e.g.

$./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  You have to read log output with /usr/include/asm*/unistd.h open in another window, because this is already quite long enough. Sadly, the debugger interfaces that this uses are only weakly consistent across Unix implementations, and are intrinsically CPU-specific. It would be relatively straightforward to port it to other CPU architectures (just add appropriate definitions of SYSCALL_*_REG), and it's probably possible to port it to any Unix that has ptrace, but you might need to muck with the syscall whitelist extensively as well as dealing with divergences in 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)); } } }  • “the target can read its command-line arguments, perform pure computations, and produce an 8-bit exit status, but will not be able to allocate memory or do I/O”—I dunno, I think you still meet the four criteria. Integers can be interpreted from commandline arguments; the exit status can be leveraged for simple output; addition isn't hindered; and all you need for a primality test is the ability to do pure computations, a bit of stack space, and a loop. – Blacklight Shining Oct 21 '15 at 19:36 • @BlacklightShining I think that this accomplishes such a huge restriction relative to normal behavior that it should be acceptable even though, as you say, you could still write a prime tester, but -DNO_EXIT mode is for people who feel as you do. No meaningful output is possible in that mode. – zwol Oct 21 '15 at 20:36 • @BlacklightShining I thought about it some more and I rewrote the program basically from scratch. It's rather cleverer now what it does and (I hope) meets even the most stringent reading of the challenge. – zwol Oct 22 '15 at 21:36 • @Joshua That's clever, and would be difficult to prevent using this approach (since the program is just modifying its own memory) but it's not currently on the list of "allowed output methods." – zwol Jan 24 '16 at 4:02 • @JesseTG Are you familiar with strace? – zwol Oct 2 '16 at 13:14 # TeX \catcode\\=10  I'm not sure this will actually work, but in theory this should break \ as escape character leaving you no way to fix it. Normally TeX can read and write files, now it can't write anything that depends on logic. Thus the language is now broken as defined by OP. EDIT: Other kill commands taken from the comments (although both might violate the code-must-be-executed rule): • \def\fi{}\iffalse by smpl creates an un-closable if branch • \catcode13=9% by iwillnotexist idonotexist creates a never-ending comment • A better version: \def\fi{}\iffalse. I can't post answers on this because it requires at least 10 rep earned from this site, but this will not allow output anymore too. – user530873 Oct 26 '15 at 0:12 • @smpl you can still redefine \fi to its original meaning, right? Thus the language is not broken beyond any repair. – Cephalopod Oct 26 '15 at 12:07 • @Cephalopod \fi is a TeX primitive. And no you can't redefine anything at this point, \iffalse has been called. – user530873 Oct 26 '15 at 14:48 • @smpl Hmm, I see. Very clever. – Cephalopod Oct 26 '15 at 19:23 • +1. I just started teaching myself out of the TeXBook and when I realized \catcode13=9% would completely break the language (Everything after % is commented and newlines (ASCII char 13) are ignored, so the comment extends to infinity) I wanted to post it here. But you have a slightly longer command already in here. – Iwillnotexist Idonotexist Jan 23 '16 at 23:03 # Scratch The when [timer v] > (0) will run as soon as the code is initialised, which if you're in the editor is before you even start the code. The when I receive (join[][]) will cause an error to be thrown every time anything is broadcast, pausing code execution if you have Developer version of Flash. The break function will create clones, and trigger the broadcast error. Every single clone will last two seconds then delete itself, putting strain on the stack. And every clone will respond to the when [timer v] > (0), running the break subroutine and resetting the timer, which causes the timer code to be run again. Also, each clone will respond to every broadcast error as well, meaning the number of errors per evaluation of break is the number of clones squared. Did I forget to mention that the break function has run without screen refresh checked, causing the editor to freeze, jolt and lag, as well as the grabbing and allocating memory. And maxing out the CPU. Any code added anywhere with this running will find itself unable to create clones (300 clone limit surpassed) as well as heating up and crashing the computer running it. And grabbing memory until there is no more to grab, leaving variables misbehaving. And, after there's too much lag to trigger the when [timer v] > (0) block, it'll still be running break. Thanks to @towerofnix for reminding me about the when I receive glitch I found a while back, and giving me the idea for run without screen refresh. If you liked this, here's the original: https://codegolf.stackexchange.com/a/61357/43394 • +1 Also might be fun to run an atomic (run without screen refresh) block with stop this script in it :P – Florrie Oct 22 '15 at 21:31 • How does that "when I receive glitch" work? – Scimonster Oct 30 '15 at 12:04 • @Scimonster The when I receive hat block is only designed to take input from the drop-down list. The join[][] block returns a data type that the when I recieve block isn't designed to accept. Every time something is broadcast, all of the hat blocks check, and evaluate the return value of the block, throwing an incorrect type error. – wizzwizz4 Oct 30 '15 at 15:24 • I see. Though you have to hack the JSON file to actually get the join block in there. – Scimonster Oct 31 '15 at 18:52 • @ppperry It's dependent on a version of Flash that ignores errors - this does exist. Taken to its extreme, "for small enough n" could be used to say (n-1) works for positive n < 3, but as this is algorithm-based a good algorithm should be able to make n large enough to be able to shrug that argument off. I'm not sure whether a faster or slower machine would make it more usable. However, I agree that this solution can be worked around. It's not a cops-and-robbers, but well done anyway. – wizzwizz4 Aug 5 '17 at 17:41 # PHP I'm suprised that it actually works, but closing STDOUT and STDERR suppresses all output. To be sure that they will not be opened again, we open /dev/null three times to reassign the file descriptors 0, 1 and 2: <?php fclose(STDIN); fclose(STDOUT); fclose(STDERR); fopen('/dev/null','r'); fopen('/dev/null','w'); fopen('/dev/null','w'); // insert program here  • There are other valid output forms, including writing to files and using the program's exit code. See the link in the relevant bullet point of the spec. – Martin Ender Oct 18 '15 at 13:54 • What exactly is allowed and not was not obvious to me. In the tag wiki for example I found nothing about files and exit codes. But if they are allowed, I don't think I can turn this into a valid submission. – Fabian Schmengler Oct 18 '15 at 15:29 • Edited the question to allow disabling only one output form. – jimmy23013 Oct 18 '15 at 15:42 • @jimmy23013 what? That completely defeats the point of the question. – hobbs Oct 18 '15 at 21:25 • @jimmy23013 If it's valid to just disable only one output form then for example suppressing the program's exit code (as Martin suggested) is all I need to do even though the language is completely useable without an exit code? – Jerry Jeremiah Oct 19 '15 at 18:38 ## Mathematica / Wolfram Language Mathematica is an interpreted language in which command names are symbols that can be manipulated by the programmer. You can't delete built-in operators, but you can overload them or otherwise modify their function. The following scrambles the "With" command, which is needed for assignment to variables even internally. This change prevents the kernel from holding arguments unevaluated until the assignment is complete, and it kills the language quite dead. ClearAttributes["With", HoldAll]  If this command is run in an interactive session or within a block of code, Mathematica will not even be able add 1+1 (the resulting error message is about a page long so I won't include it here). DOS batch (prior to Windows 95 I believe) CTTY  Issued with no arguments, this disconnects the command line from the terminal. Any further attempts to read input or generate output don't do anything. In case you wanted to know how to use CTTY correctly: MODE COM1,8600,8,N,1 CTTY COM1  A slightly more powerful batch file could even answer the modem and connect whatever dialed in to CTTY. # Scratch Here's a pretty simple example that will crash your browser (and, in theory, your computer): I left this running for about twenty seconds, then lost 2.65 GB of memory to Scratch. Only a moment later and 5 GB were gone. I highly suggest you have a means to force quit either Adobe Flash or your web browser before running this! I really wanted to make a cool answer like the clear(this) JS one but sadly Scratch doesn't have any ways to do that. Feel free to update this post (or make your own) if you DO find another way to make Scratch unusable though! • Where do you add the user code, and is it actually executed? – jimmy23013 Oct 22 '15 at 4:54 • User code? Anywhere in the project, as long as this snippet is inserted. It is executed once 0.3 seconds after the initial run, and then every 0.3 seconds (except that it also constantly reruns a script with no end, making Scratch very slow). Is it okay if I update this post with a better, more powerful crasher? – Florrie Oct 22 '15 at 17:35 • Somebody using Scratch... d:-D YAY!!! – wizzwizz4 Oct 22 '15 at 18:09 • @towerofnix By the way, I've improved / radically modified / recreated this here: codegolf.stackexchange.com/a/61490/43394 Mine doesn't rely on Microphone being on. – wizzwizz4 Oct 22 '15 at 19:08 • @wizzwizz4 Yes yours is much better than mine. please go vote his – Florrie Oct 22 '15 at 21:30 # Common Lisp (set-macro-character #\( (lambda (x y) ()))  I hope you didn't need those opening parentheses. This is a reader macro that tells the Lisp Reader to replace each instance of ( with a call to (lambda (x y) ()), a function that takes two arguments and returns nothing. So, for example, it would read (foo) as foo), interpret foo as a variable and then throw an unmatched parenthesis error on 0. • Please also interpret ) as something breaky! That way, there will be fewer errors. – wizzwizz4 Jan 21 '16 at 16:53 • I love this. "What does lisp rely on? One single character? It would be a shame if something... happened to it..." It's the same logic as redefining \ in TeX. – felixphew Jan 24 '16 at 20:55 # Thue ::=  With a newline at the end The thue language relies on defining rulesets and a ::= denotes the end of the ruleset. It is impossible to do ANYTHING in thue without defining rules that do it, so regardless of what you put after the ::=, nothing can happen. Alternative answer A::= B::= C::= D::= E::= F::= G::= H::=  (and so on for the every character in all of Unicode including those before the A character and non-printable characters). This requires the command-line option -r. • I guess the text isn't grammatically the same thing as something satisfies the criteria (such as a ruleset). – jimmy23013 Oct 18 '15 at 15:26 # MATLAB The following piece of code makes the environment completely unusable1: builtin = @(varargin)false; clear = @(varargin)false; %// Insert code after this point  This overrides the builtin function and the clear function with new anonymous function handles that simply return false every time you try and call these functions. The builtin function ensures that if there are any custom functions you write in MATLAB that are the same name as those that are built-in to MATLAB (things like sum, max, min, etc.), you are able to call these unambiguously instead of the overloaded functions. Similarly, clear gives you the ability to clear all variables that are currently declared so you can start anew. By removing these capabilities, there is no way that you can use MATLAB unless you restart the program. In MATLAB R2015a, I also get the following message: The Workspace are the variables that are currently declared in the environment so that you can use them for later. This permanently disables the Workspace, so any variables you try and create will not be saved and hence no progress can be made when executing lines of code in MATLAB. 1: Credit goes to user Dev-iL who originally discovered the idea. • In R2014b you can do feval('clear') to fix it. Or: s=str2func('clear'); s(). – Stewie Griffin Nov 8 '15 at 16:50 # /// /\///  The only operation in /// is repeated string substitution, like this: /pattern/replacement/. This code removes every /, that way you can't use repeated string substitution, so basically everything you write after that will get printed (except for /s). You can still use \s, but that won't help you much. • I've always wondered if it's possible to write a piece of /// code which is guaranteed to erase everything after itself, and thus halt without printing anything. It seems impossible, but I haven't thought of a proof that it's impossible. – Tanner Swett Jul 21 '17 at 19:47 # Befunge-96 '~h  The user's code can follow anywhere after this sequence, as long as these are the first three characters in the source. The ' command (one-shot string mode) pushes the ASCII value of the ~ onto the stack (i.e. 126), and the h command then sets what is known as the Holistic Delta with that value. For those not familiar with Befunge-96, the Holistic Delta is an offset that is added to the value of every command byte that the interpreter encounters. Once the delta is set to 126, the only valid command that can be generated is ~ (character input), via a null byte in the source. Anything other than a null byte would translate to a value greater than 126, and none of those values would be valid Befunge commands. I think it's safe to say that this would make it ineligible to qualify as a programming language. # Boo macro harmless: Context.Parameters.Pipeline.Clear()  And then, somewhere else in the project, harmless  A simple macro with a harmless-sounding name, but an amazingly frustrating effect. The Boo compiler uses a multi-step pipeline that begins with parsing source into an AST and ends with code generation. (Generally. It can be reconfigured for various applications.) Every step in between performs various operations on the AST. Partway through is the macro expansion stage, in which macros are executed in the context of the compiler. Remember the bit in the last paragraph, about the pipeline being reconfigurable? If, during macro expansion, you invoke a macro that clears the pipeline, no error will be displayed to the user, but all steps after macro expansion (including code generation) are no longer there. So you end up with something that looks like a successful compilation--no error messages displayed--but for some reason there's no binary produced! Guaranteed to drive even the best troubleshooters up the wall, if you hide the macro and the invocation well. • This answer is invalid, as the user code never gets executed. – pppery Oct 19 '15 at 20:11 • @ppperry: Sure it does: the macro can be written as part of the user code, and it's executed inside of the compiler. – Mason Wheeler Oct 19 '15 at 20:13 • You would have to define such a macro for a character of set of characters that needs to be typed in every single program or set of programs that makes boo fit the criteria. – pppery Oct 19 '15 at 20:18 • @ppperry: yes, invoking the macro (anywhere in the code) is what causes the compiler to break, fulfilling the criteria. If you're trying to say something deeper than that, you'll have to be a bit more clear, because I don't see what the problem is. – Mason Wheeler Oct 19 '15 at 20:24 • @slebetman: And when you have a REPL, or macros where user code is executed at compile time, the distinction between the two gets very blurry. – Mason Wheeler Oct 20 '15 at 10:00 # NGN/APL NGN/APL allows redefining primitives, so redefining (←) all primitive functions to ⊢ ("pass through": both ⊢3 and 2⊢3 gives 3) makes the language completely useless: ⍪←-←+←?←⍵←∊←⍴←~←↑←↓←⍳←○←*←⌈←⌊←⍕←⊂←⊃←∩←∪←⊥←⊤←|←<←≤←=←≥←>←≠←∨←∧←×←÷←⍒←⍋←⌽←⍉←⊖←⍟←⍱←⍲←!←⌹←⊣←⍎←⊢  Try it here. • -1 for now, but this seems promising! Maybe if you redefined all the primitives… – Blacklight Shining Oct 21 '15 at 19:30 • @BlacklightShining There you go. – Adám Oct 23 '15 at 14:10 # Ruby (29 characters) class Object;def send;end;end  As 'send' is used internally whenever a method is called within Ruby, and since all objects inherit from the Object class. This should stop any method being run. Fun Fact: This is perfectly sound in theory. But it appears, for some reason, not to hobble the Ruby language. I have no idea why it's possible to run this code and then still use an open Ruby environment. • Actually this works in the Pry Ruby shell. – Félix Saparelli Oct 22 '15 at 21:41 • Do you mean it works as in "this breaks it" or it works as in "it still works after this"? Only, I did mention the second being the case in plain old irb – AJFaraday Oct 22 '15 at 21:46 • I mean it breaks Pry. It doesn't break IRB, and it doesn't break running in .rb files, but it does break Pry. – Félix Saparelli Oct 22 '15 at 21:50 • Interesting. I'd guess there's some protection on the send method that isn't working in pry. – AJFaraday Oct 22 '15 at 21:52 ## Tcl foreach x [info commands] {if {$x!="rename"&&$x!="if"} {rename$x ""}}


This removes all keywords from the language except if and rename.

The above code would cause any new code to error out. So it's debatable if the new inserted code actually gets "executed". Below is a version that executes new code but does nothing because it changes all keywords (except if and proc) to a no-operation:

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


Instead of deleting keywords this code replaces them with a function that does nothing.

(Note: I'm using "keywords" very loosely here because Tcl doesn't have keywords, only functions)

• I think you can make it better by renaming if and rename after the loop. In the second version, you should also make proc an exception. – jimmy23013 Oct 20 '15 at 7:08
• @jimmy23013 Hmm.. technically you should be right but that code snippet works with the current version of tcl even when proc appears in the list before puts. Technically the code should also work without rename but built-in commands seem to be protected otherwise. Not sure what's going on but the code is tested and works as advertised. – slebetman Oct 20 '15 at 7:24
• @jimmy23013: OK. Code now works without needing to call rename. It was brainfart on my part - I forgot to exclude proc. – slebetman Oct 20 '15 at 7:27
• I decided not to rename if because being able to do if alone is pretty much useless if you want to generate output. – slebetman Oct 20 '15 at 7:28
• Of course you don't need to rename them. But this is not code-golf. I just thought renaming them may (or may not) make this answer looks better. – jimmy23013 Oct 20 '15 at 7:32

## Hoon

=<  ~


Hoon is a odd. It's pretty much entirely unlike other programming languages, not only in syntax but in semantics. Unlike languages like Hexagony, though, it wasn't made to be purposely esoteric.

Hoon compiles to Nock, a minimal combinator based VM. Nock is stupid: the spec can be gzipped to 340 bytes. The only math operation is incrementing. Everything is a noun: an atom (bignum) or a cell (pair of nouns), with the entire memory model arranged in an immutable acyclic binary tree. The only output is the noun that your expression reduces to.

Because of the weird compilation target, Hoon is also weird: it's completely pure. Hoon compiles down to a Nock expression that is evaluated on a "context". The entire kernel and stdlib, along with all variables, are passed implicitly to the program by the context.

To make Hoon unusable we just use =<, which is "evaluate a in the context of b". We are always evaluating ~, which is zero. No matter what b does, it can't change the value it reduces to, and since it can't have side effect it can't do input or output.

Side note: Since you can't actually prompt for input from Hoon (purity!), by the rules it isn't actually a programming language. Input is via function arguments, output via return values (or ~&, which is more of a printf debugging feature and is transparent to the program).

For a program to get input in Urbit, you actually write a program that return a function that accepts input, and the shell asks on your behalf and passes to the callback.

• Definitely a programming language by our standards, though – cat Oct 1 '16 at 10:41

# Taxi, 2354 bytes.

This little program simply runs the taxi in a large joyride through Townsburg, running out of gas. Any code you run after this will quickly error with error: out of gas. And even if you could reach a gas station, which I don't think is possible, you couldn't get any gas, as no money has been collected, since there are no passengers.

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 in browser

Well, at least in IE11.

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


Disables writing to the document, writing to the global variable and returning from the function.

Comment if I've missed out an output method!

• Exceptions will still show in the console. You can handle those by doing window.addEventListener('error',function(){}); – Ismael Miguel Oct 18 '15 at 19:19
• @IsmaelMiguel Now I can't take all the credit! d;-D – wizzwizz4 Oct 18 '15 at 19:24
• Does this seriously work? That makes no sense at all: document should still be accessible from the outer scope in the inserted code, and it shouldn't get replaced until after the inserted code has finished executing. – Peter Taylor Oct 18 '15 at 20:46
• @PeterTaylor :-( Your logic broke my theory. – wizzwizz4 Oct 19 '15 at 18:00
• It's not easy – Peter Taylor Oct 19 '15 at 21:02

# Python 2, insanely big

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.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
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 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:
"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):
dictionary_of(types.TracebackType)["tb_frame"] = new_frame
modified(types.TracebackType)
trashed = True
def test():
enable()
r = RExec()
try:
r.r_exec(
)
finally:
return 0
if __name__ == "__main__":
enable()
test()
sys.exit()


This insanely large amount of code is a revival of the ancient rexec module (abandoned in python 2.3) with a bunch of new modules added to the "ok" list and a bunch of weaknesses fixed (including the object.__subclasses__() method that has made at least two other python answers invalid).

Quite a bit of this code (the __init__ method of the RExec class and the entire ModuleImporter class) is copied from the python standard library with small modifications.

• 0.o wh...what have you done – cat Feb 22 '16 at 20:45
• 8064 bytes` by the way – cat Feb 22 '16 at 20:45
• @cat not that this is code golf. I could probably golf out at least 1000 bytes. – pppery Feb 22 '16 at 20:46
• of course, but you said "insanely big" so i thought i'd note it – cat Feb 22 '16 at 20:49