Skip to content

Commit 0bd103a

Browse files
aibaarsaibaars
committed
Java: add tests for Container taint steps
1 parent 6367eb9 commit 0bd103a

File tree

3 files changed

+369
-1
lines changed

3 files changed

+369
-1
lines changed

‎java/ql/test/library-tests/dataflow/collections/ContainterTest.java

Lines changed: 228 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,228 @@
1+
2+
import java.util.Collection;
3+
import java.util.List;
4+
import java.util.Vector;
5+
import java.util.Stack;
6+
import java.util.Queue;
7+
import java.util.Deque;
8+
import java.util.concurrent.BlockingQueue;
9+
import java.util.concurrent.TransferQueue;
10+
import java.util.concurrent.BlockingDeque;
11+
import java.util.SortedSet;
12+
import java.util.NavigableSet;
13+
import java.util.Map;
14+
import java.util.Map.Entry;
15+
import java.util.SortedMap;
16+
import java.util.NavigableMap;
17+
import java.util.concurrent.ConcurrentHashMap;
18+
import java.util.concurrent.TimeUnit;
19+
import java.util.Dictionary;
20+
import java.util.Iterator;
21+
import java.util.ListIterator;
22+
import java.util.Enumeration;
23+
24+
class ContainerTest {
25+
26+
private static <T> T sink(T object) { return object; }
27+
private static <T> T mkSink(Class<T> cls) { return null; }
28+
private static <T> T source(T object) { return object; }
29+
30+
public static void taintSteps(
31+
Iterable<String> iterable,
32+
Collection<String> collection,
33+
List<String> list,
34+
Vector<String> vector,
35+
Stack<String> stack,
36+
Queue<String> queue,
37+
Deque<String> deque,
38+
BlockingQueue<String> blockQueue,
39+
BlockingDeque<String> blockDeque,
40+
TransferQueue<String> transferQ,
41+
SortedSet<String> sortedSet,
42+
NavigableSet<String> navSet,
43+
Map<String, String> map,
44+
Map.Entry<String, String> entry,
45+
SortedMap<String, String> sortedMap,
46+
NavigableMap<String, String> navMap,
47+
ConcurrentHashMap<String, String> syncHashMap,
48+
Dictionary<String, String> dict,
49+
Iterator<String> iter,
50+
ListIterator<String> listIter,
51+
Enumeration<String> enumeration
52+
) throws InterruptedException {
53+
// java.util.Iterable
54+
sink(iterable.iterator());
55+
sink(iterable.spliterator());
56+
57+
// java.util.Collection
58+
sink(collection.parallelStream());
59+
sink(collection.stream());
60+
sink(collection.toArray());
61+
sink(collection.toArray(x -> new String[x]));
62+
sink(collection.toArray(new String[5]));
63+
collection.toArray(mkSink(String[].class));
64+
mkSink(Collection.class).add(source("value"));
65+
mkSink(Collection.class).addAll(collection);
66+
67+
// java.util.List
68+
sink(list.get(1));
69+
sink(list.listIterator());
70+
sink(list.listIterator(2));
71+
sink(list.remove(3));
72+
sink(list.set(4, "value"));
73+
sink(list.subList(5, 6));
74+
mkSink(List.class).add(7, source("value"));
75+
mkSink(List.class).addAll(8, collection);
76+
mkSink(List.class).set(9, source("value"));
77+
78+
// java.util.Vector
79+
sink(vector.elementAt(7));
80+
sink(vector.elements());
81+
sink(vector.firstElement());
82+
sink(vector.lastElement());
83+
mkSink(Vector.class).addElement(source("element"));
84+
mkSink(Vector.class).insertElementAt(source("element"), 1);
85+
mkSink(Vector.class).setElementAt(source("element"), 2);
86+
vector.copyInto(mkSink(String[].class));
87+
88+
// java.util.Stack
89+
sink(stack.peek());
90+
sink(stack.pop());
91+
stack.push("value"); // not tainted
92+
sink(stack.push(source("value")));
93+
mkSink(Stack.class).push(source("value"));
94+
95+
// java.util.Queue
96+
sink(queue.element());
97+
sink(queue.peek());
98+
sink(queue.poll());
99+
sink(queue.remove());
100+
mkSink(Queue.class).offer(source("element"));
101+
102+
// java.util.Deque
103+
sink(deque.getFirst());
104+
sink(deque.getLast());
105+
sink(deque.peekFirst());
106+
sink(deque.peekLast());
107+
sink(deque.pollFirst());
108+
sink(deque.pollLast());
109+
sink(deque.removeFirst());
110+
sink(deque.removeLast());
111+
mkSink(Deque.class).addFirst(source("value"));
112+
mkSink(Deque.class).addLast(source("value"));
113+
mkSink(Deque.class).offerFirst(source("value"));
114+
mkSink(Deque.class).offerLast(source("value"));
115+
mkSink(Deque.class).push(source("value"));
116+
117+
// java.util.concurrent.BlockingQueue
118+
sink(blockQueue.poll(10, TimeUnit.SECONDS));
119+
sink(blockQueue.take());
120+
blockQueue.drainTo(mkSink(Collection.class));
121+
blockQueue.drainTo(mkSink(Collection.class), 4);
122+
123+
// java.util.concurrent.TransferQueue
124+
mkSink(TransferQueue.class).transfer(source("value"));
125+
mkSink(TransferQueue.class).tryTransfer(source("value"));
126+
mkSink(TransferQueue.class).tryTransfer(source("value"), 9, TimeUnit.SECONDS);
127+
128+
// java.util.concurrent.BlockingDeque
129+
sink(blockDeque.pollFirst(11, TimeUnit.SECONDS));
130+
sink(blockDeque.pollLast(12, TimeUnit.SECONDS));
131+
sink(blockDeque.takeFirst());
132+
sink(blockDeque.takeLast());
133+
mkSink(BlockingDeque.class).offer(source("value"), 10, TimeUnit.SECONDS);
134+
mkSink(BlockingDeque.class).put(source("value"));
135+
mkSink(BlockingDeque.class).offerFirst(source("value"), 10, TimeUnit.SECONDS);
136+
mkSink(BlockingDeque.class).offerLast(source("value"), 10, TimeUnit.SECONDS);
137+
mkSink(BlockingDeque.class).putFirst(source("value"));
138+
mkSink(BlockingDeque.class).putLast(source("value"));
139+
140+
// java.util.SortedSet
141+
sink(sortedSet.first());
142+
sink(sortedSet.headSet("a"));
143+
sink(sortedSet.last());
144+
sink(sortedSet.subSet("b", "c"));
145+
sink(sortedSet.tailSet("d"));
146+
147+
// java.util.NavigableSet
148+
sink(navSet.ceiling("e"));
149+
sink(navSet.descendingIterator());
150+
sink(navSet.descendingSet());
151+
sink(navSet.floor("f"));
152+
sink(navSet.headSet("g", true));
153+
sink(navSet.higher("h"));
154+
sink(navSet.lower("i"));
155+
sink(navSet.pollFirst());
156+
sink(navSet.pollLast());
157+
sink(navSet.subSet("j", true, "k", false));
158+
sink(navSet.tailSet("l", true));
159+
160+
// java.util.Map
161+
sink(map.computeIfAbsent("key", key -> "result"));
162+
sink(map.entrySet());
163+
sink(map.get("key"));
164+
sink(map.getOrDefault("key", "default"));
165+
sink(map.merge("key", "value", (x, y) -> x + y));
166+
sink(map.put("key", "value"));
167+
sink(map.putIfAbsent("key", "value"));
168+
sink(map.remove("object"));
169+
sink(map.replace("key", "value"));
170+
sink(map.values());
171+
mkSink(Map.class).merge("key", source("v"), (x,y) -> "" + x + y);
172+
mkSink(Map.class).put("key", source("v"));
173+
mkSink(Map.class).putAll(map);
174+
mkSink(Map.class).putIfAbsent("key", source("v"));
175+
mkSink(Map.class).replace("key", source("v"));
176+
mkSink(Map.class).replace("key", "old", source("v"));
177+
mkSink(Map.class).replace("key", source("old"), "v"); // not tainted
178+
179+
// java.util.Map.Entry
180+
sink(entry.getValue());
181+
sink(entry.setValue("value"));
182+
mkSink(Map.Entry.class).setValue(source("value"));
183+
// java.util.SortedMap
184+
sink(sortedMap.headMap("key"));
185+
sink(sortedMap.subMap("key1", "key2"));
186+
sink(sortedMap.tailMap("key"));
187+
188+
// java.util.NavigableMap
189+
sink(navMap.ceilingEntry("key"));
190+
sink(navMap.descendingMap());
191+
sink(navMap.firstEntry());
192+
sink(navMap.floorEntry("key"));
193+
sink(navMap.headMap("key", true));
194+
sink(navMap.higherEntry("key"));
195+
sink(navMap.lastEntry());
196+
sink(navMap.lowerEntry("key"));
197+
sink(navMap.pollFirstEntry());
198+
sink(navMap.pollLastEntry());
199+
sink(navMap.subMap("key1", true, "key2", true));
200+
sink(navMap.tailMap("key", true));
201+
202+
// java.util.concurrent.ConcurrentHashMap
203+
sink(syncHashMap.elements());
204+
sink(syncHashMap.search(10, (k, v) -> v));
205+
sink(syncHashMap.searchEntries(11, e -> e.getValue()));
206+
sink(syncHashMap.searchValues(12, v -> v));
207+
208+
// java.util.Dictionary
209+
sink(dict.elements());
210+
sink(dict.get("object"));
211+
sink(dict.put("key", "value"));
212+
sink(dict.remove("object"));
213+
mkSink(Dictionary.class).put("key", source("value"));
214+
215+
// java.util.Iterator
216+
sink(iter.next());
217+
218+
// java.util.ListIterator
219+
sink(listIter.previous());
220+
mkSink(ListIterator.class).add(source("value"));
221+
mkSink(ListIterator.class).set(source("value"));
222+
223+
// java.util.Enumeration
224+
sink(enumeration.asIterator());
225+
sink(enumeration.nextElement());
226+
}
227+
}
228+

0 commit comments

Comments
 (0)