stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge

Browse Source
This commit is contained in:
Lana Steuck 2014-07-30 11:49:59 -07:00
commit 0d6421b218
62 changed files with 2166 additions and 512 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
jdk/src/share/classes/com/sun/jndi/toolkit/corba/CorbaUtils.java
View File

@ -55,7 +55,6 @@ public class CorbaUtils {
* Returns the CORBA object reference associated with a Remote
* object by using the javax.rmi.CORBA package.
*<p>
* Use reflection to avoid hard dependencies on javax.rmi.CORBA package.
* This method effective does the following:
*<blockquote><pre>
* java.lang.Object stub;

5
jdk/src/share/classes/com/sun/security/auth/module/Krb5LoginModule.java
View File

@ -33,7 +33,10 @@ import java.text.MessageFormat;
import java.util.*;
import javax.security.auth.*;
import javax.security.auth.kerberos.*;
import javax.security.auth.kerberos.KerberosTicket;
import javax.security.auth.kerberos.KerberosPrincipal;
import javax.security.auth.kerberos.KerberosKey;
import javax.security.auth.kerberos.KeyTab;
import javax.security.auth.callback.*;
import javax.security.auth.login.*;
import javax.security.auth.spi.*;

29
jdk/src/share/classes/com/sun/security/jgss/ExtendedGSSContext.java
View File

@ -36,33 +36,7 @@ import org.ietf.jgss.*;
public interface ExtendedGSSContext extends GSSContext {
/**
* Return the mechanism-specific attribute associated with {@code type}.
* <br><br>
* For each supported attribute type, the type for the output are
* defined below.
* <ol>
* <li>{@code KRB5_GET_TKT_FLAGS}:
* the returned object is a boolean array for the service ticket flags,
* which is long enough to contain all true bits. This means if
* the user wants to get the <em>n</em>'th bit but the length of the
* returned array is less than <em>n</em>, it is regarded as false.
* <li>{@code KRB5_GET_SESSION_KEY}:
* the returned object is an instance of {@link java.security.Key},
* which has the following properties:
* <ul>
* <li>Algorithm: enctype as a string, where
* enctype is defined in RFC 3961, section 8.
* <li>Format: "RAW"
* <li>Encoded form: the raw key bytes, not in any ASN.1 encoding
* </ul>
* <li>{@code KRB5_GET_AUTHZ_DATA}:
* the returned object is an array of
* {@link com.sun.security.jgss.AuthorizationDataEntry}, or null if the
* optional field is missing in the service ticket.
* <li>{@code KRB5_GET_AUTHTIME}:
* the returned object is a String object in the standard KerberosTime
* format defined in RFC 4120 5.2.3
* </ol>
*
* <p>
* If there is a security manager, an {@link InquireSecContextPermission}
* with the name {@code type.mech} must be granted. Otherwise, this could
* result in a {@link SecurityException}.<p>
@ -97,6 +71,7 @@ public interface ExtendedGSSContext extends GSSContext {
* @throws SecurityException if a security manager exists and a proper
* {@link InquireSecContextPermission} is not granted.
* @see InquireSecContextPermission
* @see InquireType
*/
public Object inquireSecContext(InquireType type)
throws GSSException;

45
jdk/src/share/classes/com/sun/security/jgss/InquireType.java
View File

@ -32,13 +32,38 @@ package com.sun.security.jgss;
@jdk.Exported
public enum InquireType {
/**
* Attribute type for retrieving the session key of an
* established Kerberos 5 security context.
* Attribute type for retrieving the session key of an established
* Kerberos 5 security context. The returned object is an instance of
* {@link java.security.Key}, which has the following properties:
* <ul>
* <li>Algorithm: enctype as a string, where
* enctype is defined in RFC 3961, section 8.
* <li>Format: "RAW"
* <li>Encoded form: the raw key bytes, not in any ASN.1 encoding
* </ul>
* @deprecated as of 1.9, replaced by {@link #KRB5_GET_SESSION_KEY_EX}
* which returns an instance of
* {@link sun.security.jgss.krb5.Krb5Context.EncryptionKey}
* that implements the {@link javax.crypto.SecretKey} interface and
* has similar methods with {@link javax.security.auth.kerberos.KerberosKey}.
*/
@Deprecated
KRB5_GET_SESSION_KEY,
/**
* Attribute type for retrieving the session key of an
* established Kerberos 5 security context. The return value is an
* instance of {@link javax.security.auth.kerberos.EncryptionKey}.
*
* @since 1.9
*/
KRB5_GET_SESSION_KEY_EX,
/**
* Attribute type for retrieving the service ticket flags of an
* established Kerberos 5 security context.
* established Kerberos 5 security context. The returned object is
* a boolean array for the service ticket flags, which is long enough
* to contain all true bits. This means if the user wants to get the
* <em>n</em>'th bit but the length of the returned array is less than
* <em>n</em>, it is regarded as false.
*/
KRB5_GET_TKT_FLAGS,
/**
@ -49,7 +74,17 @@ public enum InquireType {
KRB5_GET_AUTHZ_DATA,
/**
* Attribute type for retrieving the authtime in the service ticket
* of an established Kerberos 5 security context.
* of an established Kerberos 5 security context. The returned object
* is a String object in the standard KerberosTime format defined in
* RFC 4120 Section 5.2.3.
*/
KRB5_GET_AUTHTIME
KRB5_GET_AUTHTIME,
/**
* Attribute type for retrieving the KRB_CRED message that an initiator
* is about to send to an acceptor. The return type is an instance of
* {@link javax.security.auth.kerberos.KerberosCredMessage}.
*
* @since 1.9
*/
KRB5_GET_KRB_CRED,
}

260
jdk/src/share/classes/java/lang/Integer.java
View File

@ -26,6 +26,7 @@
package java.lang;
import java.lang.annotation.Native;
import java.util.Objects;
/**
* The {@code Integer} class wraps a value of the primitive type
@ -319,24 +320,27 @@ public final class Integer extends Number implements Comparable<Integer> {
}
/**
* Format a long (treated as unsigned) into a character buffer.
* Format an {@code int} (treated as unsigned) into a character buffer. If
* {@code len} exceeds the formatted ASCII representation of {@code val},
* {@code buf} will be padded with leading zeroes.
*
* @param val the unsigned int to format
* @param shift the log2 of the base to format in (4 for hex, 3 for octal, 1 for binary)
* @param buf the character buffer to write to
* @param offset the offset in the destination buffer to start at
* @param len the number of characters to write
* @return the lowest character location used
*/
static int formatUnsignedInt(int val, int shift, char[] buf, int offset, int len) {
int charPos = len;
static void formatUnsignedInt(int val, int shift, char[] buf, int offset, int len) {
// assert shift > 0 && shift <=5 : "Illegal shift value";
// assert offset >= 0 && offset < buf.length : "illegal offset";
// assert len > 0 && (offset + len) <= buf.length : "illegal length";
int charPos = offset + len;
int radix = 1 << shift;
int mask = radix - 1;
do {
buf[offset + --charPos] = Integer.digits[val & mask];
buf[--charPos] = Integer.digits[val & mask];
val >>>= shift;
} while (val != 0 && charPos > 0);
return charPos;
} while (charPos > offset);
}
final static char [] DigitTens = {
@ -549,12 +553,9 @@ public final class Integer extends Number implements Comparable<Integer> {
" greater than Character.MAX_RADIX");
}
int result = 0;
boolean negative = false;
int i = 0, len = s.length();
int limit = -Integer.MAX_VALUE;
int multmin;
int digit;
if (len > 0) {
char firstChar = s.charAt(0);
@ -562,21 +563,21 @@ public final class Integer extends Number implements Comparable<Integer> {
if (firstChar == '-') {
negative = true;
limit = Integer.MIN_VALUE;
} else if (firstChar != '+')
throw NumberFormatException.forInputString(s);
if (len == 1) // Cannot have lone "+" or "-"
throw NumberFormatException.forInputString(s);
i++;
}
multmin = limit / radix;
while (i < len) {
// Accumulating negatively avoids surprises near MAX_VALUE
digit = Character.digit(s.charAt(i++),radix);
if (digit < 0) {
} else if (firstChar != '+') {
throw NumberFormatException.forInputString(s);
}
if (result < multmin) {
if (len == 1) { // Cannot have lone "+" or "-"
throw NumberFormatException.forInputString(s);
}
i++;
}
int multmin = limit / radix;
int result = 0;
while (i < len) {
// Accumulating negatively avoids surprises near MAX_VALUE
int digit = Character.digit(s.charAt(i++), radix);
if (digit < 0 || result < multmin) {
throw NumberFormatException.forInputString(s);
}
result *= radix;
@ -585,10 +586,126 @@ public final class Integer extends Number implements Comparable<Integer> {
}
result -= digit;
}
return negative ? result : -result;
} else {
throw NumberFormatException.forInputString(s);
}
return negative ? result : -result;
}
/**
* Parses the {@link CharSequence} argument as a signed {@code int} in the
* specified {@code radix}, beginning at the specified {@code beginIndex}
* and extending to the end of the sequence.
*
* <p>The method does not take steps to guard against the
* {@code CharSequence} being mutated while parsing.
*
* @param s the {@code CharSequence} containing the {@code int}
* representation to be parsed
* @param radix the radix to be used while parsing {@code s}.
* @param beginIndex the beginning index, inclusive.
* @return the signed {@code int} represented by the subsequence in
* the specified radix.
* @throws NullPointerException if {@code s} is null.
* @throws IndexOutOfBoundsException if {@code beginIndex} is
* negative, or if {@code beginIndex} is greater than
* {@code s.length()}.
* @throws NumberFormatException if the {@code CharSequence} does not
* contain a parsable {@code int} in the specified
* {@code radix}, or if {@code radix} is either smaller than
* {@link java.lang.Character#MIN_RADIX} or larger than
* {@link java.lang.Character#MAX_RADIX}.
* @since 1.9
*/
public static int parseInt(CharSequence s, int radix, int beginIndex)
throws NumberFormatException {
// forces an implicit null check of s
return parseInt(s, radix, beginIndex, s.length());
}
/**
* Parses the {@link CharSequence} argument as a signed {@code int} in the
* specified {@code radix}, beginning at the specified {@code beginIndex}
* and extending to {@code endIndex - 1}.
*
* <p>The method does not take steps to guard against the
* {@code CharSequence} being mutated while parsing.
*
* @param s the {@code CharSequence} containing the {@code int}
* representation to be parsed
* @param radix the radix to be used while parsing {@code s}.
* @param beginIndex the beginning index, inclusive.
* @param endIndex the ending index, exclusive.
* @return the signed {@code int} represented by the subsequence in
* the specified radix.
* @throws NullPointerException if {@code s} is null.
* @throws IndexOutOfBoundsException if {@code beginIndex} is
* negative, or if {@code beginIndex} is greater than
* {@code endIndex} or if {@code endIndex} is greater than
* {@code s.length()}.
* @throws NumberFormatException if the {@code CharSequence} does not
* contain a parsable {@code int} in the specified
* {@code radix}, or if {@code radix} is either smaller than
* {@link java.lang.Character#MIN_RADIX} or larger than
* {@link java.lang.Character#MAX_RADIX}.
* @since 1.9
*/
public static int parseInt(CharSequence s, int radix, int beginIndex, int endIndex)
throws NumberFormatException {
s = Objects.requireNonNull(s);
if (beginIndex < 0 || beginIndex > endIndex || endIndex > s.length()) {
throw new IndexOutOfBoundsException();
}
if (radix < Character.MIN_RADIX) {
throw new NumberFormatException("radix " + radix +
" less than Character.MIN_RADIX");
}
if (radix > Character.MAX_RADIX) {
throw new NumberFormatException("radix " + radix +
" greater than Character.MAX_RADIX");
}
boolean negative = false;
int i = beginIndex;
int limit = -Integer.MAX_VALUE;
if (i < endIndex) {
char firstChar = s.charAt(i);
if (firstChar < '0') { // Possible leading "+" or "-"
if (firstChar == '-') {
negative = true;
limit = Integer.MIN_VALUE;
} else if (firstChar != '+') {
throw NumberFormatException.forCharSequence(s, beginIndex,
endIndex, i);
}
i++;
if (i == endIndex) { // Cannot have lone "+" or "-"
throw NumberFormatException.forCharSequence(s, beginIndex,
endIndex, i);
}
}
int multmin = limit / radix;
int result = 0;
while (i < endIndex) {
// Accumulating negatively avoids surprises near MAX_VALUE
int digit = Character.digit(s.charAt(i++), radix);
if (digit < 0 || result < multmin) {
throw NumberFormatException.forCharSequence(s, beginIndex,
endIndex, i);
}
result *= radix;
if (result < limit + digit) {
throw NumberFormatException.forCharSequence(s, beginIndex,
endIndex, i);
}
result -= digit;
}
return negative ? result : -result;
} else {
throw NumberFormatException.forInputString("");
}
}
/**
@ -688,6 +805,99 @@ public final class Integer extends Number implements Comparable<Integer> {
}
}
/**
* Parses the {@link CharSequence} argument as an unsigned {@code int} in
* the specified {@code radix}, beginning at the specified
* {@code beginIndex} and extending to the end of the sequence.
*
* <p>The method does not take steps to guard against the
* {@code CharSequence} being mutated while parsing.
*
* @param s the {@code CharSequence} containing the unsigned
* {@code int} representation to be parsed
* @param radix the radix to be used while parsing {@code s}.
* @param beginIndex the beginning index, inclusive.
* @return the unsigned {@code int} represented by the subsequence in
* the specified radix.
* @throws NullPointerException if {@code s} is null.
* @throws IndexOutOfBoundsException if {@code beginIndex} is
* negative, or if {@code beginIndex} is greater than
* {@code s.length()}.
* @throws NumberFormatException if the {@code CharSequence} does not
* contain a parsable unsigned {@code int} in the specified
* {@code radix}, or if {@code radix} is either smaller than
* {@link java.lang.Character#MIN_RADIX} or larger than
* {@link java.lang.Character#MAX_RADIX}.
* @since 1.9
*/
public static int parseUnsignedInt(CharSequence s, int radix, int beginIndex)
throws NumberFormatException {
// forces an implicit null check of s
return parseUnsignedInt(s, radix, beginIndex, s.length());
}
/**
* Parses the {@link CharSequence} argument as an unsigned {@code int} in
* the specified {@code radix}, beginning at the specified
* {@code beginIndex} and extending to {@code endIndex - 1}.
*
* <p>The method does not take steps to guard against the
* {@code CharSequence} being mutated while parsing.
*
* @param s the {@code CharSequence} containing the unsigned
* {@code int} representation to be parsed
* @param radix the radix to be used while parsing {@code s}.
* @param beginIndex the beginning index, inclusive.
* @param endIndex the ending index, exclusive.
* @return the unsigned {@code int} represented by the subsequence in
* the specified radix.
* @throws NullPointerException if {@code s} is null.
* @throws IndexOutOfBoundsException if {@code beginIndex} is
* negative, or if {@code beginIndex} is greater than
* {@code endIndex} or if {@code endIndex} is greater than
* {@code s.length()}.
* @throws NumberFormatException if the {@code CharSequence} does not
* contain a parsable unsigned {@code int} in the specified
* {@code radix}, or if {@code radix} is either smaller than
* {@link java.lang.Character#MIN_RADIX} or larger than
* {@link java.lang.Character#MAX_RADIX}.
* @since 1.9
*/
public static int parseUnsignedInt(CharSequence s, int radix, int beginIndex, int endIndex)
throws NumberFormatException {
s = Objects.requireNonNull(s);
if (beginIndex < 0 || beginIndex > endIndex || endIndex > s.length()) {
throw new IndexOutOfBoundsException();
}
int start = beginIndex, len = endIndex - beginIndex;
if (len > 0) {
char firstChar = s.charAt(start);
if (firstChar == '-') {
throw new
NumberFormatException(String.format("Illegal leading minus sign " +
"on unsigned string %s.", s));
} else {
if (len <= 5 || // Integer.MAX_VALUE in Character.MAX_RADIX is 6 digits
(radix == 10 && len <= 9)) { // Integer.MAX_VALUE in base 10 is 10 digits
return parseInt(s, radix, start, start + len);
} else {
long ell = Long.parseLong(s, radix, start, start + len);
if ((ell & 0xffff_ffff_0000_0000L) == 0) {
return (int) ell;
} else {
throw new
NumberFormatException(String.format("String value %s exceeds " +
"range of unsigned int.", s));
}
}
}
} else {
throw new NumberFormatException("");
}
}
/**
* Parses the string argument as an unsigned decimal integer. The
* characters in the string must all be decimal digits, except

318
jdk/src/share/classes/java/lang/Long.java
View File

@ -27,6 +27,7 @@ package java.lang;
import java.lang.annotation.Native;
import java.math.*;
import java.util.Objects;
/**
@ -360,24 +361,27 @@ public final class Long extends Number implements Comparable<Long> {
}
/**
* Format a long (treated as unsigned) into a character buffer.
* Format a long (treated as unsigned) into a character buffer. If
* {@code len} exceeds the formatted ASCII representation of {@code val},
* {@code buf} will be padded with leading zeroes.
*
* @param val the unsigned long to format
* @param shift the log2 of the base to format in (4 for hex, 3 for octal, 1 for binary)
* @param buf the character buffer to write to
* @param offset the offset in the destination buffer to start at
* @param len the number of characters to write
* @return the lowest character location used
*/
static int formatUnsignedLong(long val, int shift, char[] buf, int offset, int len) {
int charPos = len;
static void formatUnsignedLong(long val, int shift, char[] buf, int offset, int len) {
// assert shift > 0 && shift <=5 : "Illegal shift value";
// assert offset >= 0 && offset < buf.length : "illegal offset";
// assert len > 0 && (offset + len) <= buf.length : "illegal length";
int charPos = offset + len;
int radix = 1 << shift;
int mask = radix - 1;
do {
buf[offset + --charPos] = Integer.digits[((int) val) & mask];
buf[--charPos] = Integer.digits[((int) val) & mask];
val >>>= shift;
} while (val != 0 && charPos > 0);
return charPos;
} while (charPos > offset);
}
/**
@ -561,12 +565,9 @@ public final class Long extends Number implements Comparable<Long> {
" greater than Character.MAX_RADIX");
}
long result = 0;
boolean negative = false;
int i = 0, len = s.length();
long limit = -Long.MAX_VALUE;
long multmin;
int digit;
if (len > 0) {
char firstChar = s.charAt(0);
@ -574,21 +575,21 @@ public final class Long extends Number implements Comparable<Long> {
if (firstChar == '-') {
negative = true;
limit = Long.MIN_VALUE;
} else if (firstChar != '+')
throw NumberFormatException.forInputString(s);
if (len == 1) // Cannot have lone "+" or "-"
throw NumberFormatException.forInputString(s);
i++;
}
multmin = limit / radix;
while (i < len) {
// Accumulating negatively avoids surprises near MAX_VALUE
digit = Character.digit(s.charAt(i++),radix);
if (digit < 0) {
} else if (firstChar != '+') {
throw NumberFormatException.forInputString(s);
}
if (result < multmin) {
if (len == 1) { // Cannot have lone "+" or "-"
throw NumberFormatException.forInputString(s);
}
i++;
}
long multmin = limit / radix;
long result = 0;
while (i < len) {
// Accumulating negatively avoids surprises near MAX_VALUE
int digit = Character.digit(s.charAt(i++),radix);
if (digit < 0 || result < multmin) {
throw NumberFormatException.forInputString(s);
}
result *= radix;
@ -597,10 +598,126 @@ public final class Long extends Number implements Comparable<Long> {
}
result -= digit;
}
return negative ? result : -result;
} else {
throw NumberFormatException.forInputString(s);
}
return negative ? result : -result;
}
/**
* Parses the {@link CharSequence} argument as a signed {@code long} in
* the specified {@code radix}, beginning at the specified {@code beginIndex}
* and extending to the end of the sequence.
*
* <p>The method does not take steps to guard against the
* {@code CharSequence} being mutated while parsing.
*
* @param s the {@code CharSequence} containing the {@code long}
* representation to be parsed
* @param radix the radix to be used while parsing {@code s}.
* @param beginIndex the beginning index, inclusive.
* @return the signed {@code long} represented by the subsequence in
* the specified radix.
* @throws NullPointerException if {@code s} is null.
* @throws IndexOutOfBoundsException if {@code beginIndex} is
* negative, or if {@code beginIndex} is greater than
* {@code s.length()}.
* @throws NumberFormatException if the {@code CharSequence} does not
* contain a parsable {@code long} in the specified
* {@code radix}, or if {@code radix} is either smaller than
* {@link java.lang.Character#MIN_RADIX} or larger than
* {@link java.lang.Character#MAX_RADIX}.
* @since 1.9
*/
public static long parseLong(CharSequence s, int radix, int beginIndex)
throws NumberFormatException {
// forces a null check of s
return parseLong(s, radix, beginIndex, s.length());
}
/**
* Parses the {@link CharSequence} argument as a signed {@code long} in
* the specified {@code radix}, beginning at the specified
* {@code beginIndex} and extending to {@code endIndex - 1}.
*
* <p>The method does not take steps to guard against the
* {@code CharSequence} being mutated while parsing.
*
* @param s the {@code CharSequence} containing the {@code long}
* representation to be parsed
* @param radix the radix to be used while parsing {@code s}.
* @param beginIndex the beginning index, inclusive.
* @param endIndex the ending index, exclusive.
* @return the signed {@code long} represented by the subsequence in
* the specified radix.
* @throws NullPointerException if {@code s} is null.
* @throws IndexOutOfBoundsException if {@code beginIndex} is
* negative, or if {@code beginIndex} is greater than
* {@code endIndex} or if {@code endIndex} is greater than
* {@code s.length()}.
* @throws NumberFormatException if the {@code CharSequence} does not
* contain a parsable {@code int} in the specified
* {@code radix}, or if {@code radix} is either smaller than
* {@link java.lang.Character#MIN_RADIX} or larger than
* {@link java.lang.Character#MAX_RADIX}.
* @since 1.9
*/
public static long parseLong(CharSequence s, int radix, int beginIndex, int endIndex)
throws NumberFormatException {
s = Objects.requireNonNull(s);
if (beginIndex < 0 || beginIndex > endIndex || endIndex > s.length()) {
throw new IndexOutOfBoundsException();
}
if (radix < Character.MIN_RADIX) {
throw new NumberFormatException("radix " + radix +
" less than Character.MIN_RADIX");
}
if (radix > Character.MAX_RADIX) {
throw new NumberFormatException("radix " + radix +
" greater than Character.MAX_RADIX");
}
boolean negative = false;
int i = beginIndex;
long limit = -Long.MAX_VALUE;
if (i < endIndex) {
char firstChar = s.charAt(i);
if (firstChar < '0') { // Possible leading "+" or "-"
if (firstChar == '-') {
negative = true;
limit = Long.MIN_VALUE;
} else if (firstChar != '+') {
throw NumberFormatException.forCharSequence(s, beginIndex,
endIndex, i);
}
i++;
}
if (i >= endIndex) { // Cannot have lone "+", "-" or ""
throw NumberFormatException.forCharSequence(s, beginIndex,
endIndex, i);
}
long multmin = limit / radix;
long result = 0;
while (i < endIndex) {
// Accumulating negatively avoids surprises near MAX_VALUE
int digit = Character.digit(s.charAt(i++), radix);
if (digit < 0 || result < multmin) {
throw NumberFormatException.forCharSequence(s, beginIndex,
endIndex, i);
}
result *= radix;
if (result < limit + digit) {
throw NumberFormatException.forCharSequence(s, beginIndex,
endIndex, i);
}
result -= digit;
}
return negative ? result : -result;
} else {
throw new NumberFormatException("");
}
}
/**
@ -694,7 +811,7 @@ public final class Long extends Number implements Comparable<Long> {
}
// No need for range checks on len due to testing above.
long first = parseLong(s.substring(0, len - 1), radix);
long first = parseLong(s, radix, 0, len - 1);
int second = Character.digit(s.charAt(len - 1), radix);
if (second < 0) {
throw new NumberFormatException("Bad digit at end of " + s);
@ -763,6 +880,155 @@ public final class Long extends Number implements Comparable<Long> {
}
}
/**
* Parses the {@link CharSequence} argument as an unsigned {@code long} in
* the specified {@code radix}, beginning at the specified
* {@code beginIndex} and extending to the end of the sequence.
*
* <p>The method does not take steps to guard against the
* {@code CharSequence} being mutated while parsing.
*
* @param s the {@code CharSequence} containing the unsigned
* {@code long} representation to be parsed
* @param radix the radix to be used while parsing {@code s}.
* @param beginIndex the beginning index, inclusive.
* @return the unsigned {@code long} represented by the subsequence in
* the specified radix.
* @throws NullPointerException if {@code s} is null.
* @throws IndexOutOfBoundsException if {@code beginIndex} is
* negative, or if {@code beginIndex} is greater than
* {@code s.length()}.
* @throws NumberFormatException if the {@code CharSequence} does not
* contain a parsable unsigned {@code long} in the specified
* {@code radix}, or if {@code radix} is either smaller than
* {@link java.lang.Character#MIN_RADIX} or larger than
* {@link java.lang.Character#MAX_RADIX}.
* @since 1.9
*/
public static long parseUnsignedLong(CharSequence s, int radix, int beginIndex)
throws NumberFormatException {
// forces a null check of s
return parseUnsignedLong(s, radix, beginIndex, s.length());
}
/**
* Parses the {@link CharSequence} argument as an unsigned {@code long} in
* the specified {@code radix}, beginning at the specified
* {@code beginIndex} and extending to {@code endIndex - 1}.
*
* <p>The method does not take steps to guard against the
* {@code CharSequence} being mutated while parsing.
*
* @param s the {@code CharSequence} containing the unsigned
* {@code long} representation to be parsed
* @param radix the radix to be used while parsing {@code s}.
* @param beginIndex the beginning index, inclusive.
* @param endIndex the ending index, exclusive.
* @return the unsigned {@code long} represented by the subsequence in
* the specified radix.
* @throws NullPointerException if {@code s} is null.
* @throws IndexOutOfBoundsException if {@code beginIndex} is
* negative, or if {@code beginIndex} is greater than
* {@code endIndex} or if {@code endIndex} is greater than
* {@code s.length()}.
* @throws NumberFormatException if the {@code CharSequence} does not
* contain a parsable unsigned {@code long} in the specified
* {@code radix}, or if {@code radix} is either smaller than
* {@link java.lang.Character#MIN_RADIX} or larger than
* {@link java.lang.Character#MAX_RADIX}.
* @since 1.9
*/
public static long parseUnsignedLong(CharSequence s, int radix, int beginIndex, int endIndex)
throws NumberFormatException {
s = Objects.requireNonNull(s);
if (beginIndex < 0 || beginIndex > endIndex || endIndex > s.length()) {
throw new IndexOutOfBoundsException();
}
int start = beginIndex, len = endIndex - beginIndex;
if (len > 0) {
char firstChar = s.charAt(start);
if (firstChar == '-') {
throw new NumberFormatException(String.format("Illegal leading minus sign " +
"on unsigned string %s.", s.subSequence(start, start + len)));
} else {
if (len <= 12 || // Long.MAX_VALUE in Character.MAX_RADIX is 13 digits
(radix == 10 && len <= 18) ) { // Long.MAX_VALUE in base 10 is 19 digits
return parseLong(s, radix, start, start + len);
}
// No need for range checks on end due to testing above.
long first = parseLong(s, radix, start, start + len - 1);
int second = Character.digit(s.charAt(start + len - 1), radix);
if (second < 0) {
throw new NumberFormatException("Bad digit at end of " +
s.subSequence(start, start + len));
}
long result = first * radix + second;
/*
* Test leftmost bits of multiprecision extension of first*radix
* for overflow. The number of bits needed is defined by
* GUARD_BIT = ceil(log2(Character.MAX_RADIX)) + 1 = 7. Then
* int guard = radix*(int)(first >>> (64 - GUARD_BIT)) and
* overflow is tested by splitting guard in the ranges
* guard < 92, 92 <= guard < 128, and 128 <= guard, where
* 92 = 128 - Character.MAX_RADIX. Note that guard cannot take
* on a value which does not include a prime factor in the legal
* radix range.
*/
int guard = radix * (int) (first >>> 57);
if (guard >= 128 ||
(result >= 0 && guard >= 128 - Character.MAX_RADIX)) {
/*
* For purposes of exposition, the programmatic statements
* below should be taken to be multi-precision, i.e., not
* subject to overflow.
*
* A) Condition guard >= 128:
* If guard >= 128 then first*radix >= 2^7 * 2^57 = 2^64
* hence always overflow.
*
* B) Condition guard < 92:
* Define left7 = first >>> 57.
* Given first = (left7 * 2^57) + (first & (2^57 - 1)) then
* result <= (radix*left7)*2^57 + radix*(2^57 - 1) + second.
* Thus if radix*left7 < 92, radix <= 36, and second < 36,
* then result < 92*2^57 + 36*(2^57 - 1) + 36 = 2^64 hence
* never overflow.
*
* C) Condition 92 <= guard < 128:
* first*radix + second >= radix*left7*2^57 + second
* so that first*radix + second >= 92*2^57 + 0 > 2^63
*
* D) Condition guard < 128:
* radix*first <= (radix*left7) * 2^57 + radix*(2^57 - 1)
* so
* radix*first + second <= (radix*left7) * 2^57 + radix*(2^57 - 1) + 36
* thus
* radix*first + second < 128 * 2^57 + 36*2^57 - radix + 36
* whence
* radix*first + second < 2^64 + 2^6*2^57 = 2^64 + 2^63
*
* E) Conditions C, D, and result >= 0:
* C and D combined imply the mathematical result
* 2^63 < first*radix + second < 2^64 + 2^63. The lower
* bound is therefore negative as a signed long, but the
* upper bound is too small to overflow again after the
* signed long overflows to positive above 2^64 - 1. Hence
* result >= 0 implies overflow given C and D.
*/
throw new NumberFormatException(String.format("String value %s exceeds " +
"range of unsigned long.", s.subSequence(start, start + len)));
}
return result;
}
} else {
throw NumberFormatException.forInputString("");
}
}
/**
* Parses the string argument as an unsigned decimal {@code long}. The
* characters in the string must all be decimal digits, except

18
jdk/src/share/classes/java/lang/NumberFormatException.java
View File

@ -56,7 +56,7 @@ class NumberFormatException extends IllegalArgumentException {
}
/**
* Factory method for making a <code>NumberFormatException</code>
* Factory method for making a {@code NumberFormatException}
* given the specified input which caused the error.
*
* @param s the input causing the error
@ -64,4 +64,20 @@ class NumberFormatException extends IllegalArgumentException {
static NumberFormatException forInputString(String s) {
return new NumberFormatException("For input string: \"" + s + "\"");
}
/**
* Factory method for making a {@code NumberFormatException}
* given the specified input which caused the error.
*
* @param s the input causing the error
* @param beginIndex the beginning index, inclusive.
* @param endIndex the ending index, exclusive.
* @param errorIndex the index of the first error in s
*/
static NumberFormatException forCharSequence(CharSequence s,
int beginIndex, int endIndex, int errorIndex) {
return new NumberFormatException("Error at index "
+ (errorIndex - beginIndex) + " in: \""
+ s.subSequence(beginIndex, endIndex) + "\"");
}
}

9
jdk/src/share/classes/java/lang/String.java
View File

@ -2580,7 +2580,8 @@ public final class String
}
for (int i = first; i < len; i++) {
int cp = (int)value[i];
if (cp == '\u03A3') { // GREEK CAPITAL LETTER SIGMA
if (cp == '\u03A3' || // GREEK CAPITAL LETTER SIGMA
Character.isSurrogate((char)cp)) {
return toLowerCaseEx(result, i, locale, false);
}
if (cp == '\u0130') { // LATIN CAPITAL LETTER I WITH DOT ABOVE
@ -2742,7 +2743,11 @@ public final class String
return toUpperCaseEx(result, first, locale, false);
}
for (int i = first; i < len; i++) {
int cp = Character.toUpperCaseEx((int)value[i]);
int cp = (int)value[i];
if (Character.isSurrogate((char)cp)) {
return toUpperCaseEx(result, i, locale, false);
}
cp = Character.toUpperCaseEx(cp);
if (!Character.isBmpCodePoint(cp)) { // Character.ERROR is not bmp
return toUpperCaseEx(result, i, locale, false);
}

6
jdk/src/share/classes/java/lang/System.java
View File

@ -1263,6 +1263,12 @@ public final class System {
public void invokeFinalize(Object o) throws Throwable {
o.finalize();
}
public void formatUnsignedLong(long val, int shift, char[] buf, int offset, int len) {
Long.formatUnsignedLong(val, shift, buf, offset, len);
}
public void formatUnsignedInt(int val, int shift, char[] buf, int offset, int len) {
Integer.formatUnsignedInt(val, shift, buf, offset, len);
}
});
}
}

