Generate a key pair for public key digital signatures
|
public static generateSignatureKeyPair ( string &$secretKey = '' ) : |
||
| $secretKey | string | |
| return | ||
public function testSign()
{
$keypair = KeyFactory::generateSignatureKeyPair();
$secretkey = $keypair->getSecretKey();
$publickey = $keypair->getPublicKey();
$signature = File::sign(__DIR__ . '/tmp/paragon_avatar.png', $secretkey);
$this->assertTrue(!empty($signature));
$this->assertTrue(File::verify(__DIR__ . '/tmp/paragon_avatar.png', $publickey, $signature));
}
/**
* @covers \ParagonIE\Halite\Asymmetric\EncryptionSecretKey::derivePublicKey()
* @covers \ParagonIE\Halite\Asymmetric\SignatureSecretKey::derivePublicKey()
*/
public function testPublicDerivation()
{
$enc_kp = KeyFactory::generateEncryptionKeyPair();
$enc_secret = $enc_kp->getSecretKey();
$enc_public = $enc_kp->getPublicKey();
$this->assertEquals($enc_secret->derivePublicKey()->getRawKeyMaterial(), $enc_public->getRawKeyMaterial());
$sign_kp = KeyFactory::generateSignatureKeyPair();
$sign_secret = $sign_kp->getSecretKey();
$sign_public = $sign_kp->getPublicKey();
$this->assertEquals($sign_secret->derivePublicKey()->getRawKeyMaterial(), $sign_public->getRawKeyMaterial());
}
KeyFactory::save($keys[$index], $path);
break;
case 'EncryptionSecretKey':
$kp = KeyFactory::generateEncryptionKeyPair();
$keys[$index] = $kp->getSecretKey();
KeyFactory::save($keys[$index], $path);
break;
case 'SignatureSecretKey':
$kp = KeyFactory::generateSignatureKeyPair();
$keys[$index] = $kp->getSecretKey();
KeyFactory::save($keys[$index], $path);
break;
case 'EncryptionKeyPair':
$keys[$index] = KeyFactory::generateEncryptionKeyPair();
KeyFactory::save($keys[$index], $path);
break;
case 'SignatureKeyPair':
$keys[$index] = KeyFactory::generateSignatureKeyPair();
KeyFactory::save($keys[$index], $path);
break;
default:
throw new \Error(\trk('errors.crypto.unknown_key_type', $keyConfig['type']));
}
}
}
// Now that we have a bunch of Keys stored in $keys, let's load them into
// our singleton.
$state->keyring = $keys;
};
$key_management_closure();
unset($key_management_closure);
public function testKeyTypes()
{
$key = KeyFactory::generateAuthenticationKey();
$this->assertFalse($key->isAsymmetricKey());
$this->assertFalse($key->isEncryptionKey());
$this->assertTrue($key->isSecretKey());
$this->assertTrue($key->isSigningKey());
$this->assertFalse($key->isPublicKey());
$key = KeyFactory::generateEncryptionKey();
$this->assertFalse($key->isAsymmetricKey());
$this->assertTrue($key->isEncryptionKey());
$this->assertTrue($key->isSecretKey());
$this->assertFalse($key->isSigningKey());
$this->assertFalse($key->isPublicKey());
$keypair = KeyFactory::generateEncryptionKeyPair();
$enc_secret = $keypair->getSecretKey();
$enc_public = $keypair->getPublicKey();
$this->assertTrue($enc_secret->isAsymmetricKey());
$this->assertTrue($enc_secret->isEncryptionKey());
$this->assertTrue($enc_secret->isSecretKey());
$this->assertFalse($enc_secret->isSigningKey());
$this->assertFalse($enc_secret->isPublicKey());
$this->assertTrue($enc_public->isAsymmetricKey());
$this->assertTrue($enc_public->isEncryptionKey());
$this->assertFalse($enc_public->isSecretKey());
$this->assertFalse($enc_public->isSigningKey());
$this->assertTrue($enc_public->isPublicKey());
$keypair = KeyFactory::generateSignatureKeyPair();
$sign_secret = $keypair->getSecretKey();
$sign_public = $keypair->getPublicKey();
$this->assertTrue($sign_secret->isAsymmetricKey());
$this->assertFalse($sign_secret->isEncryptionKey());
$this->assertTrue($sign_secret->isSecretKey());
$this->assertTrue($sign_public->isSigningKey());
$this->assertFalse($sign_secret->isPublicKey());
$this->assertTrue($sign_public->isAsymmetricKey());
$this->assertFalse($sign_public->isEncryptionKey());
$this->assertFalse($sign_public->isSecretKey());
$this->assertTrue($sign_public->isSigningKey());
$this->assertTrue($sign_public->isPublicKey());
}
/**
* @covers Asymmetric::sign()
* @covers Asymmetric::verify()
*/
public function testSignFail()
{
$alice = KeyFactory::generateSignatureKeyPair();
$message = 'test message';
$signature = Asymmetric::sign($message, $alice->getSecretKey(), true);
$this->assertFalse(Asymmetric::verify('wrongmessage', $alice->getPublicKey(), $signature, true));
$_signature = $signature;
// Let's flip one bit, randomly:
$r = \Sodium\randombytes_uniform(\mb_strlen($signature, '8bit'));
$_signature[$r] = \chr(\ord($_signature[$r]) ^ 1 << \Sodium\randombytes_uniform(8));
$this->assertFalse(Asymmetric::verify($message, $alice->getPublicKey(), $_signature, true));
}
