ECDH in golang - elliptic/Curve unmarshal fails - go

Question

Unfortunaltey there is no built-in brainpool support in go so I'm trying to get ECDH working with the help of a fork from keybase.
Maybe I'm making a newbie mistake here but by code is falling at the first hurdle (i.e. elliptic.Unmarshal returns nil) ?
package main
import (
"fmt"
"io/ioutil"
"log"
"encoding/pem"
"crypto/ecdsa"
"crypto/rand"
"github.com/keybase/go-crypto/brainpool"
"crypto/elliptic"
"crypto/sha256"
)
func main() {
fmt.Println("Hello")
content, err := ioutil.ReadFile("/tmp/TEST.pem")
if err != nil {
log.Fatal(err)
}
fmt.Printf("File contents: %s", content)
block, _ := pem.Decode(content)
if block == nil || block.Type != "PUBLIC KEY" {
log.Fatal("failed to decode PEM")
}
x,y := elliptic.Unmarshal(brainpool.P512r1(),block.Bytes)
if x == nil {
log.Fatal("failed to unmarshal")
}
pubb := ecdsa.PublicKey {brainpool.P512r1(),x,y}
priva, _ := ecdsa.GenerateKey(brainpool.P512r1(), rand.Reader)
b, _ := pubb.Curve.ScalarMult(pubb.X, pubb.Y, priva.D.Bytes())
shared1 := sha256.Sum256(b.Bytes())
fmt.Printf("\nShared key %x\n", shared1)
Update to show the test key:
-----BEGIN PUBLIC KEY-----
MIGbMBQGByqGSM49AgEGCSskAwMCCAEBDQOBggAEM/zOLT7nMN374k902oTRZXnG
97DPzvqi8QQJaKXcq1BSrU/sNeUhOi6Y+hBcr7ZE+WZDYNoQkaMNrdhF+3x1XGx7
BTBFL3U1w2ENmkIPiDa2o0Q/wpSOLo/RFabdK5Q3/yvq0hoSdXlpKozE7UTre5cU
bJcUzjXvs9KDLEq54Fs=
-----END PUBLIC KEY-----

Answer 1

You are trying to unmarshal the raw ASN.1 message, not the public key part. You should first unmarshal the ASN.1 block, then unmarshal the EC data.
I was wrong in my comment, Go doesn't support the Brainpool functions. So I borrowed some code from their X509 package to build a custom parser for the 6 curves in the Brainpool package.
Playground: https://play.golang.org/p/i-Zd4mTugjU
package main
import (
"crypto/ecdsa"
"crypto/elliptic"
"crypto/rand"
"crypto/sha256"
"crypto/x509/pkix"
"encoding/asn1"
"encoding/pem"
"errors"
"fmt"
"log"
"math/big"
"github.com/keybase/go-crypto/brainpool"
)
const ecKey = `-----BEGIN PUBLIC KEY-----
MIGbMBQGByqGSM49AgEGCSskAwMCCAEBDQOBggAEM/zOLT7nMN374k902oTRZXnG
97DPzvqi8QQJaKXcq1BSrU/sNeUhOi6Y+hBcr7ZE+WZDYNoQkaMNrdhF+3x1XGx7
BTBFL3U1w2ENmkIPiDa2o0Q/wpSOLo/RFabdK5Q3/yvq0hoSdXlpKozE7UTre5cU
bJcUzjXvs9KDLEq54Fs=
-----END PUBLIC KEY-----`
func main() {
block, _ := pem.Decode([]byte(ecKey))
if block == nil || block.Type != "PUBLIC KEY" {
log.Fatal("failed to decode PEM")
}
pub, err := parseBrainpoolPKIXPublicKey(block.Bytes)
if err != nil {
log.Fatalf("failed to parse key: %v", err)
}
pubb := ecdsa.PublicKey{Curve: brainpool.P512r1(), X: pub.X, Y: pub.Y}
priva, _ := ecdsa.GenerateKey(brainpool.P512r1(), rand.Reader)
b, _ := pubb.Curve.ScalarMult(pubb.X, pubb.Y, priva.D.Bytes())
shared1 := sha256.Sum256(b.Bytes())
fmt.Printf("\nShared key %x\n", shared1)
}
type publicKeyInfo struct {
Raw asn1.RawContent
Algorithm pkix.AlgorithmIdentifier
PublicKey asn1.BitString
}
type pkcs1PublicKey struct {
N *big.Int
E int
}
var (
oidNamedCurveBrainpoolP256r1 = asn1.ObjectIdentifier{1, 3, 36, 3, 3, 2, 8, 1, 1, 7}
oidNamedCurveBrainpoolP256t1 = asn1.ObjectIdentifier{1, 3, 36, 3, 3, 2, 8, 1, 1, 8}
oidNamedCurveBrainpoolP384r1 = asn1.ObjectIdentifier{1, 3, 36, 3, 3, 2, 8, 1, 1, 11}
oidNamedCurveBrainpoolP384t1 = asn1.ObjectIdentifier{1, 3, 36, 3, 3, 2, 8, 1, 1, 12}
oidNamedCurveBrainpoolP512r1 = asn1.ObjectIdentifier{1, 3, 36, 3, 3, 2, 8, 1, 1, 13}
oidNamedCurveBrainpoolP512t1 = asn1.ObjectIdentifier{1, 3, 36, 3, 3, 2, 8, 1, 1, 14}
)
func parseBrainpoolPKIXPublicKey(derBytes []byte) (pub *ecdsa.PublicKey, err error) {
var pki publicKeyInfo
if rest, err := asn1.Unmarshal(derBytes, &pki); err != nil {
if _, err := asn1.Unmarshal(derBytes, &pkcs1PublicKey{}); err == nil {
return nil, errors.New("failed to parse public key")
}
return nil, err
} else if len(rest) != 0 {
return nil, errors.New("trailing data after ASN.1 of public-key")
}
if !pki.Algorithm.Algorithm.Equal(asn1.ObjectIdentifier{1, 2, 840, 10045, 2, 1}) {
return nil, errors.New("not an ECDSA public key")
}
return parseBrainpoolPublicKey(&pki)
}
func parseBrainpoolPublicKey(keyData *publicKeyInfo) (*ecdsa.PublicKey, error) {
asn1Data := keyData.PublicKey.RightAlign()
paramsData := keyData.Algorithm.Parameters.FullBytes
namedCurveOID := new(asn1.ObjectIdentifier)
rest, err := asn1.Unmarshal(paramsData, namedCurveOID)
if err != nil {
return nil, errors.New("failed to parse ECDSA parameters as named curve")
}
if len(rest) != 0 {
return nil, errors.New("trailing data after ECDSA parameters")
}
namedCurve := namedCurveFromOID(*namedCurveOID)
if namedCurve == nil {
return nil, errors.New("unsupported elliptic curve")
}
x, y := elliptic.Unmarshal(namedCurve, asn1Data)
if x == nil {
return nil, errors.New("failed to unmarshal elliptic curve point")
}
pub := &ecdsa.PublicKey{
Curve: namedCurve,
X: x,
Y: y,
}
return pub, nil
}
func namedCurveFromOID(oid asn1.ObjectIdentifier) elliptic.Curve {
switch {
case oid.Equal(oidNamedCurveBrainpoolP256r1):
return brainpool.P256r1()
case oid.Equal(oidNamedCurveBrainpoolP256t1):
return brainpool.P256t1()
case oid.Equal(oidNamedCurveBrainpoolP384r1):
return brainpool.P384r1()
case oid.Equal(oidNamedCurveBrainpoolP384t1):
return brainpool.P384t1()
case oid.Equal(oidNamedCurveBrainpoolP512r1):
return brainpool.P512r1()
case oid.Equal(oidNamedCurveBrainpoolP512t1):
return brainpool.P512t1()
}
return nil
}