Simple cryptography problem to be implemented in PHP - php

Question

I need to implement a couple of functions which comply with the following:
function genKey: given a string q (this may be a MD5 or SHA hash) and a seed string, the function must generate a new string p
function checkKey: this function must return true if a string p was generated from string q (using the previous function)
In seudo-code the above would be something lie this:
p=genKey(q,seed) ; // generate string p from q and seed
checkKey(p,q)==true ; // if p was generated from q, then this must return true. False otherwise.
Does anyone know about existing algorithms that do such thing??
I can implement the algorithms myself if there are no known implementations for PHP, so what I'm really asking is for the procedure to accomplish this.

Answer 1

It sounds like you might be trying to describe a MAC.
A message authentication code takes a message digest, a secret, and message. The secret and data are hashed together, and the result is included with the message.
A message recipient who knows the secret can perform the same digest computation, and compare his MAC to the one that accompanied the received message. If they are equal, he can trust that the message was not altered.
Given your comments, I understand now that you are working with asymmetric keys, rather than a secret key, which would be used in a MAC.
However, there's still a little confusion. Normally, a private signature key is kept secret by its owner, which in this case seems to be the client. A client can cryptographically prove that they possess a private key that corresponds to a public key without disclosing the private key.
Using digital signatures, you can do something like this:
p = genKey(pvt, seed)
checkKey(pub, p)
Here, pvt is the server's private key, pub is its public key. The seed parameter is the data that gets signed. If I understand your application (which I doubt), seed should be the client identifier. Then p is a message format that bundles seed and its signature together. Your question is confusing because q is used both generating and verifying p—like a shared secret.
However, there's nothing in this scheme (or in the MAC scheme) to stop one client from using another's value of p. All you can do with such a technique is to ensure that the message content has not been altered. For example, if the message is something like "clientID=Alice,IPAddress=192.168.1.1", you can make sure that Mallory didn't substitute his own IP address for Alice's.
But if the message is just "clientID=Alice", you can't stop Alice from giving Bob her tamper-proof message (in return for splitting the cost of a license), and you can't control whether Mallory hacks into Alice's box and steals the message.
By the way, if message integrity really is all you need, and you can easily share a secret between the sender and a receiver, MACs have some nice advantages over public-key cryptography, such as much smaller message size and faster performance.
Outline the threats you are trying to defend against. Cryptography is hard. Devising untried schemes usually ends badly.

Answer 2

For this discussion let p == hash(q)
You could then easily use OpenSSL with php to sign 'p' with a private key and keep that signature along side 'p'.
It is then simple to use the OpenSSL verify function to check 'p' against the signature using the public key that is paired with your private key. In this case 'p' would be the data to verify.
See openssl_sign and openssl_verify for info and examples of using OpenSSL in php to sign and verify data:

Answer 3

You could try something like this:
$p = genKey($q,rand());
checkKey($p,$q) == true;
function genkey($q,$seed)
{
if(array_search($_SESSION['seeds'],$seed) === FALSE)
{
$_SESSION['seeds'][] = $seed;
}
return hash("sha512", $q . $seed);
}
function checkKey($p,$q)
{
$returnVal = false;
foreach($_SESSION['seeds'] AS $s)
{
if(hash("sha512", $q . $s) == $p)
{
$returnVal = true;
break;
}
}
return $returnVal;
}
Of course, I would recommend something else for storage of valid seeds, but this is just a proof of concept.

Answer 4

You can use either crypt(), hash(), or md5().
Edit:
I don't mind the downvote. Looking at the complexity of the other answers, I must have misinterpreted the question. But it would be nice if people would accompany their downvotes with a comment so that I at least know what is wrong with my answer.
What I gleaned from the question is that the questioner wants to implement something like:
function genKey($q, $seed) {
// assuming $seed is a properly formatted md5/sha salt
return crypt($q, $seed);
}
function checkKey($p, $q, $seed) {
return ($p == genKey($q, $seed));
}
Am I wrong in thinking that any one of PHP's one-way encryption functions can be used to accomplish this?

Answer 5

Okay, what you are referring to is a principle of public key cryptography, specifically creating signatures. It runs along complex mathematic principles (which you would have to implement).
In basic RSA signatures, you create a signature s by applying the following math:
s = m^d % n
Where m is the message (or string q for you), d is the private key, n is the modulus (shared between the private and public key).
Then it can be verified by this math:
m = s^e % n
Where e is the public key.
Of course the keys must be generated to a specific mathematical standard for this to work. And sometimes the keys get to enormous sizes. Again, all of this is done via integers, so you would have to convert the text into decimal and back.
For more information, and more math, check out this page.
EDIT: I thought I should mention why you would want to use public key cryptography. Basically, it protects against two things: the message is verifiable and cannot be faked.

Answer 6

Will the checking side have access to seed? If seed can be kept secure on the checking side (like on a web app) you could easily do something like HTTP Digest authentication does using MD5.
Pseudocode:
function genKey(q) {
p = md5sum(q . ':' . seed);
return p;
}
function checkKey(p,q) {
return md5sum(q . ':' . seed) == p;
}
If you need a second party to verify the "signature" then you'll probably just want to use PKI.