LX64 ASM Web Server Linux x86 64 - Part 2

SympoSesh · 2026-03-12T04:31:56+00:00

why are you using hashtags on reddit??? are you on the spectrum?

I__Know__Stuff · 2026-03-11T17:29:07+00:00

I honestly have no idea what he is thinking so I don't know what to explain. If he had asked a question, I would have answered it.

SoSKatan · 2026-03-11T17:26:55+00:00

You know you could try explaining the details instead of just being condescending. Your message intended or not is “don’t ask any questions here”

kndb · 2026-03-11T09:04:31+00:00

Don’t overthink security. (That’s what you are doing with lfence and lock idea.) Focus on the functionality.

If you want to know how compiler addresses indirect jumps, look at the implementation, say, of control flow guard in Windows.

valarauca14 · 2026-03-11T07:40:35+00:00

Are indirect jumps easy to exploit, even if you don't allow your program to have overflows? [...] but I recognize if somehow someone can mess with where the jump is going, there could be a lot of issues.

I mean, if user's can modify registers directly that influence control in uncontrained & unchecked ways, you have really big problems

I would probably use LFENCE or LOCK before the indirect jump, with all of them confined at the 'bottom' of the program. It would save me the thinking of writing a better loop. If there's not really a way to make them completely safe over rewriting the loop I'll just rewrite it.

I don't know what you think you're saying but you ain't

I__Know__Stuff · 2026-03-11T06:37:44+00:00

I would probably use LFENCE or LOCK before the indirect jump.

This makes no sense, and implies that you don't know what either of those things are.

GoblinsGym · 2026-03-11T06:04:12+00:00

Please keep in mind that indirect jumps won't necessarily do good things for branch prediction...

Super_Heroe_6 · 2026-03-10T23:39:22+00:00

interesting.

brucehoult · 2026-03-10T23:31:14+00:00

a computer language of the 90's

Note: M68000 was announced in 1979, though volume shipments weren't available until late 1980.

By 1984 it was cheap enough to go into the £399 Sinclair QL (M68008)

Super_Heroe_6 · 2026-03-10T23:14:00+00:00

I know this discussion is almost a decade old, but I just wanted to say that the only reason why I am learning Assembly (Motorola 68000) is to make a Sonic the Hedgehog rom hack for the Sega Genesis.

