All repositories are in one GitHub list: Full Unlock.

How it worked

WP7 verifies every module before it loads. When an app wants something protected, the OS asks a policy engine. Full Unlock replaced both of them and hid the replacement.

• clkflt is a file-system filter. When the OS opens a stock system module, clkflt serves a patched copy instead. The modified files stay hidden from the kernel, so Windows Update kept working. It also caches file contents in memory, which made the phone a bit faster.
• ulv stands in for \Windows\mslvmod.dll, the loader verifier. It calls the original and then overrides the verdict. Every module gets permission to execute.
• upl stands in for the policy engine. If the caller’s account is privileged, the request passes. If not, upl denies it and posts a record to a message queue.
• uplhlp reads that queue and shows a toast that offers to unlock the app.
• accman moves accounts into the privileged group. It takes the list from HKLM\Software\OEM\Accman. A FULL_TRUST value there opens the whole system to every app.
• StringLoader is a small library that loads localized strings for uplhlp.

I described the whole chain in detail back in 2014: How it works: Full Unlock (in English) and Как это работает: Full Unlock (in Russian). In 2019 I gave a talk on the same topic at SPISOK-2019: Windows Phone 7 full unlock architecture.

Building it

You need Visual Studio 2008, the Windows Mobile 6 Professional SDK and the WP7 SDK. Every project targets ARMv4I. constellation-wp7 is a workspace: basis install clones all six components side by side.

Microsoft ended WP7 support in 2014, so the code is here for reading. The project pages on this site now link to the sources: Cloaking Filter, LoaderVerifier, uPolicyEngine, Account Manager.

In 2024, there are tens of IDEs, text editors that work better than IDEs, all of them use Language Server Protocols, there are many static analyzers, testing tools, whatever.

Did the development process become better? If you never coded before, it feels like yes. Endless choices of libraries, ways to show off your skills, Docker containers, Kubernetes deployments. You can literally start coding with AI (badly but still).

The truth is that the process didn’t become any better. These features harm you in many ways. Two important aspects below.

You no longer own what you develop.

Many parts of your app stay in the cloud. Most parts are developed by someone else. To use all of that, you have to pay someone directly or indirectly.

Cut off Docker, your app is dead. Cut off AWS, how does your cloud service work?

If I were to destroy the entire world’s IT, I would hit connectivity to any of these services. This is so fragile.

You no longer get hands-on experience.

I like containers as daily life simplifier. I simplify setups a lot with them. However, do you fully understand what happens inside the container?

Do you understand the underlying technology behind Docker, like Linux itself, security hardeners (seccomp, apparmor, whatever), OverlayFS, uid maps, etc. I doubt so. Moreover, package installation becomes a mystery: you just take the easiest image with a simple setup, and you never care what happens inside.

This sparkles the whole generation of fast enablers. Cool for the economy of IT fast food, terrible for proper high-tech industry where you have to actually innovate.

No conclusion

The progress is unstoppable. However, we must have some ways to stop intellectual property and actual knowledge from spreading across different parties.

I’ve seen the need to support Microchip (Atmel) Studio project generation for CMake projects. I’ve tested alternatives like a third-party generator for CMake, but it was hard to deploy in practice.

Is there anything easier to deploy than a small Python script? I doubt so. So, I’ve created a simple Python project called Cast (Compile Commands to Atmel Studio converter). As the tool’s name suggests, it can be used for any project producing compile_commands.json, not only CMake ones.

If you add a Makefile wrapper for your build system, you will be able to build from within Microchip Studio as well.

Help improve the tool if you feel it is handy for you!

Here it is: pure C library for parsing the format. Its usage is as simple as:

#include "fmt_parser.h"
#include "fmt_util.h"
#include <stdio.h>

int main()
{
    fmt_status  rc;
    fmt_spec    spec;
    const char *str = "Hello, %157$02ld test %*s world!";
    const char *tmp = str;

    do
    {
        fmt_spec_init(&spec);
        rc = fmt_read_one(&tmp, &spec);
        if (rc == FMT_EOK)
        {
            fmt_spec_print(&spec, stdout);
            printf("\n");
        }
    } while (fmt_read_is_ok(rc));

    return 0;
}

Additionally, it doesn’t allocate memory, so it is safe in that aspect.

Specifier API

If you use it from other languages, the specifier API might be handy for you as it provided some wrappers for string and specifier allocation (you should not need to know the compile-time size of structures then). This API can be disabled using -DENABLE_SPEC_API=OFF.

Custom char type

Some projects might use a custom char type. The library doesn’t support runtime change of char type as of now, but it provides an option to set up type in compile time. See -DCHAR_TYPE.

Future directions

The library doesn’t support custom specifiers. Moreover, it doesn’t support de-facto standard specifiers from Microsoft, Linux, etc. I will improve the library as I see the need for it (I will).

Contributions are always welcome! The MIT license allows reusing the library in other projects pretty freely.

