Indistinguishability Obfuscation

This is a difficult concept to wrap one's head around, so maybe ask a real cryptographer at cryptography.stakcexchange.com , because they would be able to give you a more granular breakdown of it than this channel will.

New paper was published on this a few days ago: https://cryptome.org/2020/11/Indistinguishability-Obfuscation.pdf (peer-reviewed; IACR)

https://eprint.iacr.org/2020/1003.pdf

Here's the best way that this can be broken down:

1. This is sort of like homomorphic encryption (where an entity is able to maneuver and operate on top of encrypted data without decrypting the data or having knowledge of the underlying data being managed). The reason this comparison to homomorphic encryption is being drawn is because this is essentially a property that this cryptographic scheme must possess.

2. The goal of this cryptographic scheme is to allow for programs / packages to execute given commands & schemes without the instructions for said program being decipherable (i.e., the distinguishable part).

3. This would involve you feeding the program in question some sort of encrypted information that it could iterate upon to produce the desired result w/o ever needing to decrypt your input or the 'instructions' given to the machine

If this sounds like its impossible to you, then you're not the only that's held this belief. There are plenty of others that have been incredulous about the efficacy of this proposed cryptographic scheme for years (there are no working models yet, this is all purely theoretical)

OPAQUE: PAKE Protocol

This is another nod to one of those key protocols where you don't have to actually share the password with the server (that's always the best setup, right?).

The way that this works is a bit convoluted though.

Here's an article that puts it in laymen's terms: https://blog.cryptographyengineering.com/2018/10/19/lets-talk-about-pake/

Stumbled across this because it was close to a solution that we're seeking currently that would require clients in a high-threat environment (i.e., Tor Network) to complete some form of 'Proof of Work' before even being able to contact the server itself.

(Also, a round robin rotation for exit nodes possibly as well, with said nodes evaluating the request and its accuracy; this is incomplete, there's no incentive - but I guess there never was an incentive right?)

..Digression

Pay attentoin to #4 here (and #5)

How OPAQUE works:

A) Both the server and the client hold information necessary for client authentication, but neither one of them has enough for validation / authentication (at the onset)

B) Client has password / server has the salt ; server then sends the salt over to the client for a joint computation. This is referred to as the oblivious PRF.

With just that exchange of information, the client is able to authenticate. If you want to know the sorcery behind why this is the case, then visit the link that was published above and also make sure to go ahead and visit the first whitepaper published detailing the idea: https://eprint.iacr.org/2018/163.pdf

Claims to be 'aPAKE' security.

Authors state:

"We formalize this notion in the Universally Composable (UC) settings and present two modular constructions using an Oblivious PRF as a main tool..."

Converting ed25519 into Curve25519

It has been suggested around the world of cryptography (as well as the IETF), that public ed25519 keys can also serve as encryption keys as well (Montgomery Curves).

Here's a nodejs library for those looking to do so (novelty here) - https://www.npmjs.com/package/ed2curve

You can drop the keys right into the 'NaCL Box'

Speaking of the NaCL Box

Here's a 'Go' implementation of it: https://godoc.org/golang.org/x/crypto/nacl/box

(what is 'NaCL'?) - conventionally, its "salt" if we're going by the periodic table, but in this context, we're referring to the cryptographic library (and you use 'salt' in cryptography, get it?)

This library has extremely strong cryptography. The hyperlinked text above leads to Daniel Bernstein's site - we don't need to speak on how legitimate his algorithms tend to be (despite the weird wave of hate they've been getting from other jealous cryptographers that haven't been able to achieve the same level of notoriety that Daniel Bernstein).

Getting into the Actual Box Itself

Specifications (breakdown) of the box can be found on the nacl subdomain of the cr.yp.to site here = https://nacl.cr.yp.to/box.html

Essentially this 'box' provides an API-friendly, callable authenticated public key encryption tool for communications.

The entire scheme is setup with repudiation to provide plausible deniability (i.e., deniable authentication [dPAKE]).

A really good breakdown can be found here = https://crypto.stackexchange.com/questions/78071/what-does-crypto-box-actually-mean-in-libsodium-and-nacl

Crypto Stackexchange

Usually when it comes to any online message board, question & answer platform (like Quora / Yahoo! Answers back in the day), or general social media - you're rarely going to get the best of the bunch in terms of responses.

But StackExchange is clearly the exception.

The answers that the people on there give are mind-blowingly above & beyond what is expected on the internet. Anywhere. At any point.

In fact, the answers on StackExchange are so reliable, that many consider it to be a legitimate citation whenever facts are given with a direct reference behind it linking to the site.

Many Professionals on the Network

Individuals such as the creators of the Skein hash function, Blake2 / Blake3 among others (Zooko was one of the contributors to Blake3).

Implicit Certificates (specification by the secg ; same organization that published info on various ecdsa curves)

Here's the link = https://www.secg.org/sec4-1.0.pdf

'ECQV' is its abbreviation. Make sure that you remember that if you want to check up on it for yourself at any point in the near future.

Blake3 Hash Function

