verity | Evernym Verity is a decentralized protocol platform | SDK library

I asked the question simultaneously on the XDA Forums, and got a reply there.

At the stage described above (unlocked bootloader, Magisk, signature spoofing with riru + LSPosed), all that's needed is to install NanoDroid with microG as a Magisk module. Download the current NanoDroid-microG zip from here:

https://downloads.nanolx.org/NanoDroid/Stable/

either on your phone directly or transfer it to your phone, then install it as a Magisk module from storage. Voilà, GApps are removed (or at least inaccessible) and microG works. Best to then update microG, e.g. via its F-Droid repo: https://microg.org/download.html.

Turns out the the requests can be canceled with Context.TryCancel(); and in progress rpcs can be ended with Responder.FinishWithError(grpc::Status::CANCELLED, this);

Also i was not using AsyncNotifyWhenDone

Indeed you have a clash in RestEasy (transitive) dependencies in your project:

Your third problem (truncated pickle data) is because you are using TCP, and you are unpickling whatever recv returns. You might be thinking that whenever you send something, and the receiver calls recv, returns the exact same thing, but actually it doesn't. TCP splits your data up into packets, so the receiver might not receive all the data at the same time.

For example, if you send "abcdefgh" and then separately send "ijkl", it's allowed for the first receive to return "abcd" and the second to return "efghijkl". Or the first one could return "ab" and the second one could return "cde" and the third one could return "fghijkl", or so on.

You have to design a way for the receiver to know when to stop receiving. For example, if you sent "8abcdefgh" and then "4ijkl", the receiver could get "8abcdefgh4ij", and then it knows "8abcdefgh" is one "send" (because it starts with 8 and then 8 more bytes) and it knows the "4ij" is the beginning of the next "send" but it's not the whole thing (because it starts with 4 but there aren't 4 more bytes).

Another way is to send a special character like a newline (enter key) after each message. This probably doesn't work with pickles because pickles can have newlines in them. But you could choose another byte that pickles don't have, like 0xFF. Then the receiver knows to keep on receiving until it sees the byte 0xFF.

We've been in a similar situation and ended up using Husky in conjunction with Yarn Workspaces

It's been working great for us - the only thing that every developer needs to know is to run yarn after cloning, and all tools will be installed.

The only caveat in your situation is that you will need to write your own hook for e.g. running npm install if the pulled commits contain package.json changes, but that shouldn't be very hard to do - husky hooks are plain bash scripts after all.

With pandas you can add two columns in a more simple way:

Android can use dm-verity to protect non-data partitions against manipulation (link, link).

The goal is to prevent an attacker (with physical access to the device) from inserting malicious code, e.g. into low-level Android services stored on the /system or /recovery partition.

For partitions marked with the verity flag in the fstab, at build-time the dm-verity hash tree of the partition is computed. The hash tree is signed with an RSA key and appended as meta-data to the partition. The public part of the RSA key is added to the boot partition.

At boot-time, the kernel verifies the integrity of the signed hash tree in the partition meta-data using the RSA public key stored in the boot partition. Then it can compute the hash tree of the partition and compare it to the hash tree from the meta-data. If there is a mismatch, the kernel refuses to boot.

Therefore, if an attacker manipulates the partition, the hash tree computed at boot-time will not match the hash tree from the partition meta-data. If the attacker also manipulates the hash tree from the partition meta-data, the signature validation with the RSA public key will fail.

Of course you then need an additional mechanism to ensure the integrity of the boot partition. This can be done with Secure-Boot-like mechanisms where the boot partition is again signed with another (RSA) key and the public part of that key is embedded at a lower level (vendor-specific). Such a chaining of verification mechanisms is referred to as a chain of trust. Ideally, you would want a chain of trust to extend down to the hardware level, with some vendor key being burned into the chip.

You can check the path by going to Tools -> SDK Manager and looking at Android SDK Location. Generally, the adb is present under the platform-tools folder present under this Android SDK Location.

At that location you need to execute ./adb.

Else you can also export that platform-tools path to access adb from anywhere, as follow: