With SAFE your data is yours and doesn’t belong to some megacorp.
Uses of collected user data aren’t all bad though.
If you use Google Maps you can see when a location is likely to be crowded, for a shop that might be a time when you want to avoid it, but for a bar that might be a good time to visit (at least in non-corona times).
Smart watches have activity trackers, pulse meters, oxygen sensor and are getting blood glucose sensors. This data could be collected and analyzed to make new health discoveries, even more if it could be combined with medical journals.
IoT or smart home devices collects all kinds of useful data. If you were using SAFE, sometimes some of that data might not be very private and you could just share it publically, such as data from a weather station showing outside temperatures, wind and rain. In many cases you might be vary of just publically sharing all data though.
As it turns out, it may be possible to still share private data in a way such that it can be analyzed by algorithms, without anyone being able to see the input data, only the result.
One such way is functional encryption. Functional encryptions works in such a way that a central authority generates a private and public key pair, with that private key they can then generate a number of special private keys connected to some function or algorithm, that when combined with data encrypted by the public will, will perform this function or algorithm during the decryption process.
For example 10 users may each send in a number, the authority will create a special secret key for the process of calculating the average of those numbers and each of the users will encrypt their number with the public key distributed by the autority and when decrypting these with the special key it would spit out the average.
The Fentec Project has a bunch of interesting examples published such as machine learning on encrypted data, selective access to clinical data and building a heat-map of the location of users in a fully anonymous way.
The problem with functional encryption is that you need a trusted central authority. That central authority has a master key, which could in theory decrypt all the data, but they’re trusted to only use this master key to create new special keys for the requested computations.
In SAFE, the elders of a section forms such an authority. Assuming the majority of the elders in a section are honest, if they were tasked with creating keys for some computation on encrypted data, they could be trusted to do this and not decrypt/steal the whole dataset, I suppose this would be analogous to a section stealing money that it is responsible for.
It would require some kind of compute support on SAFE though.
Modified definition taken from the wikipedia page on functional encryption.
Setup → (pk,msk)
Keygen(msk,f) → sk
Enc(pk,x) → c
Dec(sk,c) → y
Where pk is the public key, msk is the master secret key, f is the function to be performed on the encrypted data, sk is the secret they that can be used to decrypt the data while simultaneously performing the function f on it, c is the encrypted data from each user and y is the final decrypted data, containing the result of the computation.
The steps that would need to be performed by the elders of a section is Setup and Keygen. Ideally Setup would be what the elders have already done, setting up a BLS key where each elder has one part of the multisig private key. In that case a way would need to be found to use BLS keys in the rest of the steps.
The key sk returned by the keygen process could then either be published publically or kept privately in cases where for exampe a data marketplace would pay all users contributing the data and each user who wanted to access the data would need to pay to do so (anyone could in theory choose to post the data publically though).
Evaluating the results could be done by clients or adults in a section. The main point of this is that no single elder in a section would be able to decrypt the data encrypted by the users. All, or a majority of, elders would have to collude for that.
Getting stuff like this production ready would need lots of research and development and is still at minimum years away, but the SAFE Network itself should just need general compute abilities as is planned for later plus some kind of API access to section keys, maybe the last part would need to be implemented as a specific feature for functional encryption.