Purports to be quicker than all other hash functions (yes, even SHA1) by orders of magnitude.

Yes, these are the same folk that built blake2 (almost selected as the official keccak implementation; did not lose due to inferior security but rather due to 'speed reasons')

Here's the GitHub for any that wish to try it out = https://github.com/BLAKE3-team/BLAKE3

Its built in Rust. If you want it on the command line you're going to need to build up 'b3sum' (that's the ultimate binary that you're going to be calling in the terminal).

There are also binaries available in the releases though.

1. blake3 rust crate = https://crates.io/crates/blake3

2. b3sum rust crate = https://crates.io/crates/b3sum

3. Blake3 Paper (explaining the specifications, design rationale, caveats & features) = https://github.com/BLAKE3-team/BLAKE3-specs/blob/master/blake3.pdf

This is the performance that Blake3 claims to get. If this is the case, then that's pretty overwhelming (haven't tried it yet).

They have plenty of test vectors on their site for those that are looking to try it out.

Bao Hashing Mode (for Blake3)

One of the better features that the project boasts is the 'bao hashing mode' (which you can find in specifications here = https://github.com/oconnor663/bao)

"Bao is an implementation of the BLAKE3 verified streaming"

Described in section 6.4 of their specification = https://github.com/BLAKE3-team/BLAKE3-specs/blob/master/blake3.pdf

Once compiled with Rust, you're left with a binary executable (move it to path or export the path where its at), and you'll be able to call it from the command line.

What it Does

1. This is an encoder (not an encryptor, there's a difference). That means that it is designed to encode data (you can use the 'iv' that blake hashing provides for this as well)

2. Supposing you encoded a bunch of (encrypted) data, then sent that to a node or someone else to store - you would not need to process all of the encrypted blob that they're holding in order to be assured that they have all of your data. You should be able to a 'slice' out of it and checksum it from anywhere.

So that's very uniquely cool.

Europol Decryption Program

One of the more concerning developments that we've seen in this international nation-state warfare vs. encryption.

https://www.europol.europa.eu/newsroom/news/europol-and-european-commission-inaugurate-new-decryption-platform-to-tackle-challenge-of-encrypted-material-for-law-enforcement

Specifically, the article claims that Europol has managed to successfully erect a "decryption platform" that will "significantly increase Europol's capability to decrypt information lawfully obtained in criminal investigations."

The press release also goes on to state that the platform's existence is in "Full respect of fundamental rights and without limiting or weakening encryption", which rings a bit hollow when considering that the tool will be "availabe to national law enforcement authorities of all Member States to help keep societies and citizens safe and secure."

### Why This Screams Bullshit

The fact that there will be multiple different nation states (essentially all members of the European Union) that have access to this tool (whatever it is), makes the supposed benefits of this action entirely null.

To begin with there's:

1. A ton of different nation states that will have access to these tools and information. To suggest that they will all use these tools in a responsible manner that's considerate of their citizens' rights is preposterous

2. With such intel / resources being passed around freely to all of the member states of the European Union, one must wonder how in the world the EU can guarantee that there will be any level of real control for how this platform is administered.

To suggest that all member nations of the EU will unanimously act in an ethical manner in-line with the values of all of their respective citizens is a preposterous claim at best.

What Can Be Done

We can bitch about this endlessly or we can look at the reality of the situation.

The chances that they have found a way to break all of modern encryption is highly unlikely (and if this were the case, then its very unlikely that this secret would be kept very long).

However, with that being said, it is likely that the EU has amassed the resources necessary to subvert some of the more commonly used ciphers / algorithms that are in use today. The threshold for being able to do so would not require them to necessary "break" encryption schemes (which we know is exceedingly difficulty on a scale with an upper bound at infinity).

However, using exploits like Spectre / Meltdown, cache timing attacks, differential analysis etc., could afford member states of Europol with the tools necessary to compromise individuals through other means.

AsyncSSH (this is the major key that we need to use)

- Allows for SSH / SFTP / other nice things on top

- Allows for ed448 algorithm (this one is pretty fucking significant)

- We also have the option of creating a certificate as well (which will provide even more authentication in the process ; but in order for that to work, we need to ensure that the copy of the certificate on our server is also within the separate shell instance as well)<— would it be a better idea for us to just tunnel that information over there?

https://asyncssh.readthedocs.io/en/stable/#interactive-input

Stateless PGP Keys

This is something that's been needed for quite some time. This allows for you to regenerate your PGP keys deterministically.

https://github.com/skeeto/passphrase2pgp

The magic of this stems from picking a finite UNIX time to enter as an input in the key generation process. Then voila.

Quantum Safe Onion Routing = https://arxiv.org/pdf/2001.03418.pdf (this is probably already several levels above what we see from the Tor Project already; I really don't like their earlier specifications and standards to be entirely honest with you)

^^ Maybe we also throw this in the hottg.com/libredarkweb channel ; why not?

Apologies for the gap in publishing on here, there are quite a few things that I have to add in here, so figure that I may as well stop procrastinating on that and get to it.