- etcd/ca.crt
		 - etcd/ca.key
		 - etcd/server.crt
		 - etcd/server.key
		 - etcd/peer.crt
		 - etcd/peer.key
		 - etcd/healthcheck-client.crt
		 - etcd/healthcheck-client.key
		 - sa.pub
		 - sa.key
		 - front-proxy-ca.crt
		 - front-proxy-ca.key
		 - front-proxy-client.crt
		 - front-proxy-client.key

pub    5208812E1E4A6DB0
uid    Gradle Inc. <******@****.***>

-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: BCPG v1.68

mQENBFxaxWYBCADI4/gRCJYfXwZYdUoEGlAlCfRgABy90rvebzcs8MKtolAbPVkG
iqnjftXd28sZhEDx9YJrUfmzspdrYmU7hy1kgV1/WGIcWyTExTH3bqlnaIWnnTxA
HD0x4NJ2AzmX5VO8LxhqGID+BErrv7uGZvVmJT6trqUIcKeNEq7mzdDJKqTBY4cw
q+Dm8P0vs4IFTD8q5f1Vr78FmUth2srIBmsIH1wNV1nAUTmQppNBFlCmcvnWTYI1
0UMcsFFrJ2pFT1yP2AEGUNl4Lgj4hmVHZwX38/lu9pQ7iWtHSLOwZsfuC34/goS+

			}
			sub1 := h.WithAttrs([]Attr{Bool("sub1", true)})
			sub2 := h.WithAttrs([]Attr{Bool("sub2", true)})
			var wg sync.WaitGroup
			for i := 0; i < count; i++ {
				sub1Record := NewRecord(time.Time{}, LevelInfo, "hello from sub1", 0)
				sub1Record.AddAttrs(Int("i", i))
				sub2Record := NewRecord(time.Time{}, LevelInfo, "hello from sub2", 0)
				sub2Record.AddAttrs(Int("i", i))
				wg.Add(1)
				go func() {

	0x0001: func() *hkdfKDF { return &hkdfKDF{crypto.SHA256} },
}

func SetupSender(kemID, kdfID, aeadID uint16, pub crypto.PublicKey, info []byte) ([]byte, *Sender, error) {
	suiteID := SuiteID(kemID, kdfID, aeadID)

	kem, err := newDHKem(kemID)
	if err != nil {
		return nil, nil, err
	}
	pubRecipient, ok := pub.(*ecdh.PublicKey)
	if !ok {
		return nil, nil, errors.New("incorrect public key type")
	}

		pkey = parent.key
	} else {
		pcert = tmpl
		pkey = key
	}

	var pub interface{}
	switch k := key.(type) {
	case *rsa.PrivateKey:
		pub = &k.PublicKey
	case *ecdsa.PrivateKey:
		pub = &k.PublicKey
	default:
		t.Fatalf("invalid key %T", key)
	}

	der, err := x509.CreateCertificate(rand.Reader, tmpl, pcert, pub, pkey)
	if err != nil {
		t.Fatal(err)
	}

				suite.TearDownSuite(c)
			},
		)
	}
}

func (s *TestSuiteIAM) SFTPFailedPublicKeyAuthenticationInvalidKey(c *check) {
	keyBytes, err := os.ReadFile("./testdata/invalid_test_key.pub")
	if err != nil {
		c.Fatalf("could not read test key file: %s", err)
	}

	testKey, _, _, _, err := ssh.ParseAuthorizedKey(keyBytes)
	if err != nil {
		c.Fatalf("could not parse test key file: %s", err)
	}

			m("title", "This is ***fun***")},

		{`message/external-body; access-type=URL; ` +
			`URL*0="ftp://";` +
			`URL*1="cs.utk.edu/pub/moore/bulk-mailer/bulk-mailer.tar"`,
			"message/external-body",
			m("access-type", "URL",
				"url", "ftp://cs.utk.edu/pub/moore/bulk-mailer/bulk-mailer.tar")},

		{`application/x-stuff; ` +
			`title*0*=us-ascii'en'This%20is%20even%20more%20; ` +

// PrivateKey, as the latter embeds the former and will expose its methods.

// Equal reports whether pub and x have the same value.
func (pub PublicKey) Equal(x crypto.PublicKey) bool {
	xx, ok := x.(PublicKey)
	if !ok {
		return false
	}
	return subtle.ConstantTimeCompare(pub, xx) == 1
}

// PrivateKey is the type of Ed25519 private keys. It implements [crypto.Signer].
type PrivateKey []byte

	p, _ := pem.Decode([]byte(s))
	k, err := x509.ParsePKCS1PublicKey(p.Bytes)
	if err != nil {
		panic(err)
	}
	return k
}

func TestShortPKCS1v15Signature(t *testing.T) {
	pub := parsePublicKey(`-----BEGIN RSA PUBLIC KEY-----
MEgCQQCd9BVzo775lkohasxjnefF1nCMcNoibqIWEVDe/K7M2GSoO4zlSQB+gkix
O3AnTcdHB51iaZpWfxPSnew8yfulAgMBAAE=
-----END RSA PUBLIC KEY-----`)

            ring.encode(it)
        }
        def publicKeys = generator.generatePublicKeyRing().publicKeys.collect { it }
        PGPPublicKeyRing pub = new PGPPublicKeyRing(publicKeys)
        PGPPublicKeyRingCollection pubcol = new BcPGPPublicKeyRingCollection(
            [pub]
        )
        new FileOutputStream(pubring).withCloseable {
            pubcol.encode(it)
        }
        directory
    }