plan9-archive/inferno-java

java/pkg/java/security/AccessControlContext$1.class+0−0

Binary file not shown.

java/pkg/java/security/AccessControlContext.class+0−0

Binary file not shown.

java/pkg/java/security/AccessControlContext.java+598−0

@@ -0,0 +1,598 @@
	1	/*
	2	* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.util.ArrayList;
	29	import java.util.List;
	30	import sun.security.util.Debug;
	31	import sun.security.util.SecurityConstants;
	32	import sun.misc.JavaSecurityAccess;
	33	import sun.misc.SharedSecrets;
	34
	35
	36	/**
	37	* An AccessControlContext is used to make system resource access decisions
	38	* based on the context it encapsulates.
	39	*
	40	* <p>More specifically, it encapsulates a context and
	41	* has a single method, <code>checkPermission</code>,
	42	* that is equivalent to the <code>checkPermission</code> method
	43	* in the AccessController class, with one difference: The AccessControlContext
	44	* <code>checkPermission</code> method makes access decisions based on the
	45	* context it encapsulates,
	46	* rather than that of the current execution thread.
	47	*
	48	* <p>Thus, the purpose of AccessControlContext is for those situations where
	49	* a security check that should be made within a given context
	50	* actually needs to be done from within a
	51	* <i>different</i> context (for example, from within a worker thread).
	52	*
	53	* <p> An AccessControlContext is created by calling the
	54	* <code>AccessController.getContext</code> method.
	55	* The <code>getContext</code> method takes a "snapshot"
	56	* of the current calling context, and places
	57	* it in an AccessControlContext object, which it returns. A sample call is
	58	* the following:
	59	*
	60	* <pre>
	61	* AccessControlContext acc = AccessController.getContext()
	62	* </pre>
	63	*
	64	* <p>
	65	* Code within a different context can subsequently call the
	66	* <code>checkPermission</code> method on the
	67	* previously-saved AccessControlContext object. A sample call is the
	68	* following:
	69	*
	70	* <pre>
	71	* acc.checkPermission(permission)
	72	* </pre>
	73	*
	74	* @see AccessController
	75	*
	76	* @author Roland Schemers
	77	*/
	78
	79	public final class AccessControlContext {
	80
	81	private ProtectionDomain context[];
	82	private boolean isPrivileged;
	83
	84	// Note: This field is directly used by the virtual machine
	85	// native codes. Don't touch it.
	86	private AccessControlContext privilegedContext;
	87
	88	private DomainCombiner combiner = null;
	89
	90	private static boolean debugInit = false;
	91	private static Debug debug = null;
	92
	93	static Debug getDebug()
	94	{
	95	if (debugInit)
	96	return debug;
	97	else {
	98	if (Policy.isSet()) {
	99	debug = Debug.getInstance("access");
	100	debugInit = true;
	101	}
	102	return debug;
	103	}
	104	}
	105
	106	/**
	107	* Create an AccessControlContext with the given array of ProtectionDomains.
	108	* Context must not be null. Duplicate domains will be removed from the
	109	* context.
	110	*
	111	* @param context the ProtectionDomains associated with this context.
	112	* The non-duplicate domains are copied from the array. Subsequent
	113	* changes to the array will not affect this AccessControlContext.
	114	* @throws NullPointerException if <code>context</code> is <code>null</code>
	115	*/
	116	public AccessControlContext(ProtectionDomain context[])
	117	{
	118	if (context.length == 0) {
	119	this.context = null;
	120	} else if (context.length == 1) {
	121	if (context[0] != null) {
	122	this.context = context.clone();
	123	} else {
	124	this.context = null;
	125	}
	126	} else {
	127	List<ProtectionDomain> v = new ArrayList<>(context.length);
	128	for (int i =0; i< context.length; i++) {
	129	if ((context[i] != null) && (!v.contains(context[i])))
	130	v.add(context[i]);
	131	}
	132	if (!v.isEmpty()) {
	133	this.context = new ProtectionDomain[v.size()];
	134	this.context = v.toArray(this.context);
	135	}
	136	}
	137	}
	138
	139	/**
	140	* Create a new <code>AccessControlContext</code> with the given
	141	* <code>AccessControlContext</code> and <code>DomainCombiner</code>.
	142	* This constructor associates the provided
	143	* <code>DomainCombiner</code> with the provided
	144	* <code>AccessControlContext</code>.
	145	*
	146	* <p>
	147	*
	148	* @param acc the <code>AccessControlContext</code> associated
	149	* with the provided <code>DomainCombiner</code>.
	150	*
	151	* @param combiner the <code>DomainCombiner</code> to be associated
	152	* with the provided <code>AccessControlContext</code>.
	153	*
	154	* @exception NullPointerException if the provided
	155	* <code>context</code> is <code>null</code>.
	156	*
	157	* @exception SecurityException if a security manager is installed and the
	158	* caller does not have the "createAccessControlContext"
	159	* {@link SecurityPermission}
	160	* @since 1.3
	161	*/
	162	public AccessControlContext(AccessControlContext acc,
	163	DomainCombiner combiner) {
	164
	165	SecurityManager sm = System.getSecurityManager();
	166	if (sm != null) {
	167	sm.checkPermission(SecurityConstants.CREATE_ACC_PERMISSION);
	168	}
	169
	170	this.context = acc.context;
	171
	172	// we do not need to run the combine method on the
	173	// provided ACC. it was already "combined" when the
	174	// context was originally retrieved.
	175	//
	176	// at this point in time, we simply throw away the old
	177	// combiner and use the newly provided one.
	178	this.combiner = combiner;
	179	}
	180
	181	/**
	182	* package private for AccessController
	183	*/
	184	AccessControlContext(ProtectionDomain context[], DomainCombiner combiner) {
	185	if (context != null) {
	186	this.context = context.clone();
	187	}
	188	this.combiner = combiner;
	189	}
	190
	191	/**
	192	* package private constructor for AccessController.getContext()
	193	*/
	194
	195	AccessControlContext(ProtectionDomain context[],
	196	boolean isPrivileged)
	197	{
	198	this.context = context;
	199	this.isPrivileged = isPrivileged;
	200	}
	201
	202	/**
	203	* Constructor for JavaSecurityAccess.doIntersectionPrivilege()
	204	*/
	205	AccessControlContext(ProtectionDomain[] context,
	206	AccessControlContext privilegedContext)
	207	{
	208	this.context = context;
	209	this.privilegedContext = privilegedContext;
	210	this.isPrivileged = true;
	211	}
	212
	213	/**
	214	* Returns this context's context.
	215	*/
	216	ProtectionDomain[] getContext() {
	217	return context;
	218	}
	219
	220	/**
	221	* Returns true if this context is privileged.
	222	*/
	223	boolean isPrivileged()
	224	{
	225	return isPrivileged;
	226	}
	227
	228	/**
	229	* get the assigned combiner from the privileged or inherited context
	230	*/
	231	DomainCombiner getAssignedCombiner() {
	232	AccessControlContext acc;
	233	if (isPrivileged) {
	234	acc = privilegedContext;
	235	} else {
	236	acc = AccessController.getInheritedAccessControlContext();
	237	}
	238	if (acc != null) {
	239	return acc.combiner;
	240	}
	241	return null;
	242	}
	243
	244	/**
	245	* Get the <code>DomainCombiner</code> associated with this
	246	* <code>AccessControlContext</code>.
	247	*
	248	* <p>
	249	*
	250	* @return the <code>DomainCombiner</code> associated with this
	251	* <code>AccessControlContext</code>, or <code>null</code>
	252	* if there is none.
	253	*
	254	* @exception SecurityException if a security manager is installed and
	255	* the caller does not have the "getDomainCombiner"
	256	* {@link SecurityPermission}
	257	* @since 1.3
	258	*/
	259	public DomainCombiner getDomainCombiner() {
	260
	261	SecurityManager sm = System.getSecurityManager();
	262	if (sm != null) {
	263	sm.checkPermission(SecurityConstants.GET_COMBINER_PERMISSION);
	264	}
	265	return combiner;
	266	}
	267
	268	/**
	269	* Determines whether the access request indicated by the
	270	* specified permission should be allowed or denied, based on
	271	* the security policy currently in effect, and the context in
	272	* this object. The request is allowed only if every ProtectionDomain
	273	* in the context implies the permission. Otherwise the request is
	274	* denied.
	275	*
	276	* <p>
	277	* This method quietly returns if the access request
	278	* is permitted, or throws a suitable AccessControlException otherwise.
	279	*
	280	* @param perm the requested permission.
	281	*
	282	* @exception AccessControlException if the specified permission
	283	* is not permitted, based on the current security policy and the
	284	* context encapsulated by this object.
	285	* @exception NullPointerException if the permission to check for is null.
	286	*/
	287	public void checkPermission(Permission perm)
	288	throws AccessControlException
	289	{
	290	boolean dumpDebug = false;
	291
	292	if (perm == null) {
	293	throw new NullPointerException("permission can't be null");
	294	}
	295	if (getDebug() != null) {
	296	// If "codebase" is not specified, we dump the info by default.
	297	dumpDebug = !Debug.isOn("codebase=");
	298	if (!dumpDebug) {
	299	// If "codebase" is specified, only dump if the specified code
	300	// value is in the stack.
	301	for (int i = 0; context != null && i < context.length; i++) {
	302	if (context[i].getCodeSource() != null &&
	303	context[i].getCodeSource().getLocation() != null &&
	304	Debug.isOn("codebase=" + context[i].getCodeSource().getLocation().toString())) {
	305	dumpDebug = true;
	306	break;
	307	}
	308	}
	309	}
	310
	311	dumpDebug &= !Debug.isOn("permission=") \|\|
	312	Debug.isOn("permission=" + perm.getClass().getCanonicalName());
	313
	314	if (dumpDebug && Debug.isOn("stack")) {
	315	Thread.currentThread().dumpStack();
	316	}
	317
	318	if (dumpDebug && Debug.isOn("domain")) {
	319	if (context == null) {
	320	debug.println("domain (context is null)");
	321	} else {
	322	for (int i=0; i< context.length; i++) {
	323	debug.println("domain "+i+" "+context[i]);
	324	}
	325	}
	326	}
	327	}
	328
	329	/*
	330	* iterate through the ProtectionDomains in the context.
	331	* Stop at the first one that doesn't allow the
	332	* requested permission (throwing an exception).
	333	*
	334	*/
	335
	336	/* if ctxt is null, all we had on the stack were system domains,
	337	or the first domain was a Privileged system domain. This
	338	is to make the common case for system code very fast */
	339
	340	if (context == null)
	341	return;
	342
	343	for (int i=0; i< context.length; i++) {
	344	if (context[i] != null && !context[i].implies(perm)) {
	345	if (dumpDebug) {
	346	debug.println("access denied " + perm);
	347	}
	348
	349	if (Debug.isOn("failure") && debug != null) {
	350	// Want to make sure this is always displayed for failure,
	351	// but do not want to display again if already displayed
	352	// above.
	353	if (!dumpDebug) {
	354	debug.println("access denied " + perm);
	355	}
	356	Thread.currentThread().dumpStack();
	357	final ProtectionDomain pd = context[i];
	358	final Debug db = debug;
	359	AccessController.doPrivileged (new PrivilegedAction<Void>() {
	360	public Void run() {
	361	db.println("domain that failed "+pd);
	362	return null;
	363	}
	364	});
	365	}
	366	throw new AccessControlException("access denied "+perm, perm);
	367	}
	368	}
	369
	370	// allow if all of them allowed access
	371	if (dumpDebug) {
	372	debug.println("access allowed "+perm);
	373	}
	374
	375	return;
	376	}
	377
	378	/**
	379	* Take the stack-based context (this) and combine it with the
	380	* privileged or inherited context, if need be.
	381	*/
	382	AccessControlContext optimize() {
	383	// the assigned (privileged or inherited) context
	384	AccessControlContext acc;
	385	if (isPrivileged) {
	386	acc = privilegedContext;
	387	} else {
	388	acc = AccessController.getInheritedAccessControlContext();
	389	}
	390
	391	// this.context could be null if only system code is on the stack;
	392	// in that case, ignore the stack context
	393	boolean skipStack = (context == null);
	394
	395	// acc.context could be null if only system code was involved;
	396	// in that case, ignore the assigned context
	397	boolean skipAssigned = (acc == null \|\| acc.context == null);
	398
	399	if (acc != null && acc.combiner != null) {
	400	// let the assigned acc's combiner do its thing
	401	return goCombiner(context, acc);
	402	}
	403
	404	// optimization: if neither have contexts; return acc if possible
	405	// rather than this, because acc might have a combiner
	406	if (skipAssigned && skipStack) {
	407	return this;
	408	}
	409
	410	// optimization: if there is no stack context; there is no reason
	411	// to compress the assigned context, it already is compressed
	412	if (skipStack) {
	413	return acc;
	414	}
	415
	416	int slen = context.length;
	417
	418	// optimization: if there is no assigned context and the stack length
	419	// is less then or equal to two; there is no reason to compress the
	420	// stack context, it already is
	421	if (skipAssigned && slen <= 2) {
	422	return this;
	423	}
	424
	425	// optimization: if there is a single stack domain and that domain
	426	// is already in the assigned context; no need to combine
	427	if ((slen == 1) && (context[0] == acc.context[0])) {
	428	return acc;
	429	}
	430
	431	int n = (skipAssigned) ? 0 : acc.context.length;
	432
	433	// now we combine both of them, and create a new context
	434	ProtectionDomain pd[] = new ProtectionDomain[slen + n];
	435
	436	// first copy in the assigned context domains, no need to compress
	437	if (!skipAssigned) {
	438	System.arraycopy(acc.context, 0, pd, 0, n);
	439	}
	440
	441	// now add the stack context domains, discarding nulls and duplicates
	442	outer:
	443	for (int i = 0; i < context.length; i++) {
	444	ProtectionDomain sd = context[i];
	445	if (sd != null) {
	446	for (int j = 0; j < n; j++) {
	447	if (sd == pd[j]) {
	448	continue outer;
	449	}
	450	}
	451	pd[n++] = sd;
	452	}
	453	}
	454
	455	// if length isn't equal, we need to shorten the array
	456	if (n != pd.length) {
	457	// optimization: if we didn't really combine anything
	458	if (!skipAssigned && n == acc.context.length) {
	459	return acc;
	460	} else if (skipAssigned && n == slen) {
	461	return this;
	462	}
	463	ProtectionDomain tmp[] = new ProtectionDomain[n];
	464	System.arraycopy(pd, 0, tmp, 0, n);
	465	pd = tmp;
	466	}
	467
	468	// return new AccessControlContext(pd, false);
	469
	470	// Reuse existing ACC
	471
	472	this.context = pd;
	473	this.combiner = null;
	474	this.isPrivileged = false;
	475
	476	return this;
	477	}
	478
	479	private AccessControlContext goCombiner(ProtectionDomain[] current,
	480	AccessControlContext assigned) {
	481
	482	// the assigned ACC's combiner is not null --
	483	// let the combiner do its thing
	484
	485	// XXX we could add optimizations to 'current' here ...
	486
	487	if (getDebug() != null) {
	488	debug.println("AccessControlContext invoking the Combiner");
	489	}
	490
	491	// No need to clone current and assigned.context
	492	// combine() will not update them
	493	ProtectionDomain[] combinedPds = assigned.combiner.combine(
	494	current, assigned.context);
	495
	496	// return new AccessControlContext(combinedPds, assigned.combiner);
	497
	498	// Reuse existing ACC
	499	this.context = combinedPds;
	500	this.combiner = assigned.combiner;
	501	this.isPrivileged = false;
	502
	503	return this;
	504	}
	505
	506	/**
	507	* Checks two AccessControlContext objects for equality.
	508	* Checks that <i>obj</i> is
	509	* an AccessControlContext and has the same set of ProtectionDomains
	510	* as this context.
	511	* <P>
	512	* @param obj the object we are testing for equality with this object.
	513	* @return true if <i>obj</i> is an AccessControlContext, and has the
	514	* same set of ProtectionDomains as this context, false otherwise.
	515	*/
	516	public boolean equals(Object obj) {
	517	if (obj == this)
	518	return true;
	519
	520	if (! (obj instanceof AccessControlContext))
	521	return false;
	522
	523	AccessControlContext that = (AccessControlContext) obj;
	524
	525
	526	if (context == null) {
	527	return (that.context == null);
	528	}
	529
	530	if (that.context == null)
	531	return false;
	532
	533	if (!(this.containsAllPDs(that) && that.containsAllPDs(this)))
	534	return false;
	535
	536	if (this.combiner == null)
	537	return (that.combiner == null);
	538
	539	if (that.combiner == null)
	540	return false;
	541
	542	if (!this.combiner.equals(that.combiner))
	543	return false;
	544
	545	return true;
	546	}
	547
	548	private boolean containsAllPDs(AccessControlContext that) {
	549	boolean match = false;
	550	//
	551	// ProtectionDomains within an ACC currently cannot be null
	552	// and this is enforced by the constructor and the various
	553	// optimize methods. However, historically this logic made attempts
	554	// to support the notion of a null PD and therefore this logic continues
	555	// to support that notion.
	556	ProtectionDomain thisPd;
	557	for (int i = 0; i < context.length; i++) {
	558	match = false;
	559	if ((thisPd = context[i]) == null) {
	560	for (int j = 0; (j < that.context.length) && !match; j++) {
	561	match = (that.context[j] == null);
	562	}
	563	} else {
	564	Class thisPdClass = thisPd.getClass();
	565	ProtectionDomain thatPd;
	566	for (int j = 0; (j < that.context.length) && !match; j++) {
	567	thatPd = that.context[j];
	568
	569	// Class check required to avoid PD exposure (4285406)
	570	match = (thatPd != null &&
	571	thisPdClass == thatPd.getClass() && thisPd.equals(thatPd));
	572	}
	573	}
	574	if (!match) return false;
	575	}
	576	return match;
	577	}
	578	/**
	579	* Returns the hash code value for this context. The hash code
	580	* is computed by exclusive or-ing the hash code of all the protection
	581	* domains in the context together.
	582	*
	583	* @return a hash code value for this context.
	584	*/
	585
	586	public int hashCode() {
	587	int hashCode = 0;
	588
	589	if (context == null)
	590	return hashCode;
	591
	592	for (int i =0; i < context.length; i++) {
	593	if (context[i] != null)
	594	hashCode ^= context[i].hashCode();
	595	}
	596	return hashCode;
	597	}
	598	}

java/pkg/java/security/AccessControlException.class+0−0

Binary file not shown.

java/pkg/java/security/AccessControlException.java+82−0

@@ -0,0 +1,82 @@
	1	/*
	2	* Copyright (c) 1997, 2003, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	/**
	29	* <p> This exception is thrown by the AccessController to indicate
	30	* that a requested access (to a critical system resource such as the
	31	* file system or the network) is denied.
	32	*
	33	* <p> The reason to deny access can vary. For example, the requested
	34	* permission might be of an incorrect type, contain an invalid
	35	* value, or request access that is not allowed according to the
	36	* security policy. Such information should be given whenever
	37	* possible at the time the exception is thrown.
	38	*
	39	* @author Li Gong
	40	* @author Roland Schemers
	41	*/
	42
	43	public class AccessControlException extends SecurityException {
	44
	45	private static final long serialVersionUID = 5138225684096988535L;
	46
	47	// the permission that caused the exeception to be thrown.
	48	private Permission perm;
	49
	50	/**
	51	* Constructs an <code>AccessControlException</code> with the
	52	* specified, detailed message.
	53	*
	54	* @param s the detail message.
	55	*/
	56	public AccessControlException(String s) {
	57	super(s);
	58	}
	59
	60	/**
	61	* Constructs an <code>AccessControlException</code> with the
	62	* specified, detailed message, and the requested permission that caused
	63	* the exception.
	64	*
	65	* @param s the detail message.
	66	* @param p the permission that caused the exception.
	67	*/
	68	public AccessControlException(String s, Permission p) {
	69	super(s);
	70	perm = p;
	71	}
	72
	73	/**
	74	* Gets the Permission object associated with this exeception, or
	75	* null if there was no corresponding Permission object.
	76	*
	77	* @return the Permission object.
	78	*/
	79	public Permission getPermission() {
	80	return perm;
	81	}
	82	}

java/pkg/java/security/AccessController$1.class+0−0

Binary file not shown.

java/pkg/java/security/AccessController.class+0−0

Binary file not shown.

java/pkg/java/security/AccessController.java+557−0

@@ -0,0 +1,557 @@
	1	/*
	2	* Copyright (c) 1997, 2007, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import sun.security.util.Debug;
	29
	30	/**
	31	* <p> The AccessController class is used for access control operations
	32	* and decisions.
	33	*
	34	* <p> More specifically, the AccessController class is used for
	35	* three purposes:
	36	*
	37	* <ul>
	38	* <li> to decide whether an access to a critical system
	39	* resource is to be allowed or denied, based on the security policy
	40	* currently in effect,<p>
	41	* <li>to mark code as being "privileged", thus affecting subsequent
	42	* access determinations, and<p>
	43	* <li>to obtain a "snapshot" of the current calling context so
	44	* access-control decisions from a different context can be made with
	45	* respect to the saved context. </ul>
	46	*
	47	* <p> The {@link #checkPermission(Permission) checkPermission} method
	48	* determines whether the access request indicated by a specified
	49	* permission should be granted or denied. A sample call appears
	50	* below. In this example, <code>checkPermission</code> will determine
	51	* whether or not to grant "read" access to the file named "testFile" in
	52	* the "/temp" directory.
	53	*
	54	* <pre>
	55	*
	56	* FilePermission perm = new FilePermission("/temp/testFile", "read");
	57	* AccessController.checkPermission(perm);
	58	*
	59	* </pre>
	60	*
	61	* <p> If a requested access is allowed,
	62	* <code>checkPermission</code> returns quietly. If denied, an
	63	* AccessControlException is
	64	* thrown. AccessControlException can also be thrown if the requested
	65	* permission is of an incorrect type or contains an invalid value.
	66	* Such information is given whenever possible.
	67	*
	68	* Suppose the current thread traversed m callers, in the order of caller 1
	69	* to caller 2 to caller m. Then caller m invoked the
	70	* <code>checkPermission</code> method.
	71	* The <code>checkPermission </code>method determines whether access
	72	* is granted or denied based on the following algorithm:
	73	*
	74	* <pre> {@code
	75	* for (int i = m; i > 0; i--) {
	76	*
	77	* if (caller i's domain does not have the permission)
	78	* throw AccessControlException
	79	*
	80	* else if (caller i is marked as privileged) {
	81	* if (a context was specified in the call to doPrivileged)
	82	* context.checkPermission(permission)
	83	* return;
	84	* }
	85	* };
	86	*
	87	* // Next, check the context inherited when the thread was created.
	88	* // Whenever a new thread is created, the AccessControlContext at
	89	* // that time is stored and associated with the new thread, as the
	90	* // "inherited" context.
	91	*
	92	* inheritedContext.checkPermission(permission);
	93	* }</pre>
	94	*
	95	* <p> A caller can be marked as being "privileged"
	96	* (see {@link #doPrivileged(PrivilegedAction) doPrivileged} and below).
	97	* When making access control decisions, the <code>checkPermission</code>
	98	* method stops checking if it reaches a caller that
	99	* was marked as "privileged" via a <code>doPrivileged</code>
	100	* call without a context argument (see below for information about a
	101	* context argument). If that caller's domain has the
	102	* specified permission, no further checking is done and
	103	* <code>checkPermission</code>
	104	* returns quietly, indicating that the requested access is allowed.
	105	* If that domain does not have the specified permission, an exception
	106	* is thrown, as usual.
	107	*
	108	* <p> The normal use of the "privileged" feature is as follows. If you
	109	* don't need to return a value from within the "privileged" block, do
	110	* the following:
	111	*
	112	* <pre> {@code
	113	* somemethod() {
	114	* ...normal code here...
	115	* AccessController.doPrivileged(new PrivilegedAction<Void>() {
	116	* public Void run() {
	117	* // privileged code goes here, for example:
	118	* System.loadLibrary("awt");
	119	* return null; // nothing to return
	120	* }
	121	* });
	122	* ...normal code here...
	123	* }}</pre>
	124	*
	125	* <p>
	126	* PrivilegedAction is an interface with a single method, named
	127	* <code>run</code>.
	128	* The above example shows creation of an implementation
	129	* of that interface; a concrete implementation of the
	130	* <code>run</code> method is supplied.
	131	* When the call to <code>doPrivileged</code> is made, an
	132	* instance of the PrivilegedAction implementation is passed
	133	* to it. The <code>doPrivileged</code> method calls the
	134	* <code>run</code> method from the PrivilegedAction
	135	* implementation after enabling privileges, and returns the
	136	* <code>run</code> method's return value as the
	137	* <code>doPrivileged</code> return value (which is
	138	* ignored in this example).
	139	*
	140	* <p> If you need to return a value, you can do something like the following:
	141	*
	142	* <pre> {@code
	143	* somemethod() {
	144	* ...normal code here...
	145	* String user = AccessController.doPrivileged(
	146	* new PrivilegedAction<String>() {
	147	* public String run() {
	148	* return System.getProperty("user.name");
	149	* }
	150	* });
	151	* ...normal code here...
	152	* }}</pre>
	153	*
	154	* <p>If the action performed in your <code>run</code> method could
	155	* throw a "checked" exception (those listed in the <code>throws</code> clause
	156	* of a method), then you need to use the
	157	* <code>PrivilegedExceptionAction</code> interface instead of the
	158	* <code>PrivilegedAction</code> interface:
	159	*
	160	* <pre> {@code
	161	* somemethod() throws FileNotFoundException {
	162	* ...normal code here...
	163	* try {
	164	* FileInputStream fis = AccessController.doPrivileged(
	165	* new PrivilegedExceptionAction<FileInputStream>() {
	166	* public FileInputStream run() throws FileNotFoundException {
	167	* return new FileInputStream("someFile");
	168	* }
	169	* });
	170	* } catch (PrivilegedActionException e) {
	171	* // e.getException() should be an instance of FileNotFoundException,
	172	* // as only "checked" exceptions will be "wrapped" in a
	173	* // PrivilegedActionException.
	174	* throw (FileNotFoundException) e.getException();
	175	* }
	176	* ...normal code here...
	177	* }}</pre>
	178	*
	179	* <p> Be very careful in your use of the "privileged" construct, and
	180	* always remember to make the privileged code section as small as possible.
	181	*
	182	* <p> Note that <code>checkPermission</code> always performs security checks
	183	* within the context of the currently executing thread.
	184	* Sometimes a security check that should be made within a given context
	185	* will actually need to be done from within a
	186	* <i>different</i> context (for example, from within a worker thread).
	187	* The {@link #getContext() getContext} method and
	188	* AccessControlContext class are provided
	189	* for this situation. The <code>getContext</code> method takes a "snapshot"
	190	* of the current calling context, and places
	191	* it in an AccessControlContext object, which it returns. A sample call is
	192	* the following:
	193	*
	194	* <pre>
	195	*
	196	* AccessControlContext acc = AccessController.getContext()
	197	*
	198	* </pre>
	199	*
	200	* <p>
	201	* AccessControlContext itself has a <code>checkPermission</code> method
	202	* that makes access decisions based on the context <i>it</i> encapsulates,
	203	* rather than that of the current execution thread.
	204	* Code within a different context can thus call that method on the
	205	* previously-saved AccessControlContext object. A sample call is the
	206	* following:
	207	*
	208	* <pre>
	209	*
	210	* acc.checkPermission(permission)
	211	*
	212	* </pre>
	213	*
	214	* <p> There are also times where you don't know a priori which permissions
	215	* to check the context against. In these cases you can use the
	216	* doPrivileged method that takes a context:
	217	*
	218	* <pre> {@code
	219	* somemethod() {
	220	* AccessController.doPrivileged(new PrivilegedAction<Object>() {
	221	* public Object run() {
	222	* // Code goes here. Any permission checks within this
	223	* // run method will require that the intersection of the
	224	* // callers protection domain and the snapshot's
	225	* // context have the desired permission.
	226	* }
	227	* }, acc);
	228	* ...normal code here...
	229	* }}</pre>
	230	*
	231	* @see AccessControlContext
	232	*
	233	* @author Li Gong
	234	* @author Roland Schemers
	235	*/
	236
	237	public final class AccessController {
	238
	239	/**
	240	* Don't allow anyone to instantiate an AccessController
	241	*/
	242	private AccessController() { }
	243
	244	/**
	245	* Performs the specified <code>PrivilegedAction</code> with privileges
	246	* enabled. The action is performed with <i>all</i> of the permissions
	247	* possessed by the caller's protection domain.
	248	*
	249	* <p> If the action's <code>run</code> method throws an (unchecked)
	250	* exception, it will propagate through this method.
	251	*
	252	* <p> Note that any DomainCombiner associated with the current
	253	* AccessControlContext will be ignored while the action is performed.
	254	*
	255	* @param action the action to be performed.
	256	*
	257	* @return the value returned by the action's <code>run</code> method.
	258	*
	259	* @exception NullPointerException if the action is <code>null</code>
	260	*
	261	* @see #doPrivileged(PrivilegedAction,AccessControlContext)
	262	* @see #doPrivileged(PrivilegedExceptionAction)
	263	* @see #doPrivilegedWithCombiner(PrivilegedAction)
	264	* @see java.security.DomainCombiner
	265	*/
	266
	267	public static native <T> T doPrivileged(PrivilegedAction<T> action);
	268
	269	/**
	270	* Performs the specified <code>PrivilegedAction</code> with privileges
	271	* enabled. The action is performed with <i>all</i> of the permissions
	272	* possessed by the caller's protection domain.
	273	*
	274	* <p> If the action's <code>run</code> method throws an (unchecked)
	275	* exception, it will propagate through this method.
	276	*
	277	* <p> This method preserves the current AccessControlContext's
	278	* DomainCombiner (which may be null) while the action is performed.
	279	*
	280	* @param action the action to be performed.
	281	*
	282	* @return the value returned by the action's <code>run</code> method.
	283	*
	284	* @exception NullPointerException if the action is <code>null</code>
	285	*
	286	* @see #doPrivileged(PrivilegedAction)
	287	* @see java.security.DomainCombiner
	288	*
	289	* @since 1.6
	290	*/
	291	public static <T> T doPrivilegedWithCombiner(PrivilegedAction<T> action) {
	292
	293	DomainCombiner dc = null;
	294	AccessControlContext acc = getStackAccessControlContext();
	295	if (acc == null \|\| (dc = acc.getAssignedCombiner()) == null) {
	296	return AccessController.doPrivileged(action);
	297	}
	298	return AccessController.doPrivileged(action, preserveCombiner(dc));
	299	}
	300
	301
	302	/**
	303	* Performs the specified <code>PrivilegedAction</code> with privileges
	304	* enabled and restricted by the specified
	305	* <code>AccessControlContext</code>.
	306	* The action is performed with the intersection of the permissions
	307	* possessed by the caller's protection domain, and those possessed
	308	* by the domains represented by the specified
	309	* <code>AccessControlContext</code>.
	310	* <p>
	311	* If the action's <code>run</code> method throws an (unchecked) exception,
	312	* it will propagate through this method.
	313	*
	314	* @param action the action to be performed.
	315	* @param context an <i>access control context</i>
	316	* representing the restriction to be applied to the
	317	* caller's domain's privileges before performing
	318	* the specified action. If the context is
	319	* <code>null</code>,
	320	* then no additional restriction is applied.
	321	*
	322	* @return the value returned by the action's <code>run</code> method.
	323	*
	324	* @exception NullPointerException if the action is <code>null</code>
	325	*
	326	* @see #doPrivileged(PrivilegedAction)
	327	* @see #doPrivileged(PrivilegedExceptionAction,AccessControlContext)
	328	*/
	329	public static native <T> T doPrivileged(PrivilegedAction<T> action,
	330	AccessControlContext context);
	331
	332	/**
	333	* Performs the specified <code>PrivilegedExceptionAction</code> with
	334	* privileges enabled. The action is performed with <i>all</i> of the
	335	* permissions possessed by the caller's protection domain.
	336	*
	337	* <p> If the action's <code>run</code> method throws an <i>unchecked</i>
	338	* exception, it will propagate through this method.
	339	*
	340	* <p> Note that any DomainCombiner associated with the current
	341	* AccessControlContext will be ignored while the action is performed.
	342	*
	343	* @param action the action to be performed
	344	*
	345	* @return the value returned by the action's <code>run</code> method
	346	*
	347	* @exception PrivilegedActionException if the specified action's
	348	* <code>run</code> method threw a <i>checked</i> exception
	349	* @exception NullPointerException if the action is <code>null</code>
	350	*
	351	* @see #doPrivileged(PrivilegedAction)
	352	* @see #doPrivileged(PrivilegedExceptionAction,AccessControlContext)
	353	* @see #doPrivilegedWithCombiner(PrivilegedExceptionAction)
	354	* @see java.security.DomainCombiner
	355	*/
	356	public static native <T> T
	357	doPrivileged(PrivilegedExceptionAction<T> action)
	358	throws PrivilegedActionException;
	359
	360
	361	/**
	362	* Performs the specified <code>PrivilegedExceptionAction</code> with
	363	* privileges enabled. The action is performed with <i>all</i> of the
	364	* permissions possessed by the caller's protection domain.
	365	*
	366	* <p> If the action's <code>run</code> method throws an <i>unchecked</i>
	367	* exception, it will propagate through this method.
	368	*
	369	* <p> This method preserves the current AccessControlContext's
	370	* DomainCombiner (which may be null) while the action is performed.
	371	*
	372	* @param action the action to be performed.
	373	*
	374	* @return the value returned by the action's <code>run</code> method
	375	*
	376	* @exception PrivilegedActionException if the specified action's
	377	* <code>run</code> method threw a <i>checked</i> exception
	378	* @exception NullPointerException if the action is <code>null</code>
	379	*
	380	* @see #doPrivileged(PrivilegedAction)
	381	* @see #doPrivileged(PrivilegedExceptionAction,AccessControlContext)
	382	* @see java.security.DomainCombiner
	383	*
	384	* @since 1.6
	385	*/
	386	public static <T> T doPrivilegedWithCombiner
	387	(PrivilegedExceptionAction<T> action) throws PrivilegedActionException {
	388
	389	DomainCombiner dc = null;
	390	AccessControlContext acc = getStackAccessControlContext();
	391	if (acc == null \|\| (dc = acc.getAssignedCombiner()) == null) {
	392	return AccessController.doPrivileged(action);
	393	}
	394	return AccessController.doPrivileged(action, preserveCombiner(dc));
	395	}
	396
	397	/**
	398	* preserve the combiner across the doPrivileged call
	399	*/
	400	private static AccessControlContext preserveCombiner
	401	(DomainCombiner combiner) {
	402
	403	/**
	404	* callerClass[0] = Reflection.getCallerClass
	405	* callerClass[1] = AccessController.preserveCombiner
	406	* callerClass[2] = AccessController.doPrivileged
	407	* callerClass[3] = caller
	408	*/
	409	final Class callerClass = sun.reflect.Reflection.getCallerClass(3);
	410	ProtectionDomain callerPd = doPrivileged
	411	(new PrivilegedAction<ProtectionDomain>() {
	412	public ProtectionDomain run() {
	413	return callerClass.getProtectionDomain();
	414	}
	415	});
	416
	417	// perform 'combine' on the caller of doPrivileged,
	418	// even if the caller is from the bootclasspath
	419	ProtectionDomain[] pds = new ProtectionDomain[] {callerPd};
	420	return new AccessControlContext(combiner.combine(pds, null), combiner);
	421	}
	422
	423
	424	/**
	425	* Performs the specified <code>PrivilegedExceptionAction</code> with
	426	* privileges enabled and restricted by the specified
	427	* <code>AccessControlContext</code>. The action is performed with the
	428	* intersection of the permissions possessed by the caller's
	429	* protection domain, and those possessed by the domains represented by the
	430	* specified <code>AccessControlContext</code>.
	431	* <p>
	432	* If the action's <code>run</code> method throws an <i>unchecked</i>
	433	* exception, it will propagate through this method.
	434	*
	435	* @param action the action to be performed
	436	* @param context an <i>access control context</i>
	437	* representing the restriction to be applied to the
	438	* caller's domain's privileges before performing
	439	* the specified action. If the context is
	440	* <code>null</code>,
	441	* then no additional restriction is applied.
	442	*
	443	* @return the value returned by the action's <code>run</code> method
	444	*
	445	* @exception PrivilegedActionException if the specified action's
	446	* <code>run</code> method
	447	* threw a <i>checked</i> exception
	448	* @exception NullPointerException if the action is <code>null</code>
	449	*
	450	* @see #doPrivileged(PrivilegedAction)
	451	* @see #doPrivileged(PrivilegedExceptionAction,AccessControlContext)
	452	*/
	453	public static native <T> T
	454	doPrivileged(PrivilegedExceptionAction<T> action,
	455	AccessControlContext context)
	456	throws PrivilegedActionException;
	457
	458	/**
	459	* Returns the AccessControl context. i.e., it gets
	460	* the protection domains of all the callers on the stack,
	461	* starting at the first class with a non-null
	462	* ProtectionDomain.
	463	*
	464	* @return the access control context based on the current stack or
	465	* null if there was only privileged system code.
	466	*/
	467
	468	private static native AccessControlContext getStackAccessControlContext();
	469
	470	/**
	471	* Returns the "inherited" AccessControl context. This is the context
	472	* that existed when the thread was created. Package private so
	473	* AccessControlContext can use it.
	474	*/
	475
	476	static native AccessControlContext getInheritedAccessControlContext();
	477
	478	/**
	479	* This method takes a "snapshot" of the current calling context, which
	480	* includes the current Thread's inherited AccessControlContext,
	481	* and places it in an AccessControlContext object. This context may then
	482	* be checked at a later point, possibly in another thread.
	483	*
	484	* @see AccessControlContext
	485	*
	486	* @return the AccessControlContext based on the current context.
	487	*/
	488
	489	public static AccessControlContext getContext()
	490	{
	491	AccessControlContext acc = getStackAccessControlContext();
	492	if (acc == null) {
	493	// all we had was privileged system code. We don't want
	494	// to return null though, so we construct a real ACC.
	495	return new AccessControlContext(null, true);
	496	} else {
	497	return acc.optimize();
	498	}
	499	}
	500
	501	/**
	502	* Determines whether the access request indicated by the
	503	* specified permission should be allowed or denied, based on
	504	* the current AccessControlContext and security policy.
	505	* This method quietly returns if the access request
	506	* is permitted, or throws an AccessControlException otherwise. The
	507	* getPermission method of the AccessControlException returns the
	508	* <code>perm</code> Permission object instance.
	509	*
	510	* @param perm the requested permission.
	511	*
	512	* @exception AccessControlException if the specified permission
	513	* is not permitted, based on the current security policy.
	514	* @exception NullPointerException if the specified permission
	515	* is <code>null</code> and is checked based on the
	516	* security policy currently in effect.
	517	*/
	518
	519	public static void checkPermission(Permission perm)
	520	throws AccessControlException
	521	{
	522	//System.err.println("checkPermission "+perm);
	523	//Thread.currentThread().dumpStack();
	524
	525	if (perm == null) {
	526	throw new NullPointerException("permission can't be null");
	527	}
	528
	529	AccessControlContext stack = getStackAccessControlContext();
	530	// if context is null, we had privileged system code on the stack.
	531	if (stack == null) {
	532	Debug debug = AccessControlContext.getDebug();
	533	boolean dumpDebug = false;
	534	if (debug != null) {
	535	dumpDebug = !Debug.isOn("codebase=");
	536	dumpDebug &= !Debug.isOn("permission=") \|\|
	537	Debug.isOn("permission=" + perm.getClass().getCanonicalName());
	538	}
	539
	540	if (dumpDebug && Debug.isOn("stack")) {
	541	Thread.currentThread().dumpStack();
	542	}
	543
	544	if (dumpDebug && Debug.isOn("domain")) {
	545	debug.println("domain (context is null)");
	546	}
	547
	548	if (dumpDebug) {
	549	debug.println("access allowed "+perm);
	550	}
	551	return;
	552	}
	553
	554	AccessControlContext acc = stack.optimize();
	555	acc.checkPermission(perm);
	556	}
	557	}

java/pkg/java/security/AlgorithmConstraints.class+0−0

Binary file not shown.

java/pkg/java/security/AlgorithmConstraints.java+108−0

@@ -0,0 +1,108 @@
	1	/*
	2	* Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.util.Set;
	29
	30	/**
	31	* This interface specifies constraints for cryptographic algorithms,
	32	* keys (key sizes), and other algorithm parameters.
	33	* <p>
	34	* {@code AlgorithmConstraints} objects are immutable. An implementation
	35	* of this interface should not provide methods that can change the state
	36	* of an instance once it has been created.
	37	* <p>
	38	* Note that {@code AlgorithmConstraints} can be used to represent the
	39	* restrictions described by the security properties
	40	* {@code jdk.certpath.disabledAlgorithms} and
	41	* {@code jdk.tls.disabledAlgorithms}, or could be used by a
	42	* concrete {@code PKIXCertPathChecker} to check whether a specified
	43	* certificate in the certification path contains the required algorithm
	44	* constraints.
	45	*
	46	* @see javax.net.ssl.SSLParameters#getAlgorithmConstraints
	47	* @see javax.net.ssl.SSLParameters#setAlgorithmConstraints(AlgorithmConstraints)
	48	*
	49	* @since 1.7
	50	*/
	51
	52	public interface AlgorithmConstraints {
	53
	54	/**
	55	* Determines whether an algorithm is granted permission for the
	56	* specified cryptographic primitives.
	57	*
	58	* @param primitives a set of cryptographic primitives
	59	* @param algorithm the algorithm name
	60	* @param parameters the algorithm parameters, or null if no additional
	61	* parameters
	62	*
	63	* @return true if the algorithm is permitted and can be used for all
	64	* of the specified cryptographic primitives
	65	*
	66	* @throws IllegalArgumentException if primitives or algorithm is null
	67	* or empty
	68	*/
	69	public boolean permits(Set<CryptoPrimitive> primitives,
	70	String algorithm, AlgorithmParameters parameters);
	71
	72	/**
	73	* Determines whether a key is granted permission for the specified
	74	* cryptographic primitives.
	75	* <p>
	76	* This method is usually used to check key size and key usage.
	77	*
	78	* @param primitives a set of cryptographic primitives
	79	* @param key the key
	80	*
	81	* @return true if the key can be used for all of the specified
	82	* cryptographic primitives
	83	*
	84	* @throws IllegalArgumentException if primitives is null or empty,
	85	* or the key is null
	86	*/
	87	public boolean permits(Set<CryptoPrimitive> primitives, Key key);
	88
	89	/**
	90	* Determines whether an algorithm and the corresponding key are granted
	91	* permission for the specified cryptographic primitives.
	92	*
	93	* @param primitives a set of cryptographic primitives
	94	* @param algorithm the algorithm name
	95	* @param key the key
	96	* @param parameters the algorithm parameters, or null if no additional
	97	* parameters
	98	*
	99	* @return true if the key and the algorithm can be used for all of the
	100	* specified cryptographic primitives
	101	*
	102	* @throws IllegalArgumentException if primitives or algorithm is null
	103	* or empty, or the key is null
	104	*/
	105	public boolean permits(Set<CryptoPrimitive> primitives,
	106	String algorithm, Key key, AlgorithmParameters parameters);
	107
	108	}

java/pkg/java/security/AlgorithmParameterGenerator.class+0−0

Binary file not shown.

java/pkg/java/security/AlgorithmParameterGenerator.java+343−0

@@ -0,0 +1,343 @@
	1	/*
	2	* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.security.spec.AlgorithmParameterSpec;
	29
	30	/**
	31	* The <code>AlgorithmParameterGenerator</code> class is used to generate a
	32	* set of
	33	* parameters to be used with a certain algorithm. Parameter generators
	34	* are constructed using the <code>getInstance</code> factory methods
	35	* (static methods that return instances of a given class).
	36	*
	37	* <P>The object that will generate the parameters can be initialized
	38	* in two different ways: in an algorithm-independent manner, or in an
	39	* algorithm-specific manner:
	40	*
	41	* <ul>
	42	* <li>The algorithm-independent approach uses the fact that all parameter
	43	* generators share the concept of a "size" and a
	44	* source of randomness. The measure of size is universally shared
	45	* by all algorithm parameters, though it is interpreted differently
	46	* for different algorithms. For example, in the case of parameters for
	47	* the <i>DSA</i> algorithm, "size" corresponds to the size
	48	* of the prime modulus (in bits).
	49	* When using this approach, algorithm-specific parameter generation
	50	* values - if any - default to some standard values, unless they can be
	51	* derived from the specified size.<P>
	52	*
	53	* <li>The other approach initializes a parameter generator object
	54	* using algorithm-specific semantics, which are represented by a set of
	55	* algorithm-specific parameter generation values. To generate
	56	* Diffie-Hellman system parameters, for example, the parameter generation
	57	* values usually
	58	* consist of the size of the prime modulus and the size of the
	59	* random exponent, both specified in number of bits.
	60	* </ul>
	61	*
	62	* <P>In case the client does not explicitly initialize the
	63	* AlgorithmParameterGenerator
	64	* (via a call to an <code>init</code> method), each provider must supply (and
	65	* document) a default initialization. For example, the Sun provider uses a
	66	* default modulus prime size of 1024 bits for the generation of DSA
	67	* parameters.
	68	*
	69	* <p> Every implementation of the Java platform is required to support the
	70	* following standard <code>AlgorithmParameterGenerator</code> algorithms and
	71	* keysizes in parentheses:
	72	* <ul>
	73	* <li><tt>DiffieHellman</tt> (1024)</li>
	74	* <li><tt>DSA</tt> (1024)</li>
	75	* </ul>
	76	* These algorithms are described in the <a href=
	77	* "{@docRoot}/../technotes/guides/security/StandardNames.html#AlgorithmParameterGenerator">
	78	* AlgorithmParameterGenerator section</a> of the
	79	* Java Cryptography Architecture Standard Algorithm Name Documentation.
	80	* Consult the release documentation for your implementation to see if any
	81	* other algorithms are supported.
	82	*
	83	* @author Jan Luehe
	84	*
	85	*
	86	* @see AlgorithmParameters
	87	* @see java.security.spec.AlgorithmParameterSpec
	88	*
	89	* @since 1.2
	90	*/
	91
	92	public class AlgorithmParameterGenerator {
	93
	94	// The provider
	95	private Provider provider;
	96
	97	// The provider implementation (delegate)
	98	private AlgorithmParameterGeneratorSpi paramGenSpi;
	99
	100	// The algorithm
	101	private String algorithm;
	102
	103	/**
	104	* Creates an AlgorithmParameterGenerator object.
	105	*
	106	* @param paramGenSpi the delegate
	107	* @param provider the provider
	108	* @param algorithm the algorithm
	109	*/
	110	protected AlgorithmParameterGenerator
	111	(AlgorithmParameterGeneratorSpi paramGenSpi, Provider provider,
	112	String algorithm) {
	113	this.paramGenSpi = paramGenSpi;
	114	this.provider = provider;
	115	this.algorithm = algorithm;
	116	}
	117
	118	/**
	119	* Returns the standard name of the algorithm this parameter
	120	* generator is associated with.
	121	*
	122	* @return the string name of the algorithm.
	123	*/
	124	public final String getAlgorithm() {
	125	return this.algorithm;
	126	}
	127
	128	/**
	129	* Returns an AlgorithmParameterGenerator object for generating
	130	* a set of parameters to be used with the specified algorithm.
	131	*
	132	* <p> This method traverses the list of registered security Providers,
	133	* starting with the most preferred Provider.
	134	* A new AlgorithmParameterGenerator object encapsulating the
	135	* AlgorithmParameterGeneratorSpi implementation from the first
	136	* Provider that supports the specified algorithm is returned.
	137	*
	138	* <p> Note that the list of registered providers may be retrieved via
	139	* the {@link Security#getProviders() Security.getProviders()} method.
	140	*
	141	* @param algorithm the name of the algorithm this
	142	* parameter generator is associated with.
	143	* See the AlgorithmParameterGenerator section in the <a href=
	144	* "{@docRoot}/../technotes/guides/security/StandardNames.html#AlgorithmParameterGenerator">
	145	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	146	* for information about standard algorithm names.
	147	*
	148	* @return the new AlgorithmParameterGenerator object.
	149	*
	150	* @exception NoSuchAlgorithmException if no Provider supports an
	151	* AlgorithmParameterGeneratorSpi implementation for the
	152	* specified algorithm.
	153	*
	154	* @see Provider
	155	*/
	156	public static AlgorithmParameterGenerator getInstance(String algorithm)
	157	throws NoSuchAlgorithmException {
	158	try {
	159	Object[] objs = Security.getImpl(algorithm,
	160	"AlgorithmParameterGenerator",
	161	(String)null);
	162	return new AlgorithmParameterGenerator
	163	((AlgorithmParameterGeneratorSpi)objs[0],
	164	(Provider)objs[1],
	165	algorithm);
	166	} catch(NoSuchProviderException e) {
	167	throw new NoSuchAlgorithmException(algorithm + " not found");
	168	}
	169	}
	170
	171	/**
	172	* Returns an AlgorithmParameterGenerator object for generating
	173	* a set of parameters to be used with the specified algorithm.
	174	*
	175	* <p> A new AlgorithmParameterGenerator object encapsulating the
	176	* AlgorithmParameterGeneratorSpi implementation from the specified provider
	177	* is returned. The specified provider must be registered
	178	* in the security provider list.
	179	*
	180	* <p> Note that the list of registered providers may be retrieved via
	181	* the {@link Security#getProviders() Security.getProviders()} method.
	182	*
	183	* @param algorithm the name of the algorithm this
	184	* parameter generator is associated with.
	185	* See the AlgorithmParameterGenerator section in the <a href=
	186	* "{@docRoot}/../technotes/guides/security/StandardNames.html#AlgorithmParameterGenerator">
	187	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	188	* for information about standard algorithm names.
	189	*
	190	* @param provider the string name of the Provider.
	191	*
	192	* @return the new AlgorithmParameterGenerator object.
	193	*
	194	* @exception NoSuchAlgorithmException if an AlgorithmParameterGeneratorSpi
	195	* implementation for the specified algorithm is not
	196	* available from the specified provider.
	197	*
	198	* @exception NoSuchProviderException if the specified provider is not
	199	* registered in the security provider list.
	200	*
	201	* @exception IllegalArgumentException if the provider name is null
	202	* or empty.
	203	*
	204	* @see Provider
	205	*/
	206	public static AlgorithmParameterGenerator getInstance(String algorithm,
	207	String provider)
	208	throws NoSuchAlgorithmException, NoSuchProviderException
	209	{
	210	if (provider == null \|\| provider.length() == 0)
	211	throw new IllegalArgumentException("missing provider");
	212	Object[] objs = Security.getImpl(algorithm,
	213	"AlgorithmParameterGenerator",
	214	provider);
	215	return new AlgorithmParameterGenerator
	216	((AlgorithmParameterGeneratorSpi)objs[0], (Provider)objs[1],
	217	algorithm);
	218	}
	219
	220	/**
	221	* Returns an AlgorithmParameterGenerator object for generating
	222	* a set of parameters to be used with the specified algorithm.
	223	*
	224	* <p> A new AlgorithmParameterGenerator object encapsulating the
	225	* AlgorithmParameterGeneratorSpi implementation from the specified Provider
	226	* object is returned. Note that the specified Provider object
	227	* does not have to be registered in the provider list.
	228	*
	229	* @param algorithm the string name of the algorithm this
	230	* parameter generator is associated with.
	231	* See the AlgorithmParameterGenerator section in the <a href=
	232	* "{@docRoot}/../technotes/guides/security/StandardNames.html#AlgorithmParameterGenerator">
	233	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	234	* for information about standard algorithm names.
	235	*
	236	* @param provider the Provider object.
	237	*
	238	* @return the new AlgorithmParameterGenerator object.
	239	*
	240	* @exception NoSuchAlgorithmException if an AlgorithmParameterGeneratorSpi
	241	* implementation for the specified algorithm is not available
	242	* from the specified Provider object.
	243	*
	244	* @exception IllegalArgumentException if the specified provider is null.
	245	*
	246	* @see Provider
	247	*
	248	* @since 1.4
	249	*/
	250	public static AlgorithmParameterGenerator getInstance(String algorithm,
	251	Provider provider)
	252	throws NoSuchAlgorithmException
	253	{
	254	if (provider == null)
	255	throw new IllegalArgumentException("missing provider");
	256	Object[] objs = Security.getImpl(algorithm,
	257	"AlgorithmParameterGenerator",
	258	provider);
	259	return new AlgorithmParameterGenerator
	260	((AlgorithmParameterGeneratorSpi)objs[0], (Provider)objs[1],
	261	algorithm);
	262	}
	263
	264	/**
	265	* Returns the provider of this algorithm parameter generator object.
	266	*
	267	* @return the provider of this algorithm parameter generator object
	268	*/
	269	public final Provider getProvider() {
	270	return this.provider;
	271	}
	272
	273	/**
	274	* Initializes this parameter generator for a certain size.
	275	* To create the parameters, the <code>SecureRandom</code>
	276	* implementation of the highest-priority installed provider is used as
	277	* the source of randomness.
	278	* (If none of the installed providers supply an implementation of
	279	* <code>SecureRandom</code>, a system-provided source of randomness is
	280	* used.)
	281	*
	282	* @param size the size (number of bits).
	283	*/
	284	public final void init(int size) {
	285	paramGenSpi.engineInit(size, new SecureRandom());
	286	}
	287
	288	/**
	289	* Initializes this parameter generator for a certain size and source
	290	* of randomness.
	291	*
	292	* @param size the size (number of bits).
	293	* @param random the source of randomness.
	294	*/
	295	public final void init(int size, SecureRandom random) {
	296	paramGenSpi.engineInit(size, random);
	297	}
	298
	299	/**
	300	* Initializes this parameter generator with a set of algorithm-specific
	301	* parameter generation values.
	302	* To generate the parameters, the <code>SecureRandom</code>
	303	* implementation of the highest-priority installed provider is used as
	304	* the source of randomness.
	305	* (If none of the installed providers supply an implementation of
	306	* <code>SecureRandom</code>, a system-provided source of randomness is
	307	* used.)
	308	*
	309	* @param genParamSpec the set of algorithm-specific parameter generation values.
	310	*
	311	* @exception InvalidAlgorithmParameterException if the given parameter
	312	* generation values are inappropriate for this parameter generator.
	313	*/
	314	public final void init(AlgorithmParameterSpec genParamSpec)
	315	throws InvalidAlgorithmParameterException {
	316	paramGenSpi.engineInit(genParamSpec, new SecureRandom());
	317	}
	318
	319	/**
	320	* Initializes this parameter generator with a set of algorithm-specific
	321	* parameter generation values.
	322	*
	323	* @param genParamSpec the set of algorithm-specific parameter generation values.
	324	* @param random the source of randomness.
	325	*
	326	* @exception InvalidAlgorithmParameterException if the given parameter
	327	* generation values are inappropriate for this parameter generator.
	328	*/
	329	public final void init(AlgorithmParameterSpec genParamSpec,
	330	SecureRandom random)
	331	throws InvalidAlgorithmParameterException {
	332	paramGenSpi.engineInit(genParamSpec, random);
	333	}
	334
	335	/**
	336	* Generates the parameters.
	337	*
	338	* @return the new AlgorithmParameters object.
	339	*/
	340	public final AlgorithmParameters generateParameters() {
	341	return paramGenSpi.engineGenerateParameters();
	342	}
	343	}

java/pkg/java/security/AlgorithmParameterGeneratorSpi.class+0−0

Binary file not shown.

java/pkg/java/security/AlgorithmParameterGeneratorSpi.java+86−0

@@ -0,0 +1,86 @@
	1	/*
	2	* Copyright (c) 1997, 1999, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.security.spec.AlgorithmParameterSpec;
	29
	30	/**
	31	* This class defines the <i>Service Provider Interface</i> (<b>SPI</b>)
	32	* for the <code>AlgorithmParameterGenerator</code> class, which
	33	* is used to generate a set of parameters to be used with a certain algorithm.
	34	*
	35	* <p> All the abstract methods in this class must be implemented by each
	36	* cryptographic service provider who wishes to supply the implementation
	37	* of a parameter generator for a particular algorithm.
	38	*
	39	* <p> In case the client does not explicitly initialize the
	40	* AlgorithmParameterGenerator (via a call to an <code>engineInit</code>
	41	* method), each provider must supply (and document) a default initialization.
	42	* For example, the Sun provider uses a default modulus prime size of 1024
	43	* bits for the generation of DSA parameters.
	44	*
	45	* @author Jan Luehe
	46	*
	47	*
	48	* @see AlgorithmParameterGenerator
	49	* @see AlgorithmParameters
	50	* @see java.security.spec.AlgorithmParameterSpec
	51	*
	52	* @since 1.2
	53	*/
	54
	55	public abstract class AlgorithmParameterGeneratorSpi {
	56
	57	/**
	58	* Initializes this parameter generator for a certain size
	59	* and source of randomness.
	60	*
	61	* @param size the size (number of bits).
	62	* @param random the source of randomness.
	63	*/
	64	protected abstract void engineInit(int size, SecureRandom random);
	65
	66	/**
	67	* Initializes this parameter generator with a set of
	68	* algorithm-specific parameter generation values.
	69	*
	70	* @param genParamSpec the set of algorithm-specific parameter generation values.
	71	* @param random the source of randomness.
	72	*
	73	* @exception InvalidAlgorithmParameterException if the given parameter
	74	* generation values are inappropriate for this parameter generator.
	75	*/
	76	protected abstract void engineInit(AlgorithmParameterSpec genParamSpec,
	77	SecureRandom random)
	78	throws InvalidAlgorithmParameterException;
	79
	80	/**
	81	* Generates the parameters.
	82	*
	83	* @return the new AlgorithmParameters object.
	84	*/
	85	protected abstract AlgorithmParameters engineGenerateParameters();
	86	}

java/pkg/java/security/AlgorithmParameters.class+0−0

Binary file not shown.

java/pkg/java/security/AlgorithmParameters.java+398−0

@@ -0,0 +1,398 @@
	1	/*
	2	* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.io.*;
	29	import java.security.spec.AlgorithmParameterSpec;
	30	import java.security.spec.InvalidParameterSpecException;
	31
	32	/**
	33	* This class is used as an opaque representation of cryptographic parameters.
	34	*
	35	* <p>An <code>AlgorithmParameters</code> object for managing the parameters
	36	* for a particular algorithm can be obtained by
	37	* calling one of the <code>getInstance</code> factory methods
	38	* (static methods that return instances of a given class).
	39	*
	40	* <p>Once an <code>AlgorithmParameters</code> object is obtained, it must be
	41	* initialized via a call to <code>init</code>, using an appropriate parameter
	42	* specification or parameter encoding.
	43	*
	44	* <p>A transparent parameter specification is obtained from an
	45	* <code>AlgorithmParameters</code> object via a call to
	46	* <code>getParameterSpec</code>, and a byte encoding of the parameters is
	47	* obtained via a call to <code>getEncoded</code>.
	48	*
	49	* <p> Every implementation of the Java platform is required to support the
	50	* following standard <code>AlgorithmParameters</code> algorithms:
	51	* <ul>
	52	* <li><tt>AES</tt></li>
	53	* <li><tt>DES</tt></li>
	54	* <li><tt>DESede</tt></li>
	55	* <li><tt>DiffieHellman</tt></li>
	56	* <li><tt>DSA</tt></li>
	57	* </ul>
	58	* These algorithms are described in the <a href=
	59	* "{@docRoot}/../technotes/guides/security/StandardNames.html#AlgorithmParameters">
	60	* AlgorithmParameters section</a> of the
	61	* Java Cryptography Architecture Standard Algorithm Name Documentation.
	62	* Consult the release documentation for your implementation to see if any
	63	* other algorithms are supported.
	64	*
	65	* @author Jan Luehe
	66	*
	67	*
	68	* @see java.security.spec.AlgorithmParameterSpec
	69	* @see java.security.spec.DSAParameterSpec
	70	* @see KeyPairGenerator
	71	*
	72	* @since 1.2
	73	*/
	74
	75	public class AlgorithmParameters {
	76
	77	// The provider
	78	private Provider provider;
	79
	80	// The provider implementation (delegate)
	81	private AlgorithmParametersSpi paramSpi;
	82
	83	// The algorithm
	84	private String algorithm;
	85
	86	// Has this object been initialized?
	87	private boolean initialized = false;
	88
	89	/**
	90	* Creates an AlgorithmParameters object.
	91	*
	92	* @param paramSpi the delegate
	93	* @param provider the provider
	94	* @param algorithm the algorithm
	95	*/
	96	protected AlgorithmParameters(AlgorithmParametersSpi paramSpi,
	97	Provider provider, String algorithm)
	98	{
	99	this.paramSpi = paramSpi;
	100	this.provider = provider;
	101	this.algorithm = algorithm;
	102	}
	103
	104	/**
	105	* Returns the name of the algorithm associated with this parameter object.
	106	*
	107	* @return the algorithm name.
	108	*/
	109	public final String getAlgorithm() {
	110	return this.algorithm;
	111	}
	112
	113	/**
	114	* Returns a parameter object for the specified algorithm.
	115	*
	116	* <p> This method traverses the list of registered security Providers,
	117	* starting with the most preferred Provider.
	118	* A new AlgorithmParameters object encapsulating the
	119	* AlgorithmParametersSpi implementation from the first
	120	* Provider that supports the specified algorithm is returned.
	121	*
	122	* <p> Note that the list of registered providers may be retrieved via
	123	* the {@link Security#getProviders() Security.getProviders()} method.
	124	*
	125	* <p> The returned parameter object must be initialized via a call to
	126	* <code>init</code>, using an appropriate parameter specification or
	127	* parameter encoding.
	128	*
	129	* @param algorithm the name of the algorithm requested.
	130	* See the AlgorithmParameters section in the <a href=
	131	* "{@docRoot}/../technotes/guides/security/StandardNames.html#AlgorithmParameters">
	132	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	133	* for information about standard algorithm names.
	134	*
	135	* @return the new parameter object.
	136	*
	137	* @exception NoSuchAlgorithmException if no Provider supports an
	138	* AlgorithmParametersSpi implementation for the
	139	* specified algorithm.
	140	*
	141	* @see Provider
	142	*/
	143	public static AlgorithmParameters getInstance(String algorithm)
	144	throws NoSuchAlgorithmException {
	145	try {
	146	Object[] objs = Security.getImpl(algorithm, "AlgorithmParameters",
	147	(String)null);
	148	return new AlgorithmParameters((AlgorithmParametersSpi)objs[0],
	149	(Provider)objs[1],
	150	algorithm);
	151	} catch(NoSuchProviderException e) {
	152	throw new NoSuchAlgorithmException(algorithm + " not found");
	153	}
	154	}
	155
	156	/**
	157	* Returns a parameter object for the specified algorithm.
	158	*
	159	* <p> A new AlgorithmParameters object encapsulating the
	160	* AlgorithmParametersSpi implementation from the specified provider
	161	* is returned. The specified provider must be registered
	162	* in the security provider list.
	163	*
	164	* <p> Note that the list of registered providers may be retrieved via
	165	* the {@link Security#getProviders() Security.getProviders()} method.
	166	*
	167	* <p>The returned parameter object must be initialized via a call to
	168	* <code>init</code>, using an appropriate parameter specification or
	169	* parameter encoding.
	170	*
	171	* @param algorithm the name of the algorithm requested.
	172	* See the AlgorithmParameters section in the <a href=
	173	* "{@docRoot}/../technotes/guides/security/StandardNames.html#AlgorithmParameters">
	174	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	175	* for information about standard algorithm names.
	176	*
	177	* @param provider the name of the provider.
	178	*
	179	* @return the new parameter object.
	180	*
	181	* @exception NoSuchAlgorithmException if an AlgorithmParametersSpi
	182	* implementation for the specified algorithm is not
	183	* available from the specified provider.
	184	*
	185	* @exception NoSuchProviderException if the specified provider is not
	186	* registered in the security provider list.
	187	*
	188	* @exception IllegalArgumentException if the provider name is null
	189	* or empty.
	190	*
	191	* @see Provider
	192	*/
	193	public static AlgorithmParameters getInstance(String algorithm,
	194	String provider)
	195	throws NoSuchAlgorithmException, NoSuchProviderException
	196	{
	197	if (provider == null \|\| provider.length() == 0)
	198	throw new IllegalArgumentException("missing provider");
	199	Object[] objs = Security.getImpl(algorithm, "AlgorithmParameters",
	200	provider);
	201	return new AlgorithmParameters((AlgorithmParametersSpi)objs[0],
	202	(Provider)objs[1],
	203	algorithm);
	204	}
	205
	206	/**
	207	* Returns a parameter object for the specified algorithm.
	208	*
	209	* <p> A new AlgorithmParameters object encapsulating the
	210	* AlgorithmParametersSpi implementation from the specified Provider
	211	* object is returned. Note that the specified Provider object
	212	* does not have to be registered in the provider list.
	213	*
	214	* <p>The returned parameter object must be initialized via a call to
	215	* <code>init</code>, using an appropriate parameter specification or
	216	* parameter encoding.
	217	*
	218	* @param algorithm the name of the algorithm requested.
	219	* See the AlgorithmParameters section in the <a href=
	220	* "{@docRoot}/../technotes/guides/security/StandardNames.html#AlgorithmParameters">
	221	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	222	* for information about standard algorithm names.
	223	*
	224	* @param provider the name of the provider.
	225	*
	226	* @return the new parameter object.
	227	*
	228	* @exception NoSuchAlgorithmException if an AlgorithmParameterGeneratorSpi
	229	* implementation for the specified algorithm is not available
	230	* from the specified Provider object.
	231	*
	232	* @exception IllegalArgumentException if the provider is null.
	233	*
	234	* @see Provider
	235	*
	236	* @since 1.4
	237	*/
	238	public static AlgorithmParameters getInstance(String algorithm,
	239	Provider provider)
	240	throws NoSuchAlgorithmException
	241	{
	242	if (provider == null)
	243	throw new IllegalArgumentException("missing provider");
	244	Object[] objs = Security.getImpl(algorithm, "AlgorithmParameters",
	245	provider);
	246	return new AlgorithmParameters((AlgorithmParametersSpi)objs[0],
	247	(Provider)objs[1],
	248	algorithm);
	249	}
	250
	251	/**
	252	* Returns the provider of this parameter object.
	253	*
	254	* @return the provider of this parameter object
	255	*/
	256	public final Provider getProvider() {
	257	return this.provider;
	258	}
	259
	260	/**
	261	* Initializes this parameter object using the parameters
	262	* specified in <code>paramSpec</code>.
	263	*
	264	* @param paramSpec the parameter specification.
	265	*
	266	* @exception InvalidParameterSpecException if the given parameter
	267	* specification is inappropriate for the initialization of this parameter
	268	* object, or if this parameter object has already been initialized.
	269	*/
	270	public final void init(AlgorithmParameterSpec paramSpec)
	271	throws InvalidParameterSpecException
	272	{
	273	if (this.initialized)
	274	throw new InvalidParameterSpecException("already initialized");
	275	paramSpi.engineInit(paramSpec);
	276	this.initialized = true;
	277	}
	278
	279	/**
	280	* Imports the specified parameters and decodes them according to the
	281	* primary decoding format for parameters. The primary decoding
	282	* format for parameters is ASN.1, if an ASN.1 specification for this type
	283	* of parameters exists.
	284	*
	285	* @param params the encoded parameters.
	286	*
	287	* @exception IOException on decoding errors, or if this parameter object
	288	* has already been initialized.
	289	*/
	290	public final void init(byte[] params) throws IOException {
	291	if (this.initialized)
	292	throw new IOException("already initialized");
	293	paramSpi.engineInit(params);
	294	this.initialized = true;
	295	}
	296
	297	/**
	298	* Imports the parameters from <code>params</code> and decodes them
	299	* according to the specified decoding scheme.
	300	* If <code>format</code> is null, the
	301	* primary decoding format for parameters is used. The primary decoding
	302	* format is ASN.1, if an ASN.1 specification for these parameters
	303	* exists.
	304	*
	305	* @param params the encoded parameters.
	306	*
	307	* @param format the name of the decoding scheme.
	308	*
	309	* @exception IOException on decoding errors, or if this parameter object
	310	* has already been initialized.
	311	*/
	312	public final void init(byte[] params, String format) throws IOException {
	313	if (this.initialized)
	314	throw new IOException("already initialized");
	315	paramSpi.engineInit(params, format);
	316	this.initialized = true;
	317	}
	318
	319	/**
	320	* Returns a (transparent) specification of this parameter object.
	321	* <code>paramSpec</code> identifies the specification class in which
	322	* the parameters should be returned. It could, for example, be
	323	* <code>DSAParameterSpec.class</code>, to indicate that the
	324	* parameters should be returned in an instance of the
	325	* <code>DSAParameterSpec</code> class.
	326	*
	327	* @param paramSpec the specification class in which
	328	* the parameters should be returned.
	329	*
	330	* @return the parameter specification.
	331	*
	332	* @exception InvalidParameterSpecException if the requested parameter
	333	* specification is inappropriate for this parameter object, or if this
	334	* parameter object has not been initialized.
	335	*/
	336	public final <T extends AlgorithmParameterSpec>
	337	T getParameterSpec(Class<T> paramSpec)
	338	throws InvalidParameterSpecException
	339	{
	340	if (this.initialized == false) {
	341	throw new InvalidParameterSpecException("not initialized");
	342	}
	343	return paramSpi.engineGetParameterSpec(paramSpec);
	344	}
	345
	346	/**
	347	* Returns the parameters in their primary encoding format.
	348	* The primary encoding format for parameters is ASN.1, if an ASN.1
	349	* specification for this type of parameters exists.
	350	*
	351	* @return the parameters encoded using their primary encoding format.
	352	*
	353	* @exception IOException on encoding errors, or if this parameter object
	354	* has not been initialized.
	355	*/
	356	public final byte[] getEncoded() throws IOException
	357	{
	358	if (this.initialized == false) {
	359	throw new IOException("not initialized");
	360	}
	361	return paramSpi.engineGetEncoded();
	362	}
	363
	364	/**
	365	* Returns the parameters encoded in the specified scheme.
	366	* If <code>format</code> is null, the
	367	* primary encoding format for parameters is used. The primary encoding
	368	* format is ASN.1, if an ASN.1 specification for these parameters
	369	* exists.
	370	*
	371	* @param format the name of the encoding format.
	372	*
	373	* @return the parameters encoded using the specified encoding scheme.
	374	*
	375	* @exception IOException on encoding errors, or if this parameter object
	376	* has not been initialized.
	377	*/
	378	public final byte[] getEncoded(String format) throws IOException
	379	{
	380	if (this.initialized == false) {
	381	throw new IOException("not initialized");
	382	}
	383	return paramSpi.engineGetEncoded(format);
	384	}
	385
	386	/**
	387	* Returns a formatted string describing the parameters.
	388	*
	389	* @return a formatted string describing the parameters, or null if this
	390	* parameter object has not been initialized.
	391	*/
	392	public final String toString() {
	393	if (this.initialized == false) {
	394	return null;
	395	}
	396	return paramSpi.engineToString();
	397	}
	398	}

java/pkg/java/security/AlgorithmParametersSpi.class+0−0

Binary file not shown.

java/pkg/java/security/AlgorithmParametersSpi.java+151−0

@@ -0,0 +1,151 @@
	1	/*
	2	* Copyright (c) 1997, 2004, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.io.*;
	29	import java.security.spec.AlgorithmParameterSpec;
	30	import java.security.spec.InvalidParameterSpecException;
	31
	32	/**
	33	* This class defines the <i>Service Provider Interface</i> (<b>SPI</b>)
	34	* for the <code>AlgorithmParameters</code> class, which is used to manage
	35	* algorithm parameters.
	36	*
	37	* <p> All the abstract methods in this class must be implemented by each
	38	* cryptographic service provider who wishes to supply parameter management
	39	* for a particular algorithm.
	40	*
	41	* @author Jan Luehe
	42	*
	43	*
	44	* @see AlgorithmParameters
	45	* @see java.security.spec.AlgorithmParameterSpec
	46	* @see java.security.spec.DSAParameterSpec
	47	*
	48	* @since 1.2
	49	*/
	50
	51	public abstract class AlgorithmParametersSpi {
	52
	53	/**
	54	* Initializes this parameters object using the parameters
	55	* specified in <code>paramSpec</code>.
	56	*
	57	* @param paramSpec the parameter specification.
	58	*
	59	* @exception InvalidParameterSpecException if the given parameter
	60	* specification is inappropriate for the initialization of this parameter
	61	* object.
	62	*/
	63	protected abstract void engineInit(AlgorithmParameterSpec paramSpec)
	64	throws InvalidParameterSpecException;
	65
	66	/**
	67	* Imports the specified parameters and decodes them
	68	* according to the primary decoding format for parameters.
	69	* The primary decoding format for parameters is ASN.1, if an ASN.1
	70	* specification for this type of parameters exists.
	71	*
	72	* @param params the encoded parameters.
	73	*
	74	* @exception IOException on decoding errors
	75	*/
	76	protected abstract void engineInit(byte[] params)
	77	throws IOException;
	78
	79	/**
	80	* Imports the parameters from <code>params</code> and
	81	* decodes them according to the specified decoding format.
	82	* If <code>format</code> is null, the
	83	* primary decoding format for parameters is used. The primary decoding
	84	* format is ASN.1, if an ASN.1 specification for these parameters
	85	* exists.
	86	*
	87	* @param params the encoded parameters.
	88	*
	89	* @param format the name of the decoding format.
	90	*
	91	* @exception IOException on decoding errors
	92	*/
	93	protected abstract void engineInit(byte[] params, String format)
	94	throws IOException;
	95
	96	/**
	97	* Returns a (transparent) specification of this parameters
	98	* object.
	99	* <code>paramSpec</code> identifies the specification class in which
	100	* the parameters should be returned. It could, for example, be
	101	* <code>DSAParameterSpec.class</code>, to indicate that the
	102	* parameters should be returned in an instance of the
	103	* <code>DSAParameterSpec</code> class.
	104	*
	105	* @param paramSpec the specification class in which
	106	* the parameters should be returned.
	107	*
	108	* @return the parameter specification.
	109	*
	110	* @exception InvalidParameterSpecException if the requested parameter
	111	* specification is inappropriate for this parameter object.
	112	*/
	113	protected abstract
	114	<T extends AlgorithmParameterSpec>
	115	T engineGetParameterSpec(Class<T> paramSpec)
	116	throws InvalidParameterSpecException;
	117
	118	/**
	119	* Returns the parameters in their primary encoding format.
	120	* The primary encoding format for parameters is ASN.1, if an ASN.1
	121	* specification for this type of parameters exists.
	122	*
	123	* @return the parameters encoded using their primary encoding format.
	124	*
	125	* @exception IOException on encoding errors.
	126	*/
	127	protected abstract byte[] engineGetEncoded() throws IOException;
	128
	129	/**
	130	* Returns the parameters encoded in the specified format.
	131	* If <code>format</code> is null, the
	132	* primary encoding format for parameters is used. The primary encoding
	133	* format is ASN.1, if an ASN.1 specification for these parameters
	134	* exists.
	135	*
	136	* @param format the name of the encoding format.
	137	*
	138	* @return the parameters encoded using the specified encoding scheme.
	139	*
	140	* @exception IOException on encoding errors.
	141	*/
	142	protected abstract byte[] engineGetEncoded(String format)
	143	throws IOException;
	144
	145	/**
	146	* Returns a formatted string describing the parameters.
	147	*
	148	* @return a formatted string describing the parameters.
	149	*/
	150	protected abstract String engineToString();
	151	}

java/pkg/java/security/AllPermission.class+0−0

Binary file not shown.

java/pkg/java/security/AllPermission.java+237−0

@@ -0,0 +1,237 @@
	1	/*
	2	* Copyright (c) 1998, 2006, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.security.*;
	29	import java.util.Enumeration;
	30	import java.util.Hashtable;
	31	import java.util.StringTokenizer;
	32	import sun.security.util.SecurityConstants;
	33
	34	/**
	35	* The AllPermission is a permission that implies all other permissions.
	36	* <p>
	37	* <b>Note:</b> Granting AllPermission should be done with extreme care,
	38	* as it implies all other permissions. Thus, it grants code the ability
	39	* to run with security
	40	* disabled. Extreme caution should be taken before granting such
	41	* a permission to code. This permission should be used only during testing,
	42	* or in extremely rare cases where an application or applet is
	43	* completely trusted and adding the necessary permissions to the policy
	44	* is prohibitively cumbersome.
	45	*
	46	* @see java.security.Permission
	47	* @see java.security.AccessController
	48	* @see java.security.Permissions
	49	* @see java.security.PermissionCollection
	50	* @see java.lang.SecurityManager
	51	*
	52	*
	53	* @author Roland Schemers
	54	*
	55	* @serial exclude
	56	*/
	57
	58	public final class AllPermission extends Permission {
	59
	60	private static final long serialVersionUID = -2916474571451318075L;
	61
	62	/**
	63	* Creates a new AllPermission object.
	64	*/
	65
	66	public AllPermission()
	67	{
	68	super("<all permissions>");
	69	}
	70
	71
	72	/**
	73	* Creates a new AllPermission object. This
	74	* constructor exists for use by the <code>Policy</code> object
	75	* to instantiate new Permission objects.
	76	*
	77	* @param name ignored
	78	* @param actions ignored.
	79	*/
	80	public AllPermission(String name, String actions)
	81	{
	82	this();
	83	}
	84
	85	/**
	86	* Checks if the specified permission is "implied" by
	87	* this object. This method always returns true.
	88	*
	89	* @param p the permission to check against.
	90	*
	91	* @return return
	92	*/
	93	public boolean implies(Permission p) {
	94	return true;
	95	}
	96
	97	/**
	98	* Checks two AllPermission objects for equality. Two AllPermission
	99	* objects are always equal.
	100	*
	101	* @param obj the object we are testing for equality with this object.
	102	* @return true if <i>obj</i> is an AllPermission, false otherwise.
	103	*/
	104	public boolean equals(Object obj) {
	105	return (obj instanceof AllPermission);
	106	}
	107
	108	/**
	109	* Returns the hash code value for this object.
	110	*
	111	* @return a hash code value for this object.
	112	*/
	113
	114	public int hashCode() {
	115	return 1;
	116	}
	117
	118	/**
	119	* Returns the canonical string representation of the actions.
	120	*
	121	* @return the actions.
	122	*/
	123	public String getActions()
	124	{
	125	return "<all actions>";
	126	}
	127
	128	/**
	129	* Returns a new PermissionCollection object for storing AllPermission
	130	* objects.
	131	* <p>
	132	*
	133	* @return a new PermissionCollection object suitable for
	134	* storing AllPermissions.
	135	*/
	136
	137	public PermissionCollection newPermissionCollection() {
	138	return new AllPermissionCollection();
	139	}
	140
	141	}
	142
	143	/**
	144	* A AllPermissionCollection stores a collection
	145	* of AllPermission permissions. AllPermission objects
	146	* must be stored in a manner that allows them to be inserted in any
	147	* order, but enable the implies function to evaluate the implies
	148	* method in an efficient (and consistent) manner.
	149	*
	150	* @see java.security.Permission
	151	* @see java.security.Permissions
	152	*
	153	*
	154	* @author Roland Schemers
	155	*
	156	* @serial include
	157	*/
	158
	159	final class AllPermissionCollection
	160	extends PermissionCollection
	161	implements java.io.Serializable
	162	{
	163
	164	// use serialVersionUID from JDK 1.2.2 for interoperability
	165	private static final long serialVersionUID = -4023755556366636806L;
	166
	167	private boolean all_allowed; // true if any all permissions have been added
	168
	169	/**
	170	* Create an empty AllPermissions object.
	171	*
	172	*/
	173
	174	public AllPermissionCollection() {
	175	all_allowed = false;
	176	}
	177
	178	/**
	179	* Adds a permission to the AllPermissions. The key for the hash is
	180	* permission.path.
	181	*
	182	* @param permission the Permission object to add.
	183	*
	184	* @exception IllegalArgumentException - if the permission is not a
	185	* AllPermission
	186	*
	187	* @exception SecurityException - if this AllPermissionCollection object
	188	* has been marked readonly
	189	*/
	190
	191	public void add(Permission permission)
	192	{
	193	if (! (permission instanceof AllPermission))
	194	throw new IllegalArgumentException("invalid permission: "+
	195	permission);
	196	if (isReadOnly())
	197	throw new SecurityException("attempt to add a Permission to a readonly PermissionCollection");
	198
	199	all_allowed = true; // No sync; staleness OK
	200	}
	201
	202	/**
	203	* Check and see if this set of permissions implies the permissions
	204	* expressed in "permission".
	205	*
	206	* @param p the Permission object to compare
	207	*
	208	* @return always returns true.
	209	*/
	210
	211	public boolean implies(Permission permission)
	212	{
	213	return all_allowed; // No sync; staleness OK
	214	}
	215
	216	/**
	217	* Returns an enumeration of all the AllPermission objects in the
	218	* container.
	219	*
	220	* @return an enumeration of all the AllPermission objects.
	221	*/
	222	public Enumeration<Permission> elements()
	223	{
	224	return new Enumeration<Permission>() {
	225	private boolean hasMore = all_allowed;
	226
	227	public boolean hasMoreElements() {
	228	return hasMore;
	229	}
	230
	231	public Permission nextElement() {
	232	hasMore = false;
	233	return SecurityConstants.ALL_PERMISSION;
	234	}
	235	};
	236	}
	237	}

java/pkg/java/security/AllPermissionCollection$1.class+0−0

Binary file not shown.

java/pkg/java/security/AllPermissionCollection.class+0−0

Binary file not shown.

java/pkg/java/security/AuthProvider.class+0−0

Binary file not shown.

java/pkg/java/security/AuthProvider.java+126−0

@@ -0,0 +1,126 @@
	1	/*
	2	* Copyright (c) 2003, 2004, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import javax.security.auth.Subject;
	29	import javax.security.auth.login.LoginException;
	30	import javax.security.auth.callback.CallbackHandler;
	31
	32	/**
	33	* This class defines login and logout methods for a provider.
	34	*
	35	* <p> While callers may invoke <code>login</code> directly,
	36	* the provider may also invoke <code>login</code> on behalf of callers
	37	* if it determines that a login must be performed
	38	* prior to certain operations.
	39	*
	40	* @since 1.5
	41	*/
	42	public abstract class AuthProvider extends Provider {
	43
	44	/**
	45	* Constructs a provider with the specified name, version number,
	46	* and information.
	47	*
	48	* @param name the provider name.
	49	* @param version the provider version number.
	50	* @param info a description of the provider and its services.
	51	*/
	52	protected AuthProvider(String name, double version, String info) {
	53	super(name, version, info);
	54	}
	55
	56	/**
	57	* Log in to this provider.
	58	*
	59	* <p> The provider relies on a <code>CallbackHandler</code>
	60	* to obtain authentication information from the caller
	61	* (a PIN, for example). If the caller passes a <code>null</code>
	62	* handler to this method, the provider uses the handler set in the
	63	* <code>setCallbackHandler</code> method.
	64	* If no handler was set in that method, the provider queries the
	65	* <i>auth.login.defaultCallbackHandler</i> security property
	66	* for the fully qualified class name of a default handler implementation.
	67	* If the security property is not set,
	68	* the provider is assumed to have alternative means
	69	* for obtaining authentication information.
	70	*
	71	* @param subject the <code>Subject</code> which may contain
	72	* principals/credentials used for authentication,
	73	* or may be populated with additional principals/credentials
	74	* after successful authentication has completed.
	75	* This parameter may be <code>null</code>.
	76	* @param handler the <code>CallbackHandler</code> used by
	77	* this provider to obtain authentication information
	78	* from the caller, which may be <code>null</code>
	79	*
	80	* @exception LoginException if the login operation fails
	81	* @exception SecurityException if the caller does not pass a
	82	* security check for
	83	* <code>SecurityPermission("authProvider.<i>name</i>")</code>,
	84	* where <i>name</i> is the value returned by
	85	* this provider's <code>getName</code> method
	86	*/
	87	public abstract void login(Subject subject, CallbackHandler handler)
	88	throws LoginException;
	89
	90	/**
	91	* Log out from this provider.
	92	*
	93	* @exception LoginException if the logout operation fails
	94	* @exception SecurityException if the caller does not pass a
	95	* security check for
	96	* <code>SecurityPermission("authProvider.<i>name</i>")</code>,
	97	* where <i>name</i> is the value returned by
	98	* this provider's <code>getName</code> method
	99	*/
	100	public abstract void logout() throws LoginException;
	101
	102	/**
	103	* Set a <code>CallbackHandler</code>.
	104	*
	105	* <p> The provider uses this handler if one is not passed to the
	106	* <code>login</code> method. The provider also uses this handler
	107	* if it invokes <code>login</code> on behalf of callers.
	108	* In either case if a handler is not set via this method,
	109	* the provider queries the
	110	* <i>auth.login.defaultCallbackHandler</i> security property
	111	* for the fully qualified class name of a default handler implementation.
	112	* If the security property is not set,
	113	* the provider is assumed to have alternative means
	114	* for obtaining authentication information.
	115	*
	116	* @param handler a <code>CallbackHandler</code> for obtaining
	117	* authentication information, which may be <code>null</code>
	118	*
	119	* @exception SecurityException if the caller does not pass a
	120	* security check for
	121	* <code>SecurityPermission("authProvider.<i>name</i>")</code>,
	122	* where <i>name</i> is the value returned by
	123	* this provider's <code>getName</code> method
	124	*/
	125	public abstract void setCallbackHandler(CallbackHandler handler);
	126	}

java/pkg/java/security/BasicPermission.class+0−0

Binary file not shown.

java/pkg/java/security/BasicPermission.java+565−0

@@ -0,0 +1,565 @@
	1	/*
	2	* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.security.*;
	29	import java.util.Enumeration;
	30	import java.util.Map;
	31	import java.util.HashMap;
	32	import java.util.Hashtable;
	33	import java.util.Collections;
	34	import java.io.ObjectStreamField;
	35	import java.io.ObjectOutputStream;
	36	import java.io.ObjectInputStream;
	37	import java.io.IOException;
	38
	39	/**
	40	* The BasicPermission class extends the Permission class, and
	41	* can be used as the base class for permissions that want to
	42	* follow the same naming convention as BasicPermission.
	43	* <P>
	44	* The name for a BasicPermission is the name of the given permission
	45	* (for example, "exit",
	46	* "setFactory", "print.queueJob", etc). The naming
	47	* convention follows the hierarchical property naming convention.
	48	* An asterisk may appear by itself, or if immediately preceded by a "."
	49	* may appear at the end of the name, to signify a wildcard match.
	50	* For example, "" and "java." are valid, while "java", "ab",
	51	* and "java*" are not valid.
	52	* <P>
	53	* The action string (inherited from Permission) is unused.
	54	* Thus, BasicPermission is commonly used as the base class for
	55	* "named" permissions
	56	* (ones that contain a name but no actions list; you either have the
	57	* named permission or you don't.)
	58	* Subclasses may implement actions on top of BasicPermission,
	59	* if desired.
	60	* <p>
	61	* <P>
	62	* @see java.security.Permission
	63	* @see java.security.Permissions
	64	* @see java.security.PermissionCollection
	65	* @see java.lang.SecurityManager
	66	*
	67	* @author Marianne Mueller
	68	* @author Roland Schemers
	69	*/
	70
	71	public abstract class BasicPermission extends Permission
	72	implements java.io.Serializable
	73	{
	74
	75	private static final long serialVersionUID = 6279438298436773498L;
	76
	77	// does this permission have a wildcard at the end?
	78	private transient boolean wildcard;
	79
	80	// the name without the wildcard on the end
	81	private transient String path;
	82
	83	// is this permission the old-style exitVM permission (pre JDK 1.6)?
	84	private transient boolean exitVM;
	85
	86	/**
	87	* initialize a BasicPermission object. Common to all constructors.
	88	*
	89	*/
	90	private void init(String name)
	91	{
	92	if (name == null)
	93	throw new NullPointerException("name can't be null");
	94
	95	int len = name.length();
	96
	97	if (len == 0) {
	98	throw new IllegalArgumentException("name can't be empty");
	99	}
	100
	101	char last = name.charAt(len - 1);
	102
	103	// Is wildcard or ends with ".*"?
	104	if (last == '*' && (len == 1 \|\| name.charAt(len - 2) == '.')) {
	105	wildcard = true;
	106	if (len == 1) {
	107	path = "";
	108	} else {
	109	path = name.substring(0, len - 1);
	110	}
	111	} else {
	112	if (name.equals("exitVM")) {
	113	wildcard = true;
	114	path = "exitVM.";
	115	exitVM = true;
	116	} else {
	117	path = name;
	118	}
	119	}
	120	}
	121
	122	/**
	123	* Creates a new BasicPermission with the specified name.
	124	* Name is the symbolic name of the permission, such as
	125	* "setFactory",
	126	* "print.queueJob", or "topLevelWindow", etc.
	127	*
	128	* @param name the name of the BasicPermission.
	129	*
	130	* @throws NullPointerException if <code>name</code> is <code>null</code>.
	131	* @throws IllegalArgumentException if <code>name</code> is empty.
	132	*/
	133
	134	public BasicPermission(String name)
	135	{
	136	super(name);
	137	init(name);
	138	}
	139
	140
	141	/**
	142	* Creates a new BasicPermission object with the specified name.
	143	* The name is the symbolic name of the BasicPermission, and the
	144	* actions String is currently unused.
	145	*
	146	* @param name the name of the BasicPermission.
	147	* @param actions ignored.
	148	*
	149	* @throws NullPointerException if <code>name</code> is <code>null</code>.
	150	* @throws IllegalArgumentException if <code>name</code> is empty.
	151	*/
	152	public BasicPermission(String name, String actions)
	153	{
	154	super(name);
	155	init(name);
	156	}
	157
	158	/**
	159	* Checks if the specified permission is "implied" by
	160	* this object.
	161	* <P>
	162	* More specifically, this method returns true if:<p>
	163	* <ul>
	164	* <li> <i>p</i>'s class is the same as this object's class, and<p>
	165	* <li> <i>p</i>'s name equals or (in the case of wildcards)
	166	* is implied by this object's
	167	* name. For example, "a.b.*" implies "a.b.c".
	168	* </ul>
	169	*
	170	* @param p the permission to check against.
	171	*
	172	* @return true if the passed permission is equal to or
	173	* implied by this permission, false otherwise.
	174	*/
	175	public boolean implies(Permission p) {
	176	if ((p == null) \|\| (p.getClass() != getClass()))
	177	return false;
	178
	179	BasicPermission that = (BasicPermission) p;
	180
	181	if (this.wildcard) {
	182	if (that.wildcard) {
	183	// one wildcard can imply another
	184	return that.path.startsWith(path);
	185	} else {
	186	// make sure ap.path is longer so a.b.* doesn't imply a.b
	187	return (that.path.length() > this.path.length()) &&
	188	that.path.startsWith(this.path);
	189	}
	190	} else {
	191	if (that.wildcard) {
	192	// a non-wildcard can't imply a wildcard
	193	return false;
	194	}
	195	else {
	196	return this.path.equals(that.path);
	197	}
	198	}
	199	}
	200
	201	/**
	202	* Checks two BasicPermission objects for equality.
	203	* Checks that <i>obj</i>'s class is the same as this object's class
	204	* and has the same name as this object.
	205	* <P>
	206	* @param obj the object we are testing for equality with this object.
	207	* @return true if <i>obj</i>'s class is the same as this object's class
	208	* and has the same name as this BasicPermission object, false otherwise.
	209	*/
	210	public boolean equals(Object obj) {
	211	if (obj == this)
	212	return true;
	213
	214	if ((obj == null) \|\| (obj.getClass() != getClass()))
	215	return false;
	216
	217	BasicPermission bp = (BasicPermission) obj;
	218
	219	return getName().equals(bp.getName());
	220	}
	221
	222
	223	/**
	224	* Returns the hash code value for this object.
	225	* The hash code used is the hash code of the name, that is,
	226	* <code>getName().hashCode()</code>, where <code>getName</code> is
	227	* from the Permission superclass.
	228	*
	229	* @return a hash code value for this object.
	230	*/
	231	public int hashCode() {
	232	return this.getName().hashCode();
	233	}
	234
	235	/**
	236	* Returns the canonical string representation of the actions,
	237	* which currently is the empty string "", since there are no actions for
	238	* a BasicPermission.
	239	*
	240	* @return the empty string "".
	241	*/
	242	public String getActions()
	243	{
	244	return "";
	245	}
	246
	247	/**
	248	* Returns a new PermissionCollection object for storing BasicPermission
	249	* objects.
	250	*
	251	* <p>BasicPermission objects must be stored in a manner that allows them
	252	* to be inserted in any order, but that also enables the
	253	* PermissionCollection <code>implies</code> method
	254	* to be implemented in an efficient (and consistent) manner.
	255	*
	256	* @return a new PermissionCollection object suitable for
	257	* storing BasicPermissions.
	258	*/
	259	public PermissionCollection newPermissionCollection() {
	260	return new BasicPermissionCollection(this.getClass());
	261	}
	262
	263	/**
	264	* readObject is called to restore the state of the BasicPermission from
	265	* a stream.
	266	*/
	267	private void readObject(ObjectInputStream s)
	268	throws IOException, ClassNotFoundException
	269	{
	270	s.defaultReadObject();
	271	// init is called to initialize the rest of the values.
	272	init(getName());
	273	}
	274
	275	/**
	276	* Returns the canonical name of this BasicPermission.
	277	* All internal invocations of getName should invoke this method, so
	278	* that the pre-JDK 1.6 "exitVM" and current "exitVM.*" permission are
	279	* equivalent in equals/hashCode methods.
	280	*
	281	* @return the canonical name of this BasicPermission.
	282	*/
	283	final String getCanonicalName() {
	284	return exitVM ? "exitVM.*" : getName();
	285	}
	286	}
	287
	288	/**
	289	* A BasicPermissionCollection stores a collection
	290	* of BasicPermission permissions. BasicPermission objects
	291	* must be stored in a manner that allows them to be inserted in any
	292	* order, but enable the implies function to evaluate the implies
	293	* method in an efficient (and consistent) manner.
	294	*
	295	* A BasicPermissionCollection handles comparing a permission like "a.b.c.d.e"
	296	* with a Permission such as "a.b.", or "".
	297	*
	298	* @see java.security.Permission
	299	* @see java.security.Permissions
	300	* @see java.security.PermissionsImpl
	301	*
	302	*
	303	* @author Roland Schemers
	304	*
	305	* @serial include
	306	*/
	307
	308	final class BasicPermissionCollection
	309	extends PermissionCollection
	310	implements java.io.Serializable
	311	{
	312
	313	private static final long serialVersionUID = 739301742472979399L;
	314
	315	/**
	316	* Key is name, value is permission. All permission objects in
	317	* collection must be of the same type.
	318	* Not serialized; see serialization section at end of class.
	319	*/
	320	private transient Map<String, Permission> perms;
	321
	322	/**
	323	* This is set to <code>true</code> if this BasicPermissionCollection
	324	* contains a BasicPermission with '*' as its permission name.
	325	*
	326	* @see #serialPersistentFields
	327	*/
	328	private boolean all_allowed;
	329
	330	/**
	331	* The class to which all BasicPermissions in this
	332	* BasicPermissionCollection belongs.
	333	*
	334	* @see #serialPersistentFields
	335	*/
	336	private Class permClass;
	337
	338	/**
	339	* Create an empty BasicPermissionCollection object.
	340	*
	341	*/
	342
	343	public BasicPermissionCollection(Class clazz) {
	344	perms = new HashMap<String, Permission>(11);
	345	all_allowed = false;
	346	permClass = clazz;
	347	}
	348
	349	/**
	350	* Adds a permission to the BasicPermissions. The key for the hash is
	351	* permission.path.
	352	*
	353	* @param permission the Permission object to add.
	354	*
	355	* @exception IllegalArgumentException - if the permission is not a
	356	* BasicPermission, or if
	357	* the permission is not of the
	358	* same Class as the other
	359	* permissions in this collection.
	360	*
	361	* @exception SecurityException - if this BasicPermissionCollection object
	362	* has been marked readonly
	363	*/
	364
	365	public void add(Permission permission)
	366	{
	367	if (! (permission instanceof BasicPermission))
	368	throw new IllegalArgumentException("invalid permission: "+
	369	permission);
	370	if (isReadOnly())
	371	throw new SecurityException("attempt to add a Permission to a readonly PermissionCollection");
	372
	373	BasicPermission bp = (BasicPermission) permission;
	374
	375	// make sure we only add new BasicPermissions of the same class
	376	// Also check null for compatibility with deserialized form from
	377	// previous versions.
	378	if (permClass == null) {
	379	// adding first permission
	380	permClass = bp.getClass();
	381	} else {
	382	if (bp.getClass() != permClass)
	383	throw new IllegalArgumentException("invalid permission: " +
	384	permission);
	385	}
	386
	387	synchronized (this) {
	388	perms.put(bp.getCanonicalName(), permission);
	389	}
	390
	391	// No sync on all_allowed; staleness OK
	392	if (!all_allowed) {
	393	if (bp.getCanonicalName().equals("*"))
	394	all_allowed = true;
	395	}
	396	}
	397
	398	/**
	399	* Check and see if this set of permissions implies the permissions
	400	* expressed in "permission".
	401	*
	402	* @param p the Permission object to compare
	403	*
	404	* @return true if "permission" is a proper subset of a permission in
	405	* the set, false if not.
	406	*/
	407
	408	public boolean implies(Permission permission)
	409	{
	410	if (! (permission instanceof BasicPermission))
	411	return false;
	412
	413	BasicPermission bp = (BasicPermission) permission;
	414
	415	// random subclasses of BasicPermission do not imply each other
	416	if (bp.getClass() != permClass)
	417	return false;
	418
	419	// short circuit if the "*" Permission was added
	420	if (all_allowed)
	421	return true;
	422
	423	// strategy:
	424	// Check for full match first. Then work our way up the
	425	// path looking for matches on a.b..*
	426
	427	String path = bp.getCanonicalName();
	428	//System.out.println("check "+path);
	429
	430	Permission x;
	431
	432	synchronized (this) {
	433	x = perms.get(path);
	434	}
	435
	436	if (x != null) {
	437	// we have a direct hit!
	438	return x.implies(permission);
	439	}
	440
	441	// work our way up the tree...
	442	int last, offset;
	443
	444	offset = path.length()-1;
	445
	446	while ((last = path.lastIndexOf(".", offset)) != -1) {
	447
	448	path = path.substring(0, last+1) + "*";
	449	//System.out.println("check "+path);
	450
	451	synchronized (this) {
	452	x = perms.get(path);
	453	}
	454
	455	if (x != null) {
	456	return x.implies(permission);
	457	}
	458	offset = last -1;
	459	}
	460
	461	// we don't have to check for "*" as it was already checked
	462	// at the top (all_allowed), so we just return false
	463	return false;
	464	}
	465
	466	/**
	467	* Returns an enumeration of all the BasicPermission objects in the
	468	* container.
	469	*
	470	* @return an enumeration of all the BasicPermission objects.
	471	*/
	472
	473	public Enumeration<Permission> elements() {
	474	// Convert Iterator of Map values into an Enumeration
	475	synchronized (this) {
	476	return Collections.enumeration(perms.values());
	477	}
	478	}
	479
	480	// Need to maintain serialization interoperability with earlier releases,
	481	// which had the serializable field:
	482	//
	483	// @serial the Hashtable is indexed by the BasicPermission name
	484	//
	485	// private Hashtable permissions;
	486	/**
	487	* @serialField permissions java.util.Hashtable
	488	* The BasicPermissions in this BasicPermissionCollection.
	489	* All BasicPermissions in the collection must belong to the same class.
	490	* The Hashtable is indexed by the BasicPermission name; the value
	491	* of the Hashtable entry is the permission.
	492	* @serialField all_allowed boolean
	493	* This is set to <code>true</code> if this BasicPermissionCollection
	494	* contains a BasicPermission with '*' as its permission name.
	495	* @serialField permClass java.lang.Class
	496	* The class to which all BasicPermissions in this
	497	* BasicPermissionCollection belongs.
	498	*/
	499	private static final ObjectStreamField[] serialPersistentFields = {
	500	new ObjectStreamField("permissions", Hashtable.class),
	501	new ObjectStreamField("all_allowed", Boolean.TYPE),
	502	new ObjectStreamField("permClass", Class.class),
	503	};
	504
	505	/**
	506	* @serialData Default fields.
	507	*/
	508	/*
	509	* Writes the contents of the perms field out as a Hashtable for
	510	* serialization compatibility with earlier releases. all_allowed
	511	* and permClass unchanged.
	512	*/
	513	private void writeObject(ObjectOutputStream out) throws IOException {
	514	// Don't call out.defaultWriteObject()
	515
	516	// Copy perms into a Hashtable
	517	Hashtable<String, Permission> permissions =
	518	new Hashtable<>(perms.size()*2);
	519
	520	synchronized (this) {
	521	permissions.putAll(perms);
	522	}
	523
	524	// Write out serializable fields
	525	ObjectOutputStream.PutField pfields = out.putFields();
	526	pfields.put("all_allowed", all_allowed);
	527	pfields.put("permissions", permissions);
	528	pfields.put("permClass", permClass);
	529	out.writeFields();
	530	}
	531
	532	/**
	533	* readObject is called to restore the state of the
	534	* BasicPermissionCollection from a stream.
	535	*/
	536	private void readObject(java.io.ObjectInputStream in)
	537	throws IOException, ClassNotFoundException
	538	{
	539	// Don't call defaultReadObject()
	540
	541	// Read in serialized fields
	542	ObjectInputStream.GetField gfields = in.readFields();
	543
	544	// Get permissions
	545	Hashtable<String, Permission> permissions =
	546	(Hashtable<String, Permission>)gfields.get("permissions", null);
	547	perms = new HashMap<String, Permission>(permissions.size()*2);
	548	perms.putAll(permissions);
	549
	550	// Get all_allowed
	551	all_allowed = gfields.get("all_allowed", false);
	552
	553	// Get permClass
	554	permClass = (Class) gfields.get("permClass", null);
	555
	556	if (permClass == null) {
	557	// set permClass
	558	Enumeration<Permission> e = permissions.elements();
	559	if (e.hasMoreElements()) {
	560	Permission p = e.nextElement();
	561	permClass = p.getClass();
	562	}
	563	}
	564	}
	565	}

java/pkg/java/security/BasicPermissionCollection.class+0−0

Binary file not shown.

java/pkg/java/security/Certificate.class+0−0

Binary file not shown.

java/pkg/java/security/Certificate.java+156−0

@@ -0,0 +1,156 @@
	1	/*
	2	* Copyright (c) 1996, 2006, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.io.*;
	29	import java.util.Date;
	30
	31	/**
	32	* <p>This is an interface of abstract methods for managing a
	33	* variety of identity certificates.
	34	* An identity certificate is a guarantee by a principal that
	35	* a public key is that of another principal. (A principal represents
	36	* an entity such as an individual user, a group, or a corporation.)
	37	*
	38	* <p>In particular, this interface is intended to be a common
	39	* abstraction for constructs that have different formats but
	40	* important common uses. For example, different types of
	41	* certificates, such as X.509 certificates and PGP certificates,
	42	* share general certificate functionality (the need to encode and
	43	* decode certificates) and some types of information, such as a
	44	* public key, the principal whose key it is, and the guarantor
	45	* guaranteeing that the public key is that of the specified
	46	* principal. So an implementation of X.509 certificates and an
	47	* implementation of PGP certificates can both utilize the Certificate
	48	* interface, even though their formats and additional types and
	49	* amounts of information stored are different.
	50	*
	51	* <p><b>Important</b>: This interface is useful for cataloging and
	52	* grouping objects sharing certain common uses. It does not have any
	53	* semantics of its own. In particular, a Certificate object does not
	54	* make any statement as to the <i>validity</i> of the binding. It is
	55	* the duty of the application implementing this interface to verify
	56	* the certificate and satisfy itself of its validity.
	57	*
	58	* @author Benjamin Renaud
	59	* @deprecated A new certificate handling package is created in the Java platform.
	60	* This Certificate interface is entirely deprecated and
	61	* is here to allow for a smooth transition to the new
	62	* package.
	63	* @see java.security.cert.Certificate
	64	*/
	65	@Deprecated
	66	public interface Certificate {
	67
	68	/**
	69	* Returns the guarantor of the certificate, that is, the principal
	70	* guaranteeing that the public key associated with this certificate
	71	* is that of the principal associated with this certificate. For X.509
	72	* certificates, the guarantor will typically be a Certificate Authority
	73	* (such as the United States Postal Service or Verisign, Inc.).
	74	*
	75	* @return the guarantor which guaranteed the principal-key
	76	* binding.
	77	*/
	78	public abstract Principal getGuarantor();
	79
	80	/**
	81	* Returns the principal of the principal-key pair being guaranteed by
	82	* the guarantor.
	83	*
	84	* @return the principal to which this certificate is bound.
	85	*/
	86	public abstract Principal getPrincipal();
	87
	88	/**
	89	* Returns the key of the principal-key pair being guaranteed by
	90	* the guarantor.
	91	*
	92	* @return the public key that this certificate certifies belongs
	93	* to a particular principal.
	94	*/
	95	public abstract PublicKey getPublicKey();
	96
	97	/**
	98	* Encodes the certificate to an output stream in a format that can
	99	* be decoded by the <code>decode</code> method.
	100	*
	101	* @param stream the output stream to which to encode the
	102	* certificate.
	103	*
	104	* @exception KeyException if the certificate is not
	105	* properly initialized, or data is missing, etc.
	106	*
	107	* @exception IOException if a stream exception occurs while
	108	* trying to output the encoded certificate to the output stream.
	109	*
	110	* @see #decode
	111	* @see #getFormat
	112	*/
	113	public abstract void encode(OutputStream stream)
	114	throws KeyException, IOException;
	115
	116	/**
	117	* Decodes a certificate from an input stream. The format should be
	118	* that returned by <code>getFormat</code> and produced by
	119	* <code>encode</code>.
	120	*
	121	* @param stream the input stream from which to fetch the data
	122	* being decoded.
	123	*
	124	* @exception KeyException if the certificate is not properly initialized,
	125	* or data is missing, etc.
	126	*
	127	* @exception IOException if an exception occurs while trying to input
	128	* the encoded certificate from the input stream.
	129	*
	130	* @see #encode
	131	* @see #getFormat
	132	*/
	133	public abstract void decode(InputStream stream)
	134	throws KeyException, IOException;
	135
	136
	137	/**
	138	* Returns the name of the coding format. This is used as a hint to find
	139	* an appropriate parser. It could be "X.509", "PGP", etc. This is
	140	* the format produced and understood by the <code>encode</code>
	141	* and <code>decode</code> methods.
	142	*
	143	* @return the name of the coding format.
	144	*/
	145	public abstract String getFormat();
	146
	147	/**
	148	* Returns a string that represents the contents of the certificate.
	149	*
	150	* @param detailed whether or not to give detailed information
	151	* about the certificate
	152	*
	153	* @return a string representing the contents of the certificate
	154	*/
	155	public String toString(boolean detailed);
	156	}

java/pkg/java/security/CodeSigner.class+0−0

Binary file not shown.

java/pkg/java/security/CodeSigner.java+173−0

@@ -0,0 +1,173 @@
	1	/*
	2	* Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.io.*;
	29	import java.security.cert.CertPath;
	30
	31	/**
	32	* This class encapsulates information about a code signer.
	33	* It is immutable.
	34	*
	35	* @since 1.5
	36	* @author Vincent Ryan
	37	*/
	38
	39	public final class CodeSigner implements Serializable {
	40
	41	private static final long serialVersionUID = 6819288105193937581L;
	42
	43	/**
	44	* The signer's certificate path.
	45	*
	46	* @serial
	47	*/
	48	private CertPath signerCertPath;
	49
	50	/*
	51	* The signature timestamp.
	52	*
	53	* @serial
	54	*/
	55	private Timestamp timestamp;
	56
	57	/*
	58	* Hash code for this code signer.
	59	*/
	60	private transient int myhash = -1;
	61
	62	/**
	63	* Constructs a CodeSigner object.
	64	*
	65	* @param signerCertPath The signer's certificate path.
	66	* It must not be <code>null</code>.
	67	* @param timestamp A signature timestamp.
	68	* If <code>null</code> then no timestamp was generated
	69	* for the signature.
	70	* @throws NullPointerException if <code>signerCertPath</code> is
	71	* <code>null</code>.
	72	*/
	73	public CodeSigner(CertPath signerCertPath, Timestamp timestamp) {
	74	if (signerCertPath == null) {
	75	throw new NullPointerException();
	76	}
	77	this.signerCertPath = signerCertPath;
	78	this.timestamp = timestamp;
	79	}
	80
	81	/**
	82	* Returns the signer's certificate path.
	83	*
	84	* @return A certificate path.
	85	*/
	86	public CertPath getSignerCertPath() {
	87	return signerCertPath;
	88	}
	89
	90	/**
	91	* Returns the signature timestamp.
	92	*
	93	* @return The timestamp or <code>null</code> if none is present.
	94	*/
	95	public Timestamp getTimestamp() {
	96	return timestamp;
	97	}
	98
	99	/**
	100	* Returns the hash code value for this code signer.
	101	* The hash code is generated using the signer's certificate path and the
	102	* timestamp, if present.
	103	*
	104	* @return a hash code value for this code signer.
	105	*/
	106	public int hashCode() {
	107	if (myhash == -1) {
	108	if (timestamp == null) {
	109	myhash = signerCertPath.hashCode();
	110	} else {
	111	myhash = signerCertPath.hashCode() + timestamp.hashCode();
	112	}
	113	}
	114	return myhash;
	115	}
	116
	117	/**
	118	* Tests for equality between the specified object and this
	119	* code signer. Two code signers are considered equal if their
	120	* signer certificate paths are equal and if their timestamps are equal,
	121	* if present in both.
	122	*
	123	* @param obj the object to test for equality with this object.
	124	*
	125	* @return true if the objects are considered equal, false otherwise.
	126	*/
	127	public boolean equals(Object obj) {
	128	if (obj == null \|\| (!(obj instanceof CodeSigner))) {
	129	return false;
	130	}
	131	CodeSigner that = (CodeSigner)obj;
	132
	133	if (this == that) {
	134	return true;
	135	}
	136	Timestamp thatTimestamp = that.getTimestamp();
	137	if (timestamp == null) {
	138	if (thatTimestamp != null) {
	139	return false;
	140	}
	141	} else {
	142	if (thatTimestamp == null \|\|
	143	(! timestamp.equals(thatTimestamp))) {
	144	return false;
	145	}
	146	}
	147	return signerCertPath.equals(that.getSignerCertPath());
	148	}
	149
	150	/**
	151	* Returns a string describing this code signer.
	152	*
	153	* @return A string comprising the signer's certificate and a timestamp,
	154	* if present.
	155	*/
	156	public String toString() {
	157	StringBuffer sb = new StringBuffer();
	158	sb.append("(");
	159	sb.append("Signer: " + signerCertPath.getCertificates().get(0));
	160	if (timestamp != null) {
	161	sb.append("timestamp: " + timestamp);
	162	}
	163	sb.append(")");
	164	return sb.toString();
	165	}
	166
	167	// Explicitly reset hash code value to -1
	168	private void readObject(ObjectInputStream ois)
	169	throws IOException, ClassNotFoundException {
	170	ois.defaultReadObject();
	171	myhash = -1;
	172	}
	173	}

java/pkg/java/security/CodeSource.class+0−0

Binary file not shown.

java/pkg/java/security/CodeSource.java+639−0

@@ -0,0 +1,639 @@
	1	/*
	2	* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28
	29	import java.net.URL;
	30	import java.net.SocketPermission;
	31	import java.util.ArrayList;
	32	import java.util.List;
	33	import java.util.Hashtable;
	34	import java.io.ByteArrayInputStream;
	35	import java.io.IOException;
	36	import java.security.cert.*;
	37
	38	/**
	39	*
	40	* <p>This class extends the concept of a codebase to
	41	* encapsulate not only the location (URL) but also the certificate chains
	42	* that were used to verify signed code originating from that location.
	43	*
	44	* @author Li Gong
	45	* @author Roland Schemers
	46	*/
	47
	48	public class CodeSource implements java.io.Serializable {
	49
	50	private static final long serialVersionUID = 4977541819976013951L;
	51
	52	/**
	53	* The code location.
	54	*
	55	* @serial
	56	*/
	57	private URL location;
	58
	59	/*
	60	* The code signers.
	61	*/
	62	private transient CodeSigner[] signers = null;
	63
	64	/*
	65	* The code signers. Certificate chains are concatenated.
	66	*/
	67	private transient java.security.cert.Certificate certs[] = null;
	68
	69	// cached SocketPermission used for matchLocation
	70	private transient SocketPermission sp;
	71
	72	// for generating cert paths
	73	private transient CertificateFactory factory = null;
	74
	75	/**
	76	* Constructs a CodeSource and associates it with the specified
	77	* location and set of certificates.
	78	*
	79	* @param url the location (URL).
	80	*
	81	* @param certs the certificate(s). It may be null. The contents of the
	82	* array are copied to protect against subsequent modification.
	83	*/
	84	public CodeSource(URL url, java.security.cert.Certificate certs[]) {
	85	this.location = url;
	86
	87	// Copy the supplied certs
	88	if (certs != null) {
	89	this.certs = certs.clone();
	90	}
	91	}
	92
	93	/**
	94	* Constructs a CodeSource and associates it with the specified
	95	* location and set of code signers.
	96	*
	97	* @param url the location (URL).
	98	* @param signers the code signers. It may be null. The contents of the
	99	* array are copied to protect against subsequent modification.
	100	*
	101	* @since 1.5
	102	*/
	103	public CodeSource(URL url, CodeSigner[] signers) {
	104	this.location = url;
	105
	106	// Copy the supplied signers
	107	if (signers != null) {
	108	this.signers = signers.clone();
	109	}
	110	}
	111
	112	/**
	113	* Returns the hash code value for this object.
	114	*
	115	* @return a hash code value for this object.
	116	*/
	117
	118	public int hashCode() {
	119	if (location != null)
	120	return location.hashCode();
	121	else
	122	return 0;
	123	}
	124
	125	/**
	126	* Tests for equality between the specified object and this
	127	* object. Two CodeSource objects are considered equal if their
	128	* locations are of identical value and if their signer certificate
	129	* chains are of identical value. It is not required that
	130	* the certificate chains be in the same order.
	131	*
	132	* @param obj the object to test for equality with this object.
	133	*
	134	* @return true if the objects are considered equal, false otherwise.
	135	*/
	136	public boolean equals(Object obj) {
	137	if (obj == this)
	138	return true;
	139
	140	// objects types must be equal
	141	if (!(obj instanceof CodeSource))
	142	return false;
	143
	144	CodeSource cs = (CodeSource) obj;
	145
	146	// URLs must match
	147	if (location == null) {
	148	// if location is null, then cs.location must be null as well
	149	if (cs.location != null) return false;
	150	} else {
	151	// if location is not null, then it must equal cs.location
	152	if (!location.equals(cs.location)) return false;
	153	}
	154
	155	// certs must match
	156	return matchCerts(cs, true);
	157	}
	158
	159	/**
	160	* Returns the location associated with this CodeSource.
	161	*
	162	* @return the location (URL).
	163	*/
	164	public final URL getLocation() {
	165	/* since URL is practically immutable, returning itself is not
	166	a security problem */
	167	return this.location;
	168	}
	169
	170	/**
	171	* Returns the certificates associated with this CodeSource.
	172	* <p>
	173	* If this CodeSource object was created using the
	174	* {@link #CodeSource(URL url, CodeSigner[] signers)}
	175	* constructor then its certificate chains are extracted and used to
	176	* create an array of Certificate objects. Each signer certificate is
	177	* followed by its supporting certificate chain (which may be empty).
	178	* Each signer certificate and its supporting certificate chain is ordered
	179	* bottom-to-top (i.e., with the signer certificate first and the (root)
	180	* certificate authority last).
	181	*
	182	* @return A copy of the certificates array, or null if there is none.
	183	*/
	184	public final java.security.cert.Certificate[] getCertificates() {
	185	if (certs != null) {
	186	return certs.clone();
	187
	188	} else if (signers != null) {
	189	// Convert the code signers to certs
	190	ArrayList<java.security.cert.Certificate> certChains =
	191	new ArrayList<>();
	192	for (int i = 0; i < signers.length; i++) {
	193	certChains.addAll(
	194	signers[i].getSignerCertPath().getCertificates());
	195	}
	196	certs = certChains.toArray(
	197	new java.security.cert.Certificate[certChains.size()]);
	198	return certs.clone();
	199
	200	} else {
	201	return null;
	202	}
	203	}
	204
	205	/**
	206	* Returns the code signers associated with this CodeSource.
	207	* <p>
	208	* If this CodeSource object was created using the
	209	* {@link #CodeSource(URL url, Certificate[] certs)}
	210	* constructor then its certificate chains are extracted and used to
	211	* create an array of CodeSigner objects. Note that only X.509 certificates
	212	* are examined - all other certificate types are ignored.
	213	*
	214	* @return A copy of the code signer array, or null if there is none.
	215	*
	216	* @since 1.5
	217	*/
	218	public final CodeSigner[] getCodeSigners() {
	219	if (signers != null) {
	220	return signers.clone();
	221
	222	} else if (certs != null) {
	223	// Convert the certs to code signers
	224	signers = convertCertArrayToSignerArray(certs);
	225	return signers.clone();
	226
	227	} else {
	228	return null;
	229	}
	230	}
	231
	232	/**
	233	* Returns true if this CodeSource object "implies" the specified CodeSource.
	234	* <P>
	235	* More specifically, this method makes the following checks, in order.
	236	* If any fail, it returns false. If they all succeed, it returns true.<p>
	237	* <ol>
	238	* <li> <i>codesource</i> must not be null.
	239	* <li> If this object's certificates are not null, then all
	240	* of this object's certificates must be present in <i>codesource</i>'s
	241	* certificates.
	242	* <li> If this object's location (getLocation()) is not null, then the
	243	* following checks are made against this object's location and
	244	* <i>codesource</i>'s:<p>
	245	* <ol>
	246	* <li> <i>codesource</i>'s location must not be null.
	247	*
	248	* <li> If this object's location
	249	* equals <i>codesource</i>'s location, then return true.
	250	*
	251	* <li> This object's protocol (getLocation().getProtocol()) must be
	252	* equal to <i>codesource</i>'s protocol.
	253	*
	254	* <li> If this object's host (getLocation().getHost()) is not null,
	255	* then the SocketPermission
	256	* constructed with this object's host must imply the
	257	* SocketPermission constructed with <i>codesource</i>'s host.
	258	*
	259	* <li> If this object's port (getLocation().getPort()) is not
	260	* equal to -1 (that is, if a port is specified), it must equal
	261	* <i>codesource</i>'s port.
	262	*
	263	* <li> If this object's file (getLocation().getFile()) doesn't equal
	264	* <i>codesource</i>'s file, then the following checks are made:
	265	* If this object's file ends with "/-",
	266	* then <i>codesource</i>'s file must start with this object's
	267	* file (exclusive the trailing "-").
	268	* If this object's file ends with a "/*",
	269	* then <i>codesource</i>'s file must start with this object's
	270	* file and must not have any further "/" separators.
	271	* If this object's file doesn't end with a "/",
	272	* then <i>codesource</i>'s file must match this object's
	273	* file with a '/' appended.
	274	*
	275	* <li> If this object's reference (getLocation().getRef()) is
	276	* not null, it must equal <i>codesource</i>'s reference.
	277	*
	278	* </ol>
	279	* </ol>
	280	* <p>
	281	* For example, the codesource objects with the following locations
	282	* and null certificates all imply
	283	* the codesource with the location "http://java.sun.com/classes/foo.jar"
	284	* and null certificates:
	285	* <pre>
	286	* http:
	287	* http://.sun.com/classes/
	288	* http://java.sun.com/classes/-
	289	* http://java.sun.com/classes/foo.jar
	290	* </pre>
	291	*
	292	* Note that if this CodeSource has a null location and a null
	293	* certificate chain, then it implies every other CodeSource.
	294	*
	295	* @param codesource CodeSource to compare against.
	296	*
	297	* @return true if the specified codesource is implied by this codesource,
	298	* false if not.
	299	*/
	300
	301	public boolean implies(CodeSource codesource)
	302	{
	303	if (codesource == null)
	304	return false;
	305
	306	return matchCerts(codesource, false) && matchLocation(codesource);
	307	}
	308
	309	/**
	310	* Returns true if all the certs in this
	311	* CodeSource are also in <i>that</i>.
	312	*
	313	* @param that the CodeSource to check against.
	314	* @param strict If true then a strict equality match is performed.
	315	* Otherwise a subset match is performed.
	316	*/
	317	private boolean matchCerts(CodeSource that, boolean strict)
	318	{
	319	boolean match;
	320
	321	// match any key
	322	if (certs == null && signers == null) {
	323	if (strict) {
	324	return (that.certs == null && that.signers == null);
	325	} else {
	326	return true;
	327	}
	328	// both have signers
	329	} else if (signers != null && that.signers != null) {
	330	if (strict && signers.length != that.signers.length) {
	331	return false;
	332	}
	333	for (int i = 0; i < signers.length; i++) {
	334	match = false;
	335	for (int j = 0; j < that.signers.length; j++) {
	336	if (signers[i].equals(that.signers[j])) {
	337	match = true;
	338	break;
	339	}
	340	}
	341	if (!match) return false;
	342	}
	343	return true;
	344
	345	// both have certs
	346	} else if (certs != null && that.certs != null) {
	347	if (strict && certs.length != that.certs.length) {
	348	return false;
	349	}
	350	for (int i = 0; i < certs.length; i++) {
	351	match = false;
	352	for (int j = 0; j < that.certs.length; j++) {
	353	if (certs[i].equals(that.certs[j])) {
	354	match = true;
	355	break;
	356	}
	357	}
	358	if (!match) return false;
	359	}
	360	return true;
	361	}
	362
	363	return false;
	364	}
	365
	366
	367	/**
	368	* Returns true if two CodeSource's have the "same" location.
	369	*
	370	* @param that CodeSource to compare against
	371	*/
	372	private boolean matchLocation(CodeSource that)
	373	{
	374	if (location == null) {
	375	return true;
	376	}
	377
	378	if ((that == null) \|\| (that.location == null))
	379	return false;
	380
	381	if (location.equals(that.location))
	382	return true;
	383
	384	if (!location.getProtocol().equals(that.location.getProtocol()))
	385	return false;
	386
	387	String thisHost = location.getHost();
	388	String thatHost = that.location.getHost();
	389
	390	if (thisHost != null) {
	391	if (("".equals(thisHost) \|\| "localhost".equals(thisHost)) &&
	392	("".equals(thatHost) \|\| "localhost".equals(thatHost))) {
	393	// ok
	394	} else if (!thisHost.equals(thatHost)) {
	395	if (thatHost == null) {
	396	return false;
	397	}
	398	if (this.sp == null) {
	399	this.sp = new SocketPermission(thisHost, "resolve");
	400	}
	401	if (that.sp == null) {
	402	that.sp = new SocketPermission(thatHost, "resolve");
	403	}
	404	if (!this.sp.implies(that.sp)) {
	405	return false;
	406	}
	407	}
	408	}
	409
	410	if (location.getPort() != -1) {
	411	if (location.getPort() != that.location.getPort())
	412	return false;
	413	}
	414
	415	if (location.getFile().endsWith("/-")) {
	416	// Matches the directory and (recursively) all files
	417	// and subdirectories contained in that directory.
	418	// For example, "/a/b/-" implies anything that starts with
	419	// "/a/b/"
	420	String thisPath = location.getFile().substring(0,
	421	location.getFile().length()-1);
	422	if (!that.location.getFile().startsWith(thisPath))
	423	return false;
	424	} else if (location.getFile().endsWith("/*")) {
	425	// Matches the directory and all the files contained in that
	426	// directory.
	427	// For example, "/a/b/*" implies anything that starts with
	428	// "/a/b/" but has no further slashes
	429	int last = that.location.getFile().lastIndexOf('/');
	430	if (last == -1)
	431	return false;
	432	String thisPath = location.getFile().substring(0,
	433	location.getFile().length()-1);
	434	String thatPath = that.location.getFile().substring(0, last+1);
	435	if (!thatPath.equals(thisPath))
	436	return false;
	437	} else {
	438	// Exact matches only.
	439	// For example, "/a/b" and "/a/b/" both imply "/a/b/"
	440	if ((!that.location.getFile().equals(location.getFile()))
	441	&& (!that.location.getFile().equals(location.getFile()+"/"))) {
	442	return false;
	443	}
	444	}
	445
	446	if (location.getRef() == null)
	447	return true;
	448	else
	449	return location.getRef().equals(that.location.getRef());
	450	}
	451
	452	/**
	453	* Returns a string describing this CodeSource, telling its
	454	* URL and certificates.
	455	*
	456	* @return information about this CodeSource.
	457	*/
	458	public String toString() {
	459	StringBuilder sb = new StringBuilder();
	460	sb.append("(");
	461	sb.append(this.location);
	462
	463	if (this.certs != null && this.certs.length > 0) {
	464	for (int i = 0; i < this.certs.length; i++) {
	465	sb.append( " " + this.certs[i]);
	466	}
	467
	468	} else if (this.signers != null && this.signers.length > 0) {
	469	for (int i = 0; i < this.signers.length; i++) {
	470	sb.append( " " + this.signers[i]);
	471	}
	472	} else {
	473	sb.append(" <no signer certificates>");
	474	}
	475	sb.append(")");
	476	return sb.toString();
	477	}
	478
	479	/**
	480	* Writes this object out to a stream (i.e., serializes it).
	481	*
	482	* @serialData An initial <code>URL</code> is followed by an
	483	* <code>int</code> indicating the number of certificates to follow
	484	* (a value of "zero" denotes that there are no certificates associated
	485	* with this object).
	486	* Each certificate is written out starting with a <code>String</code>
	487	* denoting the certificate type, followed by an
	488	* <code>int</code> specifying the length of the certificate encoding,
	489	* followed by the certificate encoding itself which is written out as an
	490	* array of bytes. Finally, if any code signers are present then the array
	491	* of code signers is serialized and written out too.
	492	*/
	493	private void writeObject(java.io.ObjectOutputStream oos)
	494	throws IOException
	495	{
	496	oos.defaultWriteObject(); // location
	497
	498	// Serialize the array of certs
	499	if (certs == null \|\| certs.length == 0) {
	500	oos.writeInt(0);
	501	} else {
	502	// write out the total number of certs
	503	oos.writeInt(certs.length);
	504	// write out each cert, including its type
	505	for (int i = 0; i < certs.length; i++) {
	506	java.security.cert.Certificate cert = certs[i];
	507	try {
	508	oos.writeUTF(cert.getType());
	509	byte[] encoded = cert.getEncoded();
	510	oos.writeInt(encoded.length);
	511	oos.write(encoded);
	512	} catch (CertificateEncodingException cee) {
	513	throw new IOException(cee.getMessage());
	514	}
	515	}
	516	}
	517
	518	// Serialize the array of code signers (if any)
	519	if (signers != null && signers.length > 0) {
	520	oos.writeObject(signers);
	521	}
	522	}
	523
	524	/**
	525	* Restores this object from a stream (i.e., deserializes it).
	526	*/
	527	private void readObject(java.io.ObjectInputStream ois)
	528	throws IOException, ClassNotFoundException
	529	{
	530	CertificateFactory cf;
	531	Hashtable<String, CertificateFactory> cfs = null;
	532
	533	ois.defaultReadObject(); // location
	534
	535	// process any new-style certs in the stream (if present)
	536	int size = ois.readInt();
	537	if (size > 0) {
	538	// we know of 3 different cert types: X.509, PGP, SDSI, which
	539	// could all be present in the stream at the same time
	540	cfs = new Hashtable<String, CertificateFactory>(3);
	541	this.certs = new java.security.cert.Certificate[size];
	542	}
	543
	544	for (int i = 0; i < size; i++) {
	545	// read the certificate type, and instantiate a certificate
	546	// factory of that type (reuse existing factory if possible)
	547	String certType = ois.readUTF();
	548	if (cfs.containsKey(certType)) {
	549	// reuse certificate factory
	550	cf = cfs.get(certType);
	551	} else {
	552	// create new certificate factory
	553	try {
	554	cf = CertificateFactory.getInstance(certType);
	555	} catch (CertificateException ce) {
	556	throw new ClassNotFoundException
	557	("Certificate factory for " + certType + " not found");
	558	}
	559	// store the certificate factory so we can reuse it later
	560	cfs.put(certType, cf);
	561	}
	562	// parse the certificate
	563	byte[] encoded = null;
	564	try {
	565	encoded = new byte[ois.readInt()];
	566	} catch (OutOfMemoryError oome) {
	567	throw new IOException("Certificate too big");
	568	}
	569	ois.readFully(encoded);
	570	ByteArrayInputStream bais = new ByteArrayInputStream(encoded);
	571	try {
	572	this.certs[i] = cf.generateCertificate(bais);
	573	} catch (CertificateException ce) {
	574	throw new IOException(ce.getMessage());
	575	}
	576	bais.close();
	577	}
	578
	579	// Deserialize array of code signers (if any)
	580	try {
	581	this.signers = ((CodeSigner[])ois.readObject()).clone();
	582	} catch (IOException ioe) {
	583	// no signers present
	584	}
	585	}
	586
	587	/*
	588	* Convert an array of certificates to an array of code signers.
	589	* The array of certificates is a concatenation of certificate chains
	590	* where the initial certificate in each chain is the end-entity cert.
	591	*
	592	* @return An array of code signers or null if none are generated.
	593	*/
	594	private CodeSigner[] convertCertArrayToSignerArray(
	595	java.security.cert.Certificate[] certs) {
	596
	597	if (certs == null) {
	598	return null;
	599	}
	600
	601	try {
	602	// Initialize certificate factory
	603	if (factory == null) {
	604	factory = CertificateFactory.getInstance("X.509");
	605	}
	606
	607	// Iterate through all the certificates
	608	int i = 0;
	609	List<CodeSigner> signers = new ArrayList<>();
	610	while (i < certs.length) {
	611	List<java.security.cert.Certificate> certChain =
	612	new ArrayList<>();
	613	certChain.add(certs[i++]); // first cert is an end-entity cert
	614	int j = i;
	615
	616	// Extract chain of certificates
	617	// (loop while certs are not end-entity certs)
	618	while (j < certs.length &&
	619	certs[j] instanceof X509Certificate &&
	620	((X509Certificate)certs[j]).getBasicConstraints() != -1) {
	621	certChain.add(certs[j]);
	622	j++;
	623	}
	624	i = j;
	625	CertPath certPath = factory.generateCertPath(certChain);
	626	signers.add(new CodeSigner(certPath, null));
	627	}
	628
	629	if (signers.isEmpty()) {
	630	return null;
	631	} else {
	632	return signers.toArray(new CodeSigner[signers.size()]);
	633	}
	634
	635	} catch (CertificateException e) {
	636	return null; //TODO - may be better to throw an ex. here
	637	}
	638	}
	639	}

java/pkg/java/security/CryptoPrimitive.class+0−0

Binary file not shown.

java/pkg/java/security/CryptoPrimitive.java+83−0

@@ -0,0 +1,83 @@
	1	/*
	2	* Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	/**
	29	* An enumeration of cryptographic primitives.
	30	*
	31	* @since 1.7
	32	*/
	33	public enum CryptoPrimitive {
	34	/**
	35	* Hash function
	36	*/
	37	MESSAGE_DIGEST,
	38
	39	/**
	40	* Cryptographic random number generator
	41	*/
	42	SECURE_RANDOM,
	43
	44	/**
	45	* Symmetric primitive: block cipher
	46	*/
	47	BLOCK_CIPHER,
	48
	49	/**
	50	* Symmetric primitive: stream cipher
	51	*/
	52	STREAM_CIPHER,
	53
	54	/**
	55	* Symmetric primitive: message authentication code
	56	*/
	57	MAC,
	58
	59	/**
	60	* Symmetric primitive: key wrap
	61	*/
	62	KEY_WRAP,
	63
	64	/**
	65	* Asymmetric primitive: public key encryption
	66	*/
	67	PUBLIC_KEY_ENCRYPTION,
	68
	69	/**
	70	* Asymmetric primitive: signature scheme
	71	*/
	72	SIGNATURE,
	73
	74	/**
	75	* Asymmetric primitive: key encapsulation mechanism
	76	*/
	77	KEY_ENCAPSULATION,
	78
	79	/**
	80	* Asymmetric primitive: key agreement and key distribution
	81	*/
	82	KEY_AGREEMENT
	83	}

java/pkg/java/security/DigestException.class+0−0

Binary file not shown.

java/pkg/java/security/DigestException.java+86−0

@@ -0,0 +1,86 @@
	1	/*
	2	* Copyright (c) 1996, 2003, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	/**
	29	* This is the generic Message Digest exception.
	30	*
	31	* @author Benjamin Renaud
	32	*/
	33	public class DigestException extends GeneralSecurityException {
	34
	35	private static final long serialVersionUID = 5821450303093652515L;
	36
	37	/**
	38	* Constructs a DigestException with no detail message. (A
	39	* detail message is a String that describes this particular
	40	* exception.)
	41	*/
	42	public DigestException() {
	43	super();
	44	}
	45
	46	/**
	47	* Constructs a DigestException with the specified detail
	48	* message. (A detail message is a String that describes this
	49	* particular exception.)
	50	*
	51	* @param msg the detail message.
	52	*/
	53	public DigestException(String msg) {
	54	super(msg);
	55	}
	56
	57	/**
	58	* Creates a <code>DigestException</code> with the specified
	59	* detail message and cause.
	60	*
	61	* @param message the detail message (which is saved for later retrieval
	62	* by the {@link #getMessage()} method).
	63	* @param cause the cause (which is saved for later retrieval by the
	64	* {@link #getCause()} method). (A <tt>null</tt> value is permitted,
	65	* and indicates that the cause is nonexistent or unknown.)
	66	* @since 1.5
	67	*/
	68	public DigestException(String message, Throwable cause) {
	69	super(message, cause);
	70	}
	71
	72	/**
	73	* Creates a <code>DigestException</code> with the specified cause
	74	* and a detail message of <tt>(cause==null ? null : cause.toString())</tt>
	75	* (which typically contains the class and detail message of
	76	* <tt>cause</tt>).
	77	*
	78	* @param cause the cause (which is saved for later retrieval by the
	79	* {@link #getCause()} method). (A <tt>null</tt> value is permitted,
	80	* and indicates that the cause is nonexistent or unknown.)
	81	* @since 1.5
	82	*/
	83	public DigestException(Throwable cause) {
	84	super(cause);
	85	}
	86	}

java/pkg/java/security/DigestInputStream.class+0−0

Binary file not shown.

java/pkg/java/security/DigestInputStream.java+188−0

@@ -0,0 +1,188 @@
	1	/*
	2	* Copyright (c) 1996, 1999, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.io.IOException;
	29	import java.io.EOFException;
	30	import java.io.InputStream;
	31	import java.io.FilterInputStream;
	32	import java.io.PrintStream;
	33	import java.io.ByteArrayInputStream;
	34
	35	/**
	36	* A transparent stream that updates the associated message digest using
	37	* the bits going through the stream.
	38	*
	39	* <p>To complete the message digest computation, call one of the
	40	* <code>digest</code> methods on the associated message
	41	* digest after your calls to one of this digest input stream's
	42	* {@link #read() read} methods.
	43	*
	44	* <p>It is possible to turn this stream on or off (see
	45	* {@link #on(boolean) on}). When it is on, a call to one of the
	46	* <code>read</code> methods
	47	* results in an update on the message digest. But when it is off,
	48	* the message digest is not updated. The default is for the stream
	49	* to be on.
	50	*
	51	* <p>Note that digest objects can compute only one digest (see
	52	* {@link MessageDigest}),
	53	* so that in order to compute intermediate digests, a caller should
	54	* retain a handle onto the digest object, and clone it for each
	55	* digest to be computed, leaving the orginal digest untouched.
	56	*
	57	* @see MessageDigest
	58	*
	59	* @see DigestOutputStream
	60	*
	61	* @author Benjamin Renaud
	62	*/
	63
	64	public class DigestInputStream extends FilterInputStream {
	65
	66	/* NOTE: This should be made a generic UpdaterInputStream */
	67
	68	/* Are we on or off? */
	69	private boolean on = true;
	70
	71	/**
	72	* The message digest associated with this stream.
	73	*/
	74	protected MessageDigest digest;
	75
	76	/**
	77	* Creates a digest input stream, using the specified input stream
	78	* and message digest.
	79	*
	80	* @param stream the input stream.
	81	*
	82	* @param digest the message digest to associate with this stream.
	83	*/
	84	public DigestInputStream(InputStream stream, MessageDigest digest) {
	85	super(stream);
	86	setMessageDigest(digest);
	87	}
	88
	89	/**
	90	* Returns the message digest associated with this stream.
	91	*
	92	* @return the message digest associated with this stream.
	93	* @see #setMessageDigest(java.security.MessageDigest)
	94	*/
	95	public MessageDigest getMessageDigest() {
	96	return digest;
	97	}
	98
	99	/**
	100	* Associates the specified message digest with this stream.
	101	*
	102	* @param digest the message digest to be associated with this stream.
	103	* @see #getMessageDigest()
	104	*/
	105	public void setMessageDigest(MessageDigest digest) {
	106	this.digest = digest;
	107	}
	108
	109	/**
	110	* Reads a byte, and updates the message digest (if the digest
	111	* function is on). That is, this method reads a byte from the
	112	* input stream, blocking until the byte is actually read. If the
	113	* digest function is on (see {@link #on(boolean) on}), this method
	114	* will then call <code>update</code> on the message digest associated
	115	* with this stream, passing it the byte read.
	116	*
	117	* @return the byte read.
	118	*
	119	* @exception IOException if an I/O error occurs.
	120	*
	121	* @see MessageDigest#update(byte)
	122	*/
	123	public int read() throws IOException {
	124	int ch = in.read();
	125	if (on && ch != -1) {
	126	digest.update((byte)ch);
	127	}
	128	return ch;
	129	}
	130
	131	/**
	132	* Reads into a byte array, and updates the message digest (if the
	133	* digest function is on). That is, this method reads up to
	134	* <code>len</code> bytes from the input stream into the array
	135	* <code>b</code>, starting at offset <code>off</code>. This method
	136	* blocks until the data is actually
	137	* read. If the digest function is on (see
	138	* {@link #on(boolean) on}), this method will then call <code>update</code>
	139	* on the message digest associated with this stream, passing it
	140	* the data.
	141	*
	142	* @param b the array into which the data is read.
	143	*
	144	* @param off the starting offset into <code>b</code> of where the
	145	* data should be placed.
	146	*
	147	* @param len the maximum number of bytes to be read from the input
	148	* stream into b, starting at offset <code>off</code>.
	149	*
	150	* @return the actual number of bytes read. This is less than
	151	* <code>len</code> if the end of the stream is reached prior to
	152	* reading <code>len</code> bytes. -1 is returned if no bytes were
	153	* read because the end of the stream had already been reached when
	154	* the call was made.
	155	*
	156	* @exception IOException if an I/O error occurs.
	157	*
	158	* @see MessageDigest#update(byte[], int, int)
	159	*/
	160	public int read(byte[] b, int off, int len) throws IOException {
	161	int result = in.read(b, off, len);
	162	if (on && result != -1) {
	163	digest.update(b, off, result);
	164	}
	165	return result;
	166	}
	167
	168	/**
	169	* Turns the digest function on or off. The default is on. When
	170	* it is on, a call to one of the <code>read</code> methods results in an
	171	* update on the message digest. But when it is off, the message
	172	* digest is not updated.
	173	*
	174	* @param on true to turn the digest function on, false to turn
	175	* it off.
	176	*/
	177	public void on(boolean on) {
	178	this.on = on;
	179	}
	180
	181	/**
	182	* Prints a string representation of this digest input stream and
	183	* its associated message digest object.
	184	*/
	185	public String toString() {
	186	return "[Digest Input Stream] " + digest.toString();
	187	}
	188	}

java/pkg/java/security/DigestOutputStream.class+0−0

Binary file not shown.

java/pkg/java/security/DigestOutputStream.java+171−0

@@ -0,0 +1,171 @@
	1	/*
	2	* Copyright (c) 1996, 1999, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.io.IOException;
	29	import java.io.EOFException;
	30	import java.io.OutputStream;
	31	import java.io.FilterOutputStream;
	32	import java.io.PrintStream;
	33	import java.io.ByteArrayOutputStream;
	34
	35	/**
	36	* A transparent stream that updates the associated message digest using
	37	* the bits going through the stream.
	38	*
	39	* <p>To complete the message digest computation, call one of the
	40	* <code>digest</code> methods on the associated message
	41	* digest after your calls to one of this digest ouput stream's
	42	* {@link #write(int) write} methods.
	43	*
	44	* <p>It is possible to turn this stream on or off (see
	45	* {@link #on(boolean) on}). When it is on, a call to one of the
	46	* <code>write</code> methods results in
	47	* an update on the message digest. But when it is off, the message
	48	* digest is not updated. The default is for the stream to be on.
	49	*
	50	* @see MessageDigest
	51	* @see DigestInputStream
	52	*
	53	* @author Benjamin Renaud
	54	*/
	55	public class DigestOutputStream extends FilterOutputStream {
	56
	57	private boolean on = true;
	58
	59	/**
	60	* The message digest associated with this stream.
	61	*/
	62	protected MessageDigest digest;
	63
	64	/**
	65	* Creates a digest output stream, using the specified output stream
	66	* and message digest.
	67	*
	68	* @param stream the output stream.
	69	*
	70	* @param digest the message digest to associate with this stream.
	71	*/
	72	public DigestOutputStream(OutputStream stream, MessageDigest digest) {
	73	super(stream);
	74	setMessageDigest(digest);
	75	}
	76
	77	/**
	78	* Returns the message digest associated with this stream.
	79	*
	80	* @return the message digest associated with this stream.
	81	* @see #setMessageDigest(java.security.MessageDigest)
	82	*/
	83	public MessageDigest getMessageDigest() {
	84	return digest;
	85	}
	86
	87	/**
	88	* Associates the specified message digest with this stream.
	89	*
	90	* @param digest the message digest to be associated with this stream.
	91	* @see #getMessageDigest()
	92	*/
	93	public void setMessageDigest(MessageDigest digest) {
	94	this.digest = digest;
	95	}
	96
	97	/**
	98	* Updates the message digest (if the digest function is on) using
	99	* the specified byte, and in any case writes the byte
	100	* to the output stream. That is, if the digest function is on
	101	* (see {@link #on(boolean) on}), this method calls
	102	* <code>update</code> on the message digest associated with this
	103	* stream, passing it the byte <code>b</code>. This method then
	104	* writes the byte to the output stream, blocking until the byte
	105	* is actually written.
	106	*
	107	* @param b the byte to be used for updating and writing to the
	108	* output stream.
	109	*
	110	* @exception IOException if an I/O error occurs.
	111	*
	112	* @see MessageDigest#update(byte)
	113	*/
	114	public void write(int b) throws IOException {
	115	if (on) {
	116	digest.update((byte)b);
	117	}
	118	out.write(b);
	119	}
	120
	121	/**
	122	* Updates the message digest (if the digest function is on) using
	123	* the specified subarray, and in any case writes the subarray to
	124	* the output stream. That is, if the digest function is on (see
	125	* {@link #on(boolean) on}), this method calls <code>update</code>
	126	* on the message digest associated with this stream, passing it
	127	* the subarray specifications. This method then writes the subarray
	128	* bytes to the output stream, blocking until the bytes are actually
	129	* written.
	130	*
	131	* @param b the array containing the subarray to be used for updating
	132	* and writing to the output stream.
	133	*
	134	* @param off the offset into <code>b</code> of the first byte to
	135	* be updated and written.
	136	*
	137	* @param len the number of bytes of data to be updated and written
	138	* from <code>b</code>, starting at offset <code>off</code>.
	139	*
	140	* @exception IOException if an I/O error occurs.
	141	*
	142	* @see MessageDigest#update(byte[], int, int)
	143	*/
	144	public void write(byte[] b, int off, int len) throws IOException {
	145	if (on) {
	146	digest.update(b, off, len);
	147	}
	148	out.write(b, off, len);
	149	}
	150
	151	/**
	152	* Turns the digest function on or off. The default is on. When
	153	* it is on, a call to one of the <code>write</code> methods results in an
	154	* update on the message digest. But when it is off, the message
	155	* digest is not updated.
	156	*
	157	* @param on true to turn the digest function on, false to turn it
	158	* off.
	159	*/
	160	public void on(boolean on) {
	161	this.on = on;
	162	}
	163
	164	/**
	165	* Prints a string representation of this digest output stream and
	166	* its associated message digest object.
	167	*/
	168	public String toString() {
	169	return "[Digest Output Stream] " + digest.toString();
	170	}
	171	}

java/pkg/java/security/DomainCombiner.class+0−0

Binary file not shown.

java/pkg/java/security/DomainCombiner.java+112−0

@@ -0,0 +1,112 @@
	1	/*
	2	* Copyright (c) 1999, 2006, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	/**
	29	* A <code>DomainCombiner</code> provides a means to dynamically
	30	* update the ProtectionDomains associated with the current
	31	* <code>AccessControlContext</code>.
	32	*
	33	* <p> A <code>DomainCombiner</code> is passed as a parameter to the
	34	* appropriate constructor for <code>AccessControlContext</code>.
	35	* The newly constructed context is then passed to the
	36	* <code>AccessController.doPrivileged(..., context)</code> method
	37	* to bind the provided context (and associated <code>DomainCombiner</code>)
	38	* with the current execution Thread. Subsequent calls to
	39	* <code>AccessController.getContext</code> or
	40	* <code>AccessController.checkPermission</code>
	41	* cause the <code>DomainCombiner.combine</code> to get invoked.
	42	*
	43	* <p> The combine method takes two arguments. The first argument represents
	44	* an array of ProtectionDomains from the current execution Thread,
	45	* since the most recent call to <code>AccessController.doPrivileged</code>.
	46	* If no call to doPrivileged was made, then the first argument will contain
	47	* all the ProtectionDomains from the current execution Thread.
	48	* The second argument represents an array of inherited ProtectionDomains,
	49	* which may be <code>null</code>. ProtectionDomains may be inherited
	50	* from a parent Thread, or from a privileged context. If no call to
	51	* doPrivileged was made, then the second argument will contain the
	52	* ProtectionDomains inherited from the parent Thread. If one or more calls
	53	* to doPrivileged were made, and the most recent call was to
	54	* doPrivileged(action, context), then the second argument will contain the
	55	* ProtectionDomains from the privileged context. If the most recent call
	56	* was to doPrivileged(action), then there is no privileged context,
	57	* and the second argument will be <code>null</code>.
	58	*
	59	* <p> The <code>combine</code> method investigates the two input arrays
	60	* of ProtectionDomains and returns a single array containing the updated
	61	* ProtectionDomains. In the simplest case, the <code>combine</code>
	62	* method merges the two stacks into one. In more complex cases,
	63	* the <code>combine</code> method returns a modified
	64	* stack of ProtectionDomains. The modification may have added new
	65	* ProtectionDomains, removed certain ProtectionDomains, or simply
	66	* updated existing ProtectionDomains. Re-ordering and other optimizations
	67	* to the ProtectionDomains are also permitted. Typically the
	68	* <code>combine</code> method bases its updates on the information
	69	* encapsulated in the <code>DomainCombiner</code>.
	70	*
	71	* <p> After the <code>AccessController.getContext</code> method
	72	* receives the combined stack of ProtectionDomains back from
	73	* the <code>DomainCombiner</code>, it returns a new
	74	* AccessControlContext that has both the combined ProtectionDomains
	75	* as well as the <code>DomainCombiner</code>.
	76	*
	77	* @see AccessController
	78	* @see AccessControlContext
	79	* @since 1.3
	80	*/
	81	public interface DomainCombiner {
	82
	83	/**
	84	* Modify or update the provided ProtectionDomains.
	85	* ProtectionDomains may be added to or removed from the given
	86	* ProtectionDomains. The ProtectionDomains may be re-ordered.
	87	* Individual ProtectionDomains may be modified (with a new
	88	* set of Permissions, for example).
	89	*
	90	* <p>
	91	*
	92	* @param currentDomains the ProtectionDomains associated with the
	93	* current execution Thread, up to the most recent
	94	* privileged <code>ProtectionDomain</code>.
	95	* The ProtectionDomains are are listed in order of execution,
	96	* with the most recently executing <code>ProtectionDomain</code>
	97	* residing at the beginning of the array. This parameter may
	98	* be <code>null</code> if the current execution Thread
	99	* has no associated ProtectionDomains.<p>
	100	*
	101	* @param assignedDomains an array of inherited ProtectionDomains.
	102	* ProtectionDomains may be inherited from a parent Thread,
	103	* or from a privileged <code>AccessControlContext</code>.
	104	* This parameter may be <code>null</code>
	105	* if there are no inherited ProtectionDomains.
	106	*
	107	* @return a new array consisting of the updated ProtectionDomains,
	108	* or <code>null</code>.
	109	*/
	110	ProtectionDomain[] combine(ProtectionDomain[] currentDomains,
	111	ProtectionDomain[] assignedDomains);
	112	}

java/pkg/java/security/GeneralSecurityException.class+0−0

Binary file not shown.

java/pkg/java/security/GeneralSecurityException.java+88−0

@@ -0,0 +1,88 @@
	1	/*
	2	* Copyright (c) 1997, 2003, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	/**
	29	* The <code>GeneralSecurityException</code> class is a generic
	30	* security exception class that provides type safety for all the
	31	* security-related exception classes that extend from it.
	32	*
	33	* @author Jan Luehe
	34	*/
	35
	36	public class GeneralSecurityException extends Exception {
	37
	38	private static final long serialVersionUID = 894798122053539237L;
	39
	40	/**
	41	* Constructs a GeneralSecurityException with no detail message.
	42	*/
	43	public GeneralSecurityException() {
	44	super();
	45	}
	46
	47	/**
	48	* Constructs a GeneralSecurityException with the specified detail
	49	* message.
	50	* A detail message is a String that describes this particular
	51	* exception.
	52	*
	53	* @param msg the detail message.
	54	*/
	55	public GeneralSecurityException(String msg) {
	56	super(msg);
	57	}
	58
	59	/**
	60	* Creates a <code>GeneralSecurityException</code> with the specified
	61	* detail message and cause.
	62	*
	63	* @param message the detail message (which is saved for later retrieval
	64	* by the {@link #getMessage()} method).
	65	* @param cause the cause (which is saved for later retrieval by the
	66	* {@link #getCause()} method). (A <tt>null</tt> value is permitted,
	67	* and indicates that the cause is nonexistent or unknown.)
	68	* @since 1.5
	69	*/
	70	public GeneralSecurityException(String message, Throwable cause) {
	71	super(message, cause);
	72	}
	73
	74	/**
	75	* Creates a <code>GeneralSecurityException</code> with the specified cause
	76	* and a detail message of <tt>(cause==null ? null : cause.toString())</tt>
	77	* (which typically contains the class and detail message of
	78	* <tt>cause</tt>).
	79	*
	80	* @param cause the cause (which is saved for later retrieval by the
	81	* {@link #getCause()} method). (A <tt>null</tt> value is permitted,
	82	* and indicates that the cause is nonexistent or unknown.)
	83	* @since 1.5
	84	*/
	85	public GeneralSecurityException(Throwable cause) {
	86	super(cause);
	87	}
	88	}

java/pkg/java/security/Guard.class+0−0

Binary file not shown.

java/pkg/java/security/Guard.java+56−0

@@ -0,0 +1,56 @@
	1	/*
	2	* Copyright (c) 1997, 1998, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	/**
	29	* <p> This interface represents a guard, which is an object that is used
	30	* to protect access to another object.
	31	*
	32	* <p>This interface contains a single method, <code>checkGuard</code>,
	33	* with a single <code>object</code> argument. <code>checkGuard</code> is
	34	* invoked (by the GuardedObject <code>getObject</code> method)
	35	* to determine whether or not to allow access to the object.
	36	*
	37	* @see GuardedObject
	38	*
	39	* @author Roland Schemers
	40	* @author Li Gong
	41	*/
	42
	43	public interface Guard {
	44
	45	/**
	46	* Determines whether or not to allow access to the guarded object
	47	* <code>object</code>. Returns silently if access is allowed.
	48	* Otherwise, throws a SecurityException.
	49	*
	50	* @param object the object being protected by the guard.
	51	*
	52	* @exception SecurityException if access is denied.
	53	*
	54	*/
	55	void checkGuard(Object object) throws SecurityException;
	56	}

java/pkg/java/security/GuardedObject.class+0−0

Binary file not shown.

java/pkg/java/security/GuardedObject.java+102−0

@@ -0,0 +1,102 @@
	1	/*
	2	* Copyright (c) 1997, 2004, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	/**
	29	* A GuardedObject is an object that is used to protect access to
	30	* another object.
	31	*
	32	* <p>A GuardedObject encapsulates a target object and a Guard object,
	33	* such that access to the target object is possible
	34	* only if the Guard object allows it.
	35	* Once an object is encapsulated by a GuardedObject,
	36	* access to that object is controlled by the <code>getObject</code>
	37	* method, which invokes the
	38	* <code>checkGuard</code> method on the Guard object that is
	39	* guarding access. If access is not allowed,
	40	* an exception is thrown.
	41	*
	42	* @see Guard
	43	* @see Permission
	44	*
	45	* @author Roland Schemers
	46	* @author Li Gong
	47	*/
	48
	49	public class GuardedObject implements java.io.Serializable {
	50
	51	private static final long serialVersionUID = -5240450096227834308L;
	52
	53	private Object object; // the object we are guarding
	54	private Guard guard; // the guard
	55
	56	/**
	57	* Constructs a GuardedObject using the specified object and guard.
	58	* If the Guard object is null, then no restrictions will
	59	* be placed on who can access the object.
	60	*
	61	* @param object the object to be guarded.
	62	*
	63	* @param guard the Guard object that guards access to the object.
	64	*/
	65
	66	public GuardedObject(Object object, Guard guard)
	67	{
	68	this.guard = guard;
	69	this.object = object;
	70	}
	71
	72	/**
	73	* Retrieves the guarded object, or throws an exception if access
	74	* to the guarded object is denied by the guard.
	75	*
	76	* @return the guarded object.
	77	*
	78	* @exception SecurityException if access to the guarded object is
	79	* denied.
	80	*/
	81	public Object getObject()
	82	throws SecurityException
	83	{
	84	if (guard != null)
	85	guard.checkGuard(object);
	86
	87	return object;
	88	}
	89
	90	/**
	91	* Writes this object out to a stream (i.e., serializes it).
	92	* We check the guard if there is one.
	93	*/
	94	private void writeObject(java.io.ObjectOutputStream oos)
	95	throws java.io.IOException
	96	{
	97	if (guard != null)
	98	guard.checkGuard(object);
	99
	100	oos.defaultWriteObject();
	101	}
	102	}

java/pkg/java/security/Identity.class+0−0

Binary file not shown.

java/pkg/java/security/Identity.java+495−0

@@ -0,0 +1,495 @@
	1	/*
	2	* Copyright (c) 1996, 2006, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.io.Serializable;
	29	import java.util.*;
	30
	31	/**
	32	* <p>This class represents identities: real-world objects such as people,
	33	* companies or organizations whose identities can be authenticated using
	34	* their public keys. Identities may also be more abstract (or concrete)
	35	* constructs, such as daemon threads or smart cards.
	36	*
	37	* <p>All Identity objects have a name and a public key. Names are
	38	* immutable. Identities may also be scoped. That is, if an Identity is
	39	* specified to have a particular scope, then the name and public
	40	* key of the Identity are unique within that scope.
	41	*
	42	* <p>An Identity also has a set of certificates (all certifying its own
	43	* public key). The Principal names specified in these certificates need
	44	* not be the same, only the key.
	45	*
	46	* <p>An Identity can be subclassed, to include postal and email addresses,
	47	* telephone numbers, images of faces and logos, and so on.
	48	*
	49	* @see IdentityScope
	50	* @see Signer
	51	* @see Principal
	52	*
	53	* @author Benjamin Renaud
	54	* @deprecated This class is no longer used. Its functionality has been
	55	* replaced by <code>java.security.KeyStore</code>, the
	56	* <code>java.security.cert</code> package, and
	57	* <code>java.security.Principal</code>.
	58	*/
	59	@Deprecated
	60	public abstract class Identity implements Principal, Serializable {
	61
	62	/** use serialVersionUID from JDK 1.1.x for interoperability */
	63	private static final long serialVersionUID = 3609922007826600659L;
	64
	65	/**
	66	* The name for this identity.
	67	*
	68	* @serial
	69	*/
	70	private String name;
	71
	72	/**
	73	* The public key for this identity.
	74	*
	75	* @serial
	76	*/
	77	private PublicKey publicKey;
	78
	79	/**
	80	* Generic, descriptive information about the identity.
	81	*
	82	* @serial
	83	*/
	84	String info = "No further information available.";
	85
	86	/**
	87	* The scope of the identity.
	88	*
	89	* @serial
	90	*/
	91	IdentityScope scope;
	92
	93	/**
	94	* The certificates for this identity.
	95	*
	96	* @serial
	97	*/
	98	Vector<Certificate> certificates;
	99
	100	/**
	101	* Constructor for serialization only.
	102	*/
	103	protected Identity() {
	104	this("restoring...");
	105	}
	106
	107	/**
	108	* Constructs an identity with the specified name and scope.
	109	*
	110	* @param name the identity name.
	111	* @param scope the scope of the identity.
	112	*
	113	* @exception KeyManagementException if there is already an identity
	114	* with the same name in the scope.
	115	*/
	116	public Identity(String name, IdentityScope scope) throws
	117	KeyManagementException {
	118	this(name);
	119	if (scope != null) {
	120	scope.addIdentity(this);
	121	}
	122	this.scope = scope;
	123	}
	124
	125	/**
	126	* Constructs an identity with the specified name and no scope.
	127	*
	128	* @param name the identity name.
	129	*/
	130	public Identity(String name) {
	131	this.name = name;
	132	}
	133
	134	/**
	135	* Returns this identity's name.
	136	*
	137	* @return the name of this identity.
	138	*/
	139	public final String getName() {
	140	return name;
	141	}
	142
	143	/**
	144	* Returns this identity's scope.
	145	*
	146	* @return the scope of this identity.
	147	*/
	148	public final IdentityScope getScope() {
	149	return scope;
	150	}
	151
	152	/**
	153	* Returns this identity's public key.
	154	*
	155	* @return the public key for this identity.
	156	*
	157	* @see #setPublicKey
	158	*/
	159	public PublicKey getPublicKey() {
	160	return publicKey;
	161	}
	162
	163	/**
	164	* Sets this identity's public key. The old key and all of this
	165	* identity's certificates are removed by this operation.
	166	*
	167	* <p>First, if there is a security manager, its <code>checkSecurityAccess</code>
	168	* method is called with <code>"setIdentityPublicKey"</code>
	169	* as its argument to see if it's ok to set the public key.
	170	*
	171	* @param key the public key for this identity.
	172	*
	173	* @exception KeyManagementException if another identity in the
	174	* identity's scope has the same public key, or if another exception occurs.
	175	*
	176	* @exception SecurityException if a security manager exists and its
	177	* <code>checkSecurityAccess</code> method doesn't allow
	178	* setting the public key.
	179	*
	180	* @see #getPublicKey
	181	* @see SecurityManager#checkSecurityAccess
	182	*/
	183	/* Should we throw an exception if this is already set? */
	184	public void setPublicKey(PublicKey key) throws KeyManagementException {
	185
	186	check("setIdentityPublicKey");
	187	this.publicKey = key;
	188	certificates = new Vector<Certificate>();
	189	}
	190
	191	/**
	192	* Specifies a general information string for this identity.
	193	*
	194	* <p>First, if there is a security manager, its <code>checkSecurityAccess</code>
	195	* method is called with <code>"setIdentityInfo"</code>
	196	* as its argument to see if it's ok to specify the information string.
	197	*
	198	* @param info the information string.
	199	*
	200	* @exception SecurityException if a security manager exists and its
	201	* <code>checkSecurityAccess</code> method doesn't allow
	202	* setting the information string.
	203	*
	204	* @see #getInfo
	205	* @see SecurityManager#checkSecurityAccess
	206	*/
	207	public void setInfo(String info) {
	208	check("setIdentityInfo");
	209	this.info = info;
	210	}
	211
	212	/**
	213	* Returns general information previously specified for this identity.
	214	*
	215	* @return general information about this identity.
	216	*
	217	* @see #setInfo
	218	*/
	219	public String getInfo() {
	220	return info;
	221	}
	222
	223	/**
	224	* Adds a certificate for this identity. If the identity has a public
	225	* key, the public key in the certificate must be the same, and if
	226	* the identity does not have a public key, the identity's
	227	* public key is set to be that specified in the certificate.
	228	*
	229	* <p>First, if there is a security manager, its <code>checkSecurityAccess</code>
	230	* method is called with <code>"addIdentityCertificate"</code>
	231	* as its argument to see if it's ok to add a certificate.
	232	*
	233	* @param certificate the certificate to be added.
	234	*
	235	* @exception KeyManagementException if the certificate is not valid,
	236	* if the public key in the certificate being added conflicts with
	237	* this identity's public key, or if another exception occurs.
	238	*
	239	* @exception SecurityException if a security manager exists and its
	240	* <code>checkSecurityAccess</code> method doesn't allow
	241	* adding a certificate.
	242	*
	243	* @see SecurityManager#checkSecurityAccess
	244	*/
	245	public void addCertificate(Certificate certificate)
	246	throws KeyManagementException {
	247
	248	check("addIdentityCertificate");
	249
	250	if (certificates == null) {
	251	certificates = new Vector<Certificate>();
	252	}
	253	if (publicKey != null) {
	254	if (!keyEquals(publicKey, certificate.getPublicKey())) {
	255	throw new KeyManagementException(
	256	"public key different from cert public key");
	257	}
	258	} else {
	259	publicKey = certificate.getPublicKey();
	260	}
	261	certificates.addElement(certificate);
	262	}
	263
	264	private boolean keyEquals(Key aKey, Key anotherKey) {
	265	String aKeyFormat = aKey.getFormat();
	266	String anotherKeyFormat = anotherKey.getFormat();
	267	if ((aKeyFormat == null) ^ (anotherKeyFormat == null))
	268	return false;
	269	if (aKeyFormat != null && anotherKeyFormat != null)
	270	if (!aKeyFormat.equalsIgnoreCase(anotherKeyFormat))
	271	return false;
	272	return java.util.Arrays.equals(aKey.getEncoded(),
	273	anotherKey.getEncoded());
	274	}
	275
	276
	277	/**
	278	* Removes a certificate from this identity.
	279	*
	280	* <p>First, if there is a security manager, its <code>checkSecurityAccess</code>
	281	* method is called with <code>"removeIdentityCertificate"</code>
	282	* as its argument to see if it's ok to remove a certificate.
	283	*
	284	* @param certificate the certificate to be removed.
	285	*
	286	* @exception KeyManagementException if the certificate is
	287	* missing, or if another exception occurs.
	288	*
	289	* @exception SecurityException if a security manager exists and its
	290	* <code>checkSecurityAccess</code> method doesn't allow
	291	* removing a certificate.
	292	*
	293	* @see SecurityManager#checkSecurityAccess
	294	*/
	295	public void removeCertificate(Certificate certificate)
	296	throws KeyManagementException {
	297	check("removeIdentityCertificate");
	298	if (certificates != null) {
	299	certificates.removeElement(certificate);
	300	}
	301	}
	302
	303	/**
	304	* Returns a copy of all the certificates for this identity.
	305	*
	306	* @return a copy of all the certificates for this identity.
	307	*/
	308	public Certificate[] certificates() {
	309	if (certificates == null) {
	310	return new Certificate[0];
	311	}
	312	int len = certificates.size();
	313	Certificate[] certs = new Certificate[len];
	314	certificates.copyInto(certs);
	315	return certs;
	316	}
	317
	318	/**
	319	* Tests for equality between the specified object and this identity.
	320	* This first tests to see if the entities actually refer to the same
	321	* object, in which case it returns true. Next, it checks to see if
	322	* the entities have the same name and the same scope. If they do,
	323	* the method returns true. Otherwise, it calls
	324	* {@link #identityEquals(Identity) identityEquals}, which subclasses should
	325	* override.
	326	*
	327	* @param identity the object to test for equality with this identity.
	328	*
	329	* @return true if the objects are considered equal, false otherwise.
	330	*
	331	* @see #identityEquals
	332	*/
	333	public final boolean equals(Object identity) {
	334
	335	if (identity == this) {
	336	return true;
	337	}
	338
	339	if (identity instanceof Identity) {
	340	Identity i = (Identity)identity;
	341	if (this.fullName().equals(i.fullName())) {
	342	return true;
	343	} else {
	344	return identityEquals(i);
	345	}
	346	}
	347	return false;
	348	}
	349
	350	/**
	351	* Tests for equality between the specified identity and this identity.
	352	* This method should be overriden by subclasses to test for equality.
	353	* The default behavior is to return true if the names and public keys
	354	* are equal.
	355	*
	356	* @param identity the identity to test for equality with this identity.
	357	*
	358	* @return true if the identities are considered equal, false
	359	* otherwise.
	360	*
	361	* @see #equals
	362	*/
	363	protected boolean identityEquals(Identity identity) {
	364	if (!name.equalsIgnoreCase(identity.name))
	365	return false;
	366
	367	if ((publicKey == null) ^ (identity.publicKey == null))
	368	return false;
	369
	370	if (publicKey != null && identity.publicKey != null)
	371	if (!publicKey.equals(identity.publicKey))
	372	return false;
	373
	374	return true;
	375
	376	}
	377
	378	/**
	379	* Returns a parsable name for identity: identityName.scopeName
	380	*/
	381	String fullName() {
	382	String parsable = name;
	383	if (scope != null) {
	384	parsable += "." + scope.getName();
	385	}
	386	return parsable;
	387	}
	388
	389	/**
	390	* Returns a short string describing this identity, telling its
	391	* name and its scope (if any).
	392	*
	393	* <p>First, if there is a security manager, its <code>checkSecurityAccess</code>
	394	* method is called with <code>"printIdentity"</code>
	395	* as its argument to see if it's ok to return the string.
	396	*
	397	* @return information about this identity, such as its name and the
	398	* name of its scope (if any).
	399	*
	400	* @exception SecurityException if a security manager exists and its
	401	* <code>checkSecurityAccess</code> method doesn't allow
	402	* returning a string describing this identity.
	403	*
	404	* @see SecurityManager#checkSecurityAccess
	405	*/
	406	public String toString() {
	407	check("printIdentity");
	408	String printable = name;
	409	if (scope != null) {
	410	printable += "[" + scope.getName() + "]";
	411	}
	412	return printable;
	413	}
	414
	415	/**
	416	* Returns a string representation of this identity, with
	417	* optionally more details than that provided by the
	418	* <code>toString</code> method without any arguments.
	419	*
	420	* <p>First, if there is a security manager, its <code>checkSecurityAccess</code>
	421	* method is called with <code>"printIdentity"</code>
	422	* as its argument to see if it's ok to return the string.
	423	*
	424	* @param detailed whether or not to provide detailed information.
	425	*
	426	* @return information about this identity. If <code>detailed</code>
	427	* is true, then this method returns more information than that
	428	* provided by the <code>toString</code> method without any arguments.
	429	*
	430	* @exception SecurityException if a security manager exists and its
	431	* <code>checkSecurityAccess</code> method doesn't allow
	432	* returning a string describing this identity.
	433	*
	434	* @see #toString
	435	* @see SecurityManager#checkSecurityAccess
	436	*/
	437	public String toString(boolean detailed) {
	438	String out = toString();
	439	if (detailed) {
	440	out += "\n";
	441	out += printKeys();
	442	out += "\n" + printCertificates();
	443	if (info != null) {
	444	out += "\n\t" + info;
	445	} else {
	446	out += "\n\tno additional information available.";
	447	}
	448	}
	449	return out;
	450	}
	451
	452	String printKeys() {
	453	String key = "";
	454	if (publicKey != null) {
	455	key = "\tpublic key initialized";
	456	} else {
	457	key = "\tno public key";
	458	}
	459	return key;
	460	}
	461
	462	String printCertificates() {
	463	String out = "";
	464	if (certificates == null) {
	465	return "\tno certificates";
	466	} else {
	467	out += "\tcertificates: \n";
	468
	469	int i = 1;
	470	for (Certificate cert : certificates) {
	471	out += "\tcertificate " + i++ +
	472	"\tfor : " + cert.getPrincipal() + "\n";
	473	out += "\t\t\tfrom : " +
	474	cert.getGuarantor() + "\n";
	475	}
	476	}
	477	return out;
	478	}
	479
	480	/**
	481	* Returns a hashcode for this identity.
	482	*
	483	* @return a hashcode for this identity.
	484	*/
	485	public int hashCode() {
	486	return name.hashCode();
	487	}
	488
	489	private static void check(String directive) {
	490	SecurityManager security = System.getSecurityManager();
	491	if (security != null) {
	492	security.checkSecurityAccess(directive);
	493	}
	494	}
	495	}

java/pkg/java/security/IdentityScope$1.class+0−0

Binary file not shown.

java/pkg/java/security/IdentityScope.class+0−0

Binary file not shown.

java/pkg/java/security/IdentityScope.java+257−0

@@ -0,0 +1,257 @@
	1	/*
	2	* Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.io.Serializable;
	29	import java.util.Enumeration;
	30	import java.util.Properties;
	31
	32	/**
	33	* <p>This class represents a scope for identities. It is an Identity
	34	* itself, and therefore has a name and can have a scope. It can also
	35	* optionally have a public key and associated certificates.
	36	*
	37	* <p>An IdentityScope can contain Identity objects of all kinds, including
	38	* Signers. All types of Identity objects can be retrieved, added, and
	39	* removed using the same methods. Note that it is possible, and in fact
	40	* expected, that different types of identity scopes will
	41	* apply different policies for their various operations on the
	42	* various types of Identities.
	43	*
	44	* <p>There is a one-to-one mapping between keys and identities, and
	45	* there can only be one copy of one key per scope. For example, suppose
	46	* <b>Acme Software, Inc</b> is a software publisher known to a user.
	47	* Suppose it is an Identity, that is, it has a public key, and a set of
	48	* associated certificates. It is named in the scope using the name
	49	* "Acme Software". No other named Identity in the scope has the same
	50	* public key. Of course, none has the same name as well.
	51	*
	52	* @see Identity
	53	* @see Signer
	54	* @see Principal
	55	* @see Key
	56	*
	57	* @author Benjamin Renaud
	58	*
	59	* @deprecated This class is no longer used. Its functionality has been
	60	* replaced by <code>java.security.KeyStore</code>, the
	61	* <code>java.security.cert</code> package, and
	62	* <code>java.security.Principal</code>.
	63	*/
	64	@Deprecated
	65	public abstract
	66	class IdentityScope extends Identity {
	67
	68	private static final long serialVersionUID = -2337346281189773310L;
	69
	70	/* The system's scope */
	71	private static IdentityScope scope;
	72
	73	// initialize the system scope
	74	private static void initializeSystemScope() {
	75
	76	String classname = AccessController.doPrivileged(
	77	new PrivilegedAction<String>() {
	78	public String run() {
	79	return Security.getProperty("system.scope");
	80	}
	81	});
	82
	83	if (classname == null) {
	84	return;
	85
	86	} else {
	87
	88	try {
	89	Class.forName(classname);
	90	} catch (ClassNotFoundException e) {
	91	//Security.error("unable to establish a system scope from " +
	92	// classname);
	93	e.printStackTrace();
	94	}
	95	}
	96	}
	97
	98	/**
	99	* This constructor is used for serialization only and should not
	100	* be used by subclasses.
	101	*/
	102	protected IdentityScope() {
	103	this("restoring...");
	104	}
	105
	106	/**
	107	* Constructs a new identity scope with the specified name.
	108	*
	109	* @param name the scope name.
	110	*/
	111	public IdentityScope(String name) {
	112	super(name);
	113	}
	114
	115	/**
	116	* Constructs a new identity scope with the specified name and scope.
	117	*
	118	* @param name the scope name.
	119	* @param scope the scope for the new identity scope.
	120	*
	121	* @exception KeyManagementException if there is already an identity
	122	* with the same name in the scope.
	123	*/
	124	public IdentityScope(String name, IdentityScope scope)
	125	throws KeyManagementException {
	126	super(name, scope);
	127	}
	128
	129	/**
	130	* Returns the system's identity scope.
	131	*
	132	* @return the system's identity scope, or {@code null} if none has been
	133	* set.
	134	*
	135	* @see #setSystemScope
	136	*/
	137	public static IdentityScope getSystemScope() {
	138	if (scope == null) {
	139	initializeSystemScope();
	140	}
	141	return scope;
	142	}
	143
	144
	145	/**
	146	* Sets the system's identity scope.
	147	*
	148	* <p>First, if there is a security manager, its
	149	* <code>checkSecurityAccess</code>
	150	* method is called with <code>"setSystemScope"</code>
	151	* as its argument to see if it's ok to set the identity scope.
	152	*
	153	* @param scope the scope to set.
	154	*
	155	* @exception SecurityException if a security manager exists and its
	156	* <code>checkSecurityAccess</code> method doesn't allow
	157	* setting the identity scope.
	158	*
	159	* @see #getSystemScope
	160	* @see SecurityManager#checkSecurityAccess
	161	*/
	162	protected static void setSystemScope(IdentityScope scope) {
	163	check("setSystemScope");
	164	IdentityScope.scope = scope;
	165	}
	166
	167	/**
	168	* Returns the number of identities within this identity scope.
	169	*
	170	* @return the number of identities within this identity scope.
	171	*/
	172	public abstract int size();
	173
	174	/**
	175	* Returns the identity in this scope with the specified name (if any).
	176	*
	177	* @param name the name of the identity to be retrieved.
	178	*
	179	* @return the identity named <code>name</code>, or null if there are
	180	* no identities named <code>name</code> in this scope.
	181	*/
	182	public abstract Identity getIdentity(String name);
	183
	184	/**
	185	* Retrieves the identity whose name is the same as that of the
	186	* specified principal. (Note: Identity implements Principal.)
	187	*
	188	* @param principal the principal corresponding to the identity
	189	* to be retrieved.
	190	*
	191	* @return the identity whose name is the same as that of the
	192	* principal, or null if there are no identities of the same name
	193	* in this scope.
	194	*/
	195	public Identity getIdentity(Principal principal) {
	196	return getIdentity(principal.getName());
	197	}
	198
	199	/**
	200	* Retrieves the identity with the specified public key.
	201	*
	202	* @param key the public key for the identity to be returned.
	203	*
	204	* @return the identity with the given key, or null if there are
	205	* no identities in this scope with that key.
	206	*/
	207	public abstract Identity getIdentity(PublicKey key);
	208
	209	/**
	210	* Adds an identity to this identity scope.
	211	*
	212	* @param identity the identity to be added.
	213	*
	214	* @exception KeyManagementException if the identity is not
	215	* valid, a name conflict occurs, another identity has the same
	216	* public key as the identity being added, or another exception
	217	* occurs. */
	218	public abstract void addIdentity(Identity identity)
	219	throws KeyManagementException;
	220
	221	/**
	222	* Removes an identity from this identity scope.
	223	*
	224	* @param identity the identity to be removed.
	225	*
	226	* @exception KeyManagementException if the identity is missing,
	227	* or another exception occurs.
	228	*/
	229	public abstract void removeIdentity(Identity identity)
	230	throws KeyManagementException;
	231
	232	/**
	233	* Returns an enumeration of all identities in this identity scope.
	234	*
	235	* @return an enumeration of all identities in this identity scope.
	236	*/
	237	public abstract Enumeration<Identity> identities();
	238
	239	/**
	240	* Returns a string representation of this identity scope, including
	241	* its name, its scope name, and the number of identities in this
	242	* identity scope.
	243	*
	244	* @return a string representation of this identity scope.
	245	*/
	246	public String toString() {
	247	return super.toString() + "[" + size() + "]";
	248	}
	249
	250	private static void check(String directive) {
	251	SecurityManager security = System.getSecurityManager();
	252	if (security != null) {
	253	security.checkSecurityAccess(directive);
	254	}
	255	}
	256
	257	}

java/pkg/java/security/InvalidAlgorithmParameterException.class+0−0

Binary file not shown.

java/pkg/java/security/InvalidAlgorithmParameterException.java+97−0

@@ -0,0 +1,97 @@
	1	/*
	2	* Copyright (c) 1997, 2003, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	/**
	29	* This is the exception for invalid or inappropriate algorithm parameters.
	30	*
	31	* @author Jan Luehe
	32	*
	33	*
	34	* @see AlgorithmParameters
	35	* @see java.security.spec.AlgorithmParameterSpec
	36	*
	37	* @since 1.2
	38	*/
	39
	40	public class InvalidAlgorithmParameterException
	41	extends GeneralSecurityException {
	42
	43	private static final long serialVersionUID = 2864672297499471472L;
	44
	45	/**
	46	* Constructs an InvalidAlgorithmParameterException with no detail
	47	* message.
	48	* A detail message is a String that describes this particular
	49	* exception.
	50	*/
	51	public InvalidAlgorithmParameterException() {
	52	super();
	53	}
	54
	55	/**
	56	* Constructs an InvalidAlgorithmParameterException with the specified
	57	* detail message.
	58	* A detail message is a String that describes this
	59	* particular exception.
	60	*
	61	* @param msg the detail message.
	62	*/
	63	public InvalidAlgorithmParameterException(String msg) {
	64	super(msg);
	65	}
	66
	67	/**
	68	* Creates a <code>InvalidAlgorithmParameterException</code> with the
	69	* specified detail message and cause.
	70	*
	71	* @param message the detail message (which is saved for later retrieval
	72	* by the {@link #getMessage()} method).
	73	* @param cause the cause (which is saved for later retrieval by the
	74	* {@link #getCause()} method). (A <tt>null</tt> value is permitted,
	75	* and indicates that the cause is nonexistent or unknown.)
	76	* @since 1.5
	77	*/
	78	public InvalidAlgorithmParameterException(String message, Throwable cause) {
	79	super(message, cause);
	80	}
	81
	82	/**
	83	* Creates a <code>InvalidAlgorithmParameterException</code> with the
	84	* specified cause and a detail message of
	85	* <tt>(cause==null ? null : cause.toString())</tt>
	86	* (which typically contains the class and detail message of
	87	* <tt>cause</tt>).
	88	*
	89	* @param cause the cause (which is saved for later retrieval by the
	90	* {@link #getCause()} method). (A <tt>null</tt> value is permitted,
	91	* and indicates that the cause is nonexistent or unknown.)
	92	* @since 1.5
	93	*/
	94	public InvalidAlgorithmParameterException(Throwable cause) {
	95	super(cause);
	96	}
	97	}

java/pkg/java/security/InvalidKeyException.class+0−0

Binary file not shown.

java/pkg/java/security/InvalidKeyException.java+89−0

@@ -0,0 +1,89 @@
	1	/*
	2	* Copyright (c) 1996, 2003, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26
	27	package java.security;
	28
	29	/**
	30	* This is the exception for invalid Keys (invalid encoding, wrong
	31	* length, uninitialized, etc).
	32	*
	33	* @author Benjamin Renaud
	34	*/
	35
	36	public class InvalidKeyException extends KeyException {
	37
	38	private static final long serialVersionUID = 5698479920593359816L;
	39
	40	/**
	41	* Constructs an InvalidKeyException with no detail message. A
	42	* detail message is a String that describes this particular
	43	* exception.
	44	*/
	45	public InvalidKeyException() {
	46	super();
	47	}
	48
	49	/**
	50	* Constructs an InvalidKeyException with the specified detail
	51	* message. A detail message is a String that describes this
	52	* particular exception.
	53	*
	54	* @param msg the detail message.
	55	*/
	56	public InvalidKeyException(String msg) {
	57	super(msg);
	58	}
	59
	60	/**
	61	* Creates a <code>InvalidKeyException</code> with the specified
	62	* detail message and cause.
	63	*
	64	* @param message the detail message (which is saved for later retrieval
	65	* by the {@link #getMessage()} method).
	66	* @param cause the cause (which is saved for later retrieval by the
	67	* {@link #getCause()} method). (A <tt>null</tt> value is permitted,
	68	* and indicates that the cause is nonexistent or unknown.)
	69	* @since 1.5
	70	*/
	71	public InvalidKeyException(String message, Throwable cause) {
	72	super(message, cause);
	73	}
	74
	75	/**
	76	* Creates a <code>InvalidKeyException</code> with the specified cause
	77	* and a detail message of <tt>(cause==null ? null : cause.toString())</tt>
	78	* (which typically contains the class and detail message of
	79	* <tt>cause</tt>).
	80	*
	81	* @param cause the cause (which is saved for later retrieval by the
	82	* {@link #getCause()} method). (A <tt>null</tt> value is permitted,
	83	* and indicates that the cause is nonexistent or unknown.)
	84	* @since 1.5
	85	*/
	86	public InvalidKeyException(Throwable cause) {
	87	super(cause);
	88	}
	89	}

java/pkg/java/security/InvalidParameterException.class+0−0

Binary file not shown.

java/pkg/java/security/InvalidParameterException.java+59−0

@@ -0,0 +1,59 @@
	1	/*
	2	* Copyright (c) 1996, 2003, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	/**
	29	* This exception, designed for use by the JCA/JCE engine classes,
	30	* is thrown when an invalid parameter is passed
	31	* to a method.
	32	*
	33	* @author Benjamin Renaud
	34	*/
	35
	36	public class InvalidParameterException extends IllegalArgumentException {
	37
	38	private static final long serialVersionUID = -857968536935667808L;
	39
	40	/**
	41	* Constructs an InvalidParameterException with no detail message.
	42	* A detail message is a String that describes this particular
	43	* exception.
	44	*/
	45	public InvalidParameterException() {
	46	super();
	47	}
	48
	49	/**
	50	* Constructs an InvalidParameterException with the specified
	51	* detail message. A detail message is a String that describes
	52	* this particular exception.
	53	*
	54	* @param msg the detail message.
	55	*/
	56	public InvalidParameterException(String msg) {
	57	super(msg);
	58	}
	59	}

java/pkg/java/security/Key.class+0−0

Binary file not shown.

java/pkg/java/security/Key.java+153−0

@@ -0,0 +1,153 @@
	1	/*
	2	* Copyright (c) 1996, 2006, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	/**
	29	* The Key interface is the top-level interface for all keys. It
	30	* defines the functionality shared by all key objects. All keys
	31	* have three characteristics:
	32	*
	33	* <UL>
	34	*
	35	* <LI>An Algorithm
	36	*
	37	* <P>This is the key algorithm for that key. The key algorithm is usually
	38	* an encryption or asymmetric operation algorithm (such as DSA or
	39	* RSA), which will work with those algorithms and with related
	40	* algorithms (such as MD5 with RSA, SHA-1 with RSA, Raw DSA, etc.)
	41	* The name of the algorithm of a key is obtained using the
	42	* {@link #getAlgorithm() getAlgorithm} method.<P>
	43	*
	44	* <LI>An Encoded Form
	45	*
	46	* <P>This is an external encoded form for the key used when a standard
	47	* representation of the key is needed outside the Java Virtual Machine,
	48	* as when transmitting the key to some other party. The key
	49	* is encoded according to a standard format (such as
	50	* X.509 <code>SubjectPublicKeyInfo</code> or PKCS#8), and
	51	* is returned using the {@link #getEncoded() getEncoded} method.
	52	* Note: The syntax of the ASN.1 type <code>SubjectPublicKeyInfo</code>
	53	* is defined as follows:
	54	*
	55	* <pre>
	56	* SubjectPublicKeyInfo ::= SEQUENCE {
	57	* algorithm AlgorithmIdentifier,
	58	* subjectPublicKey BIT STRING }
	59	*
	60	* AlgorithmIdentifier ::= SEQUENCE {
	61	* algorithm OBJECT IDENTIFIER,
	62	* parameters ANY DEFINED BY algorithm OPTIONAL }
	63	* </pre>
	64	*
	65	* For more information, see
	66	* <a href="http://www.ietf.org/rfc/rfc3280.txt">RFC 3280:
	67	* Internet X.509 Public Key Infrastructure Certificate and CRL Profile</a>.
	68	* <P>
	69	*
	70	* <LI>A Format
	71	*
	72	* <P>This is the name of the format of the encoded key. It is returned
	73	* by the {@link #getFormat() getFormat} method.<P>
	74	*
	75	* </UL>
	76	*
	77	* Keys are generally obtained through key generators, certificates,
	78	* or various Identity classes used to manage keys.
	79	* Keys may also be obtained from key specifications (transparent
	80	* representations of the underlying key material) through the use of a key
	81	* factory (see {@link KeyFactory}).
	82	*
	83	* <p> A Key should use KeyRep as its serialized representation.
	84	* Note that a serialized Key may contain sensitive information
	85	* which should not be exposed in untrusted environments. See the
	86	* <a href="../../../platform/serialization/spec/security.html">
	87	* Security Appendix</a>
	88	* of the Serialization Specification for more information.
	89	*
	90	* @see PublicKey
	91	* @see PrivateKey
	92	* @see KeyPair
	93	* @see KeyPairGenerator
	94	* @see KeyFactory
	95	* @see KeyRep
	96	* @see java.security.spec.KeySpec
	97	* @see Identity
	98	* @see Signer
	99	*
	100	* @author Benjamin Renaud
	101	*/
	102
	103	public interface Key extends java.io.Serializable {
	104
	105	// Declare serialVersionUID to be compatible with JDK1.1
	106
	107	/**
	108	* The class fingerprint that is set to indicate
	109	* serialization compatibility with a previous
	110	* version of the class.
	111	*/
	112	static final long serialVersionUID = 6603384152749567654L;
	113
	114	/**
	115	* Returns the standard algorithm name for this key. For
	116	* example, "DSA" would indicate that this key is a DSA key.
	117	* See Appendix A in the <a href=
	118	* "../../../technotes/guides/security/crypto/CryptoSpec.html#AppA">
	119	* Java Cryptography Architecture API Specification & Reference </a>
	120	* for information about standard algorithm names.
	121	*
	122	* @return the name of the algorithm associated with this key.
	123	*/
	124	public String getAlgorithm();
	125
	126	/**
	127	* Returns the name of the primary encoding format of this key,
	128	* or null if this key does not support encoding.
	129	* The primary encoding format is
	130	* named in terms of the appropriate ASN.1 data format, if an
	131	* ASN.1 specification for this key exists.
	132	* For example, the name of the ASN.1 data format for public
	133	* keys is <I>SubjectPublicKeyInfo</I>, as
	134	* defined by the X.509 standard; in this case, the returned format is
	135	* <code>"X.509"</code>. Similarly,
	136	* the name of the ASN.1 data format for private keys is
	137	* <I>PrivateKeyInfo</I>,
	138	* as defined by the PKCS #8 standard; in this case, the returned format is
	139	* <code>"PKCS#8"</code>.
	140	*
	141	* @return the primary encoding format of the key.
	142	*/
	143	public String getFormat();
	144
	145	/**
	146	* Returns the key in its primary encoding format, or null
	147	* if this key does not support encoding.
	148	*
	149	* @return the encoded key, or null if the key does not support
	150	* encoding.
	151	*/
	152	public byte[] getEncoded();
	153	}

java/pkg/java/security/KeyException.class+0−0

Binary file not shown.

java/pkg/java/security/KeyException.java+90−0

@@ -0,0 +1,90 @@
	1	/*
	2	* Copyright (c) 1996, 2003, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	/**
	29	* This is the basic key exception.
	30	*
	31	* @see Key
	32	* @see InvalidKeyException
	33	* @see KeyManagementException
	34	*
	35	* @author Benjamin Renaud
	36	*/
	37
	38	public class KeyException extends GeneralSecurityException {
	39
	40	private static final long serialVersionUID = -7483676942812432108L;
	41
	42	/**
	43	* Constructs a KeyException with no detail message. A detail
	44	* message is a String that describes this particular exception.
	45	*/
	46	public KeyException() {
	47	super();
	48	}
	49
	50	/**
	51	* Constructs a KeyException with the specified detail message.
	52	* A detail message is a String that describes this particular
	53	* exception.
	54	*
	55	* @param msg the detail message.
	56	*/
	57	public KeyException(String msg) {
	58	super(msg);
	59	}
	60
	61	/**
	62	* Creates a <code>KeyException</code> with the specified
	63	* detail message and cause.
	64	*
	65	* @param message the detail message (which is saved for later retrieval
	66	* by the {@link #getMessage()} method).
	67	* @param cause the cause (which is saved for later retrieval by the
	68	* {@link #getCause()} method). (A <tt>null</tt> value is permitted,
	69	* and indicates that the cause is nonexistent or unknown.)
	70	* @since 1.5
	71	*/
	72	public KeyException(String message, Throwable cause) {
	73	super(message, cause);
	74	}
	75
	76	/**
	77	* Creates a <code>KeyException</code> with the specified cause
	78	* and a detail message of <tt>(cause==null ? null : cause.toString())</tt>
	79	* (which typically contains the class and detail message of
	80	* <tt>cause</tt>).
	81	*
	82	* @param cause the cause (which is saved for later retrieval by the
	83	* {@link #getCause()} method). (A <tt>null</tt> value is permitted,
	84	* and indicates that the cause is nonexistent or unknown.)
	85	* @since 1.5
	86	*/
	87	public KeyException(Throwable cause) {
	88	super(cause);
	89	}
	90	}

java/pkg/java/security/KeyFactory.class+0−0

Binary file not shown.

java/pkg/java/security/KeyFactory.java+474−0

@@ -0,0 +1,474 @@
	1	/*
	2	* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.util.*;
	29
	30	import java.security.Provider.Service;
	31	import java.security.spec.KeySpec;
	32	import java.security.spec.InvalidKeySpecException;
	33
	34	import sun.security.util.Debug;
	35	import sun.security.jca.*;
	36	import sun.security.jca.GetInstance.Instance;
	37
	38	/**
	39	* Key factories are used to convert <I>keys</I> (opaque
	40	* cryptographic keys of type <code>Key</code>) into <I>key specifications</I>
	41	* (transparent representations of the underlying key material), and vice
	42	* versa.
	43	*
	44	* <P> Key factories are bi-directional. That is, they allow you to build an
	45	* opaque key object from a given key specification (key material), or to
	46	* retrieve the underlying key material of a key object in a suitable format.
	47	*
	48	* <P> Multiple compatible key specifications may exist for the same key.
	49	* For example, a DSA public key may be specified using
	50	* <code>DSAPublicKeySpec</code> or
	51	* <code>X509EncodedKeySpec</code>. A key factory can be used to translate
	52	* between compatible key specifications.
	53	*
	54	* <P> The following is an example of how to use a key factory in order to
	55	* instantiate a DSA public key from its encoding.
	56	* Assume Alice has received a digital signature from Bob.
	57	* Bob also sent her his public key (in encoded format) to verify
	58	* his signature. Alice then performs the following actions:
	59	*
	60	* <pre>
	61	* X509EncodedKeySpec bobPubKeySpec = new X509EncodedKeySpec(bobEncodedPubKey);
	62	* KeyFactory keyFactory = KeyFactory.getInstance("DSA");
	63	* PublicKey bobPubKey = keyFactory.generatePublic(bobPubKeySpec);
	64	* Signature sig = Signature.getInstance("DSA");
	65	* sig.initVerify(bobPubKey);
	66	* sig.update(data);
	67	* sig.verify(signature);
	68	* </pre>
	69	*
	70	* <p> Every implementation of the Java platform is required to support the
	71	* following standard <code>KeyFactory</code> algorithms:
	72	* <ul>
	73	* <li><tt>DiffieHellman</tt></li>
	74	* <li><tt>DSA</tt></li>
	75	* <li><tt>RSA</tt></li>
	76	* </ul>
	77	* These algorithms are described in the <a href=
	78	* "{@docRoot}/../technotes/guides/security/StandardNames.html#KeyFactory">
	79	* KeyFactory section</a> of the
	80	* Java Cryptography Architecture Standard Algorithm Name Documentation.
	81	* Consult the release documentation for your implementation to see if any
	82	* other algorithms are supported.
	83	*
	84	* @author Jan Luehe
	85	*
	86	* @see Key
	87	* @see PublicKey
	88	* @see PrivateKey
	89	* @see java.security.spec.KeySpec
	90	* @see java.security.spec.DSAPublicKeySpec
	91	* @see java.security.spec.X509EncodedKeySpec
	92	*
	93	* @since 1.2
	94	*/
	95
	96	public class KeyFactory {
	97
	98	private static final Debug debug =
	99	Debug.getInstance("jca", "KeyFactory");
	100
	101	// The algorithm associated with this key factory
	102	private final String algorithm;
	103
	104	// The provider
	105	private Provider provider;
	106
	107	// The provider implementation (delegate)
	108	private volatile KeyFactorySpi spi;
	109
	110	// lock for mutex during provider selection
	111	private final Object lock = new Object();
	112
	113	// remaining services to try in provider selection
	114	// null once provider is selected
	115	private Iterator<Service> serviceIterator;
	116
	117	/**
	118	* Creates a KeyFactory object.
	119	*
	120	* @param keyFacSpi the delegate
	121	* @param provider the provider
	122	* @param algorithm the name of the algorithm
	123	* to associate with this <tt>KeyFactory</tt>
	124	*/
	125	protected KeyFactory(KeyFactorySpi keyFacSpi, Provider provider,
	126	String algorithm) {
	127	this.spi = keyFacSpi;
	128	this.provider = provider;
	129	this.algorithm = algorithm;
	130	}
	131
	132	private KeyFactory(String algorithm) throws NoSuchAlgorithmException {
	133	this.algorithm = algorithm;
	134	List<Service> list = GetInstance.getServices("KeyFactory", algorithm);
	135	serviceIterator = list.iterator();
	136	// fetch and instantiate initial spi
	137	if (nextSpi(null) == null) {
	138	throw new NoSuchAlgorithmException
	139	(algorithm + " KeyFactory not available");
	140	}
	141	}
	142
	143	/**
	144	* Returns a KeyFactory object that converts
	145	* public/private keys of the specified algorithm.
	146	*
	147	* <p> This method traverses the list of registered security Providers,
	148	* starting with the most preferred Provider.
	149	* A new KeyFactory object encapsulating the
	150	* KeyFactorySpi implementation from the first
	151	* Provider that supports the specified algorithm is returned.
	152	*
	153	* <p> Note that the list of registered providers may be retrieved via
	154	* the {@link Security#getProviders() Security.getProviders()} method.
	155	*
	156	* @param algorithm the name of the requested key algorithm.
	157	* See the KeyFactory section in the <a href=
	158	* "{@docRoot}/../technotes/guides/security/StandardNames.html#KeyFactory">
	159	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	160	* for information about standard algorithm names.
	161	*
	162	* @return the new KeyFactory object.
	163	*
	164	* @exception NoSuchAlgorithmException if no Provider supports a
	165	* KeyFactorySpi implementation for the
	166	* specified algorithm.
	167	*
	168	* @see Provider
	169	*/
	170	public static KeyFactory getInstance(String algorithm)
	171	throws NoSuchAlgorithmException {
	172	return new KeyFactory(algorithm);
	173	}
	174
	175	/**
	176	* Returns a KeyFactory object that converts
	177	* public/private keys of the specified algorithm.
	178	*
	179	* <p> A new KeyFactory object encapsulating the
	180	* KeyFactorySpi implementation from the specified provider
	181	* is returned. The specified provider must be registered
	182	* in the security provider list.
	183	*
	184	* <p> Note that the list of registered providers may be retrieved via
	185	* the {@link Security#getProviders() Security.getProviders()} method.
	186	*
	187	* @param algorithm the name of the requested key algorithm.
	188	* See the KeyFactory section in the <a href=
	189	* "{@docRoot}/../technotes/guides/security/StandardNames.html#KeyFactory">
	190	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	191	* for information about standard algorithm names.
	192	*
	193	* @param provider the name of the provider.
	194	*
	195	* @return the new KeyFactory object.
	196	*
	197	* @exception NoSuchAlgorithmException if a KeyFactorySpi
	198	* implementation for the specified algorithm is not
	199	* available from the specified provider.
	200	*
	201	* @exception NoSuchProviderException if the specified provider is not
	202	* registered in the security provider list.
	203	*
	204	* @exception IllegalArgumentException if the provider name is null
	205	* or empty.
	206	*
	207	* @see Provider
	208	*/
	209	public static KeyFactory getInstance(String algorithm, String provider)
	210	throws NoSuchAlgorithmException, NoSuchProviderException {
	211	Instance instance = GetInstance.getInstance("KeyFactory",
	212	KeyFactorySpi.class, algorithm, provider);
	213	return new KeyFactory((KeyFactorySpi)instance.impl,
	214	instance.provider, algorithm);
	215	}
	216
	217	/**
	218	* Returns a KeyFactory object that converts
	219	* public/private keys of the specified algorithm.
	220	*
	221	* <p> A new KeyFactory object encapsulating the
	222	* KeyFactorySpi implementation from the specified Provider
	223	* object is returned. Note that the specified Provider object
	224	* does not have to be registered in the provider list.
	225	*
	226	* @param algorithm the name of the requested key algorithm.
	227	* See the KeyFactory section in the <a href=
	228	* "{@docRoot}/../technotes/guides/security/StandardNames.html#KeyFactory">
	229	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	230	* for information about standard algorithm names.
	231	*
	232	* @param provider the provider.
	233	*
	234	* @return the new KeyFactory object.
	235	*
	236	* @exception NoSuchAlgorithmException if a KeyFactorySpi
	237	* implementation for the specified algorithm is not available
	238	* from the specified Provider object.
	239	*
	240	* @exception IllegalArgumentException if the specified provider is null.
	241	*
	242	* @see Provider
	243	*
	244	* @since 1.4
	245	*/
	246	public static KeyFactory getInstance(String algorithm, Provider provider)
	247	throws NoSuchAlgorithmException {
	248	Instance instance = GetInstance.getInstance("KeyFactory",
	249	KeyFactorySpi.class, algorithm, provider);
	250	return new KeyFactory((KeyFactorySpi)instance.impl,
	251	instance.provider, algorithm);
	252	}
	253
	254	/**
	255	* Returns the provider of this key factory object.
	256	*
	257	* @return the provider of this key factory object
	258	*/
	259	public final Provider getProvider() {
	260	synchronized (lock) {
	261	// disable further failover after this call
	262	serviceIterator = null;
	263	return provider;
	264	}
	265	}
	266
	267	/**
	268	* Gets the name of the algorithm
	269	* associated with this <tt>KeyFactory</tt>.
	270	*
	271	* @return the name of the algorithm associated with this
	272	* <tt>KeyFactory</tt>
	273	*/
	274	public final String getAlgorithm() {
	275	return this.algorithm;
	276	}
	277
	278	/**
	279	* Update the active KeyFactorySpi of this class and return the next
	280	* implementation for failover. If no more implemenations are
	281	* available, this method returns null. However, the active spi of
	282	* this class is never set to null.
	283	*/
	284	private KeyFactorySpi nextSpi(KeyFactorySpi oldSpi) {
	285	synchronized (lock) {
	286	// somebody else did a failover concurrently
	287	// try that spi now
	288	if ((oldSpi != null) && (oldSpi != spi)) {
	289	return spi;
	290	}
	291	if (serviceIterator == null) {
	292	return null;
	293	}
	294	while (serviceIterator.hasNext()) {
	295	Service s = serviceIterator.next();
	296	try {
	297	Object obj = s.newInstance(null);
	298	if (obj instanceof KeyFactorySpi == false) {
	299	continue;
	300	}
	301	KeyFactorySpi spi = (KeyFactorySpi)obj;
	302	provider = s.getProvider();
	303	this.spi = spi;
	304	return spi;
	305	} catch (NoSuchAlgorithmException e) {
	306	// ignore
	307	}
	308	}
	309	serviceIterator = null;
	310	return null;
	311	}
	312	}
	313
	314	/**
	315	* Generates a public key object from the provided key specification
	316	* (key material).
	317	*
	318	* @param keySpec the specification (key material) of the public key.
	319	*
	320	* @return the public key.
	321	*
	322	* @exception InvalidKeySpecException if the given key specification
	323	* is inappropriate for this key factory to produce a public key.
	324	*/
	325	public final PublicKey generatePublic(KeySpec keySpec)
	326	throws InvalidKeySpecException {
	327	if (serviceIterator == null) {
	328	return spi.engineGeneratePublic(keySpec);
	329	}
	330	Exception failure = null;
	331	KeyFactorySpi mySpi = spi;
	332	do {
	333	try {
	334	return mySpi.engineGeneratePublic(keySpec);
	335	} catch (Exception e) {
	336	if (failure == null) {
	337	failure = e;
	338	}
	339	mySpi = nextSpi(mySpi);
	340	}
	341	} while (mySpi != null);
	342	if (failure instanceof RuntimeException) {
	343	throw (RuntimeException)failure;
	344	}
	345	if (failure instanceof InvalidKeySpecException) {
	346	throw (InvalidKeySpecException)failure;
	347	}
	348	throw new InvalidKeySpecException
	349	("Could not generate public key", failure);
	350	}
	351
	352	/**
	353	* Generates a private key object from the provided key specification
	354	* (key material).
	355	*
	356	* @param keySpec the specification (key material) of the private key.
	357	*
	358	* @return the private key.
	359	*
	360	* @exception InvalidKeySpecException if the given key specification
	361	* is inappropriate for this key factory to produce a private key.
	362	*/
	363	public final PrivateKey generatePrivate(KeySpec keySpec)
	364	throws InvalidKeySpecException {
	365	if (serviceIterator == null) {
	366	return spi.engineGeneratePrivate(keySpec);
	367	}
	368	Exception failure = null;
	369	KeyFactorySpi mySpi = spi;
	370	do {
	371	try {
	372	return mySpi.engineGeneratePrivate(keySpec);
	373	} catch (Exception e) {
	374	if (failure == null) {
	375	failure = e;
	376	}
	377	mySpi = nextSpi(mySpi);
	378	}
	379	} while (mySpi != null);
	380	if (failure instanceof RuntimeException) {
	381	throw (RuntimeException)failure;
	382	}
	383	if (failure instanceof InvalidKeySpecException) {
	384	throw (InvalidKeySpecException)failure;
	385	}
	386	throw new InvalidKeySpecException
	387	("Could not generate private key", failure);
	388	}
	389
	390	/**
	391	* Returns a specification (key material) of the given key object.
	392	* <code>keySpec</code> identifies the specification class in which
	393	* the key material should be returned. It could, for example, be
	394	* <code>DSAPublicKeySpec.class</code>, to indicate that the
	395	* key material should be returned in an instance of the
	396	* <code>DSAPublicKeySpec</code> class.
	397	*
	398	* @param key the key.
	399	*
	400	* @param keySpec the specification class in which
	401	* the key material should be returned.
	402	*
	403	* @return the underlying key specification (key material) in an instance
	404	* of the requested specification class.
	405	*
	406	* @exception InvalidKeySpecException if the requested key specification is
	407	* inappropriate for the given key, or the given key cannot be processed
	408	* (e.g., the given key has an unrecognized algorithm or format).
	409	*/
	410	public final <T extends KeySpec> T getKeySpec(Key key, Class<T> keySpec)
	411	throws InvalidKeySpecException {
	412	if (serviceIterator == null) {
	413	return spi.engineGetKeySpec(key, keySpec);
	414	}
	415	Exception failure = null;
	416	KeyFactorySpi mySpi = spi;
	417	do {
	418	try {
	419	return mySpi.engineGetKeySpec(key, keySpec);
	420	} catch (Exception e) {
	421	if (failure == null) {
	422	failure = e;
	423	}
	424	mySpi = nextSpi(mySpi);
	425	}
	426	} while (mySpi != null);
	427	if (failure instanceof RuntimeException) {
	428	throw (RuntimeException)failure;
	429	}
	430	if (failure instanceof InvalidKeySpecException) {
	431	throw (InvalidKeySpecException)failure;
	432	}
	433	throw new InvalidKeySpecException
	434	("Could not get key spec", failure);
	435	}
	436
	437	/**
	438	* Translates a key object, whose provider may be unknown or potentially
	439	* untrusted, into a corresponding key object of this key factory.
	440	*
	441	* @param key the key whose provider is unknown or untrusted.
	442	*
	443	* @return the translated key.
	444	*
	445	* @exception InvalidKeyException if the given key cannot be processed
	446	* by this key factory.
	447	*/
	448	public final Key translateKey(Key key) throws InvalidKeyException {
	449	if (serviceIterator == null) {
	450	return spi.engineTranslateKey(key);
	451	}
	452	Exception failure = null;
	453	KeyFactorySpi mySpi = spi;
	454	do {
	455	try {
	456	return mySpi.engineTranslateKey(key);
	457	} catch (Exception e) {
	458	if (failure == null) {
	459	failure = e;
	460	}
	461	mySpi = nextSpi(mySpi);
	462	}
	463	} while (mySpi != null);
	464	if (failure instanceof RuntimeException) {
	465	throw (RuntimeException)failure;
	466	}
	467	if (failure instanceof InvalidKeyException) {
	468	throw (InvalidKeyException)failure;
	469	}
	470	throw new InvalidKeyException
	471	("Could not translate key", failure);
	472	}
	473
	474	}

java/pkg/java/security/KeyFactorySpi.class+0−0

Binary file not shown.

java/pkg/java/security/KeyFactorySpi.java+140−0

@@ -0,0 +1,140 @@
	1	/*
	2	* Copyright (c) 1997, 2004, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.security.spec.KeySpec;
	29	import java.security.spec.InvalidKeySpecException;
	30
	31	/**
	32	* This class defines the <i>Service Provider Interface</i> (<b>SPI</b>)
	33	* for the <code>KeyFactory</code> class.
	34	* All the abstract methods in this class must be implemented by each
	35	* cryptographic service provider who wishes to supply the implementation
	36	* of a key factory for a particular algorithm.
	37	*
	38	* <P> Key factories are used to convert <I>keys</I> (opaque
	39	* cryptographic keys of type <code>Key</code>) into <I>key specifications</I>
	40	* (transparent representations of the underlying key material), and vice
	41	* versa.
	42	*
	43	* <P> Key factories are bi-directional. That is, they allow you to build an
	44	* opaque key object from a given key specification (key material), or to
	45	* retrieve the underlying key material of a key object in a suitable format.
	46	*
	47	* <P> Multiple compatible key specifications may exist for the same key.
	48	* For example, a DSA public key may be specified using
	49	* <code>DSAPublicKeySpec</code> or
	50	* <code>X509EncodedKeySpec</code>. A key factory can be used to translate
	51	* between compatible key specifications.
	52	*
	53	* <P> A provider should document all the key specifications supported by its
	54	* key factory.
	55	*
	56	* @author Jan Luehe
	57	*
	58	*
	59	* @see KeyFactory
	60	* @see Key
	61	* @see PublicKey
	62	* @see PrivateKey
	63	* @see java.security.spec.KeySpec
	64	* @see java.security.spec.DSAPublicKeySpec
	65	* @see java.security.spec.X509EncodedKeySpec
	66	*
	67	* @since 1.2
	68	*/
	69
	70	public abstract class KeyFactorySpi {
	71
	72	/**
	73	* Generates a public key object from the provided key
	74	* specification (key material).
	75	*
	76	* @param keySpec the specification (key material) of the public key.
	77	*
	78	* @return the public key.
	79	*
	80	* @exception InvalidKeySpecException if the given key specification
	81	* is inappropriate for this key factory to produce a public key.
	82	*/
	83	protected abstract PublicKey engineGeneratePublic(KeySpec keySpec)
	84	throws InvalidKeySpecException;
	85
	86	/**
	87	* Generates a private key object from the provided key
	88	* specification (key material).
	89	*
	90	* @param keySpec the specification (key material) of the private key.
	91	*
	92	* @return the private key.
	93	*
	94	* @exception InvalidKeySpecException if the given key specification
	95	* is inappropriate for this key factory to produce a private key.
	96	*/
	97	protected abstract PrivateKey engineGeneratePrivate(KeySpec keySpec)
	98	throws InvalidKeySpecException;
	99
	100	/**
	101	* Returns a specification (key material) of the given key
	102	* object.
	103	* <code>keySpec</code> identifies the specification class in which
	104	* the key material should be returned. It could, for example, be
	105	* <code>DSAPublicKeySpec.class</code>, to indicate that the
	106	* key material should be returned in an instance of the
	107	* <code>DSAPublicKeySpec</code> class.
	108	*
	109	* @param key the key.
	110	*
	111	* @param keySpec the specification class in which
	112	* the key material should be returned.
	113	*
	114	* @return the underlying key specification (key material) in an instance
	115	* of the requested specification class.
	116
	117	* @exception InvalidKeySpecException if the requested key specification is
	118	* inappropriate for the given key, or the given key cannot be dealt with
	119	* (e.g., the given key has an unrecognized format).
	120	*/
	121	protected abstract <T extends KeySpec>
	122	T engineGetKeySpec(Key key, Class<T> keySpec)
	123	throws InvalidKeySpecException;
	124
	125	/**
	126	* Translates a key object, whose provider may be unknown or
	127	* potentially untrusted, into a corresponding key object of this key
	128	* factory.
	129	*
	130	* @param key the key whose provider is unknown or untrusted.
	131	*
	132	* @return the translated key.
	133	*
	134	* @exception InvalidKeyException if the given key cannot be processed
	135	* by this key factory.
	136	*/
	137	protected abstract Key engineTranslateKey(Key key)
	138	throws InvalidKeyException;
	139
	140	}

java/pkg/java/security/KeyManagementException.class+0−0

Binary file not shown.

java/pkg/java/security/KeyManagementException.java+99−0

@@ -0,0 +1,99 @@
	1	/*
	2	* Copyright (c) 1996, 2003, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	/**
	29	* This is the general key management exception for all operations
	30	* dealing with key management. Examples of subclasses of
	31	* KeyManagementException that developers might create for
	32	* giving more detailed information could include:
	33	*
	34	* <ul>
	35	* <li>KeyIDConflictException
	36	* <li>KeyAuthorizationFailureException
	37	* <li>ExpiredKeyException
	38	* </ul>
	39	*
	40	* @author Benjamin Renaud
	41	*
	42	* @see Key
	43	* @see KeyException
	44	*/
	45
	46	public class KeyManagementException extends KeyException {
	47
	48	private static final long serialVersionUID = 947674216157062695L;
	49
	50	/**
	51	* Constructs a KeyManagementException with no detail message. A
	52	* detail message is a String that describes this particular
	53	* exception.
	54	*/
	55	public KeyManagementException() {
	56	super();
	57	}
	58
	59	/**
	60	* Constructs a KeyManagementException with the specified detail
	61	* message. A detail message is a String that describes this
	62	* particular exception.
	63	*
	64	* @param msg the detail message.
	65	*/
	66	public KeyManagementException(String msg) {
	67	super(msg);
	68	}
	69
	70	/**
	71	* Creates a <code>KeyManagementException</code> with the specified
	72	* detail message and cause.
	73	*
	74	* @param message the detail message (which is saved for later retrieval
	75	* by the {@link #getMessage()} method).
	76	* @param cause the cause (which is saved for later retrieval by the
	77	* {@link #getCause()} method). (A <tt>null</tt> value is permitted,
	78	* and indicates that the cause is nonexistent or unknown.)
	79	* @since 1.5
	80	*/
	81	public KeyManagementException(String message, Throwable cause) {
	82	super(message, cause);
	83	}
	84
	85	/**
	86	* Creates a <code>KeyManagementException</code> with the specified cause
	87	* and a detail message of <tt>(cause==null ? null : cause.toString())</tt>
	88	* (which typically contains the class and detail message of
	89	* <tt>cause</tt>).
	90	*
	91	* @param cause the cause (which is saved for later retrieval by the
	92	* {@link #getCause()} method). (A <tt>null</tt> value is permitted,
	93	* and indicates that the cause is nonexistent or unknown.)
	94	* @since 1.5
	95	*/
	96	public KeyManagementException(Throwable cause) {
	97	super(cause);
	98	}
	99	}

java/pkg/java/security/KeyPair.class+0−0

Binary file not shown.

java/pkg/java/security/KeyPair.java+81−0

@@ -0,0 +1,81 @@
	1	/*
	2	* Copyright (c) 1996, 2003, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.util.*;
	29
	30	/**
	31	* This class is a simple holder for a key pair (a public key and a
	32	* private key). It does not enforce any security, and, when initialized,
	33	* should be treated like a PrivateKey.
	34	*
	35	* @see PublicKey
	36	* @see PrivateKey
	37	*
	38	* @author Benjamin Renaud
	39	*/
	40
	41	public final class KeyPair implements java.io.Serializable {
	42
	43	private static final long serialVersionUID = -7565189502268009837L;
	44
	45	private PrivateKey privateKey;
	46	private PublicKey publicKey;
	47
	48	/**
	49	* Constructs a key pair from the given public key and private key.
	50	*
	51	* <p>Note that this constructor only stores references to the public
	52	* and private key components in the generated key pair. This is safe,
	53	* because <code>Key</code> objects are immutable.
	54	*
	55	* @param publicKey the public key.
	56	*
	57	* @param privateKey the private key.
	58	*/
	59	public KeyPair(PublicKey publicKey, PrivateKey privateKey) {
	60	this.publicKey = publicKey;
	61	this.privateKey = privateKey;
	62	}
	63
	64	/**
	65	* Returns a reference to the public key component of this key pair.
	66	*
	67	* @return a reference to the public key.
	68	*/
	69	public PublicKey getPublic() {
	70	return publicKey;
	71	}
	72
	73	/**
	74	* Returns a reference to the private key component of this key pair.
	75	*
	76	* @return a reference to the private key.
	77	*/
	78	public PrivateKey getPrivate() {
	79	return privateKey;
	80	}
	81	}

java/pkg/java/security/KeyPairGenerator$Delegate.class+0−0

Binary file not shown.

java/pkg/java/security/KeyPairGenerator.class+0−0

Binary file not shown.

java/pkg/java/security/KeyPairGenerator.java+699−0

@@ -0,0 +1,699 @@
	1	/*
	2	* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.util.*;
	29
	30	import java.security.spec.AlgorithmParameterSpec;
	31
	32	import java.security.Provider.Service;
	33
	34	import sun.security.jca.*;
	35	import sun.security.jca.GetInstance.Instance;
	36
	37	/**
	38	* The KeyPairGenerator class is used to generate pairs of
	39	* public and private keys. Key pair generators are constructed using the
	40	* <code>getInstance</code> factory methods (static methods that
	41	* return instances of a given class).
	42	*
	43	* <p>A Key pair generator for a particular algorithm creates a public/private
	44	* key pair that can be used with this algorithm. It also associates
	45	* algorithm-specific parameters with each of the generated keys.
	46	*
	47	* <p>There are two ways to generate a key pair: in an algorithm-independent
	48	* manner, and in an algorithm-specific manner.
	49	* The only difference between the two is the initialization of the object:
	50	*
	51	* <ul>
	52	* <li><b>Algorithm-Independent Initialization</b>
	53	* <p>All key pair generators share the concepts of a keysize and a
	54	* source of randomness. The keysize is interpreted differently for different
	55	* algorithms (e.g., in the case of the <i>DSA</i> algorithm, the keysize
	56	* corresponds to the length of the modulus).
	57	* There is an
	58	* {@link #initialize(int, java.security.SecureRandom) initialize}
	59	* method in this KeyPairGenerator class that takes these two universally
	60	* shared types of arguments. There is also one that takes just a
	61	* <code>keysize</code> argument, and uses the <code>SecureRandom</code>
	62	* implementation of the highest-priority installed provider as the source
	63	* of randomness. (If none of the installed providers supply an implementation
	64	* of <code>SecureRandom</code>, a system-provided source of randomness is
	65	* used.)
	66	*
	67	* <p>Since no other parameters are specified when you call the above
	68	* algorithm-independent <code>initialize</code> methods, it is up to the
	69	* provider what to do about the algorithm-specific parameters (if any) to be
	70	* associated with each of the keys.
	71	*
	72	* <p>If the algorithm is the <i>DSA</i> algorithm, and the keysize (modulus
	73	* size) is 512, 768, or 1024, then the <i>Sun</i> provider uses a set of
	74	* precomputed values for the <code>p</code>, <code>q</code>, and
	75	* <code>g</code> parameters. If the modulus size is not one of the above
	76	* values, the <i>Sun</i> provider creates a new set of parameters. Other
	77	* providers might have precomputed parameter sets for more than just the
	78	* three modulus sizes mentioned above. Still others might not have a list of
	79	* precomputed parameters at all and instead always create new parameter sets.
	80	* <p>
	81	*
	82	* <li><b>Algorithm-Specific Initialization</b>
	83	* <p>For situations where a set of algorithm-specific parameters already
	84	* exists (e.g., so-called <i>community parameters</i> in DSA), there are two
	85	* {@link #initialize(java.security.spec.AlgorithmParameterSpec)
	86	* initialize} methods that have an <code>AlgorithmParameterSpec</code>
	87	* argument. One also has a <code>SecureRandom</code> argument, while the
	88	* the other uses the <code>SecureRandom</code>
	89	* implementation of the highest-priority installed provider as the source
	90	* of randomness. (If none of the installed providers supply an implementation
	91	* of <code>SecureRandom</code>, a system-provided source of randomness is
	92	* used.)
	93	* </ul>
	94	*
	95	* <p>In case the client does not explicitly initialize the KeyPairGenerator
	96	* (via a call to an <code>initialize</code> method), each provider must
	97	* supply (and document) a default initialization.
	98	* For example, the <i>Sun</i> provider uses a default modulus size (keysize)
	99	* of 1024 bits.
	100	*
	101	* <p>Note that this class is abstract and extends from
	102	* <code>KeyPairGeneratorSpi</code> for historical reasons.
	103	* Application developers should only take notice of the methods defined in
	104	* this <code>KeyPairGenerator</code> class; all the methods in
	105	* the superclass are intended for cryptographic service providers who wish to
	106	* supply their own implementations of key pair generators.
	107	*
	108	* <p> Every implementation of the Java platform is required to support the
	109	* following standard <code>KeyPairGenerator</code> algorithms and keysizes in
	110	* parentheses:
	111	* <ul>
	112	* <li><tt>DiffieHellman</tt> (1024)</li>
	113	* <li><tt>DSA</tt> (1024)</li>
	114	* <li><tt>RSA</tt> (1024, 2048)</li>
	115	* </ul>
	116	* These algorithms are described in the <a href=
	117	* "{@docRoot}/../technotes/guides/security/StandardNames.html#KeyPairGenerator">
	118	* KeyPairGenerator section</a> of the
	119	* Java Cryptography Architecture Standard Algorithm Name Documentation.
	120	* Consult the release documentation for your implementation to see if any
	121	* other algorithms are supported.
	122	*
	123	* @author Benjamin Renaud
	124	*
	125	* @see java.security.spec.AlgorithmParameterSpec
	126	*/
	127
	128	public abstract class KeyPairGenerator extends KeyPairGeneratorSpi {
	129
	130	private final String algorithm;
	131
	132	// The provider
	133	Provider provider;
	134
	135	/**
	136	* Creates a KeyPairGenerator object for the specified algorithm.
	137	*
	138	* @param algorithm the standard string name of the algorithm.
	139	* See the KeyPairGenerator section in the <a href=
	140	* "{@docRoot}/../technotes/guides/security/StandardNames.html#KeyPairGenerator">
	141	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	142	* for information about standard algorithm names.
	143	*/
	144	protected KeyPairGenerator(String algorithm) {
	145	this.algorithm = algorithm;
	146	}
	147
	148	/**
	149	* Returns the standard name of the algorithm for this key pair generator.
	150	* See the KeyPairGenerator section in the <a href=
	151	* "{@docRoot}/../technotes/guides/security/StandardNames.html#KeyPairGenerator">
	152	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	153	* for information about standard algorithm names.
	154	*
	155	* @return the standard string name of the algorithm.
	156	*/
	157	public String getAlgorithm() {
	158	return this.algorithm;
	159	}
	160
	161	private static KeyPairGenerator getInstance(Instance instance,
	162	String algorithm) {
	163	KeyPairGenerator kpg;
	164	if (instance.impl instanceof KeyPairGenerator) {
	165	kpg = (KeyPairGenerator)instance.impl;
	166	} else {
	167	KeyPairGeneratorSpi spi = (KeyPairGeneratorSpi)instance.impl;
	168	kpg = new Delegate(spi, algorithm);
	169	}
	170	kpg.provider = instance.provider;
	171	return kpg;
	172	}
	173
	174	/**
	175	* Returns a KeyPairGenerator object that generates public/private
	176	* key pairs for the specified algorithm.
	177	*
	178	* <p> This method traverses the list of registered security Providers,
	179	* starting with the most preferred Provider.
	180	* A new KeyPairGenerator object encapsulating the
	181	* KeyPairGeneratorSpi implementation from the first
	182	* Provider that supports the specified algorithm is returned.
	183	*
	184	* <p> Note that the list of registered providers may be retrieved via
	185	* the {@link Security#getProviders() Security.getProviders()} method.
	186	*
	187	* @param algorithm the standard string name of the algorithm.
	188	* See the KeyPairGenerator section in the <a href=
	189	* "{@docRoot}/../technotes/guides/security/StandardNames.html#KeyPairGenerator">
	190	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	191	* for information about standard algorithm names.
	192	*
	193	* @return the new KeyPairGenerator object.
	194	*
	195	* @exception NoSuchAlgorithmException if no Provider supports a
	196	* KeyPairGeneratorSpi implementation for the
	197	* specified algorithm.
	198	*
	199	* @see Provider
	200	*/
	201	public static KeyPairGenerator getInstance(String algorithm)
	202	throws NoSuchAlgorithmException {
	203	List<Service> list =
	204	GetInstance.getServices("KeyPairGenerator", algorithm);
	205	Iterator<Service> t = list.iterator();
	206	if (t.hasNext() == false) {
	207	throw new NoSuchAlgorithmException
	208	(algorithm + " KeyPairGenerator not available");
	209	}
	210	// find a working Spi or KeyPairGenerator subclass
	211	NoSuchAlgorithmException failure = null;
	212	do {
	213	Service s = t.next();
	214	try {
	215	Instance instance =
	216	GetInstance.getInstance(s, KeyPairGeneratorSpi.class);
	217	if (instance.impl instanceof KeyPairGenerator) {
	218	return getInstance(instance, algorithm);
	219	} else {
	220	return new Delegate(instance, t, algorithm);
	221	}
	222	} catch (NoSuchAlgorithmException e) {
	223	if (failure == null) {
	224	failure = e;
	225	}
	226	}
	227	} while (t.hasNext());
	228	throw failure;
	229	}
	230
	231	/**
	232	* Returns a KeyPairGenerator object that generates public/private
	233	* key pairs for the specified algorithm.
	234	*
	235	* <p> A new KeyPairGenerator object encapsulating the
	236	* KeyPairGeneratorSpi implementation from the specified provider
	237	* is returned. The specified provider must be registered
	238	* in the security provider list.
	239	*
	240	* <p> Note that the list of registered providers may be retrieved via
	241	* the {@link Security#getProviders() Security.getProviders()} method.
	242	*
	243	* @param algorithm the standard string name of the algorithm.
	244	* See the KeyPairGenerator section in the <a href=
	245	* "{@docRoot}/../technotes/guides/security/StandardNames.html#KeyPairGenerator">
	246	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	247	* for information about standard algorithm names.
	248	*
	249	* @param provider the string name of the provider.
	250	*
	251	* @return the new KeyPairGenerator object.
	252	*
	253	* @exception NoSuchAlgorithmException if a KeyPairGeneratorSpi
	254	* implementation for the specified algorithm is not
	255	* available from the specified provider.
	256	*
	257	* @exception NoSuchProviderException if the specified provider is not
	258	* registered in the security provider list.
	259	*
	260	* @exception IllegalArgumentException if the provider name is null
	261	* or empty.
	262	*
	263	* @see Provider
	264	*/
	265	public static KeyPairGenerator getInstance(String algorithm,
	266	String provider)
	267	throws NoSuchAlgorithmException, NoSuchProviderException {
	268	Instance instance = GetInstance.getInstance("KeyPairGenerator",
	269	KeyPairGeneratorSpi.class, algorithm, provider);
	270	return getInstance(instance, algorithm);
	271	}
	272
	273	/**
	274	* Returns a KeyPairGenerator object that generates public/private
	275	* key pairs for the specified algorithm.
	276	*
	277	* <p> A new KeyPairGenerator object encapsulating the
	278	* KeyPairGeneratorSpi implementation from the specified Provider
	279	* object is returned. Note that the specified Provider object
	280	* does not have to be registered in the provider list.
	281	*
	282	* @param algorithm the standard string name of the algorithm.
	283	* See the KeyPairGenerator section in the <a href=
	284	* "{@docRoot}/../technotes/guides/security/StandardNames.html#KeyPairGenerator">
	285	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	286	* for information about standard algorithm names.
	287	*
	288	* @param provider the provider.
	289	*
	290	* @return the new KeyPairGenerator object.
	291	*
	292	* @exception NoSuchAlgorithmException if a KeyPairGeneratorSpi
	293	* implementation for the specified algorithm is not available
	294	* from the specified Provider object.
	295	*
	296	* @exception IllegalArgumentException if the specified provider is null.
	297	*
	298	* @see Provider
	299	*
	300	* @since 1.4
	301	*/
	302	public static KeyPairGenerator getInstance(String algorithm,
	303	Provider provider) throws NoSuchAlgorithmException {
	304	Instance instance = GetInstance.getInstance("KeyPairGenerator",
	305	KeyPairGeneratorSpi.class, algorithm, provider);
	306	return getInstance(instance, algorithm);
	307	}
	308
	309	/**
	310	* Returns the provider of this key pair generator object.
	311	*
	312	* @return the provider of this key pair generator object
	313	*/
	314	public final Provider getProvider() {
	315	disableFailover();
	316	return this.provider;
	317	}
	318
	319	void disableFailover() {
	320	// empty, overridden in Delegate
	321	}
	322
	323	/**
	324	* Initializes the key pair generator for a certain keysize using
	325	* a default parameter set and the <code>SecureRandom</code>
	326	* implementation of the highest-priority installed provider as the source
	327	* of randomness.
	328	* (If none of the installed providers supply an implementation of
	329	* <code>SecureRandom</code>, a system-provided source of randomness is
	330	* used.)
	331	*
	332	* @param keysize the keysize. This is an
	333	* algorithm-specific metric, such as modulus length, specified in
	334	* number of bits.
	335	*
	336	* @exception InvalidParameterException if the <code>keysize</code> is not
	337	* supported by this KeyPairGenerator object.
	338	*/
	339	public void initialize(int keysize) {
	340	initialize(keysize, JCAUtil.getSecureRandom());
	341	}
	342
	343	/**
	344	* Initializes the key pair generator for a certain keysize with
	345	* the given source of randomness (and a default parameter set).
	346	*
	347	* @param keysize the keysize. This is an
	348	* algorithm-specific metric, such as modulus length, specified in
	349	* number of bits.
	350	* @param random the source of randomness.
	351	*
	352	* @exception InvalidParameterException if the <code>keysize</code> is not
	353	* supported by this KeyPairGenerator object.
	354	*
	355	* @since 1.2
	356	*/
	357	public void initialize(int keysize, SecureRandom random) {
	358	// This does nothing, because either
	359	// 1. the implementation object returned by getInstance() is an
	360	// instance of KeyPairGenerator which has its own
	361	// initialize(keysize, random) method, so the application would
	362	// be calling that method directly, or
	363	// 2. the implementation returned by getInstance() is an instance
	364	// of Delegate, in which case initialize(keysize, random) is
	365	// overridden to call the corresponding SPI method.
	366	// (This is a special case, because the API and SPI method have the
	367	// same name.)
	368	}
	369
	370	/**
	371	* Initializes the key pair generator using the specified parameter
	372	* set and the <code>SecureRandom</code>
	373	* implementation of the highest-priority installed provider as the source
	374	* of randomness.
	375	* (If none of the installed providers supply an implementation of
	376	* <code>SecureRandom</code>, a system-provided source of randomness is
	377	* used.).
	378	*
	379	* <p>This concrete method has been added to this previously-defined
	380	* abstract class.
	381	* This method calls the KeyPairGeneratorSpi
	382	* {@link KeyPairGeneratorSpi#initialize(
	383	* java.security.spec.AlgorithmParameterSpec,
	384	* java.security.SecureRandom) initialize} method,
	385	* passing it <code>params</code> and a source of randomness (obtained
	386	* from the highest-priority installed provider or system-provided if none
	387	* of the installed providers supply one).
	388	* That <code>initialize</code> method always throws an
	389	* UnsupportedOperationException if it is not overridden by the provider.
	390	*
	391	* @param params the parameter set used to generate the keys.
	392	*
	393	* @exception InvalidAlgorithmParameterException if the given parameters
	394	* are inappropriate for this key pair generator.
	395	*
	396	* @since 1.2
	397	*/
	398	public void initialize(AlgorithmParameterSpec params)
	399	throws InvalidAlgorithmParameterException {
	400	initialize(params, JCAUtil.getSecureRandom());
	401	}
	402
	403	/**
	404	* Initializes the key pair generator with the given parameter
	405	* set and source of randomness.
	406	*
	407	* <p>This concrete method has been added to this previously-defined
	408	* abstract class.
	409	* This method calls the KeyPairGeneratorSpi {@link
	410	* KeyPairGeneratorSpi#initialize(
	411	* java.security.spec.AlgorithmParameterSpec,
	412	* java.security.SecureRandom) initialize} method,
	413	* passing it <code>params</code> and <code>random</code>.
	414	* That <code>initialize</code>
	415	* method always throws an
	416	* UnsupportedOperationException if it is not overridden by the provider.
	417	*
	418	* @param params the parameter set used to generate the keys.
	419	* @param random the source of randomness.
	420	*
	421	* @exception InvalidAlgorithmParameterException if the given parameters
	422	* are inappropriate for this key pair generator.
	423	*
	424	* @since 1.2
	425	*/
	426	public void initialize(AlgorithmParameterSpec params,
	427	SecureRandom random)
	428	throws InvalidAlgorithmParameterException
	429	{
	430	// This does nothing, because either
	431	// 1. the implementation object returned by getInstance() is an
	432	// instance of KeyPairGenerator which has its own
	433	// initialize(params, random) method, so the application would
	434	// be calling that method directly, or
	435	// 2. the implementation returned by getInstance() is an instance
	436	// of Delegate, in which case initialize(params, random) is
	437	// overridden to call the corresponding SPI method.
	438	// (This is a special case, because the API and SPI method have the
	439	// same name.)
	440	}
	441
	442	/**
	443	* Generates a key pair.
	444	*
	445	* <p>If this KeyPairGenerator has not been initialized explicitly,
	446	* provider-specific defaults will be used for the size and other
	447	* (algorithm-specific) values of the generated keys.
	448	*
	449	* <p>This will generate a new key pair every time it is called.
	450	*
	451	* <p>This method is functionally equivalent to
	452	* {@link #generateKeyPair() generateKeyPair}.
	453	*
	454	* @return the generated key pair
	455	*
	456	* @since 1.2
	457	*/
	458	public final KeyPair genKeyPair() {
	459	return generateKeyPair();
	460	}
	461
	462	/**
	463	* Generates a key pair.
	464	*
	465	* <p>If this KeyPairGenerator has not been initialized explicitly,
	466	* provider-specific defaults will be used for the size and other
	467	* (algorithm-specific) values of the generated keys.
	468	*
	469	* <p>This will generate a new key pair every time it is called.
	470	*
	471	* <p>This method is functionally equivalent to
	472	* {@link #genKeyPair() genKeyPair}.
	473	*
	474	* @return the generated key pair
	475	*/
	476	public KeyPair generateKeyPair() {
	477	// This does nothing (except returning null), because either:
	478	//
	479	// 1. the implementation object returned by getInstance() is an
	480	// instance of KeyPairGenerator which has its own implementation
	481	// of generateKeyPair (overriding this one), so the application
	482	// would be calling that method directly, or
	483	//
	484	// 2. the implementation returned by getInstance() is an instance
	485	// of Delegate, in which case generateKeyPair is
	486	// overridden to invoke the corresponding SPI method.
	487	//
	488	// (This is a special case, because in JDK 1.1.x the generateKeyPair
	489	// method was used both as an API and a SPI method.)
	490	return null;
	491	}
	492
	493
	494	/*
	495	* The following class allows providers to extend from KeyPairGeneratorSpi
	496	* rather than from KeyPairGenerator. It represents a KeyPairGenerator
	497	* with an encapsulated, provider-supplied SPI object (of type
	498	* KeyPairGeneratorSpi).
	499	* If the provider implementation is an instance of KeyPairGeneratorSpi,
	500	* the getInstance() methods above return an instance of this class, with
	501	* the SPI object encapsulated.
	502	*
	503	* Note: All SPI methods from the original KeyPairGenerator class have been
	504	* moved up the hierarchy into a new class (KeyPairGeneratorSpi), which has
	505	* been interposed in the hierarchy between the API (KeyPairGenerator)
	506	* and its original parent (Object).
	507	*/
	508
	509	//
	510	// error failover notes:
	511	//
	512	// . we failover if the implementation throws an error during init
	513	// by retrying the init on other providers
	514	//
	515	// . we also failover if the init succeeded but the subsequent call
	516	// to generateKeyPair() fails. In order for this to work, we need
	517	// to remember the parameters to the last successful call to init
	518	// and initialize() the next spi using them.
	519	//
	520	// . although not specified, KeyPairGenerators could be thread safe,
	521	// so we make sure we do not interfere with that
	522	//
	523	// . failover is not available, if:
	524	// . getInstance(algorithm, provider) was used
	525	// . a provider extends KeyPairGenerator rather than
	526	// KeyPairGeneratorSpi (JDK 1.1 style)
	527	// . once getProvider() is called
	528	//
	529
	530	private static final class Delegate extends KeyPairGenerator {
	531
	532	// The provider implementation (delegate)
	533	private volatile KeyPairGeneratorSpi spi;
	534
	535	private final Object lock = new Object();
	536
	537	private Iterator<Service> serviceIterator;
	538
	539	private final static int I_NONE = 1;
	540	private final static int I_SIZE = 2;
	541	private final static int I_PARAMS = 3;
	542
	543	private int initType;
	544	private int initKeySize;
	545	private AlgorithmParameterSpec initParams;
	546	private SecureRandom initRandom;
	547
	548	// constructor
	549	Delegate(KeyPairGeneratorSpi spi, String algorithm) {
	550	super(algorithm);
	551	this.spi = spi;
	552	}
	553
	554	Delegate(Instance instance, Iterator<Service> serviceIterator,
	555	String algorithm) {
	556	super(algorithm);
	557	spi = (KeyPairGeneratorSpi)instance.impl;
	558	provider = instance.provider;
	559	this.serviceIterator = serviceIterator;
	560	initType = I_NONE;
	561	}
	562
	563	/**
	564	* Update the active spi of this class and return the next
	565	* implementation for failover. If no more implemenations are
	566	* available, this method returns null. However, the active spi of
	567	* this class is never set to null.
	568	*/
	569	private KeyPairGeneratorSpi nextSpi(KeyPairGeneratorSpi oldSpi,
	570	boolean reinit) {
	571	synchronized (lock) {
	572	// somebody else did a failover concurrently
	573	// try that spi now
	574	if ((oldSpi != null) && (oldSpi != spi)) {
	575	return spi;
	576	}
	577	if (serviceIterator == null) {
	578	return null;
	579	}
	580	while (serviceIterator.hasNext()) {
	581	Service s = serviceIterator.next();
	582	try {
	583	Object inst = s.newInstance(null);
	584	// ignore non-spis
	585	if (inst instanceof KeyPairGeneratorSpi == false) {
	586	continue;
	587	}
	588	if (inst instanceof KeyPairGenerator) {
	589	continue;
	590	}
	591	KeyPairGeneratorSpi spi = (KeyPairGeneratorSpi)inst;
	592	if (reinit) {
	593	if (initType == I_SIZE) {
	594	spi.initialize(initKeySize, initRandom);
	595	} else if (initType == I_PARAMS) {
	596	spi.initialize(initParams, initRandom);
	597	} else if (initType != I_NONE) {
	598	throw new AssertionError
	599	("KeyPairGenerator initType: " + initType);
	600	}
	601	}
	602	provider = s.getProvider();
	603	this.spi = spi;
	604	return spi;
	605	} catch (Exception e) {
	606	// ignore
	607	}
	608	}
	609	disableFailover();
	610	return null;
	611	}
	612	}
	613
	614	void disableFailover() {
	615	serviceIterator = null;
	616	initType = 0;
	617	initParams = null;
	618	initRandom = null;
	619	}
	620
	621	// engine method
	622	public void initialize(int keysize, SecureRandom random) {
	623	if (serviceIterator == null) {
	624	spi.initialize(keysize, random);
	625	return;
	626	}
	627	RuntimeException failure = null;
	628	KeyPairGeneratorSpi mySpi = spi;
	629	do {
	630	try {
	631	mySpi.initialize(keysize, random);
	632	initType = I_SIZE;
	633	initKeySize = keysize;
	634	initParams = null;
	635	initRandom = random;
	636	return;
	637	} catch (RuntimeException e) {
	638	if (failure == null) {
	639	failure = e;
	640	}
	641	mySpi = nextSpi(mySpi, false);
	642	}
	643	} while (mySpi != null);
	644	throw failure;
	645	}
	646
	647	// engine method
	648	public void initialize(AlgorithmParameterSpec params,
	649	SecureRandom random) throws InvalidAlgorithmParameterException {
	650	if (serviceIterator == null) {
	651	spi.initialize(params, random);
	652	return;
	653	}
	654	Exception failure = null;
	655	KeyPairGeneratorSpi mySpi = spi;
	656	do {
	657	try {
	658	mySpi.initialize(params, random);
	659	initType = I_PARAMS;
	660	initKeySize = 0;
	661	initParams = params;
	662	initRandom = random;
	663	return;
	664	} catch (Exception e) {
	665	if (failure == null) {
	666	failure = e;
	667	}
	668	mySpi = nextSpi(mySpi, false);
	669	}
	670	} while (mySpi != null);
	671	if (failure instanceof RuntimeException) {
	672	throw (RuntimeException)failure;
	673	}
	674	// must be an InvalidAlgorithmParameterException
	675	throw (InvalidAlgorithmParameterException)failure;
	676	}
	677
	678	// engine method
	679	public KeyPair generateKeyPair() {
	680	if (serviceIterator == null) {
	681	return spi.generateKeyPair();
	682	}
	683	RuntimeException failure = null;
	684	KeyPairGeneratorSpi mySpi = spi;
	685	do {
	686	try {
	687	return mySpi.generateKeyPair();
	688	} catch (RuntimeException e) {
	689	if (failure == null) {
	690	failure = e;
	691	}
	692	mySpi = nextSpi(mySpi, true);
	693	}
	694	} while (mySpi != null);
	695	throw failure;
	696	}
	697	}
	698
	699	}

java/pkg/java/security/KeyPairGeneratorSpi.class+0−0

Binary file not shown.

java/pkg/java/security/KeyPairGeneratorSpi.java+106−0

@@ -0,0 +1,106 @@
	1	/*
	2	* Copyright (c) 1997, 1999, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.security.spec.AlgorithmParameterSpec;
	29
	30	/**
	31	* <p> This class defines the <i>Service Provider Interface</i> (<b>SPI</b>)
	32	* for the <code>KeyPairGenerator</code> class, which is used to generate
	33	* pairs of public and private keys.
	34	*
	35	* <p> All the abstract methods in this class must be implemented by each
	36	* cryptographic service provider who wishes to supply the implementation
	37	* of a key pair generator for a particular algorithm.
	38	*
	39	* <p> In case the client does not explicitly initialize the KeyPairGenerator
	40	* (via a call to an <code>initialize</code> method), each provider must
	41	* supply (and document) a default initialization.
	42	* For example, the <i>Sun</i> provider uses a default modulus size (keysize)
	43	* of 1024 bits.
	44	*
	45	* @author Benjamin Renaud
	46	*
	47	*
	48	* @see KeyPairGenerator
	49	* @see java.security.spec.AlgorithmParameterSpec
	50	*/
	51
	52	public abstract class KeyPairGeneratorSpi {
	53
	54	/**
	55	* Initializes the key pair generator for a certain keysize, using
	56	* the default parameter set.
	57	*
	58	* @param keysize the keysize. This is an
	59	* algorithm-specific metric, such as modulus length, specified in
	60	* number of bits.
	61	*
	62	* @param random the source of randomness for this generator.
	63	*
	64	* @exception InvalidParameterException if the <code>keysize</code> is not
	65	* supported by this KeyPairGeneratorSpi object.
	66	*/
	67	public abstract void initialize(int keysize, SecureRandom random);
	68
	69	/**
	70	* Initializes the key pair generator using the specified parameter
	71	* set and user-provided source of randomness.
	72	*
	73	* <p>This concrete method has been added to this previously-defined
	74	* abstract class. (For backwards compatibility, it cannot be abstract.)
	75	* It may be overridden by a provider to initialize the key pair
	76	* generator. Such an override
	77	* is expected to throw an InvalidAlgorithmParameterException if
	78	* a parameter is inappropriate for this key pair generator.
	79	* If this method is not overridden, it always throws an
	80	* UnsupportedOperationException.
	81	*
	82	* @param params the parameter set used to generate the keys.
	83	*
	84	* @param random the source of randomness for this generator.
	85	*
	86	* @exception InvalidAlgorithmParameterException if the given parameters
	87	* are inappropriate for this key pair generator.
	88	*
	89	* @since 1.2
	90	*/
	91	public void initialize(AlgorithmParameterSpec params,
	92	SecureRandom random)
	93	throws InvalidAlgorithmParameterException {
	94	throw new UnsupportedOperationException();
	95	}
	96
	97	/**
	98	* Generates a key pair. Unless an initialization method is called
	99	* using a KeyPairGenerator interface, algorithm-specific defaults
	100	* will be used. This will generate a new key pair every time it
	101	* is called.
	102	*
	103	* @return the newly generated <tt>KeyPair</tt>
	104	*/
	105	public abstract KeyPair generateKeyPair();
	106	}

java/pkg/java/security/KeyRep$Type.class+0−0

Binary file not shown.

java/pkg/java/security/KeyRep.class+0−0

Binary file not shown.

java/pkg/java/security/KeyRep.java+195−0

@@ -0,0 +1,195 @@
	1	/*
	2	* Copyright (c) 2003, 2006, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.io.*;
	29
	30	import java.security.spec.PKCS8EncodedKeySpec;
	31	import java.security.spec.X509EncodedKeySpec;
	32	import java.security.spec.InvalidKeySpecException;
	33
	34	import javax.crypto.SecretKeyFactory;
	35	import javax.crypto.spec.SecretKeySpec;
	36
	37	/**
	38	* Standardized representation for serialized Key objects.
	39	*
	40	* <p>
	41	*
	42	* Note that a serialized Key may contain sensitive information
	43	* which should not be exposed in untrusted environments. See the
	44	* <a href="../../../platform/serialization/spec/security.html">
	45	* Security Appendix</a>
	46	* of the Serialization Specification for more information.
	47	*
	48	* @see Key
	49	* @see KeyFactory
	50	* @see javax.crypto.spec.SecretKeySpec
	51	* @see java.security.spec.X509EncodedKeySpec
	52	* @see java.security.spec.PKCS8EncodedKeySpec
	53	*
	54	* @since 1.5
	55	*/
	56
	57	public class KeyRep implements Serializable {
	58
	59	private static final long serialVersionUID = -4757683898830641853L;
	60
	61	/**
	62	* Key type.
	63	*
	64	* @since 1.5
	65	*/
	66	public static enum Type {
	67
	68	/** Type for secret keys. */
	69	SECRET,
	70
	71	/** Type for public keys. */
	72	PUBLIC,
	73
	74	/** Type for private keys. */
	75	PRIVATE,
	76
	77	}
	78
	79	private static final String PKCS8 = "PKCS#8";
	80	private static final String X509 = "X.509";
	81	private static final String RAW = "RAW";
	82
	83	/**
	84	* Either one of Type.SECRET, Type.PUBLIC, or Type.PRIVATE
	85	*
	86	* @serial
	87	*/
	88	private Type type;
	89
	90	/**
	91	* The Key algorithm
	92	*
	93	* @serial
	94	*/
	95	private String algorithm;
	96
	97	/**
	98	* The Key encoding format
	99	*
	100	* @serial
	101	*/
	102	private String format;
	103
	104	/**
	105	* The encoded Key bytes
	106	*
	107	* @serial
	108	*/
	109	private byte[] encoded;
	110
	111	/**
	112	* Construct the alternate Key class.
	113	*
	114	* <p>
	115	*
	116	* @param type either one of Type.SECRET, Type.PUBLIC, or Type.PRIVATE
	117	* @param algorithm the algorithm returned from
	118	* <code>Key.getAlgorithm()</code>
	119	* @param format the encoding format returned from
	120	* <code>Key.getFormat()</code>
	121	* @param encoded the encoded bytes returned from
	122	* <code>Key.getEncoded()</code>
	123	*
	124	* @exception NullPointerException
	125	* if type is <code>null</code>,
	126	* if algorithm is <code>null</code>,
	127	* if format is <code>null</code>,
	128	* or if encoded is <code>null</code>
	129	*/
	130	public KeyRep(Type type, String algorithm,
	131	String format, byte[] encoded) {
	132
	133	if (type == null \|\| algorithm == null \|\|
	134	format == null \|\| encoded == null) {
	135	throw new NullPointerException("invalid null input(s)");
	136	}
	137
	138	this.type = type;
	139	this.algorithm = algorithm;
	140	this.format = format.toUpperCase();
	141	this.encoded = encoded.clone();
	142	}
	143
	144	/**
	145	* Resolve the Key object.
	146	*
	147	* <p> This method supports three Type/format combinations:
	148	* <ul>
	149	* <li> Type.SECRET/"RAW" - returns a SecretKeySpec object
	150	* constructed using encoded key bytes and algorithm
	151	* <li> Type.PUBLIC/"X.509" - gets a KeyFactory instance for
	152	* the key algorithm, constructs an X509EncodedKeySpec with the
	153	* encoded key bytes, and generates a public key from the spec
	154	* <li> Type.PRIVATE/"PKCS#8" - gets a KeyFactory instance for
	155	* the key algorithm, constructs a PKCS8EncodedKeySpec with the
	156	* encoded key bytes, and generates a private key from the spec
	157	* </ul>
	158	*
	159	* <p>
	160	*
	161	* @return the resolved Key object
	162	*
	163	* @exception ObjectStreamException if the Type/format
	164	* combination is unrecognized, if the algorithm, key format, or
	165	* encoded key bytes are unrecognized/invalid, of if the
	166	* resolution of the key fails for any reason
	167	*/
	168	protected Object readResolve() throws ObjectStreamException {
	169	try {
	170	if (type == Type.SECRET && RAW.equals(format)) {
	171	return new SecretKeySpec(encoded, algorithm);
	172	} else if (type == Type.PUBLIC && X509.equals(format)) {
	173	KeyFactory f = KeyFactory.getInstance(algorithm);
	174	return f.generatePublic(new X509EncodedKeySpec(encoded));
	175	} else if (type == Type.PRIVATE && PKCS8.equals(format)) {
	176	KeyFactory f = KeyFactory.getInstance(algorithm);
	177	return f.generatePrivate(new PKCS8EncodedKeySpec(encoded));
	178	} else {
	179	throw new NotSerializableException
	180	("unrecognized type/format combination: " +
	181	type + "/" + format);
	182	}
	183	} catch (NotSerializableException nse) {
	184	throw nse;
	185	} catch (Exception e) {
	186	NotSerializableException nse = new NotSerializableException
	187	("java.security.Key: " +
	188	"[" + type + "] " +
	189	"[" + algorithm + "] " +
	190	"[" + format + "]");
	191	nse.initCause(e);
	192	throw nse;
	193	}
	194	}
	195	}

java/pkg/java/security/KeyStore$1.class+0−0

Binary file not shown.

java/pkg/java/security/KeyStore$Builder$1.class+0−0

Binary file not shown.

java/pkg/java/security/KeyStore$Builder$2$1.class+0−0

Binary file not shown.

java/pkg/java/security/KeyStore$Builder$2.class+0−0

Binary file not shown.

java/pkg/java/security/KeyStore$Builder$FileBuilder$1.class+0−0

Binary file not shown.

java/pkg/java/security/KeyStore$Builder$FileBuilder.class+0−0

Binary file not shown.

java/pkg/java/security/KeyStore$Builder.class+0−0

Binary file not shown.

java/pkg/java/security/KeyStore$CallbackHandlerProtection.class+0−0

Binary file not shown.

java/pkg/java/security/KeyStore$Entry.class+0−0

Binary file not shown.

java/pkg/java/security/KeyStore$LoadStoreParameter.class+0−0

Binary file not shown.

java/pkg/java/security/KeyStore$PasswordProtection.class+0−0

Binary file not shown.

java/pkg/java/security/KeyStore$PrivateKeyEntry.class+0−0

Binary file not shown.

java/pkg/java/security/KeyStore$ProtectionParameter.class+0−0

Binary file not shown.

java/pkg/java/security/KeyStore$SecretKeyEntry.class+0−0

Binary file not shown.

java/pkg/java/security/KeyStore$SimpleLoadStoreParameter.class+0−0

Binary file not shown.

java/pkg/java/security/KeyStore$TrustedCertificateEntry.class+0−0

Binary file not shown.

java/pkg/java/security/KeyStore.class+0−0

Binary file not shown.

java/pkg/java/security/KeyStore.java+1769−0

@@ -0,0 +1,1769 @@
	1	/*
	2	* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.io.*;
	29	import java.security.cert.Certificate;
	30	import java.security.cert.X509Certificate;
	31	import java.security.cert.CertificateException;
	32	import java.util.*;
	33	import javax.crypto.SecretKey;
	34
	35	import javax.security.auth.callback.*;
	36
	37	/**
	38	* This class represents a storage facility for cryptographic
	39	* keys and certificates.
	40	*
	41	* <p> A <code>KeyStore</code> manages different types of entries.
	42	* Each type of entry implements the <code>KeyStore.Entry</code> interface.
	43	* Three basic <code>KeyStore.Entry</code> implementations are provided:
	44	*
	45	* <ul>
	46	* <li><b>KeyStore.PrivateKeyEntry</b>
	47	* <p> This type of entry holds a cryptographic <code>PrivateKey</code>,
	48	* which is optionally stored in a protected format to prevent
	49	* unauthorized access. It is also accompanied by a certificate chain
	50	* for the corresponding public key.
	51	*
	52	* <p> Private keys and certificate chains are used by a given entity for
	53	* self-authentication. Applications for this authentication include software
	54	* distribution organizations which sign JAR files as part of releasing
	55	* and/or licensing software.
	56	*
	57	* <li><b>KeyStore.SecretKeyEntry</b>
	58	* <p> This type of entry holds a cryptographic <code>SecretKey</code>,
	59	* which is optionally stored in a protected format to prevent
	60	* unauthorized access.
	61	*
	62	* <li><b>KeyStore.TrustedCertificateEntry</b>
	63	* <p> This type of entry contains a single public key <code>Certificate</code>
	64	* belonging to another party. It is called a <i>trusted certificate</i>
	65	* because the keystore owner trusts that the public key in the certificate
	66	* indeed belongs to the identity identified by the <i>subject</i> (owner)
	67	* of the certificate.
	68	*
	69	* <p>This type of entry can be used to authenticate other parties.
	70	* </ul>
	71	*
	72	* <p> Each entry in a keystore is identified by an "alias" string. In the
	73	* case of private keys and their associated certificate chains, these strings
	74	* distinguish among the different ways in which the entity may authenticate
	75	* itself. For example, the entity may authenticate itself using different
	76	* certificate authorities, or using different public key algorithms.
	77	*
	78	* <p> Whether aliases are case sensitive is implementation dependent. In order
	79	* to avoid problems, it is recommended not to use aliases in a KeyStore that
	80	* only differ in case.
	81	*
	82	* <p> Whether keystores are persistent, and the mechanisms used by the
	83	* keystore if it is persistent, are not specified here. This allows
	84	* use of a variety of techniques for protecting sensitive (e.g., private or
	85	* secret) keys. Smart cards or other integrated cryptographic engines
	86	* (SafeKeyper) are one option, and simpler mechanisms such as files may also
	87	* be used (in a variety of formats).
	88	*
	89	* <p> Typical ways to request a KeyStore object include
	90	* relying on the default type and providing a specific keystore type.
	91	*
	92	* <ul>
	93	* <li>To rely on the default type:
	94	* <pre>
	95	* KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());
	96	* </pre>
	97	* The system will return a keystore implementation for the default type.
	98	* <p>
	99	*
	100	* <li>To provide a specific keystore type:
	101	* <pre>
	102	* KeyStore ks = KeyStore.getInstance("JKS");
	103	* </pre>
	104	* The system will return the most preferred implementation of the
	105	* specified keystore type available in the environment. <p>
	106	* </ul>
	107	*
	108	* <p> Before a keystore can be accessed, it must be
	109	* {@link #load(java.io.InputStream, char[]) loaded}.
	110	* <pre>
	111	* KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());
	112	*
	113	* // get user password and file input stream
	114	* char[] password = getPassword();
	115	*
	116	* java.io.FileInputStream fis = null;
	117	* try {
	118	* fis = new java.io.FileInputStream("keyStoreName");
	119	* ks.load(fis, password);
	120	* } finally {
	121	* if (fis != null) {
	122	* fis.close();
	123	* }
	124	* }
	125	* </pre>
	126	*
	127	* To create an empty keystore using the above <code>load</code> method,
	128	* pass <code>null</code> as the <code>InputStream</code> argument.
	129	*
	130	* <p> Once the keystore has been loaded, it is possible
	131	* to read existing entries from the keystore, or to write new entries
	132	* into the keystore:
	133	* <pre>
	134	* KeyStore.ProtectionParameter protParam =
	135	* new KeyStore.PasswordProtection(password);
	136	*
	137	* // get my private key
	138	* KeyStore.PrivateKeyEntry pkEntry = (KeyStore.PrivateKeyEntry)
	139	* ks.getEntry("privateKeyAlias", protParam);
	140	* PrivateKey myPrivateKey = pkEntry.getPrivateKey();
	141	*
	142	* // save my secret key
	143	* javax.crypto.SecretKey mySecretKey;
	144	* KeyStore.SecretKeyEntry skEntry =
	145	* new KeyStore.SecretKeyEntry(mySecretKey);
	146	* ks.setEntry("secretKeyAlias", skEntry, protParam);
	147	*
	148	* // store away the keystore
	149	* java.io.FileOutputStream fos = null;
	150	* try {
	151	* fos = new java.io.FileOutputStream("newKeyStoreName");
	152	* ks.store(fos, password);
	153	* } finally {
	154	* if (fos != null) {
	155	* fos.close();
	156	* }
	157	* }
	158	* </pre>
	159	*
	160	* Note that although the same password may be used to
	161	* load the keystore, to protect the private key entry,
	162	* to protect the secret key entry, and to store the keystore
	163	* (as is shown in the sample code above),
	164	* different passwords or other protection parameters
	165	* may also be used.
	166	*
	167	* <p> Every implementation of the Java platform is required to support
	168	* the following standard <code>KeyStore</code> type:
	169	* <ul>
	170	* <li><tt>PKCS12</tt></li>
	171	* </ul>
	172	* This type is described in the <a href=
	173	* "{@docRoot}/../technotes/guides/security/StandardNames.html#KeyStore">
	174	* KeyStore section</a> of the
	175	* Java Cryptography Architecture Standard Algorithm Name Documentation.
	176	* Consult the release documentation for your implementation to see if any
	177	* other types are supported.
	178	*
	179	* @author Jan Luehe
	180	*
	181	* @see java.security.PrivateKey
	182	* @see javax.crypto.SecretKey
	183	* @see java.security.cert.Certificate
	184	*
	185	* @since 1.2
	186	*/
	187
	188	public class KeyStore {
	189
	190	/*
	191	* Constant to lookup in the Security properties file to determine
	192	* the default keystore type.
	193	* In the Security properties file, the default keystore type is given as:
	194	* <pre>
	195	* keystore.type=jks
	196	* </pre>
	197	*/
	198	private static final String KEYSTORE_TYPE = "keystore.type";
	199
	200	// The keystore type
	201	private String type;
	202
	203	// The provider
	204	private Provider provider;
	205
	206	// The provider implementation
	207	private KeyStoreSpi keyStoreSpi;
	208
	209	// Has this keystore been initialized (loaded)?
	210	private boolean initialized = false;
	211
	212	/**
	213	* A marker interface for <code>KeyStore</code>
	214	* {@link #load(KeyStore.LoadStoreParameter) load}
	215	* and
	216	* {@link #store(KeyStore.LoadStoreParameter) store}
	217	* parameters.
	218	*
	219	* @since 1.5
	220	*/
	221	public static interface LoadStoreParameter {
	222	/**
	223	* Gets the parameter used to protect keystore data.
	224	*
	225	* @return the parameter used to protect keystore data, or null
	226	*/
	227	public ProtectionParameter getProtectionParameter();
	228	}
	229
	230	/**
	231	* A marker interface for keystore protection parameters.
	232	*
	233	* <p> The information stored in a <code>ProtectionParameter</code>
	234	* object protects the contents of a keystore.
	235	* For example, protection parameters may be used to check
	236	* the integrity of keystore data, or to protect the
	237	* confidentiality of sensitive keystore data
	238	* (such as a <code>PrivateKey</code>).
	239	*
	240	* @since 1.5
	241	*/
	242	public static interface ProtectionParameter { }
	243
	244	/**
	245	* A password-based implementation of <code>ProtectionParameter</code>.
	246	*
	247	* @since 1.5
	248	*/
	249	public static class PasswordProtection implements
	250	ProtectionParameter, javax.security.auth.Destroyable {
	251
	252	private final char[] password;
	253	private volatile boolean destroyed = false;
	254
	255	/**
	256	* Creates a password parameter.
	257	*
	258	* <p> The specified <code>password</code> is cloned before it is stored
	259	* in the new <code>PasswordProtection</code> object.
	260	*
	261	* @param password the password, which may be <code>null</code>
	262	*/
	263	public PasswordProtection(char[] password) {
	264	this.password = (password == null) ? null : password.clone();
	265	}
	266
	267	/**
	268	* Gets the password.
	269	*
	270	* <p>Note that this method returns a reference to the password.
	271	* If a clone of the array is created it is the caller's
	272	* responsibility to zero out the password information
	273	* after it is no longer needed.
	274	*
	275	* @see #destroy()
	276	* @return the password, which may be <code>null</code>
	277	* @exception IllegalStateException if the password has
	278	* been cleared (destroyed)
	279	*/
	280	public synchronized char[] getPassword() {
	281	if (destroyed) {
	282	throw new IllegalStateException("password has been cleared");
	283	}
	284	return password;
	285	}
	286
	287	/**
	288	* Clears the password.
	289	*
	290	* @exception DestroyFailedException if this method was unable
	291	* to clear the password
	292	*/
	293	public synchronized void destroy()
	294	throws javax.security.auth.DestroyFailedException {
	295	destroyed = true;
	296	if (password != null) {
	297	Arrays.fill(password, ' ');
	298	}
	299	}
	300
	301	/**
	302	* Determines if password has been cleared.
	303	*
	304	* @return true if the password has been cleared, false otherwise
	305	*/
	306	public synchronized boolean isDestroyed() {
	307	return destroyed;
	308	}
	309	}
	310
	311	/**
	312	* A ProtectionParameter encapsulating a CallbackHandler.
	313	*
	314	* @since 1.5
	315	*/
	316	public static class CallbackHandlerProtection
	317	implements ProtectionParameter {
	318
	319	private final CallbackHandler handler;
	320
	321	/**
	322	* Constructs a new CallbackHandlerProtection from a
	323	* CallbackHandler.
	324	*
	325	* @param handler the CallbackHandler
	326	* @exception NullPointerException if handler is null
	327	*/
	328	public CallbackHandlerProtection(CallbackHandler handler) {
	329	if (handler == null) {
	330	throw new NullPointerException("handler must not be null");
	331	}
	332	this.handler = handler;
	333	}
	334
	335	/**
	336	* Returns the CallbackHandler.
	337	*
	338	* @return the CallbackHandler.
	339	*/
	340	public CallbackHandler getCallbackHandler() {
	341	return handler;
	342	}
	343
	344	}
	345
	346	/**
	347	* A marker interface for <code>KeyStore</code> entry types.
	348	*
	349	* @since 1.5
	350	*/
	351	public static interface Entry { }
	352
	353	/**
	354	* A <code>KeyStore</code> entry that holds a <code>PrivateKey</code>
	355	* and corresponding certificate chain.
	356	*
	357	* @since 1.5
	358	*/
	359	public static final class PrivateKeyEntry implements Entry {
	360
	361	private final PrivateKey privKey;
	362	private final Certificate[] chain;
	363
	364	/**
	365	* Constructs a <code>PrivateKeyEntry</code> with a
	366	* <code>PrivateKey</code> and corresponding certificate chain.
	367	*
	368	* <p> The specified <code>chain</code> is cloned before it is stored
	369	* in the new <code>PrivateKeyEntry</code> object.
	370	*
	371	* @param privateKey the <code>PrivateKey</code>
	372	* @param chain an array of <code>Certificate</code>s
	373	* representing the certificate chain.
	374	* The chain must be ordered and contain a
	375	* <code>Certificate</code> at index 0
	376	* corresponding to the private key.
	377	*
	378	* @exception NullPointerException if
	379	* <code>privateKey</code> or <code>chain</code>
	380	* is <code>null</code>
	381	* @exception IllegalArgumentException if the specified chain has a
	382	* length of 0, if the specified chain does not contain
	383	* <code>Certificate</code>s of the same type,
	384	* or if the <code>PrivateKey</code> algorithm
	385	* does not match the algorithm of the <code>PublicKey</code>
	386	* in the end entity <code>Certificate</code> (at index 0)
	387	*/
	388	public PrivateKeyEntry(PrivateKey privateKey, Certificate[] chain) {
	389	if (privateKey == null \|\| chain == null) {
	390	throw new NullPointerException("invalid null input");
	391	}
	392	if (chain.length == 0) {
	393	throw new IllegalArgumentException
	394	("invalid zero-length input chain");
	395	}
	396
	397	Certificate[] clonedChain = chain.clone();
	398	String certType = clonedChain[0].getType();
	399	for (int i = 1; i < clonedChain.length; i++) {
	400	if (!certType.equals(clonedChain[i].getType())) {
	401	throw new IllegalArgumentException
	402	("chain does not contain certificates " +
	403	"of the same type");
	404	}
	405	}
	406	if (!privateKey.getAlgorithm().equals
	407	(clonedChain[0].getPublicKey().getAlgorithm())) {
	408	throw new IllegalArgumentException
	409	("private key algorithm does not match " +
	410	"algorithm of public key in end entity " +
	411	"certificate (at index 0)");
	412	}
	413	this.privKey = privateKey;
	414
	415	if (clonedChain[0] instanceof X509Certificate &&
	416	!(clonedChain instanceof X509Certificate[])) {
	417
	418	this.chain = new X509Certificate[clonedChain.length];
	419	System.arraycopy(clonedChain, 0,
	420	this.chain, 0, clonedChain.length);
	421	} else {
	422	this.chain = clonedChain;
	423	}
	424	}
	425
	426	/**
	427	* Gets the <code>PrivateKey</code> from this entry.
	428	*
	429	* @return the <code>PrivateKey</code> from this entry
	430	*/
	431	public PrivateKey getPrivateKey() {
	432	return privKey;
	433	}
	434
	435	/**
	436	* Gets the <code>Certificate</code> chain from this entry.
	437	*
	438	* <p> The stored chain is cloned before being returned.
	439	*
	440	* @return an array of <code>Certificate</code>s corresponding
	441	* to the certificate chain for the public key.
	442	* If the certificates are of type X.509,
	443	* the runtime type of the returned array is
	444	* <code>X509Certificate[]</code>.
	445	*/
	446	public Certificate[] getCertificateChain() {
	447	return chain.clone();
	448	}
	449
	450	/**
	451	* Gets the end entity <code>Certificate</code>
	452	* from the certificate chain in this entry.
	453	*
	454	* @return the end entity <code>Certificate</code> (at index 0)
	455	* from the certificate chain in this entry.
	456	* If the certificate is of type X.509,
	457	* the runtime type of the returned certificate is
	458	* <code>X509Certificate</code>.
	459	*/
	460	public Certificate getCertificate() {
	461	return chain[0];
	462	}
	463
	464	/**
	465	* Returns a string representation of this PrivateKeyEntry.
	466	* @return a string representation of this PrivateKeyEntry.
	467	*/
	468	public String toString() {
	469	StringBuilder sb = new StringBuilder();
	470	sb.append("Private key entry and certificate chain with "
	471	+ chain.length + " elements:\r\n");
	472	for (Certificate cert : chain) {
	473	sb.append(cert);
	474	sb.append("\r\n");
	475	}
	476	return sb.toString();
	477	}
	478
	479	}
	480
	481	/**
	482	* A <code>KeyStore</code> entry that holds a <code>SecretKey</code>.
	483	*
	484	* @since 1.5
	485	*/
	486	public static final class SecretKeyEntry implements Entry {
	487
	488	private final SecretKey sKey;
	489
	490	/**
	491	* Constructs a <code>SecretKeyEntry</code> with a
	492	* <code>SecretKey</code>.
	493	*
	494	* @param secretKey the <code>SecretKey</code>
	495	*
	496	* @exception NullPointerException if <code>secretKey</code>
	497	* is <code>null</code>
	498	*/
	499	public SecretKeyEntry(SecretKey secretKey) {
	500	if (secretKey == null) {
	501	throw new NullPointerException("invalid null input");
	502	}
	503	this.sKey = secretKey;
	504	}
	505
	506	/**
	507	* Gets the <code>SecretKey</code> from this entry.
	508	*
	509	* @return the <code>SecretKey</code> from this entry
	510	*/
	511	public SecretKey getSecretKey() {
	512	return sKey;
	513	}
	514
	515	/**
	516	* Returns a string representation of this SecretKeyEntry.
	517	* @return a string representation of this SecretKeyEntry.
	518	*/
	519	public String toString() {
	520	return "Secret key entry with algorithm " + sKey.getAlgorithm();
	521	}
	522	}
	523
	524	/**
	525	* A <code>KeyStore</code> entry that holds a trusted
	526	* <code>Certificate</code>.
	527	*
	528	* @since 1.5
	529	*/
	530	public static final class TrustedCertificateEntry implements Entry {
	531
	532	private final Certificate cert;
	533
	534	/**
	535	* Constructs a <code>TrustedCertificateEntry</code> with a
	536	* trusted <code>Certificate</code>.
	537	*
	538	* @param trustedCert the trusted <code>Certificate</code>
	539	*
	540	* @exception NullPointerException if
	541	* <code>trustedCert</code> is <code>null</code>
	542	*/
	543	public TrustedCertificateEntry(Certificate trustedCert) {
	544	if (trustedCert == null) {
	545	throw new NullPointerException("invalid null input");
	546	}
	547	this.cert = trustedCert;
	548	}
	549
	550	/**
	551	* Gets the trusted <code>Certficate</code> from this entry.
	552	*
	553	* @return the trusted <code>Certificate</code> from this entry
	554	*/
	555	public Certificate getTrustedCertificate() {
	556	return cert;
	557	}
	558
	559	/**
	560	* Returns a string representation of this TrustedCertificateEntry.
	561	* @return a string representation of this TrustedCertificateEntry.
	562	*/
	563	public String toString() {
	564	return "Trusted certificate entry:\r\n" + cert.toString();
	565	}
	566	}
	567
	568	/**
	569	* Creates a KeyStore object of the given type, and encapsulates the given
	570	* provider implementation (SPI object) in it.
	571	*
	572	* @param keyStoreSpi the provider implementation.
	573	* @param provider the provider.
	574	* @param type the keystore type.
	575	*/
	576	protected KeyStore(KeyStoreSpi keyStoreSpi, Provider provider, String type)
	577	{
	578	this.keyStoreSpi = keyStoreSpi;
	579	this.provider = provider;
	580	this.type = type;
	581	}
	582
	583	/**
	584	* Returns a keystore object of the specified type.
	585	*
	586	* <p> This method traverses the list of registered security Providers,
	587	* starting with the most preferred Provider.
	588	* A new KeyStore object encapsulating the
	589	* KeyStoreSpi implementation from the first
	590	* Provider that supports the specified type is returned.
	591	*
	592	* <p> Note that the list of registered providers may be retrieved via
	593	* the {@link Security#getProviders() Security.getProviders()} method.
	594	*
	595	* @param type the type of keystore.
	596	* See the KeyStore section in the <a href=
	597	* "{@docRoot}/../technotes/guides/security/StandardNames.html#KeyStore">
	598	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	599	* for information about standard keystore types.
	600	*
	601	* @return a keystore object of the specified type.
	602	*
	603	* @exception KeyStoreException if no Provider supports a
	604	* KeyStoreSpi implementation for the
	605	* specified type.
	606	*
	607	* @see Provider
	608	*/
	609	public static KeyStore getInstance(String type)
	610	throws KeyStoreException
	611	{
	612	try {
	613	Object[] objs = Security.getImpl(type, "KeyStore", (String)null);
	614	return new KeyStore((KeyStoreSpi)objs[0], (Provider)objs[1], type);
	615	} catch (NoSuchAlgorithmException nsae) {
	616	throw new KeyStoreException(type + " not found", nsae);
	617	} catch (NoSuchProviderException nspe) {
	618	throw new KeyStoreException(type + " not found", nspe);
	619	}
	620	}
	621
	622	/**
	623	* Returns a keystore object of the specified type.
	624	*
	625	* <p> A new KeyStore object encapsulating the
	626	* KeyStoreSpi implementation from the specified provider
	627	* is returned. The specified provider must be registered
	628	* in the security provider list.
	629	*
	630	* <p> Note that the list of registered providers may be retrieved via
	631	* the {@link Security#getProviders() Security.getProviders()} method.
	632	*
	633	* @param type the type of keystore.
	634	* See the KeyStore section in the <a href=
	635	* "{@docRoot}/../technotes/guides/security/StandardNames.html#KeyStore">
	636	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	637	* for information about standard keystore types.
	638	*
	639	* @param provider the name of the provider.
	640	*
	641	* @return a keystore object of the specified type.
	642	*
	643	* @exception KeyStoreException if a KeyStoreSpi
	644	* implementation for the specified type is not
	645	* available from the specified provider.
	646	*
	647	* @exception NoSuchProviderException if the specified provider is not
	648	* registered in the security provider list.
	649	*
	650	* @exception IllegalArgumentException if the provider name is null
	651	* or empty.
	652	*
	653	* @see Provider
	654	*/
	655	public static KeyStore getInstance(String type, String provider)
	656	throws KeyStoreException, NoSuchProviderException
	657	{
	658	if (provider == null \|\| provider.length() == 0)
	659	throw new IllegalArgumentException("missing provider");
	660	try {
	661	Object[] objs = Security.getImpl(type, "KeyStore", provider);
	662	return new KeyStore((KeyStoreSpi)objs[0], (Provider)objs[1], type);
	663	} catch (NoSuchAlgorithmException nsae) {
	664	throw new KeyStoreException(type + " not found", nsae);
	665	}
	666	}
	667
	668	/**
	669	* Returns a keystore object of the specified type.
	670	*
	671	* <p> A new KeyStore object encapsulating the
	672	* KeyStoreSpi implementation from the specified Provider
	673	* object is returned. Note that the specified Provider object
	674	* does not have to be registered in the provider list.
	675	*
	676	* @param type the type of keystore.
	677	* See the KeyStore section in the <a href=
	678	* "{@docRoot}/../technotes/guides/security/StandardNames.html#KeyStore">
	679	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	680	* for information about standard keystore types.
	681	*
	682	* @param provider the provider.
	683	*
	684	* @return a keystore object of the specified type.
	685	*
	686	* @exception KeyStoreException if KeyStoreSpi
	687	* implementation for the specified type is not available
	688	* from the specified Provider object.
	689	*
	690	* @exception IllegalArgumentException if the specified provider is null.
	691	*
	692	* @see Provider
	693	*
	694	* @since 1.4
	695	*/
	696	public static KeyStore getInstance(String type, Provider provider)
	697	throws KeyStoreException
	698	{
	699	if (provider == null)
	700	throw new IllegalArgumentException("missing provider");
	701	try {
	702	Object[] objs = Security.getImpl(type, "KeyStore", provider);
	703	return new KeyStore((KeyStoreSpi)objs[0], (Provider)objs[1], type);
	704	} catch (NoSuchAlgorithmException nsae) {
	705	throw new KeyStoreException(type + " not found", nsae);
	706	}
	707	}
	708
	709	/**
	710	* Returns the default keystore type as specified in the Java security
	711	* properties file, or the string
	712	* "jks" (acronym for "Java keystore")
	713	* if no such property exists.
	714	* The Java security properties file is located in the file named
	715	* <JAVA_HOME>/lib/security/java.security.
	716	* <JAVA_HOME> refers to the value of the java.home system property,
	717	* and specifies the directory where the JRE is installed.
	718	*
	719	* <p>The default keystore type can be used by applications that do not
	720	* want to use a hard-coded keystore type when calling one of the
	721	* <code>getInstance</code> methods, and want to provide a default keystore
	722	* type in case a user does not specify its own.
	723	*
	724	* <p>The default keystore type can be changed by setting the value of the
	725	* "keystore.type" security property (in the Java security properties
	726	* file) to the desired keystore type.
	727	*
	728	* @return the default keystore type as specified in the
	729	* Java security properties file, or the string "jks"
	730	* if no such property exists.
	731	*/
	732	public final static String getDefaultType() {
	733	String kstype;
	734	kstype = AccessController.doPrivileged(new PrivilegedAction<String>() {
	735	public String run() {
	736	return Security.getProperty(KEYSTORE_TYPE);
	737	}
	738	});
	739	if (kstype == null) {
	740	kstype = "jks";
	741	}
	742	return kstype;
	743	}
	744
	745	/**
	746	* Returns the provider of this keystore.
	747	*
	748	* @return the provider of this keystore.
	749	*/
	750	public final Provider getProvider()
	751	{
	752	return this.provider;
	753	}
	754
	755	/**
	756	* Returns the type of this keystore.
	757	*
	758	* @return the type of this keystore.
	759	*/
	760	public final String getType()
	761	{
	762	return this.type;
	763	}
	764
	765	/**
	766	* Returns the key associated with the given alias, using the given
	767	* password to recover it. The key must have been associated with
	768	* the alias by a call to <code>setKeyEntry</code>,
	769	* or by a call to <code>setEntry</code> with a
	770	* <code>PrivateKeyEntry</code> or <code>SecretKeyEntry</code>.
	771	*
	772	* @param alias the alias name
	773	* @param password the password for recovering the key
	774	*
	775	* @return the requested key, or null if the given alias does not exist
	776	* or does not identify a key-related entry.
	777	*
	778	* @exception KeyStoreException if the keystore has not been initialized
	779	* (loaded).
	780	* @exception NoSuchAlgorithmException if the algorithm for recovering the
	781	* key cannot be found
	782	* @exception UnrecoverableKeyException if the key cannot be recovered
	783	* (e.g., the given password is wrong).
	784	*/
	785	public final Key getKey(String alias, char[] password)
	786	throws KeyStoreException, NoSuchAlgorithmException,
	787	UnrecoverableKeyException
	788	{
	789	if (!initialized) {
	790	throw new KeyStoreException("Uninitialized keystore");
	791	}
	792	return keyStoreSpi.engineGetKey(alias, password);
	793	}
	794
	795	/**
	796	* Returns the certificate chain associated with the given alias.
	797	* The certificate chain must have been associated with the alias
	798	* by a call to <code>setKeyEntry</code>,
	799	* or by a call to <code>setEntry</code> with a
	800	* <code>PrivateKeyEntry</code>.
	801	*
	802	* @param alias the alias name
	803	*
	804	* @return the certificate chain (ordered with the user's certificate first
	805	* followed by zero or more certificate authorities), or null if the given alias
	806	* does not exist or does not contain a certificate chain
	807	*
	808	* @exception KeyStoreException if the keystore has not been initialized
	809	* (loaded).
	810	*/
	811	public final Certificate[] getCertificateChain(String alias)
	812	throws KeyStoreException
	813	{
	814	if (!initialized) {
	815	throw new KeyStoreException("Uninitialized keystore");
	816	}
	817	return keyStoreSpi.engineGetCertificateChain(alias);
	818	}
	819
	820	/**
	821	* Returns the certificate associated with the given alias.
	822	*
	823	* <p> If the given alias name identifies an entry
	824	* created by a call to <code>setCertificateEntry</code>,
	825	* or created by a call to <code>setEntry</code> with a
	826	* <code>TrustedCertificateEntry</code>,
	827	* then the trusted certificate contained in that entry is returned.
	828	*
	829	* <p> If the given alias name identifies an entry
	830	* created by a call to <code>setKeyEntry</code>,
	831	* or created by a call to <code>setEntry</code> with a
	832	* <code>PrivateKeyEntry</code>,
	833	* then the first element of the certificate chain in that entry
	834	* is returned.
	835	*
	836	* @param alias the alias name
	837	*
	838	* @return the certificate, or null if the given alias does not exist or
	839	* does not contain a certificate.
	840	*
	841	* @exception KeyStoreException if the keystore has not been initialized
	842	* (loaded).
	843	*/
	844	public final Certificate getCertificate(String alias)
	845	throws KeyStoreException
	846	{
	847	if (!initialized) {
	848	throw new KeyStoreException("Uninitialized keystore");
	849	}
	850	return keyStoreSpi.engineGetCertificate(alias);
	851	}
	852
	853	/**
	854	* Returns the creation date of the entry identified by the given alias.
	855	*
	856	* @param alias the alias name
	857	*
	858	* @return the creation date of this entry, or null if the given alias does
	859	* not exist
	860	*
	861	* @exception KeyStoreException if the keystore has not been initialized
	862	* (loaded).
	863	*/
	864	public final Date getCreationDate(String alias)
	865	throws KeyStoreException
	866	{
	867	if (!initialized) {
	868	throw new KeyStoreException("Uninitialized keystore");
	869	}
	870	return keyStoreSpi.engineGetCreationDate(alias);
	871	}
	872
	873	/**
	874	* Assigns the given key to the given alias, protecting it with the given
	875	* password.
	876	*
	877	* <p>If the given key is of type <code>java.security.PrivateKey</code>,
	878	* it must be accompanied by a certificate chain certifying the
	879	* corresponding public key.
	880	*
	881	* <p>If the given alias already exists, the keystore information
	882	* associated with it is overridden by the given key (and possibly
	883	* certificate chain).
	884	*
	885	* @param alias the alias name
	886	* @param key the key to be associated with the alias
	887	* @param password the password to protect the key
	888	* @param chain the certificate chain for the corresponding public
	889	* key (only required if the given key is of type
	890	* <code>java.security.PrivateKey</code>).
	891	*
	892	* @exception KeyStoreException if the keystore has not been initialized
	893	* (loaded), the given key cannot be protected, or this operation fails
	894	* for some other reason
	895	*/
	896	public final void setKeyEntry(String alias, Key key, char[] password,
	897	Certificate[] chain)
	898	throws KeyStoreException
	899	{
	900	if (!initialized) {
	901	throw new KeyStoreException("Uninitialized keystore");
	902	}
	903	if ((key instanceof PrivateKey) &&
	904	(chain == null \|\| chain.length == 0)) {
	905	throw new IllegalArgumentException("Private key must be "
	906	+ "accompanied by certificate "
	907	+ "chain");
	908	}
	909	keyStoreSpi.engineSetKeyEntry(alias, key, password, chain);
	910	}
	911
	912	/**
	913	* Assigns the given key (that has already been protected) to the given
	914	* alias.
	915	*
	916	* <p>If the protected key is of type
	917	* <code>java.security.PrivateKey</code>, it must be accompanied by a
	918	* certificate chain certifying the corresponding public key. If the
	919	* underlying keystore implementation is of type <code>jks</code>,
	920	* <code>key</code> must be encoded as an
	921	* <code>EncryptedPrivateKeyInfo</code> as defined in the PKCS #8 standard.
	922	*
	923	* <p>If the given alias already exists, the keystore information
	924	* associated with it is overridden by the given key (and possibly
	925	* certificate chain).
	926	*
	927	* @param alias the alias name
	928	* @param key the key (in protected format) to be associated with the alias
	929	* @param chain the certificate chain for the corresponding public
	930	* key (only useful if the protected key is of type
	931	* <code>java.security.PrivateKey</code>).
	932	*
	933	* @exception KeyStoreException if the keystore has not been initialized
	934	* (loaded), or if this operation fails for some other reason.
	935	*/
	936	public final void setKeyEntry(String alias, byte[] key,
	937	Certificate[] chain)
	938	throws KeyStoreException
	939	{
	940	if (!initialized) {
	941	throw new KeyStoreException("Uninitialized keystore");
	942	}
	943	keyStoreSpi.engineSetKeyEntry(alias, key, chain);
	944	}
	945
	946	/**
	947	* Assigns the given trusted certificate to the given alias.
	948	*
	949	* <p> If the given alias identifies an existing entry
	950	* created by a call to <code>setCertificateEntry</code>,
	951	* or created by a call to <code>setEntry</code> with a
	952	* <code>TrustedCertificateEntry</code>,
	953	* the trusted certificate in the existing entry
	954	* is overridden by the given certificate.
	955	*
	956	* @param alias the alias name
	957	* @param cert the certificate
	958	*
	959	* @exception KeyStoreException if the keystore has not been initialized,
	960	* or the given alias already exists and does not identify an
	961	* entry containing a trusted certificate,
	962	* or this operation fails for some other reason.
	963	*/
	964	public final void setCertificateEntry(String alias, Certificate cert)
	965	throws KeyStoreException
	966	{
	967	if (!initialized) {
	968	throw new KeyStoreException("Uninitialized keystore");
	969	}
	970	keyStoreSpi.engineSetCertificateEntry(alias, cert);
	971	}
	972
	973	/**
	974	* Deletes the entry identified by the given alias from this keystore.
	975	*
	976	* @param alias the alias name
	977	*
	978	* @exception KeyStoreException if the keystore has not been initialized,
	979	* or if the entry cannot be removed.
	980	*/
	981	public final void deleteEntry(String alias)
	982	throws KeyStoreException
	983	{
	984	if (!initialized) {
	985	throw new KeyStoreException("Uninitialized keystore");
	986	}
	987	keyStoreSpi.engineDeleteEntry(alias);
	988	}
	989
	990	/**
	991	* Lists all the alias names of this keystore.
	992	*
	993	* @return enumeration of the alias names
	994	*
	995	* @exception KeyStoreException if the keystore has not been initialized
	996	* (loaded).
	997	*/
	998	public final Enumeration<String> aliases()
	999	throws KeyStoreException
	1000	{
	1001	if (!initialized) {
	1002	throw new KeyStoreException("Uninitialized keystore");
	1003	}
	1004	return keyStoreSpi.engineAliases();
	1005	}
	1006
	1007	/**
	1008	* Checks if the given alias exists in this keystore.
	1009	*
	1010	* @param alias the alias name
	1011	*
	1012	* @return true if the alias exists, false otherwise
	1013	*
	1014	* @exception KeyStoreException if the keystore has not been initialized
	1015	* (loaded).
	1016	*/
	1017	public final boolean containsAlias(String alias)
	1018	throws KeyStoreException
	1019	{
	1020	if (!initialized) {
	1021	throw new KeyStoreException("Uninitialized keystore");
	1022	}
	1023	return keyStoreSpi.engineContainsAlias(alias);
	1024	}
	1025
	1026	/**
	1027	* Retrieves the number of entries in this keystore.
	1028	*
	1029	* @return the number of entries in this keystore
	1030	*
	1031	* @exception KeyStoreException if the keystore has not been initialized
	1032	* (loaded).
	1033	*/
	1034	public final int size()
	1035	throws KeyStoreException
	1036	{
	1037	if (!initialized) {
	1038	throw new KeyStoreException("Uninitialized keystore");
	1039	}
	1040	return keyStoreSpi.engineSize();
	1041	}
	1042
	1043	/**
	1044	* Returns true if the entry identified by the given alias
	1045	* was created by a call to <code>setKeyEntry</code>,
	1046	* or created by a call to <code>setEntry</code> with a
	1047	* <code>PrivateKeyEntry</code> or a <code>SecretKeyEntry</code>.
	1048	*
	1049	* @param alias the alias for the keystore entry to be checked
	1050	*
	1051	* @return true if the entry identified by the given alias is a
	1052	* key-related entry, false otherwise.
	1053	*
	1054	* @exception KeyStoreException if the keystore has not been initialized
	1055	* (loaded).
	1056	*/
	1057	public final boolean isKeyEntry(String alias)
	1058	throws KeyStoreException
	1059	{
	1060	if (!initialized) {
	1061	throw new KeyStoreException("Uninitialized keystore");
	1062	}
	1063	return keyStoreSpi.engineIsKeyEntry(alias);
	1064	}
	1065
	1066	/**
	1067	* Returns true if the entry identified by the given alias
	1068	* was created by a call to <code>setCertificateEntry</code>,
	1069	* or created by a call to <code>setEntry</code> with a
	1070	* <code>TrustedCertificateEntry</code>.
	1071	*
	1072	* @param alias the alias for the keystore entry to be checked
	1073	*
	1074	* @return true if the entry identified by the given alias contains a
	1075	* trusted certificate, false otherwise.
	1076	*
	1077	* @exception KeyStoreException if the keystore has not been initialized
	1078	* (loaded).
	1079	*/
	1080	public final boolean isCertificateEntry(String alias)
	1081	throws KeyStoreException
	1082	{
	1083	if (!initialized) {
	1084	throw new KeyStoreException("Uninitialized keystore");
	1085	}
	1086	return keyStoreSpi.engineIsCertificateEntry(alias);
	1087	}
	1088
	1089	/**
	1090	* Returns the (alias) name of the first keystore entry whose certificate
	1091	* matches the given certificate.
	1092	*
	1093	* <p> This method attempts to match the given certificate with each
	1094	* keystore entry. If the entry being considered was
	1095	* created by a call to <code>setCertificateEntry</code>,
	1096	* or created by a call to <code>setEntry</code> with a
	1097	* <code>TrustedCertificateEntry</code>,
	1098	* then the given certificate is compared to that entry's certificate.
	1099	*
	1100	* <p> If the entry being considered was
	1101	* created by a call to <code>setKeyEntry</code>,
	1102	* or created by a call to <code>setEntry</code> with a
	1103	* <code>PrivateKeyEntry</code>,
	1104	* then the given certificate is compared to the first
	1105	* element of that entry's certificate chain.
	1106	*
	1107	* @param cert the certificate to match with.
	1108	*
	1109	* @return the alias name of the first entry with a matching certificate,
	1110	* or null if no such entry exists in this keystore.
	1111	*
	1112	* @exception KeyStoreException if the keystore has not been initialized
	1113	* (loaded).
	1114	*/
	1115	public final String getCertificateAlias(Certificate cert)
	1116	throws KeyStoreException
	1117	{
	1118	if (!initialized) {
	1119	throw new KeyStoreException("Uninitialized keystore");
	1120	}
	1121	return keyStoreSpi.engineGetCertificateAlias(cert);
	1122	}
	1123
	1124	/**
	1125	* Stores this keystore to the given output stream, and protects its
	1126	* integrity with the given password.
	1127	*
	1128	* @param stream the output stream to which this keystore is written.
	1129	* @param password the password to generate the keystore integrity check
	1130	*
	1131	* @exception KeyStoreException if the keystore has not been initialized
	1132	* (loaded).
	1133	* @exception IOException if there was an I/O problem with data
	1134	* @exception NoSuchAlgorithmException if the appropriate data integrity
	1135	* algorithm could not be found
	1136	* @exception CertificateException if any of the certificates included in
	1137	* the keystore data could not be stored
	1138	*/
	1139	public final void store(OutputStream stream, char[] password)
	1140	throws KeyStoreException, IOException, NoSuchAlgorithmException,
	1141	CertificateException
	1142	{
	1143	if (!initialized) {
	1144	throw new KeyStoreException("Uninitialized keystore");
	1145	}
	1146	keyStoreSpi.engineStore(stream, password);
	1147	}
	1148
	1149	/**
	1150	* Stores this keystore using the given <code>LoadStoreParameter</code>.
	1151	*
	1152	* @param param the <code>LoadStoreParameter</code>
	1153	* that specifies how to store the keystore,
	1154	* which may be <code>null</code>
	1155	*
	1156	* @exception IllegalArgumentException if the given
	1157	* <code>LoadStoreParameter</code>
	1158	* input is not recognized
	1159	* @exception KeyStoreException if the keystore has not been initialized
	1160	* (loaded)
	1161	* @exception IOException if there was an I/O problem with data
	1162	* @exception NoSuchAlgorithmException if the appropriate data integrity
	1163	* algorithm could not be found
	1164	* @exception CertificateException if any of the certificates included in
	1165	* the keystore data could not be stored
	1166	*
	1167	* @since 1.5
	1168	*/
	1169	public final void store(LoadStoreParameter param)
	1170	throws KeyStoreException, IOException,
	1171	NoSuchAlgorithmException, CertificateException {
	1172	if (!initialized) {
	1173	throw new KeyStoreException("Uninitialized keystore");
	1174	}
	1175	keyStoreSpi.engineStore(param);
	1176	}
	1177
	1178	/**
	1179	* Loads this KeyStore from the given input stream.
	1180	*
	1181	* <p>A password may be given to unlock the keystore
	1182	* (e.g. the keystore resides on a hardware token device),
	1183	* or to check the integrity of the keystore data.
	1184	* If a password is not given for integrity checking,
	1185	* then integrity checking is not performed.
	1186	*
	1187	* <p>In order to create an empty keystore, or if the keystore cannot
	1188	* be initialized from a stream, pass <code>null</code>
	1189	* as the <code>stream</code> argument.
	1190	*
	1191	* <p> Note that if this keystore has already been loaded, it is
	1192	* reinitialized and loaded again from the given input stream.
	1193	*
	1194	* @param stream the input stream from which the keystore is loaded,
	1195	* or <code>null</code>
	1196	* @param password the password used to check the integrity of
	1197	* the keystore, the password used to unlock the keystore,
	1198	* or <code>null</code>
	1199	*
	1200	* @exception IOException if there is an I/O or format problem with the
	1201	* keystore data, if a password is required but not given,
	1202	* or if the given password was incorrect. If the error is due to a
	1203	* wrong password, the {@link Throwable#getCause cause} of the
	1204	* <code>IOException</code> should be an
	1205	* <code>UnrecoverableKeyException</code>
	1206	* @exception NoSuchAlgorithmException if the algorithm used to check
	1207	* the integrity of the keystore cannot be found
	1208	* @exception CertificateException if any of the certificates in the
	1209	* keystore could not be loaded
	1210	*/
	1211	public final void load(InputStream stream, char[] password)
	1212	throws IOException, NoSuchAlgorithmException, CertificateException
	1213	{
	1214	keyStoreSpi.engineLoad(stream, password);
	1215	initialized = true;
	1216	}
	1217
	1218	/**
	1219	* Loads this keystore using the given <code>LoadStoreParameter</code>.
	1220	*
	1221	* <p> Note that if this KeyStore has already been loaded, it is
	1222	* reinitialized and loaded again from the given parameter.
	1223	*
	1224	* @param param the <code>LoadStoreParameter</code>
	1225	* that specifies how to load the keystore,
	1226	* which may be <code>null</code>
	1227	*
	1228	* @exception IllegalArgumentException if the given
	1229	* <code>LoadStoreParameter</code>
	1230	* input is not recognized
	1231	* @exception IOException if there is an I/O or format problem with the
	1232	* keystore data. If the error is due to an incorrect
	1233	* <code>ProtectionParameter</code> (e.g. wrong password)
	1234	* the {@link Throwable#getCause cause} of the
	1235	* <code>IOException</code> should be an
	1236	* <code>UnrecoverableKeyException</code>
	1237	* @exception NoSuchAlgorithmException if the algorithm used to check
	1238	* the integrity of the keystore cannot be found
	1239	* @exception CertificateException if any of the certificates in the
	1240	* keystore could not be loaded
	1241	*
	1242	* @since 1.5
	1243	*/
	1244	public final void load(LoadStoreParameter param)
	1245	throws IOException, NoSuchAlgorithmException,
	1246	CertificateException {
	1247
	1248	keyStoreSpi.engineLoad(param);
	1249	initialized = true;
	1250	}
	1251
	1252	/**
	1253	* Gets a keystore <code>Entry</code> for the specified alias
	1254	* with the specified protection parameter.
	1255	*
	1256	* @param alias get the keystore <code>Entry</code> for this alias
	1257	* @param protParam the <code>ProtectionParameter</code>
	1258	* used to protect the <code>Entry</code>,
	1259	* which may be <code>null</code>
	1260	*
	1261	* @return the keystore <code>Entry</code> for the specified alias,
	1262	* or <code>null</code> if there is no such entry
	1263	*
	1264	* @exception NullPointerException if
	1265	* <code>alias</code> is <code>null</code>
	1266	* @exception NoSuchAlgorithmException if the algorithm for recovering the
	1267	* entry cannot be found
	1268	* @exception UnrecoverableEntryException if the specified
	1269	* <code>protParam</code> were insufficient or invalid
	1270	* @exception UnrecoverableKeyException if the entry is a
	1271	* <code>PrivateKeyEntry</code> or <code>SecretKeyEntry</code>
	1272	* and the specified <code>protParam</code> does not contain
	1273	* the information needed to recover the key (e.g. wrong password)
	1274	* @exception KeyStoreException if the keystore has not been initialized
	1275	* (loaded).
	1276	* @see #setEntry(String, KeyStore.Entry, KeyStore.ProtectionParameter)
	1277	*
	1278	* @since 1.5
	1279	*/
	1280	public final Entry getEntry(String alias, ProtectionParameter protParam)
	1281	throws NoSuchAlgorithmException, UnrecoverableEntryException,
	1282	KeyStoreException {
	1283
	1284	if (alias == null) {
	1285	throw new NullPointerException("invalid null input");
	1286	}
	1287	if (!initialized) {
	1288	throw new KeyStoreException("Uninitialized keystore");
	1289	}
	1290	return keyStoreSpi.engineGetEntry(alias, protParam);
	1291	}
	1292
	1293	/**
	1294	* Saves a keystore <code>Entry</code> under the specified alias.
	1295	* The protection parameter is used to protect the
	1296	* <code>Entry</code>.
	1297	*
	1298	* <p> If an entry already exists for the specified alias,
	1299	* it is overridden.
	1300	*
	1301	* @param alias save the keystore <code>Entry</code> under this alias
	1302	* @param entry the <code>Entry</code> to save
	1303	* @param protParam the <code>ProtectionParameter</code>
	1304	* used to protect the <code>Entry</code>,
	1305	* which may be <code>null</code>
	1306	*
	1307	* @exception NullPointerException if
	1308	* <code>alias</code> or <code>entry</code>
	1309	* is <code>null</code>
	1310	* @exception KeyStoreException if the keystore has not been initialized
	1311	* (loaded), or if this operation fails for some other reason
	1312	*
	1313	* @see #getEntry(String, KeyStore.ProtectionParameter)
	1314	*
	1315	* @since 1.5
	1316	*/
	1317	public final void setEntry(String alias, Entry entry,
	1318	ProtectionParameter protParam)
	1319	throws KeyStoreException {
	1320	if (alias == null \|\| entry == null) {
	1321	throw new NullPointerException("invalid null input");
	1322	}
	1323	if (!initialized) {
	1324	throw new KeyStoreException("Uninitialized keystore");
	1325	}
	1326	keyStoreSpi.engineSetEntry(alias, entry, protParam);
	1327	}
	1328
	1329	/**
	1330	* Determines if the keystore <code>Entry</code> for the specified
	1331	* <code>alias</code> is an instance or subclass of the specified
	1332	* <code>entryClass</code>.
	1333	*
	1334	* @param alias the alias name
	1335	* @param entryClass the entry class
	1336	*
	1337	* @return true if the keystore <code>Entry</code> for the specified
	1338	* <code>alias</code> is an instance or subclass of the
	1339	* specified <code>entryClass</code>, false otherwise
	1340	*
	1341	* @exception NullPointerException if
	1342	* <code>alias</code> or <code>entryClass</code>
	1343	* is <code>null</code>
	1344	* @exception KeyStoreException if the keystore has not been
	1345	* initialized (loaded)
	1346	*
	1347	* @since 1.5
	1348	*/
	1349	public final boolean
	1350	entryInstanceOf(String alias,
	1351	Class<? extends KeyStore.Entry> entryClass)
	1352	throws KeyStoreException
	1353	{
	1354
	1355	if (alias == null \|\| entryClass == null) {
	1356	throw new NullPointerException("invalid null input");
	1357	}
	1358	if (!initialized) {
	1359	throw new KeyStoreException("Uninitialized keystore");
	1360	}
	1361	return keyStoreSpi.engineEntryInstanceOf(alias, entryClass);
	1362	}
	1363
	1364	/**
	1365	* A description of a to-be-instantiated KeyStore object.
	1366	*
	1367	* <p>An instance of this class encapsulates the information needed to
	1368	* instantiate and initialize a KeyStore object. That process is
	1369	* triggered when the {@linkplain #getKeyStore} method is called.
	1370	*
	1371	* <p>This makes it possible to decouple configuration from KeyStore
	1372	* object creation and e.g. delay a password prompt until it is
	1373	* needed.
	1374	*
	1375	* @see KeyStore
	1376	* @see javax.net.ssl.KeyStoreBuilderParameters
	1377	* @since 1.5
	1378	*/
	1379	public static abstract class Builder {
	1380
	1381	// maximum times to try the callbackhandler if the password is wrong
	1382	static final int MAX_CALLBACK_TRIES = 3;
	1383
	1384	/**
	1385	* Construct a new Builder.
	1386	*/
	1387	protected Builder() {
	1388	// empty
	1389	}
	1390
	1391	/**
	1392	* Returns the KeyStore described by this object.
	1393	*
	1394	* @exception KeyStoreException if an error occured during the
	1395	* operation, for example if the KeyStore could not be
	1396	* instantiated or loaded
	1397	*/
	1398	public abstract KeyStore getKeyStore() throws KeyStoreException;
	1399
	1400	/**
	1401	* Returns the ProtectionParameters that should be used to obtain
	1402	* the {@link KeyStore.Entry Entry} with the given alias.
	1403	* The <code>getKeyStore</code> method must be invoked before this
	1404	* method may be called.
	1405	*
	1406	* @return the ProtectionParameters that should be used to obtain
	1407	* the {@link KeyStore.Entry Entry} with the given alias.
	1408	* @param alias the alias of the KeyStore entry
	1409	* @throws NullPointerException if alias is null
	1410	* @throws KeyStoreException if an error occured during the
	1411	* operation
	1412	* @throws IllegalStateException if the getKeyStore method has
	1413	* not been invoked prior to calling this method
	1414	*/
	1415	public abstract ProtectionParameter getProtectionParameter(String alias)
	1416	throws KeyStoreException;
	1417
	1418	/**
	1419	* Returns a new Builder that encapsulates the given KeyStore.
	1420	* The {@linkplain #getKeyStore} method of the returned object
	1421	* will return <code>keyStore</code>, the {@linkplain
	1422	* #getProtectionParameter getProtectionParameter()} method will
	1423	* return <code>protectionParameters</code>.
	1424	*
	1425	* <p> This is useful if an existing KeyStore object needs to be
	1426	* used with Builder-based APIs.
	1427	*
	1428	* @return a new Builder object
	1429	* @param keyStore the KeyStore to be encapsulated
	1430	* @param protectionParameter the ProtectionParameter used to
	1431	* protect the KeyStore entries
	1432	* @throws NullPointerException if keyStore or
	1433	* protectionParameters is null
	1434	* @throws IllegalArgumentException if the keyStore has not been
	1435	* initialized
	1436	*/
	1437	public static Builder newInstance(final KeyStore keyStore,
	1438	final ProtectionParameter protectionParameter) {
	1439	if ((keyStore == null) \|\| (protectionParameter == null)) {
	1440	throw new NullPointerException();
	1441	}
	1442	if (keyStore.initialized == false) {
	1443	throw new IllegalArgumentException("KeyStore not initialized");
	1444	}
	1445	return new Builder() {
	1446	private volatile boolean getCalled;
	1447
	1448	public KeyStore getKeyStore() {
	1449	getCalled = true;
	1450	return keyStore;
	1451	}
	1452
	1453	public ProtectionParameter getProtectionParameter(String alias)
	1454	{
	1455	if (alias == null) {
	1456	throw new NullPointerException();
	1457	}
	1458	if (getCalled == false) {
	1459	throw new IllegalStateException
	1460	("getKeyStore() must be called first");
	1461	}
	1462	return protectionParameter;
	1463	}
	1464	};
	1465	}
	1466
	1467	/**
	1468	* Returns a new Builder object.
	1469	*
	1470	* <p>The first call to the {@link #getKeyStore} method on the returned
	1471	* builder will create a KeyStore of type <code>type</code> and call
	1472	* its {@link KeyStore#load load()} method.
	1473	* The <code>inputStream</code> argument is constructed from
	1474	* <code>file</code>.
	1475	* If <code>protection</code> is a
	1476	* <code>PasswordProtection</code>, the password is obtained by
	1477	* calling the <code>getPassword</code> method.
	1478	* Otherwise, if <code>protection</code> is a
	1479	* <code>CallbackHandlerProtection</code>, the password is obtained
	1480	* by invoking the CallbackHandler.
	1481	*
	1482	* <p>Subsequent calls to {@link #getKeyStore} return the same object
	1483	* as the initial call. If the initial call to failed with a
	1484	* KeyStoreException, subsequent calls also throw a
	1485	* KeyStoreException.
	1486	*
	1487	* <p>The KeyStore is instantiated from <code>provider</code> if
	1488	* non-null. Otherwise, all installed providers are searched.
	1489	*
	1490	* <p>Calls to {@link #getProtectionParameter getProtectionParameter()}
	1491	* will return a {@link KeyStore.PasswordProtection PasswordProtection}
	1492	* object encapsulating the password that was used to invoke the
	1493	* <code>load</code> method.
	1494	*
	1495	* <p><em>Note</em> that the {@link #getKeyStore} method is executed
	1496	* within the {@link AccessControlContext} of the code invoking this
	1497	* method.
	1498	*
	1499	* @return a new Builder object
	1500	* @param type the type of KeyStore to be constructed
	1501	* @param provider the provider from which the KeyStore is to
	1502	* be instantiated (or null)
	1503	* @param file the File that contains the KeyStore data
	1504	* @param protection the ProtectionParameter securing the KeyStore data
	1505	* @throws NullPointerException if type, file or protection is null
	1506	* @throws IllegalArgumentException if protection is not an instance
	1507	* of either PasswordProtection or CallbackHandlerProtection; or
	1508	* if file does not exist or does not refer to a normal file
	1509	*/
	1510	public static Builder newInstance(String type, Provider provider,
	1511	File file, ProtectionParameter protection) {
	1512	if ((type == null) \|\| (file == null) \|\| (protection == null)) {
	1513	throw new NullPointerException();
	1514	}
	1515	if ((protection instanceof PasswordProtection == false) &&
	1516	(protection instanceof CallbackHandlerProtection == false)) {
	1517	throw new IllegalArgumentException
	1518	("Protection must be PasswordProtection or " +
	1519	"CallbackHandlerProtection");
	1520	}
	1521	if (file.isFile() == false) {
	1522	throw new IllegalArgumentException
	1523	("File does not exist or it does not refer " +
	1524	"to a normal file: " + file);
	1525	}
	1526	return new FileBuilder(type, provider, file, protection,
	1527	AccessController.getContext());
	1528	}
	1529
	1530	private static final class FileBuilder extends Builder {
	1531
	1532	private final String type;
	1533	private final Provider provider;
	1534	private final File file;
	1535	private ProtectionParameter protection;
	1536	private ProtectionParameter keyProtection;
	1537	private final AccessControlContext context;
	1538
	1539	private KeyStore keyStore;
	1540
	1541	private Throwable oldException;
	1542
	1543	FileBuilder(String type, Provider provider, File file,
	1544	ProtectionParameter protection,
	1545	AccessControlContext context) {
	1546	this.type = type;
	1547	this.provider = provider;
	1548	this.file = file;
	1549	this.protection = protection;
	1550	this.context = context;
	1551	}
	1552
	1553	public synchronized KeyStore getKeyStore() throws KeyStoreException
	1554	{
	1555	if (keyStore != null) {
	1556	return keyStore;
	1557	}
	1558	if (oldException != null) {
	1559	throw new KeyStoreException
	1560	("Previous KeyStore instantiation failed",
	1561	oldException);
	1562	}
	1563	PrivilegedExceptionAction<KeyStore> action =
	1564	new PrivilegedExceptionAction<KeyStore>() {
	1565	public KeyStore run() throws Exception {
	1566	if (protection instanceof CallbackHandlerProtection == false) {
	1567	return run0();
	1568	}
	1569	// when using a CallbackHandler,
	1570	// reprompt if the password is wrong
	1571	int tries = 0;
	1572	while (true) {
	1573	tries++;
	1574	try {
	1575	return run0();
	1576	} catch (IOException e) {
	1577	if ((tries < MAX_CALLBACK_TRIES)
	1578	&& (e.getCause() instanceof UnrecoverableKeyException)) {
	1579	continue;
	1580	}
	1581	throw e;
	1582	}
	1583	}
	1584	}
	1585	public KeyStore run0() throws Exception {
	1586	KeyStore ks;
	1587	if (provider == null) {
	1588	ks = KeyStore.getInstance(type);
	1589	} else {
	1590	ks = KeyStore.getInstance(type, provider);
	1591	}
	1592	InputStream in = null;
	1593	char[] password = null;
	1594	try {
	1595	in = new FileInputStream(file);
	1596	if (protection instanceof PasswordProtection) {
	1597	password =
	1598	((PasswordProtection)protection).getPassword();
	1599	keyProtection = protection;
	1600	} else {
	1601	CallbackHandler handler =
	1602	((CallbackHandlerProtection)protection)
	1603	.getCallbackHandler();
	1604	PasswordCallback callback = new PasswordCallback
	1605	("Password for keystore " + file.getName(),
	1606	false);
	1607	handler.handle(new Callback[] {callback});
	1608	password = callback.getPassword();
	1609	if (password == null) {
	1610	throw new KeyStoreException("No password" +
	1611	" provided");
	1612	}
	1613	callback.clearPassword();
	1614	keyProtection = new PasswordProtection(password);
	1615	}
	1616	ks.load(in, password);
	1617	return ks;
	1618	} finally {
	1619	if (in != null) {
	1620	in.close();
	1621	}
	1622	}
	1623	}
	1624	};
	1625	try {
	1626	keyStore = AccessController.doPrivileged(action, context);
	1627	return keyStore;
	1628	} catch (PrivilegedActionException e) {
	1629	oldException = e.getCause();
	1630	throw new KeyStoreException
	1631	("KeyStore instantiation failed", oldException);
	1632	}
	1633	}
	1634
	1635	public synchronized ProtectionParameter
	1636	getProtectionParameter(String alias) {
	1637	if (alias == null) {
	1638	throw new NullPointerException();
	1639	}
	1640	if (keyStore == null) {
	1641	throw new IllegalStateException
	1642	("getKeyStore() must be called first");
	1643	}
	1644	return keyProtection;
	1645	}
	1646	}
	1647
	1648	/**
	1649	* Returns a new Builder object.
	1650	*
	1651	* <p>Each call to the {@link #getKeyStore} method on the returned
	1652	* builder will return a new KeyStore object of type <code>type</code>.
	1653	* Its {@link KeyStore#load(KeyStore.LoadStoreParameter) load()}
	1654	* method is invoked using a
	1655	* <code>LoadStoreParameter</code> that encapsulates
	1656	* <code>protection</code>.
	1657	*
	1658	* <p>The KeyStore is instantiated from <code>provider</code> if
	1659	* non-null. Otherwise, all installed providers are searched.
	1660	*
	1661	* <p>Calls to {@link #getProtectionParameter getProtectionParameter()}
	1662	* will return <code>protection</code>.
	1663	*
	1664	* <p><em>Note</em> that the {@link #getKeyStore} method is executed
	1665	* within the {@link AccessControlContext} of the code invoking this
	1666	* method.
	1667	*
	1668	* @return a new Builder object
	1669	* @param type the type of KeyStore to be constructed
	1670	* @param provider the provider from which the KeyStore is to
	1671	* be instantiated (or null)
	1672	* @param protection the ProtectionParameter securing the Keystore
	1673	* @throws NullPointerException if type or protection is null
	1674	*/
	1675	public static Builder newInstance(final String type,
	1676	final Provider provider, final ProtectionParameter protection) {
	1677	if ((type == null) \|\| (protection == null)) {
	1678	throw new NullPointerException();
	1679	}
	1680	final AccessControlContext context = AccessController.getContext();
	1681	return new Builder() {
	1682	private volatile boolean getCalled;
	1683	private IOException oldException;
	1684
	1685	private final PrivilegedExceptionAction<KeyStore> action
	1686	= new PrivilegedExceptionAction<KeyStore>() {
	1687
	1688	public KeyStore run() throws Exception {
	1689	KeyStore ks;
	1690	if (provider == null) {
	1691	ks = KeyStore.getInstance(type);
	1692	} else {
	1693	ks = KeyStore.getInstance(type, provider);
	1694	}
	1695	LoadStoreParameter param = new SimpleLoadStoreParameter(protection);
	1696	if (protection instanceof CallbackHandlerProtection == false) {
	1697	ks.load(param);
	1698	} else {
	1699	// when using a CallbackHandler,
	1700	// reprompt if the password is wrong
	1701	int tries = 0;
	1702	while (true) {
	1703	tries++;
	1704	try {
	1705	ks.load(param);
	1706	break;
	1707	} catch (IOException e) {
	1708	if (e.getCause() instanceof UnrecoverableKeyException) {
	1709	if (tries < MAX_CALLBACK_TRIES) {
	1710	continue;
	1711	} else {
	1712	oldException = e;
	1713	}
	1714	}
	1715	throw e;
	1716	}
	1717	}
	1718	}
	1719	getCalled = true;
	1720	return ks;
	1721	}
	1722	};
	1723
	1724	public synchronized KeyStore getKeyStore()
	1725	throws KeyStoreException {
	1726	if (oldException != null) {
	1727	throw new KeyStoreException
	1728	("Previous KeyStore instantiation failed",
	1729	oldException);
	1730	}
	1731	try {
	1732	return AccessController.doPrivileged(action);
	1733	} catch (PrivilegedActionException e) {
	1734	Throwable cause = e.getCause();
	1735	throw new KeyStoreException
	1736	("KeyStore instantiation failed", cause);
	1737	}
	1738	}
	1739
	1740	public ProtectionParameter getProtectionParameter(String alias)
	1741	{
	1742	if (alias == null) {
	1743	throw new NullPointerException();
	1744	}
	1745	if (getCalled == false) {
	1746	throw new IllegalStateException
	1747	("getKeyStore() must be called first");
	1748	}
	1749	return protection;
	1750	}
	1751	};
	1752	}
	1753
	1754	}
	1755
	1756	static class SimpleLoadStoreParameter implements LoadStoreParameter {
	1757
	1758	private final ProtectionParameter protection;
	1759
	1760	SimpleLoadStoreParameter(ProtectionParameter protection) {
	1761	this.protection = protection;
	1762	}
	1763
	1764	public ProtectionParameter getProtectionParameter() {
	1765	return protection;
	1766	}
	1767	}
	1768
	1769	}

java/pkg/java/security/KeyStoreException.class+0−0

Binary file not shown.

java/pkg/java/security/KeyStoreException.java+90−0

@@ -0,0 +1,90 @@
	1	/*
	2	* Copyright (c) 1997, 2003, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	/**
	29	* This is the generic KeyStore exception.
	30	*
	31	* @author Jan Luehe
	32	*
	33	*
	34	* @since 1.2
	35	*/
	36
	37	public class KeyStoreException extends GeneralSecurityException {
	38
	39	private static final long serialVersionUID = -1119353179322377262L;
	40
	41	/**
	42	* Constructs a KeyStoreException with no detail message. (A
	43	* detail message is a String that describes this particular
	44	* exception.)
	45	*/
	46	public KeyStoreException() {
	47	super();
	48	}
	49
	50	/**
	51	* Constructs a KeyStoreException with the specified detail
	52	* message. (A detail message is a String that describes this
	53	* particular exception.)
	54	*
	55	* @param msg the detail message.
	56	*/
	57	public KeyStoreException(String msg) {
	58	super(msg);
	59	}
	60
	61	/**
	62	* Creates a <code>KeyStoreException</code> with the specified
	63	* detail message and cause.
	64	*
	65	* @param message the detail message (which is saved for later retrieval
	66	* by the {@link #getMessage()} method).
	67	* @param cause the cause (which is saved for later retrieval by the
	68	* {@link #getCause()} method). (A <tt>null</tt> value is permitted,
	69	* and indicates that the cause is nonexistent or unknown.)
	70	* @since 1.5
	71	*/
	72	public KeyStoreException(String message, Throwable cause) {
	73	super(message, cause);
	74	}
	75
	76	/**
	77	* Creates a <code>KeyStoreException</code> with the specified cause
	78	* and a detail message of <tt>(cause==null ? null : cause.toString())</tt>
	79	* (which typically contains the class and detail message of
	80	* <tt>cause</tt>).
	81	*
	82	* @param cause the cause (which is saved for later retrieval by the
	83	* {@link #getCause()} method). (A <tt>null</tt> value is permitted,
	84	* and indicates that the cause is nonexistent or unknown.)
	85	* @since 1.5
	86	*/
	87	public KeyStoreException(Throwable cause) {
	88	super(cause);
	89	}
	90	}

java/pkg/java/security/KeyStoreSpi.class+0−0

Binary file not shown.

java/pkg/java/security/KeyStoreSpi.java+593−0

@@ -0,0 +1,593 @@
	1	/*
	2	* Copyright (c) 1998, 2006, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.io.*;
	29	import java.util.*;
	30
	31	import java.security.KeyStore.*;
	32	import java.security.cert.Certificate;
	33	import java.security.cert.CertificateException;
	34
	35	import javax.crypto.SecretKey;
	36
	37	import javax.security.auth.callback.*;
	38
	39	/**
	40	* This class defines the <i>Service Provider Interface</i> (<b>SPI</b>)
	41	* for the <code>KeyStore</code> class.
	42	* All the abstract methods in this class must be implemented by each
	43	* cryptographic service provider who wishes to supply the implementation
	44	* of a keystore for a particular keystore type.
	45	*
	46	* @author Jan Luehe
	47	*
	48	*
	49	* @see KeyStore
	50	*
	51	* @since 1.2
	52	*/
	53
	54	public abstract class KeyStoreSpi {
	55
	56	/**
	57	* Returns the key associated with the given alias, using the given
	58	* password to recover it. The key must have been associated with
	59	* the alias by a call to <code>setKeyEntry</code>,
	60	* or by a call to <code>setEntry</code> with a
	61	* <code>PrivateKeyEntry</code> or <code>SecretKeyEntry</code>.
	62	*
	63	* @param alias the alias name
	64	* @param password the password for recovering the key
	65	*
	66	* @return the requested key, or null if the given alias does not exist
	67	* or does not identify a key-related entry.
	68	*
	69	* @exception NoSuchAlgorithmException if the algorithm for recovering the
	70	* key cannot be found
	71	* @exception UnrecoverableKeyException if the key cannot be recovered
	72	* (e.g., the given password is wrong).
	73	*/
	74	public abstract Key engineGetKey(String alias, char[] password)
	75	throws NoSuchAlgorithmException, UnrecoverableKeyException;
	76
	77	/**
	78	* Returns the certificate chain associated with the given alias.
	79	* The certificate chain must have been associated with the alias
	80	* by a call to <code>setKeyEntry</code>,
	81	* or by a call to <code>setEntry</code> with a
	82	* <code>PrivateKeyEntry</code>.
	83	*
	84	* @param alias the alias name
	85	*
	86	* @return the certificate chain (ordered with the user's certificate first
	87	* and the root certificate authority last), or null if the given alias
	88	* does not exist or does not contain a certificate chain
	89	*/
	90	public abstract Certificate[] engineGetCertificateChain(String alias);
	91
	92	/**
	93	* Returns the certificate associated with the given alias.
	94	*
	95	* <p> If the given alias name identifies an entry
	96	* created by a call to <code>setCertificateEntry</code>,
	97	* or created by a call to <code>setEntry</code> with a
	98	* <code>TrustedCertificateEntry</code>,
	99	* then the trusted certificate contained in that entry is returned.
	100	*
	101	* <p> If the given alias name identifies an entry
	102	* created by a call to <code>setKeyEntry</code>,
	103	* or created by a call to <code>setEntry</code> with a
	104	* <code>PrivateKeyEntry</code>,
	105	* then the first element of the certificate chain in that entry
	106	* (if a chain exists) is returned.
	107	*
	108	* @param alias the alias name
	109	*
	110	* @return the certificate, or null if the given alias does not exist or
	111	* does not contain a certificate.
	112	*/
	113	public abstract Certificate engineGetCertificate(String alias);
	114
	115	/**
	116	* Returns the creation date of the entry identified by the given alias.
	117	*
	118	* @param alias the alias name
	119	*
	120	* @return the creation date of this entry, or null if the given alias does
	121	* not exist
	122	*/
	123	public abstract Date engineGetCreationDate(String alias);
	124
	125	/**
	126	* Assigns the given key to the given alias, protecting it with the given
	127	* password.
	128	*
	129	* <p>If the given key is of type <code>java.security.PrivateKey</code>,
	130	* it must be accompanied by a certificate chain certifying the
	131	* corresponding public key.
	132	*
	133	* <p>If the given alias already exists, the keystore information
	134	* associated with it is overridden by the given key (and possibly
	135	* certificate chain).
	136	*
	137	* @param alias the alias name
	138	* @param key the key to be associated with the alias
	139	* @param password the password to protect the key
	140	* @param chain the certificate chain for the corresponding public
	141	* key (only required if the given key is of type
	142	* <code>java.security.PrivateKey</code>).
	143	*
	144	* @exception KeyStoreException if the given key cannot be protected, or
	145	* this operation fails for some other reason
	146	*/
	147	public abstract void engineSetKeyEntry(String alias, Key key,
	148	char[] password,
	149	Certificate[] chain)
	150	throws KeyStoreException;
	151
	152	/**
	153	* Assigns the given key (that has already been protected) to the given
	154	* alias.
	155	*
	156	* <p>If the protected key is of type
	157	* <code>java.security.PrivateKey</code>,
	158	* it must be accompanied by a certificate chain certifying the
	159	* corresponding public key.
	160	*
	161	* <p>If the given alias already exists, the keystore information
	162	* associated with it is overridden by the given key (and possibly
	163	* certificate chain).
	164	*
	165	* @param alias the alias name
	166	* @param key the key (in protected format) to be associated with the alias
	167	* @param chain the certificate chain for the corresponding public
	168	* key (only useful if the protected key is of type
	169	* <code>java.security.PrivateKey</code>).
	170	*
	171	* @exception KeyStoreException if this operation fails.
	172	*/
	173	public abstract void engineSetKeyEntry(String alias, byte[] key,
	174	Certificate[] chain)
	175	throws KeyStoreException;
	176
	177	/**
	178	* Assigns the given certificate to the given alias.
	179	*
	180	* <p> If the given alias identifies an existing entry
	181	* created by a call to <code>setCertificateEntry</code>,
	182	* or created by a call to <code>setEntry</code> with a
	183	* <code>TrustedCertificateEntry</code>,
	184	* the trusted certificate in the existing entry
	185	* is overridden by the given certificate.
	186	*
	187	* @param alias the alias name
	188	* @param cert the certificate
	189	*
	190	* @exception KeyStoreException if the given alias already exists and does
	191	* not identify an entry containing a trusted certificate,
	192	* or this operation fails for some other reason.
	193	*/
	194	public abstract void engineSetCertificateEntry(String alias,
	195	Certificate cert)
	196	throws KeyStoreException;
	197
	198	/**
	199	* Deletes the entry identified by the given alias from this keystore.
	200	*
	201	* @param alias the alias name
	202	*
	203	* @exception KeyStoreException if the entry cannot be removed.
	204	*/
	205	public abstract void engineDeleteEntry(String alias)
	206	throws KeyStoreException;
	207
	208	/**
	209	* Lists all the alias names of this keystore.
	210	*
	211	* @return enumeration of the alias names
	212	*/
	213	public abstract Enumeration<String> engineAliases();
	214
	215	/**
	216	* Checks if the given alias exists in this keystore.
	217	*
	218	* @param alias the alias name
	219	*
	220	* @return true if the alias exists, false otherwise
	221	*/
	222	public abstract boolean engineContainsAlias(String alias);
	223
	224	/**
	225	* Retrieves the number of entries in this keystore.
	226	*
	227	* @return the number of entries in this keystore
	228	*/
	229	public abstract int engineSize();
	230
	231	/**
	232	* Returns true if the entry identified by the given alias
	233	* was created by a call to <code>setKeyEntry</code>,
	234	* or created by a call to <code>setEntry</code> with a
	235	* <code>PrivateKeyEntry</code> or a <code>SecretKeyEntry</code>.
	236	*
	237	* @param alias the alias for the keystore entry to be checked
	238	*
	239	* @return true if the entry identified by the given alias is a
	240	* key-related, false otherwise.
	241	*/
	242	public abstract boolean engineIsKeyEntry(String alias);
	243
	244	/**
	245	* Returns true if the entry identified by the given alias
	246	* was created by a call to <code>setCertificateEntry</code>,
	247	* or created by a call to <code>setEntry</code> with a
	248	* <code>TrustedCertificateEntry</code>.
	249	*
	250	* @param alias the alias for the keystore entry to be checked
	251	*
	252	* @return true if the entry identified by the given alias contains a
	253	* trusted certificate, false otherwise.
	254	*/
	255	public abstract boolean engineIsCertificateEntry(String alias);
	256
	257	/**
	258	* Returns the (alias) name of the first keystore entry whose certificate
	259	* matches the given certificate.
	260	*
	261	* <p>This method attempts to match the given certificate with each
	262	* keystore entry. If the entry being considered was
	263	* created by a call to <code>setCertificateEntry</code>,
	264	* or created by a call to <code>setEntry</code> with a
	265	* <code>TrustedCertificateEntry</code>,
	266	* then the given certificate is compared to that entry's certificate.
	267	*
	268	* <p> If the entry being considered was
	269	* created by a call to <code>setKeyEntry</code>,
	270	* or created by a call to <code>setEntry</code> with a
	271	* <code>PrivateKeyEntry</code>,
	272	* then the given certificate is compared to the first
	273	* element of that entry's certificate chain.
	274	*
	275	* @param cert the certificate to match with.
	276	*
	277	* @return the alias name of the first entry with matching certificate,
	278	* or null if no such entry exists in this keystore.
	279	*/
	280	public abstract String engineGetCertificateAlias(Certificate cert);
	281
	282	/**
	283	* Stores this keystore to the given output stream, and protects its
	284	* integrity with the given password.
	285	*
	286	* @param stream the output stream to which this keystore is written.
	287	* @param password the password to generate the keystore integrity check
	288	*
	289	* @exception IOException if there was an I/O problem with data
	290	* @exception NoSuchAlgorithmException if the appropriate data integrity
	291	* algorithm could not be found
	292	* @exception CertificateException if any of the certificates included in
	293	* the keystore data could not be stored
	294	*/
	295	public abstract void engineStore(OutputStream stream, char[] password)
	296	throws IOException, NoSuchAlgorithmException, CertificateException;
	297
	298	/**
	299	* Stores this keystore using the given
	300	* <code>KeyStore.LoadStoreParmeter</code>.
	301	*
	302	* @param param the <code>KeyStore.LoadStoreParmeter</code>
	303	* that specifies how to store the keystore,
	304	* which may be <code>null</code>
	305	*
	306	* @exception IllegalArgumentException if the given
	307	* <code>KeyStore.LoadStoreParmeter</code>
	308	* input is not recognized
	309	* @exception IOException if there was an I/O problem with data
	310	* @exception NoSuchAlgorithmException if the appropriate data integrity
	311	* algorithm could not be found
	312	* @exception CertificateException if any of the certificates included in
	313	* the keystore data could not be stored
	314	*
	315	* @since 1.5
	316	*/
	317	public void engineStore(KeyStore.LoadStoreParameter param)
	318	throws IOException, NoSuchAlgorithmException,
	319	CertificateException {
	320	throw new UnsupportedOperationException();
	321	}
	322
	323	/**
	324	* Loads the keystore from the given input stream.
	325	*
	326	* <p>A password may be given to unlock the keystore
	327	* (e.g. the keystore resides on a hardware token device),
	328	* or to check the integrity of the keystore data.
	329	* If a password is not given for integrity checking,
	330	* then integrity checking is not performed.
	331	*
	332	* @param stream the input stream from which the keystore is loaded,
	333	* or <code>null</code>
	334	* @param password the password used to check the integrity of
	335	* the keystore, the password used to unlock the keystore,
	336	* or <code>null</code>
	337	*
	338	* @exception IOException if there is an I/O or format problem with the
	339	* keystore data, if a password is required but not given,
	340	* or if the given password was incorrect. If the error is due to a
	341	* wrong password, the {@link Throwable#getCause cause} of the
	342	* <code>IOException</code> should be an
	343	* <code>UnrecoverableKeyException</code>
	344	* @exception NoSuchAlgorithmException if the algorithm used to check
	345	* the integrity of the keystore cannot be found
	346	* @exception CertificateException if any of the certificates in the
	347	* keystore could not be loaded
	348	*/
	349	public abstract void engineLoad(InputStream stream, char[] password)
	350	throws IOException, NoSuchAlgorithmException, CertificateException;
	351
	352	/**
	353	* Loads the keystore using the given
	354	* <code>KeyStore.LoadStoreParameter</code>.
	355	*
	356	* <p> Note that if this KeyStore has already been loaded, it is
	357	* reinitialized and loaded again from the given parameter.
	358	*
	359	* @param param the <code>KeyStore.LoadStoreParameter</code>
	360	* that specifies how to load the keystore,
	361	* which may be <code>null</code>
	362	*
	363	* @exception IllegalArgumentException if the given
	364	* <code>KeyStore.LoadStoreParameter</code>
	365	* input is not recognized
	366	* @exception IOException if there is an I/O or format problem with the
	367	* keystore data. If the error is due to an incorrect
	368	* <code>ProtectionParameter</code> (e.g. wrong password)
	369	* the {@link Throwable#getCause cause} of the
	370	* <code>IOException</code> should be an
	371	* <code>UnrecoverableKeyException</code>
	372	* @exception NoSuchAlgorithmException if the algorithm used to check
	373	* the integrity of the keystore cannot be found
	374	* @exception CertificateException if any of the certificates in the
	375	* keystore could not be loaded
	376	*
	377	* @since 1.5
	378	*/
	379	public void engineLoad(KeyStore.LoadStoreParameter param)
	380	throws IOException, NoSuchAlgorithmException,
	381	CertificateException {
	382
	383	if (param == null) {
	384	engineLoad((InputStream)null, (char[])null);
	385	return;
	386	}
	387
	388	if (param instanceof KeyStore.SimpleLoadStoreParameter) {
	389	ProtectionParameter protection = param.getProtectionParameter();
	390	char[] password;
	391	if (protection instanceof PasswordProtection) {
	392	password = ((PasswordProtection)protection).getPassword();
	393	} else if (protection instanceof CallbackHandlerProtection) {
	394	CallbackHandler handler =
	395	((CallbackHandlerProtection)protection).getCallbackHandler();
	396	PasswordCallback callback =
	397	new PasswordCallback("Password: ", false);
	398	try {
	399	handler.handle(new Callback[] {callback});
	400	} catch (UnsupportedCallbackException e) {
	401	throw new NoSuchAlgorithmException
	402	("Could not obtain password", e);
	403	}
	404	password = callback.getPassword();
	405	callback.clearPassword();
	406	if (password == null) {
	407	throw new NoSuchAlgorithmException
	408	("No password provided");
	409	}
	410	} else {
	411	throw new NoSuchAlgorithmException("ProtectionParameter must"
	412	+ " be PasswordProtection or CallbackHandlerProtection");
	413	}
	414	engineLoad(null, password);
	415	return;
	416	}
	417
	418	throw new UnsupportedOperationException();
	419	}
	420
	421	/**
	422	* Gets a <code>KeyStore.Entry</code> for the specified alias
	423	* with the specified protection parameter.
	424	*
	425	* @param alias get the <code>KeyStore.Entry</code> for this alias
	426	* @param protParam the <code>ProtectionParameter</code>
	427	* used to protect the <code>Entry</code>,
	428	* which may be <code>null</code>
	429	*
	430	* @return the <code>KeyStore.Entry</code> for the specified alias,
	431	* or <code>null</code> if there is no such entry
	432	*
	433	* @exception KeyStoreException if the operation failed
	434	* @exception NoSuchAlgorithmException if the algorithm for recovering the
	435	* entry cannot be found
	436	* @exception UnrecoverableEntryException if the specified
	437	* <code>protParam</code> were insufficient or invalid
	438	* @exception UnrecoverableKeyException if the entry is a
	439	* <code>PrivateKeyEntry</code> or <code>SecretKeyEntry</code>
	440	* and the specified <code>protParam</code> does not contain
	441	* the information needed to recover the key (e.g. wrong password)
	442	*
	443	* @since 1.5
	444	*/
	445	public KeyStore.Entry engineGetEntry(String alias,
	446	KeyStore.ProtectionParameter protParam)
	447	throws KeyStoreException, NoSuchAlgorithmException,
	448	UnrecoverableEntryException {
	449
	450	if (!engineContainsAlias(alias)) {
	451	return null;
	452	}
	453
	454	if (protParam == null) {
	455	if (engineIsCertificateEntry(alias)) {
	456	return new KeyStore.TrustedCertificateEntry
	457	(engineGetCertificate(alias));
	458	} else {
	459	throw new UnrecoverableKeyException
	460	("requested entry requires a password");
	461	}
	462	}
	463
	464	if (protParam instanceof KeyStore.PasswordProtection) {
	465	if (engineIsCertificateEntry(alias)) {
	466	throw new UnsupportedOperationException
	467	("trusted certificate entries are not password-protected");
	468	} else if (engineIsKeyEntry(alias)) {
	469	KeyStore.PasswordProtection pp =
	470	(KeyStore.PasswordProtection)protParam;
	471	char[] password = pp.getPassword();
	472
	473	Key key = engineGetKey(alias, password);
	474	if (key instanceof PrivateKey) {
	475	Certificate[] chain = engineGetCertificateChain(alias);
	476	return new KeyStore.PrivateKeyEntry((PrivateKey)key, chain);
	477	} else if (key instanceof SecretKey) {
	478	return new KeyStore.SecretKeyEntry((SecretKey)key);
	479	}
	480	}
	481	}
	482
	483	throw new UnsupportedOperationException();
	484	}
	485
	486	/**
	487	* Saves a <code>KeyStore.Entry</code> under the specified alias.
	488	* The specified protection parameter is used to protect the
	489	* <code>Entry</code>.
	490	*
	491	* <p> If an entry already exists for the specified alias,
	492	* it is overridden.
	493	*
	494	* @param alias save the <code>KeyStore.Entry</code> under this alias
	495	* @param entry the <code>Entry</code> to save
	496	* @param protParam the <code>ProtectionParameter</code>
	497	* used to protect the <code>Entry</code>,
	498	* which may be <code>null</code>
	499	*
	500	* @exception KeyStoreException if this operation fails
	501	*
	502	* @since 1.5
	503	*/
	504	public void engineSetEntry(String alias, KeyStore.Entry entry,
	505	KeyStore.ProtectionParameter protParam)
	506	throws KeyStoreException {
	507
	508	// get password
	509	if (protParam != null &&
	510	!(protParam instanceof KeyStore.PasswordProtection)) {
	511	throw new KeyStoreException("unsupported protection parameter");
	512	}
	513	KeyStore.PasswordProtection pProtect = null;
	514	if (protParam != null) {
	515	pProtect = (KeyStore.PasswordProtection)protParam;
	516	}
	517
	518	// set entry
	519	if (entry instanceof KeyStore.TrustedCertificateEntry) {
	520	if (protParam != null && pProtect.getPassword() != null) {
	521	// pre-1.5 style setCertificateEntry did not allow password
	522	throw new KeyStoreException
	523	("trusted certificate entries are not password-protected");
	524	} else {
	525	KeyStore.TrustedCertificateEntry tce =
	526	(KeyStore.TrustedCertificateEntry)entry;
	527	engineSetCertificateEntry(alias, tce.getTrustedCertificate());
	528	return;
	529	}
	530	} else if (entry instanceof KeyStore.PrivateKeyEntry) {
	531	if (pProtect == null \|\| pProtect.getPassword() == null) {
	532	// pre-1.5 style setKeyEntry required password
	533	throw new KeyStoreException
	534	("non-null password required to create PrivateKeyEntry");
	535	} else {
	536	engineSetKeyEntry
	537	(alias,
	538	((KeyStore.PrivateKeyEntry)entry).getPrivateKey(),
	539	pProtect.getPassword(),
	540	((KeyStore.PrivateKeyEntry)entry).getCertificateChain());
	541	return;
	542	}
	543	} else if (entry instanceof KeyStore.SecretKeyEntry) {
	544	if (pProtect == null \|\| pProtect.getPassword() == null) {
	545	// pre-1.5 style setKeyEntry required password
	546	throw new KeyStoreException
	547	("non-null password required to create SecretKeyEntry");
	548	} else {
	549	engineSetKeyEntry
	550	(alias,
	551	((KeyStore.SecretKeyEntry)entry).getSecretKey(),
	552	pProtect.getPassword(),
	553	(Certificate[])null);
	554	return;
	555	}
	556	}
	557
	558	throw new KeyStoreException
	559	("unsupported entry type: " + entry.getClass().getName());
	560	}
	561
	562	/**
	563	* Determines if the keystore <code>Entry</code> for the specified
	564	* <code>alias</code> is an instance or subclass of the specified
	565	* <code>entryClass</code>.
	566	*
	567	* @param alias the alias name
	568	* @param entryClass the entry class
	569	*
	570	* @return true if the keystore <code>Entry</code> for the specified
	571	* <code>alias</code> is an instance or subclass of the
	572	* specified <code>entryClass</code>, false otherwise
	573	*
	574	* @since 1.5
	575	*/
	576	public boolean
	577	engineEntryInstanceOf(String alias,
	578	Class<? extends KeyStore.Entry> entryClass)
	579	{
	580	if (entryClass == KeyStore.TrustedCertificateEntry.class) {
	581	return engineIsCertificateEntry(alias);
	582	}
	583	if (entryClass == KeyStore.PrivateKeyEntry.class) {
	584	return engineIsKeyEntry(alias) &&
	585	engineGetCertificate(alias) != null;
	586	}
	587	if (entryClass == KeyStore.SecretKeyEntry.class) {
	588	return engineIsKeyEntry(alias) &&
	589	engineGetCertificate(alias) == null;
	590	}
	591	return false;
	592	}
	593	}

java/pkg/java/security/MessageDigest$Delegate.class+0−0

Binary file not shown.

java/pkg/java/security/MessageDigest.class+0−0

Binary file not shown.

java/pkg/java/security/MessageDigest.java+588−0

@@ -0,0 +1,588 @@
	1	/*
	2	* Copyright (c) 1996, 2011, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.util.*;
	29	import java.lang.*;
	30	import java.io.IOException;
	31	import java.io.ByteArrayOutputStream;
	32	import java.io.PrintStream;
	33	import java.io.InputStream;
	34	import java.io.ByteArrayInputStream;
	35
	36	import java.nio.ByteBuffer;
	37
	38	/**
	39	* This MessageDigest class provides applications the functionality of a
	40	* message digest algorithm, such as SHA-1 or SHA-256.
	41	* Message digests are secure one-way hash functions that take arbitrary-sized
	42	* data and output a fixed-length hash value.
	43	*
	44	* <p>A MessageDigest object starts out initialized. The data is
	45	* processed through it using the {@link #update(byte) update}
	46	* methods. At any point {@link #reset() reset} can be called
	47	* to reset the digest. Once all the data to be updated has been
	48	* updated, one of the {@link #digest() digest} methods should
	49	* be called to complete the hash computation.
	50	*
	51	* <p>The <code>digest</code> method can be called once for a given number
	52	* of updates. After <code>digest</code> has been called, the MessageDigest
	53	* object is reset to its initialized state.
	54	*
	55	* <p>Implementations are free to implement the Cloneable interface.
	56	* Client applications can test cloneability by attempting cloning
	57	* and catching the CloneNotSupportedException: <p>
	58	*
	59	* <pre>
	60	* MessageDigest md = MessageDigest.getInstance("SHA");
	61	*
	62	* try {
	63	* md.update(toChapter1);
	64	* MessageDigest tc1 = md.clone();
	65	* byte[] toChapter1Digest = tc1.digest();
	66	* md.update(toChapter2);
	67	* ...etc.
	68	* } catch (CloneNotSupportedException cnse) {
	69	* throw new DigestException("couldn't make digest of partial content");
	70	* }
	71	* </pre>
	72	*
	73	* <p>Note that if a given implementation is not cloneable, it is
	74	* still possible to compute intermediate digests by instantiating
	75	* several instances, if the number of digests is known in advance.
	76	*
	77	* <p>Note that this class is abstract and extends from
	78	* <code>MessageDigestSpi</code> for historical reasons.
	79	* Application developers should only take notice of the methods defined in
	80	* this <code>MessageDigest</code> class; all the methods in
	81	* the superclass are intended for cryptographic service providers who wish to
	82	* supply their own implementations of message digest algorithms.
	83	*
	84	* <p> Every implementation of the Java platform is required to support
	85	* the following standard <code>MessageDigest</code> algorithms:
	86	* <ul>
	87	* <li><tt>MD5</tt></li>
	88	* <li><tt>SHA-1</tt></li>
	89	* <li><tt>SHA-256</tt></li>
	90	* </ul>
	91	* These algorithms are described in the <a href=
	92	* "{@docRoot}/../technotes/guides/security/StandardNames.html#MessageDigest">
	93	* MessageDigest section</a> of the
	94	* Java Cryptography Architecture Standard Algorithm Name Documentation.
	95	* Consult the release documentation for your implementation to see if any
	96	* other algorithms are supported.
	97	*
	98	* @author Benjamin Renaud
	99	*
	100	* @see DigestInputStream
	101	* @see DigestOutputStream
	102	*/
	103
	104	public abstract class MessageDigest extends MessageDigestSpi {
	105
	106	private String algorithm;
	107
	108	// The state of this digest
	109	private static final int INITIAL = 0;
	110	private static final int IN_PROGRESS = 1;
	111	private int state = INITIAL;
	112
	113	// The provider
	114	private Provider provider;
	115
	116	/**
	117	* Creates a message digest with the specified algorithm name.
	118	*
	119	* @param algorithm the standard name of the digest algorithm.
	120	* See the MessageDigest section in the <a href=
	121	* "{@docRoot}/../technotes/guides/security/StandardNames.html#MessageDigest">
	122	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	123	* for information about standard algorithm names.
	124	*/
	125	protected MessageDigest(String algorithm) {
	126	this.algorithm = algorithm;
	127	}
	128
	129	/**
	130	* Returns a MessageDigest object that implements the specified digest
	131	* algorithm.
	132	*
	133	* <p> This method traverses the list of registered security Providers,
	134	* starting with the most preferred Provider.
	135	* A new MessageDigest object encapsulating the
	136	* MessageDigestSpi implementation from the first
	137	* Provider that supports the specified algorithm is returned.
	138	*
	139	* <p> Note that the list of registered providers may be retrieved via
	140	* the {@link Security#getProviders() Security.getProviders()} method.
	141	*
	142	* @param algorithm the name of the algorithm requested.
	143	* See the MessageDigest section in the <a href=
	144	* "{@docRoot}/../technotes/guides/security/StandardNames.html#MessageDigest">
	145	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	146	* for information about standard algorithm names.
	147	*
	148	* @return a Message Digest object that implements the specified algorithm.
	149	*
	150	* @exception NoSuchAlgorithmException if no Provider supports a
	151	* MessageDigestSpi implementation for the
	152	* specified algorithm.
	153	*
	154	* @see Provider
	155	*/
	156	public static MessageDigest getInstance(String algorithm)
	157	throws NoSuchAlgorithmException {
	158	try {
	159	Object[] objs = Security.getImpl(algorithm, "MessageDigest",
	160	(String)null);
	161	if (objs[0] instanceof MessageDigest) {
	162	MessageDigest md = (MessageDigest)objs[0];
	163	md.provider = (Provider)objs[1];
	164	return md;
	165	} else {
	166	MessageDigest delegate =
	167	new Delegate((MessageDigestSpi)objs[0], algorithm);
	168	delegate.provider = (Provider)objs[1];
	169	return delegate;
	170	}
	171	} catch(NoSuchProviderException e) {
	172	throw new NoSuchAlgorithmException(algorithm + " not found");
	173	}
	174	}
	175
	176	/**
	177	* Returns a MessageDigest object that implements the specified digest
	178	* algorithm.
	179	*
	180	* <p> A new MessageDigest object encapsulating the
	181	* MessageDigestSpi implementation from the specified provider
	182	* is returned. The specified provider must be registered
	183	* in the security provider list.
	184	*
	185	* <p> Note that the list of registered providers may be retrieved via
	186	* the {@link Security#getProviders() Security.getProviders()} method.
	187	*
	188	* @param algorithm the name of the algorithm requested.
	189	* See the MessageDigest section in the <a href=
	190	* "{@docRoot}/../technotes/guides/security/StandardNames.html#MessageDigest">
	191	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	192	* for information about standard algorithm names.
	193	*
	194	* @param provider the name of the provider.
	195	*
	196	* @return a MessageDigest object that implements the specified algorithm.
	197	*
	198	* @exception NoSuchAlgorithmException if a MessageDigestSpi
	199	* implementation for the specified algorithm is not
	200	* available from the specified provider.
	201	*
	202	* @exception NoSuchProviderException if the specified provider is not
	203	* registered in the security provider list.
	204	*
	205	* @exception IllegalArgumentException if the provider name is null
	206	* or empty.
	207	*
	208	* @see Provider
	209	*/
	210	public static MessageDigest getInstance(String algorithm, String provider)
	211	throws NoSuchAlgorithmException, NoSuchProviderException
	212	{
	213	if (provider == null \|\| provider.length() == 0)
	214	throw new IllegalArgumentException("missing provider");
	215	Object[] objs = Security.getImpl(algorithm, "MessageDigest", provider);
	216	if (objs[0] instanceof MessageDigest) {
	217	MessageDigest md = (MessageDigest)objs[0];
	218	md.provider = (Provider)objs[1];
	219	return md;
	220	} else {
	221	MessageDigest delegate =
	222	new Delegate((MessageDigestSpi)objs[0], algorithm);
	223	delegate.provider = (Provider)objs[1];
	224	return delegate;
	225	}
	226	}
	227
	228	/**
	229	* Returns a MessageDigest object that implements the specified digest
	230	* algorithm.
	231	*
	232	* <p> A new MessageDigest object encapsulating the
	233	* MessageDigestSpi implementation from the specified Provider
	234	* object is returned. Note that the specified Provider object
	235	* does not have to be registered in the provider list.
	236	*
	237	* @param algorithm the name of the algorithm requested.
	238	* See the MessageDigest section in the <a href=
	239	* "{@docRoot}/../technotes/guides/security/StandardNames.html#MessageDigest">
	240	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	241	* for information about standard algorithm names.
	242	*
	243	* @param provider the provider.
	244	*
	245	* @return a MessageDigest object that implements the specified algorithm.
	246	*
	247	* @exception NoSuchAlgorithmException if a MessageDigestSpi
	248	* implementation for the specified algorithm is not available
	249	* from the specified Provider object.
	250	*
	251	* @exception IllegalArgumentException if the specified provider is null.
	252	*
	253	* @see Provider
	254	*
	255	* @since 1.4
	256	*/
	257	public static MessageDigest getInstance(String algorithm,
	258	Provider provider)
	259	throws NoSuchAlgorithmException
	260	{
	261	if (provider == null)
	262	throw new IllegalArgumentException("missing provider");
	263	Object[] objs = Security.getImpl(algorithm, "MessageDigest", provider);
	264	if (objs[0] instanceof MessageDigest) {
	265	MessageDigest md = (MessageDigest)objs[0];
	266	md.provider = (Provider)objs[1];
	267	return md;
	268	} else {
	269	MessageDigest delegate =
	270	new Delegate((MessageDigestSpi)objs[0], algorithm);
	271	delegate.provider = (Provider)objs[1];
	272	return delegate;
	273	}
	274	}
	275
	276	/**
	277	* Returns the provider of this message digest object.
	278	*
	279	* @return the provider of this message digest object
	280	*/
	281	public final Provider getProvider() {
	282	return this.provider;
	283	}
	284
	285	/**
	286	* Updates the digest using the specified byte.
	287	*
	288	* @param input the byte with which to update the digest.
	289	*/
	290	public void update(byte input) {
	291	engineUpdate(input);
	292	state = IN_PROGRESS;
	293	}
	294
	295	/**
	296	* Updates the digest using the specified array of bytes, starting
	297	* at the specified offset.
	298	*
	299	* @param input the array of bytes.
	300	*
	301	* @param offset the offset to start from in the array of bytes.
	302	*
	303	* @param len the number of bytes to use, starting at
	304	* <code>offset</code>.
	305	*/
	306	public void update(byte[] input, int offset, int len) {
	307	if (input == null) {
	308	throw new IllegalArgumentException("No input buffer given");
	309	}
	310	if (input.length - offset < len) {
	311	throw new IllegalArgumentException("Input buffer too short");
	312	}
	313	engineUpdate(input, offset, len);
	314	state = IN_PROGRESS;
	315	}
	316
	317	/**
	318	* Updates the digest using the specified array of bytes.
	319	*
	320	* @param input the array of bytes.
	321	*/
	322	public void update(byte[] input) {
	323	engineUpdate(input, 0, input.length);
	324	state = IN_PROGRESS;
	325	}
	326
	327	/**
	328	* Update the digest using the specified ByteBuffer. The digest is
	329	* updated using the <code>input.remaining()</code> bytes starting
	330	* at <code>input.position()</code>.
	331	* Upon return, the buffer's position will be equal to its limit;
	332	* its limit will not have changed.
	333	*
	334	* @param input the ByteBuffer
	335	* @since 1.5
	336	*/
	337	public final void update(ByteBuffer input) {
	338	if (input == null) {
	339	throw new NullPointerException();
	340	}
	341	engineUpdate(input);
	342	state = IN_PROGRESS;
	343	}
	344
	345	/**
	346	* Completes the hash computation by performing final operations
	347	* such as padding. The digest is reset after this call is made.
	348	*
	349	* @return the array of bytes for the resulting hash value.
	350	*/
	351	public byte[] digest() {
	352	/* Resetting is the responsibility of implementors. */
	353	byte[] result = engineDigest();
	354	state = INITIAL;
	355	return result;
	356	}
	357
	358	/**
	359	* Completes the hash computation by performing final operations
	360	* such as padding. The digest is reset after this call is made.
	361	*
	362	* @param buf output buffer for the computed digest
	363	*
	364	* @param offset offset into the output buffer to begin storing the digest
	365	*
	366	* @param len number of bytes within buf allotted for the digest
	367	*
	368	* @return the number of bytes placed into <code>buf</code>
	369	*
	370	* @exception DigestException if an error occurs.
	371	*/
	372	public int digest(byte[] buf, int offset, int len) throws DigestException {
	373	if (buf == null) {
	374	throw new IllegalArgumentException("No output buffer given");
	375	}
	376	if (buf.length - offset < len) {
	377	throw new IllegalArgumentException
	378	("Output buffer too small for specified offset and length");
	379	}
	380	int numBytes = engineDigest(buf, offset, len);
	381	state = INITIAL;
	382	return numBytes;
	383	}
	384
	385	/**
	386	* Performs a final update on the digest using the specified array
	387	* of bytes, then completes the digest computation. That is, this
	388	* method first calls {@link #update(byte[]) update(input)},
	389	* passing the <i>input</i> array to the <code>update</code> method,
	390	* then calls {@link #digest() digest()}.
	391	*
	392	* @param input the input to be updated before the digest is
	393	* completed.
	394	*
	395	* @return the array of bytes for the resulting hash value.
	396	*/
	397	public byte[] digest(byte[] input) {
	398	update(input);
	399	return digest();
	400	}
	401
	402	/**
	403	* Returns a string representation of this message digest object.
	404	*/
	405	public String toString() {
	406	ByteArrayOutputStream baos = new ByteArrayOutputStream();
	407	PrintStream p = new PrintStream(baos);
	408	p.print(algorithm+" Message Digest from "+provider.getName()+", ");
	409	switch (state) {
	410	case INITIAL:
	411	p.print("<initialized>");
	412	break;
	413	case IN_PROGRESS:
	414	p.print("<in progress>");
	415	break;
	416	}
	417	p.println();
	418	return (baos.toString());
	419	}
	420
	421	/**
	422	* Compares two digests for equality. Does a simple byte compare.
	423	*
	424	* @param digesta one of the digests to compare.
	425	*
	426	* @param digestb the other digest to compare.
	427	*
	428	* @return true if the digests are equal, false otherwise.
	429	*/
	430	public static boolean isEqual(byte[] digesta, byte[] digestb) {
	431	if (digesta.length != digestb.length) {
	432	return false;
	433	}
	434
	435	int result = 0;
	436	// time-constant comparison
	437	for (int i = 0; i < digesta.length; i++) {
	438	result \|= digesta[i] ^ digestb[i];
	439	}
	440	return result == 0;
	441	}
	442
	443	/**
	444	* Resets the digest for further use.
	445	*/
	446	public void reset() {
	447	engineReset();
	448	state = INITIAL;
	449	}
	450
	451	/**
	452	* Returns a string that identifies the algorithm, independent of
	453	* implementation details. The name should be a standard
	454	* Java Security name (such as "SHA", "MD5", and so on).
	455	* See the MessageDigest section in the <a href=
	456	* "{@docRoot}/../technotes/guides/security/StandardNames.html#MessageDigest">
	457	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	458	* for information about standard algorithm names.
	459	*
	460	* @return the name of the algorithm
	461	*/
	462	public final String getAlgorithm() {
	463	return this.algorithm;
	464	}
	465
	466	/**
	467	* Returns the length of the digest in bytes, or 0 if this operation is
	468	* not supported by the provider and the implementation is not cloneable.
	469	*
	470	* @return the digest length in bytes, or 0 if this operation is not
	471	* supported by the provider and the implementation is not cloneable.
	472	*
	473	* @since 1.2
	474	*/
	475	public final int getDigestLength() {
	476	int digestLen = engineGetDigestLength();
	477	if (digestLen == 0) {
	478	try {
	479	MessageDigest md = (MessageDigest)clone();
	480	byte[] digest = md.digest();
	481	return digest.length;
	482	} catch (CloneNotSupportedException e) {
	483	return digestLen;
	484	}
	485	}
	486	return digestLen;
	487	}
	488
	489	/**
	490	* Returns a clone if the implementation is cloneable.
	491	*
	492	* @return a clone if the implementation is cloneable.
	493	*
	494	* @exception CloneNotSupportedException if this is called on an
	495	* implementation that does not support <code>Cloneable</code>.
	496	*/
	497	public Object clone() throws CloneNotSupportedException {
	498	if (this instanceof Cloneable) {
	499	return super.clone();
	500	} else {
	501	throw new CloneNotSupportedException();
	502	}
	503	}
	504
	505
	506
	507
	508	/*
	509	* The following class allows providers to extend from MessageDigestSpi
	510	* rather than from MessageDigest. It represents a MessageDigest with an
	511	* encapsulated, provider-supplied SPI object (of type MessageDigestSpi).
	512	* If the provider implementation is an instance of MessageDigestSpi,
	513	* the getInstance() methods above return an instance of this class, with
	514	* the SPI object encapsulated.
	515	*
	516	* Note: All SPI methods from the original MessageDigest class have been
	517	* moved up the hierarchy into a new class (MessageDigestSpi), which has
	518	* been interposed in the hierarchy between the API (MessageDigest)
	519	* and its original parent (Object).
	520	*/
	521
	522	static class Delegate extends MessageDigest {
	523
	524	// The provider implementation (delegate)
	525	private MessageDigestSpi digestSpi;
	526
	527	// constructor
	528	public Delegate(MessageDigestSpi digestSpi, String algorithm) {
	529	super(algorithm);
	530	this.digestSpi = digestSpi;
	531	}
	532
	533	/**
	534	* Returns a clone if the delegate is cloneable.
	535	*
	536	* @return a clone if the delegate is cloneable.
	537	*
	538	* @exception CloneNotSupportedException if this is called on a
	539	* delegate that does not support <code>Cloneable</code>.
	540	*/
	541	public Object clone() throws CloneNotSupportedException {
	542	if (digestSpi instanceof Cloneable) {
	543	MessageDigestSpi digestSpiClone =
	544	(MessageDigestSpi)digestSpi.clone();
	545	// Because 'algorithm', 'provider', and 'state' are private
	546	// members of our supertype, we must perform a cast to
	547	// access them.
	548	MessageDigest that =
	549	new Delegate(digestSpiClone,
	550	((MessageDigest)this).algorithm);
	551	that.provider = ((MessageDigest)this).provider;
	552	that.state = ((MessageDigest)this).state;
	553	return that;
	554	} else {
	555	throw new CloneNotSupportedException();
	556	}
	557	}
	558
	559	protected int engineGetDigestLength() {
	560	return digestSpi.engineGetDigestLength();
	561	}
	562
	563	protected void engineUpdate(byte input) {
	564	digestSpi.engineUpdate(input);
	565	}
	566
	567	protected void engineUpdate(byte[] input, int offset, int len) {
	568	digestSpi.engineUpdate(input, offset, len);
	569	}
	570
	571	protected void engineUpdate(ByteBuffer input) {
	572	digestSpi.engineUpdate(input);
	573	}
	574
	575	protected byte[] engineDigest() {
	576	return digestSpi.engineDigest();
	577	}
	578
	579	protected int engineDigest(byte[] buf, int offset, int len)
	580	throws DigestException {
	581	return digestSpi.engineDigest(buf, offset, len);
	582	}
	583
	584	protected void engineReset() {
	585	digestSpi.engineReset();
	586	}
	587	}
	588	}

java/pkg/java/security/MessageDigestSpi.class+0−0

Binary file not shown.

java/pkg/java/security/MessageDigestSpi.java+206−0

@@ -0,0 +1,206 @@
	1	/*
	2	* Copyright (c) 1997, 2006, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.nio.ByteBuffer;
	29
	30	import sun.security.jca.JCAUtil;
	31
	32	/**
	33	* This class defines the <i>Service Provider Interface</i> (<b>SPI</b>)
	34	* for the <code>MessageDigest</code> class, which provides the functionality
	35	* of a message digest algorithm, such as MD5 or SHA. Message digests are
	36	* secure one-way hash functions that take arbitrary-sized data and output a
	37	* fixed-length hash value.
	38	*
	39	* <p> All the abstract methods in this class must be implemented by a
	40	* cryptographic service provider who wishes to supply the implementation
	41	* of a particular message digest algorithm.
	42	*
	43	* <p> Implementations are free to implement the Cloneable interface.
	44	*
	45	* @author Benjamin Renaud
	46	*
	47	*
	48	* @see MessageDigest
	49	*/
	50
	51	public abstract class MessageDigestSpi {
	52
	53	// for re-use in engineUpdate(ByteBuffer input)
	54	private byte[] tempArray;
	55
	56	/**
	57	* Returns the digest length in bytes.
	58	*
	59	* <p>This concrete method has been added to this previously-defined
	60	* abstract class. (For backwards compatibility, it cannot be abstract.)
	61	*
	62	* <p>The default behavior is to return 0.
	63	*
	64	* <p>This method may be overridden by a provider to return the digest
	65	* length.
	66	*
	67	* @return the digest length in bytes.
	68	*
	69	* @since 1.2
	70	*/
	71	protected int engineGetDigestLength() {
	72	return 0;
	73	}
	74
	75	/**
	76	* Updates the digest using the specified byte.
	77	*
	78	* @param input the byte to use for the update.
	79	*/
	80	protected abstract void engineUpdate(byte input);
	81
	82	/**
	83	* Updates the digest using the specified array of bytes,
	84	* starting at the specified offset.
	85	*
	86	* @param input the array of bytes to use for the update.
	87	*
	88	* @param offset the offset to start from in the array of bytes.
	89	*
	90	* @param len the number of bytes to use, starting at
	91	* <code>offset</code>.
	92	*/
	93	protected abstract void engineUpdate(byte[] input, int offset, int len);
	94
	95	/**
	96	* Update the digest using the specified ByteBuffer. The digest is
	97	* updated using the <code>input.remaining()</code> bytes starting
	98	* at <code>input.position()</code>.
	99	* Upon return, the buffer's position will be equal to its limit;
	100	* its limit will not have changed.
	101	*
	102	* @param input the ByteBuffer
	103	* @since 1.5
	104	*/
	105	protected void engineUpdate(ByteBuffer input) {
	106	if (input.hasRemaining() == false) {
	107	return;
	108	}
	109	if (input.hasArray()) {
	110	byte[] b = input.array();
	111	int ofs = input.arrayOffset();
	112	int pos = input.position();
	113	int lim = input.limit();
	114	engineUpdate(b, ofs + pos, lim - pos);
	115	input.position(lim);
	116	} else {
	117	int len = input.remaining();
	118	int n = JCAUtil.getTempArraySize(len);
	119	if ((tempArray == null) \|\| (n > tempArray.length)) {
	120	tempArray = new byte[n];
	121	}
	122	while (len > 0) {
	123	int chunk = Math.min(len, tempArray.length);
	124	input.get(tempArray, 0, chunk);
	125	engineUpdate(tempArray, 0, chunk);
	126	len -= chunk;
	127	}
	128	}
	129	}
	130
	131	/**
	132	* Completes the hash computation by performing final
	133	* operations such as padding. Once <code>engineDigest</code> has
	134	* been called, the engine should be reset (see
	135	* {@link #engineReset() engineReset}).
	136	* Resetting is the responsibility of the
	137	* engine implementor.
	138	*
	139	* @return the array of bytes for the resulting hash value.
	140	*/
	141	protected abstract byte[] engineDigest();
	142
	143	/**
	144	* Completes the hash computation by performing final
	145	* operations such as padding. Once <code>engineDigest</code> has
	146	* been called, the engine should be reset (see
	147	* {@link #engineReset() engineReset}).
	148	* Resetting is the responsibility of the
	149	* engine implementor.
	150	*
	151	* This method should be abstract, but we leave it concrete for
	152	* binary compatibility. Knowledgeable providers should override this
	153	* method.
	154	*
	155	* @param buf the output buffer in which to store the digest
	156	*
	157	* @param offset offset to start from in the output buffer
	158	*
	159	* @param len number of bytes within buf allotted for the digest.
	160	* Both this default implementation and the SUN provider do not
	161	* return partial digests. The presence of this parameter is solely
	162	* for consistency in our API's. If the value of this parameter is less
	163	* than the actual digest length, the method will throw a DigestException.
	164	* This parameter is ignored if its value is greater than or equal to
	165	* the actual digest length.
	166	*
	167	* @return the length of the digest stored in the output buffer.
	168	*
	169	* @exception DigestException if an error occurs.
	170	*
	171	* @since 1.2
	172	*/
	173	protected int engineDigest(byte[] buf, int offset, int len)
	174	throws DigestException {
	175
	176	byte[] digest = engineDigest();
	177	if (len < digest.length)
	178	throw new DigestException("partial digests not returned");
	179	if (buf.length - offset < digest.length)
	180	throw new DigestException("insufficient space in the output "
	181	+ "buffer to store the digest");
	182	System.arraycopy(digest, 0, buf, offset, digest.length);
	183	return digest.length;
	184	}
	185
	186	/**
	187	* Resets the digest for further use.
	188	*/
	189	protected abstract void engineReset();
	190
	191	/**
	192	* Returns a clone if the implementation is cloneable.
	193	*
	194	* @return a clone if the implementation is cloneable.
	195	*
	196	* @exception CloneNotSupportedException if this is called on an
	197	* implementation that does not support <code>Cloneable</code>.
	198	*/
	199	public Object clone() throws CloneNotSupportedException {
	200	if (this instanceof Cloneable) {
	201	return super.clone();
	202	} else {
	203	throw new CloneNotSupportedException();
	204	}
	205	}
	206	}

java/pkg/java/security/NoSuchAlgorithmException.class+0−0

Binary file not shown.

java/pkg/java/security/NoSuchAlgorithmException.java+89−0

@@ -0,0 +1,89 @@
	1	/*
	2	* Copyright (c) 1996, 2003, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	/**
	29	* This exception is thrown when a particular cryptographic algorithm is
	30	* requested but is not available in the environment.
	31	*
	32	* @author Benjamin Renaud
	33	*/
	34
	35	public class NoSuchAlgorithmException extends GeneralSecurityException {
	36
	37	private static final long serialVersionUID = -7443947487218346562L;
	38
	39	/**
	40	* Constructs a NoSuchAlgorithmException with no detail
	41	* message. A detail message is a String that describes this
	42	* particular exception.
	43	*/
	44	public NoSuchAlgorithmException() {
	45	super();
	46	}
	47
	48	/**
	49	* Constructs a NoSuchAlgorithmException with the specified
	50	* detail message. A detail message is a String that describes
	51	* this particular exception, which may, for example, specify which
	52	* algorithm is not available.
	53	*
	54	* @param msg the detail message.
	55	*/
	56	public NoSuchAlgorithmException(String msg) {
	57	super(msg);
	58	}
	59
	60	/**
	61	* Creates a <code>NoSuchAlgorithmException</code> with the specified
	62	* detail message and cause.
	63	*
	64	* @param message the detail message (which is saved for later retrieval
	65	* by the {@link #getMessage()} method).
	66	* @param cause the cause (which is saved for later retrieval by the
	67	* {@link #getCause()} method). (A <tt>null</tt> value is permitted,
	68	* and indicates that the cause is nonexistent or unknown.)
	69	* @since 1.5
	70	*/
	71	public NoSuchAlgorithmException(String message, Throwable cause) {
	72	super(message, cause);
	73	}
	74
	75	/**
	76	* Creates a <code>NoSuchAlgorithmException</code> with the specified cause
	77	* and a detail message of <tt>(cause==null ? null : cause.toString())</tt>
	78	* (which typically contains the class and detail message of
	79	* <tt>cause</tt>).
	80	*
	81	* @param cause the cause (which is saved for later retrieval by the
	82	* {@link #getCause()} method). (A <tt>null</tt> value is permitted,
	83	* and indicates that the cause is nonexistent or unknown.)
	84	* @since 1.5
	85	*/
	86	public NoSuchAlgorithmException(Throwable cause) {
	87	super(cause);
	88	}
	89	}

java/pkg/java/security/NoSuchProviderException.class+0−0

Binary file not shown.

java/pkg/java/security/NoSuchProviderException.java+58−0

@@ -0,0 +1,58 @@
	1	/*
	2	* Copyright (c) 1996, 2003, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	/**
	29	* This exception is thrown when a particular security provider is
	30	* requested but is not available in the environment.
	31	*
	32	* @author Benjamin Renaud
	33	*/
	34
	35	public class NoSuchProviderException extends GeneralSecurityException {
	36
	37	private static final long serialVersionUID = 8488111756688534474L;
	38
	39	/**
	40	* Constructs a NoSuchProviderException with no detail message. A
	41	* detail message is a String that describes this particular
	42	* exception.
	43	*/
	44	public NoSuchProviderException() {
	45	super();
	46	}
	47
	48	/**
	49	* Constructs a NoSuchProviderException with the specified detail
	50	* message. A detail message is a String that describes this
	51	* particular exception.
	52	*
	53	* @param msg the detail message.
	54	*/
	55	public NoSuchProviderException(String msg) {
	56	super(msg);
	57	}
	58	}

java/pkg/java/security/Permission.class+0−0

Binary file not shown.

java/pkg/java/security/Permission.java+231−0

@@ -0,0 +1,231 @@
	1	/*
	2	* Copyright (c) 1997, 2009, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	/**
	29	* Abstract class for representing access to a system resource.
	30	* All permissions have a name (whose interpretation depends on the subclass),
	31	* as well as abstract functions for defining the semantics of the
	32	* particular Permission subclass.
	33	*
	34	* <p>Most Permission objects also include an "actions" list that tells the actions
	35	* that are permitted for the object. For example,
	36	* for a <code>java.io.FilePermission</code> object, the permission name is
	37	* the pathname of a file (or directory), and the actions list
	38	* (such as "read, write") specifies which actions are granted for the
	39	* specified file (or for files in the specified directory).
	40	* The actions list is optional for Permission objects, such as
	41	* <code>java.lang.RuntimePermission</code>,
	42	* that don't need such a list; you either have the named permission (such
	43	* as "system.exit") or you don't.
	44	*
	45	* <p>An important method that must be implemented by each subclass is
	46	* the <code>implies</code> method to compare Permissions. Basically,
	47	* "permission p1 implies permission p2" means that
	48	* if one is granted permission p1, one is naturally granted permission p2.
	49	* Thus, this is not an equality test, but rather more of a
	50	* subset test.
	51	*
	52	* <P> Permission objects are similar to String objects in that they
	53	* are immutable once they have been created. Subclasses should not
	54	* provide methods that can change the state of a permission
	55	* once it has been created.
	56	*
	57	* @see Permissions
	58	* @see PermissionCollection
	59	*
	60	*
	61	* @author Marianne Mueller
	62	* @author Roland Schemers
	63	*/
	64
	65	public abstract class Permission implements Guard, java.io.Serializable {
	66
	67	private static final long serialVersionUID = -5636570222231596674L;
	68
	69	private String name;
	70
	71	/**
	72	* Constructs a permission with the specified name.
	73	*
	74	* @param name name of the Permission object being created.
	75	*
	76	*/
	77
	78	public Permission(String name) {
	79	this.name = name;
	80	}
	81
	82	/**
	83	* Implements the guard interface for a permission. The
	84	* <code>SecurityManager.checkPermission</code> method is called,
	85	* passing this permission object as the permission to check.
	86	* Returns silently if access is granted. Otherwise, throws
	87	* a SecurityException.
	88	*
	89	* @param object the object being guarded (currently ignored).
	90	*
	91	* @throws SecurityException
	92	* if a security manager exists and its
	93	* <code>checkPermission</code> method doesn't allow access.
	94	*
	95	* @see Guard
	96	* @see GuardedObject
	97	* @see SecurityManager#checkPermission
	98	*
	99	*/
	100	public void checkGuard(Object object) throws SecurityException {
	101	SecurityManager sm = System.getSecurityManager();
	102	if (sm != null) sm.checkPermission(this);
	103	}
	104
	105	/**
	106	* Checks if the specified permission's actions are "implied by"
	107	* this object's actions.
	108	* <P>
	109	* This must be implemented by subclasses of Permission, as they are the
	110	* only ones that can impose semantics on a Permission object.
	111	*
	112	* <p>The <code>implies</code> method is used by the AccessController to determine
	113	* whether or not a requested permission is implied by another permission that
	114	* is known to be valid in the current execution context.
	115	*
	116	* @param permission the permission to check against.
	117	*
	118	* @return true if the specified permission is implied by this object,
	119	* false if not.
	120	*/
	121
	122	public abstract boolean implies(Permission permission);
	123
	124	/**
	125	* Checks two Permission objects for equality.
	126	* <P>
	127	* Do not use the <code>equals</code> method for making access control
	128	* decisions; use the <code>implies</code> method.
	129	*
	130	* @param obj the object we are testing for equality with this object.
	131	*
	132	* @return true if both Permission objects are equivalent.
	133	*/
	134
	135	public abstract boolean equals(Object obj);
	136
	137	/**
	138	* Returns the hash code value for this Permission object.
	139	* <P>
	140	* The required <code>hashCode</code> behavior for Permission Objects is
	141	* the following: <p>
	142	* <ul>
	143	* <li>Whenever it is invoked on the same Permission object more than
	144	* once during an execution of a Java application, the
	145	* <code>hashCode</code> method
	146	* must consistently return the same integer. This integer need not
	147	* remain consistent from one execution of an application to another
	148	* execution of the same application. <p>
	149	* <li>If two Permission objects are equal according to the
	150	* <code>equals</code>
	151	* method, then calling the <code>hashCode</code> method on each of the
	152	* two Permission objects must produce the same integer result.
	153	* </ul>
	154	*
	155	* @return a hash code value for this object.
	156	*/
	157
	158	public abstract int hashCode();
	159
	160	/**
	161	* Returns the name of this Permission.
	162	* For example, in the case of a <code>java.io.FilePermission</code>,
	163	* the name will be a pathname.
	164	*
	165	* @return the name of this Permission.
	166	*
	167	*/
	168
	169	public final String getName() {
	170	return name;
	171	}
	172
	173	/**
	174	* Returns the actions as a String. This is abstract
	175	* so subclasses can defer creating a String representation until
	176	* one is needed. Subclasses should always return actions in what they
	177	* consider to be their
	178	* canonical form. For example, two FilePermission objects created via
	179	* the following:
	180	*
	181	* <pre>
	182	* perm1 = new FilePermission(p1,"read,write");
	183	* perm2 = new FilePermission(p2,"write,read");
	184	* </pre>
	185	*
	186	* both return
	187	* "read,write" when the <code>getActions</code> method is invoked.
	188	*
	189	* @return the actions of this Permission.
	190	*
	191	*/
	192
	193	public abstract String getActions();
	194
	195	/**
	196	* Returns an empty PermissionCollection for a given Permission object, or null if
	197	* one is not defined. Subclasses of class Permission should
	198	* override this if they need to store their permissions in a particular
	199	* PermissionCollection object in order to provide the correct semantics
	200	* when the <code>PermissionCollection.implies</code> method is called.
	201	* If null is returned,
	202	* then the caller of this method is free to store permissions of this
	203	* type in any PermissionCollection they choose (one that uses a Hashtable,
	204	* one that uses a Vector, etc).
	205	*
	206	* @return a new PermissionCollection object for this type of Permission, or
	207	* null if one is not defined.
	208	*/
	209
	210	public PermissionCollection newPermissionCollection() {
	211	return null;
	212	}
	213
	214	/**
	215	* Returns a string describing this Permission. The convention is to
	216	* specify the class name, the permission name, and the actions in
	217	* the following format: '("ClassName" "name" "actions")', or
	218	* '("ClassName" "name")' if actions list is null or empty.
	219	*
	220	* @return information about this Permission.
	221	*/
	222	public String toString() {
	223	String actions = getActions();
	224	if ((actions == null) \|\| (actions.length() == 0)) { // OPTIONAL
	225	return "(\"" + getClass().getName() + "\" \"" + name + "\")";
	226	} else {
	227	return "(\"" + getClass().getName() + "\" \"" + name +
	228	"\" \"" + actions + "\")";
	229	}
	230	}
	231	}

java/pkg/java/security/PermissionCollection.class+0−0

Binary file not shown.

java/pkg/java/security/PermissionCollection.java+196−0

@@ -0,0 +1,196 @@
	1	/*
	2	* Copyright (c) 1997, 2006, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.util.*;
	29
	30	/**
	31	* Abstract class representing a collection of Permission objects.
	32	*
	33	* <p>With a PermissionCollection, you can:
	34	* <UL>
	35	* <LI> add a permission to the collection using the <code>add</code> method.
	36	* <LI> check to see if a particular permission is implied in the
	37	* collection, using the <code>implies</code> method.
	38	* <LI> enumerate all the permissions, using the <code>elements</code> method.
	39	* </UL>
	40	* <P>
	41	*
	42	* <p>When it is desirable to group together a number of Permission objects
	43	* of the same type, the <code>newPermissionCollection</code> method on that
	44	* particular type of Permission object should first be called. The default
	45	* behavior (from the Permission class) is to simply return null.
	46	* Subclasses of class Permission override the method if they need to store
	47	* their permissions in a particular PermissionCollection object in order
	48	* to provide the correct semantics when the
	49	* <code>PermissionCollection.implies</code> method is called.
	50	* If a non-null value is returned, that PermissionCollection must be used.
	51	* If null is returned, then the caller of <code>newPermissionCollection</code>
	52	* is free to store permissions of the
	53	* given type in any PermissionCollection they choose
	54	* (one that uses a Hashtable, one that uses a Vector, etc).
	55	*
	56	* <p>The PermissionCollection returned by the
	57	* <code>Permission.newPermissionCollection</code>
	58	* method is a homogeneous collection, which stores only Permission objects
	59	* for a given Permission type. A PermissionCollection may also be
	60	* heterogeneous. For example, Permissions is a PermissionCollection
	61	* subclass that represents a collection of PermissionCollections.
	62	* That is, its members are each a homogeneous PermissionCollection.
	63	* For example, a Permissions object might have a FilePermissionCollection
	64	* for all the FilePermission objects, a SocketPermissionCollection for all the
	65	* SocketPermission objects, and so on. Its <code>add</code> method adds a
	66	* permission to the appropriate collection.
	67	*
	68	* <p>Whenever a permission is added to a heterogeneous PermissionCollection
	69	* such as Permissions, and the PermissionCollection doesn't yet contain a
	70	* PermissionCollection of the specified permission's type, the
	71	* PermissionCollection should call
	72	* the <code>newPermissionCollection</code> method on the permission's class
	73	* to see if it requires a special PermissionCollection. If
	74	* <code>newPermissionCollection</code>
	75	* returns null, the PermissionCollection
	76	* is free to store the permission in any type of PermissionCollection it
	77	* desires (one using a Hashtable, one using a Vector, etc.). For example,
	78	* the Permissions object uses a default PermissionCollection implementation
	79	* that stores the permission objects in a Hashtable.
	80	*
	81	* <p> Subclass implementations of PermissionCollection should assume
	82	* that they may be called simultaneously from multiple threads,
	83	* and therefore should be synchronized properly. Furthermore,
	84	* Enumerations returned via the <code>elements</code> method are
	85	* not <em>fail-fast</em>. Modifications to a collection should not be
	86	* performed while enumerating over that collection.
	87	*
	88	* @see Permission
	89	* @see Permissions
	90	*
	91	*
	92	* @author Roland Schemers
	93	*/
	94
	95	public abstract class PermissionCollection implements java.io.Serializable {
	96
	97	private static final long serialVersionUID = -6727011328946861783L;
	98
	99	// when set, add will throw an exception.
	100	private volatile boolean readOnly;
	101
	102	/**
	103	* Adds a permission object to the current collection of permission objects.
	104	*
	105	* @param permission the Permission object to add.
	106	*
	107	* @exception SecurityException - if this PermissionCollection object
	108	* has been marked readonly
	109	* @exception IllegalArgumentException - if this PermissionCollection
	110	* object is a homogeneous collection and the permission
	111	* is not of the correct type.
	112	*/
	113	public abstract void add(Permission permission);
	114
	115	/**
	116	* Checks to see if the specified permission is implied by
	117	* the collection of Permission objects held in this PermissionCollection.
	118	*
	119	* @param permission the Permission object to compare.
	120	*
	121	* @return true if "permission" is implied by the permissions in
	122	* the collection, false if not.
	123	*/
	124	public abstract boolean implies(Permission permission);
	125
	126	/**
	127	* Returns an enumeration of all the Permission objects in the collection.
	128	*
	129	* @return an enumeration of all the Permissions.
	130	*/
	131	public abstract Enumeration<Permission> elements();
	132
	133	/**
	134	* Marks this PermissionCollection object as "readonly". After
	135	* a PermissionCollection object
	136	* is marked as readonly, no new Permission objects can be added to it
	137	* using <code>add</code>.
	138	*/
	139	public void setReadOnly() {
	140	readOnly = true;
	141	}
	142
	143	/**
	144	* Returns true if this PermissionCollection object is marked as readonly.
	145	* If it is readonly, no new Permission objects can be added to it
	146	* using <code>add</code>.
	147	*
	148	* <p>By default, the object is <i>not</i> readonly. It can be set to
	149	* readonly by a call to <code>setReadOnly</code>.
	150	*
	151	* @return true if this PermissionCollection object is marked as readonly,
	152	* false otherwise.
	153	*/
	154	public boolean isReadOnly() {
	155	return readOnly;
	156	}
	157
	158	/**
	159	* Returns a string describing this PermissionCollection object,
	160	* providing information about all the permissions it contains.
	161	* The format is:
	162	* <pre>
	163	* super.toString() (
	164	* // enumerate all the Permission
	165	* // objects and call toString() on them,
	166	* // one per line..
	167	* )</pre>
	168	*
	169	* <code>super.toString</code> is a call to the <code>toString</code>
	170	* method of this
	171	* object's superclass, which is Object. The result is
	172	* this PermissionCollection's type name followed by this object's
	173	* hashcode, thus enabling clients to differentiate different
	174	* PermissionCollections object, even if they contain the same permissions.
	175	*
	176	* @return information about this PermissionCollection object,
	177	* as described above.
	178	*
	179	*/
	180	public String toString() {
	181	Enumeration<Permission> enum_ = elements();
	182	StringBuilder sb = new StringBuilder();
	183	sb.append(super.toString()+" (\n");
	184	while (enum_.hasMoreElements()) {
	185	try {
	186	sb.append(" ");
	187	sb.append(enum_.nextElement().toString());
	188	sb.append("\n");
	189	} catch (NoSuchElementException e){
	190	// ignore
	191	}
	192	}
	193	sb.append(")\n");
	194	return sb.toString();
	195	}
	196	}

java/pkg/java/security/Permissions.class+0−0

Binary file not shown.

java/pkg/java/security/Permissions.java+598−0

@@ -0,0 +1,598 @@
	1	/*
	2	* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.util.Enumeration;
	29	import java.util.Hashtable;
	30	import java.util.NoSuchElementException;
	31	import java.util.Map;
	32	import java.util.HashMap;
	33	import java.util.List;
	34	import java.util.ArrayList;
	35	import java.util.Iterator;
	36	import java.util.Collections;
	37	import java.io.Serializable;
	38	import java.io.ObjectStreamField;
	39	import java.io.ObjectOutputStream;
	40	import java.io.ObjectInputStream;
	41	import java.io.IOException;
	42
	43
	44	/**
	45	* This class represents a heterogeneous collection of Permissions. That is,
	46	* it contains different types of Permission objects, organized into
	47	* PermissionCollections. For example, if any
	48	* <code>java.io.FilePermission</code> objects are added to an instance of
	49	* this class, they are all stored in a single
	50	* PermissionCollection. It is the PermissionCollection returned by a call to
	51	* the <code>newPermissionCollection</code> method in the FilePermission class.
	52	* Similarly, any <code>java.lang.RuntimePermission</code> objects are
	53	* stored in the PermissionCollection returned by a call to the
	54	* <code>newPermissionCollection</code> method in the
	55	* RuntimePermission class. Thus, this class represents a collection of
	56	* PermissionCollections.
	57	*
	58	* <p>When the <code>add</code> method is called to add a Permission, the
	59	* Permission is stored in the appropriate PermissionCollection. If no such
	60	* collection exists yet, the Permission object's class is determined and the
	61	* <code>newPermissionCollection</code> method is called on that class to create
	62	* the PermissionCollection and add it to the Permissions object. If
	63	* <code>newPermissionCollection</code> returns null, then a default
	64	* PermissionCollection that uses a hashtable will be created and used. Each
	65	* hashtable entry stores a Permission object as both the key and the value.
	66	*
	67	* <p> Enumerations returned via the <code>elements</code> method are
	68	* not <em>fail-fast</em>. Modifications to a collection should not be
	69	* performed while enumerating over that collection.
	70	*
	71	* @see Permission
	72	* @see PermissionCollection
	73	* @see AllPermission
	74	*
	75	*
	76	* @author Marianne Mueller
	77	* @author Roland Schemers
	78	*
	79	* @serial exclude
	80	*/
	81
	82	public final class Permissions extends PermissionCollection
	83	implements Serializable
	84	{
	85	/**
	86	* Key is permissions Class, value is PermissionCollection for that class.
	87	* Not serialized; see serialization section at end of class.
	88	*/
	89	private transient Map<Class<?>, PermissionCollection> permsMap;
	90
	91	// optimization. keep track of whether unresolved permissions need to be
	92	// checked
	93	private transient boolean hasUnresolved = false;
	94
	95	// optimization. keep track of the AllPermission collection
	96	// - package private for ProtectionDomain optimization
	97	PermissionCollection allPermission;
	98
	99	/**
	100	* Creates a new Permissions object containing no PermissionCollections.
	101	*/
	102	public Permissions() {
	103	permsMap = new HashMap<Class<?>, PermissionCollection>(11);
	104	allPermission = null;
	105	}
	106
	107	/**
	108	* Adds a permission object to the PermissionCollection for the class the
	109	* permission belongs to. For example, if <i>permission</i> is a
	110	* FilePermission, it is added to the FilePermissionCollection stored
	111	* in this Permissions object.
	112	*
	113	* This method creates
	114	* a new PermissionCollection object (and adds the permission to it)
	115	* if an appropriate collection does not yet exist. <p>
	116	*
	117	* @param permission the Permission object to add.
	118	*
	119	* @exception SecurityException if this Permissions object is
	120	* marked as readonly.
	121	*
	122	* @see PermissionCollection#isReadOnly()
	123	*/
	124
	125	public void add(Permission permission) {
	126	if (isReadOnly())
	127	throw new SecurityException(
	128	"attempt to add a Permission to a readonly Permissions object");
	129
	130	PermissionCollection pc;
	131
	132	synchronized (this) {
	133	pc = getPermissionCollection(permission, true);
	134	pc.add(permission);
	135	}
	136
	137	// No sync; staleness -> optimizations delayed, which is OK
	138	if (permission instanceof AllPermission) {
	139	allPermission = pc;
	140	}
	141	if (permission instanceof UnresolvedPermission) {
	142	hasUnresolved = true;
	143	}
	144	}
	145
	146	/**
	147	* Checks to see if this object's PermissionCollection for permissions of
	148	* the specified permission's class implies the permissions
	149	* expressed in the <i>permission</i> object. Returns true if the
	150	* combination of permissions in the appropriate PermissionCollection
	151	* (e.g., a FilePermissionCollection for a FilePermission) together
	152	* imply the specified permission.
	153	*
	154	* <p>For example, suppose there is a FilePermissionCollection in this
	155	* Permissions object, and it contains one FilePermission that specifies
	156	* "read" access for all files in all subdirectories of the "/tmp"
	157	* directory, and another FilePermission that specifies "write" access
	158	* for all files in the "/tmp/scratch/foo" directory.
	159	* Then if the <code>implies</code> method
	160	* is called with a permission specifying both "read" and "write" access
	161	* to files in the "/tmp/scratch/foo" directory, <code>true</code> is
	162	* returned.
	163	*
	164	* <p>Additionally, if this PermissionCollection contains the
	165	* AllPermission, this method will always return true.
	166	* <p>
	167	* @param permission the Permission object to check.
	168	*
	169	* @return true if "permission" is implied by the permissions in the
	170	* PermissionCollection it
	171	* belongs to, false if not.
	172	*/
	173
	174	public boolean implies(Permission permission) {
	175	// No sync; staleness -> skip optimization, which is OK
	176	if (allPermission != null) {
	177	return true; // AllPermission has already been added
	178	} else {
	179	synchronized (this) {
	180	PermissionCollection pc = getPermissionCollection(permission,
	181	false);
	182	if (pc != null) {
	183	return pc.implies(permission);
	184	} else {
	185	// none found
	186	return false;
	187	}
	188	}
	189	}
	190	}
	191
	192	/**
	193	* Returns an enumeration of all the Permission objects in all the
	194	* PermissionCollections in this Permissions object.
	195	*
	196	* @return an enumeration of all the Permissions.
	197	*/
	198
	199	public Enumeration<Permission> elements() {
	200	// go through each Permissions in the hash table
	201	// and call their elements() function.
	202
	203	synchronized (this) {
	204	return new PermissionsEnumerator(permsMap.values().iterator());
	205	}
	206	}
	207
	208	/**
	209	* Gets the PermissionCollection in this Permissions object for
	210	* permissions whose type is the same as that of <i>p</i>.
	211	* For example, if <i>p</i> is a FilePermission,
	212	* the FilePermissionCollection
	213	* stored in this Permissions object will be returned.
	214	*
	215	* If createEmpty is true,
	216	* this method creates a new PermissionCollection object for the specified
	217	* type of permission objects if one does not yet exist.
	218	* To do so, it first calls the <code>newPermissionCollection</code> method
	219	* on <i>p</i>. Subclasses of class Permission
	220	* override that method if they need to store their permissions in a
	221	* particular PermissionCollection object in order to provide the
	222	* correct semantics when the <code>PermissionCollection.implies</code>
	223	* method is called.
	224	* If the call returns a PermissionCollection, that collection is stored
	225	* in this Permissions object. If the call returns null and createEmpty
	226	* is true, then
	227	* this method instantiates and stores a default PermissionCollection
	228	* that uses a hashtable to store its permission objects.
	229	*
	230	* createEmpty is ignored when creating empty PermissionCollection
	231	* for unresolved permissions because of the overhead of determining the
	232	* PermissionCollection to use.
	233	*
	234	* createEmpty should be set to false when this method is invoked from
	235	* implies() because it incurs the additional overhead of creating and
	236	* adding an empty PermissionCollection that will just return false.
	237	* It should be set to true when invoked from add().
	238	*/
	239	private PermissionCollection getPermissionCollection(Permission p,
	240	boolean createEmpty) {
	241	Class c = p.getClass();
	242
	243	PermissionCollection pc = permsMap.get(c);
	244
	245	if (!hasUnresolved && !createEmpty) {
	246	return pc;
	247	} else if (pc == null) {
	248
	249	// Check for unresolved permissions
	250	pc = (hasUnresolved ? getUnresolvedPermissions(p) : null);
	251
	252	// if still null, create a new collection
	253	if (pc == null && createEmpty) {
	254
	255	pc = p.newPermissionCollection();
	256
	257	// still no PermissionCollection?
	258	// We'll give them a PermissionsHash.
	259	if (pc == null)
	260	pc = new PermissionsHash();
	261	}
	262
	263	if (pc != null) {
	264	permsMap.put(c, pc);
	265	}
	266	}
	267	return pc;
	268	}
	269
	270	/**
	271	* Resolves any unresolved permissions of type p.
	272	*
	273	* @param p the type of unresolved permission to resolve
	274	*
	275	* @return PermissionCollection containing the unresolved permissions,
	276	* or null if there were no unresolved permissions of type p.
	277	*
	278	*/
	279	private PermissionCollection getUnresolvedPermissions(Permission p)
	280	{
	281	// Called from within synchronized method so permsMap doesn't need lock
	282
	283	UnresolvedPermissionCollection uc =
	284	(UnresolvedPermissionCollection) permsMap.get(UnresolvedPermission.class);
	285
	286	// we have no unresolved permissions if uc is null
	287	if (uc == null)
	288	return null;
	289
	290	List<UnresolvedPermission> unresolvedPerms =
	291	uc.getUnresolvedPermissions(p);
	292
	293	// we have no unresolved permissions of this type if unresolvedPerms is null
	294	if (unresolvedPerms == null)
	295	return null;
	296
	297	java.security.cert.Certificate certs[] = null;
	298
	299	Object signers[] = p.getClass().getSigners();
	300
	301	int n = 0;
	302	if (signers != null) {
	303	for (int j=0; j < signers.length; j++) {
	304	if (signers[j] instanceof java.security.cert.Certificate) {
	305	n++;
	306	}
	307	}
	308	certs = new java.security.cert.Certificate[n];
	309	n = 0;
	310	for (int j=0; j < signers.length; j++) {
	311	if (signers[j] instanceof java.security.cert.Certificate) {
	312	certs[n++] = (java.security.cert.Certificate)signers[j];
	313	}
	314	}
	315	}
	316
	317	PermissionCollection pc = null;
	318	synchronized (unresolvedPerms) {
	319	int len = unresolvedPerms.size();
	320	for (int i = 0; i < len; i++) {
	321	UnresolvedPermission up = unresolvedPerms.get(i);
	322	Permission perm = up.resolve(p, certs);
	323	if (perm != null) {
	324	if (pc == null) {
	325	pc = p.newPermissionCollection();
	326	if (pc == null)
	327	pc = new PermissionsHash();
	328	}
	329	pc.add(perm);
	330	}
	331	}
	332	}
	333	return pc;
	334	}
	335
	336	private static final long serialVersionUID = 4858622370623524688L;
	337
	338	// Need to maintain serialization interoperability with earlier releases,
	339	// which had the serializable field:
	340	// private Hashtable perms;
	341
	342	/**
	343	* @serialField perms java.util.Hashtable
	344	* A table of the Permission classes and PermissionCollections.
	345	* @serialField allPermission java.security.PermissionCollection
	346	*/
	347	private static final ObjectStreamField[] serialPersistentFields = {
	348	new ObjectStreamField("perms", Hashtable.class),
	349	new ObjectStreamField("allPermission", PermissionCollection.class),
	350	};
	351
	352	/**
	353	* @serialData Default fields.
	354	*/
	355	/*
	356	* Writes the contents of the permsMap field out as a Hashtable for
	357	* serialization compatibility with earlier releases. allPermission
	358	* unchanged.
	359	*/
	360	private void writeObject(ObjectOutputStream out) throws IOException {
	361	// Don't call out.defaultWriteObject()
	362
	363	// Copy perms into a Hashtable
	364	Hashtable<Class<?>, PermissionCollection> perms =
	365	new Hashtable<>(permsMap.size()*2); // no sync; estimate
	366	synchronized (this) {
	367	perms.putAll(permsMap);
	368	}
	369
	370	// Write out serializable fields
	371	ObjectOutputStream.PutField pfields = out.putFields();
	372
	373	pfields.put("allPermission", allPermission); // no sync; staleness OK
	374	pfields.put("perms", perms);
	375	out.writeFields();
	376	}
	377
	378	/*
	379	* Reads in a Hashtable of Class/PermissionCollections and saves them in the
	380	* permsMap field. Reads in allPermission.
	381	*/
	382	private void readObject(ObjectInputStream in) throws IOException,
	383	ClassNotFoundException {
	384	// Don't call defaultReadObject()
	385
	386	// Read in serialized fields
	387	ObjectInputStream.GetField gfields = in.readFields();
	388
	389	// Get allPermission
	390	allPermission = (PermissionCollection) gfields.get("allPermission", null);
	391
	392	// Get permissions
	393	Hashtable<Class<?>, PermissionCollection> perms =
	394	(Hashtable<Class<?>, PermissionCollection>)gfields.get("perms", null);
	395	permsMap = new HashMap<Class<?>, PermissionCollection>(perms.size()*2);
	396	permsMap.putAll(perms);
	397
	398	// Set hasUnresolved
	399	UnresolvedPermissionCollection uc =
	400	(UnresolvedPermissionCollection) permsMap.get(UnresolvedPermission.class);
	401	hasUnresolved = (uc != null && uc.elements().hasMoreElements());
	402	}
	403	}
	404
	405	final class PermissionsEnumerator implements Enumeration<Permission> {
	406
	407	// all the perms
	408	private Iterator<PermissionCollection> perms;
	409	// the current set
	410	private Enumeration<Permission> permset;
	411
	412	PermissionsEnumerator(Iterator<PermissionCollection> e) {
	413	perms = e;
	414	permset = getNextEnumWithMore();
	415	}
	416
	417	// No need to synchronize; caller should sync on object as required
	418	public boolean hasMoreElements() {
	419	// if we enter with permissionimpl null, we know
	420	// there are no more left.
	421
	422	if (permset == null)
	423	return false;
	424
	425	// try to see if there are any left in the current one
	426
	427	if (permset.hasMoreElements())
	428	return true;
	429
	430	// get the next one that has something in it...
	431	permset = getNextEnumWithMore();
	432
	433	// if it is null, we are done!
	434	return (permset != null);
	435	}
	436
	437	// No need to synchronize; caller should sync on object as required
	438	public Permission nextElement() {
	439
	440	// hasMoreElements will update permset to the next permset
	441	// with something in it...
	442
	443	if (hasMoreElements()) {
	444	return permset.nextElement();
	445	} else {
	446	throw new NoSuchElementException("PermissionsEnumerator");
	447	}
	448
	449	}
	450
	451	private Enumeration<Permission> getNextEnumWithMore() {
	452	while (perms.hasNext()) {
	453	PermissionCollection pc = perms.next();
	454	Enumeration<Permission> next =pc.elements();
	455	if (next.hasMoreElements())
	456	return next;
	457	}
	458	return null;
	459
	460	}
	461	}
	462
	463	/**
	464	* A PermissionsHash stores a homogeneous set of permissions in a hashtable.
	465	*
	466	* @see Permission
	467	* @see Permissions
	468	*
	469	*
	470	* @author Roland Schemers
	471	*
	472	* @serial include
	473	*/
	474
	475	final class PermissionsHash extends PermissionCollection
	476	implements Serializable
	477	{
	478	/**
	479	* Key and value are (same) permissions objects.
	480	* Not serialized; see serialization section at end of class.
	481	*/
	482	private transient Map<Permission, Permission> permsMap;
	483
	484	/**
	485	* Create an empty PermissionsHash object.
	486	*/
	487
	488	PermissionsHash() {
	489	permsMap = new HashMap<Permission, Permission>(11);
	490	}
	491
	492	/**
	493	* Adds a permission to the PermissionsHash.
	494	*
	495	* @param permission the Permission object to add.
	496	*/
	497
	498	public void add(Permission permission) {
	499	synchronized (this) {
	500	permsMap.put(permission, permission);
	501	}
	502	}
	503
	504	/**
	505	* Check and see if this set of permissions implies the permissions
	506	* expressed in "permission".
	507	*
	508	* @param permission the Permission object to compare
	509	*
	510	* @return true if "permission" is a proper subset of a permission in
	511	* the set, false if not.
	512	*/
	513
	514	public boolean implies(Permission permission) {
	515	// attempt a fast lookup and implies. If that fails
	516	// then enumerate through all the permissions.
	517	synchronized (this) {
	518	Permission p = permsMap.get(permission);
	519
	520	// If permission is found, then p.equals(permission)
	521	if (p == null) {
	522	for (Permission p_ : permsMap.values()) {
	523	if (p_.implies(permission))
	524	return true;
	525	}
	526	return false;
	527	} else {
	528	return true;
	529	}
	530	}
	531	}
	532
	533	/**
	534	* Returns an enumeration of all the Permission objects in the container.
	535	*
	536	* @return an enumeration of all the Permissions.
	537	*/
	538
	539	public Enumeration<Permission> elements() {
	540	// Convert Iterator of Map values into an Enumeration
	541	synchronized (this) {
	542	return Collections.enumeration(permsMap.values());
	543	}
	544	}
	545
	546	private static final long serialVersionUID = -8491988220802933440L;
	547	// Need to maintain serialization interoperability with earlier releases,
	548	// which had the serializable field:
	549	// private Hashtable perms;
	550	/**
	551	* @serialField perms java.util.Hashtable
	552	* A table of the Permissions (both key and value are same).
	553	*/
	554	private static final ObjectStreamField[] serialPersistentFields = {
	555	new ObjectStreamField("perms", Hashtable.class),
	556	};
	557
	558	/**
	559	* @serialData Default fields.
	560	*/
	561	/*
	562	* Writes the contents of the permsMap field out as a Hashtable for
	563	* serialization compatibility with earlier releases.
	564	*/
	565	private void writeObject(ObjectOutputStream out) throws IOException {
	566	// Don't call out.defaultWriteObject()
	567
	568	// Copy perms into a Hashtable
	569	Hashtable<Permission, Permission> perms =
	570	new Hashtable<>(permsMap.size()*2);
	571	synchronized (this) {
	572	perms.putAll(permsMap);
	573	}
	574
	575	// Write out serializable fields
	576	ObjectOutputStream.PutField pfields = out.putFields();
	577	pfields.put("perms", perms);
	578	out.writeFields();
	579	}
	580
	581	/*
	582	* Reads in a Hashtable of Permission/Permission and saves them in the
	583	* permsMap field.
	584	*/
	585	private void readObject(ObjectInputStream in) throws IOException,
	586	ClassNotFoundException {
	587	// Don't call defaultReadObject()
	588
	589	// Read in serialized fields
	590	ObjectInputStream.GetField gfields = in.readFields();
	591
	592	// Get permissions
	593	Hashtable<Permission, Permission> perms =
	594	(Hashtable<Permission, Permission>)gfields.get("perms", null);
	595	permsMap = new HashMap<Permission, Permission>(perms.size()*2);
	596	permsMap.putAll(perms);
	597	}
	598	}

java/pkg/java/security/PermissionsEnumerator.class+0−0

Binary file not shown.

java/pkg/java/security/PermissionsHash.class+0−0

Binary file not shown.

java/pkg/java/security/Policy$1.class+0−0

Binary file not shown.

java/pkg/java/security/Policy$2.class+0−0

Binary file not shown.

java/pkg/java/security/Policy$3.class+0−0

Binary file not shown.

java/pkg/java/security/Policy$Parameters.class+0−0

Binary file not shown.

java/pkg/java/security/Policy$PolicyDelegate.class+0−0

Binary file not shown.

java/pkg/java/security/Policy$UnsupportedEmptyCollection.class+0−0

Binary file not shown.

java/pkg/java/security/Policy.class+0−0

Binary file not shown.

java/pkg/java/security/Policy.java+835−0

@@ -0,0 +1,835 @@
	1	/*
	2	* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26
	27	package java.security;
	28
	29	import java.io.*;
	30	import java.lang.RuntimePermission;
	31	import java.lang.reflect.*;
	32	import java.net.MalformedURLException;
	33	import java.net.URL;
	34	import java.util.Enumeration;
	35	import java.util.Hashtable;
	36	import java.util.PropertyPermission;
	37	import java.util.StringTokenizer;
	38	import java.util.Vector;
	39	import java.util.WeakHashMap;
	40	import sun.security.jca.GetInstance;
	41	import sun.security.util.Debug;
	42	import sun.security.util.SecurityConstants;
	43
	44
	45	/**
	46	* A Policy object is responsible for determining whether code executing
	47	* in the Java runtime environment has permission to perform a
	48	* security-sensitive operation.
	49	*
	50	* <p> There is only one Policy object installed in the runtime at any
	51	* given time. A Policy object can be installed by calling the
	52	* <code>setPolicy</code> method. The installed Policy object can be
	53	* obtained by calling the <code>getPolicy</code> method.
	54	*
	55	* <p> If no Policy object has been installed in the runtime, a call to
	56	* <code>getPolicy</code> installs an instance of the default Policy
	57	* implementation (a default subclass implementation of this abstract class).
	58	* The default Policy implementation can be changed by setting the value
	59	* of the "policy.provider" security property (in the Java security properties
	60	* file) to the fully qualified name of the desired Policy subclass
	61	* implementation. The Java security properties file is located in the
	62	* file named <JAVA_HOME>/lib/security/java.security.
	63	* <JAVA_HOME> refers to the value of the java.home system property,
	64	* and specifies the directory where the JRE is installed.
	65	*
	66	* <p> Application code can directly subclass Policy to provide a custom
	67	* implementation. In addition, an instance of a Policy object can be
	68	* constructed by invoking one of the <code>getInstance</code> factory methods
	69	* with a standard type. The default policy type is "JavaPolicy".
	70	*
	71	* <p> Once a Policy instance has been installed (either by default, or by
	72	* calling <code>setPolicy</code>),
	73	* the Java runtime invokes its <code>implies</code> when it needs to
	74	* determine whether executing code (encapsulated in a ProtectionDomain)
	75	* can perform SecurityManager-protected operations. How a Policy object
	76	* retrieves its policy data is up to the Policy implementation itself.
	77	* The policy data may be stored, for example, in a flat ASCII file,
	78	* in a serialized binary file of the Policy class, or in a database.
	79	*
	80	* <p> The <code>refresh</code> method causes the policy object to
	81	* refresh/reload its data. This operation is implementation-dependent.
	82	* For example, if the policy object stores its data in configuration files,
	83	* calling <code>refresh</code> will cause it to re-read the configuration
	84	* policy files. If a refresh operation is not supported, this method does
	85	* nothing. Note that refreshed policy may not have an effect on classes
	86	* in a particular ProtectionDomain. This is dependent on the Policy
	87	* provider's implementation of the <code>implies</code>
	88	* method and its PermissionCollection caching strategy.
	89	*
	90	* @author Roland Schemers
	91	* @author Gary Ellison
	92	* @see java.security.Provider
	93	* @see java.security.ProtectionDomain
	94	* @see java.security.Permission
	95	*/
	96
	97	public abstract class Policy {
	98
	99	/**
	100	* A read-only empty PermissionCollection instance.
	101	* @since 1.6
	102	*/
	103	public static final PermissionCollection UNSUPPORTED_EMPTY_COLLECTION =
	104	new UnsupportedEmptyCollection();
	105
	106	/** the system-wide policy. */
	107	private static Policy policy; // package private for AccessControlContext
	108
	109	private static final Debug debug = Debug.getInstance("policy");
	110
	111	// Cache mapping ProtectionDomain.Key to PermissionCollection
	112	private WeakHashMap<ProtectionDomain.Key, PermissionCollection> pdMapping;
	113
	114	/** package private for AccessControlContext */
	115	static boolean isSet()
	116	{
	117	return policy != null;
	118	}
	119
	120	private static void checkPermission(String type) {
	121	SecurityManager sm = System.getSecurityManager();
	122	if (sm != null) {
	123	sm.checkPermission(new SecurityPermission("createPolicy." + type));
	124	}
	125	}
	126
	127	/**
	128	* Returns the installed Policy object. This value should not be cached,
	129	* as it may be changed by a call to <code>setPolicy</code>.
	130	* This method first calls
	131	* <code>SecurityManager.checkPermission</code> with a
	132	* <code>SecurityPermission("getPolicy")</code> permission
	133	* to ensure it's ok to get the Policy object.
	134	*
	135	* @return the installed Policy.
	136	*
	137	* @throws SecurityException
	138	* if a security manager exists and its
	139	* <code>checkPermission</code> method doesn't allow
	140	* getting the Policy object.
	141	*
	142	* @see SecurityManager#checkPermission(Permission)
	143	* @see #setPolicy(java.security.Policy)
	144	*/
	145	public static Policy getPolicy()
	146	{
	147	SecurityManager sm = System.getSecurityManager();
	148	if (sm != null)
	149	sm.checkPermission(SecurityConstants.GET_POLICY_PERMISSION);
	150	return getPolicyNoCheck();
	151	}
	152
	153	/**
	154	* Returns the installed Policy object, skipping the security check.
	155	* Used by SecureClassLoader and getPolicy.
	156	*
	157	* @return the installed Policy.
	158	*
	159	*/
	160	static synchronized Policy getPolicyNoCheck()
	161	{
	162	if (policy == null) {
	163	String policy_class = null;
	164	policy_class = AccessController.doPrivileged(
	165	new PrivilegedAction<String>() {
	166	public String run() {
	167	return Security.getProperty("policy.provider");
	168	}
	169	});
	170	if (policy_class == null) {
	171	policy_class = "sun.security.provider.PolicyFile";
	172	}
	173
	174	try {
	175	policy = (Policy)
	176	Class.forName(policy_class).newInstance();
	177	} catch (Exception e) {
	178	/*
	179	* The policy_class seems to be an extension
	180	* so we have to bootstrap loading it via a policy
	181	* provider that is on the bootclasspath
	182	* If it loads then shift gears to using the configured
	183	* provider.
	184	*/
	185
	186	// install the bootstrap provider to avoid recursion
	187	policy = new sun.security.provider.PolicyFile();
	188
	189	final String pc = policy_class;
	190	Policy p = AccessController.doPrivileged(
	191	new PrivilegedAction<Policy>() {
	192	public Policy run() {
	193	try {
	194	ClassLoader cl =
	195	ClassLoader.getSystemClassLoader();
	196	// we want the extension loader
	197	ClassLoader extcl = null;
	198	while (cl != null) {
	199	extcl = cl;
	200	cl = cl.getParent();
	201	}
	202	return (extcl != null ? (Policy)Class.forName(
	203	pc, true, extcl).newInstance() : null);
	204	} catch (Exception e) {
	205	if (debug != null) {
	206	debug.println("policy provider " +
	207	pc +
	208	" not available");
	209	e.printStackTrace();
	210	}
	211	return null;
	212	}
	213	}
	214	});
	215	/*
	216	* if it loaded install it as the policy provider. Otherwise
	217	* continue to use the system default implementation
	218	*/
	219	if (p != null) {
	220	policy = p;
	221	} else {
	222	if (debug != null) {
	223	debug.println("using sun.security.provider.PolicyFile");
	224	}
	225	}
	226	}
	227	}
	228	return policy;
	229	}
	230
	231	/**
	232	* Sets the system-wide Policy object. This method first calls
	233	* <code>SecurityManager.checkPermission</code> with a
	234	* <code>SecurityPermission("setPolicy")</code>
	235	* permission to ensure it's ok to set the Policy.
	236	*
	237	* @param p the new system Policy object.
	238	*
	239	* @throws SecurityException
	240	* if a security manager exists and its
	241	* <code>checkPermission</code> method doesn't allow
	242	* setting the Policy.
	243	*
	244	* @see SecurityManager#checkPermission(Permission)
	245	* @see #getPolicy()
	246	*
	247	*/
	248	public static void setPolicy(Policy p)
	249	{
	250	SecurityManager sm = System.getSecurityManager();
	251	if (sm != null) sm.checkPermission(
	252	new SecurityPermission("setPolicy"));
	253	if (p != null) {
	254	initPolicy(p);
	255	}
	256	synchronized (Policy.class) {
	257	Policy.policy = p;
	258	}
	259	}
	260
	261	/**
	262	* Initialize superclass state such that a legacy provider can
	263	* handle queries for itself.
	264	*
	265	* @since 1.4
	266	*/
	267	private static void initPolicy (final Policy p) {
	268	/*
	269	* A policy provider not on the bootclasspath could trigger
	270	* security checks fulfilling a call to either Policy.implies
	271	* or Policy.getPermissions. If this does occur the provider
	272	* must be able to answer for it's own ProtectionDomain
	273	* without triggering additional security checks, otherwise
	274	* the policy implementation will end up in an infinite
	275	* recursion.
	276	*
	277	* To mitigate this, the provider can collect it's own
	278	* ProtectionDomain and associate a PermissionCollection while
	279	* it is being installed. The currently installed policy
	280	* provider (if there is one) will handle calls to
	281	* Policy.implies or Policy.getPermissions during this
	282	* process.
	283	*
	284	* This Policy superclass caches away the ProtectionDomain and
	285	* statically binds permissions so that legacy Policy
	286	* implementations will continue to function.
	287	*/
	288
	289	ProtectionDomain policyDomain =
	290	AccessController.doPrivileged(new PrivilegedAction<ProtectionDomain>() {
	291	public ProtectionDomain run() {
	292	return p.getClass().getProtectionDomain();
	293	}
	294	});
	295
	296	/*
	297	* Collect the permissions granted to this protection domain
	298	* so that the provider can be security checked while processing
	299	* calls to Policy.implies or Policy.getPermissions.
	300	*/
	301	PermissionCollection policyPerms = null;
	302	synchronized (p) {
	303	if (p.pdMapping == null) {
	304	p.pdMapping =
	305	new WeakHashMap<ProtectionDomain.Key, PermissionCollection>();
	306	}
	307	}
	308
	309	if (policyDomain.getCodeSource() != null) {
	310	if (Policy.isSet()) {
	311	policyPerms = policy.getPermissions(policyDomain);
	312	}
	313
	314	if (policyPerms == null) { // assume it has all
	315	policyPerms = new Permissions();
	316	policyPerms.add(SecurityConstants.ALL_PERMISSION);
	317	}
	318
	319	synchronized (p.pdMapping) {
	320	// cache of pd to permissions
	321	p.pdMapping.put(policyDomain.key, policyPerms);
	322	}
	323	}
	324	return;
	325	}
	326
	327
	328	/**
	329	* Returns a Policy object of the specified type.
	330	*
	331	* <p> This method traverses the list of registered security providers,
	332	* starting with the most preferred Provider.
	333	* A new Policy object encapsulating the
	334	* PolicySpi implementation from the first
	335	* Provider that supports the specified type is returned.
	336	*
	337	* <p> Note that the list of registered providers may be retrieved via
	338	* the {@link Security#getProviders() Security.getProviders()} method.
	339	*
	340	* @param type the specified Policy type. See the Policy section in the
	341	* <a href=
	342	* "{@docRoot}/../technotes/guides/security/StandardNames.html#Policy">
	343	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	344	* for a list of standard Policy types.
	345	*
	346	* @param params parameters for the Policy, which may be null.
	347	*
	348	* @return the new Policy object.
	349	*
	350	* @exception SecurityException if the caller does not have permission
	351	* to get a Policy instance for the specified type.
	352	*
	353	* @exception NullPointerException if the specified type is null.
	354	*
	355	* @exception IllegalArgumentException if the specified parameters
	356	* are not understood by the PolicySpi implementation
	357	* from the selected Provider.
	358	*
	359	* @exception NoSuchAlgorithmException if no Provider supports a PolicySpi
	360	* implementation for the specified type.
	361	*
	362	* @see Provider
	363	* @since 1.6
	364	*/
	365	public static Policy getInstance(String type, Policy.Parameters params)
	366	throws NoSuchAlgorithmException {
	367
	368	checkPermission(type);
	369	try {
	370	GetInstance.Instance instance = GetInstance.getInstance("Policy",
	371	PolicySpi.class,
	372	type,
	373	params);
	374	return new PolicyDelegate((PolicySpi)instance.impl,
	375	instance.provider,
	376	type,
	377	params);
	378	} catch (NoSuchAlgorithmException nsae) {
	379	return handleException(nsae);
	380	}
	381	}
	382
	383	/**
	384	* Returns a Policy object of the specified type.
	385	*
	386	* <p> A new Policy object encapsulating the
	387	* PolicySpi implementation from the specified provider
	388	* is returned. The specified provider must be registered
	389	* in the provider list.
	390	*
	391	* <p> Note that the list of registered providers may be retrieved via
	392	* the {@link Security#getProviders() Security.getProviders()} method.
	393	*
	394	* @param type the specified Policy type. See the Policy section in the
	395	* <a href=
	396	* "{@docRoot}/../technotes/guides/security/StandardNames.html#Policy">
	397	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	398	* for a list of standard Policy types.
	399	*
	400	* @param params parameters for the Policy, which may be null.
	401	*
	402	* @param provider the provider.
	403	*
	404	* @return the new Policy object.
	405	*
	406	* @exception SecurityException if the caller does not have permission
	407	* to get a Policy instance for the specified type.
	408	*
	409	* @exception NullPointerException if the specified type is null.
	410	*
	411	* @exception IllegalArgumentException if the specified provider
	412	* is null or empty,
	413	* or if the specified parameters are not understood by
	414	* the PolicySpi implementation from the specified provider.
	415	*
	416	* @exception NoSuchProviderException if the specified provider is not
	417	* registered in the security provider list.
	418	*
	419	* @exception NoSuchAlgorithmException if the specified provider does not
	420	* support a PolicySpi implementation for the specified type.
	421	*
	422	* @see Provider
	423	* @since 1.6
	424	*/
	425	public static Policy getInstance(String type,
	426	Policy.Parameters params,
	427	String provider)
	428	throws NoSuchProviderException, NoSuchAlgorithmException {
	429
	430	if (provider == null \|\| provider.length() == 0) {
	431	throw new IllegalArgumentException("missing provider");
	432	}
	433
	434	checkPermission(type);
	435	try {
	436	GetInstance.Instance instance = GetInstance.getInstance("Policy",
	437	PolicySpi.class,
	438	type,
	439	params,
	440	provider);
	441	return new PolicyDelegate((PolicySpi)instance.impl,
	442	instance.provider,
	443	type,
	444	params);
	445	} catch (NoSuchAlgorithmException nsae) {
	446	return handleException (nsae);
	447	}
	448	}
	449
	450	/**
	451	* Returns a Policy object of the specified type.
	452	*
	453	* <p> A new Policy object encapsulating the
	454	* PolicySpi implementation from the specified Provider
	455	* object is returned. Note that the specified Provider object
	456	* does not have to be registered in the provider list.
	457	*
	458	* @param type the specified Policy type. See the Policy section in the
	459	* <a href=
	460	* "{@docRoot}/../technotes/guides/security/StandardNames.html#Policy">
	461	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	462	* for a list of standard Policy types.
	463	*
	464	* @param params parameters for the Policy, which may be null.
	465	*
	466	* @param provider the Provider.
	467	*
	468	* @return the new Policy object.
	469	*
	470	* @exception SecurityException if the caller does not have permission
	471	* to get a Policy instance for the specified type.
	472	*
	473	* @exception NullPointerException if the specified type is null.
	474	*
	475	* @exception IllegalArgumentException if the specified Provider is null,
	476	* or if the specified parameters are not understood by
	477	* the PolicySpi implementation from the specified Provider.
	478	*
	479	* @exception NoSuchAlgorithmException if the specified Provider does not
	480	* support a PolicySpi implementation for the specified type.
	481	*
	482	* @see Provider
	483	* @since 1.6
	484	*/
	485	public static Policy getInstance(String type,
	486	Policy.Parameters params,
	487	Provider provider)
	488	throws NoSuchAlgorithmException {
	489
	490	if (provider == null) {
	491	throw new IllegalArgumentException("missing provider");
	492	}
	493
	494	checkPermission(type);
	495	try {
	496	GetInstance.Instance instance = GetInstance.getInstance("Policy",
	497	PolicySpi.class,
	498	type,
	499	params,
	500	provider);
	501	return new PolicyDelegate((PolicySpi)instance.impl,
	502	instance.provider,
	503	type,
	504	params);
	505	} catch (NoSuchAlgorithmException nsae) {
	506	return handleException (nsae);
	507	}
	508	}
	509
	510	private static Policy handleException(NoSuchAlgorithmException nsae)
	511	throws NoSuchAlgorithmException {
	512	Throwable cause = nsae.getCause();
	513	if (cause instanceof IllegalArgumentException) {
	514	throw (IllegalArgumentException)cause;
	515	}
	516	throw nsae;
	517	}
	518
	519	/**
	520	* Return the Provider of this Policy.
	521	*
	522	* <p> This Policy instance will only have a Provider if it
	523	* was obtained via a call to <code>Policy.getInstance</code>.
	524	* Otherwise this method returns null.
	525	*
	526	* @return the Provider of this Policy, or null.
	527	*
	528	* @since 1.6
	529	*/
	530	public Provider getProvider() {
	531	return null;
	532	}
	533
	534	/**
	535	* Return the type of this Policy.
	536	*
	537	* <p> This Policy instance will only have a type if it
	538	* was obtained via a call to <code>Policy.getInstance</code>.
	539	* Otherwise this method returns null.
	540	*
	541	* @return the type of this Policy, or null.
	542	*
	543	* @since 1.6
	544	*/
	545	public String getType() {
	546	return null;
	547	}
	548
	549	/**
	550	* Return Policy parameters.
	551	*
	552	* <p> This Policy instance will only have parameters if it
	553	* was obtained via a call to <code>Policy.getInstance</code>.
	554	* Otherwise this method returns null.
	555	*
	556	* @return Policy parameters, or null.
	557	*
	558	* @since 1.6
	559	*/
	560	public Policy.Parameters getParameters() {
	561	return null;
	562	}
	563
	564	/**
	565	* Return a PermissionCollection object containing the set of
	566	* permissions granted to the specified CodeSource.
	567	*
	568	* <p> Applications are discouraged from calling this method
	569	* since this operation may not be supported by all policy implementations.
	570	* Applications should solely rely on the <code>implies</code> method
	571	* to perform policy checks. If an application absolutely must call
	572	* a getPermissions method, it should call
	573	* <code>getPermissions(ProtectionDomain)</code>.
	574	*
	575	* <p> The default implementation of this method returns
	576	* Policy.UNSUPPORTED_EMPTY_COLLECTION. This method can be
	577	* overridden if the policy implementation can return a set of
	578	* permissions granted to a CodeSource.
	579	*
	580	* @param codesource the CodeSource to which the returned
	581	* PermissionCollection has been granted.
	582	*
	583	* @return a set of permissions granted to the specified CodeSource.
	584	* If this operation is supported, the returned
	585	* set of permissions must be a new mutable instance
	586	* and it must support heterogeneous Permission types.
	587	* If this operation is not supported,
	588	* Policy.UNSUPPORTED_EMPTY_COLLECTION is returned.
	589	*/
	590	public PermissionCollection getPermissions(CodeSource codesource) {
	591	return Policy.UNSUPPORTED_EMPTY_COLLECTION;
	592	}
	593
	594	/**
	595	* Return a PermissionCollection object containing the set of
	596	* permissions granted to the specified ProtectionDomain.
	597	*
	598	* <p> Applications are discouraged from calling this method
	599	* since this operation may not be supported by all policy implementations.
	600	* Applications should rely on the <code>implies</code> method
	601	* to perform policy checks.
	602	*
	603	* <p> The default implementation of this method first retrieves
	604	* the permissions returned via <code>getPermissions(CodeSource)</code>
	605	* (the CodeSource is taken from the specified ProtectionDomain),
	606	* as well as the permissions located inside the specified ProtectionDomain.
	607	* All of these permissions are then combined and returned in a new
	608	* PermissionCollection object. If <code>getPermissions(CodeSource)</code>
	609	* returns Policy.UNSUPPORTED_EMPTY_COLLECTION, then this method
	610	* returns the permissions contained inside the specified ProtectionDomain
	611	* in a new PermissionCollection object.
	612	*
	613	* <p> This method can be overridden if the policy implementation
	614	* supports returning a set of permissions granted to a ProtectionDomain.
	615	*
	616	* @param domain the ProtectionDomain to which the returned
	617	* PermissionCollection has been granted.
	618	*
	619	* @return a set of permissions granted to the specified ProtectionDomain.
	620	* If this operation is supported, the returned
	621	* set of permissions must be a new mutable instance
	622	* and it must support heterogeneous Permission types.
	623	* If this operation is not supported,
	624	* Policy.UNSUPPORTED_EMPTY_COLLECTION is returned.
	625	*
	626	* @since 1.4
	627	*/
	628	public PermissionCollection getPermissions(ProtectionDomain domain) {
	629	PermissionCollection pc = null;
	630
	631	if (domain == null)
	632	return new Permissions();
	633
	634	if (pdMapping == null) {
	635	initPolicy(this);
	636	}
	637
	638	synchronized (pdMapping) {
	639	pc = pdMapping.get(domain.key);
	640	}
	641
	642	if (pc != null) {
	643	Permissions perms = new Permissions();
	644	synchronized (pc) {
	645	for (Enumeration<Permission> e = pc.elements() ; e.hasMoreElements() ;) {
	646	perms.add(e.nextElement());
	647	}
	648	}
	649	return perms;
	650	}
	651
	652	pc = getPermissions(domain.getCodeSource());
	653	if (pc == null \|\| pc == UNSUPPORTED_EMPTY_COLLECTION) {
	654	pc = new Permissions();
	655	}
	656
	657	addStaticPerms(pc, domain.getPermissions());
	658	return pc;
	659	}
	660
	661	/**
	662	* add static permissions to provided permission collection
	663	*/
	664	private void addStaticPerms(PermissionCollection perms,
	665	PermissionCollection statics) {
	666	if (statics != null) {
	667	synchronized (statics) {
	668	Enumeration<Permission> e = statics.elements();
	669	while (e.hasMoreElements()) {
	670	perms.add(e.nextElement());
	671	}
	672	}
	673	}
	674	}
	675
	676	/**
	677	* Evaluates the global policy for the permissions granted to
	678	* the ProtectionDomain and tests whether the permission is
	679	* granted.
	680	*
	681	* @param domain the ProtectionDomain to test
	682	* @param permission the Permission object to be tested for implication.
	683	*
	684	* @return true if "permission" is a proper subset of a permission
	685	* granted to this ProtectionDomain.
	686	*
	687	* @see java.security.ProtectionDomain
	688	* @since 1.4
	689	*/
	690	public boolean implies(ProtectionDomain domain, Permission permission) {
	691	PermissionCollection pc;
	692
	693	if (pdMapping == null) {
	694	initPolicy(this);
	695	}
	696
	697	synchronized (pdMapping) {
	698	pc = pdMapping.get(domain.key);
	699	}
	700
	701	if (pc != null) {
	702	return pc.implies(permission);
	703	}
	704
	705	pc = getPermissions(domain);
	706	if (pc == null) {
	707	return false;
	708	}
	709
	710	synchronized (pdMapping) {
	711	// cache it
	712	pdMapping.put(domain.key, pc);
	713	}
	714
	715	return pc.implies(permission);
	716	}
	717
	718	/**
	719	* Refreshes/reloads the policy configuration. The behavior of this method
	720	* depends on the implementation. For example, calling <code>refresh</code>
	721	* on a file-based policy will cause the file to be re-read.
	722	*
	723	* <p> The default implementation of this method does nothing.
	724	* This method should be overridden if a refresh operation is supported
	725	* by the policy implementation.
	726	*/
	727	public void refresh() { }
	728
	729	/**
	730	* This subclass is returned by the getInstance calls. All Policy calls
	731	* are delegated to the underlying PolicySpi.
	732	*/
	733	private static class PolicyDelegate extends Policy {
	734
	735	private PolicySpi spi;
	736	private Provider p;
	737	private String type;
	738	private Policy.Parameters params;
	739
	740	private PolicyDelegate(PolicySpi spi, Provider p,
	741	String type, Policy.Parameters params) {
	742	this.spi = spi;
	743	this.p = p;
	744	this.type = type;
	745	this.params = params;
	746	}
	747
	748	@Override public String getType() { return type; }
	749
	750	@Override public Policy.Parameters getParameters() { return params; }
	751
	752	@Override public Provider getProvider() { return p; }
	753
	754	@Override
	755	public PermissionCollection getPermissions(CodeSource codesource) {
	756	return spi.engineGetPermissions(codesource);
	757	}
	758	@Override
	759	public PermissionCollection getPermissions(ProtectionDomain domain) {
	760	return spi.engineGetPermissions(domain);
	761	}
	762	@Override
	763	public boolean implies(ProtectionDomain domain, Permission perm) {
	764	return spi.engineImplies(domain, perm);
	765	}
	766	@Override
	767	public void refresh() {
	768	spi.engineRefresh();
	769	}
	770	}
	771
	772	/**
	773	* This represents a marker interface for Policy parameters.
	774	*
	775	* @since 1.6
	776	*/
	777	public static interface Parameters { }
	778
	779	/**
	780	* This class represents a read-only empty PermissionCollection object that
	781	* is returned from the <code>getPermissions(CodeSource)</code> and
	782	* <code>getPermissions(ProtectionDomain)</code>
	783	* methods in the Policy class when those operations are not
	784	* supported by the Policy implementation.
	785	*/
	786	private static class UnsupportedEmptyCollection
	787	extends PermissionCollection {
	788
	789	private Permissions perms;
	790
	791	/**
	792	* Create a read-only empty PermissionCollection object.
	793	*/
	794	public UnsupportedEmptyCollection() {
	795	this.perms = new Permissions();
	796	perms.setReadOnly();
	797	}
	798
	799	/**
	800	* Adds a permission object to the current collection of permission
	801	* objects.
	802	*
	803	* @param permission the Permission object to add.
	804	*
	805	* @exception SecurityException - if this PermissionCollection object
	806	* has been marked readonly
	807	*/
	808	@Override public void add(Permission permission) {
	809	perms.add(permission);
	810	}
	811
	812	/**
	813	* Checks to see if the specified permission is implied by the
	814	* collection of Permission objects held in this PermissionCollection.
	815	*
	816	* @param permission the Permission object to compare.
	817	*
	818	* @return true if "permission" is implied by the permissions in
	819	* the collection, false if not.
	820	*/
	821	@Override public boolean implies(Permission permission) {
	822	return perms.implies(permission);
	823	}
	824
	825	/**
	826	* Returns an enumeration of all the Permission objects in the
	827	* collection.
	828	*
	829	* @return an enumeration of all the Permissions.
	830	*/
	831	@Override public Enumeration<Permission> elements() {
	832	return perms.elements();
	833	}
	834	}
	835	}

java/pkg/java/security/PolicySpi.class+0−0

Binary file not shown.

java/pkg/java/security/PolicySpi.java+118−0

@@ -0,0 +1,118 @@
	1	/*
	2	* Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26
	27	package java.security;
	28
	29	/**
	30	* This class defines the <i>Service Provider Interface</i> (<b>SPI</b>)
	31	* for the <code>Policy</code> class.
	32	* All the abstract methods in this class must be implemented by each
	33	* service provider who wishes to supply a Policy implementation.
	34	*
	35	* <p> Subclass implementations of this abstract class must provide
	36	* a public constructor that takes a <code>Policy.Parameters</code>
	37	* object as an input parameter. This constructor also must throw
	38	* an IllegalArgumentException if it does not understand the
	39	* <code>Policy.Parameters</code> input.
	40	*
	41	*
	42	* @since 1.6
	43	*/
	44
	45	public abstract class PolicySpi {
	46
	47	/**
	48	* Check whether the policy has granted a Permission to a ProtectionDomain.
	49	*
	50	* @param domain the ProtectionDomain to check.
	51	*
	52	* @param permission check whether this permission is granted to the
	53	* specified domain.
	54	*
	55	* @return boolean true if the permission is granted to the domain.
	56	*/
	57	protected abstract boolean engineImplies
	58	(ProtectionDomain domain, Permission permission);
	59
	60	/**
	61	* Refreshes/reloads the policy configuration. The behavior of this method
	62	* depends on the implementation. For example, calling <code>refresh</code>
	63	* on a file-based policy will cause the file to be re-read.
	64	*
	65	* <p> The default implementation of this method does nothing.
	66	* This method should be overridden if a refresh operation is supported
	67	* by the policy implementation.
	68	*/
	69	protected void engineRefresh() { }
	70
	71	/**
	72	* Return a PermissionCollection object containing the set of
	73	* permissions granted to the specified CodeSource.
	74	*
	75	* <p> The default implementation of this method returns
	76	* Policy.UNSUPPORTED_EMPTY_COLLECTION object. This method can be
	77	* overridden if the policy implementation can return a set of
	78	* permissions granted to a CodeSource.
	79	*
	80	* @param codesource the CodeSource to which the returned
	81	* PermissionCollection has been granted.
	82	*
	83	* @return a set of permissions granted to the specified CodeSource.
	84	* If this operation is supported, the returned
	85	* set of permissions must be a new mutable instance
	86	* and it must support heterogeneous Permission types.
	87	* If this operation is not supported,
	88	* Policy.UNSUPPORTED_EMPTY_COLLECTION is returned.
	89	*/
	90	protected PermissionCollection engineGetPermissions
	91	(CodeSource codesource) {
	92	return Policy.UNSUPPORTED_EMPTY_COLLECTION;
	93	}
	94
	95	/**
	96	* Return a PermissionCollection object containing the set of
	97	* permissions granted to the specified ProtectionDomain.
	98	*
	99	* <p> The default implementation of this method returns
	100	* Policy.UNSUPPORTED_EMPTY_COLLECTION object. This method can be
	101	* overridden if the policy implementation can return a set of
	102	* permissions granted to a ProtectionDomain.
	103	*
	104	* @param domain the ProtectionDomain to which the returned
	105	* PermissionCollection has been granted.
	106	*
	107	* @return a set of permissions granted to the specified ProtectionDomain.
	108	* If this operation is supported, the returned
	109	* set of permissions must be a new mutable instance
	110	* and it must support heterogeneous Permission types.
	111	* If this operation is not supported,
	112	* Policy.UNSUPPORTED_EMPTY_COLLECTION is returned.
	113	*/
	114	protected PermissionCollection engineGetPermissions
	115	(ProtectionDomain domain) {
	116	return Policy.UNSUPPORTED_EMPTY_COLLECTION;
	117	}
	118	}

java/pkg/java/security/Principal.class+0−0

Binary file not shown.

java/pkg/java/security/Principal.java+72−0

@@ -0,0 +1,72 @@
	1	/*
	2	* Copyright (c) 1996, 1998, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	/**
	29	* This interface represents the abstract notion of a principal, which
	30	* can be used to represent any entity, such as an individual, a
	31	* corporation, and a login id.
	32	*
	33	* @see java.security.cert.X509Certificate
	34	*
	35	* @author Li Gong
	36	*/
	37	public interface Principal {
	38
	39	/**
	40	* Compares this principal to the specified object. Returns true
	41	* if the object passed in matches the principal represented by
	42	* the implementation of this interface.
	43	*
	44	* @param another principal to compare with.
	45	*
	46	* @return true if the principal passed in is the same as that
	47	* encapsulated by this principal, and false otherwise.
	48
	49	*/
	50	public boolean equals(Object another);
	51
	52	/**
	53	* Returns a string representation of this principal.
	54	*
	55	* @return a string representation of this principal.
	56	*/
	57	public String toString();
	58
	59	/**
	60	* Returns a hashcode for this principal.
	61	*
	62	* @return a hashcode for this principal.
	63	*/
	64	public int hashCode();
	65
	66	/**
	67	* Returns the name of this principal.
	68	*
	69	* @return the name of this principal.
	70	*/
	71	public String getName();
	72	}

java/pkg/java/security/PrivateKey.class+0−0

Binary file not shown.

java/pkg/java/security/PrivateKey.java+56−0

@@ -0,0 +1,56 @@
	1	/*
	2	* Copyright (c) 1996, 2001, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	/**
	29	* <p>A private key. This interface contains no methods or constants.
	30	* It merely serves to group (and provide type safety for) all private key
	31	* interfaces.
	32	*
	33	* Note: The specialized private key interfaces extend this interface.
	34	* See, for example, the DSAPrivateKey interface in
	35	* <code>java.security.interfaces</code>.
	36	*
	37	* @see Key
	38	* @see PublicKey
	39	* @see Certificate
	40	* @see Signature#initVerify
	41	* @see java.security.interfaces.DSAPrivateKey
	42	* @see java.security.interfaces.RSAPrivateKey
	43	* @see java.security.interfaces.RSAPrivateCrtKey
	44	*
	45	* @author Benjamin Renaud
	46	* @author Josh Bloch
	47	*/
	48
	49	public interface PrivateKey extends Key {
	50	// Declare serialVersionUID to be compatible with JDK1.1
	51	/**
	52	* The class fingerprint that is set to indicate serialization
	53	* compatibility with a previous version of the class.
	54	*/
	55	static final long serialVersionUID = 6034044314589513430L;
	56	}

java/pkg/java/security/PrivilegedAction.class+0−0

Binary file not shown.

java/pkg/java/security/PrivilegedAction.java+56−0

@@ -0,0 +1,56 @@
	1	/*
	2	* Copyright (c) 1998, 2004, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28
	29	/**
	30	* A computation to be performed with privileges enabled. The computation is
	31	* performed by invoking <code>AccessController.doPrivileged</code> on the
	32	* <code>PrivilegedAction</code> object. This interface is used only for
	33	* computations that do not throw checked exceptions; computations that
	34	* throw checked exceptions must use <code>PrivilegedExceptionAction</code>
	35	* instead.
	36	*
	37	* @see AccessController
	38	* @see AccessController#doPrivileged(PrivilegedAction)
	39	* @see PrivilegedExceptionAction
	40	*/
	41
	42	public interface PrivilegedAction<T> {
	43	/**
	44	* Performs the computation. This method will be called by
	45	* <code>AccessController.doPrivileged</code> after enabling privileges.
	46	*
	47	* @return a class-dependent value that may represent the results of the
	48	* computation. Each class that implements
	49	* <code>PrivilegedAction</code>
	50	* should document what (if anything) this value represents.
	51	* @see AccessController#doPrivileged(PrivilegedAction)
	52	* @see AccessController#doPrivileged(PrivilegedAction,
	53	* AccessControlContext)
	54	*/
	55	T run();
	56	}

java/pkg/java/security/PrivilegedActionException.class+0−0

Binary file not shown.

java/pkg/java/security/PrivilegedActionException.java+105−0

@@ -0,0 +1,105 @@
	1	/*
	2	* Copyright (c) 1998, 2001, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	/**
	29	* This exception is thrown by
	30	* <code>doPrivileged(PrivilegedExceptionAction)</code> and
	31	* <code>doPrivileged(PrivilegedExceptionAction,
	32	* AccessControlContext context)</code> to indicate
	33	* that the action being performed threw a checked exception. The exception
	34	* thrown by the action can be obtained by calling the
	35	* <code>getException</code> method. In effect, an
	36	* <code>PrivilegedActionException</code> is a "wrapper"
	37	* for an exception thrown by a privileged action.
	38	*
	39	* <p>As of release 1.4, this exception has been retrofitted to conform to
	40	* the general purpose exception-chaining mechanism. The "exception thrown
	41	* by the privileged computation" that is provided at construction time and
	42	* accessed via the {@link #getException()} method is now known as the
	43	* <i>cause</i>, and may be accessed via the {@link Throwable#getCause()}
	44	* method, as well as the aforementioned "legacy method."
	45	*
	46	* @see PrivilegedExceptionAction
	47	* @see AccessController#doPrivileged(PrivilegedExceptionAction)
	48	* @see AccessController#doPrivileged(PrivilegedExceptionAction,AccessControlContext)
	49	*/
	50	public class PrivilegedActionException extends Exception {
	51	// use serialVersionUID from JDK 1.2.2 for interoperability
	52	private static final long serialVersionUID = 4724086851538908602L;
	53
	54	/**
	55	* @serial
	56	*/
	57	private Exception exception;
	58
	59	/**
	60	* Constructs a new PrivilegedActionException "wrapping"
	61	* the specific Exception.
	62	*
	63	* @param exception The exception thrown
	64	*/
	65	public PrivilegedActionException(Exception exception) {
	66	super((Throwable)null); // Disallow initCause
	67	this.exception = exception;
	68	}
	69
	70	/**
	71	* Returns the exception thrown by the privileged computation that
	72	* resulted in this <code>PrivilegedActionException</code>.
	73	*
	74	* <p>This method predates the general-purpose exception chaining facility.
	75	* The {@link Throwable#getCause()} method is now the preferred means of
	76	* obtaining this information.
	77	*
	78	* @return the exception thrown by the privileged computation that
	79	* resulted in this <code>PrivilegedActionException</code>.
	80	* @see PrivilegedExceptionAction
	81	* @see AccessController#doPrivileged(PrivilegedExceptionAction)
	82	* @see AccessController#doPrivileged(PrivilegedExceptionAction,
	83	* AccessControlContext)
	84	*/
	85	public Exception getException() {
	86	return exception;
	87	}
	88
	89	/**
	90	* Returns the cause of this exception (the exception thrown by
	91	* the privileged computation that resulted in this
	92	* <code>PrivilegedActionException</code>).
	93	*
	94	* @return the cause of this exception.
	95	* @since 1.4
	96	*/
	97	public Throwable getCause() {
	98	return exception;
	99	}
	100
	101	public String toString() {
	102	String s = getClass().getName();
	103	return (exception != null) ? (s + ": " + exception.toString()) : s;
	104	}
	105	}

java/pkg/java/security/PrivilegedExceptionAction.class+0−0

Binary file not shown.

java/pkg/java/security/PrivilegedExceptionAction.java+62−0

@@ -0,0 +1,62 @@
	1	/*
	2	* Copyright (c) 1998, 2004, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28
	29	/**
	30	* A computation to be performed with privileges enabled, that throws one or
	31	* more checked exceptions. The computation is performed by invoking
	32	* <code>AccessController.doPrivileged</code> on the
	33	* <code>PrivilegedExceptionAction</code> object. This interface is
	34	* used only for computations that throw checked exceptions;
	35	* computations that do not throw
	36	* checked exceptions should use <code>PrivilegedAction</code> instead.
	37	*
	38	* @see AccessController
	39	* @see AccessController#doPrivileged(PrivilegedExceptionAction)
	40	* @see AccessController#doPrivileged(PrivilegedExceptionAction,
	41	* AccessControlContext)
	42	* @see PrivilegedAction
	43	*/
	44
	45	public interface PrivilegedExceptionAction<T> {
	46	/**
	47	* Performs the computation. This method will be called by
	48	* <code>AccessController.doPrivileged</code> after enabling privileges.
	49	*
	50	* @return a class-dependent value that may represent the results of the
	51	* computation. Each class that implements
	52	* <code>PrivilegedExceptionAction</code> should document what
	53	* (if anything) this value represents.
	54	* @throws Exception an exceptional condition has occurred. Each class
	55	* that implements <code>PrivilegedExceptionAction</code> should
	56	* document the exceptions that its run method can throw.
	57	* @see AccessController#doPrivileged(PrivilegedExceptionAction)
	58	* @see AccessController#doPrivileged(PrivilegedExceptionAction,AccessControlContext)
	59	*/
	60
	61	T run() throws Exception;
	62	}

java/pkg/java/security/ProtectionDomain$1.class+0−0

Binary file not shown.

java/pkg/java/security/ProtectionDomain$2.class+0−0

Binary file not shown.

java/pkg/java/security/ProtectionDomain$3$1.class+0−0

Binary file not shown.

java/pkg/java/security/ProtectionDomain$3.class+0−0

Binary file not shown.

java/pkg/java/security/ProtectionDomain$Key.class+0−0

Binary file not shown.

java/pkg/java/security/ProtectionDomain.class+0−0

Binary file not shown.

java/pkg/java/security/ProtectionDomain.java+467−0

@@ -0,0 +1,467 @@
	1	/*
	2	* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.util.ArrayList;
	29	import java.util.Collections;
	30	import java.util.Enumeration;
	31	import java.util.List;
	32	import java.util.Map;
	33	import java.util.WeakHashMap;
	34	import sun.misc.JavaSecurityProtectionDomainAccess;
	35	import static sun.misc.JavaSecurityProtectionDomainAccess.ProtectionDomainCache;
	36	import sun.misc.SharedSecrets;
	37	import sun.security.util.Debug;
	38	import sun.security.util.SecurityConstants;
	39	import sun.misc.JavaSecurityAccess;
	40	import sun.misc.SharedSecrets;
	41
	42	/**
	43	*
	44	*<p>
	45	* This ProtectionDomain class encapsulates the characteristics of a domain,
	46	* which encloses a set of classes whose instances are granted a set
	47	* of permissions when being executed on behalf of a given set of Principals.
	48	* <p>
	49	* A static set of permissions can be bound to a ProtectionDomain when it is
	50	* constructed; such permissions are granted to the domain regardless of the
	51	* Policy in force. However, to support dynamic security policies, a
	52	* ProtectionDomain can also be constructed such that it is dynamically
	53	* mapped to a set of permissions by the current Policy whenever a permission
	54	* is checked.
	55	* <p>
	56	*
	57	* @author Li Gong
	58	* @author Roland Schemers
	59	* @author Gary Ellison
	60	*/
	61
	62	public class ProtectionDomain {
	63
	64	static {
	65	// Set up JavaSecurityAccess in SharedSecrets
	66	SharedSecrets.setJavaSecurityAccess(
	67	new JavaSecurityAccess() {
	68	public <T> T doIntersectionPrivilege(
	69	PrivilegedAction<T> action,
	70	final AccessControlContext stack,
	71	final AccessControlContext context)
	72	{
	73	if (action == null) {
	74	throw new NullPointerException();
	75	}
	76	return AccessController.doPrivileged(
	77	action,
	78	new AccessControlContext(
	79	stack.getContext(), context).optimize()
	80	);
	81	}
	82
	83	public <T> T doIntersectionPrivilege(
	84	PrivilegedAction<T> action,
	85	AccessControlContext context)
	86	{
	87	return doIntersectionPrivilege(action,
	88	AccessController.getContext(), context);
	89	}
	90	}
	91	);
	92	}
	93
	94	/* CodeSource */
	95	private CodeSource codesource ;
	96
	97	/* ClassLoader the protection domain was consed from */
	98	private ClassLoader classloader;
	99
	100	/* Principals running-as within this protection domain */
	101	private Principal[] principals;
	102
	103	/* the rights this protection domain is granted */
	104	private PermissionCollection permissions;
	105
	106	/* if the permissions object has AllPermission */
	107	private boolean hasAllPerm = false;
	108
	109	/* the PermissionCollection is static (pre 1.4 constructor)
	110	or dynamic (via a policy refresh) */
	111	private boolean staticPermissions;
	112
	113	/*
	114	* An object used as a key when the ProtectionDomain is stored in a Map.
	115	*/
	116	final Key key = new Key();
	117
	118	private static final Debug debug = Debug.getInstance("domain");
	119
	120	/**
	121	* Creates a new ProtectionDomain with the given CodeSource and
	122	* Permissions. If the permissions object is not null, then
	123	* <code>setReadOnly())</code> will be called on the passed in
	124	* Permissions object. The only permissions granted to this domain
	125	* are the ones specified; the current Policy will not be consulted.
	126	*
	127	* @param codesource the codesource associated with this domain
	128	* @param permissions the permissions granted to this domain
	129	*/
	130	public ProtectionDomain(CodeSource codesource,
	131	PermissionCollection permissions) {
	132	this.codesource = codesource;
	133	if (permissions != null) {
	134	this.permissions = permissions;
	135	this.permissions.setReadOnly();
	136	if (permissions instanceof Permissions &&
	137	((Permissions)permissions).allPermission != null) {
	138	hasAllPerm = true;
	139	}
	140	}
	141	this.classloader = null;
	142	this.principals = new Principal[0];
	143	staticPermissions = true;
	144	}
	145
	146	/**
	147	* Creates a new ProtectionDomain qualified by the given CodeSource,
	148	* Permissions, ClassLoader and array of Principals. If the
	149	* permissions object is not null, then <code>setReadOnly()</code>
	150	* will be called on the passed in Permissions object.
	151	* The permissions granted to this domain are dynamic; they include
	152	* both the static permissions passed to this constructor, and any
	153	* permissions granted to this domain by the current Policy at the
	154	* time a permission is checked.
	155	* <p>
	156	* This constructor is typically used by
	157	* {@link SecureClassLoader ClassLoaders}
	158	* and {@link DomainCombiner DomainCombiners} which delegate to
	159	* <code>Policy</code> to actively associate the permissions granted to
	160	* this domain. This constructor affords the
	161	* Policy provider the opportunity to augment the supplied
	162	* PermissionCollection to reflect policy changes.
	163	* <p>
	164	*
	165	* @param codesource the CodeSource associated with this domain
	166	* @param permissions the permissions granted to this domain
	167	* @param classloader the ClassLoader associated with this domain
	168	* @param principals the array of Principals associated with this
	169	* domain. The contents of the array are copied to protect against
	170	* subsequent modification.
	171	* @see Policy#refresh
	172	* @see Policy#getPermissions(ProtectionDomain)
	173	* @since 1.4
	174	*/
	175	public ProtectionDomain(CodeSource codesource,
	176	PermissionCollection permissions,
	177	ClassLoader classloader,
	178	Principal[] principals) {
	179	this.codesource = codesource;
	180	if (permissions != null) {
	181	this.permissions = permissions;
	182	this.permissions.setReadOnly();
	183	if (permissions instanceof Permissions &&
	184	((Permissions)permissions).allPermission != null) {
	185	hasAllPerm = true;
	186	}
	187	}
	188	this.classloader = classloader;
	189	this.principals = (principals != null ? principals.clone():
	190	new Principal[0]);
	191	staticPermissions = false;
	192	}
	193
	194	/**
	195	* Returns the CodeSource of this domain.
	196	* @return the CodeSource of this domain which may be null.
	197	* @since 1.2
	198	*/
	199	public final CodeSource getCodeSource() {
	200	return this.codesource;
	201	}
	202
	203
	204	/**
	205	* Returns the ClassLoader of this domain.
	206	* @return the ClassLoader of this domain which may be null.
	207	*
	208	* @since 1.4
	209	*/
	210	public final ClassLoader getClassLoader() {
	211	return this.classloader;
	212	}
	213
	214
	215	/**
	216	* Returns an array of principals for this domain.
	217	* @return a non-null array of principals for this domain.
	218	* Returns a new array each time this method is called.
	219	*
	220	* @since 1.4
	221	*/
	222	public final Principal[] getPrincipals() {
	223	return this.principals.clone();
	224	}
	225
	226	/**
	227	* Returns the static permissions granted to this domain.
	228	*
	229	* @return the static set of permissions for this domain which may be null.
	230	* @see Policy#refresh
	231	* @see Policy#getPermissions(ProtectionDomain)
	232	*/
	233	public final PermissionCollection getPermissions() {
	234	return permissions;
	235	}
	236
	237	/**
	238	* Check and see if this ProtectionDomain implies the permissions
	239	* expressed in the Permission object.
	240	* <p>
	241	* The set of permissions evaluated is a function of whether the
	242	* ProtectionDomain was constructed with a static set of permissions
	243	* or it was bound to a dynamically mapped set of permissions.
	244	* <p>
	245	* If the ProtectionDomain was constructed to a
	246	* {@link #ProtectionDomain(CodeSource, PermissionCollection)
	247	* statically bound} PermissionCollection then the permission will
	248	* only be checked against the PermissionCollection supplied at
	249	* construction.
	250	* <p>
	251	* However, if the ProtectionDomain was constructed with
	252	* the constructor variant which supports
	253	* {@link #ProtectionDomain(CodeSource, PermissionCollection,
	254	* ClassLoader, java.security.Principal[]) dynamically binding}
	255	* permissions, then the permission will be checked against the
	256	* combination of the PermissionCollection supplied at construction and
	257	* the current Policy binding.
	258	* <p>
	259	*
	260	* @param permission the Permission object to check.
	261	*
	262	* @return true if "permission" is implicit to this ProtectionDomain.
	263	*/
	264	public boolean implies(Permission permission) {
	265
	266	if (hasAllPerm) {
	267	// internal permission collection already has AllPermission -
	268	// no need to go to policy
	269	return true;
	270	}
	271
	272	if (!staticPermissions &&
	273	Policy.getPolicyNoCheck().implies(this, permission))
	274	return true;
	275	if (permissions != null)
	276	return permissions.implies(permission);
	277
	278	return false;
	279	}
	280
	281	/**
	282	* Convert a ProtectionDomain to a String.
	283	*/
	284	@Override public String toString() {
	285	String pals = "<no principals>";
	286	if (principals != null && principals.length > 0) {
	287	StringBuilder palBuf = new StringBuilder("(principals ");
	288
	289	for (int i = 0; i < principals.length; i++) {
	290	palBuf.append(principals[i].getClass().getName() +
	291	" \"" + principals[i].getName() +
	292	"\"");
	293	if (i < principals.length-1)
	294	palBuf.append(",\n");
	295	else
	296	palBuf.append(")\n");
	297	}
	298	pals = palBuf.toString();
	299	}
	300
	301	// Check if policy is set; we don't want to load
	302	// the policy prematurely here
	303	PermissionCollection pc = Policy.isSet() && seeAllp() ?
	304	mergePermissions():
	305	getPermissions();
	306
	307	return "ProtectionDomain "+
	308	" "+codesource+"\n"+
	309	" "+classloader+"\n"+
	310	" "+pals+"\n"+
	311	" "+pc+"\n";
	312	}
	313
	314	/**
	315	* Return true (merge policy permissions) in the following cases:
	316	*
	317	* . SecurityManager is null
	318	*
	319	* . SecurityManager is not null,
	320	* debug is not null,
	321	* SecurityManager impelmentation is in bootclasspath,
	322	* Policy implementation is in bootclasspath
	323	* (the bootclasspath restrictions avoid recursion)
	324	*
	325	* . SecurityManager is not null,
	326	* debug is null,
	327	* caller has Policy.getPolicy permission
	328	*/
	329	private static boolean seeAllp() {
	330	SecurityManager sm = System.getSecurityManager();
	331
	332	if (sm == null) {
	333	return true;
	334	} else {
	335	if (debug != null) {
	336	if (sm.getClass().getClassLoader() == null &&
	337	Policy.getPolicyNoCheck().getClass().getClassLoader()
	338	== null) {
	339	return true;
	340	}
	341	} else {
	342	try {
	343	sm.checkPermission(SecurityConstants.GET_POLICY_PERMISSION);
	344	return true;
	345	} catch (SecurityException se) {
	346	// fall thru and return false
	347	}
	348	}
	349	}
	350
	351	return false;
	352	}
	353
	354	private PermissionCollection mergePermissions() {
	355	if (staticPermissions)
	356	return permissions;
	357
	358	PermissionCollection perms =
	359	java.security.AccessController.doPrivileged
	360	(new java.security.PrivilegedAction<PermissionCollection>() {
	361	public PermissionCollection run() {
	362	Policy p = Policy.getPolicyNoCheck();
	363	return p.getPermissions(ProtectionDomain.this);
	364	}
	365	});
	366
	367	Permissions mergedPerms = new Permissions();
	368	int swag = 32;
	369	int vcap = 8;
	370	Enumeration<Permission> e;
	371	List<Permission> pdVector = new ArrayList<>(vcap);
	372	List<Permission> plVector = new ArrayList<>(swag);
	373
	374	//
	375	// Build a vector of domain permissions for subsequent merge
	376	if (permissions != null) {
	377	synchronized (permissions) {
	378	e = permissions.elements();
	379	while (e.hasMoreElements()) {
	380	pdVector.add(e.nextElement());
	381	}
	382	}
	383	}
	384
	385	//
	386	// Build a vector of Policy permissions for subsequent merge
	387	if (perms != null) {
	388	synchronized (perms) {
	389	e = perms.elements();
	390	while (e.hasMoreElements()) {
	391	plVector.add(e.nextElement());
	392	vcap++;
	393	}
	394	}
	395	}
	396
	397	if (perms != null && permissions != null) {
	398	//
	399	// Weed out the duplicates from the policy. Unless a refresh
	400	// has occured since the pd was consed this should result in
	401	// an empty vector.
	402	synchronized (permissions) {
	403	e = permissions.elements(); // domain vs policy
	404	while (e.hasMoreElements()) {
	405	Permission pdp = e.nextElement();
	406	Class pdpClass = pdp.getClass();
	407	String pdpActions = pdp.getActions();
	408	String pdpName = pdp.getName();
	409	for (int i = 0; i < plVector.size(); i++) {
	410	Permission pp = plVector.get(i);
	411	if (pdpClass.isInstance(pp)) {
	412	// The equals() method on some permissions
	413	// have some side effects so this manual
	414	// comparison is sufficient.
	415	if (pdpName.equals(pp.getName()) &&
	416	pdpActions.equals(pp.getActions())) {
	417	plVector.remove(i);
	418	break;
	419	}
	420	}
	421	}
	422	}
	423	}
	424	}
	425
	426	if (perms !=null) {
	427	// the order of adding to merged perms and permissions
	428	// needs to preserve the bugfix 4301064
	429
	430	for (int i = plVector.size()-1; i >= 0; i--) {
	431	mergedPerms.add(plVector.get(i));
	432	}
	433	}
	434	if (permissions != null) {
	435	for (int i = pdVector.size()-1; i >= 0; i--) {
	436	mergedPerms.add(pdVector.get(i));
	437	}
	438	}
	439
	440	return mergedPerms;
	441	}
	442
	443	/**
	444	* Used for storing ProtectionDomains as keys in a Map.
	445	*/
	446	final class Key {}
	447
	448	static {
	449	SharedSecrets.setJavaSecurityProtectionDomainAccess(
	450	new JavaSecurityProtectionDomainAccess() {
	451	public ProtectionDomainCache getProtectionDomainCache() {
	452	return new ProtectionDomainCache() {
	453	private final Map<Key, PermissionCollection> map =
	454	Collections.synchronizedMap
	455	(new WeakHashMap<Key, PermissionCollection>());
	456	public void put(ProtectionDomain pd,
	457	PermissionCollection pc) {
	458	map.put((pd == null ? null : pd.key), pc);
	459	}
	460	public PermissionCollection get(ProtectionDomain pd) {
	461	return pd == null ? map.get(null) : map.get(pd.key);
	462	}
	463	};
	464	}
	465	});
	466	}
	467	}

java/pkg/java/security/Provider$1.class+0−0

Binary file not shown.

java/pkg/java/security/Provider$EngineDescription.class+0−0

Binary file not shown.

java/pkg/java/security/Provider$Service.class+0−0

Binary file not shown.

java/pkg/java/security/Provider$ServiceKey.class+0−0

Binary file not shown.

java/pkg/java/security/Provider$UString.class+0−0

Binary file not shown.

java/pkg/java/security/Provider.class+0−0

Binary file not shown.

java/pkg/java/security/Provider.java+1479−0

@@ -0,0 +1,1479 @@
	1	/*
	2	* Copyright (c) 1996, 2011, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.io.*;
	29	import java.util.*;
	30	import static java.util.Locale.ENGLISH;
	31	import java.lang.ref.*;
	32	import java.lang.reflect.*;
	33
	34	import java.security.cert.CertStoreParameters;
	35	import javax.security.auth.login.Configuration;
	36
	37	/**
	38	* This class represents a "provider" for the
	39	* Java Security API, where a provider implements some or all parts of
	40	* Java Security. Services that a provider may implement include:
	41	*
	42	* <ul>
	43	*
	44	* <li>Algorithms (such as DSA, RSA, MD5 or SHA-1).
	45	*
	46	* <li>Key generation, conversion, and management facilities (such as for
	47	* algorithm-specific keys).
	48	*
	49	*</ul>
	50	*
	51	* <p>Each provider has a name and a version number, and is configured
	52	* in each runtime it is installed in.
	53	*
	54	* <p>See <a href =
	55	* "../../../technotes/guides/security/crypto/CryptoSpec.html#Provider">The Provider Class</a>
	56	* in the "Java Cryptography Architecture API Specification & Reference"
	57	* for information about how a particular type of provider, the
	58	* cryptographic service provider, works and is installed. However,
	59	* please note that a provider can be used to implement any security
	60	* service in Java that uses a pluggable architecture with a choice
	61	* of implementations that fit underneath.
	62	*
	63	* <p>Some provider implementations may encounter unrecoverable internal
	64	* errors during their operation, for example a failure to communicate with a
	65	* security token. A {@link ProviderException} should be used to indicate
	66	* such errors.
	67	*
	68	* <p>The service type <code>Provider</code> is reserved for use by the
	69	* security framework. Services of this type cannot be added, removed,
	70	* or modified by applications.
	71	* The following attributes are automatically placed in each Provider object:
	72	* <table cellspacing=4>
	73	* <tr><th>Name</th><th>Value</th>
	74	* <tr><td><code>Provider.id name</code></td>
	75	* <td><code>String.valueOf(provider.getName())</code></td>
	76	* <tr><td><code>Provider.id version</code></td>
	77	* <td><code>String.valueOf(provider.getVersion())</code></td>
	78	* <tr><td><code>Provider.id info</code></td>
	79	<td><code>String.valueOf(provider.getInfo())</code></td>
	80	* <tr><td><code>Provider.id className</code></td>
	81	* <td><code>provider.getClass().getName()</code></td>
	82	* </table>
	83	*
	84	* @author Benjamin Renaud
	85	* @author Andreas Sterbenz
	86	*/
	87	public abstract class Provider extends Properties {
	88
	89	// Declare serialVersionUID to be compatible with JDK1.1
	90	static final long serialVersionUID = -4298000515446427739L;
	91
	92	private static final sun.security.util.Debug debug =
	93	sun.security.util.Debug.getInstance
	94	("provider", "Provider");
	95
	96	/**
	97	* The provider name.
	98	*
	99	* @serial
	100	*/
	101	private String name;
	102
	103	/**
	104	* A description of the provider and its services.
	105	*
	106	* @serial
	107	*/
	108	private String info;
	109
	110	/**
	111	* The provider version number.
	112	*
	113	* @serial
	114	*/
	115	private double version;
	116
	117
	118	private transient Set<Map.Entry<Object,Object>> entrySet = null;
	119	private transient int entrySetCallCount = 0;
	120
	121	private transient boolean initialized;
	122
	123	/**
	124	* Constructs a provider with the specified name, version number,
	125	* and information.
	126	*
	127	* @param name the provider name.
	128	*
	129	* @param version the provider version number.
	130	*
	131	* @param info a description of the provider and its services.
	132	*/
	133	protected Provider(String name, double version, String info) {
	134	this.name = name;
	135	this.version = version;
	136	this.info = info;
	137	putId();
	138	initialized = true;
	139	}
	140
	141	/**
	142	* Returns the name of this provider.
	143	*
	144	* @return the name of this provider.
	145	*/
	146	public String getName() {
	147	return name;
	148	}
	149
	150	/**
	151	* Returns the version number for this provider.
	152	*
	153	* @return the version number for this provider.
	154	*/
	155	public double getVersion() {
	156	return version;
	157	}
	158
	159	/**
	160	* Returns a human-readable description of the provider and its
	161	* services. This may return an HTML page, with relevant links.
	162	*
	163	* @return a description of the provider and its services.
	164	*/
	165	public String getInfo() {
	166	return info;
	167	}
	168
	169	/**
	170	* Returns a string with the name and the version number
	171	* of this provider.
	172	*
	173	* @return the string with the name and the version number
	174	* for this provider.
	175	*/
	176	public String toString() {
	177	return name + " version " + version;
	178	}
	179
	180	/*
	181	* override the following methods to ensure that provider
	182	* information can only be changed if the caller has the appropriate
	183	* permissions.
	184	*/
	185
	186	/**
	187	* Clears this provider so that it no longer contains the properties
	188	* used to look up facilities implemented by the provider.
	189	*
	190	* <p>First, if there is a security manager, its
	191	* <code>checkSecurityAccess</code> method is called with the string
	192	* <code>"clearProviderProperties."+name</code> (where <code>name</code>
	193	* is the provider name) to see if it's ok to clear this provider.
	194	* If the default implementation of <code>checkSecurityAccess</code>
	195	* is used (that is, that method is not overriden), then this results in
	196	* a call to the security manager's <code>checkPermission</code> method
	197	* with a <code>SecurityPermission("clearProviderProperties."+name)</code>
	198	* permission.
	199	*
	200	* @throws SecurityException
	201	* if a security manager exists and its <code>{@link
	202	* java.lang.SecurityManager#checkSecurityAccess}</code> method
	203	* denies access to clear this provider
	204	*
	205	* @since 1.2
	206	*/
	207	public synchronized void clear() {
	208	check("clearProviderProperties."+name);
	209	if (debug != null) {
	210	debug.println("Remove " + name + " provider properties");
	211	}
	212	implClear();
	213	}
	214
	215	/**
	216	* Reads a property list (key and element pairs) from the input stream.
	217	*
	218	* @param inStream the input stream.
	219	* @exception IOException if an error occurred when reading from the
	220	* input stream.
	221	* @see java.util.Properties#load
	222	*/
	223	public synchronized void load(InputStream inStream) throws IOException {
	224	check("putProviderProperty."+name);
	225	if (debug != null) {
	226	debug.println("Load " + name + " provider properties");
	227	}
	228	Properties tempProperties = new Properties();
	229	tempProperties.load(inStream);
	230	implPutAll(tempProperties);
	231	}
	232
	233	/**
	234	* Copies all of the mappings from the specified Map to this provider.
	235	* These mappings will replace any properties that this provider had
	236	* for any of the keys currently in the specified Map.
	237	*
	238	* @since 1.2
	239	*/
	240	public synchronized void putAll(Map<?,?> t) {
	241	check("putProviderProperty."+name);
	242	if (debug != null) {
	243	debug.println("Put all " + name + " provider properties");
	244	}
	245	implPutAll(t);
	246	}
	247
	248	/**
	249	* Returns an unmodifiable Set view of the property entries contained
	250	* in this Provider.
	251	*
	252	* @see java.util.Map.Entry
	253	* @since 1.2
	254	*/
	255	public synchronized Set<Map.Entry<Object,Object>> entrySet() {
	256	checkInitialized();
	257	if (entrySet == null) {
	258	if (entrySetCallCount++ == 0) // Initial call
	259	entrySet = Collections.unmodifiableMap(this).entrySet();
	260	else
	261	return super.entrySet(); // Recursive call
	262	}
	263
	264	// This exception will be thrown if the implementation of
	265	// Collections.unmodifiableMap.entrySet() is changed such that it
	266	// no longer calls entrySet() on the backing Map. (Provider's
	267	// entrySet implementation depends on this "implementation detail",
	268	// which is unlikely to change.
	269	if (entrySetCallCount != 2)
	270	throw new RuntimeException("Internal error.");
	271
	272	return entrySet;
	273	}
	274
	275	/**
	276	* Returns an unmodifiable Set view of the property keys contained in
	277	* this provider.
	278	*
	279	* @since 1.2
	280	*/
	281	public Set<Object> keySet() {
	282	checkInitialized();
	283	return Collections.unmodifiableSet(super.keySet());
	284	}
	285
	286	/**
	287	* Returns an unmodifiable Collection view of the property values
	288	* contained in this provider.
	289	*
	290	* @since 1.2
	291	*/
	292	public Collection<Object> values() {
	293	checkInitialized();
	294	return Collections.unmodifiableCollection(super.values());
	295	}
	296
	297	/**
	298	* Sets the <code>key</code> property to have the specified
	299	* <code>value</code>.
	300	*
	301	* <p>First, if there is a security manager, its
	302	* <code>checkSecurityAccess</code> method is called with the string
	303	* <code>"putProviderProperty."+name</code>, where <code>name</code> is the
	304	* provider name, to see if it's ok to set this provider's property values.
	305	* If the default implementation of <code>checkSecurityAccess</code>
	306	* is used (that is, that method is not overriden), then this results in
	307	* a call to the security manager's <code>checkPermission</code> method
	308	* with a <code>SecurityPermission("putProviderProperty."+name)</code>
	309	* permission.
	310	*
	311	* @param key the property key.
	312	*
	313	* @param value the property value.
	314	*
	315	* @return the previous value of the specified property
	316	* (<code>key</code>), or null if it did not have one.
	317	*
	318	* @throws SecurityException
	319	* if a security manager exists and its <code>{@link
	320	* java.lang.SecurityManager#checkSecurityAccess}</code> method
	321	* denies access to set property values.
	322	*
	323	* @since 1.2
	324	*/
	325	public synchronized Object put(Object key, Object value) {
	326	check("putProviderProperty."+name);
	327	if (debug != null) {
	328	debug.println("Set " + name + " provider property [" +
	329	key + "/" + value +"]");
	330	}
	331	return implPut(key, value);
	332	}
	333
	334	/**
	335	* Removes the <code>key</code> property (and its corresponding
	336	* <code>value</code>).
	337	*
	338	* <p>First, if there is a security manager, its
	339	* <code>checkSecurityAccess</code> method is called with the string
	340	* <code>"removeProviderProperty."+name</code>, where <code>name</code> is
	341	* the provider name, to see if it's ok to remove this provider's
	342	* properties. If the default implementation of
	343	* <code>checkSecurityAccess</code> is used (that is, that method is not
	344	* overriden), then this results in a call to the security manager's
	345	* <code>checkPermission</code> method with a
	346	* <code>SecurityPermission("removeProviderProperty."+name)</code>
	347	* permission.
	348	*
	349	* @param key the key for the property to be removed.
	350	*
	351	* @return the value to which the key had been mapped,
	352	* or null if the key did not have a mapping.
	353	*
	354	* @throws SecurityException
	355	* if a security manager exists and its <code>{@link
	356	* java.lang.SecurityManager#checkSecurityAccess}</code> method
	357	* denies access to remove this provider's properties.
	358	*
	359	* @since 1.2
	360	*/
	361	public synchronized Object remove(Object key) {
	362	check("removeProviderProperty."+name);
	363	if (debug != null) {
	364	debug.println("Remove " + name + " provider property " + key);
	365	}
	366	return implRemove(key);
	367	}
	368
	369	// let javadoc show doc from superclass
	370	public Object get(Object key) {
	371	checkInitialized();
	372	return super.get(key);
	373	}
	374
	375	// let javadoc show doc from superclass
	376	public Enumeration<Object> keys() {
	377	checkInitialized();
	378	return super.keys();
	379	}
	380
	381	// let javadoc show doc from superclass
	382	public Enumeration<Object> elements() {
	383	checkInitialized();
	384	return super.elements();
	385	}
	386
	387	// let javadoc show doc from superclass
	388	public String getProperty(String key) {
	389	checkInitialized();
	390	return super.getProperty(key);
	391	}
	392
	393	private void checkInitialized() {
	394	if (!initialized) {
	395	throw new IllegalStateException();
	396	}
	397	}
	398
	399	private void check(String directive) {
	400	checkInitialized();
	401	SecurityManager security = System.getSecurityManager();
	402	if (security != null) {
	403	security.checkSecurityAccess(directive);
	404	}
	405	}
	406
	407	// legacy properties changed since last call to any services method?
	408	private transient boolean legacyChanged;
	409	// serviceMap changed since last call to getServices()
	410	private transient boolean servicesChanged;
	411
	412	// Map<String,String>
	413	private transient Map<String,String> legacyStrings;
	414
	415	// Map<ServiceKey,Service>
	416	// used for services added via putService(), initialized on demand
	417	private transient Map<ServiceKey,Service> serviceMap;
	418
	419	// Map<ServiceKey,Service>
	420	// used for services added via legacy methods, init on demand
	421	private transient Map<ServiceKey,Service> legacyMap;
	422
	423	// Set<Service>
	424	// Unmodifiable set of all services. Initialized on demand.
	425	private transient Set<Service> serviceSet;
	426
	427	// register the id attributes for this provider
	428	// this is to ensure that equals() and hashCode() do not incorrectly
	429	// report to different provider objects as the same
	430	private void putId() {
	431	// note: name and info may be null
	432	super.put("Provider.id name", String.valueOf(name));
	433	super.put("Provider.id version", String.valueOf(version));
	434	super.put("Provider.id info", String.valueOf(info));
	435	super.put("Provider.id className", this.getClass().getName());
	436	}
	437
	438	private void readObject(ObjectInputStream in)
	439	throws IOException, ClassNotFoundException {
	440	Map<Object,Object> copy = new HashMap<>();
	441	for (Map.Entry<Object,Object> entry : super.entrySet()) {
	442	copy.put(entry.getKey(), entry.getValue());
	443	}
	444	defaults = null;
	445	in.defaultReadObject();
	446	implClear();
	447	initialized = true;
	448	putAll(copy);
	449	}
	450
	451	/**
	452	* Copies all of the mappings from the specified Map to this provider.
	453	* Internal method to be called AFTER the security check has been
	454	* performed.
	455	*/
	456	private void implPutAll(Map t) {
	457	for (Map.Entry e : ((Map<?,?>)t).entrySet()) {
	458	implPut(e.getKey(), e.getValue());
	459	}
	460	}
	461
	462	private Object implRemove(Object key) {
	463	if (key instanceof String) {
	464	String keyString = (String)key;
	465	if (keyString.startsWith("Provider.")) {
	466	return null;
	467	}
	468	legacyChanged = true;
	469	if (legacyStrings == null) {
	470	legacyStrings = new LinkedHashMap<String,String>();
	471	}
	472	legacyStrings.remove(keyString);
	473	}
	474	return super.remove(key);
	475	}
	476
	477	private Object implPut(Object key, Object value) {
	478	if ((key instanceof String) && (value instanceof String)) {
	479	String keyString = (String)key;
	480	if (keyString.startsWith("Provider.")) {
	481	return null;
	482	}
	483	legacyChanged = true;
	484	if (legacyStrings == null) {
	485	legacyStrings = new LinkedHashMap<String,String>();
	486	}
	487	legacyStrings.put(keyString, (String)value);
	488	}
	489	return super.put(key, value);
	490	}
	491
	492	private void implClear() {
	493	if (legacyStrings != null) {
	494	legacyStrings.clear();
	495	}
	496	if (legacyMap != null) {
	497	legacyMap.clear();
	498	}
	499	if (serviceMap != null) {
	500	serviceMap.clear();
	501	}
	502	legacyChanged = false;
	503	servicesChanged = false;
	504	serviceSet = null;
	505	super.clear();
	506	putId();
	507	}
	508
	509	// used as key in the serviceMap and legacyMap HashMaps
	510	private static class ServiceKey {
	511	private final String type;
	512	private final String algorithm;
	513	private final String originalAlgorithm;
	514	private ServiceKey(String type, String algorithm, boolean intern) {
	515	this.type = type;
	516	this.originalAlgorithm = algorithm;
	517	algorithm = algorithm.toUpperCase(ENGLISH);
	518	this.algorithm = intern ? algorithm.intern() : algorithm;
	519	}
	520	public int hashCode() {
	521	return type.hashCode() + algorithm.hashCode();
	522	}
	523	public boolean equals(Object obj) {
	524	if (this == obj) {
	525	return true;
	526	}
	527	if (obj instanceof ServiceKey == false) {
	528	return false;
	529	}
	530	ServiceKey other = (ServiceKey)obj;
	531	return this.type.equals(other.type)
	532	&& this.algorithm.equals(other.algorithm);
	533	}
	534	boolean matches(String type, String algorithm) {
	535	return (this.type == type) && (this.originalAlgorithm == algorithm);
	536	}
	537	}
	538
	539	/**
	540	* Ensure all the legacy String properties are fully parsed into
	541	* service objects.
	542	*/
	543	private void ensureLegacyParsed() {
	544	if ((legacyChanged == false) \|\| (legacyStrings == null)) {
	545	return;
	546	}
	547	serviceSet = null;
	548	if (legacyMap == null) {
	549	legacyMap = new LinkedHashMap<ServiceKey,Service>();
	550	} else {
	551	legacyMap.clear();
	552	}
	553	for (Map.Entry<String,String> entry : legacyStrings.entrySet()) {
	554	parseLegacyPut(entry.getKey(), entry.getValue());
	555	}
	556	removeInvalidServices(legacyMap);
	557	legacyChanged = false;
	558	}
	559
	560	/**
	561	* Remove all invalid services from the Map. Invalid services can only
	562	* occur if the legacy properties are inconsistent or incomplete.
	563	*/
	564	private void removeInvalidServices(Map<ServiceKey,Service> map) {
	565	for (Iterator t = map.entrySet().iterator(); t.hasNext(); ) {
	566	Map.Entry entry = (Map.Entry)t.next();
	567	Service s = (Service)entry.getValue();
	568	if (s.isValid() == false) {
	569	t.remove();
	570	}
	571	}
	572	}
	573
	574	private String[] getTypeAndAlgorithm(String key) {
	575	int i = key.indexOf(".");
	576	if (i < 1) {
	577	if (debug != null) {
	578	debug.println("Ignoring invalid entry in provider "
	579	+ name + ":" + key);
	580	}
	581	return null;
	582	}
	583	String type = key.substring(0, i);
	584	String alg = key.substring(i + 1);
	585	return new String[] {type, alg};
	586	}
	587
	588	private final static String ALIAS_PREFIX = "Alg.Alias.";
	589	private final static String ALIAS_PREFIX_LOWER = "alg.alias.";
	590	private final static int ALIAS_LENGTH = ALIAS_PREFIX.length();
	591
	592	private void parseLegacyPut(String name, String value) {
	593	if (name.toLowerCase(ENGLISH).startsWith(ALIAS_PREFIX_LOWER)) {
	594	// e.g. put("Alg.Alias.MessageDigest.SHA", "SHA-1");
	595	// aliasKey ~ MessageDigest.SHA
	596	String stdAlg = value;
	597	String aliasKey = name.substring(ALIAS_LENGTH);
	598	String[] typeAndAlg = getTypeAndAlgorithm(aliasKey);
	599	if (typeAndAlg == null) {
	600	return;
	601	}
	602	String type = getEngineName(typeAndAlg[0]);
	603	String aliasAlg = typeAndAlg[1].intern();
	604	ServiceKey key = new ServiceKey(type, stdAlg, true);
	605	Service s = legacyMap.get(key);
	606	if (s == null) {
	607	s = new Service(this);
	608	s.type = type;
	609	s.algorithm = stdAlg;
	610	legacyMap.put(key, s);
	611	}
	612	legacyMap.put(new ServiceKey(type, aliasAlg, true), s);
	613	s.addAlias(aliasAlg);
	614	} else {
	615	String[] typeAndAlg = getTypeAndAlgorithm(name);
	616	if (typeAndAlg == null) {
	617	return;
	618	}
	619	int i = typeAndAlg[1].indexOf(' ');
	620	if (i == -1) {
	621	// e.g. put("MessageDigest.SHA-1", "sun.security.provider.SHA");
	622	String type = getEngineName(typeAndAlg[0]);
	623	String stdAlg = typeAndAlg[1].intern();
	624	String className = value;
	625	ServiceKey key = new ServiceKey(type, stdAlg, true);
	626	Service s = legacyMap.get(key);
	627	if (s == null) {
	628	s = new Service(this);
	629	s.type = type;
	630	s.algorithm = stdAlg;
	631	legacyMap.put(key, s);
	632	}
	633	s.className = className;
	634	} else { // attribute
	635	// e.g. put("MessageDigest.SHA-1 ImplementedIn", "Software");
	636	String attributeValue = value;
	637	String type = getEngineName(typeAndAlg[0]);
	638	String attributeString = typeAndAlg[1];
	639	String stdAlg = attributeString.substring(0, i).intern();
	640	String attributeName = attributeString.substring(i + 1);
	641	// kill additional spaces
	642	while (attributeName.startsWith(" ")) {
	643	attributeName = attributeName.substring(1);
	644	}
	645	attributeName = attributeName.intern();
	646	ServiceKey key = new ServiceKey(type, stdAlg, true);
	647	Service s = legacyMap.get(key);
	648	if (s == null) {
	649	s = new Service(this);
	650	s.type = type;
	651	s.algorithm = stdAlg;
	652	legacyMap.put(key, s);
	653	}
	654	s.addAttribute(attributeName, attributeValue);
	655	}
	656	}
	657	}
	658
	659	/**
	660	* Get the service describing this Provider's implementation of the
	661	* specified type of this algorithm or alias. If no such
	662	* implementation exists, this method returns null. If there are two
	663	* matching services, one added to this provider using
	664	* {@link #putService putService()} and one added via {@link #put put()},
	665	* the service added via {@link #putService putService()} is returned.
	666	*
	667	* @param type the type of {@link Service service} requested
	668	* (for example, <code>MessageDigest</code>)
	669	* @param algorithm the case insensitive algorithm name (or alternate
	670	* alias) of the service requested (for example, <code>SHA-1</code>)
	671	*
	672	* @return the service describing this Provider's matching service
	673	* or null if no such service exists
	674	*
	675	* @throws NullPointerException if type or algorithm is null
	676	*
	677	* @since 1.5
	678	*/
	679	public synchronized Service getService(String type, String algorithm) {
	680	checkInitialized();
	681	// avoid allocating a new key object if possible
	682	ServiceKey key = previousKey;
	683	if (key.matches(type, algorithm) == false) {
	684	key = new ServiceKey(type, algorithm, false);
	685	previousKey = key;
	686	}
	687	if (serviceMap != null) {
	688	Service service = serviceMap.get(key);
	689	if (service != null) {
	690	return service;
	691	}
	692	}
	693	ensureLegacyParsed();
	694	return (legacyMap != null) ? legacyMap.get(key) : null;
	695	}
	696
	697	// ServiceKey from previous getService() call
	698	// by re-using it if possible we avoid allocating a new object
	699	// and the toUpperCase() call.
	700	// re-use will occur e.g. as the framework traverses the provider
	701	// list and queries each provider with the same values until it finds
	702	// a matching service
	703	private static volatile ServiceKey previousKey =
	704	new ServiceKey("", "", false);
	705
	706	/**
	707	* Get an unmodifiable Set of all services supported by
	708	* this Provider.
	709	*
	710	* @return an unmodifiable Set of all services supported by
	711	* this Provider
	712	*
	713	* @since 1.5
	714	*/
	715	public synchronized Set<Service> getServices() {
	716	checkInitialized();
	717	if (legacyChanged \|\| servicesChanged) {
	718	serviceSet = null;
	719	}
	720	if (serviceSet == null) {
	721	ensureLegacyParsed();
	722	Set<Service> set = new LinkedHashSet<>();
	723	if (serviceMap != null) {
	724	set.addAll(serviceMap.values());
	725	}
	726	if (legacyMap != null) {
	727	set.addAll(legacyMap.values());
	728	}
	729	serviceSet = Collections.unmodifiableSet(set);
	730	servicesChanged = false;
	731	}
	732	return serviceSet;
	733	}
	734
	735	/**
	736	* Add a service. If a service of the same type with the same algorithm
	737	* name exists and it was added using {@link #putService putService()},
	738	* it is replaced by the new service.
	739	* This method also places information about this service
	740	* in the provider's Hashtable values in the format described in the
	741	* <a href="../../../technotes/guides/security/crypto/CryptoSpec.html">
	742	* Java Cryptography Architecture API Specification & Reference </a>.
	743	*
	744	* <p>Also, if there is a security manager, its
	745	* <code>checkSecurityAccess</code> method is called with the string
	746	* <code>"putProviderProperty."+name</code>, where <code>name</code> is
	747	* the provider name, to see if it's ok to set this provider's property
	748	* values. If the default implementation of <code>checkSecurityAccess</code>
	749	* is used (that is, that method is not overriden), then this results in
	750	* a call to the security manager's <code>checkPermission</code> method with
	751	* a <code>SecurityPermission("putProviderProperty."+name)</code>
	752	* permission.
	753	*
	754	* @param s the Service to add
	755	*
	756	* @throws SecurityException
	757	* if a security manager exists and its <code>{@link
	758	* java.lang.SecurityManager#checkSecurityAccess}</code> method denies
	759	* access to set property values.
	760	* @throws NullPointerException if s is null
	761	*
	762	* @since 1.5
	763	*/
	764	protected synchronized void putService(Service s) {
	765	check("putProviderProperty." + name);
	766	if (debug != null) {
	767	debug.println(name + ".putService(): " + s);
	768	}
	769	if (s == null) {
	770	throw new NullPointerException();
	771	}
	772	if (s.getProvider() != this) {
	773	throw new IllegalArgumentException
	774	("service.getProvider() must match this Provider object");
	775	}
	776	if (serviceMap == null) {
	777	serviceMap = new LinkedHashMap<ServiceKey,Service>();
	778	}
	779	servicesChanged = true;
	780	String type = s.getType();
	781	String algorithm = s.getAlgorithm();
	782	ServiceKey key = new ServiceKey(type, algorithm, true);
	783	// remove existing service
	784	implRemoveService(serviceMap.get(key));
	785	serviceMap.put(key, s);
	786	for (String alias : s.getAliases()) {
	787	serviceMap.put(new ServiceKey(type, alias, true), s);
	788	}
	789	putPropertyStrings(s);
	790	}
	791
	792	/**
	793	* Put the string properties for this Service in this Provider's
	794	* Hashtable.
	795	*/
	796	private void putPropertyStrings(Service s) {
	797	String type = s.getType();
	798	String algorithm = s.getAlgorithm();
	799	// use super() to avoid permission check and other processing
	800	super.put(type + "." + algorithm, s.getClassName());
	801	for (String alias : s.getAliases()) {
	802	super.put(ALIAS_PREFIX + type + "." + alias, algorithm);
	803	}
	804	for (Map.Entry<UString,String> entry : s.attributes.entrySet()) {
	805	String key = type + "." + algorithm + " " + entry.getKey();
	806	super.put(key, entry.getValue());
	807	}
	808	}
	809
	810	/**
	811	* Remove the string properties for this Service from this Provider's
	812	* Hashtable.
	813	*/
	814	private void removePropertyStrings(Service s) {
	815	String type = s.getType();
	816	String algorithm = s.getAlgorithm();
	817	// use super() to avoid permission check and other processing
	818	super.remove(type + "." + algorithm);
	819	for (String alias : s.getAliases()) {
	820	super.remove(ALIAS_PREFIX + type + "." + alias);
	821	}
	822	for (Map.Entry<UString,String> entry : s.attributes.entrySet()) {
	823	String key = type + "." + algorithm + " " + entry.getKey();
	824	super.remove(key);
	825	}
	826	}
	827
	828	/**
	829	* Remove a service previously added using
	830	* {@link #putService putService()}. The specified service is removed from
	831	* this provider. It will no longer be returned by
	832	* {@link #getService getService()} and its information will be removed
	833	* from this provider's Hashtable.
	834	*
	835	* <p>Also, if there is a security manager, its
	836	* <code>checkSecurityAccess</code> method is called with the string
	837	* <code>"removeProviderProperty."+name</code>, where <code>name</code> is
	838	* the provider name, to see if it's ok to remove this provider's
	839	* properties. If the default implementation of
	840	* <code>checkSecurityAccess</code> is used (that is, that method is not
	841	* overriden), then this results in a call to the security manager's
	842	* <code>checkPermission</code> method with a
	843	* <code>SecurityPermission("removeProviderProperty."+name)</code>
	844	* permission.
	845	*
	846	* @param s the Service to be removed
	847	*
	848	* @throws SecurityException
	849	* if a security manager exists and its <code>{@link
	850	* java.lang.SecurityManager#checkSecurityAccess}</code> method denies
	851	* access to remove this provider's properties.
	852	* @throws NullPointerException if s is null
	853	*
	854	* @since 1.5
	855	*/
	856	protected synchronized void removeService(Service s) {
	857	check("removeProviderProperty." + name);
	858	if (debug != null) {
	859	debug.println(name + ".removeService(): " + s);
	860	}
	861	if (s == null) {
	862	throw new NullPointerException();
	863	}
	864	implRemoveService(s);
	865	}
	866
	867	private void implRemoveService(Service s) {
	868	if ((s == null) \|\| (serviceMap == null)) {
	869	return;
	870	}
	871	String type = s.getType();
	872	String algorithm = s.getAlgorithm();
	873	ServiceKey key = new ServiceKey(type, algorithm, false);
	874	Service oldService = serviceMap.get(key);
	875	if (s != oldService) {
	876	return;
	877	}
	878	servicesChanged = true;
	879	serviceMap.remove(key);
	880	for (String alias : s.getAliases()) {
	881	serviceMap.remove(new ServiceKey(type, alias, false));
	882	}
	883	removePropertyStrings(s);
	884	}
	885
	886	// Wrapped String that behaves in a case insensitive way for equals/hashCode
	887	private static class UString {
	888	final String string;
	889	final String lowerString;
	890
	891	UString(String s) {
	892	this.string = s;
	893	this.lowerString = s.toLowerCase(ENGLISH);
	894	}
	895
	896	public int hashCode() {
	897	return lowerString.hashCode();
	898	}
	899
	900	public boolean equals(Object obj) {
	901	if (this == obj) {
	902	return true;
	903	}
	904	if (obj instanceof UString == false) {
	905	return false;
	906	}
	907	UString other = (UString)obj;
	908	return lowerString.equals(other.lowerString);
	909	}
	910
	911	public String toString() {
	912	return string;
	913	}
	914	}
	915
	916	// describe relevant properties of a type of engine
	917	private static class EngineDescription {
	918	final String name;
	919	final boolean supportsParameter;
	920	final String constructorParameterClassName;
	921	private volatile Class constructorParameterClass;
	922
	923	EngineDescription(String name, boolean sp, String paramName) {
	924	this.name = name;
	925	this.supportsParameter = sp;
	926	this.constructorParameterClassName = paramName;
	927	}
	928	Class getConstructorParameterClass() throws ClassNotFoundException {
	929	Class clazz = constructorParameterClass;
	930	if (clazz == null) {
	931	clazz = Class.forName(constructorParameterClassName);
	932	constructorParameterClass = clazz;
	933	}
	934	return clazz;
	935	}
	936	}
	937
	938	// built in knowledge of the engine types shipped as part of the JDK
	939	private static final Map<String,EngineDescription> knownEngines;
	940
	941	private static void addEngine(String name, boolean sp, String paramName) {
	942	EngineDescription ed = new EngineDescription(name, sp, paramName);
	943	// also index by canonical name to avoid toLowerCase() for some lookups
	944	knownEngines.put(name.toLowerCase(ENGLISH), ed);
	945	knownEngines.put(name, ed);
	946	}
	947
	948	static {
	949	knownEngines = new HashMap<String,EngineDescription>();
	950	// JCA
	951	addEngine("AlgorithmParameterGenerator", false, null);
	952	addEngine("AlgorithmParameters", false, null);
	953	addEngine("KeyFactory", false, null);
	954	addEngine("KeyPairGenerator", false, null);
	955	addEngine("KeyStore", false, null);
	956	addEngine("MessageDigest", false, null);
	957	addEngine("SecureRandom", false, null);
	958	addEngine("Signature", true, null);
	959	addEngine("CertificateFactory", false, null);
	960	addEngine("CertPathBuilder", false, null);
	961	addEngine("CertPathValidator", false, null);
	962	addEngine("CertStore", false,
	963	"java.security.cert.CertStoreParameters");
	964	// JCE
	965	addEngine("Cipher", true, null);
	966	addEngine("ExemptionMechanism", false, null);
	967	addEngine("Mac", true, null);
	968	addEngine("KeyAgreement", true, null);
	969	addEngine("KeyGenerator", false, null);
	970	addEngine("SecretKeyFactory", false, null);
	971	// JSSE
	972	addEngine("KeyManagerFactory", false, null);
	973	addEngine("SSLContext", false, null);
	974	addEngine("TrustManagerFactory", false, null);
	975	// JGSS
	976	addEngine("GssApiMechanism", false, null);
	977	// SASL
	978	addEngine("SaslClientFactory", false, null);
	979	addEngine("SaslServerFactory", false, null);
	980	// POLICY
	981	addEngine("Policy", false,
	982	"java.security.Policy$Parameters");
	983	// CONFIGURATION
	984	addEngine("Configuration", false,
	985	"javax.security.auth.login.Configuration$Parameters");
	986	// XML DSig
	987	addEngine("XMLSignatureFactory", false, null);
	988	addEngine("KeyInfoFactory", false, null);
	989	addEngine("TransformService", false, null);
	990	// Smart Card I/O
	991	addEngine("TerminalFactory", false,
	992	"java.lang.Object");
	993	}
	994
	995	// get the "standard" (mixed-case) engine name for arbitary case engine name
	996	// if there is no known engine by that name, return s
	997	private static String getEngineName(String s) {
	998	// try original case first, usually correct
	999	EngineDescription e = knownEngines.get(s);
	1000	if (e == null) {
	1001	e = knownEngines.get(s.toLowerCase(ENGLISH));
	1002	}
	1003	return (e == null) ? s : e.name;
	1004	}
	1005
	1006	/**
	1007	* The description of a security service. It encapsulates the properties
	1008	* of a service and contains a factory method to obtain new implementation
	1009	* instances of this service.
	1010	*
	1011	* <p>Each service has a provider that offers the service, a type,
	1012	* an algorithm name, and the name of the class that implements the
	1013	* service. Optionally, it also includes a list of alternate algorithm
	1014	* names for this service (aliases) and attributes, which are a map of
	1015	* (name, value) String pairs.
	1016	*
	1017	* <p>This class defines the methods {@link #supportsParameter
	1018	* supportsParameter()} and {@link #newInstance newInstance()}
	1019	* which are used by the Java security framework when it searches for
	1020	* suitable services and instantes them. The valid arguments to those
	1021	* methods depend on the type of service. For the service types defined
	1022	* within Java SE, see the
	1023	* <a href="../../../technotes/guides/security/crypto/CryptoSpec.html">
	1024	* Java Cryptography Architecture API Specification & Reference </a>
	1025	* for the valid values.
	1026	* Note that components outside of Java SE can define additional types of
	1027	* services and their behavior.
	1028	*
	1029	* <p>Instances of this class are immutable.
	1030	*
	1031	* @since 1.5
	1032	*/
	1033	public static class Service {
	1034
	1035	private String type, algorithm, className;
	1036	private final Provider provider;
	1037	private List<String> aliases;
	1038	private Map<UString,String> attributes;
	1039
	1040	// Reference to the cached implementation Class object
	1041	private volatile Reference<Class> classRef;
	1042
	1043	// flag indicating whether this service has its attributes for
	1044	// supportedKeyFormats or supportedKeyClasses set
	1045	// if null, the values have not been initialized
	1046	// if TRUE, at least one of supportedFormats/Classes is non null
	1047	private volatile Boolean hasKeyAttributes;
	1048
	1049	// supported encoding formats
	1050	private String[] supportedFormats;
	1051
	1052	// names of the supported key (super) classes
	1053	private Class[] supportedClasses;
	1054
	1055	// whether this service has been registered with the Provider
	1056	private boolean registered;
	1057
	1058	private static final Class[] CLASS0 = new Class[0];
	1059
	1060	// this constructor and these methods are used for parsing
	1061	// the legacy string properties.
	1062
	1063	private Service(Provider provider) {
	1064	this.provider = provider;
	1065	aliases = Collections.<String>emptyList();
	1066	attributes = Collections.<UString,String>emptyMap();
	1067	}
	1068
	1069	private boolean isValid() {
	1070	return (type != null) && (algorithm != null) && (className != null);
	1071	}
	1072
	1073	private void addAlias(String alias) {
	1074	if (aliases.isEmpty()) {
	1075	aliases = new ArrayList<String>(2);
	1076	}
	1077	aliases.add(alias);
	1078	}
	1079
	1080	void addAttribute(String type, String value) {
	1081	if (attributes.isEmpty()) {
	1082	attributes = new HashMap<UString,String>(8);
	1083	}
	1084	attributes.put(new UString(type), value);
	1085	}
	1086
	1087	/**
	1088	* Construct a new service.
	1089	*
	1090	* @param provider the provider that offers this service
	1091	* @param type the type of this service
	1092	* @param algorithm the algorithm name
	1093	* @param className the name of the class implementing this service
	1094	* @param aliases List of aliases or null if algorithm has no aliases
	1095	* @param attributes Map of attributes or null if this implementation
	1096	* has no attributes
	1097	*
	1098	* @throws NullPointerException if provider, type, algorithm, or
	1099	* className is null
	1100	*/
	1101	public Service(Provider provider, String type, String algorithm,
	1102	String className, List<String> aliases,
	1103	Map<String,String> attributes) {
	1104	if ((provider == null) \|\| (type == null) \|\|
	1105	(algorithm == null) \|\| (className == null)) {
	1106	throw new NullPointerException();
	1107	}
	1108	this.provider = provider;
	1109	this.type = getEngineName(type);
	1110	this.algorithm = algorithm;
	1111	this.className = className;
	1112	if (aliases == null) {
	1113	this.aliases = Collections.<String>emptyList();
	1114	} else {
	1115	this.aliases = new ArrayList<String>(aliases);
	1116	}
	1117	if (attributes == null) {
	1118	this.attributes = Collections.<UString,String>emptyMap();
	1119	} else {
	1120	this.attributes = new HashMap<UString,String>();
	1121	for (Map.Entry<String,String> entry : attributes.entrySet()) {
	1122	this.attributes.put(new UString(entry.getKey()), entry.getValue());
	1123	}
	1124	}
	1125	}
	1126
	1127	/**
	1128	* Get the type of this service. For example, <code>MessageDigest</code>.
	1129	*
	1130	* @return the type of this service
	1131	*/
	1132	public final String getType() {
	1133	return type;
	1134	}
	1135
	1136	/**
	1137	* Return the name of the algorithm of this service. For example,
	1138	* <code>SHA-1</code>.
	1139	*
	1140	* @return the algorithm of this service
	1141	*/
	1142	public final String getAlgorithm() {
	1143	return algorithm;
	1144	}
	1145
	1146	/**
	1147	* Return the Provider of this service.
	1148	*
	1149	* @return the Provider of this service
	1150	*/
	1151	public final Provider getProvider() {
	1152	return provider;
	1153	}
	1154
	1155	/**
	1156	* Return the name of the class implementing this service.
	1157	*
	1158	* @return the name of the class implementing this service
	1159	*/
	1160	public final String getClassName() {
	1161	return className;
	1162	}
	1163
	1164	// internal only
	1165	private final List<String> getAliases() {
	1166	return aliases;
	1167	}
	1168
	1169	/**
	1170	* Return the value of the specified attribute or null if this
	1171	* attribute is not set for this Service.
	1172	*
	1173	* @param name the name of the requested attribute
	1174	*
	1175	* @return the value of the specified attribute or null if the
	1176	* attribute is not present
	1177	*
	1178	* @throws NullPointerException if name is null
	1179	*/
	1180	public final String getAttribute(String name) {
	1181	if (name == null) {
	1182	throw new NullPointerException();
	1183	}
	1184	return attributes.get(new UString(name));
	1185	}
	1186
	1187	/**
	1188	* Return a new instance of the implementation described by this
	1189	* service. The security provider framework uses this method to
	1190	* construct implementations. Applications will typically not need
	1191	* to call it.
	1192	*
	1193	* <p>The default implementation uses reflection to invoke the
	1194	* standard constructor for this type of service.
	1195	* Security providers can override this method to implement
	1196	* instantiation in a different way.
	1197	* For details and the values of constructorParameter that are
	1198	* valid for the various types of services see the
	1199	* <a href="../../../technotes/guides/security/crypto/CryptoSpec.html">
	1200	* Java Cryptography Architecture API Specification &
	1201	* Reference</a>.
	1202	*
	1203	* @param constructorParameter the value to pass to the constructor,
	1204	* or null if this type of service does not use a constructorParameter.
	1205	*
	1206	* @return a new implementation of this service
	1207	*
	1208	* @throws InvalidParameterException if the value of
	1209	* constructorParameter is invalid for this type of service.
	1210	* @throws NoSuchAlgorithmException if instantation failed for
	1211	* any other reason.
	1212	*/
	1213	public Object newInstance(Object constructorParameter)
	1214	throws NoSuchAlgorithmException {
	1215	if (registered == false) {
	1216	if (provider.getService(type, algorithm) != this) {
	1217	throw new NoSuchAlgorithmException
	1218	("Service not registered with Provider "
	1219	+ provider.getName() + ": " + this);
	1220	}
	1221	registered = true;
	1222	}
	1223	try {
	1224	EngineDescription cap = knownEngines.get(type);
	1225	if (cap == null) {
	1226	// unknown engine type, use generic code
	1227	// this is the code path future for non-core
	1228	// optional packages
	1229	return newInstanceGeneric(constructorParameter);
	1230	}
	1231	if (cap.constructorParameterClassName == null) {
	1232	if (constructorParameter != null) {
	1233	throw new InvalidParameterException
	1234	("constructorParameter not used with " + type
	1235	+ " engines");
	1236	}
	1237	Class clazz = getImplClass();
	1238	return clazz.newInstance();
	1239	} else {
	1240	Class paramClass = cap.getConstructorParameterClass();
	1241	if (constructorParameter != null) {
	1242	Class argClass = constructorParameter.getClass();
	1243	if (paramClass.isAssignableFrom(argClass) == false) {
	1244	throw new InvalidParameterException
	1245	("constructorParameter must be instanceof "
	1246	+ cap.constructorParameterClassName.replace('$', '.')
	1247	+ " for engine type " + type);
	1248	}
	1249	}
	1250	Class clazz = getImplClass();
	1251	Constructor cons = clazz.getConstructor(paramClass);
	1252	return cons.newInstance(constructorParameter);
	1253	}
	1254	} catch (NoSuchAlgorithmException e) {
	1255	throw e;
	1256	} catch (InvocationTargetException e) {
	1257	throw new NoSuchAlgorithmException
	1258	("Error constructing implementation (algorithm: "
	1259	+ algorithm + ", provider: " + provider.getName()
	1260	+ ", class: " + className + ")", e.getCause());
	1261	} catch (Exception e) {
	1262	throw new NoSuchAlgorithmException
	1263	("Error constructing implementation (algorithm: "
	1264	+ algorithm + ", provider: " + provider.getName()
	1265	+ ", class: " + className + ")", e);
	1266	}
	1267	}
	1268
	1269	// return the implementation Class object for this service
	1270	private Class getImplClass() throws NoSuchAlgorithmException {
	1271	try {
	1272	Reference<Class> ref = classRef;
	1273	Class clazz = (ref == null) ? null : ref.get();
	1274	if (clazz == null) {
	1275	ClassLoader cl = provider.getClass().getClassLoader();
	1276	if (cl == null) {
	1277	clazz = Class.forName(className);
	1278	} else {
	1279	clazz = cl.loadClass(className);
	1280	}
	1281	classRef = new WeakReference<Class>(clazz);
	1282	}
	1283	return clazz;
	1284	} catch (ClassNotFoundException e) {
	1285	throw new NoSuchAlgorithmException
	1286	("class configured for " + type + "(provider: " +
	1287	provider.getName() + ")" + "cannot be found.", e);
	1288	}
	1289	}
	1290
	1291	/**
	1292	* Generic code path for unknown engine types. Call the
	1293	* no-args constructor if constructorParameter is null, otherwise
	1294	* use the first matching constructor.
	1295	*/
	1296	private Object newInstanceGeneric(Object constructorParameter)
	1297	throws Exception {
	1298	Class clazz = getImplClass();
	1299	if (constructorParameter == null) {
	1300	Object o = clazz.newInstance();
	1301	return o;
	1302	}
	1303	Class argClass = constructorParameter.getClass();
	1304	Constructor[] cons = clazz.getConstructors();
	1305	// find first public constructor that can take the
	1306	// argument as parameter
	1307	for (int i = 0; i < cons.length; i++) {
	1308	Constructor con = cons[i];
	1309	Class[] paramTypes = con.getParameterTypes();
	1310	if (paramTypes.length != 1) {
	1311	continue;
	1312	}
	1313	if (paramTypes[0].isAssignableFrom(argClass) == false) {
	1314	continue;
	1315	}
	1316	Object o = con.newInstance(new Object[] {constructorParameter});
	1317	return o;
	1318	}
	1319	throw new NoSuchAlgorithmException("No constructor matching "
	1320	+ argClass.getName() + " found in class " + className);
	1321	}
	1322
	1323	/**
	1324	* Test whether this Service can use the specified parameter.
	1325	* Returns false if this service cannot use the parameter. Returns
	1326	* true if this service can use the parameter, if a fast test is
	1327	* infeasible, or if the status is unknown.
	1328	*
	1329	* <p>The security provider framework uses this method with
	1330	* some types of services to quickly exclude non-matching
	1331	* implementations for consideration.
	1332	* Applications will typically not need to call it.
	1333	*
	1334	* <p>For details and the values of parameter that are valid for the
	1335	* various types of services see the top of this class and the
	1336	* <a href="../../../technotes/guides/security/crypto/CryptoSpec.html">
	1337	* Java Cryptography Architecture API Specification &
	1338	* Reference</a>.
	1339	* Security providers can override it to implement their own test.
	1340	*
	1341	* @param parameter the parameter to test
	1342	*
	1343	* @return false if this this service cannot use the specified
	1344	* parameter; true if it can possibly use the parameter
	1345	*
	1346	* @throws InvalidParameterException if the value of parameter is
	1347	* invalid for this type of service or if this method cannot be
	1348	* used with this type of service
	1349	*/
	1350	public boolean supportsParameter(Object parameter) {
	1351	EngineDescription cap = knownEngines.get(type);
	1352	if (cap == null) {
	1353	// unknown engine type, return true by default
	1354	return true;
	1355	}
	1356	if (cap.supportsParameter == false) {
	1357	throw new InvalidParameterException("supportsParameter() not "
	1358	+ "used with " + type + " engines");
	1359	}
	1360	// allow null for keys without attributes for compatibility
	1361	if ((parameter != null) && (parameter instanceof Key == false)) {
	1362	throw new InvalidParameterException
	1363	("Parameter must be instanceof Key for engine " + type);
	1364	}
	1365	if (hasKeyAttributes() == false) {
	1366	return true;
	1367	}
	1368	if (parameter == null) {
	1369	return false;
	1370	}
	1371	Key key = (Key)parameter;
	1372	if (supportsKeyFormat(key)) {
	1373	return true;
	1374	}
	1375	if (supportsKeyClass(key)) {
	1376	return true;
	1377	}
	1378	return false;
	1379	}
	1380
	1381	/**
	1382	* Return whether this service has its Supported* properties for
	1383	* keys defined. Parses the attributes if not yet initialized.
	1384	*/
	1385	private boolean hasKeyAttributes() {
	1386	Boolean b = hasKeyAttributes;
	1387	if (b == null) {
	1388	synchronized (this) {
	1389	String s;
	1390	s = getAttribute("SupportedKeyFormats");
	1391	if (s != null) {
	1392	supportedFormats = s.split("\\\|");
	1393	}
	1394	s = getAttribute("SupportedKeyClasses");
	1395	if (s != null) {
	1396	String[] classNames = s.split("\\\|");
	1397	List<Class> classList =
	1398	new ArrayList<>(classNames.length);
	1399	for (String className : classNames) {
	1400	Class clazz = getKeyClass(className);
	1401	if (clazz != null) {
	1402	classList.add(clazz);
	1403	}
	1404	}
	1405	supportedClasses = classList.toArray(CLASS0);
	1406	}
	1407	boolean bool = (supportedFormats != null)
	1408	\|\| (supportedClasses != null);
	1409	b = Boolean.valueOf(bool);
	1410	hasKeyAttributes = b;
	1411	}
	1412	}
	1413	return b.booleanValue();
	1414	}
	1415
	1416	// get the key class object of the specified name
	1417	private Class getKeyClass(String name) {
	1418	try {
	1419	return Class.forName(name);
	1420	} catch (ClassNotFoundException e) {
	1421	// ignore
	1422	}
	1423	try {
	1424	ClassLoader cl = provider.getClass().getClassLoader();
	1425	if (cl != null) {
	1426	return cl.loadClass(name);
	1427	}
	1428	} catch (ClassNotFoundException e) {
	1429	// ignore
	1430	}
	1431	return null;
	1432	}
	1433
	1434	private boolean supportsKeyFormat(Key key) {
	1435	if (supportedFormats == null) {
	1436	return false;
	1437	}
	1438	String format = key.getFormat();
	1439	if (format == null) {
	1440	return false;
	1441	}
	1442	for (String supportedFormat : supportedFormats) {
	1443	if (supportedFormat.equals(format)) {
	1444	return true;
	1445	}
	1446	}
	1447	return false;
	1448	}
	1449
	1450	private boolean supportsKeyClass(Key key) {
	1451	if (supportedClasses == null) {
	1452	return false;
	1453	}
	1454	Class keyClass = key.getClass();
	1455	for (Class clazz : supportedClasses) {
	1456	if (clazz.isAssignableFrom(keyClass)) {
	1457	return true;
	1458	}
	1459	}
	1460	return false;
	1461	}
	1462
	1463	/**
	1464	* Return a String representation of this service.
	1465	*
	1466	* @return a String representation of this service.
	1467	*/
	1468	public String toString() {
	1469	String aString = aliases.isEmpty()
	1470	? "" : "\r\n aliases: " + aliases.toString();
	1471	String attrs = attributes.isEmpty()
	1472	? "" : "\r\n attributes: " + attributes.toString();
	1473	return provider.getName() + ": " + type + "." + algorithm
	1474	+ " -> " + className + aString + attrs + "\r\n";
	1475	}
	1476
	1477	}
	1478
	1479	}

java/pkg/java/security/ProviderException.class+0−0

Binary file not shown.

java/pkg/java/security/ProviderException.java+89−0

@@ -0,0 +1,89 @@
	1	/*
	2	* Copyright (c) 1996, 2003, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	/**
	29	* A runtime exception for Provider exceptions (such as
	30	* misconfiguration errors or unrecoverable internal errors),
	31	* which may be subclassed by Providers to
	32	* throw specialized, provider-specific runtime errors.
	33	*
	34	* @author Benjamin Renaud
	35	*/
	36	public class ProviderException extends RuntimeException {
	37
	38	private static final long serialVersionUID = 5256023526693665674L;
	39
	40	/**
	41	* Constructs a ProviderException with no detail message. A
	42	* detail message is a String that describes this particular
	43	* exception.
	44	*/
	45	public ProviderException() {
	46	super();
	47	}
	48
	49	/**
	50	* Constructs a ProviderException with the specified detail
	51	* message. A detail message is a String that describes this
	52	* particular exception.
	53	*
	54	* @param s the detail message.
	55	*/
	56	public ProviderException(String s) {
	57	super(s);
	58	}
	59
	60	/**
	61	* Creates a <code>ProviderException</code> with the specified
	62	* detail message and cause.
	63	*
	64	* @param message the detail message (which is saved for later retrieval
	65	* by the {@link #getMessage()} method).
	66	* @param cause the cause (which is saved for later retrieval by the
	67	* {@link #getCause()} method). (A <tt>null</tt> value is permitted,
	68	* and indicates that the cause is nonexistent or unknown.)
	69	* @since 1.5
	70	*/
	71	public ProviderException(String message, Throwable cause) {
	72	super(message, cause);
	73	}
	74
	75	/**
	76	* Creates a <code>ProviderException</code> with the specified cause
	77	* and a detail message of <tt>(cause==null ? null : cause.toString())</tt>
	78	* (which typically contains the class and detail message of
	79	* <tt>cause</tt>).
	80	*
	81	* @param cause the cause (which is saved for later retrieval by the
	82	* {@link #getCause()} method). (A <tt>null</tt> value is permitted,
	83	* and indicates that the cause is nonexistent or unknown.)
	84	* @since 1.5
	85	*/
	86	public ProviderException(Throwable cause) {
	87	super(cause);
	88	}
	89	}

java/pkg/java/security/PublicKey.class+0−0

Binary file not shown.

java/pkg/java/security/PublicKey.java+53−0

@@ -0,0 +1,53 @@
	1	/*
	2	* Copyright (c) 1996, 2001, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	/**
	29	* <p>A public key. This interface contains no methods or constants.
	30	* It merely serves to group (and provide type safety for) all public key
	31	* interfaces.
	32	*
	33	* Note: The specialized public key interfaces extend this interface.
	34	* See, for example, the DSAPublicKey interface in
	35	* <code>java.security.interfaces</code>.
	36	*
	37	* @see Key
	38	* @see PrivateKey
	39	* @see Certificate
	40	* @see Signature#initVerify
	41	* @see java.security.interfaces.DSAPublicKey
	42	* @see java.security.interfaces.RSAPublicKey
	43	*
	44	*/
	45
	46	public interface PublicKey extends Key {
	47	// Declare serialVersionUID to be compatible with JDK1.1
	48	/**
	49	* The class fingerprint that is set to indicate serialization
	50	* compatibility with a previous version of the class.
	51	*/
	52	static final long serialVersionUID = 7187392471159151072L;
	53	}

java/pkg/java/security/SecureClassLoader.class+0−0

Binary file not shown.

java/pkg/java/security/SecureClassLoader.java+227−0

@@ -0,0 +1,227 @@
	1	/*
	2	* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.util.HashMap;
	29	import java.util.ArrayList;
	30	import java.net.URL;
	31
	32	import sun.security.util.Debug;
	33
	34	/**
	35	* This class extends ClassLoader with additional support for defining
	36	* classes with an associated code source and permissions which are
	37	* retrieved by the system policy by default.
	38	*
	39	* @author Li Gong
	40	* @author Roland Schemers
	41	*/
	42	public class SecureClassLoader extends ClassLoader {
	43	/*
	44	* If initialization succeed this is set to true and security checks will
	45	* succeed. Otherwise the object is not initialized and the object is
	46	* useless.
	47	*/
	48	private final boolean initialized;
	49
	50	// HashMap that maps CodeSource to ProtectionDomain
	51	// @GuardedBy("pdcache")
	52	private final HashMap<CodeSource, ProtectionDomain> pdcache =
	53	new HashMap<>(11);
	54
	55	private static final Debug debug = Debug.getInstance("scl");
	56
	57	static {
	58	ClassLoader.registerAsParallelCapable();
	59	}
	60
	61	/**
	62	* Creates a new SecureClassLoader using the specified parent
	63	* class loader for delegation.
	64	*
	65	* <p>If there is a security manager, this method first
	66	* calls the security manager's <code>checkCreateClassLoader</code>
	67	* method to ensure creation of a class loader is allowed.
	68	* <p>
	69	* @param parent the parent ClassLoader
	70	* @exception SecurityException if a security manager exists and its
	71	* <code>checkCreateClassLoader</code> method doesn't allow
	72	* creation of a class loader.
	73	* @see SecurityManager#checkCreateClassLoader
	74	*/
	75	protected SecureClassLoader(ClassLoader parent) {
	76	super(parent);
	77	// this is to make the stack depth consistent with 1.1
	78	SecurityManager security = System.getSecurityManager();
	79	if (security != null) {
	80	security.checkCreateClassLoader();
	81	}
	82	initialized = true;
	83	}
	84
	85	/**
	86	* Creates a new SecureClassLoader using the default parent class
	87	* loader for delegation.
	88	*
	89	* <p>If there is a security manager, this method first
	90	* calls the security manager's <code>checkCreateClassLoader</code>
	91	* method to ensure creation of a class loader is allowed.
	92	*
	93	* @exception SecurityException if a security manager exists and its
	94	* <code>checkCreateClassLoader</code> method doesn't allow
	95	* creation of a class loader.
	96	* @see SecurityManager#checkCreateClassLoader
	97	*/
	98	protected SecureClassLoader() {
	99	super();
	100	// this is to make the stack depth consistent with 1.1
	101	SecurityManager security = System.getSecurityManager();
	102	if (security != null) {
	103	security.checkCreateClassLoader();
	104	}
	105	initialized = true;
	106	}
	107
	108	/**
	109	* Converts an array of bytes into an instance of class Class,
	110	* with an optional CodeSource. Before the
	111	* class can be used it must be resolved.
	112	* <p>
	113	* If a non-null CodeSource is supplied a ProtectionDomain is
	114	* constructed and associated with the class being defined.
	115	* <p>
	116	* @param name the expected name of the class, or <code>null</code>
	117	* if not known, using '.' and not '/' as the separator
	118	* and without a trailing ".class" suffix.
	119	* @param b the bytes that make up the class data. The bytes in
	120	* positions <code>off</code> through <code>off+len-1</code>
	121	* should have the format of a valid class file as defined by
	122	* <cite>The Java™ Virtual Machine Specification</cite>.
	123	* @param off the start offset in <code>b</code> of the class data
	124	* @param len the length of the class data
	125	* @param cs the associated CodeSource, or <code>null</code> if none
	126	* @return the <code>Class</code> object created from the data,
	127	* and optional CodeSource.
	128	* @exception ClassFormatError if the data did not contain a valid class
	129	* @exception IndexOutOfBoundsException if either <code>off</code> or
	130	* <code>len</code> is negative, or if
	131	* <code>off+len</code> is greater than <code>b.length</code>.
	132	*
	133	* @exception SecurityException if an attempt is made to add this class
	134	* to a package that contains classes that were signed by
	135	* a different set of certificates than this class, or if
	136	* the class name begins with "java.".
	137	*/
	138	protected final Class<?> defineClass(String name,
	139	byte[] b, int off, int len,
	140	CodeSource cs)
	141	{
	142	return defineClass(name, b, off, len, getProtectionDomain(cs));
	143	}
	144
	145	/**
	146	* Converts a {@link java.nio.ByteBuffer <tt>ByteBuffer</tt>}
	147	* into an instance of class <tt>Class</tt>, with an optional CodeSource.
	148	* Before the class can be used it must be resolved.
	149	* <p>
	150	* If a non-null CodeSource is supplied a ProtectionDomain is
	151	* constructed and associated with the class being defined.
	152	* <p>
	153	* @param name the expected name of the class, or <code>null</code>
	154	* if not known, using '.' and not '/' as the separator
	155	* and without a trailing ".class" suffix.
	156	* @param b the bytes that make up the class data. The bytes from positions
	157	* <tt>b.position()</tt> through <tt>b.position() + b.limit() -1</tt>
	158	* should have the format of a valid class file as defined by
	159	* <cite>The Java™ Virtual Machine Specification</cite>.
	160	* @param cs the associated CodeSource, or <code>null</code> if none
	161	* @return the <code>Class</code> object created from the data,
	162	* and optional CodeSource.
	163	* @exception ClassFormatError if the data did not contain a valid class
	164	* @exception SecurityException if an attempt is made to add this class
	165	* to a package that contains classes that were signed by
	166	* a different set of certificates than this class, or if
	167	* the class name begins with "java.".
	168	*
	169	* @since 1.5
	170	*/
	171	protected final Class<?> defineClass(String name, java.nio.ByteBuffer b,
	172	CodeSource cs)
	173	{
	174	return defineClass(name, b, getProtectionDomain(cs));
	175	}
	176
	177	/**
	178	* Returns the permissions for the given CodeSource object.
	179	* <p>
	180	* This method is invoked by the defineClass method which takes
	181	* a CodeSource as an argument when it is constructing the
	182	* ProtectionDomain for the class being defined.
	183	* <p>
	184	* @param codesource the codesource.
	185	*
	186	* @return the permissions granted to the codesource.
	187	*
	188	*/
	189	protected PermissionCollection getPermissions(CodeSource codesource)
	190	{
	191	check();
	192	return new Permissions(); // ProtectionDomain defers the binding
	193	}
	194
	195	/*
	196	* Returned cached ProtectionDomain for the specified CodeSource.
	197	*/
	198	private ProtectionDomain getProtectionDomain(CodeSource cs) {
	199	if (cs == null)
	200	return null;
	201
	202	ProtectionDomain pd = null;
	203	synchronized (pdcache) {
	204	pd = pdcache.get(cs);
	205	if (pd == null) {
	206	PermissionCollection perms = getPermissions(cs);
	207	pd = new ProtectionDomain(cs, perms, this, null);
	208	pdcache.put(cs, pd);
	209	if (debug != null) {
	210	debug.println(" getPermissions "+ pd);
	211	debug.println("");
	212	}
	213	}
	214	}
	215	return pd;
	216	}
	217
	218	/*
	219	* Check to make sure the class loader has been initialized.
	220	*/
	221	private void check() {
	222	if (!initialized) {
	223	throw new SecurityException("ClassLoader object not initialized");
	224	}
	225	}
	226
	227	}

java/pkg/java/security/SecureRandom.class+0−0

Binary file not shown.

java/pkg/java/security/SecureRandom.java+581−0

@@ -0,0 +1,581 @@
	1	/*
	2	* Copyright (c) 1996, 2011, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.util.*;
	29
	30	import java.security.Provider.Service;
	31
	32	import sun.security.jca.*;
	33	import sun.security.jca.GetInstance.Instance;
	34
	35	/**
	36	* This class provides a cryptographically strong random number
	37	* generator (RNG).
	38	*
	39	* <p>A cryptographically strong random number
	40	* minimally complies with the statistical random number generator tests
	41	* specified in <a href="http://csrc.nist.gov/cryptval/140-2.htm">
	42	* <i>FIPS 140-2, Security Requirements for Cryptographic Modules</i></a>,
	43	* section 4.9.1.
	44	* Additionally, SecureRandom must produce non-deterministic output.
	45	* Therefore any seed material passed to a SecureRandom object must be
	46	* unpredictable, and all SecureRandom output sequences must be
	47	* cryptographically strong, as described in
	48	* <a href="http://www.ietf.org/rfc/rfc1750.txt">
	49	* <i>RFC 1750: Randomness Recommendations for Security</i></a>.
	50	*
	51	* <p>A caller obtains a SecureRandom instance via the
	52	* no-argument constructor or one of the <code>getInstance</code> methods:
	53	*
	54	* <pre>
	55	* SecureRandom random = new SecureRandom();
	56	* </pre>
	57	*
	58	* <p> Many SecureRandom implementations are in the form of a pseudo-random
	59	* number generator (PRNG), which means they use a deterministic algorithm
	60	* to produce a pseudo-random sequence from a true random seed.
	61	* Other implementations may produce true random numbers,
	62	* and yet others may use a combination of both techniques.
	63	*
	64	* <p> Typical callers of SecureRandom invoke the following methods
	65	* to retrieve random bytes:
	66	*
	67	* <pre>
	68	* SecureRandom random = new SecureRandom();
	69	* byte bytes[] = new byte[20];
	70	* random.nextBytes(bytes);
	71	* </pre>
	72	*
	73	* <p> Callers may also invoke the <code>generateSeed</code> method
	74	* to generate a given number of seed bytes (to seed other random number
	75	* generators, for example):
	76	* <pre>
	77	* byte seed[] = random.generateSeed(20);
	78	* </pre>
	79	*
	80	* Note: Depending on the implementation, the <code>generateSeed</code> and
	81	* <code>nextBytes</code> methods may block as entropy is being gathered,
	82	* for example, if they need to read from /dev/random on various unix-like
	83	* operating systems.
	84	*
	85	* @see java.security.SecureRandomSpi
	86	* @see java.util.Random
	87	*
	88	* @author Benjamin Renaud
	89	* @author Josh Bloch
	90	*/
	91
	92	public class SecureRandom extends java.util.Random {
	93
	94	/**
	95	* The provider.
	96	*
	97	* @serial
	98	* @since 1.2
	99	*/
	100	private Provider provider = null;
	101
	102	/**
	103	* The provider implementation.
	104	*
	105	* @serial
	106	* @since 1.2
	107	*/
	108	private SecureRandomSpi secureRandomSpi = null;
	109
	110	/*
	111	* The algorithm name of null if unknown.
	112	*
	113	* @serial
	114	* @since 1.5
	115	*/
	116	private String algorithm;
	117
	118	// Seed Generator
	119	private static volatile SecureRandom seedGenerator = null;
	120
	121	/**
	122	* Constructs a secure random number generator (RNG) implementing the
	123	* default random number algorithm.
	124	*
	125	* <p> This constructor traverses the list of registered security Providers,
	126	* starting with the most preferred Provider.
	127	* A new SecureRandom object encapsulating the
	128	* SecureRandomSpi implementation from the first
	129	* Provider that supports a SecureRandom (RNG) algorithm is returned.
	130	* If none of the Providers support a RNG algorithm,
	131	* then an implementation-specific default is returned.
	132	*
	133	* <p> Note that the list of registered providers may be retrieved via
	134	* the {@link Security#getProviders() Security.getProviders()} method.
	135	*
	136	* <p> See the SecureRandom section in the <a href=
	137	* "{@docRoot}/../technotes/guides/security/StandardNames.html#SecureRandom">
	138	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	139	* for information about standard RNG algorithm names.
	140	*
	141	* <p> The returned SecureRandom object has not been seeded. To seed the
	142	* returned object, call the <code>setSeed</code> method.
	143	* If <code>setSeed</code> is not called, the first call to
	144	* <code>nextBytes</code> will force the SecureRandom object to seed itself.
	145	* This self-seeding will not occur if <code>setSeed</code> was
	146	* previously called.
	147	*/
	148	public SecureRandom() {
	149	/*
	150	* This call to our superclass constructor will result in a call
	151	* to our own <code>setSeed</code> method, which will return
	152	* immediately when it is passed zero.
	153	*/
	154	super(0);
	155	getDefaultPRNG(false, null);
	156	}
	157
	158	/**
	159	* Constructs a secure random number generator (RNG) implementing the
	160	* default random number algorithm.
	161	* The SecureRandom instance is seeded with the specified seed bytes.
	162	*
	163	* <p> This constructor traverses the list of registered security Providers,
	164	* starting with the most preferred Provider.
	165	* A new SecureRandom object encapsulating the
	166	* SecureRandomSpi implementation from the first
	167	* Provider that supports a SecureRandom (RNG) algorithm is returned.
	168	* If none of the Providers support a RNG algorithm,
	169	* then an implementation-specific default is returned.
	170	*
	171	* <p> Note that the list of registered providers may be retrieved via
	172	* the {@link Security#getProviders() Security.getProviders()} method.
	173	*
	174	* <p> See the SecureRandom section in the <a href=
	175	* "{@docRoot}/../technotes/guides/security/StandardNames.html#SecureRandom">
	176	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	177	* for information about standard RNG algorithm names.
	178	*
	179	* @param seed the seed.
	180	*/
	181	public SecureRandom(byte seed[]) {
	182	super(0);
	183	getDefaultPRNG(true, seed);
	184	}
	185
	186	private void getDefaultPRNG(boolean setSeed, byte[] seed) {
	187	String prng = getPrngAlgorithm();
	188	if (prng == null) {
	189	// bummer, get the SUN implementation
	190	prng = "SHA1PRNG";
	191	this.secureRandomSpi = new sun.security.provider.SecureRandom();
	192	this.provider = Providers.getSunProvider();
	193	if (setSeed) {
	194	this.secureRandomSpi.engineSetSeed(seed);
	195	}
	196	} else {
	197	try {
	198	SecureRandom random = SecureRandom.getInstance(prng);
	199	this.secureRandomSpi = random.getSecureRandomSpi();
	200	this.provider = random.getProvider();
	201	if (setSeed) {
	202	this.secureRandomSpi.engineSetSeed(seed);
	203	}
	204	} catch (NoSuchAlgorithmException nsae) {
	205	// never happens, because we made sure the algorithm exists
	206	throw new RuntimeException(nsae);
	207	}
	208	}
	209	// JDK 1.1 based implementations subclass SecureRandom instead of
	210	// SecureRandomSpi. They will also go through this code path because
	211	// they must call a SecureRandom constructor as it is their superclass.
	212	// If we are dealing with such an implementation, do not set the
	213	// algorithm value as it would be inaccurate.
	214	if (getClass() == SecureRandom.class) {
	215	this.algorithm = prng;
	216	}
	217	}
	218
	219	/**
	220	* Creates a SecureRandom object.
	221	*
	222	* @param secureRandomSpi the SecureRandom implementation.
	223	* @param provider the provider.
	224	*/
	225	protected SecureRandom(SecureRandomSpi secureRandomSpi,
	226	Provider provider) {
	227	this(secureRandomSpi, provider, null);
	228	}
	229
	230	private SecureRandom(SecureRandomSpi secureRandomSpi, Provider provider,
	231	String algorithm) {
	232	super(0);
	233	this.secureRandomSpi = secureRandomSpi;
	234	this.provider = provider;
	235	this.algorithm = algorithm;
	236	}
	237
	238	/**
	239	* Returns a SecureRandom object that implements the specified
	240	* Random Number Generator (RNG) algorithm.
	241	*
	242	* <p> This method traverses the list of registered security Providers,
	243	* starting with the most preferred Provider.
	244	* A new SecureRandom object encapsulating the
	245	* SecureRandomSpi implementation from the first
	246	* Provider that supports the specified algorithm is returned.
	247	*
	248	* <p> Note that the list of registered providers may be retrieved via
	249	* the {@link Security#getProviders() Security.getProviders()} method.
	250	*
	251	* <p> The returned SecureRandom object has not been seeded. To seed the
	252	* returned object, call the <code>setSeed</code> method.
	253	* If <code>setSeed</code> is not called, the first call to
	254	* <code>nextBytes</code> will force the SecureRandom object to seed itself.
	255	* This self-seeding will not occur if <code>setSeed</code> was
	256	* previously called.
	257	*
	258	* @param algorithm the name of the RNG algorithm.
	259	* See the SecureRandom section in the <a href=
	260	* "{@docRoot}/../technotes/guides/security/StandardNames.html#SecureRandom">
	261	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	262	* for information about standard RNG algorithm names.
	263	*
	264	* @return the new SecureRandom object.
	265	*
	266	* @exception NoSuchAlgorithmException if no Provider supports a
	267	* SecureRandomSpi implementation for the
	268	* specified algorithm.
	269	*
	270	* @see Provider
	271	*
	272	* @since 1.2
	273	*/
	274	public static SecureRandom getInstance(String algorithm)
	275	throws NoSuchAlgorithmException {
	276	Instance instance = GetInstance.getInstance("SecureRandom",
	277	SecureRandomSpi.class, algorithm);
	278	return new SecureRandom((SecureRandomSpi)instance.impl,
	279	instance.provider, algorithm);
	280	}
	281
	282	/**
	283	* Returns a SecureRandom object that implements the specified
	284	* Random Number Generator (RNG) algorithm.
	285	*
	286	* <p> A new SecureRandom object encapsulating the
	287	* SecureRandomSpi implementation from the specified provider
	288	* is returned. The specified provider must be registered
	289	* in the security provider list.
	290	*
	291	* <p> Note that the list of registered providers may be retrieved via
	292	* the {@link Security#getProviders() Security.getProviders()} method.
	293	*
	294	* <p> The returned SecureRandom object has not been seeded. To seed the
	295	* returned object, call the <code>setSeed</code> method.
	296	* If <code>setSeed</code> is not called, the first call to
	297	* <code>nextBytes</code> will force the SecureRandom object to seed itself.
	298	* This self-seeding will not occur if <code>setSeed</code> was
	299	* previously called.
	300	*
	301	* @param algorithm the name of the RNG algorithm.
	302	* See the SecureRandom section in the <a href=
	303	* "{@docRoot}/../technotes/guides/security/StandardNames.html#SecureRandom">
	304	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	305	* for information about standard RNG algorithm names.
	306	*
	307	* @param provider the name of the provider.
	308	*
	309	* @return the new SecureRandom object.
	310	*
	311	* @exception NoSuchAlgorithmException if a SecureRandomSpi
	312	* implementation for the specified algorithm is not
	313	* available from the specified provider.
	314	*
	315	* @exception NoSuchProviderException if the specified provider is not
	316	* registered in the security provider list.
	317	*
	318	* @exception IllegalArgumentException if the provider name is null
	319	* or empty.
	320	*
	321	* @see Provider
	322	*
	323	* @since 1.2
	324	*/
	325	public static SecureRandom getInstance(String algorithm, String provider)
	326	throws NoSuchAlgorithmException, NoSuchProviderException {
	327	Instance instance = GetInstance.getInstance("SecureRandom",
	328	SecureRandomSpi.class, algorithm, provider);
	329	return new SecureRandom((SecureRandomSpi)instance.impl,
	330	instance.provider, algorithm);
	331	}
	332
	333	/**
	334	* Returns a SecureRandom object that implements the specified
	335	* Random Number Generator (RNG) algorithm.
	336	*
	337	* <p> A new SecureRandom object encapsulating the
	338	* SecureRandomSpi implementation from the specified Provider
	339	* object is returned. Note that the specified Provider object
	340	* does not have to be registered in the provider list.
	341	*
	342	* <p> The returned SecureRandom object has not been seeded. To seed the
	343	* returned object, call the <code>setSeed</code> method.
	344	* If <code>setSeed</code> is not called, the first call to
	345	* <code>nextBytes</code> will force the SecureRandom object to seed itself.
	346	* This self-seeding will not occur if <code>setSeed</code> was
	347	* previously called.
	348	*
	349	* @param algorithm the name of the RNG algorithm.
	350	* See the SecureRandom section in the <a href=
	351	* "{@docRoot}/../technotes/guides/security/StandardNames.html#SecureRandom">
	352	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	353	* for information about standard RNG algorithm names.
	354	*
	355	* @param provider the provider.
	356	*
	357	* @return the new SecureRandom object.
	358	*
	359	* @exception NoSuchAlgorithmException if a SecureRandomSpi
	360	* implementation for the specified algorithm is not available
	361	* from the specified Provider object.
	362	*
	363	* @exception IllegalArgumentException if the specified provider is null.
	364	*
	365	* @see Provider
	366	*
	367	* @since 1.4
	368	*/
	369	public static SecureRandom getInstance(String algorithm,
	370	Provider provider) throws NoSuchAlgorithmException {
	371	Instance instance = GetInstance.getInstance("SecureRandom",
	372	SecureRandomSpi.class, algorithm, provider);
	373	return new SecureRandom((SecureRandomSpi)instance.impl,
	374	instance.provider, algorithm);
	375	}
	376
	377	/**
	378	* Returns the SecureRandomSpi of this SecureRandom object.
	379	*/
	380	SecureRandomSpi getSecureRandomSpi() {
	381	return secureRandomSpi;
	382	}
	383
	384	/**
	385	* Returns the provider of this SecureRandom object.
	386	*
	387	* @return the provider of this SecureRandom object.
	388	*/
	389	public final Provider getProvider() {
	390	return provider;
	391	}
	392
	393	/**
	394	* Returns the name of the algorithm implemented by this SecureRandom
	395	* object.
	396	*
	397	* @return the name of the algorithm or <code>unknown</code>
	398	* if the algorithm name cannot be determined.
	399	* @since 1.5
	400	*/
	401	public String getAlgorithm() {
	402	return (algorithm != null) ? algorithm : "unknown";
	403	}
	404
	405	/**
	406	* Reseeds this random object. The given seed supplements, rather than
	407	* replaces, the existing seed. Thus, repeated calls are guaranteed
	408	* never to reduce randomness.
	409	*
	410	* @param seed the seed.
	411	*
	412	* @see #getSeed
	413	*/
	414	synchronized public void setSeed(byte[] seed) {
	415	secureRandomSpi.engineSetSeed(seed);
	416	}
	417
	418	/**
	419	* Reseeds this random object, using the eight bytes contained
	420	* in the given <code>long seed</code>. The given seed supplements,
	421	* rather than replaces, the existing seed. Thus, repeated calls
	422	* are guaranteed never to reduce randomness.
	423	*
	424	* <p>This method is defined for compatibility with
	425	* <code>java.util.Random</code>.
	426	*
	427	* @param seed the seed.
	428	*
	429	* @see #getSeed
	430	*/
	431	public void setSeed(long seed) {
	432	/*
	433	* Ignore call from super constructor (as well as any other calls
	434	* unfortunate enough to be passing 0). It's critical that we
	435	* ignore call from superclass constructor, as digest has not
	436	* yet been initialized at that point.
	437	*/
	438	if (seed != 0) {
	439	secureRandomSpi.engineSetSeed(longToByteArray(seed));
	440	}
	441	}
	442
	443	/**
	444	* Generates a user-specified number of random bytes.
	445	*
	446	* <p> If a call to <code>setSeed</code> had not occurred previously,
	447	* the first call to this method forces this SecureRandom object
	448	* to seed itself. This self-seeding will not occur if
	449	* <code>setSeed</code> was previously called.
	450	*
	451	* @param bytes the array to be filled in with random bytes.
	452	*/
	453
	454	synchronized public void nextBytes(byte[] bytes) {
	455	secureRandomSpi.engineNextBytes(bytes);
	456	}
	457
	458	/**
	459	* Generates an integer containing the user-specified number of
	460	* pseudo-random bits (right justified, with leading zeros). This
	461	* method overrides a <code>java.util.Random</code> method, and serves
	462	* to provide a source of random bits to all of the methods inherited
	463	* from that class (for example, <code>nextInt</code>,
	464	* <code>nextLong</code>, and <code>nextFloat</code>).
	465	*
	466	* @param numBits number of pseudo-random bits to be generated, where
	467	* 0 <= <code>numBits</code> <= 32.
	468	*
	469	* @return an <code>int</code> containing the user-specified number
	470	* of pseudo-random bits (right justified, with leading zeros).
	471	*/
	472	final protected int next(int numBits) {
	473	int numBytes = (numBits+7)/8;
	474	byte b[] = new byte[numBytes];
	475	int next = 0;
	476
	477	nextBytes(b);
	478	for (int i = 0; i < numBytes; i++)
	479	next = (next << 8) + (b[i] & 0xFF);
	480
	481	return next >>> (numBytes*8 - numBits);
	482	}
	483
	484	/**
	485	* Returns the given number of seed bytes, computed using the seed
	486	* generation algorithm that this class uses to seed itself. This
	487	* call may be used to seed other random number generators.
	488	*
	489	* <p>This method is only included for backwards compatibility.
	490	* The caller is encouraged to use one of the alternative
	491	* <code>getInstance</code> methods to obtain a SecureRandom object, and
	492	* then call the <code>generateSeed</code> method to obtain seed bytes
	493	* from that object.
	494	*
	495	* @param numBytes the number of seed bytes to generate.
	496	*
	497	* @return the seed bytes.
	498	*
	499	* @see #setSeed
	500	*/
	501	public static byte[] getSeed(int numBytes) {
	502	if (seedGenerator == null)
	503	seedGenerator = new SecureRandom();
	504	return seedGenerator.generateSeed(numBytes);
	505	}
	506
	507	/**
	508	* Returns the given number of seed bytes, computed using the seed
	509	* generation algorithm that this class uses to seed itself. This
	510	* call may be used to seed other random number generators.
	511	*
	512	* @param numBytes the number of seed bytes to generate.
	513	*
	514	* @return the seed bytes.
	515	*/
	516	public byte[] generateSeed(int numBytes) {
	517	return secureRandomSpi.engineGenerateSeed(numBytes);
	518	}
	519
	520	/**
	521	* Helper function to convert a long into a byte array (least significant
	522	* byte first).
	523	*/
	524	private static byte[] longToByteArray(long l) {
	525	byte[] retVal = new byte[8];
	526
	527	for (int i = 0; i < 8; i++) {
	528	retVal[i] = (byte) l;
	529	l >>= 8;
	530	}
	531
	532	return retVal;
	533	}
	534
	535	/**
	536	* Gets a default PRNG algorithm by looking through all registered
	537	* providers. Returns the first PRNG algorithm of the first provider that
	538	* has registered a SecureRandom implementation, or null if none of the
	539	* registered providers supplies a SecureRandom implementation.
	540	*/
	541	private static String getPrngAlgorithm() {
	542	for (Provider p : Providers.getProviderList().providers()) {
	543	for (Service s : p.getServices()) {
	544	if (s.getType().equals("SecureRandom")) {
	545	return s.getAlgorithm();
	546	}
	547	}
	548	}
	549	return null;
	550	}
	551
	552	// Declare serialVersionUID to be compatible with JDK1.1
	553	static final long serialVersionUID = 4940670005562187L;
	554
	555	// Retain unused values serialized from JDK1.1
	556	/**
	557	* @serial
	558	*/
	559	private byte[] state;
	560	/**
	561	* @serial
	562	*/
	563	private MessageDigest digest = null;
	564	/**
	565	* @serial
	566	*
	567	* We know that the MessageDigest class does not implement
	568	* java.io.Serializable. However, since this field is no longer
	569	* used, it will always be NULL and won't affect the serialization
	570	* of the SecureRandom class itself.
	571	*/
	572	private byte[] randomBytes;
	573	/**
	574	* @serial
	575	*/
	576	private int randomBytesUsed;
	577	/**
	578	* @serial
	579	*/
	580	private long counter;
	581	}

java/pkg/java/security/SecureRandomSpi.class+0−0

Binary file not shown.

java/pkg/java/security/SecureRandomSpi.java+74−0

@@ -0,0 +1,74 @@
	1	/*
	2	* Copyright (c) 1998, 2005, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	/**
	29	* This class defines the <i>Service Provider Interface</i> (<b>SPI</b>)
	30	* for the <code>SecureRandom</code> class.
	31	* All the abstract methods in this class must be implemented by each
	32	* service provider who wishes to supply the implementation
	33	* of a cryptographically strong pseudo-random number generator.
	34	*
	35	*
	36	* @see SecureRandom
	37	* @since 1.2
	38	*/
	39
	40	public abstract class SecureRandomSpi implements java.io.Serializable {
	41
	42	private static final long serialVersionUID = -2991854161009191830L;
	43
	44	/**
	45	* Reseeds this random object. The given seed supplements, rather than
	46	* replaces, the existing seed. Thus, repeated calls are guaranteed
	47	* never to reduce randomness.
	48	*
	49	* @param seed the seed.
	50	*/
	51	protected abstract void engineSetSeed(byte[] seed);
	52
	53	/**
	54	* Generates a user-specified number of random bytes.
	55	*
	56	* <p> If a call to <code>engineSetSeed</code> had not occurred previously,
	57	* the first call to this method forces this SecureRandom implementation
	58	* to seed itself. This self-seeding will not occur if
	59	* <code>engineSetSeed</code> was previously called.
	60	*
	61	* @param bytes the array to be filled in with random bytes.
	62	*/
	63	protected abstract void engineNextBytes(byte[] bytes);
	64
	65	/**
	66	* Returns the given number of seed bytes. This call may be used to
	67	* seed other random number generators.
	68	*
	69	* @param numBytes the number of seed bytes to generate.
	70	*
	71	* @return the seed bytes.
	72	*/
	73	protected abstract byte[] engineGenerateSeed(int numBytes);
	74	}

java/pkg/java/security/Security$1.class+0−0

Binary file not shown.

java/pkg/java/security/Security$2.class+0−0

Binary file not shown.

java/pkg/java/security/Security$ProviderProperty.class+0−0

Binary file not shown.

java/pkg/java/security/Security.class+0−0

Binary file not shown.

java/pkg/java/security/Security.java+1107−0

@@ -0,0 +1,1107 @@
	1	/*
	2	* Copyright (c) 1996, 2011, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.lang.reflect.*;
	29	import java.util.*;
	30	import java.util.concurrent.ConcurrentHashMap;
	31	import java.io.*;
	32	import java.net.URL;
	33	import sun.security.util.Debug;
	34	import sun.security.util.PropertyExpander;
	35
	36	import java.security.Provider.Service;
	37
	38	import sun.security.jca.*;
	39
	40	/**
	41	* <p>This class centralizes all security properties and common security
	42	* methods. One of its primary uses is to manage providers.
	43	*
	44	* @author Benjamin Renaud
	45	*/
	46
	47	public final class Security {
	48
	49	/* Are we debugging? -- for developers */
	50	private static final Debug sdebug =
	51	Debug.getInstance("properties");
	52
	53	/* The java.security properties */
	54	private static Properties props;
	55
	56	// An element in the cache
	57	private static class ProviderProperty {
	58	String className;
	59	Provider provider;
	60	}
	61
	62	static {
	63	// doPrivileged here because there are multiple
	64	// things in initialize that might require privs.
	65	// (the FileInputStream call and the File.exists call,
	66	// the securityPropFile call, etc)
	67	AccessController.doPrivileged(new PrivilegedAction<Void>() {
	68	public Void run() {
	69	initialize();
	70	return null;
	71	}
	72	});
	73	}
	74
	75	private static void initialize() {
	76	props = new Properties();
	77	boolean loadedProps = false;
	78	boolean overrideAll = false;
	79
	80	// first load the system properties file
	81	// to determine the value of security.overridePropertiesFile
	82	File propFile = securityPropFile("java.security");
	83	if (propFile.exists()) {
	84	InputStream is = null;
	85	try {
	86	FileInputStream fis = new FileInputStream(propFile);
	87	is = new BufferedInputStream(fis);
	88	props.load(is);
	89	loadedProps = true;
	90
	91	if (sdebug != null) {
	92	sdebug.println("reading security properties file: " +
	93	propFile);
	94	}
	95	} catch (IOException e) {
	96	if (sdebug != null) {
	97	sdebug.println("unable to load security properties from " +
	98	propFile);
	99	e.printStackTrace();
	100	}
	101	} finally {
	102	if (is != null) {
	103	try {
	104	is.close();
	105	} catch (IOException ioe) {
	106	if (sdebug != null) {
	107	sdebug.println("unable to close input stream");
	108	}
	109	}
	110	}
	111	}
	112	}
	113
	114	if ("true".equalsIgnoreCase(props.getProperty
	115	("security.overridePropertiesFile"))) {
	116
	117	String extraPropFile = System.getProperty
	118	("java.security.properties");
	119	if (extraPropFile != null && extraPropFile.startsWith("=")) {
	120	overrideAll = true;
	121	extraPropFile = extraPropFile.substring(1);
	122	}
	123
	124	if (overrideAll) {
	125	props = new Properties();
	126	if (sdebug != null) {
	127	sdebug.println
	128	("overriding other security properties files!");
	129	}
	130	}
	131
	132	// now load the user-specified file so its values
	133	// will win if they conflict with the earlier values
	134	if (extraPropFile != null) {
	135	BufferedInputStream bis = null;
	136	try {
	137	URL propURL;
	138
	139	extraPropFile = PropertyExpander.expand(extraPropFile);
	140	propFile = new File(extraPropFile);
	141	if (propFile.exists()) {
	142	propURL = new URL
	143	("file:" + propFile.getCanonicalPath());
	144	} else {
	145	propURL = new URL(extraPropFile);
	146	}
	147	bis = new BufferedInputStream(propURL.openStream());
	148	props.load(bis);
	149	loadedProps = true;
	150
	151	if (sdebug != null) {
	152	sdebug.println("reading security properties file: " +
	153	propURL);
	154	if (overrideAll) {
	155	sdebug.println
	156	("overriding other security properties files!");
	157	}
	158	}
	159	} catch (Exception e) {
	160	if (sdebug != null) {
	161	sdebug.println
	162	("unable to load security properties from " +
	163	extraPropFile);
	164	e.printStackTrace();
	165	}
	166	} finally {
	167	if (bis != null) {
	168	try {
	169	bis.close();
	170	} catch (IOException ioe) {
	171	if (sdebug != null) {
	172	sdebug.println("unable to close input stream");
	173	}
	174	}
	175	}
	176	}
	177	}
	178	}
	179
	180	if (!loadedProps) {
	181	initializeStatic();
	182	if (sdebug != null) {
	183	sdebug.println("unable to load security properties " +
	184	"-- using defaults");
	185	}
	186	}
	187
	188	}
	189
	190	/*
	191	* Initialize to default values, if <java.home>/lib/java.security
	192	* is not found.
	193	*/
	194	private static void initializeStatic() {
	195	props.put("security.provider.1", "sun.security.provider.Sun");
	196	props.put("security.provider.2", "sun.security.rsa.SunRsaSign");
	197	props.put("security.provider.3", "com.sun.net.ssl.internal.ssl.Provider");
	198	props.put("security.provider.4", "com.sun.crypto.provider.SunJCE");
	199	props.put("security.provider.5", "sun.security.jgss.SunProvider");
	200	props.put("security.provider.6", "com.sun.security.sasl.Provider");
	201	}
	202
	203	/**
	204	* Don't let anyone instantiate this.
	205	*/
	206	private Security() {
	207	}
	208
	209	private static File securityPropFile(String filename) {
	210	// maybe check for a system property which will specify where to
	211	// look. Someday.
	212	String sep = File.separator;
	213	return new File(System.getProperty("java.home") + sep + "lib" + sep +
	214	"security" + sep + filename);
	215	}
	216
	217	/**
	218	* Looks up providers, and returns the property (and its associated
	219	* provider) mapping the key, if any.
	220	* The order in which the providers are looked up is the
	221	* provider-preference order, as specificed in the security
	222	* properties file.
	223	*/
	224	private static ProviderProperty getProviderProperty(String key) {
	225	ProviderProperty entry = null;
	226
	227	List<Provider> providers = Providers.getProviderList().providers();
	228	for (int i = 0; i < providers.size(); i++) {
	229
	230	String matchKey = null;
	231	Provider prov = providers.get(i);
	232	String prop = prov.getProperty(key);
	233
	234	if (prop == null) {
	235	// Is there a match if we do a case-insensitive property name
	236	// comparison? Let's try ...
	237	for (Enumeration<Object> e = prov.keys();
	238	e.hasMoreElements() && prop == null; ) {
	239	matchKey = (String)e.nextElement();
	240	if (key.equalsIgnoreCase(matchKey)) {
	241	prop = prov.getProperty(matchKey);
	242	break;
	243	}
	244	}
	245	}
	246
	247	if (prop != null) {
	248	ProviderProperty newEntry = new ProviderProperty();
	249	newEntry.className = prop;
	250	newEntry.provider = prov;
	251	return newEntry;
	252	}
	253	}
	254
	255	return entry;
	256	}
	257
	258	/**
	259	* Returns the property (if any) mapping the key for the given provider.
	260	*/
	261	private static String getProviderProperty(String key, Provider provider) {
	262	String prop = provider.getProperty(key);
	263	if (prop == null) {
	264	// Is there a match if we do a case-insensitive property name
	265	// comparison? Let's try ...
	266	for (Enumeration<Object> e = provider.keys();
	267	e.hasMoreElements() && prop == null; ) {
	268	String matchKey = (String)e.nextElement();
	269	if (key.equalsIgnoreCase(matchKey)) {
	270	prop = provider.getProperty(matchKey);
	271	break;
	272	}
	273	}
	274	}
	275	return prop;
	276	}
	277
	278	/**
	279	* Gets a specified property for an algorithm. The algorithm name
	280	* should be a standard name. See the <a href=
	281	* "{@docRoot}/../technotes/guides/security/StandardNames.html">
	282	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	283	* for information about standard algorithm names.
	284	*
	285	* One possible use is by specialized algorithm parsers, which may map
	286	* classes to algorithms which they understand (much like Key parsers
	287	* do).
	288	*
	289	* @param algName the algorithm name.
	290	*
	291	* @param propName the name of the property to get.
	292	*
	293	* @return the value of the specified property.
	294	*
	295	* @deprecated This method used to return the value of a proprietary
	296	* property in the master file of the "SUN" Cryptographic Service
	297	* Provider in order to determine how to parse algorithm-specific
	298	* parameters. Use the new provider-based and algorithm-independent
	299	* <code>AlgorithmParameters</code> and <code>KeyFactory</code> engine
	300	* classes (introduced in the J2SE version 1.2 platform) instead.
	301	*/
	302	@Deprecated
	303	public static String getAlgorithmProperty(String algName,
	304	String propName) {
	305	ProviderProperty entry = getProviderProperty("Alg." + propName
	306	+ "." + algName);
	307	if (entry != null) {
	308	return entry.className;
	309	} else {
	310	return null;
	311	}
	312	}
	313
	314	/**
	315	* Adds a new provider, at a specified position. The position is
	316	* the preference order in which providers are searched for
	317	* requested algorithms. The position is 1-based, that is,
	318	* 1 is most preferred, followed by 2, and so on.
	319	*
	320	* <p>If the given provider is installed at the requested position,
	321	* the provider that used to be at that position, and all providers
	322	* with a position greater than <code>position</code>, are shifted up
	323	* one position (towards the end of the list of installed providers).
	324	*
	325	* <p>A provider cannot be added if it is already installed.
	326	*
	327	* <p>First, if there is a security manager, its
	328	* <code>checkSecurityAccess</code>
	329	* method is called with the string
	330	* <code>"insertProvider."+provider.getName()</code>
	331	* to see if it's ok to add a new provider.
	332	* If the default implementation of <code>checkSecurityAccess</code>
	333	* is used (i.e., that method is not overriden), then this will result in
	334	* a call to the security manager's <code>checkPermission</code> method
	335	* with a
	336	* <code>SecurityPermission("insertProvider."+provider.getName())</code>
	337	* permission.
	338	*
	339	* @param provider the provider to be added.
	340	*
	341	* @param position the preference position that the caller would
	342	* like for this provider.
	343	*
	344	* @return the actual preference position in which the provider was
	345	* added, or -1 if the provider was not added because it is
	346	* already installed.
	347	*
	348	* @throws NullPointerException if provider is null
	349	* @throws SecurityException
	350	* if a security manager exists and its <code>{@link
	351	* java.lang.SecurityManager#checkSecurityAccess}</code> method
	352	* denies access to add a new provider
	353	*
	354	* @see #getProvider
	355	* @see #removeProvider
	356	* @see java.security.SecurityPermission
	357	*/
	358	public static synchronized int insertProviderAt(Provider provider,
	359	int position) {
	360	String providerName = provider.getName();
	361	check("insertProvider." + providerName);
	362	ProviderList list = Providers.getFullProviderList();
	363	ProviderList newList = ProviderList.insertAt(list, provider, position - 1);
	364	if (list == newList) {
	365	return -1;
	366	}
	367	Providers.setProviderList(newList);
	368	return newList.getIndex(providerName) + 1;
	369	}
	370
	371	/**
	372	* Adds a provider to the next position available.
	373	*
	374	* <p>First, if there is a security manager, its
	375	* <code>checkSecurityAccess</code>
	376	* method is called with the string
	377	* <code>"insertProvider."+provider.getName()</code>
	378	* to see if it's ok to add a new provider.
	379	* If the default implementation of <code>checkSecurityAccess</code>
	380	* is used (i.e., that method is not overriden), then this will result in
	381	* a call to the security manager's <code>checkPermission</code> method
	382	* with a
	383	* <code>SecurityPermission("insertProvider."+provider.getName())</code>
	384	* permission.
	385	*
	386	* @param provider the provider to be added.
	387	*
	388	* @return the preference position in which the provider was
	389	* added, or -1 if the provider was not added because it is
	390	* already installed.
	391	*
	392	* @throws NullPointerException if provider is null
	393	* @throws SecurityException
	394	* if a security manager exists and its <code>{@link
	395	* java.lang.SecurityManager#checkSecurityAccess}</code> method
	396	* denies access to add a new provider
	397	*
	398	* @see #getProvider
	399	* @see #removeProvider
	400	* @see java.security.SecurityPermission
	401	*/
	402	public static int addProvider(Provider provider) {
	403	/*
	404	* We can't assign a position here because the statically
	405	* registered providers may not have been installed yet.
	406	* insertProviderAt() will fix that value after it has
	407	* loaded the static providers.
	408	*/
	409	return insertProviderAt(provider, 0);
	410	}
	411
	412	/**
	413	* Removes the provider with the specified name.
	414	*
	415	* <p>When the specified provider is removed, all providers located
	416	* at a position greater than where the specified provider was are shifted
	417	* down one position (towards the head of the list of installed
	418	* providers).
	419	*
	420	* <p>This method returns silently if the provider is not installed or
	421	* if name is null.
	422	*
	423	* <p>First, if there is a security manager, its
	424	* <code>checkSecurityAccess</code>
	425	* method is called with the string <code>"removeProvider."+name</code>
	426	* to see if it's ok to remove the provider.
	427	* If the default implementation of <code>checkSecurityAccess</code>
	428	* is used (i.e., that method is not overriden), then this will result in
	429	* a call to the security manager's <code>checkPermission</code> method
	430	* with a <code>SecurityPermission("removeProvider."+name)</code>
	431	* permission.
	432	*
	433	* @param name the name of the provider to remove.
	434	*
	435	* @throws SecurityException
	436	* if a security manager exists and its <code>{@link
	437	* java.lang.SecurityManager#checkSecurityAccess}</code> method
	438	* denies
	439	* access to remove the provider
	440	*
	441	* @see #getProvider
	442	* @see #addProvider
	443	*/
	444	public static synchronized void removeProvider(String name) {
	445	check("removeProvider." + name);
	446	ProviderList list = Providers.getFullProviderList();
	447	ProviderList newList = ProviderList.remove(list, name);
	448	Providers.setProviderList(newList);
	449	}
	450
	451	/**
	452	* Returns an array containing all the installed providers. The order of
	453	* the providers in the array is their preference order.
	454	*
	455	* @return an array of all the installed providers.
	456	*/
	457	public static Provider[] getProviders() {
	458	return Providers.getFullProviderList().toArray();
	459	}
	460
	461	/**
	462	* Returns the provider installed with the specified name, if
	463	* any. Returns null if no provider with the specified name is
	464	* installed or if name is null.
	465	*
	466	* @param name the name of the provider to get.
	467	*
	468	* @return the provider of the specified name.
	469	*
	470	* @see #removeProvider
	471	* @see #addProvider
	472	*/
	473	public static Provider getProvider(String name) {
	474	return Providers.getProviderList().getProvider(name);
	475	}
	476
	477	/**
	478	* Returns an array containing all installed providers that satisfy the
	479	* specified selection criterion, or null if no such providers have been
	480	* installed. The returned providers are ordered
	481	* according to their <a href=
	482	* "#insertProviderAt(java.security.Provider, int)">preference order</a>.
	483	*
	484	* <p> A cryptographic service is always associated with a particular
	485	* algorithm or type. For example, a digital signature service is
	486	* always associated with a particular algorithm (e.g., DSA),
	487	* and a CertificateFactory service is always associated with
	488	* a particular certificate type (e.g., X.509).
	489	*
	490	* <p>The selection criterion must be specified in one of the following two
	491	* formats:
	492	* <ul>
	493	* <li> <i><crypto_service>.<algorithm_or_type></i> <p> The
	494	* cryptographic service name must not contain any dots.
	495	* <p> A
	496	* provider satisfies the specified selection criterion iff the provider
	497	* implements the
	498	* specified algorithm or type for the specified cryptographic service.
	499	* <p> For example, "CertificateFactory.X.509"
	500	* would be satisfied by any provider that supplied
	501	* a CertificateFactory implementation for X.509 certificates.
	502	* <li> <i><crypto_service>.<algorithm_or_type>
	503	* <attribute_name>:&lt attribute_value></i>
	504	* <p> The cryptographic service name must not contain any dots. There
	505	* must be one or more space charaters between the
	506	* <i><algorithm_or_type></i> and the <i><attribute_name></i>.
	507	* <p> A provider satisfies this selection criterion iff the
	508	* provider implements the specified algorithm or type for the specified
	509	* cryptographic service and its implementation meets the
	510	* constraint expressed by the specified attribute name/value pair.
	511	* <p> For example, "Signature.SHA1withDSA KeySize:1024" would be
	512	* satisfied by any provider that implemented
	513	* the SHA1withDSA signature algorithm with a keysize of 1024 (or larger).
	514	*
	515	* </ul>
	516	*
	517	* <p> See the <a href=
	518	* "{@docRoot}/../technotes/guides/security/StandardNames.html">
	519	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	520	* for information about standard cryptographic service names, standard
	521	* algorithm names and standard attribute names.
	522	*
	523	* @param filter the criterion for selecting
	524	* providers. The filter is case-insensitive.
	525	*
	526	* @return all the installed providers that satisfy the selection
	527	* criterion, or null if no such providers have been installed.
	528	*
	529	* @throws InvalidParameterException
	530	* if the filter is not in the required format
	531	* @throws NullPointerException if filter is null
	532	*
	533	* @see #getProviders(java.util.Map)
	534	* @since 1.3
	535	*/
	536	public static Provider[] getProviders(String filter) {
	537	String key = null;
	538	String value = null;
	539	int index = filter.indexOf(':');
	540
	541	if (index == -1) {
	542	key = filter;
	543	value = "";
	544	} else {
	545	key = filter.substring(0, index);
	546	value = filter.substring(index + 1);
	547	}
	548
	549	Hashtable<String, String> hashtableFilter = new Hashtable<>(1);
	550	hashtableFilter.put(key, value);
	551
	552	return (getProviders(hashtableFilter));
	553	}
	554
	555	/**
	556	* Returns an array containing all installed providers that satisfy the
	557	* specified* selection criteria, or null if no such providers have been
	558	* installed. The returned providers are ordered
	559	* according to their <a href=
	560	* "#insertProviderAt(java.security.Provider, int)">preference order</a>.
	561	*
	562	* <p>The selection criteria are represented by a map.
	563	* Each map entry represents a selection criterion.
	564	* A provider is selected iff it satisfies all selection
	565	* criteria. The key for any entry in such a map must be in one of the
	566	* following two formats:
	567	* <ul>
	568	* <li> <i><crypto_service>.<algorithm_or_type></i>
	569	* <p> The cryptographic service name must not contain any dots.
	570	* <p> The value associated with the key must be an empty string.
	571	* <p> A provider
	572	* satisfies this selection criterion iff the provider implements the
	573	* specified algorithm or type for the specified cryptographic service.
	574	* <li> <i><crypto_service>.<algorithm_or_type> <attribute_name></i>
	575	* <p> The cryptographic service name must not contain any dots. There
	576	* must be one or more space charaters between the <i><algorithm_or_type></i>
	577	* and the <i><attribute_name></i>.
	578	* <p> The value associated with the key must be a non-empty string.
	579	* A provider satisfies this selection criterion iff the
	580	* provider implements the specified algorithm or type for the specified
	581	* cryptographic service and its implementation meets the
	582	* constraint expressed by the specified attribute name/value pair.
	583	* </ul>
	584	*
	585	* <p> See the <a href=
	586	* "../../../technotes/guides/security/StandardNames.html">
	587	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	588	* for information about standard cryptographic service names, standard
	589	* algorithm names and standard attribute names.
	590	*
	591	* @param filter the criteria for selecting
	592	* providers. The filter is case-insensitive.
	593	*
	594	* @return all the installed providers that satisfy the selection
	595	* criteria, or null if no such providers have been installed.
	596	*
	597	* @throws InvalidParameterException
	598	* if the filter is not in the required format
	599	* @throws NullPointerException if filter is null
	600	*
	601	* @see #getProviders(java.lang.String)
	602	* @since 1.3
	603	*/
	604	public static Provider[] getProviders(Map<String,String> filter) {
	605	// Get all installed providers first.
	606	// Then only return those providers who satisfy the selection criteria.
	607	Provider[] allProviders = Security.getProviders();
	608	Set<String> keySet = filter.keySet();
	609	LinkedHashSet<Provider> candidates = new LinkedHashSet<>(5);
	610
	611	// Returns all installed providers
	612	// if the selection criteria is null.
	613	if ((keySet == null) \|\| (allProviders == null)) {
	614	return allProviders;
	615	}
	616
	617	boolean firstSearch = true;
	618
	619	// For each selection criterion, remove providers
	620	// which don't satisfy the criterion from the candidate set.
	621	for (Iterator<String> ite = keySet.iterator(); ite.hasNext(); ) {
	622	String key = ite.next();
	623	String value = filter.get(key);
	624
	625	LinkedHashSet<Provider> newCandidates = getAllQualifyingCandidates(key, value,
	626	allProviders);
	627	if (firstSearch) {
	628	candidates = newCandidates;
	629	firstSearch = false;
	630	}
	631
	632	if ((newCandidates != null) && !newCandidates.isEmpty()) {
	633	// For each provider in the candidates set, if it
	634	// isn't in the newCandidate set, we should remove
	635	// it from the candidate set.
	636	for (Iterator<Provider> cansIte = candidates.iterator();
	637	cansIte.hasNext(); ) {
	638	Provider prov = cansIte.next();
	639	if (!newCandidates.contains(prov)) {
	640	cansIte.remove();
	641	}
	642	}
	643	} else {
	644	candidates = null;
	645	break;
	646	}
	647	}
	648
	649	if ((candidates == null) \|\| (candidates.isEmpty()))
	650	return null;
	651
	652	Object[] candidatesArray = candidates.toArray();
	653	Provider[] result = new Provider[candidatesArray.length];
	654
	655	for (int i = 0; i < result.length; i++) {
	656	result[i] = (Provider)candidatesArray[i];
	657	}
	658
	659	return result;
	660	}
	661
	662	// Map containing cached Spi Class objects of the specified type
	663	private static final Map<String, Class> spiMap = new ConcurrentHashMap<>();
	664
	665	/**
	666	* Return the Class object for the given engine type
	667	* (e.g. "MessageDigest"). Works for Spis in the java.security package
	668	* only.
	669	*/
	670	private static Class getSpiClass(String type) {
	671	Class clazz = spiMap.get(type);
	672	if (clazz != null) {
	673	return clazz;
	674	}
	675	try {
	676	clazz = Class.forName("java.security." + type + "Spi");
	677	spiMap.put(type, clazz);
	678	return clazz;
	679	} catch (ClassNotFoundException e) {
	680	throw new AssertionError("Spi class not found", e);
	681	}
	682	}
	683
	684	/*
	685	* Returns an array of objects: the first object in the array is
	686	* an instance of an implementation of the requested algorithm
	687	* and type, and the second object in the array identifies the provider
	688	* of that implementation.
	689	* The <code>provider</code> argument can be null, in which case all
	690	* configured providers will be searched in order of preference.
	691	*/
	692	static Object[] getImpl(String algorithm, String type, String provider)
	693	throws NoSuchAlgorithmException, NoSuchProviderException {
	694	if (provider == null) {
	695	return GetInstance.getInstance
	696	(type, getSpiClass(type), algorithm).toArray();
	697	} else {
	698	return GetInstance.getInstance
	699	(type, getSpiClass(type), algorithm, provider).toArray();
	700	}
	701	}
	702
	703	static Object[] getImpl(String algorithm, String type, String provider,
	704	Object params) throws NoSuchAlgorithmException,
	705	NoSuchProviderException, InvalidAlgorithmParameterException {
	706	if (provider == null) {
	707	return GetInstance.getInstance
	708	(type, getSpiClass(type), algorithm, params).toArray();
	709	} else {
	710	return GetInstance.getInstance
	711	(type, getSpiClass(type), algorithm, params, provider).toArray();
	712	}
	713	}
	714
	715	/*
	716	* Returns an array of objects: the first object in the array is
	717	* an instance of an implementation of the requested algorithm
	718	* and type, and the second object in the array identifies the provider
	719	* of that implementation.
	720	* The <code>provider</code> argument cannot be null.
	721	*/
	722	static Object[] getImpl(String algorithm, String type, Provider provider)
	723	throws NoSuchAlgorithmException {
	724	return GetInstance.getInstance
	725	(type, getSpiClass(type), algorithm, provider).toArray();
	726	}
	727
	728	static Object[] getImpl(String algorithm, String type, Provider provider,
	729	Object params) throws NoSuchAlgorithmException,
	730	InvalidAlgorithmParameterException {
	731	return GetInstance.getInstance
	732	(type, getSpiClass(type), algorithm, params, provider).toArray();
	733	}
	734
	735	/**
	736	* Gets a security property value.
	737	*
	738	* <p>First, if there is a security manager, its
	739	* <code>checkPermission</code> method is called with a
	740	* <code>java.security.SecurityPermission("getProperty."+key)</code>
	741	* permission to see if it's ok to retrieve the specified
	742	* security property value..
	743	*
	744	* @param key the key of the property being retrieved.
	745	*
	746	* @return the value of the security property corresponding to key.
	747	*
	748	* @throws SecurityException
	749	* if a security manager exists and its <code>{@link
	750	* java.lang.SecurityManager#checkPermission}</code> method
	751	* denies
	752	* access to retrieve the specified security property value
	753	* @throws NullPointerException is key is null
	754	*
	755	* @see #setProperty
	756	* @see java.security.SecurityPermission
	757	*/
	758	public static String getProperty(String key) {
	759	SecurityManager sm = System.getSecurityManager();
	760	if (sm != null) {
	761	sm.checkPermission(new SecurityPermission("getProperty."+
	762	key));
	763	}
	764	String name = props.getProperty(key);
	765	if (name != null)
	766	name = name.trim(); // could be a class name with trailing ws
	767	return name;
	768	}
	769
	770	/**
	771	* Sets a security property value.
	772	*
	773	* <p>First, if there is a security manager, its
	774	* <code>checkPermission</code> method is called with a
	775	* <code>java.security.SecurityPermission("setProperty."+key)</code>
	776	* permission to see if it's ok to set the specified
	777	* security property value.
	778	*
	779	* @param key the name of the property to be set.
	780	*
	781	* @param datum the value of the property to be set.
	782	*
	783	* @throws SecurityException
	784	* if a security manager exists and its <code>{@link
	785	* java.lang.SecurityManager#checkPermission}</code> method
	786	* denies access to set the specified security property value
	787	* @throws NullPointerException if key or datum is null
	788	*
	789	* @see #getProperty
	790	* @see java.security.SecurityPermission
	791	*/
	792	public static void setProperty(String key, String datum) {
	793	check("setProperty."+key);
	794	props.put(key, datum);
	795	invalidateSMCache(key); /* See below. */
	796	}
	797
	798	/*
	799	* Implementation detail: If the property we just set in
	800	* setProperty() was either "package.access" or
	801	* "package.definition", we need to signal to the SecurityManager
	802	* class that the value has just changed, and that it should
	803	* invalidate it's local cache values.
	804	*
	805	* Rather than create a new API entry for this function,
	806	* we use reflection to set a private variable.
	807	*/
	808	private static void invalidateSMCache(String key) {
	809
	810	final boolean pa = key.equals("package.access");
	811	final boolean pd = key.equals("package.definition");
	812
	813	if (pa \|\| pd) {
	814	AccessController.doPrivileged(new PrivilegedAction<Void>() {
	815	public Void run() {
	816	try {
	817	/* Get the class via the bootstrap class loader. */
	818	Class cl = Class.forName(
	819	"java.lang.SecurityManager", false, null);
	820	Field f = null;
	821	boolean accessible = false;
	822
	823	if (pa) {
	824	f = cl.getDeclaredField("packageAccessValid");
	825	accessible = f.isAccessible();
	826	f.setAccessible(true);
	827	} else {
	828	f = cl.getDeclaredField("packageDefinitionValid");
	829	accessible = f.isAccessible();
	830	f.setAccessible(true);
	831	}
	832	f.setBoolean(f, false);
	833	f.setAccessible(accessible);
	834	}
	835	catch (Exception e1) {
	836	/* If we couldn't get the class, it hasn't
	837	* been loaded yet. If there is no such
	838	* field, we shouldn't try to set it. There
	839	* shouldn't be a security execption, as we
	840	* are loaded by boot class loader, and we
	841	* are inside a doPrivileged() here.
	842	*
	843	* NOOP: don't do anything...
	844	*/
	845	}
	846	return null;
	847	} /* run */
	848	}); /* PrivilegedAction */
	849	} /* if */
	850	}
	851
	852	private static void check(String directive) {
	853	SecurityManager security = System.getSecurityManager();
	854	if (security != null) {
	855	security.checkSecurityAccess(directive);
	856	}
	857	}
	858
	859	/*
	860	* Returns all providers who satisfy the specified
	861	* criterion.
	862	*/
	863	private static LinkedHashSet<Provider> getAllQualifyingCandidates(
	864	String filterKey,
	865	String filterValue,
	866	Provider[] allProviders) {
	867	String[] filterComponents = getFilterComponents(filterKey,
	868	filterValue);
	869
	870	// The first component is the service name.
	871	// The second is the algorithm name.
	872	// If the third isn't null, that is the attrinute name.
	873	String serviceName = filterComponents[0];
	874	String algName = filterComponents[1];
	875	String attrName = filterComponents[2];
	876
	877	return getProvidersNotUsingCache(serviceName, algName, attrName,
	878	filterValue, allProviders);
	879	}
	880
	881	private static LinkedHashSet<Provider> getProvidersNotUsingCache(
	882	String serviceName,
	883	String algName,
	884	String attrName,
	885	String filterValue,
	886	Provider[] allProviders) {
	887	LinkedHashSet<Provider> candidates = new LinkedHashSet<>(5);
	888	for (int i = 0; i < allProviders.length; i++) {
	889	if (isCriterionSatisfied(allProviders[i], serviceName,
	890	algName,
	891	attrName, filterValue)) {
	892	candidates.add(allProviders[i]);
	893	}
	894	}
	895	return candidates;
	896	}
	897
	898	/*
	899	* Returns true if the given provider satisfies
	900	* the selection criterion key:value.
	901	*/
	902	private static boolean isCriterionSatisfied(Provider prov,
	903	String serviceName,
	904	String algName,
	905	String attrName,
	906	String filterValue) {
	907	String key = serviceName + '.' + algName;
	908
	909	if (attrName != null) {
	910	key += ' ' + attrName;
	911	}
	912	// Check whether the provider has a property
	913	// whose key is the same as the given key.
	914	String propValue = getProviderProperty(key, prov);
	915
	916	if (propValue == null) {
	917	// Check whether we have an alias instead
	918	// of a standard name in the key.
	919	String standardName = getProviderProperty("Alg.Alias." +
	920	serviceName + "." +
	921	algName,
	922	prov);
	923	if (standardName != null) {
	924	key = serviceName + "." + standardName;
	925
	926	if (attrName != null) {
	927	key += ' ' + attrName;
	928	}
	929
	930	propValue = getProviderProperty(key, prov);
	931	}
	932
	933	if (propValue == null) {
	934	// The provider doesn't have the given
	935	// key in its property list.
	936	return false;
	937	}
	938	}
	939
	940	// If the key is in the format of:
	941	// <crypto_service>.<algorithm_or_type>,
	942	// there is no need to check the value.
	943
	944	if (attrName == null) {
	945	return true;
	946	}
	947
	948	// If we get here, the key must be in the
	949	// format of <crypto_service>.<algorithm_or_provider> <attribute_name>.
	950	if (isStandardAttr(attrName)) {
	951	return isConstraintSatisfied(attrName, filterValue, propValue);
	952	} else {
	953	return filterValue.equalsIgnoreCase(propValue);
	954	}
	955	}
	956
	957	/*
	958	* Returns true if the attribute is a standard attribute;
	959	* otherwise, returns false.
	960	*/
	961	private static boolean isStandardAttr(String attribute) {
	962	// For now, we just have two standard attributes:
	963	// KeySize and ImplementedIn.
	964	if (attribute.equalsIgnoreCase("KeySize"))
	965	return true;
	966
	967	if (attribute.equalsIgnoreCase("ImplementedIn"))
	968	return true;
	969
	970	return false;
	971	}
	972
	973	/*
	974	* Returns true if the requested attribute value is supported;
	975	* otherwise, returns false.
	976	*/
	977	private static boolean isConstraintSatisfied(String attribute,
	978	String value,
	979	String prop) {
	980	// For KeySize, prop is the max key size the
	981	// provider supports for a specific <crypto_service>.<algorithm>.
	982	if (attribute.equalsIgnoreCase("KeySize")) {
	983	int requestedSize = Integer.parseInt(value);
	984	int maxSize = Integer.parseInt(prop);
	985	if (requestedSize <= maxSize) {
	986	return true;
	987	} else {
	988	return false;
	989	}
	990	}
	991
	992	// For Type, prop is the type of the implementation
	993	// for a specific <crypto service>.<algorithm>.
	994	if (attribute.equalsIgnoreCase("ImplementedIn")) {
	995	return value.equalsIgnoreCase(prop);
	996	}
	997
	998	return false;
	999	}
	1000
	1001	static String[] getFilterComponents(String filterKey, String filterValue) {
	1002	int algIndex = filterKey.indexOf('.');
	1003
	1004	if (algIndex < 0) {
	1005	// There must be a dot in the filter, and the dot
	1006	// shouldn't be at the beginning of this string.
	1007	throw new InvalidParameterException("Invalid filter");
	1008	}
	1009
	1010	String serviceName = filterKey.substring(0, algIndex);
	1011	String algName = null;
	1012	String attrName = null;
	1013
	1014	if (filterValue.length() == 0) {
	1015	// The filterValue is an empty string. So the filterKey
	1016	// should be in the format of <crypto_service>.<algorithm_or_type>.
	1017	algName = filterKey.substring(algIndex + 1).trim();
	1018	if (algName.length() == 0) {
	1019	// There must be a algorithm or type name.
	1020	throw new InvalidParameterException("Invalid filter");
	1021	}
	1022	} else {
	1023	// The filterValue is a non-empty string. So the filterKey must be
	1024	// in the format of
	1025	// <crypto_service>.<algorithm_or_type> <attribute_name>
	1026	int attrIndex = filterKey.indexOf(' ');
	1027
	1028	if (attrIndex == -1) {
	1029	// There is no attribute name in the filter.
	1030	throw new InvalidParameterException("Invalid filter");
	1031	} else {
	1032	attrName = filterKey.substring(attrIndex + 1).trim();
	1033	if (attrName.length() == 0) {
	1034	// There is no attribute name in the filter.
	1035	throw new InvalidParameterException("Invalid filter");
	1036	}
	1037	}
	1038
	1039	// There must be an algorithm name in the filter.
	1040	if ((attrIndex < algIndex) \|\|
	1041	(algIndex == attrIndex - 1)) {
	1042	throw new InvalidParameterException("Invalid filter");
	1043	} else {
	1044	algName = filterKey.substring(algIndex + 1, attrIndex);
	1045	}
	1046	}
	1047
	1048	String[] result = new String[3];
	1049	result[0] = serviceName;
	1050	result[1] = algName;
	1051	result[2] = attrName;
	1052
	1053	return result;
	1054	}
	1055
	1056	/**
	1057	* Returns a Set of Strings containing the names of all available
	1058	* algorithms or types for the specified Java cryptographic service
	1059	* (e.g., Signature, MessageDigest, Cipher, Mac, KeyStore). Returns
	1060	* an empty Set if there is no provider that supports the
	1061	* specified service or if serviceName is null. For a complete list
	1062	* of Java cryptographic services, please see the
	1063	* <a href="../../../technotes/guides/security/crypto/CryptoSpec.html">Java
	1064	* Cryptography Architecture API Specification & Reference</a>.
	1065	* Note: the returned set is immutable.
	1066	*
	1067	* @param serviceName the name of the Java cryptographic
	1068	* service (e.g., Signature, MessageDigest, Cipher, Mac, KeyStore).
	1069	* Note: this parameter is case-insensitive.
	1070	*
	1071	* @return a Set of Strings containing the names of all available
	1072	* algorithms or types for the specified Java cryptographic service
	1073	* or an empty set if no provider supports the specified service.
	1074	*
	1075	* @since 1.4
	1076	**/
	1077	public static Set<String> getAlgorithms(String serviceName) {
	1078
	1079	if ((serviceName == null) \|\| (serviceName.length() == 0) \|\|
	1080	(serviceName.endsWith("."))) {
	1081	return Collections.EMPTY_SET;
	1082	}
	1083
	1084	HashSet<String> result = new HashSet<>();
	1085	Provider[] providers = Security.getProviders();
	1086
	1087	for (int i = 0; i < providers.length; i++) {
	1088	// Check the keys for each provider.
	1089	for (Enumeration<Object> e = providers[i].keys();
	1090	e.hasMoreElements(); ) {
	1091	String currentKey = ((String)e.nextElement()).toUpperCase();
	1092	if (currentKey.startsWith(serviceName.toUpperCase())) {
	1093	// We should skip the currentKey if it contains a
	1094	// whitespace. The reason is: such an entry in the
	1095	// provider property contains attributes for the
	1096	// implementation of an algorithm. We are only interested
	1097	// in entries which lead to the implementation
	1098	// classes.
	1099	if (currentKey.indexOf(" ") < 0) {
	1100	result.add(currentKey.substring(serviceName.length() + 1));
	1101	}
	1102	}
	1103	}
	1104	}
	1105	return Collections.unmodifiableSet(result);
	1106	}
	1107	}

java/pkg/java/security/SecurityPermission.class+0−0

Binary file not shown.

java/pkg/java/security/SecurityPermission.java+331−0

@@ -0,0 +1,331 @@
	1	/*
	2	* Copyright (c) 1997, 2006, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.security.*;
	29	import java.util.Enumeration;
	30	import java.util.Hashtable;
	31	import java.util.StringTokenizer;
	32
	33	/**
	34	* This class is for security permissions.
	35	* A SecurityPermission contains a name (also referred to as a "target name")
	36	* but no actions list; you either have the named permission
	37	* or you don't.
	38	* <P>
	39	* The target name is the name of a security configuration parameter (see below).
	40	* Currently the SecurityPermission object is used to guard access
	41	* to the Policy, Security, Provider, Signer, and Identity
	42	* objects.
	43	* <P>
	44	* The following table lists all the possible SecurityPermission target names,
	45	* and for each provides a description of what the permission allows
	46	* and a discussion of the risks of granting code the permission.
	47	* <P>
	48	*
	49	* <table border=1 cellpadding=5 summary="target name,what the permission allows, and associated risks">
	50	* <tr>
	51	* <th>Permission Target Name</th>
	52	* <th>What the Permission Allows</th>
	53	* <th>Risks of Allowing this Permission</th>
	54	* </tr>
	55	*
	56	* <tr>
	57	* <td>createAccessControlContext</td>
	58	* <td>Creation of an AccessControlContext</td>
	59	* <td>This allows someone to instantiate an AccessControlContext
	60	* with a <code>DomainCombiner</code>. Extreme care must be taken when
	61	* granting this permission. Malicious code could create a DomainCombiner
	62	* that augments the set of permissions granted to code, and even grant the
	63	* code {@link java.security.AllPermission}.</td>
	64	* </tr>
	65	*
	66	* <tr>
	67	* <td>getDomainCombiner</td>
	68	* <td>Retrieval of an AccessControlContext's DomainCombiner</td>
	69	* <td>This allows someone to retrieve an AccessControlContext's
	70	* <code>DomainCombiner</code>. Since DomainCombiners may contain
	71	* sensitive information, this could potentially lead to a privacy leak.</td>
	72	* </tr>
	73	*
	74	* <tr>
	75	* <td>getPolicy</td>
	76	* <td>Retrieval of the system-wide security policy (specifically, of the
	77	* currently-installed Policy object)</td>
	78	* <td>This allows someone to query the policy via the
	79	* <code>getPermissions</code> call,
	80	* which discloses which permissions would be granted to a given CodeSource.
	81	* While revealing the policy does not compromise the security of
	82	* the system, it does provide malicious code with additional information
	83	* which it may use to better aim an attack. It is wise
	84	* not to divulge more information than necessary.</td>
	85	* </tr>
	86	*
	87	* <tr>
	88	* <td>setPolicy</td>
	89	* <td>Setting of the system-wide security policy (specifically,
	90	* the Policy object)</td>
	91	* <td>Granting this permission is extremely dangerous, as malicious
	92	* code may grant itself all the necessary permissions it needs
	93	* to successfully mount an attack on the system.</td>
	94	* </tr>
	95	*
	96	* <tr>
	97	* <td>createPolicy.{policy type}</td>
	98	* <td>Getting an instance of a Policy implementation from a provider</td>
	99	* <td>Granting this permission enables code to obtain a Policy object.
	100	* Malicious code may query the Policy object to determine what permissions
	101	* have been granted to code other than itself. </td>
	102	* </tr>
	103	*
	104	* <tr>
	105	* <td>getProperty.{key}</td>
	106	* <td>Retrieval of the security property with the specified key</td>
	107	* <td>Depending on the particular key for which access has
	108	* been granted, the code may have access to the list of security
	109	* providers, as well as the location of the system-wide and user
	110	* security policies. while revealing this information does not
	111	* compromise the security of the system, it does provide malicious
	112	* code with additional information which it may use to better aim
	113	* an attack.
	114	</td>
	115	* </tr>
	116	*
	117	* <tr>
	118	* <td>setProperty.{key}</td>
	119	* <td>Setting of the security property with the specified key</td>
	120	* <td>This could include setting a security provider or defining
	121	* the location of the system-wide security policy. Malicious
	122	* code that has permission to set a new security provider may
	123	* set a rogue provider that steals confidential information such
	124	* as cryptographic private keys. In addition, malicious code with
	125	* permission to set the location of the system-wide security policy
	126	* may point it to a security policy that grants the attacker
	127	* all the necessary permissions it requires to successfully mount
	128	* an attack on the system.
	129	</td>
	130	* </tr>
	131	*
	132	* <tr>
	133	* <td>insertProvider.{provider name}</td>
	134	* <td>Addition of a new provider, with the specified name</td>
	135	* <td>This would allow somebody to introduce a possibly
	136	* malicious provider (e.g., one that discloses the private keys passed
	137	* to it) as the highest-priority provider. This would be possible
	138	* because the Security object (which manages the installed providers)
	139	* currently does not check the integrity or authenticity of a provider
	140	* before attaching it.</td>
	141	* </tr>
	142	*
	143	* <tr>
	144	* <td>removeProvider.{provider name}</td>
	145	* <td>Removal of the specified provider</td>
	146	* <td>This may change the behavior or disable execution of other
	147	* parts of the program. If a provider subsequently requested by the
	148	* program has been removed, execution may fail. Also, if the removed
	149	* provider is not explicitly requested by the rest of the program, but
	150	* it would normally be the provider chosen when a cryptography service
	151	* is requested (due to its previous order in the list of providers),
	152	* a different provider will be chosen instead, or no suitable provider
	153	* will be found, thereby resulting in program failure.</td>
	154	* </tr>
	155	*
	156	* <tr>
	157	* <td>clearProviderProperties.{provider name}</td>
	158	* <td>"Clearing" of a Provider so that it no longer contains the properties
	159	* used to look up services implemented by the provider</td>
	160	* <td>This disables the lookup of services implemented by the provider.
	161	* This may thus change the behavior or disable execution of other
	162	* parts of the program that would normally utilize the Provider, as
	163	* described under the "removeProvider.{provider name}" permission.</td>
	164	* </tr>
	165	*
	166	* <tr>
	167	* <td>putProviderProperty.{provider name}</td>
	168	* <td>Setting of properties for the specified Provider</td>
	169	* <td>The provider properties each specify the name and location
	170	* of a particular service implemented by the provider. By granting
	171	* this permission, you let code replace the service specification
	172	* with another one, thereby specifying a different implementation.</td>
	173	* </tr>
	174	*
	175	* <tr>
	176	* <td>removeProviderProperty.{provider name}</td>
	177	* <td>Removal of properties from the specified Provider</td>
	178	* <td>This disables the lookup of services implemented by the
	179	* provider. They are no longer accessible due to removal of the properties
	180	* specifying their names and locations. This
	181	* may change the behavior or disable execution of other
	182	* parts of the program that would normally utilize the Provider, as
	183	* described under the "removeProvider.{provider name}" permission.</td>
	184	* </tr>
	185	*
	186	* </table>
	187	*
	188	* <P>
	189	* The following permissions are associated with classes that have been
	190	* deprecated: {@link Identity}, {@link IdentityScope}, {@link Signer}. Use of
	191	* them is discouraged. See the applicable classes for more information.
	192	* <P>
	193	*
	194	* <table border=1 cellpadding=5 summary="target name,what the permission allows, and associated risks">
	195	* <tr>
	196	* <th>Permission Target Name</th>
	197	* <th>What the Permission Allows</th>
	198	* <th>Risks of Allowing this Permission</th>
	199	* </tr>
	200	*
	201	* <tr>
	202	* <td>setSystemScope</td>
	203	* <td>Setting of the system identity scope</td>
	204	* <td>This would allow an attacker to configure the system identity scope with
	205	* certificates that should not be trusted, thereby granting applet or
	206	* application code signed with those certificates privileges that
	207	* would have been denied by the system's original identity scope.</td>
	208	* </tr>
	209	*
	210	* <tr>
	211	* <td>setIdentityPublicKey</td>
	212	* <td>Setting of the public key for an Identity</td>
	213	* <td>If the identity is marked as "trusted", this allows an attacker to
	214	* introduce a different public key (e.g., its own) that is not trusted
	215	* by the system's identity scope, thereby granting applet or
	216	* application code signed with that public key privileges that
	217	* would have been denied otherwise.</td>
	218	* </tr>
	219	*
	220	* <tr>
	221	* <td>setIdentityInfo</td>
	222	* <td>Setting of a general information string for an Identity</td>
	223	* <td>This allows attackers to set the general description for
	224	* an identity. This may trick applications into using a different
	225	* identity than intended or may prevent applications from finding a
	226	* particular identity.</td>
	227	* </tr>
	228	*
	229	* <tr>
	230	* <td>addIdentityCertificate</td>
	231	* <td>Addition of a certificate for an Identity</td>
	232	* <td>This allows attackers to set a certificate for
	233	* an identity's public key. This is dangerous because it affects
	234	* the trust relationship across the system. This public key suddenly
	235	* becomes trusted to a wider audience than it otherwise would be.</td>
	236	* </tr>
	237	*
	238	* <tr>
	239	* <td>removeIdentityCertificate</td>
	240	* <td>Removal of a certificate for an Identity</td>
	241	* <td>This allows attackers to remove a certificate for
	242	* an identity's public key. This is dangerous because it affects
	243	* the trust relationship across the system. This public key suddenly
	244	* becomes considered less trustworthy than it otherwise would be.</td>
	245	* </tr>
	246	*
	247	* <tr>
	248	* <td>printIdentity</td>
	249	* <td>Viewing the name of a principal
	250	* and optionally the scope in which it is used, and whether
	251	* or not it is considered "trusted" in that scope</td>
	252	* <td>The scope that is printed out may be a filename, in which case
	253	* it may convey local system information. For example, here's a sample
	254	* printout of an identity named "carol", who is
	255	* marked not trusted in the user's identity database:<br>
	256	* carol[/home/luehe/identitydb.obj][not trusted]</td>
	257	*</tr>
	258	*
	259	* <tr>
	260	* <td>getSignerPrivateKey</td>
	261	* <td>Retrieval of a Signer's private key</td>
	262	* <td>It is very dangerous to allow access to a private key; private
	263	* keys are supposed to be kept secret. Otherwise, code can use the
	264	* private key to sign various files and claim the signature came from
	265	* the Signer.</td>
	266	* </tr>
	267	*
	268	* <tr>
	269	* <td>setSignerKeyPair</td>
	270	* <td>Setting of the key pair (public key and private key) for a Signer</td>
	271	* <td>This would allow an attacker to replace somebody else's (the "target's")
	272	* keypair with a possibly weaker keypair (e.g., a keypair of a smaller
	273	* keysize). This also would allow the attacker to listen in on encrypted
	274	* communication between the target and its peers. The target's peers
	275	* might wrap an encryption session key under the target's "new" public
	276	* key, which would allow the attacker (who possesses the corresponding
	277	* private key) to unwrap the session key and decipher the communication
	278	* data encrypted under that session key.</td>
	279	* </tr>
	280	*
	281	* </table>
	282	*
	283	* @see java.security.BasicPermission
	284	* @see java.security.Permission
	285	* @see java.security.Permissions
	286	* @see java.security.PermissionCollection
	287	* @see java.lang.SecurityManager
	288	*
	289	*
	290	* @author Marianne Mueller
	291	* @author Roland Schemers
	292	*/
	293
	294	public final class SecurityPermission extends BasicPermission {
	295
	296	private static final long serialVersionUID = 5236109936224050470L;
	297
	298	/**
	299	* Creates a new SecurityPermission with the specified name.
	300	* The name is the symbolic name of the SecurityPermission. An asterisk
	301	* may appear at the end of the name, following a ".", or by itself, to
	302	* signify a wildcard match.
	303	*
	304	* @param name the name of the SecurityPermission
	305	*
	306	* @throws NullPointerException if <code>name</code> is <code>null</code>.
	307	* @throws IllegalArgumentException if <code>name</code> is empty.
	308	*/
	309
	310	public SecurityPermission(String name)
	311	{
	312	super(name);
	313	}
	314
	315	/**
	316	* Creates a new SecurityPermission object with the specified name.
	317	* The name is the symbolic name of the SecurityPermission, and the
	318	* actions String is currently unused and should be null.
	319	*
	320	* @param name the name of the SecurityPermission
	321	* @param actions should be null.
	322	*
	323	* @throws NullPointerException if <code>name</code> is <code>null</code>.
	324	* @throws IllegalArgumentException if <code>name</code> is empty.
	325	*/
	326
	327	public SecurityPermission(String name, String actions)
	328	{
	329	super(name, actions);
	330	}
	331	}

java/pkg/java/security/Signature$CipherAdapter.class+0−0

Binary file not shown.

java/pkg/java/security/Signature$Delegate.class+0−0

Binary file not shown.

java/pkg/java/security/Signature.class+0−0

Binary file not shown.

java/pkg/java/security/Signature.java+1293−0

@@ -0,0 +1,1293 @@
	1	/*
	2	* Copyright (c) 1996, 2011, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.security.spec.AlgorithmParameterSpec;
	29	import java.util.*;
	30	import java.util.concurrent.ConcurrentHashMap;
	31	import java.io.*;
	32	import java.security.cert.Certificate;
	33	import java.security.cert.X509Certificate;
	34
	35	import java.nio.ByteBuffer;
	36
	37	import java.security.Provider.Service;
	38
	39	import javax.crypto.Cipher;
	40	import javax.crypto.CipherSpi;
	41	import javax.crypto.IllegalBlockSizeException;
	42	import javax.crypto.BadPaddingException;
	43	import javax.crypto.NoSuchPaddingException;
	44
	45	import sun.security.util.Debug;
	46	import sun.security.jca.*;
	47	import sun.security.jca.GetInstance.Instance;
	48
	49	/**
	50	* The Signature class is used to provide applications the functionality
	51	* of a digital signature algorithm. Digital signatures are used for
	52	* authentication and integrity assurance of digital data.
	53	*
	54	* <p> The signature algorithm can be, among others, the NIST standard
	55	* DSA, using DSA and SHA-1. The DSA algorithm using the
	56	* SHA-1 message digest algorithm can be specified as <tt>SHA1withDSA</tt>.
	57	* In the case of RSA, there are multiple choices for the message digest
	58	* algorithm, so the signing algorithm could be specified as, for example,
	59	* <tt>MD2withRSA</tt>, <tt>MD5withRSA</tt>, or <tt>SHA1withRSA</tt>.
	60	* The algorithm name must be specified, as there is no default.
	61	*
	62	* <p> A Signature object can be used to generate and verify digital
	63	* signatures.
	64	*
	65	* <p> There are three phases to the use of a Signature object for
	66	* either signing data or verifying a signature:<ol>
	67	*
	68	* <li>Initialization, with either
	69	*
	70	* <ul>
	71	*
	72	* <li>a public key, which initializes the signature for
	73	* verification (see {@link #initVerify(PublicKey) initVerify}), or
	74	*
	75	* <li>a private key (and optionally a Secure Random Number Generator),
	76	* which initializes the signature for signing
	77	* (see {@link #initSign(PrivateKey)}
	78	* and {@link #initSign(PrivateKey, SecureRandom)}).
	79	*
	80	* </ul><p>
	81	*
	82	* <li>Updating<p>
	83	*
	84	* <p>Depending on the type of initialization, this will update the
	85	* bytes to be signed or verified. See the
	86	* {@link #update(byte) update} methods.<p>
	87	*
	88	* <li>Signing or Verifying a signature on all updated bytes. See the
	89	* {@link #sign() sign} methods and the {@link #verify(byte[]) verify}
	90	* method.
	91	*
	92	* </ol>
	93	*
	94	* <p>Note that this class is abstract and extends from
	95	* <code>SignatureSpi</code> for historical reasons.
	96	* Application developers should only take notice of the methods defined in
	97	* this <code>Signature</code> class; all the methods in
	98	* the superclass are intended for cryptographic service providers who wish to
	99	* supply their own implementations of digital signature algorithms.
	100	*
	101	* <p> Every implementation of the Java platform is required to support the
	102	* following standard <code>Signature</code> algorithms:
	103	* <ul>
	104	* <li><tt>SHA1withDSA</tt></li>
	105	* <li><tt>SHA1withRSA</tt></li>
	106	* <li><tt>SHA256withRSA</tt></li>
	107	* </ul>
	108	* These algorithms are described in the <a href=
	109	* "{@docRoot}/../technotes/guides/security/StandardNames.html#Signature">
	110	* Signature section</a> of the
	111	* Java Cryptography Architecture Standard Algorithm Name Documentation.
	112	* Consult the release documentation for your implementation to see if any
	113	* other algorithms are supported.
	114	*
	115	* @author Benjamin Renaud
	116	*
	117	*/
	118
	119	public abstract class Signature extends SignatureSpi {
	120
	121	private static final Debug debug =
	122	Debug.getInstance("jca", "Signature");
	123
	124	/*
	125	* The algorithm for this signature object.
	126	* This value is used to map an OID to the particular algorithm.
	127	* The mapping is done in AlgorithmObject.algOID(String algorithm)
	128	*/
	129	private String algorithm;
	130
	131	// The provider
	132	Provider provider;
	133
	134	/**
	135	* Possible {@link #state} value, signifying that
	136	* this signature object has not yet been initialized.
	137	*/
	138	protected final static int UNINITIALIZED = 0;
	139
	140	/**
	141	* Possible {@link #state} value, signifying that
	142	* this signature object has been initialized for signing.
	143	*/
	144	protected final static int SIGN = 2;
	145
	146	/**
	147	* Possible {@link #state} value, signifying that
	148	* this signature object has been initialized for verification.
	149	*/
	150	protected final static int VERIFY = 3;
	151
	152	/**
	153	* Current state of this signature object.
	154	*/
	155	protected int state = UNINITIALIZED;
	156
	157	/**
	158	* Creates a Signature object for the specified algorithm.
	159	*
	160	* @param algorithm the standard string name of the algorithm.
	161	* See the Signature section in the <a href=
	162	* "{@docRoot}/../technotes/guides/security/StandardNames.html#Signature">
	163	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	164	* for information about standard algorithm names.
	165	*/
	166	protected Signature(String algorithm) {
	167	this.algorithm = algorithm;
	168	}
	169
	170	// name of the special signature alg
	171	private final static String RSA_SIGNATURE = "NONEwithRSA";
	172
	173	// name of the equivalent cipher alg
	174	private final static String RSA_CIPHER = "RSA/ECB/PKCS1Padding";
	175
	176	// all the services we need to lookup for compatibility with Cipher
	177	private final static List<ServiceId> rsaIds = Arrays.asList(
	178	new ServiceId[] {
	179	new ServiceId("Signature", "NONEwithRSA"),
	180	new ServiceId("Cipher", "RSA/ECB/PKCS1Padding"),
	181	new ServiceId("Cipher", "RSA/ECB"),
	182	new ServiceId("Cipher", "RSA//PKCS1Padding"),
	183	new ServiceId("Cipher", "RSA"),
	184	}
	185	);
	186
	187	/**
	188	* Returns a Signature object that implements the specified signature
	189	* algorithm.
	190	*
	191	* <p> This method traverses the list of registered security Providers,
	192	* starting with the most preferred Provider.
	193	* A new Signature object encapsulating the
	194	* SignatureSpi implementation from the first
	195	* Provider that supports the specified algorithm is returned.
	196	*
	197	* <p> Note that the list of registered providers may be retrieved via
	198	* the {@link Security#getProviders() Security.getProviders()} method.
	199	*
	200	* @param algorithm the standard name of the algorithm requested.
	201	* See the Signature section in the <a href=
	202	* "{@docRoot}/../technotes/guides/security/StandardNames.html#Signature">
	203	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	204	* for information about standard algorithm names.
	205	*
	206	* @return the new Signature object.
	207	*
	208	* @exception NoSuchAlgorithmException if no Provider supports a
	209	* Signature implementation for the
	210	* specified algorithm.
	211	*
	212	* @see Provider
	213	*/
	214	public static Signature getInstance(String algorithm)
	215	throws NoSuchAlgorithmException {
	216	List<Service> list;
	217	if (algorithm.equalsIgnoreCase(RSA_SIGNATURE)) {
	218	list = GetInstance.getServices(rsaIds);
	219	} else {
	220	list = GetInstance.getServices("Signature", algorithm);
	221	}
	222	Iterator<Service> t = list.iterator();
	223	if (t.hasNext() == false) {
	224	throw new NoSuchAlgorithmException
	225	(algorithm + " Signature not available");
	226	}
	227	// try services until we find an Spi or a working Signature subclass
	228	NoSuchAlgorithmException failure;
	229	do {
	230	Service s = t.next();
	231	if (isSpi(s)) {
	232	return new Delegate(s, t, algorithm);
	233	} else {
	234	// must be a subclass of Signature, disable dynamic selection
	235	try {
	236	Instance instance =
	237	GetInstance.getInstance(s, SignatureSpi.class);
	238	return getInstance(instance, algorithm);
	239	} catch (NoSuchAlgorithmException e) {
	240	failure = e;
	241	}
	242	}
	243	} while (t.hasNext());
	244	throw failure;
	245	}
	246
	247	private static Signature getInstance(Instance instance, String algorithm) {
	248	Signature sig;
	249	if (instance.impl instanceof Signature) {
	250	sig = (Signature)instance.impl;
	251	} else {
	252	SignatureSpi spi = (SignatureSpi)instance.impl;
	253	sig = new Delegate(spi, algorithm);
	254	}
	255	sig.provider = instance.provider;
	256	return sig;
	257	}
	258
	259	private final static Map<String,Boolean> signatureInfo;
	260
	261	static {
	262	signatureInfo = new ConcurrentHashMap<String,Boolean>();
	263	Boolean TRUE = Boolean.TRUE;
	264	// pre-initialize with values for our SignatureSpi implementations
	265	signatureInfo.put("sun.security.provider.DSA$RawDSA", TRUE);
	266	signatureInfo.put("sun.security.provider.DSA$SHA1withDSA", TRUE);
	267	signatureInfo.put("sun.security.rsa.RSASignature$MD2withRSA", TRUE);
	268	signatureInfo.put("sun.security.rsa.RSASignature$MD5withRSA", TRUE);
	269	signatureInfo.put("sun.security.rsa.RSASignature$SHA1withRSA", TRUE);
	270	signatureInfo.put("sun.security.rsa.RSASignature$SHA256withRSA", TRUE);
	271	signatureInfo.put("sun.security.rsa.RSASignature$SHA384withRSA", TRUE);
	272	signatureInfo.put("sun.security.rsa.RSASignature$SHA512withRSA", TRUE);
	273	signatureInfo.put("com.sun.net.ssl.internal.ssl.RSASignature", TRUE);
	274	signatureInfo.put("sun.security.pkcs11.P11Signature", TRUE);
	275	}
	276
	277	private static boolean isSpi(Service s) {
	278	if (s.getType().equals("Cipher")) {
	279	// must be a CipherSpi, which we can wrap with the CipherAdapter
	280	return true;
	281	}
	282	String className = s.getClassName();
	283	Boolean result = signatureInfo.get(className);
	284	if (result == null) {
	285	try {
	286	Object instance = s.newInstance(null);
	287	// Signature extends SignatureSpi
	288	// so it is a "real" Spi if it is an
	289	// instance of SignatureSpi but not Signature
	290	boolean r = (instance instanceof SignatureSpi)
	291	&& (instance instanceof Signature == false);
	292	if ((debug != null) && (r == false)) {
	293	debug.println("Not a SignatureSpi " + className);
	294	debug.println("Delayed provider selection may not be "
	295	+ "available for algorithm " + s.getAlgorithm());
	296	}
	297	result = Boolean.valueOf(r);
	298	signatureInfo.put(className, result);
	299	} catch (Exception e) {
	300	// something is wrong, assume not an SPI
	301	return false;
	302	}
	303	}
	304	return result.booleanValue();
	305	}
	306
	307	/**
	308	* Returns a Signature object that implements the specified signature
	309	* algorithm.
	310	*
	311	* <p> A new Signature object encapsulating the
	312	* SignatureSpi implementation from the specified provider
	313	* is returned. The specified provider must be registered
	314	* in the security provider list.
	315	*
	316	* <p> Note that the list of registered providers may be retrieved via
	317	* the {@link Security#getProviders() Security.getProviders()} method.
	318	*
	319	* @param algorithm the name of the algorithm requested.
	320	* See the Signature section in the <a href=
	321	* "{@docRoot}/../technotes/guides/security/StandardNames.html#Signature">
	322	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	323	* for information about standard algorithm names.
	324	*
	325	* @param provider the name of the provider.
	326	*
	327	* @return the new Signature object.
	328	*
	329	* @exception NoSuchAlgorithmException if a SignatureSpi
	330	* implementation for the specified algorithm is not
	331	* available from the specified provider.
	332	*
	333	* @exception NoSuchProviderException if the specified provider is not
	334	* registered in the security provider list.
	335	*
	336	* @exception IllegalArgumentException if the provider name is null
	337	* or empty.
	338	*
	339	* @see Provider
	340	*/
	341	public static Signature getInstance(String algorithm, String provider)
	342	throws NoSuchAlgorithmException, NoSuchProviderException {
	343	if (algorithm.equalsIgnoreCase(RSA_SIGNATURE)) {
	344	// exception compatibility with existing code
	345	if ((provider == null) \|\| (provider.length() == 0)) {
	346	throw new IllegalArgumentException("missing provider");
	347	}
	348	Provider p = Security.getProvider(provider);
	349	if (p == null) {
	350	throw new NoSuchProviderException
	351	("no such provider: " + provider);
	352	}
	353	return getInstanceRSA(p);
	354	}
	355	Instance instance = GetInstance.getInstance
	356	("Signature", SignatureSpi.class, algorithm, provider);
	357	return getInstance(instance, algorithm);
	358	}
	359
	360	/**
	361	* Returns a Signature object that implements the specified
	362	* signature algorithm.
	363	*
	364	* <p> A new Signature object encapsulating the
	365	* SignatureSpi implementation from the specified Provider
	366	* object is returned. Note that the specified Provider object
	367	* does not have to be registered in the provider list.
	368	*
	369	* @param algorithm the name of the algorithm requested.
	370	* See the Signature section in the <a href=
	371	* "{@docRoot}/../technotes/guides/security/StandardNames.html#Signature">
	372	* Java Cryptography Architecture Standard Algorithm Name Documentation</a>
	373	* for information about standard algorithm names.
	374	*
	375	* @param provider the provider.
	376	*
	377	* @return the new Signature object.
	378	*
	379	* @exception NoSuchAlgorithmException if a SignatureSpi
	380	* implementation for the specified algorithm is not available
	381	* from the specified Provider object.
	382	*
	383	* @exception IllegalArgumentException if the provider is null.
	384	*
	385	* @see Provider
	386	*
	387	* @since 1.4
	388	*/
	389	public static Signature getInstance(String algorithm, Provider provider)
	390	throws NoSuchAlgorithmException {
	391	if (algorithm.equalsIgnoreCase(RSA_SIGNATURE)) {
	392	// exception compatibility with existing code
	393	if (provider == null) {
	394	throw new IllegalArgumentException("missing provider");
	395	}
	396	return getInstanceRSA(provider);
	397	}
	398	Instance instance = GetInstance.getInstance
	399	("Signature", SignatureSpi.class, algorithm, provider);
	400	return getInstance(instance, algorithm);
	401	}
	402
	403	// return an implementation for NONEwithRSA, which is a special case
	404	// because of the Cipher.RSA/ECB/PKCS1Padding compatibility wrapper
	405	private static Signature getInstanceRSA(Provider p)
	406	throws NoSuchAlgorithmException {
	407	// try Signature first
	408	Service s = p.getService("Signature", RSA_SIGNATURE);
	409	if (s != null) {
	410	Instance instance = GetInstance.getInstance(s, SignatureSpi.class);
	411	return getInstance(instance, RSA_SIGNATURE);
	412	}
	413	// check Cipher
	414	try {
	415	Cipher c = Cipher.getInstance(RSA_CIPHER, p);
	416	return new Delegate(new CipherAdapter(c), RSA_SIGNATURE);
	417	} catch (GeneralSecurityException e) {
	418	// throw Signature style exception message to avoid confusion,
	419	// but append Cipher exception as cause
	420	throw new NoSuchAlgorithmException("no such algorithm: "
	421	+ RSA_SIGNATURE + " for provider " + p.getName(), e);
	422	}
	423	}
	424
	425	/**
	426	* Returns the provider of this signature object.
	427	*
	428	* @return the provider of this signature object
	429	*/
	430	public final Provider getProvider() {
	431	chooseFirstProvider();
	432	return this.provider;
	433	}
	434
	435	void chooseFirstProvider() {
	436	// empty, overridden in Delegate
	437	}
	438
	439	/**
	440	* Initializes this object for verification. If this method is called
	441	* again with a different argument, it negates the effect
	442	* of this call.
	443	*
	444	* @param publicKey the public key of the identity whose signature is
	445	* going to be verified.
	446	*
	447	* @exception InvalidKeyException if the key is invalid.
	448	*/
	449	public final void initVerify(PublicKey publicKey)
	450	throws InvalidKeyException {
	451	engineInitVerify(publicKey);
	452	state = VERIFY;
	453	}
	454
	455	/**
	456	* Initializes this object for verification, using the public key from
	457	* the given certificate.
	458	* <p>If the certificate is of type X.509 and has a <i>key usage</i>
	459	* extension field marked as critical, and the value of the <i>key usage</i>
	460	* extension field implies that the public key in
	461	* the certificate and its corresponding private key are not
	462	* supposed to be used for digital signatures, an
	463	* <code>InvalidKeyException</code> is thrown.
	464	*
	465	* @param certificate the certificate of the identity whose signature is
	466	* going to be verified.
	467	*
	468	* @exception InvalidKeyException if the public key in the certificate
	469	* is not encoded properly or does not include required parameter
	470	* information or cannot be used for digital signature purposes.
	471	* @since 1.3
	472	*/
	473	public final void initVerify(Certificate certificate)
	474	throws InvalidKeyException {
	475	// If the certificate is of type X509Certificate,
	476	// we should check whether it has a Key Usage
	477	// extension marked as critical.
	478	if (certificate instanceof java.security.cert.X509Certificate) {
	479	// Check whether the cert has a key usage extension
	480	// marked as a critical extension.
	481	// The OID for KeyUsage extension is 2.5.29.15.
	482	X509Certificate cert = (X509Certificate)certificate;
	483	Set<String> critSet = cert.getCriticalExtensionOIDs();
	484
	485	if (critSet != null && !critSet.isEmpty()
	486	&& critSet.contains("2.5.29.15")) {
	487	boolean[] keyUsageInfo = cert.getKeyUsage();
	488	// keyUsageInfo[0] is for digitalSignature.
	489	if ((keyUsageInfo != null) && (keyUsageInfo[0] == false))
	490	throw new InvalidKeyException("Wrong key usage");
	491	}
	492	}
	493
	494	PublicKey publicKey = certificate.getPublicKey();
	495	engineInitVerify(publicKey);
	496	state = VERIFY;
	497	}
	498
	499	/**
	500	* Initialize this object for signing. If this method is called
	501	* again with a different argument, it negates the effect
	502	* of this call.
	503	*
	504	* @param privateKey the private key of the identity whose signature
	505	* is going to be generated.
	506	*
	507	* @exception InvalidKeyException if the key is invalid.
	508	*/
	509	public final void initSign(PrivateKey privateKey)
	510	throws InvalidKeyException {
	511	engineInitSign(privateKey);
	512	state = SIGN;
	513	}
	514
	515	/**
	516	* Initialize this object for signing. If this method is called
	517	* again with a different argument, it negates the effect
	518	* of this call.
	519	*
	520	* @param privateKey the private key of the identity whose signature
	521	* is going to be generated.
	522	*
	523	* @param random the source of randomness for this signature.
	524	*
	525	* @exception InvalidKeyException if the key is invalid.
	526	*/
	527	public final void initSign(PrivateKey privateKey, SecureRandom random)
	528	throws InvalidKeyException {
	529	engineInitSign(privateKey, random);
	530	state = SIGN;
	531	}
	532
	533	/**
	534	* Returns the signature bytes of all the data updated.
	535	* The format of the signature depends on the underlying
	536	* signature scheme.
	537	*
	538	* <p>A call to this method resets this signature object to the state
	539	* it was in when previously initialized for signing via a
	540	* call to <code>initSign(PrivateKey)</code>. That is, the object is
	541	* reset and available to generate another signature from the same
	542	* signer, if desired, via new calls to <code>update</code> and
	543	* <code>sign</code>.
	544	*
	545	* @return the signature bytes of the signing operation's result.
	546	*
	547	* @exception SignatureException if this signature object is not
	548	* initialized properly or if this signature algorithm is unable to
	549	* process the input data provided.
	550	*/
	551	public final byte[] sign() throws SignatureException {
	552	if (state == SIGN) {
	553	return engineSign();
	554	}
	555	throw new SignatureException("object not initialized for " +
	556	"signing");
	557	}
	558
	559	/**
	560	* Finishes the signature operation and stores the resulting signature
	561	* bytes in the provided buffer <code>outbuf</code>, starting at
	562	* <code>offset</code>.
	563	* The format of the signature depends on the underlying
	564	* signature scheme.
	565	*
	566	* <p>This signature object is reset to its initial state (the state it
	567	* was in after a call to one of the <code>initSign</code> methods) and
	568	* can be reused to generate further signatures with the same private key.
	569	*
	570	* @param outbuf buffer for the signature result.
	571	*
	572	* @param offset offset into <code>outbuf</code> where the signature is
	573	* stored.
	574	*
	575	* @param len number of bytes within <code>outbuf</code> allotted for the
	576	* signature.
	577	*
	578	* @return the number of bytes placed into <code>outbuf</code>.
	579	*
	580	* @exception SignatureException if this signature object is not
	581	* initialized properly, if this signature algorithm is unable to
	582	* process the input data provided, or if <code>len</code> is less
	583	* than the actual signature length.
	584	*
	585	* @since 1.2
	586	*/
	587	public final int sign(byte[] outbuf, int offset, int len)
	588	throws SignatureException {
	589	if (outbuf == null) {
	590	throw new IllegalArgumentException("No output buffer given");
	591	}
	592	if (outbuf.length - offset < len) {
	593	throw new IllegalArgumentException
	594	("Output buffer too small for specified offset and length");
	595	}
	596	if (state != SIGN) {
	597	throw new SignatureException("object not initialized for " +
	598	"signing");
	599	}
	600	return engineSign(outbuf, offset, len);
	601	}
	602
	603	/**
	604	* Verifies the passed-in signature.
	605	*
	606	* <p>A call to this method resets this signature object to the state
	607	* it was in when previously initialized for verification via a
	608	* call to <code>initVerify(PublicKey)</code>. That is, the object is
	609	* reset and available to verify another signature from the identity
	610	* whose public key was specified in the call to <code>initVerify</code>.
	611	*
	612	* @param signature the signature bytes to be verified.
	613	*
	614	* @return true if the signature was verified, false if not.
	615	*
	616	* @exception SignatureException if this signature object is not
	617	* initialized properly, the passed-in signature is improperly
	618	* encoded or of the wrong type, if this signature algorithm is unable to
	619	* process the input data provided, etc.
	620	*/
	621	public final boolean verify(byte[] signature) throws SignatureException {
	622	if (state == VERIFY) {
	623	return engineVerify(signature);
	624	}
	625	throw new SignatureException("object not initialized for " +
	626	"verification");
	627	}
	628
	629	/**
	630	* Verifies the passed-in signature in the specified array
	631	* of bytes, starting at the specified offset.
	632	*
	633	* <p>A call to this method resets this signature object to the state
	634	* it was in when previously initialized for verification via a
	635	* call to <code>initVerify(PublicKey)</code>. That is, the object is
	636	* reset and available to verify another signature from the identity
	637	* whose public key was specified in the call to <code>initVerify</code>.
	638	*
	639	*
	640	* @param signature the signature bytes to be verified.
	641	* @param offset the offset to start from in the array of bytes.
	642	* @param length the number of bytes to use, starting at offset.
	643	*
	644	* @return true if the signature was verified, false if not.
	645	*
	646	* @exception SignatureException if this signature object is not
	647	* initialized properly, the passed-in signature is improperly
	648	* encoded or of the wrong type, if this signature algorithm is unable to
	649	* process the input data provided, etc.
	650	* @exception IllegalArgumentException if the <code>signature</code>
	651	* byte array is null, or the <code>offset</code> or <code>length</code>
	652	* is less than 0, or the sum of the <code>offset</code> and
	653	* <code>length</code> is greater than the length of the
	654	* <code>signature</code> byte array.
	655	* @since 1.4
	656	*/
	657	public final boolean verify(byte[] signature, int offset, int length)
	658	throws SignatureException {
	659	if (state == VERIFY) {
	660	if ((signature == null) \|\| (offset < 0) \|\| (length < 0) \|\|
	661	(offset + length > signature.length)) {
	662	throw new IllegalArgumentException("Bad arguments");
	663	}
	664
	665	return engineVerify(signature, offset, length);
	666	}
	667	throw new SignatureException("object not initialized for " +
	668	"verification");
	669	}
	670
	671	/**
	672	* Updates the data to be signed or verified by a byte.
	673	*
	674	* @param b the byte to use for the update.
	675	*
	676	* @exception SignatureException if this signature object is not
	677	* initialized properly.
	678	*/
	679	public final void update(byte b) throws SignatureException {
	680	if (state == VERIFY \|\| state == SIGN) {
	681	engineUpdate(b);
	682	} else {
	683	throw new SignatureException("object not initialized for "
	684	+ "signature or verification");
	685	}
	686	}
	687
	688	/**
	689	* Updates the data to be signed or verified, using the specified
	690	* array of bytes.
	691	*
	692	* @param data the byte array to use for the update.
	693	*
	694	* @exception SignatureException if this signature object is not
	695	* initialized properly.
	696	*/
	697	public final void update(byte[] data) throws SignatureException {
	698	update(data, 0, data.length);
	699	}
	700
	701	/**
	702	* Updates the data to be signed or verified, using the specified
	703	* array of bytes, starting at the specified offset.
	704	*
	705	* @param data the array of bytes.
	706	* @param off the offset to start from in the array of bytes.
	707	* @param len the number of bytes to use, starting at offset.
	708	*
	709	* @exception SignatureException if this signature object is not
	710	* initialized properly.
	711	*/
	712	public final void update(byte[] data, int off, int len)
	713	throws SignatureException {
	714	if (state == SIGN \|\| state == VERIFY) {
	715	engineUpdate(data, off, len);
	716	} else {
	717	throw new SignatureException("object not initialized for "
	718	+ "signature or verification");
	719	}
	720	}
	721
	722	/**
	723	* Updates the data to be signed or verified using the specified
	724	* ByteBuffer. Processes the <code>data.remaining()</code> bytes
	725	* starting at at <code>data.position()</code>.
	726	* Upon return, the buffer's position will be equal to its limit;
	727	* its limit will not have changed.
	728	*
	729	* @param data the ByteBuffer
	730	*
	731	* @exception SignatureException if this signature object is not
	732	* initialized properly.
	733	* @since 1.5
	734	*/
	735	public final void update(ByteBuffer data) throws SignatureException {
	736	if ((state != SIGN) && (state != VERIFY)) {
	737	throw new SignatureException("object not initialized for "
	738	+ "signature or verification");
	739	}
	740	if (data == null) {
	741	throw new NullPointerException();
	742	}
	743	engineUpdate(data);
	744	}
	745
	746	/**
	747	* Returns the name of the algorithm for this signature object.
	748	*
	749	* @return the name of the algorithm for this signature object.
	750	*/
	751	public final String getAlgorithm() {
	752	return this.algorithm;
	753	}
	754
	755	/**
	756	* Returns a string representation of this signature object,
	757	* providing information that includes the state of the object
	758	* and the name of the algorithm used.
	759	*
	760	* @return a string representation of this signature object.
	761	*/
	762	public String toString() {
	763	String initState = "";
	764	switch (state) {
	765	case UNINITIALIZED:
	766	initState = "<not initialized>";
	767	break;
	768	case VERIFY:
	769	initState = "<initialized for verifying>";
	770	break;
	771	case SIGN:
	772	initState = "<initialized for signing>";
	773	break;
	774	}
	775	return "Signature object: " + getAlgorithm() + initState;
	776	}
	777
	778	/**
	779	* Sets the specified algorithm parameter to the specified value.
	780	* This method supplies a general-purpose mechanism through
	781	* which it is possible to set the various parameters of this object.
	782	* A parameter may be any settable parameter for the algorithm, such as
	783	* a parameter size, or a source of random bits for signature generation
	784	* (if appropriate), or an indication of whether or not to perform
	785	* a specific but optional computation. A uniform algorithm-specific
	786	* naming scheme for each parameter is desirable but left unspecified
	787	* at this time.
	788	*
	789	* @param param the string identifier of the parameter.
	790	* @param value the parameter value.
	791	*
	792	* @exception InvalidParameterException if <code>param</code> is an
	793	* invalid parameter for this signature algorithm engine,
	794	* the parameter is already set
	795	* and cannot be set again, a security exception occurs, and so on.
	796	*
	797	* @see #getParameter
	798	*
	799	* @deprecated Use
	800	* {@link #setParameter(java.security.spec.AlgorithmParameterSpec)
	801	* setParameter}.
	802	*/
	803	@Deprecated
	804	public final void setParameter(String param, Object value)
	805	throws InvalidParameterException {
	806	engineSetParameter(param, value);
	807	}
	808
	809	/**
	810	* Initializes this signature engine with the specified parameter set.
	811	*
	812	* @param params the parameters
	813	*
	814	* @exception InvalidAlgorithmParameterException if the given parameters
	815	* are inappropriate for this signature engine
	816	*
	817	* @see #getParameters
	818	*/
	819	public final void setParameter(AlgorithmParameterSpec params)
	820	throws InvalidAlgorithmParameterException {
	821	engineSetParameter(params);
	822	}
	823
	824	/**
	825	* Returns the parameters used with this signature object.
	826	*
	827	* <p>The returned parameters may be the same that were used to initialize
	828	* this signature, or may contain a combination of default and randomly
	829	* generated parameter values used by the underlying signature
	830	* implementation if this signature requires algorithm parameters but
	831	* was not initialized with any.
	832	*
	833	* @return the parameters used with this signature, or null if this
	834	* signature does not use any parameters.
	835	*
	836	* @see #setParameter(AlgorithmParameterSpec)
	837	* @since 1.4
	838	*/
	839	public final AlgorithmParameters getParameters() {
	840	return engineGetParameters();
	841	}
	842
	843	/**
	844	* Gets the value of the specified algorithm parameter. This method
	845	* supplies a general-purpose mechanism through which it is possible to
	846	* get the various parameters of this object. A parameter may be any
	847	* settable parameter for the algorithm, such as a parameter size, or
	848	* a source of random bits for signature generation (if appropriate),
	849	* or an indication of whether or not to perform a specific but optional
	850	* computation. A uniform algorithm-specific naming scheme for each
	851	* parameter is desirable but left unspecified at this time.
	852	*
	853	* @param param the string name of the parameter.
	854	*
	855	* @return the object that represents the parameter value, or null if
	856	* there is none.
	857	*
	858	* @exception InvalidParameterException if <code>param</code> is an invalid
	859	* parameter for this engine, or another exception occurs while
	860	* trying to get this parameter.
	861	*
	862	* @see #setParameter(String, Object)
	863	*
	864	* @deprecated
	865	*/
	866	@Deprecated
	867	public final Object getParameter(String param)
	868	throws InvalidParameterException {
	869	return engineGetParameter(param);
	870	}
	871
	872	/**
	873	* Returns a clone if the implementation is cloneable.
	874	*
	875	* @return a clone if the implementation is cloneable.
	876	*
	877	* @exception CloneNotSupportedException if this is called
	878	* on an implementation that does not support <code>Cloneable</code>.
	879	*/
	880	public Object clone() throws CloneNotSupportedException {
	881	if (this instanceof Cloneable) {
	882	return super.clone();
	883	} else {
	884	throw new CloneNotSupportedException();
	885	}
	886	}
	887
	888	/*
	889	* The following class allows providers to extend from SignatureSpi
	890	* rather than from Signature. It represents a Signature with an
	891	* encapsulated, provider-supplied SPI object (of type SignatureSpi).
	892	* If the provider implementation is an instance of SignatureSpi, the
	893	* getInstance() methods above return an instance of this class, with
	894	* the SPI object encapsulated.
	895	*
	896	* Note: All SPI methods from the original Signature class have been
	897	* moved up the hierarchy into a new class (SignatureSpi), which has
	898	* been interposed in the hierarchy between the API (Signature)
	899	* and its original parent (Object).
	900	*/
	901
	902	private static class Delegate extends Signature {
	903
	904	// The provider implementation (delegate)
	905	// filled in once the provider is selected
	906	private SignatureSpi sigSpi;
	907
	908	// lock for mutex during provider selection
	909	private final Object lock;
	910
	911	// next service to try in provider selection
	912	// null once provider is selected
	913	private Service firstService;
	914
	915	// remaining services to try in provider selection
	916	// null once provider is selected
	917	private Iterator<Service> serviceIterator;
	918
	919	// constructor
	920	Delegate(SignatureSpi sigSpi, String algorithm) {
	921	super(algorithm);
	922	this.sigSpi = sigSpi;
	923	this.lock = null; // no lock needed
	924	}
	925
	926	// used with delayed provider selection
	927	Delegate(Service service,
	928	Iterator<Service> iterator, String algorithm) {
	929	super(algorithm);
	930	this.firstService = service;
	931	this.serviceIterator = iterator;
	932	this.lock = new Object();
	933	}
	934
	935	/**
	936	* Returns a clone if the delegate is cloneable.
	937	*
	938	* @return a clone if the delegate is cloneable.
	939	*
	940	* @exception CloneNotSupportedException if this is called on a
	941	* delegate that does not support <code>Cloneable</code>.
	942	*/
	943	public Object clone() throws CloneNotSupportedException {
	944	chooseFirstProvider();
	945	if (sigSpi instanceof Cloneable) {
	946	SignatureSpi sigSpiClone = (SignatureSpi)sigSpi.clone();
	947	// Because 'algorithm' and 'provider' are private
	948	// members of our supertype, we must perform a cast to
	949	// access them.
	950	Signature that =
	951	new Delegate(sigSpiClone, ((Signature)this).algorithm);
	952	that.provider = ((Signature)this).provider;
	953	return that;
	954	} else {
	955	throw new CloneNotSupportedException();
	956	}
	957	}
	958
	959	private static SignatureSpi newInstance(Service s)
	960	throws NoSuchAlgorithmException {
	961	if (s.getType().equals("Cipher")) {
	962	// must be NONEwithRSA
	963	try {
	964	Cipher c = Cipher.getInstance(RSA_CIPHER, s.getProvider());
	965	return new CipherAdapter(c);
	966	} catch (NoSuchPaddingException e) {
	967	throw new NoSuchAlgorithmException(e);
	968	}
	969	} else {
	970	Object o = s.newInstance(null);
	971	if (o instanceof SignatureSpi == false) {
	972	throw new NoSuchAlgorithmException
	973	("Not a SignatureSpi: " + o.getClass().getName());
	974	}
	975	return (SignatureSpi)o;
	976	}
	977	}
	978
	979	// max number of debug warnings to print from chooseFirstProvider()
	980	private static int warnCount = 10;
	981
	982	/**
	983	* Choose the Spi from the first provider available. Used if
	984	* delayed provider selection is not possible because initSign()/
	985	* initVerify() is not the first method called.
	986	*/
	987	void chooseFirstProvider() {
	988	if (sigSpi != null) {
	989	return;
	990	}
	991	synchronized (lock) {
	992	if (sigSpi != null) {
	993	return;
	994	}
	995	if (debug != null) {
	996	int w = --warnCount;
	997	if (w >= 0) {
	998	debug.println("Signature.init() not first method "
	999	+ "called, disabling delayed provider selection");
	1000	if (w == 0) {
	1001	debug.println("Further warnings of this type will "
	1002	+ "be suppressed");
	1003	}
	1004	new Exception("Call trace").printStackTrace();
	1005	}
	1006	}
	1007	Exception lastException = null;
	1008	while ((firstService != null) \|\| serviceIterator.hasNext()) {
	1009	Service s;
	1010	if (firstService != null) {
	1011	s = firstService;
	1012	firstService = null;
	1013	} else {
	1014	s = serviceIterator.next();
	1015	}
	1016	if (isSpi(s) == false) {
	1017	continue;
	1018	}
	1019	try {
	1020	sigSpi = newInstance(s);
	1021	provider = s.getProvider();
	1022	// not needed any more
	1023	firstService = null;
	1024	serviceIterator = null;
	1025	return;
	1026	} catch (NoSuchAlgorithmException e) {
	1027	lastException = e;
	1028	}
	1029	}
	1030	ProviderException e = new ProviderException
	1031	("Could not construct SignatureSpi instance");
	1032	if (lastException != null) {
	1033	e.initCause(lastException);
	1034	}
	1035	throw e;
	1036	}
	1037	}
	1038
	1039	private void chooseProvider(int type, Key key, SecureRandom random)
	1040	throws InvalidKeyException {
	1041	synchronized (lock) {
	1042	if (sigSpi != null) {
	1043	init(sigSpi, type, key, random);
	1044	return;
	1045	}
	1046	Exception lastException = null;
	1047	while ((firstService != null) \|\| serviceIterator.hasNext()) {
	1048	Service s;
	1049	if (firstService != null) {
	1050	s = firstService;
	1051	firstService = null;
	1052	} else {
	1053	s = serviceIterator.next();
	1054	}
	1055	// if provider says it does not support this key, ignore it
	1056	if (s.supportsParameter(key) == false) {
	1057	continue;
	1058	}
	1059	// if instance is not a SignatureSpi, ignore it
	1060	if (isSpi(s) == false) {
	1061	continue;
	1062	}
	1063	try {
	1064	SignatureSpi spi = newInstance(s);
	1065	init(spi, type, key, random);
	1066	provider = s.getProvider();
	1067	sigSpi = spi;
	1068	firstService = null;
	1069	serviceIterator = null;
	1070	return;
	1071	} catch (Exception e) {
	1072	// NoSuchAlgorithmException from newInstance()
	1073	// InvalidKeyException from init()
	1074	// RuntimeException (ProviderException) from init()
	1075	if (lastException == null) {
	1076	lastException = e;
	1077	}
	1078	}
	1079	}
	1080	// no working provider found, fail
	1081	if (lastException instanceof InvalidKeyException) {
	1082	throw (InvalidKeyException)lastException;
	1083	}
	1084	if (lastException instanceof RuntimeException) {
	1085	throw (RuntimeException)lastException;
	1086	}
	1087	String k = (key != null) ? key.getClass().getName() : "(null)";
	1088	throw new InvalidKeyException
	1089	("No installed provider supports this key: "
	1090	+ k, lastException);
	1091	}
	1092	}
	1093
	1094	private final static int I_PUB = 1;
	1095	private final static int I_PRIV = 2;
	1096	private final static int I_PRIV_SR = 3;
	1097
	1098	private void init(SignatureSpi spi, int type, Key key,
	1099	SecureRandom random) throws InvalidKeyException {
	1100	switch (type) {
	1101	case I_PUB:
	1102	spi.engineInitVerify((PublicKey)key);
	1103	break;
	1104	case I_PRIV:
	1105	spi.engineInitSign((PrivateKey)key);
	1106	break;
	1107	case I_PRIV_SR:
	1108	spi.engineInitSign((PrivateKey)key, random);
	1109	break;
	1110	default:
	1111	throw new AssertionError("Internal error: " + type);
	1112	}
	1113	}
	1114
	1115	protected void engineInitVerify(PublicKey publicKey)
	1116	throws InvalidKeyException {
	1117	if (sigSpi != null) {
	1118	sigSpi.engineInitVerify(publicKey);
	1119	} else {
	1120	chooseProvider(I_PUB, publicKey, null);
	1121	}
	1122	}
	1123
	1124	protected void engineInitSign(PrivateKey privateKey)
	1125	throws InvalidKeyException {
	1126	if (sigSpi != null) {
	1127	sigSpi.engineInitSign(privateKey);
	1128	} else {
	1129	chooseProvider(I_PRIV, privateKey, null);
	1130	}
	1131	}
	1132
	1133	protected void engineInitSign(PrivateKey privateKey, SecureRandom sr)
	1134	throws InvalidKeyException {
	1135	if (sigSpi != null) {
	1136	sigSpi.engineInitSign(privateKey, sr);
	1137	} else {
	1138	chooseProvider(I_PRIV_SR, privateKey, sr);
	1139	}
	1140	}
	1141
	1142	protected void engineUpdate(byte b) throws SignatureException {
	1143	chooseFirstProvider();
	1144	sigSpi.engineUpdate(b);
	1145	}
	1146
	1147	protected void engineUpdate(byte[] b, int off, int len)
	1148	throws SignatureException {
	1149	chooseFirstProvider();
	1150	sigSpi.engineUpdate(b, off, len);
	1151	}
	1152
	1153	protected void engineUpdate(ByteBuffer data) {
	1154	chooseFirstProvider();
	1155	sigSpi.engineUpdate(data);
	1156	}
	1157
	1158	protected byte[] engineSign() throws SignatureException {
	1159	chooseFirstProvider();
	1160	return sigSpi.engineSign();
	1161	}
	1162
	1163	protected int engineSign(byte[] outbuf, int offset, int len)
	1164	throws SignatureException {
	1165	chooseFirstProvider();
	1166	return sigSpi.engineSign(outbuf, offset, len);
	1167	}
	1168
	1169	protected boolean engineVerify(byte[] sigBytes)
	1170	throws SignatureException {
	1171	chooseFirstProvider();
	1172	return sigSpi.engineVerify(sigBytes);
	1173	}
	1174
	1175	protected boolean engineVerify(byte[] sigBytes, int offset, int length)
	1176	throws SignatureException {
	1177	chooseFirstProvider();
	1178	return sigSpi.engineVerify(sigBytes, offset, length);
	1179	}
	1180
	1181	protected void engineSetParameter(String param, Object value)
	1182	throws InvalidParameterException {
	1183	chooseFirstProvider();
	1184	sigSpi.engineSetParameter(param, value);
	1185	}
	1186
	1187	protected void engineSetParameter(AlgorithmParameterSpec params)
	1188	throws InvalidAlgorithmParameterException {
	1189	chooseFirstProvider();
	1190	sigSpi.engineSetParameter(params);
	1191	}
	1192
	1193	protected Object engineGetParameter(String param)
	1194	throws InvalidParameterException {
	1195	chooseFirstProvider();
	1196	return sigSpi.engineGetParameter(param);
	1197	}
	1198
	1199	protected AlgorithmParameters engineGetParameters() {
	1200	chooseFirstProvider();
	1201	return sigSpi.engineGetParameters();
	1202	}
	1203	}
	1204
	1205	// adapter for RSA/ECB/PKCS1Padding ciphers
	1206	private static class CipherAdapter extends SignatureSpi {
	1207
	1208	private final Cipher cipher;
	1209
	1210	private ByteArrayOutputStream data;
	1211
	1212	CipherAdapter(Cipher cipher) {
	1213	this.cipher = cipher;
	1214	}
	1215
	1216	protected void engineInitVerify(PublicKey publicKey)
	1217	throws InvalidKeyException {
	1218	cipher.init(Cipher.DECRYPT_MODE, publicKey);
	1219	if (data == null) {
	1220	data = new ByteArrayOutputStream(128);
	1221	} else {
	1222	data.reset();
	1223	}
	1224	}
	1225
	1226	protected void engineInitSign(PrivateKey privateKey)
	1227	throws InvalidKeyException {
	1228	cipher.init(Cipher.ENCRYPT_MODE, privateKey);
	1229	data = null;
	1230	}
	1231
	1232	protected void engineInitSign(PrivateKey privateKey,
	1233	SecureRandom random) throws InvalidKeyException {
	1234	cipher.init(Cipher.ENCRYPT_MODE, privateKey, random);
	1235	data = null;
	1236	}
	1237
	1238	protected void engineUpdate(byte b) throws SignatureException {
	1239	engineUpdate(new byte[] {b}, 0, 1);
	1240	}
	1241
	1242	protected void engineUpdate(byte[] b, int off, int len)
	1243	throws SignatureException {
	1244	if (data != null) {
	1245	data.write(b, off, len);
	1246	return;
	1247	}
	1248	byte[] out = cipher.update(b, off, len);
	1249	if ((out != null) && (out.length != 0)) {
	1250	throw new SignatureException
	1251	("Cipher unexpectedly returned data");
	1252	}
	1253	}
	1254
	1255	protected byte[] engineSign() throws SignatureException {
	1256	try {
	1257	return cipher.doFinal();
	1258	} catch (IllegalBlockSizeException e) {
	1259	throw new SignatureException("doFinal() failed", e);
	1260	} catch (BadPaddingException e) {
	1261	throw new SignatureException("doFinal() failed", e);
	1262	}
	1263	}
	1264
	1265	protected boolean engineVerify(byte[] sigBytes)
	1266	throws SignatureException {
	1267	try {
	1268	byte[] out = cipher.doFinal(sigBytes);
	1269	byte[] dataBytes = data.toByteArray();
	1270	data.reset();
	1271	return Arrays.equals(out, dataBytes);
	1272	} catch (BadPaddingException e) {
	1273	// e.g. wrong public key used
	1274	// return false rather than throwing exception
	1275	return false;
	1276	} catch (IllegalBlockSizeException e) {
	1277	throw new SignatureException("doFinal() failed", e);
	1278	}
	1279	}
	1280
	1281	protected void engineSetParameter(String param, Object value)
	1282	throws InvalidParameterException {
	1283	throw new InvalidParameterException("Parameters not supported");
	1284	}
	1285
	1286	protected Object engineGetParameter(String param)
	1287	throws InvalidParameterException {
	1288	throw new InvalidParameterException("Parameters not supported");
	1289	}
	1290
	1291	}
	1292
	1293	}

java/pkg/java/security/SignatureException.class+0−0

Binary file not shown.

java/pkg/java/security/SignatureException.java+87−0

@@ -0,0 +1,87 @@
	1	/*
	2	* Copyright (c) 1996, 2003, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	/**
	29	* This is the generic Signature exception.
	30	*
	31	* @author Benjamin Renaud
	32	*/
	33
	34	public class SignatureException extends GeneralSecurityException {
	35
	36	private static final long serialVersionUID = 7509989324975124438L;
	37
	38	/**
	39	* Constructs a SignatureException with no detail message. A
	40	* detail message is a String that describes this particular
	41	* exception.
	42	*/
	43	public SignatureException() {
	44	super();
	45	}
	46
	47	/**
	48	* Constructs a SignatureException with the specified detail
	49	* message. A detail message is a String that describes this
	50	* particular exception.
	51	*
	52	* @param msg the detail message.
	53	*/
	54	public SignatureException(String msg) {
	55	super(msg);
	56	}
	57
	58	/**
	59	* Creates a <code>SignatureException</code> with the specified
	60	* detail message and cause.
	61	*
	62	* @param message the detail message (which is saved for later retrieval
	63	* by the {@link #getMessage()} method).
	64	* @param cause the cause (which is saved for later retrieval by the
	65	* {@link #getCause()} method). (A <tt>null</tt> value is permitted,
	66	* and indicates that the cause is nonexistent or unknown.)
	67	* @since 1.5
	68	*/
	69	public SignatureException(String message, Throwable cause) {
	70	super(message, cause);
	71	}
	72
	73	/**
	74	* Creates a <code>SignatureException</code> with the specified cause
	75	* and a detail message of <tt>(cause==null ? null : cause.toString())</tt>
	76	* (which typically contains the class and detail message of
	77	* <tt>cause</tt>).
	78	*
	79	* @param cause the cause (which is saved for later retrieval by the
	80	* {@link #getCause()} method). (A <tt>null</tt> value is permitted,
	81	* and indicates that the cause is nonexistent or unknown.)
	82	* @since 1.5
	83	*/
	84	public SignatureException(Throwable cause) {
	85	super(cause);
	86	}
	87	}

java/pkg/java/security/SignatureSpi.class+0−0

Binary file not shown.

java/pkg/java/security/SignatureSpi.java+390−0

@@ -0,0 +1,390 @@
	1	/*
	2	* Copyright (c) 1997, 2006, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.security;
	27
	28	import java.security.spec.AlgorithmParameterSpec;
	29	import java.util.*;
	30	import java.io.*;
	31
	32	import java.nio.ByteBuffer;
	33
	34	import sun.security.jca.JCAUtil;
	35
	36	/**
	37	* This class defines the <i>Service Provider Interface</i> (<b>SPI</b>)
	38	* for the <code>Signature</code> class, which is used to provide the
	39	* functionality of a digital signature algorithm. Digital signatures are used
	40	* for authentication and integrity assurance of digital data.
	41	*.
	42	* <p> All the abstract methods in this class must be implemented by each
	43	* cryptographic service provider who wishes to supply the implementation
	44	* of a particular signature algorithm.
	45	*
	46	* @author Benjamin Renaud
	47	*
	48	*
	49	* @see Signature
	50	*/
	51
	52	public abstract class SignatureSpi {
	53
	54	/**
	55	* Application-specified source of randomness.
	56	*/
	57	protected SecureRandom appRandom = null;
	58
	59	/**
	60	* Initializes this signature object with the specified
	61	* public key for verification operations.
	62	*
	63	* @param publicKey the public key of the identity whose signature is
	64	* going to be verified.
	65	*
	66	* @exception InvalidKeyException if the key is improperly
	67	* encoded, parameters are missing, and so on.
	68	*/
	69	protected abstract void engineInitVerify(PublicKey publicKey)
	70	throws InvalidKeyException;
	71
	72	/**
	73	* Initializes this signature object with the specified
	74	* private key for signing operations.
	75	*
	76	* @param privateKey the private key of the identity whose signature
	77	* will be generated.
	78	*
	79	* @exception InvalidKeyException if the key is improperly
	80	* encoded, parameters are missing, and so on.
	81	*/
	82	protected abstract void engineInitSign(PrivateKey privateKey)
	83	throws InvalidKeyException;
	84
	85	/**
	86	* Initializes this signature object with the specified
	87	* private key and source of randomness for signing operations.
	88	*
	89	* <p>This concrete method has been added to this previously-defined
	90	* abstract class. (For backwards compatibility, it cannot be abstract.)
	91	*
	92	* @param privateKey the private key of the identity whose signature
	93	* will be generated.
	94	* @param random the source of randomness
	95	*
	96	* @exception InvalidKeyException if the key is improperly
	97	* encoded, parameters are missing, and so on.
	98	*/
	99	protected void engineInitSign(PrivateKey privateKey,
	100	SecureRandom random)
	101	throws InvalidKeyException {
	102	this.appRandom = random;
	103	engineInitSign(privateKey);
	104	}
	105
	106	/**
	107	* Updates the data to be signed or verified
	108	* using the specified byte.
	109	*
	110	* @param b the byte to use for the update.
	111	*
	112	* @exception SignatureException if the engine is not initialized
	113	* properly.
	114	*/
	115	protected abstract void engineUpdate(byte b) throws SignatureException;
	116
	117	/**
	118	* Updates the data to be signed or verified, using the
	119	* specified array of bytes, starting at the specified offset.
	120	*
	121	* @param b the array of bytes
	122	* @param off the offset to start from in the array of bytes
	123	* @param len the number of bytes to use, starting at offset
	124	*
	125	* @exception SignatureException if the engine is not initialized
	126	* properly
	127	*/
	128	protected abstract void engineUpdate(byte[] b, int off, int len)
	129	throws SignatureException;
	130
	131	/**
	132	* Updates the data to be signed or verified using the specified
	133	* ByteBuffer. Processes the <code>data.remaining()</code> bytes
	134	* starting at at <code>data.position()</code>.
	135	* Upon return, the buffer's position will be equal to its limit;
	136	* its limit will not have changed.
	137	*
	138	* @param input the ByteBuffer
	139	* @since 1.5
	140	*/
	141	protected void engineUpdate(ByteBuffer input) {
	142	if (input.hasRemaining() == false) {
	143	return;
	144	}
	145	try {
	146	if (input.hasArray()) {
	147	byte[] b = input.array();
	148	int ofs = input.arrayOffset();
	149	int pos = input.position();
	150	int lim = input.limit();
	151	engineUpdate(b, ofs + pos, lim - pos);
	152	input.position(lim);
	153	} else {
	154	int len = input.remaining();
	155	byte[] b = new byte[JCAUtil.getTempArraySize(len)];
	156	while (len > 0) {
	157	int chunk = Math.min(len, b.length);
	158	input.get(b, 0, chunk);
	159	engineUpdate(b, 0, chunk);
	160	len -= chunk;
	161	}
	162	}
	163	} catch (SignatureException e) {
	164	// is specified to only occur when the engine is not initialized
	165	// this case should never occur as it is caught in Signature.java
	166	throw new ProviderException("update() failed", e);
	167	}
	168	}
	169
	170	/**
	171	* Returns the signature bytes of all the data
	172	* updated so far.
	173	* The format of the signature depends on the underlying
	174	* signature scheme.
	175	*
	176	* @return the signature bytes of the signing operation's result.
	177	*
	178	* @exception SignatureException if the engine is not
	179	* initialized properly or if this signature algorithm is unable to
	180	* process the input data provided.
	181	*/
	182	protected abstract byte[] engineSign() throws SignatureException;
	183
	184	/**
	185	* Finishes this signature operation and stores the resulting signature
	186	* bytes in the provided buffer <code>outbuf</code>, starting at
	187	* <code>offset</code>.
	188	* The format of the signature depends on the underlying
	189	* signature scheme.
	190	*
	191	* <p>The signature implementation is reset to its initial state
	192	* (the state it was in after a call to one of the
	193	* <code>engineInitSign</code> methods)
	194	* and can be reused to generate further signatures with the same private
	195	* key.
	196	*
	197	* This method should be abstract, but we leave it concrete for
	198	* binary compatibility. Knowledgeable providers should override this
	199	* method.
	200	*
	201	* @param outbuf buffer for the signature result.
	202	*
	203	* @param offset offset into <code>outbuf</code> where the signature is
	204	* stored.
	205	*
	206	* @param len number of bytes within <code>outbuf</code> allotted for the
	207	* signature.
	208	* Both this default implementation and the SUN provider do not
	209	* return partial digests. If the value of this parameter is less
	210	* than the actual signature length, this method will throw a
	211	* SignatureException.
	212	* This parameter is ignored if its value is greater than or equal to
	213	* the actual signature length.
	214	*
	215	* @return the number of bytes placed into <code>outbuf</code>
	216	*
	217	* @exception SignatureException if the engine is not
	218	* initialized properly, if this signature algorithm is unable to
	219	* process the input data provided, or if <code>len</code> is less
	220	* than the actual signature length.
	221	*
	222	* @since 1.2
	223	*/
	224	protected int engineSign(byte[] outbuf, int offset, int len)
	225	throws SignatureException {
	226	byte[] sig = engineSign();
	227	if (len < sig.length) {
	228	throw new SignatureException
	229	("partial signatures not returned");
	230	}
	231	if (outbuf.length - offset < sig.length) {
	232	throw new SignatureException
	233	("insufficient space in the output buffer to store the "
	234	+ "signature");
	235	}
	236	System.arraycopy(sig, 0, outbuf, offset, sig.length);
	237	return sig.length;
	238	}
	239
	240	/**
	241	* Verifies the passed-in signature.
	242	*
	243	* @param sigBytes the signature bytes to be verified.
	244	*
	245	* @return true if the signature was verified, false if not.
	246	*
	247	* @exception SignatureException if the engine is not
	248	* initialized properly, the passed-in signature is improperly
	249	* encoded or of the wrong type, if this signature algorithm is unable to
	250	* process the input data provided, etc.
	251	*/
	252	protected abstract boolean engineVerify(byte[] sigBytes)
	253	throws SignatureException;
	254
	255	/**
	256	* Verifies the passed-in signature in the specified array
	257	* of bytes, starting at the specified offset.
	258	*
	259	* <p> Note: Subclasses should overwrite the default implementation.
	260	*
	261	*
	262	* @param sigBytes the signature bytes to be verified.
	263	* @param offset the offset to start from in the array of bytes.
	264	* @param length the number of bytes to use, starting at offset.
	265	*
	266	* @return true if the signature was verified, false if not.
	267	*
	268	* @exception SignatureException if the engine is not
	269	* initialized properly, the passed-in signature is improperly
	270	* encoded or of the wrong type, if this signature algorithm is unable to
	271	* process the input data provided, etc.
	272	* @since 1.4
	273	*/
	274	protected boolean engineVerify(byte[] sigBytes, int offset, int length)
	275	throws SignatureException {
	276	byte[] sigBytesCopy = new byte[length];
	277	System.arraycopy(sigBytes, offset, sigBytesCopy, 0, length);
	278	return engineVerify(sigBytesCopy);
	279	}
	280
	281	/**
	282	* Sets the specified algorithm parameter to the specified
	283	* value. This method supplies a general-purpose mechanism through
	284	* which it is possible to set the various parameters of this object.
	285	* A parameter may be any settable parameter for the algorithm, such as
	286	* a parameter size, or a source of random bits for signature generation

104 more lines aren’t shown here.

java/pkg/java/security/SignedObject.class+0−0

Binary file not shown.

java/pkg/java/security/SignedObject.java+258−0

This diff is large: its 259 lines aren’t shown here.

java/pkg/java/security/Signer$1.class+0−0

Binary file not shown.

java/pkg/java/security/Signer.class+0−0

Binary file not shown.

java/pkg/java/security/Signer.java+183−0

This diff is large: its 184 lines aren’t shown here.

java/pkg/java/security/Timestamp.class+0−0

Binary file not shown.

java/pkg/java/security/Timestamp.java+164−0

This diff is large: its 165 lines aren’t shown here.

java/pkg/java/security/URIParameter.class+0−0

Binary file not shown.

java/pkg/java/security/URIParameter.java+63−0

This diff is large: its 64 lines aren’t shown here.

java/pkg/java/security/UnrecoverableEntryException.class+0−0

Binary file not shown.

java/pkg/java/security/UnrecoverableEntryException.java+56−0

This diff is large: its 57 lines aren’t shown here.

java/pkg/java/security/UnrecoverableKeyException.class+0−0

Binary file not shown.

java/pkg/java/security/UnrecoverableKeyException.java+56−0

This diff is large: its 57 lines aren’t shown here.

java/pkg/java/security/UnresolvedPermission.class+0−0

Binary file not shown.

java/pkg/java/security/UnresolvedPermission.java+604−0

This diff is large: its 605 lines aren’t shown here.

java/pkg/java/security/UnresolvedPermissionCollection.class+0−0

Binary file not shown.

java/pkg/java/security/UnresolvedPermissionCollection.java+216−0

This diff is large: its 217 lines aren’t shown here.

java/pkg/java/security/acl/Acl.class+0−0

Binary file not shown.

java/pkg/java/security/acl/Acl.java+241−0

This diff is large: its 242 lines aren’t shown here.

java/pkg/java/security/acl/AclEntry.class+0−0

Binary file not shown.

java/pkg/java/security/acl/AclEntry.java+154−0

This diff is large: its 155 lines aren’t shown here.

java/pkg/java/security/acl/AclNotFoundException.class+0−0

Binary file not shown.

java/pkg/java/security/acl/AclNotFoundException.java+44−0

This diff is large: its 45 lines aren’t shown here.

java/pkg/java/security/acl/Group.class+0−0

Binary file not shown.

java/pkg/java/security/acl/Group.java+87−0

This diff is large: its 88 lines aren’t shown here.

java/pkg/java/security/acl/LastOwnerException.class+0−0

Binary file not shown.

java/pkg/java/security/acl/LastOwnerException.java+45−0

This diff is large: its 46 lines aren’t shown here.

java/pkg/java/security/acl/NotOwnerException.class+0−0

Binary file not shown.

java/pkg/java/security/acl/NotOwnerException.java+44−0

This diff is large: its 45 lines aren’t shown here.

java/pkg/java/security/acl/Owner.class+0−0

Binary file not shown.

java/pkg/java/security/acl/Owner.java+95−0

This diff is large: its 96 lines aren’t shown here.

java/pkg/java/security/acl/Permission.class+0−0

Binary file not shown.

java/pkg/java/security/acl/Permission.java+54−0

This diff is large: its 55 lines aren’t shown here.

java/pkg/java/security/acl/mkfile+15−0

This diff is large: its 16 lines aren’t shown here.

java/pkg/java/security/acl/package.html+54−0

This diff is large: its 55 lines aren’t shown here.

java/pkg/java/security/cert/CRL.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CRL.java+88−0

This diff is large: its 89 lines aren’t shown here.

java/pkg/java/security/cert/CRLException.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CRLException.java+88−0

This diff is large: its 89 lines aren’t shown here.

java/pkg/java/security/cert/CRLReason.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CRLReason.java+104−0

This diff is large: its 105 lines aren’t shown here.

java/pkg/java/security/cert/CRLSelector.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CRLSelector.java+66−0

This diff is large: its 67 lines aren’t shown here.

java/pkg/java/security/cert/CertPath$CertPathRep.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertPath.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertPath.java+343−0

This diff is large: its 344 lines aren’t shown here.

java/pkg/java/security/cert/CertPathBuilder$1.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertPathBuilder.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertPathBuilder.java+304−0

This diff is large: its 305 lines aren’t shown here.

java/pkg/java/security/cert/CertPathBuilderException.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertPathBuilderException.java+104−0

This diff is large: its 105 lines aren’t shown here.

java/pkg/java/security/cert/CertPathBuilderResult.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertPathBuilderResult.java+68−0

This diff is large: its 69 lines aren’t shown here.

java/pkg/java/security/cert/CertPathBuilderSpi.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertPathBuilderSpi.java+75−0

This diff is large: its 76 lines aren’t shown here.

java/pkg/java/security/cert/CertPathHelperImpl.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertPathHelperImpl.java+66−0

This diff is large: its 67 lines aren’t shown here.

java/pkg/java/security/cert/CertPathParameters.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertPathParameters.java+49−0

This diff is large: its 50 lines aren’t shown here.

java/pkg/java/security/cert/CertPathValidator$1.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertPathValidator.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertPathValidator.java+315−0

This diff is large: its 316 lines aren’t shown here.

java/pkg/java/security/cert/CertPathValidatorException$BasicReason.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertPathValidatorException$Reason.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertPathValidatorException.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertPathValidatorException.java+296−0

This diff is large: its 297 lines aren’t shown here.

java/pkg/java/security/cert/CertPathValidatorResult.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertPathValidatorResult.java+50−0

This diff is large: its 51 lines aren’t shown here.

java/pkg/java/security/cert/CertPathValidatorSpi.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertPathValidatorSpi.java+85−0

This diff is large: its 86 lines aren’t shown here.

java/pkg/java/security/cert/CertSelector.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertSelector.java+67−0

This diff is large: its 68 lines aren’t shown here.

java/pkg/java/security/cert/CertStore$1.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertStore.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertStore.java+424−0

This diff is large: its 425 lines aren’t shown here.

java/pkg/java/security/cert/CertStoreException.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertStoreException.java+103−0

This diff is large: its 104 lines aren’t shown here.

java/pkg/java/security/cert/CertStoreParameters.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertStoreParameters.java+80−0

This diff is large: its 81 lines aren’t shown here.

java/pkg/java/security/cert/CertStoreSpi.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertStoreSpi.java+125−0

This diff is large: its 126 lines aren’t shown here.

java/pkg/java/security/cert/Certificate$CertificateRep.class+0−0

Binary file not shown.

java/pkg/java/security/cert/Certificate.class+0−0

Binary file not shown.

java/pkg/java/security/cert/Certificate.java+274−0

This diff is large: its 275 lines aren’t shown here.

java/pkg/java/security/cert/CertificateEncodingException.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertificateEncodingException.java+88−0

This diff is large: its 89 lines aren’t shown here.

java/pkg/java/security/cert/CertificateException.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertificateException.java+88−0

This diff is large: its 89 lines aren’t shown here.

java/pkg/java/security/cert/CertificateExpiredException.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertificateExpiredException.java+59−0

This diff is large: its 60 lines aren’t shown here.

java/pkg/java/security/cert/CertificateFactory.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertificateFactory.java+537−0

This diff is large: its 538 lines aren’t shown here.

java/pkg/java/security/cert/CertificateFactorySpi.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertificateFactorySpi.java+315−0

This diff is large: its 316 lines aren’t shown here.

java/pkg/java/security/cert/CertificateNotYetValidException.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertificateNotYetValidException.java+59−0

This diff is large: its 60 lines aren’t shown here.

java/pkg/java/security/cert/CertificateParsingException.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertificateParsingException.java+89−0

This diff is large: its 90 lines aren’t shown here.

java/pkg/java/security/cert/CertificateRevokedException.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CertificateRevokedException.java+245−0

This diff is large: its 246 lines aren’t shown here.

java/pkg/java/security/cert/CollectionCertStoreParameters.class+0−0

Binary file not shown.

java/pkg/java/security/cert/CollectionCertStoreParameters.java+141−0

This diff is large: its 142 lines aren’t shown here.

java/pkg/java/security/cert/Extension.class+0−0

Binary file not shown.

java/pkg/java/security/cert/Extension.java+101−0

This diff is large: its 102 lines aren’t shown here.

java/pkg/java/security/cert/LDAPCertStoreParameters.class+0−0

Binary file not shown.

java/pkg/java/security/cert/LDAPCertStoreParameters.java+149−0

This diff is large: its 150 lines aren’t shown here.

java/pkg/java/security/cert/PKIXBuilderParameters.class+0−0

Binary file not shown.

java/pkg/java/security/cert/PKIXBuilderParameters.java+199−0

This diff is large: its 200 lines aren’t shown here.

java/pkg/java/security/cert/PKIXCertPathBuilderResult.class+0−0

Binary file not shown.

java/pkg/java/security/cert/PKIXCertPathBuilderResult.java+119−0

This diff is large: its 120 lines aren’t shown here.

java/pkg/java/security/cert/PKIXCertPathChecker.class+0−0

Binary file not shown.

java/pkg/java/security/cert/PKIXCertPathChecker.java+181−0

This diff is large: its 182 lines aren’t shown here.

java/pkg/java/security/cert/PKIXCertPathValidatorResult.class+0−0

Binary file not shown.

java/pkg/java/security/cert/PKIXCertPathValidatorResult.java+159−0

This diff is large: its 160 lines aren’t shown here.

java/pkg/java/security/cert/PKIXParameters.class+0−0

Binary file not shown.

java/pkg/java/security/cert/PKIXParameters.java+736−0

This diff is large: its 737 lines aren’t shown here.

java/pkg/java/security/cert/PKIXReason.class+0−0

Binary file not shown.

java/pkg/java/security/cert/PKIXReason.java+77−0

This diff is large: its 78 lines aren’t shown here.

java/pkg/java/security/cert/PolicyNode.class+0−0

Binary file not shown.

java/pkg/java/security/cert/PolicyNode.java+133−0

This diff is large: its 134 lines aren’t shown here.

java/pkg/java/security/cert/PolicyQualifierInfo.class+0−0

Binary file not shown.

java/pkg/java/security/cert/PolicyQualifierInfo.java+173−0

This diff is large: its 174 lines aren’t shown here.

java/pkg/java/security/cert/TrustAnchor.class+0−0

Binary file not shown.

java/pkg/java/security/cert/TrustAnchor.java+334−0

This diff is large: its 335 lines aren’t shown here.

java/pkg/java/security/cert/X509CRL.class+0−0

Binary file not shown.

java/pkg/java/security/cert/X509CRL.java+443−0

This diff is large: its 444 lines aren’t shown here.

java/pkg/java/security/cert/X509CRLEntry.class+0−0

Binary file not shown.

java/pkg/java/security/cert/X509CRLEntry.java+191−0

This diff is large: its 192 lines aren’t shown here.

java/pkg/java/security/cert/X509CRLSelector.class+0−0

Binary file not shown.

java/pkg/java/security/cert/X509CRLSelector.java+714−0

This diff is large: its 715 lines aren’t shown here.

java/pkg/java/security/cert/X509CertSelector.class+0−0

Binary file not shown.

java/pkg/java/security/cert/X509CertSelector.java+2638−0

This diff is large: its 2639 lines aren’t shown here.

java/pkg/java/security/cert/X509Certificate.class+0−0

Binary file not shown.

java/pkg/java/security/cert/X509Certificate.java+649−0

This diff is large: its 650 lines aren’t shown here.

java/pkg/java/security/cert/X509Extension.class+0−0

Binary file not shown.

java/pkg/java/security/cert/X509Extension.java+199−0

This diff is large: its 200 lines aren’t shown here.

java/pkg/java/security/cert/mkfile+54−0

This diff is large: its 55 lines aren’t shown here.

java/pkg/java/security/cert/package.html+65−0

This diff is large: its 66 lines aren’t shown here.

java/pkg/java/security/interfaces/DSAKey.class+0−0

Binary file not shown.

java/pkg/java/security/interfaces/DSAKey.java+50−0

This diff is large: its 51 lines aren’t shown here.

java/pkg/java/security/interfaces/DSAKeyPairGenerator.class+0−0

Binary file not shown.

java/pkg/java/security/interfaces/DSAKeyPairGenerator.java+115−0

This diff is large: its 116 lines aren’t shown here.

java/pkg/java/security/interfaces/DSAParams.class+0−0

Binary file not shown.

java/pkg/java/security/interfaces/DSAParams.java+64−0

This diff is large: its 65 lines aren’t shown here.

java/pkg/java/security/interfaces/DSAPrivateKey.class+0−0

Binary file not shown.

java/pkg/java/security/interfaces/DSAPrivateKey.java+58−0

This diff is large: its 59 lines aren’t shown here.

java/pkg/java/security/interfaces/DSAPublicKey.class+0−0

Binary file not shown.

java/pkg/java/security/interfaces/DSAPublicKey.java+58−0

This diff is large: its 59 lines aren’t shown here.

java/pkg/java/security/interfaces/ECKey.class+0−0

Binary file not shown.

java/pkg/java/security/interfaces/ECKey.java+45−0

This diff is large: its 46 lines aren’t shown here.

java/pkg/java/security/interfaces/ECPrivateKey.class+0−0

Binary file not shown.

java/pkg/java/security/interfaces/ECPrivateKey.java+53−0

This diff is large: its 54 lines aren’t shown here.

java/pkg/java/security/interfaces/ECPublicKey.class+0−0

Binary file not shown.

java/pkg/java/security/interfaces/ECPublicKey.java+55−0

This diff is large: its 56 lines aren’t shown here.

java/pkg/java/security/interfaces/RSAKey.class+0−0

Binary file not shown.

java/pkg/java/security/interfaces/RSAKey.java+49−0

This diff is large: its 50 lines aren’t shown here.

java/pkg/java/security/interfaces/RSAMultiPrimePrivateCrtKey.class+0−0

Binary file not shown.

java/pkg/java/security/interfaces/RSAMultiPrimePrivateCrtKey.java+100−0

This diff is large: its 101 lines aren’t shown here.

java/pkg/java/security/interfaces/RSAPrivateCrtKey.class+0−0

Binary file not shown.

java/pkg/java/security/interfaces/RSAPrivateCrtKey.java+85−0

This diff is large: its 86 lines aren’t shown here.

java/pkg/java/security/interfaces/RSAPrivateKey.class+0−0

Binary file not shown.

java/pkg/java/security/interfaces/RSAPrivateKey.java+50−0

This diff is large: its 51 lines aren’t shown here.

java/pkg/java/security/interfaces/RSAPublicKey.class+0−0

Binary file not shown.

java/pkg/java/security/interfaces/RSAPublicKey.java+47−0

This diff is large: its 48 lines aren’t shown here.

java/pkg/java/security/interfaces/mkfile+20−0

This diff is large: its 21 lines aren’t shown here.

java/pkg/java/security/interfaces/package.html+77−0

This diff is large: its 78 lines aren’t shown here.

java/pkg/java/security/mkfile+87−0

This diff is large: its 88 lines aren’t shown here.

java/pkg/java/security/package.html+117−0

This diff is large: its 118 lines aren’t shown here.

java/pkg/java/security/spec/AlgorithmParameterSpec.class+0−0

Binary file not shown.

java/pkg/java/security/spec/AlgorithmParameterSpec.java+44−0

This diff is large: its 45 lines aren’t shown here.

java/pkg/java/security/spec/DSAParameterSpec.class+0−0

Binary file not shown.

java/pkg/java/security/spec/DSAParameterSpec.java+89−0

This diff is large: its 90 lines aren’t shown here.

java/pkg/java/security/spec/DSAPrivateKeySpec.class+0−0

Binary file not shown.

java/pkg/java/security/spec/DSAPrivateKeySpec.java+106−0

This diff is large: its 107 lines aren’t shown here.

java/pkg/java/security/spec/DSAPublicKeySpec.class+0−0

Binary file not shown.

java/pkg/java/security/spec/DSAPublicKeySpec.java+106−0

This diff is large: its 107 lines aren’t shown here.

java/pkg/java/security/spec/ECField.class+0−0

Binary file not shown.

java/pkg/java/security/spec/ECField.java+49−0

This diff is large: its 50 lines aren’t shown here.

java/pkg/java/security/spec/ECFieldF2m.class+0−0

Binary file not shown.

java/pkg/java/security/spec/ECFieldF2m.java+241−0

This diff is large: its 242 lines aren’t shown here.

java/pkg/java/security/spec/ECFieldFp.class+0−0

Binary file not shown.

java/pkg/java/security/spec/ECFieldFp.java+98−0

This diff is large: its 99 lines aren’t shown here.

java/pkg/java/security/spec/ECGenParameterSpec.class+0−0

Binary file not shown.

java/pkg/java/security/spec/ECGenParameterSpec.java+68−0

This diff is large: its 69 lines aren’t shown here.

java/pkg/java/security/spec/ECParameterSpec.class+0−0

Binary file not shown.

java/pkg/java/security/spec/ECParameterSpec.java+113−0

This diff is large: its 114 lines aren’t shown here.

java/pkg/java/security/spec/ECPoint.class+0−0

Binary file not shown.

java/pkg/java/security/spec/ECPoint.java+114−0

This diff is large: its 115 lines aren’t shown here.

java/pkg/java/security/spec/ECPrivateKeySpec.class+0−0

Binary file not shown.

java/pkg/java/security/spec/ECPrivateKeySpec.java+81−0

This diff is large: its 82 lines aren’t shown here.

java/pkg/java/security/spec/ECPublicKeySpec.class+0−0

Binary file not shown.

java/pkg/java/security/spec/ECPublicKeySpec.java+85−0

This diff is large: its 86 lines aren’t shown here.

java/pkg/java/security/spec/EllipticCurve.class+0−0

Binary file not shown.

java/pkg/java/security/spec/EllipticCurve.java+196−0

This diff is large: its 197 lines aren’t shown here.

java/pkg/java/security/spec/EncodedKeySpec.class+0−0

Binary file not shown.

java/pkg/java/security/spec/EncodedKeySpec.java+85−0

This diff is large: its 86 lines aren’t shown here.

java/pkg/java/security/spec/InvalidKeySpecException.class+0−0

Binary file not shown.

java/pkg/java/security/spec/InvalidKeySpecException.java+94−0

This diff is large: its 95 lines aren’t shown here.

java/pkg/java/security/spec/InvalidParameterSpecException.class+0−0

Binary file not shown.

java/pkg/java/security/spec/InvalidParameterSpecException.java+66−0

This diff is large: its 67 lines aren’t shown here.

java/pkg/java/security/spec/KeySpec.class+0−0

Binary file not shown.

java/pkg/java/security/spec/KeySpec.java+62−0

This diff is large: its 63 lines aren’t shown here.

java/pkg/java/security/spec/MGF1ParameterSpec.class+0−0

Binary file not shown.

java/pkg/java/security/spec/MGF1ParameterSpec.java+107−0

This diff is large: its 108 lines aren’t shown here.

java/pkg/java/security/spec/PKCS8EncodedKeySpec.class+0−0

Binary file not shown.

java/pkg/java/security/spec/PKCS8EncodedKeySpec.java+96−0

This diff is large: its 97 lines aren’t shown here.

java/pkg/java/security/spec/PSSParameterSpec.class+0−0

Binary file not shown.

java/pkg/java/security/spec/PSSParameterSpec.java+211−0

This diff is large: its 212 lines aren’t shown here.

java/pkg/java/security/spec/RSAKeyGenParameterSpec.class+0−0

Binary file not shown.

java/pkg/java/security/spec/RSAKeyGenParameterSpec.java+86−0

This diff is large: its 87 lines aren’t shown here.

java/pkg/java/security/spec/RSAMultiPrimePrivateCrtKeySpec.class+0−0

Binary file not shown.

java/pkg/java/security/spec/RSAMultiPrimePrivateCrtKeySpec.java+212−0

This diff is large: its 213 lines aren’t shown here.

java/pkg/java/security/spec/RSAOtherPrimeInfo.class+0−0

Binary file not shown.

java/pkg/java/security/spec/RSAOtherPrimeInfo.java+120−0

This diff is large: its 121 lines aren’t shown here.

java/pkg/java/security/spec/RSAPrivateCrtKeySpec.class+0−0

Binary file not shown.

java/pkg/java/security/spec/RSAPrivateCrtKeySpec.java+143−0

This diff is large: its 144 lines aren’t shown here.

java/pkg/java/security/spec/RSAPrivateKeySpec.class+0−0

Binary file not shown.

java/pkg/java/security/spec/RSAPrivateKeySpec.java+77−0

This diff is large: its 78 lines aren’t shown here.

java/pkg/java/security/spec/RSAPublicKeySpec.class+0−0

Binary file not shown.

java/pkg/java/security/spec/RSAPublicKeySpec.java+77−0

This diff is large: its 78 lines aren’t shown here.

java/pkg/java/security/spec/X509EncodedKeySpec.class+0−0

Binary file not shown.

java/pkg/java/security/spec/X509EncodedKeySpec.java+86−0

This diff is large: its 87 lines aren’t shown here.

java/pkg/java/security/spec/mkfile+34−0

This diff is large: its 35 lines aren’t shown here.

java/pkg/java/security/spec/package.html+78−0

This diff is large: its 79 lines aren’t shown here.