type crypto/ecdh.PrivateKey

47 uses

	crypto/ecdh (current package)
		ecdh.go#L24: 	GenerateKey(rand io.Reader) (*PrivateKey, error)
		ecdh.go#L35: 	NewPrivateKey(key []byte) (*PrivateKey, error)
		ecdh.go#L52: 	ecdh(local *PrivateKey, remote *PublicKey) ([]byte, error)
		ecdh.go#L105: var _ KeyExchanger = (*PrivateKey)(nil)
		ecdh.go#L112: type PrivateKey struct {
		ecdh.go#L131: func (k *PrivateKey) ECDH(remote *PublicKey) ([]byte, error) {
		ecdh.go#L139: func (k *PrivateKey) Bytes() []byte {
		ecdh.go#L153: func (k *PrivateKey) Equal(x crypto.PrivateKey) bool {
		ecdh.go#L154: 	xx, ok := x.(*PrivateKey)
		ecdh.go#L162: func (k *PrivateKey) Curve() Curve {
		ecdh.go#L166: func (k *PrivateKey) PublicKey() *PublicKey {
		ecdh.go#L172: func (k *PrivateKey) Public() crypto.PublicKey {
		nist.go#L29: func (c *nistCurve) GenerateKey(r io.Reader) (*PrivateKey, error) {
		nist.go#L39: 		k := &PrivateKey{
		nist.go#L59: 	k := &PrivateKey{
		nist.go#L84: func (c *nistCurve) NewPrivateKey(key []byte) (*PrivateKey, error) {
		nist.go#L94: 		k := &PrivateKey{
		nist.go#L107: 	k := &PrivateKey{
		nist.go#L146: func (c *nistCurve) ecdh(local *PrivateKey, remote *PublicKey) ([]byte, error) {
		x25519.go#L37: func (c *x25519Curve) GenerateKey(r io.Reader) (*PrivateKey, error) {
		x25519.go#L49: func (c *x25519Curve) NewPrivateKey(key []byte) (*PrivateKey, error) {
		x25519.go#L62: 	return &PrivateKey{
		x25519.go#L82: func (c *x25519Curve) ecdh(local *PrivateKey, remote *PublicKey) ([]byte, error) {

	crypto/ecdsa
		ecdsa.go#L185: func (priv *PrivateKey) ECDH() (*ecdh.PrivateKey, error) {

	crypto/hpke
		kem.go#L233: var testingOnlyGenerateKey func() *ecdh.PrivateKey
		kem.go#L351: 	priv, ok := k.priv.(*ecdh.PrivateKey)
		pq.go#L193: 	var skE *ecdh.PrivateKey

	crypto/tls
		key_agreement.go#L155: 	key                *ecdh.PrivateKey
		key_agreement.go#L381: func generateECDHEKey(rand io.Reader, curveID CurveID) (*ecdh.PrivateKey, error) {
		key_schedule.go#L55: 	ecdhe *ecdh.PrivateKey

	crypto/x509
		pkcs8.go#L150: 	case *ecdh.PrivateKey:
		sec1.go#L75: func marshalECDHPrivateKey(key *ecdh.PrivateKey) ([]byte, error) {

	github.com/refraction-networking/utls
		handshake_client_tls13.go#L567: func getSharedKey(peerData []byte, key *ecdh.PrivateKey) ([]byte, error) {
		key_agreement.go#L161: 	key     *ecdh.PrivateKey
		key_schedule.go#L55: 	ecdhe      *ecdh.PrivateKey
		key_schedule.go#L57: 	mlkemEcdhe *ecdh.PrivateKey // [uTLS] seperate ecdhe key for pq keyshare in line with Chrome, instead of reusing ecdhe key like stdlib
		key_schedule.go#L64: func generateECDHEKey(rand io.Reader, curveID CurveID) (*ecdh.PrivateKey, error) {
		u_alias.go#L25: func (*KeySharesParameters) AddEcdheKeypair(curveID CurveID, ecdheKey *ecdh.PrivateKey, ecdhePubKey *ecdh.PublicKey) {
		u_alias.go#L29: func (*KeySharesParameters) GetEcdheKey(curveID CurveID) (ecdheKey *ecdh.PrivateKey, ok bool) { return }
		u_public.go#L42: 	EcdheKey *ecdh.PrivateKey
		u_public.go#L898: 	Ecdhe      *ecdh.PrivateKey
		u_public.go#L900: 	MlkemEcdhe *ecdh.PrivateKey

	github.com/refraction-networking/utls/internal/hpke
		hpke.go#L23: var testingOnlyGenerateKey func() (*ecdh.PrivateKey, error)
		hpke.go#L89: 	var privEph *ecdh.PrivateKey
		hpke.go#L110: func (dh *dhKEM) Decap(encPubEph []byte, secRecipient *ecdh.PrivateKey) ([]byte, error) {
		hpke.go#L240: func SetupReceipient(kemID, kdfID, aeadID uint16, priv *ecdh.PrivateKey, info, encPubEph []byte) (*Receipient, error) {
		hpke.go#L307: func ParseHPKEPrivateKey(kemID uint16, bytes []byte) (*ecdh.PrivateKey, error) {