// SKI returns the subject key identifier of this key.
func (k *ecdsaPrivateKey) SKI() (ski []byte) {
raw, _ := utils.PrivateKeyToDER(k.privKey)
// TODO: Error should not be thrown. Anyway, move the marshalling at initialization.
hash := sha256.New()
hash.Write(raw)
return hash.Sum(nil)
}
func TestECDSAKeyImportFromECDSAPrivateKey(t *testing.T) {
// Generate an ECDSA key, default is P256
key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
if err != nil {
t.Fatalf("Failed generating ECDSA key [%s]", err)
}
// Import the ecdsa.PrivateKey
priv, err := utils.PrivateKeyToDER(key)
if err != nil {
t.Fatalf("Failed converting raw to ecdsa.PrivateKey [%s]", err)
}
sk, err := currentBCCSP.KeyImport(priv, &bccsp.ECDSAPrivateKeyImportOpts{Temporary: false})
if err != nil {
t.Fatalf("Failed importing ECDSA private key [%s]", err)
}
if sk == nil {
t.Fatal("Failed importing ECDSA private key. Return BCCSP key cannot be nil.")
}
// Import the ecdsa.PublicKey
pub, err := utils.PublicKeyToDER(&key.PublicKey)
if err != nil {
t.Fatalf("Failed converting raw to ecdsa.PublicKey [%s]", err)
}
pk, err := currentBCCSP.KeyImport(pub, &bccsp.ECDSAPKIXPublicKeyImportOpts{Temporary: false})
if err != nil {
t.Fatalf("Failed importing ECDSA public key [%s]", err)
}
if pk == nil {
t.Fatal("Failed importing ECDSA public key. Return BCCSP key cannot be nil.")
}
// Sign and verify with the imported public key
msg := []byte("Hello World")
digest, err := currentBCCSP.Hash(msg, &bccsp.SHAOpts{})
if err != nil {
t.Fatalf("Failed computing HASH [%s]", err)
}
signature, err := currentBCCSP.Sign(sk, digest, nil)
if err != nil {
t.Fatalf("Failed generating ECDSA signature [%s]", err)
}
valid, err := currentBCCSP.Verify(pk, signature, digest, nil)
if err != nil {
t.Fatalf("Failed verifying ECDSA signature [%s]", err)
}
if !valid {
t.Fatal("Failed verifying ECDSA signature. Signature not valid.")
}
}