"istio.io/istio/pilot/pkg/config/kube/ingress"
	"istio.io/istio/pkg/config"
	"istio.io/istio/pkg/kube"
	"istio.io/istio/pkg/kube/kclient"
)

func FuzzConvertIngressVirtualService(data []byte) int {
	f := fuzz.NewConsumer(data)
	ing := knetworking.Ingress{}
	err := f.GenerateStruct(&ing)
	if err != nil {
		return 0
	}
	service := &corev1.Service{}
	cfgs := map[string]*config.Config{}

	"istio.io/istio/security/pkg/pki/util"
)

// FuzzVerifyCertificate implements a fuzzer
// that tests util.VerifyCertificate
func FuzzVerifyCertificate(data []byte) int {
	f := fuzz.NewConsumer(data)
	privPem, err := f.GetBytes()
	if err != nil {
		return 0
	}
	certChainPem, err := f.GetBytes()
	if err != nil {
		return 0
	}
	rootCertPem, err := f.GetBytes()
	if err != nil {
		return 0

	"istio.io/istio/security/pkg/pki/util"
	"istio.io/istio/security/pkg/server/ca"
	"istio.io/istio/security/pkg/server/ca/authenticate"
)

func FuzzGenCSR(data []byte) int {
	f := fuzz.NewConsumer(data)
	certOptions := util.CertOptions{}
	err := f.GenerateStruct(&certOptions)
	if err != nil {
		return 0
	}
	_, _, _ = util.GenCSR(certOptions)
	return 1
}

	"istio.io/istio/pkg/config/validation"
	"istio.io/istio/pkg/config/validation/envoyfilter"
	"istio.io/istio/pkg/kube"
)

func FuzzConfigValidation(data []byte) int {
	f := fuzz.NewConsumer(data)
	configIndex, err := f.GetInt()
	if err != nil {
		return -1
	}

	r := collections.Pilot.All()[configIndex%len(collections.Pilot.All())]
	gvk := r.GroupVersionKind()
	kgvk := schema.GroupVersionKind{

package inject

import (
	"testing"

	fuzz "github.com/AdaLogics/go-fuzz-headers"
)

func FuzzRunTemplate(f *testing.F) {
	f.Fuzz(func(t *testing.T, data []byte, v string) {
		ff := fuzz.NewConsumer(data)

		// create injection parameters
		IP := InjectionParameters{}
		err := ff.GenerateStruct(&IP)
		if err != nil {
			return
		}
		if IP.pod == nil {
			return
		}

package ca

import (
	"testing"
	"time"

	fuzz "github.com/AdaLogics/go-fuzz-headers"
)

func FuzzIstioCASign(f *testing.F) {
	f.Fuzz(func(t *testing.T, data, csrPEM []byte) {
		ff := fuzz.NewConsumer(data)
		// create ca options
		opts := &IstioCAOptions{}
		err := ff.GenerateStruct(opts)
		if err != nil {
			return
		}
		ca, err := NewIstioCA(opts)
		if err != nil {
			return
		}

package ra

import (
	"testing"

	fuzz "github.com/AdaLogics/go-fuzz-headers"
)

func FuzzValidateCSR(f *testing.F) {
	f.Fuzz(func(t *testing.T, csrPEM, subjectIDsData []byte) {
		ff := fuzz.NewConsumer(subjectIDsData)

		// create subjectIDs
		subjectIDs := make([]string, 0)
		noOfEntries, err := ff.GetUint64()
		if err != nil {
			return
		}
		var i uint64
		for i = 0; i < noOfEntries; i++ {

package fuzz

import (
	fuzz "github.com/AdaLogics/go-fuzz-headers"

	"istio.io/istio/pilot/pkg/model"
	"istio.io/istio/pilot/pkg/networking/grpcgen"
)

func FuzzGrpcGenGenerate(data []byte) int {
	f := fuzz.NewConsumer(data)

	proxy := &model.Proxy{}
	err := f.GenerateStruct(proxy)
	if err != nil {
		return 0
	}
	if !proxy.FuzzValidate() {
		return 0
	}

	w := &model.WatchedResource{}
	err = f.GenerateStruct(w)

	"istio.io/api/networking/v1alpha3"
)

func FuzzApplyLocalityLBSetting(f *testing.F) {
	f.Fuzz(func(t *testing.T, data []byte) {
		ff := fuzz.NewConsumer(data)
		proxyLabels := make(map[string]string)
		err := ff.FuzzMap(&proxyLabels)
		if err != nil {
			return
		}
		wrappedLocalityLbEndpoints := make([]*WrappedLocalityLbEndpoints, 0)

		if sr == nil {
			return errors.New("a ServiceRegistry was nil")
		}
	}
	return nil
}

func FuzzValidateClusters(data []byte) int {
	proxy := model.Proxy{}
	f := fuzz.NewConsumer(data)
	to := core.TestOptions{}
	err := f.GenerateStruct(&to)
	if err != nil {
		return 0
	}
	err = ValidateTestOptions(to)
	if err != nil {
		return 0
	}
	err = f.GenerateStruct(&proxy)