func (pubkey *Pubkey) initV3() error {
var buf bytes.Buffer
err := pubkey.PublicKeyV3.Serialize(&buf)
if err != nil {
return err
}
fingerprint := FingerprintV3(pubkey.PublicKeyV3)
bitLen, err := pubkey.PublicKeyV3.BitLength()
if err != nil {
return err
}
if pubkey.PublicKeyV3.IsSubkey {
log.Println("Expected primary public key packet, got sub-key")
return ErrInvalidPacketType
}
pubkey.RFingerprint = util.Reverse(fingerprint)
pubkey.Creation = pubkey.PublicKeyV3.CreationTime
pubkey.Expiration = NeverExpires
if pubkey.PublicKeyV3.DaysToExpire > 0 {
pubkey.Expiration = pubkey.Creation.Add(time.Duration(pubkey.PublicKeyV3.DaysToExpire) * time.Hour * 24)
}
pubkey.Algorithm = int(pubkey.PublicKeyV3.PubKeyAlgo)
pubkey.BitLen = int(bitLen)
return nil
}
func (w *Worker) lookupKeyidUuids(keyId string) (uuids []string, err error) {
keyId = strings.ToLower(keyId)
raw, err := hex.DecodeString(keyId)
if err != nil {
return nil, ErrInvalidKeyId
}
rKeyId := util.Reverse(keyId)
var compareOp string
switch len(raw) {
case 4:
compareOp = "LIKE $1 || '________________________________'"
case 8:
compareOp = "LIKE $1 || '________________________'"
case 16:
return []string{rKeyId}, nil
case 20:
return []string{rKeyId}, nil
default:
return nil, ErrInvalidKeyId
}
rows, err := w.db.Queryx(fmt.Sprintf(`
SELECT uuid FROM openpgp_pubkey WHERE uuid %s
UNION
SELECT pubkey_uuid FROM openpgp_subkey WHERE uuid %s`, compareOp, compareOp), rKeyId)
if err == sql.ErrNoRows {
return nil, ErrKeyNotFound
} else if err != nil {
return
}
return flattenUuidRows(rows)
}
func (ec *deleteCmd) deleteFingerprint() {
uuid := strings.ToLower(util.Reverse(ec.fingerprint))
row, err := ec.db.Query(
"SELECT md5 FROM openpgp_pubkey WHERE uuid = $1", uuid)
if err != nil {
die(err)
}
if !row.Next() {
die(fmt.Errorf("Key fingerprint [%s] not found", uuid))
}
var keyHash string
err = row.Scan(&keyHash)
if err != nil {
die(err)
}
keyHashBuf, err := hex.DecodeString(keyHash)
if err != nil {
die(err)
}
if err = ec.ptree.Remove(conflux.Zb(conflux.P_SKS, keyHashBuf)); err != nil {
log.Println("Remove [%s] from prefix tree: %v", keyHash, err)
}
ec.deletePubkey(uuid)
log.Println(ec.keyHash, "deleted from prefix tree and database")
}
func (pubkey *Pubkey) initUnsupported(op *packet.OpaquePacket) (err error) {
pubkey.State = PacketStateUnsuppPubkey
// Calculate opaque fingerprint on unsupported public key packet
h := sha1.New()
h.Write([]byte{0x99, byte(len(op.Contents) >> 8), byte(len(op.Contents))})
h.Write(op.Contents)
fpr := hex.EncodeToString(h.Sum(nil))
pubkey.RFingerprint = util.Reverse(fpr)
return
}
func (subkey *Subkey) initV4() error {
fingerprint := Fingerprint(subkey.PublicKey)
bitLen, err := subkey.PublicKey.BitLength()
if err != nil {
return err
}
if !subkey.PublicKey.IsSubkey {
log.Println("Expected sub-key packet, got primary public key")
return ErrInvalidPacketType
}
subkey.RFingerprint = util.Reverse(fingerprint)
subkey.Creation = subkey.PublicKey.CreationTime
subkey.Expiration = NeverExpires
subkey.Algorithm = int(subkey.PublicKey.PubKeyAlgo)
subkey.BitLen = int(bitLen)
return nil
}
func (subkey *Subkey) initV3() error {
fingerprint := FingerprintV3(subkey.PublicKeyV3)
bitLen, err := subkey.PublicKeyV3.BitLength()
if err != nil {
return err
}
if subkey.PublicKeyV3.IsSubkey {
log.Println("Expected primary public key packet, got sub-key")
return ErrInvalidPacketType
}
subkey.RFingerprint = util.Reverse(fingerprint)
subkey.Creation = subkey.PublicKeyV3.CreationTime
subkey.Expiration = NeverExpires
if subkey.PublicKeyV3.DaysToExpire > 0 {
subkey.Expiration = subkey.Creation.Add(time.Duration(subkey.PublicKeyV3.DaysToExpire) * time.Hour * 24)
}
subkey.Algorithm = int(subkey.PublicKeyV3.PubKeyAlgo)
subkey.BitLen = int(bitLen)
return nil
}
func (pubkey *Pubkey) initV4() error {
buf := bytes.NewBuffer(nil)
err := pubkey.PublicKey.Serialize(buf)
if err != nil {
return err
}
fingerprint := Fingerprint(pubkey.PublicKey)
bitLen, err := pubkey.PublicKey.BitLength()
if err != nil {
return err
}
if pubkey.PublicKey.IsSubkey {
log.Println("Expected primary public key packet, got sub-key")
return ErrInvalidPacketType
}
pubkey.RFingerprint = util.Reverse(fingerprint)
pubkey.Creation = pubkey.PublicKey.CreationTime
pubkey.Expiration = NeverExpires
pubkey.Algorithm = int(pubkey.PublicKey.PubKeyAlgo)
pubkey.BitLen = int(bitLen)
return nil
}
func (pubkey *Pubkey) ShortId() string {
if pubkey.PublicKeyV3 != nil {
return fmt.Sprintf("%08x", uint32(pubkey.PublicKeyV3.KeyId))
}
return util.Reverse(pubkey.RFingerprint[:8])
}
func (pubkey *Pubkey) KeyId() string {
if pubkey.PublicKeyV3 != nil {
return fmt.Sprintf("%016x", pubkey.PublicKeyV3.KeyId)
}
return util.Reverse(pubkey.RFingerprint[:16])
}
func (pubkey *Pubkey) Fingerprint() string {
return util.Reverse(pubkey.RFingerprint)
}
func (subkey *Subkey) ShortId() string {
return util.Reverse(subkey.RFingerprint[:8])
}
func (subkey *Subkey) KeyId() string {
return util.Reverse(subkey.RFingerprint[:16])
}
func (subkey *Subkey) Fingerprint() string {
return util.Reverse(subkey.RFingerprint)
}
