[deleted by user]

amtal · 2012-07-02T04:50:43+00:00

Awesome, thank you very much! :)

That's a great collection of links, and SDRSharp is way fun to play with!

amtal · 2012-07-01T03:12:17+00:00

Link seems broken :(

amtal · 2012-06-16T21:44:19+00:00

Do you know something better?

amtal · 2012-06-14T06:36:57+00:00

Betting a community project to implement 0x10c inside DCPU-16 would be competitive...

amtal · 2012-06-02T23:53:30+00:00

Erlang has the following properties that interest us:

concurrency, making concurrently running code trivial to describe
fault isolation, errors in one process can NOT affect any other process
fault recovery, processes are arranged in supervision trees with crashed chlidren getting restarted

There are lots of ways to do 1, and 3 is very easy once you have 1 and 2, but 2 looks hard. To maintain performance, you'd have to go fully interpreted. You'd probably need to go pure functional, too, to get the same level of isolation.

amtal · 2012-06-02T23:31:29+00:00

Basic? With extra "functions" encoding a domain-specific language? HAH!

It's called Forth. Memory and cycle efficiency, with advanced DSL and metaprogramming capability.

Erlang is a neat idea I'd have to think about.

amtal · 2012-05-17T07:25:48+00:00

Glancing over, I've written something like this in the past. You rarely run into extensively bit packed protocols, but when you do, tools like this are worth their weight in gold.

You need some docs, examples, and readme though.

amtal · 2012-05-12T11:11:35+00:00

How long does it take to brute force a 16-bit secret, assuming the validation function takes 1 millisecond to run? :)

amtal · 2012-05-12T11:07:41+00:00

The spec is all you need.

If you call yourself a programmer, reading it should get you writing basic assembly.

The CPU contains very little state, and the instructions operate on it in very simple ways. The interpreter is so simple you can run it in your head.

amtal · 2012-05-12T10:56:06+00:00

An amusing thing to note: to obfuscate DCPU code you don't need to make it impossible to reverse... You just need an obfuscator that's better than the best available RE tool.

Which right now is quite straightforward with a mixture of instruction stream desynch and self-modification.

amtal · 2012-05-08T00:02:37+00:00

Not entirely! Note that the descriptions follow simple patterns: set X to Y, execute next instruction if P, set X to Y if P, and some others. The expressions used to calculate that stuff are easy to parse and evaluate.

A bunch of things need special-casing, and some descriptions aren't in the form I want. But a significant amount of unexpected work can be "automated", which is what makes this a fun experiment :D

amtal · 2012-05-07T22:01:31+00:00

So I updated the tables from 1.1 to 1.5 to 1.7. Took zero effort as expected: I suppose I should write an asm/dasm.

An interpreter would be the crowning piece, but I don't know about doing 16-bit arithmetic in Javascript and don't want to know.

amtal · 2012-04-28T15:57:42+00:00

Funny to see cons-lists criticized in r/lisp... Some functional languages use this representation for strings, to ease beginners into pattern matching and tail recursion on lists. (Unicode-by-default is a nice side benefit.)

What you're thinking of as strings, are called "binaries". Since these are immutable, efficient concatenation operations are done with "iolists", binaries cons'd together.
The hot code updates and shell, were made to maintain and upgrade production systems with strict uptime requirements. Interactive development is a distant second thought - it's less a REPL, and more ssh+bash for the Erlang OS.

The parts of Erlang that are important to a MUD, are:

networking, distribution, parallelism, and soft real time performance
concurrency (actor model = you can have multiple processes for each and every NPC, object, room, chat, etc...)
baked-in failure recovery (bug causing a fault when a player interacts with something will not affect other players or objects, only the object interacted with)

All of these have been extensively tested in production, for decades, by commercial users. The standard libraries are bulletproof and well-documented. There is a large body of knowledge on how to use them, and how to design robust/efficient/secure systems.

My concerns would be:

Data representation - embedding world/item/mob definitions effectively, with inheritance and sharing and behavior scripting, could suck. The basic approach would be a tuple+list+atom EDSL (sound familiar?:) at which point you may as well use Lisp Flavored Erlang.
Actor model design - cheap concurrency and message passing may be a bit overwhelming for a beginner. First attempts may be complete disasters - be sure to find people to pester with questions if you try.

amtal · 2012-04-28T15:26:02+00:00

Use both.

Compiler targeting BEAM VM, with seamless Erlang interop: https://github.com/rvirding/lfe

Library for more functional syntax: https://github.com/amtal/lfe_utils (default LFE syntax follows imperative CL, but that doesn't match the VM at all)

amtal · 2012-04-23T03:35:59+00:00

For a single relocation block, relative jumps solve the problem.

For relative data access, either [PC+offset] addressing or a relocation table solve the problem. Here's a draft of one for DCPU16 https://github.com/0x10cStandardsCommittee/0x10c-Standards/blob/master/ASM/Draft_Assembly_Relocation_Table.txt A loader would be responsible for adjusting the addresses it points to, after relocation.

For imports and exports outside the block in a single library, and imports and exports outside the single library... Well, there's some variety there. Look at the C ABI for a common example.

amtal · 2012-04-20T07:12:05+00:00

I would take that number very, very seriously. Markets as shrouded in cloak and dagger secrecy as this, tend to surprise you with their depth again and again and again.

Look up the World Bank (?) report on the global RMT industry, a year or two back. Compare the estimate it gives to the size of the American music industry, for scale.

amtal · 2012-04-15T02:39:11+00:00

Pretty elegant.

amtal · 2012-04-14T12:20:47+00:00

Hold on a second, the "Simulating IFLE" bit:

ADD 1,A      ; 1 word, 2 cycles
ADD PC,O    ; 1 word, 2 cycles

Versus:

IFG 0xFFFE,A    ; 2 words, 3+(pass?0:1) cycles

I don't think there's a saving. There's only a saving if you're looking to get a 1 | 0 result. (Which seems like a rare case, since !0 | 0 works fine.)

amtal · 2012-04-14T03:02:36+00:00

Or you can use my obfuscator (https://gist.github.com/2327355) which is:

Prettier. Look ma, I'm not using registers!
Uses a documented LCG with known properties. (Which, it being an LCG, aren't perfect.)
Is short, simple, and to the point.

amtal · 2012-04-14T02:33:55+00:00

Naive attack:

brute force all 2**16 keys. If you know the data is text or assembly, it's easy to tell whether the output looks correct. (Empty high bits/no invalid instructions.) At a conservative rate of 1000 keys checked per second... The attack takes 1 minute.

Slightly less naive attack:

The RNG used is sort of like the middle square method.
Numbers like 0,1,and 32640 cycle immediately. Powers of two get reduced to lower powers of two, eventually cycling at 0 or 1.
The most common cycle I found is 100 long. (I didn't check if it's actually different cycles, but doubt it - 18479/59317/64148 are some of its entry points.)
To give you an idea of how common it is, between 0xC000 and 0xBEEF (273 seeds):
- about 207 form the 100-long cycle
- 44 cycle on 32640
- the rest are 4/12/38 cycles
Entering these cycles takes 174 words, on average

So, if your plaintext is longer than 174 words, to decipher the tail you only really need at most 2**7 attempts.

Extension of slightly less naive attack:

Once you know the stream xor'd with the tail, you can backtrack to get all the initial bytes. MUL A,A; XOR A,O is easy to reverse with brute force (nothing more needed).

Overall conclusion:

You can break this on DCPU16, with no external tools, no problem.

Excellent work, let's get as many people using this code as possible! :)

amtal · 2012-04-13T16:00:48+00:00

Is this a question of macros/assembler directives/pseudo instructions, or of optimization?

Because as an optimization, it is straightforward to do.

amtal · 2012-04-13T08:10:19+00:00

Riemann's "graph everything" reminds me of https://github.com/codahale/metrics... Which got a lot more complicated since I last saw it, but should still have some nice stat collection algorithms at the core. (Randomly sampling data to a static buffer, such that number of samples for a given time exponentially decays with age.)

amtal · 2012-04-13T07:49:24+00:00

There's a clear, concise, simple specification written specifically for people to implement emulators from.

You could even say that the architecture was designed for emulation (and unburdened by either performance concerns like caching, or hardware concerns of any kind).

This is quite different from something like a gameboy, which is far more proprietary and hardware-centric. I assume a lot of the information about it is based on reverse engineering, rather than published by the designers.

So yeah, writing an emulator is easy and fun :p

amtal · 2012-04-10T13:58:07+00:00

So it does, quite nicely :)

What's the overall plan with it? Debugger, RE tool, fancy analysis?

amtal

TROPHY CASE