return nil, err
	}

	pkix := pkixPublicKey{
		Algo: publicKeyAlgorithm,
		BitString: asn1.BitString{
			Bytes:     publicKeyBytes,
			BitLength: 8 * len(publicKeyBytes),
		},
	}

	ret, _ := asn1.Marshal(pkix)
	return ret, nil
}

// These structures reflect the ASN.1 structure of X.509 certificates.:

type certificate struct {

	return dst
}

type bitStringEncoder BitString

func (b bitStringEncoder) Len() int {
	return len(b.Bytes) + 1
}

func (b bitStringEncoder) Encode(dst []byte) {
	dst[0] = byte((8 - b.BitLength%8) % 8)
	if copy(dst[1:], b.Bytes) != len(b.Bytes) {
		panic("internal error")
	}
}

type oidEncoder []int

func (oid oidEncoder) Len() int {
	l := base128IntLength(int64(oid[0]*40 + oid[1]))

	}
}

// VersionLen is the Config Version and is only used as the nonce prefix, but we can reconstruct
// it because is is a b64 encoding of a 64 bit array, which will always be 12 chars in length.
// len = ceil(bitlength/(2^6))+1
const VersionLen = 12

func (s *DiscoveryServer) getResourceVersion(nonce, key string, cache map[string]string) string {
	if len(nonce) < VersionLen {
		return ""
	}

		{"(ObjectIdentifier).Equal", Method, 0},
		{"(ObjectIdentifier).String", Method, 3},
		{"(StructuralError).Error", Method, 0},
		{"(SyntaxError).Error", Method, 0},
		{"BitString", Type, 0},
		{"BitString.BitLength", Field, 0},
		{"BitString.Bytes", Field, 0},
		{"ClassApplication", Const, 6},
		{"ClassContextSpecific", Const, 6},
		{"ClassPrivate", Const, 6},
		{"ClassUniversal", Const, 6},
		{"Enumerated", Type, 0},