When building a model rocket, it can be fun to get into the maths of it all—calculating the expected performance of your build, and then seeing how it measures up in the real world. To aid in that task, [Rotislav Persion] has created a simple web-based simulator for charting the potential performance of your own rockets.

The calculator lets you key in the fundamentals of your hobby rocket. Punch in the diameter of your rocket, its mass, the standard rocket engine you’re using, and the diameter and delay time of your parachute, and it will chart the altitude profile expected during flight.

Punch in the details for a small 1-inch diameter rocket with an A8-5 engine, and you’ll find it won’t go very high or very far, and the calculator bears that out. However, upgrade to a C6 engine and you’ll go higher and faster, and drift a lot longer once the parachute is deployed.

Perhaps the only thing missing from the simulator is a wider variety of rocket engines to choose from, and more parameters to tweak for finer simulation. However, for small and basic rockets, it’s an interesting starting point you can use to learn about the basic mathematics and physics behind your rocket’s flight.

We’ve seen some great feats in model rocketry, not least of which was a valiant effort to master vertical landing. If you’ve got your own unique model rocket hacks cooking up in the lab, don’t hesitate to notify the tipsline!

hackaday.com/2025/08/04/a-simp…

Gli specialisti del Genians Security Center hanno scoperto una versione migliorata del malware RoKRAT, associato al gruppo nordcoreano APT37. La nuova versione si distingue per un insolito modo di nascondere il codice dannoso: nel corpo delle normali immagini JPEG. Questo approccio consente di bypassare i sistemi antivirus tradizionali, poiché la funzionalità dannosa non viene scritta direttamente sul disco, ma viene estratta nella RAM.

L’infezione iniziale inizia con l’avvio di un collegamento .LNK dannoso contenuto in un archivio ZIP. Un esempio è un archivio chiamato “National Intelligence and Counterintelligence Manuscript.zip”. La sua struttura include un file .LNK di grandi dimensioni (oltre 50 MB) che contiene documenti esca e componenti codificati: shellcode (ttf01.dat), script PowerShell (ttf02.dat) e file batch (ttf03.bat).

Quando il file viene eseguito, PowerShell viene attivato, utilizzando un XOR a un byte con la chiave 0x33, decrittografando lo shellcode a 32 bit. Il passaggio successivo prevede l’iniezione di un secondo livello di codice crittografato, che viene decrittografato all’offset 0x590 utilizzando la chiave 0xAE. Questo crea un file eseguibile contenente riferimenti a informazioni di debug, come il percorso “D:WorkUtilInjectShellcodeReleaseInjectShellcode.pdb”.

Il frammento decrittografato viene quindi iniettato in processi Windows legittimi come “mspaint.exe” o “notepad.exe” situati nella directory SysWOW64. Questa procedura crea una memoria virtuale in cui vengono scritti blocchi di dati di circa 892.928 byte. Questi vengono nuovamente decrittografati utilizzando XOR, questa volta con la chiave 0xD6. A questo punto, la parte principale di RoKRAT viene attivata.

Il file non viene salvato su disco, rendendo molto più difficile l’analisi post-infezione. I segnali di affiliazione ad APT37 includono timestamp del file, come 21 aprile 2025 alle 00:39:59 UTC, e costrutti univoci come “-wwjaughalvncjwiajs-“.

L’innovazione significativa è l’uso della steganografia. Il loader dannoso RoKRAT è incorporato in un’immagine JPEG, come “Father.jpg”, ospitata su Dropbox. Questo file conserva un’intestazione Exif valida, ma a partire dall’offset 0x4201 contiene uno shellcode codificato. Per estrarlo, viene utilizzata una doppia trasformazione XOR: prima con la chiave 0xAA, poi con 0x29. RoKRAT viene quindi caricato direttamente in memoria ed eseguito senza lasciare traccia sul file system.
Esempio di malware camuffato da file immagine
Per avviare il file DLL dannoso, vengono utilizzate tecniche di sideload tramite utility legittime, come ShellRunas.exe o AccessEnum.exe, incorporate nei documenti HWP. I download vengono effettuati da piattaforme cloud, tra cui Dropbox, pCloud e Yandex.Disk, utilizzando API e token di accesso scaduti, come ad esempio: “hFkFeKn8jJIAAAAAAAAAAZr14zutJmQzoOx-g5k9SV9vy7phb9QiNCIEO7SAp1Ch”.

Oltre a raccogliere informazioni e documenti di sistema, RoKRAT acquisisce screenshot e li invia a server esterni. Gli ultimi campioni, datati luglio 2025, sono distribuiti tramite scorciatoie come “Academy Operation for Successful Resettlement of North Korean Defectors in South Korea.lnk”. Queste versioni utilizzano già “notepad.exe” come processo di destinazione per l’iniezione e nuovi percorsi come “D:WorkWeapon” sono specificati all’interno del codice, a indicare il continuo perfezionamento del toolkit.

I sistemi di rilevamento e risposta agli endpoint (EDR) svolgono un ruolo importante nella protezione da tali attacchi. Queste soluzioni monitorano le attività insolite, tra cui iniezioni di codice e connessioni di rete alle API cloud. La visualizzazione tramite EDR consente di ricostruire l’intera catena di attacco, dall’avvio di LNK alla trasmissione dei dati al server di comando, nonché di isolare rapidamente la minaccia utilizzando la metodologia MITRE ATT&CK.

Con i metodi sempre più sofisticati dei gruppi APT basati sul diniego di accesso ai file e sul trasferimento occulto di dati, è chiaro che le tradizionali difese basate sulle firme non sono più sufficienti. Soprattutto quando vengono presi di mira i sistemi Windows in Corea del Sud e in altri paesi della regione.

L'articolo Il malware si camuffa in una foto innocente su Dropbox. La strategia steganografica di APT37 proviene da il blog della sicurezza informatica.

Originally known as FORTRAN, but written in lower case since the 1990s with Fortran 90, this language was developed initially by John Backus as a way to make writing programs for the IBM 704 mainframe easier. The 704 was a 1954 mainframe with the honor of being the first mass-produced computer that supported hardware-based floating point calculations. This functionality opened it up to a whole new dimension of scientific computing, with use by Bell Labs, US national laboratories, NACA (later NASA), and many universities.

Much of this work involved turning equations for fluid dynamics and similar into programs that could be run on mainframes like the 704. This translating of formulas used to be done tediously in assembly languages before Backus’ Formula Translator (FORTRAN) was introduced to remove most of this tedium. With it, engineers and physicists could focus on doing their work and generating results rather than deal with the minutiae of assembly code. Decades later, this is still what Fortran is used for today, as a domain-specific language (DSL) for scientific computing and related fields.

In this introduction to Fortran 90 and its later updates we will be looking at what exactly it is that makes Fortran still such a good choice today, as well as how to get started with it.

Modern Fortran

Punch card from a typical FORTRAN program by the early 1970s. (Credit: Arnold Reinhold, Wikimedia)
The release of the Fortran 90 (F90) specification in 1991 was the first major update to the language since Fortran 77, and introduced many usability improvements, as well as the dropping of punch card era legacy requirements and limitations to variable lengths and more. This is the reason for our focus on F90 here, as there is no real reason to use F77 or earlier, unless you’re maintaining a legacy codebase, or you have a stack of new cards that need punching. In case you are dying to know what changed, the Wikibooks Fortran Examples article has examples of early FORTRAN all the way to modern Fortran.

Of note here is that a modern Fortran compiler like GCC’s GFortran(forked from g95) still supports F77, but users are highly encouraged to move on to Fortran 95, a minor update to F90, with GFortran supporting up to F2008, with coarray support, as covered later. F2018 support is still a work in progress as of writing, but many features are already available.

Support for the latest standard (F2023) is not widely available yet outside of commercial compilers, but as a minor extension of F2018 it should eventually get rolled into those features as the implementation progresses. This means that for now F2008 is the latest standard we can reliably target across toolchains with new Fortran code.

Beyond GFortran there are a few more options, including Flang in LLVM and LFortran in addition to a gaggle of commercial offerings. Unless you intend to run high-performance computing code on massive parallel clusters like supercomputers, the GNU and LLVM offerings will probably suffice. Simply fetch either GFortran or Flang from your local package manager or equivalent and you should be ready to start with programming in Fortran.

Hello World

As with most DSLs, there is very little preamble to start writing the business logic. The ‘Hello World’ example is most succinct:
program helloworld
print *, "Hello, World!"
end program helloworld
The program name is specified right after the opening program keyword, which is repeated after the closing end program. This is similar to languages like Ada and Pascal. The program name does not have to match the name of the file. Although there’s no explicit specification for what the file extension has to be for a Fortran source file, convention dictates that for F77 and older you use .f or .for, while F90 and newer uses generally .f90 as extension. Although some opt to use extensions like .f95 and .f03, this is rather confusing, isn’t recognized by all compilers and all of those are similar free-form Fortran source files anyway.

Tl;dr: Use .f90 for modern Fortran source files. Our Hello World example goes into a file called hello_world.f90.

The other point of note in this basic example is the print command, which looks somewhat cryptic but is quite easy. The first argument is the format, reminiscent of C’s printf. The asterisk here simply means that we use the default format for the provided value, but we could for example print the first string as an 11 character wide field and a variable string as 8 wide:
character(len=8) :: name = 'Karl'
print '(a11,a8)', 'My name is ', name
This also shows how to declare and define a variable in Fortran. Note that if you do not start the code with implicit none, variable names that start with I through N are considered to be integer type and real otherwise. With gfortran you can also globally do this by compiling with the -fimplicit-none flag.

A total of five basic types are supported:

• real
• integer
• logical (boolean)
• complex
• character

Finally, comments in Fortran are preceded by an exclamation mark !. It’s also relevant to note that Fortran – like all good programming languages – is case insensitive, so you can still write your Fortran code like it’s F77 or Fortran II, yelling in all caps without anyone but the people reading your code batting an eye.

Hello Science

Now that we have got a handle on the basics of Fortran, we can look at some fun stuff that Fortran makes really easy. Perhaps unsurprisingly, as a DSL that targets scientific computing, much of this fun stuff focuses around making such types of computing as easy as possible. Much of this can be found in the intrinsic procedures of Fortran, which make working with real, integer and complex values quite straightforward.

For example, conjugating a complex number with conjg:
(Credit: Fortran Wiki)
Basically, whatever mathematical operation you wish to perform, Fortran should have you covered, allowing you to translate your formulas into a functional program without having to bother with any dependencies or the like. This includes working with matrices and getting into the weeds with numerical precision.

Even better is that you’re not stuck running your code on a single CPU core either. Since Fortran 2008, Coarray Fortran (CAF) is now part of the specification. This feature enables parallel processing, which is generally implementing on top of the Message Passing Interface (MPI) protocol, with gfortran implementing CAF support. Depending on the selected option with the -fcoarray= flag, gfortran can use the ‘single’ image (thread) option, or with a library like OpenCoarrays it can use MPI, GASNet, and others.

When using CAF with MPI, the program (‘image’) is distributed across all nodes in the MPI cluster per its configuration, with synchronization occurring as defined by the program. With OpenCoarrays available from many local OS repositories, this means that any budding molecular scientist and astrophysicists can set up their own MPI cluster and start running simulations with relatively very little effort.

The DSL Life

Much like when we looked at COBOL, a DSL like Fortran is often misunderstood as ‘yet another programming language’, much like how in the 1980s some thought that the scientific and engineering communities were going to switch over to Pascal or Modula-2. One simple reason that didn’t happen lies in the very nature of DSLs, with them being developed explicitly to deal with that specific domain. It will always be possible to do everything a DSL does in any generic programming language, it’s just that a DSL can be optimized more exactly, and is often easier to maintain, since it is not generic.