At some point, you notice that these projects don’t obey to rules. It is often impossible to run these tools under a debugger to get a meaningful result. You get unreadable hundred millions log lines. Reverse debuggers are not useful either: the place where the bug appears is so far from the crash point that you might never really find it.

My advice in such cases is:

1. Spend time and try to think of a possible error.
2. Narrow the log down to the domain which, as you think, might be buggy. If possible, disable all other logging so it doesn’t consume priceless time.
3. Simplify log: print inputs, outputs and actions done.
4. Repeat until you find the error in function output.

This reduces cognitive load down to a minimum and allows you to finally read all the important actions.

So, you know the technology. You think you may code more efficiently than best practices suggest, and it is often true. But what happens when you make exceptions for best practices?

Think ahead

A junior software engineer comes to the company. The person (hopefully) reads outdated policies and understands nothing about the development process in your company. The more tickets are assigned, the more code this person writes. How to write it? Of course, by looking into existing examples. Now, terrible things happen in the background, e.g. memory leaks start occurring… You review the code and miss bugs because a big part of the code looks familiar to what you write. The implicit knowledge of yours is lost.

The software consisting of implicit knowledge is broken since the beginning.

Takeaway

Exceptions from exceptions

Of course, there can be exceptions. If you think that following API usage is not efficient, write it as a comment. That will work and will teach junior engineers that explicit knowledge.

Linux is open-source, as well as the most components from Linux distributions. If you hit an issue, it is usually trivial (but not always) to narrow it down to the specific module and/or configuration. If you need to understand how to do advanced things, you can look up source code and you will understand it.

The main problem with Windows is a space comprising barely understandable layers. That’s it – a typical Windows user manages complexity pretty well, but only as long as internals are not concerned. The internal side is a big black box, and even if you have a complete Windows source code, it remains hardly understandable.

Instead, in Linux, there are no black boxes. How does it help new programmers?

• Every day you deal with a well-designed and well-decomposed operating system. You learn how to decompose problems. You learn to solve them efficiently. It doesn’t happen with Windows/proprietary toolchain as you only hit the tip of the iceberg.
• During an everyday routine, you learn how layers are bound together. You see the commands which can be used. You notice that building applications is not about hitting “Build” in IDE, but it is an invocation of compilers and linkers.
• You fix issues happening in your Linux distribution. Sometimes they can be searched for, sometimes you have to dig in logs. Efficient problem-solving skills won’t appear with time, they only appear if you solve (many) issues over time.
• In the end, your expertise improves with a larger coverage of all domains your work is made of.

What is mathematics?

First of all, it is a science about abstract objects and their relations. Numbers are one sort of these abstract objects. Usually, numbers have no boundaries, so it is possible to represent ((-\infty, \infty)). The discrete mathematics adds some limitations to numbers, say, numbers can only be integral (it is a very “rough” definition: actually, discrete mathematics is about discreteness as opposed to continuity, but most people will only consider the part about “integral” vs “any” numbers). Then, there are lattices: partially ordered sets with infimums and supremums.

Numbers are not the only abstract objects, but surely among the most important ones. The presence of abstract objects is an important property of mathematics. Now, how are the numbers represented?

Point 1: types.

How are programming languages different from mathematics? In almost every language the user deals with strongly typed numbers that can have minimum and maximum value. Say, 8-bit integer has range ([0, 255]). To sum up two such integers, there must be an overflow rule which maps the sum to the ([0, 255]) range. So, types allow making mathematical objects having specific constraints. In many ways, it is similar to lattices, and it is an essential part of mathematics.

Point 2: the abstractness of expressions.

Why should (x = 5) be mathematical when written on a paper and not when written in C program? Why is (z = f(x, y)), (x,y \in [0, 255]), (f(x, y) = (x + y) \bmod 256) mathematical, but (z = x + y) is not? I would argue that programming language term is even more abstract, because it builds upon the axiomatic knowledge of types and their relations.

Point 3: programs are not “instructions for computers” when executed not by the computer they were built for.

As one may say, programming languages allow creating programs, essentially scripts for computers, so these programs are not mathematics, they are instructions for computers to execute. The latter is true for imperative languages as long as you execute them. Once you analyze the program, it is no longer instruction, it is a purely mathematical object.

Languages such as Coq make it possible to prove real-world theorems. Z3 and CVC4 languages deal with a significant part of math mechanics and can be used for proving statements. There are also declarative languages. Programs written in these languages don’t have a single instruction for the computer.

Conclusion, but there are a lot more arguments.

These days programming languages represent modern mathematical notation. It lacks a lot of “magic” of pure Descartes notation, but it was a huge effort to unite mathematics and engineering.

Everything that can be written mathematically can be written in code.

It is not only boolean logic. The language mightn’t have all features needed to represent the special notations, but it is up to the user to choose the right language.

And now I see that my research paper in Russian Scientific Citation Index is called “Effective Translation Of Directd Acyclic Graphs To Intermediate Representation”. End of story.

The performance reported by Magician is around 3256MB/s for reading and 2939 MB/s for writing.