I'm looking for a mechanism for a type of cert/key signing, where multiple keys need to sign/encrypt something, and a final key/method does not product a valid confirmation unless all those keys did sign/encrypt.
So maybe something like
- raw data
- action by key1
- action by key2
- action by keyN
- action by final user/system
It's ideal if any of the Key1..N do not need to know about each other, or only know about the next one. If necessary, one key can know about all of the keys.
The final user system would not know about most of the keys - probably not any except one of them. Regardless, that final system should be able to run a check that will be invalid if all Key1..N did not sign. It could run this by signing something it gets, and passing that to a trusted system that confirms what is expected.
Is there some manner of blind-signature design that can allow for this?
My guess
The only solution I've considered so far, is a checksum of the data that is encrypted by each successive Key. In this way, the data is nested in layers of encryption, which can be used for proof. The final system does its own encrypt, and passes this to the trusted system, which makes calls to other APIs for the owner of each Key1..N.
Obviously, this is complex and requires systems to be maintained in synchrony.
I am hoping there is a way that each Key1..N can register a public key with the trusted system, and that system can validate that each Key [did something] that shows that party has validated.
Really-ideally, I'm hoping that the final system can do this check by using one key given to it by the trusted party, but it does not reveal how many Keys1..N were involved.
