1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.wss4j.common.crypto;
20
21 import java.io.IOException;
22 import java.io.InputStream;
23 import java.security.Provider;
24 import java.security.Security;
25 import java.util.Collection;
26 import java.util.Collections;
27 import java.util.Enumeration;
28 import java.util.Map;
29 import java.util.Set;
30
31 public final class ThreadLocalSecurityProvider extends Provider {
32
33 private static final long serialVersionUID = 3556396671069994931L;
34 private static final String NAME = "TLSP";
35 private static final ThreadLocal<Provider> PROVIDER = new ThreadLocal<>();
36 private static boolean installed = false;
37
38 public static synchronized void install() {
39 Security.insertProviderAt(new ThreadLocalSecurityProvider(),
40 Security.getProviders().length);
41 installed = true;
42 }
43
44 public static synchronized void uninstall() {
45 Security.removeProvider(NAME);
46 installed = false;
47 }
48
49 public static boolean isInstalled() {
50 return installed;
51 }
52
53 private ThreadLocalSecurityProvider() {
54 super(NAME, "2.5", "ThreadLocal Security Provider");
55 }
56
57 public static void setProvider(Provider p) {
58 PROVIDER.set(p);
59 }
60
61 public static void unsetProvider() {
62 PROVIDER.remove();
63 }
64
65 private Provider getProvider() {
66 return PROVIDER.get();
67 }
68
69 @Override
70 public synchronized void clear() {
71 Provider p = getProvider();
72 if (p != null) {
73 p.clear();
74 }
75 }
76
77 @Override
78 public synchronized void load(InputStream inStream) throws IOException {
79 Provider p = getProvider();
80 if (p != null) {
81 p.load(inStream);
82 }
83 }
84
85 @Override
86 public synchronized void putAll(Map<?, ?> t) {
87 Provider p = getProvider();
88 if (p != null) {
89 p.putAll(t);
90 }
91 }
92
93 @Override
94 public synchronized Set<Map.Entry<Object, Object>> entrySet() {
95 Provider p = getProvider();
96 if (p != null) {
97 return p.entrySet();
98 } else {
99 return Collections.emptySet();
100 }
101 }
102
103 @Override
104 public Set<Object> keySet() {
105 Provider p = getProvider();
106 if (p != null) {
107 return p.keySet();
108 } else {
109 return Collections.emptySet();
110 }
111 }
112
113 @Override
114 public Collection<Object> values() {
115 Provider p = getProvider();
116 if (p != null) {
117 return p.values();
118 } else {
119 return Collections.emptyList();
120 }
121 }
122
123 @Override
124 public synchronized Object put(Object key, Object value) {
125 Provider p = getProvider();
126 if (p != null) {
127 return p.put(key, value);
128 } else {
129 return null;
130 }
131 }
132
133 @Override
134 public synchronized Object remove(Object key) {
135 Provider p = getProvider();
136 if (p != null) {
137 return p.remove(key);
138 } else {
139 return null;
140 }
141 }
142
143 @Override
144 public Object get(Object key) {
145 Provider p = getProvider();
146 if (p != null) {
147 return p.get(key);
148 } else {
149 return null;
150 }
151 }
152
153 @Override
154 public Enumeration<Object> keys() {
155 Provider p = getProvider();
156 if (p != null) {
157 return p.keys();
158 } else {
159 return Collections.emptyEnumeration();
160 }
161 }
162
163 @Override
164 public Enumeration<Object> elements() {
165 Provider p = getProvider();
166 if (p != null) {
167 return p.elements();
168 } else {
169 return Collections.emptyEnumeration();
170 }
171 }
172
173 @Override
174 public String getProperty(String key) {
175 Provider p = getProvider();
176 if (p != null) {
177 return p.getProperty(key);
178 } else {
179 return null;
180 }
181 }
182
183 @Override
184 public synchronized Service getService(String type, String algorithm) {
185 Provider p = getProvider();
186 if (p != null) {
187 return p.getService(type, algorithm);
188 } else {
189 return null;
190 }
191 }
192
193 @Override
194 public synchronized Set<Service> getServices() {
195 Provider p = getProvider();
196 if (p != null) {
197 return p.getServices();
198 } else {
199 return Collections.emptySet();
200 }
201 }
202
203 }