There are many things that Fortran does not have to concern itself with, yet which haunt languages like C and its kin. Meanwhile, reimplementing Fortran in C would come at considerable cost, run into certain limitations of the language and potentially require compromises in order to get close to the original functionality of the DSL.

Running a cluster with Coarray-based Fortran source, churning through complex simulations that require utmost control over precision and where one small flaw can waste days of very expensive calculations, those are the kind of scenarios where you’re not looking for some generic language to poorly reinvent the wheel, but where you keep using the same – yet much more refined – wheel that has gotten us this far.

hackaday.com/2025/08/04/a-gent…

Steve and James discuss ICE (et. al.) actions, how they are becoming a secret police force and why we need to get rid of them.

youtube.com/embed/SM6kGmzkUFA?…

Sign up to our newsletter to get notified of new events or volunteer. Join us on:

• Mastodon;
• Facebook;
• Blue Sky;
• Twitter.

Some links we mentioned:

• MassPirates 2025 Administrative Coup Memory Bank;
• The IRS Is Building a Vast System to Share Millions of Taxpayers’ Data With ICE;
• 26 USC 6103: Confidentiality and disclosure of returns and return information;
• Immigration agents demand tenant information from landlords, stirring questions and confusion;
• Flight Manifests Reveal Dozens of Previously Unknown People on Three Deportation Flights to El Salvador;

Image Credit: Public Domain via Wikipedia Commons

masspirates.org/blog/2025/08/0…

Three-axis 3D printing has been with us long enough that everybody knows the limitations, but so far, adding extra axes has been very much a niche endeavor. [Daniel] at Fractal Robotics wants to change that, with the Fractal 5 Pro 5-axis printer, and its corresponding Fractal Cortex slicer.

The printer looks like an extra-beefy Voron from a distance, which is no surprise as [Daniel] admits to taking heavy inspiration from the Voron Trident. The Fractal 5 shares a core-XY geometry with the Voron, using beefy 30 mm x 30 mm extrusions. Also like the Voron, it runs Klipper on a Raspberry Pi hiding in the base. Under a standard-looking printhead using a BondTech extruder and E3D volcano hotend, we find the extra two axes hiding under the circular build plate. The B axis is a gantry that can pivot the build plate assembly a full 90 degrees; the A axis spins the plate without limit thanks to the slip rings built into the design.

The extruder may look fairly normal, but it has actually been designed very carefully to allow the nozzle to get as close as possible to the build plate when the B-axis is at 90 degrees. It looks like the E3D hotend is actually the limiting factor there, which gives plenty of design freedom when planning prints in the accompanying Fractal Cortex slicer.

Fractal Cortex is an all-new slicer written entirely in Python. It does have a 3-axis legacy mode, but it’s primarily designed for 5-axis slicing with the Fractal 5 Pro. The multi-axis operation looks very straightforward: you place “slicing planes” and orient them along the part, as many as you require. Printing pauses while the A and B axes rotate, then resumes with straight, parallel layers. Sure, non-planar slicing would be the bees’ knees on this sort of 5-axis printer, but we’ve got to say for a young engineer’s first crack at this kind of software, Fractal Cortex looks pretty good.

It sounds like [Daniel] is looking for contributors to the project, so if this project tickles your fancy, head over to the GitHub links at the top of the page and dive in.

We’ve seen other 5D printers before, but this one probably takes the cake for build volume, and having a slicer to match is a big advantage for anyone who wants to try this at home.

Thanks to [Hari] for the tip. Use all your axes to extrude your projects into our tips line here.

youtube.com/embed/2_BY-7XOgWg?…

hackaday.com/2025/08/04/open-s…

