func (client *clientImpl) validateTCert(tCertDER []byte) (*x509.Certificate, error) {
client.node.log.Debug("Validating TCert [%s]", utils.EncodeBase64(tCertDER))
// DER to x509
x509Cert, err := utils.DERToX509Certificate(tCertDER)
if err != nil {
client.node.log.Debug("Failed parsing certificate: [%s].", err)
return nil, err
}
// Handle Critical Extension TCertEncTCertIndex
if _, err = utils.GetCriticalExtension(x509Cert, utils.TCertEncTCertIndex); err != nil {
client.node.log.Error("Failed getting extension TCERT_ENC_TCERTINDEX [%s].", err.Error())
return nil, err
}
// Verify certificate against root
if _, err := utils.CheckCertAgainRoot(x509Cert, client.node.tcaCertPool); err != nil {
client.node.log.Warning("Warning verifing certificate [%s].", err.Error())
return nil, err
}
return x509Cert, nil
}
func (client *clientImpl) getTCertFromExternalDER(der []byte) (tCert, error) {
// DER to x509
x509Cert, err := utils.DERToX509Certificate(der)
if err != nil {
client.debug("Failed parsing certificate [% x]: [%s].", der, err)
return nil, err
}
// Handle Critical Extension TCertEncTCertIndex
if _, err = utils.GetCriticalExtension(x509Cert, utils.TCertEncTCertIndex); err != nil {
client.error("Failed getting extension TCERT_ENC_TCERTINDEX [% x]: [%s].", der, err)
return nil, err
}
// Verify certificate against root
if _, err := utils.CheckCertAgainRoot(x509Cert, client.tcaCertPool); err != nil {
client.warning("Warning verifing certificate [% x]: [%s].", der, err)
return nil, err
}
return &tCertImpl{client, x509Cert, nil}, nil
}
func (validator *validatorImpl) getEnrollmentCertByHashFromECA(id []byte) ([]byte, []byte, error) {
// Prepare the request
validator.peer.node.log.Debug("Reading certificate for hash [%s]", utils.EncodeBase64(id))
req := &obcca.Hash{Hash: id}
responce, err := validator.peer.node.callECAReadCertificateByHash(context.Background(), req)
if err != nil {
validator.peer.node.log.Error("Failed requesting enrollment certificate [%s].", err.Error())
return nil, nil, err
}
validator.peer.node.log.Debug("Certificate for hash [%s] = [%s][%s]", utils.EncodeBase64(id), utils.EncodeBase64(responce.Sign), utils.EncodeBase64(responce.Enc))
// Verify responce.Sign
x509Cert, err := utils.DERToX509Certificate(responce.Sign)
if err != nil {
validator.peer.node.log.Error("Failed parsing signing enrollment certificate for encrypting: [%s]", err)
return nil, nil, err
}
// Check role
roleRaw, err := utils.GetCriticalExtension(x509Cert, ECertSubjectRole)
if err != nil {
validator.peer.node.log.Error("Failed parsing ECertSubjectRole in enrollment certificate for signing: [%s]", err)
return nil, nil, err
}
role, err := strconv.ParseInt(string(roleRaw), 10, len(roleRaw)*8)
if err != nil {
validator.peer.node.log.Error("Failed parsing ECertSubjectRole in enrollment certificate for signing: [%s]", err)
return nil, nil, err
}
if obcca.Role(role) != obcca.Role_VALIDATOR {
validator.peer.node.log.Error("Invalid ECertSubjectRole in enrollment certificate for signing. Not a validator: [%s]", err)
return nil, nil, err
}
return responce.Sign, responce.Enc, nil
}
func (node *nodeImpl) getEnrollmentCertificateFromECA(id, pw string) (interface{}, []byte, []byte, error) {
// Get a new ECA Client
sock, ecaP, err := node.getECAClient()
defer sock.Close()
// Run the protocol
signPriv, err := utils.NewECDSAKey()
if err != nil {
node.log.Error("Failed generating ECDSA key [%s].", err.Error())
return nil, nil, nil, err
}
signPub, err := x509.MarshalPKIXPublicKey(&signPriv.PublicKey)
if err != nil {
node.log.Error("Failed mashalling ECDSA key [%s].", err.Error())
return nil, nil, nil, err
}
encPriv, err := utils.NewECDSAKey()
if err != nil {
node.log.Error("Failed generating Encryption key [%s].", err.Error())
return nil, nil, nil, err
}
encPub, err := x509.MarshalPKIXPublicKey(&encPriv.PublicKey)
if err != nil {
node.log.Error("Failed marshalling Encryption key [%s].", err.Error())
return nil, nil, nil, err
}
req := &obcca.ECertCreateReq{&protobuf.Timestamp{Seconds: time.Now().Unix(), Nanos: 0},
&obcca.Identity{id},
&obcca.Token{Tok: []byte(pw)},
&obcca.PublicKey{obcca.CryptoType_ECDSA, signPub},
&obcca.PublicKey{obcca.CryptoType_ECDSA, encPub},
nil}
resp, err := ecaP.CreateCertificatePair(context.Background(), req)
if err != nil {
node.log.Error("Failed invoking CreateCertficatePair [%s].", err.Error())
return nil, nil, nil, err
}
//out, err := rsa.DecryptPKCS1v15(rand.Reader, encPriv, resp.Tok.Tok)
spi := ecies.NewSPI()
eciesKey, err := spi.NewPrivateKey(nil, encPriv)
if err != nil {
node.log.Error("Failed parsing decrypting key [%s].", err.Error())
return nil, nil, nil, err
}
ecies, err := spi.NewAsymmetricCipherFromPublicKey(eciesKey)
if err != nil {
node.log.Error("Failed creating asymmetrinc cipher [%s].", err.Error())
return nil, nil, nil, err
}
out, err := ecies.Process(resp.Tok.Tok)
if err != nil {
node.log.Error("Failed decrypting toke [%s].", err.Error())
return nil, nil, nil, err
}
req.Tok.Tok = out
req.Sig = nil
hash := utils.NewHash()
raw, _ := proto.Marshal(req)
hash.Write(raw)
r, s, err := ecdsa.Sign(rand.Reader, signPriv, hash.Sum(nil))
if err != nil {
node.log.Error("Failed signing [%s].", err.Error())
return nil, nil, nil, err
}
R, _ := r.MarshalText()
S, _ := s.MarshalText()
req.Sig = &obcca.Signature{obcca.CryptoType_ECDSA, R, S}
resp, err = ecaP.CreateCertificatePair(context.Background(), req)
if err != nil {
node.log.Error("Failed invoking CreateCertificatePair [%s].", err.Error())
return nil, nil, nil, err
}
// Verify response
// Verify cert for signing
node.log.Debug("Enrollment certificate for signing [%s]", utils.EncodeBase64(utils.Hash(resp.Certs.Sign)))
x509SignCert, err := utils.DERToX509Certificate(resp.Certs.Sign)
if err != nil {
node.log.Error("Failed parsing signing enrollment certificate for signing: [%s]", err)
return nil, nil, nil, err
}
_, err = utils.GetCriticalExtension(x509SignCert, ECertSubjectRole)
if err != nil {
node.log.Error("Failed parsing ECertSubjectRole in enrollment certificate for signing: [%s]", err)
return nil, nil, nil, err
}
err = utils.CheckCertAgainstSKAndRoot(x509SignCert, signPriv, node.ecaCertPool)
if err != nil {
node.log.Error("Failed checking signing enrollment certificate for signing: [%s]", err)
return nil, nil, nil, err
}
// Verify cert for encrypting
node.log.Debug("Enrollment certificate for encrypting [%s]", utils.EncodeBase64(utils.Hash(resp.Certs.Enc)))
x509EncCert, err := utils.DERToX509Certificate(resp.Certs.Enc)
if err != nil {
node.log.Error("Failed parsing signing enrollment certificate for encrypting: [%s]", err)
return nil, nil, nil, err
}
_, err = utils.GetCriticalExtension(x509EncCert, ECertSubjectRole)
if err != nil {
node.log.Error("Failed parsing ECertSubjectRole in enrollment certificate for encrypting: [%s]", err)
return nil, nil, nil, err
}
err = utils.CheckCertAgainstSKAndRoot(x509EncCert, encPriv, node.ecaCertPool)
if err != nil {
node.log.Error("Failed checking signing enrollment certificate for encrypting: [%s]", err)
return nil, nil, nil, err
}
// END
return signPriv, resp.Certs.Sign, resp.Chain.Tok, nil
}
func (client *clientImpl) getTCertsFromTCA(num int) ([][]byte, error) {
client.node.log.Debug("Get [%d] certificates from the TCA...", num)
// Contact the TCA
TCertOwnerKDFKey, certDERs, err := client.callTCACreateCertificateSet(num)
if err != nil {
client.node.log.Debug("Failed contacting TCA [%s].", err.Error())
return nil, err
}
// client.node.log.Debug("TCertOwnerKDFKey [%s].", utils.EncodeBase64(TCertOwnerKDFKey))
// Store TCertOwnerKDFKey and checks that every time it is always the same key
if client.tCertOwnerKDFKey != nil {
// Check that the keys are the same
equal := bytes.Equal(client.tCertOwnerKDFKey, TCertOwnerKDFKey)
if !equal {
return nil, errors.New("Failed reciving kdf key from TCA. The keys are different.")
}
} else {
client.tCertOwnerKDFKey = TCertOwnerKDFKey
// TODO: handle this situation more carefully
if err := client.storeTCertOwnerKDFKey(); err != nil {
client.node.log.Error("Failed storing TCertOwnerKDFKey [%s].", err.Error())
return nil, err
}
}
// Validate the Certificates obtained
TCertOwnerEncryptKey := utils.HMACTruncated(TCertOwnerKDFKey, []byte{1}, utils.AESKeyLength)
ExpansionKey := utils.HMAC(TCertOwnerKDFKey, []byte{2})
resCert := make([][]byte, num)
j := 0
for i := 0; i < num; i++ {
client.node.log.Debug("Validating certificate [%d], [%s]", i, utils.EncodeBase64(certDERs[i]))
// DER to x509
x509Cert, err := utils.DERToX509Certificate(certDERs[i])
if err != nil {
client.node.log.Debug("Failed parsing certificate: [%s].", err)
continue
}
// Handle Critical Extenstion TCertEncTCertIndex
tCertIndexCT, err := utils.GetCriticalExtension(x509Cert, utils.TCertEncTCertIndex)
if err != nil {
client.node.log.Error("Failed getting extension TCERT_ENC_TCERTINDEX [%s].", err.Error())
continue
}
// Verify certificate against root
if _, err := utils.CheckCertAgainRoot(x509Cert, client.node.tcaCertPool); err != nil {
client.node.log.Warning("Warning verifing certificate [%s].", err.Error())
continue
}
// Verify public key
// 384-bit ExpansionValue = HMAC(Expansion_Key, TCertIndex)
// Let TCertIndex = Timestamp, RandValue, 1,2,…
// Timestamp assigned, RandValue assigned and counter reinitialized to 1 per batch
// Decrypt ct to TCertIndex (TODO: || EnrollPub_Key || EnrollID ?)
pt, err := utils.CBCPKCS7Decrypt(TCertOwnerEncryptKey, tCertIndexCT)
if err != nil {
client.node.log.Error("Failed decrypting extension TCERT_ENC_TCERTINDEX [%s].", err.Error())
continue
}
// Compute ExpansionValue based on TCertIndex
TCertIndex := pt
// TCertIndex := []byte(strconv.Itoa(i))
client.node.log.Debug("TCertIndex: [%s].", utils.EncodeBase64(TCertIndex))
mac := hmac.New(utils.NewHash, ExpansionKey)
mac.Write(TCertIndex)
ExpansionValue := mac.Sum(nil)
// Derive tpk and tsk accordingly to ExapansionValue from enrollment pk,sk
// Computable by TCA / Auditor: TCertPub_Key = EnrollPub_Key + ExpansionValue G
// using elliptic curve point addition per NIST FIPS PUB 186-4- specified P-384
// Compute temporary secret key
tempSK := &ecdsa.PrivateKey{
PublicKey: ecdsa.PublicKey{
Curve: client.node.enrollPrivKey.Curve,
X: new(big.Int),
Y: new(big.Int),
},
D: new(big.Int),
}
var k = new(big.Int).SetBytes(ExpansionValue)
var one = new(big.Int).SetInt64(1)
n := new(big.Int).Sub(client.node.enrollPrivKey.Params().N, one)
k.Mod(k, n)
k.Add(k, one)
tempSK.D.Add(client.node.enrollPrivKey.D, k)
tempSK.D.Mod(tempSK.D, client.node.enrollPrivKey.PublicKey.Params().N)
// Compute temporary public key
tempX, tempY := client.node.enrollPrivKey.PublicKey.ScalarBaseMult(k.Bytes())
tempSK.PublicKey.X, tempSK.PublicKey.Y =
tempSK.PublicKey.Add(
client.node.enrollPrivKey.PublicKey.X, client.node.enrollPrivKey.PublicKey.Y,
tempX, tempY,
)
// Verify temporary public key is a valid point on the reference curve
isOn := tempSK.Curve.IsOnCurve(tempSK.PublicKey.X, tempSK.PublicKey.Y)
if !isOn {
client.node.log.Error("Failed temporary public key IsOnCurve check.")
continue
}
// Check that the derived public key is the same as the one in the certificate
certPK := x509Cert.PublicKey.(*ecdsa.PublicKey)
cmp := certPK.X.Cmp(tempSK.PublicKey.X)
if cmp != 0 {
client.node.log.Error("Derived public key is different on X")
continue
}
cmp = certPK.Y.Cmp(tempSK.PublicKey.Y)
if cmp != 0 {
client.node.log.Error("Derived public key is different on Y")
continue
}
// Verify the signing capability of tempSK
err = utils.VerifySignCapability(tempSK, x509Cert.PublicKey)
if err != nil {
client.node.log.Error("Failed verifing signing capability [%s].", err.Error())
continue
}
// Marshall certificate and secret key to be stored in the database
resCert[j] = certDERs[i]
if err != nil {
client.node.log.Error("Failed marshalling private key [%s].", err.Error())
continue
}
if err := utils.CheckCertPKAgainstSK(x509Cert, interface{}(tempSK)); err != nil {
client.node.log.Error("Failed checking TCA cert PK against private key [%s].", err.Error())
continue
}
client.node.log.Debug("Sub index [%d]", j)
j++
client.node.log.Debug("Certificate [%d] validated.", i)
}
if j == 0 {
client.node.log.Error("No valid TCert was sent")
return nil, errors.New("No valid TCert was sent.")
}
return resCert[:j], nil
}
func (client *clientImpl) signUsingTCertX509(tCert *x509.Certificate, msg []byte) ([]byte, error) {
// Extract the signing key from the tCert
TCertOwnerEncryptKey := utils.HMACTruncated(client.tCertOwnerKDFKey, []byte{1}, utils.AESKeyLength)
ExpansionKey := utils.HMAC(client.tCertOwnerKDFKey, []byte{2})
// TODO: retrieve TCertIndex from the ciphertext encrypted under the TCertOwnerEncryptKey
ct, err := utils.GetCriticalExtension(tCert, utils.TCertEncTCertIndex)
if err != nil {
client.node.log.Error("Failed getting extension TCERT_ENC_TCERTINDEX [%s].", err.Error())
return nil, err
}
// Decrypt ct to TCertIndex (TODO: || EnrollPub_Key || EnrollID ?)
decryptedTCertIndex, err := utils.CBCPKCS7Decrypt(TCertOwnerEncryptKey, ct)
if err != nil {
client.node.log.Error("Failed decrypting extension TCERT_ENC_TCERTINDEX [%s].", err.Error())
return nil, err
}
// Compute ExpansionValue based on TCertIndex
TCertIndex := decryptedTCertIndex
client.node.log.Debug("TCertIndex [%s].", utils.EncodeBase64(TCertIndex))
mac := hmac.New(utils.NewHash, ExpansionKey)
mac.Write(TCertIndex)
ExpansionValue := mac.Sum(nil)
// Derive tpk and tsk accordingly to ExapansionValue from enrollment pk,sk
// Computable by TCA / Auditor: TCertPub_Key = EnrollPub_Key + ExpansionValue G
// using elliptic curve point addition per NIST FIPS PUB 186-4- specified P-384
// Compute temporary secret key
tempSK := &ecdsa.PrivateKey{
PublicKey: ecdsa.PublicKey{
Curve: client.node.enrollPrivKey.Curve,
X: new(big.Int),
Y: new(big.Int),
},
D: new(big.Int),
}
var k = new(big.Int).SetBytes(ExpansionValue)
var one = new(big.Int).SetInt64(1)
n := new(big.Int).Sub(client.node.enrollPrivKey.Params().N, one)
k.Mod(k, n)
k.Add(k, one)
tempSK.D.Add(client.node.enrollPrivKey.D, k)
tempSK.D.Mod(tempSK.D, client.node.enrollPrivKey.PublicKey.Params().N)
// Compute temporary public key
tempX, tempY := client.node.enrollPrivKey.PublicKey.ScalarBaseMult(k.Bytes())
tempSK.PublicKey.X, tempSK.PublicKey.Y =
tempSK.PublicKey.Add(
client.node.enrollPrivKey.PublicKey.X, client.node.enrollPrivKey.PublicKey.Y,
tempX, tempY,
)
return client.node.sign(tempSK, msg)
}
func (client *clientImpl) getTCertFromDER(der []byte) (tCert tCert, err error) {
if client.tCertOwnerKDFKey == nil {
return nil, fmt.Errorf("KDF key not initialized yet")
}
TCertOwnerEncryptKey := utils.HMACTruncated(client.tCertOwnerKDFKey, []byte{1}, utils.AESKeyLength)
ExpansionKey := utils.HMAC(client.tCertOwnerKDFKey, []byte{2})
// DER to x509
x509Cert, err := utils.DERToX509Certificate(der)
if err != nil {
client.debug("Failed parsing certificate [% x]: [%s].", der, err)
return
}
// Handle Critical Extenstion TCertEncTCertIndex
tCertIndexCT, err := utils.GetCriticalExtension(x509Cert, utils.TCertEncTCertIndex)
if err != nil {
client.error("Failed getting extension TCERT_ENC_TCERTINDEX [%s].", err.Error())
return
}
// Verify certificate against root
if _, err = utils.CheckCertAgainRoot(x509Cert, client.tcaCertPool); err != nil {
client.warning("Warning verifing certificate [%s].", err.Error())
return
}
// Verify public key
// 384-bit ExpansionValue = HMAC(Expansion_Key, TCertIndex)
// Let TCertIndex = Timestamp, RandValue, 1,2,…
// Timestamp assigned, RandValue assigned and counter reinitialized to 1 per batch
// Decrypt ct to TCertIndex (TODO: || EnrollPub_Key || EnrollID ?)
pt, err := utils.CBCPKCS7Decrypt(TCertOwnerEncryptKey, tCertIndexCT)
if err != nil {
client.error("Failed decrypting extension TCERT_ENC_TCERTINDEX [%s].", err.Error())
return
}
// Compute ExpansionValue based on TCertIndex
TCertIndex := pt
// TCertIndex := []byte(strconv.Itoa(i))
client.debug("TCertIndex: [% x].", TCertIndex)
mac := hmac.New(utils.NewHash, ExpansionKey)
mac.Write(TCertIndex)
ExpansionValue := mac.Sum(nil)
// Derive tpk and tsk accordingly to ExapansionValue from enrollment pk,sk
// Computable by TCA / Auditor: TCertPub_Key = EnrollPub_Key + ExpansionValue G
// using elliptic curve point addition per NIST FIPS PUB 186-4- specified P-384
// Compute temporary secret key
tempSK := &ecdsa.PrivateKey{
PublicKey: ecdsa.PublicKey{
Curve: client.enrollPrivKey.Curve,
X: new(big.Int),
Y: new(big.Int),
},
D: new(big.Int),
}
var k = new(big.Int).SetBytes(ExpansionValue)
var one = new(big.Int).SetInt64(1)
n := new(big.Int).Sub(client.enrollPrivKey.Params().N, one)
k.Mod(k, n)
k.Add(k, one)
tempSK.D.Add(client.enrollPrivKey.D, k)
tempSK.D.Mod(tempSK.D, client.enrollPrivKey.PublicKey.Params().N)
// Compute temporary public key
tempX, tempY := client.enrollPrivKey.PublicKey.ScalarBaseMult(k.Bytes())
tempSK.PublicKey.X, tempSK.PublicKey.Y =
tempSK.PublicKey.Add(
client.enrollPrivKey.PublicKey.X, client.enrollPrivKey.PublicKey.Y,
tempX, tempY,
)
// Verify temporary public key is a valid point on the reference curve
isOn := tempSK.Curve.IsOnCurve(tempSK.PublicKey.X, tempSK.PublicKey.Y)
if !isOn {
client.error("Failed temporary public key IsOnCurve check.")
return nil, fmt.Errorf("Failed temporary public key IsOnCurve check.")
}
// Check that the derived public key is the same as the one in the certificate
certPK := x509Cert.PublicKey.(*ecdsa.PublicKey)
if certPK.X.Cmp(tempSK.PublicKey.X) != 0 {
client.error("Derived public key is different on X")
return nil, fmt.Errorf("Derived public key is different on X")
}
if certPK.Y.Cmp(tempSK.PublicKey.Y) != 0 {
client.error("Derived public key is different on Y")
return nil, fmt.Errorf("Derived public key is different on Y")
}
// Verify the signing capability of tempSK
err = utils.VerifySignCapability(tempSK, x509Cert.PublicKey)
if err != nil {
client.error("Failed verifing signing capability [%s].", err.Error())
return
}
// Marshall certificate and secret key to be stored in the database
if err != nil {
client.error("Failed marshalling private key [%s].", err.Error())
return
}
if err = utils.CheckCertPKAgainstSK(x509Cert, interface{}(tempSK)); err != nil {
client.error("Failed checking TCA cert PK against private key [%s].", err.Error())
return
}
tCert = &tCertImpl{client, x509Cert, tempSK}
return
}