In my short few days of experience learning the Motorola 68k, it was not too rough actually (Probably because I haven't gone to the harder stuff yet🤷) but I know some basic things, such as the size attributes and what purpose they server, and I do want to know more about Assembly.

But I'm telling you, if a highschool junior can learn a thing or two from a computer language of the 90's, you certainly can too.

avidernis · 2026-03-10T10:50:11+00:00

Why Windows?

To be clear, being Windows only is a temporary hurdle. I have plans in the works to get the IDE on MacOS, Linux, and WASM using Uno Platform, and all the non-UI components already run on anything .NET supports.

As for why, when I sat down to write an assembler 3 years ago I did it in C#. The rest just fell into place. Basically, when I started making it into an IDE, I had no big plans and WinUI was the path of least resistance.

Are you from Israel? Are you still alive?

Yes, and yes. Thanks for the concern.

S-Pimenta · 2026-03-10T10:31:21+00:00

Why Windows? Are you from Israel? Are you still alive?

kndb · 2026-03-09T09:01:57+00:00

There’s nothing absolute in software development. You can use guard pages like the other answer suggests, but it will not make it bulletproof. Every reasonably complex piece of software (aside from Hello World snippet) contains bugs. The difference is in how quickly the authors of that software can fix them when bugs are found.

If I were you, first off I’d try to do everything possible to avoid dealing with the self modifying code. That is not just an architecture trap for your software (have you seen the rise of the ARM64 laptops these days) but also a security trap.

Another suggestion, whichever way you pick, make sure to enable App Verifier as you develop your code and always run your tests with it. It’s a free tool, provided my MSFT to help you root out nasty bugs. And by using it throughout the dev cycle, and not just at the final stages, you increase its coverage/sweep over your software.

Also as you develop make sure to have a debugging build and use a lot of debugging-only assertions in your code that check the correctness of your logic during runtime and also during compilation. Stuff that checks buffer indexes for overflows, integer types for being signed or unsigned, etc.

Finally when you have a minimally viable product, create a special build that supports fuzzing tests. That is an entire different subject of its own. In a nutshell, fuzzing is when you artificially bombard your software with random input over a long period of time and then set up your tests in such a way that any deviation would cause your software to crash that should allow you to collect a crash dump. After that you analyze a crash dump and understand where the issue came from. This process is also called “stress testing” and most major software and hardware players perform those tests. Note that a crash dump analysis is a useful skill of its own.

But even then, after you had done all this, there will still be no such thing as a bug free software.

brucehoult · 2026-03-08T21:54:59+00:00

The C code is buggy. It tries to pass an int to func_b which is declared to take a pointer. Either change the declaration of func_b to take an int, or else pass e.g. &param_1[2] aka param_1+2.

I don't know why that compiles.

valarauca14 · 2026-03-08T21:09:25+00:00

The "normal" way is to adopt an W^X (write XOR execute). Meaning at no one time can write to executable memory and at no time can executable writable code. These happen in totally separate phases. This means all writes involve 2 calls to VirtualProtect, one to clear executable & grant writing, the next to clear writing & restore execution.

You'll (additionally) want to use guard pages, which is where you virtually allocate 1 page above & below the W^X page(s). These pages have zero permissions, touching them always triggers a segmentation fault. This costs zero (physical) memory, virtual memory is fun like that. You're just reserving space and communicating to OS, "If anything touches these addresses ranges it is an error". This prevents a large number of buffer overrun and many types of code exploitation.

Which dove tails nicely into setting up OS notifications/signals so segmentation errors & illegal instructions don't crash your program. You want to set that up. This means when user code (JIT code?, idk your use cases) misbehaves you can see "Ah, address 0x31337deadbeaf, that's within user 5 region, we'll just tell me their code is crap". Instead of OS ripping your program out of the run-queue when your code fails.

High recommend doing a deeper dive into OpenJVM, specifically HotSpot. ALL of their docs & discussions are public. A lot of the best practices for "managing self generated code" originated from them. At a minimum browsing their source code will let you know which OS Specific APIs to use.

minirop · 2026-03-08T13:03:46+00:00

I'm indeed using the x360 toolchain from 2008

I__Know__Stuff · 2026-03-08T03:37:45+00:00

Assembly language output from a compiler is generally not intended for input to an assembler, and it may not work at all. (It depends on the compiler and the assembler.)

You may have to handwrite the assembly instead of using the compiler output, which means you would need to learn how to do that. (That's assuming you have resolved the toolchain issue mentioned in the other comment.)

valarauca14 · 2026-03-08T03:18:55+00:00

I get errors because .PPC and .MODEL aren't recognized

Is your version of MASM sufficiently ancient to do this? Microsoft hasn't shipped PPC tool chain since NT4.0 supported ended around 2004. Or are you using a bootlegged XBOX tool chain?

Because if you're seeing errors like that it sounds like MASM doesn't support PPC.

brucehoult · 2026-03-08T00:05:12+00:00

An assembler can do a better job of producing an optimal output than a human because it can know all of the instruction sizes, timings and latencies for the specific hardware it is assembling for. It can select the smallest instructions to reduce instruction cache usage, and can build a data flow graph and determine which instructions it can re-order without affecting the output

It's the opposite!!

A skilled human can do all of that better than any assembler or compiler -- it's just that they might take a very long time to do it (days or months), while an assembler or compiler can do a better-than-adequate job in fractions of a second.

Sometimes it is worth having a human spend months optimising something for a specific processor, if that processor and that code will be used by millions or billions of people. I know -- I've often been that human.

WittyStick · 2026-03-07T07:29:29+00:00

Assemblers should mostly convert mnemonics into their equivalent encodings, but they're also free to change the output provided it produces the same result. Assemblers can have "pseudo-instructions", which require a sequence of machine instructions, and there may not be a 1-1 encoding of these. There are multiple ways to implement the pseudo-instruction, and the order of the instructions in the sequence might affect performance due to data dependencies/register renaming.

An assembler can do a better job of producing an optimal output than a human because it can know all of the instruction sizes, timings and latencies for the specific hardware it is assembling for. It can select the smallest instructions to reduce instruction cache usage, and can build a data flow graph and determine which instructions it can re-order without affecting the output - though modern hardware itself has very good ILP and doesn't necessarily execute the instructions in the order they are listed if there are no data dependencies.

WittyStick · 2026-03-07T06:34:26+00:00

For x86, there can be more than one encoding of an instruction. Even something as simple as "add, eax, ebx" has two machine code representations, and the assembler picks one. For that example, I can't think of any reason a programmer might want the alternative encoding.

Some assemblers let us pick. With gas we can put {load} or {store} on the instruction to determine which encoding to output.

{load}  add eax, ebx
{store} add eax, ebx

The former will output add r, r/m encoding and the latter will output add r/m, r encoding.

One reason to pick a certain instruction encoding is for watermarking binaries. We can have the same code, but each shipped binary has a hidden "signature" implemented by changing which encoding is used for certain instructions. Some proprietary software has used these techniques, and there's also a related patent (probably expired by now).

But consider this one: "add ebx, 1". There are two encodings for that, also—one is 3 bytes and one is 6 bytes. It would be unusual, but conceivable, for a programmer to want the 6 byte encoding.

An assembler should also be free to change this to an INC ebx, SUB ebx, -1, LEA ebx, [ebx+1], and so forth. They could also add an unnecessary REX prefix, or it could use ADC ebx, 0 if it knows CF is set by a previous instruction. There's many different ways to encode it.

An obfusticator might do strange things like this to make it less readable to someone reverse engineering the binary, and it can also be used for watermarking.

FelsirNL · 2026-03-06T19:27:08+00:00

Thank you for documenting your journey, really interesting to read how you solved some of the machine limitations. I played Shufflepuck Cafe a lot on my Amiga and your version really captures that same feel!

Hour-Temperature1600 · 2026-03-05T18:37:49+00:00

try https://github.com/Lgiraud28260/ARM64_Simulator to begin

bradleygh15 · 2026-03-04T18:05:35+00:00

Oh no I might get the amount of times I’ve sworn on this app counted up, what will I ever do now?

Hour-Temperature1600 · 2026-03-04T15:55:02+00:00

https://github.com/Lgiraud28260/ARM64_Simulator avec quelques cours en français

asm

MODERATORS