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 * @version $Revision$
21 */
22
23package org.apache.harmony.security.tests.java.security;
24
25import java.security.InvalidParameterException;
26import java.security.Provider;
27import java.security.Security;
28import java.util.Arrays;
29import java.util.HashMap;
30import java.util.Locale;
31import java.util.Map;
32import java.util.Set;
33import junit.framework.TestCase;
34
35
36public class SecurityTest extends TestCase {
37
38    /**
39     * java.security.Security#insertProviderAt(Provider, int)
40     */
41    public final void test_insertProviderAtLjava_security_ProviderLI() {
42
43        try {
44            Security.insertProviderAt(null, 1);
45            fail("No expected NullPointerException");
46        } catch (NullPointerException e) {
47        }
48
49        Provider p = new MyProvider();
50        int initNum = Security.getProviders().length; // initial number of
51        // providers
52        Provider initialSecondProviderName = Security.getProviders()[1];
53
54        try {
55
56            // Insert at position -1, the provider is inserted at the end
57            assertEquals(initNum + 1, Security.insertProviderAt(p, -1));
58            assertSame(p, Security.getProviders()[initNum]);
59
60            // A provider cannot be added if it is already installed
61            assertEquals(-1, Security.insertProviderAt(p, 1));
62
63            Security.removeProvider(p.getName());
64
65            // insert at the end
66            assertEquals(initNum + 1, Security.insertProviderAt(p,
67                    initNum + 100));
68            assertSame(p, Security.getProviders()[initNum]);
69
70            Security.removeProvider(p.getName());
71
72            // insert at the first position
73            assertEquals(1, Security.insertProviderAt(p, 1));
74            assertSame(p, Security.getProviders()[0]);
75            assertSame(initialSecondProviderName, // provider shifted down
76                    Security.getProviders()[2]);
77        } finally { // clean up
78            Security.removeProvider(p.getName());
79        }
80    }
81
82    /**
83     * java.security.Security#addProvider(Provider)
84     */
85    public final void test_addProviderLjava_security_Provider() {
86
87        try {
88            Security.addProvider(null);
89            fail("No expected NullPointerException");
90        } catch (NullPointerException e) {
91        }
92
93        Provider p = new MyProvider();
94        int initNum = Security.getProviders().length; // initial number of
95        // providers
96
97        try {
98            // add
99            assertEquals(initNum + 1, Security.addProvider(p));
100            assertSame(p, Security.getProviders()[initNum]);
101
102            // A provider cannot be added if it is already installed
103            assertEquals(-1, Security.addProvider(p));
104        } finally { // clean up
105            Security.removeProvider(p.getName());
106        }
107    }
108
109    /**
110     * java.security.Security#getAlgorithmProperty(String algName, String
111     *        propName)
112     * @disabled because Security.getAlgorithmProperty looks for
113     *           "propName.algName" instead of "Alg.propName.algName"
114     */
115    @SuppressWarnings("deprecation")
116    public final void testGetAlgorithmPropertyLjava_lang_String_java_lang_String() {
117
118        Provider provider = new MyProvider();
119        Map<String, String> m = new HashMap<String, String>();
120        m.clear();
121        m.put("Alg.propName.algName", "value");
122        provider.putAll(m);
123
124        try {
125            Security.addProvider(provider);
126
127            assertNotNull(Security.getAlgorithmProperty("algName", "propName"));
128
129            assertNull(Security.getAlgorithmProperty("DSA", null));
130            assertNull(Security.getAlgorithmProperty("DSA", "propName"));
131        } finally {
132            Security.removeProvider(provider.getName());
133        }
134    }
135
136    /**
137     * java.security.Security#getAlgorithms(String serviceName)
138     */
139    public final void testGetAlgorithmsLjava_lang_String() {
140        String[] servicesNames = { "Signature", "MessageDigest", "Cipher",
141                "Mac", "KeyStore" };
142
143        String[] invalidServiceNames = { "Rubbish", "", null };
144
145        for (int i = 0; i < servicesNames.length; i++) {
146            Set<String> algs = Security.getAlgorithms(servicesNames[i]);
147            assertTrue("no services with specified name: " + servicesNames[i], algs.size() > 0);
148        }
149
150        for (int i = 0; i < invalidServiceNames.length; i++) {
151            Set<String> algs = Security.getAlgorithms(invalidServiceNames[i]);
152            assertTrue("services with specified name: " + invalidServiceNames[i], algs.size() == 0);
153        }
154    }
155
156    public final void testRemoveProvider() {
157        Provider[] providers;
158        Provider[] providers1;
159
160        providers = Security.getProviders();
161
162        try {
163            for (int i = 0; i < providers.length; i++) {
164                Security.removeProvider(providers[i].getName());
165            }
166            assertEquals("Providers not removed", 0,
167                    Security.getProviders().length);
168        } finally {    // restore providers
169            for (int i = 0; i < providers.length; i++) {
170                Security.addProvider(providers[i]);
171            }
172            providers1 = Security.getProviders();
173            for (int i = 0; i < providers1.length; i++) {
174                assertEquals("Providers not restored correctly", providers[i],
175                        providers1[i]);
176            }
177        }
178    }
179
180    /**
181     * java.security.Security#getProvider(String)
182     */
183    public final void test_getProviderLjava_lang_String() {
184
185        // Returns null if no provider with the specified name is installed
186        assertNull(Security.getProvider("SOMEINCORRECTPROVIDERNAME"));
187
188        // Returns null if name is null
189        assertNull(Security.getProvider(null));
190
191        // test for existing providers
192        Provider[] providers = Security.getProviders();
193        assertTrue("getProviders returned zero length array",
194                providers.length > 0);
195        for (Provider p : providers) {
196            String providerName = p.getName();
197            assertSame(p, Security.getProvider(providerName));
198        }
199
200        // test for newly installed provider
201        Provider p = new MyProvider();
202        try {
203            Security.addProvider(p);
204
205            assertSame(p, Security.getProvider(p.getName()));
206        } finally { // clean up
207            Security.removeProvider(p.getName());
208        }
209    }
210
211    /**
212     * java.security.Security#getProviders(String)
213     */
214    public void test_getProvidersLjava_lang_String() {
215        try {
216            Security.getProviders("");
217            fail("No expected InvalidParameterException");
218        } catch (InvalidParameterException e) {
219        }
220
221        try {
222            Security.getProviders((String) null);
223            fail("No expected NullPointerException");
224        } catch (NullPointerException e) {
225        }
226
227        testGetProviders(Locale.US);
228        testGetProviders(new Locale("tr", "TR"));
229    }
230
231    /**
232     * Test that Security.getProviders does case sensitive operations
233     * independent of its locale.
234     */
235    private void testGetProviders(Locale locale) {
236        Locale defaultLocale = Locale.getDefault();
237        Locale.setDefault(locale);
238        Provider p = new MyProvider();
239        try {
240            Security.addProvider(p);
241
242            String filter = "MyService.MyAlgorithm";
243            assertTrue(filter, Arrays.equals(new Provider[] { p }, Security
244                    .getProviders(filter)));
245
246            filter = "MyService.MyAlgorithm KeySize:512";
247            assertTrue(filter, Arrays.equals(new Provider[] { p }, Security
248                    .getProviders(filter)));
249
250            filter = "MyService.MyAlgorithm KeySize:1025";
251            assertNull(filter, Security.getProviders(filter));
252
253            // attribute name and value are case insensitive
254            filter = "MyService.MyAlgorithm imPLementedIn:softWARE";
255            assertTrue(filter, Arrays.equals(new Provider[] { p }, Security
256                    .getProviders(filter)));
257            filter = "MyService.MyAlgorithm ATTribute:attributeVALUE";
258            assertTrue(filter, Arrays.equals(new Provider[] { p }, Security
259                    .getProviders(filter)));
260            filter = "MyService.MyAlgorithm \u0130mPLemented\u0131n:softWARE"; // Turkish dotless i
261            assertTrue(filter, Arrays.equals(new Provider[] { p }, Security
262                    .getProviders(filter)));
263
264            // Regression for HARMONY-2761
265            filter = "MyService.NoKeySize KeySize:512";
266            assertNull(filter, Security.getProviders(filter));
267
268            filter = "MyService.NoImplementedIn ImplementedIn:Software";
269            assertNull(filter, Security.getProviders(filter));
270
271            filter = "ABCService.NoAttribute Attribute:ABC";
272            assertNull(filter, Security.getProviders(filter));
273        } finally { // clean up
274            Security.removeProvider(p.getName());
275            Locale.setDefault(defaultLocale);
276        }
277    }
278
279    /**
280     * java.security.Security#getProviders(java.util.Map)
281     */
282    public void test_getProvidersLjava_util_Map() {
283
284        Map<String, String> m = new HashMap<String, String>();
285        Security.getProviders(m);
286
287        assertNull("Not null result on empty map", Security.getProviders(m));
288
289        try {
290            Security.getProviders((Map<String, String>) null);
291            fail("No expected NullPointerException");
292        } catch (NullPointerException e) {
293        }
294
295        m.put("AAA.BBB.CCC", "aaaa"); // key has dot instead of space
296        try {
297            Security.getProviders(m);
298            fail("No expected InvalidParameterException");
299        } catch (InvalidParameterException e) {
300        }
301
302        Provider p = new MyProvider();
303        try {
304            Security.addProvider(p);
305
306            m.clear();
307            m.put("MyService.MyAlgorithm", "");
308            m.put("MessageDigest.SHA-1", "");
309            assertTrue("MyService.MyAlgorithm", Arrays.equals(
310                    new Provider[] { p }, Security.getProviders(m)));
311
312            m.clear();
313            m.put("MyService.MyAlgorithm KeySize", "512");
314            m.put("MessageDigest.SHA-1", "");
315            assertTrue("MyService.MyAlgorithm KeySize:512", Arrays.equals(
316                    new Provider[] { p }, Security.getProviders(m)));
317
318            m.clear();
319            m.put("MyService.MyAlgorithm KeySize", "1025");
320            m.put("MessageDigest.SHA-1", "");
321            assertNull("MyService.MyAlgorithm KeySize:1025", Security
322                    .getProviders(m));
323
324            // attribute name and value are case insensitive
325            m.clear();
326            m.put("MyService.MyAlgorithm imPLementedIn", "softWARE");
327            assertTrue(Arrays.equals(new Provider[] { p }, Security
328                    .getProviders(m)));
329            m.clear();
330            m.put("MyService.MyAlgorithm ATTribute", "attributeVALUE");
331            assertTrue(Arrays.equals(new Provider[] { p }, Security
332                    .getProviders(m)));
333
334            // Regression for HARMONY-2761
335            m.clear();
336            m.put("MyService.NoKeySize KeySize", "512");
337            assertNull("No KeySize attribute", Security.getProviders(m));
338
339            m.clear();
340            m.put("MyService.NoImplementedIn ImplementedIn", "Software");
341            assertNull("No ImplementedIn attribute", Security.getProviders(m));
342
343            m.clear();
344            m.put("ABCService.NoAttribute Attribute", "ABC");
345            assertNull(Security.getProviders(m));
346        } finally { // clean up
347            Security.removeProvider(p.getName());
348        }
349    }
350
351    /**
352     * java.security.Security#getProviders()
353     */
354    public void test_getProviders() {
355        Provider[] prv;
356
357        MyProvider provider = new MyProvider();
358        try {
359            prv = Security.getProviders();
360            int len1 = prv.length;
361            if (len1 == 0) {
362                fail("Array of providers is ampty");
363            }
364            Security.addProvider(provider);
365            prv = Security.getProviders();
366            int len2 = prv.length;
367            if ((len2 == len1 + 1) && (prv[len2-1].toString().equals("MyProvider version 1.0"))) {
368                // ok
369            } else {
370                fail("Method getProviders() returned incorrect values");
371            }
372        } catch (Exception ex) {
373            fail("Unexpected exception");
374        }
375        finally {
376            Security.removeProvider(provider.getName());
377        }
378    }
379
380    /**
381     * java.security.Security#getProperty(String)
382     */
383    public void test_getPropertyLjava_lang_String() {
384
385        try {
386            Security.getProperty(null);
387            fail("No expected NullPointerException.");
388        } catch (NullPointerException e) {
389        }
390
391        Security.setProperty("myprop","test white space    ");
392        assertEquals("test white space", Security.getProperty("myprop"));
393    }
394
395    /**
396     * java.security.Security#setProperty(String,String)
397     */
398    public void test_setPropertyLjava_lang_StringLjava_lang_String() {
399
400        try {
401            Security.setProperty(null, "");
402            fail("No expected NullPointerException.");
403        } catch (NullPointerException e) {
404        }
405
406        try {
407            Security.setProperty("", null);
408            fail("No expected NullPointerException.");
409        } catch (NullPointerException e) {
410        }
411
412        Security.setProperty("", "");
413        assertEquals("Empty property", "", Security.getProperty(""));
414
415        Security.setProperty("My Test Property", "My property value");
416        assertEquals("My property value", Security
417                .getProperty("My Test Property"));
418    }
419
420    @SuppressWarnings("serial")
421    class MyProvider extends Provider {
422        MyProvider() {
423            super("MyProvider", 1.0, "Provider for testing");
424            put("MessageDigest.SHA-1", "SomeClassName");
425            put("MyService.MyAlgorithm", "SomeClassName");
426            put("MyService.MyAlgorithm KeySize", "1024");
427            put("MyService.MyAlgorithm ImplementedIn", "Software");
428            put("MyService.MyAlgorithm Attribute", "AttributeValue");
429
430            // service has no KeySize attribute
431            put("MyService.NoKeySize", "SomeClassName");
432
433            // service has no ImplementedIn attribute
434            put("MyService.NoImplementedIn", "SomeClassName");
435
436            // service has no 'Attribute' attribute
437            put("ABCService.NoAttribute", "SomeClassName");
438        }
439    }
440}
441