3
$\begingroup$

I am building a platform in which there is a central server & devices (computers).

These computers hold the same keys pairs that correspond to specific resources (shared between devices), so that only these devices can return signed data if required.

In that setup my question is:

How to store keys on the server-side, with only devices being able to read them AND no device interactions to replicate those keys?

$\endgroup$
  • $\begingroup$ What does only devices mean? Do you have a cryptographic hardware module that needs access to them or what? (And in that case can you not store keys directly on it?) $\endgroup$ – otus Feb 12 '17 at 10:11
  • $\begingroup$ What kinds of keys / trust relationship do the devices have with the central server? Do they have a shared key with the server? Do they have a shared key for the ressource? $\endgroup$ – SEJPM Feb 12 '17 at 10:52
  • $\begingroup$ @otus "Devices only" means only those could read/decrypt those keys stored on server (ideally without using server as a hub for exchanging data/keys) $\endgroup$ – Benjamin Soulier Feb 12 '17 at 16:01
  • $\begingroup$ @SEJPM Devices could all have the same shared key, but the server. The tricky point is to get all devices to have something shared, so that they can read encrypted keys on server storage but without any device-to-device exchange. $\endgroup$ – Benjamin Soulier Feb 12 '17 at 16:05
  • 1
    $\begingroup$ The server is bound to have some way, not currently in the question, to distinguish real devices from rogue ones (like a shared secret; a conventional PKI established by a trusted third party; or that only real devices can send messages to the server). Otherwise, I fail to see that academic cryptography has a solution. $\endgroup$ – fgrieu Feb 14 '17 at 21:45
1
$\begingroup$

Problem Statement: I will answer this question as I think I understand your problem. I will write down what I've understood from your problem:

  1. Your system is comprised of a central server and some nodes/devices/computers.
  2. You need a digital signature of the devices as well as the server tying them to non-repudiation constraint (They can't deny having taken action.).
  3. The public and private key pairs between devices shouldn't be exchanged between them but rather setup by the server.
  4. The devices should be able to communicate with each other using those asymmetric key pair.

Assumptions:

  1. You can't change packet format or constitution.
  2. Every device obtains its asymmetric key pair from the server.

Solution:

Let every device have a global unique identifier (e.g Medium Access Control address), the configuration of the server takes place like this:

  • The server opens itself to requests (time-slotted) and creates a table of all the devices (IP, MAC, parameters based on design) then creates 2n keys (Public and Private) for n devices and communicates it to them.
  • Any device A which intends to communicate to any other device B requests B's public key from the server and locks the message using its (A's) private key.
  • The message is then passed on to the server which identifies the communicating parties A, B and passes it on to B.
  • B reads the message by unlocking it using its private key and finds it digitally signed using A's public key.

I would have liked to comment and verify a few details to make this answer better catered to your problem but I need to gain some rep before commenting. There are several security issues which will still remain but I will only solve them when you care enough about them.

|improve this answer|||||
$\endgroup$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.