Method loadOrGenerateKey

internal/modify/dkim/keys.go:36–96

(keyPath, newKeyAlgo string)

)

func (m *Modifier) loadOrGenerateKey(keyPath, newKeyAlgo string) (pkey crypto.Signer, newKey bool, err error) {
	f, err := os.Open(keyPath)
	if err != nil {
		if os.IsNotExist(err) {
			pkey, err = m.generateAndWrite(keyPath, newKeyAlgo)
			return pkey, true, err
		}
		return nil, false, err
	}
	defer func() {
		if err := f.Close(); err != nil {
			m.log.Error("failed to close key file", err)
		}
	}()

	pemBlob, err := io.ReadAll(f)
	if err != nil {
		return nil, false, err
	}

	block, _ := pem.Decode(pemBlob)
	if block == nil {
		return nil, false, fmt.Errorf("modify.dkim: %s: invalid PEM block", keyPath)
	}

	var key interface{}
	switch block.Type {
	case "PRIVATE KEY": // RFC 5208 aka PKCS #8
		key, err = x509.ParsePKCS8PrivateKey(block.Bytes)
		if err != nil {
			return nil, false, fmt.Errorf("modify.dkim: %s: %w", keyPath, err)
		}
	case "RSA PRIVATE KEY": // RFC 3447 aka PKCS #1
		key, err = x509.ParsePKCS1PrivateKey(block.Bytes)
		if err != nil {
			return nil, false, fmt.Errorf("modify.dkim: %s: %w", keyPath, err)
		}
	case "EC PRIVATE KEY": // RFC 5915
		key, err = x509.ParseECPrivateKey(block.Bytes)
		if err != nil {
			return nil, false, fmt.Errorf("modify.dkim: %s: %w", keyPath, err)
		}
	default:
		return nil, false, fmt.Errorf("modify.dkim: %s: not a private key or unsupported format", keyPath)
	}

	switch key := key.(type) {
	case *rsa.PrivateKey:
		if err := key.Validate(); err != nil {
			return nil, false, err
		}
		key.Precompute()
		return key, false, nil
	case ed25519.PrivateKey:
		return key, false, nil
	case *ecdsa.PublicKey:
		return nil, false, fmt.Errorf("modify.dkim: %s: ECDSA keys are not supported", keyPath)
	default: