I am currently working in security in mobile ad-hoc networks I have several clusters, and I want from the cluster head to send some data encrypted with its public key ,to the cluster members. I assume that each member has its own private key so it can decrypt the data
I ask about how to get a single public key and multiple private keys for this public key? what is the solution for this case?
What you can do in this situation is to use hybrid cryptography, in which you encrypt the message with a symmetric algorithm and encrypt the symmetric key with the recipient's public key. You can easily adapt that to send a message to many clients, each with their own public key. What you do is encrypt the symmetric key with client A's public key, and with client B's public key, and with client C's public key, and so on; you then stick all of these "symmetric key encrypted with client X's public key" tags on the front of the message, and each client can then decrypt the symmetric key and then the message. This way, you don't have to send 20 copies of the message, just 20 copies of the symmetric key.
If you want to use asymmetric cryptography, you cannot have multiple private key and one public key. These keys work as a pair of key.
What is encrypted using the public key can only be decrypted by the private key and this key only.
To solution your problem, if you have perfect control over your cluster clients, you could share the same private key among all the cluster clients. Then the head cluster can encrypt data that can be decrypted by any and all cluster client. Of course, if any cluster client gets compromised, the key is compromised for all.
You can also manage a single key pair by cluster client. Then the cluster head would have to keep track of which public key is associated to which cluster client before communicating, otherwise the request will not be deciphered.
You would also have to issue a private/public key pair for the cluster head if you want to send encrypted answers (unless you negotiate some other protocol key).
One public key and numerous private keys are compliant with the RSA algorithm in theory, but how you implement that could determine whether or not existing software and hardware can achieve so. Here is an example of a simple number algorithm:
n = 391, since p = 17, q = 23, and phi = (p-1)*(q-1) Follow the RSA, choose e, and d = (D * E) mod (phi) = 1, for example, if e = 19, d =667,1019,1371,1723,2075 denotes numerous private keys.
As a result, if M = 88, the ciphertext = M^e mod n = C, then 88^19 mod 391 = C. Nonetheless, Ciphertext must return to message (M) = C^d mod n = 88, which means that any d number can be calculated when returning to message (M).
If you want to securely send data to your recipient, you encrypt the data using the recipient's public key, not your own.
Is there a specific requirement to use asymmetric keypairs? Can you use symmetric keys instead? Or you can even combine it, i.e. protect the tranport using TLS but data going through is actually encrypted using a pre-shared AES key.
If each member has its own private key, then each member must have a corresponding public key. None of these public keys can be identical.
If you want to distribute data from one system to one or more other systems using encryption, please use an existing protocol to do this, like TLS or SSL, as these techniques have been tried and tested and are proven to be secure when configured correctly.
Data decryption for asymmetric ciphers is computationally difficult - the method for distributing large quantities of encrypted data is to only use an asymmetric cipher to negotiate and share a symmetric cipher key. The asymmetric cipher can then be replaced with a symmetric cipher - as both parties now have the shared key. Symmetric cryptography is computationally cheaper and faster than asymmetric.
All your setup requires is that the cluster head maintains a list of public keys for each of your cluster nodes, and when you want to distribute encrypted data to each of them, you encrypt your data for each node separately, using each node's public key. Each node then has access to its own encrypted data block which each can decrypt using its own private key.
To use symmetric crypto in the above example (for each client), you have to generate a new symmetric key, encrypt the data with it, then encrypt the symmetric key itself using the client's public key, and store the encrypted key with the message for the client to download.
This is basically the definition of PKI. Public Key Infrastructure is simply a structured method of managing keys and keypairs to allow secure communication to be performed between systems.
No.
You have to use one pair for each client!
Ideally, each client have to produce it's own pair and send to you his public key with a certificate request.
So you could work as a certificate authority and validate, then publish all public keys.
To get a single public key and multiple private keys for this public key, you can use a public-key infrastructure (PKI). A PKI is a system that manages public and private keys in a secure manner. It allows users to securely generate and exchange digital signatures, certificates, and other forms of authentication. You can use a PKI to generate a single public key and multiple private keys for each cluster member. The cluster head can then use the public key to encrypt the data, and each member can use their private key to decrypt the data.
