280 lines
9.1 KiB
Go
280 lines
9.1 KiB
Go
package common
|
|
|
|
/*
|
|
I2P KeysAndCert
|
|
https://geti2p.net/spec/common-structures#keysandcert
|
|
Accurate for version 0.9.24
|
|
|
|
+----+----+----+----+----+----+----+----+
|
|
| public_key |
|
|
+ +
|
|
| |
|
|
~ ~
|
|
~ ~
|
|
| |
|
|
+----+----+----+----+----+----+----+----+
|
|
| padding (optional) |
|
|
~ ~
|
|
~ ~
|
|
| |
|
|
+----+----+----+----+----+----+----+----+
|
|
| signing_key |
|
|
+ +
|
|
| |
|
|
~ ~
|
|
~ ~
|
|
| |
|
|
+----+----+----+----+----+----+----+----+
|
|
| certificate |
|
|
+----+----+----+-//
|
|
|
|
public_key :: PublicKey (partial or full)
|
|
length -> 256 bytes or as specified in key certificate
|
|
|
|
padding :: random data
|
|
length -> 0 bytes or as specified in key certificate
|
|
padding length + signing_key length == KEYS_AND_CERT_SPK_SIZE bytes
|
|
|
|
signing__key :: SigningPublicKey (partial or full)
|
|
length -> 128 bytes or as specified in key certificate
|
|
padding length + signing_key length == KEYS_AND_CERT_SPK_SIZE bytes
|
|
|
|
certificate :: Certificate
|
|
length -> >= 3 bytes
|
|
|
|
total length: 387+ bytes
|
|
*/
|
|
|
|
import (
|
|
"errors"
|
|
"github.com/go-i2p/go-i2p/lib/crypto"
|
|
log "github.com/sirupsen/logrus"
|
|
)
|
|
|
|
// Sizes of various KeysAndCert structures and requirements
|
|
const (
|
|
KEYS_AND_CERT_PUBKEY_SIZE = 256
|
|
KEYS_AND_CERT_SPK_SIZE = 128
|
|
KEYS_AND_CERT_MIN_SIZE = 387
|
|
KEYS_AND_CERT_DATA_SIZE = 384
|
|
)
|
|
|
|
type KeysAndCertInterface interface {
|
|
GetPublicKey() (key crypto.PublicKey, err error)
|
|
GetSigningPublicKey() (signing_public_key crypto.SigningPublicKey, err error)
|
|
GetCertificate() (cert Certificate, err error)
|
|
Bytes() (bytes []byte)
|
|
}
|
|
|
|
type KeysAndCert struct {
|
|
crypto.SigningPublicKey
|
|
crypto.PublicKey
|
|
CertificateInterface
|
|
}
|
|
|
|
func (keys_and_cert KeysAndCert) Bytes() (bytes []byte) { //, err error) {
|
|
pubkey, _ := keys_and_cert.GetPublicKey()
|
|
signpubkey, _ := keys_and_cert.GetSigningPublicKey()
|
|
elg_key := pubkey.(crypto.ElgPublicKey)
|
|
dsa_key := signpubkey.(crypto.DSAPublicKey)
|
|
bytes = append(bytes, dsa_key[:]...)
|
|
bytes = append(bytes, elg_key[:]...)
|
|
bytes = append(bytes, keys_and_cert.CertificateInterface.Cert()...)
|
|
return
|
|
}
|
|
|
|
//
|
|
// Return the PublicKey for this KeysAndCert, reading from the Key Certificate if it is present to
|
|
// determine correct lengths.
|
|
//
|
|
func (keys_and_cert KeysAndCert) GetPublicKey() (key crypto.PublicKey, err error) {
|
|
data := make([]byte, KEYS_AND_CERT_PUBKEY_SIZE)
|
|
if keys_and_cert.PublicKey == nil {
|
|
epk := crypto.ElgPublicKey{}
|
|
copy(data[:KEYS_AND_CERT_PUBKEY_SIZE], epk[:])
|
|
keys_and_cert.PublicKey = epk
|
|
err = errors.New("error parsing KeysAndCert: data is smaller than minimum valid size")
|
|
}
|
|
/*cert, err := keys_and_cert.GetCertificate()
|
|
if err != nil {
|
|
return
|
|
}
|
|
cert_len, err := cert.Length()
|
|
if err != nil {
|
|
return
|
|
}
|
|
if cert_len != 0 {*/
|
|
key = keys_and_cert.PublicKey
|
|
/*}*/
|
|
return
|
|
}
|
|
|
|
//
|
|
// Return the SigningPublicKey for this KeysAndCert, reading from the Key Certificate if it is present to
|
|
// determine correct lengths.
|
|
//
|
|
func (keys_and_cert KeysAndCert) GetSigningPublicKey() (signing_public_key crypto.SigningPublicKey, err error) {
|
|
if keys_and_cert.SigningPublicKey == nil {
|
|
keys_and_cert.SigningPublicKey = crypto.DSAPublicKey{}
|
|
err = errors.New("error parsing KeysAndCert: data is smaller than minimum valid size")
|
|
}
|
|
/*cert, err := keys_and_cert.GetCertificate()
|
|
if err != nil {
|
|
return
|
|
}
|
|
cert_len, err := cert.Length()
|
|
if err != nil {
|
|
return
|
|
}
|
|
if cert_len != 0 {*/
|
|
signing_public_key = keys_and_cert.SigningPublicKey
|
|
/*}*/
|
|
return
|
|
}
|
|
|
|
//
|
|
// Return the Certificate contained in the KeysAndCert and any errors encountered while parsing the
|
|
// KeysAndCert or Certificate.
|
|
//
|
|
func (keys_and_cert KeysAndCert) GetCertificate() (cert CertificateInterface, err error) {
|
|
data_len := len(keys_and_cert.Cert())
|
|
if data_len < CERT_MIN_SIZE {
|
|
log.WithFields(log.Fields{
|
|
"at": "ReadKeysAndCert",
|
|
"data_len": data_len,
|
|
"required_len": KEYS_AND_CERT_MIN_SIZE,
|
|
"reason": "not enough data",
|
|
}).Error("error parsing keys and cert")
|
|
err = errors.New("certificate parsing warning: certificate data is shorter than specified by length")
|
|
}
|
|
if data_len > CERT_MIN_SIZE {
|
|
log.WithFields(log.Fields{
|
|
"at": "ReadKeysAndCert",
|
|
"data_len": data_len,
|
|
"required_len": KEYS_AND_CERT_MIN_SIZE,
|
|
"reason": "too much data",
|
|
}).Error("error parsing keys and cert")
|
|
err = errors.New("certificate parsing warning: certificate data is longer than specified by length")
|
|
}
|
|
cert = keys_and_cert.CertificateInterface
|
|
return
|
|
}
|
|
|
|
func ReadKeys(data []byte, cert CertificateInterface) (spk crypto.SigningPublicKey, pk crypto.PublicKey, remainder []byte, err error) {
|
|
data_len := len(data)
|
|
if data_len < KEYS_AND_CERT_MIN_SIZE {
|
|
log.WithFields(log.Fields{
|
|
"at": "ReadKeysAndCert",
|
|
"data_len": data_len,
|
|
"required_len": KEYS_AND_CERT_MIN_SIZE,
|
|
"reason": "not enough data",
|
|
}).Error("error parsing keys and cert")
|
|
err = errors.New("error parsing KeysAndCert: data is smaller than minimum valid size")
|
|
return
|
|
}
|
|
if cert == nil {
|
|
// No Certificate is present, return the KEYS_AND_CERT_PUBKEY_SIZE byte
|
|
// PublicKey space as ElgPublicKey.
|
|
var elg_key crypto.ElgPublicKey
|
|
copy(data[:KEYS_AND_CERT_PUBKEY_SIZE], elg_key[:])
|
|
pk = elg_key
|
|
} else {
|
|
// A Certificate is present in this KeysAndCert
|
|
cert_type, cert_bytes, _ := cert.Type()
|
|
if cert_type == CERT_KEY {
|
|
// This KeysAndCert contains a Key Certificate, construct
|
|
// a PublicKey from the data in the KeysAndCert and
|
|
// any additional data in the Certificate.
|
|
cert_integer, _ := NewInteger(cert_bytes)
|
|
pk, err = KeyCertificate{PKType: cert_integer}.ConstructPublicKey(
|
|
data[:KEYS_AND_CERT_PUBKEY_SIZE],
|
|
)
|
|
} else {
|
|
// Key Certificate is not present, return the KEYS_AND_CERT_PUBKEY_SIZE byte
|
|
// PublicKey space as ElgPublicKey. No other Certificate
|
|
// types are currently in use.
|
|
var elg_key crypto.ElgPublicKey
|
|
copy(data[:KEYS_AND_CERT_PUBKEY_SIZE], elg_key[:])
|
|
pk = elg_key
|
|
log.WithFields(log.Fields{
|
|
"at": "(KeysAndCert) PublicKey",
|
|
"cert_type": cert_type,
|
|
}).Warn("unused certificate type observed")
|
|
}
|
|
// }
|
|
if data_len == 0 {
|
|
// No Certificate is present, return the KEYS_AND_CERT_SPK_SIZE byte
|
|
// SigningPublicKey space as legacy DSA SHA1 SigningPublicKey.
|
|
var dsa_pk crypto.DSAPublicKey
|
|
copy(dsa_pk[:], data[KEYS_AND_CERT_PUBKEY_SIZE:KEYS_AND_CERT_PUBKEY_SIZE+KEYS_AND_CERT_SPK_SIZE])
|
|
spk = dsa_pk
|
|
} else {
|
|
// A Certificate is present in this KeysAndCert
|
|
cert_type, cert_bytes, _ := cert.Type()
|
|
if cert_type == CERT_KEY {
|
|
// This KeysAndCert contains a Key Certificate, construct
|
|
// a SigningPublicKey from the data in the KeysAndCert and
|
|
// any additional data in the Certificate.
|
|
cert_integer, _ := NewInteger(cert_bytes)
|
|
spk, err = KeyCertificate{SPKType: cert_integer}.ConstructSigningPublicKey(
|
|
data[KEYS_AND_CERT_PUBKEY_SIZE : KEYS_AND_CERT_PUBKEY_SIZE+KEYS_AND_CERT_SPK_SIZE],
|
|
)
|
|
} else {
|
|
// Key Certificate is not present, return the KEYS_AND_CERT_SPK_SIZE byte
|
|
// SigningPublicKey space as legacy SHA DSA1 SigningPublicKey.
|
|
// No other Certificate types are currently in use.
|
|
var dsa_pk crypto.DSAPublicKey
|
|
copy(dsa_pk[:], data[KEYS_AND_CERT_PUBKEY_SIZE:KEYS_AND_CERT_PUBKEY_SIZE+KEYS_AND_CERT_SPK_SIZE])
|
|
spk = dsa_pk
|
|
}
|
|
}
|
|
cert_len, _ := cert.Length()
|
|
if cert_len == 0 {
|
|
remainder = data[KEYS_AND_CERT_MIN_SIZE:]
|
|
return
|
|
}
|
|
remainder = data[KEYS_AND_CERT_PUBKEY_SIZE+KEYS_AND_CERT_SPK_SIZE:]
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
//
|
|
// Read a KeysAndCert from a slice of bytes, retuning it and the remaining data as well as any errors
|
|
// encoutered parsing the KeysAndCert.
|
|
//
|
|
func ReadKeysAndCert(data []byte) (keys_and_cert KeysAndCert, remainder []byte, err error) {
|
|
data_len := len(data)
|
|
keys_and_cert.CertificateInterface = &Certificate{}
|
|
if data_len < KEYS_AND_CERT_MIN_SIZE {
|
|
log.WithFields(log.Fields{
|
|
"at": "ReadKeysAndCert",
|
|
"data_len": data_len,
|
|
"required_len": KEYS_AND_CERT_MIN_SIZE,
|
|
"reason": "not enough data",
|
|
}).Error("error parsing keys and cert")
|
|
err = errors.New("error parsing KeysAndCert: data is smaller than minimum valid size")
|
|
// return
|
|
}
|
|
cert, remainder, err := ReadCertificate(data[KEYS_AND_CERT_DATA_SIZE:])
|
|
if err != nil {
|
|
//return
|
|
log.Error("ERROR READ CERTIFICATE", err)
|
|
err = nil
|
|
|
|
}
|
|
log.Println("READ CERTIFICATE", cert.Cert())
|
|
keys_and_cert.CertificateInterface = cert
|
|
spk, pk, remainder, err := ReadKeys(data, cert)
|
|
if err != nil {
|
|
// return
|
|
log.Error("ERROR READ KEYS", err)
|
|
err = nil
|
|
|
|
}
|
|
log.Println("READ KEYS")
|
|
keys_and_cert.SigningPublicKey = spk
|
|
keys_and_cert.PublicKey = pk
|
|
return
|
|
}
|