The MOS Technology 6502 is a microprocessor which casts a long shadow over the world of computing. Many of you will know it as the beating heart of so many famous 8-bit machines from the likes of Commodore, Apple, Acorn, and more, and it has retained enough success for a version to remain in production today. It’s still a surprise though, to note that this part is now fifty years old. Though there are several contenders for its birthday, the first adverts for it were in print by July 1975, and the first customers bought their chips in September of that year. It’s thus only fitting that in August 2025, we give this processor a retrospective.

The Moment Motorola Never Really Recovered From

The advert that started it all. MOS Technology, Public domain.
The story of the 6502’s conception is a fascinating tale of how the giants of the early mocroprocessor industry set about grappling with these new machines. In the earlier half of the 1970s, Chuck Peddle worked for Motorola, whose 6800 microprocessor reached the market in 1974. The 6800 was for its time complex, expensive, and difficult to manufacture, and Peddle’s response to this was a far simpler device with a slimmed-down instruction set that his contact with customers had convinced him the market was looking for: the 6502.

There’s a tale of Motorola officially ordering him to stop working on this idea, something he would later assert as such an abandonment of the technology that he could claim the IP for himself. Accompanied by a group of his Motorola 6800 colleagues, in the summer of 1974 he jumped ship for MOS Technology to pursue the design. What first emerged was the 6501, a chip pin-compatible with the 6800, followed soon after by the 6502, with the same core, but with an on-board clock oscillator.
My 6502-powered Beeb may be showing its age, but it remains one of the most comprehensively specified computers for its time I have ever used.
If you were one of the small group of very geeky kids in the early 1980s who really used their home computers instead of merely gaming it’s likely you are part of the only generation ever to have a playground one-upmanship over processor architectures. Those of us with a Z80 in our Sinclair machines would cite the higher clock speed, while the Commodore owners would talk about the 6502’s pipelined architecture and smaller instruction set.

With the benefit of many decades’ hindsight it’s fair to say they had a point, and one that the Z80’s ability to flip between two sets of registers on a dime couldn’t make up for. The 6502 was quick, it had a reliable manufacturing process, and since MOS Technology sold it to anyone for a surprisingly reasonable price rather than restricting it to big-bucks industrial customers, it or one of its many derivatives was a natural choice for much of the first generation of home computers and consoles. If you had an Acorn, an Atari, a Commodore, an Oric, or an Apple 8-bit machine you would have had one, and if you had a Nintendo console you also joined the 6502 club.

Just Who Is Still Buying A 6502?

It’s still not too difficult to find dedicated defenders of the 6502 among those now in their 50s geeks who owned an 8-bit computer when they were new. Just as with their Z80-fan friends, they come from an era when it was possible to fully comprehend the architecture of your computer at nearly gate level. It’s thus understandable that both architectures lingered on in the world of embedded computing long after their heyday on the desktop had passed, but it’s still a surprise to find the WDC version of the chip still in production. Unlike other surviving 8-bit architectures such as the 8051, this is the real thing in a 40-pin DIP rather than a core found embedded in other chips, so we’d be curious to know: aside from a small number of retrocomputing enthusiasts, who is still buying these things? The Z80 finally shuffled off this mortal coil last year, so how long has the WDC W65C02 got left? We’d be curious for your views.

Speaking personally, I had a foot in both camps. Like many British kids of the early 1980s I could save enough pocket money for a Z80-based Sinclair ZX81 of my own, but I had access to a room full of 6502-powered Acorn BBC Micros at school. I thus painstakingly hand-assembled Z80 code for the Sinclair, and was blown away by the built-in assembler in the Beeb. But did I have a favourite? Perhaps not, after all the most important lesson is one I only fully understood years later; that far more important than what architecture a computer uses is what you can do with it. And in that, to my profound sadness as a Sinclair fan, the 6502-powered BBC Micro won hands-down.

Header image: Dirk Oppelt, CC BY-SA 3.0.

hackaday.com/2025/08/04/happy-…