2
jdk/src/share/classes/java/nio/StringCharBuffer.java
View File

@ -100,7 +100,7 @@ class StringCharBuffer // package-private
}
final String toString(int start, int end) {
return str.toString().substring(start + offset, end + offset);
return str.subSequence(start + offset, end + offset).toString();
}
public final CharBuffer subSequence(int start, int end) {

67
jdk/src/share/classes/java/util/UUID.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -27,6 +27,9 @@ package java.util;
import java.security.*;
import sun.misc.JavaLangAccess;
import sun.misc.SharedSecrets;
/**
* A class that represents an immutable universally unique identifier (UUID).
* A UUID represents a 128-bit value.
@ -88,6 +91,8 @@ public final class UUID implements java.io.Serializable, Comparable<UUID> {
*/
private final long leastSigBits;
private static final JavaLangAccess jla = SharedSecrets.getJavaLangAccess();
/*
* The random number generator used by this class to create random
* based UUIDs. In a holder class to defer initialization until needed.
@ -189,21 +194,35 @@ public final class UUID implements java.io.Serializable, Comparable<UUID> {
*
*/
public static UUID fromString(String name) {
String[] components = name.split("-");
if (components.length != 5)
throw new IllegalArgumentException("Invalid UUID string: "+name);
for (int i=0; i<5; i++)
components[i] = "0x"+components[i];
if (name.length() > 36) {
throw new IllegalArgumentException("UUID string too large");
}
long mostSigBits = Long.decode(components[0]).longValue();
mostSigBits <<= 16;
mostSigBits |= Long.decode(components[1]).longValue();
mostSigBits <<= 16;
mostSigBits |= Long.decode(components[2]).longValue();
int dash1 = name.indexOf('-', 0);
int dash2 = name.indexOf('-', dash1 + 1);
int dash3 = name.indexOf('-', dash2 + 1);
int dash4 = name.indexOf('-', dash3 + 1);
int dash5 = name.indexOf('-', dash4 + 1);
long leastSigBits = Long.decode(components[3]).longValue();
// For any valid input, dash1 through dash4 will be positive and dash5
// negative, but it's enough to check dash4 and dash5:
// - if dash1 is -1, dash4 will be -1
// - if dash1 is positive but dash2 is -1, dash4 will be -1
// - if dash1 and dash2 is positive, dash3 will be -1, dash4 will be
// positive, but so will dash5
if (dash4 < 0 || dash5 >= 0) {
throw new IllegalArgumentException("Invalid UUID string: " + name);
}
long mostSigBits = Long.parseLong(name, 16, 0, dash1) & 0xffffffffL;
mostSigBits <<= 16;
mostSigBits |= Long.parseLong(name, 16, dash1 + 1, dash2) & 0xffffL;
mostSigBits <<= 16;
mostSigBits |= Long.parseLong(name, 16, dash2 + 1, dash3) & 0xffffL;
long leastSigBits = Long.parseLong(name, 16, dash3 + 1, dash4) & 0xffffL;
leastSigBits <<= 48;
leastSigBits |= Long.decode(components[4]).longValue();
leastSigBits |= Long.parseLong(name, 16, dash4 + 1) & 0xffffffffffffL;
return new UUID(mostSigBits, leastSigBits);
}
@ -373,17 +392,17 @@ public final class UUID implements java.io.Serializable, Comparable<UUID> {
* @return A string representation of this {@code UUID}
*/
public String toString() {
return (digits(mostSigBits >> 32, 8) + "-" +
digits(mostSigBits >> 16, 4) + "-" +
digits(mostSigBits, 4) + "-" +
digits(leastSigBits >> 48, 4) + "-" +
digits(leastSigBits, 12));
}
/** Returns val represented by the specified number of hex digits. */
private static String digits(long val, int digits) {
long hi = 1L << (digits * 4);
return Long.toHexString(hi | (val & (hi - 1))).substring(1);
char[] chars = new char[36];
jla.formatUnsignedLong(mostSigBits >> 32, 4, chars, 0, 8);
chars[8] = '-';
jla.formatUnsignedLong(mostSigBits >> 16, 4, chars, 9, 4);
chars[13] = '-';
jla.formatUnsignedLong(mostSigBits, 4, chars, 14, 4);
chars[18] = '-';
jla.formatUnsignedLong(leastSigBits >> 48, 4, chars, 19, 4);
chars[23] = '-';
jla.formatUnsignedLong(leastSigBits, 4, chars, 24, 12);
return jla.newStringUnsafe(chars);
}
/**

2
jdk/src/share/classes/java/util/package.html
View File

@ -43,7 +43,7 @@ classes (a string tokenizer, a random-number generator, and a bit array).
<h2>Related Documentation</h2>
For overviews, tutorials, examples, guides, and tool documentation, please see:
<ul>
<li><a href="http://www.java.sun.com/docs/books/tutorial/collections/">
<li><a href="http://docs.oracle.com/javase/tutorial/collections/index.html">
<b>Collections Framework Tutorial</b></a>
<li><a
href="../../../technotes/guides/collections/designfaq.html"><b>Collections

208
jdk/src/share/classes/javax/security/auth/kerberos/EncryptionKey.java Normal file
View File

@ -0,0 +1,208 @@
/*
* Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package javax.security.auth.kerberos;
import java.util.Arrays;
import java.util.Objects;
import javax.crypto.SecretKey;
import javax.security.auth.DestroyFailedException;
/**
* This class encapsulates an EncryptionKey used in Kerberos.<p>
*
* An EncryptionKey is defined in Section 4.2.9 of the Kerberos Protocol
* Specification (<a href=http://www.ietf.org/rfc/rfc4120.txt>RFC 4120</a>) as:
* <pre>
* EncryptionKey ::= SEQUENCE {
* keytype [0] Int32 -- actually encryption type --,
* keyvalue [1] OCTET STRING
* }
* </pre>
* The key material of an {@code EncryptionKey} is defined as the value
* of the {@code keyValue} above.<p>
*
* @since 1.9
*/
public final class EncryptionKey implements SecretKey {
private static final long serialVersionUID = 9L;
/**
* {@code KeyImpl} is serialized by writing out the ASN.1 encoded bytes
* of the encryption key.
*
* @serial
*/
final private KeyImpl key;
private transient boolean destroyed = false;
/**
* Constructs a {@code EncryptionKey} from the given bytes and
* the key type.
* <p>
* The contents of the byte array are copied; subsequent modification of
* the byte array does not affect the newly created key.
*
* @param keyBytes the key material for the key
* @param keyType the key type for the key as defined by the
* Kerberos protocol specification.
* @throws NullPointerException if keyBytes is null
*/
public EncryptionKey(byte[] keyBytes, int keyType) {
key = new KeyImpl(Objects.requireNonNull(keyBytes), keyType);
}
/**
* Returns the key type for this key.
*
* @return the key type.
* @throws IllegalStateException if the key is destroyed
*/
public int getKeyType() {
// KeyImpl already checked if destroyed
return key.getKeyType();
}
/*
* Methods from java.security.Key
*/
/**
* Returns the standard algorithm name for this key. The algorithm names
* are the encryption type string defined on the IANA
* <a href="https://www.iana.org/assignments/kerberos-parameters/kerberos-parameters.xhtml#kerberos-parameters-1">Kerberos Encryption Type Numbers</a>
* page.
* <p>
* This method can return the following value not defined on the IANA page:
* <ol>
* <li>none: for etype equal to 0</li>
* <li>unknown: for etype greater than 0 but unsupported by
* the implementation</li>
* <li>private: for etype smaller than 0</li>
* </ol>
*
* @return the name of the algorithm associated with this key.
* @throws IllegalStateException if the key is destroyed
*/
@Override
public String getAlgorithm() {
// KeyImpl already checked if destroyed
return key.getAlgorithm();
}
/**
* Returns the name of the encoding format for this key.
*
* @return the String "RAW"
* @throws IllegalStateException if the key is destroyed
*/
@Override
public String getFormat() {
// KeyImpl already checked if destroyed
return key.getFormat();
}
/**
* Returns the key material of this key.
*
* @return a newly allocated byte array that contains the key material
* @throws IllegalStateException if the key is destroyed
*/
@Override
public byte[] getEncoded() {
// KeyImpl already checked if destroyed
return key.getEncoded();
}
/**
* Destroys this key by clearing out the key material of this key.
*
* @throws DestroyFailedException if some error occurs while destorying
* this key.
*/
@Override
public void destroy() throws DestroyFailedException {
if (!destroyed) {
key.destroy();
destroyed = true;
}
}
@Override
public boolean isDestroyed() {
return destroyed;
}
@Override
public String toString() {
if (destroyed) {
return "Destroyed EncryptionKey";
}
return "key " + key.toString();
}
@Override
public int hashCode() {
int result = 17;
if (isDestroyed()) {
return result;
}
result = 37 * result + Arrays.hashCode(getEncoded());
return 37 * result + getKeyType();
}
/**
* Compares the specified Object with this key for equality.
* Returns true if the given object is also a
* {@code EncryptionKey} and the two
* {@code EncryptionKey} instances are equivalent.
*
* @param other the Object to compare to
* @return true if the specified object is equal to this EncryptionKey,
* false otherwise. NOTE: Returns false if either of the EncryptionKey
* objects has been destroyed.
*/
@Override
public boolean equals(Object other) {
if (other == this)
return true;
if (! (other instanceof EncryptionKey)) {
return false;
}
EncryptionKey otherKey = ((EncryptionKey) other);
if (isDestroyed() || otherKey.isDestroyed()) {
return false;
}
return getKeyType() == otherKey.getKeyType()
&& Arrays.equals(getEncoded(), otherKey.getEncoded());
}
}

171
jdk/src/share/classes/javax/security/auth/kerberos/KerberosCredMessage.java Normal file
View File

@ -0,0 +1,171 @@
/*
* Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package javax.security.auth.kerberos;
import javax.security.auth.Destroyable;
import java.util.Arrays;
import java.util.Base64;
import java.util.Objects;
/**
* This class encapsulates a Kerberos 5 KRB_CRED message which can be used to
* send Kerberos credentials from one principal to another.<p>
*
* A KRB_CRED message is defined in Section 5.8.1 of the Kerberos Protocol
* Specification (<a href=http://www.ietf.org/rfc/rfc4120.txt>RFC 4120</a>) as:
* <pre>
* KRB-CRED ::= [APPLICATION 22] SEQUENCE {
* pvno [0] INTEGER (5),
* msg-type [1] INTEGER (22),
* tickets [2] SEQUENCE OF Ticket,
* enc-part [3] EncryptedData -- EncKrbCredPart
* }
* </pre><p>
*
* @since 1.9
*/
public final class KerberosCredMessage implements Destroyable {
final private KerberosPrincipal sender;
final private KerberosPrincipal recipient;
final private byte[] message;
private boolean destroyed = false;
/**
* Constructs a {@code KerberosCredMessage} object.
* <p>
* The contents of the {@code message} argument are copied; subsequent
* modification of the byte array does not affect the newly created object.
*
* @param sender the sender of the message
* @param recipient the recipient of the message
* @param message the DER encoded KRB_CRED message
* @throws NullPointerException if any of sender, recipient
* or message is null
*/
public KerberosCredMessage(KerberosPrincipal sender,
KerberosPrincipal recipient,
byte[] message) {
this.sender = Objects.requireNonNull(sender);
this.recipient = Objects.requireNonNull(recipient);
this.message = Objects.requireNonNull(message).clone();
}
/**
* Returns the DER encoded form of the KRB_CRED message.
*
* @return a newly allocated byte array that contains the encoded form
* @throws IllegalStateException if the object is destroyed
*/
public byte[] getEncoded() {
if (destroyed) {
throw new IllegalStateException("This object is no longer valid");
}
return message.clone();
}
/**
* Returns the sender of this message.
*
* @return the sender
* @throws IllegalStateException if the object is destroyed
*/
public KerberosPrincipal getSender() {
if (destroyed) {
throw new IllegalStateException("This object is no longer valid");
}
return sender;
}
/**
* Returns the recipient of this message.
*
* @return the recipient
* @throws IllegalStateException if the object is destroyed
*/
public KerberosPrincipal getRecipient() {
if (destroyed) {
throw new IllegalStateException("This object is no longer valid");
}
return recipient;
}
/**
* Destroys this object by clearing out the message.
*/
@Override
public void destroy() {
if (!destroyed) {
Arrays.fill(message, (byte)0);
destroyed = true;
}
}
@Override
public boolean isDestroyed() {
return destroyed;
}
@Override
public String toString() {
if (destroyed) {
return "Destroyed KerberosCredMessage";
} else {
return "KRB_CRED from " + sender + " to " + recipient + ":\n"
+ Base64.getUrlEncoder().encodeToString(message);
}
}
@Override
public int hashCode() {
if (isDestroyed()) {
return -1;
} else {
return Objects.hash(sender, recipient, Arrays.hashCode(message));
}
}
@Override
public boolean equals(Object other) {
if (other == this) {
return true;
}
if (! (other instanceof KerberosCredMessage)) {
return false;
}
KerberosCredMessage otherMessage = ((KerberosCredMessage) other);
if (isDestroyed() || otherMessage.isDestroyed()) {
return false;
}
return Objects.equals(sender, otherMessage.sender)
&& Objects.equals(recipient, otherMessage.recipient)
&& Arrays.equals(message, otherMessage.message);
}
}

63
jdk/src/share/classes/javax/security/auth/kerberos/KerberosKey.java
View File

@ -27,13 +27,27 @@ package javax.security.auth.kerberos;
import java.util.Arrays;
import javax.crypto.SecretKey;
import javax.security.auth.Destroyable;
import javax.security.auth.DestroyFailedException;
/**
* This class encapsulates a long term secret key for a Kerberos
* principal.<p>
*
* A {@code KerberosKey} object includes an EncryptionKey, a
* {@link KerberosPrincipal} as its owner, and the version number
* of the key.<p>
*
* An EncryptionKey is defined in Section 4.2.9 of the Kerberos Protocol
* Specification (<a href=http://www.ietf.org/rfc/rfc4120.txt>RFC 4120</a>) as:
* <pre>
* EncryptionKey ::= SEQUENCE {
* keytype [0] Int32 -- actually encryption type --,
* keyvalue [1] OCTET STRING
* }
* </pre>
* The key material of a {@code KerberosKey} is defined as the value
* of the {@code keyValue} above.<p>
*
* All Kerberos JAAS login modules that obtain a principal's password and
* generate the secret key from it should use this class.
* Sometimes, such as when authenticating a server in
@ -70,7 +84,7 @@ import javax.security.auth.DestroyFailedException;
* @author Mayank Upadhyay
* @since 1.4
*/
public class KerberosKey implements SecretKey, Destroyable {
public class KerberosKey implements SecretKey {
private static final long serialVersionUID = -4625402278148246993L;
@ -89,15 +103,8 @@ public class KerberosKey implements SecretKey, Destroyable {
private final int versionNum;
/**
* {@code KeyImpl} is serialized by writing out the ASN1 Encoded bytes
* {@code KeyImpl} is serialized by writing out the ASN.1 encoded bytes
* of the encryption key.
* The ASN1 encoding is defined in RFC4120 and as follows:
* <pre>
* EncryptionKey ::= SEQUENCE {
* keytype [0] Int32 -- actually encryption type --,
* keyvalue [1] OCTET STRING
* }
* </pre>
*
* @serial
*/
@ -111,7 +118,7 @@ public class KerberosKey implements SecretKey, Destroyable {
* key information from a Kerberos "keytab".
*
* @param principal the principal that this secret key belongs to
* @param keyBytes the raw bytes for the secret key
* @param keyBytes the key material for the secret key
* @param keyType the key type for the secret key as defined by the
* Kerberos protocol specification.
* @param versionNum the version number of this secret key
@ -153,10 +160,12 @@ public class KerberosKey implements SecretKey, Destroyable {
* Returns the principal that this key belongs to.
*
* @return the principal this key belongs to.
* @throws IllegalStateException if the key is destroyed
*/
public final KerberosPrincipal getPrincipal() {
if (destroyed)
if (destroyed) {
throw new IllegalStateException("This key is no longer valid");
}
return principal;
}
@ -164,10 +173,12 @@ public class KerberosKey implements SecretKey, Destroyable {
* Returns the key version number.
*
* @return the key version number.
* @throws IllegalStateException if the key is destroyed
*/
public final int getVersionNumber() {
if (destroyed)
if (destroyed) {
throw new IllegalStateException("This key is no longer valid");
}
return versionNum;
}
@ -175,10 +186,10 @@ public class KerberosKey implements SecretKey, Destroyable {
* Returns the key type for this long-term key.
*
* @return the key type.
* @throws IllegalStateException if the key is destroyed
*/
public final int getKeyType() {
if (destroyed)
throw new IllegalStateException("This key is no longer valid");
// KeyImpl already checked if destroyed
return key.getKeyType();
}
@ -201,10 +212,10 @@ public class KerberosKey implements SecretKey, Destroyable {
* </ol>
*
* @return the name of the algorithm associated with this key.
* @throws IllegalStateException if the key is destroyed
*/
public final String getAlgorithm() {
if (destroyed)
throw new IllegalStateException("This key is no longer valid");
// KeyImpl already checked if destroyed
return key.getAlgorithm();
}
@ -212,10 +223,10 @@ public class KerberosKey implements SecretKey, Destroyable {
* Returns the name of the encoding format for this secret key.
*
* @return the String "RAW"
* @throws IllegalStateException if the key is destroyed
*/
public final String getFormat() {
if (destroyed)
throw new IllegalStateException("This key is no longer valid");
// KeyImpl already checked if destroyed
return key.getFormat();
}
@ -223,16 +234,15 @@ public class KerberosKey implements SecretKey, Destroyable {
* Returns the key material of this secret key.
*
* @return the key material
* @throws IllegalStateException if the key is destroyed
*/
public final byte[] getEncoded() {
if (destroyed)
throw new IllegalStateException("This key is no longer valid");
// KeyImpl already checked if destroyed
return key.getEncoded();
}
/**
* Destroys this key. A call to any of its other methods after this
* will cause an IllegalStateException to be thrown.
* Destroys this key by clearing out the key material of this secret key.
*
* @throws DestroyFailedException if some error occurs while destorying
* this key.
@ -253,9 +263,9 @@ public class KerberosKey implements SecretKey, Destroyable {
public String toString() {
if (destroyed) {
return "Destroyed Principal";
return "Destroyed KerberosKey";
}
return "Kerberos Principal " + principal.toString() +
return "Kerberos Principal " + principal +
"Key Version " + versionNum +
"key " + key.toString();
}
@ -293,8 +303,9 @@ public class KerberosKey implements SecretKey, Destroyable {
*/
public boolean equals(Object other) {
if (other == this)
if (other == this) {
return true;
}
if (! (other instanceof KerberosKey)) {
return false;

123
jdk/src/share/classes/javax/security/auth/kerberos/KerberosTicket.java
View File

@ -35,9 +35,6 @@ import javax.security.auth.Destroyable;
import javax.security.auth.RefreshFailedException;
import javax.security.auth.DestroyFailedException;
import sun.misc.HexDumpEncoder;
import sun.security.krb5.EncryptionKey;
import sun.security.krb5.Asn1Exception;
import sun.security.util.*;
/**
* This class encapsulates a Kerberos ticket and associated
@ -253,9 +250,10 @@ public class KerberosTicket implements Destroyable, Refreshable,
Date endTime,
Date renewTill,
InetAddress[] clientAddresses) {
if (sessionKey == null)
throw new IllegalArgumentException("Session key for ticket"
+ " cannot be null");
if (sessionKey == null) {
throw new IllegalArgumentException("Session key for ticket"
+ " cannot be null");
}
init(asn1Encoding, client, server,
new KeyImpl(sessionKey, keyType), flags, authTime,
startTime, endTime, renewTill, clientAddresses);
@ -271,41 +269,46 @@ public class KerberosTicket implements Destroyable, Refreshable,
Date endTime,
Date renewTill,
InetAddress[] clientAddresses) {
if (asn1Encoding == null)
throw new IllegalArgumentException("ASN.1 encoding of ticket"
+ " cannot be null");
if (asn1Encoding == null) {
throw new IllegalArgumentException("ASN.1 encoding of ticket"
+ " cannot be null");
}
this.asn1Encoding = asn1Encoding.clone();
if (client == null)
throw new IllegalArgumentException("Client name in ticket"
+ " cannot be null");
if (client == null) {
throw new IllegalArgumentException("Client name in ticket"
+ " cannot be null");
}
this.client = client;
if (server == null)
throw new IllegalArgumentException("Server name in ticket"
+ " cannot be null");
if (server == null) {
throw new IllegalArgumentException("Server name in ticket"
+ " cannot be null");
}
this.server = server;
// Caller needs to make sure `sessionKey` will not be null
this.sessionKey = sessionKey;
if (flags != null) {
if (flags.length >= NUM_FLAGS)
this.flags = flags.clone();
else {
if (flags.length >= NUM_FLAGS) {
this.flags = flags.clone();
} else {
this.flags = new boolean[NUM_FLAGS];
// Fill in whatever we have
for (int i = 0; i < flags.length; i++)
for (int i = 0; i < flags.length; i++) {
this.flags[i] = flags[i];
}
}
} else
this.flags = new boolean[NUM_FLAGS];
} else {
this.flags = new boolean[NUM_FLAGS];
}
if (this.flags[RENEWABLE_TICKET_FLAG]) {
if (renewTill == null)
throw new IllegalArgumentException("The renewable period "
if (renewTill == null) {
throw new IllegalArgumentException("The renewable period "
+ "end time cannot be null for renewable tickets.");
}
this.renewTill = new Date(renewTill.getTime());
}
@ -318,13 +321,15 @@ public class KerberosTicket implements Destroyable, Refreshable,
this.startTime = this.authTime;
}
if (endTime == null)
throw new IllegalArgumentException("End time for ticket validity"
+ " cannot be null");
if (endTime == null) {
throw new IllegalArgumentException("End time for ticket validity"
+ " cannot be null");
}
this.endTime = new Date(endTime.getTime());
if (clientAddresses != null)
this.clientAddresses = clientAddresses.clone();
if (clientAddresses != null) {
this.clientAddresses = clientAddresses.clone();
}
}
/**
@ -346,14 +351,17 @@ public class KerberosTicket implements Destroyable, Refreshable,
}
/**
* Returns the session key associated with this ticket.
* Returns the session key associated with this ticket. The return value
* is always a {@link EncryptionKey} object.
*
* @return the session key.
*/
public final SecretKey getSessionKey() {
if (destroyed)
if (destroyed) {
throw new IllegalStateException("This ticket is no longer valid");
return sessionKey;
}
return new EncryptionKey(
sessionKey.getEncoded(), sessionKey.getKeyType());
}
/**
@ -366,8 +374,9 @@ public class KerberosTicket implements Destroyable, Refreshable,
* @see #getSessionKey()
*/
public final int getSessionKeyType() {
if (destroyed)
if (destroyed) {
throw new IllegalStateException("This ticket is no longer valid");
}
return sessionKey.getKeyType();
}
@ -508,8 +517,9 @@ public class KerberosTicket implements Destroyable, Refreshable,
* @return an ASN.1 encoding of the entire ticket.
*/
public final byte[] getEncoded() {
if (destroyed)
if (destroyed) {
throw new IllegalStateException("This ticket is no longer valid");
}
return asn1Encoding.clone();
}
@ -539,16 +549,17 @@ public class KerberosTicket implements Destroyable, Refreshable,
*/
public void refresh() throws RefreshFailedException {
if (destroyed)
if (destroyed) {
throw new RefreshFailedException("A destroyed ticket "
+ "cannot be renewd.");
if (!isRenewable())
+ "cannot be renewd.");
}
if (!isRenewable()) {
throw new RefreshFailedException("This ticket is not renewable");
if (System.currentTimeMillis() > getRenewTill().getTime())
}
if (System.currentTimeMillis() > getRenewTill().getTime()) {
throw new RefreshFailedException("This ticket is past "
+ "its last renewal time.");
+ "its last renewal time.");
}
Throwable e = null;
sun.security.krb5.Credentials krb5Creds = null;
@ -634,8 +645,9 @@ public class KerberosTicket implements Destroyable, Refreshable,
}
public String toString() {
if (destroyed)
throw new IllegalStateException("This ticket is no longer valid");
if (destroyed) {
return "Destroyed KerberosTicket";
}
StringBuilder caddrString = new StringBuilder();
if (clientAddresses != null) {
for (int i = 0; i < clientAddresses.length; i++) {
@ -715,8 +727,9 @@ public class KerberosTicket implements Destroyable, Refreshable,
*/
public boolean equals(Object other) {
if (other == this)
if (other == this) {
return true;
}
if (! (other instanceof KerberosTicket)) {
return false;
@ -731,7 +744,7 @@ public class KerberosTicket implements Destroyable, Refreshable,
!endTime.equals(otherTicket.getEndTime()) ||
!server.equals(otherTicket.getServer()) ||
!client.equals(otherTicket.getClient()) ||
!sessionKey.equals(otherTicket.getSessionKey()) ||
!sessionKey.equals(otherTicket.sessionKey) ||
!Arrays.equals(clientAddresses, otherTicket.getClientAddresses()) ||
!Arrays.equals(flags, otherTicket.getFlags())) {
return false;
@ -739,35 +752,41 @@ public class KerberosTicket implements Destroyable, Refreshable,
// authTime may be null
if (authTime == null) {
if (otherTicket.getAuthTime() != null)
if (otherTicket.getAuthTime() != null) {
return false;
}
} else {
if (!authTime.equals(otherTicket.getAuthTime()))
if (!authTime.equals(otherTicket.getAuthTime())) {
return false;
}
}
// startTime may be null
if (startTime == null) {
if (otherTicket.getStartTime() != null)
if (otherTicket.getStartTime() != null) {
return false;
}
} else {
if (!startTime.equals(otherTicket.getStartTime()))
if (!startTime.equals(otherTicket.getStartTime())) {
return false;
}
}
if (renewTill == null) {
if (otherTicket.getRenewTill() != null)
if (otherTicket.getRenewTill() != null) {
return false;
}
} else {
if (!renewTill.equals(otherTicket.getRenewTill()))
if (!renewTill.equals(otherTicket.getRenewTill())) {
return false;
}
}
return true;
}
private void readObject(ObjectInputStream s)
throws IOException, ClassNotFoundException {
throws IOException, ClassNotFoundException {
s.defaultReadObject();
if (sessionKey == null) {
throw new InvalidObjectException("Session key cannot be null");

6
jdk/src/share/classes/org/jcp/xml/dsig/internal/dom/DOMKeyValue.java
View File

@ -364,7 +364,7 @@ public abstract class DOMKeyValue extends DOMStructure implements KeyValue {
}
void getMethods() throws ClassNotFoundException, NoSuchMethodException {
Class<?> c = Class.forName("sun.security.ec.ECParameters");
Class<?> c = Class.forName("sun.security.util.ECParameters");
Class<?>[] params = new Class<?>[] { ECPoint.class,
EllipticCurve.class };
encodePoint = c.getMethod("encodePoint", params);
@ -372,7 +372,7 @@ public abstract class DOMKeyValue extends DOMStructure implements KeyValue {
getCurveName = c.getMethod("getCurveName", params);
params = new Class<?>[] { byte[].class, EllipticCurve.class };
decodePoint = c.getMethod("decodePoint", params);
c = Class.forName("sun.security.ec.NamedCurve");
c = Class.forName("sun.security.util.NamedCurve");
params = new Class<?>[] { String.class };
getECParameterSpec = c.getMethod("getECParameterSpec", params);
}
@ -477,7 +477,7 @@ public abstract class DOMKeyValue extends DOMStructure implements KeyValue {
throw new MarshalException(ite);
}
/*
ecPoint = sun.security.ec.ECParameters.decodePoint(
ecPoint = sun.security.util.ECParameters.decodePoint(
Base64.decode(curElem), ecParams.getCurve());
*/
ECPublicKeySpec spec = new ECPublicKeySpec(ecPoint, ecParams);

10
jdk/src/share/classes/sun/misc/JavaLangAccess.java
View File

@ -132,4 +132,14 @@ public interface JavaLangAccess {
* Invokes the finalize method of the given object.
*/
void invokeFinalize(Object o) throws Throwable;
/**
* Invokes Long.formatUnsignedLong(long val, int shift, char[] buf, int offset, int len)
*/
void formatUnsignedLong(long val, int shift, char[] buf, int offset, int len);
/**
* Invokes Integer.formatUnsignedInt(long val, int shift, char[] buf, int offset, int len)
*/
void formatUnsignedInt(int val, int shift, char[] buf, int offset, int len);
}

18
jdk/src/share/classes/sun/nio/cs/ext/ExtendedCharsets.java
View File

@ -1173,8 +1173,7 @@ public class ExtendedCharsets
if (!sun.misc.VM.isBooted())
return;
String map = AccessController.doPrivileged(
(PrivilegedAction<String>) () -> System.getProperty("sun.nio.cs.map"));
String map = getProperty("sun.nio.cs.map");
boolean sjisIsMS932 = false;
boolean iso2022jpIsMS50221 = false;
boolean iso2022jpIsMS50220 = false;
@ -1294,8 +1293,7 @@ public class ExtendedCharsets
}
}
String osName = AccessController.doPrivileged(
(PrivilegedAction<String>) () -> System.getProperty("os.name"));
String osName = getProperty("os.name");
if ("SunOS".equals(osName) || "Linux".equals(osName) || "AIX".equals(osName)
|| osName.contains("OS X")) {
charset("x-COMPOUND_TEXT", "COMPOUND_TEXT",
@ -1308,6 +1306,18 @@ public class ExtendedCharsets
initialized = true;
}
private static String getProperty(String key) {
// this method may be called during initialization of
// system class loader and thus not using lambda
return AccessController.doPrivileged(
new PrivilegedAction<String>() {
@Override
public String run() {
return System.getProperty(key);
}
});
}
public static String[] aliasesFor(String charsetName) {
if (instance == null)
return null;

3
jdk/src/share/classes/sun/security/ec/ECKeyPairGenerator.java
View File

@ -32,11 +32,10 @@ import java.security.spec.ECGenParameterSpec;
import java.security.spec.ECParameterSpec;
import java.security.spec.ECPoint;
import sun.security.ec.NamedCurve;
import sun.security.ec.ECParameters;
import sun.security.ec.ECPrivateKeyImpl;
import sun.security.ec.ECPublicKeyImpl;
import sun.security.jca.JCAUtil;
import sun.security.util.ECParameters;
import sun.security.util.ECUtil;
/**

6
jdk/src/share/classes/sun/security/ec/ECPrivateKeyImpl.java
View File

@ -32,7 +32,11 @@ import java.security.*;
import java.security.interfaces.*;
import java.security.spec.*;
import sun.security.util.*;
import sun.security.util.DerInputStream;
import sun.security.util.DerOutputStream;
import sun.security.util.DerValue;
import sun.security.util.ECParameters;
import sun.security.util.ECUtil;
import sun.security.x509.AlgorithmId;
import sun.security.pkcs.PKCS8Key;

4
jdk/src/share/classes/sun/security/ec/ECPublicKeyImpl.java
View File

@ -31,7 +31,9 @@ import java.security.*;
import java.security.interfaces.*;
import java.security.spec.*;
import sun.security.util.*;
import sun.security.util.ECParameters;
import sun.security.util.ECUtil;
import sun.security.x509.*;
/**

6
jdk/src/share/classes/sun/security/ec/SunECEntries.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2009, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2009, 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -29,6 +29,8 @@ import java.util.Collection;
import java.util.Map;
import java.util.regex.Pattern;
import sun.security.util.CurveDB;
import sun.security.util.NamedCurve;
/**
* Defines the entries of the SunEC provider.
@ -55,7 +57,7 @@ final class SunECEntries {
/*
* Algorithm Parameter engine
*/
map.put("AlgorithmParameters.EC", "sun.security.ec.ECParameters");
map.put("AlgorithmParameters.EC", "sun.security.util.ECParameters");
map.put("Alg.Alias.AlgorithmParameters.EllipticCurve", "EC");
map.put("Alg.Alias.AlgorithmParameters.1.2.840.10045.2.1", "EC");

38
jdk/src/share/classes/sun/security/jgss/krb5/Krb5Context.java
View File

@ -40,11 +40,13 @@ import java.security.Provider;
import java.security.AccessController;
import java.security.AccessControlContext;
import java.security.Key;
import java.security.PrivilegedExceptionAction;
import java.security.PrivilegedActionException;
import javax.crypto.Cipher;
import java.security.PrivilegedExceptionAction;
import javax.security.auth.Subject;
import javax.security.auth.kerberos.*;
import javax.security.auth.kerberos.ServicePermission;
import javax.security.auth.kerberos.KerberosCredMessage;
import javax.security.auth.kerberos.KerberosPrincipal;
import javax.security.auth.kerberos.KerberosTicket;
import sun.security.krb5.internal.Ticket;
/**
@ -118,6 +120,7 @@ class Krb5Context implements GSSContextSpi {
// XXX See if the required info from these can be extracted and
// stored elsewhere
private Credentials tgt;
private Credentials serviceCreds;
private KrbApReq apReq;
Ticket serviceTicket;
@ -616,7 +619,6 @@ class Krb5Context implements GSSContextSpi {
"No TGT available");
}
myName = (Krb5NameElement) myCred.getName();
Credentials tgt;
final Krb5ProxyCredential second;
if (myCred instanceof Krb5InitCredential) {
second = null;
@ -750,7 +752,6 @@ class Krb5Context implements GSSContextSpi {
// No need to write anything;
// just validate the incoming token
new AcceptSecContextToken(this, serviceCreds, apReq, is);
serviceCreds = null;
apReq = null;
state = STATE_DONE;
} else {
@ -1304,6 +1305,9 @@ class Krb5Context implements GSSContextSpi {
public final void dispose() throws GSSException {
state = STATE_DELETED;
delegatedCred = null;
tgt = null;
serviceCreds = null;
key = null;
}
public final Provider getProvider() {
@ -1424,6 +1428,9 @@ class Krb5Context implements GSSContextSpi {
switch (type) {
case KRB5_GET_SESSION_KEY:
return new KerberosSessionKey(key);
case KRB5_GET_SESSION_KEY_EX:
return new javax.security.auth.kerberos.EncryptionKey(
key.getBytes(), key.getEType());
case KRB5_GET_TKT_FLAGS:
return tktFlags.clone();
case KRB5_GET_AUTHZ_DATA:
@ -1435,6 +1442,26 @@ class Krb5Context implements GSSContextSpi {
}
case KRB5_GET_AUTHTIME:
return authTime;
case KRB5_GET_KRB_CRED:
if (!isInitiator()) {
throw new GSSException(GSSException.UNAVAILABLE, -1,
"KRB_CRED not available on acceptor side.");
}
KerberosPrincipal sender = new KerberosPrincipal(
myName.getKrb5PrincipalName().getName());
KerberosPrincipal recipient = new KerberosPrincipal(
peerName.getKrb5PrincipalName().getName());
try {
byte[] krbCred = new KrbCred(tgt, serviceCreds, key)
.getMessage();
return new KerberosCredMessage(
sender, recipient, krbCred);
} catch (KrbException | IOException e) {
GSSException gsse = new GSSException(GSSException.UNAVAILABLE, -1,
"KRB_CRED not generated correctly.");
gsse.initCause(e);
throw gsse;
}
}
throw new GSSException(GSSException.UNAVAILABLE, -1,
"Inquire type not supported.");
@ -1456,4 +1483,5 @@ class Krb5Context implements GSSContextSpi {
public void setAuthzData(com.sun.security.jgss.AuthorizationDataEntry[] authzData) {
this.authzData = authzData;
}
}

4
jdk/src/share/classes/sun/security/jgss/krb5/Krb5InitCredential.java
View File

@ -29,8 +29,8 @@ import org.ietf.jgss.*;
import sun.security.jgss.GSSCaller;
import sun.security.jgss.spi.*;
import sun.security.krb5.*;
import sun.security.krb5.Config;
import javax.security.auth.kerberos.*;
import javax.security.auth.kerberos.KerberosTicket;
import javax.security.auth.kerberos.KerberosPrincipal;
import java.net.InetAddress;
import java.io.IOException;
import java.util.Date;

45
jdk/src/share/classes/sun/security/jgss/spnego/SpNegoContext.java
View File

@ -523,13 +523,6 @@ public class SpNegoContext implements GSSContextSpi {
valid = false;
}
// get the mechanism token
byte[] mechToken = initToken.getMechToken();
if (mechToken == null) {
throw new GSSException(GSSException.FAILURE, -1,
"mechToken is missing");
}
/*
* Select the best match between the list of mechs
* that the initiator requested and the list that
@ -545,7 +538,19 @@ public class SpNegoContext implements GSSContextSpi {
internal_mech = mech_wanted;
// get the token for mechanism
byte[] accept_token = GSS_acceptSecContext(mechToken);
byte[] accept_token;
if (mechList[0].equals(mech_wanted)) {
// get the mechanism token
byte[] mechToken = initToken.getMechToken();
if (mechToken == null) {
throw new GSSException(GSSException.FAILURE, -1,
"mechToken is missing");
}
accept_token = GSS_acceptSecContext(mechToken);
} else {
accept_token = null;
}
// verify MIC
if (!GSSUtil.useMSInterop() && valid) {
@ -594,9 +599,27 @@ public class SpNegoContext implements GSSContextSpi {
retVal = targToken.getEncoded();
} else if (state == STATE_IN_PROCESS) {
// read data
byte[] token = new byte[is.available()];
SpNegoToken.readFully(is, token);
if (DEBUG) {
System.out.println("SpNegoContext.acceptSecContext: " +
"receiving token = " +
SpNegoToken.getHexBytes(token));
}
// read the SPNEGO token
// token will be validated when parsing
NegTokenTarg inputToken = new NegTokenTarg(token);
if (DEBUG) {
System.out.println("SpNegoContext.acceptSecContext: " +
"received token of type = " +
SpNegoToken.getTokenName(inputToken.getType()));
}
// read the token
byte[] client_token = new byte[is.available()];
SpNegoToken.readFully(is, client_token);
byte[] client_token = inputToken.getResponseToken();
byte[] accept_token = GSS_acceptSecContext(client_token);
if (accept_token == null) {
valid = false;
@ -1055,7 +1078,7 @@ public class SpNegoContext implements GSSContextSpi {
* This is only valid on the acceptor side of the context.
* @return GSSCredentialSpi object for the delegated credential
* @exception GSSException
* @see GSSContext#getDelegCredState
* @see GSSContext#getCredDelegState
*/
public final GSSCredentialSpi getDelegCred() throws GSSException {
if (state != STATE_IN_PROCESS && state != STATE_DONE)

2
jdk/src/share/classes/sun/security/pkcs11/P11KeyStore.java
View File

@ -67,8 +67,6 @@ import sun.security.util.Debug;
import sun.security.util.DerValue;
import sun.security.util.ECUtil;
import sun.security.ec.ECParameters;
import sun.security.pkcs11.Secmod.*;
import static sun.security.pkcs11.P11Util.*;

4
jdk/src/share/classes/sun/security/pkcs11/SunPKCS11.java
View File

@ -593,7 +593,7 @@ public final class SunPKCS11 extends AuthProvider {
// AlgorithmParameters for EC.
// Only needed until we have an EC implementation in the SUN provider.
d(AGP, "EC", "sun.security.ec.ECParameters",
d(AGP, "EC", "sun.security.util.ECParameters",
s("1.2.840.10045.2.1"),
m(CKM_EC_KEY_PAIR_GEN, CKM_ECDH1_DERIVE,
CKM_ECDSA, CKM_ECDSA_SHA1));
@ -1032,7 +1032,7 @@ public final class SunPKCS11 extends AuthProvider {
} else if (type == KS) {
return token.getKeyStore();
} else if (type == AGP) {
return new sun.security.ec.ECParameters();
return new sun.security.util.ECParameters();
} else {
throw new NoSuchAlgorithmException("Unknown type: " + type);
}

2
jdk/src/share/classes/sun/security/ssl/SupportedEllipticCurvesExtension.java
View File

@ -176,7 +176,7 @@ final class SupportedEllipticCurvesExtension extends HelloExtension {
private final static int ARBITRARY_PRIME = 0xff01;
private final static int ARBITRARY_CHAR2 = 0xff02;
// See sun.security.ec.NamedCurve for the OIDs
// See sun.security.util.NamedCurve for the OIDs
private final static String[] NAMED_CURVE_OID_TABLE = new String[] {
null, // (0) unused
"1.3.132.0.1", // (1) sect163k1, NIST K-163

8
jdk/src/share/classes/sun/security/ec/CurveDB.java → jdk/src/share/classes/sun/security/util/CurveDB.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2006, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2006, 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -23,7 +23,7 @@
* questions.
*/
package sun.security.ec;
package sun.security.util;
import java.math.BigInteger;
@ -54,10 +54,10 @@ public class CurveDB {
private static Collection<? extends NamedCurve> specCollection;
static final String SPLIT_PATTERN = ",|\\[|\\]";
public static final String SPLIT_PATTERN = ",|\\[|\\]";
// Used by SunECEntries
static Collection<? extends NamedCurve>getSupportedCurves() {
public static Collection<? extends NamedCurve>getSupportedCurves() {
return specCollection;
}

8
jdk/src/share/classes/sun/security/ec/ECParameters.java → jdk/src/share/classes/sun/security/util/ECParameters.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2006, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2006, 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -23,15 +23,13 @@
* questions.
*/
package sun.security.ec;
package sun.security.util;
import java.io.IOException;
import java.security.*;
import java.security.spec.*;
import sun.security.util.*;
/**
* This class implements encoding and decoding of Elliptic Curve parameters
* as specified in RFC 3279.
@ -77,7 +75,7 @@ import sun.security.util.*;
public final class ECParameters extends AlgorithmParametersSpi {
// used by ECPublicKeyImpl and ECPrivateKeyImpl
static AlgorithmParameters getAlgorithmParameters(ECParameterSpec spec)
public static AlgorithmParameters getAlgorithmParameters(ECParameterSpec spec)
throws InvalidKeyException {
try {
AlgorithmParameters params =

15
jdk/src/share/classes/sun/security/ec/NamedCurve.java → jdk/src/share/classes/sun/security/util/NamedCurve.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2006, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2006, 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -23,16 +23,13 @@
* questions.
*/
package sun.security.ec;
package sun.security.util;
import java.io.IOException;
import java.math.BigInteger;
import java.security.spec.*;
import sun.security.util.DerOutputStream;
import sun.security.util.ObjectIdentifier;
/**
* Contains Elliptic Curve parameters.
@ -40,7 +37,7 @@ import sun.security.util.ObjectIdentifier;
* @since 1.6
* @author Andreas Sterbenz
*/
class NamedCurve extends ECParameterSpec {
public final class NamedCurve extends ECParameterSpec {
// friendly name for toString() output
private final String name;
@ -68,15 +65,15 @@ class NamedCurve extends ECParameterSpec {
encoded = out.toByteArray();
}
String getName() {
public String getName() {
return name;
}
byte[] getEncoded() {
public byte[] getEncoded() {
return encoded.clone();
}
String getObjectId() {
public String getObjectId() {
return oid;
}

5
jdk/src/windows/native/sun/tools/attach/WindowsVirtualMachine.c
View File

@ -388,6 +388,7 @@ JNIEXPORT void JNICALL Java_sun_tools_attach_WindowsVirtualMachine_enqueue
if (argsLen > 0) {
if (argsLen > MAX_ARGS) {
JNU_ThrowInternalError(env, "Too many arguments");
return;
}
for (i=0; i<argsLen; i++) {
jobject obj = (*env)->GetObjectArrayElement(env, args, i);
@ -423,6 +424,8 @@ JNIEXPORT void JNICALL Java_sun_tools_attach_WindowsVirtualMachine_enqueue
stubLen = (DWORD)(*env)->GetArrayLength(env, stub);
stubCode = (*env)->GetByteArrayElements(env, stub, &isCopy);
if ((*env)->ExceptionOccurred(env)) return;
pCode = (PDWORD) VirtualAllocEx( hProcess, 0, stubLen, MEM_COMMIT, PAGE_EXECUTE_READWRITE );
if (pCode == NULL) {
JNU_ThrowIOExceptionWithLastError(env, "VirtualAllocEx failed");
@ -592,6 +595,8 @@ static void jstring_to_cstring(JNIEnv* env, jstring jstr, char* cstr, int len) {
cstr[0] = '\0';
} else {
str = JNU_GetStringPlatformChars(env, jstr, &isCopy);
if ((*env)->ExceptionOccurred(env)) return;
strncpy(cstr, str, len);
cstr[len-1] = '\0';
if (isCopy) {

122
jdk/test/java/lang/Integer/ParsingTest.java
View File

@ -23,29 +23,37 @@
/*
* @test
* @bug 5017980 6576055
* @bug 5017980 6576055 8041972
* @summary Test parsing methods
* @author Joseph D. Darcy
*/
import java.lang.IllegalArgumentException;
import java.lang.IndexOutOfBoundsException;
import java.lang.NullPointerException;
import java.lang.RuntimeException;
/**
* There are six methods in java.lang.Integer which transform strings
* There are eight methods in java.lang.Integer which transform strings
* into an int or Integer value:
*
* public Integer(String s)
* public static Integer decode(String nm)
* public static int parseInt(CharSequence s, int radix, int beginIndex, int endIndex)
* public static int parseInt(CharSequence s, int radix, int beginIndex)
* public static int parseInt(String s, int radix)
* public static int parseInt(String s)
* public static Integer valueOf(String s, int radix)
* public static Integer valueOf(String s)
*
* Besides decode, all the methods and constructor call down into
* parseInt(String, int) to do the actual work. Therefore, the
* behavior of parseInt(String, int) will be tested here.
* parseInt(CharSequence, int, int, int) to do the actual work. Therefore, the
* behavior of parseInt(CharSequence, int, int, int) will be tested here.
*
*/
public class ParsingTest {
public static void main(String... argv) {
check("+100", +100);
check("-100", -100);
@ -55,10 +63,14 @@ public class ParsingTest {
check("+00000", 0);
check("-00000", 0);
check("+00000", 0, 0, 6);
check("-00000", 0, 0, 6);
check("0", 0);
check("1", 1);
check("9", 9);
checkFailure("");
checkFailure("\u0000");
checkFailure("\u002f");
checkFailure("+");
@ -72,12 +84,45 @@ public class ParsingTest {
checkFailure("+-6");
checkFailure("-+6");
checkFailure("*100");
check("test-00000", 0, 4, 10);
check("test-12345", -12345, 4, 10);
check("xx12345yy", 12345, 2, 7);
checkNumberFormatException("", 10, 0);
checkNumberFormatException("100", 10, 3);
checkNumberFormatException("+1000000", 10, 8);
checkNumberFormatException("-1000000", 10, 8);
checkNumberFormatException("", 10, 0, 0);
checkNumberFormatException("+-6", 10, 0, 3);
checkNumberFormatException("1000000", 10, 7);
checkNumberFormatException("1000000", 10, 7, 7);
checkNumberFormatException("1000000", Character.MAX_RADIX + 1, 0, 2);
checkNumberFormatException("1000000", Character.MIN_RADIX - 1, 0, 2);
checkIndexOutOfBoundsException("1000000", 10, 8);
checkIndexOutOfBoundsException("1000000", 10, -1);
checkIndexOutOfBoundsException("1000000", 10, 10, 4);
checkIndexOutOfBoundsException("1000000", Character.MAX_RADIX + 1, -1, 2);
checkIndexOutOfBoundsException("1000000", Character.MIN_RADIX - 1, -1, 2);
checkIndexOutOfBoundsException("1000000", Character.MAX_RADIX + 1, 10, 2);
checkIndexOutOfBoundsException("1000000", Character.MIN_RADIX - 1, 10, 2);
checkIndexOutOfBoundsException("-1", 10, 0, 3);
checkIndexOutOfBoundsException("-1", 10, 2, 3);
checkIndexOutOfBoundsException("-1", 10, -1, 2);
checkNull(10, 0, 1);
checkNull(10, -1, 0);
checkNull(10, 0, 0);
checkNull(10, 0, -1);
checkNull(-1, -1, -1);
}
private static void check(String val, int expected) {
int n = Integer.parseInt(val);
if (n != expected)
throw new RuntimeException("Integer.parsedInt failed. String:" +
throw new RuntimeException("Integer.parseInt failed. String:" +
val + " Result:" + n);
}
@ -91,4 +136,71 @@ public class ParsingTest {
; // Expected
}
}
private static void checkNumberFormatException(String val, int radix, int start) {
int n = 0;
try {
n = Integer.parseInt(val, radix, start);
System.err.println("parseInt(" + val + ", " + radix + ", " + start +
") incorrectly returned " + n);
throw new RuntimeException();
} catch (NumberFormatException nfe) {
; // Expected
}
}
private static void checkNumberFormatException(String val, int radix, int start, int end) {
int n = 0;
try {
n = Integer.parseInt(val, radix, start, end);
System.err.println("parseInt(" + val + ", " + radix + ", " + start + ", " + end +
") incorrectly returned " + n);
throw new RuntimeException();
} catch (NumberFormatException nfe) {
; // Expected
}
}
private static void checkIndexOutOfBoundsException(String val, int radix, int start) {
int n = 0;
try {
n = Integer.parseInt(val, radix, start);
System.err.println("parseInt(" + val + ", " + radix + ", " + start +
") incorrectly returned " + n);
throw new RuntimeException();
} catch (IndexOutOfBoundsException ioob) {
; // Expected
}
}
private static void checkIndexOutOfBoundsException(String val, int radix, int start, int end) {
int n = 0;
try {
n = Integer.parseInt(val, radix, start, end);
System.err.println("parseInt(" + val + ", " + radix + ", " + start + ", " + end +
") incorrectly returned " + n);
throw new RuntimeException();
} catch (IndexOutOfBoundsException ioob) {
; // Expected
}
}
private static void checkNull(int radix, int start, int end) {
int n = 0;
try {
n = Integer.parseInt(null, 10, start, end);
System.err.println("parseInt(null, " + radix + ", " + start + ", " + end +
") incorrectly returned " + n);
throw new RuntimeException();
} catch (NullPointerException npe) {
; // Expected
}
}
private static void check(String val, int expected, int start, int end) {
int n = Integer.parseInt(val, 10, start, end);
if (n != expected)
throw new RuntimeException("Integer.parsedInt failed. String:" +
val + ", start: " + start + ", end: " + end + " Result:" + n);
}
}

114
jdk/test/java/lang/Long/ParsingTest.java
View File

@ -23,29 +23,31 @@
/*
* @test
* @bug 5017980 6576055
* @bug 5017980 6576055 8041972
* @summary Test parsing methods
* @author Joseph D. Darcy
*/
/**
* There are six methods in java.lang.Long which transform strings
* There are eight methods in java.lang.Long which transform strings
* into a long or Long value:
*
* public Long(String s)
* public static Long decode(String nm)
* public static long parseLong(CharSequence s, int radix, int beginIndex, int endIndex)
* public static long parseLong(CharSequence s, int radix, int beginIndex)
* public static long parseLong(String s, int radix)
* public static long parseLong(String s)
* public static Long valueOf(String s, int radix)
* public static Long valueOf(String s)
*
* Besides decode, all the methods and constructor call down into
* parseLong(String, int) to do the actual work. Therefore, the
* behavior of parseLong(String, int) will be tested here.
* parseLong(CharSequence, int, int, int) to do the actual work. Therefore, the
* behavior of parseLong(CharSequence, int, int, int) will be tested here.
*/
public class ParsingTest {
public static void main(String... argv) {
check("+100", +100L);
check("-100", -100L);
@ -59,6 +61,7 @@ public class ParsingTest {
check("1", 1L);
check("9", 9L);
checkFailure("");
checkFailure("\u0000");
checkFailure("\u002f");
checkFailure("+");
@ -72,12 +75,44 @@ public class ParsingTest {
checkFailure("+-6");
checkFailure("-+6");
checkFailure("*100");
check("test-00000", 0L, 4, 10);
check("test-12345", -12345L, 4, 10);
check("xx12345yy", 12345L, 2, 7);
check("xx123456789012345yy", 123456789012345L, 2, 17);
checkNumberFormatException("100", 10, 3);
checkNumberFormatException("", 10, 0);
checkNumberFormatException("+1000000", 10, 8);
checkNumberFormatException("-1000000", 10, 8);
checkNumberFormatException("", 10, 0, 0);
checkNumberFormatException("+-6", 10, 0, 3);
checkNumberFormatException("1000000", 10, 7, 7);
checkNumberFormatException("1000000", Character.MAX_RADIX + 1, 0, 2);
checkNumberFormatException("1000000", Character.MIN_RADIX - 1, 0, 2);
checkIndexOutOfBoundsException("", 10, 1, 1);
checkIndexOutOfBoundsException("1000000", 10, 10, 4);
checkIndexOutOfBoundsException("1000000", Character.MAX_RADIX + 1, 10, 2);
checkIndexOutOfBoundsException("1000000", Character.MIN_RADIX - 1, 10, 2);
checkIndexOutOfBoundsException("1000000", Character.MAX_RADIX + 1, -1, 2);
checkIndexOutOfBoundsException("1000000", Character.MIN_RADIX - 1, -1, 2);
checkIndexOutOfBoundsException("-1", 10, 0, 3);
checkIndexOutOfBoundsException("-1", 10, 2, 3);
checkIndexOutOfBoundsException("-1", 10, -1, 2);
checkNull(10, 0, 1);
checkNull(10, -1, 0);
checkNull(10, 0, 0);
checkNull(10, 0, -1);
checkNull(-1, -1, -1);
}
private static void check(String val, long expected) {
long n = Long.parseLong(val);
if (n != expected)
throw new RuntimeException("Long.parsedLong failed. String:" +
throw new RuntimeException("Long.parseLong failed. String:" +
val + " Result:" + n);
}
@ -91,4 +126,71 @@ public class ParsingTest {
; // Expected
}
}
private static void checkNumberFormatException(String val, int radix, int start) {
int n = 0;
try {
n = Integer.parseInt(val, radix, start);
System.err.println("parseInt(" + val + ", " + radix + ", " + start +
") incorrectly returned " + n);
throw new RuntimeException();
} catch (NumberFormatException nfe) {
; // Expected
}
}
private static void checkNumberFormatException(String val, int radix, int start, int end) {
long n = 0;
try {
n = Long.parseLong(val, radix, start, end);
System.err.println("parseInt(" + val + ", " + radix + ", " + start + ", " + end +
") incorrectly returned " + n);
throw new RuntimeException();
} catch (NumberFormatException nfe) {
; // Expected
}
}
private static void checkIndexOutOfBoundsException(String val, int radix, int start) {
int n = 0;
try {
n = Integer.parseInt(val, radix, start);
System.err.println("parseInt(" + val + ", " + radix + ", " + start +
") incorrectly returned " + n);
throw new RuntimeException();
} catch (IndexOutOfBoundsException ioob) {
; // Expected
}
}
private static void checkIndexOutOfBoundsException(String val, int radix, int start, int end) {
long n = 0;
try {
n = Long.parseLong(val, radix, start, end);
System.err.println("parseInt(" + val + ", " + radix + ", " + start + ", " + end +
") incorrectly returned " + n);
throw new RuntimeException();
} catch (IndexOutOfBoundsException ioob) {
; // Expected
}
}
private static void checkNull(int radix, int start, int end) {
long n = 0;
try {
n = Long.parseLong(null, 10, start, end);
System.err.println("parseInt(null, " + radix + ", " + start + ", " + end +
") incorrectly returned " + n);
throw new RuntimeException();
} catch (NullPointerException npe) {
; // Expected
}
}
private static void check(String val, long expected, int start, int end) {
long n = Long.parseLong(val, 10, start, end);
if (n != expected)
throw new RuntimeException("Long.parseLong failed. String:" +
val + ", start: " + start + ", end: " + end + " Result:" + n);
}
}

8
jdk/test/java/lang/String/ToLowerCase.java
View File

@ -23,7 +23,7 @@
/*
@test
@bug 4217441 4533872 4900935 8020037 8032012 8041791
@bug 4217441 4533872 4900935 8020037 8032012 8041791 8042589
@summary toLowerCase should lower-case Greek Sigma correctly depending
on the context (final/non-final). Also it should handle
Locale specific (lt, tr, and az) lowercasings and supplementary
@ -106,6 +106,12 @@ public class ToLowerCase {
// invalid code point tests:
test("\uD800\uD800\uD801A\uDC00\uDC00\uDC00B", Locale.US, "\uD800\uD800\uD801a\uDC00\uDC00\uDC00b");
// lower/uppercase + surrogates
test("a\uD801\uDC1c", Locale.ROOT, "a\uD801\uDC44");
test("A\uD801\uDC1c", Locale.ROOT, "a\uD801\uDC44");
test("a\uD801\uDC00\uD801\uDC01\uD801\uDC02", Locale.US, "a\uD801\uDC28\uD801\uDC29\uD801\uDC2A");
test("A\uD801\uDC00\uD801\uDC01\uD801\uDC02", Locale.US, "a\uD801\uDC28\uD801\uDC29\uD801\uDC2A");
// test bmp + supp1
StringBuilder src = new StringBuilder(0x20000);
StringBuilder exp = new StringBuilder(0x20000);

8
jdk/test/java/lang/String/ToUpperCase.java
View File

@ -23,7 +23,7 @@
/*
@test
@bug 4219630 4304573 4533872 4900935
@bug 4219630 4304573 4533872 4900935 8042589
@summary toUpperCase should upper-case German sharp s correctly even if
it's the only character in the string. should also uppercase
all of the 1:M char mappings correctly. Also it should handle
@ -91,6 +91,12 @@ public class ToUpperCase {
test("\uD801\uDC28a\uD801\uDC29b\uD801\uDC2Ac", Locale.US, "\uD801\uDC00A\uD801\uDC01B\uD801\uDC02C");
// invalid code point tests:
test("\uD800\uD800\uD801a\uDC00\uDC00\uDC00b", Locale.US, "\uD800\uD800\uD801A\uDC00\uDC00\uDC00B");
// lower/uppercase + surrogates
test("a\uD801\uDC44", Locale.ROOT, "A\uD801\uDC1c");
test("A\uD801\uDC44", Locale.ROOT, "A\uD801\uDC1c");
test("a\uD801\uDC28\uD801\uDC29\uD801\uDC2A", Locale.US, "A\uD801\uDC00\uD801\uDC01\uD801\uDC02");
test("A\uD801\uDC28a\uD801\uDC29b\uD801\uDC2Ac", Locale.US, "A\uD801\uDC00A\uD801\uDC01B\uD801\uDC02C");
}
static void test(String in, Locale locale, String expected) {

28
jdk/test/java/net/MulticastSocket/TestInterfaces.java
View File

@ -28,6 +28,8 @@
* same InetAddress set by MulticastSocket.setInterface
*/
import java.net.*;
import java.util.Arrays;
import java.util.Collections;
import java.util.Enumeration;
import java.io.IOException;
@ -47,6 +49,7 @@ public class TestInterfaces {
/*
* Test MulticastSocket.getInterface
*/
System.out.println("Testing network interface " + ni);
Enumeration addrs = ni.getInetAddresses();
while (addrs.hasMoreElements()) {
InetAddress ia = (InetAddress)addrs.nextElement();
@ -64,6 +67,8 @@ public class TestInterfaces {
InetAddress curr = soc.getInterface();
if (!curr.equals(ia)) {
System.err.println("NetworkInterface under test " + ni);
displayInterfaceInformation(ni);
System.err.println("MulticastSocket.getInterface returned: " + curr);
System.err.println("Failed! Expected: " + ia);
failures++;
@ -96,6 +101,10 @@ public class TestInterfaces {
if (!curr.equals(ni)) {
System.err.println("MulticastSocket.getNetworkInterface returned: " + curr);
System.err.println("Failed! Expected: " + ni);
System.err.println("NetworkInterface details for curr variable ");
displayInterfaceInformation(curr);
System.err.println("NetworkInterface details for ni variable ");
displayInterfaceInformation(ni) ;
failures++;
} else {
System.out.println("Passed.");
@ -110,4 +119,23 @@ public class TestInterfaces {
}
static void displayInterfaceInformation(NetworkInterface netint) throws SocketException {
System.err.println("Display name: " + netint.getDisplayName());
System.err.println("Name: " + netint.getName());
Enumeration<InetAddress> inetAddresses = netint.getInetAddresses();
for (InetAddress inetAddress : Collections.list(inetAddresses))
System.err.println("InetAddress: " + inetAddress);
System.err.println("Up? " + netint.isUp());
System.err.println("Loopback? " + netint.isLoopback());
System.err.println("PointToPoint? " + netint.isPointToPoint());
System.err.println("Supports multicast? " + netint.supportsMulticast());
System.err.println("Virtual? " + netint.isVirtual());
System.err.println("Hardware address: " +
Arrays.toString(netint.getHardwareAddress()));
System.err.println("MTU: " + netint.getMTU());
System.err.println("Index: " + netint.getIndex());
System.err.println();
}
}

17
jdk/test/java/util/UUID/UUIDTest.java
View File

@ -96,6 +96,23 @@ public class UUIDTest {
if (!u1.equals(u2))
throw new Exception("UUID -> string -> UUID failed");
}
testFromStringError("-0");
testFromStringError("x");
testFromStringError("----");
testFromStringError("-0-0-0-0");
testFromStringError("0-0-0-0-");
testFromStringError("0-0-0-0-0-");
testFromStringError("0-0-0-0-x");
}
private static void testFromStringError(String str) {
try {
UUID test = UUID.fromString(str);
throw new RuntimeException("Should have thrown IAE");
} catch (IllegalArgumentException iae) {
// pass
}
}
private static void versionTest() throws Exception {

79
jdk/test/javax/security/auth/kerberos/KerberosHashEqualsTest.java
View File

@ -33,9 +33,7 @@
import java.net.InetAddress;
import java.util.Date;
import javax.security.auth.kerberos.KerberosKey;
import javax.security.auth.kerberos.KerberosPrincipal;
import javax.security.auth.kerberos.KerberosTicket;
import javax.security.auth.kerberos.*;
public class KerberosHashEqualsTest {
public static void main(String[] args) throws Exception {
@ -66,28 +64,67 @@ public class KerberosHashEqualsTest {
k2.destroy();
checkNotSame(k1, k2);
// destroyed keys doesn't equal to each other
checkNotSame(k2, k1);
checkSame(k2, k2);
k1.destroy();
checkNotSame(k1, k2);
// Destroyed key has string and hashCode
k1.toString(); k1.hashCode();
// a little different
k1 = new KerberosKey(newKP("A"), "pass".getBytes(), 1, 1);
k2 = new KerberosKey(newKP("B"), "pass".getBytes(), 1, 1);
checkNotSame(k1, k2);
k2 = new KerberosKey(newKP("A"), "ssap".getBytes(), 1, 1);
checkNotSame(k1, k2);
k2 = new KerberosKey(newKP("A"), "pass".getBytes(), 2, 1);
checkNotSame(k1, k2);
k2 = new KerberosKey(newKP("A"), "pass".getBytes(), 1, 2);
checkNotSame(k1, k2);
// Null
k1 = new KerberosKey(null, "pass".getBytes(), 1, 2);
checkNotSame(k1, k2); // null to non-null
k2 = new KerberosKey(null, "pass".getBytes(), 1, 2);
checkSame(k1, k2); // null to null
// Even key with null principal has a string and hashCode
k1.toString(); k1.hashCode();
checkNotSame(k1, "Another Object");
EncryptionKey e1, e2;
e1 = new EncryptionKey("pass".getBytes(), 1);
e2 = new EncryptionKey("pass".getBytes(), 1);
checkSame(e1, e1); // me to me
checkSame(e1, e2); // same
e2.destroy();
checkNotSame(e1, e2);
checkNotSame(e2, e1);
checkSame(e2, e2);
e1.destroy();
checkNotSame(e1, e2);
// Destroyed key has string and hashCode
e1.toString(); e1.hashCode();
// a little different
e1 = new EncryptionKey("pass".getBytes(), 1);
e2 = new EncryptionKey("ssap".getBytes(), 1);
checkNotSame(e1, e2);
e2 = new EncryptionKey("pass".getBytes(), 2);
checkNotSame(e1, e2);
checkNotSame(e1, "Another Object");
KerberosTicket t1, t2;
t1 = new KerberosTicket("asn1".getBytes(), newKP("client"), newKP("server"), "pass".getBytes(), 1, new boolean[] {true, true}, new Date(0), new Date(0), new Date(0), new Date(0), null);
t2 = new KerberosTicket("asn1".getBytes(), newKP("client"), newKP("server"), "pass".getBytes(), 1, new boolean[] {true, true}, new Date(0), new Date(0), new Date(0), new Date(0), null);
@ -120,6 +157,7 @@ public class KerberosHashEqualsTest {
t2.destroy();
checkNotSame(t1, t2);
t2.hashCode(); t2.toString();
// destroyed tickets doesn't equal to each other
checkNotSame(t2, t1);
@ -130,6 +168,37 @@ public class KerberosHashEqualsTest {
checkNotSame(t1, t2); // renewtill is useful
checkNotSame(t1, "Another Object");
KerberosCredMessage m1, m2;
m1 = new KerberosCredMessage(newKP("C"), newKP("S"), "message".getBytes());
m2 = new KerberosCredMessage(newKP("C"), newKP("S"), "message".getBytes());
checkSame(m1, m1); // me to me
checkSame(m1, m2); // same
m2.destroy();
checkNotSame(m1, m2);
checkNotSame(m2, m1);
checkSame(m2, m2);
m1.destroy();
checkNotSame(m1, m2);
// Destroyed message has string and hashCode
m1.toString(); m1.hashCode();
// a little different
m1 = new KerberosCredMessage(newKP("C"), newKP("S"), "message".getBytes());
m2 = new KerberosCredMessage(newKP("A"), newKP("S"), "message".getBytes());
checkNotSame(m1, m2);
m2 = new KerberosCredMessage(newKP("C"), newKP("B"), "message".getBytes());
checkNotSame(m1, m2);
m1 = new KerberosCredMessage(newKP("C"), newKP("S"), "hello".getBytes());
checkNotSame(m1, m2);
checkNotSame(m1, "Another Object");
System.out.println("Good!");
}

92
jdk/test/javax/security/auth/kerberos/KerberosNullsAndDestroyTest.java Normal file
View File

@ -0,0 +1,92 @@
/*
* Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test
* @bug 8043071
* @summary Expose session key and KRB_CRED through extended GSS-API
*/
import javax.security.auth.kerberos.*;
import java.util.function.Supplier;
public class KerberosNullsAndDestroyTest {
public static void main(String[] args) throws Exception {
KerberosPrincipal c = new KerberosPrincipal("me@HERE");
KerberosPrincipal s = new KerberosPrincipal("you@THERE");
// These object constructions should throw NullPointerException
checkNPE(() -> new KerberosKey(c, null, 17, 1));
checkNPE(() -> new EncryptionKey(null, 17));
checkNPE(() -> new KerberosCredMessage(null, s, new byte[1]));
checkNPE(() -> new KerberosCredMessage(c, null, new byte[1]));
checkNPE(() -> new KerberosCredMessage(c, s, null));
KerberosKey k1 = new KerberosKey(c, new byte[16], 17, 1);
EncryptionKey k2 = new EncryptionKey(new byte[16], 17);
KerberosCredMessage m = new KerberosCredMessage(c, s, new byte[1]);
// These get calls should throw IllegalStateException
k1.destroy();
checkISE(() -> k1.getAlgorithm());
checkISE(() -> k1.getEncoded());
checkISE(() -> k1.getFormat());
checkISE(() -> k1.getKeyType());
checkISE(() -> k1.getPrincipal());
checkISE(() -> k1.getVersionNumber());
k2.destroy();
checkISE(() -> k2.getAlgorithm());
checkISE(() -> k2.getEncoded());
checkISE(() -> k2.getFormat());
checkISE(() -> k2.getKeyType());
m.destroy();
checkISE(() -> m.getSender());
checkISE(() -> m.getRecipient());
checkISE(() -> m.getEncoded());
}
static void checkNPE(Supplier<?> f) throws Exception {
check(f, NullPointerException.class);
}
static void checkISE(Supplier<?> f) throws Exception {
check(f, IllegalStateException.class);
}
static void check(Supplier<?> f, Class<? extends Exception> type) throws Exception {
try {
f.get();
} catch (Exception e) {
if (e.getClass() != type) {
throw e;
} else {
return;
}
}
throw new Exception("Should fail");
}
}

58
jdk/test/javax/xml/bind/xjc/8029837/PreParseGrammarTest.java Normal file
View File

@ -0,0 +1,58 @@
/*
* Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test
* @bug 8029837
* @summary Test simulates the partial call to xjc ant task that fails with
* NullPointer exception
* @run main/othervm PreParseGrammarTest
*/
import com.sun.org.apache.xerces.internal.parsers.XMLGrammarPreparser;
import com.sun.org.apache.xerces.internal.xni.XNIException;
import com.sun.org.apache.xerces.internal.xni.grammars.Grammar;
import com.sun.org.apache.xerces.internal.xni.grammars.XMLGrammarDescription;
import com.sun.org.apache.xerces.internal.xni.parser.XMLInputSource;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
public class PreParseGrammarTest {
public static void main(String[] args) throws FileNotFoundException, XNIException, IOException {
File xsdf = new File(System.getProperty("test.src", ".") + "/test.xsd");
InputStream is = new BufferedInputStream(new FileInputStream(xsdf));
XMLInputSource xis = new XMLInputSource(null, null, null, is, null);
XMLGrammarPreparser gp = new XMLGrammarPreparser();
gp.registerPreparser(XMLGrammarDescription.XML_SCHEMA, null);
//The NullPointerException is observed on next call during ant task
// execution
Grammar res = gp.preparseGrammar(XMLGrammarDescription.XML_SCHEMA, xis);
System.out.println("Grammar preparsed successfully:" + res);
return;
}
}

4
jdk/test/javax/xml/bind/xjc/8029837/test.xsd Normal file
View File

@ -0,0 +1,4 @@
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:element name="root">
</xsd:element>
</xsd:schema>

78
jdk/test/sun/misc/JavaLangAccess/FormatUnsigned.java Normal file
View File

@ -0,0 +1,78 @@
/*
* Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
import sun.misc.JavaLangAccess;
import sun.misc.SharedSecrets;
/*
* @test
* @summary Test JavaLangAccess.formatUnsignedInt/-Long
* @bug 8050114
*/
public class FormatUnsigned {
static final JavaLangAccess jla = SharedSecrets.getJavaLangAccess();
public static void testFormatUnsignedInt() {
testFormatUnsignedInt("7fffffff", Integer.MAX_VALUE, 8, 4, 0, 8);
testFormatUnsignedInt("80000000", Integer.MIN_VALUE, 8, 4, 0, 8);
testFormatUnsignedInt("4711", 04711, 4, 3, 0, 4);
testFormatUnsignedInt("4711", 0x4711, 4, 4, 0, 4);
testFormatUnsignedInt("1010", 0b1010, 4, 1, 0, 4);
testFormatUnsignedInt("00001010", 0b1010, 8, 1, 0, 8);
testFormatUnsignedInt("\u0000\u000000001010", 0b1010, 10, 1, 2, 8);
}
public static void testFormatUnsignedLong() {
testFormatUnsignedLong("7fffffffffffffff", Long.MAX_VALUE, 16, 4, 0, 16);
testFormatUnsignedLong("8000000000000000", Long.MIN_VALUE, 16, 4, 0, 16);
testFormatUnsignedLong("4711", 04711L, 4, 3, 0, 4);
testFormatUnsignedLong("4711", 0x4711L, 4, 4, 0, 4);
testFormatUnsignedLong("1010", 0b1010L, 4, 1, 0, 4);
testFormatUnsignedLong("00001010", 0b1010L, 8, 1, 0, 8);
testFormatUnsignedLong("\u0000\u000000001010", 0b1010L, 10, 1, 2, 8);
}
public static void testFormatUnsignedInt(String expected, int value, int arraySize, int shift, int offset, int length) {
char[] chars = new char[arraySize];
jla.formatUnsignedInt(value, shift, chars, offset, length);
String s = new String(chars);
if (!expected.equals(s)) {
throw new Error(s + " should be equal to expected " + expected);
}
}
public static void testFormatUnsignedLong(String expected, long value, int arraySize, int shift, int offset, int length) {
char[] chars = new char[arraySize];
jla.formatUnsignedLong(value, shift, chars, offset, length);
String s = new String(chars);
if (!expected.equals(s)) {
throw new Error(s + " should be equal to expected " + expected);
}
}
public static void main(String[] args) {
testFormatUnsignedInt();
testFormatUnsignedLong();
}
}

100
jdk/test/sun/security/jgss/spnego/NotPreferredMech.java Normal file
View File

@ -0,0 +1,100 @@
/*
* Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test
* @bug 8048194
* @run main/othervm NotPreferredMech
* @summary GSSContext.acceptSecContext fails when a supported mech is not initiator preferred
*/
import org.ietf.jgss.*;
import sun.security.jgss.*;
import sun.security.jgss.spnego.NegTokenInit;
import sun.security.jgss.spnego.NegTokenTarg;
import sun.security.util.BitArray;
import sun.security.util.DerOutputStream;
import sun.security.util.DerValue;
import sun.security.util.ObjectIdentifier;
import java.io.ByteArrayOutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
public class NotPreferredMech {
public static void main(String[] argv) throws Exception {
// Generates a NegTokenInit mechTypes field, with an
// unsupported mech as the preferred.
DerOutputStream mech = new DerOutputStream();
mech.write(new Oid("1.2.3.4").getDER());
mech.write(GSSUtil.GSS_KRB5_MECH_OID.getDER());
DerOutputStream mechTypeList = new DerOutputStream();
mechTypeList.write(DerValue.tag_Sequence, mech);
// Generates a NegTokenInit mechToken field for 1.2.3.4 mech
GSSHeader h1 = new GSSHeader(new ObjectIdentifier("1.2.3.4"), 1);
ByteArrayOutputStream bout = new ByteArrayOutputStream();
h1.encode(bout);
bout.write(new byte[1]);
// Generates the NegTokenInit token
Constructor<NegTokenInit> ctor = NegTokenInit.class.getDeclaredConstructor(
byte[].class, BitArray.class, byte[].class, byte[].class);
ctor.setAccessible(true);
NegTokenInit initToken = ctor.newInstance(
mechTypeList.toByteArray(),
new BitArray(0),
bout.toByteArray(),
null);
Method m = Class.forName("sun.security.jgss.spnego.SpNegoToken")
.getDeclaredMethod("getEncoded");
m.setAccessible(true);
byte[] spnegoToken = (byte[])m.invoke(initToken);
// and wraps it into a GSSToken
GSSHeader h = new GSSHeader(
new ObjectIdentifier(GSSUtil.GSS_SPNEGO_MECH_OID.toString()),
spnegoToken.length);
bout = new ByteArrayOutputStream();
h.encode(bout);
bout.write(spnegoToken);
byte[] token = bout.toByteArray();
// and feeds it to a GSS acceptor
GSSManager man = GSSManager.getInstance();
GSSContext ctxt = man.createContext((GSSCredential) null);
token = ctxt.acceptSecContext(token, 0, token.length);
NegTokenTarg targ = new NegTokenTarg(token);
// Make sure it's a GO-ON message
Method m2 = NegTokenTarg.class.getDeclaredMethod("getNegotiatedResult");
m2.setAccessible(true);
int negResult = (int)m2.invoke(targ);
if (negResult != 1 /* ACCEPT_INCOMPLETE */) {
throw new Exception("Not a continue");
}
}
}

23
jdk/test/sun/security/krb5/auto/Context.java
View File

@ -26,9 +26,11 @@ import java.security.Key;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.util.Arrays;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;
import javax.security.auth.Subject;
import javax.security.auth.kerberos.KerberosCredMessage;
import javax.security.auth.kerberos.KerberosKey;
import javax.security.auth.kerberos.KerberosTicket;
import javax.security.auth.login.LoginContext;
@ -86,7 +88,6 @@ public class Context {
/**
* Using the delegated credentials from a previous acceptor
* @param c
*/
public Context delegated() throws Exception {
Context out = new Context();
@ -177,7 +178,6 @@ public class Context {
/**
* Logins with username/keytab as an existing Subject. The
* same subject can be used multiple times to simulate multiple logins.
* @param s existing subject
*/
public static Context fromUserKtab(
String user, String ktab, boolean storeKey) throws Exception {
@ -411,6 +411,12 @@ public class Context {
Key k = (Key)ex.inquireSecContext(
InquireType.KRB5_GET_SESSION_KEY);
if (k == null) {
throw new Exception("(Old) Session key cannot be null");
}
System.out.println("(Old) Session key is: " + k);
Key k2 = (Key)ex.inquireSecContext(
InquireType.KRB5_GET_SESSION_KEY_EX);
if (k2 == null) {
throw new Exception("Session key cannot be null");
}
System.out.println("Session key is: " + k);
@ -431,6 +437,19 @@ public class Context {
InquireType.KRB5_GET_AUTHZ_DATA);
System.out.println("AuthzData is: " + Arrays.toString(ad));
}
try {
KerberosCredMessage tok = (KerberosCredMessage)ex.inquireSecContext(
InquireType.KRB5_GET_KRB_CRED);
System.out.println("KRB_CRED is " +
(tok == null?"not ":"") + "available");
if (tok != null) {
System.out.println("From " + tok.getSender() + " to "
+ tok.getRecipient());
System.out.println(Base64.getEncoder().encodeToString(tok.getEncoded()));
}
} catch (Exception e) {
System.out.println("KRB_CRED is not available: " + e);
}
}
}
}

174
jdk/test/sun/security/krb5/auto/KerberosHashEqualsTest.java
View File

@ -1,174 +0,0 @@
/*
* Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test
* @bug 4641821
* @run main/othervm KerberosHashEqualsTest
* @summary hashCode() and equals() for KerberosKey and KerberosTicket
*/
import java.net.InetAddress;
import java.util.Date;
import javax.security.auth.kerberos.KerberosKey;
import javax.security.auth.kerberos.KerberosPrincipal;
import javax.security.auth.kerberos.KerberosTicket;
public class KerberosHashEqualsTest {
public static void main(String[] args) throws Exception {
new OneKDC(null);
new KerberosHashEqualsTest().check();
}
void checkSame(Object o1, Object o2) {
if(!o1.equals(o2)) {
throw new RuntimeException("equals() fails");
}
if(o1.hashCode() != o2.hashCode()) {
throw new RuntimeException("hashCode() not same");
}
}
void checkNotSame(Object o1, Object o2) {
if(o1.equals(o2)) {
throw new RuntimeException("equals() succeeds");
}
}
void check() throws Exception {
// The key part:
// new KerberosKey(principal, bytes, keyType, version)
KerberosKey k1, k2;
KerberosPrincipal CLIENT = new KerberosPrincipal("client");
KerberosPrincipal SERVER = new KerberosPrincipal("server");
byte[] PASS = "pass".getBytes();
k1 = new KerberosKey(CLIENT, PASS, 1, 1);
k2 = new KerberosKey(CLIENT, PASS, 1, 1);
checkSame(k1, k1); // me is me
checkSame(k1, k2); // same
// A destroyed key doesn't equal to any key
k2.destroy();
checkNotSame(k1, k2);
checkNotSame(k2, k1);
k1.destroy();
checkNotSame(k1, k2); // even if they are both destroyed
checkNotSame(k2, k1);
checkSame(k2, k2);
// a little difference means not equal
k1 = new KerberosKey(CLIENT, PASS, 1, 1);
k2 = new KerberosKey(SERVER, PASS, 1, 1);
checkNotSame(k1, k2); // Different principal name
k2 = new KerberosKey(CLIENT, "ssap".getBytes(), 1, 1);
checkNotSame(k1, k2); // Different password
k2 = new KerberosKey(CLIENT, PASS, 2, 1);
checkNotSame(k1, k2); // Different keytype
k2 = new KerberosKey(CLIENT, PASS, 1, 2);
checkNotSame(k1, k2); // Different version
k2 = new KerberosKey(null, PASS, 1, 2);
checkNotSame(k1, k2); // null is not non-null
k1 = new KerberosKey(null, PASS, 1, 2);
checkSame(k1, k2); // null is null
checkNotSame(k1, "Another Object");
// The ticket part:
// new KerberosTicket(asn1 bytes, client, server, session key, type, flags,
// auth, start, end, renewUntil times, address)
KerberosTicket t1, t2;
byte[] ASN1 = "asn1".getBytes();
boolean[] FORWARDABLE = new boolean[] {true, true};
boolean[] ALLTRUE = new boolean[] {true, true, true, true, true, true, true, true, true, true};
Date D0 = new Date(0);
t1 = new KerberosTicket(ASN1, CLIENT, SERVER, PASS, 1, FORWARDABLE, D0, D0, D0, D0, null);
t2 = new KerberosTicket(ASN1, CLIENT, SERVER, PASS, 1, FORWARDABLE, D0, D0, D0, D0, null);
checkSame(t1, t1);
checkSame(t1, t2);
// destroyed tickets doesn't equal to each other
t1.destroy();
checkNotSame(t1, t2);
checkNotSame(t2, t1);
t2.destroy();
checkNotSame(t1, t2); // even if they are both destroyed
checkNotSame(t2, t1);
checkSame(t2, t2); // unless they are the same object
// a little difference means not equal
t1 = new KerberosTicket(ASN1, CLIENT, SERVER, PASS, 1, FORWARDABLE, D0, D0, D0, D0, null);
t2 = new KerberosTicket("asn11".getBytes(), CLIENT, SERVER, PASS, 1, FORWARDABLE, D0, D0, D0, D0, null);
checkNotSame(t1, t2); // Different ASN1 encoding
t2 = new KerberosTicket(ASN1, new KerberosPrincipal("client1"), SERVER, PASS, 1, FORWARDABLE, D0, D0, D0, D0, null);
checkNotSame(t1, t2); // Different client
t2 = new KerberosTicket(ASN1, CLIENT, new KerberosPrincipal("server1"), PASS, 1, FORWARDABLE, D0, D0, D0, D0, null);
checkNotSame(t1, t2); // Different server
t2 = new KerberosTicket(ASN1, CLIENT, SERVER, "pass1".getBytes(), 1, FORWARDABLE, D0, D0, D0, D0, null);
checkNotSame(t1, t2); // Different session key
t2 = new KerberosTicket(ASN1, CLIENT, SERVER, PASS, 2, FORWARDABLE, D0, D0, D0, D0, null);
checkNotSame(t1, t2); // Different key type
t2 = new KerberosTicket(ASN1, CLIENT, SERVER, PASS, 1, new boolean[] {true, false}, D0, D0, D0, D0, null);
checkNotSame(t1, t2); // Different flags, not FORWARDABLE
t2 = new KerberosTicket(ASN1, CLIENT, SERVER, PASS, 1, FORWARDABLE, new Date(1), D0, D0, D0, null);
checkNotSame(t1, t2); // Different authtime
t2 = new KerberosTicket(ASN1, CLIENT, SERVER, PASS, 1, FORWARDABLE, D0, new Date(1), D0, D0, null);
checkNotSame(t1, t2); // Different starttime
t2 = new KerberosTicket(ASN1, CLIENT, SERVER, PASS, 1, FORWARDABLE, D0, D0, new Date(1), D0, null);
checkNotSame(t1, t2); // Different endtime
t2 = new KerberosTicket(ASN1, CLIENT, SERVER, PASS, 1, FORWARDABLE, D0, D0, D0, D0, new InetAddress[2]);
checkNotSame(t1, t2); // Different client addresses
t2 = new KerberosTicket(ASN1, CLIENT, SERVER, PASS, 1, FORWARDABLE, D0, D0, D0, new Date(1), null);
t1 = new KerberosTicket(ASN1, CLIENT, SERVER, PASS, 1, FORWARDABLE, D0, D0, D0, new Date(2), null);
checkSame(t1, t2); // renewtill is ignored when RENEWABLE ticket flag is not set.
t2 = new KerberosTicket(ASN1, CLIENT, SERVER, PASS, 1, ALLTRUE, D0, D0, D0, new Date(1), null);
t1 = new KerberosTicket(ASN1, CLIENT, SERVER, PASS, 1, ALLTRUE, D0, D0, D0, new Date(2), null);
checkNotSame(t1, t2); // renewtill is used when RENEWABLE is set.
checkNotSame(t1, "Another Object");
System.out.println("Good!");
}
}

65
jdk/test/sun/security/krb5/auto/NewInquireTypes.java Normal file
View File

@ -0,0 +1,65 @@
/*
* Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test
* @bug 8043071
* @summary Expose session key and KRB_CRED through extended GSS-API
* @compile -XDignore.symbol.file NewInquireTypes.java
* @run main/othervm NewInquireTypes
*/
import com.sun.security.jgss.InquireType;
import sun.security.jgss.GSSUtil;
import sun.security.krb5.internal.KRBCred;
import sun.security.krb5.internal.crypto.KeyUsage;
import javax.security.auth.kerberos.KerberosCredMessage;
import javax.security.auth.kerberos.EncryptionKey;
public class NewInquireTypes {
public static void main(String[] args) throws Exception {
new OneKDC(null).writeJAASConf();
Context c, s;
c = Context.fromJAAS("client");
s = Context.fromJAAS("server");
c.startAsClient(OneKDC.SERVER, GSSUtil.GSS_KRB5_MECH_OID);
s.startAsServer(GSSUtil.GSS_KRB5_MECH_OID);
Context.handshake(c, s);
EncryptionKey key = (EncryptionKey)
c.x().inquireSecContext(InquireType.KRB5_GET_SESSION_KEY_EX);
KerberosCredMessage cred = (KerberosCredMessage)
c.x().inquireSecContext(InquireType.KRB5_GET_KRB_CRED);
// Confirm the KRB_CRED message is encrypted with the session key.
new KRBCred(cred.getEncoded()).encPart.decrypt(
new sun.security.krb5.EncryptionKey(key.getKeyType(), key.getEncoded()),
KeyUsage.KU_ENC_KRB_CRED_PART);
}
}

4
jdk/test/sun/security/smartcardio/TestAll.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2005, 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -26,7 +26,7 @@
// Because all the tests are marked @ignore as they require special hardware,
// we cannot use jtreg to do this.
import java.lang.reflect.*;
import java.lang.reflect.Method;
public class TestAll {

10
jdk/test/sun/security/smartcardio/TestChannel.java
View File

@ -31,10 +31,10 @@
// This test requires special hardware.
import java.io.*;
import java.util.*;
import javax.smartcardio.*;
import javax.smartcardio.Card;
import javax.smartcardio.CardChannel;
import javax.smartcardio.CardTerminal;
import javax.smartcardio.CommandAPDU;
public class TestChannel extends Utils {
@ -95,7 +95,7 @@ public class TestChannel extends Utils {
}
// disconnect
card.disconnect(false);
card.disconnect(true);
System.out.println("OK.");
}

14
jdk/test/sun/security/smartcardio/TestConnect.java
View File

@ -31,10 +31,11 @@
// This test requires special hardware.
import java.io.*;
import java.util.*;
import javax.smartcardio.*;
import java.util.List;
import javax.smartcardio.TerminalFactory;
import javax.smartcardio.Card;
import javax.smartcardio.CardChannel;
import javax.smartcardio.CardTerminal;
public class TestConnect extends Utils {
@ -63,7 +64,7 @@ public class TestConnect extends Utils {
throw new Exception("Not T=0 protocol");
}
transmit(card);
card.disconnect(false);
card.disconnect(true);
try {
transmit(card);
@ -96,7 +97,7 @@ public class TestConnect extends Utils {
throw new Exception("Not T=0 protocol");
}
transmit(card);
card.disconnect(true);
card.disconnect(false);
card = terminal.connect("*");
System.out.println("card: " + card);
@ -105,7 +106,6 @@ public class TestConnect extends Utils {
}
transmit(card);
card.disconnect(true);
card.disconnect(true);
System.out.println("OK.");
}

10
jdk/test/sun/security/smartcardio/TestConnectAgain.java
View File

@ -31,10 +31,10 @@
// This test requires special hardware.
import java.io.*;
import java.util.*;
import javax.smartcardio.*;
import javax.smartcardio.Card;
import javax.smartcardio.CardException;
import javax.smartcardio.CardChannel;
import javax.smartcardio.CardTerminal;
public class TestConnectAgain extends Utils {
@ -95,7 +95,7 @@ public class TestConnectAgain extends Utils {
}
// disconnect
card.disconnect(false);
card.disconnect(true);
System.out.println("OK.");
}

9
jdk/test/sun/security/smartcardio/TestControl.java
View File

@ -31,10 +31,9 @@
// This test requires special hardware.
import java.io.*;
import java.util.*;
import javax.smartcardio.*;
import javax.smartcardio.Card;
import javax.smartcardio.CardException;
import javax.smartcardio.CardTerminal;
public class TestControl extends Utils {
@ -68,7 +67,7 @@ public class TestControl extends Utils {
}
// disconnect
card.disconnect(false);
card.disconnect(true);
System.out.println("OK.");
}

7
jdk/test/sun/security/smartcardio/TestDefault.java
View File

@ -31,10 +31,9 @@
// This test requires special hardware.
import java.io.*;
import java.util.*;
import javax.smartcardio.*;
import java.util.List;
import javax.smartcardio.CardTerminal;
import javax.smartcardio.TerminalFactory;
public class TestDefault {

13
jdk/test/sun/security/smartcardio/TestExclusive.java
View File

@ -31,10 +31,11 @@
// This test requires special hardware.
import java.io.*;
import java.util.*;
import javax.smartcardio.*;
import javax.smartcardio.Card;
import javax.smartcardio.CardChannel;
import javax.smartcardio.CardException;
import javax.smartcardio.CardTerminal;
import javax.smartcardio.CommandAPDU;
public class TestExclusive extends Utils {
@ -84,9 +85,9 @@ public class TestExclusive extends Utils {
Thread.sleep(1000);
// disconnect
card.disconnect(false);
card.disconnect(true);
if (otherOK == false) {
if (! otherOK) {
throw new Exception("Secondary thread failed");
}

8
jdk/test/sun/security/smartcardio/TestMultiplePresent.java
View File

@ -31,10 +31,10 @@
// This test requires special hardware.
import java.io.*;
import java.util.*;
import javax.smartcardio.*;
import java.util.List;
import javax.smartcardio.CardTerminal;
import javax.smartcardio.CardTerminals;
import javax.smartcardio.TerminalFactory;
import static javax.smartcardio.CardTerminals.State.*;
public class TestMultiplePresent {

7
jdk/test/sun/security/smartcardio/TestPresent.java
View File

@ -31,10 +31,9 @@
// This test requires special hardware.
import java.io.*;
import java.util.*;
import javax.smartcardio.*;
import java.util.List;
import javax.smartcardio.CardTerminal;
import javax.smartcardio.TerminalFactory;
public class TestPresent {

16
jdk/test/sun/security/smartcardio/TestTransmit.java
View File

@ -31,10 +31,16 @@
// This test requires special hardware.
import java.io.*;
import java.util.*;
import javax.smartcardio.*;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.StringReader;
import javax.smartcardio.Card;
import javax.smartcardio.CardChannel;
import javax.smartcardio.CardTerminal;
import javax.smartcardio.CommandAPDU;
import javax.smartcardio.ResponseAPDU;
public class TestTransmit extends Utils {
@ -79,7 +85,7 @@ public class TestTransmit extends Utils {
}
// disconnect
card.disconnect(false);
card.disconnect(true);
System.out.println("OK.");
}

14
jdk/test/sun/security/smartcardio/Utils.java
View File

@ -24,10 +24,16 @@
// common utility functions for the PC/SC tests
import javax.smartcardio.*;
import java.io.*;
import java.util.*;
import java.io.StringReader;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import javax.smartcardio.CardTerminal;
import javax.smartcardio.CardChannel;
import javax.smartcardio.ResponseAPDU;
import javax.smartcardio.CommandAPDU;
import javax.smartcardio.TerminalFactory;
public class Utils {

64
jdk/test/sun/security/tools/jarsigner/default_options.sh Normal file
View File

@ -0,0 +1,64 @@
#
# Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License version 2 only, as
# published by the Free Software Foundation.
#
# This code is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
# version 2 for more details (a copy is included in the LICENSE file that
# accompanied this code).
#
# You should have received a copy of the GNU General Public License version
# 2 along with this work; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
# or visit www.oracle.com if you need additional information or have any
# questions.
#
# @test
# @bug 8049834
# @summary Two security tools tests do not run with only JRE
#
if [ "${TESTJAVA}" = "" ] ; then
JAVAC_CMD=`which javac`
TESTJAVA=`dirname $JAVAC_CMD`/..
fi
KS=ks
KEYTOOL="$TESTJAVA/bin/keytool ${TESTTOOLVMOPTS}"
JAR="$TESTJAVA/bin/jar ${TESTTOOLVMOPTS}"
JARSIGNER="$TESTJAVA/bin/jarsigner ${TESTTOOLVMOPTS}"
rm $KS 2> /dev/null
PASS=changeit
export PASS
$KEYTOOL -genkeypair -dname CN=A -alias a \
-storepass:env PASS -keypass:env PASS -keystore $KS \
-keyalg rsa || exit 1
cat <<EOF > js.conf
jarsigner.all = -keystore \${user.dir}/$KS -storepass:env PASS -debug -strict
jarsigner.sign = -digestalg SHA1
jarsigner.verify = -verbose:summary
EOF
$JAR cvf a.jar ks js.conf
$JARSIGNER -conf js.conf a.jar a || exit 21
$JARSIGNER -conf js.conf -verify a.jar > jarsigner.out || exit 22
grep "and 1 more" jarsigner.out || exit 23
$JAR xvf a.jar META-INF/MANIFEST.MF
grep "SHA1-Digest" META-INF/MANIFEST.MF || exit 24
echo Done
exit 0

0
jdk/test/sun/security/tools/keytool/weaksize.sh → jdk/test/sun/security/tools/jarsigner/weaksize.sh
View File

21
jdk/test/sun/security/tools/keytool/default_options.sh
View File

@ -33,16 +33,12 @@ fi
KS=ks
KEYTOOL="$TESTJAVA/bin/keytool ${TESTTOOLVMOPTS}"
JAR="$TESTJAVA/bin/jar ${TESTTOOLVMOPTS}"
JARSIGNER="$TESTJAVA/bin/jarsigner ${TESTTOOLVMOPTS}"
rm $KS 2> /dev/null
PASS=changeit
export PASS
# keytool
cat <<EOF > kt.conf
# A Pre-configured options file
keytool.all = -storepass:env PASS -keypass:env PASS -keystore \${user.dir}/$KS -debug
@ -69,23 +65,6 @@ $KEYTOOL -conf kt.conf -delete -alias a && exit 16
# Single-valued option on command line overrides again
$KEYTOOL -conf kt.conf -delete -alias b -keystore $KS || exit 17
# jarsigner
cat <<EOF > js.conf
jarsigner.all = -keystore \${user.dir}/$KS -storepass:env PASS -debug -strict
jarsigner.sign = -digestalg SHA1
jarsigner.verify = -verbose:summary
EOF
$JAR cvf a.jar ks js.conf kt.conf
$JARSIGNER -conf js.conf a.jar a || exit 21
$JARSIGNER -conf js.conf -verify a.jar > jarsigner.out || exit 22
grep "and 2 more" jarsigner.out || exit 23
$JAR xvf a.jar META-INF/MANIFEST.MF
grep "SHA1-Digest" META-INF/MANIFEST.MF || exit 24
# Error cases
# File does not exist