diff options
Diffstat (limited to 'src/main/java/com/code_intelligence/jazzer/mutation/annotation')
13 files changed, 415 insertions, 0 deletions
diff --git a/src/main/java/com/code_intelligence/jazzer/mutation/annotation/AppliesTo.java b/src/main/java/com/code_intelligence/jazzer/mutation/annotation/AppliesTo.java new file mode 100644 index 00000000..4d4c4a89 --- /dev/null +++ b/src/main/java/com/code_intelligence/jazzer/mutation/annotation/AppliesTo.java @@ -0,0 +1,40 @@ +/* + * Copyright 2023 Code Intelligence GmbH + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.code_intelligence.jazzer.mutation.annotation; + +import static java.lang.annotation.ElementType.ANNOTATION_TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * A meta-annotation that limits the concrete types an annotation for type usages applies to. + */ +@Target(ANNOTATION_TYPE) +@Retention(RUNTIME) +public @interface AppliesTo { + /** + * The meta-annotated annotation can be applied to these classes. + */ + Class<?>[] value() default {}; + + /** + * The meta-annotated annotation can be applied to subclasses of these classes. + */ + Class<?>[] subClassesOf() default {}; +} diff --git a/src/main/java/com/code_intelligence/jazzer/mutation/annotation/Ascii.java b/src/main/java/com/code_intelligence/jazzer/mutation/annotation/Ascii.java new file mode 100644 index 00000000..190ada09 --- /dev/null +++ b/src/main/java/com/code_intelligence/jazzer/mutation/annotation/Ascii.java @@ -0,0 +1,28 @@ +/* + * Copyright 2023 Code Intelligence GmbH + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.code_intelligence.jazzer.mutation.annotation; + +import static java.lang.annotation.ElementType.TYPE_USE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +@Target(TYPE_USE) +@Retention(RUNTIME) +@AppliesTo(String.class) +public @interface Ascii {} diff --git a/src/main/java/com/code_intelligence/jazzer/mutation/annotation/BUILD.bazel b/src/main/java/com/code_intelligence/jazzer/mutation/annotation/BUILD.bazel new file mode 100644 index 00000000..6d6c4da9 --- /dev/null +++ b/src/main/java/com/code_intelligence/jazzer/mutation/annotation/BUILD.bazel @@ -0,0 +1,5 @@ +java_library( + name = "annotation", + srcs = glob(["*.java"]), + visibility = ["//visibility:public"], +) diff --git a/src/main/java/com/code_intelligence/jazzer/mutation/annotation/DoubleInRange.java b/src/main/java/com/code_intelligence/jazzer/mutation/annotation/DoubleInRange.java new file mode 100644 index 00000000..27765879 --- /dev/null +++ b/src/main/java/com/code_intelligence/jazzer/mutation/annotation/DoubleInRange.java @@ -0,0 +1,32 @@ +/* + * Copyright 2023 Code Intelligence GmbH + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.code_intelligence.jazzer.mutation.annotation; + +import static java.lang.annotation.ElementType.TYPE_USE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +@Target(TYPE_USE) +@Retention(RUNTIME) +@AppliesTo({double.class, Double.class}) +public @interface DoubleInRange { + double min() default Double.NEGATIVE_INFINITY; + double max() default Double.POSITIVE_INFINITY; + boolean allowNaN() default true; +} diff --git a/src/main/java/com/code_intelligence/jazzer/mutation/annotation/FloatInRange.java b/src/main/java/com/code_intelligence/jazzer/mutation/annotation/FloatInRange.java new file mode 100644 index 00000000..ec54e026 --- /dev/null +++ b/src/main/java/com/code_intelligence/jazzer/mutation/annotation/FloatInRange.java @@ -0,0 +1,32 @@ +/* + * Copyright 2023 Code Intelligence GmbH + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.code_intelligence.jazzer.mutation.annotation; + +import static java.lang.annotation.ElementType.TYPE_USE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +@Target(TYPE_USE) +@Retention(RUNTIME) +@AppliesTo({float.class, Float.class}) +public @interface FloatInRange { + float min() default Float.NEGATIVE_INFINITY; + float max() default Float.POSITIVE_INFINITY; + boolean allowNaN() default true; +} diff --git a/src/main/java/com/code_intelligence/jazzer/mutation/annotation/InRange.java b/src/main/java/com/code_intelligence/jazzer/mutation/annotation/InRange.java new file mode 100644 index 00000000..a8dc8281 --- /dev/null +++ b/src/main/java/com/code_intelligence/jazzer/mutation/annotation/InRange.java @@ -0,0 +1,35 @@ +/* + * Copyright 2023 Code Intelligence GmbH + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.code_intelligence.jazzer.mutation.annotation; + +import static java.lang.annotation.ElementType.TYPE_USE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Target(TYPE_USE) +@Retention(RUNTIME) +@AppliesTo({byte.class, Byte.class, short.class, Short.class, int.class, Integer.class, long.class, + Long.class}) +public @interface InRange { + long min() default Long.MIN_VALUE; + + long max() default Long.MAX_VALUE; +} diff --git a/src/main/java/com/code_intelligence/jazzer/mutation/annotation/NotNull.java b/src/main/java/com/code_intelligence/jazzer/mutation/annotation/NotNull.java new file mode 100644 index 00000000..061eeffc --- /dev/null +++ b/src/main/java/com/code_intelligence/jazzer/mutation/annotation/NotNull.java @@ -0,0 +1,29 @@ +/* + * Copyright 2023 Code Intelligence GmbH + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.code_intelligence.jazzer.mutation.annotation; + +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE_USE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +@Target({PARAMETER, TYPE_USE}) +@Retention(RUNTIME) +@AppliesTo(subClassesOf = Object.class) +public @interface NotNull {} diff --git a/src/main/java/com/code_intelligence/jazzer/mutation/annotation/WithLength.java b/src/main/java/com/code_intelligence/jazzer/mutation/annotation/WithLength.java new file mode 100644 index 00000000..7cee23df --- /dev/null +++ b/src/main/java/com/code_intelligence/jazzer/mutation/annotation/WithLength.java @@ -0,0 +1,33 @@ +/* + * Copyright 2023 Code Intelligence GmbH + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.code_intelligence.jazzer.mutation.annotation; + +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE_USE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +@Target(TYPE_USE) +@Retention(RUNTIME) +@AppliesTo(byte[].class) +public @interface WithLength { + int min() default 0; + + int max() default 1000; +} diff --git a/src/main/java/com/code_intelligence/jazzer/mutation/annotation/WithSize.java b/src/main/java/com/code_intelligence/jazzer/mutation/annotation/WithSize.java new file mode 100644 index 00000000..32233f4b --- /dev/null +++ b/src/main/java/com/code_intelligence/jazzer/mutation/annotation/WithSize.java @@ -0,0 +1,34 @@ +/* + * Copyright 2023 Code Intelligence GmbH + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.code_intelligence.jazzer.mutation.annotation; + +import static java.lang.annotation.ElementType.TYPE_USE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; +import java.util.List; +import java.util.Map; + +@Target(TYPE_USE) +@Retention(RUNTIME) +@AppliesTo({List.class, Map.class}) +public @interface WithSize { + int min() default 0; + + int max() default 1000; +} diff --git a/src/main/java/com/code_intelligence/jazzer/mutation/annotation/WithUtf8Length.java b/src/main/java/com/code_intelligence/jazzer/mutation/annotation/WithUtf8Length.java new file mode 100644 index 00000000..00b1f463 --- /dev/null +++ b/src/main/java/com/code_intelligence/jazzer/mutation/annotation/WithUtf8Length.java @@ -0,0 +1,43 @@ +/* + * Copyright 2023 Code Intelligence GmbH + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.code_intelligence.jazzer.mutation.annotation; + +import static java.lang.annotation.ElementType.TYPE_USE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * An annotation that applies to {@link String} to <strong>limit the length of the UTF-8 + * encoding</strong> of the string. In practical terms, this means that strings given this + * annotation will sometimes have a {@link String#length()} of less than + * {@code min} but will never exceed {@code max}. <p> Due to the fact that our String mutator is + * backed by the byte array mutator, it's difficult to know how many characters we'll get from the + * byte array we get from libfuzzer. Rather than reuse {@link WithLength} for strings which may give + * the impression that {@link String#length()} will return a value between {@code min} and {@code + * max}, we use this annotation to help make clear that the string consists of between + * {@code min} and {@code max} UTF-8 bytes, not necessarily (UTF-16) characters. + */ +@Target(TYPE_USE) +@Retention(RUNTIME) +@AppliesTo(String.class) +public @interface WithUtf8Length { + int min() default 0; + + int max() default 1000; +} diff --git a/src/main/java/com/code_intelligence/jazzer/mutation/annotation/proto/AnySource.java b/src/main/java/com/code_intelligence/jazzer/mutation/annotation/proto/AnySource.java new file mode 100644 index 00000000..9f802dfe --- /dev/null +++ b/src/main/java/com/code_intelligence/jazzer/mutation/annotation/proto/AnySource.java @@ -0,0 +1,40 @@ +/* + * Copyright 2023 Code Intelligence GmbH + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.code_intelligence.jazzer.mutation.annotation.proto; + +import static java.lang.annotation.ElementType.TYPE_USE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +import com.code_intelligence.jazzer.mutation.annotation.AppliesTo; +import com.google.protobuf.Message; +import com.google.protobuf.Message.Builder; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * Controls the mutations of {@link com.google.protobuf.Any} fields in messages of the annotated + * type as well as its recursive message fields. + */ +@Target(TYPE_USE) +@Retention(RUNTIME) +@AppliesTo(subClassesOf = {Message.class, Builder.class}) +public @interface AnySource { + /** + * A non-empty list of {@link Message}s to use for {@link com.google.protobuf.Any} fields. + */ + Class<? extends Message>[] value(); +} diff --git a/src/main/java/com/code_intelligence/jazzer/mutation/annotation/proto/BUILD.bazel b/src/main/java/com/code_intelligence/jazzer/mutation/annotation/proto/BUILD.bazel new file mode 100644 index 00000000..8ef6863b --- /dev/null +++ b/src/main/java/com/code_intelligence/jazzer/mutation/annotation/proto/BUILD.bazel @@ -0,0 +1,21 @@ +java_library( + name = "proto", + srcs = glob(["*.java"]), + visibility = ["//visibility:public"], + deps = [ + ":protobuf_runtime_compile_only", + "//src/main/java/com/code_intelligence/jazzer/mutation/annotation", + ], +) + +java_library( + name = "protobuf_runtime_compile_only", + # The proto mutator factory detects the presence of Protobuf at runtime and disables itself if + # it isn't found. Without something else bringing in the Protobuf runtime, there is no point in + # supporting proto mutations. + neverlink = True, + visibility = ["//src/main/java/com/code_intelligence/jazzer/mutation/mutator/proto:__pkg__"], + exports = [ + "@com_google_protobuf_protobuf_java//jar", + ], +) diff --git a/src/main/java/com/code_intelligence/jazzer/mutation/annotation/proto/WithDefaultInstance.java b/src/main/java/com/code_intelligence/jazzer/mutation/annotation/proto/WithDefaultInstance.java new file mode 100644 index 00000000..e26d73a2 --- /dev/null +++ b/src/main/java/com/code_intelligence/jazzer/mutation/annotation/proto/WithDefaultInstance.java @@ -0,0 +1,43 @@ +/* + * Copyright 2023 Code Intelligence GmbH + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.code_intelligence.jazzer.mutation.annotation.proto; + +import static java.lang.annotation.ElementType.TYPE_USE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +import com.code_intelligence.jazzer.mutation.annotation.AppliesTo; +import com.google.protobuf.DynamicMessage; +import com.google.protobuf.Message; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * Provides a default instance to use as the base for mutations of the annotated {@link Message} or + * {@link DynamicMessage.Builder}. + */ +@Target(TYPE_USE) +@Retention(RUNTIME) +@AppliesTo(subClassesOf = {Message.class, Message.Builder.class}) +public @interface WithDefaultInstance { + /** + * The fully qualified name of a static method (e.g. + * {@code com.example.MyClass#getDefaultInstance}) with return type assignable to + * {@link com.google.protobuf.Message}, which returns a default instance that mutations should be + * based on. + */ + String value(); +} |