1/*
2 *  Licensed to the Apache Software Foundation (ASF) under one or more
3 *  contributor license agreements.  See the NOTICE file distributed with
4 *  this work for additional information regarding copyright ownership.
5 *  The ASF licenses this file to You under the Apache License, Version 2.0
6 *  (the "License"); you may not use this file except in compliance with
7 *  the License.  You may obtain a copy of the License at
8 *
9 *     http://www.apache.org/licenses/LICENSE-2.0
10 *
11 *  Unless required by applicable law or agreed to in writing, software
12 *  distributed under the License is distributed on an "AS IS" BASIS,
13 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 *  See the License for the specific language governing permissions and
15 *  limitations under the License.
16 */
17
18/**
19 * @author Boris V. Kuznetsov
20 */
21
22package org.apache.harmony.security.tests.java.security;
23
24import java.security.InvalidParameterException;
25import java.security.KeyFactory;
26import java.security.MessageDigest;
27import java.security.NoSuchAlgorithmException;
28import java.security.Provider;
29import java.security.Security;
30import java.security.Signature;
31import java.util.Arrays;
32import java.util.HashMap;
33import java.util.Map;
34
35import junit.framework.TestCase;
36
37import org.apache.harmony.security.tests.support.TestKeyPair;
38
39/**
40 * Tests for <code>Security</code> constructor and methods
41 */
42public class SecurityTest extends TestCase {
43
44    public final void testMixed() {
45
46        TestKeyPair tkp = null;
47        try {
48            tkp = new TestKeyPair("DSA");
49        } catch (NoSuchAlgorithmException e1) {
50            e1.printStackTrace();
51            return;
52        }
53
54        try {
55            MessageDigest.getInstance("SHA-1");
56            KeyFactory.getInstance("DSA");
57            Signature ss = Signature.getInstance("DSA");
58            ss.initSign(tkp.getPrivate());
59            Signature.getInstance("aaaaaaaaaaaa");
60        } catch (Exception e) {
61            // ignore
62        }
63
64    }
65
66    /**
67     * @tests java.security.Security#insertProviderAt(Provider, int)
68     */
69    public final void test_insertProviderAtLjava_security_ProviderLI() {
70
71        try {
72            Security.insertProviderAt(null, 1);
73            fail("No expected NullPointerException");
74        } catch (NullPointerException e) {
75        }
76
77        Provider p = new MyProvider();
78        int initNum = Security.getProviders().length; // initial number of providers
79        Provider initialSecondProviderName = Security.getProviders()[1];
80
81        try {
82
83            // Insert at position -1, the provider is inserted at the end
84            assertEquals(initNum + 1, Security.insertProviderAt(p, -1));
85            assertSame(p, Security.getProviders()[initNum]);
86
87            // A provider cannot be added if it is already installed
88            assertEquals(-1, Security.insertProviderAt(p, 1));
89
90            Security.removeProvider(p.getName());
91
92            // insert at the end
93            assertEquals(initNum + 1, Security.insertProviderAt(p,
94                    initNum + 100));
95            assertSame(p, Security.getProviders()[initNum]);
96
97            Security.removeProvider(p.getName());
98
99            // insert at the first position
100            assertEquals(1, Security.insertProviderAt(p, 1));
101            assertSame(p, Security.getProviders()[0]);
102            assertSame(initialSecondProviderName, // provider shifted down
103                    Security.getProviders()[2]);
104        } finally { //clean up
105            Security.removeProvider(p.getName());
106        }
107    }
108
109    /**
110     * @tests java.security.Security#addProvider(Provider)
111     */
112    public final void test_addProviderLjava_security_Provider() {
113
114        try {
115            Security.addProvider(null);
116            fail("No expected NullPointerException");
117        } catch (NullPointerException e) {
118        }
119
120        Provider p = new MyProvider();
121        int initNum = Security.getProviders().length; // initial number of providers
122
123        try {
124            // add
125            assertEquals(initNum + 1, Security.addProvider(p));
126            assertSame(p, Security.getProviders()[initNum]);
127
128            // A provider cannot be added if it is already installed
129            assertEquals(-1, Security.addProvider(p));
130        } finally { //clean up
131            Security.removeProvider(p.getName());
132        }
133    }
134
135    public final void testRemoveProvider() {
136        Provider[] providers;
137        Provider[] providers1;
138
139        providers = Security.getProviders();
140
141        try {
142            for (int i = 0; i < providers.length; i++) {
143                Security.removeProvider(providers[i].getName());
144            }
145            assertEquals("Providers not removed", 0,
146                    Security.getProviders().length);
147        } finally {    // restore providers
148            for (int i = 0; i < providers.length; i++) {
149                Security.addProvider(providers[i]);
150            }
151            providers1 = Security.getProviders();
152            for (int i = 0; i < providers1.length; i++) {
153                assertEquals("Providers not restored correctly", providers[i],
154                        providers1[i]);
155            }
156        }
157    }
158
159    /**
160     * @tests java.security.Security#getProvider(String)
161     */
162    public final void test_getProviderLjava_lang_String() {
163
164        // Returns null if no provider with the specified name is installed
165        assertNull(Security.getProvider("SOMEINCORRECTPROVIDERNAME"));
166
167        // Returns null if name is null
168        assertNull(Security.getProvider(null));
169
170        // test for existing providers
171        Provider[] providers = Security.getProviders();
172        assertTrue("getProviders returned zero length array",
173                providers.length > 0);
174        for (Provider p : providers) {
175            String providerName = p.getName();
176            assertSame(p, Security.getProvider(providerName));
177        }
178
179        // test for newly installed provider
180        Provider p = new MyProvider();
181        try {
182            Security.addProvider(p);
183
184            assertSame(p, Security.getProvider(p.getName()));
185        } finally { //clean up
186            Security.removeProvider(p.getName());
187        }
188    }
189
190    /**
191     * @tests java.security.Security#getProviders(String)
192     */
193    public void test_getProvidersLjava_lang_String() {
194
195        try {
196            Security.getProviders("");
197            fail("No expected InvalidParameterException");
198        } catch (InvalidParameterException e) {
199        }
200
201        try {
202            Security.getProviders((String) null);
203            fail("No expected NullPointerException");
204        } catch (NullPointerException e) {
205        }
206
207        Provider p = new MyProvider();
208        try {
209            Security.addProvider(p);
210
211            String filter = "MyService.MyAlgorithm";
212            assertTrue(filter, Arrays.equals(new Provider[] { p }, Security
213                    .getProviders(filter)));
214
215            filter = "MyService.MyAlgorithm KeySize:512";
216            assertTrue(filter, Arrays.equals(new Provider[] { p }, Security
217                    .getProviders(filter)));
218
219            filter = "MyService.MyAlgorithm KeySize:1025";
220            assertNull(filter, Security.getProviders(filter));
221
222            // attribute name and value are case insensitive
223            filter = "MyService.MyAlgorithm imPLementedIn:softWARE";
224            assertTrue(filter, Arrays.equals(new Provider[] { p }, Security
225                    .getProviders(filter)));
226            filter = "MyService.MyAlgorithm ATTribute:attributeVALUE";
227            assertTrue(filter, Arrays.equals(new Provider[] { p }, Security
228                    .getProviders(filter)));
229
230            // Regression for HARMONY-2761
231            filter = "MyService.NoKeySize KeySize:512";
232            assertNull(filter, Security.getProviders(filter));
233
234            filter = "MyService.NoImplementedIn ImplementedIn:Software";
235            assertNull(filter, Security.getProviders(filter));
236
237            filter = "ABCService.NoAttribute Attribute:ABC";
238            assertNull(filter, Security.getProviders(filter));
239        } finally { //clean up
240            Security.removeProvider(p.getName());
241        }
242    }
243
244    /**
245     * @tests java.security.Security#getProviders(java.util.Map)
246     */
247    public void test_getProvidersLjava_util_Map() {
248
249        Map<String, String> m = new HashMap<String, String>();
250        Security.getProviders(m);
251
252        assertNull("Not null result on empty map", Security.getProviders(m));
253
254        try {
255            Security.getProviders((Map<String, String>) null);
256            fail("No expected NullPointerException");
257        } catch (NullPointerException e) {
258        }
259
260        m.put("AAA.BBB.CCC", "aaaa"); // key has dot instead of space
261        try {
262            Security.getProviders(m);
263            fail("No expected InvalidParameterException");
264        } catch (InvalidParameterException e) {
265        }
266
267        Provider p = new MyProvider();
268        try {
269            Security.addProvider(p);
270
271            m.clear();
272            m.put("MyService.MyAlgorithm", "");
273            m.put("MessageDigest.SHA-1", "");
274            assertTrue("MyService.MyAlgorithm", Arrays.equals(
275                    new Provider[] { p }, Security.getProviders(m)));
276
277            m.clear();
278            m.put("MyService.MyAlgorithm KeySize", "512");
279            m.put("MessageDigest.SHA-1", "");
280            assertTrue("MyService.MyAlgorithm KeySize:512", Arrays.equals(
281                    new Provider[] { p }, Security.getProviders(m)));
282
283            m.clear();
284            m.put("MyService.MyAlgorithm KeySize", "1025");
285            m.put("MessageDigest.SHA-1", "");
286            assertNull("MyService.MyAlgorithm KeySize:1025", Security
287                    .getProviders(m));
288
289            // attribute name and value are case insensitive
290            m.clear();
291            m.put("MyService.MyAlgorithm imPLementedIn", "softWARE");
292            assertTrue(Arrays.equals(new Provider[] { p }, Security
293                    .getProviders(m)));
294            m.clear();
295            m.put("MyService.MyAlgorithm ATTribute", "attributeVALUE");
296            assertTrue(Arrays.equals(new Provider[] { p }, Security
297                    .getProviders(m)));
298
299            // Regression for HARMONY-2761
300            m.clear();
301            m.put("MyService.NoKeySize KeySize", "512");
302            assertNull("No KeySize attribute", Security.getProviders(m));
303
304            m.clear();
305            m.put("MyService.NoImplementedIn ImplementedIn", "Software");
306            assertNull("No ImplementedIn attribute", Security.getProviders(m));
307
308            m.clear();
309            m.put("ABCService.NoAttribute Attribute", "ABC");
310            assertNull(Security.getProviders(m));
311        } finally { //clean up
312            Security.removeProvider(p.getName());
313        }
314    }
315
316    /**
317     * @tests java.security.Security#getProperty(String)
318     */
319    public void test_getPropertyLjava_lang_String() {
320
321        try {
322            Security.getProperty(null);
323            fail("No expected NullPointerException.");
324        } catch (NullPointerException e) {
325        }
326
327        Security.setProperty("myprop", "test white space    ");
328        assertEquals("test white space", Security.getProperty("myprop"));
329    }
330
331    /**
332     * @tests java.security.Security#setProperty(String, String)
333     */
334    public void test_setPropertyLjava_lang_StringLjava_lang_String() {
335
336        try {
337            Security.setProperty(null, "");
338            fail("No expected NullPointerException.");
339        } catch (NullPointerException e) {
340        }
341
342        try {
343            Security.setProperty("", null);
344            fail("No expected NullPointerException.");
345        } catch (NullPointerException e) {
346        }
347
348        Security.setProperty("", "");
349        assertEquals("Empty property", "", Security.getProperty(""));
350
351        Security.setProperty("My Test Property", "My property value");
352        assertEquals("My property value", Security
353                .getProperty("My Test Property"));
354    }
355
356    @SuppressWarnings("serial")
357    class MyProvider extends Provider {
358        MyProvider() {
359            super("MyProvider", 1.0, "Provider for testing");
360            put("MessageDigest.SHA-1", "SomeClassName");
361            put("MyService.MyAlgorithm", "SomeClassName");
362            put("MyService.MyAlgorithm KeySize", "1024");
363            put("MyService.MyAlgorithm ImplementedIn", "Software");
364            put("MyService.MyAlgorithm Attribute", "AttributeValue");
365
366            // service has no KeySize attribute
367            put("MyService.NoKeySize", "SomeClassName");
368
369            // service has no ImplementedIn attribute
370            put("MyService.NoImplementedIn", "SomeClassName");
371
372            // service has no 'Attribute' attribute
373            put("ABCService.NoAttribute", "SomeClassName");
374        }
375    }
376}
377