index int64 0 0 | repo_id stringlengths 9 205 | file_path stringlengths 31 246 | content stringlengths 1 12.2M | __index_level_0__ int64 0 10k |
|---|---|---|---|---|
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/userauth/UserIdTokenAuthenticationData.java | /**
* Copyright (c) 2014-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.userauth;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.MslUserAuthException;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.tokens.MasterToken;
import com.netflix.msl.tokens.UserIdToken;
import com.netflix.msl.util.MslContext;
/**
* <p>User ID token-based user authentication data.</p>
*
* <p>
* {@code {
* "#mandatory" : [ "mastertoken", "useridtoken" ],
* "mastertoken" : mastertoken,
* "useridtoken" : useridtoken,
* }} where:
* <ul>
* <li>{@code mastertoken} is the master token</li>
* <li>{@code useridtoken} is the user ID token</li>
* </ul></p>
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class UserIdTokenAuthenticationData extends UserAuthenticationData {
/** Key master token. */
private static final String KEY_MASTER_TOKEN = "mastertoken";
/** Key user ID token. */
private static final String KEY_USER_ID_TOKEN = "useridtoken";
/**
* Construct a new user ID token authentication data instance from the
* provided master token and user ID token.
*
* @param masterToken the master token.
* @param userIdToken the user ID token.
*/
public UserIdTokenAuthenticationData(final MasterToken masterToken, final UserIdToken userIdToken) {
super(UserAuthenticationScheme.USER_ID_TOKEN);
if (!userIdToken.isBoundTo(masterToken))
throw new MslInternalException("User ID token must be bound to master token.");
this.masterToken = masterToken;
this.userIdToken = userIdToken;
}
/**
* Construct a new user ID token authentication data instance from the
* provided MSL object.
*
* @param ctx MSl context.
* @param userIdTokenAuthMo the MSL object.
* @throws MslEncodingException if there is an error parsing the data.
* @throws MslUserAuthException if the token data is invalid or the user ID
* token is not bound to the master token.
*/
public UserIdTokenAuthenticationData(final MslContext ctx, final MslObject userIdTokenAuthMo) throws MslEncodingException, MslUserAuthException {
super(UserAuthenticationScheme.USER_ID_TOKEN);
// Extract master token and user ID token representations.
final MslEncoderFactory encoder = ctx.getMslEncoderFactory();
final MslObject masterTokenMo, userIdTokenMo;
try {
masterTokenMo = userIdTokenAuthMo.getMslObject(KEY_MASTER_TOKEN, encoder);
userIdTokenMo = userIdTokenAuthMo.getMslObject(KEY_USER_ID_TOKEN, encoder);
} catch (final MslEncoderException e) {
throw new MslEncodingException(MslError.MSL_PARSE_ERROR, "user ID token authdata " + userIdTokenAuthMo, e);
}
// Convert any MslExceptions into MslUserAuthException because we don't
// want to trigger entity or user re-authentication incorrectly.
try {
masterToken = new MasterToken(ctx, masterTokenMo);
} catch (final MslException e) {
throw new MslUserAuthException(MslError.USERAUTH_MASTERTOKEN_INVALID, "user ID token authdata " + userIdTokenAuthMo, e);
}
try {
userIdToken = new UserIdToken(ctx, userIdTokenMo, masterToken);
} catch (final MslException e) {
throw new MslUserAuthException(MslError.USERAUTH_USERIDTOKEN_INVALID, "user ID token authdata " + userIdTokenAuthMo, e);
}
}
/**
* @return the master token.
*/
public MasterToken getMasterToken() {
return masterToken;
}
/**
* @return the user ID token.
*/
public UserIdToken getUserIdToken() {
return userIdToken;
}
/* (non-Javadoc)
* @see com.netflix.msl.userauth.UserAuthenticationData#getAuthData(com.netflix.msl.io.MslEncoderFactory, com.netflix.msl.io.MslEncoderFormat)
*/
@Override
public MslObject getAuthData(final MslEncoderFactory encoder, final MslEncoderFormat format) throws MslEncoderException {
final MslObject authdata = encoder.createObject();
authdata.put(KEY_MASTER_TOKEN, masterToken);
authdata.put(KEY_USER_ID_TOKEN, userIdToken);
return encoder.parseObject(encoder.encodeObject(authdata, format));
}
/* (non-Javadoc)
* @see com.netflix.msl.userauth.UserAuthenticationData#equals(java.lang.Object)
*/
@Override
public boolean equals(final Object obj) {
if (obj == this) return true;
if (!(obj instanceof UserIdTokenAuthenticationData)) return false;
final UserIdTokenAuthenticationData that = (UserIdTokenAuthenticationData)obj;
return super.equals(obj) && masterToken.equals(that.masterToken) && userIdToken.equals(that.userIdToken);
}
/* (non-Javadoc)
* @see com.netflix.msl.userauth.UserAuthenticationData#hashCode()
*/
@Override
public int hashCode() {
return super.hashCode() ^ masterToken.hashCode() ^ userIdToken.hashCode();
}
/** Master token. */
private final MasterToken masterToken;
/** User ID token. */
private final UserIdToken userIdToken;
}
| 9,900 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/userauth/UserAuthenticationFactory.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.userauth;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslUserAuthException;
import com.netflix.msl.MslUserIdTokenException;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.tokens.MasterToken;
import com.netflix.msl.tokens.MslUser;
import com.netflix.msl.tokens.UserIdToken;
import com.netflix.msl.util.MslContext;
/**
* A user authentication factory creates authentication data instances and
* performs authentication for a specific user authentication scheme.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public abstract class UserAuthenticationFactory {
/**
* Create a new user authentication factory for the specified scheme.
*
* @param scheme the user authentication scheme.
*/
protected UserAuthenticationFactory(final UserAuthenticationScheme scheme) {
this.scheme = scheme;
}
/**
* @return the user authentication scheme this factory is for.
*/
public UserAuthenticationScheme getScheme() {
return scheme;
}
/**
* <p>Construct a new user authentication data instance from the provided
* MSL object.</p>
*
* <p>A master token may be required for certain user authentication
* schemes.</p>
*
* @param ctx MSL context.
* @param masterToken the entity master token. May be {@code null}.
* @param userAuthMo the MSL object.
* @return the user authentication data.
* @throws MslEncodingException if there is an error parsing the data.
* @throws MslUserAuthException if there is an error creating the user
* authentication data.
* @throws MslCryptoException if there is an error with the user
* authentication data cryptography.
*/
public abstract UserAuthenticationData createData(final MslContext ctx, final MasterToken masterToken, final MslObject userAuthMo) throws MslEncodingException, MslUserAuthException, MslCryptoException;
/**
* <p>Authenticate the user using the provided authentication data.</p>
*
* <p>If a user ID token is provided then also validate the authenticated
* user against the provided user ID token. This is typically a check to
* ensure the user identities are equal but not always. The returned user
* must be the user identified by the user ID token.</p>
*
* @param ctx MSL context.
* @param identity the entity identity.
* @param data user authentication data.
* @param userIdToken user ID token. May be {@code null}.
* @return the MSL user.
* @throws MslUserAuthException if there is an error authenticating the
* user or if the user authentication data and user ID token
* identities do not match.
* @throws MslUserIdTokenException if there is a problem with the user ID
* token.
*/
public abstract MslUser authenticate(final MslContext ctx, final String identity, final UserAuthenticationData data, final UserIdToken userIdToken) throws MslUserAuthException, MslUserIdTokenException;
/** The factory's user authentication scheme. */
private final UserAuthenticationScheme scheme;
}
| 9,901 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/userauth/UserAuthenticationData.java | /**
* Copyright 2015 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.userauth;
import java.util.HashMap;
import java.util.Map;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslUserAuthException;
import com.netflix.msl.io.MslEncodable;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.tokens.MasterToken;
import com.netflix.msl.util.MslContext;
/**
* <p>The user authentication data provides proof of user identity.</p>
*
* <p>Specific user authentication mechanisms should define their own user
* authentication data types.</p>
*
* <p>User authentication data is represented as
* {@code
* userauthdata = {
* "#mandatory" : [ "scheme"., "authdata" ],
* "scheme" : "string",
* "authdata" : object
* }} where
* <ul>
* <li>{@code scheme} is the user authentication scheme</li>
* <li>{@code authdata} is the scheme-specific authentication data</li>
* </ul></p>
*/
public abstract class UserAuthenticationData implements MslEncodable {
/** Key user authentication scheme. */
private static final String KEY_SCHEME = "scheme";
/** Key user authentication data. */
private static final String KEY_AUTHDATA = "authdata";
/**
* Create a new user authentication data object with the specified user
* authentication scheme.
*
* @param scheme the user authentication scheme.
*/
protected UserAuthenticationData(final UserAuthenticationScheme scheme) {
this.scheme = scheme;
}
/**
* <p>Construct a new user authentication data instance of the correct type
* from the provided MSL object.</p>
*
* <p>A master token may be required for certain user authentication
* schemes.</p>
*
* @param ctx MSL context.
* @param masterToken the master token associated with the user
* authentication data. May be {@code null}.
* @param userAuthMo the MSL object.
* @return the user authentication data concrete instance.
* @throws MslEncodingException if there is an error parsing the data.
* @throws MslUserAuthException if there is an error instantiating the user
* authentication data.
* @throws MslCryptoException if there is an error with the entity
* authentication data cryptography.
*/
public static UserAuthenticationData create(final MslContext ctx, final MasterToken masterToken, final MslObject userAuthMo) throws MslUserAuthException, MslEncodingException, MslCryptoException {
try {
// Pull the scheme.
final String schemeName = userAuthMo.getString(KEY_SCHEME);
final UserAuthenticationScheme scheme = ctx.getUserAuthenticationScheme(schemeName);
if (scheme == null)
throw new MslUserAuthException(MslError.UNIDENTIFIED_USERAUTH_SCHEME, schemeName);
// Construct an instance of the concrete subclass.
final UserAuthenticationFactory factory = ctx.getUserAuthenticationFactory(scheme);
if (factory == null)
throw new MslUserAuthException(MslError.USERAUTH_FACTORY_NOT_FOUND, scheme.name());
final MslEncoderFactory encoder = ctx.getMslEncoderFactory();
return factory.createData(ctx, masterToken, userAuthMo.getMslObject(KEY_AUTHDATA, encoder));
} catch (final MslEncoderException e) {
throw new MslEncodingException(MslError.MSL_PARSE_ERROR, "userauthdata " + userAuthMo, e);
}
}
/**
* @return the user authentication scheme.
*/
public UserAuthenticationScheme getScheme() {
return scheme;
}
/**
* Returns the scheme-specific user authentication data. This method is
* expected to succeed unless there is an internal error.
*
* @param encoder the encoder factory.
* @param format the encoder format.
* @return the authentication data MSL object.
* @throws MslEncoderException if there was an error constructing the
* MSL object.
*/
public abstract MslObject getAuthData(final MslEncoderFactory encoder, final MslEncoderFormat format) throws MslEncoderException;
/** User authentication scheme. */
private final UserAuthenticationScheme scheme;
/** Cached encodings. */
private final Map<MslEncoderFormat,byte[]> encodings = new HashMap<MslEncoderFormat,byte[]>();
/* (non-Javadoc)
* @see com.netflix.msl.io.MslEncodable#toMslEncoding(com.netflix.msl.io.MslEncoderFactory, com.netflix.msl.io.MslEncoderFormat)
*/
@Override
public byte[] toMslEncoding(final MslEncoderFactory encoder, final MslEncoderFormat format) throws MslEncoderException {
// Return any cached encoding.
if (encodings.containsKey(format))
return encodings.get(format);
// Encode the user authentication data.
final MslObject mo = encoder.createObject();
mo.put(KEY_SCHEME, scheme.name());
mo.put(KEY_AUTHDATA, getAuthData(encoder, format));
final byte[] encoding = encoder.encodeObject(mo, format);
// Cache and return the encoding.
encodings.put(format, encoding);
return encoding;
}
/* (non-Javadoc)
* @see java.lang.Object#equals(java.lang.Object)
*/
@Override
public boolean equals(final Object obj) {
if (obj == this) return true;
if (!(obj instanceof UserAuthenticationData)) return false;
final UserAuthenticationData that = (UserAuthenticationData)obj;
return scheme.equals(that.scheme);
}
/* (non-Javadoc)
* @see java.lang.Object#hashCode()
*/
@Override
public int hashCode() {
return scheme.hashCode();
}
} | 9,902 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/userauth/EmailPasswordStore.java | /**
* Copyright (c) 2014 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.userauth;
import com.netflix.msl.tokens.MslUser;
/**
* An email/password store contains user credentials.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public interface EmailPasswordStore {
/**
* Return the user if the email/password combination is valid.
*
* @param email email address.
* @param password password.
* @return the MSL user or null if there is no such user.
*/
public MslUser isUser(final String email, final String password);
}
| 9,903 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/userauth/UserIdTokenAuthenticationFactory.java | /**
* Copyright (c) 2014-2018 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.userauth;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.MslUserAuthException;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.tokens.MasterToken;
import com.netflix.msl.tokens.MslUser;
import com.netflix.msl.tokens.UserIdToken;
import com.netflix.msl.util.AuthenticationUtils;
import com.netflix.msl.util.MslContext;
/**
* User ID token-based user authentication factory.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class UserIdTokenAuthenticationFactory extends UserAuthenticationFactory {
/**
* Construct a new user ID token-based user authentication factory.
*
* @param authutils authentication utilities.
*/
public UserIdTokenAuthenticationFactory(final AuthenticationUtils authutils) {
super(UserAuthenticationScheme.USER_ID_TOKEN);
this.authutils = authutils;
}
/* (non-Javadoc)
* @see com.netflix.msl.userauth.UserAuthenticationFactory#createData(com.netflix.msl.util.MslContext, com.netflix.msl.tokens.MasterToken, com.netflix.msl.io.MslObject)
*/
@Override
public UserAuthenticationData createData(final MslContext ctx, final MasterToken masterToken, final MslObject userAuthMo) throws MslEncodingException, MslUserAuthException {
return new UserIdTokenAuthenticationData(ctx, userAuthMo);
}
/* (non-Javadoc)
* @see com.netflix.msl.userauth.UserAuthenticationFactory#authenticate(com.netflix.msl.util.MslContext, java.lang.String, com.netflix.msl.userauth.UserAuthenticationData, com.netflix.msl.tokens.UserIdToken)
*/
@Override
public MslUser authenticate(final MslContext ctx, final String identity, final UserAuthenticationData data, final UserIdToken userIdToken) throws MslUserAuthException {
// Make sure we have the right kind of user authentication data.
if (!(data instanceof UserIdTokenAuthenticationData))
throw new MslInternalException("Incorrect authentication data type " + data.getClass().getName() + ".");
final UserIdTokenAuthenticationData uitad = (UserIdTokenAuthenticationData)data;
// Verify the scheme is permitted.
if(!authutils.isSchemePermitted(identity, this.getScheme()))
throw new MslUserAuthException(MslError.USERAUTH_ENTITY_INCORRECT_DATA, "Authentication scheme " + this.getScheme() + " not permitted for entity " + identity + ".").setUserAuthenticationData(data);
// Extract and check master token.
final MasterToken uitadMasterToken = uitad.getMasterToken();
final String uitadIdentity = uitadMasterToken.getIdentity();
if (uitadIdentity == null)
throw new MslUserAuthException(MslError.USERAUTH_MASTERTOKEN_NOT_DECRYPTED).setUserAuthenticationData(uitad);
if (!identity.equals(uitadIdentity))
throw new MslUserAuthException(MslError.USERAUTH_ENTITY_MISMATCH, "entity identity " + identity + "; uad identity " + uitadIdentity).setUserAuthenticationData(uitad);
// Authenticate the user.
final UserIdToken uitadUserIdToken = uitad.getUserIdToken();
final MslUser user = uitadUserIdToken.getUser();
if (user == null)
throw new MslUserAuthException(MslError.USERAUTH_USERIDTOKEN_NOT_DECRYPTED).setUserAuthenticationData(uitad);
// Verify the scheme is still permitted.
if (!authutils.isSchemePermitted(identity, user, this.getScheme()))
throw new MslUserAuthException(MslError.USERAUTH_ENTITYUSER_INCORRECT_DATA, "Authentication scheme " + this.getScheme() + " not permitted for entity " + identity + ".").setUserAuthenticationData(data);
// Verify token has not been revoked.
final MslError revokeMslError;
try {
revokeMslError = ctx.getTokenFactory().isUserIdTokenRevoked(ctx, uitadMasterToken, uitadUserIdToken);
} catch (final MslException e) {
throw new MslUserAuthException(MslError.USERAUTH_USERIDTOKEN_REVOKE_CHECK_ERROR, "Error while checking user ID token for revocation.", e).setUserAuthenticationData(uitad);
}
if (revokeMslError != null)
throw new MslUserAuthException(revokeMslError, "User ID token used to authenticate was revoked.").setUserAuthenticationData(uitad);
// If a user ID token was provided validate the user identities.
if (userIdToken != null) {
final MslUser uitUser = userIdToken.getUser();
if (!user.equals(uitUser))
throw new MslUserAuthException(MslError.USERIDTOKEN_USERAUTH_DATA_MISMATCH, "uad user " + user + "; uit user " + uitUser).setUserAuthenticationData(uitad);
}
// Return the user.
return user;
}
/** Authentication utilities. */
private final AuthenticationUtils authutils;
}
| 9,904 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/tokens/MasterToken.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.tokens;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import com.netflix.msl.MslConstants;
import com.netflix.msl.MslConstants.EncryptionAlgo;
import com.netflix.msl.MslConstants.SignatureAlgo;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.crypto.JcaAlgorithm;
import com.netflix.msl.io.MslEncodable;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.util.Base64;
import com.netflix.msl.util.MslContext;
/**
* <p>The master token provides proof of remote entity identity. A MSL-specific
* crypto context is used to encrypt the master token data and generate the
* master token verification data. The remote entity cannot decrypt the master
* token data or generate the master token verification data.</p>
*
* <p>The master token session keys will be used for MSL message encryption and
* integrity protection. The use of these session keys implies the MSL message
* identity as specified in the master token.</p>
*
* <p>Master tokens also contain a sequence number identifying the issue number
* of the token. This is a monotonically increasing number that is incremented
* by one each time a master token is renewed.</p>
*
* <p>When in possession of multiple master tokens, the token with the highest
* sequence number should be considered the newest token. Since the sequence
* number space is signed 53-bit numbers, if a sequence number is smaller by
* more than 45-bits (e.g. the new sequence number is <= 128 and the old
* sequence number is 2^53), it is considered the newest token.</p>
*
* <p>The renewal window indicates the time after which the master token will
* be renewed if requested by the entity. The expiration is the time after
* which the master token will be renewed no matter what.</p>
*
* <p>Master tokens also contain a serial number against which all other tokens
* are bound. Changing the serial number when the master token is renewed
* invalidates all of those tokens.</p>
*
* <p>The issuer identity identifies the issuer of this master token, which may
* be useful to services that accept the master token.</p>
*
* <p>While there can be multiple versions of a master token, this class should
* encapsulate support for all of those versions.</p>
*
* <p>Master tokens are represented as
* {@code
* mastertoken = {
* "#mandatory" : [ "tokendata", "signature" ],
* "tokendata" : "binary",
* "signature" : "binary"
* }} where:
* <ul>
* <li>{@code tokendata} is the master token data (mastertokendata)</li>
* <li>{@code signature} is the verification data of the master token data</li>
* </ul></p>
*
* <p>The token data is represented as
* {@code
* mastertokendata = {
* "#mandatory" : [ "renewalwindow", "expiration", "sequencenumber", "serialnumber", "sessiondata" ],
* "renewalwindow" : "int64(0,-)",
* "expiration" : "int64(0,-)",
* "sequencenumber" : "int64(0,2^53^)",
* "serialnumber" : "int64(0,2^53^)",
* "sessiondata" : "binary"
* }} where:
* <ul>
* <li>{@code renewalwindow} is when the renewal window opens in seconds since the epoch</li>
* <li>{@code expiration} is the expiration timestamp in seconds since the epoch</li>
* <li>{@code sequencenumber} is the master token sequence number</li>
* <li>{@code serialnumber} is the master token serial number</li>
* <li>{@code sessiondata} is the encrypted session data (sessiondata)</li>
* </ul></p>
*
* <p>The decrypted session data is represented as
* {@code
* sessiondata = {
* "#mandatory" : [ "identity", "encryptionkey" ],
* "#conditions" : [ "hmackey" or "signaturekey" ],
* "issuerdata" : object,
* "identity" : "string",
* "encryptionkey" : "binary",
* "encryptionkeyalgorithm" : "string",
* "hmackey" : "binary",
* "signaturekey" : "binary",
* "signaturekeyalgorithm" : "string",
* }}
* where:
* <ul>
* <li>{@code issuerdata} is the master token issuer data</li>
* <li>{@code identity} is the identifier of the remote entity</li>
* <li>{@code encryptionkey} is the encryption session key</li>
* <li>{@code encryptionkeyalgorithm} is the JCA encryption algorithm name (default: AES/CBC/PKCS5Padding)</li>
* <li>{@code hmackey} is the HMAC session key</li>
* <li>{@code signaturekey} is the signature session key</li>
* <li>{@code signaturekeyalgorithm} is the JCA signature algorithm name (default: HmacSHA256)</li>
* </ul></p>
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class MasterToken implements MslEncodable {
/** Milliseconds per second. */
private static final long MILLISECONDS_PER_SECOND = 1000;
/** Key token data. */
private static final String KEY_TOKENDATA = "tokendata";
/** Key signature. */
private static final String KEY_SIGNATURE = "signature";
// tokendata
/** Key renewal window timestamp. */
private static final String KEY_RENEWAL_WINDOW = "renewalwindow";
/** Key expiration timestamp. */
private static final String KEY_EXPIRATION = "expiration";
/** Key sequence number. */
private static final String KEY_SEQUENCE_NUMBER = "sequencenumber";
/** Key serial number. */
private static final String KEY_SERIAL_NUMBER = "serialnumber";
/** Key session data. */
private static final String KEY_SESSIONDATA = "sessiondata";
// sessiondata
/** Key issuer data. */
private static final String KEY_ISSUER_DATA = "issuerdata";
/** Key identity. */
private static final String KEY_IDENTITY = "identity";
/** Key symmetric encryption key. */
private static final String KEY_ENCRYPTION_KEY = "encryptionkey";
/** Key encryption algorithm. */
private static final String KEY_ENCRYPTION_ALGORITHM = "encryptionalgorithm";
/** Key symmetric HMAC key. */
private static final String KEY_HMAC_KEY = "hmackey";
/** Key signature key. */
private static final String KEY_SIGNATURE_KEY = "signaturekey";
/** Key signature algorithm. */
private static final String KEY_SIGNATURE_ALGORITHM = "signaturealgorithm";
/**
* Create a new master token with the specified expiration, identity,
* serial number, and encryption and signature keys.
*
* @param ctx MSL context.
* @param renewalWindow the renewal window.
* @param expiration the expiration.
* @param sequenceNumber the master token sequence number.
* @param serialNumber the master token serial number.
* @param issuerData the issuer data. May be null.
* @param identity the singular identity this master token represents.
* @param encryptionKey the session encryption key.
* @param signatureKey the session signature key.
* @throws MslEncodingException if there is an error encoding the data.
* @throws MslCryptoException if there is an error encrypting or signing
* the token data or the crypto algorithms are not recognized.
*/
public MasterToken(final MslContext ctx, final Date renewalWindow, final Date expiration, final long sequenceNumber, final long serialNumber, final MslObject issuerData, final String identity, final SecretKey encryptionKey, final SecretKey signatureKey) throws MslEncodingException, MslCryptoException {
// The expiration must appear after the renewal window.
if (expiration.before(renewalWindow))
throw new MslInternalException("Cannot construct a master token that expires before its renewal window opens.");
// The sequence number and serial number must be within range.
if (sequenceNumber < 0 || sequenceNumber > MslConstants.MAX_LONG_VALUE)
throw new MslInternalException("Sequence number " + sequenceNumber + " is outside the valid range.");
if (serialNumber < 0 || serialNumber > MslConstants.MAX_LONG_VALUE)
throw new MslInternalException("Serial number " + serialNumber + " is outside the valid range.");
this.ctx = ctx;
this.renewalWindow = renewalWindow.getTime() / MILLISECONDS_PER_SECOND;
this.expiration = expiration.getTime() / MILLISECONDS_PER_SECOND;
this.sequenceNumber = sequenceNumber;
this.serialNumber = serialNumber;
this.issuerdata = issuerData;
this.identity = identity;
this.encryptionKey = encryptionKey;
this.signatureKey = signatureKey;
// Encode session keys and algorithm names.
final byte[] encryptionKeyBytes = this.encryptionKey.getEncoded();
final byte[] signatureKeyBytes = this.signatureKey.getEncoded();
final EncryptionAlgo encryptionAlgo;
final SignatureAlgo signatureAlgo;
try {
encryptionAlgo = EncryptionAlgo.fromString(this.encryptionKey.getAlgorithm());
signatureAlgo = SignatureAlgo.fromString(this.signatureKey.getAlgorithm());
} catch (final IllegalArgumentException e) {
throw new MslCryptoException(MslError.UNIDENTIFIED_ALGORITHM, "encryption algorithm: " + this.encryptionKey.getAlgorithm() + "; signature algorithm: " + this.signatureKey.getAlgorithm(), e);
}
// Create session data.
final MslEncoderFactory encoder = ctx.getMslEncoderFactory();
this.sessiondata = encoder.createObject();
if (this.issuerdata != null)
this.sessiondata.put(KEY_ISSUER_DATA, this.issuerdata);
this.sessiondata.put(KEY_IDENTITY, this.identity);
this.sessiondata.put(KEY_ENCRYPTION_KEY, encryptionKeyBytes);
this.sessiondata.put(KEY_ENCRYPTION_ALGORITHM, encryptionAlgo);
this.sessiondata.put(KEY_HMAC_KEY, signatureKeyBytes);
this.sessiondata.put(KEY_SIGNATURE_KEY, signatureKeyBytes);
this.sessiondata.put(KEY_SIGNATURE_ALGORITHM, signatureAlgo);
this.tokendataBytes = null;
this.signatureBytes = null;
this.verified = true;
}
/**
* Create a new master token from the provided MSL object.
*
* @param ctx MSL context.
* @param masterTokenMo master token MSL object.
* @throws MslEncodingException if there is an error parsing the object,
* the token data is missing or invalid, the signature is missing
* or invalid, or the session data is missing or invalid.
* @throws MslCryptoException if there is an error verifying the token data
* or extracting the session keys.
* @throws MslException if the expiration timestamp occurs before the
* renewal window, or the sequence number is out of range, or the
* serial number is out of range.
*/
public MasterToken(final MslContext ctx, final MslObject masterTokenMo) throws MslEncodingException, MslCryptoException, MslException {
this.ctx = ctx;
// Grab the crypto context.
final ICryptoContext cryptoContext = ctx.getMslCryptoContext();
// Verify the encoding.
final MslEncoderFactory encoder = ctx.getMslEncoderFactory();
try {
tokendataBytes = masterTokenMo.getBytes(KEY_TOKENDATA);
if (tokendataBytes.length == 0)
throw new MslEncodingException(MslError.MASTERTOKEN_TOKENDATA_MISSING, "mastertoken " + masterTokenMo);
signatureBytes = masterTokenMo.getBytes(KEY_SIGNATURE);
verified = cryptoContext.verify(tokendataBytes, signatureBytes, encoder);
} catch (final MslEncoderException e) {
throw new MslEncodingException(MslError.MSL_PARSE_ERROR, "mastertoken " + masterTokenMo, e);
}
// Pull the token data.
final byte[] plaintext;
try {
final MslObject tokendata = encoder.parseObject(tokendataBytes);
renewalWindow = tokendata.getLong(KEY_RENEWAL_WINDOW);
expiration = tokendata.getLong(KEY_EXPIRATION);
if (expiration < renewalWindow)
throw new MslException(MslError.MASTERTOKEN_EXPIRES_BEFORE_RENEWAL, "mastertokendata " + tokendata);
sequenceNumber = tokendata.getLong(KEY_SEQUENCE_NUMBER);
if (sequenceNumber < 0 || sequenceNumber > MslConstants.MAX_LONG_VALUE)
throw new MslException(MslError.MASTERTOKEN_SEQUENCE_NUMBER_OUT_OF_RANGE, "mastertokendata " + tokendata);
serialNumber = tokendata.getLong(KEY_SERIAL_NUMBER);
if (serialNumber < 0 || serialNumber > MslConstants.MAX_LONG_VALUE)
throw new MslException(MslError.MASTERTOKEN_SERIAL_NUMBER_OUT_OF_RANGE, "mastertokendata " + tokendata);
final byte[] ciphertext = tokendata.getBytes(KEY_SESSIONDATA);
if (ciphertext.length == 0)
throw new MslEncodingException(MslError.MASTERTOKEN_SESSIONDATA_MISSING, "mastertokendata " + tokendata);
plaintext = (this.verified) ? cryptoContext.decrypt(ciphertext, encoder) : null;
} catch (final MslEncoderException e) {
throw new MslEncodingException(MslError.MASTERTOKEN_TOKENDATA_PARSE_ERROR, "mastertokendata " + Base64.encode(tokendataBytes), e);
}
// Pull the session data.
if (plaintext != null) {
final byte[] rawEncryptionKey, rawSignatureKey;
final String encryptionAlgo, signatureAlgo;
try {
sessiondata = encoder.parseObject(plaintext);
issuerdata = (sessiondata.has(KEY_ISSUER_DATA)) ? sessiondata.getMslObject(KEY_ISSUER_DATA, encoder) : null;
identity = sessiondata.getString(KEY_IDENTITY);
rawEncryptionKey = sessiondata.getBytes(KEY_ENCRYPTION_KEY);
encryptionAlgo = sessiondata.optString(KEY_ENCRYPTION_ALGORITHM, JcaAlgorithm.AES);
rawSignatureKey = (sessiondata.has(KEY_SIGNATURE_KEY))
? sessiondata.getBytes(KEY_SIGNATURE_KEY)
: sessiondata.getBytes(KEY_HMAC_KEY);
signatureAlgo = sessiondata.optString(KEY_SIGNATURE_ALGORITHM, JcaAlgorithm.HMAC_SHA256);
} catch (final MslEncoderException e) {
throw new MslEncodingException(MslError.MASTERTOKEN_SESSIONDATA_PARSE_ERROR, "sessiondata " + Base64.encode(plaintext), e);
}
// Decode algorithm names.
final String jcaEncryptionAlgo, jcaSignatureAlgo;
try {
jcaEncryptionAlgo = EncryptionAlgo.fromString(encryptionAlgo).toString();
jcaSignatureAlgo = SignatureAlgo.fromString(signatureAlgo).toString();
} catch (final IllegalArgumentException e) {
throw new MslCryptoException(MslError.UNIDENTIFIED_ALGORITHM, "encryption algorithm: " + encryptionAlgo + "; signature algorithm" + signatureAlgo, e);
}
// Reconstruct keys.
try {
encryptionKey = new SecretKeySpec(rawEncryptionKey, jcaEncryptionAlgo);
signatureKey = new SecretKeySpec(rawSignatureKey, jcaSignatureAlgo);
} catch (final IllegalArgumentException e) {
throw new MslCryptoException(MslError.MASTERTOKEN_KEY_CREATION_ERROR, e);
}
} else {
sessiondata = null;
issuerdata = null;
identity = null;
encryptionKey = null;
signatureKey = null;
}
}
/**
* @return true if the decrypted content is available. (Implies verified.)
*/
public boolean isDecrypted() {
return sessiondata != null;
}
/**
* @return true if the token has been verified.
*/
public boolean isVerified() {
return verified;
}
/**
* @return the start of the renewal window.
*/
public Date getRenewalWindow() {
return new Date(renewalWindow * MILLISECONDS_PER_SECOND);
}
/**
* <p>Returns true if the master token renewal window has been entered.</p>
*
* <ul>
* <li>If a time is provided the renewal window value will be compared
* against the provided time.</li>
* <li>If the master token was issued by the local entity the renewal
* window value will be compared against the local entity time. We assume
* its clock at the time of issuance is in sync with the clock now.</li>
* <li>Otherwise the master token is considered renewable under the
* assumption that the local time is not synchronized with the master token
* issuing entity time.</li>
* </ul>
*
* @param now the time to compare against. May be {@code null}.
* @return true if the renewal window has been entered.
*/
public boolean isRenewable(final Date now) {
if (now != null)
return renewalWindow * MILLISECONDS_PER_SECOND <= now.getTime();
if (isVerified())
return renewalWindow * MILLISECONDS_PER_SECOND <= ctx.getTime();
return true;
}
/**
* @return the expiration.
*/
public Date getExpiration() {
return new Date(expiration * MILLISECONDS_PER_SECOND);
}
/**
* <p>Returns true if the master token is expired.</p>
*
* <ul>
* <li>If a time is provided the expiration value will be compared against
* the provided time.</li>
* <li>If the master token was issued by the local entity the expiration
* value will be compared against the local entity time. We assume
* its clock at the time of issuance is in sync with the clock now.</li>
* <li>Otherwise the master token is considered not expired under the
* assumption that the local time is not synchronized with the token-
* issuing entity time.</li>
* </ul>
*
* @param now the time to compare against.
* @return true if expired.
*/
public boolean isExpired(final Date now) {
if (now != null)
return expiration * MILLISECONDS_PER_SECOND <= now.getTime();
if (isVerified())
return expiration * MILLISECONDS_PER_SECOND <= ctx.getTime();
return false;
}
/**
* @return the sequence number.
*/
public long getSequenceNumber() {
return sequenceNumber;
}
/**
* @return the serial number.
*/
public long getSerialNumber() {
return serialNumber;
}
/**
* <p>A master token is considered newer if its sequence number is greater
* than another master token. If both the sequence numbers are equal, then
* the master token with the later expiration date is considered newer.</p>
*
* <p>Serial numbers are not taken into consideration when comparing which
* master token is newer because serial numbers will change when new master
* tokens are created as opposed to renewed. The caller of this function
* should already be comparing master tokens that can be used
* interchangeably (i.e. for the same MSL network).</p>
*
* @param that the master token to compare with.
* @return true if this master token is newer than the provided one.
*/
public boolean isNewerThan(final MasterToken that) {
// If the sequence numbers are equal then compare the expiration dates.
if (this.sequenceNumber == that.sequenceNumber)
return this.expiration > that.expiration;
// If this sequence number is bigger than that sequence number, make
// sure that sequence number is not less than the cutoff.
if (this.sequenceNumber > that.sequenceNumber) {
final long cutoff = this.sequenceNumber - MslConstants.MAX_LONG_VALUE + 127;
return that.sequenceNumber >= cutoff;
}
// If this sequence number is smaller than that sequence number, make
// sure this sequence number is less than the cutoff.
final long cutoff = that.sequenceNumber - MslConstants.MAX_LONG_VALUE + 127;
return this.sequenceNumber < cutoff;
}
/**
* Returns the issuer data.
*
* @return the master token issuer data or null if there is none or it is
* unknown (session data could not be decrypted).
*/
public MslObject getIssuerData() {
return issuerdata;
}
/**
* Returns the identifier of the authenticated peer.
*
* @return the Netflix peer identity or null if unknown (session data could
* not be decrypted).
*/
public String getIdentity() {
return identity;
}
/**
* @return the encryption key or null if unknown (session data could not be
* decrypted).
*/
public SecretKey getEncryptionKey() {
return encryptionKey;
}
/**
* @return the signature key or null if unknown (session data could not be
* decrypted).
*/
public SecretKey getSignatureKey() {
return signatureKey;
}
/** MSL context. */
private final MslContext ctx;
/** Master token renewal window in seconds since the epoch. */
private final long renewalWindow;
/** Master token expiration in seconds since the epoch. */
private final long expiration;
/** Sequence number. */
private final long sequenceNumber;
/** Serial number. */
private final long serialNumber;
/** Session data. */
private final MslObject sessiondata;
/** Issuer data. */
private final MslObject issuerdata;
/** Entity identity. */
private final String identity;
/** Encryption key. */
private final SecretKey encryptionKey;
/** Signature key. */
private final SecretKey signatureKey;
/** Token data bytes. */
private final byte[] tokendataBytes;
/** Signature bytes. */
private final byte[] signatureBytes;
/** Token is verified. */
private final boolean verified;
/** Cached encodings. */
private final Map<MslEncoderFormat,byte[]> encodings = new HashMap<MslEncoderFormat,byte[]>();
/* (non-Javadoc)
* @see com.netflix.msl.io.MslEncodable#toMslEncoding(com.netflix.msl.io.MslEncoderFactory, com.netflix.msl.io.MslEncoderFormat)
*/
@Override
public byte[] toMslEncoding(final MslEncoderFactory encoder, final MslEncoderFormat format) throws MslEncoderException {
// Return any cached encoding.
if (encodings.containsKey(format))
return encodings.get(format);
// If we parsed this token (i.e. did not create it from scratch) then
// we should not re-encrypt or re-sign as there is no guarantee out MSL
// crypto context is capable of encrypting and signing with the same
// keys, even if it is capable of decrypting and verifying.
final byte[] data, signature;
if (tokendataBytes != null || signatureBytes != null) {
data = tokendataBytes;
signature = signatureBytes;
}
//
// Otherwise create the token data and signature.
else {
// Grab the MSL token crypto context.
final ICryptoContext cryptoContext;
try {
cryptoContext = ctx.getMslCryptoContext();
} catch (final MslCryptoException e) {
throw new MslEncoderException("Error creating the MSL crypto context.", e);
}
// Encrypt the session data.
final byte[] plaintext = encoder.encodeObject(sessiondata, format);
final byte[] ciphertext;
try {
ciphertext = cryptoContext.encrypt(plaintext, encoder, format);
} catch (final MslCryptoException e) {
throw new MslEncoderException("Error encrypting the session data.", e);
}
// Construct the token data.
final MslObject tokendata = encoder.createObject();
tokendata.put(KEY_RENEWAL_WINDOW, renewalWindow);
tokendata.put(KEY_EXPIRATION, expiration);
tokendata.put(KEY_SEQUENCE_NUMBER, sequenceNumber);
tokendata.put(KEY_SERIAL_NUMBER, serialNumber);
tokendata.put(KEY_SESSIONDATA, ciphertext);
// Sign the token data.
data = encoder.encodeObject(tokendata, format);
try {
signature = cryptoContext.sign(data, encoder, format);
} catch (final MslCryptoException e) {
throw new MslEncoderException("Error signing the token data.", e);
}
}
// Encode the token.
final MslObject token = encoder.createObject();
token.put(KEY_TOKENDATA, data);
token.put(KEY_SIGNATURE, signature);
final byte[] encoding = encoder.encodeObject(token, format);
// Cache and return the encoding.
encodings.put(format, encoding);
return encoding;
}
/* (non-Javadoc)
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
final MslEncoderFactory encoder = ctx.getMslEncoderFactory();
final MslObject tokendata = encoder.createObject();
tokendata.put(KEY_RENEWAL_WINDOW, renewalWindow);
tokendata.put(KEY_EXPIRATION, expiration);
tokendata.put(KEY_SEQUENCE_NUMBER, sequenceNumber);
tokendata.put(KEY_SERIAL_NUMBER, serialNumber);
tokendata.put(KEY_SESSIONDATA, "(redacted)");
final MslObject token = encoder.createObject();
token.put(KEY_TOKENDATA, tokendata);
token.put(KEY_SIGNATURE, (signatureBytes != null) ? signatureBytes : "(null)");
return token.toString();
}
/**
* <p>Returns true if the other object is a master token with the same
* serial number, sequence number, and expiration. The expiration is
* considered in the event the issuer renews a master token but is unable
* or unwilling to increment the sequence number.</p>
*
* @param obj the reference object with which to compare.
* @return true if the other object is a master token with the same
* serial number, sequence number, and expiration.
* @see java.lang.Object#equals(java.lang.Object)
*/
@Override
public boolean equals(final Object obj) {
if (this == obj) return true;
if (obj instanceof MasterToken) {
final MasterToken that = (MasterToken)obj;
return this.serialNumber == that.serialNumber &&
this.sequenceNumber == that.sequenceNumber &&
this.expiration == that.expiration;
}
return false;
}
/* (non-Javadoc)
* @see java.lang.Object#hashCode()
*/
@Override
public int hashCode() {
return (String.valueOf(serialNumber) + ":" + String.valueOf(sequenceNumber) + ":" + String.valueOf(expiration)).hashCode();
}
}
| 9,905 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/tokens/UserIdToken.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.tokens;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import com.netflix.msl.MslConstants;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.io.MslEncodable;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.util.Base64;
import com.netflix.msl.util.MslContext;
/**
* <p>A user ID token provides proof of user identity. While there can be
* multiple versions of a user ID token, this class should encapsulate support
* for all of those versions.</p>
*
* <p>User ID tokens are bound to a specific master token by the master token's
* serial number.</p>
*
* <p>The renewal window indicates the time after which the user ID token will
* be renewed if requested by the entity. The expiration is the time after
* which the user ID token will be renewed no matter what.</p>
*
* <p>User ID tokens are represented as
* {@code
* useridtoken = {
* "#mandatory" : [ "tokendata", "signature" ],
* "tokendata" : "binary",
* "signature" : "binary"
* }} where:
* <ul>
* <li>{@code tokendata} is the user ID token data (usertokendata)</li>
* <li>{@code signature} is the verification data of the user ID token data</li>
* </ul>
*
* <p>The token data is represented as
* {@code
* usertokendata = {
* "#mandatory" : [ "renewalwindow", "expiration", "mtserialnumber", "serialnumber", "userdata" ],
* "renewalwindow" : "int64(0,-)",
* "expiration" : "int64(0,-)",
* "mtserialnumber" : "int64(0,2^53^)",
* "serialnumber" : "int64(0,2^53^)",
* "userdata" : "binary"
* }} where:
* <ul>
* <li>{@code renewalwindow} is when the renewal window opens in seconds since the epoch</li>
* <li>{@code expiration} is the expiration timestamp in seconds since the epoch</li>
* <li>{@code mtserialnumber} is the master token serial number</li>
* <li>{@code serialnumber} is the user ID token serial number</li>
* <li>{@code userdata} is the encrypted user data (userdata)</li>
* </ul></p>
*
* <p>The decrypted user data is represented as
* {@code
* userdata = {
* "#mandatory" : [ "identity" ],
* "issuerdata" : object,
* "identity" : "string"
* }}
* where:
* <ul>
* <li>{@code issuerdata} is the user ID token issuer data</li>
* <li>{@code identity} is the encoded user identity data</li>
* </ul></p>
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class UserIdToken implements MslEncodable {
/** Milliseconds per second. */
private static final long MILLISECONDS_PER_SECOND = 1000;
/** Key token data. */
private static final String KEY_TOKENDATA = "tokendata";
/** Key signature. */
private static final String KEY_SIGNATURE = "signature";
// tokendata
/** Key renewal window timestamp. */
private static final String KEY_RENEWAL_WINDOW = "renewalwindow";
/** Key expiration timestamp. */
private static final String KEY_EXPIRATION = "expiration";
/** Key master token serial number. */
private static final String KEY_MASTER_TOKEN_SERIAL_NUMBER = "mtserialnumber";
/** Key user ID token serial number. */
private static final String KEY_SERIAL_NUMBER = "serialnumber";
/** Key token user data. */
private static final String KEY_USERDATA = "userdata";
// userdata
/** Key issuer data. */
private static final String KEY_ISSUER_DATA = "issuerdata";
/** Key identity. */
private static final String KEY_IDENTITY = "identity";
/**
* Create a new user ID token with the specified user.
*
* @param ctx MSL context.
* @param renewalWindow the renewal window.
* @param expiration the expiration.
* @param masterToken the master token.
* @param serialNumber the user ID token serial number.
* @param issuerData the issuer data. May be null.
* @param user the MSL user.
* @throws MslEncodingException if there is an error encoding the data.
* @throws MslCryptoException if there is an error encrypting or signing
* the token data.
*/
public UserIdToken(final MslContext ctx, final Date renewalWindow, final Date expiration, final MasterToken masterToken, final long serialNumber, final MslObject issuerData, final MslUser user) throws MslEncodingException, MslCryptoException {
// The expiration must appear after the renewal window.
if (expiration.before(renewalWindow))
throw new MslInternalException("Cannot construct a user ID token that expires before its renewal window opens.");
// A master token must be provided.
if (masterToken == null)
throw new MslInternalException("Cannot construct a user ID token without a master token.");
// The serial number must be within range.
if (serialNumber < 0 || serialNumber > MslConstants.MAX_LONG_VALUE)
throw new MslInternalException("Serial number " + serialNumber + " is outside the valid range.");
this.ctx = ctx;
this.renewalWindow = renewalWindow.getTime() / MILLISECONDS_PER_SECOND;
this.expiration = expiration.getTime() / MILLISECONDS_PER_SECOND;
this.mtSerialNumber = masterToken.getSerialNumber();
this.serialNumber = serialNumber;
this.issuerdata = issuerData;
this.user = user;
// Construct the user data.
final MslEncoderFactory encoder = this.ctx.getMslEncoderFactory();
this.userdata = encoder.createObject();
if (this.issuerdata != null)
this.userdata.put(KEY_ISSUER_DATA, this.issuerdata);
this.userdata.put(KEY_IDENTITY, user.getEncoded());
this.tokendataBytes = null;
this.signatureBytes = null;
this.verified = true;
}
/**
* Create a new user ID token from the provided MSL object. The associated
* master token must be provided to verify the user ID token.
*
* @param ctx MSL context.
* @param userIdTokenMo user ID token MSL object.
* @param masterToken the master token.
* @throws MslEncodingException if there is an error parsing the data, the
* token data is missing or invalid, or the signature is invalid.
* @throws MslCryptoException if there is an error verifying the token
* data.
* @throws MslException if the user ID token master token serial number
* does not match the master token serial number, or the expiration
* timestamp occurs before the renewal window, or the user data is
* missing or invalid, or the user ID token master token serial
* number is out of range, or the user ID token serial number is
* out of range.
*/
public UserIdToken(final MslContext ctx, final MslObject userIdTokenMo, final MasterToken masterToken) throws MslEncodingException, MslCryptoException, MslException {
this.ctx = ctx;
// Grab the crypto context and encoder.
final ICryptoContext cryptoContext = ctx.getMslCryptoContext();
final MslEncoderFactory encoder = ctx.getMslEncoderFactory();
// Verify the encoding.
try {
tokendataBytes = userIdTokenMo.getBytes(KEY_TOKENDATA);
if (tokendataBytes.length == 0)
throw new MslEncodingException(MslError.USERIDTOKEN_TOKENDATA_MISSING, "useridtoken " + userIdTokenMo).setMasterToken(masterToken);
signatureBytes = userIdTokenMo.getBytes(KEY_SIGNATURE);
verified = cryptoContext.verify(tokendataBytes, signatureBytes, encoder);
} catch (final MslEncoderException e) {
throw new MslEncodingException(MslError.MSL_PARSE_ERROR, "useridtoken " + userIdTokenMo, e).setMasterToken(masterToken);
}
// Pull the token data.
final byte[] plaintext;
try {
final MslObject tokendata = encoder.parseObject(tokendataBytes);
renewalWindow = tokendata.getLong(KEY_RENEWAL_WINDOW);
expiration = tokendata.getLong(KEY_EXPIRATION);
if (expiration < renewalWindow)
throw new MslException(MslError.USERIDTOKEN_EXPIRES_BEFORE_RENEWAL, "usertokendata " + tokendata).setMasterToken(masterToken);
mtSerialNumber = tokendata.getLong(KEY_MASTER_TOKEN_SERIAL_NUMBER);
if (mtSerialNumber < 0 || mtSerialNumber > MslConstants.MAX_LONG_VALUE)
throw new MslException(MslError.USERIDTOKEN_MASTERTOKEN_SERIAL_NUMBER_OUT_OF_RANGE, "usertokendata " + tokendata).setMasterToken(masterToken);
serialNumber = tokendata.getLong(KEY_SERIAL_NUMBER);
if (serialNumber < 0 || serialNumber > MslConstants.MAX_LONG_VALUE)
throw new MslException(MslError.USERIDTOKEN_SERIAL_NUMBER_OUT_OF_RANGE, "usertokendata " + tokendata).setMasterToken(masterToken);
final byte[] ciphertext = tokendata.getBytes(KEY_USERDATA);
if (ciphertext.length == 0)
throw new MslException(MslError.USERIDTOKEN_USERDATA_MISSING).setMasterToken(masterToken);
plaintext = (verified) ? cryptoContext.decrypt(ciphertext, encoder) : null;
} catch (final MslEncoderException e) {
throw new MslEncodingException(MslError.USERIDTOKEN_TOKENDATA_PARSE_ERROR, "usertokendata " + Base64.encode(tokendataBytes), e).setMasterToken(masterToken);
} catch (final MslCryptoException e) {
e.setMasterToken(masterToken);
throw e;
}
// Pull the user data.
if (plaintext != null) {
try {
userdata = encoder.parseObject(plaintext);
issuerdata = (userdata.has(KEY_ISSUER_DATA)) ? userdata.getMslObject(KEY_ISSUER_DATA, encoder) : null;
final String identity = userdata.getString(KEY_IDENTITY);
if (identity == null || identity.length() == 0)
throw new MslException(MslError.USERIDTOKEN_IDENTITY_INVALID, "userdata " + userdata).setMasterToken(masterToken);
final TokenFactory factory = ctx.getTokenFactory();
user = factory.createUser(ctx, identity);
if (user == null)
throw new MslInternalException("TokenFactory.createUser() returned null in violation of the interface contract.");
} catch (final MslEncoderException e) {
throw new MslEncodingException(MslError.USERIDTOKEN_USERDATA_PARSE_ERROR, "userdata " + Base64.encode(plaintext), e).setMasterToken(masterToken);
}
} else {
userdata = null;
issuerdata = null;
user = null;
}
// Verify serial numbers.
if (masterToken == null || this.mtSerialNumber != masterToken.getSerialNumber())
throw new MslException(MslError.USERIDTOKEN_MASTERTOKEN_MISMATCH, "uit mtserialnumber " + this.mtSerialNumber + "; mt " + masterToken).setMasterToken(masterToken);
}
/**
* @return true if the decrypted content is available. (Implies verified.)
*/
public boolean isDecrypted() {
return user != null;
}
/**
* @return true if the token has been verified.
*/
public boolean isVerified() {
return verified;
}
/**
* @return the start of the renewal window.
*/
public Date getRenewalWindow() {
return new Date(renewalWindow * MILLISECONDS_PER_SECOND);
}
/**
* <p>Returns true if the user ID token renewal window has been entered.</p>
*
* <ul>
* <li>If a time is provided the renewal window value will be compared
* against the provided time.</li>
* <li>If the user ID token was issued by the local entity the renewal
* window value will be compared against the local entity time. We assume
* its clock at the time of issuance is in sync with the clock now.</li>
* <li>Otherwise the user ID token is considered renewable under the
* assumption that the local time is not synchronized with the master token
* issuing entity time.</li>
* </ul>
*
* @param now the time to compare against. May be {@code null}.
* @return true if the renewal window has been entered.
*/
public boolean isRenewable(final Date now) {
if (now != null)
return renewalWindow * MILLISECONDS_PER_SECOND <= now.getTime();
if (isVerified())
return renewalWindow * MILLISECONDS_PER_SECOND <= ctx.getTime();
return true;
}
/**
* @return the expiration.
*/
public Date getExpiration() {
return new Date(expiration * MILLISECONDS_PER_SECOND);
}
/**
* <p>Returns true if the user ID token is expired.</p>
*
* <ul>
* <li>If a time is provided the expiration value will be compared against
* the provided time.</li>
* <li>If the user ID token was issued by the local entity the expiration
* value will be compared against the local entity time. We assume
* its clock at the time of issuance is in sync with the clock now.</li>
* <li>Otherwise the user ID token is considered not expired under the
* assumption that the local time is not synchronized with the token-
* issuing entity time.</li>
* </ul>
*
* @param now the time to compare against.
* @return true if expired.
*/
public boolean isExpired(final Date now) {
if (now != null)
return expiration * MILLISECONDS_PER_SECOND <= now.getTime();
if (isVerified())
return expiration * MILLISECONDS_PER_SECOND <= ctx.getTime();
return false;
}
/**
* @return the user ID token issuer data or null if there is none or it is
* unknown (user data could not be decrypted).
*/
public MslObject getIssuerData() {
return issuerdata;
}
/**
* @return the MSL user, or null if unknown (user data could not be
* decrypted).
*/
public MslUser getUser() {
return user;
}
/**
* @return the user ID token serial number.
*/
public long getSerialNumber() {
return serialNumber;
}
/**
* Return the serial number of the master token this user ID token is bound
* to.
*
* @return the master token serial number.
*/
public long getMasterTokenSerialNumber() {
return mtSerialNumber;
}
/**
* @param masterToken master token. May be null.
* @return true if this token is bound to the provided master token.
*/
public boolean isBoundTo(final MasterToken masterToken) {
return masterToken != null && masterToken.getSerialNumber() == mtSerialNumber;
}
/** MSL context. */
private final MslContext ctx;
/** User ID token renewal window in seconds since the epoch. */
private final long renewalWindow;
/** User ID token expiration in seconds since the epoch. */
private final long expiration;
/** Master token serial number. */
private final long mtSerialNumber;
/** Serial number. */
private final long serialNumber;
/** User data. */
private final MslObject userdata;
/** Issuer data. */
private final MslObject issuerdata;
/** MSL user. */
private final MslUser user;
/** Token data bytes. */
private final byte[] tokendataBytes;
/** Signature bytes. */
private final byte[] signatureBytes;
/** Token is verified. */
private final boolean verified;
/** Cached encodings. */
private final Map<MslEncoderFormat,byte[]> encodings = new HashMap<MslEncoderFormat,byte[]>();
/* (non-Javadoc)
* @see com.netflix.msl.io.MslEncodable#toMslEncoding(com.netflix.msl.io.MslEncoderFactory, com.netflix.msl.io.MslEncoderFormat)
*/
@Override
public byte[] toMslEncoding(final MslEncoderFactory encoder, final MslEncoderFormat format) throws MslEncoderException {
// Return any cached encoding.
if (encodings.containsKey(format))
return encodings.get(format);
// If we parsed this token (i.e. did not create it from scratch) then
// we should not re-encrypt or re-sign as there is no guarantee out MSL
// crypto context is capable of encrypting and signing with the same
// keys, even if it is capable of decrypting and verifying.
final byte[] data, signature;
if (tokendataBytes != null || signatureBytes != null) {
data = tokendataBytes;
signature = signatureBytes;
}
//
// Otherwise create the token data and signature.
else {
// Grab the MSL token crypto context.
final ICryptoContext cryptoContext;
try {
cryptoContext = ctx.getMslCryptoContext();
} catch (final MslCryptoException e) {
throw new MslEncoderException("Error creating the MSL crypto context.", e);
}
// Encrypt the user data.
final byte[] plaintext = encoder.encodeObject(userdata, format);
final byte[] ciphertext;
try {
ciphertext = cryptoContext.encrypt(plaintext, encoder, format);
} catch (final MslCryptoException e) {
throw new MslEncoderException("Error encrypting the user data.", e);
}
// Construct the token data.
final MslObject tokendata = encoder.createObject();
tokendata.put(KEY_RENEWAL_WINDOW, this.renewalWindow);
tokendata.put(KEY_EXPIRATION, this.expiration);
tokendata.put(KEY_MASTER_TOKEN_SERIAL_NUMBER, this.mtSerialNumber);
tokendata.put(KEY_SERIAL_NUMBER, this.serialNumber);
tokendata.put(KEY_USERDATA, ciphertext);
// Sign the token data.
data = encoder.encodeObject(tokendata, format);
try {
signature = cryptoContext.sign(data, encoder, format);
} catch (final MslCryptoException e) {
throw new MslEncoderException("Error signing the token data.", e);
}
}
// Encode the token.
final MslObject token = encoder.createObject();
token.put(KEY_TOKENDATA, data);
token.put(KEY_SIGNATURE, signature);
final byte[] encoding = encoder.encodeObject(token, format);
// Cache and return the encoding.
encodings.put(format, encoding);
return encoding;
}
/* (non-Javadoc)
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
final MslEncoderFactory encoder = ctx.getMslEncoderFactory();
final MslObject tokendataMo = encoder.createObject();
tokendataMo.put(KEY_RENEWAL_WINDOW, renewalWindow);
tokendataMo.put(KEY_EXPIRATION, expiration);
tokendataMo.put(KEY_MASTER_TOKEN_SERIAL_NUMBER, mtSerialNumber);
tokendataMo.put(KEY_SERIAL_NUMBER, serialNumber);
tokendataMo.put(KEY_USERDATA, "(redacted)");
final MslObject mslObj = encoder.createObject();
mslObj.put(KEY_TOKENDATA, tokendataMo);
mslObj.put(KEY_SIGNATURE, (signatureBytes != null) ? signatureBytes : "(null)");
return mslObj.toString();
}
/**
* <p>Returns true if the other object is a user ID token with the same
* serial number bound to the same master token.</p>
*
* <p>This function is designed for use with sets and maps to guarantee
* uniqueness of individual user ID tokens.</p>
*
* @param obj the reference object with which to compare.
* @return true if the other object is a user ID token with the same serial
* number bound to the same master token.
* @see java.lang.Object#equals(java.lang.Object)
*/
@Override
public boolean equals(final Object obj) {
if (this == obj) return true;
if (obj instanceof UserIdToken) {
final UserIdToken that = (UserIdToken)obj;
return this.serialNumber == that.serialNumber &&
this.mtSerialNumber == that.mtSerialNumber;
}
return false;
}
/* (non-Javadoc)
* @see java.lang.Object#hashCode()
*/
@Override
public int hashCode() {
return (String.valueOf(serialNumber) + ":" + String.valueOf(mtSerialNumber)).hashCode();
}
}
| 9,906 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/tokens/TokenFactory.java | /**
* Copyright (c) 2012-2018 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.tokens;
import javax.crypto.SecretKey;
import com.netflix.msl.MslConstants.ResponseCode;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
import com.netflix.msl.MslMasterTokenException;
import com.netflix.msl.MslUserIdTokenException;
import com.netflix.msl.entityauth.EntityAuthenticationData;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.util.MslContext;
/**
* The token factory creates and renews master tokens and user ID tokens.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public interface TokenFactory {
/**
* <p>Return false if the master token has been revoked.</p>
*
* <p>A master token may be revoked at any time after creation and before
* renewal for various reasons, including but not limited to entity
* revocation or knowledge that a master token or its session keys has been
* compromised. The entity will be forced to re-authenticate if its master
* token is rejected.</p>
*
* <p>This method is slightly different than
* {@link #isMasterTokenRenewable(MslContext, MasterToken)} because it
* will be called for every received message and should not check the
* renewability of the master token.</p>
*
* <p>This method should return the exact {@link MslError} identifying the
* reason the master token has been revoked. The response code associated
* with the error will be honored.</p>
*
* @param ctx MSL context.
* @param masterToken the master token to check.
* @return {@code null} if the master token has not been revoked. Otherwise
* return a MSL error.
* @throws MslMasterTokenException if the master token is not trusted.
* @throws MslException if there is an error performing the revocation
* check.
*/
public MslError isMasterTokenRevoked(final MslContext ctx, final MasterToken masterToken) throws MslMasterTokenException, MslException;
/**
* <p>Return true if the non-replayable ID is larger by no more than 65536
* than the largest non-replayable ID accepted so far for the provided
* master token.</p>
*
* <p>Non-replayable IDs should be tracked by the master token entity
* identity and serial number. Before accepting any non-replayable IDs the
* largest value accepted so far shall be considered zero. The maximum non-
* replayable ID is equal to
* {@link com.netflix.msl.MslConstants#MAX_LONG_VALUE} which the IDs wrap
* around to zero. The wrap around must be considered when comparing the
* non-replayable ID to the largest non-replayable ID accepted so far.</p>
*
* <p>It is also permitted to accept non-replayable IDs less than the
* largest non-replayable ID accepted so far if those non-replayable IDs
* have not been seen. The set of smaller non-replayable IDs accepted
* should be limited in size based on a reasonable expectation for the the
* number of concurrent non-replayable messages the entity may create.</p>
*
* <p>This method should return the exact {@link MslError} identifying the
* reason the non-replayable ID was rejected. The response code associated
* with the error will be honored. If the master token entity cannot be
* expected to recover if the message is sent with a new non-replayable ID
* then the response code {@link ResponseCode#ENTITYDATA_REAUTH} should be
* used.</p>
*
* @param ctx MSL context.
* @param masterToken the master token.
* @param nonReplayableId non-replayable ID.
* @return {@code null} if the non-replayable ID has been accepted.
* Otherwise return a MSL error.
* @throws MslMasterTokenException if the master token is not trusted.
* @throws MslException if there is an error comparing or updating the non-
* replayable ID associated with this master token.
* @see #createMasterToken(MslContext, EntityAuthenticationData, SecretKey, SecretKey, MslObject)
* @see MslError#MESSAGE_REPLAYED
* @see MslError#MESSAGE_REPLAYED_UNRECOVERABLE
*/
public MslError acceptNonReplayableId(final MslContext ctx, final MasterToken masterToken, final long nonReplayableId) throws MslMasterTokenException, MslException;
/**
* <p>Create a new master token with the specified identity and session
* keys.</p>
*
* <p>Creating a new master token implies all previous master tokens issued
* to the specified entity are no longer valid and therefore all state data
* for the non-replayable IDs associated with the entity identity may be
* discarded.</p>
*
* @param ctx MSL context.
* @param entityAuthData the entity authentication data.
* @param encryptionKey the session encryption key.
* @param hmacKey the session HMAC key.
* @param issuerData optional master token issuer data that should be
* included in the master token. May be {@code null}.
* @return the new master token.
* @throws MslEncodingException if there is an error encoding the data.
* @throws MslCryptoException if there is an error encrypting or signing
* the token data.
* @throws MslException if there is an error creating the master token.
* @see #acceptNonReplayableId(MslContext, MasterToken, long)
*/
public MasterToken createMasterToken(final MslContext ctx, final EntityAuthenticationData entityAuthData, final SecretKey encryptionKey, final SecretKey hmacKey, final MslObject issuerData) throws MslEncodingException, MslCryptoException, MslException;
/**
* <p>Check if the master token would be renewed by a call to
* {@link #renewMasterToken(MslContext, MasterToken, SecretKey, SecretKey, MslObject)}.</p>
*
* <p>This method should return the exact {@link MslError} identifying the
* reason the master token will not be renewed.</p>
*
* @param ctx MSL context.
* @param masterToken the master token to check.
* @return {@code null} if the master token would be renewed. Otherwise
* return a MSL error.
* @throws MslMasterTokenException if the master token is not trusted.
* @throws MslException if there is an error checking the master token
* renewability.
* @see #renewMasterToken(MslContext, MasterToken, SecretKey, SecretKey, MslObject)
*/
public MslError isMasterTokenRenewable(final MslContext ctx, final MasterToken masterToken) throws MslMasterTokenException, MslException;
/**
* <p>Renew a master token assigning it the new session keys.</p>
*
* <p>This method should also perform any additional entity checks such as
* if the entity has been revoked.</p>
*
* @param ctx MSL context.
* @param masterToken the master token to renew.
* @param encryptionKey the session encryption key.
* @param hmacKey the session HMAC key.
* @param issuerData optional master token issuer data that should be
* merged into or overwrite any existing issuer data. May be
* {@code null}.
* @return the new master token.
* @throws MslEncodingException if there is an error encoding the data.
* @throws MslCryptoException if there is an error encrypting or signing
* the token data.
* @throws MslMasterTokenException if the master token is not trusted or
* the factory does not wish to renew it.
* @throws MslException if there is an error renewing the master token.
* @see #isMasterTokenRenewable(MslContext, MasterToken)
*/
public MasterToken renewMasterToken(final MslContext ctx, final MasterToken masterToken, final SecretKey encryptionKey, final SecretKey hmacKey, final MslObject issuerData) throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslException;
/**
* <p>Return false if the user ID token has been revoked.</p>
*
* <p>A user ID token may be revoked at any time after creation and before
* renewal for various reasons, including but not limited to user deletion.
* The user will be forced to re-authenticate if its user ID token is
* rejected.</p>
*
* <p>This method should return the exact {@link MslError} identifying the
* reason the user ID token has been revoked.</p>
*
* @param ctx MSL context.
* @param masterToken the associated master token.
* @param userIdToken the user ID token to check.
* @return {@code null} if the user ID token has not been revoked.
* Otherwise return a MSL error.
* @throws MslMasterTokenException if the master token is not trusted.
* @throws MslUserIdTokenException if the user ID token is not trusted.
* @throws MslException if there is an error performing the revocation
* check.
*/
public MslError isUserIdTokenRevoked(final MslContext ctx, final MasterToken masterToken, final UserIdToken userIdToken) throws MslMasterTokenException, MslUserIdTokenException, MslException;
/**
* Create a new user ID token bound to the provided master token.
*
* @param ctx MSL context.
* @param user MSL user.
* @param masterToken the master token to bind the user token against.
* @return the new user ID token.
* @throws MslEncodingException if there is an error encoding the data.
* @throws MslCryptoException if there is an error encrypting or signing
* the token data.
* @throws MslMasterTokenException if the master token is not trusted.
* @throws MslException if there is an error creating the user ID token.
*/
public UserIdToken createUserIdToken(final MslContext ctx, final MslUser user, final MasterToken masterToken) throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslException;
/**
* <p>Renew a user ID token and bind it to the provided master token.</p>
*
* <p>This method should also perform any additional user checks such as if
* the user no longer exists or must re-login.</p>
*
* @param ctx MSL context.
* @param userIdToken the user ID token to renew.
* @param masterToken the master token to bind the user token against.
* @return the new user ID token.
* @throws MslEncodingException if there is an error encoding the data.
* @throws MslCryptoException if there is an error encrypting or signing
* the token data.
* @throws MslUserIdTokenException if the user ID token is not decrypted or
* the factory does not wish to renew it.
* @throws MslMasterTokenException if the master token is not trusted.
* @throws MslException if there is an error renewing the user ID token.
*/
public UserIdToken renewUserIdToken(final MslContext ctx, final UserIdToken userIdToken, final MasterToken masterToken) throws MslEncodingException, MslCryptoException, MslUserIdTokenException, MslMasterTokenException, MslException;
/**
* <p>Create a new MSL user instance from the serialized user data.</p>
*
* <p>This method is called when reconstructing a user ID token. Thrown
* {@link MslException}s should keep that in mind when deciding upon the
* {@link MslError} to reference.</p>
*
* @param ctx MSL context.
* @param userdata serialized user data.
* @return the MSL user.
* @throws MslEncodingException if there is an error parsing the user data.
* @throws MslException if there is an error creating the MSL user.
*/
public MslUser createUser(final MslContext ctx, final String userdata) throws MslEncodingException, MslException;
}
| 9,907 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/tokens/ServiceToken.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.tokens;
import java.util.HashMap;
import java.util.Map;
import com.netflix.msl.MslConstants;
import com.netflix.msl.MslConstants.CompressionAlgorithm;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.io.MslEncodable;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.util.Base64;
import com.netflix.msl.util.MslCompression;
import com.netflix.msl.util.MslContext;
/**
* <p>Service tokens are service-defined tokens carried as part of any MSL
* message. These tokens should be used to carry service state.</p>
*
* <p>Service tokens are optionally bound to a specific master token and user
* ID token by their serial numbers.</p>
*
* <p>Service tokens are either verified or encrypted. Verified tokens carry
* their data in the clear but are accompanied by a signature allowing the
* issuer to ensure the data has not been tampered with. Encrypted tokens
* encrypt their data as well as contain a signature.</p>
*
* <p>Service tokens should use application- or service-specific crypto
* contexts and not the crypto context associated with the entity credentials
* or master token.</p>
*
* <p>Service tokens are represented as
* {@code
* servicetoken = {
* "#mandatory" : [ "tokendata", "signature" ],
* "tokendata" : "binary",
* "signature" : "binary"
* }} where:
* <ul>
* <li>{@code tokendata} is the service token data (servicetokendata)</li>
* <li>{@code signature} is the verification data of the service token data</li>
* </ul></p>
*
* <p>The token data is represented as
* {@code
* servicetokendata = {
* "#mandatory" : [ "name", "mtserialnumber", "uitserialnumber", "encrypted", "servicedata" ],
* "name" : "string",
* "mtserialnumber" : "int64(0,2^53^)",
* "uitserialnumber" : "int64(0,2^53^)",
* "encrypted" : "boolean",
* "compressionalgo" : "enum(GZIP|LZW)",
* "servicedata" : "binary"
* }} where:
* <ul>
* <li>{@code name} is the token name</li>
* <li>{@code mtserialnumber} is the master token serial number or -1 if unbound</li>
* <li>{@code utserialnumber} is the user ID token serial number or -1 if unbound</li>
* <li>{@code encrypted} indicates if the service data is encrypted or not</li>
* <li>{@code compressionalgo} indicates the algorithm used to compress the data</li>
* <li>{@code servicedata} is the optionally encrypted service data</li>
* </ul></p>
*
* <p>Service token names should follow a reverse fully-qualified domain
* hierarchy. e.g. {@literal com.netflix.service.tokenname}.</p>
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class ServiceToken implements MslEncodable {
/** Key token data. */
private static final String KEY_TOKENDATA = "tokendata";
/** Key signature. */
private static final String KEY_SIGNATURE = "signature";
// tokendata
/** Key token name. */
private static final String KEY_NAME = "name";
/** Key master token serial number. */
private static final String KEY_MASTER_TOKEN_SERIAL_NUMBER = "mtserialnumber";
/** Key user ID token serial number. */
private static final String KEY_USER_ID_TOKEN_SERIAL_NUMBER = "uitserialnumber";
/** Key encrypted. */
private static final String KEY_ENCRYPTED = "encrypted";
/** Key compression algorithm. */
private static final String KEY_COMPRESSION_ALGORITHM = "compressionalgo";
/** Key service data. */
private static final String KEY_SERVICEDATA = "servicedata";
/**
* <p>Select the appropriate crypto context for the service token
* represented by the provided MSL object.</p>
*
* <p>If the service token name exists as a key in the map of crypto
* contexts, the mapped crypto context will be returned. Otherwise the
* default crypto context mapped from the empty string key will be
* returned. If no explicit or default crypto context exists null will be
* returned.</p>
*
* @param encoder the MSL encoder factory.
* @param serviceTokenMo the MSL object.
* @param cryptoContexts the map of service token names onto crypto
* contexts used to decrypt and verify service tokens.
* @return the correct crypto context for the service token or null.
* @throws MslEncodingException if there is a problem parsing the data.
*/
private static ICryptoContext selectCryptoContext(final MslEncoderFactory encoder, final MslObject serviceTokenMo, final Map<String,ICryptoContext> cryptoContexts) throws MslEncodingException {
try {
final byte[] tokendata = serviceTokenMo.getBytes(KEY_TOKENDATA);
if (tokendata.length == 0)
throw new MslEncodingException(MslError.SERVICETOKEN_TOKENDATA_MISSING, "servicetoken " + serviceTokenMo);
final MslObject tokenDataMo = encoder.parseObject(tokendata);
final String name = tokenDataMo.getString(KEY_NAME);
if (cryptoContexts.containsKey(name))
return cryptoContexts.get(name);
return cryptoContexts.get("");
} catch (final MslEncoderException e) {
throw new MslEncodingException(MslError.MSL_PARSE_ERROR, "servicetoken " + serviceTokenMo, e);
}
}
/**
* <p>Construct a new service token with the specified name and data. If a
* master token is provided, the service token is bound to the master
* token's serial number. If a user ID token is provided, the service token
* is bound to the user ID token's serial number.</p>
*
* <p>For encrypted tokens, the token data is encrypted using the provided
* crypto context. For verified tokens, the token data is signed using the
* provided crypto context.</p>
*
* @param ctx the MSL context.
* @param name the service token name--must be unique.
* @param data the service token data (unencrypted).
* @param masterToken the master token. May be null.
* @param userIdToken the user ID token. May be null.
* @param encrypted true if the token should be encrypted.
* @param compressionAlgo the compression algorithm. May be {@code null}
* for no compression.
* @param cryptoContext the crypto context.
* @throws MslException if there is an error compressing the data.
*/
public ServiceToken(final MslContext ctx, final String name, final byte[] data, final MasterToken masterToken, final UserIdToken userIdToken, final boolean encrypted, final CompressionAlgorithm compressionAlgo, final ICryptoContext cryptoContext) throws MslException {
this.ctx = ctx;
// If both master token and user ID token are provided the user ID
// token must be bound to the master token.
if (masterToken != null && userIdToken != null && !userIdToken.isBoundTo(masterToken))
throw new MslInternalException("Cannot construct a service token bound to a master token and user ID token where the user ID token is not bound to the same master token.");
// The crypto context may not be null.
if (cryptoContext == null)
throw new NullPointerException("Crypto context may not be null.");
// Set token properties.
this.name = name;
this.mtSerialNumber = (masterToken != null) ? masterToken.getSerialNumber() : -1;
this.uitSerialNumber = (userIdToken != null) ? userIdToken.getSerialNumber() : -1;
this.servicedata = data;
this.encrypted = encrypted;
// Optionally compress the service data.
if (compressionAlgo != null) {
final byte[] compressed = MslCompression.compress(compressionAlgo, data);
// Only use compression if the compressed data is smaller than the
// uncompressed data.
if (compressed != null && compressed.length < data.length) {
this.compressionAlgo = compressionAlgo;
this.compressedServicedata = compressed;
} else {
this.compressionAlgo = null;
this.compressedServicedata = data;
}
} else {
this.compressionAlgo = null;
this.compressedServicedata = data;
}
// Save the crypto context.
this.cryptoContext = cryptoContext;
this.tokendataBytes = null;
this.signatureBytes = null;
this.verified = true;
}
/**
* <p>Construct a new service token from the provided MSL object and
* attempt to decrypt and verify the signature of the service token using
* the appropriate crypto context. If the data cannot be decrypted or the
* signature cannot be verified, the token will still be created.</p>
*
* <p>If the service token name exists as a key in the map of crypto
* contexts, the mapped crypto context will be used. Otherwise the default
* crypto context mapped from the empty string key will be used.</p>
*
* <p>If a matching crypto context is found, the token data will be
* decrypted and its signature verified.</p>
*
* <p>If the service token is bound to a master token or user ID token it
* will be verified against the provided master token or user ID tokens
* which must not be null.</p>
*
* @param ctx the MSL context.
* @param serviceTokenMo the MSL object.
* @param masterToken the master token. May be null.
* @param userIdToken the user ID token. May be null.
* @param cryptoContexts a map of service token names onto crypto contexts.
* @throws MslEncodingException if there is a problem parsing the data.
* @throws MslCryptoException if there is an error decrypting or verifying
* the token data.
* @throws MslException if the service token is bound to a master token or
* user ID token and the provided tokens are null or the serial
* numbers do not match, or if bound to a user ID token but not to
* a master token, or if the service data is missing, or if the
* compression algorithm is not known or there is an error
* uncompressing the data.
*/
public ServiceToken(final MslContext ctx, final MslObject serviceTokenMo, final MasterToken masterToken, final UserIdToken userIdToken, final Map<String,ICryptoContext> cryptoContexts) throws MslEncodingException, MslCryptoException, MslException {
this(ctx, serviceTokenMo, masterToken, userIdToken, selectCryptoContext(ctx.getMslEncoderFactory(), serviceTokenMo, cryptoContexts));
}
/**
* <p>Construct a new service token from the provided MSL object.</p>
*
* <p>If a crypto context is provided, the token data will be decrypted and
* its signature verified. If the data cannot be decrypted or the signature
* cannot be verified, the token will still be created.</p>
*
* <p>If the service token is bound to a master token or user ID token it
* will be verified against the provided master token or user ID tokens
* which must not be null.</p>
*
* @param ctx the MSL context.
* @param serviceTokenMo the MSL object.
* @param masterToken the master token. May be null.
* @param userIdToken the user ID token. May be null.
* @param cryptoContext the crypto context. May be null.
* @throws MslCryptoException if there is a problem decrypting or verifying
* the token data.
* @throws MslEncodingException if there is a problem parsing the data, the
* token data is missing or invalid, or the signature is invalid.
* @throws MslException if the service token is bound to a master token or
* user ID token and the provided tokens are null or the serial
* numbers do not match, or if bound to a user ID token but not to
* a master token, or if the service data is missing, or if the
* service token master token serial number is out of range, or if
* the service token user ID token serial number is out of range,
* or if the compression algorithm is not known or there is an
* error uncompressing the data.
*/
public ServiceToken(final MslContext ctx, final MslObject serviceTokenMo, final MasterToken masterToken, final UserIdToken userIdToken, final ICryptoContext cryptoContext) throws MslCryptoException, MslEncodingException, MslException {
this.ctx = ctx;
this.cryptoContext = cryptoContext;
final MslEncoderFactory encoder = ctx.getMslEncoderFactory();
// Verify the data representation.
try {
tokendataBytes = serviceTokenMo.getBytes(KEY_TOKENDATA);
if (tokendataBytes.length == 0)
throw new MslEncodingException(MslError.SERVICETOKEN_TOKENDATA_MISSING, "servicetoken " + serviceTokenMo).setMasterToken(masterToken).setUserIdToken(userIdToken);
signatureBytes = serviceTokenMo.getBytes(KEY_SIGNATURE);
verified = (cryptoContext != null) ? cryptoContext.verify(tokendataBytes, signatureBytes, encoder) : false;
} catch (final MslEncoderException e) {
throw new MslEncodingException(MslError.MSL_PARSE_ERROR, "servicetoken " + serviceTokenMo, e).setMasterToken(masterToken).setUserIdToken(userIdToken);
} catch (final MslCryptoException e) {
e.setMasterToken(masterToken);
throw e;
}
// Pull the token data.
try {
final MslObject tokendata = encoder.parseObject(tokendataBytes);
name = tokendata.getString(KEY_NAME);
if (tokendata.has(KEY_MASTER_TOKEN_SERIAL_NUMBER)) {
mtSerialNumber = tokendata.getLong(KEY_MASTER_TOKEN_SERIAL_NUMBER);
if (mtSerialNumber < 0 || mtSerialNumber > MslConstants.MAX_LONG_VALUE)
throw new MslException(MslError.SERVICETOKEN_MASTERTOKEN_SERIAL_NUMBER_OUT_OF_RANGE, "servicetokendata " + tokendata).setMasterToken(masterToken).setUserIdToken(userIdToken);
} else {
mtSerialNumber = -1;
}
if (tokendata.has(KEY_USER_ID_TOKEN_SERIAL_NUMBER)) {
uitSerialNumber = tokendata.getLong(KEY_USER_ID_TOKEN_SERIAL_NUMBER);
if (uitSerialNumber < 0 || uitSerialNumber > MslConstants.MAX_LONG_VALUE)
throw new MslException(MslError.SERVICETOKEN_USERIDTOKEN_SERIAL_NUMBER_OUT_OF_RANGE, "servicetokendata " + tokendata).setMasterToken(masterToken).setUserIdToken(userIdToken);
} else {
uitSerialNumber = -1;
}
// There has to be a master token serial number if there is a
// user ID token serial number.
encrypted = tokendata.getBoolean(KEY_ENCRYPTED);
if (tokendata.has(KEY_COMPRESSION_ALGORITHM)) {
final String algoName = tokendata.getString(KEY_COMPRESSION_ALGORITHM);
try {
compressionAlgo = CompressionAlgorithm.valueOf(algoName);
} catch (final IllegalArgumentException e) {
throw new MslException(MslError.UNIDENTIFIED_COMPRESSION, algoName, e);
}
} else {
compressionAlgo = null;
}
// If encrypted, and we were able to verify the data then we better
// be able to decrypt it. (An exception is thrown if decryption
// fails.)
final byte[] data = tokendata.getBytes(KEY_SERVICEDATA);
if (verified) {
final byte[] ciphertext = data;
compressedServicedata = (encrypted && ciphertext.length > 0)
? cryptoContext.decrypt(ciphertext, encoder)
: ciphertext;
servicedata = (compressionAlgo != null)
? MslCompression.uncompress(compressionAlgo, compressedServicedata)
: compressedServicedata;
} else {
compressedServicedata = data;
servicedata = (data.length == 0) ? new byte[0] : null;
}
} catch (final MslEncoderException e) {
throw new MslEncodingException(MslError.MSL_PARSE_ERROR, "servicetokendata " + Base64.encode(tokendataBytes), e).setMasterToken(masterToken).setUserIdToken(userIdToken);
} catch (final MslCryptoException e) {
e.setMasterToken(masterToken);
e.setUserIdToken(userIdToken);
throw e;
}
// Verify serial numbers.
if (mtSerialNumber != -1 && (masterToken == null || mtSerialNumber != masterToken.getSerialNumber()))
throw new MslException(MslError.SERVICETOKEN_MASTERTOKEN_MISMATCH, "st mtserialnumber " + mtSerialNumber + "; mt " + masterToken).setMasterToken(masterToken).setUserIdToken(userIdToken);
if (uitSerialNumber != -1 && (userIdToken == null || uitSerialNumber != userIdToken.getSerialNumber()))
throw new MslException(MslError.SERVICETOKEN_USERIDTOKEN_MISMATCH, "st uitserialnumber " + uitSerialNumber + "; uit " + userIdToken).setMasterToken(masterToken).setUserIdToken(userIdToken);
}
/**
* @return true if the content is encrypted.
*/
public boolean isEncrypted() {
return encrypted;
}
/**
* @return true if the decrypted content is available. (Implies verified.)
*/
public boolean isDecrypted() {
return servicedata != null;
}
/**
* @return true if the token has been verified.
*/
public boolean isVerified() {
return verified;
}
/**
* @return the application token name.
*/
public String getName() {
return name;
}
/**
* @return true if this token has been marked for deletion.
* @see #getData()
*/
public boolean isDeleted() {
return servicedata != null && servicedata.length == 0;
}
/**
* @return the compression algorithm. May be {@code null} if not
* compressed.
*/
public CompressionAlgorithm getCompressionAlgo() {
return compressionAlgo;
}
/**
* Returns the service data if the token data was not encrypted or we were
* able to decrypt it.
*
* Zero-length data indicates this token should be deleted.
*
* @return the service data or null if we don't have it.
* @see #isDeleted()
*/
public byte[] getData() {
return servicedata;
}
/**
* Returns the serial number of the master token this service token is
* bound to.
*
* @return the master token serial number or -1 if unbound.
*/
public long getMasterTokenSerialNumber() {
return mtSerialNumber;
}
/**
* @return true if this token is bound to a master token.
*/
public boolean isMasterTokenBound() {
return mtSerialNumber != -1;
}
/**
* @param masterToken master token. May be null.
* @return true if this token is bound to the provided master token.
*/
public boolean isBoundTo(final MasterToken masterToken) {
return masterToken != null && masterToken.getSerialNumber() == mtSerialNumber;
}
/**
* Returns the serial number of the user ID token this service token is
* bound to.
*
* @return the user ID token serial number or -1 if unbound.
*/
public long getUserIdTokenSerialNumber() {
return uitSerialNumber;
}
/**
* Returns true if this token is bound to a user ID token. This implies the
* token is bound to a master token as well.
*
* @return true if this token is bound to a user ID token.
*/
public boolean isUserIdTokenBound() {
return uitSerialNumber != -1;
}
/**
* @param userIdToken user ID token. May be null.
* @return true if this token is bound to the provided user ID token.
*/
public boolean isBoundTo(final UserIdToken userIdToken) {
return userIdToken != null && userIdToken.getSerialNumber() == uitSerialNumber;
}
/**
* @return true if this token is not bound to a master token or user ID
* token.
*/
public boolean isUnbound() {
return mtSerialNumber == -1 && uitSerialNumber == -1;
}
/** MSL context. */
private final MslContext ctx;
/** Service token crypto context. */
private final ICryptoContext cryptoContext;
/** The service token name. */
private final String name;
/** The service token master token serial number. */
private final long mtSerialNumber;
/** The service token user ID token serial number. */
private final long uitSerialNumber;
/** Service token data is encrypted. */
private final boolean encrypted;
/** Compression algorithm. */
private final CompressionAlgorithm compressionAlgo;
/** The service token data. */
private final byte[] servicedata;
/** The compressed service token data. */
private final byte[] compressedServicedata;
/** Token data bytes. */
private final byte[] tokendataBytes;
/** Signature bytes. */
private final byte[] signatureBytes;
/** Token is verified. */
private final boolean verified;
/** Cached encodings. */
private final Map<MslEncoderFormat,byte[]> encodings = new HashMap<MslEncoderFormat,byte[]>();
/* (non-Javadoc)
* @see com.netflix.msl.io.MslEncodable#toMslEncoding(com.netflix.msl.io.MslEncoderFactory, com.netflix.msl.io.MslEncoderFormat)
*/
@Override
public byte[] toMslEncoding(final MslEncoderFactory encoder, final MslEncoderFormat format) throws MslEncoderException {
// Return any cached encoding.
if (encodings.containsKey(format))
return encodings.get(format);
// If we parsed this token (i.e. did not create it from scratch) then
// we should not re-encrypt or re-sign as there is no guarantee out MSL
// crypto context is capable of encrypting and signing with the same
// keys, even if it is capable of decrypting and verifying.
final byte[] data, signature;
if (tokendataBytes != null || signatureBytes != null) {
data = tokendataBytes;
signature = signatureBytes;
}
//
// Otherwise create the token data and signature.
else {
// Encrypt the service data if the length is > 0. Otherwise encode
// as empty data to indicate this token should be deleted.
final byte[] ciphertext;
try {
ciphertext = (encrypted && compressedServicedata.length > 0)
? cryptoContext.encrypt(compressedServicedata, encoder, format)
: compressedServicedata;
} catch (final MslCryptoException e) {
throw new MslEncoderException("Error encrypting the service data.", e);
}
// Construct the token data.
final MslObject tokendata = encoder.createObject();
tokendata.put(KEY_NAME, this.name);
if (this.mtSerialNumber != -1) tokendata.put(KEY_MASTER_TOKEN_SERIAL_NUMBER, this.mtSerialNumber);
if (this.uitSerialNumber != -1) tokendata.put(KEY_USER_ID_TOKEN_SERIAL_NUMBER, this.uitSerialNumber);
tokendata.put(KEY_ENCRYPTED, this.encrypted);
if (this.compressionAlgo != null) tokendata.put(KEY_COMPRESSION_ALGORITHM, this.compressionAlgo.name());
tokendata.put(KEY_SERVICEDATA, ciphertext);
// Sign the token data.
data = encoder.encodeObject(tokendata, format);
try {
signature = cryptoContext.sign(data, encoder, format);
} catch (final MslCryptoException e) {
throw new MslEncoderException("Error signing the token data.", e);
}
}
// Encode the token.
final MslObject token = encoder.createObject();
token.put(KEY_TOKENDATA, data);
token.put(KEY_SIGNATURE, signature);
final byte[] encoding = encoder.encodeObject(token, format);
// Cache and return the encoding.
encodings.put(format, encoding);
return encoding;
}
/* (non-Javadoc)
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
final MslEncoderFactory encoder = ctx.getMslEncoderFactory();
final MslObject tokendata = encoder.createObject();
tokendata.put(KEY_NAME, name);
tokendata.put(KEY_MASTER_TOKEN_SERIAL_NUMBER, mtSerialNumber);
tokendata.put(KEY_USER_ID_TOKEN_SERIAL_NUMBER, uitSerialNumber);
tokendata.put(KEY_SERVICEDATA, "(redacted)");
final MslObject token = encoder.createObject();
token.put(KEY_TOKENDATA, tokendata);
token.put(KEY_SIGNATURE, (signatureBytes != null) ? signatureBytes : "(null)");
return token.toString();
}
/**
* <p>Returns true if the other object is a service token with the same
* name and bound to the same tokens.</p>
*
* <p>This function is designed for use with sets and maps to guarantee
* uniqueness of individual service tokens.</p>
*
* @param obj the reference object with which to compare.
* @return true if the other object is a service token with the same name
* and bound to the same tokens.
* @see java.lang.Object#equals(java.lang.Object)
*/
@Override
public boolean equals(final Object obj) {
if (this == obj) return true;
if (obj instanceof ServiceToken) {
final ServiceToken that = (ServiceToken)obj;
return this.name.equals(that.name) &&
this.mtSerialNumber == that.mtSerialNumber &&
this.uitSerialNumber == that.uitSerialNumber;
}
return false;
}
/* (non-Javadoc)
* @see java.lang.Object#hashCode()
*/
@Override
public int hashCode() {
return (this.name + ":" + String.valueOf(mtSerialNumber) + ":" + String.valueOf(uitSerialNumber)).hashCode();
}
}
| 9,908 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/tokens/ClientTokenFactory.java | /**
* Copyright (c) 2014-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.tokens;
import javax.crypto.SecretKey;
import com.netflix.msl.MslError;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.entityauth.EntityAuthenticationData;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.util.MslContext;
/**
* This class should be used by trusted network clients for the token factory.
* Since trusted network clients do not issue tokens the mamority of these
* methods either return under the assumption everything should be accepted or
* trusted, or throw exceptions if the operation should never occur.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class ClientTokenFactory implements TokenFactory {
/* (non-Javadoc)
* @see com.netflix.msl.tokens.TokenFactory#isMasterTokenRevoked(com.netflix.msl.util.MslContext, com.netflix.msl.tokens.MasterToken)
*/
@Override
public MslError isMasterTokenRevoked(final MslContext ctx, final MasterToken masterToken) {
return null;
}
/* (non-Javadoc)
* @see com.netflix.msl.tokens.TokenFactory#acceptNonReplayableId(com.netflix.msl.util.MslContext, com.netflix.msl.tokens.MasterToken, long)
*/
@Override
public MslError acceptNonReplayableId(final MslContext ctx, final MasterToken masterToken, final long nonReplayableId) {
return null;
}
/* (non-Javadoc)
* @see com.netflix.msl.tokens.TokenFactory#createMasterToken(com.netflix.msl.util.MslContext, com.netflix.msl.entityauth.EntityAuthenticationData, javax.crypto.SecretKey, javax.crypto.SecretKey, com.netflix.msl.io.MslObject)
*/
@Override
public MasterToken createMasterToken(final MslContext ctx, final EntityAuthenticationData entityAuthData, final SecretKey encryptionKey, final SecretKey hmacKey, final MslObject issuerData) {
throw new MslInternalException("Creating master tokens is unsupported by the token factory.");
}
/* (non-Javadoc)
* @see com.netflix.msl.tokens.TokenFactory#isMasterTokenRenewable(com.netflix.msl.util.MslContext, com.netflix.msl.tokens.MasterToken)
*/
@Override
public MslError isMasterTokenRenewable(final MslContext ctx, final MasterToken masterToken) {
return null;
}
/* (non-Javadoc)
* @see com.netflix.msl.tokens.TokenFactory#renewMasterToken(com.netflix.msl.util.MslContext, com.netflix.msl.tokens.MasterToken, javax.crypto.SecretKey, javax.crypto.SecretKey, com.netflix.msl.io.MslObject)
*/
@Override
public MasterToken renewMasterToken(final MslContext ctx, final MasterToken masterToken, final SecretKey encryptionKey, final SecretKey hmacKey, final MslObject issuerData) {
throw new MslInternalException("Renewing master tokens is unsupported by the token factory.");
}
/* (non-Javadoc)
* @see com.netflix.msl.tokens.TokenFactory#isUserIdTokenRevoked(com.netflix.msl.util.MslContext, com.netflix.msl.tokens.MasterToken, com.netflix.msl.tokens.UserIdToken)
*/
@Override
public MslError isUserIdTokenRevoked(final MslContext ctx, final MasterToken masterToken, final UserIdToken userIdToken) {
return null;
}
/* (non-Javadoc)
* @see com.netflix.msl.tokens.TokenFactory#createUserIdToken(com.netflix.msl.util.MslContext, com.netflix.msl.tokens.MslUser, com.netflix.msl.tokens.MasterToken)
*/
@Override
public UserIdToken createUserIdToken(final MslContext ctx, final MslUser user, final MasterToken masterToken) {
throw new MslInternalException("Creating user ID tokens is unsupported by the token factory.");
}
/* (non-Javadoc)
* @see com.netflix.msl.tokens.TokenFactory#renewUserIdToken(com.netflix.msl.util.MslContext, com.netflix.msl.tokens.UserIdToken, com.netflix.msl.tokens.MasterToken)
*/
@Override
public UserIdToken renewUserIdToken(final MslContext ctx, final UserIdToken userIdToken, final MasterToken masterToken) {
throw new MslInternalException("Renewing master tokens is unsupported by the token factory.");
}
/* (non-Javadoc)
* @see com.netflix.msl.tokens.TokenFactory#createUser(com.netflix.msl.util.MslContext, java.lang.String)
*/
@Override
public MslUser createUser(final MslContext ctx, final String userdata) {
throw new MslInternalException("Creating users is unsupported by the token factory.");
}
}
| 9,909 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/tokens/MslUser.java | /**
* Copyright (c) 2014 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.tokens;
/**
* <p>A MSL user. The {@link #equals(Object)} and {@link #hashCode()} methods
* must be implemented.</p>
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public interface MslUser {
/**
* <p>Returns a serialized data encoding of the MSL user. This is the value
* that will be used by the MSL stack during transport and to reconstruct
* the MSL user instance.</p>
*
* @return the MSL user encoding.
*/
public String getEncoded();
/**
* <p>Compares this object against the provided object. This method must
* return true if the provided object is a {@code MslUser} referencing the
* same MSL user.</p>
*
* @param obj the object with which to compare.
* @return {@code true} if the object is a {@code MslUser} that references
* the same MSL user.
* @see #hashCode()
*/
@Override
public boolean equals(final Object obj);
/* (non-Javadoc)
* @see java.lang.Object#hashCode()
*/
@Override
public int hashCode();
}
| 9,910 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/entityauth/X509Store.java | /**
* Copyright (c) 1997-2013 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.PrivateKey;
import java.security.SignatureException;
import java.security.cert.CertificateException;
import java.security.cert.CertificateExpiredException;
import java.security.cert.CertificateFactory;
import java.security.cert.CertificateNotYetValidException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.security.auth.x500.X500Principal;
import com.netflix.msl.util.Base64;
/**
* <p>An X.509 certificate store.</p>
*
* <p>This class provides a clearing house of X.509 certificate validation. It
* contains individual trusted certificates, trusted certificate chains, and
* may support CRLs in the future. It provides X.509 certificate signature
* verification, certificate chaining, validity (time) checks, and trust store
* management functionality.</p>
*/
public class X509Store {
/**
* <p>Return the issuing certificate for the provided certificate. The
* certificate will only be returned if the provided certificate signature
* is verified by the issuing certificate.</p>
*
* @param cert the certificate.
* @return the issuing certificate or {@code null} if not found.
*/
private X509Certificate getIssuer(final X509Certificate cert) {
final X500Principal issuerDn = cert.getIssuerX500Principal();
final List<X509Certificate> issuers = store.get(issuerDn);
if (issuers == null)
return null;
for (final X509Certificate issuer : issuers) {
try {
cert.verify(issuer.getPublicKey());
return issuer;
} catch (final Exception e) {
// Ignore failures.
}
}
return null;
}
/**
* <p>Returns the chain of issuer certificates for the provided
* certificate.</p>
*
* <p>The first certificate in the chain will be self-signed and will be
* ordered with the root certificate in the first position.</p>
*
* @param cert the certificate.
* @return the ordered chain of issuer certificates.
* @throws CertificateException if an issuer certificate cannot be found.
*/
private List<X509Certificate> getIssuerChain(final X509Certificate cert) throws CertificateException {
final List<X509Certificate> chain = new ArrayList<X509Certificate>();
X509Certificate current = cert;
do {
final X509Certificate issuer = getIssuer(current);
if (issuer == null)
throw new CertificateException("No issuer found for certificate: " + Base64.encode(current.getEncoded()));
chain.add(0, issuer);
current = issuer;
} while (!isSelfSigned(current));
return chain;
}
/**
* <p>Return true if the certificate is self-signed.</p>
*
* @param cert the certificate.
* @return true if the certificate is self-signed.
*/
private static boolean isSelfSigned(final X509Certificate cert) {
final X500Principal subject = cert.getSubjectX500Principal();
final X500Principal issuer = cert.getIssuerX500Principal();
return subject.equals(issuer);
}
/**
* @param cert the certificate.
* @return true if the certificate is verified by a trusted certificate.
*/
private boolean isVerified(final X509Certificate cert) {
final X509Certificate issuer = getIssuer(cert);
return (issuer != null);
}
/**
* <p>Verifies that the provided certificate is allowed to be a CA
* certificate based on the issuer chain's path lengths.</p>
*
* @param cert the certificate.
* @return true if the certificate distance from its issuers is acceptable.
* @throws CertificateException if an issuer certificate cannot be found.
*/
private boolean isPermittedByIssuer(final X509Certificate cert) throws CertificateException {
// Get the issuer chain. It should never be empty.
final List<X509Certificate> issuerChain = getIssuerChain(cert);
if (issuerChain.isEmpty())
return false;
// If at any point in the chain we see a path length set, we use "lazy"
// chain enforcement: the path length field is optional for all
// subordinate CA certificates as long the path length has not been
// exceeded and any path lengths of subordinate certificates are equal
// to or less than the expected path length.
int expectedPathLength = -1;
for (final X509Certificate issuer : issuerChain) {
final int nextPathLength = issuer.getBasicConstraints();
// There is no path length in this issuing certificate...
if (nextPathLength == -1) {
// If there is no path length from a superior certificate then
// fail.
if (expectedPathLength == -1)
return false;
// Otherwise decrement the current path length.
--expectedPathLength;
}
// Otherwise if this is our first path length then start using it.
else if (expectedPathLength == -1) {
expectedPathLength = nextPathLength;
}
// Otherwise if this certificate's path length is too large then
// fail.
else if (nextPathLength > expectedPathLength) {
return false;
}
// Otherwise the new path length is acceptable.
else {
expectedPathLength = nextPathLength;
}
// Make sure the path length is not zero.
if (expectedPathLength == 0)
return false;
}
// Make sure this certificate's path length is equal to or less than
// the expected path length.
final int next = cert.getBasicConstraints();
if (next != -1 && next > expectedPathLength)
return false;
// Success.
return true;
}
/**
* <p>Add one or more trusted certificates (in DER format, binary or Base64-
* encoded) to this X509Store.</p>
*
* <p>This method calls {@link #addTrusted(X509Certificate)} on each
* certificate found. If an exception is thrown, any certificates
* parsed prior to the error will still be in the trust store.</p>
*
* @param input the input stream.
* @throws IOException if there is an error reading the input stream.
* @throws CertificateExpiredException if the certificate is expired.
* @throws CertificateNotYetValidException if the certificate is not yet
* valid.
* @throws CertificateException if a certificate is not a CA certificate, a
* certificate is not self-signed and not trusted by an existing
* trusted certificate, a certificate is not permitted as a
* subordinate certificate, a certificate is malformed, or there is
* no X.509 certificate factory.
* @throws SignatureException if the certificate signature cannot be or
* fails to verify for any reason including a malformed certificate.
* @throws NoSuchAlgorithmException if the signature algorithm is
* unsupported.
* @throws InvalidKeyException if a certificate public key is invalid.
* @throws NoSuchProviderException if there is no X.509 certificate
* provider.
*/
public void addTrusted(final InputStream input) throws CertificateExpiredException, CertificateNotYetValidException, CertificateException, IOException, InvalidKeyException, SignatureException, NoSuchAlgorithmException, NoSuchProviderException {
final BufferedInputStream bis = new BufferedInputStream(input);
final CertificateFactory factory = CertificateFactory.getInstance("X.509");
while (bis.available() > 0) {
final X509Certificate cert = (X509Certificate)factory.generateCertificate(bis);
addTrusted(cert);
}
}
/**
* <p>Add a chain of trusted certificates to this X509Store.</p>
*
* <p>The first certificate in the chain must be self-signed, and all
* certificates must be CA certificates. The list must be ordered with the
* root certificate in the first position and the leaf certificate in the
* last position.</p>
*
* @param chain the ordered chain of certificates.
* @throws NoSuchAlgorithmException if the signature algorithm is
* unsupported.
* @throws InvalidKeyException if an certificate's public key is invalid.
* @throws NoSuchProviderException if there is no signature provider.
* @throws SignatureException if a certificate signature verification fails.
* @throws CertificateExpiredException if the certificate is expired.
* @throws CertificateNotYetValidException if the certificate is not yet
* valid.
* @throws CertificateException if a certificate is malformed or the first
* certificate is not a self-signed certificate.
*/
public void addTrusted(final List<X509Certificate> chain) throws CertificateExpiredException, CertificateNotYetValidException, CertificateException, NoSuchAlgorithmException, InvalidKeyException, NoSuchProviderException, SignatureException {
// Do nothing if the chain is null or empty.
if (chain == null || chain.isEmpty())
return;
// Verify that the root certificate is self-signed and add it.
X509Certificate issuer = chain.get(0);
if(!isSelfSigned(issuer))
throw new CertificateException("First certificate is not self-signed: " + Base64.encode(issuer.getEncoded()));
addTrusted(issuer);
// Add subordinate certificates.
for (int i = 1; i < chain.size(); ++i) {
final X509Certificate cert = chain.get(i);
cert.verify(issuer.getPublicKey());
addTrusted(cert);
issuer = cert;
}
}
/**
* <p>Add a trusted certificate (in DER format, binary or Base64-encoded)
* to this X509Store.</p>
*
* <p>This method verifies the certificate. That has the effect of
* requiring the CA root certificate to be added before any subordinate
* CA certificates.</p>
*
* <p>To add a certificate chain, use {@link #addTrusted(List)} instead.</p>
*
* @param cert the X.509 certificate to add.
* @throws CertificateExpiredException if the certificate is expired.
* @throws CertificateNotYetValidException if the certificate is not yet
* valid.
* @throws CertificateException if the certificate is not a CA certificate,
* the certificate is not self-signed and not trusted by an
* existing trusted certificate, or the certificate is not
* permitted as a subordinate certificate, or the certificate is
* malformed.
* @throws SignatureException if the certificate signature cannot be or
* fails to verify for any reason including a malformed certificate.
* @throws NoSuchAlgorithmException if the signature algorithm is
* unsupported.
* @throws InvalidKeyException if a certificate public key is invalid.
* @throws NoSuchProviderException if there is no X.509 certificate
* provider.
*/
public void addTrusted(final X509Certificate cert) throws CertificateExpiredException, CertificateNotYetValidException, CertificateException, SignatureException, InvalidKeyException, NoSuchAlgorithmException, NoSuchProviderException {
// Verify the certificate not-yet-valid and expiration dates.
cert.checkValidity();
// Verify this is a CA certificate.
final int pathlen = cert.getBasicConstraints();
if (pathlen < 0)
throw new CertificateException("Certificate is not a CA certificate: " + Base64.encode(cert.getEncoded()));
// Verify the certificate signature.
if (isSelfSigned(cert)) {
cert.verify(cert.getPublicKey());
} else {
if (!isVerified(cert))
throw new CertificateException("Certificate is not self-signed and not trusted by any known CA certificate: " + Base64.encode(cert.getEncoded()));
// Subordinate certificates must have their path length validated.
if (!isPermittedByIssuer(cert))
throw new CertificateException("Certificate appears too far from its issuing CA certificate: " + Base64.encode(cert.getEncoded()));
}
// Add the certificate.
final X500Principal subjectName = cert.getSubjectX500Principal();
if (!store.containsKey(subjectName))
store.put(subjectName, new ArrayList<X509Certificate>());
final List<X509Certificate> certs = store.get(subjectName);
if (!certs.contains(cert))
certs.add(cert);
}
/**
* <p>Add a trusted certificate (in DER format, binary or Base64-encoded)
* and its corresponding private key to this X509Store.</p>
*
* <p>This method verifies the certificate. That has the effect of
* requiring the CA root certificate to be added before any subordinate
* CA certificates.</p>
*
* <p>To add a certificate chain, use {@link #addTrusted(List)} instead.</p>
*
* @param cert the X.509 certificate to add.
* @param privkey matching private key to add.
* @throws CertificateExpiredException if the certificate is expired.
* @throws CertificateNotYetValidException if the certificate is not yet
* valid.
* @throws CertificateException if the certificate is not a CA certificate,
* the certificate is not self-signed and not trusted by an
* existing trusted certificate, or the certificate is not
* permitted as a subordinate certificate, or the certificate is
* malformed.
* @throws SignatureException if the certificate signature cannot be or
* fails to verify for any reason including a malformed certificate.
* @throws NoSuchAlgorithmException if the signature algorithm is
* unsupported.
* @throws InvalidKeyException if a certificate public key is invalid.
* @throws NoSuchProviderException if there is no X.509 certificate
* provider.
* @see #getPrivateKey(X509Certificate)
*/
public void addTrusted(final X509Certificate cert, final PrivateKey privkey) throws CertificateExpiredException, CertificateNotYetValidException, CertificateException, SignatureException, InvalidKeyException, NoSuchAlgorithmException, NoSuchProviderException {
// Add the certificate.
addTrusted(cert);
// Add the private key.
final X500Principal subjectName = cert.getSubjectX500Principal();
privateKeys.put(subjectName, privkey);
}
/**
* <p>Return true if the provided certificate is valid and accepted by a
* trusted certificate in this store.</p>
*
* @param cert the certificate.
* @return true if the certificate is accepted.
* @throws CertificateExpiredException if the certificate is expired.
* @throws CertificateNotYetValidException if the certificate is not yet
* valid.
*/
public boolean isAccepted(final X509Certificate cert) throws CertificateExpiredException, CertificateNotYetValidException {
cert.checkValidity();
return isVerified(cert);
}
/**
* <p>Return the private key associated with the provided certificate.</p>
*
* @param cert the certificate.
* @return the private key or null if not found.
* @see #addTrusted(X509Certificate, PrivateKey)
*/
public PrivateKey getPrivateKey(final X509Certificate cert) {
final X500Principal subjectName = cert.getSubjectX500Principal();
return privateKeys.get(subjectName);
}
/** Map of certificate subject names onto X.509 certificates. */
private final Map</*SubjectName*/X500Principal, List<X509Certificate>> store = new HashMap<X500Principal, List<X509Certificate>>();
/** Map of certificate subject names onto private keys. */
private final Map</*SubjectName*/X500Principal, PrivateKey> privateKeys = new HashMap<X500Principal, PrivateKey>();
}
| 9,911 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/entityauth/UnauthenticatedAuthenticationData.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslObject;
/**
* <p>Unauthenticated entity authentication data. This form of authentication
* is used by entities that cannot provide any form of entity
* authentication.</p>
*
* <p>Unauthenticated entity authentication data is represented as
* {@code
* unauthenticatedauthdata = {
* "#mandatory" : [ "identity" ],
* "identity" : "string"
* }} where:
* <ul>
* <li>{@code identity} is the entity identity</li>
* </ul></p>
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class UnauthenticatedAuthenticationData extends EntityAuthenticationData {
/** Key entity identity. */
private static final String KEY_IDENTITY = "identity";
/**
* Construct a new unauthenticated entity authentication data instance from
* the specified entity identity.
*
* @param identity the entity identity.
*/
public UnauthenticatedAuthenticationData(final String identity) {
super(EntityAuthenticationScheme.NONE);
this.identity = identity;
}
/**
* Construct a new unauthenticated entity authentication data instance from
* the provided MSL object.
*
* @param unauthenticatedAuthMo the authentication data MSL object.
* @throws MslEncodingException if there is an error parsing the MSL data.
*/
UnauthenticatedAuthenticationData(final MslObject unauthenticatedAuthMo) throws MslEncodingException {
super(EntityAuthenticationScheme.NONE);
try {
identity = unauthenticatedAuthMo.getString(KEY_IDENTITY);
} catch (final MslEncoderException e) {
throw new MslEncodingException(MslError.MSL_PARSE_ERROR, "unauthenticated authdata " + unauthenticatedAuthMo, e);
}
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#getIdentity()
*/
@Override
public String getIdentity() {
return identity;
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#getAuthData(com.netflix.msl.io.MslEncoderFactory, com.netflix.msl.io.MslEncoderFormat)
*/
@Override
public MslObject getAuthData(final MslEncoderFactory encoder, final MslEncoderFormat format) {
final MslObject mo = encoder.createObject();
mo.put(KEY_IDENTITY, identity);
return mo;
}
/** Entity identity. */
private final String identity;
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#equals(java.lang.Object)
*/
@Override
public boolean equals(final Object obj) {
if (obj == this) return true;
if (!(obj instanceof UnauthenticatedAuthenticationData)) return false;
final UnauthenticatedAuthenticationData that = (UnauthenticatedAuthenticationData)obj;
return super.equals(obj) && this.identity.equals(that.identity);
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#hashCode()
*/
@Override
public int hashCode() {
return super.hashCode() ^ identity.hashCode();
}
}
| 9,912 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/entityauth/ProvisionedAuthenticationData.java | /**
* Copyright (c) 2016-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslObject;
/**
* <p>Provisioned entity authentication data. This form of authentication is
* used by entities that cannot provide any form of entity authentication and
* also want to delegate the generation or assignment of their identity to the
* remote entity.</p>
*
* <p>Provisioned entity authentication data is represented as
* {@code
* provisionedauthdata = {
* }}</p>
*
* <p>Until the entity identity has been provisioned, the entity identity will
* be equal to the empty string.</p>
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class ProvisionedAuthenticationData extends EntityAuthenticationData {
/**
* Construct a new provisioned entity authentication data instance.
*/
public ProvisionedAuthenticationData() {
super(EntityAuthenticationScheme.PROVISIONED);
}
/**
* Construct a new provisioned entity authentication data instance from the
* provided JSON object.
*
* @param provisionedAuthMo the authentication data JSON object.
*/
public ProvisionedAuthenticationData(final MslObject provisionedAuthMo) {
super(EntityAuthenticationScheme.PROVISIONED);
}
/**
* <p>Sets the entity identity.</p>
*
* @param identity the entity identity.
*/
void setIdentity(final String identity) {
this.identity = identity;
}
/**
* <p>Return the entity identity. Prior to provisioning, this function will
* return the empty string. After an identity has been provisioned, this
* function will return the provisioned identity.</p>
*
* @see #setIdentity(String)
*/
@Override
public String getIdentity() {
return identity;
}
@Override
public MslObject getAuthData(final MslEncoderFactory encoder, final MslEncoderFormat format) throws MslEncoderException {
return encoder.createObject();
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#equals(java.lang.Object)
*/
@Override
public boolean equals(final Object obj) {
if (obj == this) return true;
if (!(obj instanceof ProvisionedAuthenticationData)) return false;
return super.equals(obj);
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#hashCode()
*/
@Override
public int hashCode() {
return super.hashCode();
}
/** Entity identity. */
private String identity = "";
}
| 9,913 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/entityauth/UnauthenticatedAuthenticationFactory.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.crypto.NullCryptoContext;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.util.AuthenticationUtils;
import com.netflix.msl.util.MslContext;
/**
* <p>Unauthenticated entity authentication factory.</p>
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class UnauthenticatedAuthenticationFactory extends EntityAuthenticationFactory {
/**
* Construct a new unauthenticated authentication factory instance.
*
* @param authutils authentication utilities.
*/
public UnauthenticatedAuthenticationFactory(final AuthenticationUtils authutils) {
super(EntityAuthenticationScheme.NONE);
this.authutils = authutils;
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationFactory#createData(com.netflix.msl.util.MslContext, com.netflix.msl.io.MslObject)
*/
@Override
public EntityAuthenticationData createData(final MslContext ctx, final MslObject entityAuthMo) throws MslEncodingException {
return new UnauthenticatedAuthenticationData(entityAuthMo);
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationFactory#getCryptoContext(com.netflix.msl.util.MslContext, com.netflix.msl.entityauth.EntityAuthenticationData)
*/
@Override
public ICryptoContext getCryptoContext(final MslContext ctx, final EntityAuthenticationData authdata) throws MslEntityAuthException {
// Make sure we have the right kind of entity authentication data.
if (!(authdata instanceof UnauthenticatedAuthenticationData))
throw new MslInternalException("Incorrect authentication data type " + authdata.getClass().getName() + ".");
final UnauthenticatedAuthenticationData uad = (UnauthenticatedAuthenticationData)authdata;
// Check for revocation.
final String identity = uad.getIdentity();
if (authutils.isEntityRevoked(identity))
throw new MslEntityAuthException(MslError.ENTITY_REVOKED, "none " + identity).setEntityAuthenticationData(uad);
// Verify the scheme is permitted.
if (!authutils.isSchemePermitted(identity, getScheme()))
throw new MslEntityAuthException(MslError.INCORRECT_ENTITYAUTH_DATA, "Authentication Scheme for Device Type Not Supported " + identity + ":" + getScheme()).setEntityAuthenticationData(uad);
// Return the crypto context.
return new NullCryptoContext();
}
/** Authentication utilities. */
final AuthenticationUtils authutils;
}
| 9,914 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/entityauth/ProvisionedAuthenticationFactory.java | /**
* Copyright (c) 2016-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.crypto.NullCryptoContext;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.util.MslContext;
/**
* <p>Provisioned entity authentication factory.</p>
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class ProvisionedAuthenticationFactory extends EntityAuthenticationFactory {
/**
* An identity provisioning service returns unique entity identities.
*/
public interface IdentityProvisioningService {
/**
* @return the next unique entity identity.
*/
public String nextIdentity();
}
/**
* Construct a new provisioned authentication factory instance.
*
* @param service the identity provisioning service to use.
*/
public ProvisionedAuthenticationFactory(final IdentityProvisioningService service) {
super(EntityAuthenticationScheme.PROVISIONED);
this.service = service;
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationFactory#createData(com.netflix.msl.util.MslContext, com.netflix.msl.io.MslObject)
*/
@Override
public EntityAuthenticationData createData(final MslContext ctx, final MslObject entityAuthMo) {
return new ProvisionedAuthenticationData(entityAuthMo);
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationFactory#getCryptoContext(com.netflix.msl.util.MslContext, com.netflix.msl.entityauth.EntityAuthenticationData)
*/
@Override
public ICryptoContext getCryptoContext(final MslContext ctx, final EntityAuthenticationData authdata) throws MslCryptoException, MslEntityAuthException {
// Make sure we have the right kind of entity authentication data.
if (!(authdata instanceof ProvisionedAuthenticationData))
throw new MslInternalException("Incorrect authentication data type " + authdata.getClass().getName() + ".");
final ProvisionedAuthenticationData pad = (ProvisionedAuthenticationData)authdata;
// Provision an entity identity.
final String identity = service.nextIdentity();
pad.setIdentity(identity);
// Return the crypto context.
return new NullCryptoContext();
}
/** Identity provisioning service. */
final IdentityProvisioningService service;
}
| 9,915 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/entityauth/RsaAuthenticationData.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslObject;
/**
* <p>RSA asymmetric keys entity authentication data.</p>
*
* <p>
* {@code {
* "#mandatory" : [ "identity", "pubkeyid" ],
* "identity" : "string",
* "pubkeyid" : "string"
* }} where:
* <ul>
* <li>{@code identity} is the entity identity</li>
* <li>{@code pubkeyid} is the identity of the RSA public key associated with this identity</li>
* </ul></p>
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class RsaAuthenticationData extends EntityAuthenticationData {
/** Key entity identity. */
private static final String KEY_IDENTITY = "identity";
/** Key public key ID. */
private static final String KEY_PUBKEY_ID = "pubkeyid";
/**
* Construct a new public key authentication data instance from the
* specified entity identity and public key ID.
*
* @param identity the entity identity.
* @param pubkeyid the public key ID.
*/
public RsaAuthenticationData(final String identity, final String pubkeyid) {
super(EntityAuthenticationScheme.RSA);
this.identity = identity;
this.pubkeyid = pubkeyid;
}
/**
* Construct a new RSA asymmetric keys authentication data instance from
* the provided MSL object.
*
* @param rsaAuthMo the authentication data MSL object.
* @throws MslEncodingException if there is an error parsing the MSL data.
*/
public RsaAuthenticationData(final MslObject rsaAuthMo) throws MslCryptoException, MslEncodingException {
super(EntityAuthenticationScheme.RSA);
try {
// Extract RSA authentication data.
identity = rsaAuthMo.getString(KEY_IDENTITY);
pubkeyid = rsaAuthMo.getString(KEY_PUBKEY_ID);
} catch (final MslEncoderException e) {
throw new MslEncodingException(MslError.MSL_PARSE_ERROR, "RSA authdata " + rsaAuthMo, e);
}
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#getIdentity()
*/
@Override
public String getIdentity() {
return identity;
}
/**
* @return the public key ID.
*/
public String getPublicKeyId() {
return pubkeyid;
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#getAuthData(com.netflix.msl.io.MslEncoderFactory, com.netflix.msl.io.MslEncoderFormat)
*/
@Override
public MslObject getAuthData(final MslEncoderFactory encoder, final MslEncoderFormat format) {
final MslObject mo = encoder.createObject();
mo.put(KEY_IDENTITY, identity);
mo.put(KEY_PUBKEY_ID, pubkeyid);
return mo;
}
/** Entity identity. */
private final String identity;
/** Public key ID. */
private final String pubkeyid;
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#equals(java.lang.Object)
*/
@Override
public boolean equals(final Object obj) {
if (obj == this) return true;
if (!(obj instanceof RsaAuthenticationData)) return false;
final RsaAuthenticationData that = (RsaAuthenticationData)obj;
return super.equals(obj) && this.identity.equals(that.identity) && this.pubkeyid.equals(that.pubkeyid);
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#hashCode()
*/
@Override
public int hashCode() {
return super.hashCode() ^ (identity + "|" + pubkeyid).hashCode();
}
}
| 9,916 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/entityauth/EntityAuthenticationData.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import java.util.HashMap;
import java.util.Map;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.io.MslEncodable;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.util.MslContext;
/**
* <p>The entity authentication data provides proof of entity identity.</p>
*
* <p>Specific entity authentication mechanisms should define their own entity
* authentication data types.</p>
*
* <p>Entity authentication data is represented as
* {@code
* entityauthdata = {
* "#mandatory" : [ "scheme", "authdata" ],
* "scheme" : "string",
* "authdata" : object
* }} where:
* <ul>
* <li>{@code scheme} is the entity authentication scheme</li>
* <li>{@code authdata} is the scheme-specific entity authentication data</li>
* </ul></p>
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public abstract class EntityAuthenticationData implements MslEncodable {
/** Key entity authentication scheme. */
private static final String KEY_SCHEME = "scheme";
/** Key entity authentication data. */
private static final String KEY_AUTHDATA = "authdata";
/**
* Create a new entity authentication data object with the specified entity
* authentication scheme.
*
* @param scheme the entity authentication scheme.
*/
protected EntityAuthenticationData(final EntityAuthenticationScheme scheme) {
this.scheme = scheme;
}
/**
* Construct a new entity authentication data instance of the correct type
* from the provided MSL object.
*
* @param ctx MSL context.
* @param entityAuthMo the MSL object.
* @return the entity authentication data concrete instance.
* @throws MslEntityAuthException if unable to create the entity
* authentication data.
* @throws MslEncodingException if there is an error parsing the entity
* authentication data.
* @throws MslCryptoException if there is an error creating the entity
* authentication data crypto.
*/
public static EntityAuthenticationData create(final MslContext ctx, final MslObject entityAuthMo) throws MslEntityAuthException, MslEncodingException, MslCryptoException {
try {
// Identify the concrete subclass from the authentication scheme.
final String schemeName = entityAuthMo.getString(KEY_SCHEME);
final EntityAuthenticationScheme scheme = ctx.getEntityAuthenticationScheme(schemeName);
if (scheme == null)
throw new MslEntityAuthException(MslError.UNIDENTIFIED_ENTITYAUTH_SCHEME, schemeName);
final MslEncoderFactory encoder = ctx.getMslEncoderFactory();
final MslObject authdata = entityAuthMo.getMslObject(KEY_AUTHDATA, encoder);
// Construct an instance of the concrete subclass.
final EntityAuthenticationFactory factory = ctx.getEntityAuthenticationFactory(scheme);
if (factory == null)
throw new MslEntityAuthException(MslError.ENTITYAUTH_FACTORY_NOT_FOUND, scheme.name());
return factory.createData(ctx, authdata);
} catch (final MslEncoderException e) {
throw new MslEncodingException(MslError.MSL_PARSE_ERROR, "entityauthdata " + entityAuthMo, e);
}
}
/**
* @return the entity authentication scheme.
*/
public EntityAuthenticationScheme getScheme() {
return scheme;
}
/**
* @return the entity identity. May be {@code null} if unknown.
* @throws MslCryptoException if there is a crypto error accessing the
* entity identity.
*/
public abstract String getIdentity() throws MslCryptoException;
/**
* @param encoder MSL encoder factory.
* @param format MSL encoder format.
* @return the authentication data MSL representation.
* @throws MslEncoderException if there was an error constructing the
* MSL object.
*/
public abstract MslObject getAuthData(final MslEncoderFactory encoder, final MslEncoderFormat format) throws MslEncoderException;
/* (non-Javadoc)
* @see com.netflix.msl.io.MslEncodable#toMslEncoding(com.netflix.msl.io.MslEncoderFactory, com.netflix.msl.io.MslEncoderFormat)
*/
@Override
public final byte[] toMslEncoding(final MslEncoderFactory encoder, final MslEncoderFormat format) throws MslEncoderException {
// Return any cached encoding.
if (encodings.containsKey(format))
return encodings.get(format);
// Encode the entity authentication data.
final MslObject mo = encoder.createObject();
mo.put(KEY_SCHEME, scheme.name());
mo.put(KEY_AUTHDATA, getAuthData(encoder, format));
final byte[] encoding = encoder.encodeObject(mo, format);
// Cache and return the encoding.
encodings.put(format, encoding);
return encoding;
}
/* (non-Javadoc)
* @see java.lang.Object#equals(java.lang.Object)
*/
@Override
public boolean equals(final Object obj) {
if (obj == this) return true;
if (!(obj instanceof EntityAuthenticationData)) return false;
final EntityAuthenticationData that = (EntityAuthenticationData)obj;
return this.scheme.equals(that.scheme);
}
/* (non-Javadoc)
* @see java.lang.Object#hashCode()
*/
@Override
public int hashCode() {
return scheme.hashCode();
}
/** Entity authentication scheme. */
private final EntityAuthenticationScheme scheme;
/** Cached encodings. */
private final Map<MslEncoderFormat,byte[]> encodings = new HashMap<MslEncoderFormat,byte[]>();
}
| 9,917 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/entityauth/EccStore.java | /**
* Copyright (c) 2016 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Set;
/**
* An ECC public key store contains trusted ECC public and private keys.
*/
public interface EccStore {
/**
* @return the known key pair identities.
*/
public Set<String> getIdentities();
/**
* Return the public key of the identified ECC key pair.
*
* @param identity ECC key pair identity.
* @return the public key of the identified key pair or null if not found.
*/
public PublicKey getPublicKey(final String identity);
/**
* Return the private key of the identified ECC key pair.
*
* @param identity ECC key pair identity.
* @return the private key of the identified key pair or null if not found.
*/
public PrivateKey getPrivateKey(final String identity);
}
| 9,918 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/entityauth/EccAuthenticationData.java | /**
* Copyright (c) 2016-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslObject;
/**
* <p>ECC asymmetric keys entity authentication data.</p>
*
* <p>
* {@code {
* "#mandatory" : [ "identity", "pubkeyid" ],
* "identity" : "string",
* "pubkeyid" : "string"
* }} where:
* <ul>
* <li>{@code identity} is the entity identity</li>
* <li>{@code pubkeyid} is the identity of the ECC public key associated with this identity</li>
* </ul></p>
*/
public class EccAuthenticationData extends EntityAuthenticationData {
/** Key entity identity. */
private static final String KEY_IDENTITY = "identity";
/** Key public key ID. */
private static final String KEY_PUBKEY_ID = "pubkeyid";
/**
* Construct a new public key authentication data instance from the
* specified entity identity and public key ID.
*
* @param identity the entity identity.
* @param pubkeyid the public key ID.
*/
public EccAuthenticationData(final String identity, final String pubkeyid) {
super(EntityAuthenticationScheme.ECC);
this.identity = identity;
this.pubkeyid = pubkeyid;
}
/**
* Construct a new ECC asymmetric keys authentication data instance from
* the provided MSL object.
*
* @param eccAuthMo the authentication data MSL object.
* @throws MslEncodingException if there is an error parsing the data.
*/
EccAuthenticationData(final MslObject eccAuthMo) throws MslCryptoException, MslEncodingException {
super(EntityAuthenticationScheme.ECC);
try {
// Extract ECC authentication data.
identity = eccAuthMo.getString(KEY_IDENTITY);
pubkeyid = eccAuthMo.getString(KEY_PUBKEY_ID);
} catch (final MslEncoderException e) {
throw new MslEncodingException(MslError.MSL_PARSE_ERROR, "ECC authdata " + eccAuthMo, e);
}
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#getIdentity()
*/
@Override
public String getIdentity() {
return identity;
}
/**
* @return the public key ID.
*/
public String getPublicKeyId() {
return pubkeyid;
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#getAuthData(com.netflix.msl.io.MslEncoderFactory, com.netflix.msl.io.MslEncoderFormat)
*/
@Override
public MslObject getAuthData(final MslEncoderFactory encoder, final MslEncoderFormat format) throws MslEncoderException {
final MslObject mo = encoder.createObject();
mo.put(KEY_IDENTITY, identity);
mo.put(KEY_PUBKEY_ID, pubkeyid);
return mo;
}
/** Entity identity. */
private final String identity;
/** Public key ID. */
private final String pubkeyid;
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#equals(java.lang.Object)
*/
@Override
public boolean equals(final Object obj) {
if (obj == this) return true;
if (!(obj instanceof EccAuthenticationData)) return false;
final EccAuthenticationData that = (EccAuthenticationData)obj;
return super.equals(obj) && this.identity.equals(that.identity) && this.pubkeyid.equals(that.pubkeyid);
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#hashCode()
*/
@Override
public int hashCode() {
return super.hashCode() ^ (identity + "|" + pubkeyid).hashCode();
}
}
| 9,919 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/entityauth/PresharedAuthenticationFactory.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.crypto.SymmetricCryptoContext;
import com.netflix.msl.entityauth.KeySetStore.KeySet;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.util.AuthenticationUtils;
import com.netflix.msl.util.MslContext;
/**
* Preshared keys entity authentication factory.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class PresharedAuthenticationFactory extends EntityAuthenticationFactory {
/**
* Construct a new preshared keys authentication factory instance.
*
* @param store preshared key store.
* @param authutils authentication utilities.
*/
public PresharedAuthenticationFactory(final KeySetStore store, final AuthenticationUtils authutils) {
super(EntityAuthenticationScheme.PSK);
this.store = store;
this.authutils = authutils;
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationFactory#createData(com.netflix.msl.util.MslContext, com.netflix.msl.io.MslObject)
*/
@Override
public EntityAuthenticationData createData(final MslContext ctx, final MslObject entityAuthMo) throws MslEncodingException {
return new PresharedAuthenticationData(entityAuthMo);
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationFactory#getCryptoContext(com.netflix.msl.util.MslContext, com.netflix.msl.entityauth.EntityAuthenticationData)
*/
@Override
public ICryptoContext getCryptoContext(final MslContext ctx, final EntityAuthenticationData authdata) throws MslCryptoException, MslEntityAuthException {
// Make sure we have the right kind of entity authentication data.
if (!(authdata instanceof PresharedAuthenticationData))
throw new MslInternalException("Incorrect authentication data type " + authdata.getClass().getName() + ".");
final PresharedAuthenticationData pad = (PresharedAuthenticationData)authdata;
// Check for revocation.
final String identity = pad.getIdentity();
if (authutils.isEntityRevoked(identity))
throw new MslEntityAuthException(MslError.ENTITY_REVOKED, "psk " + identity).setEntityAuthenticationData(pad);
// Verify the scheme is permitted.
if (!authutils.isSchemePermitted(identity, getScheme()))
throw new MslEntityAuthException(MslError.INCORRECT_ENTITYAUTH_DATA, "Authentication Scheme for Device Type Not Supported " + identity + ":" + getScheme()).setEntityAuthenticationData(pad);
// Load key set.
final KeySet keys = store.getKeys(identity);
if (keys == null)
throw new MslEntityAuthException(MslError.ENTITY_NOT_FOUND, "psk " + identity).setEntityAuthenticationData(pad);
// Return the crypto context.
return new SymmetricCryptoContext(ctx, identity, keys.encryptionKey, keys.hmacKey, keys.wrappingKey);
}
/** Preshared keys store. */
private final KeySetStore store;
/** Authentication utilities. */
private final AuthenticationUtils authutils;
}
| 9,920 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/entityauth/PresharedProfileAuthenticationFactory.java | /**
* Copyright (c) 2014-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.crypto.SymmetricCryptoContext;
import com.netflix.msl.entityauth.KeySetStore.KeySet;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.util.AuthenticationUtils;
import com.netflix.msl.util.MslContext;
/**
* <p>Preshared keys profile entity authentication factory.</p>
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class PresharedProfileAuthenticationFactory extends EntityAuthenticationFactory {
/**
* Construct a new preshared keys profile authentication factory instance.
*
* @param store preshared key store.
* @param authutils authentication utilities.
*/
public PresharedProfileAuthenticationFactory(final KeySetStore store, final AuthenticationUtils authutils) {
super(EntityAuthenticationScheme.PSK_PROFILE);
this.store = store;
this.authutils = authutils;
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationFactory#createData(com.netflix.msl.util.MslContext, com.netflix.msl.io.MslObject)
*/
@Override
public EntityAuthenticationData createData(final MslContext ctx, final MslObject entityAuthMo) throws MslEncodingException {
return new PresharedProfileAuthenticationData(entityAuthMo);
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationFactory#getCryptoContext(com.netflix.msl.util.MslContext, com.netflix.msl.entityauth.EntityAuthenticationData)
*/
@Override
public ICryptoContext getCryptoContext(final MslContext ctx, final EntityAuthenticationData authdata) throws MslEntityAuthException {
// Make sure we have the right kind of entity authentication data.
if (!(authdata instanceof PresharedProfileAuthenticationData))
throw new MslInternalException("Incorrect authentication data type " + authdata.getClass().getName() + ".");
final PresharedProfileAuthenticationData ppad = (PresharedProfileAuthenticationData)authdata;
// Check for revocation.
final String pskId = ppad.getPresharedKeysId();
if (authutils.isEntityRevoked(pskId))
throw new MslEntityAuthException(MslError.ENTITY_REVOKED, "psk profile " + pskId).setEntityAuthenticationData(ppad);
// Verify the scheme is permitted.
if (!authutils.isSchemePermitted(pskId, getScheme()))
throw new MslEntityAuthException(MslError.INCORRECT_ENTITYAUTH_DATA, "Authentication Scheme for Device Type Not Supported " + pskId + ":" + getScheme()).setEntityAuthenticationData(ppad);
// Load key set.
final KeySet keys = store.getKeys(pskId);
if (keys == null)
throw new MslEntityAuthException(MslError.ENTITY_NOT_FOUND, "psk profile " + pskId).setEntityAuthenticationData(ppad);
// Return the crypto context.
final String identity = ppad.getIdentity();
return new SymmetricCryptoContext(ctx, identity, keys.encryptionKey, keys.hmacKey, keys.wrappingKey);
}
/** Preshared keys store. */
private final KeySetStore store;
/** Authentication utilities. */
private final AuthenticationUtils authutils;
}
| 9,921 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/entityauth/PresharedAuthenticationData.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslObject;
/**
* <p>Preshared keys entity authentication data.</p>
*
* <p>
* {@code {
* "#mandatory" : [ "identity" ],
* "identity" : "string"
* }} where:
* <ul>
* <li>{@code identity} is the entity identity</li>
* </ul></p>
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class PresharedAuthenticationData extends EntityAuthenticationData {
/** Key entity identity. */
private static final String KEY_IDENTITY = "identity";
/**
* Construct a new preshared keys authentication data instance from the
* specified entity identity.
*
* @param identity the entity identity.
*/
public PresharedAuthenticationData(final String identity) {
super(EntityAuthenticationScheme.PSK);
this.identity = identity;
}
/**
* Construct a new preshared keys authentication data instance from the
* provided MSL object.
*
* @param presharedAuthMo the authentication data MSL object.
* @throws MslEncodingException if there is an error parsing the entity
* authentication data.
*/
PresharedAuthenticationData(final MslObject presharedAuthMo) throws MslEncodingException {
super(EntityAuthenticationScheme.PSK);
try {
identity = presharedAuthMo.getString(KEY_IDENTITY);
} catch (final MslEncoderException e) {
throw new MslEncodingException(MslError.MSL_PARSE_ERROR, "psk authdata " + presharedAuthMo, e);
}
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#getIdentity()
*/
@Override
public String getIdentity() {
return identity;
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#getAuthData(com.netflix.msl.io.MslEncoderFactory, com.netflix.msl.io.MslEncoderFormat)
*/
@Override
public MslObject getAuthData(final MslEncoderFactory encoder, final MslEncoderFormat format) {
final MslObject mo = encoder.createObject();
mo.put(KEY_IDENTITY, identity);
return mo;
}
/** Entity identity. */
private final String identity;
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#equals(java.lang.Object)
*/
@Override
public boolean equals(final Object obj) {
if (obj == this) return true;
if (!(obj instanceof PresharedAuthenticationData)) return false;
final PresharedAuthenticationData that = (PresharedAuthenticationData)obj;
return super.equals(obj) && this.identity.equals(that.identity);
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#hashCode()
*/
@Override
public int hashCode() {
return super.hashCode() ^ identity.hashCode();
}
}
| 9,922 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/entityauth/X509AuthenticationData.java | /**
* Copyright (c) 2012-2018 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import java.io.ByteArrayInputStream;
import java.security.cert.CertificateEncodingException;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.util.Base64;
/**
* <p>X.509 asymmetric keys entity authentication data.</p>
*
* <p>The X.509 certificate should be used to enumerate any entity
* properties. The certificate subject canonical name is considered the device
* identity. X.509 authentication data is considered equal based on the device
* identity.</p>
*
* <p>
* {@code {
* "#mandatory" : [ "x509certificate" ],
* "x509certificate" : "string"
* }} where:
* <ul>
* <li>{@code x509certificate} is the Base64-encoded X.509 certificate</li>
* </ul></p>
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class X509AuthenticationData extends EntityAuthenticationData {
/** Key entity X.509 certificate. */
private static final String KEY_X509_CERT = "x509certificate";
/**
* Construct a new X.509 asymmetric keys authentication data instance from
* the provided X.509 certificate.
*
* @param x509cert entity X.509 certificate.
* @throws MslCryptoException if the X.509 certificate data cannot be
* parsed.
*/
public X509AuthenticationData(final X509Certificate x509cert) throws MslCryptoException {
super(EntityAuthenticationScheme.X509);
this.x509cert = x509cert;
this.identity = x509cert.getSubjectX500Principal().getName();
}
/**
* Construct a new X.509 asymmetric keys authentication data instance from
* the provided MSL object.
*
* @param x509AuthMo the authentication data MSL object.
* @throws MslCryptoException if the X.509 certificate data cannot be
* parsed.
* @throws MslEncodingException if the X.509 certificate cannot be found.
*/
public X509AuthenticationData(final MslObject x509AuthMo) throws MslCryptoException, MslEncodingException {
super(EntityAuthenticationScheme.X509);
// Extract X.509 certificate representation.
final String x509;
try {
x509 = x509AuthMo.getString(KEY_X509_CERT);
} catch (final MslEncoderException e) {
throw new MslEncodingException(MslError.MSL_PARSE_ERROR, "X.509 authdata " + x509AuthMo, e);
}
// Get the X.509 certificate factory.
final CertificateFactory factory;
try {
factory = CertificateFactory.getInstance("X.509");
} catch (final CertificateException e) {
throw new MslInternalException("No certificate X.509 certificate factory.", e);
}
// Create X.509 cert.
final byte[] x509bytes;
try {
x509bytes = Base64.decode(x509);
} catch (final IllegalArgumentException e) {
throw new MslCryptoException(MslError.X509CERT_INVALID, x509, e);
}
try {
final ByteArrayInputStream bais = new ByteArrayInputStream(x509bytes);
x509cert = (X509Certificate)factory.generateCertificate(bais);
identity = x509cert.getSubjectX500Principal().getName();
} catch (final CertificateException e) {
throw new MslCryptoException(MslError.X509CERT_PARSE_ERROR, Base64.encode(x509bytes), e);
}
}
/**
* @return the X.509 certificate.
*/
public X509Certificate getX509Cert() {
return x509cert;
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#getIdentity()
*/
@Override
public String getIdentity() {
return identity;
}
@Override
public MslObject getAuthData(final MslEncoderFactory encoder, final MslEncoderFormat format) throws MslEncoderException {
final MslObject mo = encoder.createObject();
try {
mo.put(KEY_X509_CERT, Base64.encode(x509cert.getEncoded()));
} catch (final CertificateEncodingException | IllegalArgumentException e) {
throw new MslEncoderException("Error encoding X.509 authdata", e);
}
return mo;
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#equals(java.lang.Object)
*/
@Override
public boolean equals(final Object obj) {
if (obj == this) return true;
if (!(obj instanceof X509AuthenticationData)) return false;
final X509AuthenticationData that = (X509AuthenticationData)obj;
return super.equals(obj) && this.identity.equals(that.identity);
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#hashCode()
*/
@Override
public int hashCode() {
return super.hashCode() ^ identity.hashCode();
}
/** Entity X.509 certificate. */
private final X509Certificate x509cert;
/** Entity identity. */
private final String identity;
}
| 9,923 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/entityauth/KeySetStore.java | /**
* Copyright (c) 2014-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import javax.crypto.SecretKey;
/**
* A key set store contains trusted key sets.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public interface KeySetStore {
/**
* A set of encryption, HMAC, and wrapping keys.
*/
public static class KeySet {
/**
* Create a new key set with the given keys.
*
* @param encryptionKey the encryption key.
* @param hmacKey the HMAC key.
* @param wrappingKey the wrapping key.
*/
public KeySet(final SecretKey encryptionKey, final SecretKey hmacKey, final SecretKey wrappingKey) {
this.encryptionKey = encryptionKey;
this.hmacKey = hmacKey;
this.wrappingKey = wrappingKey;
}
/** Encryption key. */
public final SecretKey encryptionKey;
/** HMAC key. */
public final SecretKey hmacKey;
/** Wrapping key. */
public final SecretKey wrappingKey;
}
/**
* Return the encryption, HMAC, and wrapping keys for the given identity.
*
* @param identity key set identity.
* @return the keys set associated with the identity or null if not found.
*/
public KeySet getKeys(final String identity);
}
| 9,924 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/entityauth/RsaStore.java | /**
* Copyright (c) 2012-2014 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Set;
/**
* An RSA public key store contains trusted RSA public and private keys.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public interface RsaStore {
/**
* @return the known key pair identities.
*/
public Set<String> getIdentities();
/**
* Return the public key of the identified RSA key pair.
*
* @param identity RSA key pair identity.
* @return the public key of the identified key pair or null if not found.
*/
public PublicKey getPublicKey(final String identity);
/**
* Return the private key of the identified RSA key pair.
*
* @param identity RSA key pair identity.
* @return the private key of the identified key pair or null if not found.
*/
public PrivateKey getPrivateKey(final String identity);
}
| 9,925 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/entityauth/EntityAuthenticationFactory.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.util.MslContext;
/**
* A entity authentication factory creates authentication data instances and
* authenticators for a specific entity authentication scheme.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public abstract class EntityAuthenticationFactory {
/**
* Create a new entity authentication factory for the specified scheme.
*
* @param scheme the entity authentication scheme.
*/
protected EntityAuthenticationFactory(final EntityAuthenticationScheme scheme) {
this.scheme = scheme;
}
/**
* @return the entity authentication scheme this factory is for.
*/
public EntityAuthenticationScheme getScheme() {
return scheme;
}
/**
* Construct a new entity authentication data instance from the provided
* MSL object.
*
* @param ctx MSL context.
* @param entityAuthMo the MSL object.
* @return the entity authentication data.
* @throws MslEncodingException if there is an error parsing the data.
* @throws MslCryptoException if there is an error with the entity
* authentication data cryptography.
* @throws MslEntityAuthException if there is an error creating the entity
* authentication data.
*/
public abstract EntityAuthenticationData createData(final MslContext ctx, final MslObject entityAuthMo) throws MslEncodingException, MslCryptoException, MslEntityAuthException;
/**
* Create a crypto context that can be used to encrypt/decrypt and
* authenticate data from the entity. The implementation of this function
* must, by necessity, authenticate the entity authentication data.
*
* @param ctx MSL context.
* @param authdata the authentication data.
* @return the entity crypto context.
* @throws MslCryptoException if there is an error instantiating the crypto
* context.
* @throws MslEntityAuthException if there is an error with the entity
* authentication data.
*/
public abstract ICryptoContext getCryptoContext(final MslContext ctx, final EntityAuthenticationData authdata) throws MslCryptoException, MslEntityAuthException;
/** The factory's entity authentication scheme. */
private final EntityAuthenticationScheme scheme;
}
| 9,926 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/entityauth/EccAuthenticationFactory.java | /**
* Copyright (c) 2016-2018 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import java.security.PrivateKey;
import java.security.PublicKey;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.crypto.EccCryptoContext;
import com.netflix.msl.crypto.EccCryptoContext.Mode;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.util.AuthenticationUtils;
import com.netflix.msl.util.MslContext;
/**
* <p>ECC asymmetric keys entity authentication factory.</p>
*/
public class EccAuthenticationFactory extends EntityAuthenticationFactory {
/**
* <p>Construct a new ECC asymmetric keys authentication factory
* instance.</p>
*
* @param store ECC key store.
* @param authutils authentication utilities.
*/
public EccAuthenticationFactory(final EccStore store, final AuthenticationUtils authutils) {
this(null, store, authutils);
}
/**
* <p>Construct a new ECC asymmetric keys authentication factory instance
* with the specified key pair ID for the local entity. The ECC key store
* must contain a private key for the local entity (a public key is
* optional).</p>
*
* @param keyPairId local entity key pair ID.
* @param store ECC key store.
* @param authutils authentication utilities.
*/
public EccAuthenticationFactory(final String keyPairId, final EccStore store, final AuthenticationUtils authutils) {
super(EntityAuthenticationScheme.ECC);
this.keyPairId = keyPairId;
this.store = store;
this.authutils = authutils;
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationFactory#createData(com.netflix.msl.util.MslContext, com.netflix.msl.io.MslObject)
*/
@Override
public EntityAuthenticationData createData(final MslContext ctx, final MslObject entityAuthMo) throws MslEncodingException, MslCryptoException {
return new EccAuthenticationData(entityAuthMo);
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationFactory#getCryptoContext(com.netflix.msl.util.MslContext, com.netflix.msl.entityauth.EntityAuthenticationData)
*/
@Override
public ICryptoContext getCryptoContext(final MslContext ctx, final EntityAuthenticationData authdata) throws MslEntityAuthException {
// Make sure we have the right kind of entity authentication data.
if (!(authdata instanceof EccAuthenticationData))
throw new MslInternalException("Incorrect authentication data type " + authdata.getClass().getName() + ".");
final EccAuthenticationData ead = (EccAuthenticationData)authdata;
// Check for revocation.
final String identity = ead.getIdentity();
if (authutils.isEntityRevoked(identity))
throw new MslEntityAuthException(MslError.ENTITY_REVOKED, "ecc" + identity).setEntityAuthenticationData(ead);
// Verify the scheme is permitted.
if (!authutils.isSchemePermitted(identity, getScheme()))
throw new MslEntityAuthException(MslError.INCORRECT_ENTITYAUTH_DATA, "Authentication Scheme for Device Type Not Supported " + identity + ":" + getScheme()).setEntityAuthenticationData(ead);
// Extract ECC authentication data.
final String pubkeyid = ead.getPublicKeyId();
final PublicKey publicKey = store.getPublicKey(pubkeyid);
final PrivateKey privateKey = store.getPrivateKey(pubkeyid);
// The local entity must have a private key.
if (pubkeyid.equals(keyPairId) && privateKey == null)
throw new MslEntityAuthException(MslError.ECC_PRIVATEKEY_NOT_FOUND, pubkeyid).setEntityAuthenticationData(ead);
// Remote entities must have a public key.
else if (!pubkeyid.equals(keyPairId) && publicKey == null)
throw new MslEntityAuthException(MslError.ECC_PUBLICKEY_NOT_FOUND, pubkeyid).setEntityAuthenticationData(ead);
// Return the crypto context.
return new EccCryptoContext(identity, privateKey, publicKey, Mode.SIGN_VERIFY);
}
/** Local entity key pair ID. */
private final String keyPairId;
/** ECC key store. */
private final EccStore store;
/** Authentication utilities. */
private final AuthenticationUtils authutils;
}
| 9,927 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/entityauth/MasterTokenProtectedAuthenticationData.java | /**
* Copyright (c) 2015-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import java.util.HashMap;
import java.util.Map;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
import com.netflix.msl.MslMasterTokenException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.crypto.SessionCryptoContext;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.tokens.MasterToken;
import com.netflix.msl.util.MslContext;
/**
* <p>Master token protected entity authentication data.</p>
*
* <p>
* {@code {
* "#mandatory" : [ "mastertoken", "authdata", "signature" ],
* "mastertoken" : mastertoken,
* "authdata" : "binary",
* "signature" : "binary",
* }} where:
* <ul>
* <li>{@code mastertoken} is the master token used to protect the encapsulated authentication data</li>
* <li>{@code authdata} is the ciphertext envelope containing the encapsulated authentication data</li>
* <li>{@code signature} is the signature envelope verifying the encapsulated authentication data</li>
* </ul></p>
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class MasterTokenProtectedAuthenticationData extends EntityAuthenticationData {
/** Key master token. */
protected static final String KEY_MASTER_TOKEN = "mastertoken";
/** Key authentication data. */
protected static final String KEY_AUTHENTICATION_DATA = "authdata";
/** Key signature. */
protected static final String KEY_SIGNATURE = "signature";
/**
* <p>Construct a new master token protected entity authentication data
* instance using the provided master token and actual entity
* authentication data.</p>
*
* @param ctx MSL context.
* @param masterToken the master token.
* @param authdata encapsulated authentication data.
* @throws MslCryptoException if there is an error encrypting or signing
* the encapsulated authentication data.
* @throws MslEntityAuthException if the master token crypto context cannot
* be found in the MSL store and cannot be created.
*/
public MasterTokenProtectedAuthenticationData(final MslContext ctx, final MasterToken masterToken, final EntityAuthenticationData authdata) throws MslCryptoException, MslEntityAuthException {
super(EntityAuthenticationScheme.MT_PROTECTED);
this.ctx = ctx;
this.masterToken = masterToken;
this.authdata = authdata;
}
/**
* <p>Construct a new master token protected entity authentication data
* instance from the provided MSL object.</p>
*
* @param ctx MSL context.
* @param authdataMo the authentication data MSL object.
* @throws MslEncodingException if there is an error parsing the MSL
* representation.
* @throws MslCryptoException if there is an error decrypting or verifying
* the encapsulated authentication data.
* @throws MslEntityAuthException if the encapsulated authentication data
* or signature are invalid, if the master token is invalid, or if
* the master token crypto context cannot be found in the MSL store
* and cannot be created.
*/
MasterTokenProtectedAuthenticationData(final MslContext ctx, final MslObject authdataMo) throws MslEncodingException, MslCryptoException, MslEntityAuthException {
super(EntityAuthenticationScheme.MT_PROTECTED);
this.ctx = ctx;
// Extract authentication data fields.
final byte[] ciphertext, signature;
try {
ciphertext = authdataMo.getBytes(KEY_AUTHENTICATION_DATA);
signature = authdataMo.getBytes(KEY_SIGNATURE);
final MslEncoderFactory encoder = ctx.getMslEncoderFactory();
try {
this.masterToken = new MasterToken(ctx, authdataMo.getMslObject(KEY_MASTER_TOKEN, encoder));
} catch (final MslException e) {
throw new MslEntityAuthException(MslError.ENTITYAUTH_MASTERTOKEN_INVALID, "master token protected authdata " + authdataMo, e);
}
} catch (final MslEncoderException e) {
throw new MslEncodingException(MslError.MSL_PARSE_ERROR, "master token protected authdata " + authdataMo, e);
}
// Grab master token crypto context.
final ICryptoContext cryptoContext;
try {
final ICryptoContext cachedCryptoContext = ctx.getMslStore().getCryptoContext(masterToken);
if (cachedCryptoContext != null)
cryptoContext = cachedCryptoContext;
else
cryptoContext = new SessionCryptoContext(ctx, masterToken);
} catch (final MslMasterTokenException e) {
throw new MslEntityAuthException(MslError.ENTITYAUTH_MASTERTOKEN_NOT_DECRYPTED, e);
}
// Verify and decrypt the authentication data.
try {
final MslEncoderFactory encoder = ctx.getMslEncoderFactory();
if (!cryptoContext.verify(ciphertext, signature, encoder))
throw new MslEntityAuthException(MslError.ENTITYAUTH_VERIFICATION_FAILED, "master token protected authdata " + authdataMo);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject internalAuthdataMo = encoder.parseObject(plaintext);
this.authdata = EntityAuthenticationData.create(ctx, internalAuthdataMo);
} catch (final MslEncoderException e) {
throw new MslEncodingException(MslError.MSL_PARSE_ERROR, "master token protected authdata " + authdataMo, e);
}
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#getIdentity()
*/
@Override
public String getIdentity() throws MslCryptoException {
return authdata.getIdentity();
}
/**
* Return the encapsulated entity authentication data.
*
* @return the encapsulated entity authentication data.
*/
public EntityAuthenticationData getEncapsulatedAuthdata() {
return authdata;
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#getAuthData(com.netflix.msl.io.MslEncoderFactory, com.netflix.msl.io.MslEncoderFormat)
*/
@Override
public MslObject getAuthData(final MslEncoderFactory encoder, final MslEncoderFormat format) throws MslEncoderException {
// Return any cached object.
if (objects.containsKey(format))
return objects.get(format);
// Grab master token crypto context.
final ICryptoContext cryptoContext;
try {
final ICryptoContext cachedCryptoContext = ctx.getMslStore().getCryptoContext(masterToken);
if (cachedCryptoContext != null)
cryptoContext = cachedCryptoContext;
else
cryptoContext = new SessionCryptoContext(ctx, masterToken);
} catch (final MslMasterTokenException e) {
throw new MslEncoderException("Master token is not trusted; cannot create session crypto context.", e);
}
// Encrypt and sign the authentication data.
final byte[] plaintext = authdata.toMslEncoding(encoder, format);
final byte[] ciphertext, signature;
try {
ciphertext = cryptoContext.encrypt(plaintext, encoder, format);
signature = cryptoContext.sign(ciphertext, encoder, format);
} catch (final MslCryptoException e) {
throw new MslEncoderException("Error encrypting and signing the authentication data.", e);
}
// Return the authentication data.
final MslObject mo = encoder.createObject();
mo.put(KEY_MASTER_TOKEN, masterToken);
mo.put(KEY_AUTHENTICATION_DATA, ciphertext);
mo.put(KEY_SIGNATURE, signature);
// Cache and return the object.
final byte[] encoded = encoder.encodeObject(mo, format);
final MslObject decoded = encoder.parseObject(encoded);
objects.put(format, decoded);
return decoded;
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#equals(java.lang.Object)
*/
@Override
public boolean equals(final Object obj) {
if (obj == this) return true;
if (!(obj instanceof MasterTokenProtectedAuthenticationData)) return false;
final MasterTokenProtectedAuthenticationData that = (MasterTokenProtectedAuthenticationData)obj;
return super.equals(obj) &&
this.masterToken.equals(that.masterToken) &&
this.authdata.equals(that.authdata);
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#hashCode()
*/
@Override
public int hashCode() {
return super.hashCode() ^
masterToken.hashCode() ^
authdata.hashCode();
}
/** MSL context. */
private final MslContext ctx;
/** Master token. */
private final MasterToken masterToken;
/** Entity authentication data. */
private final EntityAuthenticationData authdata;
/** Cached encoded objects. */
private final Map<MslEncoderFormat,MslObject> objects = new HashMap<MslEncoderFormat,MslObject>();
}
| 9,928 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/entityauth/UnauthenticatedSuffixedAuthenticationData.java | /**
* Copyright (c) 2015-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslObject;
/**
* <p>Unauthenticated suffixed entity authentication data. This form of
* authentication is used by entities that cannot provide any form of entity
* authentication, and wish to share a root identity across themselves. This
* scheme may also be useful in cases where multiple MSL stacks need to execute
* independently on a single entity.</p>
*
* <p>A suffixed scheme can expose an entity to cloning attacks of the root
* identity as the master token sequence number will now be tied to the
* root and suffix pair. This is probably acceptable for unauthenticated
* entities anyway as they have no credentials to provide as proof of their
* claimed identity.</p>
*
* <p>Unauthenticated suffixed entity authentication data is represented as
* {@code
* unauthenticatedauthdata = {
* "#mandatory" : [ "root", "suffix" ],
* "root" : "string",
* "suffix" : "string"
* }} where:
* <ul>
* <li>{@code root} is the entity identity root</li>
* <li>{@code suffix} is the entity identity suffix</li>
* </ul></p>
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class UnauthenticatedSuffixedAuthenticationData extends EntityAuthenticationData {
/** Key entity root. */
private static final String KEY_ROOT = "root";
/** Key entity suffix. */
private static final String KEY_SUFFIX = "suffix";
/** Identity concatenation character. */
private static final String CONCAT_CHAR = ".";
/**
* Construct a new unauthenticated suffixed entity authentication data
* instance from the specified entity identity root and suffix.
*
* @param root the entity identity root.
* @param suffix the entity identity suffix.
*/
public UnauthenticatedSuffixedAuthenticationData(final String root, final String suffix) {
super(EntityAuthenticationScheme.NONE_SUFFIXED);
this.root = root;
this.suffix = suffix;
}
/**
* Construct a new unauthenticated suffixed entity authentication data
* instance from the provided MSL object.
*
* @param unauthSuffixedAuthMo the authentication data MSL object.
* @throws MslEncodingException if there is an error parsing the MSL data.
*/
public UnauthenticatedSuffixedAuthenticationData(final MslObject unauthSuffixedAuthMo) throws MslEncodingException {
super(EntityAuthenticationScheme.NONE_SUFFIXED);
try {
root = unauthSuffixedAuthMo.getString(KEY_ROOT);
suffix = unauthSuffixedAuthMo.getString(KEY_SUFFIX);
} catch (final MslEncoderException e) {
throw new MslEncodingException(MslError.MSL_PARSE_ERROR, "unauthenticated suffixed authdata " + unauthSuffixedAuthMo, e);
}
}
/**
* <p>Returns the entity identity. This is equal to the root and suffix
* strings moined with a period, e.g. {@code root.suffix}.</p>
*
* @return the entity identity.
*/
@Override
public String getIdentity() {
return root + CONCAT_CHAR + suffix;
}
/**
* @return the entity identity root.
*/
public String getRoot() {
return root;
}
/**
* @return the entity identity suffix.
*/
public String getSuffix() {
return suffix;
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#getAuthData(com.netflix.msl.io.MslEncoderFactory, com.netflix.msl.io.MslEncoderFormat)
*/
@Override
public MslObject getAuthData(final MslEncoderFactory encoder, final MslEncoderFormat format) {
final MslObject mo = encoder.createObject();
mo.put(KEY_ROOT, root);
mo.put(KEY_SUFFIX, suffix);
return mo;
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#equals(java.lang.Object)
*/
@Override
public boolean equals(final Object obj) {
if (obj == this) return true;
if (!(obj instanceof UnauthenticatedSuffixedAuthenticationData)) return false;
final UnauthenticatedSuffixedAuthenticationData that = (UnauthenticatedSuffixedAuthenticationData)obj;
return super.equals(obj) && this.root.equals(that.root) && this.suffix.equals(that.suffix);
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#hashCode()
*/
@Override
public int hashCode() {
return super.hashCode() ^ root.hashCode() ^ suffix.hashCode();
}
/** Entity identity root. */
private final String root;
/** Entity identity suffix. */
private final String suffix;
}
| 9,929 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/entityauth/UnauthenticatedSuffixedAuthenticationFactory.java | /**
* Copyright (c) 2015-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.crypto.NullCryptoContext;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.util.AuthenticationUtils;
import com.netflix.msl.util.MslContext;
/**
* <p>Unauthenticated suffixed entity authentication factory.</p>
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class UnauthenticatedSuffixedAuthenticationFactory extends EntityAuthenticationFactory {
/**
* Construct a new unauthenticated suffixed authentication factory instance.
*
* @param authutils authentication utilities.
*/
public UnauthenticatedSuffixedAuthenticationFactory(final AuthenticationUtils authutils) {
super(EntityAuthenticationScheme.NONE_SUFFIXED);
this.authutils = authutils;
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationFactory#createData(com.netflix.msl.util.MslContext, com.netflix.msl.io.MslObject)
*/
@Override
public EntityAuthenticationData createData(final MslContext ctx, final MslObject entityAuthMo) throws MslEncodingException {
return new UnauthenticatedSuffixedAuthenticationData(entityAuthMo);
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationFactory#getCryptoContext(com.netflix.msl.util.MslContext, com.netflix.msl.entityauth.EntityAuthenticationData)
*/
@Override
public ICryptoContext getCryptoContext(final MslContext ctx, final EntityAuthenticationData authdata) throws MslEntityAuthException {
// Make sure we have the right kind of entity authentication data.
if (!(authdata instanceof UnauthenticatedSuffixedAuthenticationData))
throw new MslInternalException("Incorrect authentication data type " + authdata.getClass().getName() + ".");
final UnauthenticatedSuffixedAuthenticationData usad = (UnauthenticatedSuffixedAuthenticationData)authdata;
// Check for revocation.
final String root = usad.getRoot();
if (authutils.isEntityRevoked(root))
throw new MslEntityAuthException(MslError.ENTITY_REVOKED, "none suffixed " + root).setEntityAuthenticationData(usad);
// Verify the scheme is permitted.
if (!authutils.isSchemePermitted(root, getScheme()))
throw new MslEntityAuthException(MslError.INCORRECT_ENTITYAUTH_DATA, "Authentication Scheme for Device Type Not Supported " + root + ":" + getScheme()).setEntityAuthenticationData(usad);
// Return the crypto context.
return new NullCryptoContext();
}
/** Authentication utilities. */
final AuthenticationUtils authutils;
} | 9,930 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/entityauth/MasterTokenProtectedAuthenticationFactory.java | /**
* Copyright (c) 2015-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.util.AuthenticationUtils;
import com.netflix.msl.util.MslContext;
/**
* <p>Master token protected entity authentication factory.</p>
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class MasterTokenProtectedAuthenticationFactory extends EntityAuthenticationFactory {
/**
* <p>Construct a new master token protected entity authentication factory
* instance.</p>
*
* @param authutils authentication utilities.
*/
public MasterTokenProtectedAuthenticationFactory(final AuthenticationUtils authutils) {
super(EntityAuthenticationScheme.MT_PROTECTED);
this.authutils = authutils;
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationFactory#createData(com.netflix.msl.util.MslContext, com.netflix.msl.io.MslObject)
*/
@Override
public EntityAuthenticationData createData(final MslContext ctx, final MslObject entityAuthMo) throws MslEncodingException, MslCryptoException, MslEntityAuthException {
return new MasterTokenProtectedAuthenticationData(ctx, entityAuthMo);
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationFactory#getCryptoContext(com.netflix.msl.util.MslContext, com.netflix.msl.entityauth.EntityAuthenticationData)
*/
@Override
public ICryptoContext getCryptoContext(final MslContext ctx, final EntityAuthenticationData authdata) throws MslCryptoException, MslEntityAuthException {
// Make sure we have the right kind of entity authentication data.
if (!(authdata instanceof MasterTokenProtectedAuthenticationData))
throw new MslInternalException("Incorrect authentication data type " + authdata.getClass().getName() + ".");
final MasterTokenProtectedAuthenticationData mtpad = (MasterTokenProtectedAuthenticationData)authdata;
// Check for revocation.
final String identity = mtpad.getIdentity();
if (authutils.isEntityRevoked(identity))
throw new MslEntityAuthException(MslError.ENTITY_REVOKED, "none " + identity).setEntityAuthenticationData(mtpad);
// Verify the scheme is permitted.
if (!authutils.isSchemePermitted(identity, getScheme()))
throw new MslEntityAuthException(MslError.INCORRECT_ENTITYAUTH_DATA, "Authentication Scheme for Device Type Not Supported " + identity + ":" + getScheme()).setEntityAuthenticationData(mtpad);
// Authenticate using the encapsulated authentication data.
final EntityAuthenticationData ead = mtpad.getEncapsulatedAuthdata();
final EntityAuthenticationScheme scheme = ead.getScheme();
final EntityAuthenticationFactory factory = ctx.getEntityAuthenticationFactory(scheme);
if (factory == null)
throw new MslEntityAuthException(MslError.ENTITYAUTH_FACTORY_NOT_FOUND, scheme.name()).setEntityAuthenticationData(mtpad);
return factory.getCryptoContext(ctx, ead);
}
/** Authentication utilities. */
final AuthenticationUtils authutils;
}
| 9,931 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/entityauth/PresharedProfileAuthenticationData.java | /**
* Copyright (c) 2014-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslObject;
/**
* <p>Preshared keys profile entity authentication data.</p>
*
* <p>
* {@code {
* "#mandatory" : [ "pskid", "profile" ],
* "pskid" : "string",
* "profile" : "string",
* }} where:
* <ul>
* <li>{@code pskid} is the entity preshared keys identity</li>
* <li>{@code profile} is the entity profile</li>
* </ul></p>
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class PresharedProfileAuthenticationData extends EntityAuthenticationData {
/** Key entity preshared keys identity. */
private static final String KEY_PSKID = "pskid";
/** Key entity profile. */
private static final String KEY_PROFILE = "profile";
/** Identity concatenation character. */
private static final String CONCAT_CHAR = "-";
/**
* Construct a new preshared keys authentication data instance from the
* specified entity preshared keys identity and profile.
*
* @param pskid the entity preshared keys identity.
* @param profile the entity profile.
*/
public PresharedProfileAuthenticationData(final String pskid, final String profile) {
super(EntityAuthenticationScheme.PSK_PROFILE);
this.pskid = pskid;
this.profile = profile;
}
/**
* Construct a new preshared keys profile authentication data instance from
* the provided MSL object.
*
* @param authMo the authentication data MSL object.
* @throws MslEncodingException if there is an error parsing the entity
* authentication data.
*/
public PresharedProfileAuthenticationData(final MslObject authMo) throws MslEncodingException {
super(EntityAuthenticationScheme.PSK_PROFILE);
try {
pskid = authMo.getString(KEY_PSKID);
profile = authMo.getString(KEY_PROFILE);
} catch (final MslEncoderException e) {
throw new MslEncodingException(MslError.MSL_PARSE_ERROR, "psk profile authdata " + authMo.toString(), e);
}
}
/**
* <p>Returns the entity identity. This is equal to the preshared keys
* identity and profile strings joined with a hyphen, e.g.
* {@code pskid-profile}.</p>
*
* @return the entity identity.
*/
@Override
public String getIdentity() {
return pskid + CONCAT_CHAR + profile;
}
/**
* @return the entity preshared keys identity.
*/
public String getPresharedKeysId() {
return pskid;
}
/**
* @return the entity profile.
*/
public String getProfile() {
return profile;
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#getAuthData(com.netflix.msl.io.MslEncoderFactory, com.netflix.msl.io.MslEncoderFormat)
*/
@Override
public MslObject getAuthData(final MslEncoderFactory encoder, final MslEncoderFormat format) {
final MslObject mo = encoder.createObject();
mo.put(KEY_PSKID, pskid);
mo.put(KEY_PROFILE, profile);
return mo;
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#equals(java.lang.Object)
*/
@Override
public boolean equals(final Object obj) {
if (obj == this) return true;
if (!(obj instanceof PresharedProfileAuthenticationData)) return false;
final PresharedProfileAuthenticationData that = (PresharedProfileAuthenticationData)obj;
return super.equals(obj) && this.pskid.equals(that.pskid) && this.profile.equals(that.profile);
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationData#hashCode()
*/
@Override
public int hashCode() {
return super.hashCode() ^ pskid.hashCode() ^ profile.hashCode();
}
/** Entity preshared keys identity. */
private final String pskid;
/** Entity profile. */
private final String profile;
}
| 9,932 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/entityauth/EntityAuthenticationScheme.java | /**
* Copyright (c) 2012-2014 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
/**
* <p>Entity authentication schemes.</p>
*
* <p>The scheme name is used to uniquely identify entity authentication
* schemes.</p>
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class EntityAuthenticationScheme {
/** Map of names onto schemes. */
private static Map<String,EntityAuthenticationScheme> schemes = new HashMap<String,EntityAuthenticationScheme>();
/** Pre-shared keys. */
public static final EntityAuthenticationScheme PSK = new EntityAuthenticationScheme("PSK", true, true);
/** Pre-shared keys with entity profiles. */
public static final EntityAuthenticationScheme PSK_PROFILE = new EntityAuthenticationScheme("PSK_PROFILE", true, true);
/** X.509 public/private key pair. */
public static final EntityAuthenticationScheme X509 = new EntityAuthenticationScheme("X509", false, true);
/** RSA public/private key pair. */
public static final EntityAuthenticationScheme RSA = new EntityAuthenticationScheme("RSA", false, true);
/** ECC public/private key pair. */
public static final EntityAuthenticationScheme ECC = new EntityAuthenticationScheme("ECC", false, true);
/** Unauthenticated. */
public static final EntityAuthenticationScheme NONE = new EntityAuthenticationScheme("NONE", false, false);
/** Unauthenticated suffixed. */
public static final EntityAuthenticationScheme NONE_SUFFIXED = new EntityAuthenticationScheme("NONE_SUFFIXED", false, false);
/** Master token protected. */
public static final EntityAuthenticationScheme MT_PROTECTED = new EntityAuthenticationScheme("MT_PROTECTED", false, false);
/** Provisioned. */
public static final EntityAuthenticationScheme PROVISIONED = new EntityAuthenticationScheme("PROVISIONED", false, false);
/**
* Define an entity authentication scheme with the specified name and
* cryptographic properties.
*
* @param name the entity authentication scheme name.
* @param encrypts true if the scheme encrypts message data.
* @param protects true if the scheme protects message integrity.
*/
protected EntityAuthenticationScheme(final String name, final boolean encrypts, final boolean protects) {
this.name = name;
this.encrypts = encrypts;
this.protects = protects;
// Add this scheme to the map.
synchronized (schemes) {
schemes.put(name, this);
}
}
/**
* @param name the entity authentication scheme name.
* @return the scheme identified by the specified name or {@code null} if
* there is none.
*/
public static EntityAuthenticationScheme getScheme(final String name) {
return schemes.get(name);
}
/**
* @return all known entity authentication schemes.
*/
public static Collection<EntityAuthenticationScheme> values() {
return schemes.values();
}
/**
* @return the scheme identifier.
*/
public String name() {
return name;
}
/**
* @return true if the scheme encrypts message data.
*/
public boolean encrypts() {
return encrypts;
}
/**
* @return true if the scheme protects message integrity.
*/
public boolean protectsIntegrity() {
return protects;
}
/* (non-Javadoc)
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
return name();
}
/* (non-Javadoc)
* @see java.lang.Object#hashCode()
*/
@Override
public int hashCode() {
return name.hashCode();
}
/* (non-Javadoc)
* @see java.lang.Object#equals(java.lang.Object)
*/
@Override
public boolean equals(final Object obj) {
if (obj == this) return true;
if (!(obj instanceof EntityAuthenticationScheme)) return false;
final EntityAuthenticationScheme that = (EntityAuthenticationScheme)obj;
return this.name.equals(that.name);
}
/** Scheme name. */
private final String name;
/** Encrypts message data. */
private final boolean encrypts;
/** Protects message integrity. */
private final boolean protects;
}
| 9,933 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/entityauth/RsaAuthenticationFactory.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import java.security.PrivateKey;
import java.security.PublicKey;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.crypto.RsaCryptoContext;
import com.netflix.msl.crypto.RsaCryptoContext.Mode;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.util.AuthenticationUtils;
import com.netflix.msl.util.MslContext;
/**
* <p>RSA asymmetric keys entity authentication factory.</p>
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class RsaAuthenticationFactory extends EntityAuthenticationFactory {
/**
* <p>Construct a new RSA asymmetric keys authentication factory
* instance.</p>
*
* @param store RSA key store.
* @param authutils authentication utilities.
*/
public RsaAuthenticationFactory(final RsaStore store, final AuthenticationUtils authutils) {
this(null, store, authutils);
}
/**
* <p>Construct a new RSA asymmetric keys authentication factory instance
* with the specified key pair ID for the local entity. The RSA key store
* must contain a private key for the local entity (a public key is
* optional).</p>
*
* @param keyPairId local entity key pair ID.
* @param store RSA key store.
* @param authutils authentication utilities.
*/
public RsaAuthenticationFactory(final String keyPairId, final RsaStore store, final AuthenticationUtils authutils) {
super(EntityAuthenticationScheme.RSA);
this.keyPairId = keyPairId;
this.store = store;
this.authutils = authutils;
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationFactory#createData(com.netflix.msl.util.MslContext, com.netflix.msl.io.MslObject)
*/
@Override
public EntityAuthenticationData createData(final MslContext ctx, final MslObject entityAuthMo) throws MslEncodingException, MslCryptoException {
return new RsaAuthenticationData(entityAuthMo);
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationFactory#getCryptoContext(com.netflix.msl.util.MslContext, com.netflix.msl.entityauth.EntityAuthenticationData)
*/
@Override
public ICryptoContext getCryptoContext(final MslContext ctx, final EntityAuthenticationData authdata) throws MslEntityAuthException {
// Make sure we have the right kind of entity authentication data.
if (!(authdata instanceof RsaAuthenticationData))
throw new MslInternalException("Incorrect authentication data type " + authdata.getClass().getName() + ".");
final RsaAuthenticationData rad = (RsaAuthenticationData)authdata;
// Check for revocation.
final String identity = rad.getIdentity();
if (authutils.isEntityRevoked(identity))
throw new MslEntityAuthException(MslError.ENTITY_REVOKED, "rsa " + identity).setEntityAuthenticationData(rad);
// Verify the scheme is permitted.
if (!authutils.isSchemePermitted(identity, getScheme()))
throw new MslEntityAuthException(MslError.INCORRECT_ENTITYAUTH_DATA, "Authentication Scheme for Device Type Not Supported " + identity + ":" + getScheme()).setEntityAuthenticationData(rad);
// Extract RSA authentication data.
final String pubkeyid = rad.getPublicKeyId();
final PublicKey publicKey = store.getPublicKey(pubkeyid);
final PrivateKey privateKey = store.getPrivateKey(pubkeyid);
// The local entity must have a private key.
if (pubkeyid.equals(keyPairId) && privateKey == null)
throw new MslEntityAuthException(MslError.RSA_PRIVATEKEY_NOT_FOUND, pubkeyid).setEntityAuthenticationData(rad);
// Remote entities must have a public key.
else if (!pubkeyid.equals(keyPairId) && publicKey == null)
throw new MslEntityAuthException(MslError.RSA_PUBLICKEY_NOT_FOUND, pubkeyid).setEntityAuthenticationData(rad);
// Return the crypto context.
return new RsaCryptoContext(ctx, identity, privateKey, publicKey, Mode.SIGN_VERIFY);
}
/** Local entity key pair ID. */
private final String keyPairId;
/** RSA key store. */
private final RsaStore store;
/** Authentication utilities. */
final AuthenticationUtils authutils;
}
| 9,934 |
0 | Create_ds/msl/core/src/main/java/com/netflix/msl | Create_ds/msl/core/src/main/java/com/netflix/msl/entityauth/X509AuthenticationFactory.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.cert.CertificateExpiredException;
import java.security.cert.CertificateNotYetValidException;
import java.security.cert.X509Certificate;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.crypto.RsaCryptoContext;
import com.netflix.msl.crypto.RsaCryptoContext.Mode;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.util.AuthenticationUtils;
import com.netflix.msl.util.MslContext;
/**
* <p>X.509 asymmetric keys entity authentication factory.</p>
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class X509AuthenticationFactory extends EntityAuthenticationFactory {
/**
* Construct a new X.509 asymmetric keys authentication factory instance.
*
* @param store X.509 certificate authority store.
* @param authutils entity authentication utilities.
*/
public X509AuthenticationFactory(final X509Store store, final AuthenticationUtils authutils) {
super(EntityAuthenticationScheme.X509);
this.caStore = store;
this.authutils = authutils;
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationFactory#createData(com.netflix.msl.util.MslContext, com.netflix.msl.io.MslObject)
*/
@Override
public EntityAuthenticationData createData(final MslContext ctx, final MslObject entityAuthMo) throws MslCryptoException, MslEncodingException {
return new X509AuthenticationData(entityAuthMo);
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthenticationFactory#getCryptoContext(com.netflix.msl.util.MslContext, com.netflix.msl.entityauth.EntityAuthenticationData)
*/
@Override
public ICryptoContext getCryptoContext(final MslContext ctx, final EntityAuthenticationData authdata) throws MslCryptoException, MslEntityAuthException {
// Make sure we have the right kind of entity authentication data.
if (!(authdata instanceof X509AuthenticationData))
throw new MslInternalException("Incorrect authentication data type " + authdata.getClass().getName() + ".");
final X509AuthenticationData x509ad = (X509AuthenticationData)authdata;
// Extract X.509 authentication data.
final X509Certificate cert = x509ad.getX509Cert();
final String identity = cert.getSubjectX500Principal().getName();
final PublicKey publicKey = cert.getPublicKey();
// Check for revocation.
if (authutils.isEntityRevoked(identity))
throw new MslEntityAuthException(MslError.ENTITY_REVOKED, cert.toString()).setEntityAuthenticationData(x509ad);
// Verify the scheme is permitted.
if (!authutils.isSchemePermitted(identity, getScheme()))
throw new MslEntityAuthException(MslError.INCORRECT_ENTITYAUTH_DATA, "Authentication Scheme for Device Type Not Supported " + identity + ":" + getScheme()).setEntityAuthenticationData(x509ad);
// Verify entity certificate.
try {
if (!caStore.isAccepted(cert))
throw new MslEntityAuthException(MslError.X509CERT_VERIFICATION_FAILED, cert.toString()).setEntityAuthenticationData(x509ad);
} catch (final CertificateExpiredException e) {
throw new MslEntityAuthException(MslError.X509CERT_EXPIRED, cert.toString(), e).setEntityAuthenticationData(x509ad);
} catch (final CertificateNotYetValidException e) {
throw new MslEntityAuthException(MslError.X509CERT_NOT_YET_VALID, cert.toString(), e).setEntityAuthenticationData(x509ad);
}
// Grab the optional private key.
final PrivateKey privkey = caStore.getPrivateKey(cert);
// Return the crypto context.
return new RsaCryptoContext(ctx, identity, privkey, publicKey, Mode.SIGN_VERIFY);
}
/** X.509 CA store. */
private final X509Store caStore;
/** Entity authentication utilities. */
private final AuthenticationUtils authutils;
}
| 9,935 |
0 | Create_ds/msl/tests/src/test/java/com/netflix | Create_ds/msl/tests/src/test/java/com/netflix/msl/MslExceptionTest.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import org.junit.Before;
import org.junit.Test;
import com.netflix.msl.entityauth.EntityAuthenticationData;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.tokens.MasterToken;
import com.netflix.msl.tokens.UserIdToken;
import com.netflix.msl.userauth.EmailPasswordAuthenticationData;
import com.netflix.msl.userauth.MockEmailPasswordAuthenticationFactory;
import com.netflix.msl.userauth.UserAuthenticationData;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* MslException unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class MslExceptionTest {
/**
* @return dummy user authentication data.
*/
private static UserAuthenticationData getUserAuthenticationData() {
return new EmailPasswordAuthenticationData("email", "password");
}
/** MSL context. */
private MslContext ctx;
@Before
public void setup() throws MslEncodingException, MslCryptoException {
ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
}
@Test
public void error() {
final MslException e = new MslException(MslError.MSL_PARSE_ERROR);
assertEquals(MslError.MSL_PARSE_ERROR, e.getError());
assertEquals(MslError.MSL_PARSE_ERROR.getMessage(), e.getMessage());
}
@Test
public void errorDetails() {
final MslException e = new MslException(MslError.MSL_ENCODE_ERROR, "details");
assertEquals(MslError.MSL_ENCODE_ERROR, e.getError());
assertEquals(MslError.MSL_ENCODE_ERROR.getMessage() + " [details]", e.getMessage());
}
@Test
public void errorDetailsCause() {
final MslException e = new MslException(MslError.ENCRYPT_ERROR, "details", new RuntimeException("cause"));
assertEquals(MslError.ENCRYPT_ERROR, e.getError());
assertEquals(MslError.ENCRYPT_ERROR.getMessage() + " [details]", e.getMessage());
final Throwable cause = e.getCause();
assertTrue(cause instanceof RuntimeException);
assertEquals("cause", cause.getMessage());
}
@Test
public void errorCause() {
final MslException e = new MslException(MslError.DECRYPT_ERROR, new RuntimeException("cause"));
assertEquals(MslError.DECRYPT_ERROR, e.getError());
assertEquals(MslError.DECRYPT_ERROR.getMessage(), e.getMessage());
final Throwable cause = e.getCause();
assertTrue(cause instanceof RuntimeException);
assertEquals("cause", cause.getMessage());
}
@Test
public void setEntityMasterToken() throws MslEncodingException, MslCryptoException {
final MslException e = new MslException(MslError.MSL_PARSE_ERROR);
assertNull(e.getMasterToken());
assertNull(e.getEntityAuthenticationData());
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
e.setMasterToken(masterToken);
e.setEntityAuthenticationData(ctx.getEntityAuthenticationData(null));
assertEquals(masterToken, e.getMasterToken());
assertNull(e.getEntityAuthenticationData());
}
@Test
public void setEntityEntityAuthData() {
final MslException e = new MslException(MslError.MSL_PARSE_ERROR);
assertNull(e.getMasterToken());
assertNull(e.getEntityAuthenticationData());
final EntityAuthenticationData entityAuthData = ctx.getEntityAuthenticationData(null);
e.setEntityAuthenticationData(entityAuthData);
assertNull(e.getMasterToken());
assertEquals(entityAuthData, e.getEntityAuthenticationData());
}
@Test
public void setUserUserIdToken() throws MslEncodingException, MslCryptoException {
final MslException e = new MslException(MslError.MSL_PARSE_ERROR);
assertNull(e.getUserIdToken());
assertNull(e.getUserAuthenticationData());
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(ctx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
final UserAuthenticationData userAuthData = getUserAuthenticationData();
e.setUserIdToken(userIdToken);
e.setUserAuthenticationData(userAuthData);
assertEquals(userIdToken, e.getUserIdToken());
assertNull(e.getUserAuthenticationData());
}
@Test
public void setUserUserAuthData() {
final MslException e = new MslException(MslError.MSL_PARSE_ERROR);
assertNull(e.getUserIdToken());
assertNull(e.getUserAuthenticationData());
final UserAuthenticationData userAuthData = getUserAuthenticationData();
e.setUserAuthenticationData(userAuthData);
assertNull(e.getUserIdToken());
assertEquals(userAuthData, e.getUserAuthenticationData());
}
@Test
public void setMessageId() {
final MslException e = new MslException(MslError.MSL_PARSE_ERROR);
assertNull(e.getMessageId());
e.setMessageId(1);
assertEquals(Long.valueOf(1), e.getMessageId());
}
@Test(expected = IllegalArgumentException.class)
public void negativeMessageId() {
final MslException e = new MslException(MslError.MSL_PARSE_ERROR);
e.setMessageId(-1);
}
@Test(expected = IllegalArgumentException.class)
public void tooLargeMessageId() {
final MslException e = new MslException(MslError.MSL_PARSE_ERROR);
e.setMessageId(MslConstants.MAX_LONG_VALUE + 1);
}
} | 9,936 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/crypto/JsonWebKeyTest.java | /**
* Copyright (c) 2013-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.crypto;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.math.BigInteger;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.Security;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.json.JSONArray;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.crypto.JsonWebKey.Algorithm;
import com.netflix.msl.crypto.JsonWebKey.KeyOp;
import com.netflix.msl.crypto.JsonWebKey.Type;
import com.netflix.msl.crypto.JsonWebKey.Usage;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.io.MslArray;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* JSON web key unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class JsonWebKeyTest {
/** JSON key key type. */
private static final String KEY_TYPE = "kty";
/** JSON key usage. */
private static final String KEY_USAGE = "use";
/** JSON key key operations. */
private static final String KEY_KEY_OPS = "key_ops";
/** JSON key algorithm. */
private static final String KEY_ALGORITHM = "alg";
/** JSON key extractable. */
private static final String KEY_EXTRACTABLE = "extractable";
/** JSON key key ID. */
private static final String KEY_KEY_ID = "kid";
// RSA keys.
/** JSON key modulus. */
private static final String KEY_MODULUS = "n";
/** JSON key public exponent. */
private static final String KEY_PUBLIC_EXPONENT = "e";
/** JSON key private exponent. */
private static final String KEY_PRIVATE_EXPONENT = "d";
// Symmetric keys.
/** JSON key key. */
private static final String KEY_KEY = "k";
// Key operations.
/** Encrypt/decrypt key operations. */
private static final Set<KeyOp> ENCRYPT_DECRYPT = new HashSet<KeyOp>(Arrays.asList(KeyOp.encrypt, KeyOp.decrypt));
/** Wrap/unwrap key operations. */
private static final Set<KeyOp> WRAP_UNWRAP = new HashSet<KeyOp>(Arrays.asList(KeyOp.wrapKey, KeyOp.unwrapKey));
/** Sign/verify key operations. */
private static final Set<KeyOp> SIGN_VERIFY = new HashSet<KeyOp>(Arrays.asList(KeyOp.sign, KeyOp.verify));
// Expected key operations MSL arrays.
/** Sign/verify. */
private static final MslArray MA_SIGN_VERIFY = new MslArray(Arrays.asList(KeyOp.sign.name(), KeyOp.verify.name()).toArray());
/** Encrypt/decrypt. */
private static final MslArray MA_ENCRYPT_DECRYPT = new MslArray(Arrays.asList(KeyOp.encrypt.name(), KeyOp.verify.name()).toArray());
/** Wrap/unwrap. */
private static final MslArray MA_WRAP_UNWRAP = new MslArray(Arrays.asList(KeyOp.wrapKey.name(), KeyOp.unwrapKey.name()).toArray());
/** Null usage. */
private static final Usage NULL_USAGE = null;
/** Null key operations. */
private static final Set<KeyOp> NULL_KEYOPS = null;
/**
* Returns the big integer in big-endian format without any leading sign
* bits.
*
* @param bi the big integer.
* @return the big integer in big-endian form.
*/
private static byte[] bi2bytes(final BigInteger bi) {
final byte[] bib = bi.toByteArray();
final int len = (int)Math.ceil((double)bi.bitLength() / Byte.SIZE);
return Arrays.copyOfRange(bib, bib.length - len, bib.length);
}
private static final boolean EXTRACTABLE = true;
private static final String KEY_ID = "kid";
private static RSAPublicKey PUBLIC_KEY;
private static RSAPrivateKey PRIVATE_KEY;
private static SecretKey SECRET_KEY;
private static final Random random = new Random();
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
/** Encoder format. */
private static MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@BeforeClass
public static void setup() throws NoSuchAlgorithmException, MslEncodingException, MslCryptoException {
Security.addProvider(new BouncyCastleProvider());
final MslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = ctx.getMslEncoderFactory();
final KeyPairGenerator keypairGenerator = KeyPairGenerator.getInstance("RSA");
keypairGenerator.initialize(512);
final KeyPair keypair = keypairGenerator.generateKeyPair();
PRIVATE_KEY = (RSAPrivateKey)keypair.getPrivate();
PUBLIC_KEY = (RSAPublicKey)keypair.getPublic();
final byte[] keydata = new byte[16];
random.nextBytes(keydata);
SECRET_KEY = new SecretKeySpec(keydata, JcaAlgorithm.AES);
}
@AfterClass
public static void teardown() {
encoder = null;
}
@Test
public void rsaUsageCtor() throws MslCryptoException, MslEncodingException, MslEncoderException {
final JsonWebKey jwk = new JsonWebKey(Usage.sig, Algorithm.RSA1_5, EXTRACTABLE, KEY_ID, PUBLIC_KEY, PRIVATE_KEY);
assertEquals(EXTRACTABLE, jwk.isExtractable());
assertEquals(Algorithm.RSA1_5, jwk.getAlgorithm());
assertEquals(KEY_ID, jwk.getId());
final KeyPair keypair = jwk.getRsaKeyPair();
assertNotNull(keypair);
final RSAPublicKey pubkey = (RSAPublicKey)keypair.getPublic();
assertEquals(PUBLIC_KEY.getModulus(), pubkey.getModulus());
assertEquals(PUBLIC_KEY.getPublicExponent(), pubkey.getPublicExponent());
final RSAPrivateKey privkey = (RSAPrivateKey)keypair.getPrivate();
assertEquals(PRIVATE_KEY.getModulus(), privkey.getModulus());
assertEquals(PRIVATE_KEY.getPrivateExponent(), privkey.getPrivateExponent());
assertNull(jwk.getSecretKey());
assertEquals(Type.rsa, jwk.getType());
assertEquals(Usage.sig, jwk.getUsage());
assertNull(jwk.getKeyOps());
final byte[] encode = jwk.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final JsonWebKey moJwk = new JsonWebKey(encoder.parseObject(encode));
assertEquals(jwk.isExtractable(), moJwk.isExtractable());
assertEquals(jwk.getAlgorithm(), moJwk.getAlgorithm());
assertEquals(jwk.getId(), moJwk.getId());
final KeyPair moKeypair = moJwk.getRsaKeyPair();
assertNotNull(moKeypair);
final RSAPublicKey moPubkey = (RSAPublicKey)moKeypair.getPublic();
assertEquals(pubkey.getModulus(), moPubkey.getModulus());
assertEquals(pubkey.getPublicExponent(), moPubkey.getPublicExponent());
final RSAPrivateKey moPrivkey = (RSAPrivateKey)moKeypair.getPrivate();
assertEquals(privkey.getModulus(), moPrivkey.getModulus());
assertEquals(privkey.getPrivateExponent(), moPrivkey.getPrivateExponent());
assertNull(moJwk.getSecretKey());
assertEquals(jwk.getType(), moJwk.getType());
assertEquals(jwk.getUsage(), moJwk.getUsage());
assertEquals(jwk.getKeyOps(), moJwk.getKeyOps());
final byte[] moEncode = moJwk.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void rsaKeyOpsCtor() throws MslCryptoException, MslEncodingException, MslEncoderException {
final JsonWebKey jwk = new JsonWebKey(SIGN_VERIFY, Algorithm.RSA1_5, EXTRACTABLE, KEY_ID, PUBLIC_KEY, PRIVATE_KEY);
assertEquals(EXTRACTABLE, jwk.isExtractable());
assertEquals(Algorithm.RSA1_5, jwk.getAlgorithm());
assertEquals(KEY_ID, jwk.getId());
final KeyPair keypair = jwk.getRsaKeyPair();
assertNotNull(keypair);
final RSAPublicKey pubkey = (RSAPublicKey)keypair.getPublic();
assertEquals(PUBLIC_KEY.getModulus(), pubkey.getModulus());
assertEquals(PUBLIC_KEY.getPublicExponent(), pubkey.getPublicExponent());
final RSAPrivateKey privkey = (RSAPrivateKey)keypair.getPrivate();
assertEquals(PRIVATE_KEY.getModulus(), privkey.getModulus());
assertEquals(PRIVATE_KEY.getPrivateExponent(), privkey.getPrivateExponent());
assertNull(jwk.getSecretKey());
assertEquals(Type.rsa, jwk.getType());
assertNull(jwk.getUsage());
assertEquals(SIGN_VERIFY, jwk.getKeyOps());
final byte[] encode = jwk.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final JsonWebKey moJwk = new JsonWebKey(encoder.parseObject(encode));
assertEquals(jwk.isExtractable(), moJwk.isExtractable());
assertEquals(jwk.getAlgorithm(), moJwk.getAlgorithm());
assertEquals(jwk.getId(), moJwk.getId());
final KeyPair moKeypair = moJwk.getRsaKeyPair();
assertNotNull(moKeypair);
final RSAPublicKey moPubkey = (RSAPublicKey)moKeypair.getPublic();
assertEquals(pubkey.getModulus(), moPubkey.getModulus());
assertEquals(pubkey.getPublicExponent(), moPubkey.getPublicExponent());
final RSAPrivateKey moPrivkey = (RSAPrivateKey)moKeypair.getPrivate();
assertEquals(privkey.getModulus(), moPrivkey.getModulus());
assertEquals(privkey.getPrivateExponent(), moPrivkey.getPrivateExponent());
assertNull(moJwk.getSecretKey());
assertEquals(jwk.getType(), moJwk.getType());
assertEquals(jwk.getUsage(), moJwk.getUsage());
assertEquals(jwk.getKeyOps(), moJwk.getKeyOps());
final byte[] moEncode = moJwk.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
// This test will not always pass since the key operations are
// unordered.
//assertArrayEquals(encode, moEncode);
}
@Test
public void rsaUsageJson() throws MslEncoderException {
final JsonWebKey jwk = new JsonWebKey(Usage.sig, Algorithm.RSA1_5, EXTRACTABLE, KEY_ID, PUBLIC_KEY, PRIVATE_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, jwk);
assertEquals(EXTRACTABLE, mo.optBoolean(KEY_EXTRACTABLE));
assertEquals(Algorithm.RSA1_5.name(), mo.getString(KEY_ALGORITHM));
assertEquals(KEY_ID, mo.getString(KEY_KEY_ID));
assertEquals(Type.rsa.name(), mo.getString(KEY_TYPE));
assertEquals(Usage.sig.name(), mo.getString(KEY_USAGE));
assertFalse(mo.has(KEY_KEY_OPS));
final String modulus = MslEncoderUtils.b64urlEncode(bi2bytes(PUBLIC_KEY.getModulus()));
final String pubexp = MslEncoderUtils.b64urlEncode(bi2bytes(PUBLIC_KEY.getPublicExponent()));
final String privexp = MslEncoderUtils.b64urlEncode(bi2bytes(PRIVATE_KEY.getPrivateExponent()));
assertEquals(modulus, mo.getString(KEY_MODULUS));
assertEquals(pubexp, mo.getString(KEY_PUBLIC_EXPONENT));
assertEquals(privexp, mo.getString(KEY_PRIVATE_EXPONENT));
assertFalse(mo.has(KEY_KEY));
}
@Test
public void rsaKeyOpsJson() throws MslEncoderException {
final JsonWebKey jwk = new JsonWebKey(SIGN_VERIFY, Algorithm.RSA1_5, EXTRACTABLE, KEY_ID, PUBLIC_KEY, PRIVATE_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, jwk);
assertEquals(EXTRACTABLE, mo.optBoolean(KEY_EXTRACTABLE));
assertEquals(Algorithm.RSA1_5.name(), mo.getString(KEY_ALGORITHM));
assertEquals(KEY_ID, mo.getString(KEY_KEY_ID));
assertEquals(Type.rsa.name(), mo.getString(KEY_TYPE));
assertFalse(mo.has(KEY_USAGE));
assertTrue(MslEncoderUtils.equalSets(MA_SIGN_VERIFY, mo.getMslArray(KEY_KEY_OPS)));
final String modulus = MslEncoderUtils.b64urlEncode(bi2bytes(PUBLIC_KEY.getModulus()));
final String pubexp = MslEncoderUtils.b64urlEncode(bi2bytes(PUBLIC_KEY.getPublicExponent()));
final String privexp = MslEncoderUtils.b64urlEncode(bi2bytes(PRIVATE_KEY.getPrivateExponent()));
assertEquals(modulus, mo.getString(KEY_MODULUS));
assertEquals(pubexp, mo.getString(KEY_PUBLIC_EXPONENT));
assertEquals(privexp, mo.getString(KEY_PRIVATE_EXPONENT));
assertFalse(mo.has(KEY_KEY));
}
@Test
public void rsaNullCtorPublic() throws MslCryptoException, MslEncodingException, MslEncoderException {
final JsonWebKey jwk = new JsonWebKey(NULL_USAGE, null, false, null, PUBLIC_KEY, null);
assertFalse(jwk.isExtractable());
assertNull(jwk.getAlgorithm());
assertNull(jwk.getId());
final KeyPair keypair = jwk.getRsaKeyPair();
assertNotNull(keypair);
final RSAPublicKey pubkey = (RSAPublicKey)keypair.getPublic();
assertEquals(PUBLIC_KEY.getModulus(), pubkey.getModulus());
assertEquals(PUBLIC_KEY.getPublicExponent(), pubkey.getPublicExponent());
final RSAPrivateKey privkey = (RSAPrivateKey)keypair.getPrivate();
assertNull(privkey);
assertNull(jwk.getSecretKey());
assertEquals(Type.rsa, jwk.getType());
assertNull(jwk.getUsage());
assertNull(jwk.getKeyOps());
final byte[] encode = jwk.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final JsonWebKey moJwk = new JsonWebKey(encoder.parseObject(encode));
assertEquals(jwk.isExtractable(), moJwk.isExtractable());
assertEquals(jwk.getAlgorithm(), moJwk.getAlgorithm());
assertEquals(jwk.getId(), moJwk.getId());
final KeyPair moKeypair = moJwk.getRsaKeyPair();
assertNotNull(moKeypair);
final RSAPublicKey moPubkey = (RSAPublicKey)moKeypair.getPublic();
assertEquals(pubkey.getModulus(), moPubkey.getModulus());
assertEquals(pubkey.getPublicExponent(), moPubkey.getPublicExponent());
final RSAPrivateKey moPrivkey = (RSAPrivateKey)moKeypair.getPrivate();
assertNull(moPrivkey);
assertNull(moJwk.getSecretKey());
assertEquals(jwk.getType(), moJwk.getType());
assertEquals(jwk.getUsage(), moJwk.getUsage());
assertEquals(jwk.getKeyOps(), moJwk.getKeyOps());
final byte[] moEncode = moJwk.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void rsaNullCtorPrivate() throws MslCryptoException, MslEncodingException, MslEncoderException {
final JsonWebKey jwk = new JsonWebKey(NULL_USAGE, null, false, null, null, PRIVATE_KEY);
assertFalse(jwk.isExtractable());
assertNull(jwk.getAlgorithm());
assertNull(jwk.getId());
final KeyPair keypair = jwk.getRsaKeyPair();
assertNotNull(keypair);
final RSAPublicKey pubkey = (RSAPublicKey)keypair.getPublic();
assertNull(pubkey);
final RSAPrivateKey privkey = (RSAPrivateKey)keypair.getPrivate();
assertEquals(PRIVATE_KEY.getModulus(), privkey.getModulus());
assertEquals(PRIVATE_KEY.getPrivateExponent(), privkey.getPrivateExponent());
assertNull(jwk.getSecretKey());
assertEquals(Type.rsa, jwk.getType());
assertNull(jwk.getUsage());
assertNull(jwk.getKeyOps());
final byte[] encode = jwk.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final JsonWebKey moJwk = new JsonWebKey(encoder.parseObject(encode));
assertEquals(jwk.isExtractable(), moJwk.isExtractable());
assertEquals(jwk.getAlgorithm(), moJwk.getAlgorithm());
assertEquals(jwk.getId(), moJwk.getId());
final KeyPair moKeypair = moJwk.getRsaKeyPair();
assertNotNull(moKeypair);
final RSAPublicKey moPubkey = (RSAPublicKey)moKeypair.getPublic();
assertNull(moPubkey);
final RSAPrivateKey moPrivkey = (RSAPrivateKey)moKeypair.getPrivate();
assertEquals(privkey.getModulus(), moPrivkey.getModulus());
assertEquals(privkey.getPrivateExponent(), moPrivkey.getPrivateExponent());
assertNull(moJwk.getSecretKey());
assertEquals(jwk.getType(), moJwk.getType());
assertEquals(jwk.getUsage(), moJwk.getUsage());
assertEquals(jwk.getKeyOps(), moJwk.getKeyOps());
final byte[] moEncode = moJwk.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void rsaNullJsonPublic() throws MslEncoderException {
final JsonWebKey jwk = new JsonWebKey(NULL_USAGE, null, false, null, PUBLIC_KEY, null);
final byte[] encode = jwk.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
assertFalse(mo.getBoolean(KEY_EXTRACTABLE));
assertFalse(mo.has(KEY_ALGORITHM));
assertFalse(mo.has(KEY_KEY_ID));
assertEquals(Type.rsa.name(), mo.getString(KEY_TYPE));
assertFalse(mo.has(KEY_USAGE));
assertFalse(mo.has(KEY_KEY_OPS));
final String modulus = MslEncoderUtils.b64urlEncode(bi2bytes(PUBLIC_KEY.getModulus()));
final String pubexp = MslEncoderUtils.b64urlEncode(bi2bytes(PUBLIC_KEY.getPublicExponent()));
assertEquals(modulus, mo.getString(KEY_MODULUS));
assertEquals(pubexp, mo.getString(KEY_PUBLIC_EXPONENT));
assertFalse(mo.has(KEY_PRIVATE_EXPONENT));
assertFalse(mo.has(KEY_KEY));
}
@Test
public void rsaNullJsonPrivate() throws MslEncoderException {
final JsonWebKey jwk = new JsonWebKey(NULL_USAGE, null, false, null, null, PRIVATE_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, jwk);
assertFalse(mo.getBoolean(KEY_EXTRACTABLE));
assertFalse(mo.has(KEY_ALGORITHM));
assertFalse(mo.has(KEY_KEY_ID));
assertEquals(Type.rsa.name(), mo.getString(KEY_TYPE));
assertFalse(mo.has(KEY_USAGE));
assertFalse(mo.has(KEY_KEY_OPS));
final String modulus = MslEncoderUtils.b64urlEncode(bi2bytes(PUBLIC_KEY.getModulus()));
final String privexp = MslEncoderUtils.b64urlEncode(bi2bytes(PRIVATE_KEY.getPrivateExponent()));
assertEquals(modulus, mo.getString(KEY_MODULUS));
assertFalse(mo.has(KEY_PUBLIC_EXPONENT));
assertEquals(privexp, mo.getString(KEY_PRIVATE_EXPONENT));
assertFalse(mo.has(KEY_KEY));
}
@Test(expected = MslInternalException.class)
public void rsaCtorNullKeys() {
new JsonWebKey(NULL_USAGE, null, false, null, null, null);
}
@Test(expected = MslInternalException.class)
public void rsaCtorMismatchedAlgorithm() {
new JsonWebKey(NULL_USAGE, Algorithm.A128CBC, false, null, PUBLIC_KEY, PRIVATE_KEY);
}
@Test
public void octUsageCtor() throws MslCryptoException, MslEncodingException, MslEncoderException {
final JsonWebKey jwk = new JsonWebKey(Usage.enc, Algorithm.A128CBC, EXTRACTABLE, KEY_ID, SECRET_KEY);
assertEquals(EXTRACTABLE, jwk.isExtractable());
assertEquals(Algorithm.A128CBC, jwk.getAlgorithm());
assertEquals(KEY_ID, jwk.getId());
assertNull(jwk.getRsaKeyPair());
assertArrayEquals(SECRET_KEY.getEncoded(), jwk.getSecretKey().getEncoded());
assertEquals(Type.oct, jwk.getType());
assertEquals(Usage.enc, jwk.getUsage());
assertNull(jwk.getKeyOps());
final byte[] encode = jwk.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final JsonWebKey moJwk = new JsonWebKey(encoder.parseObject(encode));
assertEquals(jwk.isExtractable(), moJwk.isExtractable());
assertEquals(jwk.getAlgorithm(), moJwk.getAlgorithm());
assertEquals(jwk.getId(), moJwk.getId());
assertNull(moJwk.getRsaKeyPair());
assertArrayEquals(jwk.getSecretKey().getEncoded(), moJwk.getSecretKey().getEncoded());
assertEquals(jwk.getType(), moJwk.getType());
assertEquals(jwk.getUsage(), moJwk.getUsage());
assertEquals(jwk.getKeyOps(), moJwk.getKeyOps());
final byte[] moEncode = moJwk.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void octKeyOpsCtor() throws MslCryptoException, MslEncodingException, MslEncoderException {
final JsonWebKey jwk = new JsonWebKey(ENCRYPT_DECRYPT, Algorithm.A128CBC, EXTRACTABLE, KEY_ID, SECRET_KEY);
assertEquals(EXTRACTABLE, jwk.isExtractable());
assertEquals(Algorithm.A128CBC, jwk.getAlgorithm());
assertEquals(KEY_ID, jwk.getId());
assertNull(jwk.getRsaKeyPair());
assertArrayEquals(SECRET_KEY.getEncoded(), jwk.getSecretKey().getEncoded());
assertEquals(Type.oct, jwk.getType());
assertNull(jwk.getUsage());
assertEquals(ENCRYPT_DECRYPT, jwk.getKeyOps());
final byte[] encode = jwk.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final JsonWebKey moJwk = new JsonWebKey(encoder.parseObject(encode));
assertEquals(jwk.isExtractable(), moJwk.isExtractable());
assertEquals(jwk.getAlgorithm(), moJwk.getAlgorithm());
assertEquals(jwk.getId(), moJwk.getId());
assertNull(moJwk.getRsaKeyPair());
assertArrayEquals(jwk.getSecretKey().getEncoded(), moJwk.getSecretKey().getEncoded());
assertEquals(jwk.getType(), moJwk.getType());
assertEquals(jwk.getUsage(), moJwk.getUsage());
assertEquals(jwk.getKeyOps(), moJwk.getKeyOps());
final byte[] moEncode = moJwk.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
// This test will not always pass since the key operations are
// unordered.
//assertArrayEquals(encode, moEncode);
}
@Test
public void octUsageJson() throws MslEncoderException {
final JsonWebKey jwk = new JsonWebKey(Usage.wrap, Algorithm.A128KW, EXTRACTABLE, KEY_ID, SECRET_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, jwk);
assertEquals(EXTRACTABLE, mo.optBoolean(KEY_EXTRACTABLE));
assertEquals(Algorithm.A128KW.name(), mo.getString(KEY_ALGORITHM));
assertEquals(KEY_ID, mo.getString(KEY_KEY_ID));
assertEquals(Type.oct.name(), mo.getString(KEY_TYPE));
assertEquals(Usage.wrap.name(), mo.getString(KEY_USAGE));
assertFalse(mo.has(KEY_KEY_OPS));
assertFalse(mo.has(KEY_MODULUS));
assertFalse(mo.has(KEY_PUBLIC_EXPONENT));
assertFalse(mo.has(KEY_PRIVATE_EXPONENT));
final String key = MslEncoderUtils.b64urlEncode(SECRET_KEY.getEncoded());
assertEquals(key, mo.getString(KEY_KEY));
}
@Test
public void octKeyOpsJson() throws MslEncoderException {
final JsonWebKey jwk = new JsonWebKey(WRAP_UNWRAP, Algorithm.A128KW, EXTRACTABLE, KEY_ID, SECRET_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, jwk);
assertEquals(EXTRACTABLE, mo.optBoolean(KEY_EXTRACTABLE));
assertEquals(Algorithm.A128KW.name(), mo.getString(KEY_ALGORITHM));
assertEquals(KEY_ID, mo.getString(KEY_KEY_ID));
assertEquals(Type.oct.name(), mo.getString(KEY_TYPE));
assertFalse(mo.has(KEY_USAGE));
assertTrue(MslEncoderUtils.equalSets(MA_WRAP_UNWRAP, mo.getMslArray(KEY_KEY_OPS)));
assertFalse(mo.has(KEY_MODULUS));
assertFalse(mo.has(KEY_PUBLIC_EXPONENT));
assertFalse(mo.has(KEY_PRIVATE_EXPONENT));
final String key = MslEncoderUtils.b64urlEncode(SECRET_KEY.getEncoded());
assertEquals(key, mo.getString(KEY_KEY));
}
@Test
public void octNullCtor() throws MslCryptoException, MslEncodingException, MslEncoderException {
final JsonWebKey jwk = new JsonWebKey(NULL_USAGE, null, false, null, SECRET_KEY);
assertFalse(jwk.isExtractable());
assertNull(jwk.getAlgorithm());
assertNull(jwk.getId());
assertNull(jwk.getRsaKeyPair());
assertArrayEquals(SECRET_KEY.getEncoded(), jwk.getSecretKey().getEncoded());
assertEquals(Type.oct, jwk.getType());
assertNull(jwk.getUsage());
assertNull(jwk.getKeyOps());
final byte[] encode = jwk.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final JsonWebKey moJwk = new JsonWebKey(encoder.parseObject(encode));
assertEquals(jwk.isExtractable(), moJwk.isExtractable());
assertEquals(jwk.getAlgorithm(), moJwk.getAlgorithm());
assertEquals(jwk.getId(), moJwk.getId());
assertNull(moJwk.getRsaKeyPair());
assertArrayEquals(jwk.getSecretKey(SECRET_KEY.getAlgorithm()).getEncoded(), moJwk.getSecretKey(SECRET_KEY.getAlgorithm()).getEncoded());
assertEquals(jwk.getType(), moJwk.getType());
assertEquals(jwk.getUsage(), moJwk.getUsage());
assertEquals(jwk.getKeyOps(), moJwk.getKeyOps());
final byte[] moEncode = moJwk.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void octNullJson() throws MslEncoderException {
final JsonWebKey jwk = new JsonWebKey(NULL_USAGE, null, false, null, SECRET_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, jwk);
assertFalse(mo.getBoolean(KEY_EXTRACTABLE));
assertFalse(mo.has(KEY_ALGORITHM));
assertFalse(mo.has(KEY_KEY_ID));
assertEquals(Type.oct.name(), mo.getString(KEY_TYPE));
assertFalse(mo.has(KEY_USAGE));
assertFalse(mo.has(KEY_KEY_OPS));
assertFalse(mo.has(KEY_MODULUS));
assertFalse(mo.has(KEY_PUBLIC_EXPONENT));
assertFalse(mo.has(KEY_PRIVATE_EXPONENT));
final String key = MslEncoderUtils.b64urlEncode(SECRET_KEY.getEncoded());
assertEquals(key, mo.getString(KEY_KEY));
}
public void usageOnly() throws MslEncoderException, MslCryptoException, MslEncodingException {
final JsonWebKey jwk = new JsonWebKey(NULL_USAGE, null, false, null, SECRET_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, jwk);
mo.put(KEY_USAGE, Usage.enc.name());
final JsonWebKey moJwk = new JsonWebKey(mo);
assertEquals(Usage.enc, moJwk.getUsage());
assertNull(moJwk.getKeyOps());
}
public void keyOpsOnly() throws MslEncoderException, MslCryptoException, MslEncodingException {
final JsonWebKey jwk = new JsonWebKey(NULL_KEYOPS, null, false, null, SECRET_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, jwk);
mo.put(KEY_KEY_OPS, MA_ENCRYPT_DECRYPT);
final JsonWebKey moJwk = new JsonWebKey(mo);
assertNull(moJwk.getUsage());
assertEquals(new HashSet<KeyOp>(Arrays.asList(KeyOp.encrypt, KeyOp.decrypt)), moJwk.getKeyOps());
}
@Test(expected = MslInternalException.class)
public void octCtorMismatchedAlgo() {
new JsonWebKey(NULL_USAGE, Algorithm.RSA1_5, false, null, SECRET_KEY);
}
@Test
public void missingType() throws MslEncoderException, MslCryptoException, MslEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final JsonWebKey jwk = new JsonWebKey(NULL_USAGE, null, false, null, SECRET_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, jwk);
mo.remove(KEY_TYPE);
new JsonWebKey(mo);
}
@Test
public void invalidType() throws MslCryptoException, MslEncodingException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNIDENTIFIED_JWK_TYPE);
final JsonWebKey jwk = new JsonWebKey(NULL_USAGE, null, false, null, SECRET_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, jwk);
mo.put(KEY_TYPE, "x");
new JsonWebKey(mo);
}
@Test
public void invalidUsage() throws MslCryptoException, MslEncodingException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNIDENTIFIED_JWK_USAGE);
final JsonWebKey jwk = new JsonWebKey(NULL_USAGE, null, false, null, SECRET_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, jwk);
mo.put(KEY_USAGE, "x");
new JsonWebKey(mo);
}
@Test
public void invalidKeyOp() throws MslEncoderException, MslCryptoException, MslEncodingException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNIDENTIFIED_JWK_KEYOP);
final JsonWebKey jwk = new JsonWebKey(NULL_KEYOPS, null, false, null, SECRET_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, jwk);
mo.put(KEY_KEY_OPS, new JSONArray(Arrays.asList(KeyOp.encrypt.name(), "x", KeyOp.decrypt.name()).toArray()));
new JsonWebKey(mo);
}
@Test
public void invalidAlgorithm() throws MslCryptoException, MslEncodingException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNIDENTIFIED_JWK_ALGORITHM);
final JsonWebKey jwk = new JsonWebKey(NULL_USAGE, null, false, null, SECRET_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, jwk);
mo.put(KEY_ALGORITHM, "x");
new JsonWebKey(mo);
}
@Test
public void missingExtractable() throws MslEncoderException, MslCryptoException, MslEncodingException {
final JsonWebKey jwk = new JsonWebKey(NULL_USAGE, null, false, null, SECRET_KEY);
final byte[] encode = jwk.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
assertNotNull(mo.remove(KEY_EXTRACTABLE));
final JsonWebKey moJwk = new JsonWebKey(mo);
assertEquals(jwk.isExtractable(), moJwk.isExtractable());
assertEquals(jwk.getAlgorithm(), moJwk.getAlgorithm());
assertEquals(jwk.getId(), moJwk.getId());
assertNull(moJwk.getRsaKeyPair());
assertArrayEquals(jwk.getSecretKey(SECRET_KEY.getAlgorithm()).getEncoded(), moJwk.getSecretKey(SECRET_KEY.getAlgorithm()).getEncoded());
assertEquals(jwk.getType(), moJwk.getType());
assertEquals(jwk.getUsage(), moJwk.getUsage());
final byte[] moEncode = moJwk.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void invalidExtractable() throws MslEncodingException, MslEncoderException, MslCryptoException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final JsonWebKey jwk = new JsonWebKey(NULL_USAGE, null, false, null, SECRET_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, jwk);
mo.put(KEY_EXTRACTABLE, "x");
new JsonWebKey(mo);
}
@Test
public void missingKey() throws MslCryptoException, MslEncodingException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final JsonWebKey jwk = new JsonWebKey(NULL_USAGE, null, false, null, SECRET_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, jwk);
mo.remove(KEY_KEY);
new JsonWebKey(mo);
}
@Test
public void emptyKey() throws MslCryptoException, MslEncodingException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.INVALID_JWK_KEYDATA);
final JsonWebKey jwk = new JsonWebKey(NULL_USAGE, null, false, null, SECRET_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, jwk);
mo.put(KEY_KEY, "");
new JsonWebKey(mo);
}
@Test
public void missingModulus() throws MslCryptoException, MslEncodingException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final JsonWebKey jwk = new JsonWebKey(NULL_USAGE, null, false, null, PUBLIC_KEY, PRIVATE_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, jwk);
mo.remove(KEY_MODULUS);
new JsonWebKey(mo);
}
@Test
public void emptyModulus() throws MslCryptoException, MslEncodingException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.INVALID_JWK_KEYDATA);
final JsonWebKey jwk = new JsonWebKey(NULL_USAGE, null, false, null, PUBLIC_KEY, PRIVATE_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, jwk);
mo.put(KEY_MODULUS, "");
new JsonWebKey(mo);
}
@Test
public void missingExponents() throws MslCryptoException, MslEncodingException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final JsonWebKey jwk = new JsonWebKey(NULL_USAGE, null, false, null, PUBLIC_KEY, PRIVATE_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, jwk);
mo.remove(KEY_PUBLIC_EXPONENT);
mo.remove(KEY_PRIVATE_EXPONENT);
new JsonWebKey(mo);
}
@Test
public void emptyPublicExponent() throws MslCryptoException, MslEncodingException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.INVALID_JWK_KEYDATA);
final JsonWebKey jwk = new JsonWebKey(NULL_USAGE, null, false, null, PUBLIC_KEY, PRIVATE_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, jwk);
mo.put(KEY_PUBLIC_EXPONENT, "");
new JsonWebKey(mo);
}
// This unit test no longer passes because
// Base64.decode() does not error when given invalid
// Base64 encoded data.
@Ignore
@Test
public void invalidPublicExpontent() throws MslCryptoException, MslEncodingException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.INVALID_JWK_KEYDATA);
final JsonWebKey jwk = new JsonWebKey(NULL_USAGE, null, false, null, PUBLIC_KEY, PRIVATE_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, jwk);
mo.put(KEY_PUBLIC_EXPONENT, "x");
new JsonWebKey(mo);
}
@Test
public void emptyPrivateExponent() throws MslCryptoException, MslEncodingException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.INVALID_JWK_KEYDATA);
final JsonWebKey jwk = new JsonWebKey(NULL_USAGE, null, false, null, PUBLIC_KEY, PRIVATE_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, jwk);
mo.put(KEY_PRIVATE_EXPONENT, "");
new JsonWebKey(mo);
}
// This unit test no longer passes because
// Base64.decode() does not error when given invalid
// Base64 encoded data.
@Ignore
@Test
public void invalidPrivateExponent() throws MslCryptoException, MslEncodingException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.INVALID_JWK_KEYDATA);
final JsonWebKey jwk = new JsonWebKey(NULL_USAGE, null, false, null, PUBLIC_KEY, PRIVATE_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, jwk);
mo.put(KEY_PRIVATE_EXPONENT, "x");
new JsonWebKey(mo);
}
}
| 9,937 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/crypto/MslSignatureEnvelopeSuite.java | /**
* Copyright (c) 2013-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.crypto;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Random;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;
import com.netflix.msl.MslConstants.SignatureAlgo;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.crypto.MslSignatureEnvelope.Version;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
/**
* MSL signature envelope unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
@RunWith(Suite.class)
@SuiteClasses({MslSignatureEnvelopeSuite.Version1.class,
MslSignatureEnvelopeSuite.Version2.class})
public class MslSignatureEnvelopeSuite {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key version. */
private static final String KEY_VERSION = "version";
/** Key algorithm. */
private static final String KEY_ALGORITHM = "algorithm";
/** Key signature. */
private static final String KEY_SIGNATURE = "signature";
private static final byte[] SIGNATURE = new byte[32];
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException {
final Random random = new Random();
random.nextBytes(SIGNATURE);
final MslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = ctx.getMslEncoderFactory();
}
@AfterClass
public static void teardown() {
// Teardown causes problems because the data is shared by the inner
// classes, so don't do any cleanup.
}
public static class Version1 {
@Test
public void ctors() throws MslCryptoException, MslEncodingException, MslEncoderException {
final MslSignatureEnvelope envelope = new MslSignatureEnvelope(SIGNATURE);
assertNull(envelope.getAlgorithm());
assertArrayEquals(SIGNATURE, envelope.getSignature());
final byte[] envelopeBytes = envelope.getBytes(encoder, ENCODER_FORMAT);
assertNotNull(envelopeBytes);
final MslSignatureEnvelope moEnvelope = MslSignatureEnvelope.parse(envelopeBytes, encoder);
assertEquals(envelope.getAlgorithm(), moEnvelope.getAlgorithm());
assertArrayEquals(envelope.getSignature(), moEnvelope.getSignature());
final byte[] moEnvelopeBytes = moEnvelope.getBytes(encoder, ENCODER_FORMAT);
assertArrayEquals(envelopeBytes, moEnvelopeBytes);
}
@Test
public void encode() throws MslCryptoException, MslEncodingException, MslEncoderException {
final MslSignatureEnvelope envelope = new MslSignatureEnvelope(SIGNATURE);
final byte[] envelopeBytes = envelope.getBytes(encoder, ENCODER_FORMAT);
assertNotNull(envelopeBytes);
assertArrayEquals(SIGNATURE, envelopeBytes);
}
}
@RunWith(Parameterized.class)
public static class Version2 {
@Parameters
public static Collection<Object[]> data() throws MslEncodingException, MslCryptoException {
MslSignatureEnvelopeSuite.setup();
final List<Object[]> params = new ArrayList<Object[]>();
for (final SignatureAlgo algo: SignatureAlgo.values())
params.add(new Object[] { algo });
return params;
}
/** Algorithm. */
private final SignatureAlgo algorithm;
/**
* Create a new Version 2 test set with the provided algorithm.
*
* @param algorithm the algorithm.
*/
public Version2(final SignatureAlgo algorithm) {
this.algorithm = algorithm;
}
@Test
public void ctors() throws MslCryptoException, MslEncodingException, MslEncoderException {
final MslSignatureEnvelope envelope = new MslSignatureEnvelope(algorithm, SIGNATURE);
assertEquals(algorithm, envelope.getAlgorithm());
assertArrayEquals(SIGNATURE, envelope.getSignature());
final byte[] envelopeBytes = envelope.getBytes(encoder, ENCODER_FORMAT);
assertNotNull(envelopeBytes);
final MslSignatureEnvelope moEnvelope = MslSignatureEnvelope.parse(envelopeBytes, encoder);
assertEquals(envelope.getAlgorithm(), moEnvelope.getAlgorithm());
assertArrayEquals(envelope.getSignature(), moEnvelope.getSignature());
final byte[] moEnvelopeBytes = moEnvelope.getBytes(encoder, ENCODER_FORMAT);
assertArrayEquals(envelopeBytes, moEnvelopeBytes);
}
@Test
public void encode() throws MslEncoderException, MslEncoderException {
final MslSignatureEnvelope envelope = new MslSignatureEnvelope(algorithm, SIGNATURE);
final byte[] envelopeBytes = envelope.getBytes(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(envelopeBytes);
assertEquals(Version.V2.intValue(), mo.getInt(KEY_VERSION));
assertEquals(algorithm.toString(), mo.getString(KEY_ALGORITHM));
assertArrayEquals(SIGNATURE, mo.getBytes(KEY_SIGNATURE));
}
@Test
public void missingVersion() throws MslCryptoException, MslEncodingException, MslEncoderException {
final MslSignatureEnvelope envelope = new MslSignatureEnvelope(algorithm, SIGNATURE);
final byte[] envelopeBytes = envelope.getBytes(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(envelopeBytes);
mo.remove(KEY_VERSION);
final byte[] moEncode = encoder.encodeObject(mo, ENCODER_FORMAT);
final MslSignatureEnvelope moEnvelope = MslSignatureEnvelope.parse(moEncode, encoder);
assertNull(moEnvelope.getAlgorithm());
assertArrayEquals(moEncode, moEnvelope.getSignature());
}
@Test
public void invalidVersion() throws MslEncoderException, MslCryptoException, MslEncodingException {
final MslSignatureEnvelope envelope = new MslSignatureEnvelope(algorithm, SIGNATURE);
final byte[] envelopeBytes = envelope.getBytes(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(envelopeBytes);
mo.put(KEY_VERSION, "x");
final byte[] moEncode = encoder.encodeObject(mo, ENCODER_FORMAT);
final MslSignatureEnvelope moEnvelope = MslSignatureEnvelope.parse(moEncode, encoder);
assertNull(moEnvelope.getAlgorithm());
assertArrayEquals(moEncode, moEnvelope.getSignature());
}
@Test
public void unknownVersion() throws MslEncoderException, MslCryptoException, MslEncodingException {
final MslSignatureEnvelope envelope = new MslSignatureEnvelope(algorithm, SIGNATURE);
final byte[] envelopeBytes = envelope.getBytes(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(envelopeBytes);
mo.put(KEY_VERSION, -1);
final byte[] moEncode = encoder.encodeObject(mo, ENCODER_FORMAT);
final MslSignatureEnvelope moEnvelope = MslSignatureEnvelope.parse(moEncode, encoder);
assertNull(moEnvelope.getAlgorithm());
assertArrayEquals(moEncode, moEnvelope.getSignature());
}
@Test
public void missingAlgorithm() throws MslEncoderException, MslCryptoException, MslEncodingException {
final MslSignatureEnvelope envelope = new MslSignatureEnvelope(algorithm, SIGNATURE);
final byte[] envelopeBytes = envelope.getBytes(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(envelopeBytes);
mo.remove(KEY_ALGORITHM);
final byte[] moEncode = encoder.encodeObject(mo, ENCODER_FORMAT);
final MslSignatureEnvelope moEnvelope = MslSignatureEnvelope.parse(moEncode, encoder);
assertNull(moEnvelope.getAlgorithm());
assertArrayEquals(moEncode, moEnvelope.getSignature());
}
@Test
public void invalidAlgorithm() throws MslEncoderException, MslCryptoException, MslEncodingException {
final MslSignatureEnvelope envelope = new MslSignatureEnvelope(algorithm, SIGNATURE);
final byte[] envelopeBytes = envelope.getBytes(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(envelopeBytes);
mo.put(KEY_ALGORITHM, "x");
final byte[] moEncode = encoder.encodeObject(mo, ENCODER_FORMAT);
final MslSignatureEnvelope moEnvelope = MslSignatureEnvelope.parse(moEncode, encoder);
assertNull(moEnvelope.getAlgorithm());
assertArrayEquals(moEncode, moEnvelope.getSignature());
}
@Test
public void missingSignature() throws MslEncoderException, MslCryptoException, MslEncodingException {
final MslSignatureEnvelope envelope = new MslSignatureEnvelope(algorithm, SIGNATURE);
final byte[] envelopeBytes = envelope.getBytes(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(envelopeBytes);
mo.remove(KEY_SIGNATURE);
final byte[] moEncode = encoder.encodeObject(mo, ENCODER_FORMAT);
final MslSignatureEnvelope moEnvelope = MslSignatureEnvelope.parse(moEncode, encoder);
assertNull(moEnvelope.getAlgorithm());
assertArrayEquals(moEncode, moEnvelope.getSignature());
}
}
}
| 9,938 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/crypto/NullCryptoContextTest.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.crypto;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.util.Random;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
/**
* Null crypto context unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class NullCryptoContextTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException {
final MslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = ctx.getMslEncoderFactory();
}
@AfterClass
public static void teardown() {
encoder = null;
}
@Test
public void encryptDecrypt() throws MslCryptoException {
final Random random = new Random();
final byte[] message = new byte[32];
random.nextBytes(message);
final NullCryptoContext cryptoContext = new NullCryptoContext();
final byte[] ciphertext = cryptoContext.encrypt(message, encoder, ENCODER_FORMAT);
assertNotNull(ciphertext);
assertArrayEquals(message, ciphertext);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
assertNotNull(plaintext);
assertArrayEquals(message, plaintext);
}
@Test
public void wrapUnwrap() throws MslCryptoException {
final Random random = new Random();
final byte[] message = new byte[32];
random.nextBytes(message);
final NullCryptoContext cryptoContext = new NullCryptoContext();
final byte[] ciphertext = cryptoContext.wrap(message, encoder, ENCODER_FORMAT);
assertNotNull(ciphertext);
assertArrayEquals(message, ciphertext);
final byte[] plaintext = cryptoContext.unwrap(ciphertext, encoder);
assertNotNull(plaintext);
assertArrayEquals(message, plaintext);
}
@Test
public void signVerify() throws MslCryptoException {
final Random random = new Random();
final byte[] messageA = new byte[32];
random.nextBytes(messageA);
final NullCryptoContext cryptoContext = new NullCryptoContext();
final byte[] signatureA = cryptoContext.sign(messageA, encoder, ENCODER_FORMAT);
assertNotNull(signatureA);
assertEquals(0, signatureA.length);
assertTrue(cryptoContext.verify(messageA, signatureA, encoder));
final byte[] messageB = new byte[32];
random.nextBytes(messageB);
final byte[] signatureB = cryptoContext.sign(messageB, encoder, ENCODER_FORMAT);
assertArrayEquals(signatureA, signatureB);
assertTrue(cryptoContext.verify(messageB, signatureB, encoder));
assertTrue(cryptoContext.verify(messageB, signatureA, encoder));
}
}
| 9,939 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/crypto/JsonWebEncryptionCryptoContextSuite.java | /**
* Copyright (c) 2013-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.crypto;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import java.math.BigInteger;
import java.nio.charset.Charset;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Security;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.KeySpec;
import java.security.spec.RSAPrivateKeySpec;
import java.security.spec.RSAPublicKeySpec;
import java.util.Arrays;
import java.util.Random;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.crypto.JsonWebEncryptionCryptoContext.CekCryptoContext;
import com.netflix.msl.crypto.JsonWebEncryptionCryptoContext.Encryption;
import com.netflix.msl.crypto.JsonWebEncryptionCryptoContext.Format;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.io.MslArray;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
/**
* JSON Web Encryption crypto context unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
@RunWith(Suite.class)
@SuiteClasses({JsonWebEncryptionCryptoContextSuite.JWE.class,
JsonWebEncryptionCryptoContextSuite.RsaOaepCompactSerialization.class,
JsonWebEncryptionCryptoContextSuite.RsaOaepJsonSerialization.class,
JsonWebEncryptionCryptoContextSuite.AesKwCompactSerialization.class,
JsonWebEncryptionCryptoContextSuite.AesKwJsonSerialization.class})
public class JsonWebEncryptionCryptoContextSuite {
/** Encoding charset. */
private static final Charset UTF_8 = Charset.forName("UTF-8");
/** Encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** JSON key recipients. */
private static final String KEY_RECIPIENTS = "recipients";
/** JSON key header. */
private static final String KEY_HEADER = "header";
/** JSON key encrypted key. */
private static final String KEY_ENCRYPTED_KEY = "encrypted_key";
/** JSON key integrity value. */
private static final String KEY_INTEGRITY_VALUE = "integrity_value";
/** JSON key initialization vector. */
private static final String KEY_INITIALIZATION_VECTOR = "initialization_vector";
/** JSON key ciphertext. */
private static final String KEY_CIPHERTEXT = "ciphertext";
/** JSON key wrap algorithm. */
private static final String KEY_ALGORITHM = "alg";
/** JSON key encryption algorithm. */
private static final String KEY_ENCRYPTION = "enc";
/** Compact serialization header part index. */
private static final int HEADER_INDEX = 0;
/** Compact serialization encrypted content encryption key part index. */
private static final int ECEK_INDEX = 1;
/** Compact serialization initialization vector part index. */
private static final int IV_INDEX = 2;
/** Compact serialization ciphertext part index. */
private static final int CIPHERTEXT_INDEX = 3;
/** Compact serialization authentication tag part index. */
private static final int AUTHENTICATION_TAG_INDEX = 4;
/**
* Replace one part of the provided compact serialization with a specified
* value.
*
* @param serialization compact serialization.
* @param part zero-based part number to replace.
* @param value Base64-encoded replacement value.
* @return the modified compact serialization.
*/
private static byte[] replace(final byte[] serialization, final int part, final String value) {
final String s = new String(serialization, UTF_8);
final String[] parts = s.split("\\.");
parts[part] = value;
final StringBuilder b = new StringBuilder(parts[0]);
for (int i = 1; i < parts.length; ++i)
b.append("." + parts[i]);
return b.toString().getBytes(UTF_8);
}
/**
* Return the requested value of the provided JSON serialization.
*
* @param serialization JSON serialization.
* @param key JSON key.
* @return the requested Base64-encoded value.
* @throws MslEncoderException if there is an error parsing the serialization.
*/
private static String get(final byte[] serialization, final String key) throws MslEncoderException {
final MslObject serializationMo = encoder.parseObject(serialization);
final MslArray recipients = serializationMo.getMslArray(KEY_RECIPIENTS);
final MslObject recipient = recipients.getMslObject(0, encoder);
if (KEY_HEADER.equals(key) ||
KEY_ENCRYPTED_KEY.equals(key) ||
KEY_INTEGRITY_VALUE.equals(key))
{
return recipient.getString(key);
}
if (KEY_INITIALIZATION_VECTOR.equals(key) ||
KEY_CIPHERTEXT.equals(key))
{
return serializationMo.getString(key);
}
throw new IllegalArgumentException("Unknown JSON key: " + key);
}
/**
* Replace one part of the provided JSON serialization with a specified
* value.
*
* @param serialization JSON serialization.
* @param key JSON key.
* @param value replacement value.
* @return the modified JSON serialization.
* @throws MslEncoderException if there is an error modifying the JSON
* serialization.
*/
private static byte[] replace(final byte[] serialization, final String key, final Object value) throws MslEncoderException {
final MslObject serializationMo = encoder.parseObject(serialization);
final MslArray recipients = serializationMo.getMslArray(KEY_RECIPIENTS);
final MslObject recipient = recipients.getMslObject(0, encoder);
if (KEY_RECIPIENTS.equals(key)) {
// Return immediately after replacing because this creates a
// malformed serialization.
serializationMo.put(KEY_RECIPIENTS, value);
return serializationMo.toString().getBytes(UTF_8);
}
if (KEY_HEADER.equals(key) ||
KEY_ENCRYPTED_KEY.equals(key) ||
KEY_INTEGRITY_VALUE.equals(key))
{
recipient.put(key, value);
} else if (KEY_INITIALIZATION_VECTOR.equals(key) ||
KEY_CIPHERTEXT.equals(key))
{
serializationMo.put(key, value);
} else {
throw new IllegalArgumentException("Unknown JSON key: " + key);
}
recipients.put(0, recipient);
serializationMo.put(KEY_RECIPIENTS, recipients);
return serializationMo.toString().getBytes(UTF_8);
}
/**
* Remove one part of the provided JSON serialization.
*
* @param serialization JSON serialization.
* @param key JSON key.
* @return the modified JSON serialization.
* @throws MslEncoderException if there is an error modifying the JSON
* serialization.
*/
private static byte[] remove(final byte[] serialization, final String key) throws MslEncoderException {
final MslObject serializationJo = encoder.parseObject(serialization);
final MslArray recipients = serializationJo.getMslArray(KEY_RECIPIENTS);
final MslObject recipient = recipients.getMslObject(0, encoder);
if (KEY_RECIPIENTS.equals(key)) {
// Return immediately after removing because this creates a
// malformed serialization.
serializationJo.remove(KEY_RECIPIENTS);
return serializationJo.toString().getBytes(UTF_8);
}
if (KEY_HEADER.equals(key) ||
KEY_ENCRYPTED_KEY.equals(key) ||
KEY_INTEGRITY_VALUE.equals(key))
{
recipient.remove(key);
} else if (KEY_INITIALIZATION_VECTOR.equals(key) ||
KEY_CIPHERTEXT.equals(key))
{
serializationJo.remove(key);
} else {
throw new IllegalArgumentException("Unknown JSON key: " + key);
}
recipients.put(0, recipient);
serializationJo.put(KEY_RECIPIENTS, recipients);
return serializationJo.toString().getBytes(UTF_8);
}
/** MSL context. */
private static MslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
/** Random. */
private static Random random;
/** Random data. */
private static byte[] data;
/** RSA-OAEP content encryption key crypto context. */
private static CekCryptoContext rsaCryptoContext;
/** AES key wrap content encryption key crypto context. */
private static CekCryptoContext aesCryptoContext;
@BeforeClass
public static synchronized void setup() throws NoSuchAlgorithmException, MslEncodingException, MslCryptoException {
if (random == null) {
random = new Random();
data = new byte[1024];
random.nextBytes(data);
ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = ctx.getMslEncoderFactory();
final KeyPairGenerator keypairGenerator = KeyPairGenerator.getInstance("RSA");
keypairGenerator.initialize(512);
final KeyPair keypair = keypairGenerator.generateKeyPair();
final PrivateKey privateKey = keypair.getPrivate();
final PublicKey publicKey = keypair.getPublic();
rsaCryptoContext = new JsonWebEncryptionCryptoContext.RsaOaepCryptoContext(privateKey, publicKey);
final byte[] keydata = new byte[16];
random.nextBytes(keydata);
final SecretKey wrappingKey = new SecretKeySpec(keydata, JcaAlgorithm.AESKW);
aesCryptoContext = new JsonWebEncryptionCryptoContext.AesKwCryptoContext(wrappingKey);
}
}
@AfterClass
public static synchronized void teardown() {
// Teardown causes problems because the data is shared by the inner
// classes, so don't do any cleanup.
}
/** RSA-OAEP compact serialization unit tests. */
public static class RsaOaepCompactSerialization {
/** RFC RSA-OAEP keypair modulus. */
private static final byte[] RFC_MODULUS = {
(byte)161, (byte)168, (byte)84, (byte)34, (byte)133, (byte)176, (byte)208, (byte)173,
(byte)46, (byte)176, (byte)163, (byte)110, (byte)57, (byte)30, (byte)135, (byte)227,
(byte)9, (byte)31, (byte)226, (byte)128, (byte)84, (byte)92, (byte)116, (byte)241,
(byte)70, (byte)248, (byte)27, (byte)227, (byte)193, (byte)62, (byte)5, (byte)91,
(byte)241, (byte)145, (byte)224, (byte)205, (byte)141, (byte)176, (byte)184, (byte)133,
(byte)239, (byte)43, (byte)81, (byte)103, (byte)9, (byte)161, (byte)153, (byte)157,
(byte)179, (byte)104, (byte)123, (byte)51, (byte)189, (byte)34, (byte)152, (byte)69,
(byte)97, (byte)69, (byte)78, (byte)93, (byte)140, (byte)131, (byte)87, (byte)182,
(byte)169, (byte)101, (byte)92, (byte)142, (byte)3, (byte)22, (byte)167, (byte)8,
(byte)212, (byte)56, (byte)35, (byte)79, (byte)210, (byte)222, (byte)192, (byte)208,
(byte)252, (byte)49, (byte)109, (byte)138, (byte)173, (byte)253, (byte)210, (byte)166,
(byte)201, (byte)63, (byte)102, (byte)74, (byte)5, (byte)158, (byte)41, (byte)90,
(byte)144, (byte)108, (byte)160, (byte)79, (byte)10, (byte)89, (byte)222, (byte)231,
(byte)172, (byte)31, (byte)227, (byte)197, (byte)0, (byte)19, (byte)72, (byte)81,
(byte)138, (byte)78, (byte)136, (byte)221, (byte)121, (byte)118, (byte)196, (byte)17,
(byte)146, (byte)10, (byte)244, (byte)188, (byte)72, (byte)113, (byte)55, (byte)221,
(byte)162, (byte)217, (byte)171, (byte)27, (byte)57, (byte)233, (byte)210, (byte)101,
(byte)236, (byte)154, (byte)199, (byte)56, (byte)138, (byte)239, (byte)101, (byte)48,
(byte)198, (byte)186, (byte)202, (byte)160, (byte)76, (byte)111, (byte)234, (byte)71,
(byte)57, (byte)183, (byte)5, (byte)211, (byte)171, (byte)136, (byte)126, (byte)64,
(byte)40, (byte)75, (byte)58, (byte)89, (byte)244, (byte)254, (byte)107, (byte)84,
(byte)103, (byte)7, (byte)236, (byte)69, (byte)163, (byte)18, (byte)180, (byte)251,
(byte)58, (byte)153, (byte)46, (byte)151, (byte)174, (byte)12, (byte)103, (byte)197,
(byte)181, (byte)161, (byte)162, (byte)55, (byte)250, (byte)235, (byte)123, (byte)110,
(byte)17, (byte)11, (byte)158, (byte)24, (byte)47, (byte)133, (byte)8, (byte)199,
(byte)235, (byte)107, (byte)126, (byte)130, (byte)246, (byte)73, (byte)195, (byte)20,
(byte)108, (byte)202, (byte)176, (byte)214, (byte)187, (byte)45, (byte)146, (byte)182,
(byte)118, (byte)54, (byte)32, (byte)200, (byte)61, (byte)201, (byte)71, (byte)243,
(byte)1, (byte)255, (byte)131, (byte)84, (byte)37, (byte)111, (byte)211, (byte)168,
(byte)228, (byte)45, (byte)192, (byte)118, (byte)27, (byte)197, (byte)235, (byte)232,
(byte)36, (byte)10, (byte)230, (byte)248, (byte)190, (byte)82, (byte)182, (byte)140,
(byte)35, (byte)204, (byte)108, (byte)190, (byte)253, (byte)186, (byte)186, (byte)27 };
/** RFC RSA-OAEP keypair exponent. */
private static final byte[] RFC_PUBLIC_EXPONENT = { (byte)1, (byte)0, (byte)1 };
/** RFC RSA-OAEP private exponent. */
private static final byte[] RFC_PRIVATE_EXPONENT = {
(byte)144, (byte)183, (byte)109, (byte)34, (byte)62, (byte)134, (byte)108, (byte)57,
(byte)44, (byte)252, (byte)10, (byte)66, (byte)73, (byte)54, (byte)16, (byte)181,
(byte)233, (byte)92, (byte)54, (byte)219, (byte)101, (byte)42, (byte)35, (byte)178,
(byte)63, (byte)51, (byte)43, (byte)92, (byte)119, (byte)136, (byte)251, (byte)41,
(byte)53, (byte)23, (byte)191, (byte)164, (byte)164, (byte)60, (byte)88, (byte)227,
(byte)229, (byte)152, (byte)228, (byte)213, (byte)149, (byte)228, (byte)169, (byte)237,
(byte)104, (byte)71, (byte)151, (byte)75, (byte)88, (byte)252, (byte)216, (byte)77,
(byte)251, (byte)231, (byte)28, (byte)97, (byte)88, (byte)193, (byte)215, (byte)202,
(byte)248, (byte)216, (byte)121, (byte)195, (byte)211, (byte)245, (byte)250, (byte)112,
(byte)71, (byte)243, (byte)61, (byte)129, (byte)95, (byte)39, (byte)244, (byte)122,
(byte)225, (byte)217, (byte)169, (byte)211, (byte)165, (byte)48, (byte)253, (byte)220,
(byte)59, (byte)122, (byte)219, (byte)42, (byte)86, (byte)223, (byte)32, (byte)236,
(byte)39, (byte)48, (byte)103, (byte)78, (byte)122, (byte)216, (byte)187, (byte)88,
(byte)176, (byte)89, (byte)24, (byte)1, (byte)42, (byte)177, (byte)24, (byte)99,
(byte)142, (byte)170, (byte)1, (byte)146, (byte)43, (byte)3, (byte)108, (byte)64,
(byte)194, (byte)121, (byte)182, (byte)95, (byte)187, (byte)134, (byte)71, (byte)88,
(byte)96, (byte)134, (byte)74, (byte)131, (byte)167, (byte)69, (byte)106, (byte)143,
(byte)121, (byte)27, (byte)72, (byte)44, (byte)245, (byte)95, (byte)39, (byte)194,
(byte)179, (byte)175, (byte)203, (byte)122, (byte)16, (byte)112, (byte)183, (byte)17,
(byte)200, (byte)202, (byte)31, (byte)17, (byte)138, (byte)156, (byte)184, (byte)210,
(byte)157, (byte)184, (byte)154, (byte)131, (byte)128, (byte)110, (byte)12, (byte)85,
(byte)195, (byte)122, (byte)241, (byte)79, (byte)251, (byte)229, (byte)183, (byte)117,
(byte)21, (byte)123, (byte)133, (byte)142, (byte)220, (byte)153, (byte)9, (byte)59,
(byte)57, (byte)105, (byte)81, (byte)255, (byte)138, (byte)77, (byte)82, (byte)54,
(byte)62, (byte)216, (byte)38, (byte)249, (byte)208, (byte)17, (byte)197, (byte)49,
(byte)45, (byte)19, (byte)232, (byte)157, (byte)251, (byte)131, (byte)137, (byte)175,
(byte)72, (byte)126, (byte)43, (byte)229, (byte)69, (byte)179, (byte)117, (byte)82,
(byte)157, (byte)213, (byte)83, (byte)35, (byte)57, (byte)210, (byte)197, (byte)252,
(byte)171, (byte)143, (byte)194, (byte)11, (byte)47, (byte)163, (byte)6, (byte)253,
(byte)75, (byte)252, (byte)96, (byte)11, (byte)187, (byte)84, (byte)130, (byte)210,
(byte)7, (byte)121, (byte)78, (byte)91, (byte)79, (byte)57, (byte)251, (byte)138,
(byte)132, (byte)220, (byte)60, (byte)224, (byte)173, (byte)56, (byte)224, (byte)201 };
/** RFC RSA-OAEP wrapped compact serialization. */
private static final byte[] RFC_SERIALIZATION =
("eyJhbGciOiJSU0EtT0FFUCIsImVuYyI6IkEyNTZHQ00ifQ." +
"M2XxpbORKezKSzzQL_95-GjiudRBTqn_omS8z9xgoRb7L0Jw5UsEbxmtyHn2T71m" +
"rZLkjg4Mp8gbhYoltPkEOHvAopz25-vZ8C2e1cOaAo5WPcbSIuFcB4DjBOM3t0UA" +
"O6JHkWLuAEYoe58lcxIQneyKdaYSLbV9cKqoUoFQpvKWYRHZbfszIyfsa18rmgTj" +
"zrtLDTPnc09DSJE24aQ8w3i8RXEDthW9T1J6LsTH_vwHdwUgkI-tC2PNeGrnM-dN" +
"SfzF3Y7-lwcGy0FsdXkPXytvDV7y4pZeeUiQ-0VdibIN2AjjfW60nfrPuOjepMFG" +
"6BBBbR37pHcyzext9epOAQ." +
"48V1_ALb6US04U3b." +
"_e21tGGhac_peEFkLXr2dMPUZiUkrw." +
"7V5ZDko0v_mf2PAc4JMiUg").getBytes(UTF_8);
/** RFC RSA-OAEP plaintext. */
private static final byte[] RFC_PLAINTEXT =
("Live long and prosper.").getBytes(UTF_8);
/*{
(byte)76, (byte)105, (byte)118, (byte)101, (byte)32, (byte)108, (byte)111, (byte)110,
(byte)103, (byte)32, (byte)97, (byte)110, (byte)100, (byte)32, (byte)112, (byte)114,
(byte)111, (byte)115, (byte)112, (byte)101, (byte)114, (byte)46 };*/
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
/** JWE crypto context. */
private static ICryptoContext cryptoContext;
@BeforeClass
public static void setup() throws NoSuchAlgorithmException, MslEncodingException, MslCryptoException {
JsonWebEncryptionCryptoContextSuite.setup();
Security.addProvider(new BouncyCastleProvider());
cryptoContext = new JsonWebEncryptionCryptoContext(ctx, rsaCryptoContext, Encryption.A128GCM, Format.JWE_CS);
}
@AfterClass
public static void teardown() {
cryptoContext = null;
}
@Test
public void wrapUnwrap() throws MslCryptoException {
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
assertNotNull(wrapped);
assertFalse(Arrays.equals(data, wrapped));
final byte[] unwrapped = cryptoContext.unwrap(wrapped, encoder);
assertArrayEquals(data, unwrapped);
}
@Test
public void wrapUnwrapShort() throws MslCryptoException {
final byte[] data = new byte[3];
random.nextBytes(data);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
assertNotNull(wrapped);
assertFalse(Arrays.equals(data, wrapped));
final byte[] unwrapped = cryptoContext.unwrap(wrapped, encoder);
assertArrayEquals(data, unwrapped);
}
@Test
public void wrapUnwrapRfc() throws InvalidKeySpecException, NoSuchAlgorithmException, MslCryptoException {
final BigInteger modulus = new BigInteger(1, RFC_MODULUS);
final BigInteger publicExponent = new BigInteger(1, RFC_PUBLIC_EXPONENT);
final BigInteger privateExponent = new BigInteger(1, RFC_PRIVATE_EXPONENT);
final KeySpec privateKeySpec = new RSAPrivateKeySpec(modulus, privateExponent);
final KeySpec publicKeySpec = new RSAPublicKeySpec(modulus, publicExponent);
final KeyFactory factory = KeyFactory.getInstance("RSA");
final PrivateKey privateKey = factory.generatePrivate(privateKeySpec);
final PublicKey publicKey = factory.generatePublic(publicKeySpec);
final CekCryptoContext cekCryptoContext = new JsonWebEncryptionCryptoContext.RsaOaepCryptoContext(privateKey, publicKey);
final ICryptoContext cryptoContext = new JsonWebEncryptionCryptoContext(ctx, cekCryptoContext, Encryption.A256GCM, Format.JWE_CS);
final byte[] plaintext = cryptoContext.unwrap(RFC_SERIALIZATION, encoder);
assertNotNull(plaintext);
assertArrayEquals(RFC_PLAINTEXT, plaintext);
}
@Test
public void invalidSerialization() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = "x".getBytes(UTF_8);
cryptoContext.unwrap(wrapped, encoder);
}
@Test
public void shortSerialization() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final String serialization = new String(wrapped, UTF_8);
final String shortSerialization = serialization.substring(0, serialization.lastIndexOf('.'));
final byte[] shortWrapped = shortSerialization.getBytes(UTF_8);
cryptoContext.unwrap(shortWrapped, encoder);
}
@Test
public void longSerialization() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] longWrapped = Arrays.copyOf(wrapped, 2 * wrapped.length);
System.arraycopy(wrapped, 0, longWrapped, wrapped.length, wrapped.length);
cryptoContext.unwrap(longWrapped, encoder);
}
@Test
public void missingHeader() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, HEADER_INDEX, "");
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidHeader() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, HEADER_INDEX, MslEncoderUtils.b64urlEncode("x"));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void missingCek() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, ECEK_INDEX, "");
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidCek() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.CIPHERTEXT_BAD_PADDING);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, ECEK_INDEX, MslEncoderUtils.b64urlEncode("x"));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void missingIv() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, IV_INDEX, "");
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidIv() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNWRAP_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, IV_INDEX, MslEncoderUtils.b64urlEncode("x"));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void missingCiphertext() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, CIPHERTEXT_INDEX, "");
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidCiphertext() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNWRAP_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, CIPHERTEXT_INDEX, MslEncoderUtils.b64urlEncode("x"));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void missingAuthenticationTag() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, AUTHENTICATION_TAG_INDEX, "");
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidAuthenticationTag() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.INVALID_ALGORITHM_PARAMS);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, AUTHENTICATION_TAG_INDEX, MslEncoderUtils.b64urlEncode("x"));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void wrongAuthenticationTag() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNWRAP_ERROR);
final byte[] at = new byte[16];
random.nextBytes(at);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, AUTHENTICATION_TAG_INDEX, MslEncoderUtils.b64urlEncode(at));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void missingAlgorithm() throws MslEncoderException, MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final String wrappedB64 = new String(wrapped, UTF_8);
final String headerB64 = wrappedB64.substring(0, wrappedB64.indexOf('.'));
final MslObject header = encoder.parseObject(MslEncoderUtils.b64urlDecode(headerB64));
assertNotNull(header.remove(KEY_ALGORITHM));
final byte[] missingWrapped = replace(wrapped, HEADER_INDEX, MslEncoderUtils.b64urlEncode(encoder.encodeObject(header, MslEncoderFormat.JSON)));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidAlgorithm() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final String wrappedB64 = new String(wrapped, UTF_8);
final String headerB64 = wrappedB64.substring(0, wrappedB64.indexOf('.'));
final MslObject header = encoder.parseObject(MslEncoderUtils.b64urlDecode(headerB64));
header.put(KEY_ALGORITHM, "x");
final byte[] missingWrapped = replace(wrapped, HEADER_INDEX, MslEncoderUtils.b64urlEncode(encoder.encodeObject(header, MslEncoderFormat.JSON)));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void missingEncryption() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final String wrappedB64 = new String(wrapped, UTF_8);
final String headerB64 = wrappedB64.substring(0, wrappedB64.indexOf('.'));
final MslObject header = encoder.parseObject(MslEncoderUtils.b64urlDecode(headerB64));
assertNotNull(header.remove(KEY_ENCRYPTION));
final byte[] missingWrapped = replace(wrapped, HEADER_INDEX, MslEncoderUtils.b64urlEncode(encoder.encodeObject(header, MslEncoderFormat.JSON)));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidEncryption() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final String wrappedB64 = new String(wrapped, UTF_8);
final String headerB64 = wrappedB64.substring(0, wrappedB64.indexOf('.'));
final MslObject header = encoder.parseObject(MslEncoderUtils.b64urlDecode(headerB64));
header.put(KEY_ENCRYPTION, "x");
final byte[] missingWrapped = replace(wrapped, HEADER_INDEX, MslEncoderUtils.b64urlEncode(encoder.encodeObject(header, MslEncoderFormat.JSON)));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void badCek() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] ecek = new byte[137];
random.nextBytes(ecek);
final byte[] badWrapped = replace(wrapped, ECEK_INDEX, MslEncoderUtils.b64urlEncode(ecek));
cryptoContext.unwrap(badWrapped, encoder);
}
@Test
public void badIv() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNWRAP_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] iv = new byte[31];
random.nextBytes(iv);
final byte[] badWrapped = replace(wrapped, IV_INDEX, MslEncoderUtils.b64urlEncode(iv));
cryptoContext.unwrap(badWrapped, encoder);
}
@Test
public void wrongCek() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNWRAP_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] cek = new byte[16];
random.nextBytes(cek);
final byte[] ecek = rsaCryptoContext.encrypt(cek, encoder, ENCODER_FORMAT);
final byte[] wrongWrapped = replace(wrapped, ECEK_INDEX, MslEncoderUtils.b64urlEncode(ecek));
cryptoContext.unwrap(wrongWrapped, encoder);
}
@Test
public void wrongIv() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNWRAP_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] iv = new byte[16];
random.nextBytes(iv);
final byte[] wrongWrapped = replace(wrapped, IV_INDEX, MslEncoderUtils.b64urlEncode(iv));
cryptoContext.unwrap(wrongWrapped, encoder);
}
}
/** RSA-OAEP JSON serialization unit tests. */
public static class RsaOaepJsonSerialization {
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
/** JWE crypto context. */
private static ICryptoContext cryptoContext;
@BeforeClass
public static void setup() throws NoSuchAlgorithmException, MslEncodingException, MslCryptoException {
JsonWebEncryptionCryptoContextSuite.setup();
Security.addProvider(new BouncyCastleProvider());
cryptoContext = new JsonWebEncryptionCryptoContext(ctx, rsaCryptoContext, Encryption.A128GCM, Format.JWE_JS);
}
@AfterClass
public static void teardown() {
cryptoContext = null;
}
@Test
public void wrapUnwrap() throws MslCryptoException {
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
assertNotNull(wrapped);
assertFalse(Arrays.equals(data, wrapped));
final byte[] unwrapped = cryptoContext.unwrap(wrapped, encoder);
assertArrayEquals(data, unwrapped);
}
@Test
public void wrapUnwrapShort() throws MslCryptoException {
final byte[] data = new byte[3];
random.nextBytes(data);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
assertNotNull(wrapped);
assertFalse(Arrays.equals(data, wrapped));
final byte[] unwrapped = cryptoContext.unwrap(wrapped, encoder);
assertArrayEquals(data, unwrapped);
}
@Test
public void invalidSerialization() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = "x".getBytes(UTF_8);
cryptoContext.unwrap(wrapped, encoder);
}
@Test
public void missingRecipients() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = remove(wrapped, KEY_RECIPIENTS);
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidRecipients() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, KEY_RECIPIENTS, "x");
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void missingRecipient() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, KEY_RECIPIENTS, encoder.createArray());
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidRecipient() throws MslEncoderException, MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final MslArray value = new MslArray(Arrays.asList("x"));
final byte[] missingWrapped = replace(wrapped, KEY_RECIPIENTS, value);
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void missingHeader() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = remove(wrapped, KEY_HEADER);
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidHeader() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, KEY_HEADER, MslEncoderUtils.b64urlEncode("x"));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void missingCek() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = remove(wrapped, KEY_ENCRYPTED_KEY);
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidCek() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.CIPHERTEXT_BAD_PADDING);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, KEY_ENCRYPTED_KEY, MslEncoderUtils.b64urlEncode("x"));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void missingIv() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = remove(wrapped, KEY_INITIALIZATION_VECTOR);
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidIv() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNWRAP_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, KEY_INITIALIZATION_VECTOR, MslEncoderUtils.b64urlEncode("x"));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void missingCiphertext() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = remove(wrapped, KEY_CIPHERTEXT);
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidCiphertext() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNWRAP_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, KEY_CIPHERTEXT, MslEncoderUtils.b64urlEncode("x"));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void missingAuthenticationTag() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = remove(wrapped, KEY_INTEGRITY_VALUE);
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidAuthenticationTag() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.INVALID_ALGORITHM_PARAMS);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, KEY_INTEGRITY_VALUE, MslEncoderUtils.b64urlEncode("x"));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void wrongAuthenticationTag() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNWRAP_ERROR);
final byte[] at = new byte[16];
random.nextBytes(at);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, KEY_INTEGRITY_VALUE, MslEncoderUtils.b64urlEncode(at));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void missingAlgorithm() throws MslEncoderException, MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final String headerB64 = get(wrapped, KEY_HEADER);
final MslObject header = encoder.parseObject(MslEncoderUtils.b64urlDecode(headerB64));
assertNotNull(header.remove(KEY_ALGORITHM));
final byte[] missingWrapped = replace(wrapped, KEY_HEADER, MslEncoderUtils.b64urlEncode(encoder.encodeObject(header, MslEncoderFormat.JSON)));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidAlgorithm() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final String headerB64 = get(wrapped, KEY_HEADER);
final MslObject header = encoder.parseObject(MslEncoderUtils.b64urlDecode(headerB64));
header.put(KEY_ALGORITHM, "x");
final byte[] missingWrapped = replace(wrapped, KEY_HEADER, MslEncoderUtils.b64urlEncode(encoder.encodeObject(header, MslEncoderFormat.JSON)));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void missingEncryption() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final String headerB64 = get(wrapped, KEY_HEADER);
final MslObject header = encoder.parseObject(MslEncoderUtils.b64urlDecode(headerB64));
assertNotNull(header.remove(KEY_ENCRYPTION));
final byte[] missingWrapped = replace(wrapped, KEY_HEADER, MslEncoderUtils.b64urlEncode(encoder.encodeObject(header, MslEncoderFormat.JSON)));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidEncryption() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final String headerB64 = get(wrapped, KEY_HEADER);
final MslObject header = encoder.parseObject(MslEncoderUtils.b64urlDecode(headerB64));
header.put(KEY_ENCRYPTION, "x");
final byte[] missingWrapped = replace(wrapped, KEY_HEADER, MslEncoderUtils.b64urlEncode(encoder.encodeObject(header, MslEncoderFormat.JSON)));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void badCek() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] ecek = new byte[137];
random.nextBytes(ecek);
final byte[] badWrapped = replace(wrapped, KEY_ENCRYPTED_KEY, MslEncoderUtils.b64urlEncode(ecek));
cryptoContext.unwrap(badWrapped, encoder);
}
@Test
public void badIv() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNWRAP_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] iv = new byte[31];
random.nextBytes(iv);
final byte[] badWrapped = replace(wrapped, KEY_INITIALIZATION_VECTOR, MslEncoderUtils.b64urlEncode(iv));
cryptoContext.unwrap(badWrapped, encoder);
}
@Test
public void wrongCek() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNWRAP_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] cek = new byte[16];
random.nextBytes(cek);
final byte[] ecek = rsaCryptoContext.encrypt(cek, encoder, ENCODER_FORMAT);
final byte[] wrongWrapped = replace(wrapped, KEY_ENCRYPTED_KEY, MslEncoderUtils.b64urlEncode(ecek));
cryptoContext.unwrap(wrongWrapped, encoder);
}
@Test
public void wrongIv() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNWRAP_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] iv = new byte[16];
random.nextBytes(iv);
final byte[] wrongWrapped = replace(wrapped, KEY_INITIALIZATION_VECTOR, MslEncoderUtils.b64urlEncode(iv));
cryptoContext.unwrap(wrongWrapped, encoder);
}
}
/** AES key wrap compact serialization unit tests. */
public static class AesKwCompactSerialization {
/** RFC AES key wrap symmetric key. */
private static final byte[] RFC_KEY = {
(byte)25, (byte)172, (byte)32, (byte)130, (byte)225, (byte)114, (byte)26, (byte)181,
(byte)138, (byte)106, (byte)254, (byte)192, (byte)95, (byte)133, (byte)74, (byte)82 };
/** RFC AES key wrap wrapped compact serialization. */
private static final byte[] RFC_SERIALIZATION =
("eyJhbGciOiJBMTI4S1ciLCJlbmMiOiJBMTI4R0NNIn0." +
"pP_7AUDIQcgixVGPK9PwJr-htXV3RCxQ." +
"_dxQGaaYsqhhY0NZ." +
"4wxZhLkQ-F2RVzWCX3M-aIpgbUd806VnymMVwQTiVOX-apDxJ1aUhKBoWOjkbVUH" +
"VlCGaqYYXMfSvJm72kXj." +
"miNQayWUUQZnBDzOq6VxQw").getBytes(UTF_8);
/** RFC AES key wrap plaintext. */
private static final byte[] RFC_PLAINTEXT =
("The true sign of intelligence is not knowledge but imagination.").getBytes(UTF_8);
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
/** JWE crypto context. */
private static ICryptoContext cryptoContext;
@BeforeClass
public static void setup() throws NoSuchAlgorithmException, MslEncodingException, MslCryptoException {
JsonWebEncryptionCryptoContextSuite.setup();
Security.addProvider(new BouncyCastleProvider());
cryptoContext = new JsonWebEncryptionCryptoContext(ctx, aesCryptoContext, Encryption.A256GCM, Format.JWE_CS);
}
@AfterClass
public static void teardown() {
cryptoContext = null;
}
@Test
public void wrapUnwrap() throws MslCryptoException {
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
assertNotNull(wrapped);
assertFalse(Arrays.equals(data, wrapped));
final byte[] unwrapped = cryptoContext.unwrap(wrapped, encoder);
assertArrayEquals(data, unwrapped);
}
@Test
public void wrapUnwrapShort() throws MslCryptoException {
final byte[] data = new byte[3];
random.nextBytes(data);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
assertNotNull(wrapped);
assertFalse(Arrays.equals(data, wrapped));
final byte[] unwrapped = cryptoContext.unwrap(wrapped, encoder);
assertArrayEquals(data, unwrapped);
}
@Test
public void wrapUnwrapRfc() throws InvalidKeySpecException, NoSuchAlgorithmException, MslCryptoException {
final SecretKey key = new SecretKeySpec(RFC_KEY, JcaAlgorithm.AESKW);
final CekCryptoContext cekCryptoContext = new JsonWebEncryptionCryptoContext.AesKwCryptoContext(key);
final ICryptoContext cryptoContext = new JsonWebEncryptionCryptoContext(ctx, cekCryptoContext, Encryption.A128GCM, Format.JWE_CS);
final byte[] plaintext = cryptoContext.unwrap(RFC_SERIALIZATION, encoder);
assertNotNull(plaintext);
assertArrayEquals(RFC_PLAINTEXT, plaintext);
}
@Test
public void invalidSerialization() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = "x".getBytes(UTF_8);
cryptoContext.unwrap(wrapped, encoder);
}
@Test
public void shortSerialization() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final String serialization = new String(wrapped, UTF_8);
final String shortSerialization = serialization.substring(0, serialization.lastIndexOf('.'));
final byte[] shortWrapped = shortSerialization.getBytes(UTF_8);
cryptoContext.unwrap(shortWrapped, encoder);
}
@Test
public void longSerialization() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] longWrapped = Arrays.copyOf(wrapped, 2 * wrapped.length);
System.arraycopy(wrapped, 0, longWrapped, wrapped.length, wrapped.length);
cryptoContext.unwrap(longWrapped, encoder);
}
@Test
public void missingHeader() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, HEADER_INDEX, "");
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidHeader() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, HEADER_INDEX, MslEncoderUtils.b64urlEncode("x"));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void missingCek() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, ECEK_INDEX, "");
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidCek() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.INVALID_SYMMETRIC_KEY);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, ECEK_INDEX, MslEncoderUtils.b64urlEncode("x"));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void missingIv() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, IV_INDEX, "");
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidIv() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNWRAP_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, IV_INDEX, MslEncoderUtils.b64urlEncode("x"));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void missingCiphertext() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, CIPHERTEXT_INDEX, "");
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidCiphertext() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNWRAP_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, CIPHERTEXT_INDEX, MslEncoderUtils.b64urlEncode("x"));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void missingAuthenticationTag() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, AUTHENTICATION_TAG_INDEX, "");
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidAuthenticationTag() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.INVALID_ALGORITHM_PARAMS);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, AUTHENTICATION_TAG_INDEX, MslEncoderUtils.b64urlEncode("x"));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void wrongAuthenticationTag() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNWRAP_ERROR);
final byte[] at = new byte[16];
random.nextBytes(at);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, AUTHENTICATION_TAG_INDEX, MslEncoderUtils.b64urlEncode(at));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void missingAlgorithm() throws MslEncoderException, MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final String wrappedB64 = new String(wrapped, UTF_8);
final String headerB64 = wrappedB64.substring(0, wrappedB64.indexOf('.'));
final MslObject header = encoder.parseObject(MslEncoderUtils.b64urlDecode(headerB64));
assertNotNull(header.remove(KEY_ALGORITHM));
final byte[] missingWrapped = replace(wrapped, HEADER_INDEX, MslEncoderUtils.b64urlEncode(encoder.encodeObject(header, MslEncoderFormat.JSON)));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidAlgorithm() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final String wrappedB64 = new String(wrapped, UTF_8);
final String headerB64 = wrappedB64.substring(0, wrappedB64.indexOf('.'));
final MslObject header = encoder.parseObject(MslEncoderUtils.b64urlDecode(headerB64));
header.put(KEY_ALGORITHM, "x");
final byte[] missingWrapped = replace(wrapped, HEADER_INDEX, MslEncoderUtils.b64urlEncode(encoder.encodeObject(header, MslEncoderFormat.JSON)));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void missingEncryption() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final String wrappedB64 = new String(wrapped, UTF_8);
final String headerB64 = wrappedB64.substring(0, wrappedB64.indexOf('.'));
final MslObject header = encoder.parseObject(MslEncoderUtils.b64urlDecode(headerB64));
assertNotNull(header.remove(KEY_ENCRYPTION));
final byte[] missingWrapped = replace(wrapped, HEADER_INDEX, MslEncoderUtils.b64urlEncode(encoder.encodeObject(header, MslEncoderFormat.JSON)));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidEncryption() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final String wrappedB64 = new String(wrapped, UTF_8);
final String headerB64 = wrappedB64.substring(0, wrappedB64.indexOf('.'));
final MslObject header = encoder.parseObject(MslEncoderUtils.b64urlDecode(headerB64));
header.put(KEY_ENCRYPTION, "x");
final byte[] missingWrapped = replace(wrapped, HEADER_INDEX, MslEncoderUtils.b64urlEncode(encoder.encodeObject(header, MslEncoderFormat.JSON)));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void badCek() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.INVALID_SYMMETRIC_KEY);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] ecek = new byte[137];
random.nextBytes(ecek);
final byte[] badWrapped = replace(wrapped, ECEK_INDEX, MslEncoderUtils.b64urlEncode(ecek));
cryptoContext.unwrap(badWrapped, encoder);
}
@Test
public void badIv() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNWRAP_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] iv = new byte[31];
random.nextBytes(iv);
final byte[] badWrapped = replace(wrapped, IV_INDEX, MslEncoderUtils.b64urlEncode(iv));
cryptoContext.unwrap(badWrapped, encoder);
}
@Test
public void wrongCek() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.INVALID_SYMMETRIC_KEY);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] cek = new byte[16];
random.nextBytes(cek);
final byte[] ecek = aesCryptoContext.encrypt(cek, encoder, ENCODER_FORMAT);
final byte[] wrongWrapped = replace(wrapped, ECEK_INDEX, MslEncoderUtils.b64urlEncode(ecek));
cryptoContext.unwrap(wrongWrapped, encoder);
}
@Test
public void wrongIv() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNWRAP_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] iv = new byte[16];
random.nextBytes(iv);
final byte[] wrongWrapped = replace(wrapped, IV_INDEX, MslEncoderUtils.b64urlEncode(iv));
cryptoContext.unwrap(wrongWrapped, encoder);
}
}
/** AES key wrap JSON serialization unit tests. */
public static class AesKwJsonSerialization {
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
/** JWE crypto context. */
private static ICryptoContext cryptoContext;
@BeforeClass
public static void setup() throws NoSuchAlgorithmException, MslEncodingException, MslCryptoException {
JsonWebEncryptionCryptoContextSuite.setup();
Security.addProvider(new BouncyCastleProvider());
cryptoContext = new JsonWebEncryptionCryptoContext(ctx, aesCryptoContext, Encryption.A256GCM, Format.JWE_JS);
}
@AfterClass
public static void teardown() {
cryptoContext = null;
}
@Test
public void wrapUnwrap() throws MslCryptoException {
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
assertNotNull(wrapped);
assertFalse(Arrays.equals(data, wrapped));
final byte[] unwrapped = cryptoContext.unwrap(wrapped, encoder);
assertArrayEquals(data, unwrapped);
}
@Test
public void wrapUnwrapShort() throws MslCryptoException {
final byte[] data = new byte[3];
random.nextBytes(data);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
assertNotNull(wrapped);
assertFalse(Arrays.equals(data, wrapped));
final byte[] unwrapped = cryptoContext.unwrap(wrapped, encoder);
assertArrayEquals(data, unwrapped);
}
@Test
public void invalidSerialization() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = "x".getBytes(UTF_8);
cryptoContext.unwrap(wrapped, encoder);
}
@Test
public void missingRecipients() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = remove(wrapped, KEY_RECIPIENTS);
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidRecipients() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, KEY_RECIPIENTS, "x");
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void missingRecipient() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, KEY_RECIPIENTS, encoder.createArray());
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidRecipient() throws MslEncoderException, MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final MslArray value = new MslArray(Arrays.asList("x"));
final byte[] missingWrapped = replace(wrapped, KEY_RECIPIENTS, value);
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void missingHeader() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = remove(wrapped, KEY_HEADER);
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidHeader() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, KEY_HEADER, MslEncoderUtils.b64urlEncode("x"));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void missingCek() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = remove(wrapped, KEY_ENCRYPTED_KEY);
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidCek() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.INVALID_SYMMETRIC_KEY);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, KEY_ENCRYPTED_KEY, MslEncoderUtils.b64urlEncode("x"));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void missingIv() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = remove(wrapped, KEY_INITIALIZATION_VECTOR);
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidIv() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNWRAP_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, KEY_INITIALIZATION_VECTOR, MslEncoderUtils.b64urlEncode("x"));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void missingCiphertext() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = remove(wrapped, KEY_CIPHERTEXT);
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidCiphertext() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNWRAP_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, KEY_CIPHERTEXT, MslEncoderUtils.b64urlEncode("x"));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void missingAuthenticationTag() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = remove(wrapped, KEY_INTEGRITY_VALUE);
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidAuthenticationTag() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.INVALID_ALGORITHM_PARAMS);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, KEY_INTEGRITY_VALUE, MslEncoderUtils.b64urlEncode("x"));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void wrongAuthenticationTag() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNWRAP_ERROR);
final byte[] at = new byte[16];
random.nextBytes(at);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] missingWrapped = replace(wrapped, KEY_INTEGRITY_VALUE, MslEncoderUtils.b64urlEncode(at));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void missingAlgorithm() throws MslEncoderException, MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final String headerB64 = get(wrapped, KEY_HEADER);
final MslObject header = encoder.parseObject(MslEncoderUtils.b64urlDecode(headerB64));
assertNotNull(header.remove(KEY_ALGORITHM));
final byte[] missingWrapped = replace(wrapped, KEY_HEADER, MslEncoderUtils.b64urlEncode(encoder.encodeObject(header, MslEncoderFormat.JSON)));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidAlgorithm() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final String headerB64 = get(wrapped, KEY_HEADER);
final MslObject header = encoder.parseObject(MslEncoderUtils.b64urlDecode(headerB64));
header.put(KEY_ALGORITHM, "x");
final byte[] missingWrapped = replace(wrapped, KEY_HEADER, MslEncoderUtils.b64urlEncode(encoder.encodeObject(header, MslEncoderFormat.JSON)));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void missingEncryption() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final String headerB64 = get(wrapped, KEY_HEADER);
final MslObject header = encoder.parseObject(MslEncoderUtils.b64urlDecode(headerB64));
assertNotNull(header.remove(KEY_ENCRYPTION));
final byte[] missingWrapped = replace(wrapped, KEY_HEADER, MslEncoderUtils.b64urlEncode(encoder.encodeObject(header, MslEncoderFormat.JSON)));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void invalidEncryption() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_PARSE_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final String headerB64 = get(wrapped, KEY_HEADER);
final MslObject header = encoder.parseObject(MslEncoderUtils.b64urlDecode(headerB64));
header.put(KEY_ENCRYPTION, "x");
final byte[] missingWrapped = replace(wrapped, KEY_HEADER, MslEncoderUtils.b64urlEncode(encoder.encodeObject(header, MslEncoderFormat.JSON)));
cryptoContext.unwrap(missingWrapped, encoder);
}
@Test
public void badCek() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.INVALID_SYMMETRIC_KEY);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] ecek = new byte[137];
random.nextBytes(ecek);
final byte[] badWrapped = replace(wrapped, KEY_ENCRYPTED_KEY, MslEncoderUtils.b64urlEncode(ecek));
cryptoContext.unwrap(badWrapped, encoder);
}
@Test
public void badIv() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNWRAP_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] iv = new byte[31];
random.nextBytes(iv);
final byte[] badWrapped = replace(wrapped, KEY_INITIALIZATION_VECTOR, MslEncoderUtils.b64urlEncode(iv));
cryptoContext.unwrap(badWrapped, encoder);
}
@Test
public void wrongCek() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.INVALID_SYMMETRIC_KEY);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] cek = new byte[16];
random.nextBytes(cek);
final byte[] ecek = aesCryptoContext.encrypt(cek, encoder, ENCODER_FORMAT);
final byte[] wrongWrapped = replace(wrapped, KEY_ENCRYPTED_KEY, MslEncoderUtils.b64urlEncode(ecek));
cryptoContext.unwrap(wrongWrapped, encoder);
}
@Test
public void wrongIv() throws MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNWRAP_ERROR);
final byte[] wrapped = cryptoContext.wrap(data, encoder, ENCODER_FORMAT);
final byte[] iv = new byte[16];
random.nextBytes(iv);
final byte[] wrongWrapped = replace(wrapped, KEY_INITIALIZATION_VECTOR, MslEncoderUtils.b64urlEncode(iv));
cryptoContext.unwrap(wrongWrapped, encoder);
}
}
/** JSON Web Encryption unit tests. */
public static class JWE {
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
/** JWE crypto context. */
private static ICryptoContext cryptoContext;
@BeforeClass
public static void setup() throws NoSuchAlgorithmException, MslEncodingException, MslCryptoException {
JsonWebEncryptionCryptoContextSuite.setup();
Security.addProvider(new BouncyCastleProvider());
cryptoContext = new JsonWebEncryptionCryptoContext(ctx, rsaCryptoContext, Encryption.A128GCM, Format.JWE_CS);
}
@AfterClass
public static void teardown() {
cryptoContext = null;
}
@Test
public void encrypt() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.ENCRYPT_NOT_SUPPORTED);
cryptoContext.encrypt(new byte[0], encoder, ENCODER_FORMAT);
}
@Test
public void decrypt() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.DECRYPT_NOT_SUPPORTED);
cryptoContext.decrypt(new byte[0], encoder);
}
@Test
public void sign() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.SIGN_NOT_SUPPORTED);
cryptoContext.sign(new byte[0], encoder, ENCODER_FORMAT);
}
@Test
public void verify() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.VERIFY_NOT_SUPPORTED);
cryptoContext.verify(new byte[0], new byte[0], encoder);
}
@Test
public void algorithmMismatch() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_ALGORITHM_MISMATCH);
final ICryptoContext cryptoContextA = new JsonWebEncryptionCryptoContext(ctx, rsaCryptoContext, Encryption.A128GCM, Format.JWE_CS);
final ICryptoContext cryptoContextB = new JsonWebEncryptionCryptoContext(ctx, aesCryptoContext, Encryption.A128GCM, Format.JWE_CS);
final byte[] wrapped = cryptoContextA.wrap(data, encoder, ENCODER_FORMAT);
cryptoContextB.unwrap(wrapped, encoder);
}
@Test
public void encryptionMismatch() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.JWE_ALGORITHM_MISMATCH);
final ICryptoContext cryptoContextA = new JsonWebEncryptionCryptoContext(ctx, rsaCryptoContext, Encryption.A128GCM, Format.JWE_CS);
final ICryptoContext cryptoContextB = new JsonWebEncryptionCryptoContext(ctx, rsaCryptoContext, Encryption.A256GCM, Format.JWE_CS);
final byte[] wrapped = cryptoContextA.wrap(data, encoder, ENCODER_FORMAT);
cryptoContextB.unwrap(wrapped, encoder);
}
}
}
| 9,940 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/crypto/SessionCryptoContextTest.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.crypto;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
import java.util.Date;
import java.util.Random;
import javax.crypto.SecretKey;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
import com.netflix.msl.MslMasterTokenException;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.entityauth.MockPresharedAuthenticationFactory;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.tokens.MasterToken;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* Session crypto context unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class SessionCryptoContextTest {
/** Key ciphertext. */
private final static String KEY_CIPHERTEXT = "ciphertext";
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/**
* @param ctx MSL context.
* @return a new master token.
* @throws MslEncodingException if there is an error encoding the data.
* @throws MslCryptoException if there is an error encrypting or signing
* the token data.
*/
private static MasterToken getTrustedMasterToken(final MslContext ctx) throws MslEncodingException, MslCryptoException {
final Date renewalWindow = new Date(System.currentTimeMillis() + 1000);
final Date expiration = new Date(System.currentTimeMillis() + 2000);
final String identity = MockPresharedAuthenticationFactory.PSK_ESN;
final SecretKey encryptionKey = MockPresharedAuthenticationFactory.KPE;
final SecretKey signatureKey = MockPresharedAuthenticationFactory.KPH;
final MasterToken masterToken = new MasterToken(ctx, renewalWindow, expiration, 1L, 1L, null, identity, encryptionKey, signatureKey);
return masterToken;
}
/**
* @param ctx MSL context.
* @param encryptionKey master token encryption key.
* @param signatureKey master token signature key.
* @return a new master token.
* @throws MslEncodingException if there is an error encoding the data.
* @throws MslCryptoException if there is an error encrypting or signing
* the token data.
* @throws MslException if the master token is constructed incorrectly.
* @throws MslEncoderException if there is an error editing the data.
*/
private static MasterToken getUntrustedMasterToken(final MslContext ctx, final SecretKey encryptionKey, final SecretKey signatureKey) throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
final Date renewalWindow = new Date(System.currentTimeMillis() + 1000);
final Date expiration = new Date(System.currentTimeMillis() + 2000);
final String identity = MockPresharedAuthenticationFactory.PSK_ESN;
final MasterToken masterToken = new MasterToken(ctx, renewalWindow, expiration, 1L, 1L, null, identity, encryptionKey, signatureKey);
final MslObject mo = MslTestUtils.toMslObject(encoder, masterToken);
final byte[] signature = mo.getBytes("signature");
++signature[1];
mo.put("signature", signature);
final MasterToken untrustedMasterToken = new MasterToken(ctx, mo);
return untrustedMasterToken;
}
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
/** MSL context. */
private static MslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
/** Random. */
private static Random random;
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException {
ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = ctx.getMslEncoderFactory();
random = new Random();
}
@AfterClass
public static void teardown() {
random = null;
encoder = null;
ctx = null;
}
@Test
public void untrusted() throws MslEncoderException, MslException {
thrown.expect(MslMasterTokenException.class);
thrown.expectMslError(MslError.MASTERTOKEN_UNTRUSTED);
final SecretKey encryptionKey = MockPresharedAuthenticationFactory.KPE;
final SecretKey signatureKey = MockPresharedAuthenticationFactory.KPH;
final MasterToken masterToken = getUntrustedMasterToken(ctx, encryptionKey, signatureKey);
new SessionCryptoContext(ctx, masterToken);
}
@Test
public void encryptDecrypt() throws MslEncodingException, MslCryptoException, MslMasterTokenException {
final MasterToken masterToken = getTrustedMasterToken(ctx);
final SessionCryptoContext cryptoContext = new SessionCryptoContext(ctx, masterToken);
final byte[] messageA = new byte[32];
random.nextBytes(messageA);
final byte[] ciphertextA = cryptoContext.encrypt(messageA, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextA);
assertThat(messageA, is(not(ciphertextA)));
final byte[] plaintextA = cryptoContext.decrypt(ciphertextA, encoder);
assertNotNull(plaintextA);
assertArrayEquals(messageA, plaintextA);
final byte[] messageB = new byte[32];
random.nextBytes(messageB);
final byte[] ciphertextB = cryptoContext.encrypt(messageB, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextB);
assertThat(messageB, is(not(ciphertextB)));
assertThat(ciphertextB, is(not(ciphertextA)));
final byte[] plaintextB = cryptoContext.decrypt(ciphertextB, encoder);
assertNotNull(plaintextB);
assertArrayEquals(messageB, plaintextB);
}
@Test
public void encryptDecryptKeys() throws MslEncoderException, MslException {
final String identity = MockPresharedAuthenticationFactory.PSK_ESN;
final SecretKey encryptionKey = MockPresharedAuthenticationFactory.KPE;
final SecretKey signatureKey = MockPresharedAuthenticationFactory.KPH;
final MasterToken masterToken = getUntrustedMasterToken(ctx, encryptionKey, signatureKey);
final SessionCryptoContext cryptoContext = new SessionCryptoContext(ctx, masterToken, identity, encryptionKey, signatureKey);
final byte[] messageA = new byte[32];
random.nextBytes(messageA);
final byte[] ciphertextA = cryptoContext.encrypt(messageA, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextA);
assertThat(messageA, is(not(ciphertextA)));
final byte[] plaintextA = cryptoContext.decrypt(ciphertextA, encoder);
assertNotNull(plaintextA);
assertArrayEquals(messageA, plaintextA);
final byte[] messageB = new byte[32];
random.nextBytes(messageB);
final byte[] ciphertextB = cryptoContext.encrypt(messageB, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextB);
assertThat(messageB, is(not(ciphertextB)));
assertThat(ciphertextB, is(not(ciphertextA)));
final byte[] plaintextB = cryptoContext.decrypt(ciphertextB, encoder);
assertNotNull(plaintextB);
assertArrayEquals(messageB, plaintextB);
}
@Test
public void invalidCiphertext() throws MslEncodingException, MslCryptoException, MslEncoderException, MslMasterTokenException, UnsupportedEncodingException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.CIPHERTEXT_BAD_PADDING);
final MasterToken masterToken = getTrustedMasterToken(ctx);
final SessionCryptoContext cryptoContext = new SessionCryptoContext(ctx, masterToken);
final byte[] message = new byte[32];
random.nextBytes(message);
final byte[] data = cryptoContext.encrypt(message, encoder, ENCODER_FORMAT);
final MslObject envelopeMo = encoder.parseObject(data);
final MslCiphertextEnvelope envelope = new MslCiphertextEnvelope(envelopeMo);
final byte[] ciphertext = envelope.getCiphertext();
++ciphertext[ciphertext.length - 1];
final MslCiphertextEnvelope shortEnvelope = new MslCiphertextEnvelope(envelope.getKeyId(), envelope.getIv(), ciphertext);
cryptoContext.decrypt(shortEnvelope.toMslEncoding(encoder, ENCODER_FORMAT), encoder);
}
// I want this to catch the ArrayIndexOutOfBounds
// MslError.INSUFFICIENT_CIPHERTEXT but I'm not sure how to trigger it
// anymore.
@Test
public void insufficientCiphertext() throws MslCryptoException, MslEncoderException, MslEncodingException, MslMasterTokenException, UnsupportedEncodingException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.CIPHERTEXT_ILLEGAL_BLOCK_SIZE);
final MasterToken masterToken = getTrustedMasterToken(ctx);
final SessionCryptoContext cryptoContext = new SessionCryptoContext(ctx, masterToken);
final byte[] message = new byte[32];
random.nextBytes(message);
final byte[] data = cryptoContext.encrypt(message, encoder, ENCODER_FORMAT);
final MslObject envelopeMo = encoder.parseObject(data);
final MslCiphertextEnvelope envelope = new MslCiphertextEnvelope(envelopeMo);
final byte[] ciphertext = envelope.getCiphertext();
final byte[] shortCiphertext = Arrays.copyOf(ciphertext, ciphertext.length - 1);
final MslCiphertextEnvelope shortEnvelope = new MslCiphertextEnvelope(envelope.getKeyId(), envelope.getIv(), shortCiphertext);
cryptoContext.decrypt(shortEnvelope.toMslEncoding(encoder, ENCODER_FORMAT), encoder);
}
@Test
public void notEnvelope() throws MslCryptoException, MslEncoderException, MslEncodingException, MslMasterTokenException, UnsupportedEncodingException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.CIPHERTEXT_ENVELOPE_PARSE_ERROR);
final MasterToken masterToken = getTrustedMasterToken(ctx);
final SessionCryptoContext cryptoContext = new SessionCryptoContext(ctx, masterToken);
final byte[] message = new byte[32];
random.nextBytes(message);
final byte[] data = cryptoContext.encrypt(message, encoder, ENCODER_FORMAT);
final MslObject envelopeMo = encoder.parseObject(data);
envelopeMo.remove(KEY_CIPHERTEXT);
cryptoContext.decrypt(encoder.encodeObject(envelopeMo, ENCODER_FORMAT), encoder);
}
@Test
public void corruptEnvelope() throws MslCryptoException, MslEncodingException, MslMasterTokenException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.CIPHERTEXT_ENVELOPE_PARSE_ERROR);
final MasterToken masterToken = getTrustedMasterToken(ctx);
final SessionCryptoContext cryptoContext = new SessionCryptoContext(ctx, masterToken);
final byte[] message = new byte[32];
random.nextBytes(message);
final byte[] data = cryptoContext.encrypt(message, encoder, ENCODER_FORMAT);
data[0] = 0;
cryptoContext.decrypt(data, encoder);
}
@Test
public void encryptDecryptNullEncryption() throws MslEncoderException, MslException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.ENCRYPT_NOT_SUPPORTED);
final String identity = MockPresharedAuthenticationFactory.PSK_ESN;
final SecretKey encryptionKey = MockPresharedAuthenticationFactory.KPE;
final SecretKey signatureKey = MockPresharedAuthenticationFactory.KPH;
final MasterToken masterToken;
try {
masterToken = getUntrustedMasterToken(ctx, encryptionKey, signatureKey);
} catch (final MslCryptoException e) {
fail(e.getMessage());
return;
}
final SessionCryptoContext cryptoContext = new SessionCryptoContext(ctx, masterToken, identity, null, signatureKey);
final byte[] messageA = new byte[32];
random.nextBytes(messageA);
cryptoContext.encrypt(messageA, encoder, ENCODER_FORMAT);
}
@Test
public void encryptDecryptNullSignature() throws MslEncoderException, MslException {
final String identity = MockPresharedAuthenticationFactory.PSK_ESN;
final SecretKey encryptionKey = MockPresharedAuthenticationFactory.KPE;
final SecretKey signatureKey = MockPresharedAuthenticationFactory.KPH;
final MasterToken masterToken = getUntrustedMasterToken(ctx, encryptionKey, signatureKey);
final SessionCryptoContext cryptoContext = new SessionCryptoContext(ctx, masterToken, identity, encryptionKey, null);
final byte[] messageA = new byte[32];
random.nextBytes(messageA);
final byte[] ciphertextA = cryptoContext.encrypt(messageA, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextA);
assertThat(messageA, is(not(ciphertextA)));
final byte[] plaintextA = cryptoContext.decrypt(ciphertextA, encoder);
assertNotNull(plaintextA);
assertArrayEquals(messageA, plaintextA);
final byte[] messageB = new byte[32];
random.nextBytes(messageB);
final byte[] ciphertextB = cryptoContext.encrypt(messageB, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextB);
assertThat(messageB, is(not(ciphertextB)));
assertThat(ciphertextB, is(not(ciphertextA)));
final byte[] plaintextB = cryptoContext.decrypt(ciphertextB, encoder);
assertNotNull(plaintextB);
assertArrayEquals(messageB, plaintextB);
}
@Test
public void encryptDecryptIdMismatch() throws MslEncoderException, MslException {
final String identity = MockPresharedAuthenticationFactory.PSK_ESN;
final SecretKey encryptionKey = MockPresharedAuthenticationFactory.KPE;
final SecretKey signatureKey = MockPresharedAuthenticationFactory.KPH;
final MasterToken masterToken;
try {
masterToken = getUntrustedMasterToken(ctx, encryptionKey, signatureKey);
} catch (final MslCryptoException e) {
fail(e.getMessage());
return;
}
// With untrusted master tokens, there is no way of verifying the
// identity provided against the internals of the master token. So this
// test makes use of two session crypto contexts with different
// identities.
final SessionCryptoContext cryptoContextA = new SessionCryptoContext(ctx, masterToken, identity + "A", encryptionKey, signatureKey);
final SessionCryptoContext cryptoContextB = new SessionCryptoContext(ctx, masterToken, identity + "B", encryptionKey, signatureKey);
final byte[] message = new byte[32];
random.nextBytes(message);
final byte[] ciphertext = cryptoContextA.encrypt(message, encoder, ENCODER_FORMAT);
assertNotNull(ciphertext);
assertThat(message, is(not(ciphertext)));
final byte[] plaintext = cryptoContextB.decrypt(ciphertext, encoder);
assertNotNull(plaintext);
assertArrayEquals(message, plaintext);
}
@Test
public void encryptDecryptKeysMismatch() throws MslEncoderException, MslException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.CIPHERTEXT_BAD_PADDING);
final String identity = MockPresharedAuthenticationFactory.PSK_ESN;
final SecretKey encryptionKeyA = MockPresharedAuthenticationFactory.KPE;
final SecretKey signatureKeyA = MockPresharedAuthenticationFactory.KPH;
final SecretKey encryptionKeyB = MockPresharedAuthenticationFactory.KPE2;
final SecretKey signatureKeyB = MockPresharedAuthenticationFactory.KPH2;
final MasterToken masterTokenA, masterTokenB;
try {
masterTokenA = getUntrustedMasterToken(ctx, encryptionKeyA, signatureKeyA);
masterTokenB = getUntrustedMasterToken(ctx, encryptionKeyB, signatureKeyB);
} catch (final MslCryptoException e) {
fail(e.getMessage());
return;
}
final SessionCryptoContext cryptoContextA = new SessionCryptoContext(ctx, masterTokenA, identity, encryptionKeyA, signatureKeyA);
final SessionCryptoContext cryptoContextB = new SessionCryptoContext(ctx, masterTokenB, identity, encryptionKeyB, signatureKeyB);
final byte[] message = new byte[32];
random.nextBytes(message);
final byte[] ciphertext;
try {
ciphertext = cryptoContextA.encrypt(message, encoder, ENCODER_FORMAT);
} catch (final MslCryptoException e) {
fail(e.getMessage());
return;
}
cryptoContextB.decrypt(ciphertext, encoder);
}
@Test
public void signVerify() throws MslCryptoException, MslEncodingException, MslMasterTokenException {
final MasterToken masterToken = getTrustedMasterToken(ctx);
final SessionCryptoContext cryptoContext = new SessionCryptoContext(ctx, masterToken);
final byte[] messageA = new byte[32];
random.nextBytes(messageA);
final byte[] signatureA = cryptoContext.sign(messageA, encoder, ENCODER_FORMAT);
assertNotNull(signatureA);
assertTrue(signatureA.length > 0);
assertThat(messageA, is(not(signatureA)));
assertTrue(cryptoContext.verify(messageA, signatureA, encoder));
final byte[] messageB = new byte[32];
random.nextBytes(messageB);
final byte[] signatureB = cryptoContext.sign(messageB, encoder, ENCODER_FORMAT);
assertTrue(signatureB.length > 0);
assertThat(signatureA, is(not(signatureB)));
assertTrue(cryptoContext.verify(messageB, signatureB, encoder));
assertFalse(cryptoContext.verify(messageB, signatureA, encoder));
}
@Test
public void signVerifyContextMismatch() throws MslEncoderException, MslException {
final String identity = MockPresharedAuthenticationFactory.PSK_ESN;
final SecretKey encryptionKeyA = MockPresharedAuthenticationFactory.KPE;
final SecretKey signatureKeyA = MockPresharedAuthenticationFactory.KPH;
final SecretKey encryptionKeyB = MockPresharedAuthenticationFactory.KPE2;
final SecretKey signatureKeyB = MockPresharedAuthenticationFactory.KPH2;
final MasterToken masterTokenA, masterTokenB;
try {
masterTokenA = getUntrustedMasterToken(ctx, encryptionKeyA, signatureKeyA);
masterTokenB = getUntrustedMasterToken(ctx, encryptionKeyB, signatureKeyB);
} catch (final MslCryptoException e) {
fail(e.getMessage());
return;
}
final SessionCryptoContext cryptoContextA = new SessionCryptoContext(ctx, masterTokenA, identity, encryptionKeyA, signatureKeyA);
final SessionCryptoContext cryptoContextB = new SessionCryptoContext(ctx, masterTokenB, identity, encryptionKeyB, signatureKeyB);
final byte[] message = new byte[32];
random.nextBytes(message);
final byte[] signature = cryptoContextA.sign(message, encoder, ENCODER_FORMAT);
assertFalse(cryptoContextB.verify(message, signature, encoder));
}
@Test
public void signVerifyKeys() throws MslEncoderException, MslException {
final String identity = MockPresharedAuthenticationFactory.PSK_ESN;
final SecretKey encryptionKey = MockPresharedAuthenticationFactory.KPE;
final SecretKey signatureKey = MockPresharedAuthenticationFactory.KPH;
final MasterToken masterToken = getUntrustedMasterToken(ctx, encryptionKey, signatureKey);
final SessionCryptoContext cryptoContext = new SessionCryptoContext(ctx, masterToken, identity, encryptionKey, signatureKey);
final byte[] messageA = new byte[32];
random.nextBytes(messageA);
final byte[] signatureA = cryptoContext.sign(messageA, encoder, ENCODER_FORMAT);
assertNotNull(signatureA);
assertTrue(signatureA.length > 0);
assertThat(messageA, is(not(signatureA)));
assertTrue(cryptoContext.verify(messageA, signatureA, encoder));
final byte[] messageB = new byte[32];
random.nextBytes(messageB);
final byte[] signatureB = cryptoContext.sign(messageB, encoder, ENCODER_FORMAT);
assertTrue(signatureB.length > 0);
assertThat(signatureA, is(not(signatureB)));
assertTrue(cryptoContext.verify(messageB, signatureB, encoder));
assertFalse(cryptoContext.verify(messageB, signatureA, encoder));
}
@Test
public void signVerifyNullEncryption() throws MslEncoderException, MslException {
final String identity = MockPresharedAuthenticationFactory.PSK_ESN;
final SecretKey encryptionKey = MockPresharedAuthenticationFactory.KPE;
final SecretKey signatureKey = MockPresharedAuthenticationFactory.KPH;
final MasterToken masterToken = getUntrustedMasterToken(ctx, encryptionKey, signatureKey);
final SessionCryptoContext cryptoContext = new SessionCryptoContext(ctx, masterToken, identity, null, signatureKey);
final byte[] messageA = new byte[32];
random.nextBytes(messageA);
final byte[] signatureA = cryptoContext.sign(messageA, encoder, ENCODER_FORMAT);
assertNotNull(signatureA);
assertTrue(signatureA.length > 0);
assertThat(messageA, is(not(signatureA)));
assertTrue(cryptoContext.verify(messageA, signatureA, encoder));
final byte[] messageB = new byte[32];
random.nextBytes(messageB);
final byte[] signatureB = cryptoContext.sign(messageB, encoder, ENCODER_FORMAT);
assertTrue(signatureB.length > 0);
assertThat(signatureA, is(not(signatureB)));
assertTrue(cryptoContext.verify(messageB, signatureB, encoder));
assertFalse(cryptoContext.verify(messageB, signatureA, encoder));
}
@Test
public void verifyNullSignature() throws MslEncoderException, MslException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.SIGN_NOT_SUPPORTED);
final String identity = MockPresharedAuthenticationFactory.PSK_ESN;
final SecretKey encryptionKey = MockPresharedAuthenticationFactory.KPE;
final SecretKey signatureKey = MockPresharedAuthenticationFactory.KPH;
final MasterToken masterToken;
try {
masterToken = getUntrustedMasterToken(ctx, encryptionKey, signatureKey);
} catch (final MslCryptoException e) {
fail(e.getMessage());
return;
}
final SessionCryptoContext cryptoContext = new SessionCryptoContext(ctx, masterToken, identity, encryptionKey, null);
final byte[] messageA = new byte[32];
random.nextBytes(messageA);
cryptoContext.sign(messageA, encoder, ENCODER_FORMAT);
}
}
| 9,941 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/crypto/EccCryptoContextSuite.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.crypto;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.math.BigInteger;
import java.security.InvalidAlgorithmParameterException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Security;
import java.security.spec.AlgorithmParameterSpec;
import java.security.spec.InvalidParameterSpecException;
import java.util.Random;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.jce.spec.ECParameterSpec;
import org.bouncycastle.math.ec.ECCurve;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.crypto.EccCryptoContext.Mode;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
/**
* ECC crypto context unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
@RunWith(Suite.class)
@SuiteClasses({EccCryptoContextSuite.EncryptDecrypt.class,
EccCryptoContextSuite.SignVerify.class})
public class EccCryptoContextSuite {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key pair ID. */
private static final String KEYPAIR_ID = "keypairid";
/** EC curve q. */
private static final BigInteger EC_Q = new BigInteger("883423532389192164791648750360308885314476597252960362792450860609699839");
/** EC coefficient a. */
private static final BigInteger EC_A = new BigInteger("7fffffffffffffffffffffff7fffffffffff8000000000007ffffffffffc", 16);
/** EC coefficient b. */
private static final BigInteger EC_B = new BigInteger("6b016c3bdcf18941d0d654921475ca71a9db2fb27d1d37796185c2942c0a", 16);
/** EC base point g. */
private static final BigInteger EC_G = new BigInteger("020ffa963cdca8816ccc33b8642bedf905c3d358573d3f27fbbd3b3cb9aaaf", 16);
/** EC generator order n. */
private static final BigInteger EC_N = new BigInteger("883423532389192164791648750360308884807550341691627752275345424702807307");
@AfterClass
public static synchronized void teardown() {
// Teardown causes problems because the data is shared by the inner
// classes, so don't do any cleanup.
}
/** Encrypt/decrypt mode unit tests. */
@Ignore // Cannot perform ECIES encryption/decryption at the moment.
public static class EncryptDecrypt {
}
/** Sign/verify mode unit tests. */
public static class SignVerify {
@BeforeClass
public static synchronized void setup() throws NoSuchAlgorithmException, InvalidAlgorithmParameterException, InvalidParameterSpecException, NoSuchProviderException, MslEncodingException, MslCryptoException {
if (random == null) {
Security.addProvider(new BouncyCastleProvider());
final MslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = ctx.getMslEncoderFactory();
final ECCurve curve = new ECCurve.Fp(EC_Q, EC_A, EC_B);
final AlgorithmParameterSpec paramSpec = new ECParameterSpec(curve, curve.decodePoint(EC_G.toByteArray()), EC_N);
final KeyPairGenerator keypairGenerator = KeyPairGenerator.getInstance("ECDSA", "BC");
keypairGenerator.initialize(paramSpec);
final KeyPair keypairA = keypairGenerator.generateKeyPair();
privateKeyA = keypairA.getPrivate();
publicKeyA = keypairA.getPublic();
keypairGenerator.initialize(paramSpec);
final KeyPair keypairB = keypairGenerator.generateKeyPair();
privateKeyB = keypairB.getPrivate();
publicKeyB = keypairB.getPublic();
random = new Random();
}
}
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@Test
public void encryptDecrypt() throws MslCryptoException {
final byte[] message = new byte[32];
random.nextBytes(message);
final EccCryptoContext cryptoContext = new EccCryptoContext(KEYPAIR_ID, privateKeyA, publicKeyA, Mode.SIGN_VERIFY);
final byte[] ciphertext = cryptoContext.encrypt(message, encoder, ENCODER_FORMAT);
assertNotNull(ciphertext);
assertArrayEquals(message, ciphertext);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
assertNotNull(plaintext);
assertArrayEquals(message, plaintext);
}
@Test
public void encryptNullPublic() throws MslCryptoException {
final byte[] message = new byte[32];
random.nextBytes(message);
final EccCryptoContext cryptoContext = new EccCryptoContext(KEYPAIR_ID, privateKeyA, null, Mode.SIGN_VERIFY);
final byte[] ciphertext = cryptoContext.encrypt(message, encoder, ENCODER_FORMAT);
assertNotNull(ciphertext);
assertArrayEquals(message, ciphertext);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
assertNotNull(plaintext);
assertArrayEquals(message, plaintext);
}
@Test
public void decryptNullPrivate() throws MslCryptoException {
final byte[] message = new byte[32];
random.nextBytes(message);
final EccCryptoContext cryptoContext = new EccCryptoContext(KEYPAIR_ID, null, publicKeyA, Mode.SIGN_VERIFY);
final byte[] ciphertext = cryptoContext.encrypt(message, encoder, ENCODER_FORMAT);
assertNotNull(ciphertext);
assertArrayEquals(message, ciphertext);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
assertNotNull(plaintext);
assertArrayEquals(message, plaintext);
}
@Test
public void encryptDecryptIdMismatch() throws MslCryptoException {
final byte[] message = new byte[32];
random.nextBytes(message);
final EccCryptoContext cryptoContextA = new EccCryptoContext(KEYPAIR_ID + "A", privateKeyA, publicKeyA, Mode.SIGN_VERIFY);
final byte[] ciphertext = cryptoContextA.encrypt(message, encoder, ENCODER_FORMAT);
assertNotNull(ciphertext);
assertArrayEquals(message, ciphertext);
final EccCryptoContext cryptoContextB = new EccCryptoContext(KEYPAIR_ID + "B", privateKeyB, publicKeyB, Mode.SIGN_VERIFY);
final byte[] plaintext = cryptoContextB.decrypt(ciphertext, encoder);
assertNotNull(plaintext);
assertArrayEquals(message, plaintext);
}
@Test
public void encryptDecryptKeyMismatch() throws MslCryptoException {
final byte[] message = new byte[32];
random.nextBytes(message);
final EccCryptoContext cryptoContextA = new EccCryptoContext(KEYPAIR_ID, privateKeyA, publicKeyA, Mode.SIGN_VERIFY);
final byte[] ciphertext = cryptoContextA.encrypt(message, encoder, ENCODER_FORMAT);
assertNotNull(ciphertext);
assertArrayEquals(message, ciphertext);
final EccCryptoContext cryptoContextB = new EccCryptoContext(KEYPAIR_ID, privateKeyB, publicKeyB, Mode.SIGN_VERIFY);
final byte[] plaintext = cryptoContextB.decrypt(ciphertext, encoder);
assertNotNull(plaintext);
assertArrayEquals(message, plaintext);
}
@Test
public void signVerify() throws MslCryptoException {
final byte[] messageA = new byte[32];
random.nextBytes(messageA);
final EccCryptoContext cryptoContext = new EccCryptoContext(KEYPAIR_ID, privateKeyA, publicKeyA, Mode.SIGN_VERIFY);
final byte[] signatureA = cryptoContext.sign(messageA, encoder, ENCODER_FORMAT);
assertNotNull(signatureA);
assertTrue(signatureA.length > 0);
assertThat(messageA, is(not(signatureA)));
assertTrue(cryptoContext.verify(messageA, signatureA, encoder));
final byte[] messageB = new byte[32];
random.nextBytes(messageB);
final byte[] signatureB = cryptoContext.sign(messageB, encoder, ENCODER_FORMAT);
assertTrue(signatureB.length > 0);
assertThat(signatureA, is(not(signatureB)));
assertTrue(cryptoContext.verify(messageB, signatureB, encoder));
assertFalse(cryptoContext.verify(messageB, signatureA, encoder));
}
@Test
public void signVerifyContextMismatch() throws MslCryptoException {
final byte[] message = new byte[32];
random.nextBytes(message);
final EccCryptoContext cryptoContextA = new EccCryptoContext(KEYPAIR_ID, privateKeyA, publicKeyA, Mode.SIGN_VERIFY);
final byte[] signature = cryptoContextA.sign(message, encoder, ENCODER_FORMAT);
final EccCryptoContext cryptoContextB = new EccCryptoContext(KEYPAIR_ID, privateKeyB, publicKeyB, Mode.SIGN_VERIFY);
assertFalse(cryptoContextB.verify(message, signature, encoder));
}
@Test
public void signNullPrivate() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.SIGN_NOT_SUPPORTED);
final byte[] message = new byte[32];
random.nextBytes(message);
final EccCryptoContext cryptoContext = new EccCryptoContext(KEYPAIR_ID, null, publicKeyA, Mode.SIGN_VERIFY);
cryptoContext.sign(message, encoder, ENCODER_FORMAT);
}
@Test
public void verifyNullPublic() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.VERIFY_NOT_SUPPORTED);
final byte[] message = new byte[32];
random.nextBytes(message);
final EccCryptoContext cryptoContext = new EccCryptoContext(KEYPAIR_ID, privateKeyA, null, Mode.SIGN_VERIFY);
final byte[] signature;
try {
signature = cryptoContext.sign(message, encoder, ENCODER_FORMAT);
} catch (final MslCryptoException e) {
fail(e.getMessage());
return;
}
cryptoContext.verify(message, signature, encoder);
}
}
/** ECC public key A. */
private static PublicKey publicKeyA;
/** ECC private key A. */
private static PrivateKey privateKeyA;
/** ECC public key B. */
private static PublicKey publicKeyB;
/** ECC private key B. */
private static PrivateKey privateKeyB;
/** Random. */
private static Random random;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
}
| 9,942 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/crypto/MslCiphertextEnvelopeSuite.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.crypto;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Random;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;
import com.netflix.msl.MslConstants.CipherSpec;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.crypto.MslCiphertextEnvelope.Version;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
/**
* MSL encryption envelope unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
@RunWith(Suite.class)
@SuiteClasses({MslCiphertextEnvelopeSuite.Version1.class,
MslCiphertextEnvelopeSuite.Version2.class})
public class MslCiphertextEnvelopeSuite {
/** Key version. */
private final static String KEY_VERSION = "version";
/** Key key ID. */
private final static String KEY_KEY_ID = "keyid";
/** Key cipherspec. */
private final static String KEY_CIPHERSPEC = "cipherspec";
/** Key initialization vector. */
private final static String KEY_IV = "iv";
/** Key ciphertext. */
private final static String KEY_CIPHERTEXT = "ciphertext";
/** Key SHA-256. */
private final static String KEY_SHA256 = "sha256";
/** MSL encoder format. */
private final static MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key ID. */
private final static String KEY_ID = "keyid";
private static final byte[] IV = new byte[16];
private static final byte[] CIPHERTEXT = new byte[32];
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException {
final Random random = new Random();
random.nextBytes(IV);
random.nextBytes(CIPHERTEXT);
final MslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = ctx.getMslEncoderFactory();
}
@AfterClass
public static void teardown() {
// Teardown causes problems because the data is shared by the inner
// classes, so don't do any cleanup.
}
public static class Version1 {
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@Test
public void ctors() throws MslCryptoException, MslEncodingException, MslEncoderException {
final MslCiphertextEnvelope envelope = new MslCiphertextEnvelope(KEY_ID, IV, CIPHERTEXT);
assertEquals(KEY_ID, envelope.getKeyId());
assertNull(envelope.getCipherSpec());
assertArrayEquals(IV, envelope.getIv());
assertArrayEquals(CIPHERTEXT, envelope.getCiphertext());
final byte[] encode = envelope.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final MslObject mo = encoder.parseObject(encode);
final MslCiphertextEnvelope moEnvelope = new MslCiphertextEnvelope(mo);
assertEquals(envelope.getKeyId(), moEnvelope.getKeyId());
assertEquals(envelope.getCipherSpec(), moEnvelope.getCipherSpec());
assertArrayEquals(envelope.getIv(), moEnvelope.getIv());
assertArrayEquals(envelope.getCiphertext(), moEnvelope.getCiphertext());
final byte[] moEncode = moEnvelope.toMslEncoding(encoder, ENCODER_FORMAT);
assertArrayEquals(encode, moEncode);
}
@Test
public void ctorsNullIv() throws MslEncoderException, MslCryptoException, MslEncodingException {
final MslCiphertextEnvelope envelope = new MslCiphertextEnvelope(KEY_ID, null, CIPHERTEXT);
assertEquals(KEY_ID, envelope.getKeyId());
assertNull(envelope.getCipherSpec());
assertNull(envelope.getIv());
assertArrayEquals(CIPHERTEXT, envelope.getCiphertext());
final byte[] encode = envelope.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final MslObject mo = encoder.parseObject(encode);
final MslCiphertextEnvelope moEnvelope = new MslCiphertextEnvelope(mo);
assertEquals(envelope.getKeyId(), moEnvelope.getKeyId());
assertEquals(envelope.getCipherSpec(), moEnvelope.getCipherSpec());
assertArrayEquals(envelope.getIv(), moEnvelope.getIv());
assertArrayEquals(envelope.getCiphertext(), moEnvelope.getCiphertext());
final byte[] moEncode = moEnvelope.toMslEncoding(encoder, ENCODER_FORMAT);
assertArrayEquals(encode, moEncode);
}
@Test
public void encode() throws MslEncoderException, MslCryptoException, MslEncodingException {
final MslCiphertextEnvelope envelope = new MslCiphertextEnvelope(KEY_ID, IV, CIPHERTEXT);
final byte[] encode = envelope.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
assertEquals(KEY_ID, mo.getString(KEY_KEY_ID));
assertFalse(mo.has(KEY_CIPHERSPEC));
assertArrayEquals(IV, mo.getBytes(KEY_IV));
assertArrayEquals(CIPHERTEXT, mo.getBytes(KEY_CIPHERTEXT));
}
@Test
public void encodeNullIv() throws MslCryptoException, MslEncodingException, MslEncoderException {
final MslCiphertextEnvelope envelope = new MslCiphertextEnvelope(KEY_ID, null, CIPHERTEXT);
final byte[] encode = envelope.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
assertEquals(KEY_ID, mo.getString(KEY_KEY_ID));
assertFalse(mo.has(KEY_CIPHERSPEC));
assertFalse(mo.has(KEY_IV));
assertArrayEquals(CIPHERTEXT, mo.getBytes(KEY_CIPHERTEXT));
}
@Test
public void missingKeyId() throws MslEncoderException, MslCryptoException, MslEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final MslCiphertextEnvelope envelope = new MslCiphertextEnvelope(KEY_ID, IV, CIPHERTEXT);
final byte[] encode = envelope.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
mo.remove(KEY_KEY_ID);
new MslCiphertextEnvelope(mo);
}
@Test
public void missingCiphertext() throws MslEncoderException, MslCryptoException, MslEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final MslCiphertextEnvelope envelope = new MslCiphertextEnvelope(KEY_ID, IV, CIPHERTEXT);
final byte[] encode = envelope.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
mo.remove(KEY_CIPHERTEXT);
new MslCiphertextEnvelope(mo);
}
@Test
public void missingSha256() throws MslEncoderException, MslCryptoException, MslEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final MslCiphertextEnvelope envelope = new MslCiphertextEnvelope(KEY_ID, IV, CIPHERTEXT);
final byte[] encode = envelope.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
mo.remove(KEY_SHA256);
new MslCiphertextEnvelope(mo);
}
@Test
public void incorrectSha256() throws MslEncoderException, MslCryptoException, MslEncodingException {
final MslCiphertextEnvelope envelope = new MslCiphertextEnvelope(KEY_ID, IV, CIPHERTEXT);
final byte[] encode = envelope.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] hash = mo.getBytes(KEY_SHA256);
assertNotNull(hash);
hash[0] += 1;
mo.put(KEY_SHA256, hash);
final MslCiphertextEnvelope moEnvelope = new MslCiphertextEnvelope(mo);
assertEquals(KEY_ID, moEnvelope.getKeyId());
assertNull(moEnvelope.getCipherSpec());
assertArrayEquals(IV, moEnvelope.getIv());
assertArrayEquals(CIPHERTEXT, moEnvelope.getCiphertext());
}
}
@RunWith(Parameterized.class)
public static class Version2 {
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@Parameters
public static Collection<Object[]> data() {
final List<Object[]> params = new ArrayList<Object[]>();
for (final CipherSpec spec : CipherSpec.values())
params.add(new Object[] { spec });
return params;
}
/** Cipher specification. */
private final CipherSpec cipherSpec;
/**
* Create a new Version 2 test set with the provided cipher
* specification.
*
* @param cipherSpec the cipher specification.
*/
public Version2(final CipherSpec cipherSpec) {
this.cipherSpec = cipherSpec;
}
@Test
public void ctors() throws MslCryptoException, MslEncodingException, MslEncoderException {
final MslCiphertextEnvelope envelope = new MslCiphertextEnvelope(cipherSpec, IV, CIPHERTEXT);
assertNull(envelope.getKeyId());
assertEquals(cipherSpec, envelope.getCipherSpec());
assertArrayEquals(IV, envelope.getIv());
assertArrayEquals(CIPHERTEXT, envelope.getCiphertext());
final byte[] encode = envelope.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final MslObject mo = encoder.parseObject(encode);
final MslCiphertextEnvelope moEnvelope = new MslCiphertextEnvelope(mo);
assertEquals(envelope.getKeyId(), moEnvelope.getKeyId());
assertEquals(envelope.getCipherSpec(), moEnvelope.getCipherSpec());
assertArrayEquals(envelope.getIv(), moEnvelope.getIv());
assertArrayEquals(envelope.getCiphertext(), moEnvelope.getCiphertext());
final byte[] moEncode = moEnvelope.toMslEncoding(encoder, ENCODER_FORMAT);
assertArrayEquals(encode, moEncode);
}
@Test
public void ctorsNullIv() throws MslEncoderException, MslCryptoException, MslEncodingException {
final MslCiphertextEnvelope envelope = new MslCiphertextEnvelope(cipherSpec, null, CIPHERTEXT);
assertNull(envelope.getKeyId());
assertEquals(cipherSpec, envelope.getCipherSpec());
assertNull(envelope.getIv());
assertArrayEquals(CIPHERTEXT, envelope.getCiphertext());
final byte[] encode = envelope.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final MslObject mo = encoder.parseObject(encode);
final MslCiphertextEnvelope moEnvelope = new MslCiphertextEnvelope(mo);
assertEquals(envelope.getKeyId(), moEnvelope.getKeyId());
assertEquals(envelope.getCipherSpec(), moEnvelope.getCipherSpec());
assertArrayEquals(envelope.getIv(), moEnvelope.getIv());
assertArrayEquals(envelope.getCiphertext(), moEnvelope.getCiphertext());
final byte[] moEncode = moEnvelope.toMslEncoding(encoder, ENCODER_FORMAT);
assertArrayEquals(encode, moEncode);
}
@Test
public void encode() throws MslEncoderException, MslCryptoException, MslEncodingException {
final MslCiphertextEnvelope envelope = new MslCiphertextEnvelope(cipherSpec, IV, CIPHERTEXT);
final byte[] encode = envelope.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
assertEquals(Version.V2.intValue(), mo.getInt(KEY_VERSION));
assertFalse(mo.has(KEY_KEY_ID));
assertEquals(cipherSpec.toString(), mo.getString(KEY_CIPHERSPEC));
assertArrayEquals(IV, mo.getBytes(KEY_IV));
assertArrayEquals(CIPHERTEXT, mo.getBytes(KEY_CIPHERTEXT));
}
@Test
public void encodeNullIv() throws MslCryptoException, MslEncodingException, MslEncoderException {
final MslCiphertextEnvelope envelope = new MslCiphertextEnvelope(cipherSpec, null, CIPHERTEXT);
final byte[] encode = envelope.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
assertEquals(Version.V2.intValue(), mo.getInt(KEY_VERSION));
assertFalse(mo.has(KEY_KEY_ID));
assertEquals(cipherSpec.toString(), mo.getString(KEY_CIPHERSPEC));
assertFalse(mo.has(KEY_IV));
assertArrayEquals(CIPHERTEXT, mo.getBytes(KEY_CIPHERTEXT));
}
@Test
public void misingVersion() throws MslEncoderException, MslCryptoException, MslEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final MslCiphertextEnvelope envelope = new MslCiphertextEnvelope(cipherSpec, IV, CIPHERTEXT);
final byte[] encode = envelope.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
mo.remove(KEY_VERSION);
new MslCiphertextEnvelope(mo);
}
@Test
public void invalidVersion() throws MslEncoderException, MslCryptoException, MslEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final MslCiphertextEnvelope envelope = new MslCiphertextEnvelope(cipherSpec, IV, CIPHERTEXT);
final byte[] encode = envelope.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
mo.put(KEY_VERSION, "x");
new MslCiphertextEnvelope(mo);
}
@Test
public void unknownVersion() throws MslEncoderException, MslCryptoException, MslEncodingException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNIDENTIFIED_CIPHERTEXT_ENVELOPE);
final MslCiphertextEnvelope envelope = new MslCiphertextEnvelope(cipherSpec, IV, CIPHERTEXT);
final byte[] encode = envelope.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
mo.put(KEY_VERSION, -1);
new MslCiphertextEnvelope(mo);
}
@Test
public void missingCipherSpec() throws MslEncoderException, MslCryptoException, MslEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final MslCiphertextEnvelope envelope = new MslCiphertextEnvelope(cipherSpec, IV, CIPHERTEXT);
final byte[] encode = envelope.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
mo.remove(KEY_CIPHERSPEC);
new MslCiphertextEnvelope(mo);
}
@Test
public void invalidCipherSpec() throws MslEncoderException, MslCryptoException, MslEncodingException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNIDENTIFIED_CIPHERSPEC);
final MslCiphertextEnvelope envelope = new MslCiphertextEnvelope(cipherSpec, IV, CIPHERTEXT);
final byte[] encode = envelope.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
mo.put(KEY_CIPHERSPEC, "x");
new MslCiphertextEnvelope(mo);
}
@Test
public void missingCiphertext() throws MslEncoderException, MslCryptoException, MslEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final MslCiphertextEnvelope envelope = new MslCiphertextEnvelope(cipherSpec, IV, CIPHERTEXT);
final byte[] encode = envelope.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
mo.remove(KEY_CIPHERTEXT);
new MslCiphertextEnvelope(mo);
}
}
}
| 9,943 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/crypto/RsaCryptoContextSuite.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.crypto;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.security.InvalidAlgorithmParameterException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Security;
import java.security.spec.InvalidParameterSpecException;
import java.util.Arrays;
import java.util.Collection;
import java.util.Random;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslMasterTokenException;
import com.netflix.msl.crypto.RsaCryptoContext.Mode;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
/**
* RSA crypto context unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
@RunWith(Suite.class)
@SuiteClasses({RsaCryptoContextSuite.EncryptDecrypt.class,
RsaCryptoContextSuite.WrapUnwrap.class,
RsaCryptoContextSuite.SignVerify.class})
public class RsaCryptoContextSuite{
/** Key pair ID. */
private static final String KEYPAIR_ID = "keypairid";
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
@BeforeClass
public static synchronized void setup() throws NoSuchAlgorithmException, InvalidAlgorithmParameterException, InvalidParameterSpecException, NoSuchProviderException, MslEncodingException, MslCryptoException {
if (random == null) {
ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = ctx.getMslEncoderFactory();
Security.addProvider(new BouncyCastleProvider());
final KeyPairGenerator keypairGenerator = KeyPairGenerator.getInstance("RSA");
keypairGenerator.initialize(512);
final KeyPair keypairA = keypairGenerator.generateKeyPair();
privateKeyA = keypairA.getPrivate();
publicKeyA = keypairA.getPublic();
final KeyPair keypairB = keypairGenerator.generateKeyPair();
privateKeyB = keypairB.getPrivate();
publicKeyB = keypairB.getPublic();
random = new Random();
}
}
@AfterClass
public static synchronized void teardown() {
// Teardown causes problems because the data is shared by the inner
// classes, so don't do any cleanup.
}
/** Encrypt/decrypt mode unit tests. */
@RunWith(Parameterized.class)
public static class EncryptDecrypt {
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@Parameters
public static Collection<Object[]> data() {
return Arrays.asList(new Object[][] {
{ Mode.ENCRYPT_DECRYPT_OAEP, 16 },
{ Mode.ENCRYPT_DECRYPT_PKCS1, 32 }
});
}
/** Crypto context mode. */
private final Mode mode;
/** Plaintext message size in bytes. */
private final int messageSize;
/**
* Create a new encrypt/decrypt test instance with the specified
* mode and plaintext message size.
*
* @param mode crypto context mode.
* @param messageSize plaintext message size in bytes.
*/
public EncryptDecrypt(final Mode mode, final int messageSize) {
this.mode = mode;
this.messageSize = messageSize;
}
@Test
public void encryptDecrypt() throws MslEncodingException, MslCryptoException, MslMasterTokenException {
final byte[] messageA = new byte[messageSize];
random.nextBytes(messageA);
final RsaCryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, publicKeyA, mode);
final byte[] ciphertextA = cryptoContext.encrypt(messageA, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextA);
assertThat(messageA, is(not(ciphertextA)));
final byte[] plaintextA = cryptoContext.decrypt(ciphertextA, encoder);
assertNotNull(plaintextA);
assertArrayEquals(messageA, plaintextA);
final byte[] messageB = new byte[messageSize];
random.nextBytes(messageB);
final byte[] ciphertextB = cryptoContext.encrypt(messageB, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextB);
assertThat(messageB, is(not(ciphertextB)));
assertThat(ciphertextB, is(not(ciphertextA)));
final byte[] plaintextB = cryptoContext.decrypt(ciphertextB, encoder);
assertNotNull(plaintextB);
assertArrayEquals(messageB, plaintextB);
}
@Test
public void encryptNullPublic() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.ENCRYPT_NOT_SUPPORTED);
final byte[] message = new byte[messageSize];
random.nextBytes(message);
final RsaCryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, null, mode);
cryptoContext.encrypt(message, encoder, ENCODER_FORMAT);
}
@Test
public void decryptNullPrivate() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.DECRYPT_NOT_SUPPORTED);
final byte[] message = new byte[messageSize];
random.nextBytes(message);
final RsaCryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, null, publicKeyA, mode);
final byte[] ciphertext = cryptoContext.encrypt(message, encoder, ENCODER_FORMAT);
cryptoContext.decrypt(ciphertext, encoder);
}
@Test
public void encryptDecryptIdMismatch() throws MslCryptoException {
final byte[] message = new byte[messageSize];
random.nextBytes(message);
final RsaCryptoContext cryptoContextA = new RsaCryptoContext(ctx, KEYPAIR_ID + "A", privateKeyA, publicKeyA, mode);
final byte[] ciphertext = cryptoContextA.encrypt(message, encoder, ENCODER_FORMAT);
assertNotNull(ciphertext);
assertThat(message, is(not(ciphertext)));
final RsaCryptoContext cryptoContextB = new RsaCryptoContext(ctx, KEYPAIR_ID + "B", privateKeyA, publicKeyA, mode);
final byte[] plaintext = cryptoContextB.decrypt(ciphertext, encoder);
assertNotNull(plaintext);
assertArrayEquals(message, plaintext);
}
@Test
public void encryptDecryptKeysMismatch() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.CIPHERTEXT_BAD_PADDING);
final byte[] message = new byte[messageSize];
random.nextBytes(message);
final RsaCryptoContext cryptoContextA = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, publicKeyA, mode);
final byte[] ciphertext = cryptoContextA.encrypt(message, encoder, ENCODER_FORMAT);
final RsaCryptoContext cryptoContextB = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyB, publicKeyB, mode);
cryptoContextB.decrypt(ciphertext, encoder);
}
@Test
public void wrapUnwrapOneBlock() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.WRAP_NOT_SUPPORTED);
final ICryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, publicKeyA, mode);
final byte[] keydataA = new byte[8];
random.nextBytes(keydataA);
final byte[] ciphertextA = cryptoContext.wrap(keydataA, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextA);
assertArrayEquals(keydataA, ciphertextA);
}
@Test
public void wrapUnwrapBlockAligned() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.WRAP_NOT_SUPPORTED);
final ICryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, publicKeyA, mode);
final byte[] keydataA = new byte[messageSize];
random.nextBytes(keydataA);
final byte[] ciphertextA = cryptoContext.wrap(keydataA, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextA);
assertArrayEquals(keydataA, ciphertextA);
}
@Test
public void wrapUnwrapBlockUnaligned() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.WRAP_NOT_SUPPORTED);
final ICryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, publicKeyA, mode);
final byte[] keydataA = new byte[127];
random.nextBytes(keydataA);
final byte[] ciphertextA = cryptoContext.wrap(keydataA, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextA);
assertArrayEquals(keydataA, ciphertextA);
}
@Test
public void wrapNullPublic() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.WRAP_NOT_SUPPORTED);
final ICryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, null, mode);
final byte[] messageA = new byte[messageSize];
random.nextBytes(messageA);
final byte[] ciphertextA = cryptoContext.wrap(messageA, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextA);
assertArrayEquals(messageA, ciphertextA);
}
@Test
public void unwrapNullPrivate() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNWRAP_NOT_SUPPORTED);
final ICryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, null, publicKeyA, mode);
final byte[] messageA = new byte[messageSize];
random.nextBytes(messageA);
final byte[] plaintextA = cryptoContext.unwrap(messageA, encoder);
assertNotNull(plaintextA);
assertArrayEquals(messageA, plaintextA);
}
@Test
public void unwrapUnalignedData() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNWRAP_NOT_SUPPORTED);
final ICryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, publicKeyA, mode);
final byte[] keydataA = new byte[1];
random.nextBytes(keydataA);
final byte[] plaintextA = cryptoContext.unwrap(keydataA, encoder);
assertNotNull(plaintextA);
assertArrayEquals(keydataA, plaintextA);
}
@Test
public void signVerify() throws MslCryptoException {
final byte[] message = new byte[messageSize];
random.nextBytes(message);
final RsaCryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, publicKeyA, mode);
final byte[] signature = cryptoContext.sign(message, encoder, ENCODER_FORMAT);
assertNotNull(signature);
assertEquals(0, signature.length);
assertTrue(cryptoContext.verify(message, signature, encoder));
}
@Test
public void signVerifyContextMismatch() throws MslCryptoException {
final byte[] message = new byte[messageSize];
random.nextBytes(message);
final RsaCryptoContext cryptoContextA = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, publicKeyA, mode);
final byte [] signature = cryptoContextA.sign(message, encoder, ENCODER_FORMAT);
final RsaCryptoContext cryptoContextB = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyB, publicKeyB, mode);
assertTrue(cryptoContextB.verify(message, signature, encoder));
}
@Test
public void signNullPrivate() throws MslCryptoException {
final byte[] message = new byte[messageSize];
random.nextBytes(message);
final RsaCryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, null, publicKeyA, mode);
final byte[] signature = cryptoContext.sign(message, encoder, ENCODER_FORMAT);
assertNotNull(signature);
assertEquals(0, signature.length);
assertTrue(cryptoContext.verify(message, signature, encoder));
}
@Test
public void verifyNullPublic() throws MslCryptoException {
final byte[] message = new byte[messageSize];
random.nextBytes(message);
final RsaCryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, null, mode);
final byte[] signature = cryptoContext.sign(message, encoder, ENCODER_FORMAT);
assertNotNull(signature);
assertEquals(0, signature.length);
assertTrue(cryptoContext.verify(message, signature, encoder));
}
}
/** Wrap/unwrap mode unit tests. */
@Ignore
public static class WrapUnwrap {
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@Test
public void encryptDecrypt() throws MslCryptoException {
final byte[] message = new byte[32];
random.nextBytes(message);
final RsaCryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, publicKeyA, Mode.SIGN_VERIFY);
final byte[] ciphertext = cryptoContext.encrypt(message, encoder, ENCODER_FORMAT);
assertNotNull(ciphertext);
assertArrayEquals(message, ciphertext);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
assertNotNull(plaintext);
assertArrayEquals(message, plaintext);
}
@Test
public void encryptNullPublic() throws MslCryptoException {
final byte[] message = new byte[32];
random.nextBytes(message);
final RsaCryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, null, Mode.SIGN_VERIFY);
final byte[] ciphertext = cryptoContext.encrypt(message, encoder, ENCODER_FORMAT);
assertNotNull(ciphertext);
assertArrayEquals(message, ciphertext);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
assertNotNull(plaintext);
assertArrayEquals(message, plaintext);
}
@Test
public void decryptNullPrivate() throws MslCryptoException {
final byte[] message = new byte[32];
random.nextBytes(message);
final RsaCryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, null, publicKeyA, Mode.SIGN_VERIFY);
final byte[] ciphertext = cryptoContext.encrypt(message, encoder, ENCODER_FORMAT);
assertNotNull(ciphertext);
assertArrayEquals(message, ciphertext);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
assertNotNull(plaintext);
assertArrayEquals(message, plaintext);
}
@Test
public void encryptDecryptIdMismatch() throws MslCryptoException {
final byte[] message = new byte[32];
random.nextBytes(message);
final RsaCryptoContext cryptoContextA = new RsaCryptoContext(ctx, KEYPAIR_ID + "A", privateKeyA, publicKeyA, Mode.SIGN_VERIFY);
final byte[] ciphertext = cryptoContextA.encrypt(message, encoder, ENCODER_FORMAT);
assertNotNull(ciphertext);
assertArrayEquals(message, ciphertext);
final RsaCryptoContext cryptoContextB = new RsaCryptoContext(ctx, KEYPAIR_ID + "B", privateKeyA, publicKeyA, Mode.SIGN_VERIFY);
final byte[] plaintext = cryptoContextB.decrypt(ciphertext, encoder);
assertNotNull(plaintext);
assertArrayEquals(message, plaintext);
}
@Test
public void encryptDecryptKeysMismatch() throws MslCryptoException {
final byte[] message = new byte[32];
random.nextBytes(message);
final RsaCryptoContext cryptoContextA = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, publicKeyA, Mode.SIGN_VERIFY);
final byte[] ciphertext = cryptoContextA.encrypt(message, encoder, ENCODER_FORMAT);
assertNotNull(ciphertext);
assertArrayEquals(message, ciphertext);
final RsaCryptoContext cryptoContextB = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyB, publicKeyB, Mode.SIGN_VERIFY);
final byte[] plaintext = cryptoContextB.decrypt(ciphertext, encoder);
assertNotNull(plaintext);
assertArrayEquals(message, plaintext);
}
@Test
public void wrapUnwrapOneBlock() throws MslCryptoException {
final ICryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, publicKeyA, Mode.WRAP_UNWRAP);
final byte[] keydataA = new byte[8];
random.nextBytes(keydataA);
final byte[] ciphertextA = cryptoContext.wrap(keydataA, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextA);
assertThat(keydataA, is(not(ciphertextA)));
final byte[] plaintextA = cryptoContext.unwrap(ciphertextA, encoder);
assertNotNull(plaintextA);
assertArrayEquals(keydataA, plaintextA);
final byte[] keydataB = new byte[8];
random.nextBytes(keydataB);
final byte[] ciphertextB = cryptoContext.wrap(keydataB, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextB);
assertThat(keydataB, is(not(ciphertextB)));
assertThat(ciphertextB, is(not(ciphertextA)));
final byte[] plaintextB = cryptoContext.unwrap(ciphertextB, encoder);
assertNotNull(plaintextB);
assertArrayEquals(keydataB, plaintextB);
}
@Test
public void wrapUnwrapBlockAligned() throws MslCryptoException {
final ICryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, publicKeyA, Mode.WRAP_UNWRAP);
final byte[] keydataA = new byte[32];
random.nextBytes(keydataA);
final byte[] ciphertextA = cryptoContext.wrap(keydataA, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextA);
assertThat(keydataA, is(not(ciphertextA)));
final byte[] plaintextA = cryptoContext.unwrap(ciphertextA, encoder);
assertNotNull(plaintextA);
assertArrayEquals(keydataA, plaintextA);
final byte[] keydataB = new byte[32];
random.nextBytes(keydataB);
final byte[] ciphertextB = cryptoContext.wrap(keydataB, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextB);
assertThat(keydataB, is(not(ciphertextB)));
assertThat(ciphertextB, is(not(ciphertextA)));
final byte[] plaintextB = cryptoContext.unwrap(ciphertextB, encoder);
assertNotNull(plaintextB);
assertArrayEquals(keydataB, plaintextB);
}
@Test
public void wrapUnwrapBlockUnaligned() throws MslCryptoException {
final ICryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, publicKeyA, Mode.WRAP_UNWRAP);
final byte[] keydataA = new byte[127];
random.nextBytes(keydataA);
final byte[] ciphertextA = cryptoContext.wrap(keydataA, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextA);
assertThat(keydataA, is(not(ciphertextA)));
final byte[] plaintextA = cryptoContext.unwrap(ciphertextA, encoder);
assertNotNull(plaintextA);
assertArrayEquals(keydataA, plaintextA);
final byte[] keydataB = new byte[127];
random.nextBytes(keydataB);
final byte[] ciphertextB = cryptoContext.wrap(keydataB, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextB);
assertThat(keydataB, is(not(ciphertextB)));
assertThat(ciphertextB, is(not(ciphertextA)));
final byte[] plaintextB = cryptoContext.unwrap(ciphertextB, encoder);
assertNotNull(plaintextB);
assertArrayEquals(keydataB, plaintextB);
}
@Test
public void wrapNullPublic() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.WRAP_NOT_SUPPORTED);
final ICryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, null, Mode.WRAP_UNWRAP);
final byte[] messageA = new byte[32];
random.nextBytes(messageA);
cryptoContext.wrap(messageA, encoder, ENCODER_FORMAT);
}
@Test
public void unwrapNullPrivate() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNWRAP_NOT_SUPPORTED);
final ICryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, null, publicKeyA, Mode.WRAP_UNWRAP);
final byte[] messageA = new byte[32];
random.nextBytes(messageA);
cryptoContext.unwrap(messageA, encoder);
}
@Test
public void unwrapUnalignedData() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.INVALID_WRAP_CIPHERTEXT);
final ICryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, publicKeyA, Mode.WRAP_UNWRAP);
final byte[] keydataA = new byte[1];
random.nextBytes(keydataA);
cryptoContext.unwrap(keydataA, encoder);
}
@Test
public void signVerify() throws MslCryptoException {
final byte[] message = new byte[32];
random.nextBytes(message);
final RsaCryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, publicKeyA, Mode.WRAP_UNWRAP);
final byte[] signature = cryptoContext.sign(message, encoder, ENCODER_FORMAT);
assertNotNull(signature);
assertEquals(0, signature.length);
assertTrue(cryptoContext.verify(message, signature, encoder));
}
@Test
public void signVerifyContextMismatch() throws MslCryptoException {
final byte[] message = new byte[32];
random.nextBytes(message);
final RsaCryptoContext cryptoContextA = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, publicKeyA, Mode.WRAP_UNWRAP);
final byte [] signature = cryptoContextA.sign(message, encoder, ENCODER_FORMAT);
final RsaCryptoContext cryptoContextB = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyB, publicKeyB, Mode.WRAP_UNWRAP);
assertTrue(cryptoContextB.verify(message, signature, encoder));
}
@Test
public void signNullPrivate() throws MslCryptoException {
final byte[] message = new byte[32];
random.nextBytes(message);
final RsaCryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, null, publicKeyA, Mode.WRAP_UNWRAP);
final byte[] signature = cryptoContext.sign(message, encoder, ENCODER_FORMAT);
assertNotNull(signature);
assertEquals(0, signature.length);
assertTrue(cryptoContext.verify(message, signature, encoder));
}
@Test
public void verifyNullPublic() throws MslCryptoException {
final byte[] message = new byte[32];
random.nextBytes(message);
final RsaCryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, null, Mode.WRAP_UNWRAP);
final byte[] signature = cryptoContext.sign(message, encoder, ENCODER_FORMAT);
assertNotNull(signature);
assertEquals(0, signature.length);
assertTrue(cryptoContext.verify(message, signature, encoder));
}
}
/** Sign/verify mode unit tests. */
public static class SignVerify {
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@Test
public void encryptDecrypt() throws MslCryptoException {
final byte[] message = new byte[32];
random.nextBytes(message);
final RsaCryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, publicKeyA, Mode.SIGN_VERIFY);
final byte[] ciphertext = cryptoContext.encrypt(message, encoder, ENCODER_FORMAT);
assertNotNull(ciphertext);
assertArrayEquals(message, ciphertext);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
assertNotNull(plaintext);
assertArrayEquals(message, plaintext);
}
@Test
public void encryptNullPublic() throws MslCryptoException {
final byte[] message = new byte[32];
random.nextBytes(message);
final RsaCryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, null, Mode.SIGN_VERIFY);
final byte[] ciphertext = cryptoContext.encrypt(message, encoder, ENCODER_FORMAT);
assertNotNull(ciphertext);
assertArrayEquals(message, ciphertext);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
assertNotNull(plaintext);
assertArrayEquals(message, plaintext);
}
@Test
public void decryptNullPrivate() throws MslCryptoException {
final byte[] message = new byte[32];
random.nextBytes(message);
final RsaCryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, null, publicKeyA, Mode.SIGN_VERIFY);
final byte[] ciphertext = cryptoContext.encrypt(message, encoder, ENCODER_FORMAT);
assertNotNull(ciphertext);
assertArrayEquals(message, ciphertext);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
assertNotNull(plaintext);
assertArrayEquals(message, plaintext);
}
@Test
public void encryptDecryptIdMismatch() throws MslCryptoException {
final byte[] message = new byte[32];
random.nextBytes(message);
final RsaCryptoContext cryptoContextA = new RsaCryptoContext(ctx, KEYPAIR_ID + "A", privateKeyA, publicKeyA, Mode.SIGN_VERIFY);
final byte[] ciphertext = cryptoContextA.encrypt(message, encoder, ENCODER_FORMAT);
assertNotNull(ciphertext);
assertArrayEquals(message, ciphertext);
final RsaCryptoContext cryptoContextB = new RsaCryptoContext(ctx, KEYPAIR_ID + "B", privateKeyA, publicKeyA, Mode.SIGN_VERIFY);
final byte[] plaintext = cryptoContextB.decrypt(ciphertext, encoder);
assertNotNull(plaintext);
assertArrayEquals(message, plaintext);
}
@Test
public void encryptDecryptKeysMismatch() throws MslCryptoException {
final byte[] message = new byte[32];
random.nextBytes(message);
final RsaCryptoContext cryptoContextA = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, publicKeyA, Mode.SIGN_VERIFY);
final byte[] ciphertext = cryptoContextA.encrypt(message, encoder, ENCODER_FORMAT);
assertNotNull(ciphertext);
assertArrayEquals(message, ciphertext);
final RsaCryptoContext cryptoContextB = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyB, publicKeyB, Mode.SIGN_VERIFY);
final byte[] plaintext = cryptoContextB.decrypt(ciphertext, encoder);
assertNotNull(plaintext);
assertArrayEquals(message, plaintext);
}
@Test
public void wrapUnwrapOneBlock() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.WRAP_NOT_SUPPORTED);
final ICryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, publicKeyA, Mode.SIGN_VERIFY);
final byte[] keydataA = new byte[8];
random.nextBytes(keydataA);
final byte[] ciphertextA = cryptoContext.wrap(keydataA, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextA);
assertArrayEquals(keydataA, ciphertextA);
}
@Test
public void wrapUnwrapBlockAligned() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.WRAP_NOT_SUPPORTED);
final ICryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, publicKeyA, Mode.SIGN_VERIFY);
final byte[] keydataA = new byte[32];
random.nextBytes(keydataA);
final byte[] ciphertextA = cryptoContext.wrap(keydataA, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextA);
assertArrayEquals(keydataA, ciphertextA);
}
@Test
public void wrapUnwrapBlockUnaligned() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.WRAP_NOT_SUPPORTED);
final ICryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, publicKeyA, Mode.SIGN_VERIFY);
final byte[] keydataA = new byte[127];
random.nextBytes(keydataA);
final byte[] ciphertextA = cryptoContext.wrap(keydataA, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextA);
assertArrayEquals(keydataA, ciphertextA);
}
@Test
public void wrapNullPublic() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.WRAP_NOT_SUPPORTED);
final ICryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, null, Mode.SIGN_VERIFY);
final byte[] messageA = new byte[32];
random.nextBytes(messageA);
final byte[] ciphertextA = cryptoContext.wrap(messageA, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextA);
assertArrayEquals(messageA, ciphertextA);
}
@Test
public void unwrapNullPrivate() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNWRAP_NOT_SUPPORTED);
final ICryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, null, publicKeyA, Mode.SIGN_VERIFY);
final byte[] messageA = new byte[32];
random.nextBytes(messageA);
final byte[] plaintextA = cryptoContext.unwrap(messageA, encoder);
assertNotNull(plaintextA);
assertArrayEquals(messageA, plaintextA);
}
@Test
public void unwrapUnalignedData() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNWRAP_NOT_SUPPORTED);
final ICryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, publicKeyA, Mode.SIGN_VERIFY);
final byte[] keydataA = new byte[1];
random.nextBytes(keydataA);
final byte[] plaintextA = cryptoContext.unwrap(keydataA, encoder);
assertNotNull(plaintextA);
assertArrayEquals(keydataA, plaintextA);
}
@Test
public void signVerify() throws MslCryptoException {
final byte[] messageA = new byte[32];
random.nextBytes(messageA);
final RsaCryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, publicKeyA, Mode.SIGN_VERIFY);
final byte[] signatureA = cryptoContext.sign(messageA, encoder, ENCODER_FORMAT);
assertNotNull(signatureA);
assertTrue(signatureA.length > 0);
assertThat(messageA, is(not(signatureA)));
assertTrue(cryptoContext.verify(messageA, signatureA, encoder));
final byte[] messageB = new byte[32];
random.nextBytes(messageB);
final byte[] signatureB = cryptoContext.sign(messageB, encoder, ENCODER_FORMAT);
assertTrue(signatureB.length > 0);
assertThat(signatureA, is(not(signatureB)));
assertTrue(cryptoContext.verify(messageB, signatureB, encoder));
assertFalse(cryptoContext.verify(messageB, signatureA, encoder));
}
@Test
public void signVerifyContextMismatch() throws MslCryptoException {
final byte[] message = new byte[32];
random.nextBytes(message);
final RsaCryptoContext cryptoContextA = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, publicKeyA, Mode.SIGN_VERIFY);
final byte [] signature = cryptoContextA.sign(message, encoder, ENCODER_FORMAT);
final RsaCryptoContext cryptoContextB = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyB, publicKeyB, Mode.SIGN_VERIFY);
assertFalse(cryptoContextB.verify(message, signature, encoder));
}
@Test
public void signNullPrivate() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.SIGN_NOT_SUPPORTED);
final byte[] message = new byte[32];
random.nextBytes(message);
final RsaCryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, null, publicKeyA, Mode.SIGN_VERIFY);
cryptoContext.sign(message, encoder, ENCODER_FORMAT);
}
@Test
public void verifyNullPublic() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.VERIFY_NOT_SUPPORTED);
final byte[] message = new byte[32];
random.nextBytes(message);
final RsaCryptoContext cryptoContext = new RsaCryptoContext(ctx, KEYPAIR_ID, privateKeyA, null, Mode.SIGN_VERIFY);
final byte[] signature;
try {
signature = cryptoContext.sign(message, encoder, ENCODER_FORMAT);
} catch (final MslCryptoException e) {
fail(e.getMessage());
return;
}
cryptoContext.verify(message, signature, encoder);
}
}
/** RSA public key A. */
private static PublicKey publicKeyA;
/** RSA private key A. */
private static PrivateKey privateKeyA;
/** RSA public key B. */
private static PublicKey publicKeyB;
/** RSA private key B. */
private static PrivateKey privateKeyB;
/** MSL context. */
private static MslContext ctx;
/** Random. */
private static Random random;
}
| 9,944 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/crypto/SymmetricCryptoContextTest.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.crypto;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslMasterTokenException;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.entityauth.MockPresharedAuthenticationFactory;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
/**
* Symmetric crypto context unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
@RunWith(Parameterized.class)
public class SymmetricCryptoContextTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key set ID. */
private static final String KEYSET_ID = "keysetid";
/** Key ciphertext. */
private static final String KEY_CIPHERTEXT = "ciphertext";
/** AES-128 CMAC key length in bytes. */
private static final int AES_CMAC_KEY_LENGTH = 16;
/** RFC 3394 encryption key. */
private final byte[] RFC_KEY = {
(byte)0x00, (byte)0x01, (byte)0x02, (byte)0x03, (byte)0x04, (byte)0x05, (byte)0x06, (byte)0x07,
(byte)0x08, (byte)0x09, (byte)0x0A, (byte)0x0B, (byte)0x0C, (byte)0x0D, (byte)0x0E, (byte)0x0F };
/** RFC 3394 plaintext (key data). */
private final byte[] RFC_PLAINTEXT = {
(byte)0x00, (byte)0x11, (byte)0x22, (byte)0x33, (byte)0x44, (byte)0x55, (byte)0x66, (byte)0x77,
(byte)0x88, (byte)0x99, (byte)0xAA, (byte)0xBB, (byte)0xCC, (byte)0xDD, (byte)0xEE, (byte)0xFF };
/** RFC 3394 ciphertext. */
private final byte[] RFC_CIPHERTEXT = {
(byte)0x1F, (byte)0xA6, (byte)0x8B, (byte)0x0A, (byte)0x81, (byte)0x12, (byte)0xB4, (byte)0x47,
(byte)0xAE, (byte)0xF3, (byte)0x4B, (byte)0xD8, (byte)0xFB, (byte)0x5A, (byte)0x7B, (byte)0x82,
(byte)0x9D, (byte)0x3E, (byte)0x86, (byte)0x23, (byte)0x71, (byte)0xD2, (byte)0xCF, (byte)0xE5 };
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException {
random = new Random();
ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = ctx.getMslEncoderFactory();
}
@AfterClass
public static void teardown() {
encoder = null;
ctx = null;
random = null;
}
@Parameters
public static List<Object[]> data() {
final byte[] aesKey = new byte[AES_CMAC_KEY_LENGTH];
new Random().nextBytes(aesKey);
final SecretKey aesCmacKey = new SecretKeySpec(aesKey, JcaAlgorithm.AES_CMAC);
return Arrays.asList(new Object[][] {
{ MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH, MockPresharedAuthenticationFactory.KPW },
{ MockPresharedAuthenticationFactory.KPE, aesCmacKey, MockPresharedAuthenticationFactory.KPW },
});
}
/** Crypto context. */
private final ICryptoContext cryptoContext;
/**
* Create a new symmetric crypto context test instance.
*
* @param encryptionKey encryption key.
* @param signatureKey signature key.
* @param wrappingKey wrpaping key.
*/
public SymmetricCryptoContextTest(final SecretKey encryptionKey, final SecretKey signatureKey, final SecretKey wrappingKey) {
this.cryptoContext = new SymmetricCryptoContext(ctx, KEYSET_ID, encryptionKey, signatureKey, wrappingKey);
}
@Test
public void encryptDecrypt() throws MslEncodingException, MslCryptoException, MslMasterTokenException {
final byte[] messageA = new byte[32];
random.nextBytes(messageA);
final byte[] ciphertextA = cryptoContext.encrypt(messageA, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextA);
assertThat(messageA, is(not(ciphertextA)));
final byte[] plaintextA = cryptoContext.decrypt(ciphertextA, encoder);
assertNotNull(plaintextA);
assertArrayEquals(messageA, plaintextA);
final byte[] messageB = new byte[32];
random.nextBytes(messageB);
final byte[] ciphertextB = cryptoContext.encrypt(messageB, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextB);
assertThat(messageB, is(not(ciphertextB)));
assertThat(ciphertextB, is(not(ciphertextA)));
final byte[] plaintextB = cryptoContext.decrypt(ciphertextB, encoder);
assertNotNull(plaintextB);
assertArrayEquals(messageB, plaintextB);
}
@Test
public void invalidCiphertext() throws MslEncodingException, MslCryptoException, MslEncoderException, UnsupportedEncodingException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.CIPHERTEXT_BAD_PADDING);
final byte[] message = new byte[32];
random.nextBytes(message);
final byte[] data = cryptoContext.encrypt(message, encoder, ENCODER_FORMAT);
final MslObject envelopeMo = encoder.parseObject(data);
final MslCiphertextEnvelope envelope = new MslCiphertextEnvelope(envelopeMo);
final byte[] ciphertext = envelope.getCiphertext();
++ciphertext[ciphertext.length - 2];
final MslCiphertextEnvelope shortEnvelope = new MslCiphertextEnvelope(envelope.getKeyId(), envelope.getIv(), ciphertext);
cryptoContext.decrypt(shortEnvelope.toMslEncoding(encoder, ENCODER_FORMAT), encoder);
}
@Test
public void insufficientCiphertext() throws MslCryptoException, MslEncoderException, MslEncodingException, UnsupportedEncodingException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.CIPHERTEXT_ILLEGAL_BLOCK_SIZE);
final byte[] message = new byte[32];
random.nextBytes(message);
final byte[] data = cryptoContext.encrypt(message, encoder, ENCODER_FORMAT);
final MslObject envelopeMo = encoder.parseObject(data);
final MslCiphertextEnvelope envelope = new MslCiphertextEnvelope(envelopeMo);
final byte[] ciphertext = envelope.getCiphertext();
final byte[] shortCiphertext = Arrays.copyOf(ciphertext, ciphertext.length - 1);
final MslCiphertextEnvelope shortEnvelope = new MslCiphertextEnvelope(envelope.getKeyId(), envelope.getIv(), shortCiphertext);
cryptoContext.decrypt(shortEnvelope.toMslEncoding(encoder, ENCODER_FORMAT), encoder);
}
@Test
public void notEnvelope() throws MslCryptoException, MslEncoderException, MslEncodingException, UnsupportedEncodingException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.CIPHERTEXT_ENVELOPE_PARSE_ERROR);
final byte[] message = new byte[32];
random.nextBytes(message);
final byte[] data = cryptoContext.encrypt(message, encoder, ENCODER_FORMAT);
final MslObject envelopeMo = encoder.parseObject(data);
envelopeMo.remove(KEY_CIPHERTEXT);
cryptoContext.decrypt(encoder.encodeObject(envelopeMo, ENCODER_FORMAT), encoder);
}
@Test
public void corruptEnvelope() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.CIPHERTEXT_ENVELOPE_PARSE_ERROR);
final byte[] message = new byte[32];
random.nextBytes(message);
final byte[] data = cryptoContext.encrypt(message, encoder, ENCODER_FORMAT);
data[0] = 0;
cryptoContext.decrypt(data, encoder);
}
@Test
public void encryptNullEncryption() throws MslEncodingException, MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.ENCRYPT_NOT_SUPPORTED);
final ICryptoContext cryptoContext= new SymmetricCryptoContext(ctx, KEYSET_ID, null, MockPresharedAuthenticationFactory.KPH, MockPresharedAuthenticationFactory.KPW);
final byte[] messageA = new byte[32];
random.nextBytes(messageA);
cryptoContext.encrypt(messageA, encoder, ENCODER_FORMAT);
}
@Test
public void decryptNullEncryption() throws MslEncodingException, MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.DECRYPT_NOT_SUPPORTED);
final ICryptoContext cryptoContext= new SymmetricCryptoContext(ctx, KEYSET_ID, null, MockPresharedAuthenticationFactory.KPH, MockPresharedAuthenticationFactory.KPW);
final byte[] messageA = new byte[32];
random.nextBytes(messageA);
cryptoContext.decrypt(messageA, encoder);
}
@Test
public void encryptDecryptNullKeys() throws MslEncodingException, MslCryptoException, MslEncoderException {
final ICryptoContext cryptoContext = new SymmetricCryptoContext(ctx, KEYSET_ID, MockPresharedAuthenticationFactory.KPE, null, null);
final byte[] messageA = new byte[32];
random.nextBytes(messageA);
final byte[] ciphertextA = cryptoContext.encrypt(messageA, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextA);
assertThat(messageA, is(not(ciphertextA)));
final byte[] plaintextA = cryptoContext.decrypt(ciphertextA, encoder);
assertNotNull(plaintextA);
assertArrayEquals(messageA, plaintextA);
final byte[] messageB = new byte[32];
random.nextBytes(messageB);
final byte[] ciphertextB = cryptoContext.encrypt(messageB, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextB);
assertThat(messageB, is(not(ciphertextB)));
assertThat(ciphertextB, is(not(ciphertextA)));
final byte[] plaintextB = cryptoContext.decrypt(ciphertextB, encoder);
assertNotNull(plaintextB);
assertArrayEquals(messageB, plaintextB);
}
@Test
public void encryptDecryptIdMismatch() throws MslEncodingException, MslCryptoException, MslEncoderException {
final ICryptoContext cryptoContextA = new SymmetricCryptoContext(ctx, KEYSET_ID + "A", MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH, MockPresharedAuthenticationFactory.KPW);
final ICryptoContext cryptoContextB = new SymmetricCryptoContext(ctx, KEYSET_ID + "B", MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH, MockPresharedAuthenticationFactory.KPW);
final byte[] message = new byte[32];
random.nextBytes(message);
final byte[] ciphertext = cryptoContextA.encrypt(message, encoder, ENCODER_FORMAT);
assertNotNull(ciphertext);
assertThat(ciphertext, is(not(message)));
final byte[] plaintext = cryptoContextB.decrypt(ciphertext, encoder);
assertNotNull(plaintext);
assertArrayEquals(message, plaintext);
}
@Test
public void encryptDecryptKeysMismatch() throws MslEncodingException, MslCryptoException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.CIPHERTEXT_BAD_PADDING);
final ICryptoContext cryptoContextA = new SymmetricCryptoContext(ctx, KEYSET_ID, MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH, MockPresharedAuthenticationFactory.KPW);
final ICryptoContext cryptoContextB = new SymmetricCryptoContext(ctx, KEYSET_ID, MockPresharedAuthenticationFactory.KPE2, MockPresharedAuthenticationFactory.KPH2, MockPresharedAuthenticationFactory.KPW2);
final byte[] message = new byte[32];
random.nextBytes(message);
final byte[] ciphertext;
try {
ciphertext = cryptoContextA.encrypt(message, encoder, ENCODER_FORMAT);
} catch (final MslCryptoException e) {
fail(e.getMessage());
return;
}
cryptoContextB.decrypt(ciphertext, encoder);
}
@Test
public void wrapUnwrapOneBlock() throws MslCryptoException {
final byte[] keydataA = new byte[8];
random.nextBytes(keydataA);
final byte[] ciphertextA = cryptoContext.wrap(keydataA, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextA);
assertThat(keydataA, is(not(ciphertextA)));
final byte[] plaintextA = cryptoContext.unwrap(ciphertextA, encoder);
assertNotNull(plaintextA);
assertArrayEquals(keydataA, plaintextA);
final byte[] keydataB = new byte[8];
random.nextBytes(keydataB);
final byte[] ciphertextB = cryptoContext.wrap(keydataB, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextB);
assertThat(keydataB, is(not(ciphertextB)));
assertThat(ciphertextB, is(not(ciphertextA)));
final byte[] plaintextB = cryptoContext.unwrap(ciphertextB, encoder);
assertNotNull(plaintextB);
assertArrayEquals(keydataB, plaintextB);
}
@Test
public void wrapUnwrapBlockAligned() throws MslCryptoException {
final byte[] keydataA = new byte[32];
random.nextBytes(keydataA);
final byte[] ciphertextA = cryptoContext.wrap(keydataA, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextA);
assertThat(keydataA, is(not(ciphertextA)));
final byte[] plaintextA = cryptoContext.unwrap(ciphertextA, encoder);
assertNotNull(plaintextA);
assertArrayEquals(keydataA, plaintextA);
final byte[] keydataB = new byte[32];
random.nextBytes(keydataB);
final byte[] ciphertextB = cryptoContext.wrap(keydataB, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextB);
assertThat(keydataB, is(not(ciphertextB)));
assertThat(ciphertextB, is(not(ciphertextA)));
final byte[] plaintextB = cryptoContext.unwrap(ciphertextB, encoder);
assertNotNull(plaintextB);
assertArrayEquals(keydataB, plaintextB);
}
@Test
public void wrapBlockUnaligned() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.PLAINTEXT_ILLEGAL_BLOCK_SIZE);
final byte[] keydataA = new byte[127];
random.nextBytes(keydataA);
cryptoContext.wrap(keydataA, encoder, ENCODER_FORMAT);
}
@Test
public void unwrapBlockUnaligned() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.CIPHERTEXT_ILLEGAL_BLOCK_SIZE);
final byte[] ciphertextA = new byte[127];
random.nextBytes(ciphertextA);
cryptoContext.unwrap(ciphertextA, encoder);
}
@Test
public void wrapNullWrap() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.WRAP_NOT_SUPPORTED);
final ICryptoContext cryptoContext= new SymmetricCryptoContext(ctx, KEYSET_ID, MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH, null);
final byte[] messageA = new byte[32];
random.nextBytes(messageA);
cryptoContext.wrap(messageA, encoder, ENCODER_FORMAT);
}
@Test
public void unwrapNullWrap() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNWRAP_NOT_SUPPORTED);
final ICryptoContext cryptoContext= new SymmetricCryptoContext(ctx, KEYSET_ID, MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH, null);
final byte[] messageA = new byte[32];
random.nextBytes(messageA);
cryptoContext.unwrap(messageA, encoder);
}
@Test
public void wrapUnwrapNullKeys() throws MslCryptoException {
final ICryptoContext cryptoContext = new SymmetricCryptoContext(ctx, KEYSET_ID, null, null, MockPresharedAuthenticationFactory.KPW);
final byte[] keydataA = new byte[32];
random.nextBytes(keydataA);
final byte[] ciphertextA = cryptoContext.wrap(keydataA, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextA);
assertThat(keydataA, is(not(ciphertextA)));
final byte[] plaintextA = cryptoContext.unwrap(ciphertextA, encoder);
assertNotNull(plaintextA);
assertArrayEquals(keydataA, plaintextA);
final byte[] keydataB = new byte[32];
random.nextBytes(keydataB);
final byte[] ciphertextB = cryptoContext.wrap(keydataB, encoder, ENCODER_FORMAT);
assertNotNull(ciphertextB);
assertThat(keydataB, is(not(ciphertextB)));
assertThat(ciphertextB, is(not(ciphertextA)));
final byte[] plaintextB = cryptoContext.unwrap(ciphertextB, encoder);
assertNotNull(plaintextB);
assertArrayEquals(keydataB, plaintextB);
}
@Test
public void unwrapUnalignedData() throws MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.CIPHERTEXT_ILLEGAL_BLOCK_SIZE);
final byte[] keydataA = new byte[1];
random.nextBytes(keydataA);
cryptoContext.unwrap(keydataA, encoder);
}
@Test
public void rfcWrapUnwrap() throws MslEntityAuthException, MslCryptoException {
final SecretKey wrappingKey = new SecretKeySpec(RFC_KEY, JcaAlgorithm.AESKW);
final ICryptoContext cryptoContext = new SymmetricCryptoContext(ctx, "RFC", null, null, wrappingKey);
final byte[] wrapped = cryptoContext.wrap(RFC_PLAINTEXT, encoder, ENCODER_FORMAT);
assertArrayEquals(RFC_CIPHERTEXT, wrapped);
final byte[] unwrapped = cryptoContext.unwrap(wrapped, encoder);
assertArrayEquals(RFC_PLAINTEXT, unwrapped);
}
@Test
public void signVerify() throws MslCryptoException, MslEncodingException, MslMasterTokenException {
final byte[] messageA = new byte[32];
random.nextBytes(messageA);
final byte[] signatureA = cryptoContext.sign(messageA, encoder, ENCODER_FORMAT);
assertNotNull(signatureA);
assertTrue(signatureA.length > 0);
assertThat(messageA, is(not(signatureA)));
assertTrue(cryptoContext.verify(messageA, signatureA, encoder));
final byte[] messageB = new byte[32];
random.nextBytes(messageB);
final byte[] signatureB = cryptoContext.sign(messageB, encoder, ENCODER_FORMAT);
assertTrue(signatureB.length > 0);
assertThat(signatureA, is(not(signatureB)));
assertTrue(cryptoContext.verify(messageB, signatureB, encoder));
assertFalse(cryptoContext.verify(messageB, signatureA, encoder));
}
@Test
public void signVerifyContextMismatch() throws MslEncodingException, MslEncoderException, MslCryptoException {
final ICryptoContext cryptoContextA = new SymmetricCryptoContext(ctx, KEYSET_ID, MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH, MockPresharedAuthenticationFactory.KPW);
final ICryptoContext cryptoContextB = new SymmetricCryptoContext(ctx, KEYSET_ID, MockPresharedAuthenticationFactory.KPE2, MockPresharedAuthenticationFactory.KPH2, MockPresharedAuthenticationFactory.KPW2);
final byte[] message = new byte[32];
random.nextBytes(message);
final byte[] signature = cryptoContextA.sign(message, encoder, ENCODER_FORMAT);
assertFalse(cryptoContextB.verify(message, signature, encoder));
}
@Test
public void signVerifyNullKeys() throws MslCryptoException, MslEncodingException, MslEncoderException {
final ICryptoContext cryptoContext = new SymmetricCryptoContext(ctx, KEYSET_ID, null, MockPresharedAuthenticationFactory.KPH, null);
final byte[] messageA = new byte[32];
random.nextBytes(messageA);
final byte[] signatureA = cryptoContext.sign(messageA, encoder, ENCODER_FORMAT);
assertNotNull(signatureA);
assertTrue(signatureA.length > 0);
assertThat(messageA, is(not(signatureA)));
assertTrue(cryptoContext.verify(messageA, signatureA, encoder));
final byte[] messageB = new byte[32];
random.nextBytes(messageB);
final byte[] signatureB = cryptoContext.sign(messageB, encoder, ENCODER_FORMAT);
assertTrue(signatureB.length > 0);
assertThat(signatureA, is(not(signatureB)));
assertTrue(cryptoContext.verify(messageB, signatureB, encoder));
assertFalse(cryptoContext.verify(messageB, signatureA, encoder));
}
@Test
public void signNullHmac() throws MslCryptoException, MslEncodingException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.SIGN_NOT_SUPPORTED);
final ICryptoContext cryptoContext = new SymmetricCryptoContext(ctx, KEYSET_ID, MockPresharedAuthenticationFactory.KPE, null, MockPresharedAuthenticationFactory.KPW);
final byte[] messageA = new byte[32];
random.nextBytes(messageA);
cryptoContext.sign(messageA, encoder, ENCODER_FORMAT);
}
@Test
public void verifyNullHmac() throws MslCryptoException, MslEncodingException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.VERIFY_NOT_SUPPORTED);
final ICryptoContext cryptoContext = new SymmetricCryptoContext(ctx, KEYSET_ID, MockPresharedAuthenticationFactory.KPE, null, MockPresharedAuthenticationFactory.KPW);
final byte[] message = new byte[32];
random.nextBytes(message);
final byte[] signature = new byte[32];
random.nextBytes(signature);
cryptoContext.verify(message, signature, encoder);
}
/** MSL context. */
private static MslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
/** Random. */
private static Random random;
}
| 9,945 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/util/Base64Test.java | /**
* Copyright (c) 2016-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.util;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import java.nio.charset.Charset;
import java.util.Arrays;
import java.util.Collection;
import javax.xml.bind.DatatypeConverter;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
import com.netflix.msl.util.Base64.Base64Impl;
/**
* Base64 tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
@RunWith(Parameterized.class)
public class Base64Test {
/** UTF-8 charset. */
private static final Charset CHARSET = Charset.forName("utf-8");
/** Binary Base64 example. */
private static final String BINARY_B64 = "R0lGODlhPQBEAPeoAJosM//AwO/AwHVYZ/z595kzAP/s7P+goOXMv8+fhw/v739/f+8PD98fH/8mJl+fn/9ZWb8/PzWlwv///6wWGbImAPgTEMImIN9gUFCEm/gDALULDN8PAD6atYdCTX9gUNKlj8wZAKUsAOzZz+UMAOsJAP/Z2ccMDA8PD/95eX5NWvsJCOVNQPtfX/8zM8+QePLl38MGBr8JCP+zs9myn/8GBqwpAP/GxgwJCPny78lzYLgjAJ8vAP9fX/+MjMUcAN8zM/9wcM8ZGcATEL+QePdZWf/29uc/P9cmJu9MTDImIN+/r7+/vz8/P8VNQGNugV8AAF9fX8swMNgTAFlDOICAgPNSUnNWSMQ5MBAQEJE3QPIGAM9AQMqGcG9vb6MhJsEdGM8vLx8fH98AANIWAMuQeL8fABkTEPPQ0OM5OSYdGFl5jo+Pj/+pqcsTE78wMFNGQLYmID4dGPvd3UBAQJmTkP+8vH9QUK+vr8ZWSHpzcJMmILdwcLOGcHRQUHxwcK9PT9DQ0O/v70w5MLypoG8wKOuwsP/g4P/Q0IcwKEswKMl8aJ9fX2xjdOtGRs/Pz+Dg4GImIP8gIH0sKEAwKKmTiKZ8aB/f39Wsl+LFt8dgUE9PT5x5aHBwcP+AgP+WltdgYMyZfyywz78AAAAAAAD///8AAP9mZv///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAEAAKgALAAAAAA9AEQAAAj/AFEJHEiwoMGDCBMqXMiwocAbBww4nEhxoYkUpzJGrMixogkfGUNqlNixJEIDB0SqHGmyJSojM1bKZOmyop0gM3Oe2liTISKMOoPy7GnwY9CjIYcSRYm0aVKSLmE6nfq05QycVLPuhDrxBlCtYJUqNAq2bNWEBj6ZXRuyxZyDRtqwnXvkhACDV+euTeJm1Ki7A73qNWtFiF+/gA95Gly2CJLDhwEHMOUAAuOpLYDEgBxZ4GRTlC1fDnpkM+fOqD6DDj1aZpITp0dtGCDhr+fVuCu3zlg49ijaokTZTo27uG7Gjn2P+hI8+PDPERoUB318bWbfAJ5sUNFcuGRTYUqV/3ogfXp1rWlMc6awJjiAAd2fm4ogXjz56aypOoIde4OE5u/F9x199dlXnnGiHZWEYbGpsAEA3QXYnHwEFliKAgswgJ8LPeiUXGwedCAKABACCN+EA1pYIIYaFlcDhytd51sGAJbo3onOpajiihlO92KHGaUXGwWjUBChjSPiWJuOO/LYIm4v1tXfE6J4gCSJEZ7YgRYUNrkji9P55sF/ogxw5ZkSqIDaZBV6aSGYq/lGZplndkckZ98xoICbTcIJGQAZcNmdmUc210hs35nCyJ58fgmIKX5RQGOZowxaZwYA+JaoKQwswGijBV4C6SiTUmpphMspJx9unX4KaimjDv9aaXOEBteBqmuuxgEHoLX6Kqx+yXqqBANsgCtit4FWQAEkrNbpq7HSOmtwag5w57GrmlJBASEU18ADjUYb3ADTinIttsgSB1oJFfA63bduimuqKB1keqwUhoCSK374wbujvOSu4QG6UvxBRydcpKsav++Ca6G8A6Pr1x2kVMyHwsVxUALDq/krnrhPSOzXG1lUTIoffqGR7Goi2MAxbv6O2kEG56I7CSlRsEFKFVyovDJoIRTg7sugNRDGqCJzJgcKE0ywc0ELm6KBCCJo8DIPFeCWNGcyqNFE06ToAfV0HBRgxsvLThHn1oddQMrXj5DyAQgjEHSAJMWZwS3HPxT/QMbabI/iBCliMLEJKX2EEkomBAUCxRi42VDADxyTYDVogV+wSChqmKxEKCDAYFDFj4OmwbY7bDGdBhtrnTQYOigeChUmc1K3QTnAUfEgGFgAWt88hKA6aCRIXhxnQ1yg3BCayK44EWdkUQcBByEQChFXfCB776aQsG0BIlQgQgE8qO26X1h8cEUep8ngRBnOy74E9QgRgEAC8SvOfQkh7FDBDmS43PmGoIiKUUEGkMEC/PJHgxw0xH74yx/3XnaYRJgMB8obxQW6kL9QYEJ0FIFgByfIL7/IQAlvQwEpnAC7DtLNJCKUoO/w45c44GwCXiAFB/OXAATQryUxdN4LfFiwgjCNYg+kYMIEFkCKDs6PKAIJouyGWMS1FSKJOMRB/BoIxYJIUXFUxNwoIkEKPAgCBZSQHQ1A2EWDfDEUVLyADj5AChSIQW6gu10bE/JG2VnCZGfo4R4d0sdQoBAHhPjhIB94v/wRoRKQWGRHgrhGSQJxCS+0pCZbEhAAOw==";
/** Standard Base64 examples. */
private static final Object[][] EXAMPLES = {
{ "The long winded author is going for a walk while the light breeze bellows in his ears.".getBytes(CHARSET),
"VGhlIGxvbmcgd2luZGVkIGF1dGhvciBpcyBnb2luZyBmb3IgYSB3YWxrIHdoaWxlIHRoZSBsaWdodCBicmVlemUgYmVsbG93cyBpbiBoaXMgZWFycy4=" },
{ "Sometimes porcupines need beds to sleep on.".getBytes(CHARSET),
"U29tZXRpbWVzIHBvcmN1cGluZXMgbmVlZCBiZWRzIHRvIHNsZWVwIG9uLg==" },
{ "Even the restless dreamer enjoys home-cooked foods.".getBytes(CHARSET),
"RXZlbiB0aGUgcmVzdGxlc3MgZHJlYW1lciBlbmpveXMgaG9tZS1jb29rZWQgZm9vZHMu" },
// We use DatatypeConverter here knowing BINARY_B64 is valid and that
// DatatypeConverter is functionally correct.
{ DatatypeConverter.parseBase64Binary(BINARY_B64),
BINARY_B64 },
};
/** Invalid Base64 examples. */
private static final String[] INVALID_EXAMPLES = {
"AAAAA",
"AAAAAAA",
"%$#@=",
"ZZZZZZZZZZ=",
"ZZZZZZZZZ==",
"U29tZXRpbWVzIHBvcmN1cGluZX=gbmVlZCBiZWRzIHRvIHNsZWVwIG9uLg==",
"RXZlbiB0aGUgcmVzdGxlc3MgZHJ=YW1lciBlbmpveXMgaG9tZS1jb29rZWQgZm9vZHMu",
"RXZlbiB0aGUgcmVzdGxlc3MgZHJ=Y",
"VGhlIGxvbmcgd2luZGVkIGF1dGhvciBpcyBnb2luZyBmb3IgY幸B3YWxrIHdoaWxlIHRoZSBsaWdodCBicmVlemUgYmVsbG93cyBpbiBoaXMgZWFycy4=",
};
@Parameters
public static Collection<Object[]> data() {
return Arrays.asList(new Object[][] {
{ new Base64Jaxb() },
{ new Base64Secure() }
});
}
@Rule
public ExpectedException thrown = ExpectedException.none();
/**
* @param impl Base64 encode/decode implementation.
*/
public Base64Test(final Base64Impl impl) {
Base64.setImpl(impl);
}
@Test
public void standard() {
for (int i = 0; i < EXAMPLES.length; ++i) {
// Prepare.
final Object[] example = EXAMPLES[i];
final byte[] data = (byte[])example[0];
final String base64 = (String)example[1];
// Encode/decode.
final String encoded = Base64.encode(data);
final byte[] decoded = Base64.decode(base64);
// Validate.
assertEquals(base64, encoded);
assertArrayEquals(data, decoded);
}
}
@Test
public void whitespace() {
for (int i = 0; i < EXAMPLES.length; ++i) {
// Prepare.
final Object[] example = EXAMPLES[i];
final byte[] data = (byte[])example[0];
final String base64 = (String)example[1];
// Modify.
final int half = base64.length() / 2;
final String modifiedBase64 = " \t" + base64.substring(0, half) + "\r\n \r\n\t" + base64.substring(half) + " \t \n";
// Encode/decode.
final String encoded = Base64.encode(data);
final byte[] decoded = Base64.decode(modifiedBase64);
// Validate.
assertEquals(base64, encoded);
assertArrayEquals(data, decoded);
}
}
@Test
public void invalidPadding() {
for (int i = 0; i < EXAMPLES.length; ++i) {
// Prepare.
final Object[] example = EXAMPLES[i];
final String base64 = (String)example[1];
// Modify.
final String modifiedBase64 = base64 + "=";
// Decode.
boolean invalid = false;
try {
Base64.decode(modifiedBase64);
} catch (final IllegalArgumentException e) {
invalid = true;
}
assertTrue(invalid);
}
}
@Test
public void injectedPadding() {
for (int i = 0; i < EXAMPLES.length; ++i) {
// Prepare.
final Object[] example = EXAMPLES[i];
final String base64 = (String)example[1];
// Modify.
final int half = base64.length() / 2;
final String modifiedBase64 = base64.substring(0, half) + "=" + base64.substring(half);
// Decode.
boolean invalid = false;
try {
Base64.decode(modifiedBase64);
} catch (final IllegalArgumentException e) {
invalid = true;
}
assertTrue(invalid);
}
}
@Test
public void invalidCharacter() {
for (int i = 0; i < EXAMPLES.length; ++i) {
// Prepare.
final Object[] example = EXAMPLES[i];
final String base64 = (String)example[1];
// Modify.
final int half = base64.length() / 2;
final String modifiedBase64 = base64.substring(0, half) + "|" + base64.substring(half);
// Decode.
boolean invalid = false;
try {
Base64.decode(modifiedBase64);
} catch (final IllegalArgumentException e) {
invalid = true;
}
assertTrue(invalid);
}
}
@Test
public void outOfRangeCharacter() {
for (int i = 0; i < EXAMPLES.length; ++i) {
// Prepare.
final Object[] example = EXAMPLES[i];
final String base64 = (String)example[1];
// Modify.
final int half = base64.length() / 2;
final String modifiedBase64 = base64.substring(0, half) + new String(new byte[] {(byte)128}) + base64.substring(half);
// Decode.
boolean invalid = false;
try {
Base64.decode(modifiedBase64);
} catch (final IllegalArgumentException e) {
invalid = true;
}
assertTrue(invalid);
}
}
@Test
public void invalidLength() {
for (int i = 0; i < EXAMPLES.length; ++i) {
// Prepare.
final Object[] example = EXAMPLES[i];
final String base64 = (String)example[1];
// Modify.
final String modifiedBase64 = base64.substring(1);
// Decode.
boolean invalid = false;
try {
Base64.decode(modifiedBase64);
} catch (final IllegalArgumentException e) {
invalid = true;
}
assertTrue(invalid);
}
}
@Test
public void invalid() {
for (int i = 0; i < INVALID_EXAMPLES.length; ++i) {
final String base64 = INVALID_EXAMPLES[i];
boolean invalid = false;
try {
Base64.decode(base64);
} catch (final IllegalArgumentException e) {
invalid = true;
}
assertTrue(invalid);
}
}
@Test
public void emptyString() {
final String base64 = "";
final byte[] b = Base64.decode(base64);
assertEquals(0, b.length);
}
}
| 9,946 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/util/MslCompressionTest.java | /**
* Copyright (c) 2018 Netflix, Inc. All rights reserved.
*/
package com.netflix.msl.util;
import static org.junit.Assert.assertArrayEquals;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslConstants.CompressionAlgorithm;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
import com.netflix.msl.test.ExpectedMslException;
/**
* <p>MSL compression unit tests.</p>
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class MslCompressionTest {
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@Test
public void compressRatioExceeded() throws MslException {
final byte[] codes = new byte[] {
(byte)0x00, (byte)0x80, (byte)0x40, (byte)0x60, (byte)0x50, (byte)0x38, (byte)0x24, (byte)0x16, (byte)0x0d, (byte)0x07, (byte)0x84, (byte)0x42, (byte)0x61, (byte)0x50, (byte)0xb8, (byte)0x64,
(byte)0x36, (byte)0x1d, (byte)0x0f, (byte)0x88, (byte)0x44, (byte)0x62, (byte)0x51, (byte)0x38, (byte)0xa4, (byte)0x56, (byte)0x2d, (byte)0x17, (byte)0x8c, (byte)0x46, (byte)0x63, (byte)0x51,
(byte)0xb8, (byte)0xe4, (byte)0x76, (byte)0x3d, (byte)0x1f, (byte)0x90, (byte)0x48, (byte)0x64, (byte)0x52, (byte)0x39, (byte)0x24, (byte)0x96, (byte)0x4d, (byte)0x27, (byte)0x94, (byte)0x4a,
(byte)0x65, (byte)0x52, (byte)0x00 };
final byte[] data = new byte[1024];
final byte[] compressed = MslCompression.compress(CompressionAlgorithm.LZW, data);
assertArrayEquals(codes, compressed);
final byte[] uncompressed = MslCompression.uncompress(CompressionAlgorithm.LZW, codes);
assertArrayEquals(data, uncompressed);
thrown.expect(MslException.class);
thrown.expectMslError(MslError.UNCOMPRESSION_ERROR);
MslCompression.setMaxDeflateRatio(10);
MslCompression.uncompress(CompressionAlgorithm.LZW, codes);
}
}
| 9,947 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/util/SimpleMslStoreTest.java | /**
* Copyright (c) 2012-2020 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.util;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import java.util.Collection;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslConstants;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.MslMasterTokenException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.crypto.NullCryptoContext;
import com.netflix.msl.crypto.SessionCryptoContext;
import com.netflix.msl.crypto.SymmetricCryptoContext;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.tokens.MasterToken;
import com.netflix.msl.tokens.ServiceToken;
import com.netflix.msl.tokens.UserIdToken;
import com.netflix.msl.userauth.MockEmailPasswordAuthenticationFactory;
/**
* Simple MSL store unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class SimpleMslStoreTest {
private static final String KEYSET_ID = "keyset";
private static final String USER_ID = "userid";
/** Maximum number of randomly generated tokens. */
private static final int MAX_TOKENS = 3;
/** Stress test pool shutdown timeout in milliseconds. */
private static final int STRESS_TIMEOUT_MILLIS = 3000;
/**
* @param c1 first collection.
* @param c2 second collection.
* @return true if each collection contain all elements found in the other.
*/
private static boolean equal(final Collection<? extends Object> c1, final Collection<? extends Object> c2) {
return c1.containsAll(c2) && c2.containsAll(c1);
}
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException {
ctx = new MockMslContext(EntityAuthenticationScheme.NONE, false);
}
@AfterClass
public static void teardown() {
ctx = null;
}
@Before
public void createStore() {
store = new SimpleMslStore();
}
@After
public void destroyStore() {
store = null;
}
@Test
public void storeCryptoContext() throws MslEncodingException, MslCryptoException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
assertNull(store.getCryptoContext(masterToken));
final ICryptoContext cc1 = new SymmetricCryptoContext(ctx, KEYSET_ID, masterToken.getEncryptionKey(), masterToken.getSignatureKey(), null);
store.setCryptoContext(masterToken, cc1);
final ICryptoContext cc2 = store.getCryptoContext(masterToken);
assertNotNull(cc2);
assertSame(cc1, cc2);
assertEquals(masterToken, store.getMasterToken());
}
@Test
public void replaceCryptoContext() throws MslEncodingException, MslCryptoException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final ICryptoContext cc1 = new SymmetricCryptoContext(ctx, KEYSET_ID, masterToken.getEncryptionKey(), masterToken.getSignatureKey(), null);
final ICryptoContext cc2 = new NullCryptoContext();
store.setCryptoContext(masterToken, cc1);
final ICryptoContext cc3 = store.getCryptoContext(masterToken);
assertSame(cc1, cc3);
assertNotSame(cc2, cc3);
store.setCryptoContext(masterToken, cc2);
final ICryptoContext cc4 = store.getCryptoContext(masterToken);
assertNotSame(cc1, cc4);
assertSame(cc2, cc4);
assertEquals(masterToken, store.getMasterToken());
}
@Test
public void removeCryptoContext() throws MslEncodingException, MslCryptoException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final ICryptoContext cryptoContext = new NullCryptoContext();
store.setCryptoContext(masterToken, cryptoContext);
store.removeCryptoContext(masterToken);
assertNull(store.getMasterToken());
assertNull(store.getCryptoContext(masterToken));
}
@Test
public void clearCryptoContext() throws MslEncodingException, MslCryptoException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final ICryptoContext cc1 = new SymmetricCryptoContext(ctx, KEYSET_ID, masterToken.getEncryptionKey(), masterToken.getSignatureKey(), null);
store.setCryptoContext(masterToken, cc1);
store.clearCryptoContexts();
assertNull(store.getCryptoContext(masterToken));
assertNull(store.getMasterToken());
}
@Test
public void twoCryptoContexts() throws MslEncodingException, MslCryptoException, MslMasterTokenException {
final MasterToken mtA = MslTestUtils.getMasterToken(ctx, 1, 1);
final MasterToken mtB = MslTestUtils.getMasterToken(ctx, 2, 1);
final ICryptoContext ccMtA1 = new SessionCryptoContext(ctx, mtA);
final ICryptoContext ccMtB1 = new SessionCryptoContext(ctx, mtB);
store.setCryptoContext(mtA, ccMtA1);
store.setCryptoContext(mtB, ccMtB1);
final ICryptoContext ccMtA2 = store.getCryptoContext(mtA);
assertNotNull(ccMtA2);
assertSame(ccMtA1, ccMtA2);
final ICryptoContext ccMtB2 = store.getCryptoContext(mtB);
assertNotNull(ccMtB2);
assertSame(ccMtB1, ccMtB2);
assertEquals(mtB, store.getMasterToken());
}
@Test
public void replaceTwoCryptoContexts() throws MslEncodingException, MslCryptoException, MslMasterTokenException {
final MasterToken mtA = MslTestUtils.getMasterToken(ctx, 1, 1);
final MasterToken mtB = MslTestUtils.getMasterToken(ctx, 2, 1);
final ICryptoContext ccMtA1 = new SessionCryptoContext(ctx, mtA);
final ICryptoContext ccMtB1 = new SessionCryptoContext(ctx, mtB);
store.setCryptoContext(mtA, ccMtA1);
store.setCryptoContext(mtB, ccMtB1);
assertEquals(mtB, store.getMasterToken());
final ICryptoContext ccNull = new NullCryptoContext();
store.setCryptoContext(mtA, ccNull);
final ICryptoContext ccMtA2 = store.getCryptoContext(mtA);
assertNotNull(ccMtA2);
assertNotSame(ccMtA1, ccMtA2);
assertSame(ccNull, ccMtA2);
final ICryptoContext ccMtB2 = store.getCryptoContext(mtB);
assertNotNull(ccMtB2);
assertSame(ccMtB1, ccMtB2);
assertEquals(mtB, store.getMasterToken());
}
@Test
public void clearTwoCryptoContexts() throws MslEncodingException, MslCryptoException, MslMasterTokenException {
final MasterToken mtA = MslTestUtils.getMasterToken(ctx, 1, 1);
final MasterToken mtB = MslTestUtils.getMasterToken(ctx, 2, 1);
final ICryptoContext ccMtA1 = new SessionCryptoContext(ctx, mtA);
final ICryptoContext ccMtB1 = new SessionCryptoContext(ctx, mtB);
store.setCryptoContext(mtA, ccMtA1);
store.setCryptoContext(mtB, ccMtB1);
store.clearCryptoContexts();
assertNull(store.getCryptoContext(mtA));
assertNull(store.getCryptoContext(mtB));
assertNull(store.getMasterToken());
}
@Test
public void removeTwoCryptoContexts() throws MslEncodingException, MslCryptoException, MslMasterTokenException {
final MasterToken mtA = MslTestUtils.getMasterToken(ctx, 1, 1);
final MasterToken mtB = MslTestUtils.getMasterToken(ctx, 2, 1);
final ICryptoContext ccMtA1 = new SessionCryptoContext(ctx, mtA);
final ICryptoContext ccMtB1 = new SessionCryptoContext(ctx, mtB);
store.setCryptoContext(mtA, ccMtA1);
store.setCryptoContext(mtB, ccMtB1);
store.removeCryptoContext(mtA);
assertNull(store.getCryptoContext(mtA));
assertEquals(ccMtB1, store.getCryptoContext(mtB));
}
/**
* Crypto context add/remove stress test runner.
*
* Randomly adds or removes a crypto context for one of many master tokens
* (by master token entity identity). Also iterates through the set crypto
* contexts.
*/
private static class CryptoContextStressor implements Runnable {
/**
* Create a new crypto context stressor.
*
* @param ctx MSL context.
* @param store MSL store.
* @param count the number of master token identities to stress.
*/
public CryptoContextStressor(final MslContext ctx, final MslStore store, final int count) {
this.ctx = ctx;
this.store = store;
this.count = count;
}
/* (non-Javadoc)
* @see java.lang.Runnable#run()
*/
@Override
public void run() {
final Random r = new Random();
try {
for (int i = 0; i < 10 * count; ++i) {
final int tokenIndex = r.nextInt(count);
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, tokenIndex, 1);
final int option = r.nextInt(4);
switch (option) {
case 0:
store.setCryptoContext(masterToken, null);
break;
case 1:
final ICryptoContext cryptoContext = new SessionCryptoContext(ctx, masterToken);
store.setCryptoContext(masterToken, cryptoContext);
break;
case 2:
store.getCryptoContext(masterToken);
break;
case 3:
store.removeCryptoContext(masterToken);
break;
}
}
} catch (final MslMasterTokenException e) {
throw new MslInternalException("Unexpected master token exception.", e);
} catch (final MslEncodingException e) {
throw new MslInternalException("Unexpected master token encoding exception.", e);
} catch (final MslCryptoException e) {
throw new MslInternalException("Unexpected master token creation exception.", e);
}
}
/** MSL context. */
private final MslContext ctx;
/** MSL store. */
private final MslStore store;
/** Number of crypto context identities. */
private final int count;
}
@Test
public void stressCryptoContexts() throws InterruptedException, MslEncodingException, MslCryptoException {
final ExecutorService service = Executors.newCachedThreadPool();
for (int i = 0; i < 10 * MAX_TOKENS; ++i) {
service.execute(new CryptoContextStressor(ctx, store, MAX_TOKENS));
}
service.shutdown();
assertTrue(service.awaitTermination(STRESS_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS));
}
@Test
public void nonReplayableId() throws MslEncodingException, MslCryptoException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
for (int i = 1; i < 10; ++i)
assertEquals(i, store.getNonReplayableId(masterToken));
}
@Ignore
@Test
public void wrappedNonReplayableId() throws MslEncodingException, MslCryptoException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
for (long i = 1; i < MslConstants.MAX_LONG_VALUE; ++i)
store.getNonReplayableId(masterToken);
assertEquals(MslConstants.MAX_LONG_VALUE, store.getNonReplayableId(masterToken));
assertEquals(0, store.getNonReplayableId(masterToken));
assertEquals(1, store.getNonReplayableId(masterToken));
}
@Test
public void twoNonReplayableIds() throws MslEncodingException, MslCryptoException {
final MasterToken masterTokenA = MslTestUtils.getMasterToken(ctx, 1, 1);
final MasterToken masterTokenB = MslTestUtils.getMasterToken(ctx, 1, 2);
for (int i = 1; i < 10; ++i) {
assertEquals(i, store.getNonReplayableId(masterTokenA));
assertEquals(i, store.getNonReplayableId(masterTokenB));
}
}
@Test
public void addUserIdToken() throws MslException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(ctx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
final ICryptoContext cryptoContext = new NullCryptoContext();
store.setCryptoContext(masterToken, cryptoContext);
store.addUserIdToken(USER_ID, userIdToken);
assertEquals(userIdToken, store.getUserIdToken(USER_ID));
assertNull(store.getUserIdToken(USER_ID + "x"));
}
@Test
public void removeUserIdToken() throws MslEncodingException, MslCryptoException, MslException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(ctx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
final ICryptoContext cryptoContext = new NullCryptoContext();
store.setCryptoContext(masterToken, cryptoContext);
store.addUserIdToken(USER_ID, userIdToken);
store.removeUserIdToken(userIdToken);
assertNull(store.getUserIdToken(USER_ID));
}
@Test
public void replaceUserIdToken() throws MslEncodingException, MslCryptoException, MslException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final ICryptoContext cryptoContext = new NullCryptoContext();
final UserIdToken userIdTokenA = MslTestUtils.getUserIdToken(ctx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
final UserIdToken userIdTokenB = MslTestUtils.getUserIdToken(ctx, masterToken, 2, MockEmailPasswordAuthenticationFactory.USER);
store.setCryptoContext(masterToken, cryptoContext);
store.addUserIdToken(USER_ID, userIdTokenA);
store.addUserIdToken(USER_ID, userIdTokenB);
assertEquals(userIdTokenB, store.getUserIdToken(USER_ID));
}
@Test
public void twoUserIdTokens() throws MslEncodingException, MslCryptoException, MslException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final ICryptoContext cryptoContext = new NullCryptoContext();
final String userIdA = USER_ID + "A";
final String userIdB = USER_ID + "B";
final UserIdToken userIdTokenA = MslTestUtils.getUserIdToken(ctx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
final UserIdToken userIdTokenB = MslTestUtils.getUserIdToken(ctx, masterToken, 2, MockEmailPasswordAuthenticationFactory.USER);
store.setCryptoContext(masterToken, cryptoContext);
store.addUserIdToken(userIdA, userIdTokenA);
store.addUserIdToken(userIdB, userIdTokenB);
assertEquals(userIdTokenA, store.getUserIdToken(userIdA));
assertEquals(userIdTokenB, store.getUserIdToken(userIdB));
}
@Test
public void replaceTwoUserIdTokens() throws MslEncodingException, MslCryptoException, MslException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final ICryptoContext cryptoContext = new NullCryptoContext();
final String userIdA = USER_ID + "A";
final String userIdB = USER_ID + "B";
final UserIdToken userIdTokenA = MslTestUtils.getUserIdToken(ctx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
final UserIdToken userIdTokenB = MslTestUtils.getUserIdToken(ctx, masterToken, 2, MockEmailPasswordAuthenticationFactory.USER);
store.setCryptoContext(masterToken, cryptoContext);
store.addUserIdToken(userIdA, userIdTokenA);
store.addUserIdToken(userIdB, userIdTokenB);
final UserIdToken userIdTokenC = MslTestUtils.getUserIdToken(ctx, masterToken, 3, MockEmailPasswordAuthenticationFactory.USER);
store.addUserIdToken(userIdA, userIdTokenC);
assertEquals(userIdTokenC, store.getUserIdToken(userIdA));
assertEquals(userIdTokenB, store.getUserIdToken(userIdB));
}
@Test
public void removeTwoUserIdTokens() throws MslEncodingException, MslCryptoException, MslException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final ICryptoContext cryptoContext = new NullCryptoContext();
final String userIdA = USER_ID + "A";
final String userIdB = USER_ID + "B";
final UserIdToken userIdTokenA = MslTestUtils.getUserIdToken(ctx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
final UserIdToken userIdTokenB = MslTestUtils.getUserIdToken(ctx, masterToken, 2, MockEmailPasswordAuthenticationFactory.USER);
store.setCryptoContext(masterToken, cryptoContext);
store.addUserIdToken(userIdA, userIdTokenA);
store.addUserIdToken(userIdB, userIdTokenB);
store.removeUserIdToken(userIdTokenA);
assertNull(store.getUserIdToken(userIdA));
assertEquals(userIdTokenB, store.getUserIdToken(userIdB));
}
@Test
public void clearUserIdTokens() throws MslEncodingException, MslCryptoException, MslException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final ICryptoContext cryptoContext = new NullCryptoContext();
final String userIdA = USER_ID + "A";
final String userIdB = USER_ID + "B";
final UserIdToken userIdTokenA = MslTestUtils.getUserIdToken(ctx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
final UserIdToken userIdTokenB = MslTestUtils.getUserIdToken(ctx, masterToken, 2, MockEmailPasswordAuthenticationFactory.USER);
store.setCryptoContext(masterToken, cryptoContext);
store.addUserIdToken(userIdA, userIdTokenA);
store.addUserIdToken(userIdB, userIdTokenB);
store.clearUserIdTokens();
assertNull(store.getUserIdToken(userIdA));
assertNull(store.getUserIdToken(userIdB));
}
@Test
public void unknownMasterTokenUserIdToken() throws MslEncodingException, MslCryptoException, MslException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.USERIDTOKEN_MASTERTOKEN_NOT_FOUND);
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(ctx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
store.addUserIdToken(USER_ID, userIdToken);
}
@Test
public void removeMasterTokenSameSerialNumberUserIdTokens() throws MslEncodingException, MslCryptoException, MslException {
final MasterToken masterTokenA = MslTestUtils.getMasterToken(ctx, 1, 1);
final MasterToken masterTokenB = MslTestUtils.getMasterToken(ctx, 2, 1);
final ICryptoContext cryptoContext = new NullCryptoContext();
final String userIdA = USER_ID + "A";
final String userIdB = USER_ID + "B";
final String userIdC = USER_ID + "C";
final UserIdToken userIdTokenA = MslTestUtils.getUserIdToken(ctx, masterTokenA, 1, MockEmailPasswordAuthenticationFactory.USER);
final UserIdToken userIdTokenB = MslTestUtils.getUserIdToken(ctx, masterTokenA, 2, MockEmailPasswordAuthenticationFactory.USER);
final UserIdToken userIdTokenC = MslTestUtils.getUserIdToken(ctx, masterTokenB, 1, MockEmailPasswordAuthenticationFactory.USER);
store.setCryptoContext(masterTokenA, cryptoContext);
store.setCryptoContext(masterTokenB, cryptoContext);
store.addUserIdToken(userIdA, userIdTokenA);
store.addUserIdToken(userIdB, userIdTokenB);
store.addUserIdToken(userIdC, userIdTokenC);
// We still have a master token with serial number 1 so no user ID
// tokens should be deleted.
store.removeCryptoContext(masterTokenA);
assertEquals(userIdTokenA, store.getUserIdToken(userIdA));
assertEquals(userIdTokenB, store.getUserIdToken(userIdB));
assertEquals(userIdTokenC, store.getUserIdToken(userIdC));
}
@Test
public void removeMasterTokenReissuedUserIdTokens() throws MslEncodingException, MslCryptoException, MslException {
// Master token B has a new serial number, to invalidate the old master
// token and its user ID tokens.
final MasterToken masterTokenA = MslTestUtils.getMasterToken(ctx, 1, 1);
final MasterToken masterTokenB = MslTestUtils.getMasterToken(ctx, 1, 2);
final ICryptoContext cryptoContext = new NullCryptoContext();
final String userIdA = USER_ID + "A";
final String userIdB = USER_ID + "B";
final String userIdC = USER_ID + "C";
final UserIdToken userIdTokenA = MslTestUtils.getUserIdToken(ctx, masterTokenA, 1, MockEmailPasswordAuthenticationFactory.USER);
final UserIdToken userIdTokenB = MslTestUtils.getUserIdToken(ctx, masterTokenA, 2, MockEmailPasswordAuthenticationFactory.USER);
final UserIdToken userIdTokenC = MslTestUtils.getUserIdToken(ctx, masterTokenB, 1, MockEmailPasswordAuthenticationFactory.USER);
store.setCryptoContext(masterTokenA, cryptoContext);
store.addUserIdToken(userIdA, userIdTokenA);
store.addUserIdToken(userIdB, userIdTokenB);
store.setCryptoContext(masterTokenB, cryptoContext);
store.addUserIdToken(userIdC, userIdTokenC);
// All of master token A's user ID tokens should be deleted.
store.removeCryptoContext(masterTokenA);
assertNull(store.getUserIdToken(userIdA));
assertNull(store.getUserIdToken(userIdB));
assertEquals(userIdTokenC, store.getUserIdToken(userIdC));
}
@Test
public void clearCryptoContextsUserIdTokens() throws MslEncodingException, MslCryptoException, MslException {
// Master token B has a new serial number, to invalidate the old master
// token and its user ID tokens.
final MasterToken masterTokenA = MslTestUtils.getMasterToken(ctx, 1, 1);
final MasterToken masterTokenB = MslTestUtils.getMasterToken(ctx, 1, 2);
final ICryptoContext cryptoContext = new NullCryptoContext();
final String userIdA = USER_ID + "A";
final String userIdB = USER_ID + "B";
final UserIdToken userIdTokenA = MslTestUtils.getUserIdToken(ctx, masterTokenA, 1, MockEmailPasswordAuthenticationFactory.USER);
final UserIdToken userIdTokenB = MslTestUtils.getUserIdToken(ctx, masterTokenB, 2, MockEmailPasswordAuthenticationFactory.USER);
store.setCryptoContext(masterTokenA, cryptoContext);
store.setCryptoContext(masterTokenB, cryptoContext);
store.addUserIdToken(userIdA, userIdTokenA);
store.addUserIdToken(userIdB, userIdTokenB);
// All user ID tokens should be deleted.
store.clearCryptoContexts();
assertNull(store.getUserIdToken(userIdA));
assertNull(store.getUserIdToken(userIdB));
}
/**
* User ID token add/remove stress test runner.
*
* Randomly adds or removes user ID tokens. Also iterates through the user
* ID tokens.
*/
private static class UserIdTokenStressor implements Runnable {
/**
* Create a new service token stressor.
*
* @param ctx MSL context.
* @param store MSL store.
* @param count the number of master token and user ID tokens to create
* combinations of.
*/
public UserIdTokenStressor(final MslContext ctx, final MslStore store, final int count) {
this.ctx = ctx;
this.store = store;
this.count = count;
}
/* (non-Javadoc)
* @see java.lang.Runnable#run()
*/
@Override
public void run() {
final Random r = new Random();
try {
for (int i = 0; i < 10 * count; ++i) {
final int tokenIndex = r.nextInt(count);
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, tokenIndex, 1);
final long userId = r.nextInt(count);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(ctx, masterToken, userId, MockEmailPasswordAuthenticationFactory.USER);
final int option = r.nextInt(3);
switch (option) {
case 0:
{
store.setCryptoContext(masterToken, new NullCryptoContext());
store.addUserIdToken(USER_ID + userId, userIdToken);
break;
}
case 1:
{
store.getUserIdToken(USER_ID + userId);
break;
}
case 2:
{
store.removeUserIdToken(userIdToken);
break;
}
}
}
} catch (final MslMasterTokenException e) {
throw new MslInternalException("Unexpected master token exception.", e);
} catch (final MslEncodingException e) {
throw new MslInternalException("Unexpected master token encoding exception.", e);
} catch (final MslCryptoException e) {
throw new MslInternalException("Unexpected master token creation exception.", e);
} catch (final MslException e) {
throw new MslInternalException("Master token / user ID token service token query mismatch.", e);
}
}
/** MSL context. */
private final MslContext ctx;
/** MSL store. */
private final MslStore store;
/** Number of master token and user ID token identities. */
private final int count;
}
@Test
public void stressUserIdTokens() throws InterruptedException {
final ExecutorService service = Executors.newCachedThreadPool();
for (int i = 0; i < 10 * MAX_TOKENS; ++i) {
service.execute(new UserIdTokenStressor(ctx, store, MAX_TOKENS));
}
service.shutdown();
assertTrue(service.awaitTermination(STRESS_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS));
}
@Test
public void masterBoundServiceTokens() throws MslException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final ICryptoContext cryptoContext = new NullCryptoContext();
final Set<ServiceToken> tokens = MslTestUtils.getServiceTokens(ctx, masterToken, null);
store.setCryptoContext(masterToken, cryptoContext);
final Set<ServiceToken> emptyTokens = store.getServiceTokens(masterToken, null);
assertNotNull(emptyTokens);
assertEquals(0, emptyTokens.size());
store.addServiceTokens(tokens);
final Set<ServiceToken> storedTokens = store.getServiceTokens(masterToken, null);
assertNotNull(storedTokens);
assertTrue(equal(tokens, storedTokens));
}
@Test
public void missingMasterTokenAddServiceTokens() throws MslException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final Set<ServiceToken> tokens = MslTestUtils.getServiceTokens(ctx, masterToken, null);
MslException exception = null;
try {
store.addServiceTokens(tokens);
} catch (final MslException e) {
exception = e;
}
assertNotNull(exception);
final Set<ServiceToken> emptyTokens = store.getServiceTokens(masterToken, null);
assertNotNull(emptyTokens);
assertEquals(0, emptyTokens.size());
}
@Test
public void userBoundServiceTokens() throws MslEncodingException, MslCryptoException, MslException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(ctx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
final ICryptoContext cryptoContext = new NullCryptoContext();
final Set<ServiceToken> tokens = MslTestUtils.getServiceTokens(ctx, masterToken, userIdToken);
store.setCryptoContext(masterToken, cryptoContext);
store.addUserIdToken(USER_ID, userIdToken);
final Set<ServiceToken> emptyTokens = store.getServiceTokens(masterToken, userIdToken);
assertNotNull(emptyTokens);
assertEquals(0, emptyTokens.size());
store.addServiceTokens(tokens);
final Set<ServiceToken> storedTokens = store.getServiceTokens(masterToken, userIdToken);
assertNotNull(storedTokens);
assertTrue(equal(tokens, storedTokens));
}
@Test
public void missingUserIdTokenAddServiceTokens() throws MslException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(ctx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
final ICryptoContext cryptoContext = new NullCryptoContext();
final Set<ServiceToken> tokens = MslTestUtils.getServiceTokens(ctx, masterToken, userIdToken);
store.setCryptoContext(masterToken, cryptoContext);
MslException exception = null;
try {
store.addServiceTokens(tokens);
} catch (final MslException e) {
exception = e;
}
assertNotNull(exception);
final Set<ServiceToken> emptyTokens = store.getServiceTokens(masterToken, null);
assertNotNull(emptyTokens);
assertEquals(0, emptyTokens.size());
}
@Test
public void unboundServiceTokens() throws MslException {
final Set<ServiceToken> tokens = MslTestUtils.getServiceTokens(ctx, null, null);
final Set<ServiceToken> emptyTokens = store.getServiceTokens(null, null);
assertNotNull(emptyTokens);
assertEquals(0, emptyTokens.size());
store.addServiceTokens(tokens);
final Set<ServiceToken> storedTokens = store.getServiceTokens(null, null);
assertNotNull(storedTokens);
assertTrue(equal(tokens, storedTokens));
}
@Test
public void removeMasterBoundServiceTokens() throws MslException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(ctx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
final ICryptoContext cryptoContext = new NullCryptoContext();
final Set<ServiceToken> masterBoundTokens = MslTestUtils.getMasterBoundServiceTokens(ctx, masterToken);
final Set<ServiceToken> userBoundTokens = MslTestUtils.getUserBoundServiceTokens(ctx, masterToken, userIdToken);
final Set<ServiceToken> unboundTokens = MslTestUtils.getServiceTokens(ctx, null, null);
store.setCryptoContext(masterToken, cryptoContext);
store.addUserIdToken(USER_ID, userIdToken);
store.addServiceTokens(masterBoundTokens);
store.addServiceTokens(userBoundTokens);
store.addServiceTokens(unboundTokens);
store.removeServiceTokens(null, masterToken, null);
// This should only return the unbound tokens.
final Set<ServiceToken> storedMasterBoundTokens = store.getServiceTokens(masterToken, null);
assertNotNull(storedMasterBoundTokens);
assertTrue(equal(unboundTokens, storedMasterBoundTokens));
// This should only return the unbound and user-bound tokens.
final Set<ServiceToken> unboundAndUserBoundTokens = new HashSet<ServiceToken>();
unboundAndUserBoundTokens.addAll(unboundTokens);
unboundAndUserBoundTokens.addAll(userBoundTokens);
final Set<ServiceToken> storedUserBoundTokens = store.getServiceTokens(masterToken, userIdToken);
assertTrue(equal(unboundAndUserBoundTokens, storedUserBoundTokens));
// This should only return the unbound tokens.
final Set<ServiceToken> storedUnboundTokens = store.getServiceTokens(null, null);
assertNotNull(storedUnboundTokens);
assertTrue(equal(unboundTokens, storedUnboundTokens));
}
@Test
public void removeUserBoundServiceTokens() throws MslException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(ctx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
final ICryptoContext cryptoContext = new NullCryptoContext();
final Set<ServiceToken> masterBoundTokens = MslTestUtils.getMasterBoundServiceTokens(ctx, masterToken);
final Set<ServiceToken> userBoundTokens = MslTestUtils.getUserBoundServiceTokens(ctx, masterToken, userIdToken);
final Set<ServiceToken> unboundTokens = MslTestUtils.getServiceTokens(ctx, null, null);
store.setCryptoContext(masterToken, cryptoContext);
store.addUserIdToken(USER_ID, userIdToken);
store.addServiceTokens(masterBoundTokens);
store.addServiceTokens(userBoundTokens);
store.addServiceTokens(unboundTokens);
store.removeServiceTokens(null, null, userIdToken);
// This should only return the unbound and master bound-only tokens.
final Set<ServiceToken> storedMasterBoundTokens = store.getServiceTokens(masterToken, null);
assertNotNull(storedMasterBoundTokens);
final Set<ServiceToken> unboundAndMasterBoundTokens = new HashSet<ServiceToken>();
unboundAndMasterBoundTokens.addAll(unboundTokens);
unboundAndMasterBoundTokens.addAll(masterBoundTokens);
assertTrue(equal(unboundAndMasterBoundTokens, storedMasterBoundTokens));
// This should only return the unbound and master bound-only tokens.
final Set<ServiceToken> storedUserBoundTokens = store.getServiceTokens(masterToken, userIdToken);
assertNotNull(storedUserBoundTokens);
assertTrue(equal(unboundAndMasterBoundTokens, storedUserBoundTokens));
// This should only return the unbound tokens.
final Set<ServiceToken> storedUnboundTokens = store.getServiceTokens(null, null);
assertNotNull(storedUnboundTokens);
assertTrue(equal(unboundTokens, storedUnboundTokens));
}
@Test
public void removeNoServiceTokens() throws MslException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(ctx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
final ICryptoContext cryptoContext = new NullCryptoContext();
final Set<ServiceToken> masterBoundTokens = MslTestUtils.getMasterBoundServiceTokens(ctx, masterToken);
final Set<ServiceToken> userBoundTokens = MslTestUtils.getUserBoundServiceTokens(ctx, masterToken, userIdToken);
final Set<ServiceToken> unboundTokens = MslTestUtils.getServiceTokens(ctx, null, null);
store.setCryptoContext(masterToken, cryptoContext);
store.addUserIdToken(USER_ID, userIdToken);
store.addServiceTokens(masterBoundTokens);
store.addServiceTokens(userBoundTokens);
store.addServiceTokens(unboundTokens);
store.removeServiceTokens(null, null, null);
// This should only return the unbound and master bound tokens.
final Set<ServiceToken> storedMasterBoundTokens = store.getServiceTokens(masterToken, null);
assertNotNull(storedMasterBoundTokens);
final Set<ServiceToken> unboundAndMasterBoundTokens = new HashSet<ServiceToken>();
unboundAndMasterBoundTokens.addAll(unboundTokens);
unboundAndMasterBoundTokens.addAll(masterBoundTokens);
assertTrue(equal(unboundAndMasterBoundTokens, storedMasterBoundTokens));
// This should return all of the tokens.
final Set<ServiceToken> storedUserBoundTokens = store.getServiceTokens(masterToken, userIdToken);
assertNotNull(storedUserBoundTokens);
final Set<ServiceToken> allTokens = new HashSet<ServiceToken>();
allTokens.addAll(unboundTokens);
allTokens.addAll(userBoundTokens);
allTokens.addAll(masterBoundTokens);
assertTrue(equal(allTokens, storedUserBoundTokens));
// This should only return the unbound tokens.
final Set<ServiceToken> storedUnboundTokens = store.getServiceTokens(null, null);
assertNotNull(storedUnboundTokens);
assertTrue(equal(unboundTokens, storedUnboundTokens));
}
@Test
public void removeNamedServiceTokens() throws MslException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(ctx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
final ICryptoContext cryptoContext = new NullCryptoContext();
final Set<ServiceToken> masterBoundTokens = MslTestUtils.getMasterBoundServiceTokens(ctx, masterToken);
final Set<ServiceToken> userBoundTokens = MslTestUtils.getUserBoundServiceTokens(ctx, masterToken, userIdToken);
final Set<ServiceToken> unboundTokens = MslTestUtils.getServiceTokens(ctx, null, null);
store.setCryptoContext(masterToken, cryptoContext);
store.addUserIdToken(USER_ID, userIdToken);
store.addServiceTokens(masterBoundTokens);
store.addServiceTokens(userBoundTokens);
store.addServiceTokens(unboundTokens);
final Set<ServiceToken> allTokens = new HashSet<ServiceToken>();
allTokens.addAll(masterBoundTokens);
allTokens.addAll(userBoundTokens);
allTokens.addAll(unboundTokens);
final Random random = new Random();
final Set<ServiceToken> removedTokens = new HashSet<ServiceToken>();
for (final ServiceToken token : allTokens) {
if (random.nextBoolean()) continue;
store.removeServiceTokens(token.getName(), token.isMasterTokenBound() ? masterToken : null, token.isUserIdTokenBound() ? userIdToken : null);
removedTokens.add(token);
}
// This should only return tokens that haven't been removed.
final Set<ServiceToken> storedMasterBoundTokens = store.getServiceTokens(masterToken, null);
assertNotNull(storedMasterBoundTokens);
assertFalse(storedMasterBoundTokens.removeAll(removedTokens));
// This should only return tokens that haven't been removed.
final Set<ServiceToken> storedUserBoundTokens = store.getServiceTokens(masterToken, userIdToken);
assertNotNull(storedUserBoundTokens);
assertFalse(storedUserBoundTokens.removeAll(removedTokens));
// This should only return tokens that haven't been removed.
final Set<ServiceToken> storedUnboundTokens = store.getServiceTokens(null, null);
assertNotNull(storedUnboundTokens);
assertFalse(storedUnboundTokens.removeAll(removedTokens));
}
@Test
public void clearServiceTokens() throws MslException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(ctx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
final ICryptoContext cryptoContext = new NullCryptoContext();
final Set<ServiceToken> masterBoundTokens = MslTestUtils.getMasterBoundServiceTokens(ctx, masterToken);
final Set<ServiceToken> userBoundTokens = MslTestUtils.getUserBoundServiceTokens(ctx, masterToken, userIdToken);
final Set<ServiceToken> unboundTokens = MslTestUtils.getServiceTokens(ctx, null, null);
store.setCryptoContext(masterToken, cryptoContext);
store.addUserIdToken(USER_ID, userIdToken);
store.addServiceTokens(masterBoundTokens);
store.addServiceTokens(userBoundTokens);
store.addServiceTokens(unboundTokens);
store.clearServiceTokens();
final Set<ServiceToken> storedMasterBoundTokens = store.getServiceTokens(masterToken, null);
assertNotNull(storedMasterBoundTokens);
assertEquals(0, storedMasterBoundTokens.size());
final Set<ServiceToken> storedUserBoundTokens = store.getServiceTokens(masterToken, userIdToken);
assertNotNull(storedUserBoundTokens);
assertEquals(0, storedUserBoundTokens.size());
final Set<ServiceToken> storedUnboundTokens = store.getServiceTokens(null, null);
assertNotNull(storedUnboundTokens);
assertEquals(0, storedUserBoundTokens.size());
}
@Test
public void mismatchedGetServiceTokens() throws MslException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.USERIDTOKEN_MASTERTOKEN_MISMATCH);
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(ctx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
final MasterToken mismatchedMasterToken = MslTestUtils.getMasterToken(ctx, 2, 2);
store.getServiceTokens(mismatchedMasterToken, userIdToken);
}
@Test
public void missingMasterTokenGetServiceTokens() throws MslException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.USERIDTOKEN_MASTERTOKEN_NULL);
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(ctx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
store.getServiceTokens(null, userIdToken);
}
@Test
public void mismatchedRemoveServiceTokens() throws MslException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.USERIDTOKEN_MASTERTOKEN_MISMATCH);
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(ctx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
final MasterToken mismatchedMasterToken = MslTestUtils.getMasterToken(ctx, 2, 2);
store.removeServiceTokens(null, mismatchedMasterToken, userIdToken);
}
@Test
public void removeMasterTokenSameSerialNumberServiceTokens() throws MslEncodingException, MslCryptoException, MslException {
final MasterToken masterTokenA = MslTestUtils.getMasterToken(ctx, 1, 1);
final MasterToken masterTokenB = MslTestUtils.getMasterToken(ctx, 2, 1);
final ICryptoContext cryptoContext = new NullCryptoContext();
final String userIdA = USER_ID + "A";
final String userIdB = USER_ID + "B";
final UserIdToken userIdTokenA = MslTestUtils.getUserIdToken(ctx, masterTokenA, 1, MockEmailPasswordAuthenticationFactory.USER);
final UserIdToken userIdTokenB = MslTestUtils.getUserIdToken(ctx, masterTokenB, 2, MockEmailPasswordAuthenticationFactory.USER);
final Set<ServiceToken> masterBoundServiceTokens = MslTestUtils.getMasterBoundServiceTokens(ctx, masterTokenA);
final Set<ServiceToken> serviceTokensA = MslTestUtils.getUserBoundServiceTokens(ctx, masterTokenA, userIdTokenA);
final Set<ServiceToken> serviceTokensB = MslTestUtils.getUserBoundServiceTokens(ctx, masterTokenB, userIdTokenB);
store.setCryptoContext(masterTokenA, cryptoContext);
store.setCryptoContext(masterTokenB, cryptoContext);
store.addUserIdToken(userIdA, userIdTokenA);
store.addUserIdToken(userIdB, userIdTokenB);
store.addServiceTokens(masterBoundServiceTokens);
store.addServiceTokens(serviceTokensA);
store.addServiceTokens(serviceTokensB);
// We still have a master token with serial number 1 so no service
// tokens should have been deleted.
store.removeCryptoContext(masterTokenA);
final Set<ServiceToken> storedServiceTokensA = store.getServiceTokens(masterTokenB, userIdTokenA);
final Set<ServiceToken> storedServiceTokensB = store.getServiceTokens(masterTokenB, userIdTokenB);
final Set<ServiceToken> expectedServiceTokensA = new HashSet<ServiceToken>(masterBoundServiceTokens);
expectedServiceTokensA.addAll(serviceTokensA);
assertEquals(expectedServiceTokensA, storedServiceTokensA);
final Set<ServiceToken> expectedServiceTokensB = new HashSet<ServiceToken>(masterBoundServiceTokens);
expectedServiceTokensB.addAll(serviceTokensB);
assertEquals(expectedServiceTokensB, storedServiceTokensB);
}
@Test
public void removeMasterTokenReissuedServiceTokens() throws MslEncodingException, MslCryptoException, MslException {
// Master token B has a new serial number, to invalidate the old master
// token and its user ID tokens.
final MasterToken masterTokenA = MslTestUtils.getMasterToken(ctx, 1, 1);
final MasterToken masterTokenB = MslTestUtils.getMasterToken(ctx, 1, 2);
final ICryptoContext cryptoContext = new NullCryptoContext();
final String userIdA = USER_ID + "A";
final String userIdB = USER_ID + "B";
final UserIdToken userIdTokenA = MslTestUtils.getUserIdToken(ctx, masterTokenA, 1, MockEmailPasswordAuthenticationFactory.USER);
final UserIdToken userIdTokenB = MslTestUtils.getUserIdToken(ctx, masterTokenB, 2, MockEmailPasswordAuthenticationFactory.USER);
final Set<ServiceToken> masterBoundServiceTokens = MslTestUtils.getMasterBoundServiceTokens(ctx, masterTokenA);
final Set<ServiceToken> serviceTokensA = MslTestUtils.getUserBoundServiceTokens(ctx, masterTokenA, userIdTokenA);
final Set<ServiceToken> serviceTokensB = MslTestUtils.getUserBoundServiceTokens(ctx, masterTokenB, userIdTokenB);
store.setCryptoContext(masterTokenA, cryptoContext);
store.setCryptoContext(masterTokenB, cryptoContext);
store.addUserIdToken(userIdA, userIdTokenA);
store.addUserIdToken(userIdB, userIdTokenB);
store.addServiceTokens(masterBoundServiceTokens);
store.addServiceTokens(serviceTokensA);
store.addServiceTokens(serviceTokensB);
// All of master token A's user ID tokens should be deleted.
store.removeCryptoContext(masterTokenA);
assertTrue(store.getServiceTokens(masterTokenA, userIdTokenA).isEmpty());
final Set<ServiceToken> storedServiceTokensB = store.getServiceTokens(masterTokenB, userIdTokenB);
assertEquals(serviceTokensB, storedServiceTokensB);
}
@Test
public void clearCryptoContextsServiceTokens() throws MslEncodingException, MslCryptoException, MslException {
// Master token B has a new serial number, to invalidate the old master
// token and its user ID tokens.
final MasterToken masterTokenA = MslTestUtils.getMasterToken(ctx, 1, 1);
final MasterToken masterTokenB = MslTestUtils.getMasterToken(ctx, 1, 2);
final ICryptoContext cryptoContext = new NullCryptoContext();
final String userIdA = USER_ID + "A";
final String userIdB = USER_ID + "B";
final UserIdToken userIdTokenA = MslTestUtils.getUserIdToken(ctx, masterTokenA, 1, MockEmailPasswordAuthenticationFactory.USER);
final UserIdToken userIdTokenB = MslTestUtils.getUserIdToken(ctx, masterTokenB, 2, MockEmailPasswordAuthenticationFactory.USER);
final Set<ServiceToken> unboundServiceTokens = MslTestUtils.getServiceTokens(ctx, null, null);
final Set<ServiceToken> serviceTokensA = MslTestUtils.getUserBoundServiceTokens(ctx, masterTokenA, userIdTokenA);
final Set<ServiceToken> serviceTokensB = MslTestUtils.getUserBoundServiceTokens(ctx, masterTokenB, userIdTokenB);
store.setCryptoContext(masterTokenA, cryptoContext);
store.setCryptoContext(masterTokenB, cryptoContext);
store.addUserIdToken(userIdA, userIdTokenA);
store.addUserIdToken(userIdB, userIdTokenB);
store.addServiceTokens(unboundServiceTokens);
store.addServiceTokens(serviceTokensA);
store.addServiceTokens(serviceTokensB);
// All bound service tokens should be deleted.
store.clearCryptoContexts();
assertEquals(unboundServiceTokens, store.getServiceTokens(masterTokenA, userIdTokenA));
assertEquals(unboundServiceTokens, store.getServiceTokens(masterTokenB, userIdTokenB));
final Set<ServiceToken> storedServiceTokens = store.getServiceTokens(null, null);
assertEquals(unboundServiceTokens, storedServiceTokens);
}
@Test
public void removeUserIdTokenServiceTokens() throws MslEncodingException, MslCryptoException, MslException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final ICryptoContext cryptoContext = new NullCryptoContext();
final String userIdA = USER_ID + "A";
final String userIdB = USER_ID + "B";
final UserIdToken userIdTokenA = MslTestUtils.getUserIdToken(ctx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
final UserIdToken userIdTokenB = MslTestUtils.getUserIdToken(ctx, masterToken, 2, MockEmailPasswordAuthenticationFactory.USER);
final Set<ServiceToken> masterBoundServiceTokens = MslTestUtils.getMasterBoundServiceTokens(ctx, masterToken);
final Set<ServiceToken> serviceTokensA = MslTestUtils.getUserBoundServiceTokens(ctx, masterToken, userIdTokenA);
final Set<ServiceToken> serviceTokensB = MslTestUtils.getUserBoundServiceTokens(ctx, masterToken, userIdTokenB);
store.setCryptoContext(masterToken, cryptoContext);
store.addUserIdToken(userIdA, userIdTokenA);
store.addUserIdToken(userIdB, userIdTokenB);
store.addServiceTokens(masterBoundServiceTokens);
store.addServiceTokens(serviceTokensA);
store.addServiceTokens(serviceTokensB);
// We should still have all the master token bound and user ID token B
// bound service tokens.
store.removeUserIdToken(userIdTokenA);
final Set<ServiceToken> storedServiceTokens = store.getServiceTokens(masterToken, userIdTokenB);
final Set<ServiceToken> expectedServiceTokens = new HashSet<ServiceToken>(masterBoundServiceTokens);
expectedServiceTokens.addAll(serviceTokensB);
assertEquals(expectedServiceTokens, storedServiceTokens);
}
@Test
public void clearUserIdTokensServiceTokens() throws MslEncodingException, MslCryptoException, MslException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final ICryptoContext cryptoContext = new NullCryptoContext();
final String userIdA = USER_ID + "A";
final String userIdB = USER_ID + "B";
final UserIdToken userIdTokenA = MslTestUtils.getUserIdToken(ctx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
final UserIdToken userIdTokenB = MslTestUtils.getUserIdToken(ctx, masterToken, 2, MockEmailPasswordAuthenticationFactory.USER);
final Set<ServiceToken> masterBoundServiceTokens = MslTestUtils.getMasterBoundServiceTokens(ctx, masterToken);
final Set<ServiceToken> serviceTokensA = MslTestUtils.getUserBoundServiceTokens(ctx, masterToken, userIdTokenA);
final Set<ServiceToken> serviceTokensB = MslTestUtils.getUserBoundServiceTokens(ctx, masterToken, userIdTokenB);
store.setCryptoContext(masterToken, cryptoContext);
store.addUserIdToken(userIdA, userIdTokenA);
store.addUserIdToken(userIdB, userIdTokenB);
store.addServiceTokens(masterBoundServiceTokens);
store.addServiceTokens(serviceTokensA);
store.addServiceTokens(serviceTokensB);
// Only the master token bound service tokens should be left.
store.clearUserIdTokens();
final Set<ServiceToken> storedServiceTokens = store.getServiceTokens(masterToken, userIdTokenB);
assertEquals(masterBoundServiceTokens, storedServiceTokens);
}
/**
* Service token add/remove stress test runner.
*
* Randomly adds or removes service tokens in combinations of unbound,
* master token bound, and user ID token bound Also iterates through the
* service tokens.
*/
private static class ServiceTokenStressor implements Runnable {
/**
* Create a new service token stressor.
*
* @param ctx MSL context.
* @param store MSL store.
* @param count the number of master token and user ID tokens to create
* combinations of.
*/
public ServiceTokenStressor(final MslContext ctx, final MslStore store, final int count) {
this.ctx = ctx;
this.store = store;
this.count = count;
}
/* (non-Javadoc)
* @see java.lang.Runnable#run()
*/
@Override
public void run() {
final Random r = new Random();
try {
for (int i = 0; i < 10 * count; ++i) {
final int tokenIndex = r.nextInt(count);
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, tokenIndex, 1);
final long userId = r.nextInt(count);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(ctx, masterToken, userId, MockEmailPasswordAuthenticationFactory.USER);
final int option = r.nextInt(6);
switch (option) {
case 0:
{
final Set<ServiceToken> tokens = MslTestUtils.getServiceTokens(ctx, null, null);
store.addServiceTokens(tokens);
break;
}
case 1:
{
store.setCryptoContext(masterToken, new NullCryptoContext());
final Set<ServiceToken> tokens = MslTestUtils.getServiceTokens(ctx, masterToken, null);
store.addServiceTokens(tokens);
break;
}
case 2:
{
store.setCryptoContext(masterToken, new NullCryptoContext());
store.addUserIdToken(USER_ID + userId, userIdToken);
final Set<ServiceToken> tokens = MslTestUtils.getServiceTokens(ctx, masterToken, userIdToken);
store.addServiceTokens(tokens);
break;
}
case 3:
{
store.getServiceTokens(null, null);
break;
}
case 4:
{
store.getServiceTokens(masterToken, null);
break;
}
case 5:
{
store.getServiceTokens(masterToken, userIdToken);
break;
}
}
}
} catch (final MslMasterTokenException e) {
throw new MslInternalException("Unexpected master token exception.", e);
} catch (final MslEncodingException e) {
throw new MslInternalException("Unexpected master token encoding exception.", e);
} catch (final MslCryptoException e) {
throw new MslInternalException("Unexpected master token creation exception.", e);
} catch (final MslException e) {
throw new MslInternalException("Master token / user ID token service token query mismatch.", e);
}
}
/** MSL context. */
private final MslContext ctx;
/** MSL store. */
private final MslStore store;
/** Number of master token and user ID token identities. */
private final int count;
}
@Test
public void stressServiceTokens() throws InterruptedException {
final ExecutorService service = Executors.newCachedThreadPool();
for (int i = 0; i < 10 * MAX_TOKENS; ++i) {
service.execute(new ServiceTokenStressor(ctx, store, MAX_TOKENS));
}
service.shutdown();
assertTrue(service.awaitTermination(STRESS_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS));
}
/** MSL context. */
private static MslContext ctx;
/** MSL store. */
private MslStore store;
}
| 9,948 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/util/NullMslStoreTest.java | /**
* Copyright (c) 2012-2014 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.util;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import java.util.HashSet;
import java.util.Set;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.crypto.NullCryptoContext;
import com.netflix.msl.entityauth.EntityAuthenticationData;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.entityauth.MockPresharedAuthenticationFactory;
import com.netflix.msl.entityauth.PresharedAuthenticationData;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.tokens.MasterToken;
import com.netflix.msl.tokens.MockTokenFactory;
import com.netflix.msl.tokens.ServiceToken;
import com.netflix.msl.tokens.TokenFactory;
import com.netflix.msl.tokens.UserIdToken;
import com.netflix.msl.userauth.MockEmailPasswordAuthenticationFactory;
/**
* Null MSL store unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class NullMslStoreTest {
private static final String TOKEN_NAME = "name";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException {
ctx = new MockMslContext(EntityAuthenticationScheme.NONE, false);
factory = new MockTokenFactory();
entityAuthData = new PresharedAuthenticationData(MockPresharedAuthenticationFactory.PSK_ESN);
}
@AfterClass
public static void teardown() {
entityAuthData = null;
factory = null;
ctx = null;
}
@Before
public void createStore() {
store = new NullMslStore();
}
@After
public void destroyStore() {
store = null;
}
@Test
public void cryptoContexts() throws MslException {
final MasterToken masterToken = factory.createMasterToken(ctx, entityAuthData, MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH, null);
assertNull(store.getCryptoContext(masterToken));
final ICryptoContext cryptoContext = new NullCryptoContext();
store.setCryptoContext(masterToken, cryptoContext);
assertNull(store.getCryptoContext(masterToken));
store.clearCryptoContexts();
}
@Test
public void nonReplayableId() throws MslEncodingException, MslCryptoException, MslException {
final MasterToken masterToken = factory.createMasterToken(ctx, entityAuthData, MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH, null);
for (int i = 0; i < 10; ++i)
assertEquals(1, store.getNonReplayableId(masterToken));
}
@Test
public void serviceTokens() throws MslException {
assertEquals(0, store.getServiceTokens(null, null).size());
final ICryptoContext cryptoContext = new NullCryptoContext();
final byte[] data = new byte[8];
ctx.getRandom().nextBytes(data);
final ServiceToken serviceToken = new ServiceToken(ctx, TOKEN_NAME, data, null, null, false, null, cryptoContext);
final Set<ServiceToken> tokens = new HashSet<ServiceToken>();
tokens.add(serviceToken);
store.addServiceTokens(tokens);
assertEquals(0, store.getServiceTokens(null, null).size());
store.removeServiceTokens(TOKEN_NAME, null, null);
store.clearServiceTokens();
}
@Test
public void mismatchedGetServiceTokens() throws MslException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.USERIDTOKEN_MASTERTOKEN_MISMATCH);
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(ctx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
final MasterToken mismatchedMasterToken = MslTestUtils.getMasterToken(ctx, 2, 2);
store.getServiceTokens(mismatchedMasterToken, userIdToken);
}
@Test
public void missingMasterTokenGetServiceTokens() throws MslException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.USERIDTOKEN_MASTERTOKEN_NULL);
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(ctx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
store.getServiceTokens(null, userIdToken);
}
@Test
public void mismatchedRemoveServiceTokens() throws MslException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.USERIDTOKEN_MASTERTOKEN_MISMATCH);
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(ctx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
final MasterToken mismatchedMasterToken = MslTestUtils.getMasterToken(ctx, 2, 2);
store.removeServiceTokens(null, mismatchedMasterToken, userIdToken);
}
/** MSL context. */
private static MslContext ctx;
/** Token factory. */
private static TokenFactory factory;
/** Entity authentication data. */
private static EntityAuthenticationData entityAuthData;
/** MSL store. */
private MslStore store;
}
| 9,949 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/msg/JSONTokenerTest.java | /**
* Copyright (c) 2012-2014 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.msg;
import static org.junit.Assert.*;
import org.json.JSONException;
import org.json.JSONObject;
import org.json.JSONTokener;
import org.junit.Test;
/**
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class JSONTokenerTest {
private static final String mobjs = "{ \"name1\" : \"firstobj\" } { \"name2\" : \"secondobj\" }";
@Test
public void multipleObjects() throws JSONException {
final JSONTokener tokener = new JSONTokener(mobjs);
assertTrue("No objects found", tokener.more());
final Object first = tokener.nextValue();
assertTrue("First object not JSONObject", first instanceof JSONObject);
final JSONObject firstJo = (JSONObject)first;
assertTrue("First object missing name", firstJo.has("name1"));
assertEquals("firstobj", firstJo.getString("name1"));
System.out.println(firstJo.toString());
assertTrue("No more objects found", tokener.more());
final Object second = tokener.nextValue();
assertTrue("Second object not JSONObject", second instanceof JSONObject);
final JSONObject secondJo = (JSONObject)second;
assertTrue("Second object missing name", secondJo.has("name2"));
assertEquals("secondobj", secondJo.getString("name2"));
System.out.println(secondJo.toString());
}
}
| 9,950 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/msg/MessageOutputStreamTest.java | /**
* Copyright (c) 2012-2018 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.msg;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import com.netflix.msl.MslConstants.CompressionAlgorithm;
import com.netflix.msl.MslConstants.ResponseCode;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslException;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.MslKeyExchangeException;
import com.netflix.msl.MslMasterTokenException;
import com.netflix.msl.MslMessageException;
import com.netflix.msl.MslUserAuthException;
import com.netflix.msl.MslUserIdTokenException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.entityauth.EntityAuthenticationData;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.entityauth.MockPresharedAuthenticationFactory;
import com.netflix.msl.entityauth.MockRsaAuthenticationFactory;
import com.netflix.msl.entityauth.PresharedAuthenticationData;
import com.netflix.msl.entityauth.RsaAuthenticationData;
import com.netflix.msl.entityauth.UnauthenticatedAuthenticationData;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.io.MslTokenizer;
import com.netflix.msl.keyx.KeyExchangeFactory;
import com.netflix.msl.keyx.KeyExchangeFactory.KeyExchangeData;
import com.netflix.msl.keyx.KeyRequestData;
import com.netflix.msl.keyx.KeyResponseData;
import com.netflix.msl.keyx.SymmetricWrappedExchange;
import com.netflix.msl.keyx.SymmetricWrappedExchange.KeyId;
import com.netflix.msl.msg.MessageHeader.HeaderData;
import com.netflix.msl.msg.MessageHeader.HeaderPeerData;
import com.netflix.msl.tokens.MasterToken;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* Message output stream unit tests.
*
* These tests assume the MessageOutputStream does not construct the header
* data but delegates that to the Header. Likewise for PayloadChunks. So there
* are no checks for proper encoding.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class MessageOutputStreamTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Maximum number of payload chunks to generate. */
private static final int MAX_PAYLOAD_CHUNKS = 10;
/** Maximum payload chunk data size in bytes. */
private static final int MAX_DATA_SIZE = 1024 * 1024;
/** Compressible data. */
private static final byte[] COMPRESSIBLE_DATA = new String(
"Kiba and Nami immortalized in code. I will never forget you. I'm sorry and I love you. Forgive me." +
"Kiba and Nami immortalized in code. I will never forget you. I'm sorry and I love you. Forgive me." +
"Kiba and Nami immortalized in code. I will never forget you. I'm sorry and I love you. Forgive me."
).getBytes();
/** I/O operation timeout in milliseconds. */
private static final int TIMEOUT = 20;
/** Random. */
private static Random random = new Random();
/** MSL context. */
private static MslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
/** Destination output stream. */
private static ByteArrayOutputStream destination = new ByteArrayOutputStream();
/** Payload crypto context. */
private static ICryptoContext PAYLOAD_CRYPTO_CONTEXT;
/** Header service token crypto contexts. */
private static Map<String,ICryptoContext> cryptoContexts = new HashMap<String,ICryptoContext>();
private static MessageFactory messageFactory = new MessageFactory();
private static EntityAuthenticationData ENTITY_AUTH_DATA;
private static MessageHeader MESSAGE_HEADER;
private static ErrorHeader ERROR_HEADER;
private static final Set<KeyRequestData> KEY_REQUEST_DATA = new HashSet<KeyRequestData>();
private static KeyResponseData KEY_RESPONSE_DATA;
private static ICryptoContext KEYX_CRYPTO_CONTEXT;
private static final String UNAUTHENTICATED_ESN = "MOCKUNAUTH-ESN";
@BeforeClass
public static void setup() throws MslMasterTokenException, MslEntityAuthException, MslException {
ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = ctx.getMslEncoderFactory();
final HeaderData headerData = new HeaderData(1, null, false, false, ctx.getMessageCapabilities(), null, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
ENTITY_AUTH_DATA = ctx.getEntityAuthenticationData(null);
MESSAGE_HEADER = new MessageHeader(ctx, ENTITY_AUTH_DATA, null, headerData, peerData);
PAYLOAD_CRYPTO_CONTEXT = MESSAGE_HEADER.getCryptoContext();
ERROR_HEADER = new ErrorHeader(ctx, ENTITY_AUTH_DATA, 1, ResponseCode.FAIL, 3, "errormsg", "usermsg");
final KeyRequestData keyRequest = new SymmetricWrappedExchange.RequestData(KeyId.PSK);
KEY_REQUEST_DATA.add(keyRequest);
final KeyExchangeFactory factory = ctx.getKeyExchangeFactory(keyRequest.getKeyExchangeScheme());
final KeyExchangeData keyxData = factory.generateResponse(ctx, ENCODER_FORMAT, keyRequest, ENTITY_AUTH_DATA);
KEY_RESPONSE_DATA = keyxData.keyResponseData;
KEYX_CRYPTO_CONTEXT = keyxData.cryptoContext;
}
@AfterClass
public static void teardown() {
KEYX_CRYPTO_CONTEXT = null;
KEY_RESPONSE_DATA = null;
KEY_REQUEST_DATA.clear();
PAYLOAD_CRYPTO_CONTEXT = null;
ERROR_HEADER = null;
MESSAGE_HEADER = null;
encoder = null;
ctx = null;
}
@After
public void reset() {
destination.reset();
}
@Test
public void messageHeader() throws IOException, MslEncoderException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, MESSAGE_HEADER, PAYLOAD_CRYPTO_CONTEXT);
mos.close();
final InputStream mslMessage = new ByteArrayInputStream(destination.toByteArray());
final MslTokenizer tokenizer = encoder.createTokenizer(mslMessage);
// There should be one header.
assertTrue(tokenizer.more(TIMEOUT));
final Object first = tokenizer.nextObject(TIMEOUT);
assertTrue(first instanceof MslObject);
final MslObject headerMo = (MslObject)first;
// The reconstructed header should be equal to the original.
final Header header = Header.parseHeader(ctx, headerMo, cryptoContexts);
assertTrue(header instanceof MessageHeader);
final MessageHeader messageHeader = (MessageHeader)header;
assertEquals(MESSAGE_HEADER, messageHeader);
// There should be one payload with no data indicating end of message.
assertTrue(tokenizer.more(TIMEOUT));
final Object second = tokenizer.nextObject(TIMEOUT);
assertTrue(second instanceof MslObject);
final MslObject payloadMo = (MslObject)second;
// Verify the payload.
final ICryptoContext cryptoContext = messageHeader.getCryptoContext();
assertNotNull(cryptoContext);
final PayloadChunk payload = new PayloadChunk(ctx, payloadMo, cryptoContext);
assertTrue(payload.isEndOfMessage());
assertEquals(1, payload.getSequenceNumber());
assertEquals(MESSAGE_HEADER.getMessageId(), payload.getMessageId());
assertEquals(0, payload.getData().length);
// There should be nothing else.
assertFalse(tokenizer.more(TIMEOUT));
// Verify cached payloads.
final List<PayloadChunk> payloads = mos.getPayloads();
assertEquals(1, payloads.size());
assertEquals(payload, payloads.get(0));
// Close the tokenizer.
tokenizer.close();
}
@Test
public void errorHeader() throws IOException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, ERROR_HEADER, ENCODER_FORMAT);
mos.close();
final InputStream mslMessage = new ByteArrayInputStream(destination.toByteArray());
final MslTokenizer tokenizer = encoder.createTokenizer(mslMessage);
// There should be one header.
assertTrue(tokenizer.more(TIMEOUT));
final Object first = tokenizer.nextObject(TIMEOUT);
assertTrue(first instanceof MslObject);
final MslObject headerMo = (MslObject)first;
// The reconstructed header should be equal to the original.
final Header header = Header.parseHeader(ctx, headerMo, cryptoContexts);
assertTrue(header instanceof ErrorHeader);
assertEquals(ERROR_HEADER, header);
// There should be no payloads.
assertFalse(tokenizer.more(TIMEOUT));
// Verify cached payloads.
final List<PayloadChunk> payloads = mos.getPayloads();
assertEquals(0, payloads.size());
// Close the tokenizer.
tokenizer.close();
}
@Test
public void entityAuthSchemeEncrypts() throws IOException, MslEncoderException, MslUserAuthException, MslMessageException, MslKeyExchangeException, MslUserIdTokenException, MslException {
final HeaderData headerData = new HeaderData(1, null, false, false, null, null, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = new PresharedAuthenticationData(MockPresharedAuthenticationFactory.PSK_ESN);
final MessageHeader messageHeader = new MessageHeader(ctx, entityAuthData, null, headerData, peerData);
final ICryptoContext cryptoContext = messageHeader.getCryptoContext();
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, messageHeader, cryptoContext);
assertTrue(mos.encryptsPayloads());
mos.close();
}
@Test
public void entityAuthSchemeDoesNotEncrypt() throws IOException, MslEncoderException, MslUserAuthException, MslMessageException, MslKeyExchangeException, MslUserIdTokenException, MslException {
final HeaderData headerData = new HeaderData(1, null, false, false, null, null, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = new RsaAuthenticationData(MockRsaAuthenticationFactory.RSA_ESN, MockRsaAuthenticationFactory.RSA_PUBKEY_ID);
final MessageHeader messageHeader = new MessageHeader(ctx, entityAuthData, null, headerData, peerData);
final ICryptoContext cryptoContext = messageHeader.getCryptoContext();
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, messageHeader, cryptoContext);
assertFalse(mos.encryptsPayloads());
mos.close();
}
@Test
public void entityAuthSchemeIntegrityProtects() throws IOException, MslEncoderException, MslUserAuthException, MslMessageException, MslKeyExchangeException, MslUserIdTokenException, MslException {
final HeaderData headerData = new HeaderData(1, null, false, false, null, null, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = new RsaAuthenticationData(MockRsaAuthenticationFactory.RSA_ESN, MockRsaAuthenticationFactory.RSA_PUBKEY_ID);
final MessageHeader messageHeader = new MessageHeader(ctx, entityAuthData, null, headerData, peerData);
final ICryptoContext cryptoContext = messageHeader.getCryptoContext();
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, messageHeader, cryptoContext);
assertTrue(mos.protectsPayloadIntegrity());
mos.close();
}
@Test
public void entityAuthSchemeDoesNotIntegrityProtect() throws IOException, MslEncoderException, MslUserAuthException, MslMessageException, MslKeyExchangeException, MslUserIdTokenException, MslException {
final HeaderData headerData = new HeaderData(1, null, false, false, null, null, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = new UnauthenticatedAuthenticationData(UNAUTHENTICATED_ESN);
final MessageHeader messageHeader = new MessageHeader(ctx, entityAuthData, null, headerData, peerData);
final ICryptoContext cryptoContext = messageHeader.getCryptoContext();
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, messageHeader, cryptoContext);
assertFalse(mos.protectsPayloadIntegrity());
mos.close();
}
@Test
public void entityAuthSchemeKeyxEncrypts() throws IOException, MslEncoderException, MslUserAuthException, MslMessageException, MslKeyExchangeException, MslUserIdTokenException, MslException {
final HeaderData headerData = new HeaderData(1, null, false, false, null, null, KEY_RESPONSE_DATA, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = new PresharedAuthenticationData(MockPresharedAuthenticationFactory.PSK_ESN);
final MessageHeader messageHeader = new MessageHeader(ctx, entityAuthData, null, headerData, peerData);
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, messageHeader, KEYX_CRYPTO_CONTEXT);
assertTrue(mos.encryptsPayloads());
mos.close();
}
@Test
public void entityAuthSchemeKeyxIntegrityProtects() throws IOException, MslEncoderException, MslUserAuthException, MslMessageException, MslKeyExchangeException, MslUserIdTokenException, MslException {
final HeaderData headerData = new HeaderData(1, null, false, false, null, null, KEY_RESPONSE_DATA, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = new RsaAuthenticationData(MockRsaAuthenticationFactory.RSA_ESN, MockRsaAuthenticationFactory.RSA_PUBKEY_ID);
final MessageHeader messageHeader = new MessageHeader(ctx, entityAuthData, null, headerData, peerData);
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, messageHeader, KEYX_CRYPTO_CONTEXT);
assertTrue(mos.protectsPayloadIntegrity());
mos.close();
}
@Test
public void entityAuthSchemeDoesNotKeyxEncrypts() throws IOException, MslEncoderException, MslUserAuthException, MslMessageException, MslKeyExchangeException, MslUserIdTokenException, MslException {
final HeaderData headerData = new HeaderData(1, null, false, false, null, null, KEY_RESPONSE_DATA, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = new RsaAuthenticationData(MockRsaAuthenticationFactory.RSA_ESN, MockRsaAuthenticationFactory.RSA_PUBKEY_ID);
final MessageHeader messageHeader = new MessageHeader(ctx, entityAuthData, null, headerData, peerData);
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, messageHeader, KEYX_CRYPTO_CONTEXT);
assertTrue(mos.encryptsPayloads());
mos.close();
}
@Test
public void entityAuthSchemeDoesNotKeyxIntegrityProtects() throws IOException, MslEncoderException, MslUserAuthException, MslMessageException, MslKeyExchangeException, MslUserIdTokenException, MslException {
final HeaderData headerData = new HeaderData(1, null, false, false, null, null, KEY_RESPONSE_DATA, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = new UnauthenticatedAuthenticationData(UNAUTHENTICATED_ESN);
final MessageHeader messageHeader = new MessageHeader(ctx, entityAuthData, null, headerData, peerData);
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, messageHeader, KEYX_CRYPTO_CONTEXT);
assertTrue(mos.protectsPayloadIntegrity());
mos.close();
}
@Test
public void masterTokenEncrypts() throws IOException, MslEncoderException, MslUserAuthException, MslMessageException, MslKeyExchangeException, MslUserIdTokenException, MslException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final HeaderData headerData = new HeaderData(1, null, false, false, null, null, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(ctx, null, masterToken, headerData, peerData);
final ICryptoContext cryptoContext = messageHeader.getCryptoContext();
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, messageHeader, cryptoContext);
assertTrue(mos.encryptsPayloads());
mos.close();
}
@Test
public void masterTokenIntegrityProtects() throws IOException, MslEncoderException, MslUserAuthException, MslMessageException, MslKeyExchangeException, MslUserIdTokenException, MslException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final HeaderData headerData = new HeaderData(1, null, false, false, null, null, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(ctx, null, masterToken, headerData, peerData);
final ICryptoContext cryptoContext = messageHeader.getCryptoContext();
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, messageHeader, cryptoContext);
assertTrue(mos.protectsPayloadIntegrity());
mos.close();
}
@Test
public void masterTokenKeyxEncrypts() throws IOException, MslEncoderException, MslUserAuthException, MslMessageException, MslKeyExchangeException, MslUserIdTokenException, MslException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final HeaderData headerData = new HeaderData(1, null, false, false, null, null, KEY_RESPONSE_DATA, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(ctx, null, masterToken, headerData, peerData);
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, messageHeader, KEYX_CRYPTO_CONTEXT);
assertTrue(mos.encryptsPayloads());
mos.close();
}
@Test
public void masterTokenKeyxIntegrityProtects() throws IOException, MslEncoderException, MslUserAuthException, MslMessageException, MslKeyExchangeException, MslUserIdTokenException, MslException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final HeaderData headerData = new HeaderData(1, null, false, false, null, null, KEY_RESPONSE_DATA, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(ctx, null, masterToken, headerData, peerData);
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, messageHeader, KEYX_CRYPTO_CONTEXT);
assertTrue(mos.protectsPayloadIntegrity());
mos.close();
}
@Test
public void writeOffsets() throws IOException, MslEncoderException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final byte[] data = new byte[32];
random.nextBytes(data);
final int from = 8;
final int length = 8;
final int to = from + length; // exclusive
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, MESSAGE_HEADER, PAYLOAD_CRYPTO_CONTEXT);
mos.write(data, from, length);
mos.close();
final InputStream mslMessage = new ByteArrayInputStream(destination.toByteArray());
final MslTokenizer tokenizer = encoder.createTokenizer(mslMessage);
// There should be one header.
assertTrue(tokenizer.more(TIMEOUT));
final Object first = tokenizer.nextObject(TIMEOUT);
assertTrue(first instanceof MslObject);
final MslObject headerMo = (MslObject)first;
// We assume the reconstructed header is equal to the original.
final Header header = Header.parseHeader(ctx, headerMo, cryptoContexts);
assertTrue(header instanceof MessageHeader);
final MessageHeader messageHeader = (MessageHeader)header;
// There should be one payload.
assertTrue(tokenizer.more(TIMEOUT));
final Object second = tokenizer.nextObject(TIMEOUT);
assertTrue(second instanceof MslObject);
final MslObject payloadMo = (MslObject)second;
// Verify the payload.
final ICryptoContext cryptoContext = messageHeader.getCryptoContext();
assertNotNull(cryptoContext);
final PayloadChunk payload = new PayloadChunk(ctx, payloadMo, cryptoContext);
assertTrue(payload.isEndOfMessage());
assertEquals(1, payload.getSequenceNumber());
assertEquals(MESSAGE_HEADER.getMessageId(), payload.getMessageId());
assertArrayEquals(Arrays.copyOfRange(data, from, to), payload.getData());
// There should be nothing else.
assertFalse(tokenizer.more(TIMEOUT));
// Verify cached payloads.
final List<PayloadChunk> payloads = mos.getPayloads();
assertEquals(1, payloads.size());
assertEquals(payload, payloads.get(0));
// Close the tokenizer.
tokenizer.close();
}
@Test
public void writeBytes() throws IOException, MslEncoderException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final byte[] data = new byte[32];
random.nextBytes(data);
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, MESSAGE_HEADER, PAYLOAD_CRYPTO_CONTEXT);
mos.write(data);
mos.close();
final InputStream mslMessage = new ByteArrayInputStream(destination.toByteArray());
final MslTokenizer tokenizer = encoder.createTokenizer(mslMessage);
// There should be one header.
assertTrue(tokenizer.more(TIMEOUT));
final Object first = tokenizer.nextObject(TIMEOUT);
assertTrue(first instanceof MslObject);
final MslObject headerMo = (MslObject)first;
// We assume the reconstructed header is equal to the original.
final Header header = Header.parseHeader(ctx, headerMo, cryptoContexts);
assertTrue(header instanceof MessageHeader);
final MessageHeader messageHeader = (MessageHeader)header;
// There should be one payload.
assertTrue(tokenizer.more(TIMEOUT));
final Object second = tokenizer.nextObject(TIMEOUT);
assertTrue(second instanceof MslObject);
final MslObject payloadMo = (MslObject)second;
// Verify the payload.
final ICryptoContext cryptoContext = messageHeader.getCryptoContext();
assertNotNull(cryptoContext);
final PayloadChunk payload = new PayloadChunk(ctx, payloadMo, cryptoContext);
assertTrue(payload.isEndOfMessage());
assertEquals(1, payload.getSequenceNumber());
assertEquals(MESSAGE_HEADER.getMessageId(), payload.getMessageId());
assertArrayEquals(data, payload.getData());
// There should be nothing else.
assertFalse(tokenizer.more(TIMEOUT));
// Verify cached payloads.
final List<PayloadChunk> payloads = mos.getPayloads();
assertEquals(1, payloads.size());
assertEquals(payload, payloads.get(0));
// Close the tokenizer.
tokenizer.close();
}
@Test
public void writeInt() throws IOException, MslEncoderException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final int value = 1;
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, MESSAGE_HEADER, PAYLOAD_CRYPTO_CONTEXT);
mos.write(value);
mos.close();
final InputStream mslMessage = new ByteArrayInputStream(destination.toByteArray());
final MslTokenizer tokenizer = encoder.createTokenizer(mslMessage);
// There should be one header.
assertTrue(tokenizer.more(TIMEOUT));
final Object first = tokenizer.nextObject(TIMEOUT);
assertTrue(first instanceof MslObject);
final MslObject headerMo = (MslObject)first;
// We assume the reconstructed header is equal to the original.
final Header header = Header.parseHeader(ctx, headerMo, cryptoContexts);
assertTrue(header instanceof MessageHeader);
final MessageHeader messageHeader = (MessageHeader)header;
// There should be one payload.
assertTrue(tokenizer.more(TIMEOUT));
final Object second = tokenizer.nextObject(TIMEOUT);
assertTrue(second instanceof MslObject);
final MslObject payloadMo = (MslObject)second;
// Verify the payload.
final ICryptoContext cryptoContext = messageHeader.getCryptoContext();
assertNotNull(cryptoContext);
final PayloadChunk payload = new PayloadChunk(ctx, payloadMo, cryptoContext);
assertTrue(payload.isEndOfMessage());
assertEquals(1, payload.getSequenceNumber());
assertEquals(MESSAGE_HEADER.getMessageId(), payload.getMessageId());
assertArrayEquals(new byte[] { value }, payload.getData());
// There should be nothing else.
assertFalse(tokenizer.more(TIMEOUT));
// Verify cached payloads.
final List<PayloadChunk> payloads = mos.getPayloads();
assertEquals(1, payloads.size());
assertEquals(payload, payloads.get(0));
// Close the tokenizer.
tokenizer.close();
}
@Test
public void compressed() throws IOException, MslEncoderException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, MESSAGE_HEADER, PAYLOAD_CRYPTO_CONTEXT);
// Write the first payload.
assertTrue(mos.setCompressionAlgorithm(null));
final byte[] first = Arrays.copyOf(COMPRESSIBLE_DATA, COMPRESSIBLE_DATA.length);
random.nextBytes(first);
mos.write(first);
// Changing the compressed value should result in a new payload.
assertTrue(mos.setCompressionAlgorithm(CompressionAlgorithm.GZIP));
final byte[] secondA = Arrays.copyOf(first, 2 * first.length);
System.arraycopy(COMPRESSIBLE_DATA, 0, secondA, COMPRESSIBLE_DATA.length, COMPRESSIBLE_DATA.length);
random.nextBytes(secondA);
mos.write(secondA);
// Setting the compressed value to the same should maintain the same
// payload.
assertTrue(mos.setCompressionAlgorithm(CompressionAlgorithm.GZIP));
final byte[] secondB = Arrays.copyOf(first, 3 * first.length);
System.arraycopy(COMPRESSIBLE_DATA, 0, secondB, COMPRESSIBLE_DATA.length, COMPRESSIBLE_DATA.length);
System.arraycopy(COMPRESSIBLE_DATA, 0, secondB, 2 * COMPRESSIBLE_DATA.length, COMPRESSIBLE_DATA.length);
random.nextBytes(secondB);
mos.write(secondB);
// Changing the compressed value should flush the second payload.
assertTrue(mos.setCompressionAlgorithm(null));
// Closing should create a final end-of-message payload.
mos.close();
// Grab the MSL objects.
final InputStream mslMessage = new ByteArrayInputStream(destination.toByteArray());
final MslTokenizer tokenizer = encoder.createTokenizer(mslMessage);
final MslObject headerMo = tokenizer.nextObject(TIMEOUT);
final List<MslObject> payloadMos = new ArrayList<MslObject>();
while (tokenizer.more(TIMEOUT))
payloadMos.add(tokenizer.nextObject(TIMEOUT));
tokenizer.close();
// Verify the number and contents of the payloads.
final MessageHeader messageHeader = (MessageHeader)Header.parseHeader(ctx, headerMo, cryptoContexts);
final ICryptoContext cryptoContext = messageHeader.getCryptoContext();
assertEquals(3, payloadMos.size());
final PayloadChunk firstPayload = new PayloadChunk(ctx, payloadMos.get(0), cryptoContext);
assertArrayEquals(first, firstPayload.getData());
final PayloadChunk secondPayload = new PayloadChunk(ctx, payloadMos.get(1), cryptoContext);
assertArrayEquals(secondA, Arrays.copyOfRange(secondPayload.getData(), 0, secondA.length));
assertArrayEquals(secondB, Arrays.copyOfRange(secondPayload.getData(), secondA.length, secondA.length + secondB.length));
final PayloadChunk thirdPayload = new PayloadChunk(ctx, payloadMos.get(2), cryptoContext);
assertEquals(0, thirdPayload.getData().length);
assertTrue(thirdPayload.isEndOfMessage());
// Verify cached payloads.
final List<PayloadChunk> payloads = mos.getPayloads();
assertEquals(payloadMos.size(), payloads.size());
assertEquals(firstPayload, payloads.get(0));
assertEquals(secondPayload, payloads.get(1));
assertEquals(thirdPayload, payloads.get(2));
}
@Test
public void flush() throws IOException, MslEncoderException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, MESSAGE_HEADER, PAYLOAD_CRYPTO_CONTEXT);
// Write the first payload.
final byte[] first = new byte[10];
random.nextBytes(first);
mos.write(first);
// Flushing should result in a new payload.
mos.flush();
final byte[] secondA = new byte[20];
random.nextBytes(secondA);
mos.write(secondA);
// Not flushing should maintain the same payload.
final byte[] secondB = new byte[30];
random.nextBytes(secondB);
mos.write(secondB);
// Flush the second payload.
mos.flush();
// Closing should create a final end-of-message payload.
mos.close();
// Grab the MSL objects.
final InputStream mslMessage = new ByteArrayInputStream(destination.toByteArray());
final MslTokenizer tokenizer = encoder.createTokenizer(mslMessage);
final MslObject headerMo = tokenizer.nextObject(TIMEOUT);
final List<MslObject> payloadMos = new ArrayList<MslObject>();
while (tokenizer.more(TIMEOUT))
payloadMos.add(tokenizer.nextObject(TIMEOUT));
tokenizer.close();
// Verify the number and contents of the payloads.
final MessageHeader messageHeader = (MessageHeader)Header.parseHeader(ctx, headerMo, cryptoContexts);
final ICryptoContext cryptoContext = messageHeader.getCryptoContext();
assertEquals(3, payloadMos.size());
final PayloadChunk firstPayload = new PayloadChunk(ctx, payloadMos.get(0), cryptoContext);
assertArrayEquals(first, firstPayload.getData());
final PayloadChunk secondPayload = new PayloadChunk(ctx, payloadMos.get(1), cryptoContext);
assertArrayEquals(secondA, Arrays.copyOfRange(secondPayload.getData(), 0, secondA.length));
assertArrayEquals(secondB, Arrays.copyOfRange(secondPayload.getData(), secondA.length, secondA.length + secondB.length));
final PayloadChunk thirdPayload = new PayloadChunk(ctx, payloadMos.get(2), cryptoContext);
assertEquals(0, thirdPayload.getData().length);
assertTrue(thirdPayload.isEndOfMessage());
// Verify cached payloads.
final List<PayloadChunk> payloads = mos.getPayloads();
assertEquals(payloadMos.size(), payloads.size());
assertEquals(firstPayload, payloads.get(0));
assertEquals(secondPayload, payloads.get(1));
assertEquals(thirdPayload, payloads.get(2));
}
@Test(expected = MslInternalException.class)
public void writeErrorHeader() throws MslMasterTokenException, MslCryptoException, IOException {
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, ERROR_HEADER, ENCODER_FORMAT);
try {
mos.write(new byte[0]);
} finally {
mos.close();
}
}
@Test(expected = MslInternalException.class)
public void writeHandshakeMessage() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException, IOException {
final HeaderData headerData = new HeaderData(1, null, false, true, ctx.getMessageCapabilities(), null, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(ctx, ENTITY_AUTH_DATA, null, headerData, peerData);
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, messageHeader, messageHeader.getCryptoContext());
try {
mos.write(new byte[0]);
} finally {
mos.close();
}
}
@Test(expected = IOException.class)
public void closed() throws MslMasterTokenException, MslCryptoException, IOException {
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, MESSAGE_HEADER, PAYLOAD_CRYPTO_CONTEXT);
mos.close();
mos.write(new byte[0]);
}
@Test
public void flushErrorHeader() throws IOException, MslMasterTokenException, MslCryptoException {
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, ERROR_HEADER, ENCODER_FORMAT);
try {
// No data so this should be a no-op.
mos.flush();
} finally {
mos.close();
}
}
@Test
public void stopCaching() throws IOException {
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, MESSAGE_HEADER, PAYLOAD_CRYPTO_CONTEXT);
// Write the first payload.
final byte[] first = new byte[10];
random.nextBytes(first);
mos.write(first);
mos.flush();
// Verify one payload.
final List<PayloadChunk> onePayload = mos.getPayloads();
assertEquals(1, onePayload.size());
// Stop caching.
mos.stopCaching();
final List<PayloadChunk> zeroPayload = mos.getPayloads();
assertEquals(0, zeroPayload.size());
// Write the second payload.
final byte[] secondA = new byte[20];
random.nextBytes(secondA);
mos.write(secondA);
// Verify zero payloads.
final List<PayloadChunk> twoPayload = mos.getPayloads();
assertEquals(0, twoPayload.size());
// Close
mos.close();
}
@Test
public void multiClose() throws IOException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, MESSAGE_HEADER, PAYLOAD_CRYPTO_CONTEXT);
mos.close();
mos.close();
final InputStream mslMessage = new ByteArrayInputStream(destination.toByteArray());
final MslTokenizer tokenizer = encoder.createTokenizer(mslMessage);
// There should be one header.
assertTrue(tokenizer.more(TIMEOUT));
final Object first = tokenizer.nextObject(TIMEOUT);
assertTrue(first instanceof MslObject);
final MslObject headerMo = (MslObject)first;
// We assume the reconstructed header is equal to the original.
final Header header = Header.parseHeader(ctx, headerMo, cryptoContexts);
assertTrue(header instanceof MessageHeader);
final MessageHeader messageHeader = (MessageHeader)header;
// There should be one payload with no data indicating end of message.
assertTrue(tokenizer.more(TIMEOUT));
final Object second = tokenizer.nextObject(TIMEOUT);
assertTrue(second instanceof MslObject);
final MslObject payloadMo = (MslObject)second;
// Verify the payload.
final ICryptoContext cryptoContext = messageHeader.getCryptoContext();
assertNotNull(cryptoContext);
final PayloadChunk payload = new PayloadChunk(ctx, payloadMo, cryptoContext);
assertTrue(payload.isEndOfMessage());
assertEquals(1, payload.getSequenceNumber());
assertEquals(MESSAGE_HEADER.getMessageId(), payload.getMessageId());
assertEquals(0, payload.getData().length);
// There should be nothing else.
assertFalse(tokenizer.more(TIMEOUT));
// Verify cached payloads.
final List<PayloadChunk> payloads = mos.getPayloads();
assertEquals(1, payloads.size());
assertEquals(payload, payloads.get(0));
// Close the tokenizer.
tokenizer.close();
}
@Test
public void stressWrite() throws IOException, MslEncoderException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, MESSAGE_HEADER, PAYLOAD_CRYPTO_CONTEXT);
mos.setCompressionAlgorithm(null);
// Generate some payload chunks, keeping track of what we're writing.
final ByteArrayOutputStream message = new ByteArrayOutputStream();
final int count = random.nextInt(MAX_PAYLOAD_CHUNKS) + 1;
for (int i = 0; i < count; ++i) {
// Randomly choose to set the compression algorithm and call flush.
if (random.nextBoolean()) mos.flush();
mos.setCompressionAlgorithm(random.nextBoolean() ? CompressionAlgorithm.GZIP : null);
final byte[] data = new byte[random.nextInt(MAX_DATA_SIZE) + 1];
random.nextBytes(data);
mos.write(data);
message.write(data);
}
mos.close();
// The destination should have received the message header followed by
// one or more payload chunks.
final InputStream mslMessage = new ByteArrayInputStream(destination.toByteArray());
final MslTokenizer tokenizer = encoder.createTokenizer(mslMessage);
final MslObject headerMo = tokenizer.nextObject(TIMEOUT);
final List<MslObject> payloadMos = new ArrayList<MslObject>();
while (tokenizer.more(TIMEOUT))
payloadMos.add(tokenizer.nextObject(TIMEOUT));
tokenizer.close();
final Header header = Header.parseHeader(ctx, headerMo, cryptoContexts);
assertTrue(header instanceof MessageHeader);
final MessageHeader messageHeader = (MessageHeader)header;
// Verify payloads, cached payloads, and aggregate data.
int sequenceNumber = 1;
final ByteArrayOutputStream data = new ByteArrayOutputStream();
final ICryptoContext cryptoContext = messageHeader.getCryptoContext();
final List<PayloadChunk> payloads = mos.getPayloads();
assertEquals(payloadMos.size(), payloads.size());
for (int i = 0; i < payloadMos.size(); ++i) {
final PayloadChunk payload = new PayloadChunk(ctx, payloadMos.get(i), cryptoContext);
assertEquals(sequenceNumber++, payload.getSequenceNumber());
assertEquals(messageHeader.getMessageId(), payload.getMessageId());
assertEquals(i == payloadMos.size() - 1, payload.isEndOfMessage());
data.write(payload.getData());
assertEquals(payload, payloads.get(i));
}
assertArrayEquals(message.toByteArray(), data.toByteArray());
}
@Test
public void noCtxCompressionAlgorithm() throws IOException, MslKeyExchangeException, MslUserAuthException, MslException {
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
ctx.setMessageCapabilities(null);
// The intersection of compression algorithms is computed when a
// response header is generated.
final MessageBuilder builder = messageFactory.createResponse(ctx, MESSAGE_HEADER);
final MessageHeader responseHeader = builder.getHeader();
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, responseHeader, PAYLOAD_CRYPTO_CONTEXT);
assertFalse(mos.setCompressionAlgorithm(CompressionAlgorithm.GZIP));
assertFalse(mos.setCompressionAlgorithm(CompressionAlgorithm.LZW));
mos.write(COMPRESSIBLE_DATA);
mos.close();
final List<PayloadChunk> payloads = mos.getPayloads();
assertEquals(1, payloads.size());
assertNull(payloads.get(0).getCompressionAlgo());
}
@Test
public void noRequestCompressionAlgorithm() throws IOException, MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException {
final HeaderData headerData = new HeaderData(1, null, false, false, null, null, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(ctx, ENTITY_AUTH_DATA, null, headerData, peerData);
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, messageHeader, PAYLOAD_CRYPTO_CONTEXT);
assertFalse(mos.setCompressionAlgorithm(CompressionAlgorithm.GZIP));
assertFalse(mos.setCompressionAlgorithm(CompressionAlgorithm.LZW));
mos.write(COMPRESSIBLE_DATA);
mos.close();
final List<PayloadChunk> payloads = mos.getPayloads();
assertEquals(1, payloads.size());
assertNull(payloads.get(0).getCompressionAlgo());
}
@Test
public void bestCompressionAlgorithm() throws IOException, MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException {
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, MESSAGE_HEADER, PAYLOAD_CRYPTO_CONTEXT);
mos.write(COMPRESSIBLE_DATA);
mos.close();
final List<PayloadChunk> payloads = mos.getPayloads();
assertEquals(1, payloads.size());
final MessageCapabilities capabilities = ctx.getMessageCapabilities();
final Set<CompressionAlgorithm> algos = capabilities.getCompressionAlgorithms();
final CompressionAlgorithm bestAlgo = CompressionAlgorithm.getPreferredAlgorithm(algos);
assertEquals(bestAlgo, payloads.get(0).getCompressionAlgo());
}
@Test
public void setCompressionAlgorithm() throws IOException, MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException {
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, MESSAGE_HEADER, PAYLOAD_CRYPTO_CONTEXT);
assertTrue(mos.setCompressionAlgorithm(CompressionAlgorithm.GZIP));
mos.write(COMPRESSIBLE_DATA);
assertTrue(mos.setCompressionAlgorithm(CompressionAlgorithm.LZW));
mos.write(COMPRESSIBLE_DATA);
mos.close();
final List<PayloadChunk> payloads = mos.getPayloads();
assertEquals(2, payloads.size());
assertEquals(CompressionAlgorithm.GZIP, payloads.get(0).getCompressionAlgo());
assertEquals(CompressionAlgorithm.LZW, payloads.get(1).getCompressionAlgo());
}
@Test
public void oneCompressionAlgorithm() throws IOException, MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException {
final Set<CompressionAlgorithm> algos = new HashSet<CompressionAlgorithm>();
algos.add(CompressionAlgorithm.GZIP);
final MessageCapabilities capabilities = new MessageCapabilities(algos, null, null);
final HeaderData headerData = new HeaderData(1, null, false, false, capabilities, null, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(ctx, ENTITY_AUTH_DATA, null, headerData, peerData);
final MessageOutputStream mos = new MessageOutputStream(ctx, destination, messageHeader, PAYLOAD_CRYPTO_CONTEXT);
assertFalse(mos.setCompressionAlgorithm(CompressionAlgorithm.LZW));
mos.write(COMPRESSIBLE_DATA);
mos.close();
final List<PayloadChunk> payloads = mos.getPayloads();
assertEquals(1, payloads.size());
assertEquals(CompressionAlgorithm.GZIP, payloads.get(0).getCompressionAlgo());
}
}
| 9,951 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/msg/MessageInputStreamTest.java | /**
* Copyright (c) 2012-2018 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.msg;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslConstants;
import com.netflix.msl.MslConstants.ResponseCode;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.MslKeyExchangeException;
import com.netflix.msl.MslMasterTokenException;
import com.netflix.msl.MslMessageException;
import com.netflix.msl.MslUserAuthException;
import com.netflix.msl.MslUserIdTokenException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.crypto.JcaAlgorithm;
import com.netflix.msl.crypto.NullCryptoContext;
import com.netflix.msl.crypto.SessionCryptoContext;
import com.netflix.msl.crypto.SymmetricCryptoContext;
import com.netflix.msl.entityauth.EntityAuthenticationData;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.entityauth.MockPresharedAuthenticationFactory;
import com.netflix.msl.entityauth.MockRsaAuthenticationFactory;
import com.netflix.msl.entityauth.PresharedAuthenticationData;
import com.netflix.msl.entityauth.RsaAuthenticationData;
import com.netflix.msl.entityauth.UnauthenticatedAuthenticationData;
import com.netflix.msl.entityauth.UnauthenticatedAuthenticationFactory;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.keyx.KeyExchangeFactory;
import com.netflix.msl.keyx.KeyExchangeFactory.KeyExchangeData;
import com.netflix.msl.keyx.KeyExchangeScheme;
import com.netflix.msl.keyx.KeyRequestData;
import com.netflix.msl.keyx.KeyResponseData;
import com.netflix.msl.keyx.SymmetricWrappedExchange;
import com.netflix.msl.keyx.SymmetricWrappedExchange.KeyId;
import com.netflix.msl.msg.MessageHeader.HeaderData;
import com.netflix.msl.msg.MessageHeader.HeaderPeerData;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.tokens.MasterToken;
import com.netflix.msl.tokens.MockTokenFactory;
import com.netflix.msl.tokens.UserIdToken;
import com.netflix.msl.userauth.MockEmailPasswordAuthenticationFactory;
import com.netflix.msl.util.MockAuthenticationUtils;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* Message input stream unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class MessageInputStreamTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Maximum number of payload chunks to generate. */
private static final int MAX_PAYLOAD_CHUNKS = 12;
/** Maximum payload chunk data size in bytes. */
private static final int MAX_DATA_SIZE = 100 * 1024;
/** Non-replayable ID acceptance window. */
private static final long NON_REPLAYABLE_ID_WINDOW = 65536;
/** Random. */
private static Random random = new Random();
/** Trusted network MSL context. */
private static MslContext trustedNetCtx;
/** Peer-to-peer MSL context. */
private static MslContext p2pCtx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
/** Header service token crypto contexts. */
private static Map<String,ICryptoContext> cryptoContexts = new HashMap<String,ICryptoContext>();
/** Message payloads (initially empty). */
private static final List<PayloadChunk> payloads = new ArrayList<PayloadChunk>();
/** Data read buffer. */
private static byte[] buffer;
private static MessageHeader MESSAGE_HEADER;
private static ErrorHeader ERROR_HEADER;
private static final Set<KeyRequestData> KEY_REQUEST_DATA = new HashSet<KeyRequestData>();
private static KeyResponseData KEY_RESPONSE_DATA;
private static ICryptoContext KEYX_CRYPTO_CONTEXT, ALT_MSL_CRYPTO_CONTEXT;
private static final long SEQ_NO = 1;
private static final long MSG_ID = 42;
private static final boolean END_OF_MSG = true;
private static final byte[] DATA = new byte[32];
private static final String UNAUTHENTICATED_ESN = "MOCKUNAUTH-ESN";
/**
* A crypto context that always returns false for verify. The other crypto
* operations are no-ops.
*/
private static class RejectingCryptoContext extends NullCryptoContext {
/* (non-Javadoc)
* @see com.netflix.msl.crypto.NullCryptoContext#verify(byte[], byte[], com.netflix.msl.io.MslEncoderFactory)
*/
@Override
public boolean verify(final byte[] data, final byte[] signature, final MslEncoderFactory encoder) throws MslCryptoException {
return false;
}
}
/**
* Increments the provided non-replayable ID by 1, wrapping around to zero
* if the provided value is equal to {@link MslConstants#MAX_LONG_VALUE}.
*
* @param id the non-replayable ID to increment.
* @return the non-replayable ID + 1.
* @throws MslInternalException if the provided non-replayable ID is out of
* range.
*/
private static long incrementNonReplayableId(final long id) {
if (id < 0 || id > MslConstants.MAX_LONG_VALUE)
throw new MslInternalException("Non-replayable ID " + id + " is outside the valid range.");
return (id == MslConstants.MAX_LONG_VALUE) ? 0 : id + 1;
}
/**
* Create a new input stream containing a MSL message constructed from the
* provided header and payloads.
*
* @param header message or error header.
* @param payloads zero or more payload chunks.
* @return an input stream containing the MSL message.
* @throws IOException if there is an error creating the input stream.
* @throws MslEncoderException if there is an error encoding the data.
*/
private static InputStream generateInputStream(final Header header, final List<PayloadChunk> payloads) throws IOException, MslEncoderException {
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
baos.write(header.toMslEncoding(encoder, ENCODER_FORMAT));
for (final PayloadChunk payload : payloads)
baos.write(payload.toMslEncoding(encoder, ENCODER_FORMAT));
return new ByteArrayInputStream(baos.toByteArray());
}
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@BeforeClass
public static void setup() throws MslMasterTokenException, MslEntityAuthException, MslException {
trustedNetCtx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
p2pCtx = new MockMslContext(EntityAuthenticationScheme.PSK, true);
encoder = trustedNetCtx.getMslEncoderFactory();
random.nextBytes(DATA);
buffer = new byte[MAX_PAYLOAD_CHUNKS * MAX_DATA_SIZE];
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
MESSAGE_HEADER = new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
ERROR_HEADER = new ErrorHeader(trustedNetCtx, entityAuthData, 1, ResponseCode.FAIL, 3, "errormsg", "usermsg");
final KeyRequestData keyRequest = new SymmetricWrappedExchange.RequestData(KeyId.PSK);
KEY_REQUEST_DATA.add(keyRequest);
final KeyExchangeFactory factory = trustedNetCtx.getKeyExchangeFactory(keyRequest.getKeyExchangeScheme());
final KeyExchangeData keyxData = factory.generateResponse(trustedNetCtx, ENCODER_FORMAT, keyRequest, entityAuthData);
KEY_RESPONSE_DATA = keyxData.keyResponseData;
KEYX_CRYPTO_CONTEXT = keyxData.cryptoContext;
final byte[] mke = new byte[16];
final byte[] mkh = new byte[32];
final byte[] mkw = new byte[16];
random.nextBytes(mke);
random.nextBytes(mkh);
random.nextBytes(mkw);
final SecretKey encryptionKey = new SecretKeySpec(mke, JcaAlgorithm.AES);
final SecretKey hmacKey = new SecretKeySpec(mkh, JcaAlgorithm.HMAC_SHA256);
final SecretKey wrappingKey = new SecretKeySpec(mkw, JcaAlgorithm.AESKW);
ALT_MSL_CRYPTO_CONTEXT = new SymmetricCryptoContext(trustedNetCtx, "clientMslCryptoContext", encryptionKey, hmacKey, wrappingKey);
}
@AfterClass
public static void teardown() {
ALT_MSL_CRYPTO_CONTEXT = null;
KEYX_CRYPTO_CONTEXT = null;
KEY_RESPONSE_DATA = null;
KEY_REQUEST_DATA.clear();
ERROR_HEADER = null;
MESSAGE_HEADER = null;
buffer = null;
encoder = null;
p2pCtx = null;
trustedNetCtx = null;
}
@Before
public void reset() {
payloads.clear();
}
@Test
public void messageHeaderEmpty() throws MslEncodingException, MslException, IOException, MslEncoderException {
// An end-of-message payload is expected.
final ICryptoContext cryptoContext = MESSAGE_HEADER.getCryptoContext();
payloads.add(new PayloadChunk(trustedNetCtx, SEQ_NO, MSG_ID, END_OF_MSG, null, new byte[0], cryptoContext));
final InputStream is = generateInputStream(MESSAGE_HEADER, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
assertEquals(0, mis.available());
assertNull(mis.getErrorHeader());
assertEquals(MESSAGE_HEADER, mis.getMessageHeader());
assertTrue(mis.markSupported());
assertEquals(-1, mis.read());
assertEquals(-1, mis.read(buffer));
assertEquals(-1, mis.read(buffer, 0, 1));
assertEquals(0, mis.skip(1));
mis.mark(0);
mis.reset();
mis.close();
}
@Test
public void messageHeaderData() throws MslEncodingException, MslException, IOException, MslEncoderException {
// An end-of-message payload is expected.
final ICryptoContext cryptoContext = MESSAGE_HEADER.getCryptoContext();
payloads.add(new PayloadChunk(trustedNetCtx, SEQ_NO, MSG_ID, END_OF_MSG, null, DATA, cryptoContext));
final InputStream is = generateInputStream(MESSAGE_HEADER, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
assertEquals(DATA.length, mis.read(buffer));
assertArrayEquals(DATA, Arrays.copyOf(buffer, DATA.length));
mis.close();
}
@Test
public void entityAuthDataIdentity() throws MslException, IOException, MslEncoderException {
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
assertEquals(entityAuthData.getIdentity(), mis.getIdentity());
mis.close();
}
@Test
public void masterTokenIdentity() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException, MslUserAuthException, MslKeyExchangeException, MslException, IOException, MslEncoderException {
final MasterToken masterToken = MslTestUtils.getMasterToken(trustedNetCtx, 1, 1);
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, null, masterToken, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
assertEquals(masterToken.getIdentity(), mis.getIdentity());
mis.close();
}
@Test
public void errorHeaderIdentity() throws MslEncodingException, MslEntityAuthException, MslCryptoException, MslUserAuthException, MslMessageException, MslKeyExchangeException, MslMasterTokenException, IOException, MslException, MslEncoderException {
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final ErrorHeader errorHeader = new ErrorHeader(trustedNetCtx, entityAuthData, 1, ResponseCode.FAIL, 3, "errormsg", "usermsg");
final InputStream is = generateInputStream(errorHeader, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
assertEquals(entityAuthData.getIdentity(), mis.getIdentity());
mis.close();
}
@Test
public void revokedEntity() throws IOException, MslUserAuthException, MslKeyExchangeException, MslException, MslEncoderException {
thrown.expect(MslEntityAuthException.class);
thrown.expectMslError(MslError.ENTITY_REVOKED);
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.NONE, false);
final MockAuthenticationUtils authutils = new MockAuthenticationUtils();
final UnauthenticatedAuthenticationFactory factory = new UnauthenticatedAuthenticationFactory(authutils);
ctx.addEntityAuthenticationFactory(factory);
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = ctx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(ctx, entityAuthData, null, headerData, peerData);
authutils.revokeEntity(entityAuthData.getIdentity());
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(ctx, is, KEY_REQUEST_DATA, cryptoContexts);
mis.close();
}
@Test
public void revokedMasterToken() throws IOException, MslEncodingException, MslEntityAuthException, MslCryptoException, MslUserAuthException, MslMessageException, MslKeyExchangeException, MslMasterTokenException, MslException, MslEncoderException {
thrown.expect(MslMasterTokenException.class);
thrown.expectMslError(MslError.MASTERTOKEN_IDENTITY_REVOKED);
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
final MockTokenFactory factory = new MockTokenFactory();
ctx.setTokenFactory(factory);
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(ctx, null, masterToken, headerData, peerData);
factory.setRevokedMasterToken(masterToken);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(ctx, is, KEY_REQUEST_DATA, cryptoContexts);
mis.close();
}
@Test
public void nullUser() throws MslEncodingException, MslEntityAuthException, MslUserAuthException, MslMessageException, MslKeyExchangeException, MslMasterTokenException, MslException, IOException, MslEncoderException {
final InputStream is = generateInputStream(MESSAGE_HEADER, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
assertNull(mis.getUser());
mis.close();
}
@Test
public void userIdTokenUser() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException, MslUserAuthException, MslKeyExchangeException, MslException, IOException, MslEncoderException {
final MasterToken masterToken = MslTestUtils.getMasterToken(trustedNetCtx, 1, 1);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(trustedNetCtx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, null, null, userIdToken, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, null, masterToken, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
assertEquals(userIdToken.getUser(), mis.getUser());
mis.close();
}
@Test
public void revokedUserIdToken() throws IOException, MslUserAuthException, MslKeyExchangeException, MslUserIdTokenException, MslException, MslEncoderException {
thrown.expect(MslUserIdTokenException.class);
thrown.expectMslError(MslError.USERIDTOKEN_REVOKED);
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
final MockTokenFactory factory = new MockTokenFactory();
ctx.setTokenFactory(factory);
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(ctx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, null, null, userIdToken, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(ctx, null, masterToken, headerData, peerData);
factory.setRevokedUserIdToken(userIdToken);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(ctx, is, KEY_REQUEST_DATA, cryptoContexts);
mis.close();
}
@Test
public void untrustedUserIdToken() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException, MslUserAuthException, MslKeyExchangeException, MslUserIdTokenException, MslEncoderException, MslException, IOException {
thrown.expect(MslUserIdTokenException.class);
thrown.expectMessageId(MSG_ID);
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
final MockTokenFactory factory = new MockTokenFactory();
ctx.setTokenFactory(factory);
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final UserIdToken userIdToken = MslTestUtils.getUntrustedUserIdToken(ctx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, null, null, userIdToken, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(ctx, null, masterToken, headerData, peerData);
factory.setRevokedUserIdToken(userIdToken);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(ctx, is, KEY_REQUEST_DATA, cryptoContexts);
mis.close();
}
// FIXME This can be removed once the old handshake logic is removed.
@Test
public void explicitHandshake() throws IOException, MslUserAuthException, MslKeyExchangeException, MslUserIdTokenException, MslException, MslEncoderException {
final HeaderData headerData = new HeaderData(MSG_ID, null, true, true, null, KEY_REQUEST_DATA, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
assertTrue(mis.isHandshake());
mis.close();
}
// FIXME This can be removed once the old handshake logic is removed.
@Test
public void inferredHandshake() throws MslException, IOException, MslEncoderException {
final HeaderData headerData = new HeaderData(MSG_ID, null, true, false, null, KEY_REQUEST_DATA, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
payloads.add(new PayloadChunk(trustedNetCtx, SEQ_NO, MSG_ID, END_OF_MSG, null, new byte[0], messageHeader.getCryptoContext()));
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
assertTrue(mis.isHandshake());
mis.close();
}
// FIXME This can be removed once the old handshake logic is removed.
@Test
public void notHandshake() throws IOException, MslException, MslEncoderException {
final HeaderData headerData = new HeaderData(MSG_ID, null, true, false, null, KEY_REQUEST_DATA, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
payloads.add(new PayloadChunk(trustedNetCtx, SEQ_NO, MSG_ID, END_OF_MSG, null, DATA, messageHeader.getCryptoContext()));
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
assertFalse(mis.isHandshake());
mis.close();
}
@Test
public void keyExchange() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException, MslUserAuthException, MslKeyExchangeException, MslException, IOException, MslEncoderException {
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, KEY_RESPONSE_DATA, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
// Encrypt the payload with the key exchange crypto context.
payloads.add(new PayloadChunk(trustedNetCtx, SEQ_NO, MSG_ID, END_OF_MSG, null, DATA, KEYX_CRYPTO_CONTEXT));
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
assertEquals(DATA.length, mis.read(buffer));
assertArrayEquals(DATA, Arrays.copyOf(buffer, DATA.length));
assertEquals(mis.getPayloadCryptoContext(), mis.getKeyExchangeCryptoContext());
mis.close();
}
@Test
public void peerKeyExchange() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException, MslUserAuthException, MslKeyExchangeException, MslException, IOException, MslEncoderException {
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, KEY_RESPONSE_DATA, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = p2pCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, entityAuthData, null, headerData, peerData);
// Encrypt the payload with the key exchange crypto context.
final ICryptoContext cryptoContext = messageHeader.getCryptoContext();
payloads.add(new PayloadChunk(p2pCtx, SEQ_NO, MSG_ID, END_OF_MSG, null, DATA, cryptoContext));
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(p2pCtx, is, KEY_REQUEST_DATA, cryptoContexts);
assertEquals(DATA.length, mis.read(buffer));
assertArrayEquals(DATA, Arrays.copyOf(buffer, DATA.length));
assertTrue(mis.getPayloadCryptoContext() != mis.getKeyExchangeCryptoContext());
mis.close();
}
@Test
public void unsupportedKeyExchangeScheme() throws IOException, MslUserAuthException, MslException, MslEncoderException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.KEYX_FACTORY_NOT_FOUND);
thrown.expectMessageId(MSG_ID);
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
ctx.removeKeyExchangeFactories(KeyExchangeScheme.SYMMETRIC_WRAPPED);
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, KEY_RESPONSE_DATA, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = ctx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(ctx, entityAuthData, null, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(ctx, is, KEY_REQUEST_DATA, cryptoContexts);
mis.close();
}
@Test
public void missingKeyRequestData() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException, MslUserAuthException, MslKeyExchangeException, IOException, MslException, MslEncoderException {
// We need to replace the MSL crypto context before parsing the message
// so create a local MSL context.
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, true);
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.KEYX_RESPONSE_REQUEST_MISMATCH);
thrown.expectMessageId(MSG_ID);
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, KEY_RESPONSE_DATA, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = ctx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(ctx, entityAuthData, null, headerData, peerData);
ctx.setMslCryptoContext(new RejectingCryptoContext());
final InputStream is = generateInputStream(messageHeader, payloads);
final Set<KeyRequestData> keyRequestData = Collections.emptySet();
final MessageInputStream mis = new MessageInputStream(ctx, is, keyRequestData, cryptoContexts);
mis.close();
}
@Test
public void incompatibleKeyRequestData() throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslEntityAuthException, MslMasterTokenException, MslMessageException, MslUserAuthException, IOException, MslException, MslEncoderException {
// We need to replace the MSL crypto context before parsing the message
// so create a local MSL context.
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, true);
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.KEYX_RESPONSE_REQUEST_MISMATCH);
thrown.expectMessageId(MSG_ID);
final Set<KeyRequestData> keyRequestData = new HashSet<KeyRequestData>();
keyRequestData.add(new SymmetricWrappedExchange.RequestData(KeyId.SESSION));
final KeyRequestData keyRequest = new SymmetricWrappedExchange.RequestData(KeyId.PSK);
final KeyExchangeFactory factory = ctx.getKeyExchangeFactory(keyRequest.getKeyExchangeScheme());
final EntityAuthenticationData entityAuthData = ctx.getEntityAuthenticationData(null);
final KeyExchangeData keyExchangeData = factory.generateResponse(ctx, ENCODER_FORMAT, keyRequest, entityAuthData);
final KeyResponseData keyResponseData = keyExchangeData.keyResponseData;
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, keyResponseData, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(ctx, entityAuthData, null, headerData, peerData);
ctx.setMslCryptoContext(new RejectingCryptoContext());
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(ctx, is, keyRequestData, cryptoContexts);
mis.close();
}
@Test
public void oneCompatibleKeyRequestData() throws IOException, MslUserAuthException, MslException, MslEncoderException {
// Populate the key request data such that the compatible data requires
// iterating through one of the incompatible ones.
final Set<KeyRequestData> keyRequestData = new HashSet<KeyRequestData>();
final KeyRequestData keyRequest = new SymmetricWrappedExchange.RequestData(KeyId.PSK);
keyRequestData.add(new SymmetricWrappedExchange.RequestData(KeyId.SESSION));
keyRequestData.add(keyRequest);
keyRequestData.add(new SymmetricWrappedExchange.RequestData(KeyId.SESSION));
final KeyExchangeFactory factory = trustedNetCtx.getKeyExchangeFactory(keyRequest.getKeyExchangeScheme());
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final KeyExchangeData keyExchangeData = factory.generateResponse(trustedNetCtx, ENCODER_FORMAT, keyRequest, entityAuthData);
final KeyResponseData keyResponseData = keyExchangeData.keyResponseData;
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, keyResponseData, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, keyRequestData, cryptoContexts);
mis.close();
}
@Test
public void expiredRenewableClientMessage() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException, MslUserAuthException, MslKeyExchangeException, IOException, MslException, MslEncoderException {
final Date renewalWindow = new Date(System.currentTimeMillis() - 20000);
final Date expiration = new Date(System.currentTimeMillis() - 10000);
final MasterToken masterToken = new MasterToken(trustedNetCtx, renewalWindow, expiration, 1L, 1L, null, MockPresharedAuthenticationFactory.PSK_ESN, MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH);
final HeaderData headerData = new HeaderData(MSG_ID, null, true, false, null, KEY_REQUEST_DATA, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, null, masterToken, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
mis.close();
}
@Test
public void expiredRenewablePeerMessage() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException, MslUserAuthException, MslKeyExchangeException, IOException, MslException, MslEncoderException {
final Date renewalWindow = new Date(System.currentTimeMillis() - 20000);
final Date expiration = new Date(System.currentTimeMillis() - 10000);
final MasterToken masterToken = new MasterToken(p2pCtx, renewalWindow, expiration, 1L, 1L, null, MockPresharedAuthenticationFactory.PSK_ESN, MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH);
final HeaderData headerData = new HeaderData(MSG_ID, null, true, false, null, KEY_REQUEST_DATA, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, masterToken, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(p2pCtx, is, KEY_REQUEST_DATA, cryptoContexts);
mis.close();
}
@Test
public void expiredNotRenewableClientMessage() throws IOException, MslUserAuthException, MslException, MslEncoderException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.MESSAGE_EXPIRED_NOT_RENEWABLE);
thrown.expectMessageId(MSG_ID);
// Expired messages received by a trusted network server should be
// rejected.
final Date renewalWindow = new Date(System.currentTimeMillis() - 20000);
final Date expiration = new Date(System.currentTimeMillis() - 10000);
final MasterToken masterToken = new MasterToken(trustedNetCtx, renewalWindow, expiration, 1L, 1L, null, MockPresharedAuthenticationFactory.PSK_ESN, MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH);
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, null, masterToken, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
mis.close();
}
@Test
public void expiredNoKeyRequestDataClientMessage() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException, MslUserAuthException, MslKeyExchangeException, IOException, MslException, MslEncoderException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.MESSAGE_EXPIRED_NO_KEYREQUEST_DATA);
thrown.expectMessageId(MSG_ID);
// Expired renewable messages received by a trusted network server
// with no key request data should be rejected.
final Date renewalWindow = new Date(System.currentTimeMillis() - 20000);
final Date expiration = new Date(System.currentTimeMillis() - 10000);
final MasterToken masterToken = new MasterToken(trustedNetCtx, renewalWindow, expiration, 1L, 1L, null, MockPresharedAuthenticationFactory.PSK_ESN, MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH);
final HeaderData headerData = new HeaderData(MSG_ID, null, true, false, null, null, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, null, masterToken, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
mis.close();
}
@Test
public void expiredNotRenewableServerMessage() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException, MslUserAuthException, MslKeyExchangeException, MslEncoderException, MslException, IOException {
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
// Expired messages received by a trusted network client should not be
// rejected.
final Date renewalWindow = new Date(System.currentTimeMillis() - 20000);
final Date expiration = new Date(System.currentTimeMillis() - 10000);
final MasterToken masterToken = new MasterToken(ctx, renewalWindow, expiration, 1L, 1L, null, MockPresharedAuthenticationFactory.PSK_ESN, MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH);
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(ctx, null, masterToken, headerData, peerData);
// The master token's crypto context must be cached, as if the client
// constructed it after a previous message exchange.
final ICryptoContext cryptoContext = new SessionCryptoContext(ctx, masterToken);
ctx.getMslStore().setCryptoContext(masterToken, cryptoContext);
// Generate the input stream. This will encode the message.
final InputStream is = generateInputStream(messageHeader, payloads);
// Change the MSL crypto context so the master token can no longer be
// verified or decrypted.
ctx.setMslCryptoContext(ALT_MSL_CRYPTO_CONTEXT);
// Now "receive" the message with a master token that we cannot verify
// or decrypt, but for which a cached crypto context exists.
final MessageInputStream mis = new MessageInputStream(ctx, is, KEY_REQUEST_DATA, cryptoContexts);
mis.close();
}
@Test
public void expiredNoKeyRequestDataPeerMessage() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException, MslUserAuthException, MslKeyExchangeException, IOException, MslException, MslEncoderException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.MESSAGE_EXPIRED_NO_KEYREQUEST_DATA);
thrown.expectMessageId(MSG_ID);
final Date renewalWindow = new Date(System.currentTimeMillis() - 20000);
final Date expiration = new Date(System.currentTimeMillis() - 10000);
final MasterToken masterToken = new MasterToken(p2pCtx, renewalWindow, expiration, 1L, 1L, null, MockPresharedAuthenticationFactory.PSK_ESN, MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH);
final HeaderData headerData = new HeaderData(MSG_ID, null, true, false, null, null, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, masterToken, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(p2pCtx, is, KEY_REQUEST_DATA, cryptoContexts);
mis.close();
}
@Test
public void expiredNotRenewablePeerMessage() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException, MslUserAuthException, MslKeyExchangeException, IOException, MslException, MslEncoderException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.MESSAGE_EXPIRED_NOT_RENEWABLE);
thrown.expectMessageId(MSG_ID);
final Date renewalWindow = new Date(System.currentTimeMillis() - 20000);
final Date expiration = new Date(System.currentTimeMillis() - 10000);
final MasterToken masterToken = new MasterToken(p2pCtx, renewalWindow, expiration, 1L, 1L, null, MockPresharedAuthenticationFactory.PSK_ESN, MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH);
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, masterToken, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(p2pCtx, is, KEY_REQUEST_DATA, cryptoContexts);
mis.close();
}
@Test
public void handshakeNotRenewable() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException, MslUserAuthException, MslKeyExchangeException, MslUserIdTokenException, IOException, MslException, MslEncoderException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.HANDSHAKE_DATA_MISSING);
thrown.expectMessageId(MSG_ID);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final HeaderData headerData = new HeaderData(MSG_ID, 1L, false, true, null, KEY_REQUEST_DATA, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
mis.close();
}
@Test
public void handshakeMissingKeyRequestData() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException, MslUserAuthException, MslKeyExchangeException, MslUserIdTokenException, IOException, MslException, MslEncoderException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.HANDSHAKE_DATA_MISSING);
thrown.expectMessageId(MSG_ID);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final HeaderData headerData = new HeaderData(MSG_ID, 1L, true, true, null, null, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
mis.close();
}
@Test
public void nonReplayableNoMasterTokenClientMessage() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException, MslUserAuthException, MslKeyExchangeException, IOException, MslException, MslEncoderException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.INCOMPLETE_NONREPLAYABLE_MESSAGE);
thrown.expectMessageId(MSG_ID);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final HeaderData headerData = new HeaderData(MSG_ID, 1L, true, false, null, KEY_REQUEST_DATA, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
mis.close();
}
@Test
public void nonReplayableNoMasterTokenPeerMessage() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException, MslUserAuthException, MslKeyExchangeException, IOException, MslException, MslEncoderException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.INCOMPLETE_NONREPLAYABLE_MESSAGE);
thrown.expectMessageId(MSG_ID);
final EntityAuthenticationData entityAuthData = p2pCtx.getEntityAuthenticationData(null);
final HeaderData headerData = new HeaderData(MSG_ID, 1L, true, false, null, KEY_REQUEST_DATA, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, entityAuthData, null, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(p2pCtx, is, KEY_REQUEST_DATA, cryptoContexts);
mis.close();
}
@Test
public void nonReplayableIdEqual() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException, MslUserAuthException, MslKeyExchangeException, IOException, MslException, MslEncoderException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.MESSAGE_REPLAYED);
thrown.expectMessageId(MSG_ID);
final long nonReplayableId = 1L;
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1L, 1L);
final MockTokenFactory factory = new MockTokenFactory();
factory.setLargestNonReplayableId(nonReplayableId);
ctx.setTokenFactory(factory);
final HeaderData headerData = new HeaderData(MSG_ID, nonReplayableId, true, false, null, KEY_REQUEST_DATA, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(ctx, null, masterToken, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(ctx, is, KEY_REQUEST_DATA, cryptoContexts);
mis.close();
}
@Test
public void nonReplayableIdSmaller() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException, MslUserAuthException, MslKeyExchangeException, IOException, MslException, MslEncoderException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.MESSAGE_REPLAYED);
thrown.expectMessageId(MSG_ID);
final long nonReplayableId = 2L;
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1L, 1L);
final MockTokenFactory factory = new MockTokenFactory();
factory.setLargestNonReplayableId(nonReplayableId);
ctx.setTokenFactory(factory);
final HeaderData headerData = new HeaderData(MSG_ID, nonReplayableId - 1, true, false, null, KEY_REQUEST_DATA, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(ctx, null, masterToken, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(ctx, is, KEY_REQUEST_DATA, cryptoContexts);
mis.close();
}
@Test
public void nonReplayableIdOutsideWindow() throws IOException, MslUserAuthException, MslKeyExchangeException, MslException, MslEncoderException {
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1L, 1L);
final MockTokenFactory factory = new MockTokenFactory();
ctx.setTokenFactory(factory);
long largestNonReplayableId = MslConstants.MAX_LONG_VALUE - NON_REPLAYABLE_ID_WINDOW - 1;
long nonReplayableId = MslConstants.MAX_LONG_VALUE;
for (int i = 0; i < 2; ++i) {
MessageInputStream mis = null;
try {
factory.setLargestNonReplayableId(largestNonReplayableId);
final HeaderData headerData = new HeaderData(MSG_ID, nonReplayableId, true, false, null, KEY_REQUEST_DATA, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(ctx, null, masterToken, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
mis = new MessageInputStream(ctx, is, KEY_REQUEST_DATA, cryptoContexts);
fail(i + ": Non-replayable ID " + nonReplayableId + " accepted with largest non-replayable ID " + largestNonReplayableId);
} catch (final MslMessageException e) {
assertEquals(MslError.MESSAGE_REPLAYED_UNRECOVERABLE, e.getError());
assertEquals((Long)MSG_ID, e.getMessageId());
} finally {
if (mis != null) mis.close();
}
largestNonReplayableId = incrementNonReplayableId(largestNonReplayableId);
nonReplayableId = incrementNonReplayableId(nonReplayableId);
}
}
@Test
public void nonReplayableIdInsideWindow() throws MslUserAuthException, MslKeyExchangeException, MslException, IOException, MslEncoderException {
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1L, 1L);
final MockTokenFactory factory = new MockTokenFactory();
ctx.setTokenFactory(factory);
long largestNonReplayableId = MslConstants.MAX_LONG_VALUE - NON_REPLAYABLE_ID_WINDOW;
long nonReplayableId = MslConstants.MAX_LONG_VALUE;
for (int i = 0; i < NON_REPLAYABLE_ID_WINDOW + 1; ++i) {
MessageInputStream mis = null;
try {
factory.setLargestNonReplayableId(largestNonReplayableId);
final HeaderData headerData = new HeaderData(MSG_ID, nonReplayableId, true, false, null, KEY_REQUEST_DATA, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(ctx, null, masterToken, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
mis = new MessageInputStream(ctx, is, KEY_REQUEST_DATA, cryptoContexts);
} catch (final MslMessageException e) {
fail(i + ": Non-replayable ID " + nonReplayableId + " rejected with largest non-replayable ID " + largestNonReplayableId);
} finally {
if (mis != null) mis.close();
}
largestNonReplayableId = incrementNonReplayableId(largestNonReplayableId);
nonReplayableId = incrementNonReplayableId(nonReplayableId);
}
}
@Test
public void replayedClientMessage() throws MslMasterTokenException, MslEntityAuthException, MslMessageException, MslUserAuthException, MslKeyExchangeException, IOException, MslException, MslEncoderException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.MESSAGE_REPLAYED);
thrown.expectMessageId(MSG_ID);
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1L, 1L);
final MockTokenFactory factory = new MockTokenFactory();
factory.setLargestNonReplayableId(1L);
ctx.setTokenFactory(factory);
final HeaderData headerData = new HeaderData(MSG_ID, 1L, true, false, null, KEY_REQUEST_DATA, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(ctx, null, masterToken, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(ctx, is, KEY_REQUEST_DATA, cryptoContexts);
mis.close();
}
@Test
public void replayedPeerMessage() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException, MslUserAuthException, MslKeyExchangeException, IOException, MslException, MslEncoderException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.MESSAGE_REPLAYED);
thrown.expectMessageId(MSG_ID);
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, true);
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1L, 1L);
final MockTokenFactory factory = new MockTokenFactory();
factory.setLargestNonReplayableId(1L);
ctx.setTokenFactory(factory);
final HeaderData headerData = new HeaderData(MSG_ID, 1L, true, false, null, KEY_REQUEST_DATA, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(ctx, null, masterToken, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(ctx, is, KEY_REQUEST_DATA, cryptoContexts);
mis.close();
}
@Test
public void errorHeader() throws MslEncodingException, MslEntityAuthException, MslCryptoException, MslUserAuthException, MslException, IOException, MslEncoderException {
final InputStream is = generateInputStream(ERROR_HEADER, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
assertEquals(0, mis.available());
assertEquals(ERROR_HEADER, mis.getErrorHeader());
assertNull(mis.getMessageHeader());
assertTrue(mis.markSupported());
mis.mark(0);
mis.reset();
mis.close();
}
@Test(expected = MslInternalException.class)
public void readFromError() throws MslEncodingException, MslEntityAuthException, MslCryptoException, MslUserAuthException, MslException, IOException, MslEncoderException {
final InputStream is = generateInputStream(ERROR_HEADER, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
try {
mis.read(buffer);
} finally {
mis.close();
}
}
@Test
public void readFromHandshakeMessage() throws IOException, MslUserAuthException, MslKeyExchangeException, MslUserIdTokenException, MslException, MslEncoderException {
final HeaderData headerData = new HeaderData(MSG_ID, null, true, true, null, KEY_REQUEST_DATA, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
final int read = mis.read();
assertEquals(-1, read);
mis.close();
}
@Test
public void missingEndOfMessage() throws MslEncodingException, MslEntityAuthException, MslCryptoException, MslUserAuthException, MslException, IOException, MslEncoderException {
final InputStream is = generateInputStream(MESSAGE_HEADER, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
// If there's nothing left we'll receive end of message anyway.
assertEquals(-1, mis.read(buffer));
mis.close();
}
@Test
public void entityAuthSchemeEncrypts() throws IOException, MslEncoderException, MslUserAuthException, MslMessageException, MslKeyExchangeException, MslUserIdTokenException, MslException {
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = new PresharedAuthenticationData(MockPresharedAuthenticationFactory.PSK_ESN);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
assertTrue(mis.encryptsPayloads());
mis.close();
}
@Test
public void entityAuthSchemeDoesNotEncrypt() throws IOException, MslEncoderException, MslUserAuthException, MslMessageException, MslKeyExchangeException, MslUserIdTokenException, MslException {
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = new RsaAuthenticationData(MockRsaAuthenticationFactory.RSA_ESN, MockRsaAuthenticationFactory.RSA_PUBKEY_ID);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
assertFalse(mis.encryptsPayloads());
mis.close();
}
@Test
public void entityAuthSchemeIntegrityProtects() throws IOException, MslEncoderException, MslUserAuthException, MslMessageException, MslKeyExchangeException, MslUserIdTokenException, MslException {
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = new RsaAuthenticationData(MockRsaAuthenticationFactory.RSA_ESN, MockRsaAuthenticationFactory.RSA_PUBKEY_ID);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
assertTrue(mis.protectsPayloadIntegrity());
mis.close();
}
@Test
public void entityAuthSchemeDoesNotIntegrityProtect() throws IOException, MslEncoderException, MslUserAuthException, MslMessageException, MslKeyExchangeException, MslUserIdTokenException, MslException {
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = new UnauthenticatedAuthenticationData(UNAUTHENTICATED_ESN);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
assertFalse(mis.protectsPayloadIntegrity());
mis.close();
}
@Test
public void entityAuthSchemeKeyxEncrypts() throws IOException, MslEncoderException, MslUserAuthException, MslMessageException, MslKeyExchangeException, MslUserIdTokenException, MslException {
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, KEY_RESPONSE_DATA, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = new PresharedAuthenticationData(MockPresharedAuthenticationFactory.PSK_ESN);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
assertTrue(mis.encryptsPayloads());
mis.close();
}
@Test
public void entityAuthSchemeKeyxIntegrityProtects() throws IOException, MslEncoderException, MslUserAuthException, MslMessageException, MslKeyExchangeException, MslUserIdTokenException, MslException {
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, KEY_RESPONSE_DATA, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = new RsaAuthenticationData(MockRsaAuthenticationFactory.RSA_ESN, MockRsaAuthenticationFactory.RSA_PUBKEY_ID);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
assertTrue(mis.protectsPayloadIntegrity());
mis.close();
}
@Test
public void entitAuthSchemeDoesNotKeyxEncrypts() throws IOException, MslEncoderException, MslUserAuthException, MslMessageException, MslKeyExchangeException, MslUserIdTokenException, MslException {
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, KEY_RESPONSE_DATA, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = new RsaAuthenticationData(MockRsaAuthenticationFactory.RSA_ESN, MockRsaAuthenticationFactory.RSA_PUBKEY_ID);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
assertTrue(mis.encryptsPayloads());
mis.close();
}
@Test
public void entityAuthSchemeDoesNotKeyxIntegrityProtects() throws IOException, MslEncoderException, MslUserAuthException, MslMessageException, MslKeyExchangeException, MslUserIdTokenException, MslException {
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, KEY_RESPONSE_DATA, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = new UnauthenticatedAuthenticationData(UNAUTHENTICATED_ESN);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
assertTrue(mis.protectsPayloadIntegrity());
mis.close();
}
@Test
public void masterTokenEncrypts() throws IOException, MslEncoderException, MslUserAuthException, MslMessageException, MslKeyExchangeException, MslUserIdTokenException, MslException {
final MasterToken masterToken = MslTestUtils.getMasterToken(trustedNetCtx, 1, 1);
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, null, masterToken, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
assertTrue(mis.encryptsPayloads());
mis.close();
}
@Test
public void masterTokenIntegrityProtects() throws IOException, MslEncoderException, MslUserAuthException, MslMessageException, MslKeyExchangeException, MslUserIdTokenException, MslException {
final MasterToken masterToken = MslTestUtils.getMasterToken(trustedNetCtx, 1, 1);
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, null, masterToken, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
assertTrue(mis.protectsPayloadIntegrity());
mis.close();
}
@Test
public void masterTokenKeyxEncrypts() throws IOException, MslEncoderException, MslUserAuthException, MslMessageException, MslKeyExchangeException, MslUserIdTokenException, MslException {
final MasterToken masterToken = MslTestUtils.getMasterToken(trustedNetCtx, 1, 1);
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, KEY_RESPONSE_DATA, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, null, masterToken, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
assertTrue(mis.encryptsPayloads());
mis.close();
}
@Test
public void masterTokenKeyxIntegrityProtects() throws IOException, MslEncoderException, MslUserAuthException, MslMessageException, MslKeyExchangeException, MslUserIdTokenException, MslException {
final MasterToken masterToken = MslTestUtils.getMasterToken(trustedNetCtx, 1, 1);
final HeaderData headerData = new HeaderData(MSG_ID, null, false, false, null, null, KEY_RESPONSE_DATA, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, null, masterToken, headerData, peerData);
final InputStream is = generateInputStream(messageHeader, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
assertTrue(mis.protectsPayloadIntegrity());
mis.close();
}
@Test
public void prematureEndOfMessage() throws MslCryptoException, MslEncodingException, MslException, IOException, MslEncoderException {
// Payloads after an end of message are ignored.
final int extraPayloads = MAX_PAYLOAD_CHUNKS / 2;
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
final ICryptoContext cryptoContext = MESSAGE_HEADER.getCryptoContext();
for (int i = 0; i < MAX_PAYLOAD_CHUNKS; ++i) {
final byte[] data = new byte[random.nextInt(MAX_DATA_SIZE) + 1];
random.nextBytes(data);
if (i < extraPayloads) {
payloads.add(new PayloadChunk(trustedNetCtx, SEQ_NO + i, MSG_ID, (i == extraPayloads - 1), null, data, cryptoContext));
baos.write(data);
} else {
payloads.add(new PayloadChunk(trustedNetCtx, SEQ_NO + i, MSG_ID, false, null, data, cryptoContext));
}
}
final byte[] appdata = baos.toByteArray();
final InputStream is = generateInputStream(MESSAGE_HEADER, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
// Read everything. We shouldn't get any of the extra payloads.
assertEquals(appdata.length, mis.read(buffer));
assertArrayEquals(appdata, Arrays.copyOfRange(buffer, 0, appdata.length));
mis.close();
}
@Test
public void mismatchedMessageId() throws MslCryptoException, MslEncodingException, MslException, IOException, MslEncoderException {
// Payloads with an incorrect message ID should be skipped.
int badPayloads = 0;
long sequenceNumber = SEQ_NO;
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
final ICryptoContext cryptoContext = MESSAGE_HEADER.getCryptoContext();
for (int i = 0; i < MAX_PAYLOAD_CHUNKS; ++i) {
final byte[] data = new byte[random.nextInt(MAX_DATA_SIZE) + 1];
random.nextBytes(data);
if (random.nextBoolean()) {
payloads.add(new PayloadChunk(trustedNetCtx, sequenceNumber++, MSG_ID, (i == MAX_PAYLOAD_CHUNKS - 1), null, data, cryptoContext));
baos.write(data);
} else {
payloads.add(new PayloadChunk(trustedNetCtx, sequenceNumber, 2 * MSG_ID, (i == MAX_PAYLOAD_CHUNKS - 1), null, data, cryptoContext));
++badPayloads;
}
}
final byte[] appdata = baos.toByteArray();
final InputStream is = generateInputStream(MESSAGE_HEADER, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
// Read everything. Each bad payload should throw an exception.
int offset = 0;
int caughtExceptions = 0;
while (true) {
try {
final int bytesRead = mis.read(buffer, offset, buffer.length - offset);
if (bytesRead == -1) break;
offset += bytesRead;
} catch (final IOException e) {
++caughtExceptions;
}
}
assertEquals(badPayloads, caughtExceptions);
assertArrayEquals(appdata, Arrays.copyOfRange(buffer, 0, appdata.length));
mis.close();
}
@Test
public void incorrectSequenceNumber() throws MslCryptoException, MslEncodingException, MslException, IOException, MslEncoderException {
// Payloads with an incorrect sequence number should be skipped.
int badPayloads = 0;
long sequenceNumber = SEQ_NO;
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
final ICryptoContext cryptoContext = MESSAGE_HEADER.getCryptoContext();
for (int i = 0; i < MAX_PAYLOAD_CHUNKS; ++i) {
final byte[] data = new byte[random.nextInt(MAX_DATA_SIZE) + 1];
random.nextBytes(data);
if (random.nextBoolean()) {
payloads.add(new PayloadChunk(trustedNetCtx, sequenceNumber++, MSG_ID, (i == MAX_PAYLOAD_CHUNKS - 1), null, data, cryptoContext));
baos.write(data);
} else {
payloads.add(new PayloadChunk(trustedNetCtx, 2 * sequenceNumber + i, MSG_ID, (i == MAX_PAYLOAD_CHUNKS - 1), null, data, cryptoContext));
++badPayloads;
}
}
final byte[] appdata = baos.toByteArray();
final InputStream is = generateInputStream(MESSAGE_HEADER, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
// Read everything. Each bad payload should throw an exception.
int offset = 0;
int caughtExceptions = 0;
while (true) {
try {
final int bytesRead = mis.read(buffer, offset, buffer.length - offset);
if (bytesRead == -1) break;
offset += bytesRead;
} catch (final IOException e) {
++caughtExceptions;
}
}
assertEquals(badPayloads, caughtExceptions);
assertArrayEquals(appdata, Arrays.copyOfRange(buffer, 0, appdata.length));
mis.close();
}
@Test
public void markReset() throws MslEncodingException, MslCryptoException, MslException, IOException, MslEncoderException {
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
final ICryptoContext cryptoContext = MESSAGE_HEADER.getCryptoContext();
for (int i = 0; i < MAX_PAYLOAD_CHUNKS; ++i) {
final byte[] data = new byte[random.nextInt(MAX_DATA_SIZE) + 1];
random.nextBytes(data);
payloads.add(new PayloadChunk(trustedNetCtx, SEQ_NO + i, MSG_ID, (i == MAX_PAYLOAD_CHUNKS - 1), null, data, cryptoContext));
baos.write(data);
}
final byte[] appdata = baos.toByteArray();
final InputStream is = generateInputStream(MESSAGE_HEADER, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
// Mark and reset to the beginning.
final int beginningOffset = 0;
final int beginningLength = appdata.length / 4;
final int beginningTo = beginningOffset + beginningLength;
final byte[] expectedBeginning = Arrays.copyOfRange(appdata, beginningOffset, beginningTo);
mis.mark(appdata.length);
assertEquals(expectedBeginning.length, mis.read(buffer, beginningOffset, beginningLength));
assertArrayEquals(expectedBeginning, Arrays.copyOfRange(buffer, beginningOffset, beginningTo));
mis.reset();
assertEquals(expectedBeginning.length, mis.read(buffer, beginningOffset, beginningLength));
assertArrayEquals(expectedBeginning, Arrays.copyOfRange(buffer, beginningOffset, beginningTo));
// Mark and reset from where we are.
final int middleOffset = beginningTo;
final int middleLength = appdata.length / 4;
final int middleTo = middleOffset + middleLength;
final byte[] expectedMiddle = Arrays.copyOfRange(appdata, middleOffset, middleTo);
mis.mark(appdata.length);
assertEquals(expectedMiddle.length, mis.read(buffer, middleOffset, middleLength));
assertArrayEquals(expectedMiddle, Arrays.copyOfRange(buffer, middleOffset, middleTo));
mis.reset();
assertEquals(expectedMiddle.length, mis.read(buffer, middleOffset, middleLength));
assertArrayEquals(expectedMiddle, Arrays.copyOfRange(buffer, middleOffset, middleTo));
// Mark and reset the remainder.
final int endingOffset = middleTo;
final int endingLength = appdata.length - middleLength - beginningLength;
final int endingTo = endingOffset + endingLength;
final byte[] expectedEnding = Arrays.copyOfRange(appdata, endingOffset, endingTo);
mis.mark(appdata.length);
assertEquals(expectedEnding.length, mis.read(buffer, endingOffset, endingLength));
assertArrayEquals(expectedEnding, Arrays.copyOfRange(buffer, endingOffset, endingTo));
mis.reset();
assertEquals(expectedEnding.length, mis.read(buffer, endingOffset, endingLength));
assertArrayEquals(expectedEnding, Arrays.copyOfRange(buffer, endingOffset, endingTo));
// Confirm equality.
assertArrayEquals(appdata, Arrays.copyOfRange(buffer, 0, appdata.length));
mis.close();
}
@Test
public void markResetShortMark() throws IOException, MslEncodingException, MslEntityAuthException, MslUserAuthException, MslException, MslEncoderException {
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
final ICryptoContext cryptoContext = MESSAGE_HEADER.getCryptoContext();
for (int i = 0; i < MAX_PAYLOAD_CHUNKS; ++i) {
final byte[] data = new byte[random.nextInt(MAX_DATA_SIZE) + 1];
random.nextBytes(data);
payloads.add(new PayloadChunk(trustedNetCtx, SEQ_NO + i, MSG_ID, (i == MAX_PAYLOAD_CHUNKS - 1), null, data, cryptoContext));
baos.write(data);
}
final byte[] appdata = baos.toByteArray();
final InputStream is = generateInputStream(MESSAGE_HEADER, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
// Mark and reset to the beginning.
final int beginningOffset = 0;
final int beginningLength = appdata.length / 2;
final int beginningTo = beginningOffset + beginningLength;
final byte[] expectedBeginning = Arrays.copyOfRange(appdata, beginningOffset, beginningTo);
mis.mark(appdata.length);
assertEquals(expectedBeginning.length, mis.read(buffer, beginningOffset, beginningLength));
assertArrayEquals(expectedBeginning, Arrays.copyOfRange(buffer, beginningOffset, beginningTo));
mis.reset();
// Read a little bit, and mark again so we drop one or more payloads
// but are likely to have more than one payload remaining.
final byte[] reread = new byte[appdata.length / 4];
assertEquals(reread.length, mis.read(reread));
mis.mark(appdata.length);
// Read the remainder, reset, and re-read to confirm.
final int endingOffset = reread.length;
final int endingLength = appdata.length - endingOffset;
final int endingTo = endingOffset + endingLength;
final byte[] expectedEnding = Arrays.copyOfRange(appdata, endingOffset, endingTo);
assertEquals(expectedEnding.length, mis.read(buffer, endingOffset, endingLength));
assertArrayEquals(expectedEnding, Arrays.copyOfRange(buffer, endingOffset, endingTo));
mis.reset();
assertEquals(expectedEnding.length, mis.read(buffer, endingOffset, endingLength));
assertArrayEquals(expectedEnding, Arrays.copyOfRange(buffer, endingOffset, endingTo));
// Confirm equality.
assertArrayEquals(appdata, Arrays.copyOfRange(buffer, 0, appdata.length));
mis.close();
}
@Test
public void markOneReadLimit() throws IOException, MslEncodingException, MslEntityAuthException, MslUserAuthException, MslException, MslEncoderException {
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
final ICryptoContext cryptoContext = MESSAGE_HEADER.getCryptoContext();
for (int i = 0; i < MAX_PAYLOAD_CHUNKS; ++i) {
final byte[] data = new byte[random.nextInt(MAX_DATA_SIZE) + 1];
random.nextBytes(data);
payloads.add(new PayloadChunk(trustedNetCtx, SEQ_NO + i, MSG_ID, (i == MAX_PAYLOAD_CHUNKS - 1), null, data, cryptoContext));
baos.write(data);
}
final byte[] appdata = baos.toByteArray();
final InputStream is = generateInputStream(MESSAGE_HEADER, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
// Mark one byte and reset to the beginning.
final byte expectedOne = appdata[0];
mis.mark(1);
assertEquals(expectedOne, mis.read());
mis.reset();
// Read a little bit and reset (which should not work).
final int beginningOffset = 0;
final int beginningLength = appdata.length / 2;
final int beginningTo = beginningOffset + beginningLength;
final byte[] expectedBeginning = Arrays.copyOfRange(appdata, beginningOffset, beginningTo);
assertEquals(expectedBeginning.length, mis.read(buffer, beginningOffset, beginningLength));
assertArrayEquals(expectedBeginning, Arrays.copyOfRange(buffer, beginningOffset, beginningTo));
mis.reset();
// Read the remainder.
final int endingOffset = beginningLength;
final int endingLength = appdata.length - endingOffset;
final int endingTo = endingOffset + endingLength;
final byte[] expectedEnding = Arrays.copyOfRange(appdata, endingOffset, endingTo);
assertEquals(expectedEnding.length, mis.read(buffer, endingOffset, endingLength));
assertArrayEquals(expectedEnding, Arrays.copyOfRange(buffer, endingOffset, endingTo));
// Confirm equality.
assertArrayEquals(appdata, Arrays.copyOfRange(buffer, 0, appdata.length));
// Confirm end-of-stream.
assertEquals(-1, mis.read());
mis.close();
}
@Test
public void markReadLimit() throws IOException, MslEncodingException, MslEntityAuthException, MslUserAuthException, MslException, MslEncoderException {
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
final ICryptoContext cryptoContext = MESSAGE_HEADER.getCryptoContext();
for (int i = 0; i < MAX_PAYLOAD_CHUNKS; ++i) {
final byte[] data = new byte[random.nextInt(MAX_DATA_SIZE) + 1];
random.nextBytes(data);
payloads.add(new PayloadChunk(trustedNetCtx, SEQ_NO + i, MSG_ID, (i == MAX_PAYLOAD_CHUNKS - 1), null, data, cryptoContext));
baos.write(data);
}
final byte[] appdata = baos.toByteArray();
final InputStream is = generateInputStream(MESSAGE_HEADER, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
// Read a little bit and mark with a short read limit.
final int beginningOffset = 0;
final int beginningLength = appdata.length / 4;
final int beginningTo = beginningOffset + beginningLength;
final byte[] expectedBeginning = Arrays.copyOfRange(appdata, beginningOffset, beginningTo);
assertEquals(expectedBeginning.length, mis.read(buffer, beginningOffset, beginningLength));
assertArrayEquals(expectedBeginning, Arrays.copyOfRange(buffer, beginningOffset, beginningTo));
final int readlimit = appdata.length / 8;
mis.mark(readlimit);
// Read up to the read limit.
final int readOffset = beginningLength;
final int readLength = readlimit;
final int readTo = readOffset + readLength;
final byte[] expectedRead = Arrays.copyOfRange(appdata, readOffset, readTo);
assertEquals(expectedRead.length, mis.read(buffer, readOffset, readLength));
assertArrayEquals(expectedRead, Arrays.copyOfRange(buffer, readOffset, readTo));
// Reset and re-read.
mis.reset();
assertEquals(expectedRead.length, mis.read(buffer, readOffset, readLength));
assertArrayEquals(expectedRead, Arrays.copyOfRange(buffer, readOffset, readTo));
// Reset and re-read.
mis.reset();
assertEquals(expectedRead.length, mis.read(buffer, readOffset, readLength));
assertArrayEquals(expectedRead, Arrays.copyOfRange(buffer, readOffset, readTo));
// Reset and read past the read limit.
mis.reset();
final int readPastOffset = beginningLength;
final int readPastLength = readlimit + 1;
final int readPastTo = readPastOffset + readPastLength;
final byte[] expectedReadPast = Arrays.copyOfRange(appdata, readPastOffset, readPastTo);
assertEquals(expectedReadPast.length, mis.read(buffer, readPastOffset, readPastLength));
assertArrayEquals(expectedReadPast, Arrays.copyOfRange(buffer, readPastOffset, readPastTo));
// Reset and confirm it did not work.
mis.reset();
final int endingOffset = readPastTo;
final int endingLength = appdata.length - endingOffset;
final int endingTo = appdata.length;
final byte[] expectedEnding = Arrays.copyOfRange(appdata, endingOffset, endingTo);
assertEquals(expectedEnding.length, mis.read(buffer, endingOffset, endingLength));
assertArrayEquals(expectedEnding, Arrays.copyOfRange(buffer, endingOffset, endingTo));
// Confirm equality.
assertArrayEquals(appdata, Arrays.copyOfRange(buffer, 0, appdata.length));
// Confirm end-of-stream.
assertEquals(-1, mis.read());
mis.close();
}
@Test
public void available() throws MslEncodingException, MslEntityAuthException, MslCryptoException, MslUserAuthException, MslException, IOException, MslEncoderException {
final ICryptoContext cryptoContext = MESSAGE_HEADER.getCryptoContext();
for (int i = 0; i < MAX_PAYLOAD_CHUNKS; ++i) {
final byte[] data = new byte[random.nextInt(MAX_DATA_SIZE) + 1];
random.nextBytes(data);
payloads.add(new PayloadChunk(trustedNetCtx, SEQ_NO + i, MSG_ID, (i == MAX_PAYLOAD_CHUNKS - 1), null, data, cryptoContext));
}
final InputStream is = generateInputStream(MESSAGE_HEADER, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
// The remainder of a payload should be available, once the payload is
// processed.
final int firstLength = payloads.get(0).getData().length;
mis.read();
assertEquals(firstLength - 1, mis.available());
// Mark and read the remainder. Nothing should be available.
mis.mark(buffer.length);
final int bytesRead = mis.read(buffer);
assertEquals(0, mis.available());
// Reset. Everything except for the original one byte should be
// available.
mis.reset();
assertEquals(bytesRead, mis.available());
// Read a little bit. Reset. Confirm the amount available.
final int shortRead = mis.read(buffer, 0, bytesRead / 10);
assertEquals(bytesRead - shortRead, mis.available());
mis.close();
}
@Test
public void skipAvailable() throws MslCryptoException, MslEncodingException, MslException, IOException, MslEncoderException {
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
final ICryptoContext cryptoContext = MESSAGE_HEADER.getCryptoContext();
for (int i = 0; i < MAX_PAYLOAD_CHUNKS; ++i) {
final byte[] data = new byte[random.nextInt(MAX_DATA_SIZE) + 1];
random.nextBytes(data);
payloads.add(new PayloadChunk(trustedNetCtx, SEQ_NO + i, MSG_ID, (i == MAX_PAYLOAD_CHUNKS - 1), null, data, cryptoContext));
baos.write(data);
}
final byte[] appdata = baos.toByteArray();
final InputStream is = generateInputStream(MESSAGE_HEADER, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
// Mark and then skip some data.
mis.mark(appdata.length);
final int skipLength = appdata.length / 6;
assertEquals(skipLength, mis.skip(skipLength));
// Confirm availability equal to the current payload's remaining data.
int consumedBytes = 0;
final ListIterator<PayloadChunk> chunks = payloads.listIterator();
while (consumedBytes < skipLength && chunks.hasNext()) {
final PayloadChunk payload = chunks.next();
consumedBytes += payload.getData().length;
}
assertEquals(consumedBytes - skipLength, mis.available());
// Read and skip for a while.
int skipped = skipLength;
while (skipped < appdata.length) {
final int readLength = Math.min(appdata.length / 6, appdata.length - skipped);
final int readTo = skipped + readLength;
final byte[] expected = Arrays.copyOfRange(appdata, skipped, readTo);
assertEquals(expected.length, mis.read(buffer, skipped, readLength));
assertArrayEquals(expected, Arrays.copyOfRange(buffer, skipped, readTo));
skipped += expected.length;
// Confirm availability equal to the current payload's remaining
// data.
while (consumedBytes < skipped && chunks.hasNext()) {
final PayloadChunk payload = chunks.next();
consumedBytes += payload.getData().length;
}
assertEquals(consumedBytes - skipped, mis.available());
}
// Reset and redo the read and skips now that the data is buffered.
mis.reset();
skipped = 0;
while (skipped < appdata.length) {
final int readLength = Math.min(appdata.length / 6, appdata.length - skipped);
final int readTo = skipped + readLength;
final byte[] expected = Arrays.copyOfRange(appdata, skipped, readTo);
assertEquals(expected.length, mis.read(buffer, skipped, readLength));
assertArrayEquals(expected, Arrays.copyOfRange(buffer, skipped, readTo));
skipped += expected.length;
// Confirm availability equal to the remaining data.
assertEquals(appdata.length - skipped, mis.available());
}
// Confirm equality.
assertArrayEquals(appdata, Arrays.copyOfRange(buffer, 0, appdata.length));
mis.close();
}
@Test
public void largePayload() throws MslEncodingException, MslException, IOException, MslEncoderException {
final ICryptoContext cryptoContext = MESSAGE_HEADER.getCryptoContext();
final byte[] data = new byte[10 * 1024 * 1024];
random.nextBytes(data);
payloads.add(new PayloadChunk(trustedNetCtx, SEQ_NO, MSG_ID, true, null, data, cryptoContext));
final InputStream is = generateInputStream(MESSAGE_HEADER, payloads);
final MessageInputStream mis = new MessageInputStream(trustedNetCtx, is, KEY_REQUEST_DATA, cryptoContexts);
final byte[] copy = new byte[data.length];
assertEquals(copy.length, mis.read(copy));
assertEquals(-1, mis.read());
assertArrayEquals(data, copy);
mis.close();
}
}
| 9,952 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/msg/ErrorHeaderTest.java | /**
* Copyright (c) 2012-2018 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.msg;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.io.UnsupportedEncodingException;
import java.util.Collections;
import java.util.Date;
import java.util.Map;
import org.bouncycastle.util.encoders.Base64;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslConstants;
import com.netflix.msl.MslConstants.ResponseCode;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.MslKeyExchangeException;
import com.netflix.msl.MslMessageException;
import com.netflix.msl.MslUserAuthException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.entityauth.EntityAuthenticationData;
import com.netflix.msl.entityauth.EntityAuthenticationFactory;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* Error header unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class ErrorHeaderTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Milliseconds per second. */
private static final long MILLISECONDS_PER_SECOND = 1000;
/** Key entity authentication data. */
private static final String KEY_ENTITY_AUTHENTICATION_DATA = "entityauthdata";
/** Key error data. */
private static final String KEY_ERRORDATA = "errordata";
/** Key error data signature. */
private static final String KEY_SIGNATURE = "signature";
// Message error data.
/** Key timestamp. */
private static final String KEY_TIMESTAMP = "timestamp";
/** Key message ID. */
private static final String KEY_MESSAGE_ID = "messageid";
/** Key error code. */
private static final String KEY_ERROR_CODE = "errorcode";
/** Key internal code. */
private static final String KEY_INTERNAL_CODE = "internalcode";
/** Key error message. */
private static final String KEY_ERROR_MESSAGE = "errormsg";
/** Key user message. */
private static final String KEY_USER_MESSAGE = "usermsg";
/**
* Checks if the given timestamp is close to "now".
*
* @param timestamp the timestamp to compare.
* @return true if the timestamp is about now.
*/
private static boolean isAboutNow(final Date timestamp) {
final long now = System.currentTimeMillis();
final long time = timestamp.getTime();
return (now - 1000 <= time && time <= now + 1000);
}
/**
* Checks if the given timestamp is close to "now".
*
* @param seconds the timestamp to compare in seconds since the epoch.
* @return true if the timestamp is about now.
*/
private static boolean isAboutNowSeconds(final long seconds) {
final long now = System.currentTimeMillis();
final long time = seconds * MILLISECONDS_PER_SECOND;
return (now - 1000 <= time && time <= now + 1000);
}
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
/** MSL context. */
private static MslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
/** Header crypto context. */
private static ICryptoContext cryptoContext;
private static EntityAuthenticationData ENTITY_AUTH_DATA;
private static final long MESSAGE_ID = 17;
private static final ResponseCode ERROR_CODE = ResponseCode.FAIL;
private static final int INTERNAL_CODE = 621;
private static final String ERROR_MSG = "Error message.";
private static final String USER_MSG = "User message.";
private static final Map<String,ICryptoContext> CRYPTO_CONTEXTS = Collections.emptyMap();
@BeforeClass
public static void setup() throws MslEntityAuthException, MslEncodingException, MslCryptoException {
ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = ctx.getMslEncoderFactory();
ENTITY_AUTH_DATA = ctx.getEntityAuthenticationData(null);
final EntityAuthenticationScheme scheme = ENTITY_AUTH_DATA.getScheme();
final EntityAuthenticationFactory factory = ctx.getEntityAuthenticationFactory(scheme);
cryptoContext = factory.getCryptoContext(ctx, ENTITY_AUTH_DATA);
}
@AfterClass
public static void teardown() {
ENTITY_AUTH_DATA = null;
encoder = null;
ctx = null;
}
@Test
public void ctors() throws MslEncodingException, MslEntityAuthException, MslMessageException, MslCryptoException {
final ErrorHeader errorHeader = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
assertEquals(ENTITY_AUTH_DATA, errorHeader.getEntityAuthenticationData());
assertEquals(ERROR_CODE, errorHeader.getErrorCode());
assertEquals(ERROR_MSG, errorHeader.getErrorMessage());
assertEquals(INTERNAL_CODE, errorHeader.getInternalCode());
assertEquals(MESSAGE_ID, errorHeader.getMessageId());
assertEquals(USER_MSG, errorHeader.getUserMessage());
assertTrue(isAboutNow(errorHeader.getTimestamp()));
}
@Test
public void mslObject() throws MslEncodingException, MslEntityAuthException, MslEncoderException, UnsupportedEncodingException, MslMessageException, MslCryptoException {
final ErrorHeader errorHeader = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
final MslObject mo = MslTestUtils.toMslObject(encoder, errorHeader);
final MslObject entityAuthDataMo = mo.getMslObject(KEY_ENTITY_AUTHENTICATION_DATA, encoder);
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, ENTITY_AUTH_DATA), entityAuthDataMo));
final byte[] ciphertext = mo.getBytes(KEY_ERRORDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject errordata = encoder.parseObject(plaintext);
final byte[] signature = mo.getBytes(KEY_SIGNATURE);
assertTrue(cryptoContext.verify(ciphertext, signature, encoder));
assertEquals(MESSAGE_ID, errordata.getLong(KEY_MESSAGE_ID));
assertEquals(ERROR_CODE.intValue(), errordata.getInt(KEY_ERROR_CODE));
assertEquals(INTERNAL_CODE, errordata.getInt(KEY_INTERNAL_CODE));
assertEquals(ERROR_MSG, errordata.getString(KEY_ERROR_MESSAGE));
assertEquals(USER_MSG, errordata.getString(KEY_USER_MESSAGE));
assertTrue(isAboutNowSeconds(errordata.getLong(KEY_TIMESTAMP)));
}
@Test
public void negativeInternalCodeMslObject() throws MslEncodingException, MslEntityAuthException, MslEncoderException, MslMessageException, MslCryptoException {
final ErrorHeader errorHeader = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, -17, ERROR_MSG, USER_MSG);
assertEquals(-1, errorHeader.getInternalCode());
final MslObject mo = MslTestUtils.toMslObject(encoder, errorHeader);
final MslObject entityAuthDataMo = mo.getMslObject(KEY_ENTITY_AUTHENTICATION_DATA, encoder);
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, ENTITY_AUTH_DATA), entityAuthDataMo));
final byte[] ciphertext = mo.getBytes(KEY_ERRORDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject errordata = encoder.parseObject(plaintext);
final byte[] signature = mo.getBytes(KEY_SIGNATURE);
assertTrue(cryptoContext.verify(ciphertext, signature, encoder));
assertTrue(isAboutNowSeconds(errordata.getLong(KEY_TIMESTAMP)));
assertEquals(MESSAGE_ID, errordata.getLong(KEY_MESSAGE_ID));
assertEquals(ERROR_CODE.intValue(), errordata.getInt(KEY_ERROR_CODE));
assertFalse(errordata.has(KEY_INTERNAL_CODE));
assertEquals(ERROR_MSG, errordata.getString(KEY_ERROR_MESSAGE));
assertEquals(USER_MSG, errordata.getString(KEY_USER_MESSAGE));
}
@Test
public void nullErrorMessageMslObject() throws MslEncodingException, MslEntityAuthException, MslEncoderException, MslMessageException, MslCryptoException {
final ErrorHeader errorHeader = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, null, USER_MSG);
assertNull(errorHeader.getErrorMessage());
final MslObject mo = MslTestUtils.toMslObject(encoder, errorHeader);
final MslObject entityAuthDataMo = mo.getMslObject(KEY_ENTITY_AUTHENTICATION_DATA, encoder);
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, ENTITY_AUTH_DATA), entityAuthDataMo));
final byte[] ciphertext = mo.getBytes(KEY_ERRORDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject errordata = encoder.parseObject(plaintext);
final byte[] signature = mo.getBytes(KEY_SIGNATURE);
assertTrue(cryptoContext.verify(ciphertext, signature, encoder));
assertTrue(isAboutNowSeconds(errordata.getLong(KEY_TIMESTAMP)));
assertEquals(MESSAGE_ID, errordata.getLong(KEY_MESSAGE_ID));
assertEquals(ERROR_CODE.intValue(), errordata.getInt(KEY_ERROR_CODE));
assertEquals(INTERNAL_CODE, errordata.getInt(KEY_INTERNAL_CODE));
assertFalse(errordata.has(KEY_ERROR_MESSAGE));
assertEquals(USER_MSG, errordata.getString(KEY_USER_MESSAGE));
}
@Test
public void nullUserMessageMslObject() throws MslEncodingException, MslEntityAuthException, MslEncoderException, MslMessageException, MslCryptoException {
final ErrorHeader errorHeader = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, null);
assertNull(errorHeader.getUserMessage());
final MslObject mo = MslTestUtils.toMslObject(encoder, errorHeader);
final MslObject entityAuthDataMo = mo.getMslObject(KEY_ENTITY_AUTHENTICATION_DATA, encoder);
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, ENTITY_AUTH_DATA), entityAuthDataMo));
final byte[] ciphertext = mo.getBytes(KEY_ERRORDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject errordata = encoder.parseObject(plaintext);
final byte[] signature = mo.getBytes(KEY_SIGNATURE);
assertTrue(cryptoContext.verify(ciphertext, signature, encoder));
assertTrue(isAboutNowSeconds(errordata.getLong(KEY_TIMESTAMP)));
assertEquals(MESSAGE_ID, errordata.getLong(KEY_MESSAGE_ID));
assertEquals(ERROR_CODE.intValue(), errordata.getInt(KEY_ERROR_CODE));
assertEquals(INTERNAL_CODE, errordata.getInt(KEY_INTERNAL_CODE));
assertEquals(ERROR_MSG, errordata.getString(KEY_ERROR_MESSAGE));
assertFalse(errordata.has(KEY_USER_MESSAGE));
}
@Test
public void parseHeader() throws MslEncoderException, MslKeyExchangeException, MslUserAuthException, MslException {
final ErrorHeader errorHeader = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
final MslObject errorHeaderMo = MslTestUtils.toMslObject(encoder, errorHeader);
final Header header = Header.parseHeader(ctx, errorHeaderMo, CRYPTO_CONTEXTS);
assertNotNull(header);
assertTrue(header instanceof ErrorHeader);
final ErrorHeader moErrorHeader = (ErrorHeader)header;
assertEquals(errorHeader.getEntityAuthenticationData(), moErrorHeader.getEntityAuthenticationData());
assertEquals(errorHeader.getTimestamp(), moErrorHeader.getTimestamp());
assertEquals(errorHeader.getErrorCode(), moErrorHeader.getErrorCode());
assertEquals(errorHeader.getErrorMessage(), moErrorHeader.getErrorMessage());
assertEquals(errorHeader.getInternalCode(), moErrorHeader.getInternalCode());
assertEquals(errorHeader.getMessageId(), moErrorHeader.getMessageId());
assertEquals(errorHeader.getUserMessage(), moErrorHeader.getUserMessage());
}
@Test
public void missingEntityAuthDataCtor() throws MslEncodingException, MslEntityAuthException, MslMessageException, MslCryptoException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.MESSAGE_ENTITY_NOT_FOUND);
new ErrorHeader(ctx, null, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
}
@Test
public void missingEntityAuthDataParseHeader() throws MslEncodingException, MslEntityAuthException, MslCryptoException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.MESSAGE_ENTITY_NOT_FOUND);
final ErrorHeader errorHeader = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
final MslObject errorHeaderMo = MslTestUtils.toMslObject(encoder, errorHeader);
assertNotNull(errorHeaderMo.remove(KEY_ENTITY_AUTHENTICATION_DATA));
Header.parseHeader(ctx, errorHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void invalidEntityAuthData() throws MslEncodingException, MslEntityAuthException, MslCryptoException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ErrorHeader errorHeader = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
final MslObject errorHeaderMo = MslTestUtils.toMslObject(encoder, errorHeader);
errorHeaderMo.put(KEY_ENTITY_AUTHENTICATION_DATA, "x");
Header.parseHeader(ctx, errorHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void missingSignature() throws MslEncoderException, MslEncodingException, MslEntityAuthException, MslCryptoException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ErrorHeader errorHeader = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
final MslObject errorHeaderMo = MslTestUtils.toMslObject(encoder, errorHeader);
assertNotNull(errorHeaderMo.remove(KEY_SIGNATURE));
Header.parseHeader(ctx, errorHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void invalidSignature() throws MslEncoderException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ErrorHeader errorHeader = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
final MslObject errorHeaderMo = MslTestUtils.toMslObject(encoder, errorHeader);
errorHeaderMo.put(KEY_SIGNATURE, false);
Header.parseHeader(ctx, errorHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void incorrectSignature() throws MslEncoderException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.MESSAGE_VERIFICATION_FAILED);
final ErrorHeader errorHeader = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
final MslObject errorHeaderMo = MslTestUtils.toMslObject(encoder, errorHeader);
errorHeaderMo.put(KEY_SIGNATURE, Base64.decode("AAA="));
Header.parseHeader(ctx, errorHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void missingErrordata() throws MslEncoderException, MslKeyExchangeException, MslUserAuthException, MslException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ErrorHeader errorHeader = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
final MslObject errorHeaderMo = MslTestUtils.toMslObject(encoder, errorHeader);
assertNotNull(errorHeaderMo.remove(KEY_ERRORDATA));
Header.parseHeader(ctx, errorHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void invalidErrordata() throws MslEncodingException, MslEntityAuthException, MslCryptoException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.CIPHERTEXT_ENVELOPE_PARSE_ERROR);
final ErrorHeader errorHeader = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
final MslObject errorHeaderMo = MslTestUtils.toMslObject(encoder, errorHeader);
// This tests invalid but trusted error data so we must sign it.
final byte[] errordata = new byte[1];
errordata[0] = 'x';
errorHeaderMo.put(KEY_ERRORDATA, errordata);
final byte[] signature = cryptoContext.sign(errordata, encoder, ENCODER_FORMAT);
errorHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(ctx, errorHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void emptyErrordata() throws MslEncoderException, MslKeyExchangeException, MslUserAuthException, MslException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.HEADER_DATA_MISSING);
final ErrorHeader errorHeader = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
final MslObject errorHeaderMo = MslTestUtils.toMslObject(encoder, errorHeader);
// This tests empty but trusted error data so we must sign it.
final byte[] ciphertext = new byte[0];
errorHeaderMo.put(KEY_ERRORDATA, ciphertext);
final byte[] signature = cryptoContext.sign(ciphertext, encoder, ENCODER_FORMAT);
errorHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(ctx, errorHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void missingTimestamp() throws MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
final ErrorHeader errorHeader = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
final MslObject errorHeaderMo = MslTestUtils.toMslObject(encoder, errorHeader);
// Before modifying the error data we need to decrypt it.
final byte[] ciphertext = errorHeaderMo.getBytes(KEY_ERRORDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject errordata = encoder.parseObject(plaintext);
// After modifying the error data we need to encrypt it.
assertNotNull(errordata.remove(KEY_TIMESTAMP));
final byte[] modifiedPlaintext = encoder.encodeObject(errordata, ENCODER_FORMAT);
final byte[] modifiedCiphertext = cryptoContext.encrypt(modifiedPlaintext, encoder, ENCODER_FORMAT);
errorHeaderMo.put(KEY_ERRORDATA, modifiedCiphertext);
// The error data must be signed otherwise the error data will not be
// processed.
final byte[] modifiedSignature = cryptoContext.sign(modifiedCiphertext, encoder, ENCODER_FORMAT);
errorHeaderMo.put(KEY_SIGNATURE, modifiedSignature);
Header.parseHeader(ctx, errorHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void invalidTimestamp() throws MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ErrorHeader errorHeader = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
final MslObject errorHeaderMo = MslTestUtils.toMslObject(encoder, errorHeader);
// Before modifying the error data we need to decrypt it.
final byte[] ciphertext = errorHeaderMo.getBytes(KEY_ERRORDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject errordata = encoder.parseObject(plaintext);
// After modifying the error data we need to encrypt it.
errordata.put(KEY_TIMESTAMP, "x");
final byte[] modifiedPlaintext = errordata.toString().getBytes(MslConstants.DEFAULT_CHARSET);
final byte[] modifiedCiphertext = cryptoContext.encrypt(modifiedPlaintext, encoder, ENCODER_FORMAT);
errorHeaderMo.put(KEY_ERRORDATA, modifiedCiphertext);
// The error data must be signed otherwise the error data will not be
// processed.
final byte[] modifiedSignature = cryptoContext.sign(modifiedCiphertext, encoder, ENCODER_FORMAT);
errorHeaderMo.put(KEY_SIGNATURE, modifiedSignature);
Header.parseHeader(ctx, errorHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void missingMessageId() throws MslEncoderException, UnsupportedEncodingException, MslKeyExchangeException, MslUserAuthException, MslException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ErrorHeader errorHeader = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
final MslObject errorHeaderMo = MslTestUtils.toMslObject(encoder, errorHeader);
// Before modifying the error data we need to decrypt it.
final byte[] ciphertext = errorHeaderMo.getBytes(KEY_ERRORDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject errordata = encoder.parseObject(plaintext);
// After modifying the error data we need to encrypt it.
assertNotNull(errordata.remove(KEY_MESSAGE_ID));
final byte[] modifiedPlaintext = errordata.toString().getBytes(MslConstants.DEFAULT_CHARSET);
final byte[] modifiedCiphertext = cryptoContext.encrypt(modifiedPlaintext, encoder, ENCODER_FORMAT);
errorHeaderMo.put(KEY_ERRORDATA, modifiedCiphertext);
// The error data must be signed otherwise the error data will not be
// processed.
final byte[] modifiedSignature = cryptoContext.sign(modifiedCiphertext, encoder, ENCODER_FORMAT);
errorHeaderMo.put(KEY_SIGNATURE, modifiedSignature);
Header.parseHeader(ctx, errorHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void invalidMessageId() throws UnsupportedEncodingException, MslEncoderException, MslKeyExchangeException, MslUserAuthException, MslException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ErrorHeader errorHeader = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
final MslObject errorHeaderMo = MslTestUtils.toMslObject(encoder, errorHeader);
// Before modifying the error data we need to decrypt it.
final byte[] ciphertext = errorHeaderMo.getBytes(KEY_ERRORDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject errordata = encoder.parseObject(plaintext);
// After modifying the error data we need to encrypt it.
errordata.put(KEY_MESSAGE_ID, "x");
final byte[] modifiedPlaintext = errordata.toString().getBytes(MslConstants.DEFAULT_CHARSET);
final byte[] modifiedCiphertext = cryptoContext.encrypt(modifiedPlaintext, encoder, ENCODER_FORMAT);
errorHeaderMo.put(KEY_ERRORDATA, modifiedCiphertext);
// The error data must be signed otherwise the error data will not be
// processed.
final byte[] modifiedSignature = cryptoContext.sign(modifiedCiphertext, encoder, ENCODER_FORMAT);
errorHeaderMo.put(KEY_SIGNATURE, modifiedSignature);
Header.parseHeader(ctx, errorHeaderMo, CRYPTO_CONTEXTS);
}
@Test(expected = MslInternalException.class)
public void negativeMessageIdCtor() throws MslEncodingException, MslEntityAuthException, MslMessageException, MslCryptoException {
new ErrorHeader(ctx, ENTITY_AUTH_DATA, -1, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
}
@Test(expected = MslInternalException.class)
public void tooLargeMessageIdCtor() throws MslEncodingException, MslEntityAuthException, MslMessageException, MslCryptoException {
new ErrorHeader(ctx, ENTITY_AUTH_DATA, MslConstants.MAX_LONG_VALUE + 1, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
}
@Test
public void negativeMessageIdParseHeader() throws MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslEncoderException, MslException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.MESSAGE_ID_OUT_OF_RANGE);
final ErrorHeader errorHeader = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
final MslObject errorHeaderMo = MslTestUtils.toMslObject(encoder, errorHeader);
// Before modifying the error data we need to decrypt it.
final byte[] ciphertext = errorHeaderMo.getBytes(KEY_ERRORDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject errordata = encoder.parseObject(plaintext);
// After modifying the error data we need to encrypt it.
errordata.put(KEY_MESSAGE_ID, -1L);
final byte[] modifiedPlaintext = errordata.toString().getBytes(MslConstants.DEFAULT_CHARSET);
final byte[] modifiedCiphertext = cryptoContext.encrypt(modifiedPlaintext, encoder, ENCODER_FORMAT);
errorHeaderMo.put(KEY_ERRORDATA, modifiedCiphertext);
// The error data must be signed otherwise the error data will not be
// processed.
final byte[] modifiedSignature = cryptoContext.sign(modifiedCiphertext, encoder, ENCODER_FORMAT);
errorHeaderMo.put(KEY_SIGNATURE, modifiedSignature);
Header.parseHeader(ctx, errorHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void tooLargeMessageIdParseHeader() throws MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslEncoderException, MslException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.MESSAGE_ID_OUT_OF_RANGE);
final ErrorHeader errorHeader = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
final MslObject errorHeaderMo = MslTestUtils.toMslObject(encoder, errorHeader);
// Before modifying the error data we need to decrypt it.
final byte[] ciphertext = errorHeaderMo.getBytes(KEY_ERRORDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject errordata = encoder.parseObject(plaintext);
// After modifying the error data we need to encrypt it.
errordata.put(KEY_MESSAGE_ID, MslConstants.MAX_LONG_VALUE + 1);
final byte[] modifiedPlaintext = errordata.toString().getBytes(MslConstants.DEFAULT_CHARSET);
final byte[] modifiedCiphertext = cryptoContext.encrypt(modifiedPlaintext, encoder, ENCODER_FORMAT);
errorHeaderMo.put(KEY_ERRORDATA, modifiedCiphertext);
// The error data must be signed otherwise the error data will not be
// processed.
final byte[] modifiedSignature = cryptoContext.sign(modifiedCiphertext, encoder, ENCODER_FORMAT);
errorHeaderMo.put(KEY_SIGNATURE, modifiedSignature);
Header.parseHeader(ctx, errorHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void missingErrorCode() throws MslEncodingException, MslEntityAuthException, MslCryptoException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
thrown.expectMessageId(MESSAGE_ID);
final ErrorHeader errorHeader = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
final MslObject errorHeaderMo = MslTestUtils.toMslObject(encoder, errorHeader);
// Before modifying the error data we need to decrypt it.
final byte[] ciphertext = errorHeaderMo.getBytes(KEY_ERRORDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject errordata = encoder.parseObject(plaintext);
// After modifying the error data we need to encrypt it.
assertNotNull(errordata.remove(KEY_ERROR_CODE));
final byte[] modifiedPlaintext = errordata.toString().getBytes(MslConstants.DEFAULT_CHARSET);
final byte[] modifiedCiphertext = cryptoContext.encrypt(modifiedPlaintext, encoder, ENCODER_FORMAT);
errorHeaderMo.put(KEY_ERRORDATA, modifiedCiphertext);
// The error data must be signed otherwise the error data will not be
// processed.
final byte[] modifiedSignature = cryptoContext.sign(modifiedCiphertext, encoder, ENCODER_FORMAT);
errorHeaderMo.put(KEY_SIGNATURE, modifiedSignature);
Header.parseHeader(ctx, errorHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void invalidErrorCode() throws MslEncodingException, MslEntityAuthException, MslCryptoException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
thrown.expectMessageId(MESSAGE_ID);
final ErrorHeader errorHeader = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
final MslObject errorHeaderMo = MslTestUtils.toMslObject(encoder, errorHeader);
// Before modifying the error data we need to decrypt it.
final byte[] ciphertext = errorHeaderMo.getBytes(KEY_ERRORDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject errordata = encoder.parseObject(plaintext);
// After modifying the error data we need to encrypt it.
errordata.put(KEY_ERROR_CODE, "x");
final byte[] modifiedPlaintext = errordata.toString().getBytes(MslConstants.DEFAULT_CHARSET);
final byte[] modifiedCiphertext = cryptoContext.encrypt(modifiedPlaintext, encoder, ENCODER_FORMAT);
errorHeaderMo.put(KEY_ERRORDATA, modifiedCiphertext);
// The error data must be signed otherwise the error data will not be
// processed.
final byte[] modifiedSignature = cryptoContext.sign(modifiedCiphertext, encoder, ENCODER_FORMAT);
errorHeaderMo.put(KEY_SIGNATURE, modifiedSignature);
Header.parseHeader(ctx, errorHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void missingInternalCode() throws MslEncoderException, MslKeyExchangeException, MslUserAuthException, MslException {
final ErrorHeader errorHeader = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
final MslObject errorHeaderMo = MslTestUtils.toMslObject(encoder, errorHeader);
// Before modifying the error data we need to decrypt it.
final byte[] ciphertext = errorHeaderMo.getBytes(KEY_ERRORDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject errordata = encoder.parseObject(plaintext);
// After modifying the error data we need to encrypt it.
assertNotNull(errordata.remove(KEY_INTERNAL_CODE));
final byte[] modifiedPlaintext = errordata.toString().getBytes(MslConstants.DEFAULT_CHARSET);
final byte[] modifiedCiphertext = cryptoContext.encrypt(modifiedPlaintext, encoder, ENCODER_FORMAT);
errorHeaderMo.put(KEY_ERRORDATA, modifiedCiphertext);
// The error data must be signed otherwise the error data will not be
// processed.
final byte[] modifiedSignature = cryptoContext.sign(modifiedCiphertext, encoder, ENCODER_FORMAT);
errorHeaderMo.put(KEY_SIGNATURE, modifiedSignature);
final ErrorHeader moErrorHeader = (ErrorHeader)Header.parseHeader(ctx, errorHeaderMo, CRYPTO_CONTEXTS);
assertEquals(-1, moErrorHeader.getInternalCode());
}
@Test
public void invalidInternalCode() throws MslEncoderException, MslKeyExchangeException, MslUserAuthException, MslException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
thrown.expectMessageId(MESSAGE_ID);
final ErrorHeader errorHeader = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
final MslObject errorHeaderMo = MslTestUtils.toMslObject(encoder, errorHeader);
// Before modifying the error data we need to decrypt it.
final byte[] ciphertext = errorHeaderMo.getBytes(KEY_ERRORDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject errordata = encoder.parseObject(plaintext);
// After modifying the error data we need to encrypt it.
errordata.put(KEY_INTERNAL_CODE, "x");
final byte[] modifiedPlaintext = errordata.toString().getBytes(MslConstants.DEFAULT_CHARSET);
final byte[] modifiedCiphertext = cryptoContext.encrypt(modifiedPlaintext, encoder, ENCODER_FORMAT);
errorHeaderMo.put(KEY_ERRORDATA, modifiedCiphertext);
// The error data must be signed otherwise the error data will not be
// processed.
final byte[] modifiedSignature = cryptoContext.sign(modifiedCiphertext, encoder, ENCODER_FORMAT);
errorHeaderMo.put(KEY_SIGNATURE, modifiedSignature);
Header.parseHeader(ctx, errorHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void negativeInternalCode() throws MslEncoderException, MslKeyExchangeException, MslUserAuthException, MslException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.INTERNAL_CODE_NEGATIVE);
thrown.expectMessageId(MESSAGE_ID);
final ErrorHeader errorHeader = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
final MslObject errorHeaderMo = MslTestUtils.toMslObject(encoder, errorHeader);
// Before modifying the error data we need to decrypt it.
final byte[] ciphertext = errorHeaderMo.getBytes(KEY_ERRORDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject errordata = encoder.parseObject(plaintext);
// After modifying the error data we need to encrypt it.
errordata.put(KEY_INTERNAL_CODE, -17);
final byte[] modifiedPlaintext = errordata.toString().getBytes(MslConstants.DEFAULT_CHARSET);
final byte[] modifiedCiphertext = cryptoContext.encrypt(modifiedPlaintext, encoder, ENCODER_FORMAT);
errorHeaderMo.put(KEY_ERRORDATA, modifiedCiphertext);
// The error data must be signed otherwise the error data will not be
// processed.
final byte[] modifiedSignature = cryptoContext.sign(modifiedCiphertext, encoder, ENCODER_FORMAT);
errorHeaderMo.put(KEY_SIGNATURE, modifiedSignature);
Header.parseHeader(ctx, errorHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void missingErrorMessage() throws UnsupportedEncodingException, MslEncoderException, MslKeyExchangeException, MslUserAuthException, MslException {
final ErrorHeader errorHeader = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
final MslObject errorHeaderMo = MslTestUtils.toMslObject(encoder, errorHeader);
// Before modifying the error data we need to decrypt it.
final byte[] ciphertext = errorHeaderMo.getBytes(KEY_ERRORDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject errordata = encoder.parseObject(plaintext);
// After modifying the error data we need to encrypt it.
assertNotNull(errordata.remove(KEY_ERROR_MESSAGE));
final byte[] modifiedPlaintext = errordata.toString().getBytes(MslConstants.DEFAULT_CHARSET);
final byte[] modifiedCiphertext = cryptoContext.encrypt(modifiedPlaintext, encoder, ENCODER_FORMAT);
errorHeaderMo.put(KEY_ERRORDATA, modifiedCiphertext);
// The error data must be signed otherwise the error data will not be
// processed.
final byte[] modifiedSignature = cryptoContext.sign(modifiedCiphertext, encoder, ENCODER_FORMAT);
errorHeaderMo.put(KEY_SIGNATURE, modifiedSignature);
final ErrorHeader moErrorHeader = (ErrorHeader)Header.parseHeader(ctx, errorHeaderMo, CRYPTO_CONTEXTS);
assertNull(moErrorHeader.getErrorMessage());
}
@Test
public void missingUserMessage() throws MslEncodingException, MslEntityAuthException, MslMessageException, MslKeyExchangeException, MslUserAuthException, MslEncoderException, MslException {
final ErrorHeader errorHeader = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
final MslObject errorHeaderMo = MslTestUtils.toMslObject(encoder, errorHeader);
// Before modifying the error data we need to decrypt it.
final byte[] ciphertext = errorHeaderMo.getBytes(KEY_ERRORDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject errordata = encoder.parseObject(plaintext);
// After modifying the error data we need to encrypt it.
assertNotNull(errordata.remove(KEY_USER_MESSAGE));
final byte[] modifiedPlaintext = errordata.toString().getBytes(MslConstants.DEFAULT_CHARSET);
final byte[] modifiedCiphertext = cryptoContext.encrypt(modifiedPlaintext, encoder, ENCODER_FORMAT);
errorHeaderMo.put(KEY_ERRORDATA, modifiedCiphertext);
// The error data must be signed otherwise the error data will not be
// processed.
final byte[] modifiedSignature = cryptoContext.sign(modifiedCiphertext, encoder, ENCODER_FORMAT);
errorHeaderMo.put(KEY_SIGNATURE, modifiedSignature);
final ErrorHeader moErrorHeader = (ErrorHeader)Header.parseHeader(ctx, errorHeaderMo, CRYPTO_CONTEXTS);
assertNull(moErrorHeader.getUserMessage());
}
@Test
public void equalsTimestamp() throws InterruptedException, MslKeyExchangeException, MslUserAuthException, MslEncoderException, MslException {
final ErrorHeader errorHeaderA = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
Thread.sleep(MILLISECONDS_PER_SECOND);
final ErrorHeader errorHeaderB = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
final ErrorHeader errorHeaderA2 = (ErrorHeader)Header.parseHeader(ctx, MslTestUtils.toMslObject(encoder, errorHeaderA), CRYPTO_CONTEXTS);
assertTrue(errorHeaderA.equals(errorHeaderA));
assertEquals(errorHeaderA.hashCode(), errorHeaderA.hashCode());
assertFalse(errorHeaderA.equals(errorHeaderB));
assertFalse(errorHeaderB.equals(errorHeaderA));
assertTrue(errorHeaderA.hashCode() != errorHeaderB.hashCode());
assertTrue(errorHeaderA.equals(errorHeaderA2));
assertTrue(errorHeaderA2.equals(errorHeaderA));
assertEquals(errorHeaderA.hashCode(), errorHeaderA2.hashCode());
}
@Test
public void equalsMessageId() throws MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
final long messageIdA = 1;
final long messageIdB = 2;
final ErrorHeader errorHeaderA = new ErrorHeader(ctx, ENTITY_AUTH_DATA, messageIdA, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
final ErrorHeader errorHeaderB = new ErrorHeader(ctx, ENTITY_AUTH_DATA, messageIdB, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
final ErrorHeader errorHeaderA2 = (ErrorHeader)Header.parseHeader(ctx, MslTestUtils.toMslObject(encoder, errorHeaderA), CRYPTO_CONTEXTS);
assertTrue(errorHeaderA.equals(errorHeaderA));
assertEquals(errorHeaderA.hashCode(), errorHeaderA.hashCode());
assertFalse(errorHeaderA.equals(errorHeaderB));
assertFalse(errorHeaderB.equals(errorHeaderA));
assertTrue(errorHeaderA.hashCode() != errorHeaderB.hashCode());
assertTrue(errorHeaderA.equals(errorHeaderA2));
assertTrue(errorHeaderA2.equals(errorHeaderA));
assertEquals(errorHeaderA.hashCode(), errorHeaderA2.hashCode());
}
@Test
public void equalsErrorCode() throws MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
final ResponseCode errorCodeA = ResponseCode.FAIL;
final ResponseCode errorCodeB = ResponseCode.TRANSIENT_FAILURE;
final ErrorHeader errorHeaderA = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, errorCodeA, INTERNAL_CODE, ERROR_MSG, USER_MSG);
final ErrorHeader errorHeaderB = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, errorCodeB, INTERNAL_CODE, ERROR_MSG, USER_MSG);
final ErrorHeader errorHeaderA2 = (ErrorHeader)Header.parseHeader(ctx, MslTestUtils.toMslObject(encoder, errorHeaderA), CRYPTO_CONTEXTS);
assertTrue(errorHeaderA.equals(errorHeaderA));
assertEquals(errorHeaderA.hashCode(), errorHeaderA.hashCode());
assertFalse(errorHeaderA.equals(errorHeaderB));
assertFalse(errorHeaderB.equals(errorHeaderA));
assertTrue(errorHeaderA.hashCode() != errorHeaderB.hashCode());
assertTrue(errorHeaderA.equals(errorHeaderA2));
assertTrue(errorHeaderA2.equals(errorHeaderA));
assertEquals(errorHeaderA.hashCode(), errorHeaderA2.hashCode());
}
@Test
public void equalsInternalCode() throws MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
final int internalCodeA = 1;
final int internalCodeB = 2;
final ErrorHeader errorHeaderA = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, internalCodeA, ERROR_MSG, USER_MSG);
final ErrorHeader errorHeaderB = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, internalCodeB, ERROR_MSG, USER_MSG);
final ErrorHeader errorHeaderA2 = (ErrorHeader)Header.parseHeader(ctx, MslTestUtils.toMslObject(encoder, errorHeaderA), CRYPTO_CONTEXTS);
assertTrue(errorHeaderA.equals(errorHeaderA));
assertEquals(errorHeaderA.hashCode(), errorHeaderA.hashCode());
assertFalse(errorHeaderA.equals(errorHeaderB));
assertFalse(errorHeaderB.equals(errorHeaderA));
assertTrue(errorHeaderA.hashCode() != errorHeaderB.hashCode());
assertTrue(errorHeaderA.equals(errorHeaderA2));
assertTrue(errorHeaderA2.equals(errorHeaderA));
assertEquals(errorHeaderA.hashCode(), errorHeaderA2.hashCode());
}
@Test
public void equalsErrorMessage() throws MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
final String errorMsgA = "A";
final String errorMsgB = "B";
final ErrorHeader errorHeaderA = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, errorMsgA, USER_MSG);
final ErrorHeader errorHeaderB = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, errorMsgB, USER_MSG);
final ErrorHeader errorHeaderC = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, null, USER_MSG);
final ErrorHeader errorHeaderA2 = (ErrorHeader)Header.parseHeader(ctx, MslTestUtils.toMslObject(encoder, errorHeaderA), CRYPTO_CONTEXTS);
assertTrue(errorHeaderA.equals(errorHeaderA));
assertEquals(errorHeaderA.hashCode(), errorHeaderA.hashCode());
assertFalse(errorHeaderA.equals(errorHeaderB));
assertFalse(errorHeaderB.equals(errorHeaderA));
assertTrue(errorHeaderA.hashCode() != errorHeaderB.hashCode());
assertFalse(errorHeaderA.equals(errorHeaderC));
assertFalse(errorHeaderC.equals(errorHeaderA));
assertTrue(errorHeaderA.hashCode() != errorHeaderC.hashCode());
assertTrue(errorHeaderA.equals(errorHeaderA2));
assertTrue(errorHeaderA2.equals(errorHeaderA));
assertEquals(errorHeaderA.hashCode(), errorHeaderA2.hashCode());
}
@Test
public void equalsUserMessage() throws MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
final String userMsgA = "A";
final String userMsgB = "B";
final ErrorHeader errorHeaderA = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, userMsgA);
final ErrorHeader errorHeaderB = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, userMsgB);
final ErrorHeader errorHeaderC = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, null);
final ErrorHeader errorHeaderA2 = (ErrorHeader)Header.parseHeader(ctx, MslTestUtils.toMslObject(encoder, errorHeaderA), CRYPTO_CONTEXTS);
assertTrue(errorHeaderA.equals(errorHeaderA));
assertEquals(errorHeaderA.hashCode(), errorHeaderA.hashCode());
assertFalse(errorHeaderA.equals(errorHeaderB));
assertFalse(errorHeaderB.equals(errorHeaderA));
assertTrue(errorHeaderA.hashCode() != errorHeaderB.hashCode());
assertFalse(errorHeaderA.equals(errorHeaderC));
assertFalse(errorHeaderC.equals(errorHeaderA));
assertTrue(errorHeaderA.hashCode() != errorHeaderC.hashCode());
assertTrue(errorHeaderA.equals(errorHeaderA2));
assertTrue(errorHeaderA2.equals(errorHeaderA));
assertEquals(errorHeaderA.hashCode(), errorHeaderA2.hashCode());
}
@Test
public void equalsObject() throws MslEncodingException, MslEntityAuthException, MslMessageException, MslCryptoException {
final ErrorHeader errorHeader = new ErrorHeader(ctx, ENTITY_AUTH_DATA, MESSAGE_ID, ERROR_CODE, INTERNAL_CODE, ERROR_MSG, USER_MSG);
assertFalse(errorHeader.equals(null));
assertFalse(errorHeader.equals(ERROR_MSG));
assertTrue(errorHeader.hashCode() != ERROR_MSG.hashCode());
}
}
| 9,953 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/msg/MessageServiceTokenBuilderTest.java | /**
* Copyright (c) 2012-2020 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.msg;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.security.InvalidAlgorithmParameterException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Random;
import java.util.Set;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import com.netflix.msl.MslConstants.CompressionAlgorithm;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslException;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.MslKeyExchangeException;
import com.netflix.msl.MslMessageException;
import com.netflix.msl.crypto.NullCryptoContext;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.keyx.AsymmetricWrappedExchange;
import com.netflix.msl.keyx.AsymmetricWrappedExchange.RequestData.Mechanism;
import com.netflix.msl.keyx.KeyRequestData;
import com.netflix.msl.tokens.MasterToken;
import com.netflix.msl.tokens.ServiceToken;
import com.netflix.msl.tokens.UserIdToken;
import com.netflix.msl.userauth.MockEmailPasswordAuthenticationFactory;
import com.netflix.msl.userauth.UserAuthenticationScheme;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* Message service token builder unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class MessageServiceTokenBuilderTest {
private static final String KEY_PAIR_ID = "keyPairId";
private static final String USER_ID = "userid";
private static final String TOKEN_NAME = "tokenName";
private static final String EMPTY_TOKEN_NAME = "";
private static byte[] DATA;
private static final boolean ENCRYPT = true;
private static final CompressionAlgorithm COMPRESSION_ALGO = null;
private static MasterToken MASTER_TOKEN, PEER_MASTER_TOKEN;
private static UserIdToken USER_ID_TOKEN, PEER_USER_ID_TOKEN;
private static KeyRequestData KEY_REQUEST_DATA;
private static MessageFactory messageFactory = new MessageFactory();
private static Random random;
private static MslContext trustedNetCtx;
private static MockMessageContext trustedNetMsgCtx;
private static MslContext p2pCtx;
private static MockMessageContext p2pMsgCtx;
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException, NoSuchAlgorithmException, InvalidAlgorithmParameterException, MslKeyExchangeException {
random = new Random();
trustedNetCtx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
trustedNetMsgCtx = new MockMessageContext(trustedNetCtx, USER_ID, UserAuthenticationScheme.EMAIL_PASSWORD);
p2pCtx = new MockMslContext(EntityAuthenticationScheme.PSK, true);
p2pMsgCtx = new MockMessageContext(p2pCtx, USER_ID, UserAuthenticationScheme.EMAIL_PASSWORD);
MASTER_TOKEN = MslTestUtils.getMasterToken(p2pCtx, 1, 1);
USER_ID_TOKEN = MslTestUtils.getUserIdToken(p2pCtx, MASTER_TOKEN, 1, MockEmailPasswordAuthenticationFactory.USER);
PEER_MASTER_TOKEN = MslTestUtils.getMasterToken(p2pCtx, 1, 2);
PEER_USER_ID_TOKEN = MslTestUtils.getUserIdToken(p2pCtx, PEER_MASTER_TOKEN, 1, MockEmailPasswordAuthenticationFactory.USER);
final KeyPairGenerator rsaGenerator = KeyPairGenerator.getInstance("RSA");
final KeyPair rsaKeyPair = rsaGenerator.generateKeyPair();
final PrivateKey privateKey = rsaKeyPair.getPrivate();
final PublicKey publicKey = rsaKeyPair.getPublic();
KEY_REQUEST_DATA = new AsymmetricWrappedExchange.RequestData(KEY_PAIR_ID, Mechanism.JWEJS_RSA, publicKey, privateKey);
DATA = new byte[128];
random.nextBytes(DATA);
}
@AfterClass
public static void teardown() {
PEER_USER_ID_TOKEN = null;
PEER_MASTER_TOKEN = null;
USER_ID_TOKEN = null;
MASTER_TOKEN = null;
p2pMsgCtx = null;
p2pCtx = null;
trustedNetMsgCtx = null;
trustedNetCtx = null;
random = null;
}
@After
public void reset() throws NoSuchAlgorithmException, InvalidAlgorithmParameterException, MslCryptoException, MslKeyExchangeException {
p2pCtx.getMslStore().clearCryptoContexts();
p2pCtx.getMslStore().clearServiceTokens();
p2pCtx.getMslStore().clearUserIdTokens();
p2pMsgCtx = new MockMessageContext(p2pCtx, USER_ID, UserAuthenticationScheme.EMAIL_PASSWORD);
}
@Test
public void primaryMasterToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, null);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertTrue(tokenBuilder.isPrimaryMasterTokenAvailable());
assertFalse(tokenBuilder.isPrimaryUserIdTokenAvailable());
assertFalse(tokenBuilder.isPeerMasterTokenAvailable());
assertFalse(tokenBuilder.isPeerUserIdTokenAvailable());
}
@Test
public void primaryMasterTokenKeyx() throws MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, null, null);
requestBuilder.setRenewable(true);
requestBuilder.addKeyRequestData(KEY_REQUEST_DATA);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(trustedNetCtx, trustedNetMsgCtx, responseBuilder);
assertNull(responseBuilder.getMasterToken());
assertNotNull(responseBuilder.getKeyExchangeData());
assertTrue(tokenBuilder.isPrimaryMasterTokenAvailable());
assertFalse(tokenBuilder.isPrimaryUserIdTokenAvailable());
assertFalse(tokenBuilder.isPeerMasterTokenAvailable());
assertFalse(tokenBuilder.isPeerUserIdTokenAvailable());
}
@Test
public void primaryUserIdToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertTrue(tokenBuilder.isPrimaryMasterTokenAvailable());
assertTrue(tokenBuilder.isPrimaryUserIdTokenAvailable());
assertFalse(tokenBuilder.isPeerMasterTokenAvailable());
assertFalse(tokenBuilder.isPeerUserIdTokenAvailable());
}
@Test
public void peerMasterToken() throws MslMessageException, MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, null, null);
msgBuilder.setPeerAuthTokens(PEER_MASTER_TOKEN, null);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertFalse(tokenBuilder.isPrimaryMasterTokenAvailable());
assertFalse(tokenBuilder.isPrimaryUserIdTokenAvailable());
assertTrue(tokenBuilder.isPeerMasterTokenAvailable());
assertFalse(tokenBuilder.isPeerUserIdTokenAvailable());
}
@Test
public void peerMasterTokenKeyx() throws MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(p2pCtx, null, null);
requestBuilder.setRenewable(true);
requestBuilder.addKeyRequestData(KEY_REQUEST_DATA);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(p2pCtx, request);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, responseBuilder);
assertFalse(tokenBuilder.isPrimaryMasterTokenAvailable());
assertFalse(tokenBuilder.isPrimaryUserIdTokenAvailable());
assertFalse(tokenBuilder.isPeerMasterTokenAvailable());
assertFalse(tokenBuilder.isPeerUserIdTokenAvailable());
}
@Test
public void peerUserIdToken() throws MslMessageException, MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, null, null);
msgBuilder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertFalse(tokenBuilder.isPrimaryMasterTokenAvailable());
assertFalse(tokenBuilder.isPrimaryUserIdTokenAvailable());
assertTrue(tokenBuilder.isPeerMasterTokenAvailable());
assertTrue(tokenBuilder.isPeerUserIdTokenAvailable());
}
@Test
public void getPrimaryServiceTokens() throws MslEncodingException, MslCryptoException, MslMessageException, MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
for (final ServiceToken serviceToken : serviceTokens)
msgBuilder.addServiceToken(serviceToken);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertEquals(serviceTokens, tokenBuilder.getPrimaryServiceTokens());
assertTrue(tokenBuilder.getPeerServiceTokens().isEmpty());
}
@Test
public void getPeerServiceTokens() throws MslEncodingException, MslCryptoException, MslMessageException, MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, null, null);
msgBuilder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
for (final ServiceToken peerServiceToken : peerServiceTokens)
msgBuilder.addPeerServiceToken(peerServiceToken);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertEquals(peerServiceTokens, tokenBuilder.getPeerServiceTokens());
assertTrue(tokenBuilder.getPrimaryServiceTokens().isEmpty());
}
@Test
public void getBothServiceTokens() throws MslEncodingException, MslCryptoException, MslMessageException, MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
for (final ServiceToken serviceToken : serviceTokens)
msgBuilder.addServiceToken(serviceToken);
msgBuilder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
for (final ServiceToken peerServiceToken : peerServiceTokens)
msgBuilder.addPeerServiceToken(peerServiceToken);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertEquals(serviceTokens, tokenBuilder.getPrimaryServiceTokens());
assertEquals(peerServiceTokens, tokenBuilder.getPeerServiceTokens());
}
@Test
public void addPrimaryServiceToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertTrue(tokenBuilder.getPrimaryServiceTokens().isEmpty());
final ServiceToken serviceToken = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, false, null, new NullCryptoContext());
assertTrue(tokenBuilder.addPrimaryServiceToken(serviceToken));
final Set<ServiceToken> serviceTokens = tokenBuilder.getPrimaryServiceTokens();
assertEquals(1, serviceTokens.size());
final ServiceToken builderServiceToken = serviceTokens.toArray(new ServiceToken[0])[0];
assertEquals(serviceToken, builderServiceToken);
}
@Test
public void addNamedPrimaryServiceTokens() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertTrue(tokenBuilder.getPrimaryServiceTokens().isEmpty());
final ServiceToken unboundServiceTokenA = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, null, null, false, null, new NullCryptoContext());
assertTrue(tokenBuilder.addPrimaryServiceToken(unboundServiceTokenA));
assertEquals(1, tokenBuilder.getPrimaryServiceTokens().size());
final ServiceToken unboundServiceTokenB = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, null, null, false, null, new NullCryptoContext());
assertTrue(tokenBuilder.addPrimaryServiceToken(unboundServiceTokenB));
assertEquals(1, tokenBuilder.getPrimaryServiceTokens().size());
final ServiceToken masterBoundServiceTokenA = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, MASTER_TOKEN, null, false, null, new NullCryptoContext());
assertTrue(tokenBuilder.addPrimaryServiceToken(masterBoundServiceTokenA));
assertEquals(2, tokenBuilder.getPrimaryServiceTokens().size());
final ServiceToken masterBoundServiceTokenB = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, MASTER_TOKEN, null, false, null, new NullCryptoContext());
assertTrue(tokenBuilder.addPrimaryServiceToken(masterBoundServiceTokenB));
assertEquals(2, tokenBuilder.getPrimaryServiceTokens().size());
final ServiceToken userBoundServiceTokenA = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, false, null, new NullCryptoContext());
assertTrue(tokenBuilder.addPrimaryServiceToken(userBoundServiceTokenA));
assertEquals(3, tokenBuilder.getPrimaryServiceTokens().size());
final ServiceToken userBoundServiceTokenB = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, false, null, new NullCryptoContext());
assertTrue(tokenBuilder.addPrimaryServiceToken(userBoundServiceTokenB));
assertEquals(3, tokenBuilder.getPrimaryServiceTokens().size());
}
@Test
public void mismatchedMasterTokenAddPrimaryServiceToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
final ServiceToken serviceToken = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, PEER_MASTER_TOKEN, null, false, null, new NullCryptoContext());
assertFalse(tokenBuilder.addPrimaryServiceToken(serviceToken));
assertTrue(tokenBuilder.getPrimaryServiceTokens().isEmpty());
}
@Test
public void mismatchedUserIdTokenAddPrimaryServiceToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(p2pCtx, MASTER_TOKEN, 2, MockEmailPasswordAuthenticationFactory.USER);
final ServiceToken serviceToken = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, MASTER_TOKEN, userIdToken, false, null, new NullCryptoContext());
assertFalse(tokenBuilder.addPrimaryServiceToken(serviceToken));
assertTrue(tokenBuilder.getPrimaryServiceTokens().isEmpty());
}
@Test
public void noMasterTokenAddPrimaryServiceToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, null, null);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
final ServiceToken serviceToken = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, MASTER_TOKEN, null, false, null, new NullCryptoContext());
assertFalse(tokenBuilder.addPrimaryServiceToken(serviceToken));
assertTrue(tokenBuilder.getPrimaryServiceTokens().isEmpty());
}
@Test
public void noUserIdTokenAddPrimaryServiceToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, null);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
final ServiceToken serviceToken = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, false, null, new NullCryptoContext());
assertFalse(tokenBuilder.addPrimaryServiceToken(serviceToken));
assertTrue(tokenBuilder.getPrimaryServiceTokens().isEmpty());
}
@Test
public void addPeerServiceToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
msgBuilder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertTrue(tokenBuilder.getPeerServiceTokens().isEmpty());
final ServiceToken serviceToken = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, false, null, new NullCryptoContext());
tokenBuilder.addPeerServiceToken(serviceToken);
final Set<ServiceToken> serviceTokens = tokenBuilder.getPeerServiceTokens();
assertEquals(1, serviceTokens.size());
final ServiceToken builderServiceToken = serviceTokens.toArray(new ServiceToken[0])[0];
assertEquals(serviceToken, builderServiceToken);
}
@Test
public void addNamedPeerServiceTokens() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
msgBuilder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertTrue(tokenBuilder.getPeerServiceTokens().isEmpty());
final ServiceToken unboundServiceTokenA = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, null, null, false, null, new NullCryptoContext());
assertTrue(tokenBuilder.addPeerServiceToken(unboundServiceTokenA));
assertEquals(1, tokenBuilder.getPeerServiceTokens().size());
final ServiceToken unboundServiceTokenB = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, null, null, false, null, new NullCryptoContext());
assertTrue(tokenBuilder.addPeerServiceToken(unboundServiceTokenB));
assertEquals(1, tokenBuilder.getPeerServiceTokens().size());
final ServiceToken masterBoundServiceTokenA = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, PEER_MASTER_TOKEN, null, false, null, new NullCryptoContext());
assertTrue(tokenBuilder.addPeerServiceToken(masterBoundServiceTokenA));
assertEquals(2, tokenBuilder.getPeerServiceTokens().size());
final ServiceToken masterBoundServiceTokenB = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, PEER_MASTER_TOKEN, null, false, null, new NullCryptoContext());
assertTrue(tokenBuilder.addPeerServiceToken(masterBoundServiceTokenB));
assertEquals(2, tokenBuilder.getPeerServiceTokens().size());
final ServiceToken userBoundServiceTokenA = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, false, null, new NullCryptoContext());
assertTrue(tokenBuilder.addPeerServiceToken(userBoundServiceTokenA));
assertEquals(3, tokenBuilder.getPeerServiceTokens().size());
final ServiceToken userBoundServiceTokenB = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, false, null, new NullCryptoContext());
assertTrue(tokenBuilder.addPeerServiceToken(userBoundServiceTokenB));
assertEquals(3, tokenBuilder.getPeerServiceTokens().size());
}
@Test
public void mismatchedMasterTokenAddPeerServiceToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
msgBuilder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
final ServiceToken serviceToken = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, MASTER_TOKEN, null, false, null, new NullCryptoContext());
assertFalse(tokenBuilder.addPeerServiceToken(serviceToken));
assertTrue(tokenBuilder.getPeerServiceTokens().isEmpty());
}
@Test
public void mismatchedUserIdTokenAddPeerServiceToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
msgBuilder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(p2pCtx, PEER_MASTER_TOKEN, 2, MockEmailPasswordAuthenticationFactory.USER);
final ServiceToken serviceToken = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, PEER_MASTER_TOKEN, userIdToken, false, null, new NullCryptoContext());
assertFalse(tokenBuilder.addPeerServiceToken(serviceToken));
assertTrue(tokenBuilder.getPeerServiceTokens().isEmpty());
}
@Test
public void noMasterTokenAddPeerServiceToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
final ServiceToken serviceToken = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, PEER_MASTER_TOKEN, null, false, null, new NullCryptoContext());
assertFalse(tokenBuilder.addPeerServiceToken(serviceToken));
assertTrue(tokenBuilder.getPeerServiceTokens().isEmpty());
}
@Test
public void noUserIdTokenAddPeerServiceToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
msgBuilder.setPeerAuthTokens(PEER_MASTER_TOKEN, null);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
final ServiceToken serviceToken = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, false, null, new NullCryptoContext());
assertFalse(tokenBuilder.addPeerServiceToken(serviceToken));
assertTrue(tokenBuilder.getPeerServiceTokens().isEmpty());
}
@Test(expected = MslInternalException.class)
public void trustedNetAddPeerServiceToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
final ServiceToken serviceToken = new ServiceToken(trustedNetCtx, TOKEN_NAME, DATA, null, null, false, null, new NullCryptoContext());
tokenBuilder.addPeerServiceToken(serviceToken);
}
@Test
public void addUnboundPrimaryServiceToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, null, null);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertTrue(tokenBuilder.getPrimaryServiceTokens().isEmpty());
assertTrue(tokenBuilder.addUnboundPrimaryServiceToken(TOKEN_NAME, DATA, ENCRYPT, COMPRESSION_ALGO));
final Set<ServiceToken> serviceTokens = tokenBuilder.getPrimaryServiceTokens();
assertEquals(1, serviceTokens.size());
final ServiceToken serviceToken = serviceTokens.toArray(new ServiceToken[0])[0];
assertEquals(TOKEN_NAME, serviceToken.getName());
assertArrayEquals(DATA, serviceToken.getData());
assertEquals(ENCRYPT, serviceToken.isEncrypted());
assertTrue(serviceToken.isUnbound());
assertEquals(serviceTokens, msgBuilder.getServiceTokens());
}
@Test
public void noCryptoContextAddUnboundPrimaryServiceToken() throws MslException {
p2pMsgCtx.removeCryptoContext(TOKEN_NAME);
p2pMsgCtx.removeCryptoContext(EMPTY_TOKEN_NAME);
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, null, null);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertFalse(tokenBuilder.addUnboundPrimaryServiceToken(TOKEN_NAME, DATA, ENCRYPT, COMPRESSION_ALGO));
final Set<ServiceToken> serviceTokens = tokenBuilder.getPrimaryServiceTokens();
assertEquals(0, serviceTokens.size());
assertEquals(0, msgBuilder.getServiceTokens().size());
}
@Test
public void addMasterBoundPrimaryServiceToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, null);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertTrue(tokenBuilder.getPrimaryServiceTokens().isEmpty());
assertTrue(tokenBuilder.addMasterBoundPrimaryServiceToken(TOKEN_NAME, DATA, ENCRYPT, COMPRESSION_ALGO));
final Set<ServiceToken> serviceTokens = tokenBuilder.getPrimaryServiceTokens();
assertEquals(1, serviceTokens.size());
final ServiceToken serviceToken = serviceTokens.toArray(new ServiceToken[0])[0];
assertEquals(TOKEN_NAME, serviceToken.getName());
assertArrayEquals(DATA, serviceToken.getData());
assertEquals(ENCRYPT, serviceToken.isEncrypted());
assertTrue(serviceToken.isBoundTo(MASTER_TOKEN));
assertEquals(serviceTokens, msgBuilder.getServiceTokens());
}
@Test
public void noMasterTokenAddMasterBoundPrimaryServiceToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, null, null);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertFalse(tokenBuilder.addMasterBoundPrimaryServiceToken(TOKEN_NAME, DATA, ENCRYPT, COMPRESSION_ALGO));
final Set<ServiceToken> serviceTokens = tokenBuilder.getPrimaryServiceTokens();
assertEquals(0, serviceTokens.size());
assertEquals(0, msgBuilder.getServiceTokens().size());
}
@Test
public void noCryptoContextAddMasterBoundPrimaryServiceToken() throws MslEncodingException, MslCryptoException, MslException {
p2pMsgCtx.removeCryptoContext(TOKEN_NAME);
p2pMsgCtx.removeCryptoContext(EMPTY_TOKEN_NAME);
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, null);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertFalse(tokenBuilder.addMasterBoundPrimaryServiceToken(TOKEN_NAME, DATA, ENCRYPT, COMPRESSION_ALGO));
final Set<ServiceToken> serviceTokens = tokenBuilder.getPrimaryServiceTokens();
assertEquals(0, serviceTokens.size());
assertEquals(0, msgBuilder.getServiceTokens().size());
}
@Test
public void addUserBoundPrimaryServiceToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertTrue(tokenBuilder.getPrimaryServiceTokens().isEmpty());
assertTrue(tokenBuilder.addUserBoundPrimaryServiceToken(TOKEN_NAME, DATA, ENCRYPT, COMPRESSION_ALGO));
final Set<ServiceToken> serviceTokens = tokenBuilder.getPrimaryServiceTokens();
assertEquals(1, serviceTokens.size());
final ServiceToken serviceToken = serviceTokens.toArray(new ServiceToken[0])[0];
assertEquals(TOKEN_NAME, serviceToken.getName());
assertArrayEquals(DATA, serviceToken.getData());
assertEquals(ENCRYPT, serviceToken.isEncrypted());
assertTrue(serviceToken.isBoundTo(USER_ID_TOKEN));
assertEquals(serviceTokens, msgBuilder.getServiceTokens());
}
@Test
public void noMasterTokenAddUserBoundPrimaryServiceToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, null, null);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertFalse(tokenBuilder.addUserBoundPrimaryServiceToken(TOKEN_NAME, DATA, ENCRYPT, COMPRESSION_ALGO));
final Set<ServiceToken> serviceTokens = tokenBuilder.getPrimaryServiceTokens();
assertEquals(0, serviceTokens.size());
assertEquals(0, msgBuilder.getServiceTokens().size());
}
@Test
public void noUserIdTokenAddUserBoundPrimaryServiceToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, null);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertFalse(tokenBuilder.addUserBoundPrimaryServiceToken(TOKEN_NAME, DATA, ENCRYPT, COMPRESSION_ALGO));
final Set<ServiceToken> serviceTokens = tokenBuilder.getPrimaryServiceTokens();
assertEquals(0, serviceTokens.size());
assertEquals(0, msgBuilder.getServiceTokens().size());
}
@Test
public void noCryptoContextAddUserBoundPrimaryServiceToken() throws MslEncodingException, MslCryptoException, MslException {
p2pMsgCtx.removeCryptoContext(TOKEN_NAME);
p2pMsgCtx.removeCryptoContext(EMPTY_TOKEN_NAME);
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertFalse(tokenBuilder.addUserBoundPrimaryServiceToken(TOKEN_NAME, DATA, ENCRYPT, COMPRESSION_ALGO));
final Set<ServiceToken> serviceTokens = tokenBuilder.getPrimaryServiceTokens();
assertEquals(0, serviceTokens.size());
assertEquals(0, msgBuilder.getServiceTokens().size());
}
@Test
public void excludeUnboundPrimaryServiceToken() throws MslEncodingException, MslCryptoException, MslMessageException, MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
final ServiceToken serviceToken = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, null, null, ENCRYPT, COMPRESSION_ALGO, new NullCryptoContext());
msgBuilder.addServiceToken(serviceToken);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertEquals(1, tokenBuilder.getPrimaryServiceTokens().size());
assertEquals(1, msgBuilder.getServiceTokens().size());
assertFalse(tokenBuilder.excludePrimaryServiceToken(TOKEN_NAME, true, false));
assertEquals(1, tokenBuilder.getPrimaryServiceTokens().size());
assertEquals(1, msgBuilder.getServiceTokens().size());
assertFalse(tokenBuilder.excludePrimaryServiceToken(TOKEN_NAME, true, true));
assertEquals(1, tokenBuilder.getPrimaryServiceTokens().size());
assertEquals(1, msgBuilder.getServiceTokens().size());
assertTrue(tokenBuilder.excludePrimaryServiceToken(TOKEN_NAME, false, false));
assertEquals(0, tokenBuilder.getPrimaryServiceTokens().size());
assertEquals(0, msgBuilder.getServiceTokens().size());
assertTrue(tokenBuilder.addPrimaryServiceToken(serviceToken));
assertEquals(1, tokenBuilder.getPrimaryServiceTokens().size());
assertEquals(1, msgBuilder.getServiceTokens().size());
assertTrue(tokenBuilder.excludePrimaryServiceToken(serviceToken));
assertEquals(0, tokenBuilder.getPrimaryServiceTokens().size());
assertEquals(0, msgBuilder.getServiceTokens().size());
}
@Test
public void excludeMasterBoundPrimaryServiceToken() throws MslEncodingException, MslCryptoException, MslMessageException, MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
final ServiceToken serviceToken = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, MASTER_TOKEN, null, ENCRYPT, COMPRESSION_ALGO, new NullCryptoContext());
msgBuilder.addServiceToken(serviceToken);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertEquals(1, tokenBuilder.getPrimaryServiceTokens().size());
assertEquals(1, msgBuilder.getServiceTokens().size());
assertFalse(tokenBuilder.excludePrimaryServiceToken(TOKEN_NAME, false, false));
assertEquals(1, tokenBuilder.getPrimaryServiceTokens().size());
assertEquals(1, msgBuilder.getServiceTokens().size());
assertFalse(tokenBuilder.excludePrimaryServiceToken(TOKEN_NAME, true, true));
assertEquals(1, tokenBuilder.getPrimaryServiceTokens().size());
assertEquals(1, msgBuilder.getServiceTokens().size());
assertTrue(tokenBuilder.excludePrimaryServiceToken(TOKEN_NAME, true, false));
assertEquals(0, tokenBuilder.getPrimaryServiceTokens().size());
assertEquals(0, msgBuilder.getServiceTokens().size());
assertTrue(tokenBuilder.addPrimaryServiceToken(serviceToken));
assertEquals(1, tokenBuilder.getPrimaryServiceTokens().size());
assertEquals(1, msgBuilder.getServiceTokens().size());
assertTrue(tokenBuilder.excludePrimaryServiceToken(serviceToken));
assertEquals(0, tokenBuilder.getPrimaryServiceTokens().size());
assertEquals(0, msgBuilder.getServiceTokens().size());
}
@Test
public void excludeUserBoundPrimaryServiceToken() throws MslEncodingException, MslCryptoException, MslMessageException, MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
final ServiceToken serviceToken = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPT, COMPRESSION_ALGO, new NullCryptoContext());
msgBuilder.addServiceToken(serviceToken);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertEquals(1, tokenBuilder.getPrimaryServiceTokens().size());
assertEquals(1, msgBuilder.getServiceTokens().size());
assertFalse(tokenBuilder.excludePrimaryServiceToken(TOKEN_NAME, false, false));
assertEquals(1, tokenBuilder.getPrimaryServiceTokens().size());
assertEquals(1, msgBuilder.getServiceTokens().size());
assertFalse(tokenBuilder.excludePrimaryServiceToken(TOKEN_NAME, true, false));
assertEquals(1, tokenBuilder.getPrimaryServiceTokens().size());
assertEquals(1, msgBuilder.getServiceTokens().size());
assertTrue(tokenBuilder.excludePrimaryServiceToken(TOKEN_NAME, true, true));
assertEquals(0, tokenBuilder.getPrimaryServiceTokens().size());
assertEquals(0, msgBuilder.getServiceTokens().size());
assertTrue(tokenBuilder.addPrimaryServiceToken(serviceToken));
assertEquals(1, tokenBuilder.getPrimaryServiceTokens().size());
assertEquals(1, msgBuilder.getServiceTokens().size());
assertTrue(tokenBuilder.excludePrimaryServiceToken(serviceToken));
assertEquals(0, tokenBuilder.getPrimaryServiceTokens().size());
assertEquals(0, msgBuilder.getServiceTokens().size());
}
@Test
public void excludeUnknownUserBoundPrimaryServiceToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertFalse(tokenBuilder.excludePrimaryServiceToken(TOKEN_NAME, false, false));
assertEquals(0, tokenBuilder.getPrimaryServiceTokens().size());
assertEquals(0, msgBuilder.getServiceTokens().size());
assertFalse(tokenBuilder.excludePrimaryServiceToken(TOKEN_NAME, true, false));
assertEquals(0, tokenBuilder.getPrimaryServiceTokens().size());
assertEquals(0, msgBuilder.getServiceTokens().size());
assertFalse(tokenBuilder.excludePrimaryServiceToken(TOKEN_NAME, true, true));
assertEquals(0, tokenBuilder.getPrimaryServiceTokens().size());
assertEquals(0, msgBuilder.getServiceTokens().size());
}
@Test
public void deleteUnboundPrimaryServiceToken() throws MslEncodingException, MslCryptoException, MslMessageException, MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
final ServiceToken serviceToken = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, null, null, ENCRYPT, COMPRESSION_ALGO, new NullCryptoContext());
msgBuilder.addServiceToken(serviceToken);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertEquals(1, tokenBuilder.getPrimaryServiceTokens().size());
assertFalse(tokenBuilder.deletePrimaryServiceToken(TOKEN_NAME, true, false));
assertFalse(tokenBuilder.deletePrimaryServiceToken(TOKEN_NAME, true, true));
assertTrue(tokenBuilder.deletePrimaryServiceToken(TOKEN_NAME, false, false));
final Set<ServiceToken> builderServiceTokens = tokenBuilder.getPrimaryServiceTokens();
assertEquals(1, builderServiceTokens.size());
final ServiceToken builderServiceToken = builderServiceTokens.toArray(new ServiceToken[0])[0];
assertEquals(TOKEN_NAME, builderServiceToken.getName());
assertEquals(0, builderServiceToken.getData().length);
assertFalse(builderServiceToken.isEncrypted());
assertFalse(builderServiceToken.isMasterTokenBound());
assertFalse(builderServiceToken.isUserIdTokenBound());
final Set<ServiceToken> msgServiceTokens = msgBuilder.getServiceTokens();
assertEquals(1, msgServiceTokens.size());
final ServiceToken msgServiceToken = msgServiceTokens.toArray(new ServiceToken[0])[0];
assertEquals(TOKEN_NAME, msgServiceToken.getName());
assertEquals(0, msgServiceToken.getData().length);
assertFalse(msgServiceToken.isEncrypted());
assertFalse(msgServiceToken.isMasterTokenBound());
assertFalse(msgServiceToken.isMasterTokenBound());
assertTrue(tokenBuilder.addPrimaryServiceToken(serviceToken));
assertTrue(tokenBuilder.deletePrimaryServiceToken(serviceToken));
assertEquals(1, tokenBuilder.getPrimaryServiceTokens().size());
assertEquals(1, msgBuilder.getServiceTokens().size());
}
@Test
public void deleteMasterBoundPrimaryServiceToken() throws MslEncodingException, MslCryptoException, MslMessageException, MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
final ServiceToken serviceToken = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, MASTER_TOKEN, null, ENCRYPT, COMPRESSION_ALGO, new NullCryptoContext());
msgBuilder.addServiceToken(serviceToken);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertEquals(1, tokenBuilder.getPrimaryServiceTokens().size());
assertFalse(tokenBuilder.deletePrimaryServiceToken(TOKEN_NAME, false, false));
assertFalse(tokenBuilder.deletePrimaryServiceToken(TOKEN_NAME, true, true));
assertTrue(tokenBuilder.deletePrimaryServiceToken(TOKEN_NAME, true, false));
final Set<ServiceToken> builderServiceTokens = tokenBuilder.getPrimaryServiceTokens();
assertEquals(1, builderServiceTokens.size());
final ServiceToken builderServiceToken = builderServiceTokens.toArray(new ServiceToken[0])[0];
assertEquals(TOKEN_NAME, builderServiceToken.getName());
assertEquals(0, builderServiceToken.getData().length);
assertFalse(builderServiceToken.isEncrypted());
assertTrue(builderServiceToken.isBoundTo(MASTER_TOKEN));
assertFalse(builderServiceToken.isUserIdTokenBound());
final Set<ServiceToken> msgServiceTokens = msgBuilder.getServiceTokens();
assertEquals(1, msgServiceTokens.size());
final ServiceToken msgServiceToken = msgServiceTokens.toArray(new ServiceToken[0])[0];
assertEquals(TOKEN_NAME, msgServiceToken.getName());
assertEquals(0, msgServiceToken.getData().length);
assertFalse(msgServiceToken.isEncrypted());
assertTrue(msgServiceToken.isBoundTo(MASTER_TOKEN));
assertFalse(msgServiceToken.isUserIdTokenBound());
assertTrue(tokenBuilder.addPrimaryServiceToken(serviceToken));
assertTrue(tokenBuilder.deletePrimaryServiceToken(serviceToken));
assertEquals(1, tokenBuilder.getPrimaryServiceTokens().size());
assertEquals(1, msgBuilder.getServiceTokens().size());
}
@Test
public void deleteUserBoundPrimaryServiceToken() throws MslEncodingException, MslCryptoException, MslMessageException, MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
final ServiceToken serviceToken = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPT, COMPRESSION_ALGO, new NullCryptoContext());
msgBuilder.addServiceToken(serviceToken);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertEquals(1, tokenBuilder.getPrimaryServiceTokens().size());
assertFalse(tokenBuilder.deletePrimaryServiceToken(TOKEN_NAME, false, false));
assertFalse(tokenBuilder.deletePrimaryServiceToken(TOKEN_NAME, true, false));
assertTrue(tokenBuilder.deletePrimaryServiceToken(TOKEN_NAME, true, true));
final Set<ServiceToken> builderServiceTokens = tokenBuilder.getPrimaryServiceTokens();
assertEquals(1, builderServiceTokens.size());
final ServiceToken builderServiceToken = builderServiceTokens.toArray(new ServiceToken[0])[0];
assertEquals(TOKEN_NAME, builderServiceToken.getName());
assertEquals(0, builderServiceToken.getData().length);
assertFalse(builderServiceToken.isEncrypted());
assertTrue(builderServiceToken.isBoundTo(MASTER_TOKEN));
assertTrue(builderServiceToken.isBoundTo(USER_ID_TOKEN));
final Set<ServiceToken> msgServiceTokens = msgBuilder.getServiceTokens();
assertEquals(1, msgServiceTokens.size());
final ServiceToken msgServiceToken = msgServiceTokens.toArray(new ServiceToken[0])[0];
assertEquals(TOKEN_NAME, msgServiceToken.getName());
assertEquals(0, msgServiceToken.getData().length);
assertFalse(msgServiceToken.isEncrypted());
assertTrue(msgServiceToken.isBoundTo(MASTER_TOKEN));
assertTrue(msgServiceToken.isBoundTo(USER_ID_TOKEN));
assertTrue(tokenBuilder.addPrimaryServiceToken(serviceToken));
assertTrue(tokenBuilder.deletePrimaryServiceToken(serviceToken));
assertEquals(1, tokenBuilder.getPrimaryServiceTokens().size());
assertEquals(1, msgBuilder.getServiceTokens().size());
}
@Test
public void deleteUnknownPrimaryServiceToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertFalse(tokenBuilder.deletePrimaryServiceToken(TOKEN_NAME, false, false));
assertFalse(tokenBuilder.deletePrimaryServiceToken(TOKEN_NAME, true, false));
assertFalse(tokenBuilder.deletePrimaryServiceToken(TOKEN_NAME, true, true));
}
@Test
public void addUnboundPeerServiceToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, null, null);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertTrue(tokenBuilder.getPeerServiceTokens().isEmpty());
assertTrue(tokenBuilder.addUnboundPeerServiceToken(TOKEN_NAME, DATA, ENCRYPT, COMPRESSION_ALGO));
final Set<ServiceToken> serviceTokens = tokenBuilder.getPeerServiceTokens();
assertEquals(1, serviceTokens.size());
final ServiceToken serviceToken = serviceTokens.toArray(new ServiceToken[0])[0];
assertEquals(TOKEN_NAME, serviceToken.getName());
assertArrayEquals(DATA, serviceToken.getData());
assertEquals(ENCRYPT, serviceToken.isEncrypted());
assertTrue(serviceToken.isUnbound());
assertEquals(serviceTokens, msgBuilder.getPeerServiceTokens());
}
@Test(expected = MslInternalException.class)
public void trustedNetAddUnboundPeerServiceToken() throws MslEncodingException, MslCryptoException, MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(trustedNetCtx, null, null);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(trustedNetCtx, trustedNetMsgCtx, msgBuilder);
tokenBuilder.addUnboundPeerServiceToken(TOKEN_NAME, DATA, ENCRYPT, COMPRESSION_ALGO);
}
@Test
public void noCryptoContextAddUnboundPeerServiceToken() throws MslException {
p2pMsgCtx.removeCryptoContext(TOKEN_NAME);
p2pMsgCtx.removeCryptoContext(EMPTY_TOKEN_NAME);
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, null, null);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertFalse(tokenBuilder.addUnboundPeerServiceToken(TOKEN_NAME, DATA, ENCRYPT, COMPRESSION_ALGO));
final Set<ServiceToken> serviceTokens = tokenBuilder.getPeerServiceTokens();
assertEquals(0, serviceTokens.size());
assertEquals(0, msgBuilder.getServiceTokens().size());
}
@Test
public void addMasterBoundPeerServiceToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, null);
msgBuilder.setPeerAuthTokens(PEER_MASTER_TOKEN, null);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertTrue(tokenBuilder.getPeerServiceTokens().isEmpty());
assertTrue(tokenBuilder.addMasterBoundPeerServiceToken(TOKEN_NAME, DATA, ENCRYPT, COMPRESSION_ALGO));
final Set<ServiceToken> serviceTokens = tokenBuilder.getPeerServiceTokens();
assertEquals(1, serviceTokens.size());
final ServiceToken serviceToken = serviceTokens.toArray(new ServiceToken[0])[0];
assertEquals(TOKEN_NAME, serviceToken.getName());
assertArrayEquals(DATA, serviceToken.getData());
assertEquals(ENCRYPT, serviceToken.isEncrypted());
assertTrue(serviceToken.isBoundTo(PEER_MASTER_TOKEN));
assertEquals(serviceTokens, msgBuilder.getPeerServiceTokens());
}
@Test
public void noMasterTokenAddMasterBoundPeerServiceToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, null, null);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertFalse(tokenBuilder.addMasterBoundPeerServiceToken(TOKEN_NAME, DATA, ENCRYPT, COMPRESSION_ALGO));
final Set<ServiceToken> serviceTokens = tokenBuilder.getPeerServiceTokens();
assertEquals(0, serviceTokens.size());
assertEquals(0, msgBuilder.getServiceTokens().size());
}
@Test
public void noCryptoContextAddMasterBoundPeerServiceToken() throws MslEncodingException, MslCryptoException, MslException {
p2pMsgCtx.removeCryptoContext(TOKEN_NAME);
p2pMsgCtx.removeCryptoContext(EMPTY_TOKEN_NAME);
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, null);
msgBuilder.setPeerAuthTokens(PEER_MASTER_TOKEN, null);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertFalse(tokenBuilder.addMasterBoundPeerServiceToken(TOKEN_NAME, DATA, ENCRYPT, COMPRESSION_ALGO));
final Set<ServiceToken> serviceTokens = tokenBuilder.getPeerServiceTokens();
assertEquals(0, serviceTokens.size());
assertEquals(0, msgBuilder.getServiceTokens().size());
}
@Test
public void trustedNetAddMasterBoundPeerServiceToken() throws MslEncodingException, MslCryptoException, MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, null);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(trustedNetCtx, trustedNetMsgCtx, msgBuilder);
assertFalse(tokenBuilder.addMasterBoundPeerServiceToken(TOKEN_NAME, DATA, ENCRYPT, COMPRESSION_ALGO));
}
@Test
public void addUserBoundPeerServiceToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
msgBuilder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertTrue(tokenBuilder.getPeerServiceTokens().isEmpty());
assertTrue(tokenBuilder.addUserBoundPeerServiceToken(TOKEN_NAME, DATA, ENCRYPT, COMPRESSION_ALGO));
final Set<ServiceToken> serviceTokens = tokenBuilder.getPeerServiceTokens();
assertEquals(1, serviceTokens.size());
final ServiceToken serviceToken = serviceTokens.toArray(new ServiceToken[0])[0];
assertEquals(TOKEN_NAME, serviceToken.getName());
assertArrayEquals(DATA, serviceToken.getData());
assertEquals(ENCRYPT, serviceToken.isEncrypted());
assertTrue(serviceToken.isBoundTo(USER_ID_TOKEN));
assertEquals(serviceTokens, msgBuilder.getPeerServiceTokens());
}
@Test
public void noMasterTokenAddUserBoundPeerServiceToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, null, null);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertFalse(tokenBuilder.addUserBoundPeerServiceToken(TOKEN_NAME, DATA, ENCRYPT, COMPRESSION_ALGO));
final Set<ServiceToken> serviceTokens = tokenBuilder.getPeerServiceTokens();
assertEquals(0, serviceTokens.size());
assertEquals(0, msgBuilder.getServiceTokens().size());
}
@Test
public void noUserIdTokenAddUserBoundPeerServiceToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, null);
msgBuilder.setPeerAuthTokens(PEER_MASTER_TOKEN, null);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertFalse(tokenBuilder.addUserBoundPeerServiceToken(TOKEN_NAME, DATA, ENCRYPT, COMPRESSION_ALGO));
final Set<ServiceToken> serviceTokens = tokenBuilder.getPeerServiceTokens();
assertEquals(0, serviceTokens.size());
assertEquals(0, msgBuilder.getServiceTokens().size());
}
@Test
public void noCryptoContextAddUserBoundPeerServiceToken() throws MslEncodingException, MslCryptoException, MslException {
p2pMsgCtx.removeCryptoContext(TOKEN_NAME);
p2pMsgCtx.removeCryptoContext(EMPTY_TOKEN_NAME);
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
msgBuilder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertFalse(tokenBuilder.addUserBoundPeerServiceToken(TOKEN_NAME, DATA, ENCRYPT, COMPRESSION_ALGO));
final Set<ServiceToken> serviceTokens = tokenBuilder.getPeerServiceTokens();
assertEquals(0, serviceTokens.size());
assertEquals(0, msgBuilder.getServiceTokens().size());
}
@Test
public void trustedNetAddUserBoundPeerServiceToken() throws MslEncodingException, MslCryptoException, MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(trustedNetCtx, trustedNetMsgCtx, msgBuilder);
assertFalse(tokenBuilder.addUserBoundPeerServiceToken(TOKEN_NAME, DATA, ENCRYPT, COMPRESSION_ALGO));
}
@Test
public void excludeUnboundPeerServiceToken() throws MslEncodingException, MslCryptoException, MslMessageException, MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
msgBuilder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final ServiceToken serviceToken = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, null, null, ENCRYPT, COMPRESSION_ALGO, new NullCryptoContext());
msgBuilder.addPeerServiceToken(serviceToken);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertEquals(1, tokenBuilder.getPeerServiceTokens().size());
assertEquals(1, msgBuilder.getPeerServiceTokens().size());
assertFalse(tokenBuilder.excludePeerServiceToken(TOKEN_NAME, true, false));
assertEquals(1, tokenBuilder.getPeerServiceTokens().size());
assertEquals(1, msgBuilder.getPeerServiceTokens().size());
assertFalse(tokenBuilder.excludePeerServiceToken(TOKEN_NAME, true, true));
assertEquals(1, tokenBuilder.getPeerServiceTokens().size());
assertEquals(1, msgBuilder.getPeerServiceTokens().size());
assertTrue(tokenBuilder.excludePeerServiceToken(TOKEN_NAME, false, false));
assertEquals(0, tokenBuilder.getPeerServiceTokens().size());
assertEquals(0, msgBuilder.getPeerServiceTokens().size());
assertTrue(tokenBuilder.addPeerServiceToken(serviceToken));
assertEquals(1, tokenBuilder.getPeerServiceTokens().size());
assertEquals(1, msgBuilder.getPeerServiceTokens().size());
assertTrue(tokenBuilder.excludePeerServiceToken(serviceToken));
assertEquals(0, tokenBuilder.getPeerServiceTokens().size());
assertEquals(0, msgBuilder.getPeerServiceTokens().size());
}
@Test
public void excludeMasterBoundPeerServiceToken() throws MslEncodingException, MslCryptoException, MslMessageException, MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
msgBuilder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final ServiceToken serviceToken = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, PEER_MASTER_TOKEN, null, ENCRYPT, COMPRESSION_ALGO, new NullCryptoContext());
msgBuilder.addPeerServiceToken(serviceToken);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertEquals(1, tokenBuilder.getPeerServiceTokens().size());
assertEquals(1, msgBuilder.getPeerServiceTokens().size());
assertFalse(tokenBuilder.excludePeerServiceToken(TOKEN_NAME, false, false));
assertEquals(1, tokenBuilder.getPeerServiceTokens().size());
assertEquals(1, msgBuilder.getPeerServiceTokens().size());
assertFalse(tokenBuilder.excludePeerServiceToken(TOKEN_NAME, true, true));
assertEquals(1, tokenBuilder.getPeerServiceTokens().size());
assertEquals(1, msgBuilder.getPeerServiceTokens().size());
assertTrue(tokenBuilder.excludePeerServiceToken(TOKEN_NAME, true, false));
assertEquals(0, tokenBuilder.getPeerServiceTokens().size());
assertEquals(0, msgBuilder.getPeerServiceTokens().size());
assertTrue(tokenBuilder.addPeerServiceToken(serviceToken));
assertEquals(1, tokenBuilder.getPeerServiceTokens().size());
assertEquals(1, msgBuilder.getPeerServiceTokens().size());
assertTrue(tokenBuilder.excludePeerServiceToken(serviceToken));
assertEquals(0, tokenBuilder.getPeerServiceTokens().size());
assertEquals(0, msgBuilder.getPeerServiceTokens().size());
}
@Test
public void excludeUserBoundPeerServiceToken() throws MslEncodingException, MslCryptoException, MslMessageException, MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
msgBuilder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final ServiceToken serviceToken = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, ENCRYPT, COMPRESSION_ALGO, new NullCryptoContext());
msgBuilder.addPeerServiceToken(serviceToken);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertEquals(1, tokenBuilder.getPeerServiceTokens().size());
assertEquals(1, msgBuilder.getPeerServiceTokens().size());
assertFalse(tokenBuilder.excludePeerServiceToken(TOKEN_NAME, false, false));
assertEquals(1, tokenBuilder.getPeerServiceTokens().size());
assertEquals(1, msgBuilder.getPeerServiceTokens().size());
assertFalse(tokenBuilder.excludePeerServiceToken(TOKEN_NAME, true, false));
assertEquals(1, tokenBuilder.getPeerServiceTokens().size());
assertEquals(1, msgBuilder.getPeerServiceTokens().size());
assertTrue(tokenBuilder.excludePeerServiceToken(TOKEN_NAME, true, true));
assertEquals(0, tokenBuilder.getPeerServiceTokens().size());
assertEquals(0, msgBuilder.getPeerServiceTokens().size());
assertTrue(tokenBuilder.addPeerServiceToken(serviceToken));
assertEquals(1, tokenBuilder.getPeerServiceTokens().size());
assertEquals(1, msgBuilder.getPeerServiceTokens().size());
assertTrue(tokenBuilder.excludePeerServiceToken(serviceToken));
assertEquals(0, tokenBuilder.getPeerServiceTokens().size());
assertEquals(0, msgBuilder.getPeerServiceTokens().size());
}
@Test
public void excludeUnknownPeerServiceToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
msgBuilder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertFalse(tokenBuilder.excludePeerServiceToken(TOKEN_NAME, false, false));
assertEquals(0, tokenBuilder.getPeerServiceTokens().size());
assertEquals(0, msgBuilder.getPeerServiceTokens().size());
assertFalse(tokenBuilder.excludePeerServiceToken(TOKEN_NAME, true, false));
assertEquals(0, tokenBuilder.getPeerServiceTokens().size());
assertEquals(0, msgBuilder.getPeerServiceTokens().size());
assertFalse(tokenBuilder.excludePeerServiceToken(TOKEN_NAME, true, true));
assertEquals(0, tokenBuilder.getPeerServiceTokens().size());
assertEquals(0, msgBuilder.getPeerServiceTokens().size());
}
@Test
public void deleteUnboundPeerServiceToken() throws MslEncodingException, MslCryptoException, MslMessageException, MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
msgBuilder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final ServiceToken serviceToken = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, null, null, ENCRYPT, COMPRESSION_ALGO, new NullCryptoContext());
msgBuilder.addPeerServiceToken(serviceToken);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertEquals(1, tokenBuilder.getPeerServiceTokens().size());
assertFalse(tokenBuilder.deletePeerServiceToken(TOKEN_NAME, true, false));
assertFalse(tokenBuilder.deletePeerServiceToken(TOKEN_NAME, true, true));
assertTrue(tokenBuilder.deletePeerServiceToken(TOKEN_NAME, false, false));
final Set<ServiceToken> builderServiceTokens = tokenBuilder.getPeerServiceTokens();
assertEquals(1, builderServiceTokens.size());
final ServiceToken builderServiceToken = builderServiceTokens.toArray(new ServiceToken[0])[0];
assertEquals(TOKEN_NAME, builderServiceToken.getName());
assertEquals(0, builderServiceToken.getData().length);
assertFalse(builderServiceToken.isEncrypted());
assertFalse(builderServiceToken.isMasterTokenBound());
assertFalse(builderServiceToken.isUserIdTokenBound());
final Set<ServiceToken> msgServiceTokens = msgBuilder.getPeerServiceTokens();
assertEquals(1, msgServiceTokens.size());
final ServiceToken msgServiceToken = msgServiceTokens.toArray(new ServiceToken[0])[0];
assertEquals(TOKEN_NAME, msgServiceToken.getName());
assertEquals(0, msgServiceToken.getData().length);
assertFalse(msgServiceToken.isEncrypted());
assertFalse(msgServiceToken.isMasterTokenBound());
assertFalse(msgServiceToken.isUserIdTokenBound());
assertTrue(tokenBuilder.addPeerServiceToken(serviceToken));
assertTrue(tokenBuilder.deletePeerServiceToken(serviceToken));
assertEquals(1, tokenBuilder.getPeerServiceTokens().size());
assertEquals(1, msgBuilder.getPeerServiceTokens().size());
}
@Test
public void deleteMasterBoundPeerServiceToken() throws MslEncodingException, MslCryptoException, MslMessageException, MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
msgBuilder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final ServiceToken serviceToken = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, PEER_MASTER_TOKEN, null, ENCRYPT, COMPRESSION_ALGO, new NullCryptoContext());
msgBuilder.addPeerServiceToken(serviceToken);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertEquals(1, tokenBuilder.getPeerServiceTokens().size());
assertFalse(tokenBuilder.deletePeerServiceToken(TOKEN_NAME, false, false));
assertFalse(tokenBuilder.deletePeerServiceToken(TOKEN_NAME, true, true));
assertTrue(tokenBuilder.deletePeerServiceToken(TOKEN_NAME, true, false));
final Set<ServiceToken> builderServiceTokens = tokenBuilder.getPeerServiceTokens();
assertEquals(1, builderServiceTokens.size());
final ServiceToken builderServiceToken = builderServiceTokens.toArray(new ServiceToken[0])[0];
assertEquals(TOKEN_NAME, builderServiceToken.getName());
assertEquals(0, builderServiceToken.getData().length);
assertFalse(builderServiceToken.isEncrypted());
assertTrue(builderServiceToken.isBoundTo(PEER_MASTER_TOKEN));
assertFalse(builderServiceToken.isUserIdTokenBound());
final Set<ServiceToken> msgServiceTokens = msgBuilder.getPeerServiceTokens();
assertEquals(1, msgServiceTokens.size());
final ServiceToken msgServiceToken = msgServiceTokens.toArray(new ServiceToken[0])[0];
assertEquals(TOKEN_NAME, msgServiceToken.getName());
assertEquals(0, msgServiceToken.getData().length);
assertFalse(msgServiceToken.isEncrypted());
assertTrue(msgServiceToken.isBoundTo(PEER_MASTER_TOKEN));
assertFalse(msgServiceToken.isUserIdTokenBound());
assertTrue(tokenBuilder.addPeerServiceToken(serviceToken));
assertTrue(tokenBuilder.deletePeerServiceToken(serviceToken));
assertEquals(1, tokenBuilder.getPeerServiceTokens().size());
assertEquals(1, msgBuilder.getPeerServiceTokens().size());
}
@Test
public void deleteUserBoundPeerServiceToken() throws MslEncodingException, MslCryptoException, MslMessageException, MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
msgBuilder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final ServiceToken serviceToken = new ServiceToken(p2pCtx, TOKEN_NAME, DATA, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, ENCRYPT, COMPRESSION_ALGO, new NullCryptoContext());
msgBuilder.addPeerServiceToken(serviceToken);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertEquals(1, tokenBuilder.getPeerServiceTokens().size());
assertFalse(tokenBuilder.deletePeerServiceToken(TOKEN_NAME, false, false));
assertFalse(tokenBuilder.deletePeerServiceToken(TOKEN_NAME, true, false));
assertTrue(tokenBuilder.deletePeerServiceToken(TOKEN_NAME, true, true));
final Set<ServiceToken> builderServiceTokens = tokenBuilder.getPeerServiceTokens();
assertEquals(1, builderServiceTokens.size());
final ServiceToken builderServiceToken = builderServiceTokens.toArray(new ServiceToken[0])[0];
assertEquals(TOKEN_NAME, builderServiceToken.getName());
assertEquals(0, builderServiceToken.getData().length);
assertFalse(builderServiceToken.isEncrypted());
assertTrue(builderServiceToken.isBoundTo(PEER_MASTER_TOKEN));
assertTrue(builderServiceToken.isBoundTo(PEER_USER_ID_TOKEN));
final Set<ServiceToken> msgServiceTokens = msgBuilder.getPeerServiceTokens();
assertEquals(1, msgServiceTokens.size());
final ServiceToken msgServiceToken = msgServiceTokens.toArray(new ServiceToken[0])[0];
assertEquals(TOKEN_NAME, msgServiceToken.getName());
assertEquals(0, msgServiceToken.getData().length);
assertFalse(msgServiceToken.isEncrypted());
assertTrue(msgServiceToken.isBoundTo(PEER_MASTER_TOKEN));
assertTrue(msgServiceToken.isBoundTo(PEER_USER_ID_TOKEN));
assertTrue(tokenBuilder.addPeerServiceToken(serviceToken));
assertTrue(tokenBuilder.deletePeerServiceToken(serviceToken));
assertEquals(1, tokenBuilder.getPeerServiceTokens().size());
assertEquals(1, msgBuilder.getPeerServiceTokens().size());
}
@Test
public void deleteUnknownPeerServiceToken() throws MslException {
final MessageBuilder msgBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
msgBuilder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final MessageServiceTokenBuilder tokenBuilder = new MessageServiceTokenBuilder(p2pCtx, p2pMsgCtx, msgBuilder);
assertFalse(tokenBuilder.deletePrimaryServiceToken(TOKEN_NAME, false, false));
assertFalse(tokenBuilder.deletePrimaryServiceToken(TOKEN_NAME, true, false));
assertFalse(tokenBuilder.deletePrimaryServiceToken(TOKEN_NAME, true, true));
}
}
| 9,954 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/msg/PayloadChunkTest.java | /**
* Copyright (c) 2012-2018 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.msg;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.util.Random;
import java.util.zip.GZIPInputStream;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslConstants;
import com.netflix.msl.MslConstants.CompressionAlgorithm;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.MslMessageException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.crypto.JcaAlgorithm;
import com.netflix.msl.crypto.SymmetricCryptoContext;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.io.LZWInputStream;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.util.Base64;
import com.netflix.msl.util.IOUtils;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* Payload chunk unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class PayloadChunkTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** RAW data file. */
private static final String DATAFILE = "/pg1112.txt";
/** Key payload. */
private static final String KEY_PAYLOAD = "payload";
/** Key signature. */
private static final String KEY_SIGNATURE = "signature";
// payload
/** Key sequence number. */
private static final String KEY_SEQUENCE_NUMBER = "sequencenumber";
/** Key message ID. */
private static final String KEY_MESSAGE_ID = "messageid";
/** Key end of message. */
private static final String KEY_END_OF_MESSAGE = "endofmsg";
/** Key compression algorithm. */
private static final String KEY_COMPRESSION_ALGORITHM = "compressionalgo";
/** Key encrypted data. */
private static final String KEY_DATA = "data";
/**
* Uncompress the provided data using the specified compression algorithm.
*
* @param compressionAlgo the compression algorithm.
* @param data the data to uncompress.
* @return the uncompressed data.
* @throws MslException if there is an error uncompressing the data.
*/
private static byte[] uncompress(final CompressionAlgorithm compressionAlgo, final byte[] data) throws MslException {
try {
switch (compressionAlgo) {
case GZIP:
{
final ByteArrayInputStream bais = new ByteArrayInputStream(data);
final GZIPInputStream gzis = new GZIPInputStream(bais);
return IOUtils.readAllBytes(gzis);
}
case LZW:
{
final ByteArrayInputStream bais = new ByteArrayInputStream(data);
final LZWInputStream lzwis = new LZWInputStream(bais);
return IOUtils.readAllBytes(lzwis);
}
default:
throw new MslException(MslError.UNSUPPORTED_COMPRESSION, compressionAlgo.name());
}
} catch (final IOException e) {
throw new MslException(MslError.UNCOMPRESSION_ERROR, "algo " + compressionAlgo.name() + " data " + Base64.encode(data), e);
}
}
private static final String CRYPTO_CONTEXT_ID = "cryptoContextId";
private static SecretKey ENCRYPTION_KEY;
private static SecretKey HMAC_KEY;
/** MSL context. */
private static MslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
/** Random. */
private static final Random random = new Random();
private static final long SEQ_NO = 1;
private static final long MSG_ID = 42;
private static final boolean END_OF_MSG = false;
private static final byte[] DATA = "We have to use some data that is compressible, otherwise payloads will not always use the compression we request.".getBytes();
private static ICryptoContext CRYPTO_CONTEXT;
/** Raw data. */
private static byte[] rawdata;
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException, IOException {
ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = ctx.getMslEncoderFactory();
final byte[] encryptionBytes = new byte[16];
final byte[] hmacBytes = new byte[32];
random.nextBytes(encryptionBytes);
random.nextBytes(hmacBytes);
ENCRYPTION_KEY = new SecretKeySpec(encryptionBytes, JcaAlgorithm.AES);
HMAC_KEY = new SecretKeySpec(hmacBytes, JcaAlgorithm.HMAC_SHA256);
CRYPTO_CONTEXT = new SymmetricCryptoContext(ctx, CRYPTO_CONTEXT_ID, ENCRYPTION_KEY, HMAC_KEY, null);
// Load the raw file.
rawdata = IOUtils.readResource(DATAFILE);
}
@AfterClass
public static void teardown() {
CRYPTO_CONTEXT = null;
encoder = null;
ctx = null;
}
@Test
public void ctors() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, END_OF_MSG, null, DATA, CRYPTO_CONTEXT);
assertEquals(END_OF_MSG, chunk.isEndOfMessage());
assertArrayEquals(DATA, chunk.getData());
assertNull(chunk.getCompressionAlgo());
assertEquals(MSG_ID, chunk.getMessageId());
assertEquals(SEQ_NO, chunk.getSequenceNumber());
final byte[] encode = chunk.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final PayloadChunk moChunk = new PayloadChunk(ctx, encoder.parseObject(encode), CRYPTO_CONTEXT);
assertEquals(chunk.isEndOfMessage(), moChunk.isEndOfMessage());
assertArrayEquals(chunk.getData(), moChunk.getData());
assertEquals(chunk.getMessageId(), moChunk.getMessageId());
assertEquals(chunk.getSequenceNumber(), moChunk.getSequenceNumber());
final byte[] moEncode = moChunk.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
// The two payload chunk encodings will not be equal because the
// ciphertext and signature will be generated on-demand.
}
@Test(expected = MslInternalException.class)
public void negativeSequenceNumberCtor() throws MslEncodingException, MslCryptoException, MslException {
final long sequenceNumber = -1;
new PayloadChunk(ctx, sequenceNumber, MSG_ID, END_OF_MSG, null, DATA, CRYPTO_CONTEXT);
}
@Test(expected = MslInternalException.class)
public void tooLargeSequenceNumberCtor() throws MslEncodingException, MslCryptoException, MslException {
final long sequenceNumber = MslConstants.MAX_LONG_VALUE + 1;
new PayloadChunk(ctx, sequenceNumber, MSG_ID, END_OF_MSG, null, DATA, CRYPTO_CONTEXT);
}
@Test(expected = MslInternalException.class)
public void negativeMessageIdCtor() throws MslEncodingException, MslCryptoException, MslException {
final long messageId = -1;
new PayloadChunk(ctx, SEQ_NO, messageId, END_OF_MSG, null, DATA, CRYPTO_CONTEXT);
}
@Test(expected = MslInternalException.class)
public void tooLargeMessageIdCtor() throws MslEncodingException, MslCryptoException, MslException {
final long messageId = MslConstants.MAX_LONG_VALUE + 1;
new PayloadChunk(ctx, SEQ_NO, messageId, END_OF_MSG, null, DATA, CRYPTO_CONTEXT);
}
@Test
public void mslObject() throws MslEncodingException, MslException, MslEncoderException {
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, END_OF_MSG, null, DATA, CRYPTO_CONTEXT);
final byte[] encode = chunk.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final MslObject mo = encoder.parseObject(encode);
final byte[] ciphertext = mo.getBytes(KEY_PAYLOAD);
final byte[] signature = mo.getBytes(KEY_SIGNATURE);
assertTrue(CRYPTO_CONTEXT.verify(ciphertext, signature, encoder));
final byte[] payload = CRYPTO_CONTEXT.decrypt(ciphertext, encoder);
final MslObject payloadMo = encoder.parseObject(payload);
assertEquals(SEQ_NO, payloadMo.getLong(KEY_SEQUENCE_NUMBER));
assertEquals(MSG_ID, payloadMo.getLong(KEY_MESSAGE_ID));
assertEquals(END_OF_MSG, payloadMo.optBoolean(KEY_END_OF_MESSAGE));
assertFalse(payloadMo.has(KEY_COMPRESSION_ALGORITHM));
assertArrayEquals(DATA, payloadMo.getBytes(KEY_DATA));
}
@Test
public void gzipCtors() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, END_OF_MSG, CompressionAlgorithm.GZIP, DATA, CRYPTO_CONTEXT);
assertEquals(END_OF_MSG, chunk.isEndOfMessage());
assertArrayEquals(DATA, chunk.getData());
assertEquals(CompressionAlgorithm.GZIP, chunk.getCompressionAlgo());
assertEquals(MSG_ID, chunk.getMessageId());
assertEquals(SEQ_NO, chunk.getSequenceNumber());
final byte[] encode = chunk.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final PayloadChunk moChunk = new PayloadChunk(ctx, encoder.parseObject(encode), CRYPTO_CONTEXT);
assertEquals(chunk.isEndOfMessage(), moChunk.isEndOfMessage());
assertArrayEquals(chunk.getData(), moChunk.getData());
assertEquals(chunk.getMessageId(), moChunk.getMessageId());
assertEquals(chunk.getSequenceNumber(), moChunk.getSequenceNumber());
final byte[] moEncode = moChunk.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
// The two payload chunk encodings will not be equal because the
// ciphertext and signature will be generated on-demand.
}
@Test
public void gzipMslObject() throws MslEncoderException, MslEncodingException, MslCryptoException, MslException {
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, END_OF_MSG, CompressionAlgorithm.GZIP, DATA, CRYPTO_CONTEXT);
final byte[] encode = chunk.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final MslObject mo = encoder.parseObject(encode);
final byte[] ciphertext = mo.getBytes(KEY_PAYLOAD);
final byte[] signature = mo.getBytes(KEY_SIGNATURE);
assertTrue(CRYPTO_CONTEXT.verify(ciphertext, signature, encoder));
final byte[] payload = CRYPTO_CONTEXT.decrypt(ciphertext, encoder);
final MslObject payloadMo = encoder.parseObject(payload);
assertEquals(SEQ_NO, payloadMo.getLong(KEY_SEQUENCE_NUMBER));
assertEquals(MSG_ID, payloadMo.getLong(KEY_MESSAGE_ID));
assertEquals(END_OF_MSG, payloadMo.optBoolean(KEY_END_OF_MESSAGE));
assertEquals(CompressionAlgorithm.GZIP.toString(), payloadMo.getString(KEY_COMPRESSION_ALGORITHM));
final byte[] gzipped = payloadMo.getBytes(KEY_DATA);
final byte[] plaintext = uncompress(CompressionAlgorithm.GZIP, gzipped);
assertArrayEquals(DATA, plaintext);
}
@Test
public void lzwCtors() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, END_OF_MSG, CompressionAlgorithm.LZW, DATA, CRYPTO_CONTEXT);
assertEquals(END_OF_MSG, chunk.isEndOfMessage());
assertArrayEquals(DATA, chunk.getData());
assertEquals(CompressionAlgorithm.LZW, chunk.getCompressionAlgo());
assertEquals(MSG_ID, chunk.getMessageId());
assertEquals(SEQ_NO, chunk.getSequenceNumber());
final byte[] encode = chunk.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final PayloadChunk moChunk = new PayloadChunk(ctx, encoder.parseObject(encode), CRYPTO_CONTEXT);
assertEquals(chunk.isEndOfMessage(), moChunk.isEndOfMessage());
assertArrayEquals(chunk.getData(), moChunk.getData());
assertEquals(chunk.getMessageId(), moChunk.getMessageId());
assertEquals(chunk.getSequenceNumber(), moChunk.getSequenceNumber());
final byte[] moEncode = moChunk.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
// The two payload chunk encodings will not be equal because the
// ciphertext and signature will be generated on-demand.
}
@Test
public void lzwMslObject() throws MslEncoderException, MslEncodingException, MslCryptoException, MslException {
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, END_OF_MSG, CompressionAlgorithm.LZW, DATA, CRYPTO_CONTEXT);
final byte[] encode = chunk.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final MslObject mo = encoder.parseObject(encode);
final byte[] ciphertext = mo.getBytes(KEY_PAYLOAD);
final byte[] signature = mo.getBytes(KEY_SIGNATURE);
assertTrue(CRYPTO_CONTEXT.verify(ciphertext, signature, encoder));
final byte[] payload = CRYPTO_CONTEXT.decrypt(ciphertext, encoder);
final MslObject payloadMo = encoder.parseObject(payload);
assertEquals(SEQ_NO, payloadMo.getLong(KEY_SEQUENCE_NUMBER));
assertEquals(MSG_ID, payloadMo.getLong(KEY_MESSAGE_ID));
assertEquals(END_OF_MSG, payloadMo.optBoolean(KEY_END_OF_MESSAGE));
assertEquals(CompressionAlgorithm.LZW.toString(), payloadMo.getString(KEY_COMPRESSION_ALGORITHM));
final byte[] gzipped = payloadMo.getBytes(KEY_DATA);
final byte[] plaintext = uncompress(CompressionAlgorithm.LZW, gzipped);
assertArrayEquals(DATA, plaintext);
}
public void mismatchedCryptoContextId() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
final ICryptoContext cryptoContextA = new SymmetricCryptoContext(ctx, CRYPTO_CONTEXT_ID + "A", ENCRYPTION_KEY, HMAC_KEY, null);
final ICryptoContext cryptoContextB = new SymmetricCryptoContext(ctx, CRYPTO_CONTEXT_ID + "B", ENCRYPTION_KEY, HMAC_KEY, null);
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, END_OF_MSG, CompressionAlgorithm.GZIP, DATA, cryptoContextA);
final MslObject mo = MslTestUtils.toMslObject(encoder, chunk);
final PayloadChunk moChunk = new PayloadChunk(ctx, mo, cryptoContextB);
assertEquals(chunk.isEndOfMessage(), moChunk.isEndOfMessage());
assertArrayEquals(chunk.getData(), moChunk.getData());
assertEquals(chunk.getMessageId(), moChunk.getMessageId());
assertEquals(chunk.getSequenceNumber(), moChunk.getSequenceNumber());
final byte[] moEncode = moChunk.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
// The two payload chunk encodings will not be equal because the
// ciphertext and signature will be generated on-demand.
}
@Test(expected = MslCryptoException.class)
public void mismatchedCryptoContextEncryptionKey() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
final byte[] encryptionBytesA = new byte[16];
final byte[] encryptionBytesB = new byte[16];
random.nextBytes(encryptionBytesA);
random.nextBytes(encryptionBytesB);
final SecretKey encryptionKeyA = new SecretKeySpec(encryptionBytesA, JcaAlgorithm.AES);
final SecretKey encryptionKeyB = new SecretKeySpec(encryptionBytesB, JcaAlgorithm.AES);
final ICryptoContext cryptoContextA = new SymmetricCryptoContext(ctx, CRYPTO_CONTEXT_ID, encryptionKeyA, HMAC_KEY, null);
final ICryptoContext cryptoContextB = new SymmetricCryptoContext(ctx, CRYPTO_CONTEXT_ID, encryptionKeyB, HMAC_KEY, null);
// Mismatched encryption keys will just result in the wrong data.
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, END_OF_MSG, CompressionAlgorithm.GZIP, DATA, cryptoContextA);
final MslObject mo = MslTestUtils.toMslObject(encoder, chunk);
// Sometimes decryption will succeed so check for a crypto exception
// or encoding exception. Both are OK.
try {
new PayloadChunk(ctx, mo, cryptoContextB);
} catch (final MslEncodingException e) {
throw new MslCryptoException(MslError.DECRYPT_ERROR, e);
}
}
@Test
public void mismatchedCryptoContextSignKey() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.PAYLOAD_VERIFICATION_FAILED);
final byte[] hmacBytesA = new byte[32];
final byte[] hmacBytesB = new byte[32];
random.nextBytes(hmacBytesA);
random.nextBytes(hmacBytesB);
final SecretKey hmacKeyA = new SecretKeySpec(hmacBytesA, JcaAlgorithm.HMAC_SHA256);
final SecretKey hmacKeyB = new SecretKeySpec(hmacBytesB, JcaAlgorithm.HMAC_SHA256);
final ICryptoContext cryptoContextA = new SymmetricCryptoContext(ctx, CRYPTO_CONTEXT_ID, ENCRYPTION_KEY, hmacKeyA, null);
final ICryptoContext cryptoContextB = new SymmetricCryptoContext(ctx, CRYPTO_CONTEXT_ID, ENCRYPTION_KEY, hmacKeyB, null);
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, END_OF_MSG, CompressionAlgorithm.GZIP, DATA, cryptoContextA);
final MslObject mo = MslTestUtils.toMslObject(encoder, chunk);
new PayloadChunk(ctx, mo, cryptoContextB);
}
@Test
public void incorrectSignature() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.PAYLOAD_VERIFICATION_FAILED);
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, END_OF_MSG, CompressionAlgorithm.GZIP, DATA, CRYPTO_CONTEXT);
final MslObject mo = MslTestUtils.toMslObject(encoder, chunk);
final byte[] signature = new byte[32];
random.nextBytes(signature);
mo.put(KEY_SIGNATURE, signature);
new PayloadChunk(ctx, mo, CRYPTO_CONTEXT);
}
@Test
public void missingPayload() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, END_OF_MSG, CompressionAlgorithm.GZIP, DATA, CRYPTO_CONTEXT);
final MslObject mo = MslTestUtils.toMslObject(encoder, chunk);
assertNotNull(mo.remove(KEY_PAYLOAD));
new PayloadChunk(ctx, mo, CRYPTO_CONTEXT);
}
@Test
public void invalidPayload() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, END_OF_MSG, CompressionAlgorithm.GZIP, DATA, CRYPTO_CONTEXT);
final MslObject mo = MslTestUtils.toMslObject(encoder, chunk);
mo.put(KEY_PAYLOAD, "x");
new PayloadChunk(ctx, mo, CRYPTO_CONTEXT);
}
@Test(expected = MslCryptoException.class)
public void corruptPayload() throws MslEncoderException, MslEncodingException, MslCryptoException, MslException {
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, END_OF_MSG, CompressionAlgorithm.GZIP, DATA, CRYPTO_CONTEXT);
final MslObject mo = MslTestUtils.toMslObject(encoder, chunk);
final byte[] ciphertext = new byte[32];
random.nextBytes(ciphertext);
mo.put(KEY_PAYLOAD, ciphertext);
final byte[] signature = CRYPTO_CONTEXT.sign(ciphertext, encoder, ENCODER_FORMAT);
mo.put(KEY_SIGNATURE, signature);
new PayloadChunk(ctx, mo, CRYPTO_CONTEXT);
}
@Test
public void emptyPayloadEndOfMessage() throws MslEncoderException, MslEncodingException, MslCryptoException, MslException {
final byte[] data = new byte[0];
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, true, CompressionAlgorithm.GZIP, data, CRYPTO_CONTEXT);
final MslObject mo = MslTestUtils.toMslObject(encoder, chunk);
final PayloadChunk moChunk = new PayloadChunk(ctx, mo, CRYPTO_CONTEXT);
assertEquals(0, moChunk.getData().length);
}
@Test
public void missingSequenceNumber() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, END_OF_MSG, CompressionAlgorithm.GZIP, DATA, CRYPTO_CONTEXT);
final MslObject mo = MslTestUtils.toMslObject(encoder, chunk);
final byte[] ciphertext = mo.getBytes(KEY_PAYLOAD);
final byte[] payload = CRYPTO_CONTEXT.decrypt(ciphertext, encoder);
final MslObject payloadMo = encoder.parseObject(payload);
assertNotNull(payloadMo.remove(KEY_SEQUENCE_NUMBER));
final byte[] plaintext = encoder.encodeObject(payloadMo, ENCODER_FORMAT);
final byte[] newPayload = CRYPTO_CONTEXT.encrypt(plaintext, encoder, ENCODER_FORMAT);
final byte[] signature = CRYPTO_CONTEXT.sign(newPayload, encoder, ENCODER_FORMAT);
mo.put(KEY_PAYLOAD, newPayload);
mo.put(KEY_SIGNATURE, signature);
new PayloadChunk(ctx, mo, CRYPTO_CONTEXT);
}
@Test
public void invalidSequenceNumber() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, true, CompressionAlgorithm.GZIP, DATA, CRYPTO_CONTEXT);
final MslObject mo = MslTestUtils.toMslObject(encoder, chunk);
final byte[] ciphertext = mo.getBytes(KEY_PAYLOAD);
final byte[] payload = CRYPTO_CONTEXT.decrypt(ciphertext, encoder);
final MslObject payloadMo = encoder.parseObject(payload);
payloadMo.put(KEY_SEQUENCE_NUMBER, "x");
final byte[] plaintext = encoder.encodeObject(payloadMo, ENCODER_FORMAT);
final byte[] newPayload = CRYPTO_CONTEXT.encrypt(plaintext, encoder, ENCODER_FORMAT);
final byte[] signature = CRYPTO_CONTEXT.sign(newPayload, encoder, ENCODER_FORMAT);
mo.put(KEY_PAYLOAD, newPayload);
mo.put(KEY_SIGNATURE, signature);
new PayloadChunk(ctx, mo, CRYPTO_CONTEXT);
}
@Test
public void negativeSequenceNumber() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.PAYLOAD_SEQUENCE_NUMBER_OUT_OF_RANGE);
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, true, CompressionAlgorithm.GZIP, DATA, CRYPTO_CONTEXT);
final MslObject mo = MslTestUtils.toMslObject(encoder, chunk);
final byte[] ciphertext = mo.getBytes(KEY_PAYLOAD);
final byte[] payload = CRYPTO_CONTEXT.decrypt(ciphertext, encoder);
final MslObject payloadMo = encoder.parseObject(payload);
payloadMo.put(KEY_SEQUENCE_NUMBER, -1);
final byte[] plaintext = encoder.encodeObject(payloadMo, ENCODER_FORMAT);
final byte[] newPayload = CRYPTO_CONTEXT.encrypt(plaintext, encoder, ENCODER_FORMAT);
final byte[] signature = CRYPTO_CONTEXT.sign(newPayload, encoder, ENCODER_FORMAT);
mo.put(KEY_PAYLOAD, newPayload);
mo.put(KEY_SIGNATURE, signature);
new PayloadChunk(ctx, mo, CRYPTO_CONTEXT);
}
@Test
public void tooLargeSequenceNumber() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.PAYLOAD_SEQUENCE_NUMBER_OUT_OF_RANGE);
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, true, CompressionAlgorithm.GZIP, DATA, CRYPTO_CONTEXT);
final MslObject mo = MslTestUtils.toMslObject(encoder, chunk);
final byte[] ciphertext = mo.getBytes(KEY_PAYLOAD);
final byte[] payload = CRYPTO_CONTEXT.decrypt(ciphertext, encoder);
final MslObject payloadMo = encoder.parseObject(payload);
payloadMo.put(KEY_SEQUENCE_NUMBER, MslConstants.MAX_LONG_VALUE + 1);
final byte[] plaintext = encoder.encodeObject(payloadMo, ENCODER_FORMAT);
final byte[] newPayload = CRYPTO_CONTEXT.encrypt(plaintext, encoder, ENCODER_FORMAT);
final byte[] signature = CRYPTO_CONTEXT.sign(newPayload, encoder, ENCODER_FORMAT);
mo.put(KEY_PAYLOAD, newPayload);
mo.put(KEY_SIGNATURE, signature);
new PayloadChunk(ctx, mo, CRYPTO_CONTEXT);
}
@Test
public void missingMessageId() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, END_OF_MSG, CompressionAlgorithm.GZIP, DATA, CRYPTO_CONTEXT);
final MslObject mo = MslTestUtils.toMslObject(encoder, chunk);
final byte[] ciphertext = mo.getBytes(KEY_PAYLOAD);
final byte[] payload = CRYPTO_CONTEXT.decrypt(ciphertext, encoder);
final MslObject payloadMo = encoder.parseObject(payload);
assertNotNull(payloadMo.remove(KEY_MESSAGE_ID));
final byte[] plaintext = encoder.encodeObject(payloadMo, ENCODER_FORMAT);
final byte[] newPayload = CRYPTO_CONTEXT.encrypt(plaintext, encoder, ENCODER_FORMAT);
final byte[] signature = CRYPTO_CONTEXT.sign(newPayload, encoder, ENCODER_FORMAT);
mo.put(KEY_PAYLOAD, newPayload);
mo.put(KEY_SIGNATURE, signature);
new PayloadChunk(ctx, mo, CRYPTO_CONTEXT);
}
@Test
public void invalidMessageId() throws MslEncoderException, MslEncodingException, MslCryptoException, MslException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, true, CompressionAlgorithm.GZIP, DATA, CRYPTO_CONTEXT);
final MslObject mo = MslTestUtils.toMslObject(encoder, chunk);
final byte[] ciphertext = mo.getBytes(KEY_PAYLOAD);
final byte[] payload = CRYPTO_CONTEXT.decrypt(ciphertext, encoder);
final MslObject payloadMo = encoder.parseObject(payload);
payloadMo.put(KEY_MESSAGE_ID, "x");
final byte[] plaintext = encoder.encodeObject(payloadMo, ENCODER_FORMAT);
final byte[] newPayload = CRYPTO_CONTEXT.encrypt(plaintext, encoder, ENCODER_FORMAT);
final byte[] signature = CRYPTO_CONTEXT.sign(newPayload, encoder, ENCODER_FORMAT);
mo.put(KEY_PAYLOAD, newPayload);
mo.put(KEY_SIGNATURE, signature);
new PayloadChunk(ctx, mo, CRYPTO_CONTEXT);
}
@Test
public void invalidEndOfMessage() throws MslEncoderException, MslEncodingException, MslCryptoException, MslException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, true, CompressionAlgorithm.GZIP, DATA, CRYPTO_CONTEXT);
final MslObject mo = MslTestUtils.toMslObject(encoder, chunk);
final byte[] ciphertext = mo.getBytes(KEY_PAYLOAD);
final byte[] payload = CRYPTO_CONTEXT.decrypt(ciphertext, encoder);
final MslObject payloadMo = encoder.parseObject(payload);
payloadMo.put(KEY_END_OF_MESSAGE, "x");
final byte[] plaintext = encoder.encodeObject(payloadMo, ENCODER_FORMAT);
final byte[] newPayload = CRYPTO_CONTEXT.encrypt(plaintext, encoder, ENCODER_FORMAT);
final byte[] signature = CRYPTO_CONTEXT.sign(newPayload, encoder, ENCODER_FORMAT);
mo.put(KEY_PAYLOAD, newPayload);
mo.put(KEY_SIGNATURE, signature);
new PayloadChunk(ctx, mo, CRYPTO_CONTEXT);
}
@Test
public void invalidCompressionAlgorithm() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.UNIDENTIFIED_COMPRESSION);
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, true, CompressionAlgorithm.GZIP, DATA, CRYPTO_CONTEXT);
final MslObject mo = MslTestUtils.toMslObject(encoder, chunk);
final byte[] ciphertext = mo.getBytes(KEY_PAYLOAD);
final byte[] payload = CRYPTO_CONTEXT.decrypt(ciphertext, encoder);
final MslObject payloadMo = encoder.parseObject(payload);
payloadMo.put(KEY_COMPRESSION_ALGORITHM, "x");
final byte[] plaintext = encoder.encodeObject(payloadMo, ENCODER_FORMAT);
final byte[] newPayload = CRYPTO_CONTEXT.encrypt(plaintext, encoder, ENCODER_FORMAT);
final byte[] signature = CRYPTO_CONTEXT.sign(newPayload, encoder, ENCODER_FORMAT);
mo.put(KEY_PAYLOAD, newPayload);
mo.put(KEY_SIGNATURE, signature);
new PayloadChunk(ctx, mo, CRYPTO_CONTEXT);
}
@Test
public void missingData() throws MslEncoderException, MslEncodingException, MslCryptoException, MslException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, END_OF_MSG, CompressionAlgorithm.GZIP, DATA, CRYPTO_CONTEXT);
final MslObject mo = MslTestUtils.toMslObject(encoder, chunk);
final byte[] ciphertext = mo.getBytes(KEY_PAYLOAD);
final byte[] payload = CRYPTO_CONTEXT.decrypt(ciphertext, encoder);
final MslObject payloadMo = encoder.parseObject(payload);
assertNotNull(payloadMo.remove(KEY_DATA));
final byte[] plaintext = encoder.encodeObject(payloadMo, ENCODER_FORMAT);
final byte[] newPayload = CRYPTO_CONTEXT.encrypt(plaintext, encoder, ENCODER_FORMAT);
final byte[] signature = CRYPTO_CONTEXT.sign(newPayload, encoder, ENCODER_FORMAT);
mo.put(KEY_PAYLOAD, newPayload);
mo.put(KEY_SIGNATURE, signature);
new PayloadChunk(ctx, mo, CRYPTO_CONTEXT);
}
@Test
public void emptyData() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.PAYLOAD_DATA_MISSING);
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, END_OF_MSG, CompressionAlgorithm.GZIP, DATA, CRYPTO_CONTEXT);
final MslObject mo = MslTestUtils.toMslObject(encoder, chunk);
final byte[] ciphertext = mo.getBytes(KEY_PAYLOAD);
final byte[] payload = CRYPTO_CONTEXT.decrypt(ciphertext, encoder);
final MslObject payloadMo = encoder.parseObject(payload);
payloadMo.put(KEY_DATA, "");
final byte[] plaintext = encoder.encodeObject(payloadMo, ENCODER_FORMAT);
final byte[] newPayload = CRYPTO_CONTEXT.encrypt(plaintext, encoder, ENCODER_FORMAT);
final byte[] signature = CRYPTO_CONTEXT.sign(newPayload, encoder, ENCODER_FORMAT);
mo.put(KEY_PAYLOAD, newPayload);
mo.put(KEY_SIGNATURE, signature);
new PayloadChunk(ctx, mo, CRYPTO_CONTEXT);
}
@Test
public void invalidDataEndOfMessage() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, true, CompressionAlgorithm.GZIP, DATA, CRYPTO_CONTEXT);
final MslObject mo = MslTestUtils.toMslObject(encoder, chunk);
final byte[] ciphertext = mo.getBytes(KEY_PAYLOAD);
final byte[] payload = CRYPTO_CONTEXT.decrypt(ciphertext, encoder);
final MslObject payloadMo = encoder.parseObject(payload);
payloadMo.put(KEY_DATA, false);
final byte[] plaintext = encoder.encodeObject(payloadMo, ENCODER_FORMAT);
final byte[] newPayload = CRYPTO_CONTEXT.encrypt(plaintext, encoder, ENCODER_FORMAT);
final byte[] signature = CRYPTO_CONTEXT.sign(newPayload, encoder, ENCODER_FORMAT);
mo.put(KEY_PAYLOAD, newPayload);
mo.put(KEY_SIGNATURE, signature);
new PayloadChunk(ctx, mo, CRYPTO_CONTEXT);
}
@Test
public void largeData() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
final byte[] data = new byte[10 * 1024 * 1024];
random.nextBytes(data);
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, true, null, data, CRYPTO_CONTEXT);
assertArrayEquals(data, chunk.getData());
final MslObject mo = MslTestUtils.toMslObject(encoder, chunk);
final PayloadChunk moChunk = new PayloadChunk(ctx, mo, CRYPTO_CONTEXT);
assertArrayEquals(chunk.getData(), moChunk.getData());
}
@Test
public void gzipLargeData() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
final byte[] data = new byte[10 * 1024 * 1024];
random.nextBytes(data);
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, true, CompressionAlgorithm.GZIP, data, CRYPTO_CONTEXT);
assertArrayEquals(data, chunk.getData());
// Random data will not compress.
assertNull(chunk.getCompressionAlgo());
final MslObject mo = MslTestUtils.toMslObject(encoder, chunk);
final PayloadChunk moChunk = new PayloadChunk(ctx, mo, CRYPTO_CONTEXT);
assertArrayEquals(chunk.getData(), moChunk.getData());
assertEquals(chunk.getCompressionAlgo(), moChunk.getCompressionAlgo());
}
@Test
public void gzipVerona() throws MslEncodingException, MslCryptoException, MslMessageException, MslException, MslEncoderException {
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, true, CompressionAlgorithm.GZIP, rawdata, CRYPTO_CONTEXT);
assertArrayEquals(rawdata, chunk.getData());
// Romeo and Juliet will compress.
assertEquals(CompressionAlgorithm.GZIP, chunk.getCompressionAlgo());
final MslObject mo = MslTestUtils.toMslObject(encoder, chunk);
final PayloadChunk moChunk = new PayloadChunk(ctx, mo, CRYPTO_CONTEXT);
assertArrayEquals(chunk.getData(), moChunk.getData());
assertEquals(chunk.getCompressionAlgo(), moChunk.getCompressionAlgo());
}
@Test
public void lzwRandomData() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
final byte[] data = new byte[10 * 1024 * 1024];
random.nextBytes(data);
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, true, CompressionAlgorithm.LZW, data, CRYPTO_CONTEXT);
assertArrayEquals(data, chunk.getData());
// Random data will not compress.
assertNull(chunk.getCompressionAlgo());
final MslObject mo = MslTestUtils.toMslObject(encoder, chunk);
final PayloadChunk moChunk = new PayloadChunk(ctx, mo, CRYPTO_CONTEXT);
assertArrayEquals(chunk.getData(), moChunk.getData());
assertEquals(chunk.getCompressionAlgo(), moChunk.getCompressionAlgo());
}
@Test
public void lzwVerona() throws MslEncodingException, MslCryptoException, MslMessageException, MslException, MslEncoderException {
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, true, CompressionAlgorithm.LZW, rawdata, CRYPTO_CONTEXT);
assertArrayEquals(rawdata, chunk.getData());
// Romeo and Juliet will compress.
assertEquals(CompressionAlgorithm.LZW, chunk.getCompressionAlgo());
final MslObject mo = MslTestUtils.toMslObject(encoder, chunk);
final PayloadChunk moChunk = new PayloadChunk(ctx, mo, CRYPTO_CONTEXT);
assertArrayEquals(chunk.getData(), moChunk.getData());
assertEquals(chunk.getCompressionAlgo(), moChunk.getCompressionAlgo());
}
@Test
public void equalsSequenceNumber() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
final long seqNoA = 1;
final long seqNoB = 2;
final PayloadChunk chunkA = new PayloadChunk(ctx, seqNoA, MSG_ID, false, null, DATA, CRYPTO_CONTEXT);
final PayloadChunk chunkB = new PayloadChunk(ctx, seqNoB, MSG_ID, false, null, DATA, CRYPTO_CONTEXT);
final PayloadChunk chunkA2 = new PayloadChunk(ctx, MslTestUtils.toMslObject(encoder, chunkA), CRYPTO_CONTEXT);
assertTrue(chunkA.equals(chunkA));
assertEquals(chunkA.hashCode(), chunkA.hashCode());
assertFalse(chunkA.equals(chunkB));
assertFalse(chunkB.equals(chunkA));
assertTrue(chunkA.hashCode() != chunkB.hashCode());
assertTrue(chunkA.equals(chunkA2));
assertTrue(chunkA2.equals(chunkA));
assertEquals(chunkA.hashCode(), chunkA2.hashCode());
}
@Test
public void equalsMessageId() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
final long msgIdA = 1;
final long msgIdB = 2;
final PayloadChunk chunkA = new PayloadChunk(ctx, SEQ_NO, msgIdA, false, null, DATA, CRYPTO_CONTEXT);
final PayloadChunk chunkB = new PayloadChunk(ctx, SEQ_NO, msgIdB, false, null, DATA, CRYPTO_CONTEXT);
final PayloadChunk chunkA2 = new PayloadChunk(ctx, MslTestUtils.toMslObject(encoder, chunkA), CRYPTO_CONTEXT);
assertTrue(chunkA.equals(chunkA));
assertEquals(chunkA.hashCode(), chunkA.hashCode());
assertFalse(chunkA.equals(chunkB));
assertFalse(chunkB.equals(chunkA));
assertTrue(chunkA.hashCode() != chunkB.hashCode());
assertTrue(chunkA.equals(chunkA2));
assertTrue(chunkA2.equals(chunkA));
assertEquals(chunkA.hashCode(), chunkA2.hashCode());
}
@Test
public void equalsEndOfMessage() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
final PayloadChunk chunkA = new PayloadChunk(ctx, SEQ_NO, MSG_ID, true, null, DATA, CRYPTO_CONTEXT);
final PayloadChunk chunkB = new PayloadChunk(ctx, SEQ_NO, MSG_ID, false, null, DATA, CRYPTO_CONTEXT);
final PayloadChunk chunkA2 = new PayloadChunk(ctx, MslTestUtils.toMslObject(encoder, chunkA), CRYPTO_CONTEXT);
assertTrue(chunkA.equals(chunkA));
assertEquals(chunkA.hashCode(), chunkA.hashCode());
assertFalse(chunkA.equals(chunkB));
assertFalse(chunkB.equals(chunkA));
assertTrue(chunkA.hashCode() != chunkB.hashCode());
assertTrue(chunkA.equals(chunkA2));
assertTrue(chunkA2.equals(chunkA));
assertEquals(chunkA.hashCode(), chunkA2.hashCode());
}
@Test
public void equalsCompressionAlgorithm() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
final PayloadChunk chunkA = new PayloadChunk(ctx, SEQ_NO, MSG_ID, true, CompressionAlgorithm.GZIP, DATA, CRYPTO_CONTEXT);
final PayloadChunk chunkB = new PayloadChunk(ctx, SEQ_NO, MSG_ID, true, null, DATA, CRYPTO_CONTEXT);
final PayloadChunk chunkA2 = new PayloadChunk(ctx, MslTestUtils.toMslObject(encoder, chunkA), CRYPTO_CONTEXT);
assertTrue(chunkA.equals(chunkA));
assertEquals(chunkA.hashCode(), chunkA.hashCode());
assertFalse(chunkA.equals(chunkB));
assertFalse(chunkB.equals(chunkA));
assertTrue(chunkA.hashCode() != chunkB.hashCode());
assertTrue(chunkA.equals(chunkA2));
assertTrue(chunkA2.equals(chunkA));
assertEquals(chunkA.hashCode(), chunkA2.hashCode());
}
@Test
public void equalsData() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
final byte[] dataA = new byte[32];
random.nextBytes(dataA);
final byte[] dataB = new byte[32];
random.nextBytes(dataB);
final byte[] dataC = new byte[0];
final PayloadChunk chunkA = new PayloadChunk(ctx, SEQ_NO, MSG_ID, true, CompressionAlgorithm.GZIP, dataA, CRYPTO_CONTEXT);
final PayloadChunk chunkB = new PayloadChunk(ctx, SEQ_NO, MSG_ID, true, CompressionAlgorithm.GZIP, dataB, CRYPTO_CONTEXT);
final PayloadChunk chunkC = new PayloadChunk(ctx, SEQ_NO, MSG_ID, true, CompressionAlgorithm.GZIP, dataC, CRYPTO_CONTEXT);
final PayloadChunk chunkA2 = new PayloadChunk(ctx, MslTestUtils.toMslObject(encoder, chunkA), CRYPTO_CONTEXT);
assertTrue(chunkA.equals(chunkA));
assertEquals(chunkA.hashCode(), chunkA.hashCode());
assertFalse(chunkA.equals(chunkB));
assertFalse(chunkB.equals(chunkA));
assertTrue(chunkA.hashCode() != chunkB.hashCode());
assertFalse(chunkA.equals(chunkC));
assertFalse(chunkC.equals(chunkA));
assertTrue(chunkA.hashCode() != chunkC.hashCode());
assertTrue(chunkA.equals(chunkA2));
assertTrue(chunkA2.equals(chunkA));
assertEquals(chunkA.hashCode(), chunkA2.hashCode());
}
@Test
public void equalsObject() throws MslEncodingException, MslCryptoException, MslException {
final PayloadChunk chunk = new PayloadChunk(ctx, SEQ_NO, MSG_ID, true, CompressionAlgorithm.GZIP, DATA, CRYPTO_CONTEXT);
assertFalse(chunk.equals(null));
assertFalse(chunk.equals(CRYPTO_CONTEXT_ID));
assertTrue(chunk.hashCode() != CRYPTO_CONTEXT_ID.hashCode());
}
}
| 9,955 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/msg/MessageCapabilitiesTest.java | /**
* Copyright (c) 2013-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.msg;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import com.netflix.msl.MslConstants.CompressionAlgorithm;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.io.MslArray;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* Message capabilities unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class MessageCapabilitiesTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key compression algorithms. */
private static final String KEY_COMPRESSION_ALGOS = "compressionalgos";
/** Key encoder formats. */
private static final String KEY_ENCODER_FORMATS = "encoderformats";
private static final Set<CompressionAlgorithm> ALGOS = new HashSet<CompressionAlgorithm>();
private static final List<String> LANGUAGES = Arrays.asList(new String[] { "en-US", "es" });
private static final Set<MslEncoderFormat> FORMATS = new HashSet<MslEncoderFormat>();
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException {
final MslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = ctx.getMslEncoderFactory();
ALGOS.add(CompressionAlgorithm.GZIP);
ALGOS.add(CompressionAlgorithm.LZW);
FORMATS.add(MslEncoderFormat.JSON);
}
@AfterClass
public static void teardown() {
FORMATS.clear();
ALGOS.clear();
encoder = null;
}
@Test
public void ctors() throws MslEncodingException, MslEncoderException {
final MessageCapabilities caps = new MessageCapabilities(ALGOS, LANGUAGES, FORMATS);
assertEquals(ALGOS, caps.getCompressionAlgorithms());
assertEquals(LANGUAGES, caps.getLanguages());
assertEquals(FORMATS, caps.getEncoderFormats());
final byte[] encode = caps.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final MessageCapabilities moCaps = new MessageCapabilities(encoder.parseObject(encode));
assertEquals(caps.getCompressionAlgorithms(), moCaps.getCompressionAlgorithms());
assertEquals(caps.getLanguages(), moCaps.getLanguages());
assertEquals(caps.getEncoderFormats(), moCaps.getEncoderFormats());
final byte[] moEncode = moCaps.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
// This test will not always pass since set data is unordered.
//assertEquals(encode, moEncode);
final MessageCapabilities mo2Caps = new MessageCapabilities(encoder.parseObject(moEncode));
assertEquals(moCaps, mo2Caps);
}
@Test
public void nullAlgos() throws MslEncodingException, MslEncoderException {
final MessageCapabilities caps = new MessageCapabilities(null, LANGUAGES, FORMATS);
final Set<CompressionAlgorithm> algos = caps.getCompressionAlgorithms();
assertNotNull(algos);
assertEquals(0, algos.size());
assertEquals(LANGUAGES, caps.getLanguages());
assertEquals(FORMATS, caps.getEncoderFormats());
final byte[] encode = caps.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final MessageCapabilities moCaps = new MessageCapabilities(encoder.parseObject(encode));
assertEquals(caps.getCompressionAlgorithms(), moCaps.getCompressionAlgorithms());
assertEquals(caps.getLanguages(), moCaps.getLanguages());
assertEquals(caps.getEncoderFormats(), moCaps.getEncoderFormats());
final byte[] moEncode = moCaps.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
// This test will not always pass since set data is unordered.
//assertEquals(encode, moEncode);
final MessageCapabilities mo2Caps = new MessageCapabilities(encoder.parseObject(moEncode));
assertEquals(moCaps, mo2Caps);
}
@Test
public void unknownCompressionAlgo() throws MslEncoderException, MslEncodingException {
final MessageCapabilities caps = new MessageCapabilities(ALGOS, LANGUAGES, FORMATS);
final MslObject mo = MslTestUtils.toMslObject(encoder, caps);
final MslArray ma = mo.getMslArray(KEY_COMPRESSION_ALGOS);
ma.put(-1, "CATZ");
mo.put(KEY_COMPRESSION_ALGOS, ma);
final MessageCapabilities moCaps = new MessageCapabilities(mo);
assertEquals(caps.getCompressionAlgorithms(), moCaps.getCompressionAlgorithms());
}
@Test
public void nullLanguages() throws MslEncodingException, MslEncoderException {
final MessageCapabilities caps = new MessageCapabilities(ALGOS, null, FORMATS);
assertEquals(ALGOS, caps.getCompressionAlgorithms());
final List<String> languages = caps.getLanguages();
assertNotNull(languages);
assertEquals(0, languages.size());
assertEquals(FORMATS, caps.getEncoderFormats());
final byte[] encode = caps.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final MessageCapabilities moCaps = new MessageCapabilities(encoder.parseObject(encode));
assertEquals(caps.getCompressionAlgorithms(), moCaps.getCompressionAlgorithms());
assertEquals(caps.getLanguages(), moCaps.getLanguages());
assertEquals(caps.getEncoderFormats(), moCaps.getEncoderFormats());
final byte[] moEncode = moCaps.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
// This test will not always pass since set data is unordered.
//assertEquals(encode, moEncode);
final MessageCapabilities mo2Caps = new MessageCapabilities(encoder.parseObject(moEncode));
assertEquals(moCaps, mo2Caps);
}
@Test
public void nullEncoderFormats() throws MslEncodingException, MslEncoderException {
final MessageCapabilities caps = new MessageCapabilities(ALGOS, LANGUAGES, null);
assertEquals(ALGOS, caps.getCompressionAlgorithms());
assertEquals(LANGUAGES, caps.getLanguages());
final Set<MslEncoderFormat> formats = caps.getEncoderFormats();
assertNotNull(formats);
assertEquals(0, formats.size());
final byte[] encode = caps.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final MessageCapabilities moCaps = new MessageCapabilities(encoder.parseObject(encode));
assertEquals(caps.getCompressionAlgorithms(), moCaps.getCompressionAlgorithms());
assertEquals(caps.getLanguages(), moCaps.getLanguages());
assertEquals(caps.getEncoderFormats(), moCaps.getEncoderFormats());
final byte[] moEncode = moCaps.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
// This test will not always pass since set data is unordered.
//assertEquals(encode, moEncode);
final MessageCapabilities mo2Caps = new MessageCapabilities(encoder.parseObject(moEncode));
assertEquals(moCaps, mo2Caps);
}
@Test
public void unknownEncoderFormat() throws MslEncoderException, MslEncodingException {
final MessageCapabilities caps = new MessageCapabilities(ALGOS, LANGUAGES, FORMATS);
final MslObject mo = MslTestUtils.toMslObject(encoder, caps);
final MslArray ma = mo.getMslArray(KEY_ENCODER_FORMATS);
ma.put(-1, "CATZ");
mo.put(KEY_ENCODER_FORMATS, ma);
final MessageCapabilities moCaps = new MessageCapabilities(mo);
assertEquals(caps.getEncoderFormats(), moCaps.getEncoderFormats());
}
@Test
public void equalsCompressionAlgos() throws MslEncodingException, MslEncoderException {
final Set<CompressionAlgorithm> algosA = new HashSet<CompressionAlgorithm>(ALGOS);
final Set<CompressionAlgorithm> algosB = new HashSet<CompressionAlgorithm>();
final MessageCapabilities capsA = new MessageCapabilities(algosA, LANGUAGES, FORMATS);
final MessageCapabilities capsB = new MessageCapabilities(algosB, LANGUAGES, FORMATS);
final MessageCapabilities capsA2 = new MessageCapabilities(MslTestUtils.toMslObject(encoder, capsA));
assertTrue(capsA.equals(capsA));
assertEquals(capsA.hashCode(), capsA.hashCode());
assertFalse(capsA.equals(capsB));
assertFalse(capsB.equals(capsA));
assertTrue(capsA.hashCode() != capsB.hashCode());
assertTrue(capsA.equals(capsA2));
assertTrue(capsA2.equals(capsA));
assertEquals(capsA.hashCode(), capsA2.hashCode());
}
@Test
public void equalsLanguages() throws MslEncodingException, MslEncoderException {
final List<String> langsA = Arrays.asList(new String[] { "en-US" });
final List<String> langsB = Arrays.asList(new String[] { "es" });
final MessageCapabilities capsA = new MessageCapabilities(ALGOS, langsA, FORMATS);
final MessageCapabilities capsB = new MessageCapabilities(ALGOS, langsB, FORMATS);
final MessageCapabilities capsA2 = new MessageCapabilities(MslTestUtils.toMslObject(encoder, capsA));
assertTrue(capsA.equals(capsA));
assertEquals(capsA.hashCode(), capsA.hashCode());
assertFalse(capsA.equals(capsB));
assertFalse(capsB.equals(capsA));
assertTrue(capsA.hashCode() != capsB.hashCode());
assertTrue(capsA.equals(capsA2));
assertTrue(capsA2.equals(capsA));
assertEquals(capsA.hashCode(), capsA2.hashCode());
}
@Test
public void equalsEncoderFormats() throws MslEncodingException, MslEncoderException {
final Set<MslEncoderFormat> formatsA = new HashSet<MslEncoderFormat>(FORMATS);
final Set<MslEncoderFormat> formatsB = new HashSet<MslEncoderFormat>();
final MessageCapabilities capsA = new MessageCapabilities(ALGOS, LANGUAGES, formatsA);
final MessageCapabilities capsB = new MessageCapabilities(ALGOS, LANGUAGES, formatsB);
final MessageCapabilities capsA2 = new MessageCapabilities(MslTestUtils.toMslObject(encoder, capsA));
assertTrue(capsA.equals(capsA));
assertEquals(capsA.hashCode(), capsA.hashCode());
assertFalse(capsA.equals(capsB));
assertFalse(capsB.equals(capsA));
assertTrue(capsA.hashCode() != capsB.hashCode());
assertTrue(capsA.equals(capsA2));
assertTrue(capsA2.equals(capsA));
assertEquals(capsA.hashCode(), capsA2.hashCode());
}
@Test
public void selfIntersection() {
final MessageCapabilities capsA = new MessageCapabilities(ALGOS, LANGUAGES, FORMATS);
final MessageCapabilities capsB = new MessageCapabilities(ALGOS, LANGUAGES, FORMATS);
final MessageCapabilities intersection = MessageCapabilities.intersection(capsA, capsB);
assertTrue(intersection.equals(capsA));
assertTrue(intersection.equals(capsB));
}
@Test
public void intersection() {
final Set<CompressionAlgorithm> gzipOnly = new HashSet<CompressionAlgorithm>();
gzipOnly.add(CompressionAlgorithm.GZIP);
final List<String> oneLanguage = new ArrayList<String>();
oneLanguage.add(LANGUAGES.get(0));
final Set<MslEncoderFormat> noFormats = new HashSet<MslEncoderFormat>();
final MessageCapabilities capsA = new MessageCapabilities(ALGOS, oneLanguage, FORMATS);
final MessageCapabilities capsB = new MessageCapabilities(gzipOnly, LANGUAGES, FORMATS);
final MessageCapabilities capsC = new MessageCapabilities(ALGOS, LANGUAGES, noFormats);
final MessageCapabilities intersectionAB = MessageCapabilities.intersection(capsA, capsB);
final MessageCapabilities intersectionBA = MessageCapabilities.intersection(capsB, capsA);
final MessageCapabilities intersectionAC = MessageCapabilities.intersection(capsA, capsC);
final MessageCapabilities intersectionCA = MessageCapabilities.intersection(capsC, capsA);
final MessageCapabilities intersectionBC = MessageCapabilities.intersection(capsB, capsC);
final MessageCapabilities intersectionCB = MessageCapabilities.intersection(capsC, capsB);
assertTrue(intersectionAB.equals(intersectionBA));
assertEquals(gzipOnly, intersectionAB.getCompressionAlgorithms());
assertTrue(oneLanguage.containsAll(intersectionAB.getLanguages()));
assertEquals(FORMATS, intersectionAB.getEncoderFormats());
assertTrue(intersectionAC.equals(intersectionCA));
assertEquals(ALGOS, intersectionAC.getCompressionAlgorithms());
assertTrue(oneLanguage.containsAll(intersectionAC.getLanguages()));
assertEquals(noFormats, intersectionAC.getEncoderFormats());
assertTrue(intersectionBC.equals(intersectionCB));
assertEquals(gzipOnly, intersectionBC.getCompressionAlgorithms());
assertTrue(LANGUAGES.containsAll(intersectionBC.getLanguages()));
assertEquals(noFormats, intersectionBC.getEncoderFormats());
}
@Test
public void nullIntersection() {
final MessageCapabilities caps = new MessageCapabilities(ALGOS, LANGUAGES, FORMATS);
final MessageCapabilities intersectionA = MessageCapabilities.intersection(null, caps);
final MessageCapabilities intersectionB = MessageCapabilities.intersection(caps, null);
assertNull(intersectionA);
assertNull(intersectionB);
}
}
| 9,956 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/msg/MessageBuilderSuite.java | /**
* Copyright (c) 2012-2020 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.msg;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.math.BigInteger;
import java.security.InvalidAlgorithmParameterException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import javax.crypto.SecretKey;
import javax.crypto.interfaces.DHPrivateKey;
import javax.crypto.interfaces.DHPublicKey;
import javax.crypto.spec.DHParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;
import com.netflix.msl.MslConstants;
import com.netflix.msl.MslConstants.CompressionAlgorithm;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.MslKeyExchangeException;
import com.netflix.msl.MslMasterTokenException;
import com.netflix.msl.MslMessageException;
import com.netflix.msl.MslUserAuthException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.crypto.JcaAlgorithm;
import com.netflix.msl.crypto.NullCryptoContext;
import com.netflix.msl.crypto.SessionCryptoContext;
import com.netflix.msl.crypto.SymmetricCryptoContext;
import com.netflix.msl.entityauth.EntityAuthenticationData;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.entityauth.MockPresharedAuthenticationFactory;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.keyx.AsymmetricWrappedExchange;
import com.netflix.msl.keyx.AsymmetricWrappedExchange.RequestData.Mechanism;
import com.netflix.msl.keyx.DiffieHellmanExchange;
import com.netflix.msl.keyx.DiffieHellmanParameters;
import com.netflix.msl.keyx.KeyExchangeScheme;
import com.netflix.msl.keyx.KeyRequestData;
import com.netflix.msl.keyx.KeyResponseData;
import com.netflix.msl.keyx.MockDiffieHellmanParameters;
import com.netflix.msl.keyx.SymmetricWrappedExchange;
import com.netflix.msl.keyx.SymmetricWrappedExchange.KeyId;
import com.netflix.msl.msg.MessageHeader.HeaderData;
import com.netflix.msl.msg.MessageHeader.HeaderPeerData;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.tokens.MasterToken;
import com.netflix.msl.tokens.MslUser;
import com.netflix.msl.tokens.ServiceToken;
import com.netflix.msl.tokens.UserIdToken;
import com.netflix.msl.userauth.EmailPasswordAuthenticationData;
import com.netflix.msl.userauth.MockEmailPasswordAuthenticationFactory;
import com.netflix.msl.userauth.UserAuthenticationData;
import com.netflix.msl.userauth.UserAuthenticationScheme;
import com.netflix.msl.util.MockAuthenticationUtils;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslStore;
import com.netflix.msl.util.MslTestUtils;
/**
* Message builder unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
@RunWith(Suite.class)
@SuiteClasses({MessageBuilderSuite.Tests.class,
MessageBuilderSuite.CreateRequestTest.class,
MessageBuilderSuite.CreateErrorTest.class,
MessageBuilderSuite.CreateResponseTest.class})
public class MessageBuilderSuite {
private static final String SERVICE_TOKEN_NAME = "serviceTokenName";
private static final String USER_ID = "userid";
private static final String PEER_USER_ID = "peeruserid";
private static final String PARAMETERS_ID = MockDiffieHellmanParameters.DEFAULT_ID;
/** Random. */
private static Random random;
/** MSL trusted network context. */
private static MslContext trustedNetCtx;
/** MSL peer-to-peer context. */
private static MslContext p2pCtx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
/** Message Factory. */
private static MessageFactory messageFactory = new MessageFactory();
private static MasterToken MASTER_TOKEN, PEER_MASTER_TOKEN;
private static ICryptoContext CRYPTO_CONTEXT, ALT_MSL_CRYPTO_CONTEXT;
private static UserIdToken USER_ID_TOKEN, PEER_USER_ID_TOKEN;
private static UserAuthenticationData USER_AUTH_DATA;
private static final Set<KeyRequestData> KEY_REQUEST_DATA = new HashSet<KeyRequestData>();
private static final Set<KeyRequestData> PEER_KEY_REQUEST_DATA = new HashSet<KeyRequestData>();
@BeforeClass
public static synchronized void setup() throws MslEncodingException, MslCryptoException, MslKeyExchangeException, MslMasterTokenException, MslEntityAuthException, InvalidAlgorithmParameterException, NoSuchAlgorithmException {
if (random == null) {
random = new Random();
trustedNetCtx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
p2pCtx = new MockMslContext(EntityAuthenticationScheme.PSK, true);
encoder = trustedNetCtx.getMslEncoderFactory();
USER_AUTH_DATA = new EmailPasswordAuthenticationData(MockEmailPasswordAuthenticationFactory.EMAIL, MockEmailPasswordAuthenticationFactory.PASSWORD);
MASTER_TOKEN = MslTestUtils.getMasterToken(trustedNetCtx, 1, 1);
USER_ID_TOKEN = MslTestUtils.getUserIdToken(trustedNetCtx, MASTER_TOKEN, 1, MockEmailPasswordAuthenticationFactory.USER);
CRYPTO_CONTEXT = new NullCryptoContext();
final DiffieHellmanParameters params = MockDiffieHellmanParameters.getDefaultParameters();
final DHParameterSpec paramSpec = params.getParameterSpec(MockDiffieHellmanParameters.DEFAULT_ID);
final KeyPairGenerator generator = KeyPairGenerator.getInstance("DH");
generator.initialize(paramSpec);
final KeyPair requestKeyPair = generator.generateKeyPair();
final BigInteger publicKey = ((DHPublicKey)requestKeyPair.getPublic()).getY();
final DHPrivateKey privateKey = (DHPrivateKey)requestKeyPair.getPrivate();
KEY_REQUEST_DATA.add(new DiffieHellmanExchange.RequestData(PARAMETERS_ID, publicKey, privateKey));
KEY_REQUEST_DATA.add(new SymmetricWrappedExchange.RequestData(KeyId.SESSION));
KEY_REQUEST_DATA.add(new SymmetricWrappedExchange.RequestData(KeyId.PSK));
PEER_MASTER_TOKEN = MslTestUtils.getMasterToken(p2pCtx, 1, 2);
PEER_USER_ID_TOKEN = MslTestUtils.getUserIdToken(p2pCtx, PEER_MASTER_TOKEN, 1, MockEmailPasswordAuthenticationFactory.USER);
final KeyRequestData peerKeyRequestData = new SymmetricWrappedExchange.RequestData(KeyId.SESSION);
PEER_KEY_REQUEST_DATA.add(peerKeyRequestData);
PEER_KEY_REQUEST_DATA.add(new SymmetricWrappedExchange.RequestData(KeyId.PSK));
final byte[] mke = new byte[16];
final byte[] mkh = new byte[32];
final byte[] mkw = new byte[16];
random.nextBytes(mke);
random.nextBytes(mkh);
random.nextBytes(mkw);
final SecretKey encryptionKey = new SecretKeySpec(mke, JcaAlgorithm.AES);
final SecretKey hmacKey = new SecretKeySpec(mkh, JcaAlgorithm.HMAC_SHA256);
final SecretKey wrappingKey = new SecretKeySpec(mkw, JcaAlgorithm.AESKW);
ALT_MSL_CRYPTO_CONTEXT = new SymmetricCryptoContext(trustedNetCtx, "clientMslCryptoContext", encryptionKey, hmacKey, wrappingKey);
}
}
@AfterClass
public static synchronized void teardown() {
// Teardown causes problems because the data is shared by the inner
// classes, so don't do any cleanup.
}
/** Common tests. */
public static class Tests {
@Test
public void incrementMessageId() {
final long one = MessageBuilder.incrementMessageId(0);
assertEquals(1, one);
final long zero = MessageBuilder.incrementMessageId(MslConstants.MAX_LONG_VALUE);
assertEquals(0, zero);
for (int i = 0; i < 1000; ++i) {
long initial = -1;
do {
initial = random.nextLong();
} while (initial < 0 || initial > MslConstants.MAX_LONG_VALUE);
final long next = MessageBuilder.incrementMessageId(initial);
assertEquals((initial != MslConstants.MAX_LONG_VALUE) ? initial + 1 : 0, next);
}
}
@Test(expected = MslInternalException.class)
public void incrementNegativeMessageId() {
MessageBuilder.incrementMessageId(-1);
}
@Test(expected = MslInternalException.class)
public void incrementTooLargeMessageId() {
MessageBuilder.incrementMessageId(MslConstants.MAX_LONG_VALUE + 1);
}
@Test
public void decrementMessageId() {
final long max = MessageBuilder.decrementMessageId(0);
assertEquals(MslConstants.MAX_LONG_VALUE, max);
final long max_m1 = MessageBuilder.decrementMessageId(MslConstants.MAX_LONG_VALUE);
assertEquals(MslConstants.MAX_LONG_VALUE - 1, max_m1);
for (int i = 0; i < 1000; ++i) {
long initial = -1;
do {
initial = random.nextLong();
} while (initial < 0 || initial > MslConstants.MAX_LONG_VALUE);
final long next = MessageBuilder.decrementMessageId(initial);
assertEquals((initial != 0) ? initial - 1 : MslConstants.MAX_LONG_VALUE, next);
}
}
@Test(expected = MslInternalException.class)
public void decrementNegativeMessageId() {
MessageBuilder.decrementMessageId(-1);
}
@Test(expected = MslInternalException.class)
public void decrementTooLargeMessageId() {
MessageBuilder.decrementMessageId(MslConstants.MAX_LONG_VALUE + 1);
}
}
/** Create request unit tests. */
public static class CreateRequestTest {
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@Before
public void reset() {
trustedNetCtx.getMslStore().clearCryptoContexts();
trustedNetCtx.getMslStore().clearServiceTokens();
p2pCtx.getMslStore().clearCryptoContexts();
p2pCtx.getMslStore().clearServiceTokens();
}
@Test
public void createNullRequest() throws MslException {
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, null, null);
assertTrue(builder.willEncryptHeader());
assertTrue(builder.willEncryptPayloads());
assertTrue(builder.willIntegrityProtectHeader());
assertTrue(builder.willIntegrityProtectPayloads());
final MessageHeader header = builder.getHeader();
assertNotNull(header);
assertNull(header.getNonReplayableId());
assertFalse(header.isRenewable());
assertFalse(header.isHandshake());
assertNotNull(header.getCryptoContext());
assertEquals(trustedNetCtx.getEntityAuthenticationData(null), header.getEntityAuthenticationData());
assertTrue(header.getKeyRequestData().isEmpty());
assertNull(header.getKeyResponseData());
assertNull(header.getMasterToken());
assertTrue(header.getMessageId() >= 0);
assertEquals(trustedNetCtx.getMessageCapabilities(), header.getMessageCapabilities());
assertNull(header.getPeerMasterToken());
assertTrue(header.getPeerServiceTokens().isEmpty());
assertNull(header.getPeerUserIdToken());
assertTrue(header.getServiceTokens().isEmpty());
assertNull(header.getUserAuthenticationData());
assertNull(header.getUserIdToken());
}
@Test
public void createNullPeerRequest() throws MslException {
final MessageBuilder builder = messageFactory.createRequest(p2pCtx, null, null);
assertTrue(builder.willEncryptHeader());
assertTrue(builder.willEncryptPayloads());
assertTrue(builder.willIntegrityProtectHeader());
assertTrue(builder.willIntegrityProtectPayloads());
final MessageHeader header = builder.getHeader();
assertNotNull(header);
assertNull(header.getNonReplayableId());
assertFalse(header.isRenewable());
assertFalse(header.isHandshake());
assertNotNull(header.getCryptoContext());
assertEquals(p2pCtx.getEntityAuthenticationData(null), header.getEntityAuthenticationData());
assertTrue(header.getKeyRequestData().isEmpty());
assertNull(header.getKeyResponseData());
assertNull(header.getMasterToken());
assertTrue(header.getMessageId() >= 0);
assertEquals(p2pCtx.getMessageCapabilities(), header.getMessageCapabilities());
assertNull(header.getPeerMasterToken());
assertTrue(header.getPeerServiceTokens().isEmpty());
assertNull(header.getPeerUserIdToken());
assertTrue(header.getServiceTokens().isEmpty());
assertNull(header.getUserAuthenticationData());
assertNull(header.getUserIdToken());
}
@Test
public void createRequest() throws MslException {
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
builder.addKeyRequestData(keyRequestData);
for (final ServiceToken serviceToken : serviceTokens)
builder.addServiceToken(serviceToken);
builder.setNonReplayable(true);
builder.setRenewable(true);
assertTrue(builder.willEncryptHeader());
assertTrue(builder.willEncryptPayloads());
assertTrue(builder.willIntegrityProtectHeader());
assertTrue(builder.willIntegrityProtectPayloads());
assertEquals(serviceTokens, builder.getServiceTokens());
assertTrue(builder.getPeerServiceTokens().isEmpty());
final MessageHeader header = builder.getHeader();
assertNotNull(header);
assertNotNull(header.getNonReplayableId());
assertTrue(header.isRenewable());
assertFalse(header.isHandshake());
assertNotNull(header.getCryptoContext());
assertNull(header.getEntityAuthenticationData());
assertTrue(header.getKeyRequestData().equals(KEY_REQUEST_DATA));
assertNull(header.getKeyResponseData());
assertEquals(MASTER_TOKEN, header.getMasterToken());
assertTrue(header.getMessageId() >= 0);
assertEquals(trustedNetCtx.getMessageCapabilities(), header.getMessageCapabilities());
assertNotNull(header.getNonReplayableId());
assertNull(header.getPeerMasterToken());
assertTrue(header.getPeerServiceTokens().isEmpty());
assertNull(header.getPeerUserIdToken());
assertTrue(header.getServiceTokens().equals(serviceTokens));
assertNull(header.getUserAuthenticationData());
assertEquals(USER_ID_TOKEN, header.getUserIdToken());
}
@Test
public void createRequestWithMessageId() throws MslEncodingException, MslCryptoException, MslMessageException, MslMasterTokenException, MslEntityAuthException, MslException {
final long messageId = 17;
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN, messageId);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
builder.addKeyRequestData(keyRequestData);
for (final ServiceToken serviceToken : serviceTokens)
builder.addServiceToken(serviceToken);
builder.setNonReplayable(true);
builder.setRenewable(true);
assertTrue(builder.willEncryptHeader());
assertTrue(builder.willEncryptPayloads());
assertTrue(builder.willIntegrityProtectHeader());
assertTrue(builder.willIntegrityProtectPayloads());
assertEquals(serviceTokens, builder.getServiceTokens());
assertTrue(builder.getPeerServiceTokens().isEmpty());
final MessageHeader header = builder.getHeader();
assertNotNull(header);
assertTrue(header.isRenewable());
assertFalse(header.isHandshake());
assertNotNull(header.getCryptoContext());
assertNull(header.getEntityAuthenticationData());
assertTrue(header.getKeyRequestData().equals(KEY_REQUEST_DATA));
assertNull(header.getKeyResponseData());
assertEquals(MASTER_TOKEN, header.getMasterToken());
assertEquals(messageId, header.getMessageId());
assertEquals(trustedNetCtx.getMessageCapabilities(), header.getMessageCapabilities());
assertNotNull(header.getNonReplayableId());
assertNull(header.getPeerMasterToken());
assertTrue(header.getPeerServiceTokens().isEmpty());
assertNull(header.getPeerUserIdToken());
assertTrue(header.getServiceTokens().equals(serviceTokens));
assertNull(header.getUserAuthenticationData());
assertEquals(USER_ID_TOKEN, header.getUserIdToken());
}
@Test
public void createPeerRequest() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
final MessageBuilder builder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
builder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
builder.addKeyRequestData(keyRequestData);
for (final ServiceToken serviceToken : serviceTokens)
builder.addServiceToken(serviceToken);
builder.setNonReplayable(true);
builder.setRenewable(true);
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
for (final ServiceToken peerServiceToken : peerServiceTokens)
builder.addPeerServiceToken(peerServiceToken);
assertTrue(builder.willEncryptHeader());
assertTrue(builder.willEncryptPayloads());
assertTrue(builder.willIntegrityProtectHeader());
assertTrue(builder.willIntegrityProtectPayloads());
assertEquals(serviceTokens, builder.getServiceTokens());
assertEquals(peerServiceTokens, builder.getPeerServiceTokens());
final MessageHeader header = builder.getHeader();
assertNotNull(header);
assertTrue(header.isRenewable());
assertFalse(header.isHandshake());
assertNotNull(header.getCryptoContext());
assertNull(header.getEntityAuthenticationData());
assertTrue(header.getKeyRequestData().equals(KEY_REQUEST_DATA));
assertNull(header.getKeyResponseData());
assertEquals(MASTER_TOKEN, header.getMasterToken());
assertTrue(header.getMessageId() >= 0);
assertEquals(p2pCtx.getMessageCapabilities(), header.getMessageCapabilities());
assertNotNull(header.getNonReplayableId());
assertEquals(PEER_MASTER_TOKEN, header.getPeerMasterToken());
assertTrue(header.getPeerServiceTokens().equals(peerServiceTokens));
assertEquals(PEER_USER_ID_TOKEN, header.getPeerUserIdToken());
assertTrue(header.getServiceTokens().equals(serviceTokens));
assertNull(header.getUserAuthenticationData());
assertEquals(USER_ID_TOKEN, header.getUserIdToken());
}
@Test
public void createHandshakeRequest() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException, MslException {
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, null, null);
builder.setNonReplayable(true);
builder.setRenewable(false);
builder.setHandshake(true);
assertFalse(builder.isNonReplayable());
assertTrue(builder.isHandshake());
assertTrue(builder.isRenewable());
final MessageHeader header = builder.getHeader();
assertNotNull(header);
assertTrue(header.isRenewable());
assertTrue(header.isHandshake());
assertNotNull(header.getCryptoContext());
assertEquals(trustedNetCtx.getEntityAuthenticationData(null), header.getEntityAuthenticationData());
assertTrue(header.getKeyRequestData().isEmpty());
assertNull(header.getKeyResponseData());
assertNull(header.getMasterToken());
assertTrue(header.getMessageId() >= 0);
assertEquals(trustedNetCtx.getMessageCapabilities(), header.getMessageCapabilities());
assertNull(header.getNonReplayableId());
assertNull(header.getPeerMasterToken());
assertTrue(header.getPeerServiceTokens().isEmpty());
assertNull(header.getPeerUserIdToken());
assertTrue(header.getServiceTokens().isEmpty());
assertNull(header.getUserAuthenticationData());
assertNull(header.getUserIdToken());
}
@Test
public void createPeerHandshakeRequest() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException, MslException {
final MessageBuilder builder = messageFactory.createRequest(p2pCtx, null, null);
builder.setNonReplayable(true);
builder.setRenewable(false);
builder.setHandshake(true);
assertFalse(builder.isNonReplayable());
assertTrue(builder.isHandshake());
assertTrue(builder.isRenewable());
final MessageHeader header = builder.getHeader();
assertNotNull(header);
assertNull(header.getNonReplayableId());
assertTrue(header.isRenewable());
assertTrue(header.isHandshake());
assertNotNull(header.getCryptoContext());
assertEquals(p2pCtx.getEntityAuthenticationData(null), header.getEntityAuthenticationData());
assertTrue(header.getKeyRequestData().isEmpty());
assertNull(header.getKeyResponseData());
assertNull(header.getMasterToken());
assertTrue(header.getMessageId() >= 0);
assertEquals(p2pCtx.getMessageCapabilities(), header.getMessageCapabilities());
assertNull(header.getPeerMasterToken());
assertTrue(header.getPeerServiceTokens().isEmpty());
assertNull(header.getPeerUserIdToken());
assertTrue(header.getServiceTokens().isEmpty());
assertNull(header.getUserAuthenticationData());
assertNull(header.getUserIdToken());
}
@Test
public void willEncryptX509EntityAuth() throws MslException {
final MslContext x509Ctx = new MockMslContext(EntityAuthenticationScheme.X509, false);
final MessageBuilder builder = messageFactory.createRequest(x509Ctx, null, null);
assertFalse(builder.willEncryptHeader());
assertFalse(builder.willEncryptPayloads());
assertTrue(builder.willIntegrityProtectHeader());
assertTrue(builder.willIntegrityProtectPayloads());
}
@Test
public void willIntegrityProtectNoneAuth() throws MslException {
final MslContext noneCtx = new MockMslContext(EntityAuthenticationScheme.NONE, false);
final MessageBuilder builder = messageFactory.createRequest(noneCtx, null, null);
assertFalse(builder.willEncryptHeader());
assertFalse(builder.willEncryptPayloads());
assertFalse(builder.willIntegrityProtectHeader());
assertFalse(builder.willIntegrityProtectPayloads());
}
@Test
public void storedServiceTokens() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final MslStore store = trustedNetCtx.getMslStore();
store.setCryptoContext(MASTER_TOKEN, CRYPTO_CONTEXT);
store.addUserIdToken(USER_ID, USER_ID_TOKEN);
store.setCryptoContext(PEER_MASTER_TOKEN, CRYPTO_CONTEXT);
store.addUserIdToken(PEER_USER_ID, PEER_USER_ID_TOKEN);
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
store.addServiceTokens(serviceTokens);
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
store.addServiceTokens(peerServiceTokens);
// The message will include all unbound service tokens.
final Set<ServiceToken> updatedServiceTokens = new HashSet<ServiceToken>(serviceTokens);
for (final ServiceToken peerServiceToken : peerServiceTokens) {
if (peerServiceToken.isUnbound())
updatedServiceTokens.add(peerServiceToken);
}
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
assertEquals(updatedServiceTokens, builder.getServiceTokens());
assertTrue(builder.getPeerServiceTokens().isEmpty());
final MessageHeader header = builder.getHeader();
assertTrue(header.getServiceTokens().equals(updatedServiceTokens));
assertTrue(header.getPeerServiceTokens().isEmpty());
}
@Test
public void storedPeerServiceTokens() throws MslEncodingException, MslCryptoException, MslMessageException, MslMasterTokenException, MslEntityAuthException, MslException {
final MslStore store = p2pCtx.getMslStore();
store.setCryptoContext(MASTER_TOKEN, CRYPTO_CONTEXT);
store.addUserIdToken(USER_ID, USER_ID_TOKEN);
store.setCryptoContext(PEER_MASTER_TOKEN, CRYPTO_CONTEXT);
store.addUserIdToken(PEER_USER_ID, PEER_USER_ID_TOKEN);
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
store.addServiceTokens(serviceTokens);
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
store.addServiceTokens(peerServiceTokens);
// The non-peer service tokens will include all unbound service
// tokens.
final Set<ServiceToken> updatedServiceTokens = new HashSet<ServiceToken>(serviceTokens);
for (final ServiceToken peerServiceToken : peerServiceTokens) {
if (peerServiceToken.isUnbound())
updatedServiceTokens.add(peerServiceToken);
}
// The peer service tokens will include all unbound service tokens.
final Set<ServiceToken> updatedPeerServiceTokens = new HashSet<ServiceToken>(peerServiceTokens);
for (final ServiceToken serviceToken : serviceTokens) {
if (serviceToken.isUnbound())
updatedPeerServiceTokens.add(serviceToken);
}
final MessageBuilder builder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
builder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
assertEquals(updatedServiceTokens, builder.getServiceTokens());
assertEquals(updatedPeerServiceTokens, builder.getPeerServiceTokens());
final MessageHeader header = builder.getHeader();
assertTrue(header.getServiceTokens().equals(updatedServiceTokens));
assertTrue(header.getPeerServiceTokens().equals(updatedPeerServiceTokens));
}
@Test
public void setUserAuthData() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
// Setting the user authentication data will replace the user ID token
// and remove any user ID token bound service tokens.
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
builder.addKeyRequestData(keyRequestData);
for (final ServiceToken serviceToken : serviceTokens)
builder.addServiceToken(serviceToken);
builder.setNonReplayable(true);
builder.setRenewable(true);
builder.setUserAuthenticationData(USER_AUTH_DATA);
assertEquals(serviceTokens, builder.getServiceTokens());
assertTrue(builder.getPeerServiceTokens().isEmpty());
final MessageHeader header = builder.getHeader();
assertNotNull(header.getNonReplayableId());
assertTrue(header.isRenewable());
assertNotNull(header.getCryptoContext());
assertNull(header.getEntityAuthenticationData());
assertTrue(header.getKeyRequestData().equals(KEY_REQUEST_DATA));
assertNull(header.getKeyResponseData());
assertEquals(MASTER_TOKEN, header.getMasterToken());
assertTrue(header.getMessageId() >= 0);
assertEquals(trustedNetCtx.getMessageCapabilities(), header.getMessageCapabilities());
assertNull(header.getPeerMasterToken());
assertTrue(header.getPeerServiceTokens().isEmpty());
assertNull(header.getPeerUserIdToken());
assertTrue(header.getServiceTokens().equals(serviceTokens));
assertEquals(USER_AUTH_DATA, header.getUserAuthenticationData());
assertEquals(USER_ID_TOKEN, header.getUserIdToken());
}
@Test
public void setUserAuthDataNull() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
builder.addKeyRequestData(keyRequestData);
for (final ServiceToken serviceToken : serviceTokens)
builder.addServiceToken(serviceToken);
builder.setNonReplayable(true);
builder.setRenewable(true);
builder.setUserAuthenticationData(null);
assertEquals(serviceTokens, builder.getServiceTokens());
assertTrue(builder.getPeerServiceTokens().isEmpty());
final MessageHeader header = builder.getHeader();
assertNotNull(header.getNonReplayableId());
assertTrue(header.isRenewable());
assertNotNull(header.getCryptoContext());
assertNull(header.getEntityAuthenticationData());
assertTrue(header.getKeyRequestData().equals(KEY_REQUEST_DATA));
assertNull(header.getKeyResponseData());
assertEquals(MASTER_TOKEN, header.getMasterToken());
assertTrue(header.getMessageId() >= 0);
assertEquals(trustedNetCtx.getMessageCapabilities(), header.getMessageCapabilities());
assertNull(header.getPeerMasterToken());
assertTrue(header.getPeerServiceTokens().isEmpty());
assertNull(header.getPeerUserIdToken());
assertTrue(header.getServiceTokens().equals(serviceTokens));
assertNull(header.getUserAuthenticationData());
assertEquals(USER_ID_TOKEN, header.getUserIdToken());
}
@Test
public void unsetUserAuthData() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
builder.addKeyRequestData(keyRequestData);
for (final ServiceToken serviceToken : serviceTokens)
builder.addServiceToken(serviceToken);
builder.setNonReplayable(true);
builder.setRenewable(true);
builder.setUserAuthenticationData(USER_AUTH_DATA);
builder.setUserAuthenticationData(null);
assertEquals(serviceTokens, builder.getServiceTokens());
assertTrue(builder.getPeerServiceTokens().isEmpty());
final MessageHeader header = builder.getHeader();
assertNotNull(header.getNonReplayableId());
assertTrue(header.isRenewable());
assertNotNull(header.getCryptoContext());
assertNull(header.getEntityAuthenticationData());
assertTrue(header.getKeyRequestData().equals(KEY_REQUEST_DATA));
assertNull(header.getKeyResponseData());
assertEquals(MASTER_TOKEN, header.getMasterToken());
assertTrue(header.getMessageId() >= 0);
assertEquals(trustedNetCtx.getMessageCapabilities(), header.getMessageCapabilities());
assertNull(header.getPeerMasterToken());
assertTrue(header.getPeerServiceTokens().isEmpty());
assertNull(header.getPeerUserIdToken());
assertTrue(header.getServiceTokens().equals(serviceTokens));
assertNull(header.getUserAuthenticationData());
assertEquals(USER_ID_TOKEN, header.getUserIdToken());
}
@Test
public void overwriteKeyRequestData() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, null, null);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
builder.addKeyRequestData(keyRequestData);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
builder.addKeyRequestData(keyRequestData);
final MessageHeader header = builder.getHeader();
assertNull(header.getNonReplayableId());
assertFalse(header.isRenewable());
assertNotNull(header.getCryptoContext());
assertEquals(trustedNetCtx.getEntityAuthenticationData(null), header.getEntityAuthenticationData());
assertTrue(header.getKeyRequestData().equals(KEY_REQUEST_DATA));
assertNull(header.getKeyResponseData());
assertNull(header.getMasterToken());
assertTrue(header.getMessageId() >= 0);
assertEquals(trustedNetCtx.getMessageCapabilities(), header.getMessageCapabilities());
assertNull(header.getPeerMasterToken());
assertTrue(header.getPeerServiceTokens().isEmpty());
assertNull(header.getPeerUserIdToken());
assertTrue(header.getServiceTokens().isEmpty());
assertNull(header.getUserAuthenticationData());
assertNull(header.getUserIdToken());
}
@Test
public void removeKeyRequestData() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, null, null);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
builder.addKeyRequestData(keyRequestData);
final KeyRequestData keyRequestData = KEY_REQUEST_DATA.toArray(new KeyRequestData[0])[0];
final Set<KeyRequestData> updatedKeyRequestData = new HashSet<KeyRequestData>(KEY_REQUEST_DATA);
updatedKeyRequestData.remove(keyRequestData);
builder.removeKeyRequestData(keyRequestData);
builder.removeKeyRequestData(keyRequestData);
final MessageHeader header = builder.getHeader();
assertNull(header.getNonReplayableId());
assertFalse(header.isRenewable());
assertNotNull(header.getCryptoContext());
assertEquals(trustedNetCtx.getEntityAuthenticationData(null), header.getEntityAuthenticationData());
assertTrue(header.getKeyRequestData().equals(updatedKeyRequestData));
assertNull(header.getKeyResponseData());
assertNull(header.getMasterToken());
assertTrue(header.getMessageId() >= 0);
assertEquals(trustedNetCtx.getMessageCapabilities(), header.getMessageCapabilities());
assertNull(header.getPeerMasterToken());
assertTrue(header.getPeerServiceTokens().isEmpty());
assertNull(header.getPeerUserIdToken());
assertTrue(header.getServiceTokens().isEmpty());
assertNull(header.getUserAuthenticationData());
assertNull(header.getUserIdToken());
}
@Test
public void nonReplayableMissingMasterToken() throws MslException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.NONREPLAYABLE_MESSAGE_REQUIRES_MASTERTOKEN);
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, null, null);
builder.setNonReplayable(true);
builder.getHeader();
}
@Test
public void mismatchedMasterTokenAddTokenServiceToken() throws MslException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.SERVICETOKEN_MASTERTOKEN_MISMATCH);
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, null);
final byte[] data = new byte[1];
random.nextBytes(data);
final ServiceToken serviceToken = new ServiceToken(trustedNetCtx, SERVICE_TOKEN_NAME, data, PEER_MASTER_TOKEN, null, false, null, new NullCryptoContext());
builder.addServiceToken(serviceToken);
}
@Test
public void nullMasterTokenAddServiceToken() throws MslException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.SERVICETOKEN_MASTERTOKEN_MISMATCH);
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, null, null);
final byte[] data = new byte[1];
random.nextBytes(data);
final ServiceToken serviceToken = new ServiceToken(trustedNetCtx, SERVICE_TOKEN_NAME, data, MASTER_TOKEN, null, false, null, new NullCryptoContext());
builder.addServiceToken(serviceToken);
}
@Test
public void mismatchedUserIdTokenAddServiceToken() throws MslException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.SERVICETOKEN_USERIDTOKEN_MISMATCH);
final UserIdToken userIdTokenA = MslTestUtils.getUserIdToken(trustedNetCtx, MASTER_TOKEN, 1, MockEmailPasswordAuthenticationFactory.USER);
final UserIdToken userIdTokenB = MslTestUtils.getUserIdToken(trustedNetCtx, MASTER_TOKEN, 2, MockEmailPasswordAuthenticationFactory.USER);
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, userIdTokenA);
final byte[] data = new byte[1];
random.nextBytes(data);
final ServiceToken serviceToken = new ServiceToken(trustedNetCtx, SERVICE_TOKEN_NAME, data, MASTER_TOKEN, userIdTokenB, false, null, new NullCryptoContext());
builder.addServiceToken(serviceToken);
}
@Test
public void nullUserIdTokenAddServiceToken() throws MslException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.SERVICETOKEN_USERIDTOKEN_MISMATCH);
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, null);
final byte[] data = new byte[1];
random.nextBytes(data);
final ServiceToken serviceToken = new ServiceToken(trustedNetCtx, SERVICE_TOKEN_NAME, data, MASTER_TOKEN, USER_ID_TOKEN, false, null, new NullCryptoContext());
builder.addServiceToken(serviceToken);
}
@Test
public void addNamedServiceTokens() throws MslException {
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
final byte[] data = new byte[1];
random.nextBytes(data);
final ServiceToken unboundServiceTokenA = new ServiceToken(trustedNetCtx, SERVICE_TOKEN_NAME, data, null, null, false, null, new NullCryptoContext());
builder.addServiceToken(unboundServiceTokenA);
assertEquals(1, builder.getServiceTokens().size());
final ServiceToken unboundServiceTokenB = new ServiceToken(trustedNetCtx, SERVICE_TOKEN_NAME, data, null, null, false, null, new NullCryptoContext());
builder.addServiceToken(unboundServiceTokenB);
assertEquals(1, builder.getServiceTokens().size());
final ServiceToken masterBoundServiceTokenA = new ServiceToken(trustedNetCtx, SERVICE_TOKEN_NAME, data, MASTER_TOKEN, null, false, null, new NullCryptoContext());
builder.addServiceToken(masterBoundServiceTokenA);
assertEquals(2, builder.getServiceTokens().size());
final ServiceToken masterBoundServiceTokenB = new ServiceToken(trustedNetCtx, SERVICE_TOKEN_NAME, data, MASTER_TOKEN, null, false, null, new NullCryptoContext());
builder.addServiceToken(masterBoundServiceTokenB);
assertEquals(2, builder.getServiceTokens().size());
final ServiceToken userBoundServiceTokenA = new ServiceToken(trustedNetCtx, SERVICE_TOKEN_NAME, data, MASTER_TOKEN, USER_ID_TOKEN, false, null, new NullCryptoContext());
builder.addServiceToken(userBoundServiceTokenA);
assertEquals(3, builder.getServiceTokens().size());
final ServiceToken userBoundServiceTokenB = new ServiceToken(trustedNetCtx, SERVICE_TOKEN_NAME, data, MASTER_TOKEN, USER_ID_TOKEN, false, null, new NullCryptoContext());
builder.addServiceToken(userBoundServiceTokenB);
assertEquals(3, builder.getServiceTokens().size());
}
@Test
public void excludeServiceToken() throws MslEncodingException, MslCryptoException, MslException {
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
for (final ServiceToken serviceToken : serviceTokens)
builder.addServiceToken(serviceToken);
final Iterator<ServiceToken> tokens = serviceTokens.iterator();
while (tokens.hasNext()) {
final ServiceToken token = tokens.next();
builder.excludeServiceToken(token.getName(), token.isMasterTokenBound(), token.isUserIdTokenBound());
tokens.remove();
final MessageHeader messageHeader = builder.getHeader();
assertTrue(messageHeader.getServiceTokens().equals(serviceTokens));
}
}
@Test
public void excludeServiceTokenAlternate() throws MslEncodingException, MslCryptoException, MslException {
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
for (final ServiceToken serviceToken : serviceTokens)
builder.addServiceToken(serviceToken);
final Iterator<ServiceToken> tokens = serviceTokens.iterator();
while (tokens.hasNext()) {
final ServiceToken token = tokens.next();
builder.excludeServiceToken(token);
tokens.remove();
final MessageHeader messageHeader = builder.getHeader();
assertTrue(messageHeader.getServiceTokens().equals(serviceTokens));
}
}
@Test
public void deleteServiceToken() throws MslException {
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
// The service token must exist before it can be deleted.
final byte[] data = new byte[1];
random.nextBytes(data);
final ServiceToken serviceToken = new ServiceToken(trustedNetCtx, SERVICE_TOKEN_NAME, data, MASTER_TOKEN, USER_ID_TOKEN, false, null, new NullCryptoContext());
builder.addServiceToken(serviceToken);
// Delete the service token.
builder.deleteServiceToken(SERVICE_TOKEN_NAME, true, true);
final MessageHeader messageHeader = builder.getHeader();
final Set<ServiceToken> tokens = messageHeader.getServiceTokens();
for (final ServiceToken token : tokens) {
if (token.getName().equals(SERVICE_TOKEN_NAME)) {
assertEquals(0, token.getData().length);
return;
}
}
fail("Deleted service token not found.");
}
@Test
public void deleteServiceTokenAlternate() throws MslException {
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
// The service token must exist before it can be deleted.
final byte[] data = new byte[1];
random.nextBytes(data);
final ServiceToken serviceToken = new ServiceToken(trustedNetCtx, SERVICE_TOKEN_NAME, data, MASTER_TOKEN, USER_ID_TOKEN, false, null, new NullCryptoContext());
builder.addServiceToken(serviceToken);
// Delete the service token.
builder.deleteServiceToken(serviceToken);
final MessageHeader messageHeader = builder.getHeader();
final Set<ServiceToken> tokens = messageHeader.getServiceTokens();
for (final ServiceToken token : tokens) {
if (token.getName().equals(SERVICE_TOKEN_NAME)) {
assertEquals(0, token.getData().length);
return;
}
}
fail("Deleted service token not found.");
}
@Test
public void deleteUnknownServiceToken() throws MslException {
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
builder.deleteServiceToken(SERVICE_TOKEN_NAME, true, true);
final MessageHeader messageHeader = builder.getHeader();
final Set<ServiceToken> tokens = messageHeader.getServiceTokens();
for (final ServiceToken token : tokens) {
if (token.getName().equals(SERVICE_TOKEN_NAME)) {
assertEquals(0, token.getData().length);
return;
}
}
fail("Deleted unknown service token not found.");
}
@Test(expected = MslInternalException.class)
public void notP2PCreatePeerRequest() throws MslException {
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
builder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
}
@Test(expected = MslInternalException.class)
public void missingPeerMasterTokenCreatePeerRequest() throws MslException {
final MessageBuilder builder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
builder.setPeerAuthTokens(null, PEER_USER_ID_TOKEN);
}
@Test(expected = MslException.class)
public void mismatchedPeerMasterTokenCreatePeerRequest() throws MslException {
final MessageBuilder builder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
builder.setPeerAuthTokens(MASTER_TOKEN, PEER_USER_ID_TOKEN);
}
@Test(expected = MslInternalException.class)
public void notP2PAddPeerServiceToken() throws MslEncodingException, MslCryptoException, MslException {
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
final ServiceToken peerServiceToken = new ServiceToken(trustedNetCtx, SERVICE_TOKEN_NAME, new byte[0], null, null, false, null, new NullCryptoContext());
builder.addPeerServiceToken(peerServiceToken);
}
@Test
public void missingPeerMasterTokenAddPeerServiceToken() throws MslException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.SERVICETOKEN_MASTERTOKEN_MISMATCH);
final MessageBuilder builder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
final ServiceToken peerServiceToken = new ServiceToken(p2pCtx, SERVICE_TOKEN_NAME, new byte[0], PEER_MASTER_TOKEN, null, false, null, new NullCryptoContext());
builder.addPeerServiceToken(peerServiceToken);
}
@Test
public void mismatchedPeerMasterTokenAddPeerServiceToken() throws MslEncodingException, MslCryptoException, MslException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.SERVICETOKEN_MASTERTOKEN_MISMATCH);
final MessageBuilder builder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
builder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final ServiceToken peerServiceToken = new ServiceToken(trustedNetCtx, SERVICE_TOKEN_NAME, new byte[0], MASTER_TOKEN, null, false, null, new NullCryptoContext());
builder.addPeerServiceToken(peerServiceToken);
}
@Test
public void missingPeerUserIdTokenAddPeerServiceToken() throws MslException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.SERVICETOKEN_USERIDTOKEN_MISMATCH);
final MessageBuilder builder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
builder.setPeerAuthTokens(PEER_MASTER_TOKEN, null);
final ServiceToken peerServiceToken = new ServiceToken(p2pCtx, SERVICE_TOKEN_NAME, new byte[0], PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, false, null, new NullCryptoContext());
builder.addPeerServiceToken(peerServiceToken);
}
@Test
public void mismatchedPeerUserIdTokenAddPeerServiceToken() throws MslException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.SERVICETOKEN_USERIDTOKEN_MISMATCH);
final UserIdToken userIdTokenA = MslTestUtils.getUserIdToken(p2pCtx, PEER_MASTER_TOKEN, 1, MockEmailPasswordAuthenticationFactory.USER);
final UserIdToken userIdTokenB = MslTestUtils.getUserIdToken(p2pCtx, PEER_MASTER_TOKEN, 2, MockEmailPasswordAuthenticationFactory.USER);
final MessageBuilder builder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
builder.setPeerAuthTokens(PEER_MASTER_TOKEN, userIdTokenA);
final ServiceToken peerServiceToken = new ServiceToken(p2pCtx, SERVICE_TOKEN_NAME, new byte[0], PEER_MASTER_TOKEN, userIdTokenB, false, null, new NullCryptoContext());
builder.addPeerServiceToken(peerServiceToken);
}
@Test
public void addNamedPeerServiceTokens() throws MslException {
final MessageBuilder builder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
builder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final byte[] data = new byte[1];
random.nextBytes(data);
final ServiceToken unboundServiceTokenA = new ServiceToken(p2pCtx, SERVICE_TOKEN_NAME, data, null, null, false, null, new NullCryptoContext());
builder.addPeerServiceToken(unboundServiceTokenA);
assertEquals(1, builder.getPeerServiceTokens().size());
final ServiceToken unboundServiceTokenB = new ServiceToken(p2pCtx, SERVICE_TOKEN_NAME, data, null, null, false, null, new NullCryptoContext());
builder.addPeerServiceToken(unboundServiceTokenB);
assertEquals(1, builder.getPeerServiceTokens().size());
final ServiceToken masterBoundServiceTokenA = new ServiceToken(p2pCtx, SERVICE_TOKEN_NAME, data, PEER_MASTER_TOKEN, null, false, null, new NullCryptoContext());
builder.addPeerServiceToken(masterBoundServiceTokenA);
assertEquals(2, builder.getPeerServiceTokens().size());
final ServiceToken masterBoundServiceTokenB = new ServiceToken(p2pCtx, SERVICE_TOKEN_NAME, data, PEER_MASTER_TOKEN, null, false, null, new NullCryptoContext());
builder.addPeerServiceToken(masterBoundServiceTokenB);
assertEquals(2, builder.getPeerServiceTokens().size());
final ServiceToken userBoundServiceTokenA = new ServiceToken(p2pCtx, SERVICE_TOKEN_NAME, data, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, false, null, new NullCryptoContext());
builder.addPeerServiceToken(userBoundServiceTokenA);
assertEquals(3, builder.getPeerServiceTokens().size());
final ServiceToken userBoundServiceTokenB = new ServiceToken(p2pCtx, SERVICE_TOKEN_NAME, data, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, false, null, new NullCryptoContext());
builder.addPeerServiceToken(userBoundServiceTokenB);
assertEquals(3, builder.getPeerServiceTokens().size());
}
@Test
public void excludePeerServiceToken() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final MessageBuilder builder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
builder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
for (final ServiceToken serviceToken : serviceTokens)
builder.addPeerServiceToken(serviceToken);
final Iterator<ServiceToken> tokens = serviceTokens.iterator();
while (tokens.hasNext()) {
final ServiceToken token = tokens.next();
builder.excludePeerServiceToken(token.getName(), token.isMasterTokenBound(), token.isUserIdTokenBound());
tokens.remove();
assertEquals(serviceTokens, builder.getPeerServiceTokens());
final MessageHeader messageHeader = builder.getHeader();
assertEquals(serviceTokens, messageHeader.getPeerServiceTokens());
}
}
@Test
public void excludePeerServiceTokenAlternate() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final MessageBuilder builder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
builder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
for (final ServiceToken serviceToken : serviceTokens)
builder.addPeerServiceToken(serviceToken);
final Iterator<ServiceToken> tokens = serviceTokens.iterator();
while (tokens.hasNext()) {
final ServiceToken token = tokens.next();
builder.excludePeerServiceToken(token);
tokens.remove();
assertEquals(serviceTokens, builder.getPeerServiceTokens());
final MessageHeader messageHeader = builder.getHeader();
assertEquals(serviceTokens, messageHeader.getPeerServiceTokens());
}
}
@Test
public void deletePeerServiceToken() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final MessageBuilder builder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
builder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
// The service token must exist before it can be deleted.
final byte[] data = new byte[1];
random.nextBytes(data);
final ServiceToken serviceToken = new ServiceToken(p2pCtx, SERVICE_TOKEN_NAME, data, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, false, null, new NullCryptoContext());
builder.addPeerServiceToken(serviceToken);
// Delete the service token.
builder.deletePeerServiceToken(SERVICE_TOKEN_NAME, true, true);
final MessageHeader messageHeader = builder.getHeader();
final Set<ServiceToken> tokens = messageHeader.getPeerServiceTokens();
for (final ServiceToken token : tokens) {
if (token.getName().equals(SERVICE_TOKEN_NAME)) {
assertEquals(0, token.getData().length);
return;
}
}
fail("Deleted peer service token not found.");
}
@Test
public void deletePeerServiceTokenAlternate() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final MessageBuilder builder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
builder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
// The service token must exist before it can be deleted.
final byte[] data = new byte[1];
random.nextBytes(data);
final ServiceToken serviceToken = new ServiceToken(p2pCtx, SERVICE_TOKEN_NAME, data, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, false, null, new NullCryptoContext());
builder.addPeerServiceToken(serviceToken);
// Delete the service token.
builder.deletePeerServiceToken(serviceToken);
final MessageHeader messageHeader = builder.getHeader();
final Set<ServiceToken> tokens = messageHeader.getPeerServiceTokens();
for (final ServiceToken token : tokens) {
if (token.getName().equals(SERVICE_TOKEN_NAME)) {
assertEquals(0, token.getData().length);
return;
}
}
fail("Deleted peer service token not found.");
}
@Test
public void deleteUnknownPeerServiceToken() throws MslException {
final MessageBuilder builder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
builder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
builder.deletePeerServiceToken(SERVICE_TOKEN_NAME, true, true);
final MessageHeader messageHeader = builder.getHeader();
final Set<ServiceToken> tokens = messageHeader.getPeerServiceTokens();
for (final ServiceToken token : tokens) {
if (token.getName().equals(SERVICE_TOKEN_NAME)) {
assertEquals(0, token.getData().length);
return;
}
}
fail("Deleted unknown peer service token not found.");
}
@Test
public void setMasterToken() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final MslStore store = trustedNetCtx.getMslStore();
store.setCryptoContext(MASTER_TOKEN, CRYPTO_CONTEXT);
store.setCryptoContext(PEER_MASTER_TOKEN, CRYPTO_CONTEXT);
store.addUserIdToken(PEER_USER_ID, PEER_USER_ID_TOKEN);
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, null);
store.addServiceTokens(serviceTokens);
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
store.addServiceTokens(peerServiceTokens);
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, null, null);
builder.setAuthTokens(MASTER_TOKEN, null);
// The message service tokens will include all unbound service
// tokens.
final Set<ServiceToken> updatedServiceTokens = new HashSet<ServiceToken>(serviceTokens);
for (final ServiceToken peerServiceToken : peerServiceTokens) {
if (peerServiceToken.isUnbound())
updatedServiceTokens.add(peerServiceToken);
}
assertEquals(updatedServiceTokens, builder.getServiceTokens());
assertTrue(builder.getPeerServiceTokens().isEmpty());
final MessageHeader messageHeader = builder.getHeader();
assertEquals(updatedServiceTokens, messageHeader.getServiceTokens());
assertTrue(messageHeader.getPeerServiceTokens().isEmpty());
}
@Test
public void setExistingMasterToken() throws MslException {
final MslStore store = trustedNetCtx.getMslStore();
store.setCryptoContext(MASTER_TOKEN, CRYPTO_CONTEXT);
store.addUserIdToken(USER_ID, USER_ID_TOKEN);
store.setCryptoContext(PEER_MASTER_TOKEN, CRYPTO_CONTEXT);
store.addUserIdToken(PEER_USER_ID, PEER_USER_ID_TOKEN);
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, null);
store.addServiceTokens(serviceTokens);
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
store.addServiceTokens(peerServiceTokens);
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, null);
builder.setAuthTokens(MASTER_TOKEN, null);
// The message service tokens will include all unbound service
// tokens.
final Set<ServiceToken> updatedServiceTokens = new HashSet<ServiceToken>(serviceTokens);
for (final ServiceToken peerServiceToken : peerServiceTokens) {
if (peerServiceToken.isUnbound())
updatedServiceTokens.add(peerServiceToken);
}
assertEquals(updatedServiceTokens, builder.getServiceTokens());
assertTrue(builder.getPeerServiceTokens().isEmpty());
final MessageHeader messageHeader = builder.getHeader();
assertEquals(updatedServiceTokens, messageHeader.getServiceTokens());
assertTrue(messageHeader.getPeerServiceTokens().isEmpty());
}
@Test
public void setAuthTokens() throws MslEncodingException, MslCryptoException, MslException {
final MslStore store = trustedNetCtx.getMslStore();
store.setCryptoContext(MASTER_TOKEN, CRYPTO_CONTEXT);
store.addUserIdToken(USER_ID, USER_ID_TOKEN);
store.setCryptoContext(PEER_MASTER_TOKEN, CRYPTO_CONTEXT);
store.addUserIdToken(PEER_USER_ID, PEER_USER_ID_TOKEN);
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
store.addServiceTokens(serviceTokens);
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
store.addServiceTokens(peerServiceTokens);
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, null, null);
builder.setAuthTokens(MASTER_TOKEN, USER_ID_TOKEN);
// The message service tokens will include all unbound service
// tokens.
final Set<ServiceToken> updatedServiceTokens = new HashSet<ServiceToken>(serviceTokens);
for (final ServiceToken peerServiceToken : peerServiceTokens) {
if (peerServiceToken.isUnbound())
updatedServiceTokens.add(peerServiceToken);
}
assertEquals(updatedServiceTokens, builder.getServiceTokens());
assertTrue(builder.getPeerServiceTokens().isEmpty());
final MessageHeader messageHeader = builder.getHeader();
assertEquals(updatedServiceTokens, messageHeader.getServiceTokens());
assertTrue(messageHeader.getPeerServiceTokens().isEmpty());
}
@Test
public void setExistingAuthTokens() throws MslEncodingException, MslCryptoException, MslException {
final MslStore store = trustedNetCtx.getMslStore();
store.setCryptoContext(MASTER_TOKEN, CRYPTO_CONTEXT);
store.addUserIdToken(USER_ID, USER_ID_TOKEN);
store.setCryptoContext(PEER_MASTER_TOKEN, CRYPTO_CONTEXT);
store.addUserIdToken(PEER_USER_ID, PEER_USER_ID_TOKEN);
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
store.addServiceTokens(serviceTokens);
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
store.addServiceTokens(peerServiceTokens);
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, null);
builder.setAuthTokens(MASTER_TOKEN, USER_ID_TOKEN);
// The message service tokens will include all unbound service
// tokens.
final Set<ServiceToken> updatedServiceTokens = new HashSet<ServiceToken>(serviceTokens);
for (final ServiceToken peerServiceToken : peerServiceTokens) {
if (peerServiceToken.isUnbound())
updatedServiceTokens.add(peerServiceToken);
}
assertEquals(updatedServiceTokens, builder.getServiceTokens());
assertTrue(builder.getPeerServiceTokens().isEmpty());
final MessageHeader messageHeader = builder.getHeader();
assertEquals(updatedServiceTokens, messageHeader.getServiceTokens());
assertTrue(messageHeader.getPeerServiceTokens().isEmpty());
}
@Test
public void setNullMasterToken() throws MslException {
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, null, null);
builder.setAuthTokens(null, null);
final MessageHeader header = builder.getHeader();
assertNotNull(header);
assertNull(header.getMasterToken());
assertNull(header.getUserIdToken());
}
@Test(expected = MslInternalException.class)
public void setMismatchedAuthTokens() throws MslException {
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, null, null);
builder.setAuthTokens(MASTER_TOKEN, PEER_USER_ID_TOKEN);
}
@Test
public void setUser() throws MslException {
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, null);
builder.setUser(USER_ID_TOKEN.getUser());
final UserIdToken userIdToken = builder.getUserIdToken();
assertNotNull(userIdToken);
assertEquals(USER_ID_TOKEN.getUser(), userIdToken.getUser());
}
@Test(expected = MslInternalException.class)
public void setUserNoMasterToken() throws MslException {
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, null, null);
builder.setUser(USER_ID_TOKEN.getUser());
}
@Test(expected = MslInternalException.class)
public void setUserHasUserIdToken() throws MslEncodingException, MslCryptoException, MslException {
final MessageBuilder builder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
builder.setUser(USER_ID_TOKEN.getUser());
}
@Test
public void setPeerUser() throws MslMessageException, MslEncodingException, MslCryptoException, MslException {
final MessageBuilder builder = messageFactory.createRequest(p2pCtx, null, null);
builder.setPeerAuthTokens(PEER_MASTER_TOKEN, null);
builder.setUser(PEER_USER_ID_TOKEN.getUser());
final UserIdToken userIdToken = builder.getPeerUserIdToken();
assertNotNull(userIdToken);
assertEquals(PEER_USER_ID_TOKEN.getUser(), userIdToken.getUser());
}
@Test(expected = MslInternalException.class)
public void setPeerUserNoPeerMasterToken() throws MslEncodingException, MslCryptoException, MslException {
final MessageBuilder builder = messageFactory.createRequest(p2pCtx, null, null);
builder.setUser(PEER_USER_ID_TOKEN.getUser());
}
@Test(expected = MslInternalException.class)
public void setPeerUserHasPeerUserIdToken() throws MslEncodingException, MslCryptoException, MslException {
final MessageBuilder builder = messageFactory.createRequest(p2pCtx, null, null);
builder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
builder.setUser(USER_ID_TOKEN.getUser());
}
@Test(expected = MslInternalException.class)
public void negativeMessageId() throws MslException {
messageFactory.createRequest(trustedNetCtx, null, null, -1);
}
@Test(expected = MslInternalException.class)
public void tooLargeMessageId() throws MslException {
messageFactory.createRequest(trustedNetCtx, null, null, MslConstants.MAX_LONG_VALUE + 1);
}
}
/** Create error unit tests. */
public static class CreateErrorTest {
private static final Long REQUEST_MESSAGE_ID = Long.valueOf(17L);
private static final MslError MSL_ERROR = MslError.MSL_PARSE_ERROR;
private static final String USER_MESSAGE = "user message";
@Test
public void ctor() throws MslEncodingException, MslEntityAuthException, MslMessageException, MslCryptoException {
final ErrorHeader errorHeader = messageFactory.createErrorResponse(trustedNetCtx, REQUEST_MESSAGE_ID, MSL_ERROR, USER_MESSAGE);
assertNotNull(errorHeader);
assertEquals(MSL_ERROR.getResponseCode(), errorHeader.getErrorCode());
assertEquals(MSL_ERROR.getMessage(), errorHeader.getErrorMessage());
assertEquals(USER_MESSAGE, errorHeader.getUserMessage());
assertEquals(REQUEST_MESSAGE_ID + 1, errorHeader.getMessageId());
}
@Test
public void nullRecipient() throws MslEncodingException, MslEntityAuthException, MslMessageException, MslCryptoException {
final ErrorHeader errorHeader = messageFactory.createErrorResponse(trustedNetCtx, REQUEST_MESSAGE_ID, MSL_ERROR, USER_MESSAGE);
assertNotNull(errorHeader);
assertEquals(MSL_ERROR.getResponseCode(), errorHeader.getErrorCode());
assertEquals(MSL_ERROR.getMessage(), errorHeader.getErrorMessage());
assertEquals(USER_MESSAGE, errorHeader.getUserMessage());
assertEquals(REQUEST_MESSAGE_ID + 1, errorHeader.getMessageId());
}
@Test
public void maxMessageId() throws MslEncodingException, MslEntityAuthException, MslMessageException, MslCryptoException {
final Long messageId = MslConstants.MAX_LONG_VALUE;
final ErrorHeader errorHeader = messageFactory.createErrorResponse(trustedNetCtx, messageId, MSL_ERROR, USER_MESSAGE);
assertNotNull(errorHeader);
assertEquals(MSL_ERROR.getResponseCode(), errorHeader.getErrorCode());
assertEquals(MSL_ERROR.getMessage(), errorHeader.getErrorMessage());
assertEquals(USER_MESSAGE, errorHeader.getUserMessage());
assertEquals(0, errorHeader.getMessageId());
}
@Test
public void nullMessageId() throws MslEncodingException, MslEntityAuthException, MslMessageException, MslCryptoException {
final ErrorHeader errorHeader = messageFactory.createErrorResponse(trustedNetCtx, null, MSL_ERROR, USER_MESSAGE);
assertNotNull(errorHeader);
assertEquals(MSL_ERROR.getResponseCode(), errorHeader.getErrorCode());
assertEquals(MSL_ERROR.getMessage(), errorHeader.getErrorMessage());
assertEquals(USER_MESSAGE, errorHeader.getUserMessage());
assertTrue(errorHeader.getMessageId() > 0);
}
@Test(expected = MslInternalException.class)
public void negativeMessageId() throws MslEncodingException, MslEntityAuthException, MslMessageException, MslCryptoException {
final Long messageId = -12L;
messageFactory.createErrorResponse(trustedNetCtx, messageId, MSL_ERROR, USER_MESSAGE);
}
@Test
public void nullUserMessage() throws MslEncodingException, MslEntityAuthException, MslMessageException, MslCryptoException {
final ErrorHeader errorHeader = messageFactory.createErrorResponse(trustedNetCtx, REQUEST_MESSAGE_ID, MSL_ERROR, null);
assertNotNull(errorHeader);
assertEquals(MSL_ERROR.getResponseCode(), errorHeader.getErrorCode());
assertEquals(MSL_ERROR.getMessage(), errorHeader.getErrorMessage());
assertNull(errorHeader.getUserMessage());
assertEquals(REQUEST_MESSAGE_ID + 1, errorHeader.getMessageId());
}
}
/** Create response unit tests. */
public static class CreateResponseTest {
private static final long REQUEST_MESSAGE_ID = 17L;
private static final String KEY_PAIR_ID = "rsaKeyPairId";
private static PublicKey RSA_PUBLIC_KEY;
private static PrivateKey RSA_PRIVATE_KEY;
private static final Map<String,ICryptoContext> CRYPTO_CONTEXTS = new HashMap<String,ICryptoContext>();
private static MslObject ISSUER_DATA;
private static MslUser USER;
/**
* @param value the value to increment.
* @return the value + 1, wrapped back to zero on overflow.
*/
private static long incrementLong(final long value) {
if (value == MslConstants.MAX_LONG_VALUE) return 0;
return value + 1;
}
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@BeforeClass
public static void setup() throws NoSuchAlgorithmException, MslEncoderException {
final KeyPairGenerator rsaGenerator = KeyPairGenerator.getInstance("RSA");
final KeyPair rsaKeyPair = rsaGenerator.generateKeyPair();
RSA_PUBLIC_KEY = rsaKeyPair.getPublic();
RSA_PRIVATE_KEY = rsaKeyPair.getPrivate();
ISSUER_DATA = encoder.parseObject("{ 'issuerid' : 17 }".getBytes());
USER = MockEmailPasswordAuthenticationFactory.USER;
}
@AfterClass
public static void teardown() {
USER = null;
RSA_PRIVATE_KEY = null;
RSA_PUBLIC_KEY = null;
}
@Before
public void reset() {
trustedNetCtx.getMslStore().clearCryptoContexts();
trustedNetCtx.getMslStore().clearServiceTokens();
p2pCtx.getMslStore().clearCryptoContexts();
p2pCtx.getMslStore().clearServiceTokens();
}
@Test
public void createNullResponse() throws MslEncodingException, MslCryptoException, MslMessageException, MslMasterTokenException, MslEntityAuthException, MslException {
// This will not exercise any of the complex logic, so no key
// request data, entity auth data, or user auth data. Just tokens.
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
for (final ServiceToken serviceToken : serviceTokens)
requestBuilder.addServiceToken(serviceToken);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
assertTrue(responseBuilder.willEncryptHeader());
assertTrue(responseBuilder.willEncryptPayloads());
assertEquals(serviceTokens, responseBuilder.getServiceTokens());
assertTrue(responseBuilder.getPeerServiceTokens().isEmpty());
final MessageHeader response = responseBuilder.getHeader();
assertNotNull(response);
assertNull(response.getNonReplayableId());
assertFalse(response.isRenewable());
assertFalse(response.isHandshake());
assertNotNull(response.getCryptoContext());
assertNull(response.getEntityAuthenticationData());
assertTrue(response.getKeyRequestData().isEmpty());
assertNull(response.getKeyResponseData());
assertEquals(MASTER_TOKEN, response.getMasterToken());
assertEquals(incrementLong(request.getMessageId()), response.getMessageId());
assertEquals(trustedNetCtx.getMessageCapabilities(), response.getMessageCapabilities());
assertNull(response.getPeerMasterToken());
assertTrue(response.getPeerServiceTokens().isEmpty());
assertNull(response.getPeerUserIdToken());
assertTrue(response.getServiceTokens().equals(serviceTokens));
assertNull(response.getUserAuthenticationData());
assertEquals(USER_ID_TOKEN, response.getUserIdToken());
}
@Test
public void createNullPeerResponse() throws MslEncodingException, MslCryptoException, MslMessageException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
// This will not exercise any of the complex logic, so no key
// request data, entity auth data, or user auth data. Just tokens.
final MessageBuilder requestBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
requestBuilder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
for (final ServiceToken serviceToken : serviceTokens)
requestBuilder.addServiceToken(serviceToken);
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
for (final ServiceToken peerServiceToken : peerServiceTokens)
requestBuilder.addPeerServiceToken(peerServiceToken);
final MessageHeader request = requestBuilder.getHeader();
// The tokens should be swapped.
final MessageBuilder responseBuilder = messageFactory.createResponse(p2pCtx, request);
assertTrue(responseBuilder.willEncryptHeader());
assertTrue(responseBuilder.willEncryptPayloads());
assertEquals(serviceTokens, responseBuilder.getPeerServiceTokens());
assertEquals(peerServiceTokens, responseBuilder.getServiceTokens());
final MessageHeader response = responseBuilder.getHeader();
assertNotNull(response);
assertNull(response.getNonReplayableId());
assertFalse(response.isRenewable());
assertFalse(response.isHandshake());
assertNotNull(response.getCryptoContext());
assertNull(response.getEntityAuthenticationData());
assertTrue(response.getKeyRequestData().isEmpty());
assertNull(response.getKeyResponseData());
assertEquals(PEER_MASTER_TOKEN, response.getMasterToken());
assertEquals(incrementLong(request.getMessageId()), response.getMessageId());
assertEquals(p2pCtx.getMessageCapabilities(), response.getMessageCapabilities());
assertEquals(MASTER_TOKEN, response.getPeerMasterToken());
assertEquals(USER_ID_TOKEN, response.getPeerUserIdToken());
assertNull(response.getUserAuthenticationData());
assertEquals(PEER_USER_ID_TOKEN, response.getUserIdToken());
assertTrue(response.getPeerServiceTokens().equals(serviceTokens));
assertTrue(response.getServiceTokens().equals(peerServiceTokens));
}
@Test
public void createEntityAuthResponse() throws MslEncodingException, MslCryptoException, MslMessageException, MslMasterTokenException, MslEntityAuthException, MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, null, null);
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, null, null);
for (final ServiceToken serviceToken : serviceTokens)
requestBuilder.addServiceToken(serviceToken);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
assertTrue(responseBuilder.willEncryptHeader());
assertTrue(responseBuilder.willEncryptPayloads());
assertEquals(serviceTokens, responseBuilder.getServiceTokens());
assertTrue(responseBuilder.getPeerServiceTokens().isEmpty());
final MessageHeader response = responseBuilder.getHeader();
assertNotNull(response);
assertNull(response.getNonReplayableId());
assertFalse(response.isRenewable());
assertFalse(response.isHandshake());
assertNotNull(response.getCryptoContext());
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
assertEquals(entityAuthData, response.getEntityAuthenticationData());
assertTrue(response.getKeyRequestData().isEmpty());
assertNull(response.getKeyResponseData());
assertNull(response.getMasterToken());
assertEquals(incrementLong(request.getMessageId()), response.getMessageId());
assertEquals(trustedNetCtx.getMessageCapabilities(), response.getMessageCapabilities());
assertNull(response.getPeerMasterToken());
assertTrue(response.getPeerServiceTokens().isEmpty());
assertNull(response.getPeerUserIdToken());
assertTrue(response.getServiceTokens().equals(serviceTokens));
assertNull(response.getUserAuthenticationData());
assertNull(response.getUserIdToken());
}
@Test
public void createEntityAuthPeerResponse() throws MslEncodingException, MslCryptoException, MslMessageException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(p2pCtx, null, null);
requestBuilder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(p2pCtx, null, null);
for (final ServiceToken serviceToken : serviceTokens)
requestBuilder.addServiceToken(serviceToken);
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
for (final ServiceToken peerServiceToken : peerServiceTokens)
requestBuilder.addPeerServiceToken(peerServiceToken);
final MessageHeader request = requestBuilder.getHeader();
// The tokens should be swapped.
final MessageBuilder responseBuilder = messageFactory.createResponse(p2pCtx, request);
assertTrue(responseBuilder.willEncryptHeader());
assertTrue(responseBuilder.willEncryptPayloads());
assertEquals(serviceTokens, responseBuilder.getPeerServiceTokens());
assertEquals(peerServiceTokens, responseBuilder.getServiceTokens());
final MessageHeader response = responseBuilder.getHeader();
assertNotNull(response);
assertNull(response.getNonReplayableId());
assertFalse(response.isRenewable());
assertFalse(response.isHandshake());
assertNotNull(response.getCryptoContext());
assertNull(response.getEntityAuthenticationData());
assertTrue(response.getKeyRequestData().isEmpty());
assertNull(response.getKeyResponseData());
assertEquals(PEER_MASTER_TOKEN, response.getMasterToken());
assertEquals(incrementLong(request.getMessageId()), response.getMessageId());
assertEquals(p2pCtx.getMessageCapabilities(), response.getMessageCapabilities());
assertNull(response.getPeerMasterToken());
assertNull(response.getPeerUserIdToken());
assertNull(response.getUserAuthenticationData());
assertEquals(PEER_USER_ID_TOKEN, response.getUserIdToken());
assertTrue(response.getPeerServiceTokens().equals(serviceTokens));
assertTrue(response.getServiceTokens().equals(peerServiceTokens));
}
@Test
public void createResponse() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
responseBuilder.setNonReplayable(true);
responseBuilder.setRenewable(true);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
responseBuilder.addKeyRequestData(keyRequestData);
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, null, null);
for (final ServiceToken serviceToken : serviceTokens)
responseBuilder.addServiceToken(serviceToken);
responseBuilder.setUserAuthenticationData(USER_AUTH_DATA);
assertTrue(responseBuilder.willEncryptHeader());
assertTrue(responseBuilder.willEncryptPayloads());
assertEquals(serviceTokens, responseBuilder.getServiceTokens());
assertTrue(responseBuilder.getPeerServiceTokens().isEmpty());
final MessageHeader response = responseBuilder.getHeader();
assertNotNull(response);
assertNotNull(response.getNonReplayableId());
assertTrue(response.isRenewable());
assertFalse(response.isHandshake());
assertNotNull(response.getCryptoContext());
assertNull(response.getEntityAuthenticationData());
assertTrue(response.getKeyRequestData().equals(KEY_REQUEST_DATA));
assertNull(response.getKeyResponseData());
assertEquals(MASTER_TOKEN, response.getMasterToken());
assertEquals(incrementLong(request.getMessageId()), response.getMessageId());
assertEquals(trustedNetCtx.getMessageCapabilities(), response.getMessageCapabilities());
assertNull(response.getPeerMasterToken());
assertTrue(response.getPeerServiceTokens().isEmpty());
assertNull(response.getPeerUserIdToken());
assertTrue(response.getServiceTokens().equals(serviceTokens));
assertEquals(USER_AUTH_DATA, response.getUserAuthenticationData());
assertEquals(USER_ID_TOKEN, response.getUserIdToken());
}
@Test
public void createPeerResponse() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslMessageException, MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(p2pCtx, request);
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(p2pCtx, null, null);
for (final ServiceToken serviceToken : serviceTokens)
responseBuilder.addServiceToken(serviceToken);
responseBuilder.setUserAuthenticationData(USER_AUTH_DATA);
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
for (final ServiceToken peerServiceToken : peerServiceTokens)
responseBuilder.addPeerServiceToken(peerServiceToken);
assertTrue(responseBuilder.willEncryptHeader());
assertTrue(responseBuilder.willEncryptPayloads());
assertEquals(peerServiceTokens, responseBuilder.getPeerServiceTokens());
assertEquals(serviceTokens, responseBuilder.getServiceTokens());
final MessageHeader response = responseBuilder.getHeader();
assertNotNull(response);
assertNull(response.getNonReplayableId());
assertFalse(response.isRenewable());
assertFalse(response.isHandshake());
assertNotNull(response.getCryptoContext());
assertEquals(trustedNetCtx.getEntityAuthenticationData(null), response.getEntityAuthenticationData());
assertTrue(response.getKeyRequestData().isEmpty());
assertNull(response.getKeyResponseData());
assertNull(response.getMasterToken());
assertEquals(incrementLong(request.getMessageId()), response.getMessageId());
assertEquals(p2pCtx.getMessageCapabilities(), response.getMessageCapabilities());
assertEquals(PEER_MASTER_TOKEN, response.getPeerMasterToken());
assertEquals(PEER_USER_ID_TOKEN, response.getPeerUserIdToken());
assertEquals(USER_AUTH_DATA, response.getUserAuthenticationData());
assertTrue(response.getPeerServiceTokens().equals(peerServiceTokens));
assertTrue(response.getServiceTokens().equals(serviceTokens));
assertNull(response.getUserIdToken());
}
@Test
public void createHandshakeResponse() throws MslEncodingException, MslCryptoException, MslMessageException, MslMasterTokenException, MslEntityAuthException, MslException {
// This will not exercise any of the complex logic, so no key
// request data, entity auth data, or user auth data. Just tokens.
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
for (final ServiceToken serviceToken : serviceTokens)
requestBuilder.addServiceToken(serviceToken);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
responseBuilder.setNonReplayable(true);
responseBuilder.setRenewable(false);
responseBuilder.setHandshake(true);
assertTrue(responseBuilder.willEncryptHeader());
assertTrue(responseBuilder.willEncryptPayloads());
assertEquals(serviceTokens, responseBuilder.getServiceTokens());
assertTrue(responseBuilder.getPeerServiceTokens().isEmpty());
final MessageHeader response = responseBuilder.getHeader();
assertNotNull(response);
assertNull(response.getNonReplayableId());
assertTrue(response.isRenewable());
assertTrue(response.isHandshake());
assertNotNull(response.getCryptoContext());
assertNull(response.getEntityAuthenticationData());
assertTrue(response.getKeyRequestData().isEmpty());
assertNull(response.getKeyResponseData());
assertEquals(MASTER_TOKEN, response.getMasterToken());
assertEquals(incrementLong(request.getMessageId()), response.getMessageId());
assertEquals(trustedNetCtx.getMessageCapabilities(), response.getMessageCapabilities());
assertNull(response.getPeerMasterToken());
assertTrue(response.getPeerServiceTokens().isEmpty());
assertNull(response.getPeerUserIdToken());
assertTrue(response.getServiceTokens().equals(serviceTokens));
assertNull(response.getUserAuthenticationData());
assertEquals(USER_ID_TOKEN, response.getUserIdToken());
}
@Test
public void createPeerHandshakeResponse() throws MslEncodingException, MslCryptoException, MslMessageException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
// This will not exercise any of the complex logic, so no key
// request data, entity auth data, or user auth data. Just tokens.
final MessageBuilder requestBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
requestBuilder.setPeerAuthTokens(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
for (final ServiceToken serviceToken : serviceTokens)
requestBuilder.addServiceToken(serviceToken);
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
for (final ServiceToken peerServiceToken : peerServiceTokens)
requestBuilder.addPeerServiceToken(peerServiceToken);
final MessageHeader request = requestBuilder.getHeader();
// The tokens should be swapped.
final MessageBuilder responseBuilder = messageFactory.createResponse(p2pCtx, request);
responseBuilder.setNonReplayable(true);
responseBuilder.setRenewable(false);
responseBuilder.setHandshake(true);
assertTrue(responseBuilder.willEncryptHeader());
assertTrue(responseBuilder.willEncryptPayloads());
assertEquals(serviceTokens, responseBuilder.getPeerServiceTokens());
assertEquals(peerServiceTokens, responseBuilder.getServiceTokens());
final MessageHeader response = responseBuilder.getHeader();
assertNotNull(response);
assertNull(response.getNonReplayableId());
assertTrue(response.isRenewable());
assertTrue(response.isHandshake());
assertNotNull(response.getCryptoContext());
assertNull(response.getEntityAuthenticationData());
assertTrue(response.getKeyRequestData().isEmpty());
assertNull(response.getKeyResponseData());
assertEquals(PEER_MASTER_TOKEN, response.getMasterToken());
assertEquals(incrementLong(request.getMessageId()), response.getMessageId());
assertEquals(p2pCtx.getMessageCapabilities(), response.getMessageCapabilities());
assertEquals(MASTER_TOKEN, response.getPeerMasterToken());
assertEquals(USER_ID_TOKEN, response.getPeerUserIdToken());
assertNull(response.getUserAuthenticationData());
assertEquals(PEER_USER_ID_TOKEN, response.getUserIdToken());
assertTrue(response.getPeerServiceTokens().equals(serviceTokens));
assertTrue(response.getServiceTokens().equals(peerServiceTokens));
}
@Test
public void willEncryptX509EntityAuth() throws MslException {
final MslContext x509Ctx = new MockMslContext(EntityAuthenticationScheme.X509, false);
final MessageBuilder requestBuilder = messageFactory.createRequest(x509Ctx, null, null);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(x509Ctx, request);
assertFalse(responseBuilder.willEncryptHeader());
assertFalse(responseBuilder.willEncryptPayloads());
}
@Test
public void willEncryptX509EntityAuthKeyExchange() throws MslException {
final MslContext x509Ctx = new MockMslContext(EntityAuthenticationScheme.X509, false);
final MessageBuilder requestBuilder = messageFactory.createRequest(x509Ctx, null, null);
requestBuilder.setRenewable(true);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
requestBuilder.addKeyRequestData(keyRequestData);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(x509Ctx, request);
assertFalse(responseBuilder.willEncryptHeader());
assertTrue(responseBuilder.willEncryptPayloads());
}
@Test
public void storedServiceTokens() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
final MessageHeader request = requestBuilder.getHeader();
assertTrue(request.getServiceTokens().isEmpty());
final MslStore store = trustedNetCtx.getMslStore();
store.setCryptoContext(MASTER_TOKEN, CRYPTO_CONTEXT);
store.addUserIdToken(USER_ID, USER_ID_TOKEN);
store.setCryptoContext(PEER_MASTER_TOKEN, CRYPTO_CONTEXT);
store.addUserIdToken(PEER_USER_ID, PEER_USER_ID_TOKEN);
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
store.addServiceTokens(serviceTokens);
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
store.addServiceTokens(peerServiceTokens);
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
// The message will include all unbound service tokens.
final Set<ServiceToken> updatedServiceTokens = new HashSet<ServiceToken>(serviceTokens);
for (final ServiceToken peerServiceToken : peerServiceTokens) {
if (peerServiceToken.isUnbound())
updatedServiceTokens.add(peerServiceToken);
}
assertEquals(updatedServiceTokens, responseBuilder.getServiceTokens());
assertTrue(responseBuilder.getPeerServiceTokens().isEmpty());
final MessageHeader response = responseBuilder.getHeader();
assertEquals(updatedServiceTokens, response.getServiceTokens());
assertTrue(response.getPeerServiceTokens().isEmpty());
}
@Test
public void storedPeerServiceTokens() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
final MessageHeader request = requestBuilder.getHeader();
assertTrue(request.getServiceTokens().isEmpty());
assertTrue(request.getPeerServiceTokens().isEmpty());
final MslStore store = p2pCtx.getMslStore();
store.setCryptoContext(MASTER_TOKEN, CRYPTO_CONTEXT);
store.addUserIdToken(USER_ID, USER_ID_TOKEN);
store.setCryptoContext(PEER_MASTER_TOKEN, CRYPTO_CONTEXT);
store.addUserIdToken(PEER_USER_ID, PEER_USER_ID_TOKEN);
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
store.addServiceTokens(serviceTokens);
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
store.addServiceTokens(peerServiceTokens);
final MessageBuilder responseBuilder = messageFactory.createResponse(p2pCtx, request);
// Update the set of expected peer service tokens with any unbound
// service tokens.
final Set<ServiceToken> updatedServiceTokens = new HashSet<ServiceToken>(serviceTokens);
for (final ServiceToken peerServiceToken : peerServiceTokens) {
if (peerServiceToken.isUnbound())
updatedServiceTokens.add(peerServiceToken);
}
// The service tokens will all be unbound.
for (final ServiceToken serviceToken : responseBuilder.getServiceTokens()) {
assertTrue(serviceToken.isUnbound());
assertTrue(serviceTokens.contains(serviceToken) || peerServiceTokens.contains(serviceToken));
}
assertEquals(updatedServiceTokens, responseBuilder.getPeerServiceTokens());
final MessageHeader response = responseBuilder.getHeader();
// The service tokens will all be unbound.
for (final ServiceToken serviceToken : response.getServiceTokens()) {
assertTrue(serviceToken.isUnbound());
assertTrue(serviceTokens.contains(serviceToken) || peerServiceTokens.contains(serviceToken));
}
assertEquals(updatedServiceTokens, response.getPeerServiceTokens());
}
@Test
public void keyxAddServiceToken() throws MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, null, null);
requestBuilder.setRenewable(true);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
requestBuilder.addKeyRequestData(keyRequestData);
requestBuilder.setUserAuthenticationData(USER_AUTH_DATA);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
assertNull(responseBuilder.getMasterToken());
final UserIdToken userIdToken = responseBuilder.getUserIdToken();
assertNotNull(userIdToken);
assertNotNull(responseBuilder.getKeyExchangeData());
final MasterToken keyxMasterToken = responseBuilder.getKeyExchangeData().keyResponseData.getMasterToken();
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, keyxMasterToken, userIdToken);
for (final ServiceToken serviceToken : serviceTokens)
responseBuilder.addServiceToken(serviceToken);
final MessageHeader response = responseBuilder.getHeader();
assertEquals(serviceTokens, response.getServiceTokens());
}
@Test
public void nullKeyxAddServiceToken() throws MslException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.SERVICETOKEN_MASTERTOKEN_MISMATCH);
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, null, null);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
assertNull(responseBuilder.getMasterToken());
assertNull(responseBuilder.getKeyExchangeData());
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, null);
for (final ServiceToken serviceToken : serviceTokens)
responseBuilder.addServiceToken(serviceToken);
}
@Test
public void keyxAddMismatchedServiceToken() throws MslException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.SERVICETOKEN_MASTERTOKEN_MISMATCH);
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, null, null);
requestBuilder.setRenewable(true);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
requestBuilder.addKeyRequestData(keyRequestData);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
assertNull(responseBuilder.getMasterToken());
assertNotNull(responseBuilder.getKeyExchangeData());
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, null);
for (final ServiceToken serviceToken : serviceTokens)
responseBuilder.addServiceToken(serviceToken);
}
@Test
public void peerKeyxAddMismatchedServiceToken() throws MslException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.SERVICETOKEN_MASTERTOKEN_MISMATCH);
final MessageBuilder requestBuilder = messageFactory.createRequest(p2pCtx, null, null);
requestBuilder.setRenewable(true);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
requestBuilder.addKeyRequestData(keyRequestData);
requestBuilder.setUserAuthenticationData(USER_AUTH_DATA);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(p2pCtx, request);
assertNull(responseBuilder.getMasterToken());
assertNull(responseBuilder.getUserIdToken());
assertNotNull(responseBuilder.getKeyExchangeData());
final MasterToken keyxMasterToken = responseBuilder.getKeyExchangeData().keyResponseData.getMasterToken();
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(p2pCtx, keyxMasterToken, null);
for (final ServiceToken serviceToken : serviceTokens)
responseBuilder.addServiceToken(serviceToken);
}
@Test
public void maxRequestMessageId() throws MslKeyExchangeException, MslUserAuthException, MslException {
final HeaderData headerData = new HeaderData(MslConstants.MAX_LONG_VALUE, null, false, false, null, null, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader request = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerData, peerData);
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
final MessageHeader response = responseBuilder.getHeader();
assertEquals(0, response.getMessageId());
}
@Test
public void renewMasterToken() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final Date renewalWindow = new Date(System.currentTimeMillis() - 10000);
final Date expiration = new Date(System.currentTimeMillis() + 10000);
final MasterToken requestMasterToken = new MasterToken(trustedNetCtx, renewalWindow, expiration, 1L, 1L, null, MockPresharedAuthenticationFactory.PSK_ESN, MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH);
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, requestMasterToken, null);
requestBuilder.setRenewable(true);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
requestBuilder.addKeyRequestData(keyRequestData);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
final MessageHeader response = responseBuilder.getHeader();
assertEquals(requestMasterToken, response.getMasterToken());
final KeyResponseData keyResponseData = response.getKeyResponseData();
assertNotNull(keyResponseData);
final MasterToken keyxMasterToken = keyResponseData.getMasterToken();
assertEquals(requestMasterToken.getIdentity(), keyxMasterToken.getIdentity());
assertEquals(incrementLong(requestMasterToken.getSequenceNumber()), keyxMasterToken.getSequenceNumber());
assertEquals(requestMasterToken.getSerialNumber(), keyxMasterToken.getSerialNumber());
}
@Test
public void peerRenewMasterToken() throws MslMasterTokenException, MslEntityAuthException, MslException {
final Date renewalWindow = new Date(System.currentTimeMillis() - 10000);
final Date expirationWindow = new Date(System.currentTimeMillis() + 10000);
final MasterToken requestMasterToken = new MasterToken(p2pCtx, renewalWindow, expirationWindow, 1L, 1L, null, MockPresharedAuthenticationFactory.PSK_ESN, MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH);
final MessageBuilder requestBuilder = messageFactory.createRequest(p2pCtx, requestMasterToken, null);
requestBuilder.setRenewable(true);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
requestBuilder.addKeyRequestData(keyRequestData);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(p2pCtx, request);
final MessageHeader response = responseBuilder.getHeader();
assertNull(response.getMasterToken());
assertEquals(requestMasterToken, response.getPeerMasterToken());
final KeyResponseData keyResponseData = response.getKeyResponseData();
assertNotNull(keyResponseData);
final MasterToken keyxMasterToken = keyResponseData.getMasterToken();
assertEquals(requestMasterToken.getIdentity(), keyxMasterToken.getIdentity());
assertEquals(incrementLong(requestMasterToken.getSequenceNumber()), keyxMasterToken.getSequenceNumber());
assertEquals(requestMasterToken.getSerialNumber(), keyxMasterToken.getSerialNumber());
}
@Test
public void renewMasterTokenMaxSequenceNumber() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final Date renewalWindow = new Date(System.currentTimeMillis() - 10000);
final Date expirationWindow = new Date(System.currentTimeMillis() + 10000);
final MasterToken requestMasterToken = new MasterToken(trustedNetCtx, renewalWindow, expirationWindow, MslConstants.MAX_LONG_VALUE, 1L, null, MockPresharedAuthenticationFactory.PSK_ESN, MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH);
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, requestMasterToken, null);
requestBuilder.setRenewable(true);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
requestBuilder.addKeyRequestData(keyRequestData);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
final MessageHeader response = responseBuilder.getHeader();
final MasterToken responseMasterToken = response.getMasterToken();
assertEquals(requestMasterToken.getIdentity(), responseMasterToken.getIdentity());
assertEquals(requestMasterToken.getSequenceNumber(), responseMasterToken.getSequenceNumber());
assertEquals(requestMasterToken.getSerialNumber(), responseMasterToken.getSerialNumber());
final KeyResponseData keyResponseData = response.getKeyResponseData();
assertNotNull(keyResponseData);
final MasterToken keyxMasterToken = keyResponseData.getMasterToken();
assertEquals(requestMasterToken.getIdentity(), keyxMasterToken.getIdentity());
assertEquals(incrementLong(requestMasterToken.getSequenceNumber()), keyxMasterToken.getSequenceNumber());
assertEquals(requestMasterToken.getSerialNumber(), keyxMasterToken.getSerialNumber());
}
@Test
public void renewMasterTokenFutureRenewalWindow() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final Date renewalWindow = new Date(System.currentTimeMillis() + 10000);
final Date expirationWindow = new Date(System.currentTimeMillis() + 20000);
final MasterToken requestMasterToken = new MasterToken(trustedNetCtx, renewalWindow, expirationWindow, 1L, 1L, null, MockPresharedAuthenticationFactory.PSK_ESN, MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH);
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, requestMasterToken, null);
requestBuilder.setRenewable(true);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
requestBuilder.addKeyRequestData(keyRequestData);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
final MessageHeader response = responseBuilder.getHeader();
final MasterToken responseMasterToken = response.getMasterToken();
assertEquals(requestMasterToken.getIdentity(), responseMasterToken.getIdentity());
assertEquals(requestMasterToken.getSequenceNumber(), responseMasterToken.getSequenceNumber());
assertEquals(requestMasterToken.getSerialNumber(), responseMasterToken.getSerialNumber());
final KeyResponseData keyResponseData = response.getKeyResponseData();
assertNull(keyResponseData);
}
@Test
public void expiredMasterToken() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final Date renewalWindow = new Date(System.currentTimeMillis() - 20000);
final Date expirationWindow = new Date(System.currentTimeMillis() - 10000);
final MasterToken requestMasterToken = new MasterToken(trustedNetCtx, renewalWindow, expirationWindow, 1L, 1L, null, MockPresharedAuthenticationFactory.PSK_ESN, MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH);
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, requestMasterToken, null);
requestBuilder.setRenewable(true);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
requestBuilder.addKeyRequestData(keyRequestData);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
final MessageHeader response = responseBuilder.getHeader();
assertEquals(requestMasterToken, response.getMasterToken());
final KeyResponseData keyResponseData = response.getKeyResponseData();
assertNotNull(keyResponseData);
final MasterToken keyxMasterToken = keyResponseData.getMasterToken();
assertEquals(requestMasterToken.getIdentity(), keyxMasterToken.getIdentity());
assertEquals(incrementLong(requestMasterToken.getSequenceNumber()), keyxMasterToken.getSequenceNumber());
assertEquals(requestMasterToken.getSerialNumber(), keyxMasterToken.getSerialNumber());
}
@Test
public void nonReplayableRequest() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final Date renewalWindow = new Date(System.currentTimeMillis() + 10000);
final Date expirationWindow = new Date(System.currentTimeMillis() + 20000);
final MasterToken requestMasterToken = new MasterToken(trustedNetCtx, renewalWindow, expirationWindow, MslConstants.MAX_LONG_VALUE, 1L, null, MockPresharedAuthenticationFactory.PSK_ESN, MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH);
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, requestMasterToken, null);
requestBuilder.setNonReplayable(true);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
final MessageHeader response = responseBuilder.getHeader();
assertEquals(requestMasterToken, response.getMasterToken());
assertNull(response.getKeyResponseData());
}
@Test
public void unsupportedKeyExchangeRenewMasterToken() throws MslException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.KEYX_FACTORY_NOT_FOUND);
thrown.expectMessageId(REQUEST_MESSAGE_ID);
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
for (final KeyExchangeScheme scheme : KeyExchangeScheme.values())
ctx.removeKeyExchangeFactories(scheme);
final Date renewalWindow = new Date(System.currentTimeMillis() - 10000);
final Date expirationWindow = new Date(System.currentTimeMillis() + 10000);
final MasterToken requestMasterToken = new MasterToken(ctx, renewalWindow, expirationWindow, 1L, 1L, null, MockPresharedAuthenticationFactory.PSK_ESN, MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH);
final HeaderData headerData = new HeaderData(REQUEST_MESSAGE_ID, null, true, false, null, KEY_REQUEST_DATA, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader request = new MessageHeader(trustedNetCtx, null, requestMasterToken, headerData, peerData);
messageFactory.createResponse(ctx, request);
}
@Test
public void oneSupportedKeyExchangeRenewMasterToken() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
for (final KeyExchangeScheme scheme : KeyExchangeScheme.values())
ctx.removeKeyExchangeFactories(scheme);
ctx.addKeyExchangeFactory(new SymmetricWrappedExchange(new MockAuthenticationUtils()));
final Date renewalWindow = new Date(System.currentTimeMillis() - 10000);
final Date expirationWindow = new Date(System.currentTimeMillis() + 10000);
final MasterToken requestMasterToken = new MasterToken(ctx, renewalWindow, expirationWindow, 1L, 1L, null, MockPresharedAuthenticationFactory.PSK_ESN, MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH);
final MessageBuilder requestBuilder = messageFactory.createRequest(ctx, requestMasterToken, null);
requestBuilder.setRenewable(true);
// This should place the supported key exchange scheme in the
// middle, guaranteeing that we will have to skip one unsupported
// scheme.
requestBuilder.addKeyRequestData(new AsymmetricWrappedExchange.RequestData(KEY_PAIR_ID, Mechanism.RSA, RSA_PUBLIC_KEY, RSA_PRIVATE_KEY));
requestBuilder.addKeyRequestData(new SymmetricWrappedExchange.RequestData(KeyId.PSK));
requestBuilder.addKeyRequestData(new AsymmetricWrappedExchange.RequestData(KEY_PAIR_ID, Mechanism.RSA, RSA_PUBLIC_KEY, RSA_PRIVATE_KEY));
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(ctx, request);
final MessageHeader response = responseBuilder.getHeader();
assertEquals(requestMasterToken, response.getMasterToken());
final KeyResponseData keyResponseData = response.getKeyResponseData();
assertNotNull(keyResponseData);
final MasterToken keyxMasterToken = keyResponseData.getMasterToken();
assertEquals(requestMasterToken.getIdentity(), keyxMasterToken.getIdentity());
assertEquals(incrementLong(requestMasterToken.getSequenceNumber()), keyxMasterToken.getSequenceNumber());
assertEquals(requestMasterToken.getSerialNumber(), keyxMasterToken.getSerialNumber());
}
@Test(expected = MslMasterTokenException.class)
public void untrustedMasterTokenRenewMasterToken() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslEncoderException, MslException {
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
final Date renewalWindow = new Date(System.currentTimeMillis() - 10000);
final Date expirationWindow = new Date(System.currentTimeMillis() + 10000);
final MasterToken requestMasterToken = new MasterToken(ctx, renewalWindow, expirationWindow, 1L, 1L, null, MockPresharedAuthenticationFactory.PSK_ESN, MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH);
final HeaderData headerData = new HeaderData(REQUEST_MESSAGE_ID, null, true, false, null, KEY_REQUEST_DATA, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader request = new MessageHeader(ctx, null, requestMasterToken, headerData, peerData);
// Encode the request. This will use the MSL crypto context to
// encrypt and sign the master token.
final MslObject mo = MslTestUtils.toMslObject(encoder, request);
// The master token's crypto context must be cached, so we can
// rebuild the message.
final ICryptoContext cryptoContext = new SessionCryptoContext(ctx, requestMasterToken);
ctx.getMslStore().setCryptoContext(requestMasterToken, cryptoContext);
// Change the MSL crypto context so the master token can no longer be
// verified or decrypted.
final byte[] mke = new byte[16];
final byte[] mkh = new byte[32];
final byte[] mkw = new byte[16];
random.nextBytes(mke);
random.nextBytes(mkh);
random.nextBytes(mkw);
final SecretKey encryptionKey = new SecretKeySpec(mke, JcaAlgorithm.AES);
final SecretKey hmacKey = new SecretKeySpec(mkh, JcaAlgorithm.HMAC_SHA256);
final SecretKey wrappingKey = new SecretKeySpec(mkw, JcaAlgorithm.AESKW);
ctx.setMslCryptoContext(new SymmetricCryptoContext(ctx, "clientMslCryptoContext", encryptionKey, hmacKey, wrappingKey));
// Reconstruct the request now that we no longer have the same
// MSL crypto context.
final MessageHeader untrustedRequest = (MessageHeader)Header.parseHeader(ctx, mo, CRYPTO_CONTEXTS);
messageFactory.createResponse(ctx, untrustedRequest);
}
@Test
public void keyResponseData() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final MessageBuilder localRequestBuilder = messageFactory.createRequest(trustedNetCtx, null, null);
localRequestBuilder.setRenewable(true);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
localRequestBuilder.addKeyRequestData(keyRequestData);
final MessageHeader localRequest = localRequestBuilder.getHeader();
final MessageBuilder remoteResponseBuilder = messageFactory.createResponse(trustedNetCtx, localRequest);
final MessageHeader remoteResponse = remoteResponseBuilder.getHeader();
final KeyResponseData keyResponseData = remoteResponse.getKeyResponseData();
assertNotNull(keyResponseData);
final MessageBuilder localResponseBuilder = messageFactory.createResponse(trustedNetCtx, remoteResponse);
final MessageHeader localResponse = localResponseBuilder.getHeader();
final MasterToken localMasterToken = localResponse.getMasterToken();
assertNotNull(localMasterToken);
assertEquals(keyResponseData.getMasterToken(), localMasterToken);
}
@Test
public void peerKeyResponseData() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final MessageBuilder localRequestBuilder = messageFactory.createRequest(p2pCtx, null, null);
localRequestBuilder.setRenewable(true);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
localRequestBuilder.addKeyRequestData(keyRequestData);
final MessageHeader localRequest = localRequestBuilder.getHeader();
final MessageBuilder remoteResponseBuilder = messageFactory.createResponse(p2pCtx, localRequest);
final MessageHeader remoteResponse = remoteResponseBuilder.getHeader();
assertNull(remoteResponse.getMasterToken());
assertNull(remoteResponse.getPeerMasterToken());
final KeyResponseData keyResponseData = remoteResponse.getKeyResponseData();
assertNotNull(keyResponseData);
final MessageBuilder localResponseBuilder = messageFactory.createResponse(p2pCtx, remoteResponse);
final MessageHeader localResponse = localResponseBuilder.getHeader();
final MasterToken localMasterToken = localResponse.getMasterToken();
assertNotNull(localMasterToken);
assertEquals(keyResponseData.getMasterToken(), localMasterToken);
assertNull(localResponse.getPeerMasterToken());
final MessageBuilder remoteSecondResponseBuilder = messageFactory.createResponse(p2pCtx, localResponse);
final MessageHeader remoteSecondResponse = remoteSecondResponseBuilder.getHeader();
assertNull(remoteResponse.getMasterToken());
final MasterToken remotePeerMasterToken = remoteSecondResponse.getPeerMasterToken();
assertNotNull(remotePeerMasterToken);
assertEquals(localMasterToken, remotePeerMasterToken);
}
@Test
public void entityAuthDataNotRenewable() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, null, null);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
requestBuilder.addKeyRequestData(keyRequestData);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
final MessageHeader response = responseBuilder.getHeader();
assertNull(response.getMasterToken());
assertEquals(trustedNetCtx.getEntityAuthenticationData(null), response.getEntityAuthenticationData());
assertEquals(incrementLong(request.getMessageId()), response.getMessageId());
}
@Test
public void entityAuthDataRenewable() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, null, null);
requestBuilder.setRenewable(true);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
requestBuilder.addKeyRequestData(keyRequestData);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
final MessageHeader response = responseBuilder.getHeader();
assertNull(response.getMasterToken());
final KeyResponseData keyResponseData = response.getKeyResponseData();
assertNotNull(keyResponseData);
final MasterToken keyxMasterToken = keyResponseData.getMasterToken();
assertEquals(trustedNetCtx.getEntityAuthenticationData(null).getIdentity(), keyxMasterToken.getIdentity());
}
@Test
public void peerEntityAuthDataRenewable() throws MslKeyExchangeException, MslMasterTokenException, MslUserAuthException, MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(p2pCtx, null, null);
requestBuilder.setRenewable(true);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
requestBuilder.addKeyRequestData(keyRequestData);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(p2pCtx, request);
final MessageHeader response = responseBuilder.getHeader();
assertNull(response.getMasterToken());
assertNull(response.getPeerMasterToken());
final KeyResponseData keyResponseData = response.getKeyResponseData();
assertNotNull(keyResponseData);
final MasterToken keyxMasterToken = keyResponseData.getMasterToken();
assertNotNull(keyxMasterToken);
assertEquals(p2pCtx.getEntityAuthenticationData(null).getIdentity(), keyxMasterToken.getIdentity());
}
@Test
public void unsupportedKeyExchangeEntityAuthData() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.KEYX_FACTORY_NOT_FOUND);
thrown.expectMessageId(REQUEST_MESSAGE_ID);
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
for (final KeyExchangeScheme scheme : KeyExchangeScheme.values())
ctx.removeKeyExchangeFactories(scheme);
final HeaderData headerData = new HeaderData(REQUEST_MESSAGE_ID, null, true, false, null, KEY_REQUEST_DATA, null, null, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader request = new MessageHeader(ctx, ctx.getEntityAuthenticationData(null), null, headerData, peerData);
messageFactory.createResponse(ctx, request);
}
@Test
public void oneSupportedKeyExchangeEntityAuthData() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
for (final KeyExchangeScheme scheme : KeyExchangeScheme.values())
ctx.removeKeyExchangeFactories(scheme);
ctx.addKeyExchangeFactory(new AsymmetricWrappedExchange(new MockAuthenticationUtils()));
final MessageBuilder requestBuilder = messageFactory.createRequest(ctx, null, null);
requestBuilder.setRenewable(true);
// This should place the supported key exchange scheme in the
// middle, guaranteeing that we will have to skip one unsupported
// scheme.
requestBuilder.addKeyRequestData(new SymmetricWrappedExchange.RequestData(KeyId.SESSION));
requestBuilder.addKeyRequestData(new AsymmetricWrappedExchange.RequestData(KEY_PAIR_ID, Mechanism.JWE_RSA, RSA_PUBLIC_KEY, RSA_PRIVATE_KEY));
requestBuilder.addKeyRequestData(new SymmetricWrappedExchange.RequestData(KeyId.PSK));
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(ctx, request);
final MessageHeader response = responseBuilder.getHeader();
assertNotNull(response.getKeyResponseData());
}
@Test
public void renewUserIdToken() throws MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final Date renewalWindow = new Date(System.currentTimeMillis() - 10000);
final Date expiration = new Date(System.currentTimeMillis() + 10000);
final UserIdToken requestUserIdToken = new UserIdToken(trustedNetCtx, renewalWindow, expiration, MASTER_TOKEN, 1L, ISSUER_DATA, USER);
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, requestUserIdToken);
requestBuilder.setRenewable(true);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
final MessageHeader response = responseBuilder.getHeader();
assertEquals(MASTER_TOKEN, response.getMasterToken());
final UserIdToken responseUserIdToken = response.getUserIdToken();
assertNotNull(responseUserIdToken);
assertEquals(requestUserIdToken.getUser(), responseUserIdToken.getUser());
assertEquals(requestUserIdToken.getMasterTokenSerialNumber(), responseUserIdToken.getMasterTokenSerialNumber());
assertEquals(requestUserIdToken.getSerialNumber(), responseUserIdToken.getSerialNumber());
assertFalse(responseUserIdToken.isRenewable(null));
}
@Test
public void renewUserIdTokenNotRenewable() throws MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final Date renewalWindow = new Date(System.currentTimeMillis() - 10000);
final Date expiration = new Date(System.currentTimeMillis() + 10000);
final UserIdToken requestUserIdToken = new UserIdToken(trustedNetCtx, renewalWindow, expiration, MASTER_TOKEN, 1L, ISSUER_DATA, USER);
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, requestUserIdToken);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
final MessageHeader response = responseBuilder.getHeader();
assertEquals(MASTER_TOKEN, response.getMasterToken());
final UserIdToken responseUserIdToken = response.getUserIdToken();
assertNotNull(responseUserIdToken);
assertEquals(requestUserIdToken.getUser(), responseUserIdToken.getUser());
assertEquals(requestUserIdToken.getMasterTokenSerialNumber(), responseUserIdToken.getMasterTokenSerialNumber());
assertEquals(requestUserIdToken.getSerialNumber(), responseUserIdToken.getSerialNumber());
assertEquals(requestUserIdToken.getRenewalWindow(), responseUserIdToken.getRenewalWindow());
assertEquals(requestUserIdToken.getExpiration(), responseUserIdToken.getExpiration());
}
@Test
public void peerRenewUserIdToken() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final Date renewalWindow = new Date(System.currentTimeMillis() - 10000);
final Date expiration = new Date(System.currentTimeMillis() + 10000);
final UserIdToken requestUserIdToken = new UserIdToken(p2pCtx, renewalWindow, expiration, MASTER_TOKEN, 1L, ISSUER_DATA, USER);
final MessageBuilder requestBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, requestUserIdToken);
requestBuilder.setRenewable(true);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(p2pCtx, request);
final MessageHeader response = responseBuilder.getHeader();
assertEquals(MASTER_TOKEN, response.getPeerMasterToken());
assertNull(response.getUserIdToken());
final UserIdToken responseUserIdToken = response.getPeerUserIdToken();
assertNotNull(responseUserIdToken);
assertEquals(requestUserIdToken.getUser(), responseUserIdToken.getUser());
assertEquals(requestUserIdToken.getMasterTokenSerialNumber(), responseUserIdToken.getMasterTokenSerialNumber());
assertEquals(requestUserIdToken.getSerialNumber(), responseUserIdToken.getSerialNumber());
assertFalse(responseUserIdToken.isRenewable(null));
}
@Test
public void expiredUserIdToken() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final Date renewalWindow = new Date(System.currentTimeMillis() - 20000);
final Date expiration = new Date(System.currentTimeMillis() - 10000);
final UserIdToken requestUserIdToken = new UserIdToken(trustedNetCtx, renewalWindow, expiration, MASTER_TOKEN, 1L, ISSUER_DATA, USER);
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, requestUserIdToken);
requestBuilder.setRenewable(true);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
final MessageHeader response = responseBuilder.getHeader();
assertEquals(MASTER_TOKEN, response.getMasterToken());
final UserIdToken responseUserIdToken = response.getUserIdToken();
assertNotNull(responseUserIdToken);
assertEquals(requestUserIdToken.getUser(), responseUserIdToken.getUser());
assertEquals(requestUserIdToken.getMasterTokenSerialNumber(), responseUserIdToken.getMasterTokenSerialNumber());
assertEquals(requestUserIdToken.getSerialNumber(), responseUserIdToken.getSerialNumber());
assertFalse(responseUserIdToken.isExpired(null));
}
@Test
public void expiredUserIdTokenNotRenewable() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final Date renewalWindow = new Date(System.currentTimeMillis() - 20000);
final Date expiration = new Date(System.currentTimeMillis() - 10000);
final UserIdToken requestUserIdToken = new UserIdToken(trustedNetCtx, renewalWindow, expiration, MASTER_TOKEN, 1L, ISSUER_DATA, USER);
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, requestUserIdToken);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
final MessageHeader response = responseBuilder.getHeader();
assertEquals(MASTER_TOKEN, response.getMasterToken());
final UserIdToken responseUserIdToken = response.getUserIdToken();
assertNotNull(responseUserIdToken);
assertEquals(requestUserIdToken.getUser(), responseUserIdToken.getUser());
assertEquals(requestUserIdToken.getMasterTokenSerialNumber(), responseUserIdToken.getMasterTokenSerialNumber());
assertEquals(requestUserIdToken.getSerialNumber(), responseUserIdToken.getSerialNumber());
assertFalse(responseUserIdToken.isExpired(null));
}
@Test
public void expiredUserIdTokenServerMessage() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
final Date renewalWindow = new Date(System.currentTimeMillis() - 20000);
final Date expiration = new Date(System.currentTimeMillis() - 10000);
final UserIdToken requestUserIdToken = new UserIdToken(ctx, renewalWindow, expiration, MASTER_TOKEN, 1L, ISSUER_DATA, USER);
// Change the MSL crypto context so the master token and user ID
// token are not issued by the local entity.
ctx.setMslCryptoContext(ALT_MSL_CRYPTO_CONTEXT);
// Now rebuild the user ID token and the build the request.
final MslObject userIdTokenMo = MslTestUtils.toMslObject(encoder, requestUserIdToken);
final UserIdToken unverifiedUserIdToken = new UserIdToken(ctx, userIdTokenMo, MASTER_TOKEN);
final MessageBuilder requestBuilder = messageFactory.createRequest(ctx, MASTER_TOKEN, unverifiedUserIdToken);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(ctx, request);
final MessageHeader response = responseBuilder.getHeader();
assertEquals(MASTER_TOKEN, response.getMasterToken());
final UserIdToken responseUserIdToken = response.getUserIdToken();
assertNotNull(responseUserIdToken);
// Can't compare users because the unverified user ID token won't
// have it.
assertEquals(unverifiedUserIdToken.getMasterTokenSerialNumber(), responseUserIdToken.getMasterTokenSerialNumber());
assertEquals(unverifiedUserIdToken.getSerialNumber(), responseUserIdToken.getSerialNumber());
assertFalse(responseUserIdToken.isExpired(null));
}
@Test
public void renewMasterTokenAndRenewUserIdToken() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final Date renewalWindow = new Date(System.currentTimeMillis() - 10000);
final Date expiration = new Date(System.currentTimeMillis() + 10000);
final MasterToken requestMasterToken = new MasterToken(trustedNetCtx, renewalWindow, expiration, 1L, 1L, null, MockPresharedAuthenticationFactory.PSK_ESN, MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH);
final UserIdToken requestUserIdToken = new UserIdToken(trustedNetCtx, renewalWindow, expiration, requestMasterToken, 1L, ISSUER_DATA, USER);
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, requestMasterToken, requestUserIdToken);
requestBuilder.setRenewable(true);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
requestBuilder.addKeyRequestData(keyRequestData);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
final MessageHeader response = responseBuilder.getHeader();
assertEquals(requestMasterToken, response.getMasterToken());
final KeyResponseData keyResponseData = response.getKeyResponseData();
assertNotNull(keyResponseData);
final MasterToken keyxMasterToken = keyResponseData.getMasterToken();
assertEquals(requestMasterToken.getIdentity(), keyxMasterToken.getIdentity());
assertEquals(incrementLong(requestMasterToken.getSequenceNumber()), keyxMasterToken.getSequenceNumber());
assertEquals(requestMasterToken.getSerialNumber(), keyxMasterToken.getSerialNumber());
final UserIdToken responseUserIdToken = response.getUserIdToken();
assertNotNull(responseUserIdToken);
assertEquals(requestUserIdToken.getUser(), responseUserIdToken.getUser());
assertEquals(requestUserIdToken.getMasterTokenSerialNumber(), responseUserIdToken.getMasterTokenSerialNumber());
assertEquals(requestUserIdToken.getSerialNumber(), responseUserIdToken.getSerialNumber());
}
@Test
public void renewTokensNoKeyRequestData() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final Date renewalWindow = new Date(System.currentTimeMillis() - 10000);
final Date expiration = new Date(System.currentTimeMillis() + 10000);
final MasterToken requestMasterToken = new MasterToken(trustedNetCtx, renewalWindow, expiration, 1L, 1L, null, MockPresharedAuthenticationFactory.PSK_ESN, MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH);
final UserIdToken requestUserIdToken = new UserIdToken(trustedNetCtx, renewalWindow, expiration, requestMasterToken, 1L, ISSUER_DATA, USER);
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, requestMasterToken, requestUserIdToken);
requestBuilder.setRenewable(true);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
final MessageHeader response = responseBuilder.getHeader();
final MasterToken responseMasterToken = response.getMasterToken();
final UserIdToken responseUserIdToken = response.getUserIdToken();
assertEquals(requestMasterToken, responseMasterToken);
assertEquals(requestMasterToken.getRenewalWindow(), responseMasterToken.getRenewalWindow());
assertEquals(requestMasterToken.getExpiration(), responseMasterToken.getExpiration());
assertEquals(requestUserIdToken, responseUserIdToken);
assertFalse(requestUserIdToken.getRenewalWindow().equals(responseUserIdToken.getRenewalWindow()));
assertFalse(requestUserIdToken.getExpiration().equals(responseUserIdToken.getExpiration()));
assertNull(response.getKeyResponseData());
}
@Test
public void peerRenewMasterTokenAndRenewUserIdToken() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final Date renewalWindow = new Date(System.currentTimeMillis() - 10000);
final Date expiration = new Date(System.currentTimeMillis() + 10000);
final MasterToken requestMasterToken = new MasterToken(p2pCtx, renewalWindow, expiration, 1L, 1L, null, MockPresharedAuthenticationFactory.PSK_ESN, MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH);
final UserIdToken requestUserIdToken = new UserIdToken(p2pCtx, renewalWindow, expiration, requestMasterToken, 1L, ISSUER_DATA, USER);
final MessageBuilder requestBuilder = messageFactory.createRequest(p2pCtx, requestMasterToken, requestUserIdToken);
requestBuilder.setRenewable(true);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
requestBuilder.addKeyRequestData(keyRequestData);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(p2pCtx, request);
final MessageHeader response = responseBuilder.getHeader();
assertNull(response.getMasterToken());
assertEquals(requestMasterToken, response.getPeerMasterToken());
final KeyResponseData keyResponseData = response.getKeyResponseData();
assertNotNull(keyResponseData);
final MasterToken keyxMasterToken = keyResponseData.getMasterToken();
assertEquals(requestMasterToken.getIdentity(), keyxMasterToken.getIdentity());
assertEquals(incrementLong(requestMasterToken.getSequenceNumber()), keyxMasterToken.getSequenceNumber());
assertEquals(requestMasterToken.getSerialNumber(), keyxMasterToken.getSerialNumber());
assertNull(response.getUserIdToken());
final UserIdToken responseUserIdToken = response.getPeerUserIdToken();
assertNotNull(responseUserIdToken);
assertEquals(requestUserIdToken.getUser(), responseUserIdToken.getUser());
assertEquals(requestUserIdToken.getMasterTokenSerialNumber(), responseUserIdToken.getMasterTokenSerialNumber());
assertEquals(requestUserIdToken.getSerialNumber(), responseUserIdToken.getSerialNumber());
}
@Test
public void masterTokenUserAuthData() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, null);
requestBuilder.setRenewable(true);
requestBuilder.setUserAuthenticationData(USER_AUTH_DATA);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
final MessageHeader response = responseBuilder.getHeader();
final UserIdToken userIdToken = response.getUserIdToken();
assertNotNull(userIdToken);
assertEquals(MockEmailPasswordAuthenticationFactory.USER, userIdToken.getUser());
}
@Test
public void masterTokenUserAuthenticated() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
final MessageBuilder requestBuilder = messageFactory.createRequest(ctx, MASTER_TOKEN, null);
requestBuilder.setRenewable(true);
requestBuilder.setUserAuthenticationData(USER_AUTH_DATA);
final MessageHeader request = requestBuilder.getHeader();
final MslObject requestMo = MslTestUtils.toMslObject(encoder, request);
final MessageHeader moRequest = (MessageHeader)Header.parseHeader(ctx, requestMo, CRYPTO_CONTEXTS);
assertNotNull(moRequest.getUser());
// Remove support for user authentication to prove the response
// does not perform it.
ctx.removeUserAuthenticationFactory(USER_AUTH_DATA.getScheme());
final MessageBuilder responseBuilder = messageFactory.createResponse(ctx, moRequest);
final MessageHeader response = responseBuilder.getHeader();
final UserIdToken userIdToken = response.getUserIdToken();
assertNotNull(userIdToken);
assertEquals(MockEmailPasswordAuthenticationFactory.USER, userIdToken.getUser());
}
@Test
public void peerMasterTokenUserAuthData() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, null);
requestBuilder.setRenewable(true);
requestBuilder.setUserAuthenticationData(USER_AUTH_DATA);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(p2pCtx, request);
final MessageHeader response = responseBuilder.getHeader();
assertNull(response.getUserIdToken());
final UserIdToken userIdToken = response.getPeerUserIdToken();
assertNotNull(userIdToken);
assertEquals(MockEmailPasswordAuthenticationFactory.USER, userIdToken.getUser());
}
@Test
public void peerMasterTokenUserAuthenticated() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, true);
final MessageBuilder requestBuilder = messageFactory.createRequest(ctx, MASTER_TOKEN, null);
requestBuilder.setRenewable(true);
requestBuilder.setUserAuthenticationData(USER_AUTH_DATA);
final MessageHeader request = requestBuilder.getHeader();
final MslObject requestMo = MslTestUtils.toMslObject(encoder, request);
final MessageHeader moRequest = (MessageHeader)Header.parseHeader(ctx, requestMo, CRYPTO_CONTEXTS);
assertNotNull(moRequest.getUser());
// Remove support for user authentication to prove the response
// does not perform it.
ctx.removeUserAuthenticationFactory(USER_AUTH_DATA.getScheme());
final MessageBuilder responseBuilder = messageFactory.createResponse(ctx, moRequest);
final MessageHeader response = responseBuilder.getHeader();
final UserIdToken userIdToken = response.getPeerUserIdToken();
assertNotNull(userIdToken);
assertEquals(MockEmailPasswordAuthenticationFactory.USER, userIdToken.getUser());
}
@Test
public void entityAuthDataUserAuthData() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, null, null);
requestBuilder.setRenewable(true);
requestBuilder.setUserAuthenticationData(USER_AUTH_DATA);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
requestBuilder.addKeyRequestData(keyRequestData);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
final MessageHeader response = responseBuilder.getHeader();
assertNull(response.getMasterToken());
final KeyResponseData keyResponseData = response.getKeyResponseData();
assertNotNull(keyResponseData);
final MasterToken keyxMasterToken = keyResponseData.getMasterToken();
assertEquals(trustedNetCtx.getEntityAuthenticationData(null).getIdentity(), keyxMasterToken.getIdentity());
final UserIdToken userIdToken = response.getUserIdToken();
assertNotNull(userIdToken);
assertEquals(MockEmailPasswordAuthenticationFactory.USER, userIdToken.getUser());
assertTrue(userIdToken.isBoundTo(keyxMasterToken));
}
@Test
public void entityAuthDataUserAuthenticatedData() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
final MessageBuilder requestBuilder = messageFactory.createRequest(ctx, null, null);
requestBuilder.setRenewable(true);
requestBuilder.setUserAuthenticationData(USER_AUTH_DATA);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
requestBuilder.addKeyRequestData(keyRequestData);
final MessageHeader request = requestBuilder.getHeader();
final MslObject requestMo = MslTestUtils.toMslObject(encoder, request);
final MessageHeader moRequest = (MessageHeader)Header.parseHeader(ctx, requestMo, CRYPTO_CONTEXTS);
assertNotNull(moRequest.getUser());
// Remove support for user authentication to prove the response
// does not perform it.
ctx.removeUserAuthenticationFactory(USER_AUTH_DATA.getScheme());
final MessageBuilder responseBuilder = messageFactory.createResponse(ctx, moRequest);
final MessageHeader response = responseBuilder.getHeader();
assertNull(response.getMasterToken());
final KeyResponseData keyResponseData = response.getKeyResponseData();
assertNotNull(keyResponseData);
final MasterToken keyxMasterToken = keyResponseData.getMasterToken();
assertEquals(trustedNetCtx.getEntityAuthenticationData(null).getIdentity(), keyxMasterToken.getIdentity());
final UserIdToken userIdToken = response.getUserIdToken();
assertNotNull(userIdToken);
assertEquals(MockEmailPasswordAuthenticationFactory.USER, userIdToken.getUser());
assertTrue(userIdToken.isBoundTo(keyxMasterToken));
}
@Test
public void entityUserAuthNoKeyRequestData() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, null, null);
requestBuilder.setRenewable(true);
requestBuilder.setUserAuthenticationData(USER_AUTH_DATA);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
final MessageHeader response = responseBuilder.getHeader();
assertNull(response.getMasterToken());
assertNull(response.getUserIdToken());
assertNull(response.getKeyResponseData());
assertEquals(trustedNetCtx.getEntityAuthenticationData(null), response.getEntityAuthenticationData());
}
@Test
public void peerEntityAuthDataUserAuthData() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(p2pCtx, null, null);
requestBuilder.setRenewable(true);
requestBuilder.setUserAuthenticationData(USER_AUTH_DATA);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
requestBuilder.addKeyRequestData(keyRequestData);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(p2pCtx, request);
final MessageHeader response = responseBuilder.getHeader();
assertNull(response.getMasterToken());
final KeyResponseData keyResponseData = response.getKeyResponseData();
assertNotNull(keyResponseData);
final MasterToken keyxMasterToken = keyResponseData.getMasterToken();
assertEquals(p2pCtx.getEntityAuthenticationData(null).getIdentity(), keyxMasterToken.getIdentity());
assertNull(response.getUserIdToken());
final UserIdToken userIdToken = response.getPeerUserIdToken();
assertNotNull(userIdToken);
assertEquals(MockEmailPasswordAuthenticationFactory.USER, userIdToken.getUser());
}
@Test
public void peerEntityAuthDataUserAuthenticatedData() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, true);
final MessageBuilder requestBuilder = messageFactory.createRequest(ctx, null, null);
requestBuilder.setRenewable(true);
requestBuilder.setUserAuthenticationData(USER_AUTH_DATA);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
requestBuilder.addKeyRequestData(keyRequestData);
final MessageHeader request = requestBuilder.getHeader();
final MslObject requestMo = MslTestUtils.toMslObject(encoder, request);
final MessageHeader moRequest = (MessageHeader)Header.parseHeader(ctx, requestMo, CRYPTO_CONTEXTS);
assertNotNull(moRequest.getUser());
// Remove support for user authentication to prove the response
// does not perform it.
ctx.removeUserAuthenticationFactory(USER_AUTH_DATA.getScheme());
final MessageBuilder responseBuilder = messageFactory.createResponse(ctx, moRequest);
final MessageHeader response = responseBuilder.getHeader();
assertNull(response.getMasterToken());
final KeyResponseData keyResponseData = response.getKeyResponseData();
assertNotNull(keyResponseData);
final MasterToken keyxMasterToken = keyResponseData.getMasterToken();
assertEquals(p2pCtx.getEntityAuthenticationData(null).getIdentity(), keyxMasterToken.getIdentity());
assertNull(response.getUserIdToken());
final UserIdToken userIdToken = response.getPeerUserIdToken();
assertNotNull(userIdToken);
assertEquals(MockEmailPasswordAuthenticationFactory.USER, userIdToken.getUser());
}
@Test
public void unsupportedUserAuthentication() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
thrown.expect(MslUserAuthException.class);
thrown.expectMslError(MslError.USERAUTH_FACTORY_NOT_FOUND);
thrown.expectMessageId(REQUEST_MESSAGE_ID);
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
for (final UserAuthenticationScheme scheme : UserAuthenticationScheme.values())
ctx.removeUserAuthenticationFactory(scheme);
final HeaderData headerData = new HeaderData(REQUEST_MESSAGE_ID, null, true, false, null, null, null, USER_AUTH_DATA, null, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader request = new MessageHeader(ctx, null, MASTER_TOKEN, headerData, peerData);
messageFactory.createResponse(ctx, request);
}
@Test
public void setMasterToken() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, null, null);
final MessageHeader request = requestBuilder.getHeader();
final MslStore store = trustedNetCtx.getMslStore();
store.setCryptoContext(MASTER_TOKEN, CRYPTO_CONTEXT);
store.setCryptoContext(PEER_MASTER_TOKEN, CRYPTO_CONTEXT);
store.addUserIdToken(PEER_USER_ID, PEER_USER_ID_TOKEN);
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, null);
store.addServiceTokens(serviceTokens);
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
store.addServiceTokens(peerServiceTokens);
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
responseBuilder.setAuthTokens(MASTER_TOKEN, null);
final MessageHeader messageHeader = responseBuilder.getHeader();
// The message service tokens will include all unbound service
// tokens.
final Set<ServiceToken> updatedServiceTokens = new HashSet<ServiceToken>(serviceTokens);
for (final ServiceToken peerServiceToken : peerServiceTokens) {
if (peerServiceToken.isUnbound())
updatedServiceTokens.add(peerServiceToken);
}
assertTrue(messageHeader.getServiceTokens().equals(updatedServiceTokens));
}
@Test
public void setExistingMasterToken() throws MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, null);
final MessageHeader request = requestBuilder.getHeader();
final MslStore store = trustedNetCtx.getMslStore();
store.setCryptoContext(MASTER_TOKEN, CRYPTO_CONTEXT);
store.setCryptoContext(PEER_MASTER_TOKEN, CRYPTO_CONTEXT);
store.addUserIdToken(PEER_USER_ID, PEER_USER_ID_TOKEN);
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, null);
store.addServiceTokens(serviceTokens);
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
store.addServiceTokens(peerServiceTokens);
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
responseBuilder.setAuthTokens(MASTER_TOKEN, null);
final MessageHeader messageHeader = responseBuilder.getHeader();
// The message service tokens will include all unbound service
// tokens.
final Set<ServiceToken> updatedServiceTokens = new HashSet<ServiceToken>(serviceTokens);
for (final ServiceToken peerServiceToken : peerServiceTokens) {
if (peerServiceToken.isUnbound())
updatedServiceTokens.add(peerServiceToken);
}
assertTrue(messageHeader.getServiceTokens().equals(updatedServiceTokens));
}
@Test
public void setAuthTokens() throws MslEncodingException, MslCryptoException, MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, null, null);
final MessageHeader request = requestBuilder.getHeader();
final MslStore store = trustedNetCtx.getMslStore();
store.setCryptoContext(MASTER_TOKEN, CRYPTO_CONTEXT);
store.setCryptoContext(PEER_MASTER_TOKEN, CRYPTO_CONTEXT);
store.addUserIdToken(PEER_USER_ID, PEER_USER_ID_TOKEN);
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
store.addServiceTokens(serviceTokens);
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
store.addServiceTokens(peerServiceTokens);
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
responseBuilder.setAuthTokens(MASTER_TOKEN, USER_ID_TOKEN);
final MessageHeader messageHeader = responseBuilder.getHeader();
// The message service tokens will include all unbound service
// tokens.
final Set<ServiceToken> updatedServiceTokens = new HashSet<ServiceToken>(serviceTokens);
for (final ServiceToken peerServiceToken : peerServiceTokens) {
if (peerServiceToken.isUnbound())
updatedServiceTokens.add(peerServiceToken);
}
assertTrue(messageHeader.getServiceTokens().equals(updatedServiceTokens));
}
@Test
public void setExistingAuthTokens() throws MslEncodingException, MslCryptoException, MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
final MessageHeader request = requestBuilder.getHeader();
final MslStore store = trustedNetCtx.getMslStore();
store.setCryptoContext(MASTER_TOKEN, CRYPTO_CONTEXT);
store.setCryptoContext(PEER_MASTER_TOKEN, CRYPTO_CONTEXT);
store.addUserIdToken(PEER_USER_ID, PEER_USER_ID_TOKEN);
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
store.addServiceTokens(serviceTokens);
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
store.addServiceTokens(peerServiceTokens);
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
responseBuilder.setAuthTokens(MASTER_TOKEN, USER_ID_TOKEN);
final MessageHeader messageHeader = responseBuilder.getHeader();
// The message service tokens will include all unbound service
// tokens.
final Set<ServiceToken> updatedServiceTokens = new HashSet<ServiceToken>(serviceTokens);
for (final ServiceToken peerServiceToken : peerServiceTokens) {
if (peerServiceToken.isUnbound())
updatedServiceTokens.add(peerServiceToken);
}
assertTrue(messageHeader.getServiceTokens().equals(updatedServiceTokens));
}
@Test
public void setNullMasterToken() throws MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, null, null);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
responseBuilder.setAuthTokens(null, null);
final MessageHeader response = responseBuilder.getHeader();
assertNull(response.getMasterToken());
assertNull(response.getUserIdToken());
}
@Test(expected = MslInternalException.class)
public void setMismatchedAuthTokens() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, null, null);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
responseBuilder.setAuthTokens(MASTER_TOKEN, PEER_USER_ID_TOKEN);
}
@Test(expected = MslInternalException.class)
public void setMasterTokenHasKeyExchangeData() throws MslException {
// The master token must be renewable to force a key exchange to
// happen.
final Date renewalWindow = new Date(System.currentTimeMillis() - 1000);
final Date expiration = new Date(System.currentTimeMillis() + 2000);
final String identity = MockPresharedAuthenticationFactory.PSK_ESN;
final SecretKey encryptionKey = MockPresharedAuthenticationFactory.KPE;
final SecretKey hmacKey = MockPresharedAuthenticationFactory.KPH;
final MasterToken masterToken = new MasterToken(trustedNetCtx, renewalWindow, expiration, 1, 1, null, identity, encryptionKey, hmacKey);
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, masterToken, null);
requestBuilder.setRenewable(true);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
requestBuilder.addKeyRequestData(keyRequestData);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
responseBuilder.setAuthTokens(MASTER_TOKEN, null);
}
@Test
public void setMasterTokenHasPeerKeyExchangeData() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
for (final KeyRequestData keyRequestData : KEY_REQUEST_DATA)
requestBuilder.addKeyRequestData(keyRequestData);
final MessageHeader request = requestBuilder.getHeader();
final MslStore store = p2pCtx.getMslStore();
store.setCryptoContext(MASTER_TOKEN, CRYPTO_CONTEXT);
store.addUserIdToken(USER_ID, USER_ID_TOKEN);
store.setCryptoContext(PEER_MASTER_TOKEN, CRYPTO_CONTEXT);
store.addUserIdToken(PEER_USER_ID, PEER_USER_ID_TOKEN);
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
store.addServiceTokens(serviceTokens);
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
store.addServiceTokens(peerServiceTokens);
final MessageBuilder responseBuilder = messageFactory.createResponse(p2pCtx, request);
responseBuilder.setAuthTokens(PEER_MASTER_TOKEN, null);
final MessageHeader response = responseBuilder.getHeader();
// Build the set of expected service tokens.
final Set<ServiceToken> expectedServiceTokens = new HashSet<ServiceToken>();
for (final ServiceToken serviceToken : serviceTokens) {
if (serviceToken.isUnbound())
expectedServiceTokens.add(serviceToken);
}
for (final ServiceToken peerServiceToken : peerServiceTokens) {
if (!peerServiceToken.isUserIdTokenBound())
expectedServiceTokens.add(peerServiceToken);
}
assertTrue(response.getServiceTokens().equals(expectedServiceTokens));
// Build the set of expected peer service tokens.
final Set<ServiceToken> expectedPeerServiceTokens = new HashSet<ServiceToken>(serviceTokens);
for (final ServiceToken peerServiceToken : peerServiceTokens) {
if (peerServiceToken.isUnbound())
expectedPeerServiceTokens.add(peerServiceToken);
}
assertTrue(response.getPeerServiceTokens().equals(expectedPeerServiceTokens));
}
@Test
public void setUser() throws MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, null);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
responseBuilder.setUser(USER_ID_TOKEN.getUser());
final UserIdToken userIdToken = responseBuilder.getUserIdToken();
assertNotNull(userIdToken);
assertEquals(USER_ID_TOKEN.getUser(), userIdToken.getUser());
}
@Test(expected = MslInternalException.class)
public void setUserNoMasterToken() throws MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, null, null);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
responseBuilder.setUser(USER_ID_TOKEN.getUser());
}
@Test(expected = MslInternalException.class)
public void setUserHasUserIdToken() throws MslEncodingException, MslCryptoException, MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(trustedNetCtx, request);
responseBuilder.setUser(USER_ID_TOKEN.getUser());
}
@Test
public void setPeerUser() throws MslMessageException, MslEncodingException, MslCryptoException, MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, null);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(p2pCtx, request);
responseBuilder.setUser(USER_ID_TOKEN.getUser());
final UserIdToken userIdToken = responseBuilder.getPeerUserIdToken();
assertNotNull(userIdToken);
assertEquals(USER_ID_TOKEN.getUser(), userIdToken.getUser());
}
@Test(expected = MslInternalException.class)
public void setPeerUserNoPeerMasterToken() throws MslEncodingException, MslCryptoException, MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(p2pCtx, null, null);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(p2pCtx, request);
responseBuilder.setUser(USER_ID_TOKEN.getUser());
}
@Test(expected = MslInternalException.class)
public void setPeerUserHasPeerUserIdToken() throws MslEncodingException, MslCryptoException, MslException {
final MessageBuilder requestBuilder = messageFactory.createRequest(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
final MessageHeader request = requestBuilder.getHeader();
final MessageBuilder responseBuilder = messageFactory.createResponse(p2pCtx, request);
responseBuilder.setUser(USER_ID_TOKEN.getUser());
}
@Test
public void oneRequestCapabilities() throws MslException {
final Set<CompressionAlgorithm> algos = new HashSet<CompressionAlgorithm>();
algos.add(CompressionAlgorithm.GZIP);
algos.add(CompressionAlgorithm.LZW);
final Set<CompressionAlgorithm> gzipOnly = new HashSet<CompressionAlgorithm>();
gzipOnly.add(CompressionAlgorithm.GZIP);
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
final MessageCapabilities caps = new MessageCapabilities(gzipOnly, null, null);
ctx.setMessageCapabilities(caps);
final MessageBuilder requestBuilder = messageFactory.createRequest(ctx, null, null);
final MessageHeader request = requestBuilder.getHeader();
assertEquals(caps, request.getMessageCapabilities());
ctx.setMessageCapabilities(new MessageCapabilities(algos, null, null));
final MessageBuilder responseBuilder = messageFactory.createResponse(ctx, request);
final MessageHeader response = responseBuilder.getHeader();
assertEquals(caps, response.getMessageCapabilities());
}
@Test
public void nullRequestCapabilities() throws MslException {
final Set<CompressionAlgorithm> algos = new HashSet<CompressionAlgorithm>();
algos.add(CompressionAlgorithm.GZIP);
algos.add(CompressionAlgorithm.LZW);
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
ctx.setMessageCapabilities(null);
final MessageBuilder requestBuilder = messageFactory.createRequest(ctx, null, null);
final MessageHeader request = requestBuilder.getHeader();
assertNull(request.getMessageCapabilities());
ctx.setMessageCapabilities(new MessageCapabilities(algos, null, null));
final MessageBuilder responseBuilder = messageFactory.createResponse(ctx, request);
final MessageHeader response = responseBuilder.getHeader();
assertNull(response.getMessageCapabilities());
}
}
}
| 9,957 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/msg/MessageHeaderTest.java | /**
* Copyright (c) 2012-2018 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.msg;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslConstants;
import com.netflix.msl.MslConstants.CompressionAlgorithm;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.MslKeyExchangeException;
import com.netflix.msl.MslMasterTokenException;
import com.netflix.msl.MslMessageException;
import com.netflix.msl.MslUserAuthException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.crypto.NullCryptoContext;
import com.netflix.msl.crypto.SessionCryptoContext;
import com.netflix.msl.entityauth.EntityAuthenticationData;
import com.netflix.msl.entityauth.EntityAuthenticationFactory;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.entityauth.MockPresharedAuthenticationFactory;
import com.netflix.msl.entityauth.PresharedAuthenticationData;
import com.netflix.msl.io.MslArray;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.keyx.KeyExchangeFactory;
import com.netflix.msl.keyx.KeyExchangeFactory.KeyExchangeData;
import com.netflix.msl.keyx.KeyRequestData;
import com.netflix.msl.keyx.KeyResponseData;
import com.netflix.msl.keyx.SymmetricWrappedExchange;
import com.netflix.msl.keyx.SymmetricWrappedExchange.KeyId;
import com.netflix.msl.msg.MessageHeader.HeaderData;
import com.netflix.msl.msg.MessageHeader.HeaderPeerData;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.tokens.MasterToken;
import com.netflix.msl.tokens.ServiceToken;
import com.netflix.msl.tokens.UserIdToken;
import com.netflix.msl.userauth.EmailPasswordAuthenticationData;
import com.netflix.msl.userauth.MockEmailPasswordAuthenticationFactory;
import com.netflix.msl.userauth.UserAuthenticationData;
import com.netflix.msl.util.Base64;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* Message header unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class MessageHeaderTest {
/** Milliseconds per second. */
private static final long MILLISECONDS_PER_SECOND = 1000;
/** Key entity authentication data. */
private static final String KEY_ENTITY_AUTHENTICATION_DATA = "entityauthdata";
/** Key master token. */
private static final String KEY_MASTER_TOKEN = "mastertoken";
/** Key header data. */
private static final String KEY_HEADERDATA = "headerdata";
/** Key error data signature. */
private static final String KEY_SIGNATURE = "signature";
// Message header data.
/** Key timestamp. */
private static final String KEY_TIMESTAMP = "timestamp";
/** Key message ID. */
private static final String KEY_MESSAGE_ID = "messageid";
/** Key non-replayable ID. */
private static final String KEY_NON_REPLAYABLE_ID = "nonreplayableid";
/** Key renewable flag. */
private static final String KEY_RENEWABLE = "renewable";
/** Key handshake flag */
private static final String KEY_HANDSHAKE = "handshake";
/** Key capabilities. */
private static final String KEY_CAPABILITIES = "capabilities";
/** Key key negotiation request. */
private static final String KEY_KEY_REQUEST_DATA = "keyrequestdata";
/** Key key negotiation response. */
private static final String KEY_KEY_RESPONSE_DATA = "keyresponsedata";
/** Key user authentication data. */
private static final String KEY_USER_AUTHENTICATION_DATA = "userauthdata";
/** Key user ID token. */
private static final String KEY_USER_ID_TOKEN = "useridtoken";
/** Key service tokens. */
private static final String KEY_SERVICE_TOKENS = "servicetokens";
// Message header peer data.
/** Key peer master token. */
private static final String KEY_PEER_MASTER_TOKEN = "peermastertoken";
/** Key peer user ID token. */
private static final String KEY_PEER_USER_ID_TOKEN = "peeruseridtoken";
/** Key peer service tokens. */
private static final String KEY_PEER_SERVICE_TOKENS = "peerservicetokens";
/**
* Checks if the given timestamp is close to "now".
*
* @param timestamp the timestamp to compare.
* @return true if the timestamp is about now.
*/
private static boolean isAboutNow(final Date timestamp) {
final long now = System.currentTimeMillis();
final long time = timestamp.getTime();
return (now - 1000 <= time && time <= now + 1000);
}
/**
* Checks if the given timestamp is close to "now".
*
* @param seconds the timestamp to compare in seconds since the epoch.
* @return true if the timestamp is about now.
*/
private static boolean isAboutNowSeconds(final long seconds) {
final long now = System.currentTimeMillis();
final long time = seconds * MILLISECONDS_PER_SECOND;
return (now - 1000 <= time && time <= now + 1000);
}
private static final Set<CompressionAlgorithm> ALGOS = new HashSet<CompressionAlgorithm>();
private static final List<String> LANGUAGES = Arrays.asList(new String[] {"en-US"});
private static final Set<MslEncoderFormat> FORMATS = new HashSet<MslEncoderFormat>();
private static MasterToken MASTER_TOKEN;
private static final long MESSAGE_ID = 1;
private static final Long NON_REPLAYABLE_ID = 1L;
private static final boolean RENEWABLE = true;
private static final boolean HANDSHAKE = false;
private static MessageCapabilities CAPABILITIES;
private static final Set<KeyRequestData> KEY_REQUEST_DATA = new HashSet<KeyRequestData>();
private static KeyResponseData KEY_RESPONSE_DATA;
private static UserAuthenticationData USER_AUTH_DATA;
private static UserIdToken USER_ID_TOKEN;
private static MasterToken PEER_MASTER_TOKEN;
private static UserIdToken PEER_USER_ID_TOKEN;
private static final Set<KeyRequestData> PEER_KEY_REQUEST_DATA = new HashSet<KeyRequestData>();
private static KeyResponseData PEER_KEY_RESPONSE_DATA;
private static final Map<String,ICryptoContext> CRYPTO_CONTEXTS = Collections.emptyMap();
/** MSL trusted network context. */
private static MslContext trustedNetCtx;
/** MSL peer-to-peer context. */
private static MslContext p2pCtx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
/** MSL encoder format. */
private static MslEncoderFormat format;
/**
* A helper class for building message header data.
*/
private static class HeaderDataBuilder {
/**
* Create a new header data builder with the default constant values
* and a random set of service tokens that may be bound to the provided
* master token and user ID token.
*
* @param ctx MSL context.
* @param masterToken message header master token. May be null.
* @param userIdToken message header user ID token. May be null.
* @param serviceTokens true to create service tokens. Otherwise the
* service token value will be set to null.
* @throws MslEncodingException if there is an error encoding the JSON
* data.
* @throws MslCryptoException if there is an error encrypting or signing
* the token data.
* @throws MslException if there is an error compressing the data.
*/
public HeaderDataBuilder(final MslContext ctx, final MasterToken masterToken, final UserIdToken userIdToken, final boolean serviceTokens) throws MslEncodingException, MslCryptoException, MslException {
final Set<ServiceToken> tokens = (serviceTokens) ? MslTestUtils.getServiceTokens(ctx, masterToken, userIdToken) : null;
values.put(KEY_MESSAGE_ID, MESSAGE_ID);
values.put(KEY_NON_REPLAYABLE_ID, NON_REPLAYABLE_ID);
values.put(KEY_RENEWABLE, RENEWABLE);
values.put(KEY_HANDSHAKE, HANDSHAKE);
values.put(KEY_CAPABILITIES, CAPABILITIES);
values.put(KEY_KEY_REQUEST_DATA, (!ctx.isPeerToPeer()) ? KEY_REQUEST_DATA : PEER_KEY_REQUEST_DATA);
values.put(KEY_KEY_RESPONSE_DATA, (!ctx.isPeerToPeer()) ? KEY_RESPONSE_DATA : PEER_KEY_RESPONSE_DATA);
values.put(KEY_USER_AUTHENTICATION_DATA, USER_AUTH_DATA);
values.put(KEY_USER_ID_TOKEN, userIdToken);
values.put(KEY_SERVICE_TOKENS, tokens);
}
/**
* Create a new header data builder with the default constant values
* and the provided set of service tokens.
*
* @param ctx MSL context.
* @param userIdToken message header user ID token. May be null.
* @param serviceTokens message header service tokens. May be null.
*/
public HeaderDataBuilder(final MslContext ctx, final UserIdToken userIdToken, final Set<ServiceToken> serviceTokens) {
values.put(KEY_MESSAGE_ID, MESSAGE_ID);
values.put(KEY_NON_REPLAYABLE_ID, NON_REPLAYABLE_ID);
values.put(KEY_RENEWABLE, RENEWABLE);
values.put(KEY_HANDSHAKE, HANDSHAKE);
values.put(KEY_CAPABILITIES, CAPABILITIES);
values.put(KEY_KEY_REQUEST_DATA, (!ctx.isPeerToPeer()) ? KEY_REQUEST_DATA : PEER_KEY_REQUEST_DATA);
values.put(KEY_KEY_RESPONSE_DATA, (!ctx.isPeerToPeer()) ? KEY_RESPONSE_DATA : PEER_KEY_RESPONSE_DATA);
values.put(KEY_USER_AUTHENTICATION_DATA, USER_AUTH_DATA);
values.put(KEY_USER_ID_TOKEN, userIdToken);
values.put(KEY_SERVICE_TOKENS, serviceTokens);
}
/**
* Set the value for the specified message data field.
*
* @param key message header field name.
* @param value message header field value.
* @return the builder.
*/
public HeaderDataBuilder set(final String key, final Object value) {
values.put(key, value);
return this;
}
/**
* @return the current set of service tokens. May be null.
*/
@SuppressWarnings("unchecked")
public Set<ServiceToken> getServiceTokens() {
return (Set<ServiceToken>)values.get(KEY_SERVICE_TOKENS);
}
/**
* Builds a new header data container with the currently set values.
*
* @return the header data.
*/
@SuppressWarnings("unchecked")
public HeaderData build() {
final Long messageId = (Long)values.get(KEY_MESSAGE_ID);
final Long nonReplayableId = (Long)values.get(KEY_NON_REPLAYABLE_ID);
final Boolean renewable = (Boolean)values.get(KEY_RENEWABLE);
final Boolean handshake = (Boolean)values.get(KEY_HANDSHAKE);
final MessageCapabilities capabilities = (MessageCapabilities)values.get(KEY_CAPABILITIES);
final Set<KeyRequestData> keyRequestData = (Set<KeyRequestData>)values.get(KEY_KEY_REQUEST_DATA);
final KeyResponseData keyResponseData = (KeyResponseData)values.get(KEY_KEY_RESPONSE_DATA);
final UserAuthenticationData userAuthData = (UserAuthenticationData)values.get(KEY_USER_AUTHENTICATION_DATA);
final UserIdToken userIdToken = (UserIdToken)values.get(KEY_USER_ID_TOKEN);
final Set<ServiceToken> serviceTokens = (Set<ServiceToken>)values.get(KEY_SERVICE_TOKENS);
return new HeaderData(messageId, nonReplayableId, renewable, handshake, capabilities, keyRequestData, keyResponseData, userAuthData, userIdToken, serviceTokens);
}
/** Header data values. */
private final Map<String,Object> values = new HashMap<String,Object>();
}
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@BeforeClass
public static void setup() throws MslException {
trustedNetCtx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
p2pCtx = new MockMslContext(EntityAuthenticationScheme.PSK, true);
encoder = trustedNetCtx.getMslEncoderFactory();
ALGOS.add(CompressionAlgorithm.GZIP);
ALGOS.add(CompressionAlgorithm.LZW);
FORMATS.add(MslEncoderFormat.JSON);
CAPABILITIES = new MessageCapabilities(ALGOS, LANGUAGES, FORMATS);
format = encoder.getPreferredFormat(CAPABILITIES.getEncoderFormats());
MASTER_TOKEN = MslTestUtils.getMasterToken(trustedNetCtx, 1, 1);
final KeyRequestData keyRequestData = new SymmetricWrappedExchange.RequestData(KeyId.PSK);
final KeyExchangeFactory factory = trustedNetCtx.getKeyExchangeFactory(keyRequestData.getKeyExchangeScheme());
final KeyExchangeData keyxData = factory.generateResponse(trustedNetCtx, format, keyRequestData, MASTER_TOKEN);
KEY_REQUEST_DATA.add(keyRequestData);
KEY_RESPONSE_DATA = keyxData.keyResponseData;
USER_AUTH_DATA = new EmailPasswordAuthenticationData(MockEmailPasswordAuthenticationFactory.EMAIL, MockEmailPasswordAuthenticationFactory.PASSWORD);
USER_ID_TOKEN = MslTestUtils.getUserIdToken(trustedNetCtx, MASTER_TOKEN, 1, MockEmailPasswordAuthenticationFactory.USER);
PEER_MASTER_TOKEN = MslTestUtils.getMasterToken(p2pCtx, 1, 2);
PEER_USER_ID_TOKEN = MslTestUtils.getUserIdToken(p2pCtx, PEER_MASTER_TOKEN, 1, MockEmailPasswordAuthenticationFactory.USER);
final KeyRequestData peerKeyRequestData = new SymmetricWrappedExchange.RequestData(KeyId.PSK);
final KeyExchangeFactory peerFactory = p2pCtx.getKeyExchangeFactory(peerKeyRequestData.getKeyExchangeScheme());
final KeyExchangeData peerKeyxData = peerFactory.generateResponse(p2pCtx, format, peerKeyRequestData, PEER_MASTER_TOKEN);
PEER_KEY_REQUEST_DATA.add(peerKeyRequestData);
PEER_KEY_RESPONSE_DATA = peerKeyxData.keyResponseData;
}
@AfterClass
public static void teardown() {
format = null;
encoder = null;
p2pCtx = null;
trustedNetCtx = null;
}
@Before
public void reset() {
trustedNetCtx.getMslStore().clearCryptoContexts();
trustedNetCtx.getMslStore().clearServiceTokens();
p2pCtx.getMslStore().clearCryptoContexts();
p2pCtx.getMslStore().clearServiceTokens();
}
@Test
public void entityAuthDataCtors() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
// Service tokens may be created with the key response data tokens. The
// key response data master token has the same serial number as the
// original master token so we can use the same user ID token.
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
assertTrue(messageHeader.isEncrypting());
assertEquals(NON_REPLAYABLE_ID, messageHeader.getNonReplayableId());
assertEquals(RENEWABLE, messageHeader.isRenewable());
assertEquals(HANDSHAKE, messageHeader.isHandshake());
assertEquals(CAPABILITIES, messageHeader.getMessageCapabilities());
assertNotNull(messageHeader.getCryptoContext());
assertEquals(entityAuthData, messageHeader.getEntityAuthenticationData());
final Set<KeyRequestData> keyRequestData = messageHeader.getKeyRequestData();
assertTrue(keyRequestData.containsAll(KEY_REQUEST_DATA));
assertEquals(KEY_RESPONSE_DATA, messageHeader.getKeyResponseData());
assertNull(messageHeader.getMasterToken());
assertTrue(isAboutNow(messageHeader.getTimestamp()));
assertEquals(MESSAGE_ID, messageHeader.getMessageId());
assertNull(messageHeader.getPeerMasterToken());
assertTrue(messageHeader.getPeerServiceTokens().isEmpty());
assertNull(messageHeader.getPeerUserIdToken());
final Set<ServiceToken> serviceTokens = builder.getServiceTokens();
assertTrue(messageHeader.getServiceTokens().containsAll(serviceTokens));
assertEquals(USER_AUTH_DATA, messageHeader.getUserAuthenticationData());
assertEquals(USER_ID_TOKEN, messageHeader.getUserIdToken());
assertEquals(USER_ID_TOKEN.getUser(), messageHeader.getUser());
}
@Test
public void entityAuthDataReplayable() throws MslEncodingException, MslCryptoException, MslException {
// Service tokens may be created with the key response data tokens. The
// key response data master token has the same serial number as the
// original master token so we can use the same user ID token.
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_NON_REPLAYABLE_ID, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
assertTrue(messageHeader.isEncrypting());
assertNull(messageHeader.getNonReplayableId());
assertEquals(RENEWABLE, messageHeader.isRenewable());
assertEquals(HANDSHAKE, messageHeader.isHandshake());
assertEquals(CAPABILITIES, messageHeader.getMessageCapabilities());
assertNotNull(messageHeader.getCryptoContext());
assertEquals(entityAuthData, messageHeader.getEntityAuthenticationData());
final Set<KeyRequestData> keyRequestData = messageHeader.getKeyRequestData();
assertTrue(keyRequestData.containsAll(KEY_REQUEST_DATA));
assertEquals(KEY_RESPONSE_DATA, messageHeader.getKeyResponseData());
assertNull(messageHeader.getMasterToken());
assertTrue(isAboutNow(messageHeader.getTimestamp()));
assertEquals(MESSAGE_ID, messageHeader.getMessageId());
assertNull(messageHeader.getPeerMasterToken());
assertTrue(messageHeader.getPeerServiceTokens().isEmpty());
assertNull(messageHeader.getPeerUserIdToken());
final Set<ServiceToken> serviceTokens = builder.getServiceTokens();
assertTrue(messageHeader.getServiceTokens().containsAll(serviceTokens));
assertEquals(USER_AUTH_DATA, messageHeader.getUserAuthenticationData());
assertEquals(USER_ID_TOKEN, messageHeader.getUserIdToken());
assertEquals(USER_ID_TOKEN.getUser(), messageHeader.getUser());
}
@Test
public void entityAuthDataMslObject() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException, MslEncoderException, UnsupportedEncodingException {
// Service tokens may be created with the key response data tokens. The
// key response data master token has the same serial number as the
// original master token so we can use the same user ID token.
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
final EntityAuthenticationScheme scheme = entityAuthData.getScheme();
final EntityAuthenticationFactory factory = trustedNetCtx.getEntityAuthenticationFactory(scheme);
final ICryptoContext cryptoContext = factory.getCryptoContext(trustedNetCtx, entityAuthData);
final MslObject mo = MslTestUtils.toMslObject(encoder, messageHeader);
final MslObject entityAuthDataMo = mo.getMslObject(KEY_ENTITY_AUTHENTICATION_DATA, encoder);
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, entityAuthData), entityAuthDataMo));
assertFalse(mo.has(KEY_MASTER_TOKEN));
final byte[] ciphertext = mo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdata = encoder.parseObject(plaintext);
final byte[] signature = mo.getBytes(KEY_SIGNATURE);
assertTrue(cryptoContext.verify(ciphertext, signature, encoder));
assertEquals(NON_REPLAYABLE_ID, (Long)headerdata.getLong(KEY_NON_REPLAYABLE_ID));
assertEquals(RENEWABLE, headerdata.getBoolean(KEY_RENEWABLE));
assertEquals(HANDSHAKE, headerdata.getBoolean(KEY_HANDSHAKE));
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, CAPABILITIES), headerdata.getMslObject(KEY_CAPABILITIES, encoder)));
assertTrue(MslEncoderUtils.equalArrays(MslEncoderUtils.createArray(trustedNetCtx, format, KEY_REQUEST_DATA), headerdata.getMslArray(KEY_KEY_REQUEST_DATA)));
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, KEY_RESPONSE_DATA), headerdata.getMslObject(KEY_KEY_RESPONSE_DATA, encoder)));
assertTrue(isAboutNowSeconds(headerdata.getLong(KEY_TIMESTAMP)));
assertEquals(MESSAGE_ID, headerdata.getLong(KEY_MESSAGE_ID));
assertFalse(headerdata.has(KEY_PEER_MASTER_TOKEN));
assertFalse(headerdata.has(KEY_PEER_SERVICE_TOKENS));
assertFalse(headerdata.has(KEY_PEER_USER_ID_TOKEN));
final Set<ServiceToken> serviceTokens = builder.getServiceTokens();
assertTrue(MslEncoderUtils.equalArrays(MslEncoderUtils.createArray(trustedNetCtx, format, serviceTokens), headerdata.getMslArray(KEY_SERVICE_TOKENS)));
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, USER_AUTH_DATA), headerdata.getMslObject(KEY_USER_AUTHENTICATION_DATA, encoder)));
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, USER_ID_TOKEN), headerdata.getMslObject(KEY_USER_ID_TOKEN, encoder)));
}
@Test
public void entityAuthDataReplayableMslObject() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException, MslEncoderException, UnsupportedEncodingException {
// Service tokens may be created with the key response data tokens. The
// key response data master token has the same serial number as the
// original master token so we can use the same user ID token.
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_NON_REPLAYABLE_ID, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
final EntityAuthenticationScheme scheme = entityAuthData.getScheme();
final EntityAuthenticationFactory factory = trustedNetCtx.getEntityAuthenticationFactory(scheme);
final ICryptoContext cryptoContext = factory.getCryptoContext(trustedNetCtx, entityAuthData);
final MslObject mo = MslTestUtils.toMslObject(encoder, messageHeader);
final MslObject entityAuthDataMo = mo.getMslObject(KEY_ENTITY_AUTHENTICATION_DATA, encoder);
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, entityAuthData), entityAuthDataMo));
assertFalse(mo.has(KEY_MASTER_TOKEN));
final byte[] ciphertext = mo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdata = encoder.parseObject(plaintext);
final byte[] signature = mo.getBytes(KEY_SIGNATURE);
assertTrue(cryptoContext.verify(ciphertext, signature, encoder));
assertFalse(headerdata.has(KEY_NON_REPLAYABLE_ID));
assertEquals(RENEWABLE, headerdata.getBoolean(KEY_RENEWABLE));
assertEquals(HANDSHAKE, headerdata.getBoolean(KEY_HANDSHAKE));
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, CAPABILITIES), headerdata.getMslObject(KEY_CAPABILITIES, encoder)));
assertTrue(MslEncoderUtils.equalArrays(MslEncoderUtils.createArray(trustedNetCtx, format, KEY_REQUEST_DATA), headerdata.getMslArray(KEY_KEY_REQUEST_DATA)));
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, KEY_RESPONSE_DATA), headerdata.getMslObject(KEY_KEY_RESPONSE_DATA, encoder)));
assertTrue(isAboutNowSeconds(headerdata.getLong(KEY_TIMESTAMP)));
assertEquals(MESSAGE_ID, headerdata.getLong(KEY_MESSAGE_ID));
assertFalse(headerdata.has(KEY_PEER_MASTER_TOKEN));
assertFalse(headerdata.has(KEY_PEER_SERVICE_TOKENS));
assertFalse(headerdata.has(KEY_PEER_USER_ID_TOKEN));
final Set<ServiceToken> serviceTokens = builder.getServiceTokens();
assertTrue(MslEncoderUtils.equalArrays(MslEncoderUtils.createArray(trustedNetCtx, format, serviceTokens), headerdata.getMslArray(KEY_SERVICE_TOKENS)));
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, USER_AUTH_DATA), headerdata.getMslObject(KEY_USER_AUTHENTICATION_DATA, encoder)));
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, USER_ID_TOKEN), headerdata.getMslObject(KEY_USER_ID_TOKEN, encoder)));
}
@Test
public void entityAuthDataPeerCtors() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, null, null, true);
final HeaderData headerData = builder.build();
// Peer service tokens may be created with the key response data master
// token. The peer key response data master token has the same serial
// number as the original peer master token so we can use the same peer
// user ID token.
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final EntityAuthenticationData entityAuthData = p2pCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, entityAuthData, null, headerData, peerData);
assertTrue(messageHeader.isEncrypting());
assertEquals(NON_REPLAYABLE_ID, messageHeader.getNonReplayableId());
assertEquals(RENEWABLE, messageHeader.isRenewable());
assertEquals(HANDSHAKE, messageHeader.isHandshake());
assertEquals(CAPABILITIES, messageHeader.getMessageCapabilities());
assertNotNull(messageHeader.getCryptoContext());
assertEquals(entityAuthData, messageHeader.getEntityAuthenticationData());
final Set<KeyRequestData> keyRequestData = messageHeader.getKeyRequestData();
assertTrue(keyRequestData.containsAll(PEER_KEY_REQUEST_DATA));
assertEquals(PEER_KEY_RESPONSE_DATA, messageHeader.getKeyResponseData());
assertNull(messageHeader.getMasterToken());
assertTrue(isAboutNow(messageHeader.getTimestamp()));
assertEquals(MESSAGE_ID, messageHeader.getMessageId());
assertEquals(PEER_MASTER_TOKEN, messageHeader.getPeerMasterToken());
assertTrue(messageHeader.getPeerServiceTokens().containsAll(peerServiceTokens));
assertEquals(PEER_USER_ID_TOKEN, messageHeader.getPeerUserIdToken());
final Set<ServiceToken> serviceTokens = builder.getServiceTokens();
assertTrue(messageHeader.getServiceTokens().containsAll(serviceTokens));
assertEquals(USER_AUTH_DATA, messageHeader.getUserAuthenticationData());
assertNull(messageHeader.getUserIdToken());
assertNull(messageHeader.getUser());
}
@Test
public void entityAuthDataReplayablePeerCtors() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, null, null, true);
builder.set(KEY_NON_REPLAYABLE_ID, null);
final HeaderData headerData = builder.build();
// Peer service tokens may be created with the key response data master
// token. The peer key response data master token has the same serial
// number as the original peer master token so we can use the same peer
// user ID token.
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final EntityAuthenticationData entityAuthData = p2pCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, entityAuthData, null, headerData, peerData);
assertTrue(messageHeader.isEncrypting());
assertNull(messageHeader.getNonReplayableId());
assertEquals(RENEWABLE, messageHeader.isRenewable());
assertEquals(HANDSHAKE, messageHeader.isHandshake());
assertEquals(CAPABILITIES, messageHeader.getMessageCapabilities());
assertNotNull(messageHeader.getCryptoContext());
assertEquals(entityAuthData, messageHeader.getEntityAuthenticationData());
final Set<KeyRequestData> keyRequestData = messageHeader.getKeyRequestData();
assertTrue(keyRequestData.containsAll(PEER_KEY_REQUEST_DATA));
assertEquals(PEER_KEY_RESPONSE_DATA, messageHeader.getKeyResponseData());
assertNull(messageHeader.getMasterToken());
assertTrue(isAboutNow(messageHeader.getTimestamp()));
assertEquals(MESSAGE_ID, messageHeader.getMessageId());
assertEquals(PEER_MASTER_TOKEN, messageHeader.getPeerMasterToken());
assertTrue(messageHeader.getPeerServiceTokens().containsAll(peerServiceTokens));
assertEquals(PEER_USER_ID_TOKEN, messageHeader.getPeerUserIdToken());
final Set<ServiceToken> serviceTokens = builder.getServiceTokens();
assertTrue(messageHeader.getServiceTokens().containsAll(serviceTokens));
assertEquals(USER_AUTH_DATA, messageHeader.getUserAuthenticationData());
assertNull(messageHeader.getUserIdToken());
assertNull(messageHeader.getUser());
}
@Test
public void entityAuthDataPeerMslObject() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException, MslEncoderException, UnsupportedEncodingException {
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, null, null, true);
final HeaderData headerData = builder.build();
// Peer service tokens may be created with the key response data master
// token. The peer key response data master token has the same serial
// number as the original peer master token so we can use the same peer
// user ID token.
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final EntityAuthenticationData entityAuthData = p2pCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, entityAuthData, null, headerData, peerData);
final EntityAuthenticationScheme scheme = entityAuthData.getScheme();
final EntityAuthenticationFactory factory = p2pCtx.getEntityAuthenticationFactory(scheme);
final ICryptoContext cryptoContext = factory.getCryptoContext(p2pCtx, entityAuthData);
final MslObject mo = MslTestUtils.toMslObject(encoder, messageHeader);
final MslObject entityAuthDataMo = mo.getMslObject(KEY_ENTITY_AUTHENTICATION_DATA, encoder);
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, entityAuthData), entityAuthDataMo));
assertFalse(mo.has(KEY_MASTER_TOKEN));
final byte[] ciphertext = mo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdata = encoder.parseObject(plaintext);
final byte[] signature = mo.getBytes(KEY_SIGNATURE);
assertTrue(cryptoContext.verify(ciphertext, signature, encoder));
assertEquals(NON_REPLAYABLE_ID, (Long)headerdata.getLong(KEY_NON_REPLAYABLE_ID));
assertEquals(RENEWABLE, headerdata.getBoolean(KEY_RENEWABLE));
assertEquals(HANDSHAKE, headerdata.getBoolean(KEY_HANDSHAKE));
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, CAPABILITIES), headerdata.getMslObject(KEY_CAPABILITIES, encoder)));
assertTrue(MslEncoderUtils.equalArrays(MslEncoderUtils.createArray(p2pCtx, format, PEER_KEY_REQUEST_DATA), headerdata.getMslArray(KEY_KEY_REQUEST_DATA)));
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, PEER_KEY_RESPONSE_DATA), headerdata.getMslObject(KEY_KEY_RESPONSE_DATA, encoder)));
assertTrue(isAboutNowSeconds(headerdata.getLong(KEY_TIMESTAMP)));
assertEquals(MESSAGE_ID, headerdata.getLong(KEY_MESSAGE_ID));
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, PEER_MASTER_TOKEN), headerdata.getMslObject(KEY_PEER_MASTER_TOKEN, encoder)));
assertTrue(MslEncoderUtils.equalArrays(MslEncoderUtils.createArray(p2pCtx, format, peerServiceTokens), headerdata.getMslArray(KEY_PEER_SERVICE_TOKENS)));
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, PEER_USER_ID_TOKEN), headerdata.getMslObject(KEY_PEER_USER_ID_TOKEN, encoder)));
final Set<ServiceToken> serviceTokens = builder.getServiceTokens();
assertTrue(MslEncoderUtils.equalArrays(MslEncoderUtils.createArray(p2pCtx, format, serviceTokens), headerdata.getMslArray(KEY_SERVICE_TOKENS)));
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, USER_AUTH_DATA), headerdata.getMslObject(KEY_USER_AUTHENTICATION_DATA, encoder)));
assertFalse(headerdata.has(KEY_USER_ID_TOKEN));
}
@Test
public void entityAuthDataReplayablePeerMslObject() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException, MslEncoderException, UnsupportedEncodingException {
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, null, null, true);
builder.set(KEY_NON_REPLAYABLE_ID, null);
final HeaderData headerData = builder.build();
// Peer service tokens may be created with the key response data master
// token. The peer key response data master token has the same serial
// number as the original peer master token so we can use the same peer
// user ID token.
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final EntityAuthenticationData entityAuthData = p2pCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, entityAuthData, null, headerData, peerData);
final EntityAuthenticationScheme scheme = entityAuthData.getScheme();
final EntityAuthenticationFactory factory = p2pCtx.getEntityAuthenticationFactory(scheme);
final ICryptoContext cryptoContext = factory.getCryptoContext(p2pCtx, entityAuthData);
final MslObject mo = MslTestUtils.toMslObject(encoder, messageHeader);
final MslObject entityAuthDataMo = mo.getMslObject(KEY_ENTITY_AUTHENTICATION_DATA, encoder);
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, entityAuthData), entityAuthDataMo));
assertFalse(mo.has(KEY_MASTER_TOKEN));
final byte[] ciphertext = mo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdata = encoder.parseObject(plaintext);
final byte[] signature = mo.getBytes(KEY_SIGNATURE);
assertTrue(cryptoContext.verify(ciphertext, signature, encoder));
assertFalse(headerdata.has(KEY_NON_REPLAYABLE_ID));
assertEquals(RENEWABLE, headerdata.getBoolean(KEY_RENEWABLE));
assertEquals(HANDSHAKE, headerdata.getBoolean(KEY_HANDSHAKE));
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, CAPABILITIES), headerdata.getMslObject(KEY_CAPABILITIES, encoder)));
assertTrue(MslEncoderUtils.equalArrays(MslEncoderUtils.createArray(p2pCtx, format, PEER_KEY_REQUEST_DATA), headerdata.getMslArray(KEY_KEY_REQUEST_DATA)));
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, PEER_KEY_RESPONSE_DATA), headerdata.getMslObject(KEY_KEY_RESPONSE_DATA, encoder)));
assertTrue(isAboutNowSeconds(headerdata.getLong(KEY_TIMESTAMP)));
assertEquals(MESSAGE_ID, headerdata.getLong(KEY_MESSAGE_ID));
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, PEER_MASTER_TOKEN), headerdata.getMslObject(KEY_PEER_MASTER_TOKEN, encoder)));
assertTrue(MslEncoderUtils.equalArrays(MslEncoderUtils.createArray(p2pCtx, format, peerServiceTokens), headerdata.getMslArray(KEY_PEER_SERVICE_TOKENS)));
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, PEER_USER_ID_TOKEN), headerdata.getMslObject(KEY_PEER_USER_ID_TOKEN, encoder)));
final Set<ServiceToken> serviceTokens = builder.getServiceTokens();
assertTrue(MslEncoderUtils.equalArrays(MslEncoderUtils.createArray(p2pCtx, format, serviceTokens), headerdata.getMslArray(KEY_SERVICE_TOKENS)));
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, USER_AUTH_DATA), headerdata.getMslObject(KEY_USER_AUTHENTICATION_DATA, encoder)));
assertFalse(headerdata.has(KEY_USER_ID_TOKEN));
}
@Test
public void masterTokenCtors() throws MslMasterTokenException, MslEntityAuthException, MslException {
// Service tokens may be created with the key response data tokens. The
// key response data master token has the same serial number as the
// original master token so we can use the same user ID token.
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, MASTER_TOKEN, headerData, peerData);
assertTrue(messageHeader.isEncrypting());
assertEquals(NON_REPLAYABLE_ID, messageHeader.getNonReplayableId());
assertEquals(RENEWABLE, messageHeader.isRenewable());
assertEquals(HANDSHAKE, messageHeader.isHandshake());
assertEquals(CAPABILITIES, messageHeader.getMessageCapabilities());
assertNotNull(messageHeader.getCryptoContext());
assertNull(messageHeader.getEntityAuthenticationData());
final Set<KeyRequestData> keyRequestData = messageHeader.getKeyRequestData();
assertTrue(keyRequestData.containsAll(KEY_REQUEST_DATA));
assertEquals(KEY_RESPONSE_DATA, messageHeader.getKeyResponseData());
assertEquals(MASTER_TOKEN, messageHeader.getMasterToken());
assertTrue(isAboutNow(messageHeader.getTimestamp()));
assertEquals(MESSAGE_ID, messageHeader.getMessageId());
assertNull(messageHeader.getPeerMasterToken());
assertTrue(messageHeader.getPeerServiceTokens().isEmpty());
assertNull(messageHeader.getPeerUserIdToken());
final Set<ServiceToken> serviceTokens = builder.getServiceTokens();
assertTrue(messageHeader.getServiceTokens().containsAll(serviceTokens));
assertEquals(USER_AUTH_DATA, messageHeader.getUserAuthenticationData());
assertEquals(USER_ID_TOKEN, messageHeader.getUserIdToken());
assertEquals(USER_ID_TOKEN.getUser(), messageHeader.getUser());
}
@Test
public void masterTokenMslObject() throws MslEntityAuthException, MslException, MslEncoderException, UnsupportedEncodingException {
// Service tokens may be created with the key response data tokens. The
// key response data master token has the same serial number as the
// original master token so we can use the same user ID token.
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, MASTER_TOKEN, headerData, peerData);
final ICryptoContext cryptoContext = new SessionCryptoContext(trustedNetCtx, MASTER_TOKEN);
final MslObject mo = MslTestUtils.toMslObject(encoder, messageHeader);
assertFalse(mo.has(KEY_ENTITY_AUTHENTICATION_DATA));
final MslObject masterToken = mo.getMslObject(KEY_MASTER_TOKEN, encoder);
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, MASTER_TOKEN), masterToken));
final byte[] ciphertext = mo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdata = encoder.parseObject(plaintext);
final byte[] signature = mo.getBytes(KEY_SIGNATURE);
assertTrue(cryptoContext.verify(ciphertext, signature, encoder));
assertEquals(NON_REPLAYABLE_ID, (Long)headerdata.getLong(KEY_NON_REPLAYABLE_ID));
assertEquals(RENEWABLE, headerdata.getBoolean(KEY_RENEWABLE));
assertEquals(HANDSHAKE, headerdata.getBoolean(KEY_HANDSHAKE));
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, CAPABILITIES), headerdata.getMslObject(KEY_CAPABILITIES, encoder)));
assertTrue(MslEncoderUtils.equalArrays(MslEncoderUtils.createArray(trustedNetCtx, format, KEY_REQUEST_DATA), headerdata.getMslArray(KEY_KEY_REQUEST_DATA)));
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, KEY_RESPONSE_DATA), headerdata.getMslObject(KEY_KEY_RESPONSE_DATA, encoder)));
assertTrue(isAboutNowSeconds(headerdata.getLong(KEY_TIMESTAMP)));
assertEquals(MESSAGE_ID, headerdata.getLong(KEY_MESSAGE_ID));
assertFalse(headerdata.has(KEY_PEER_MASTER_TOKEN));
assertFalse(headerdata.has(KEY_PEER_SERVICE_TOKENS));
assertFalse(headerdata.has(KEY_PEER_USER_ID_TOKEN));
final Set<ServiceToken> serviceTokens = builder.getServiceTokens();
assertTrue(MslEncoderUtils.equalArrays(MslEncoderUtils.createArray(trustedNetCtx, format, serviceTokens), headerdata.getMslArray(KEY_SERVICE_TOKENS)));
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, USER_AUTH_DATA), headerdata.getMslObject(KEY_USER_AUTHENTICATION_DATA, encoder)));
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, USER_ID_TOKEN), headerdata.getMslObject(KEY_USER_ID_TOKEN, encoder)));
}
@Test
public void masterTokenPeerCtors() throws MslMasterTokenException, MslEntityAuthException, MslException {
// The key response data master token has the same serial number as
// the original master token so we can use the same service tokens and
// user ID token.
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
final HeaderData headerData = builder.build();
// Peer service tokens may be created with the key response data master
// token. The peer key response data master token has the same serial
// number as the original peer master token so we can use the same peer
// user ID token.
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final EntityAuthenticationData entityAuthData = p2pCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, entityAuthData, MASTER_TOKEN, headerData, peerData);
assertTrue(messageHeader.isEncrypting());
assertEquals(NON_REPLAYABLE_ID, messageHeader.getNonReplayableId());
assertEquals(RENEWABLE, messageHeader.isRenewable());
assertEquals(HANDSHAKE, messageHeader.isHandshake());
assertEquals(CAPABILITIES, messageHeader.getMessageCapabilities());
assertNotNull(messageHeader.getCryptoContext());
assertNull(messageHeader.getEntityAuthenticationData());
final Set<KeyRequestData> keyRequestData = messageHeader.getKeyRequestData();
assertTrue(keyRequestData.containsAll(PEER_KEY_REQUEST_DATA));
assertEquals(PEER_KEY_RESPONSE_DATA, messageHeader.getKeyResponseData());
assertEquals(MASTER_TOKEN, messageHeader.getMasterToken());
assertTrue(isAboutNow(messageHeader.getTimestamp()));
assertEquals(MESSAGE_ID, messageHeader.getMessageId());
assertEquals(PEER_MASTER_TOKEN, messageHeader.getPeerMasterToken());
assertTrue(messageHeader.getPeerServiceTokens().containsAll(peerServiceTokens));
assertEquals(PEER_USER_ID_TOKEN, messageHeader.getPeerUserIdToken());
final Set<ServiceToken> serviceTokens = builder.getServiceTokens();
assertTrue(messageHeader.getServiceTokens().containsAll(serviceTokens));
assertEquals(USER_AUTH_DATA, messageHeader.getUserAuthenticationData());
assertEquals(USER_ID_TOKEN, messageHeader.getUserIdToken());
assertEquals(USER_ID_TOKEN.getUser(), messageHeader.getUser());
}
@Test
public void masterTokenPeerMslObject() throws MslMasterTokenException, MslEntityAuthException, MslException, MslEncoderException, UnsupportedEncodingException {
// The key response data master token has the same serial number as
// the original master token so we can use the same service tokens and
// user ID token.
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
final HeaderData headerData = builder.build();
// Peer service tokens may be created with the key response data master
// token. The peer key response data master token has the same serial
// number as the original peer master token so we can use the same peer
// user ID token.
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final EntityAuthenticationData entityAuthData = p2pCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, entityAuthData, MASTER_TOKEN, headerData, peerData);
final ICryptoContext cryptoContext = new SessionCryptoContext(trustedNetCtx, MASTER_TOKEN);
final MslObject mo = MslTestUtils.toMslObject(encoder, messageHeader);
assertFalse(mo.has(KEY_ENTITY_AUTHENTICATION_DATA));
final MslObject masterToken = mo.getMslObject(KEY_MASTER_TOKEN, encoder);
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, MASTER_TOKEN), masterToken));
final byte[] ciphertext = mo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdata = encoder.parseObject(plaintext);
final byte[] signature = mo.getBytes(KEY_SIGNATURE);
assertTrue(cryptoContext.verify(ciphertext, signature, encoder));
assertEquals(NON_REPLAYABLE_ID, (Long)headerdata.getLong(KEY_NON_REPLAYABLE_ID));
assertEquals(RENEWABLE, headerdata.getBoolean(KEY_RENEWABLE));
assertEquals(HANDSHAKE, headerdata.getBoolean(KEY_HANDSHAKE));
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, CAPABILITIES), headerdata.getMslObject(KEY_CAPABILITIES, encoder)));
assertTrue(MslEncoderUtils.equalArrays(MslEncoderUtils.createArray(p2pCtx, format, PEER_KEY_REQUEST_DATA), headerdata.getMslArray(KEY_KEY_REQUEST_DATA)));
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, PEER_KEY_RESPONSE_DATA), headerdata.getMslObject(KEY_KEY_RESPONSE_DATA, encoder)));
assertTrue(isAboutNowSeconds(headerdata.getLong(KEY_TIMESTAMP)));
assertEquals(MESSAGE_ID, headerdata.getLong(KEY_MESSAGE_ID));
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, PEER_MASTER_TOKEN), headerdata.getMslObject(KEY_PEER_MASTER_TOKEN, encoder)));
assertTrue(MslEncoderUtils.equalArrays(MslEncoderUtils.createArray(p2pCtx, format, peerServiceTokens), headerdata.getMslArray(KEY_PEER_SERVICE_TOKENS)));
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, PEER_USER_ID_TOKEN), headerdata.getMslObject(KEY_PEER_USER_ID_TOKEN, encoder)));
final Set<ServiceToken> serviceTokens = builder.getServiceTokens();
assertTrue(MslEncoderUtils.equalArrays(MslEncoderUtils.createArray(p2pCtx, format, serviceTokens), headerdata.getMslArray(KEY_SERVICE_TOKENS)));
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, USER_AUTH_DATA), headerdata.getMslObject(KEY_USER_AUTHENTICATION_DATA, encoder)));
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, USER_ID_TOKEN), headerdata.getMslObject(KEY_USER_ID_TOKEN, encoder)));
}
@Test
public void nullArgumentsEntityAuthCtor() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, null, null, false);
builder.set(KEY_CAPABILITIES, null);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
builder.set(KEY_USER_AUTHENTICATION_DATA, null);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = p2pCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, entityAuthData, null, headerData, peerData);
assertTrue(messageHeader.isEncrypting());
assertEquals(NON_REPLAYABLE_ID, messageHeader.getNonReplayableId());
assertEquals(RENEWABLE, messageHeader.isRenewable());
assertEquals(HANDSHAKE, messageHeader.isHandshake());
assertNull(messageHeader.getMessageCapabilities());
assertNotNull(messageHeader.getCryptoContext());
assertEquals(entityAuthData, messageHeader.getEntityAuthenticationData());
assertTrue(messageHeader.getKeyRequestData().isEmpty());
assertNull(messageHeader.getKeyResponseData());
assertNull(messageHeader.getMasterToken());
assertTrue(isAboutNow(messageHeader.getTimestamp()));
assertEquals(MESSAGE_ID, messageHeader.getMessageId());
assertNull(messageHeader.getPeerMasterToken());
assertTrue(messageHeader.getPeerServiceTokens().isEmpty());
assertNull(messageHeader.getPeerUserIdToken());
assertTrue(messageHeader.getServiceTokens().isEmpty());
assertNull(messageHeader.getUserAuthenticationData());
assertNull(messageHeader.getUserIdToken());
assertNull(messageHeader.getUser());
}
@Test
public void emptyArgumentsEntityAuthCtor() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final Set<KeyRequestData> keyRequestData = Collections.emptySet();
final Set<ServiceToken> serviceTokens = Collections.emptySet();
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, null, null, false);
builder.set(KEY_CAPABILITIES, null);
builder.set(KEY_KEY_REQUEST_DATA, keyRequestData);
builder.set(KEY_KEY_RESPONSE_DATA, null);
builder.set(KEY_USER_AUTHENTICATION_DATA, null);
builder.set(KEY_SERVICE_TOKENS, serviceTokens);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = Collections.emptySet();
final HeaderPeerData peerData = new HeaderPeerData(null, null, peerServiceTokens);
final EntityAuthenticationData entityAuthData = p2pCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, entityAuthData, null, headerData, peerData);
assertTrue(messageHeader.isEncrypting());
assertEquals(NON_REPLAYABLE_ID, messageHeader.getNonReplayableId());
assertEquals(RENEWABLE, messageHeader.isRenewable());
assertEquals(HANDSHAKE, messageHeader.isHandshake());
assertNull(messageHeader.getMessageCapabilities());
assertNotNull(messageHeader.getCryptoContext());
assertEquals(entityAuthData, messageHeader.getEntityAuthenticationData());
assertTrue(messageHeader.getKeyRequestData().isEmpty());
assertNull(messageHeader.getKeyResponseData());
assertNull(messageHeader.getMasterToken());
assertTrue(isAboutNow(messageHeader.getTimestamp()));
assertEquals(MESSAGE_ID, messageHeader.getMessageId());
assertNull(messageHeader.getPeerMasterToken());
assertTrue(messageHeader.getPeerServiceTokens().isEmpty());
assertNull(messageHeader.getPeerUserIdToken());
assertTrue(messageHeader.getServiceTokens().isEmpty());
assertNull(messageHeader.getUserAuthenticationData());
assertNull(messageHeader.getUserIdToken());
assertNull(messageHeader.getUser());
}
@Test
public void nullArgumentsMasterTokenCtor() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, null, null, false);
builder.set(KEY_CAPABILITIES, null);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
builder.set(KEY_USER_AUTHENTICATION_DATA, null);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
assertTrue(messageHeader.isEncrypting());
assertEquals(NON_REPLAYABLE_ID, messageHeader.getNonReplayableId());
assertEquals(RENEWABLE, messageHeader.isRenewable());
assertEquals(HANDSHAKE, messageHeader.isHandshake());
assertNull(messageHeader.getMessageCapabilities());
assertNotNull(messageHeader.getCryptoContext());
assertNull(messageHeader.getEntityAuthenticationData());
assertTrue(messageHeader.getKeyRequestData().isEmpty());
assertNull(messageHeader.getKeyResponseData());
assertEquals(MASTER_TOKEN, messageHeader.getMasterToken());
assertTrue(isAboutNow(messageHeader.getTimestamp()));
assertEquals(MESSAGE_ID, messageHeader.getMessageId());
assertNull(messageHeader.getPeerMasterToken());
assertTrue(messageHeader.getPeerServiceTokens().isEmpty());
assertNull(messageHeader.getPeerUserIdToken());
assertTrue(messageHeader.getServiceTokens().isEmpty());
assertNull(messageHeader.getUserAuthenticationData());
assertNull(messageHeader.getUserIdToken());
assertNull(messageHeader.getUser());
}
@Test
public void emptyArgumentsMasterTokenCtor() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final Set<KeyRequestData> keyRequestData = Collections.emptySet();
final Set<ServiceToken> serviceTokens = Collections.emptySet();
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, null, null, false);
builder.set(KEY_CAPABILITIES, null);
builder.set(KEY_KEY_REQUEST_DATA, keyRequestData);
builder.set(KEY_KEY_RESPONSE_DATA, null);
builder.set(KEY_USER_AUTHENTICATION_DATA, null);
builder.set(KEY_SERVICE_TOKENS, serviceTokens);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = Collections.emptySet();
final HeaderPeerData peerData = new HeaderPeerData(null, null, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
assertTrue(messageHeader.isEncrypting());
assertEquals(NON_REPLAYABLE_ID, messageHeader.getNonReplayableId());
assertEquals(RENEWABLE, messageHeader.isRenewable());
assertEquals(HANDSHAKE, messageHeader.isHandshake());
assertNull(messageHeader.getMessageCapabilities());
assertNotNull(messageHeader.getCryptoContext());
assertNull(messageHeader.getEntityAuthenticationData());
assertTrue(messageHeader.getKeyRequestData().isEmpty());
assertNull(messageHeader.getKeyResponseData());
assertEquals(MASTER_TOKEN, messageHeader.getMasterToken());
assertTrue(isAboutNow(messageHeader.getTimestamp()));
assertEquals(MESSAGE_ID, messageHeader.getMessageId());
assertNull(messageHeader.getPeerMasterToken());
assertTrue(messageHeader.getPeerServiceTokens().isEmpty());
assertNull(messageHeader.getPeerUserIdToken());
assertTrue(messageHeader.getServiceTokens().isEmpty());
assertNull(messageHeader.getUserAuthenticationData());
assertNull(messageHeader.getUserIdToken());
assertNull(messageHeader.getUser());
}
@Test
public void x509isEncrypting() throws MslException {
final MslContext x509Ctx = new MockMslContext(EntityAuthenticationScheme.X509, false);
final HeaderDataBuilder builder = new HeaderDataBuilder(x509Ctx, MASTER_TOKEN, USER_ID_TOKEN, false);
builder.set(KEY_USER_AUTHENTICATION_DATA, null);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = x509Ctx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(x509Ctx, entityAuthData, null, headerData, peerData);
assertFalse(messageHeader.isEncrypting());
}
@Test(expected = MslInternalException.class)
public void missingBothAuthDataCtor() throws MslMasterTokenException, MslEntityAuthException, MslException {
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN, false);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
new MessageHeader(trustedNetCtx, null, null, headerData, peerData);
}
@Test(expected = MslInternalException.class)
public void userIdTokenNullMasterTokenCtor() throws MslMasterTokenException, MslEntityAuthException, MslException {
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN, false);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
}
@Test(expected = MslInternalException.class)
public void userIdTokenMismatchedMasterTokenCtor() throws MslMasterTokenException, MslEntityAuthException, MslException {
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(trustedNetCtx, PEER_MASTER_TOKEN, 1, MockEmailPasswordAuthenticationFactory.USER);
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, userIdToken, false);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerData, peerData);
}
@Test(expected = MslInternalException.class)
public void serviceTokenNullMasterTokenCtor() throws MslMasterTokenException, MslEntityAuthException, MslException {
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
}
@Test(expected = MslInternalException.class)
public void serviceTokenMismatchedMasterTokenCtor() throws MslMasterTokenException, MslEntityAuthException, MslException {
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, PEER_MASTER_TOKEN, null, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
builder.set(KEY_USER_ID_TOKEN, USER_ID_TOKEN);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerData, peerData);
}
@Test(expected = MslInternalException.class)
public void serviceTokenNullUserIdTokenCtor() throws MslMasterTokenException, MslEntityAuthException, MslException {
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
builder.set(KEY_USER_ID_TOKEN, null);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerData, peerData);
}
@Test(expected = MslInternalException.class)
public void serviceTokenMismatchedUserIdTokenCtor() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
// Technically the implementation does not hit this check because it
// will bail out earlier, but in case the implementation changes the
// order of checks (which it should not) this test will catch it.
//
// We cannot construct inconsistent service tokens via the ServiceToken
// ctor, so pass in a mismatched user ID token.
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
builder.set(KEY_USER_ID_TOKEN, PEER_USER_ID_TOKEN);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerData, peerData);
}
@Test(expected = MslInternalException.class)
public void peerUserIdTokenNullPeerMasterTokenCtor() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, false);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, PEER_USER_ID_TOKEN, null);
final EntityAuthenticationData entityAuthData = p2pCtx.getEntityAuthenticationData(null);
new MessageHeader(p2pCtx, entityAuthData, null, headerData, peerData);
}
@Test(expected = MslInternalException.class)
public void peerUserIdTokenMismatchedPeerMasterTokenCtor() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, false);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final UserIdToken peerUserIdToken = MslTestUtils.getUserIdToken(p2pCtx, MASTER_TOKEN, 1, MockEmailPasswordAuthenticationFactory.USER);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, peerUserIdToken, null);
final EntityAuthenticationData entityAuthData = p2pCtx.getEntityAuthenticationData(null);
new MessageHeader(p2pCtx, entityAuthData, null, headerData, peerData);
}
@Test(expected = MslInternalException.class)
public void peerServiceTokenNullMasterTokenCtor() throws MslMasterTokenException, MslEntityAuthException, MslException {
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, false);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, null);
final HeaderPeerData peerData = new HeaderPeerData(null, null, peerServiceTokens);
final EntityAuthenticationData entityAuthData = p2pCtx.getEntityAuthenticationData(null);
new MessageHeader(p2pCtx, entityAuthData, null, headerData, peerData);
}
@Test(expected = MslInternalException.class)
public void peerServiceTokenMismatchedMasterTokenCtor() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, false);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, MASTER_TOKEN, null);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, null, peerServiceTokens);
final EntityAuthenticationData entityAuthData = p2pCtx.getEntityAuthenticationData(null);
new MessageHeader(p2pCtx, entityAuthData, null, headerData, peerData);
}
@Test(expected = MslInternalException.class)
public void peerServiceTokenNullUserIdTokenCtor() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, false);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, null, peerServiceTokens);
final EntityAuthenticationData entityAuthData = p2pCtx.getEntityAuthenticationData(null);
new MessageHeader(p2pCtx, entityAuthData, null, headerData, peerData);
}
@Test(expected = MslInternalException.class)
public void peerServiceTokenMismatchedUserIdTokenCtor() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
// Technically the implementation does not hit this check because it
// will bail out earlier, but in case the implementation changes the
// order of checks (which it should not) this test will catch it.
//
// We cannot construct inconsistent service tokens via the ServiceToken
// ctor, so pass in a mismatched user ID token.
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, null, null, false);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, USER_ID_TOKEN, peerServiceTokens);
final EntityAuthenticationData entityAuthData = p2pCtx.getEntityAuthenticationData(null);
new MessageHeader(p2pCtx, entityAuthData, null, headerData, peerData);
}
@Test
public void untrustedMasterTokenCtor() throws MslEncodingException, MslCryptoException, MslEncoderException, MslException {
thrown.expect(MslMasterTokenException.class);
thrown.expectMslError(MslError.MASTERTOKEN_UNTRUSTED);
thrown.expectMessageId(MESSAGE_ID);
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, null, null, false);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, null);
final MasterToken masterToken = MslTestUtils.getUntrustedMasterToken(p2pCtx);
new MessageHeader(p2pCtx, null, masterToken, headerData, peerData);
}
@Test
public void unsupportedEntityAuthSchemeCtor() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
thrown.expect(MslEntityAuthException.class);
thrown.expectMslError(MslError.ENTITYAUTH_FACTORY_NOT_FOUND);
thrown.expectMessageId(MESSAGE_ID);
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
final EntityAuthenticationData entityAuthData = ctx.getEntityAuthenticationData(null);
ctx.removeEntityAuthenticationFactory(entityAuthData.getScheme());
final HeaderDataBuilder builder = new HeaderDataBuilder(ctx, null, null, false);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
new MessageHeader(ctx, entityAuthData, null, headerData, peerData);
}
@Test
public void cachedCryptoContextMasterTokenCtor() throws MslEncodingException, MslCryptoException, MslEncoderException, MslException {
// We should be okay with an untrusted master token if a crypto context
// is associated with it.
final MasterToken masterToken = MslTestUtils.getUntrustedMasterToken(p2pCtx);
final ICryptoContext cryptoContext = new NullCryptoContext();
p2pCtx.getMslStore().setCryptoContext(masterToken, cryptoContext);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(p2pCtx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, masterToken, null, true);
builder.set(KEY_USER_ID_TOKEN, userIdToken);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, masterToken, headerData, peerData);
assertEquals(NON_REPLAYABLE_ID, messageHeader.getNonReplayableId());
assertEquals(RENEWABLE, messageHeader.isRenewable());
assertEquals(HANDSHAKE, messageHeader.isHandshake());
assertNotNull(messageHeader.getCryptoContext());
assertNull(messageHeader.getEntityAuthenticationData());
final Set<KeyRequestData> keyRequestData = messageHeader.getKeyRequestData();
assertTrue(keyRequestData.containsAll(PEER_KEY_REQUEST_DATA));
assertEquals(PEER_KEY_RESPONSE_DATA, messageHeader.getKeyResponseData());
assertEquals(masterToken, messageHeader.getMasterToken());
assertEquals(MESSAGE_ID, messageHeader.getMessageId());
assertEquals(PEER_MASTER_TOKEN, messageHeader.getPeerMasterToken());
assertTrue(messageHeader.getPeerServiceTokens().containsAll(peerServiceTokens));
assertEquals(PEER_USER_ID_TOKEN, messageHeader.getPeerUserIdToken());
final Set<ServiceToken> serviceTokens = builder.getServiceTokens();
assertTrue(messageHeader.getServiceTokens().containsAll(serviceTokens));
assertEquals(USER_AUTH_DATA, messageHeader.getUserAuthenticationData());
assertEquals(userIdToken, messageHeader.getUserIdToken());
assertEquals(userIdToken.getUser(), messageHeader.getUser());
}
@Test
public void entityAuthDataParseHeader() throws MslMasterTokenException, MslEntityAuthException, MslException, MslEncoderException {
// Service tokens may be created with the key response data tokens. The
// key response data master token has the same serial number as the
// original master token so we can use the same user ID token.
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
final Header header = Header.parseHeader(trustedNetCtx, messageHeaderMo, CRYPTO_CONTEXTS);
assertNotNull(header);
assertTrue(header instanceof MessageHeader);
final MessageHeader moMessageHeader = (MessageHeader)header;
assertEquals(messageHeader.getNonReplayableId(), moMessageHeader.getNonReplayableId());
assertEquals(messageHeader.isRenewable(), moMessageHeader.isRenewable());
assertNotNull(messageHeader.getCryptoContext());
assertEquals(messageHeader.getEntityAuthenticationData(), moMessageHeader.getEntityAuthenticationData());
final Set<KeyRequestData> keyRequestData = messageHeader.getKeyRequestData();
final Set<KeyRequestData> moKeyRequestData = moMessageHeader.getKeyRequestData();
assertTrue(keyRequestData.containsAll(moKeyRequestData));
assertTrue(moKeyRequestData.containsAll(keyRequestData));
assertEquals(messageHeader.getKeyResponseData(), moMessageHeader.getKeyResponseData());
assertEquals(messageHeader.getMasterToken(), moMessageHeader.getMasterToken());
assertEquals(messageHeader.getMessageId(), moMessageHeader.getMessageId());
assertNull(messageHeader.getPeerMasterToken());
assertTrue(messageHeader.getPeerServiceTokens().isEmpty());
assertNull(messageHeader.getPeerUserIdToken());
final Set<ServiceToken> serviceTokens = messageHeader.getServiceTokens();
final Set<ServiceToken> moServiceTokens = moMessageHeader.getServiceTokens();
assertTrue(serviceTokens.containsAll(moServiceTokens));
assertTrue(moServiceTokens.containsAll(serviceTokens));
assertEquals(messageHeader.getUserAuthenticationData(), moMessageHeader.getUserAuthenticationData());
assertEquals(messageHeader.getUserIdToken(), moMessageHeader.getUserIdToken());
assertEquals(messageHeader.getUser(), moMessageHeader.getUser());
}
@Test
public void entityAuthDataPeerParseHeader() throws MslMasterTokenException, MslEntityAuthException, MslException, MslEncoderException {
// Service tokens may be created with the key response data tokens. The
// key response data master token has the same serial number as the
// original master token so we can use the same user ID token.
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, null, null, true);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final EntityAuthenticationData entityAuthData = p2pCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, entityAuthData, null, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
final Header header = Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
assertNotNull(header);
assertTrue(header instanceof MessageHeader);
final MessageHeader moMessageHeader = (MessageHeader)header;
assertEquals(messageHeader.getNonReplayableId(), moMessageHeader.getNonReplayableId());
assertEquals(messageHeader.isRenewable(), moMessageHeader.isRenewable());
assertNotNull(messageHeader.getCryptoContext());
assertEquals(messageHeader.getEntityAuthenticationData(), moMessageHeader.getEntityAuthenticationData());
final Set<KeyRequestData> keyRequestData = messageHeader.getKeyRequestData();
final Set<KeyRequestData> moKeyRequestData = moMessageHeader.getKeyRequestData();
assertTrue(keyRequestData.containsAll(moKeyRequestData));
assertTrue(moKeyRequestData.containsAll(keyRequestData));
assertEquals(messageHeader.getKeyResponseData(), moMessageHeader.getKeyResponseData());
assertEquals(messageHeader.getMasterToken(), moMessageHeader.getMasterToken());
assertEquals(messageHeader.getMessageId(), moMessageHeader.getMessageId());
assertEquals(messageHeader.getPeerMasterToken(), moMessageHeader.getPeerMasterToken());
final Set<ServiceToken> moPeerServiceTokens = moMessageHeader.getPeerServiceTokens();
assertTrue(peerServiceTokens.containsAll(moPeerServiceTokens));
assertTrue(moPeerServiceTokens.containsAll(peerServiceTokens));
assertEquals(messageHeader.getPeerUserIdToken(), moMessageHeader.getPeerUserIdToken());
final Set<ServiceToken> serviceTokens = messageHeader.getServiceTokens();
final Set<ServiceToken> moServiceTokens = moMessageHeader.getServiceTokens();
assertTrue(serviceTokens.containsAll(moServiceTokens));
assertTrue(moServiceTokens.containsAll(serviceTokens));
assertEquals(messageHeader.getUserAuthenticationData(), moMessageHeader.getUserAuthenticationData());
assertEquals(messageHeader.getUserIdToken(), moMessageHeader.getUserIdToken());
assertNotNull(moMessageHeader.getUser());
}
@Test
public void masterTokenParseHeader() throws MslMasterTokenException, MslEntityAuthException, MslException, MslEncoderException {
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(trustedNetCtx,PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
final Header header = Header.parseHeader(trustedNetCtx, messageHeaderMo, CRYPTO_CONTEXTS);
assertNotNull(header);
assertTrue(header instanceof MessageHeader);
final MessageHeader moMessageHeader = (MessageHeader)header;
assertEquals(messageHeader.getNonReplayableId(), moMessageHeader.getNonReplayableId());
assertEquals(messageHeader.isRenewable(), moMessageHeader.isRenewable());
assertNotNull(messageHeader.getCryptoContext());
assertEquals(messageHeader.getEntityAuthenticationData(), moMessageHeader.getEntityAuthenticationData());
final Set<KeyRequestData> keyRequestData = messageHeader.getKeyRequestData();
final Set<KeyRequestData> moKeyRequestData = moMessageHeader.getKeyRequestData();
assertTrue(keyRequestData.containsAll(moKeyRequestData));
assertTrue(moKeyRequestData.containsAll(keyRequestData));
assertEquals(messageHeader.getKeyResponseData(), moMessageHeader.getKeyResponseData());
assertEquals(messageHeader.getMasterToken(), moMessageHeader.getMasterToken());
assertEquals(messageHeader.getMessageId(), moMessageHeader.getMessageId());
assertNull(moMessageHeader.getPeerMasterToken());
assertTrue(moMessageHeader.getPeerServiceTokens().isEmpty());
assertNull(moMessageHeader.getPeerUserIdToken());
final Set<ServiceToken> serviceTokens = messageHeader.getServiceTokens();
final Set<ServiceToken> moServiceTokens = moMessageHeader.getServiceTokens();
assertTrue(serviceTokens.containsAll(moServiceTokens));
assertTrue(moServiceTokens.containsAll(serviceTokens));
assertEquals(messageHeader.getUserAuthenticationData(), moMessageHeader.getUserAuthenticationData());
assertEquals(messageHeader.getUserIdToken(), moMessageHeader.getUserIdToken());
assertEquals(messageHeader.getUser(), moMessageHeader.getUser());
}
@Test
public void masterTokenPeerParseHeader() throws MslMasterTokenException, MslEntityAuthException, MslException, MslEncoderException {
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final EntityAuthenticationData entityAuthData = p2pCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, entityAuthData, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
final Header header = Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
assertNotNull(header);
assertTrue(header instanceof MessageHeader);
final MessageHeader moMessageHeader = (MessageHeader)header;
assertEquals(messageHeader.getNonReplayableId(), moMessageHeader.getNonReplayableId());
assertEquals(messageHeader.isRenewable(), moMessageHeader.isRenewable());
assertNotNull(messageHeader.getCryptoContext());
assertEquals(messageHeader.getEntityAuthenticationData(), moMessageHeader.getEntityAuthenticationData());
final Set<KeyRequestData> keyRequestData = messageHeader.getKeyRequestData();
final Set<KeyRequestData> moKeyRequestData = moMessageHeader.getKeyRequestData();
assertTrue(keyRequestData.containsAll(moKeyRequestData));
assertTrue(moKeyRequestData.containsAll(keyRequestData));
assertEquals(messageHeader.getKeyResponseData(), moMessageHeader.getKeyResponseData());
assertEquals(messageHeader.getMasterToken(), moMessageHeader.getMasterToken());
assertEquals(messageHeader.getMessageId(), moMessageHeader.getMessageId());
assertEquals(messageHeader.getPeerMasterToken(), moMessageHeader.getPeerMasterToken());
final Set<ServiceToken> moPeerServiceTokens = moMessageHeader.getPeerServiceTokens();
assertTrue(peerServiceTokens.containsAll(moPeerServiceTokens));
assertTrue(moPeerServiceTokens.containsAll(peerServiceTokens));
assertEquals(messageHeader.getPeerUserIdToken(), moMessageHeader.getPeerUserIdToken());
final Set<ServiceToken> serviceTokens = messageHeader.getServiceTokens();
final Set<ServiceToken> moServiceTokens = moMessageHeader.getServiceTokens();
assertTrue(serviceTokens.containsAll(moServiceTokens));
assertTrue(moServiceTokens.containsAll(serviceTokens));
assertEquals(messageHeader.getUserAuthenticationData(), moMessageHeader.getUserAuthenticationData());
assertEquals(messageHeader.getUserIdToken(), moMessageHeader.getUserIdToken());
assertEquals(messageHeader.getUser(), moMessageHeader.getUser());
}
@Test
public void userAuthDataParseHeader() throws MslEncoderException, MslKeyExchangeException, MslUserAuthException, MslException {
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, null, true);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(trustedNetCtx,PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
final Header header = Header.parseHeader(trustedNetCtx, messageHeaderMo, CRYPTO_CONTEXTS);
assertNotNull(header);
assertTrue(header instanceof MessageHeader);
final MessageHeader moMessageHeader = (MessageHeader)header;
assertEquals(messageHeader.getNonReplayableId(), moMessageHeader.getNonReplayableId());
assertEquals(messageHeader.isRenewable(), moMessageHeader.isRenewable());
assertNotNull(messageHeader.getCryptoContext());
assertEquals(messageHeader.getEntityAuthenticationData(), moMessageHeader.getEntityAuthenticationData());
final Set<KeyRequestData> keyRequestData = messageHeader.getKeyRequestData();
final Set<KeyRequestData> moKeyRequestData = moMessageHeader.getKeyRequestData();
assertTrue(keyRequestData.containsAll(moKeyRequestData));
assertTrue(moKeyRequestData.containsAll(keyRequestData));
assertEquals(messageHeader.getKeyResponseData(), moMessageHeader.getKeyResponseData());
assertEquals(messageHeader.getMasterToken(), moMessageHeader.getMasterToken());
assertEquals(messageHeader.getMessageId(), moMessageHeader.getMessageId());
assertNull(moMessageHeader.getPeerMasterToken());
assertTrue(moMessageHeader.getPeerServiceTokens().isEmpty());
assertNull(moMessageHeader.getPeerUserIdToken());
final Set<ServiceToken> serviceTokens = messageHeader.getServiceTokens();
final Set<ServiceToken> moServiceTokens = moMessageHeader.getServiceTokens();
assertTrue(serviceTokens.containsAll(moServiceTokens));
assertTrue(moServiceTokens.containsAll(serviceTokens));
assertEquals(messageHeader.getUserAuthenticationData(), moMessageHeader.getUserAuthenticationData());
assertEquals(messageHeader.getUserIdToken(), moMessageHeader.getUserIdToken());
assertNotNull(moMessageHeader.getUser());
}
@Test
public void userAuthDataPeerParseHeader() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException, MslKeyExchangeException, MslUserAuthException, MslEncoderException, MslException {
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, null, true);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final EntityAuthenticationData entityAuthData = p2pCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, entityAuthData, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
final Header header = Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
assertNotNull(header);
assertTrue(header instanceof MessageHeader);
final MessageHeader moMessageHeader = (MessageHeader)header;
assertEquals(messageHeader.getNonReplayableId(), moMessageHeader.getNonReplayableId());
assertEquals(messageHeader.isRenewable(), moMessageHeader.isRenewable());
assertNotNull(messageHeader.getCryptoContext());
assertEquals(messageHeader.getEntityAuthenticationData(), moMessageHeader.getEntityAuthenticationData());
final Set<KeyRequestData> keyRequestData = messageHeader.getKeyRequestData();
final Set<KeyRequestData> moKeyRequestData = moMessageHeader.getKeyRequestData();
assertTrue(keyRequestData.containsAll(moKeyRequestData));
assertTrue(moKeyRequestData.containsAll(keyRequestData));
assertEquals(messageHeader.getKeyResponseData(), moMessageHeader.getKeyResponseData());
assertEquals(messageHeader.getMasterToken(), moMessageHeader.getMasterToken());
assertEquals(messageHeader.getMessageId(), moMessageHeader.getMessageId());
assertEquals(messageHeader.getPeerMasterToken(), moMessageHeader.getPeerMasterToken());
final Set<ServiceToken> moPeerServiceTokens = moMessageHeader.getPeerServiceTokens();
assertTrue(peerServiceTokens.containsAll(moPeerServiceTokens));
assertTrue(moPeerServiceTokens.containsAll(peerServiceTokens));
assertEquals(messageHeader.getPeerUserIdToken(), moMessageHeader.getPeerUserIdToken());
final Set<ServiceToken> serviceTokens = messageHeader.getServiceTokens();
final Set<ServiceToken> moServiceTokens = moMessageHeader.getServiceTokens();
assertTrue(serviceTokens.containsAll(moServiceTokens));
assertTrue(moServiceTokens.containsAll(serviceTokens));
assertEquals(messageHeader.getUserAuthenticationData(), moMessageHeader.getUserAuthenticationData());
assertEquals(messageHeader.getUserIdToken(), moMessageHeader.getUserIdToken());
assertNotNull(moMessageHeader.getUser());
}
@Test
public void untrustedMasterTokenParseHeader() throws MslEncodingException, MslCryptoException, MslEncoderException, MslException {
thrown.expect(MslMasterTokenException.class);
thrown.expectMslError(MslError.MASTERTOKEN_UNTRUSTED);
// We can first create a message header with an untrusted master token
// by having a cached crypto context.
final MasterToken masterToken = MslTestUtils.getUntrustedMasterToken(p2pCtx);
final ICryptoContext cryptoContext = new NullCryptoContext();
p2pCtx.getMslStore().setCryptoContext(masterToken, cryptoContext);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(p2pCtx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, masterToken, null, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
builder.set(KEY_USER_ID_TOKEN, userIdToken);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, masterToken, headerData, peerData);
// Removing the cached crypto context means the master token must now
// be trusted when parsing a message header.
p2pCtx.getMslStore().clearCryptoContexts();
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void unsupportedEntityAuthSchemeParseHeader() throws MslEncodingException, MslEntityAuthException, MslCryptoException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
thrown.expect(MslEntityAuthException.class);
thrown.expectMslError(MslError.ENTITYAUTH_FACTORY_NOT_FOUND);
// We can first create a message header when the entity authentication
// scheme is supported.
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
final HeaderDataBuilder builder = new HeaderDataBuilder(ctx, null, null, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = ctx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(ctx, entityAuthData, null, headerData, peerData);
// Removing support for the entity authentication scheme will now fail
// parsing of message headers.
ctx.removeEntityAuthenticationFactory(entityAuthData.getScheme());
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
Header.parseHeader(ctx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void unsupportedUserAuthSchemeParseHeader() throws MslKeyExchangeException, MslUserAuthException, MslEncoderException, MslException {
thrown.expect(MslUserAuthException.class);
thrown.expectMslError(MslError.USERAUTH_FACTORY_NOT_FOUND);
thrown.expectMessageId(MESSAGE_ID);
// We can first create a message header when the user authentication
// scheme is supported.
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
final HeaderDataBuilder builder = new HeaderDataBuilder(ctx, null, null, false);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(ctx, null, MASTER_TOKEN, headerData, peerData);
// Remove support for the user authentication scheme will now fail
// user authentication.
ctx.removeUserAuthenticationFactory(USER_AUTH_DATA.getScheme());
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
Header.parseHeader(ctx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void cachedCryptoContextMasterTokenParseHeader() throws MslEncodingException, MslCryptoException, MslEncoderException, MslException {
// We should be okay with an untrusted master token if a crypto context
// is associated with it.
final MasterToken masterToken = MslTestUtils.getUntrustedMasterToken(p2pCtx);
final ICryptoContext cryptoContext = new NullCryptoContext();
p2pCtx.getMslStore().setCryptoContext(masterToken, cryptoContext);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(p2pCtx, masterToken, 1, MockEmailPasswordAuthenticationFactory.USER);
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, masterToken, null, true);
builder.set(KEY_USER_ID_TOKEN, userIdToken);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, masterToken, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
final Header header = Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
assertNotNull(header);
assertTrue(header instanceof MessageHeader);
final MessageHeader moMessageHeader = (MessageHeader)header;
assertEquals(messageHeader.getNonReplayableId(), moMessageHeader.getNonReplayableId());
assertEquals(messageHeader.isRenewable(), moMessageHeader.isRenewable());
assertNotNull(messageHeader.getCryptoContext());
assertEquals(messageHeader.getEntityAuthenticationData(), moMessageHeader.getEntityAuthenticationData());
final Set<KeyRequestData> keyRequestData = messageHeader.getKeyRequestData();
final Set<KeyRequestData> moKeyRequestData = moMessageHeader.getKeyRequestData();
assertTrue(keyRequestData.containsAll(moKeyRequestData));
assertTrue(moKeyRequestData.containsAll(keyRequestData));
assertEquals(messageHeader.getKeyResponseData(), moMessageHeader.getKeyResponseData());
// The reconstructed untrusted service token won't pass tests for
// equality.
assertNotNull(moMessageHeader.getMasterToken());
assertEquals(messageHeader.getMessageId(), moMessageHeader.getMessageId());
assertEquals(messageHeader.getPeerMasterToken(), moMessageHeader.getPeerMasterToken());
final Set<ServiceToken> moPeerServiceTokens = moMessageHeader.getPeerServiceTokens();
assertTrue(peerServiceTokens.containsAll(moPeerServiceTokens));
assertTrue(moPeerServiceTokens.containsAll(peerServiceTokens));
assertEquals(messageHeader.getPeerUserIdToken(), moMessageHeader.getPeerUserIdToken());
final Set<ServiceToken> serviceTokens = messageHeader.getServiceTokens();
final Set<ServiceToken> moServiceTokens = moMessageHeader.getServiceTokens();
assertTrue(serviceTokens.containsAll(moServiceTokens));
assertTrue(moServiceTokens.containsAll(serviceTokens));
assertEquals(messageHeader.getUserAuthenticationData(), moMessageHeader.getUserAuthenticationData());
assertEquals(messageHeader.getUserIdToken(), moMessageHeader.getUserIdToken());
assertEquals(messageHeader.getUser(), moMessageHeader.getUser());
}
@Test
public void invalidEntityAuthDataParseHeader() throws MslMasterTokenException, MslEntityAuthException, MslException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, null, null, false);
builder.set(KEY_USER_ID_TOKEN, USER_ID_TOKEN);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, null);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
messageHeaderMo.put(KEY_ENTITY_AUTHENTICATION_DATA, "x");
Header.parseHeader(trustedNetCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void missingBothAuthDataParseHeader() throws MslEncodingException, MslEntityAuthException, MslCryptoException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.MESSAGE_ENTITY_NOT_FOUND);
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN, false);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, null);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
messageHeaderMo.remove(KEY_ENTITY_AUTHENTICATION_DATA);
messageHeaderMo.remove(KEY_MASTER_TOKEN);
Header.parseHeader(trustedNetCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void invalidMasterTokenParseHeader() throws MslEncodingException, MslEntityAuthException, MslCryptoException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN, false);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, null);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
messageHeaderMo.put(KEY_MASTER_TOKEN, "x");
Header.parseHeader(trustedNetCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void missingSignatureParseHeader() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN, false);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, null);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
assertNotNull(messageHeaderMo.remove(KEY_SIGNATURE));
Header.parseHeader(trustedNetCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void invalidSignatureParseHeader() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN, false);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, null);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
messageHeaderMo.put(KEY_SIGNATURE, "x");
Header.parseHeader(trustedNetCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void incorrectSignatureParseHeader() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.MESSAGE_ENTITYDATABASED_VERIFICATION_FAILED);
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, null, null, false);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
messageHeaderMo.put(KEY_SIGNATURE, Base64.decode("AAA="));
Header.parseHeader(trustedNetCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void missingHeaderdataParseHeader() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN, false);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, null);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
assertNotNull(messageHeaderMo.remove(KEY_HEADERDATA));
Header.parseHeader(trustedNetCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void invalidHeaderDataParseHeader() throws MslEncodingException, MslEntityAuthException, MslCryptoException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN, false);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, null);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
messageHeaderMo.put(KEY_HEADERDATA, "x");
Header.parseHeader(trustedNetCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void corruptHeaderDataParseHeader() throws MslEncodingException, MslEntityAuthException, MslException, MslEncoderException, UnsupportedEncodingException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.MESSAGE_MASTERTOKENBASED_VERIFICATION_FAILED);
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN, false);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, null);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
++ciphertext[0];
messageHeaderMo.put(KEY_HEADERDATA, ciphertext);
Header.parseHeader(trustedNetCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void missingPairsEntityAuthParseHeader() throws MslEncoderException, MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, null, null, false);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
builder.set(KEY_USER_AUTHENTICATION_DATA, null);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = p2pCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, entityAuthData, null, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
final Header header = Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
assertNotNull(header);
assertTrue(header instanceof MessageHeader);
final MessageHeader moMessageHeader = (MessageHeader)header;
assertEquals(messageHeader.getNonReplayableId(), moMessageHeader.getNonReplayableId());
assertEquals(messageHeader.isRenewable(), moMessageHeader.isRenewable());
assertNotNull(messageHeader.getCryptoContext());
assertEquals(messageHeader.getEntityAuthenticationData(), moMessageHeader.getEntityAuthenticationData());
final Set<KeyRequestData> keyRequestData = messageHeader.getKeyRequestData();
final Set<KeyRequestData> moKeyRequestData = moMessageHeader.getKeyRequestData();
assertTrue(keyRequestData.containsAll(moKeyRequestData));
assertTrue(moKeyRequestData.containsAll(keyRequestData));
assertEquals(messageHeader.getKeyResponseData(), moMessageHeader.getKeyResponseData());
assertEquals(messageHeader.getMasterToken(), moMessageHeader.getMasterToken());
assertEquals(messageHeader.getMessageId(), moMessageHeader.getMessageId());
assertEquals(messageHeader.getPeerMasterToken(), moMessageHeader.getPeerMasterToken());
final Set<ServiceToken> peerServiceTokens = messageHeader.getPeerServiceTokens();
final Set<ServiceToken> moPeerServiceTokens = moMessageHeader.getPeerServiceTokens();
assertTrue(peerServiceTokens.containsAll(moPeerServiceTokens));
assertTrue(moPeerServiceTokens.containsAll(peerServiceTokens));
assertEquals(messageHeader.getPeerUserIdToken(), moMessageHeader.getPeerUserIdToken());
final Set<ServiceToken> serviceTokens = messageHeader.getServiceTokens();
final Set<ServiceToken> moServiceTokens = moMessageHeader.getServiceTokens();
assertTrue(serviceTokens.containsAll(moServiceTokens));
assertTrue(moServiceTokens.containsAll(serviceTokens));
assertEquals(messageHeader.getUserAuthenticationData(), moMessageHeader.getUserAuthenticationData());
assertEquals(messageHeader.getUserIdToken(), moMessageHeader.getUserIdToken());
assertEquals(messageHeader.getUser(), moMessageHeader.getUser());
}
@Test
public void emptyArraysEntityAuthParseHeader() throws MslEncodingException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException, UnsupportedEncodingException {
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, null, null, false);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
builder.set(KEY_USER_AUTHENTICATION_DATA, null);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = p2pCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, entityAuthData, null, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final EntityAuthenticationScheme scheme = entityAuthData.getScheme();
final EntityAuthenticationFactory factory = p2pCtx.getEntityAuthenticationFactory(scheme);
final ICryptoContext cryptoContext = factory.getCryptoContext(p2pCtx, entityAuthData);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
headerdataMo.put(KEY_KEY_REQUEST_DATA, encoder.createArray());
headerdataMo.put(KEY_SERVICE_TOKENS, encoder.createArray());
headerdataMo.put(KEY_PEER_SERVICE_TOKENS, encoder.createArray());
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
final Header header = Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
assertNotNull(header);
assertTrue(header instanceof MessageHeader);
final MessageHeader moMessageHeader = (MessageHeader)header;
assertEquals(messageHeader.getNonReplayableId(), moMessageHeader.getNonReplayableId());
assertEquals(messageHeader.isRenewable(), moMessageHeader.isRenewable());
assertNotNull(messageHeader.getCryptoContext());
assertEquals(messageHeader.getEntityAuthenticationData(), moMessageHeader.getEntityAuthenticationData());
final Set<KeyRequestData> keyRequestData = messageHeader.getKeyRequestData();
final Set<KeyRequestData> moKeyRequestData = moMessageHeader.getKeyRequestData();
assertTrue(keyRequestData.containsAll(moKeyRequestData));
assertTrue(moKeyRequestData.containsAll(keyRequestData));
assertEquals(messageHeader.getKeyResponseData(), moMessageHeader.getKeyResponseData());
assertEquals(messageHeader.getMasterToken(), moMessageHeader.getMasterToken());
assertEquals(messageHeader.getMessageId(), moMessageHeader.getMessageId());
assertEquals(messageHeader.getPeerMasterToken(), moMessageHeader.getPeerMasterToken());
final Set<ServiceToken> peerServiceTokens = messageHeader.getPeerServiceTokens();
final Set<ServiceToken> moPeerServiceTokens = moMessageHeader.getPeerServiceTokens();
assertTrue(peerServiceTokens.containsAll(moPeerServiceTokens));
assertTrue(moPeerServiceTokens.containsAll(peerServiceTokens));
assertEquals(messageHeader.getPeerUserIdToken(), moMessageHeader.getPeerUserIdToken());
final Set<ServiceToken> serviceTokens = messageHeader.getServiceTokens();
final Set<ServiceToken> moServiceTokens = moMessageHeader.getServiceTokens();
assertTrue(serviceTokens.containsAll(moServiceTokens));
assertTrue(moServiceTokens.containsAll(serviceTokens));
assertEquals(messageHeader.getUserAuthenticationData(), moMessageHeader.getUserAuthenticationData());
assertEquals(messageHeader.getUserIdToken(), moMessageHeader.getUserIdToken());
assertEquals(messageHeader.getUser(), moMessageHeader.getUser());
}
@Test
public void missingPairsMasterTokenParseHeader() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException, MslEncoderException {
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, null, null, false);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
builder.set(KEY_USER_AUTHENTICATION_DATA, null);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
final Header header = Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
assertNotNull(header);
assertTrue(header instanceof MessageHeader);
final MessageHeader moMessageHeader = (MessageHeader)header;
assertEquals(messageHeader.getNonReplayableId(), moMessageHeader.getNonReplayableId());
assertEquals(messageHeader.isRenewable(), moMessageHeader.isRenewable());
assertNotNull(messageHeader.getCryptoContext());
assertEquals(messageHeader.getEntityAuthenticationData(), moMessageHeader.getEntityAuthenticationData());
final Set<KeyRequestData> keyRequestData = messageHeader.getKeyRequestData();
final Set<KeyRequestData> moKeyRequestData = moMessageHeader.getKeyRequestData();
assertTrue(keyRequestData.containsAll(moKeyRequestData));
assertTrue(moKeyRequestData.containsAll(keyRequestData));
assertEquals(messageHeader.getKeyResponseData(), moMessageHeader.getKeyResponseData());
assertEquals(messageHeader.getMasterToken(), moMessageHeader.getMasterToken());
assertEquals(messageHeader.getMessageId(), moMessageHeader.getMessageId());
assertEquals(messageHeader.getPeerMasterToken(), moMessageHeader.getPeerMasterToken());
final Set<ServiceToken> peerServiceTokens = messageHeader.getPeerServiceTokens();
final Set<ServiceToken> moPeerServiceTokens = moMessageHeader.getPeerServiceTokens();
assertTrue(peerServiceTokens.containsAll(moPeerServiceTokens));
assertTrue(moPeerServiceTokens.containsAll(peerServiceTokens));
assertEquals(messageHeader.getPeerUserIdToken(), moMessageHeader.getPeerUserIdToken());
final Set<ServiceToken> serviceTokens = messageHeader.getServiceTokens();
final Set<ServiceToken> moServiceTokens = moMessageHeader.getServiceTokens();
assertTrue(serviceTokens.containsAll(moServiceTokens));
assertTrue(moServiceTokens.containsAll(serviceTokens));
assertEquals(messageHeader.getUserAuthenticationData(), moMessageHeader.getUserAuthenticationData());
assertEquals(messageHeader.getUserIdToken(), moMessageHeader.getUserIdToken());
assertEquals(messageHeader.getUser(), moMessageHeader.getUser());
}
@Test
public void emptyArraysMasterTokenParseHeader() throws MslEncoderException, UnsupportedEncodingException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, null, null, false);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
builder.set(KEY_USER_AUTHENTICATION_DATA, null);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(p2pCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
headerdataMo.put(KEY_KEY_REQUEST_DATA, encoder.createArray());
headerdataMo.put(KEY_SERVICE_TOKENS, encoder.createArray());
headerdataMo.put(KEY_PEER_SERVICE_TOKENS, encoder.createArray());
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
final Header header = Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
assertNotNull(header);
assertTrue(header instanceof MessageHeader);
final MessageHeader moMessageHeader = (MessageHeader)header;
assertEquals(messageHeader.getNonReplayableId(), moMessageHeader.getNonReplayableId());
assertEquals(messageHeader.isRenewable(), moMessageHeader.isRenewable());
assertNotNull(messageHeader.getCryptoContext());
assertEquals(messageHeader.getEntityAuthenticationData(), moMessageHeader.getEntityAuthenticationData());
final Set<KeyRequestData> keyRequestData = messageHeader.getKeyRequestData();
final Set<KeyRequestData> moKeyRequestData = moMessageHeader.getKeyRequestData();
assertTrue(keyRequestData.containsAll(moKeyRequestData));
assertTrue(moKeyRequestData.containsAll(keyRequestData));
assertEquals(messageHeader.getKeyResponseData(), moMessageHeader.getKeyResponseData());
assertEquals(messageHeader.getMasterToken(), moMessageHeader.getMasterToken());
assertEquals(messageHeader.getMessageId(), moMessageHeader.getMessageId());
assertEquals(messageHeader.getPeerMasterToken(), moMessageHeader.getPeerMasterToken());
final Set<ServiceToken> peerServiceTokens = messageHeader.getPeerServiceTokens();
final Set<ServiceToken> moPeerServiceTokens = moMessageHeader.getPeerServiceTokens();
assertTrue(peerServiceTokens.containsAll(moPeerServiceTokens));
assertTrue(moPeerServiceTokens.containsAll(peerServiceTokens));
assertEquals(messageHeader.getPeerUserIdToken(), moMessageHeader.getPeerUserIdToken());
final Set<ServiceToken> serviceTokens = messageHeader.getServiceTokens();
final Set<ServiceToken> moServiceTokens = moMessageHeader.getServiceTokens();
assertTrue(serviceTokens.containsAll(moServiceTokens));
assertTrue(moServiceTokens.containsAll(serviceTokens));
assertEquals(messageHeader.getUserAuthenticationData(), moMessageHeader.getUserAuthenticationData());
assertEquals(messageHeader.getUserIdToken(), moMessageHeader.getUserIdToken());
assertEquals(messageHeader.getUser(), moMessageHeader.getUser());
}
@Test
public void userIdTokenNullMasterTokenParseHeader() throws MslEncodingException, MslEntityAuthException, MslCryptoException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException, UnsupportedEncodingException {
thrown.expect(MslException.class);
thrown.expectMessageId(MESSAGE_ID);
// Since removing the master token will prevent the header data from
// getting parsed, and removing the master token from the key exchange
// data will also prevent the header data from getting parsed, the only
// way to simulate this is to use entity authentication data and insert
// a user ID token.
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, null, null, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final EntityAuthenticationScheme scheme = entityAuthData.getScheme();
final EntityAuthenticationFactory factory = trustedNetCtx.getEntityAuthenticationFactory(scheme);
final ICryptoContext cryptoContext = factory.getCryptoContext(trustedNetCtx, entityAuthData);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(trustedNetCtx, MASTER_TOKEN, 1, MockEmailPasswordAuthenticationFactory.USER);
headerdataMo.put(KEY_USER_ID_TOKEN, userIdToken);
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(trustedNetCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void userIdTokenMismatchedMasterTokenParseHeader() throws MslMasterTokenException, MslEntityAuthException, MslException, MslEncoderException, UnsupportedEncodingException {
thrown.expect(MslException.class);
thrown.expectMessageId(MESSAGE_ID);
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(trustedNetCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(trustedNetCtx, PEER_MASTER_TOKEN, 1, MockEmailPasswordAuthenticationFactory.USER);
headerdataMo.put(KEY_USER_ID_TOKEN, userIdToken);
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(trustedNetCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void userIdTokenMismatchedUserAuthDataParseHeader() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException, MslKeyExchangeException, MslUserAuthException, MslEncoderException, MslException {
thrown.expect(MslUserAuthException.class);
thrown.expectMslError(MslError.USERIDTOKEN_USERAUTH_DATA_MISMATCH);
thrown.expectMessageId(MESSAGE_ID);
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN, false);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
builder.set(KEY_USER_AUTHENTICATION_DATA, null);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(trustedNetCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
final UserAuthenticationData userAuthData = new EmailPasswordAuthenticationData(MockEmailPasswordAuthenticationFactory.EMAIL_2, MockEmailPasswordAuthenticationFactory.PASSWORD_2);
headerdataMo.put(KEY_USER_AUTHENTICATION_DATA, userAuthData);
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(trustedNetCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void peerUserIdTokenMissingPeerMasterTokenParseHeader() throws MslEncodingException, MslEntityAuthException, MslException, UnsupportedEncodingException, MslEncoderException {
thrown.expect(MslException.class);
thrown.expectMessageId(MESSAGE_ID);
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, false);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(p2pCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
assertNotNull(headerdataMo.remove(KEY_PEER_MASTER_TOKEN));
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test(expected = MslException.class)
public void peerUserIdTokenMismatchedPeerMasterTokenParseHeader() throws MslEncoderException, UnsupportedEncodingException, MslEntityAuthException, MslException {
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(p2pCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
headerdataMo.put(KEY_PEER_MASTER_TOKEN, MASTER_TOKEN);
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void serviceTokenMismatchedMasterTokenParseHeader() throws MslEncoderException, UnsupportedEncodingException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
thrown.expect(MslException.class);
thrown.expectMessageId(MESSAGE_ID);
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(trustedNetCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
final Set<ServiceToken> serviceTokens = builder.getServiceTokens();
serviceTokens.addAll(MslTestUtils.getServiceTokens(trustedNetCtx, PEER_MASTER_TOKEN, null));
headerdataMo.put(KEY_SERVICE_TOKENS, MslEncoderUtils.createArray(trustedNetCtx, format, serviceTokens));
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(trustedNetCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void serviceTokenMismatchedUserIdTokenParseHeader() throws UnsupportedEncodingException, MslMasterTokenException, MslEntityAuthException, MslException, MslEncoderException {
thrown.expect(MslException.class);
thrown.expectMessageId(MESSAGE_ID);
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(trustedNetCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
final Set<ServiceToken> serviceTokens = builder.getServiceTokens();
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(trustedNetCtx, MASTER_TOKEN, 2, MockEmailPasswordAuthenticationFactory.USER);
serviceTokens.addAll(MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, userIdToken));
headerdataMo.put(KEY_SERVICE_TOKENS, MslEncoderUtils.createArray(trustedNetCtx, format, serviceTokens));
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(trustedNetCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void peerServiceTokenMissingPeerMasterTokenParseHeader() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException, UnsupportedEncodingException, MslEncoderException {
thrown.expect(MslException.class);
thrown.expectMessageId(MESSAGE_ID);
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, null);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, null, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(p2pCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
assertNotNull(headerdataMo.remove(KEY_PEER_MASTER_TOKEN));
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void peerServiceTokenMismatchedPeerMasterTokenParseHeader() throws MslMasterTokenException, MslEntityAuthException, MslException, UnsupportedEncodingException, MslEncoderException {
thrown.expect(MslException.class);
thrown.expectMessageId(MESSAGE_ID);
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, null);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, null, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(p2pCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
headerdataMo.put(KEY_PEER_MASTER_TOKEN, MASTER_TOKEN);
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void peerServiceTokenMismatchedPeerUserIdTokenParseHeader() throws UnsupportedEncodingException, MslEncodingException, MslMasterTokenException, MslEntityAuthException, MslException, MslEncoderException {
thrown.expect(MslException.class);
thrown.expectMessageId(MESSAGE_ID);
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(p2pCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(p2pCtx, PEER_MASTER_TOKEN, 2, MockEmailPasswordAuthenticationFactory.USER);
headerdataMo.put(KEY_PEER_USER_ID_TOKEN, userIdToken);
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void missingTimestamp() throws MslEncoderException, MslKeyExchangeException, MslUserAuthException, MslException {
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, null, null, false);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
builder.set(KEY_USER_AUTHENTICATION_DATA, null);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(trustedNetCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
assertNotNull(headerdataMo.remove(KEY_TIMESTAMP));
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(trustedNetCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void invalidTimestamp() throws MslEncoderException, MslKeyExchangeException, MslUserAuthException, MslException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, null, null, false);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
builder.set(KEY_USER_AUTHENTICATION_DATA, null);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(trustedNetCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
headerdataMo.put(KEY_TIMESTAMP, "x");
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(trustedNetCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void missingMessageIdParseHeader() throws UnsupportedEncodingException, MslEncoderException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(p2pCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
assertNotNull(headerdataMo.remove(KEY_MESSAGE_ID));
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void invalidMessageIdParseHeader() throws MslEncoderException, MslEncodingException, MslEntityAuthException, MslCryptoException, MslKeyExchangeException, MslUserAuthException, MslException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(p2pCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
headerdataMo.put(KEY_MESSAGE_ID, "x");
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test(expected = MslInternalException.class)
public void negativeMessageIdCtor() throws MslException {
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, false);
builder.set(KEY_MESSAGE_ID, -1L);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
}
@Test(expected = MslInternalException.class)
public void tooLargeMessageIdCtor() throws MslException {
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, false);
builder.set(KEY_MESSAGE_ID, MslConstants.MAX_LONG_VALUE + 1);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
}
@Test
public void negativeMessageIdParseHeader() throws MslEncoderException, MslKeyExchangeException, MslUserAuthException, MslException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.MESSAGE_ID_OUT_OF_RANGE);
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(p2pCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
headerdataMo.put(KEY_MESSAGE_ID, -1);
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void tooLargeMessageIdParseHeader() throws MslEncoderException, MslKeyExchangeException, MslUserAuthException, MslException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.MESSAGE_ID_OUT_OF_RANGE);
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(p2pCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
headerdataMo.put(KEY_MESSAGE_ID, MslConstants.MAX_LONG_VALUE + 1);
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void invalidNonReplayableParseHeader() throws MslEncodingException, MslEntityAuthException, MslCryptoException, MslKeyExchangeException, MslUserAuthException, MslException, UnsupportedEncodingException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
thrown.expectMessageId(MESSAGE_ID);
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(p2pCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
headerdataMo.put(KEY_NON_REPLAYABLE_ID, "x");
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void missingRenewableParseHeader() throws UnsupportedEncodingException, MslEncoderException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
thrown.expectMessageId(MESSAGE_ID);
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(p2pCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
assertNotNull(headerdataMo.remove(KEY_RENEWABLE));
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void invalidRenewableParseHeader() throws UnsupportedEncodingException, MslEncoderException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
thrown.expectMessageId(MESSAGE_ID);
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(p2pCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
headerdataMo.put(KEY_RENEWABLE, "x");
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void missingHandshakeParseHeader() throws UnsupportedEncodingException, MslEncoderException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
// FIXME It is okay for the handshake flag to be missing for now.
// thrown.expect(MslEncodingException.class);
// thrown.expectMslError(MslError.MSL_PARSE_ERROR);
// thrown.expectMessageId(MESSAGE_ID);
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(p2pCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
assertNotNull(headerdataMo.remove(KEY_HANDSHAKE));
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
// FIXME For now a missing handshake flag will result in a false value.
final Header header = Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
assertTrue(header instanceof MessageHeader);
final MessageHeader moMessageHeader = (MessageHeader)header;
assertFalse(moMessageHeader.isHandshake());
}
@Test
public void invalidHandshakeParseHeader() throws UnsupportedEncodingException, MslEncoderException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
thrown.expectMessageId(MESSAGE_ID);
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(p2pCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
headerdataMo.put(KEY_HANDSHAKE, "x");
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void invalidCapabilities() throws MslEncoderException, MslKeyExchangeException, MslUserAuthException, MslException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
thrown.expectMessageId(MESSAGE_ID);
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(p2pCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
headerdataMo.put(KEY_CAPABILITIES, "x");
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void invalidKeyRequestDataArrayParseHeader() throws MslEncoderException, UnsupportedEncodingException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
thrown.expect(MslException.class);
thrown.expectMessageId(MESSAGE_ID);
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(p2pCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
headerdataMo.put(KEY_KEY_REQUEST_DATA, "x");
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void invalidKeyRequestDataParseHeader() throws MslEncodingException, MslEntityAuthException, MslCryptoException, MslKeyExchangeException, MslUserAuthException, MslException, UnsupportedEncodingException, MslEncoderException {
thrown.expect(MslException.class);
thrown.expectMessageId(MESSAGE_ID);
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(p2pCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
final MslArray a = encoder.createArray();
a.put(-1, "x");
headerdataMo.put(KEY_PEER_SERVICE_TOKENS, a);
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void invalidServiceTokensArrayParseHeader() throws MslEncoderException, UnsupportedEncodingException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
thrown.expect(MslException.class);
thrown.expectMessageId(MESSAGE_ID);
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(p2pCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
headerdataMo.put(KEY_SERVICE_TOKENS, "x");
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void invalidServiceTokenParseHeader() throws UnsupportedEncodingException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
thrown.expect(MslException.class);
thrown.expectMessageId(MESSAGE_ID);
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(p2pCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
final MslArray a = encoder.createArray();
a.put(-1, "x");
headerdataMo.put(KEY_SERVICE_TOKENS, a);
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void invalidPeerServiceTokensArrayParseHeader() throws MslEncoderException, UnsupportedEncodingException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
thrown.expect(MslException.class);
thrown.expectMessageId(MESSAGE_ID);
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(p2pCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
headerdataMo.put(KEY_PEER_SERVICE_TOKENS, "x");
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void invalidPeerServiceTokenParseHeader() throws MslEncoderException, UnsupportedEncodingException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
thrown.expect(MslException.class);
thrown.expectMessageId(MESSAGE_ID);
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(p2pCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
final MslArray a = encoder.createArray();
a.put(-1, "x");
headerdataMo.put(KEY_PEER_SERVICE_TOKENS, a);
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void invalidPeerMasterTokenParseHeader() throws MslEncoderException, UnsupportedEncodingException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
thrown.expect(MslException.class);
thrown.expectMessageId(MESSAGE_ID);
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(p2pCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
headerdataMo.put(KEY_PEER_MASTER_TOKEN, "x");
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void invalidPeerUserIdTokenParseHeader() throws MslEncoderException, UnsupportedEncodingException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException {
thrown.expect(MslException.class);
thrown.expectMessageId(MESSAGE_ID);
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(p2pCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
headerdataMo.put(KEY_PEER_USER_ID_TOKEN, "x");
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test
public void invalidUserAuthParseHeader() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException, MslKeyExchangeException, MslUserAuthException, MslEncoderException, MslException {
thrown.expect(MslEncodingException.class);
thrown.expectMessageId(MESSAGE_ID);
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, null, true);
builder.set(KEY_KEY_REQUEST_DATA, null);
builder.set(KEY_KEY_RESPONSE_DATA, null);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// Before modifying the header data we need to decrypt it.
final ICryptoContext cryptoContext = new SessionCryptoContext(p2pCtx, MASTER_TOKEN);
final byte[] ciphertext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject headerdataMo = encoder.parseObject(plaintext);
// After modifying the header data we need to encrypt it.
headerdataMo.put(KEY_USER_AUTHENTICATION_DATA, "x");
final byte[] headerdata = cryptoContext.encrypt(encoder.encodeObject(headerdataMo, format), encoder, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(p2pCtx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test(expected = MslInternalException.class)
public void unencryptedUserAuthDataCtor() throws MslEncodingException, MslCryptoException, MslException {
final MslContext x509Ctx = new MockMslContext(EntityAuthenticationScheme.X509, false);
final HeaderDataBuilder builder = new HeaderDataBuilder(x509Ctx, null, null, false);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = x509Ctx.getEntityAuthenticationData(null);
new MessageHeader(x509Ctx, entityAuthData, null, headerData, peerData);
}
@Test
public void unencryptedUserAuthDataParseHeader() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
thrown.expect(MslMessageException.class);
thrown.expectMslError(MslError.UNENCRYPTED_MESSAGE_WITH_USERAUTHDATA);
thrown.expectMessageId(MESSAGE_ID);
final MslContext x509Ctx = new MockMslContext(EntityAuthenticationScheme.X509, false);
final HeaderDataBuilder builder = new HeaderDataBuilder(x509Ctx, null, null, true);
builder.set(KEY_USER_AUTHENTICATION_DATA, null);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = x509Ctx.getEntityAuthenticationData(null);
final MessageHeader messageHeader = new MessageHeader(x509Ctx, entityAuthData, null, headerData, peerData);
final MslObject messageHeaderMo = MslTestUtils.toMslObject(encoder, messageHeader);
// The header data is not encrypted.
final byte[] plaintext = messageHeaderMo.getBytes(KEY_HEADERDATA);
final MslObject headerdataMo = encoder.parseObject(plaintext);
headerdataMo.put(KEY_USER_AUTHENTICATION_DATA, USER_AUTH_DATA);
final byte[] headerdata = encoder.encodeObject(headerdataMo, format);
messageHeaderMo.put(KEY_HEADERDATA, headerdata);
// The header data must be signed or it will not be processed.
final EntityAuthenticationFactory factory = x509Ctx.getEntityAuthenticationFactory(entityAuthData.getScheme());
final ICryptoContext cryptoContext = factory.getCryptoContext(x509Ctx, entityAuthData);
final byte[] signature = cryptoContext.sign(headerdata, encoder, format);
messageHeaderMo.put(KEY_SIGNATURE, signature);
Header.parseHeader(x509Ctx, messageHeaderMo, CRYPTO_CONTEXTS);
}
@Test(expected = UnsupportedOperationException.class)
public void immutableKeyRequestData() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN, false);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerData, peerData);
messageHeader.getKeyRequestData().clear();
}
@Test(expected = UnsupportedOperationException.class)
public void immutableServiceTokens() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN, false);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerData, peerData);
messageHeader.getServiceTokens().clear();
}
@Test(expected = UnsupportedOperationException.class)
public void immutablePeerServiceTokens() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, false);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokens = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerData = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokens);
final MessageHeader messageHeader = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerData);
messageHeader.getPeerServiceTokens().clear();
}
@Test
public void equalsMasterToken() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException, MslEncoderException {
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, null, null, false);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MasterToken masterTokenA = MslTestUtils.getMasterToken(trustedNetCtx, 1, 1);
final MasterToken masterTokenB = MslTestUtils.getMasterToken(trustedNetCtx, 1, 2);
final MessageHeader messageHeaderA = new MessageHeader(trustedNetCtx, null, masterTokenA, headerData, peerData);
final MessageHeader messageHeaderB = new MessageHeader(trustedNetCtx, null, masterTokenB, headerData, peerData);
final MessageHeader messageHeaderA2 = (MessageHeader)Header.parseHeader(trustedNetCtx, MslTestUtils.toMslObject(encoder, messageHeaderA), CRYPTO_CONTEXTS);
assertTrue(messageHeaderA.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA.hashCode());
assertFalse(messageHeaderA.equals(messageHeaderB));
assertFalse(messageHeaderB.equals(messageHeaderA));
assertTrue(messageHeaderA.hashCode() != messageHeaderB.hashCode());
assertTrue(messageHeaderA.equals(messageHeaderA2));
assertTrue(messageHeaderA2.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA2.hashCode());
}
@Test
public void equalsEntityAuthData() throws MslMasterTokenException, MslEntityAuthException, MslException, MslEncoderException {
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, null, null, false);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthDataA = new PresharedAuthenticationData(MockPresharedAuthenticationFactory.PSK_ESN);
final EntityAuthenticationData entityAuthDataB = new PresharedAuthenticationData(MockPresharedAuthenticationFactory.PSK_ESN2);
final MessageHeader messageHeaderA = new MessageHeader(trustedNetCtx, entityAuthDataA, null, headerData, peerData);
final MessageHeader messageHeaderB = new MessageHeader(trustedNetCtx, entityAuthDataB, null, headerData, peerData);
final MessageHeader messageHeaderA2 = (MessageHeader)Header.parseHeader(trustedNetCtx, MslTestUtils.toMslObject(encoder, messageHeaderA), CRYPTO_CONTEXTS);
assertTrue(messageHeaderA.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA.hashCode());
assertFalse(messageHeaderA.equals(messageHeaderB));
assertFalse(messageHeaderB.equals(messageHeaderA));
assertTrue(messageHeaderA.hashCode() != messageHeaderB.hashCode());
assertTrue(messageHeaderA.equals(messageHeaderA2));
assertTrue(messageHeaderA2.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA2.hashCode());
}
@Test
public void equalsMasterTokenEntityAuthData() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException, MslEncoderException {
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, null, null, false);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = trustedNetCtx.getEntityAuthenticationData(null);
final MessageHeader messageHeaderA = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerData, peerData);
final MessageHeader messageHeaderB = new MessageHeader(trustedNetCtx, entityAuthData, null, headerData, peerData);
final MessageHeader messageHeaderA2 = (MessageHeader)Header.parseHeader(trustedNetCtx, MslTestUtils.toMslObject(encoder, messageHeaderA), CRYPTO_CONTEXTS);
assertTrue(messageHeaderA.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA.hashCode());
assertFalse(messageHeaderA.equals(messageHeaderB));
assertFalse(messageHeaderB.equals(messageHeaderA));
assertTrue(messageHeaderA.hashCode() != messageHeaderB.hashCode());
assertTrue(messageHeaderA.equals(messageHeaderA2));
assertTrue(messageHeaderA2.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA2.hashCode());
}
@Test
public void equalsTimestamp() throws MslEncodingException, MslCryptoException, MslException, InterruptedException, MslEncoderException {
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, null, null, false);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeaderA = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerData, peerData);
Thread.sleep(MILLISECONDS_PER_SECOND);
final MessageHeader messageHeaderB = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerData, peerData);
final MessageHeader messageHeaderA2 = (MessageHeader)Header.parseHeader(trustedNetCtx, MslTestUtils.toMslObject(encoder, messageHeaderA), CRYPTO_CONTEXTS);
assertTrue(messageHeaderA.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA.hashCode());
assertFalse(messageHeaderA.equals(messageHeaderB));
assertFalse(messageHeaderB.equals(messageHeaderA));
assertTrue(messageHeaderA.hashCode() != messageHeaderB.hashCode());
assertTrue(messageHeaderA.equals(messageHeaderA2));
assertTrue(messageHeaderA2.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA2.hashCode());
}
@Test
public void equalsMessageId() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException, MslEncoderException {
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
final HeaderData headerDataA = new HeaderDataBuilder(trustedNetCtx, USER_ID_TOKEN, serviceTokens).set(KEY_MESSAGE_ID, 1L).build();
final HeaderData headerDataB = new HeaderDataBuilder(trustedNetCtx, USER_ID_TOKEN, serviceTokens).set(KEY_MESSAGE_ID, 2L).build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeaderA = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerDataA, peerData);
final MessageHeader messageHeaderB = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerDataB, peerData);
final MessageHeader messageHeaderA2 = (MessageHeader)Header.parseHeader(trustedNetCtx, MslTestUtils.toMslObject(encoder, messageHeaderA), CRYPTO_CONTEXTS);
assertTrue(messageHeaderA.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA.hashCode());
assertFalse(messageHeaderA.equals(messageHeaderB));
assertFalse(messageHeaderB.equals(messageHeaderA));
assertTrue(messageHeaderA.hashCode() != messageHeaderB.hashCode());
assertTrue(messageHeaderA.equals(messageHeaderA2));
assertTrue(messageHeaderA2.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA2.hashCode());
}
@Test
public void equalsNonReplayable() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
final HeaderData headerDataA = new HeaderDataBuilder(trustedNetCtx, USER_ID_TOKEN, serviceTokens).set(KEY_NON_REPLAYABLE_ID, 1L).build();
final HeaderData headerDataB = new HeaderDataBuilder(trustedNetCtx, USER_ID_TOKEN, serviceTokens).set(KEY_NON_REPLAYABLE_ID, 2L).build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeaderA = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerDataA, peerData);
final MessageHeader messageHeaderB = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerDataB, peerData);
final MessageHeader messageHeaderA2 = (MessageHeader)Header.parseHeader(trustedNetCtx, MslTestUtils.toMslObject(encoder, messageHeaderA), CRYPTO_CONTEXTS);
assertTrue(messageHeaderA.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA.hashCode());
assertFalse(messageHeaderA.equals(messageHeaderB));
assertFalse(messageHeaderB.equals(messageHeaderA));
assertTrue(messageHeaderA.hashCode() != messageHeaderB.hashCode());
assertTrue(messageHeaderA.equals(messageHeaderA2));
assertTrue(messageHeaderA2.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA2.hashCode());
}
@Test
public void equalsRenewable() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException, MslEncoderException {
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
final HeaderData headerDataA = new HeaderDataBuilder(trustedNetCtx, USER_ID_TOKEN, serviceTokens).set(KEY_RENEWABLE, true).build();
final HeaderData headerDataB = new HeaderDataBuilder(trustedNetCtx, USER_ID_TOKEN, serviceTokens).set(KEY_RENEWABLE, false).build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeaderA = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerDataA, peerData);
final MessageHeader messageHeaderB = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerDataB, peerData);
final MessageHeader messageHeaderA2 = (MessageHeader)Header.parseHeader(trustedNetCtx, MslTestUtils.toMslObject(encoder, messageHeaderA), CRYPTO_CONTEXTS);
assertTrue(messageHeaderA.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA.hashCode());
assertFalse(messageHeaderA.equals(messageHeaderB));
assertFalse(messageHeaderB.equals(messageHeaderA));
assertTrue(messageHeaderA.hashCode() != messageHeaderB.hashCode());
assertTrue(messageHeaderA.equals(messageHeaderA2));
assertTrue(messageHeaderA2.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA2.hashCode());
}
@Test
public void equalsHandshake() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException, MslEncoderException {
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
final HeaderData headerDataA = new HeaderDataBuilder(trustedNetCtx, USER_ID_TOKEN, serviceTokens).set(KEY_HANDSHAKE, true).build();
final HeaderData headerDataB = new HeaderDataBuilder(trustedNetCtx, USER_ID_TOKEN, serviceTokens).set(KEY_HANDSHAKE, false).build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeaderA = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerDataA, peerData);
final MessageHeader messageHeaderB = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerDataB, peerData);
final MessageHeader messageHeaderA2 = (MessageHeader)Header.parseHeader(trustedNetCtx, MslTestUtils.toMslObject(encoder, messageHeaderA), CRYPTO_CONTEXTS);
assertTrue(messageHeaderA.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA.hashCode());
assertFalse(messageHeaderA.equals(messageHeaderB));
assertFalse(messageHeaderB.equals(messageHeaderA));
assertTrue(messageHeaderA.hashCode() != messageHeaderB.hashCode());
assertTrue(messageHeaderA.equals(messageHeaderA2));
assertTrue(messageHeaderA2.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA2.hashCode());
}
@Test
public void equalsCapabilities() throws MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
final MessageCapabilities capsA = new MessageCapabilities(ALGOS, LANGUAGES, FORMATS);
final MessageCapabilities capsB = new MessageCapabilities(new HashSet<CompressionAlgorithm>(), new ArrayList<String>(), new HashSet<MslEncoderFormat>());
final HeaderData headerDataA = new HeaderDataBuilder(trustedNetCtx, USER_ID_TOKEN, null).set(KEY_CAPABILITIES, capsA).build();
final HeaderData headerDataB = new HeaderDataBuilder(trustedNetCtx, USER_ID_TOKEN, null).set(KEY_CAPABILITIES, capsB).build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeaderA = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerDataA, peerData);
final MessageHeader messageHeaderB = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerDataB, peerData);
final MessageHeader messageHeaderA2 = (MessageHeader)Header.parseHeader(trustedNetCtx, MslTestUtils.toMslObject(encoder, messageHeaderA), CRYPTO_CONTEXTS);
assertTrue(messageHeaderA.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA.hashCode());
assertFalse(messageHeaderA.equals(messageHeaderB));
assertFalse(messageHeaderB.equals(messageHeaderA));
assertTrue(messageHeaderA.hashCode() != messageHeaderB.hashCode());
assertTrue(messageHeaderA.equals(messageHeaderA2));
assertTrue(messageHeaderA2.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA2.hashCode());
}
@Test
public void equalsKeyRequestData() throws MslEncodingException, MslEntityAuthException, MslCryptoException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
final Set<KeyRequestData> keyRequestDataA = new HashSet<KeyRequestData>();
keyRequestDataA.add(new SymmetricWrappedExchange.RequestData(KeyId.SESSION));
final Set<KeyRequestData> keyRequestDataB = new HashSet<KeyRequestData>();
keyRequestDataB.add(new SymmetricWrappedExchange.RequestData(KeyId.PSK));
final HeaderData headerDataA = new HeaderDataBuilder(trustedNetCtx, USER_ID_TOKEN, serviceTokens).set(KEY_KEY_REQUEST_DATA, keyRequestDataA).build();
final HeaderData headerDataB = new HeaderDataBuilder(trustedNetCtx, USER_ID_TOKEN, serviceTokens).set(KEY_KEY_REQUEST_DATA, keyRequestDataB).build();
final HeaderData headerDataC = new HeaderDataBuilder(trustedNetCtx, USER_ID_TOKEN, serviceTokens).set(KEY_KEY_REQUEST_DATA, null).build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeaderA = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerDataA, peerData);
final MessageHeader messageHeaderB = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerDataB, peerData);
final MessageHeader messageHeaderC = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerDataC, peerData);
final MessageHeader messageHeaderA2 = (MessageHeader)Header.parseHeader(trustedNetCtx, MslTestUtils.toMslObject(encoder, messageHeaderA), CRYPTO_CONTEXTS);
assertTrue(messageHeaderA.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA.hashCode());
assertFalse(messageHeaderA.equals(messageHeaderB));
assertFalse(messageHeaderB.equals(messageHeaderA));
assertTrue(messageHeaderA.hashCode() != messageHeaderB.hashCode());
assertFalse(messageHeaderA.equals(messageHeaderC));
assertFalse(messageHeaderC.equals(messageHeaderA));
assertTrue(messageHeaderA.hashCode() != messageHeaderC.hashCode());
assertTrue(messageHeaderA.equals(messageHeaderA2));
assertTrue(messageHeaderA2.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA2.hashCode());
}
@Test
public void equalsKeyResponseData() throws MslEncodingException, MslEntityAuthException, MslCryptoException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
final KeyRequestData keyRequestData = KEY_REQUEST_DATA.toArray(new KeyRequestData[0])[0];
final KeyExchangeFactory factory = trustedNetCtx.getKeyExchangeFactory(keyRequestData.getKeyExchangeScheme());
final KeyExchangeData keyxDataA = factory.generateResponse(trustedNetCtx, format, keyRequestData, MASTER_TOKEN);
final KeyResponseData keyResponseDataA = keyxDataA.keyResponseData;
final KeyExchangeData keyxDataB = factory.generateResponse(trustedNetCtx, format, keyRequestData, MASTER_TOKEN);
final KeyResponseData keyResponseDataB = keyxDataB.keyResponseData;
final HeaderData headerDataA = new HeaderDataBuilder(trustedNetCtx, USER_ID_TOKEN, serviceTokens).set(KEY_KEY_RESPONSE_DATA, keyResponseDataA).build();
final HeaderData headerDataB = new HeaderDataBuilder(trustedNetCtx, USER_ID_TOKEN, serviceTokens).set(KEY_KEY_RESPONSE_DATA, keyResponseDataB).build();
final HeaderData headerDataC = new HeaderDataBuilder(trustedNetCtx, USER_ID_TOKEN, serviceTokens).set(KEY_KEY_RESPONSE_DATA, null).build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeaderA = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerDataA, peerData);
final MessageHeader messageHeaderB = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerDataB, peerData);
final MessageHeader messageHeaderC = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerDataC, peerData);
final MessageHeader messageHeaderA2 = (MessageHeader)Header.parseHeader(trustedNetCtx, MslTestUtils.toMslObject(encoder, messageHeaderA), CRYPTO_CONTEXTS);
assertTrue(messageHeaderA.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA.hashCode());
assertFalse(messageHeaderA.equals(messageHeaderB));
assertFalse(messageHeaderB.equals(messageHeaderA));
assertTrue(messageHeaderA.hashCode() != messageHeaderB.hashCode());
assertFalse(messageHeaderA.equals(messageHeaderC));
assertFalse(messageHeaderC.equals(messageHeaderA));
assertTrue(messageHeaderA.hashCode() != messageHeaderC.hashCode());
assertTrue(messageHeaderA.equals(messageHeaderA2));
assertTrue(messageHeaderA2.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA2.hashCode());
}
@Test
public void equalsUserAuthData() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
final Set<ServiceToken> serviceTokens = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, null);
final UserAuthenticationData userAuthDataA = new EmailPasswordAuthenticationData(MockEmailPasswordAuthenticationFactory.EMAIL + "A", MockEmailPasswordAuthenticationFactory.PASSWORD);
final UserAuthenticationData userAuthDataB = new EmailPasswordAuthenticationData(MockEmailPasswordAuthenticationFactory.EMAIL + "B", MockEmailPasswordAuthenticationFactory.PASSWORD);
final HeaderData headerDataA = new HeaderDataBuilder(trustedNetCtx, null, serviceTokens).set(KEY_USER_AUTHENTICATION_DATA, userAuthDataA).build();
final HeaderData headerDataB = new HeaderDataBuilder(trustedNetCtx, null, serviceTokens).set(KEY_USER_AUTHENTICATION_DATA, userAuthDataB).build();
final HeaderData headerDataC = new HeaderDataBuilder(trustedNetCtx, null, serviceTokens).set(KEY_USER_AUTHENTICATION_DATA, null).build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeaderA = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerDataA, peerData);
final MessageHeader messageHeaderB = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerDataB, peerData);
final MessageHeader messageHeaderC = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerDataC, peerData);
assertTrue(messageHeaderA.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA.hashCode());
assertFalse(messageHeaderA.equals(messageHeaderB));
assertFalse(messageHeaderB.equals(messageHeaderA));
assertTrue(messageHeaderA.hashCode() != messageHeaderB.hashCode());
assertFalse(messageHeaderA.equals(messageHeaderC));
assertFalse(messageHeaderC.equals(messageHeaderA));
assertTrue(messageHeaderA.hashCode() != messageHeaderC.hashCode());
// This test does not include a parsed header to avoid requiring user
// authentication to succeed.
}
@Test
public void equalsUserIdToken() throws MslEncodingException, MslEntityAuthException, MslCryptoException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
final UserIdToken userIdTokenA = MslTestUtils.getUserIdToken(trustedNetCtx, MASTER_TOKEN, 1, MockEmailPasswordAuthenticationFactory.USER);
final UserIdToken userIdTokenB = MslTestUtils.getUserIdToken(trustedNetCtx, MASTER_TOKEN, 2, MockEmailPasswordAuthenticationFactory.USER);
final HeaderData headerDataA = new HeaderDataBuilder(trustedNetCtx, userIdTokenA, null).build();
final HeaderData headerDataB = new HeaderDataBuilder(trustedNetCtx, userIdTokenB, null).build();
final HeaderData headerDataC = new HeaderDataBuilder(trustedNetCtx, null, null).build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeaderA = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerDataA, peerData);
final MessageHeader messageHeaderB = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerDataB, peerData);
final MessageHeader messageHeaderC = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerDataC, peerData);
final MessageHeader messageHeaderA2 = (MessageHeader)Header.parseHeader(trustedNetCtx, MslTestUtils.toMslObject(encoder, messageHeaderA), CRYPTO_CONTEXTS);
assertTrue(messageHeaderA.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA.hashCode());
assertFalse(messageHeaderA.equals(messageHeaderB));
assertFalse(messageHeaderB.equals(messageHeaderA));
assertTrue(messageHeaderA.hashCode() != messageHeaderB.hashCode());
assertFalse(messageHeaderA.equals(messageHeaderC));
assertFalse(messageHeaderC.equals(messageHeaderA));
assertTrue(messageHeaderA.hashCode() != messageHeaderC.hashCode());
assertTrue(messageHeaderA.equals(messageHeaderA2));
assertTrue(messageHeaderA2.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA2.hashCode());
}
@Test
public void equalsServiceTokens() throws MslEncodingException, MslEntityAuthException, MslCryptoException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
final Set<ServiceToken> serviceTokensA = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
final Set<ServiceToken> serviceTokensB = MslTestUtils.getServiceTokens(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN);
final HeaderData headerDataA = new HeaderDataBuilder(trustedNetCtx, USER_ID_TOKEN, serviceTokensA).build();
final HeaderData headerDataB = new HeaderDataBuilder(trustedNetCtx, USER_ID_TOKEN, serviceTokensB).build();
final HeaderData headerDataC = new HeaderDataBuilder(trustedNetCtx, USER_ID_TOKEN, null).build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeaderA = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerDataA, peerData);
final MessageHeader messageHeaderB = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerDataB, peerData);
final MessageHeader messageHeaderC = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerDataC, peerData);
final MessageHeader messageHeaderA2 = (MessageHeader)Header.parseHeader(trustedNetCtx, MslTestUtils.toMslObject(encoder, messageHeaderA), CRYPTO_CONTEXTS);
assertTrue(messageHeaderA.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA.hashCode());
assertFalse(messageHeaderA.equals(messageHeaderB));
assertFalse(messageHeaderB.equals(messageHeaderA));
assertTrue(messageHeaderA.hashCode() != messageHeaderB.hashCode());
assertFalse(messageHeaderA.equals(messageHeaderC));
assertFalse(messageHeaderC.equals(messageHeaderA));
assertTrue(messageHeaderA.hashCode() != messageHeaderC.hashCode());
assertTrue(messageHeaderA.equals(messageHeaderA2));
assertTrue(messageHeaderA2.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA2.hashCode());
}
@Test
public void equalsPeerMasterToken() throws MslEncodingException, MslEntityAuthException, MslCryptoException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
final HeaderData headerData = builder.build();
final MasterToken peerMasterTokenA = MslTestUtils.getMasterToken(p2pCtx, 1, 1);
final MasterToken peerMasterTokenB = MslTestUtils.getMasterToken(p2pCtx, 1, 2);
final HeaderPeerData peerDataA = new HeaderPeerData(peerMasterTokenA, null, null);
final HeaderPeerData peerDataB = new HeaderPeerData(peerMasterTokenB, null, null);
final HeaderPeerData peerDataC = new HeaderPeerData(null, null, null);
final MessageHeader messageHeaderA = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerDataA);
final MessageHeader messageHeaderB = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerDataB);
final MessageHeader messageHeaderC = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerDataC);
final MessageHeader messageHeaderA2 = (MessageHeader)Header.parseHeader(p2pCtx, MslTestUtils.toMslObject(encoder, messageHeaderA), CRYPTO_CONTEXTS);
assertTrue(messageHeaderA.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA.hashCode());
assertFalse(messageHeaderA.equals(messageHeaderB));
assertFalse(messageHeaderB.equals(messageHeaderA));
assertTrue(messageHeaderA.hashCode() != messageHeaderB.hashCode());
assertFalse(messageHeaderA.equals(messageHeaderC));
assertFalse(messageHeaderC.equals(messageHeaderA));
assertTrue(messageHeaderA.hashCode() != messageHeaderC.hashCode());
assertTrue(messageHeaderA.equals(messageHeaderA2));
assertTrue(messageHeaderA2.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA2.hashCode());
}
@Test
public void equalsPeerUserIdToken() throws MslEncodingException, MslEntityAuthException, MslCryptoException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
final HeaderData headerData = builder.build();
final UserIdToken peerUserIdTokenA = MslTestUtils.getUserIdToken(p2pCtx, PEER_MASTER_TOKEN, 1, MockEmailPasswordAuthenticationFactory.USER);
final UserIdToken peerUserIdTokenB = MslTestUtils.getUserIdToken(p2pCtx, PEER_MASTER_TOKEN, 2, MockEmailPasswordAuthenticationFactory.USER);
final HeaderPeerData peerDataA = new HeaderPeerData(PEER_MASTER_TOKEN, peerUserIdTokenA, null);
final HeaderPeerData peerDataB = new HeaderPeerData(PEER_MASTER_TOKEN, peerUserIdTokenB, null);
final HeaderPeerData peerDataC = new HeaderPeerData(PEER_MASTER_TOKEN, null, null);
final MessageHeader messageHeaderA = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerDataA);
final MessageHeader messageHeaderB = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerDataB);
final MessageHeader messageHeaderC = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerDataC);
final MessageHeader messageHeaderA2 = (MessageHeader)Header.parseHeader(p2pCtx, MslTestUtils.toMslObject(encoder, messageHeaderA), CRYPTO_CONTEXTS);
assertTrue(messageHeaderA.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA.hashCode());
assertFalse(messageHeaderA.equals(messageHeaderB));
assertFalse(messageHeaderB.equals(messageHeaderA));
assertTrue(messageHeaderA.hashCode() != messageHeaderB.hashCode());
assertFalse(messageHeaderA.equals(messageHeaderC));
assertFalse(messageHeaderC.equals(messageHeaderA));
assertTrue(messageHeaderA.hashCode() != messageHeaderC.hashCode());
assertTrue(messageHeaderA.equals(messageHeaderA2));
assertTrue(messageHeaderA2.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA2.hashCode());
}
@Test
public void equalsPeerServiceTokens() throws MslEncodingException, MslEntityAuthException, MslCryptoException, MslKeyExchangeException, MslUserAuthException, MslException, MslEncoderException {
final HeaderDataBuilder builder = new HeaderDataBuilder(p2pCtx, MASTER_TOKEN, USER_ID_TOKEN, true);
final HeaderData headerData = builder.build();
final Set<ServiceToken> peerServiceTokensA = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final Set<ServiceToken> peerServiceTokensB = MslTestUtils.getServiceTokens(p2pCtx, PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN);
final HeaderPeerData peerDataA = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokensA);
final HeaderPeerData peerDataB = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, peerServiceTokensB);
final HeaderPeerData peerDataC = new HeaderPeerData(PEER_MASTER_TOKEN, PEER_USER_ID_TOKEN, null);
final MessageHeader messageHeaderA = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerDataA);
final MessageHeader messageHeaderB = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerDataB);
final MessageHeader messageHeaderC = new MessageHeader(p2pCtx, null, MASTER_TOKEN, headerData, peerDataC);
final MessageHeader messageHeaderA2 = (MessageHeader)Header.parseHeader(p2pCtx, MslTestUtils.toMslObject(encoder, messageHeaderA), CRYPTO_CONTEXTS);
assertTrue(messageHeaderA.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA.hashCode());
assertFalse(messageHeaderA.equals(messageHeaderB));
assertFalse(messageHeaderB.equals(messageHeaderA));
assertTrue(messageHeaderA.hashCode() != messageHeaderB.hashCode());
assertFalse(messageHeaderA.equals(messageHeaderC));
assertFalse(messageHeaderC.equals(messageHeaderA));
assertTrue(messageHeaderA.hashCode() != messageHeaderC.hashCode());
assertTrue(messageHeaderA.equals(messageHeaderA2));
assertTrue(messageHeaderA2.equals(messageHeaderA));
assertEquals(messageHeaderA.hashCode(), messageHeaderA2.hashCode());
}
@Test
public void equalsObject() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslException {
final HeaderDataBuilder builder = new HeaderDataBuilder(trustedNetCtx, MASTER_TOKEN, USER_ID_TOKEN, false);
final HeaderData headerData = builder.build();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final MessageHeader messageHeader = new MessageHeader(trustedNetCtx, null, MASTER_TOKEN, headerData, peerData);
assertFalse(messageHeader.equals(null));
assertFalse(messageHeader.equals(MASTER_TOKEN));
assertTrue(messageHeader.hashCode() != MASTER_TOKEN.hashCode());
}
}
| 9,958 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/keyx/JsonWebKeyLadderExchangeSuite.java | /**
* Copyright (c) 2013-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.keyx;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.security.NoSuchAlgorithmException;
import java.security.Security;
import java.util.Arrays;
import java.util.Random;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.MslKeyExchangeException;
import com.netflix.msl.MslMasterTokenException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.crypto.JcaAlgorithm;
import com.netflix.msl.crypto.JsonWebKey;
import com.netflix.msl.crypto.JsonWebKey.Algorithm;
import com.netflix.msl.crypto.JsonWebKey.Usage;
import com.netflix.msl.entityauth.EntityAuthenticationData;
import com.netflix.msl.entityauth.EntityAuthenticationFactory;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.entityauth.MockPresharedAuthenticationFactory;
import com.netflix.msl.entityauth.PresharedAuthenticationData;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.keyx.JsonWebKeyLadderExchange.AesKwJwkCryptoContext;
import com.netflix.msl.keyx.JsonWebKeyLadderExchange.JwkCryptoContext;
import com.netflix.msl.keyx.JsonWebKeyLadderExchange.Mechanism;
import com.netflix.msl.keyx.JsonWebKeyLadderExchange.RequestData;
import com.netflix.msl.keyx.JsonWebKeyLadderExchange.ResponseData;
import com.netflix.msl.keyx.KeyExchangeFactory.KeyExchangeData;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.tokens.MasterToken;
import com.netflix.msl.util.AuthenticationUtils;
import com.netflix.msl.util.MockAuthenticationUtils;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* JSON Web Key ladder exchange unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
@RunWith(Suite.class)
@SuiteClasses({JsonWebKeyLadderExchangeSuite.KeyExchangeFactoryTest.class,
JsonWebKeyLadderExchangeSuite.RequestDataTest.class,
JsonWebKeyLadderExchangeSuite.ResponseDataTest.class})
public class JsonWebKeyLadderExchangeSuite {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key key exchange scheme. */
private static final String KEY_SCHEME = "scheme";
/** Key key request data. */
private static final String KEY_KEYDATA = "keydata";
private static ICryptoContext PSK_CRYPTO_CONTEXT, WRAP_CRYPTO_CONTEXT;
private static byte[] WRAP_JWK;
private static byte[] WRAPDATA;
private static final String PSK_IDENTITY = MockPresharedAuthenticationFactory.PSK_ESN;
private static MasterToken PSK_MASTER_TOKEN;
private static byte[] PSK_ENCRYPTION_JWK;
private static byte[] PSK_HMAC_JWK;
@BeforeClass
public static synchronized void setup() throws MslEncodingException, MslCryptoException, NoSuchAlgorithmException, MslEntityAuthException {
if (pskCtx == null) {
Security.addProvider(new BouncyCastleProvider());
pskCtx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = pskCtx.getMslEncoderFactory();
// Create PSK wrapping crypto context.
{
final EntityAuthenticationData entityAuthData = pskCtx.getEntityAuthenticationData(null);
final EntityAuthenticationFactory entityAuthFactory = pskCtx.getEntityAuthenticationFactory(entityAuthData.getScheme());
final ICryptoContext cryptoContext = entityAuthFactory.getCryptoContext(pskCtx, entityAuthData);
PSK_CRYPTO_CONTEXT = new AesKwJwkCryptoContext(cryptoContext);
}
// The wrap key is the new wrapping key wrapped by the specified
// wrapping key (e.g. PSK or RSA) inside a JWK. Technically we
// shouldn't know this but that's the only way to verify things.
//
// Create the new wrapping key and wrap crypto context.
final byte[] wrappingKey = new byte[16];
pskCtx.getRandom().nextBytes(wrappingKey);
final SecretKey wrapKey = new SecretKeySpec(wrappingKey, JcaAlgorithm.AESKW);
WRAP_CRYPTO_CONTEXT = new AesKwJwkCryptoContext(wrapKey);
//
// Wrap the new wrapping key using a PSK wrap crypto context.
final JsonWebKey wrapJwk = new JsonWebKey(Usage.wrap, Algorithm.A128KW, false, null, wrapKey);
WRAP_JWK = PSK_CRYPTO_CONTEXT.wrap(wrapJwk.toMslEncoding(encoder, ENCODER_FORMAT), encoder, ENCODER_FORMAT);
// The wrap data is an AES-128 key wrapped by the primary MSL
// context. Technically we shouldn't know this but that's the only
// way to verify things.
WRAPDATA = pskCtx.getMslCryptoContext().wrap(wrappingKey, encoder, ENCODER_FORMAT);
final WrapCryptoContextRepository repository = new MockCryptoContextRepository();
final AuthenticationUtils authutils = new MockAuthenticationUtils();
final KeyExchangeFactory keyxFactory = new JsonWebKeyLadderExchange(repository, authutils);
pskCtx.addKeyExchangeFactory(keyxFactory);
PSK_MASTER_TOKEN = MslTestUtils.getMasterToken(pskCtx, 1, 1);
final SecretKey pskEncryptionKey = PSK_MASTER_TOKEN.getEncryptionKey();
final JsonWebKey pskEncryptionJwk = new JsonWebKey(Usage.enc, Algorithm.A128CBC, false, null, pskEncryptionKey);
PSK_ENCRYPTION_JWK = WRAP_CRYPTO_CONTEXT.wrap(pskEncryptionJwk.toMslEncoding(encoder, ENCODER_FORMAT), encoder, ENCODER_FORMAT);
final SecretKey pskHmacKey = PSK_MASTER_TOKEN.getSignatureKey();
final JsonWebKey pskHmacJwk = new JsonWebKey(Usage.sig, Algorithm.HS256, false, null, pskHmacKey);
PSK_HMAC_JWK = WRAP_CRYPTO_CONTEXT.wrap(pskHmacJwk.toMslEncoding(encoder, ENCODER_FORMAT), encoder, ENCODER_FORMAT);
}
}
@AfterClass
public static synchronized void teardown() {
// Teardown causes problems because the data is shared by the inner
// classes, so don't do any cleanup.
}
/** PSK MSL context. */
private static MockMslContext pskCtx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
/** Request data unit tests. */
public static class RequestDataTest {
/** Key wrap key wrapping mechanism. */
private static final String KEY_MECHANISM = "mechanism";
/** Key public key. */
private static final String KEY_PUBLIC_KEY = "publickey";
/** Key wrap data. */
private static final String KEY_WRAPDATA = "wrapdata";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@Test
public void ctorsWrap() throws MslCryptoException, MslKeyExchangeException, MslEncodingException, MslException, MslEncoderException {
final RequestData req = new RequestData(Mechanism.WRAP, WRAPDATA);
assertEquals(KeyExchangeScheme.JWK_LADDER, req.getKeyExchangeScheme());
assertEquals(Mechanism.WRAP, req.getMechanism());
assertArrayEquals(WRAPDATA, req.getWrapdata());
final MslObject keydata = req.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata);
final RequestData moReq = new RequestData(keydata);
assertEquals(req.getKeyExchangeScheme(), moReq.getKeyExchangeScheme());
assertEquals(req.getMechanism(), moReq.getMechanism());
assertArrayEquals(req.getWrapdata(), moReq.getWrapdata());
final MslObject moKeydata = req.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(moKeydata);
assertTrue(MslEncoderUtils.equalObjects(keydata, moKeydata));
}
@Test
public void jsonWrap() throws MslException, MslEncoderException {
final RequestData req = new RequestData(Mechanism.WRAP, WRAPDATA);
final MslObject mo = MslTestUtils.toMslObject(encoder, req);
assertEquals(KeyExchangeScheme.JWK_LADDER.name(), mo.getString(KEY_SCHEME));
final MslObject keydata = mo.getMslObject(KEY_KEYDATA, encoder);
assertEquals(Mechanism.WRAP.name(), keydata.getString(KEY_MECHANISM));
assertFalse(keydata.has(KEY_PUBLIC_KEY));
assertArrayEquals(WRAPDATA, keydata.getBytes(KEY_WRAPDATA));
}
@Test
public void createWrap() throws MslException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslCryptoException, MslEncoderException {
final RequestData req = new RequestData(Mechanism.WRAP, WRAPDATA);
final MslObject mo = MslTestUtils.toMslObject(encoder, req);
final KeyRequestData keyRequestData = KeyRequestData.create(pskCtx, mo);
assertNotNull(keyRequestData);
assertTrue(keyRequestData instanceof RequestData);
final RequestData moReq = (RequestData)keyRequestData;
assertEquals(req.getKeyExchangeScheme(), moReq.getKeyExchangeScheme());
assertEquals(req.getMechanism(), moReq.getMechanism());
assertArrayEquals(req.getWrapdata(), moReq.getWrapdata());
}
@Test(expected = MslInternalException.class)
public void ctorWrapNullWrapdata() {
new RequestData(Mechanism.WRAP, null);
}
@Test
public void ctorsPsk() throws MslCryptoException, MslKeyExchangeException, MslEncodingException, MslException, MslEncoderException {
final RequestData req = new RequestData(Mechanism.PSK, null);
assertEquals(KeyExchangeScheme.JWK_LADDER, req.getKeyExchangeScheme());
assertEquals(Mechanism.PSK, req.getMechanism());
assertNull(req.getWrapdata());
final MslObject keydata = req.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata);
final RequestData moReq = new RequestData(keydata);
assertEquals(req.getKeyExchangeScheme(), moReq.getKeyExchangeScheme());
assertEquals(req.getMechanism(), moReq.getMechanism());
assertNull(moReq.getWrapdata());
final MslObject moKeydata = req.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(moKeydata);
assertTrue(MslEncoderUtils.equalObjects(keydata, moKeydata));
}
@Test
public void jsonPsk() throws MslException, MslEncoderException {
final RequestData req = new RequestData(Mechanism.PSK, null);
final MslObject mo = MslTestUtils.toMslObject(encoder, req);
assertEquals(KeyExchangeScheme.JWK_LADDER.name(), mo.getString(KEY_SCHEME));
final MslObject keydata = mo.getMslObject(KEY_KEYDATA, encoder);
assertEquals(Mechanism.PSK.name(), keydata.getString(KEY_MECHANISM));
assertFalse(keydata.has(KEY_PUBLIC_KEY));
assertFalse(keydata.has(KEY_WRAPDATA));
}
@Test
public void createPsk() throws MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslException, MslCryptoException, MslEncoderException {
final RequestData req = new RequestData(Mechanism.PSK, null);
final MslObject mo = MslTestUtils.toMslObject(encoder, req);
final KeyRequestData keyRequestData = KeyRequestData.create(pskCtx, mo);
assertNotNull(keyRequestData);
assertTrue(keyRequestData instanceof RequestData);
final RequestData moReq = (RequestData)keyRequestData;
assertEquals(req.getKeyExchangeScheme(), moReq.getKeyExchangeScheme());
assertEquals(req.getMechanism(), moReq.getMechanism());
assertNull(moReq.getWrapdata());
}
@Test
public void missingMechanism() throws MslException, MslCryptoException, MslKeyExchangeException, MslEncodingException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final RequestData req = new RequestData(Mechanism.PSK, null);
final MslObject keydata = req.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata.remove(KEY_MECHANISM));
new RequestData(keydata);
}
@Test
public void invalidMechanism() throws MslCryptoException, MslKeyExchangeException, MslEncodingException, MslException, MslEncoderException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.UNIDENTIFIED_KEYX_MECHANISM);
final RequestData req = new RequestData(Mechanism.PSK, null);
final MslObject keydata = req.getKeydata(encoder, ENCODER_FORMAT);
keydata.put(KEY_MECHANISM, "x");
new RequestData(keydata);
}
@Test
public void wrapMissingWrapdata() throws MslCryptoException, MslKeyExchangeException, MslEncodingException, MslException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final RequestData req = new RequestData(Mechanism.WRAP, WRAPDATA);
final MslObject keydata = req.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata.remove(KEY_WRAPDATA));
new RequestData(keydata);
}
@Test
public void wrapInvalidWrapdata() throws MslCryptoException, MslKeyExchangeException, MslEncodingException, MslException, MslEncoderException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.KEYX_WRAPPING_KEY_MISSING);
final RequestData req = new RequestData(Mechanism.WRAP, WRAPDATA);
final MslObject keydata = req.getKeydata(encoder, ENCODER_FORMAT);
keydata.put(KEY_WRAPDATA, new byte[0]);
new RequestData(keydata);
}
@Test
public void equalsMechanism() throws MslCryptoException, MslKeyExchangeException, MslEncodingException, MslException, MslEncoderException {
final RequestData dataA = new RequestData(Mechanism.WRAP, WRAPDATA);
final RequestData dataB = new RequestData(Mechanism.PSK, null);
final RequestData dataA2 = new RequestData(dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsWrapdata() throws MslCryptoException, MslKeyExchangeException, MslEncodingException, MslException, MslEncoderException {
final byte[] wrapdataB = Arrays.copyOf(WRAPDATA, WRAPDATA.length);
++wrapdataB[0];
final RequestData dataA = new RequestData(Mechanism.WRAP, WRAPDATA);
final RequestData dataB = new RequestData(Mechanism.WRAP, wrapdataB);
final RequestData dataA2 = new RequestData(dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
}
/** Response data unit tests. */
public static class ResponseDataTest {
/** Key master token. */
private static final String KEY_MASTER_TOKEN = "mastertoken";
/** Key wrapping key. */
private static final String KEY_WRAP_KEY = "wrapkey";
/** Key wrapping key data. */
private static final String KEY_WRAPDATA = "wrapdata";
/** Key encrypted encryption key. */
private static final String KEY_ENCRYPTION_KEY = "encryptionkey";
/** Key encrypted HMAC key. */
private static final String KEY_HMAC_KEY = "hmackey";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@Test
public void ctors() throws MslException, MslKeyExchangeException, MslEncodingException, MslEncoderException {
final ResponseData resp = new ResponseData(PSK_MASTER_TOKEN, WRAP_JWK, WRAPDATA, PSK_ENCRYPTION_JWK, PSK_HMAC_JWK);
assertArrayEquals(PSK_ENCRYPTION_JWK, resp.getEncryptionKey());
assertArrayEquals(PSK_HMAC_JWK, resp.getHmacKey());
assertEquals(KeyExchangeScheme.JWK_LADDER, resp.getKeyExchangeScheme());
assertEquals(PSK_MASTER_TOKEN, resp.getMasterToken());
assertArrayEquals(WRAPDATA, resp.getWrapdata());
assertArrayEquals(WRAP_JWK, resp.getWrapKey());
final MslObject keydata = resp.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata);
final ResponseData moResp = new ResponseData(PSK_MASTER_TOKEN, keydata);
assertArrayEquals(resp.getEncryptionKey(), moResp.getEncryptionKey());
assertArrayEquals(resp.getHmacKey(), moResp.getHmacKey());
assertEquals(resp.getKeyExchangeScheme(), moResp.getKeyExchangeScheme());
assertEquals(resp.getMasterToken(), moResp.getMasterToken());
assertArrayEquals(resp.getWrapdata(), moResp.getWrapdata());
assertArrayEquals(resp.getWrapKey(), moResp.getWrapKey());
final MslObject moKeydata = moResp.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(moKeydata);
assertTrue(MslEncoderUtils.equalObjects(keydata, moKeydata));
}
@Test
public void json() throws MslEncodingException, MslCryptoException, MslException, MslException, MslEncoderException {
final ResponseData resp = new ResponseData(PSK_MASTER_TOKEN, WRAP_JWK, WRAPDATA, PSK_ENCRYPTION_JWK, PSK_HMAC_JWK);
final MslObject mo = MslTestUtils.toMslObject(encoder, resp);
assertEquals(KeyExchangeScheme.JWK_LADDER.name(), mo.getString(KEY_SCHEME));
final MasterToken masterToken = new MasterToken(pskCtx, mo.getMslObject(KEY_MASTER_TOKEN, encoder));
assertEquals(PSK_MASTER_TOKEN, masterToken);
final MslObject keydata = mo.getMslObject(KEY_KEYDATA, encoder);
assertArrayEquals(PSK_ENCRYPTION_JWK, keydata.getBytes(KEY_ENCRYPTION_KEY));
assertArrayEquals(PSK_HMAC_JWK, keydata.getBytes(KEY_HMAC_KEY));
assertArrayEquals(WRAPDATA, keydata.getBytes(KEY_WRAPDATA));
assertArrayEquals(WRAP_JWK, keydata.getBytes(KEY_WRAP_KEY));
}
@Test
public void create() throws MslException, MslEncodingException, MslCryptoException, MslKeyExchangeException, MslException, MslEncoderException {
final ResponseData resp = new ResponseData(PSK_MASTER_TOKEN, WRAP_JWK, WRAPDATA, PSK_ENCRYPTION_JWK, PSK_HMAC_JWK);
final MslObject mo = MslTestUtils.toMslObject(encoder, resp);
final KeyResponseData keyResponseData = KeyResponseData.create(pskCtx, mo);
assertNotNull(keyResponseData);
assertTrue(keyResponseData instanceof ResponseData);
final ResponseData moResp = (ResponseData)keyResponseData;
assertArrayEquals(resp.getEncryptionKey(), moResp.getEncryptionKey());
assertArrayEquals(resp.getHmacKey(), moResp.getHmacKey());
assertEquals(resp.getKeyExchangeScheme(), moResp.getKeyExchangeScheme());
assertEquals(resp.getMasterToken(), moResp.getMasterToken());
assertArrayEquals(resp.getWrapdata(), moResp.getWrapdata());
assertArrayEquals(resp.getWrapKey(), moResp.getWrapKey());
}
@Test
public void missingWrapKey() throws MslException, MslKeyExchangeException, MslEncodingException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ResponseData resp = new ResponseData(PSK_MASTER_TOKEN, WRAP_JWK, WRAPDATA, PSK_ENCRYPTION_JWK, PSK_HMAC_JWK);
final MslObject keydata = resp.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata.remove(KEY_WRAP_KEY));
new ResponseData(PSK_MASTER_TOKEN, keydata);
}
@Test
public void missingWrapdata() throws MslException, MslKeyExchangeException, MslEncodingException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ResponseData resp = new ResponseData(PSK_MASTER_TOKEN, WRAP_JWK, WRAPDATA, PSK_ENCRYPTION_JWK, PSK_HMAC_JWK);
final MslObject keydata = resp.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata.remove(KEY_WRAPDATA));
new ResponseData(PSK_MASTER_TOKEN, keydata);
}
@Test
public void missingEncryptionKey() throws MslKeyExchangeException, MslEncodingException, MslException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ResponseData resp = new ResponseData(PSK_MASTER_TOKEN, WRAP_JWK, WRAPDATA, PSK_ENCRYPTION_JWK, PSK_HMAC_JWK);
final MslObject keydata = resp.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata.remove(KEY_ENCRYPTION_KEY));
new ResponseData(PSK_MASTER_TOKEN, keydata);
}
@Test
public void missingHmacKey() throws MslException, MslKeyExchangeException, MslEncodingException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ResponseData resp = new ResponseData(PSK_MASTER_TOKEN, WRAP_JWK, WRAPDATA, PSK_ENCRYPTION_JWK, PSK_HMAC_JWK);
final MslObject keydata = resp.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata.remove(KEY_HMAC_KEY));
new ResponseData(PSK_MASTER_TOKEN, keydata);
}
@Test
public void equalsWrapKey() throws MslKeyExchangeException, MslEncodingException, MslException, MslEncoderException {
final byte[] wrapKeyB = Arrays.copyOf(WRAP_JWK, WRAP_JWK.length);
++wrapKeyB[0];
final ResponseData dataA = new ResponseData(PSK_MASTER_TOKEN, WRAP_JWK, WRAPDATA, PSK_ENCRYPTION_JWK, PSK_HMAC_JWK);
final ResponseData dataB = new ResponseData(PSK_MASTER_TOKEN, wrapKeyB, WRAPDATA, PSK_ENCRYPTION_JWK, PSK_HMAC_JWK);
final ResponseData dataA2 = new ResponseData(PSK_MASTER_TOKEN, dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsWrapdata() throws MslKeyExchangeException, MslEncodingException, MslException, MslEncoderException {
final byte[] wrapdataB = Arrays.copyOf(WRAPDATA, WRAPDATA.length);
++wrapdataB[0];
final ResponseData dataA = new ResponseData(PSK_MASTER_TOKEN, WRAP_JWK, WRAPDATA, PSK_ENCRYPTION_JWK, PSK_HMAC_JWK);
final ResponseData dataB = new ResponseData(PSK_MASTER_TOKEN, WRAP_JWK, wrapdataB, PSK_ENCRYPTION_JWK, PSK_HMAC_JWK);
final ResponseData dataA2 = new ResponseData(PSK_MASTER_TOKEN, dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsEncryptionKey() throws MslKeyExchangeException, MslEncodingException, MslException, MslEncoderException {
final byte[] encryptionKeyB = Arrays.copyOf(PSK_ENCRYPTION_JWK, PSK_ENCRYPTION_JWK.length);
++encryptionKeyB[0];
final ResponseData dataA = new ResponseData(PSK_MASTER_TOKEN, WRAP_JWK, WRAPDATA, PSK_ENCRYPTION_JWK, PSK_HMAC_JWK);
final ResponseData dataB = new ResponseData(PSK_MASTER_TOKEN, WRAP_JWK, WRAPDATA, encryptionKeyB, PSK_HMAC_JWK);
final ResponseData dataA2 = new ResponseData(PSK_MASTER_TOKEN, dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsHmacKey() throws MslKeyExchangeException, MslEncodingException, MslException, MslEncoderException {
final byte[] hmacKeyB = Arrays.copyOf(PSK_HMAC_JWK, PSK_HMAC_JWK.length);
++hmacKeyB[0];
final ResponseData dataA = new ResponseData(PSK_MASTER_TOKEN, WRAP_JWK, WRAPDATA, PSK_ENCRYPTION_JWK, PSK_HMAC_JWK);
final ResponseData dataB = new ResponseData(PSK_MASTER_TOKEN, WRAP_JWK, WRAPDATA, PSK_ENCRYPTION_JWK, hmacKeyB);
final ResponseData dataA2 = new ResponseData(PSK_MASTER_TOKEN, dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
}
/** Key exchange factory unit tests. */
public static class KeyExchangeFactoryTest {
/**
* Fake key request data for the JSON Web Key key ladder key exchange
* scheme.
*/
private static class FakeKeyRequestData extends KeyRequestData {
/** Create a new fake key request data. */
protected FakeKeyRequestData() {
super(KeyExchangeScheme.JWK_LADDER);
}
/* (non-Javadoc)
* @see com.netflix.msl.keyx.KeyRequestData#getKeydata(com.netflix.msl.io.MslEncoderFactory, com.netflix.msl.io.MslEncoderFormat)
*/
@Override
protected MslObject getKeydata(final MslEncoderFactory encoder, final MslEncoderFormat format) throws MslEncoderException {
return null;
}
}
/**
* Fake key response data for the JSON Web Key key ladder key exchange
* scheme.
*/
private static class FakeKeyResponseData extends KeyResponseData {
/** Create a new fake key response data. */
protected FakeKeyResponseData() {
super(PSK_MASTER_TOKEN, KeyExchangeScheme.JWK_LADDER);
}
/* (non-Javadoc)
* @see com.netflix.msl.keyx.KeyResponseData#getKeydata(com.netflix.msl.io.MslEncoderFactory, com.netflix.msl.io.MslEncoderFormat)
*/
@Override
protected MslObject getKeydata(final MslEncoderFactory encoder, final MslEncoderFormat format) throws MslEncoderException {
return null;
}
}
/**
* Unwrap a JSON Web Key and return the secret key it contains.
*
* @param wrapCryptoContext crypto context for unwrapping the JSON Web Key.
* @param wrappedJwk the wrapped JSON Web Key.
* @return the secret key.
* @throws MslCryptoException if there is an error unwrapping the JSON
* Web Key.
* @throws MslException if there is an error reconstructing the JSON
* Web Key MSL object.
* @throws MslEncodingException if there is an error parsing the JSON
* Web Key MSL object.
* @throws MslEncoderException if there is an error parsing the data.
*/
private static SecretKey extractJwkSecretKey(final ICryptoContext wrapCryptoContext, final byte[] wrappedJwk) throws MslCryptoException, MslException, MslEncodingException, MslEncoderException {
final byte[] unwrappedJwk = wrapCryptoContext.unwrap(wrappedJwk, encoder);
final JsonWebKey jwk = new JsonWebKey(encoder.parseObject(unwrappedJwk));
return jwk.getSecretKey();
}
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@BeforeClass
public static void setup() {
random = new Random();
repository = new MockCryptoContextRepository();
authutils = new MockAuthenticationUtils();
factory = new JsonWebKeyLadderExchange(repository, authutils);
entityAuthData = new PresharedAuthenticationData(PSK_IDENTITY);
// Not sure why I have to do this again since it's already done by
// the parent class.
Security.addProvider(new BouncyCastleProvider());
}
@AfterClass
public static void teardown() {
entityAuthData = null;
factory = null;
authutils = null;
repository = null;
random = null;
}
@Before
public void reset() {
authutils.reset();
pskCtx.getMslStore().clearCryptoContexts();
pskCtx.getMslStore().clearServiceTokens();
repository.clear();
}
/** Random. */
private static Random random;
/** JWK key ladder crypto context repository. */
private static MockCryptoContextRepository repository;
/** Authentication utilities. */
private static MockAuthenticationUtils authutils;
/** Key exchange factory. */
private static KeyExchangeFactory factory;
/** Entity authentication data. */
private static EntityAuthenticationData entityAuthData;
@Test
public void factory() {
assertEquals(KeyExchangeScheme.JWK_LADDER, factory.getScheme());
}
@Test
public void generateWrapInitialResponse() throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslEntityAuthException, MslException, MslException, MslEncoderException {
final KeyRequestData req = new RequestData(Mechanism.WRAP, WRAPDATA);
final KeyExchangeData keyxData = factory.generateResponse(pskCtx, ENCODER_FORMAT, req, entityAuthData);
assertNotNull(keyxData);
assertNotNull(keyxData.cryptoContext);
assertNotNull(keyxData.keyResponseData);
final KeyResponseData resp = keyxData.keyResponseData;
assertEquals(KeyExchangeScheme.JWK_LADDER, resp.getKeyExchangeScheme());
final MasterToken masterToken = resp.getMasterToken();
assertNotNull(masterToken);
assertEquals(PSK_IDENTITY, masterToken.getIdentity());
// Unwrap the new wrapping key and create a crypto context from it.
assertTrue(resp instanceof ResponseData);
final ResponseData respdata = (ResponseData)resp;
final SecretKey wrappingKey = extractJwkSecretKey(WRAP_CRYPTO_CONTEXT, respdata.getWrapKey());
final JwkCryptoContext wrapCryptoContext = new AesKwJwkCryptoContext(wrappingKey);
// Unwrap the session keys.
final SecretKey encryptionKey = extractJwkSecretKey(wrapCryptoContext, respdata.getEncryptionKey());
assertArrayEquals(masterToken.getEncryptionKey().getEncoded(), encryptionKey.getEncoded());
final SecretKey hmacKey = extractJwkSecretKey(wrapCryptoContext, respdata.getHmacKey());
assertArrayEquals(masterToken.getSignatureKey().getEncoded(), hmacKey.getEncoded());
}
@Test
public void generatePskInitialResponse() throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslEntityAuthException, MslException, MslException, MslEncoderException {
final KeyRequestData req = new RequestData(Mechanism.PSK, null);
final KeyExchangeData keyxData = factory.generateResponse(pskCtx, ENCODER_FORMAT, req, entityAuthData);
assertNotNull(keyxData);
assertNotNull(keyxData.cryptoContext);
assertNotNull(keyxData.keyResponseData);
final KeyResponseData resp = keyxData.keyResponseData;
assertEquals(KeyExchangeScheme.JWK_LADDER, resp.getKeyExchangeScheme());
final MasterToken masterToken = resp.getMasterToken();
assertNotNull(masterToken);
assertEquals(PSK_IDENTITY, masterToken.getIdentity());
// Unwrap the new wrapping key and create a crypto context from it.
assertTrue(resp instanceof ResponseData);
final ResponseData respdata = (ResponseData)resp;
final SecretKey wrappingKey = extractJwkSecretKey(PSK_CRYPTO_CONTEXT, respdata.getWrapKey());
final JwkCryptoContext wrapCryptoContext = new AesKwJwkCryptoContext(wrappingKey);
// Unwrap the session keys.
final SecretKey encryptionKey = extractJwkSecretKey(wrapCryptoContext, respdata.getEncryptionKey());
assertArrayEquals(masterToken.getEncryptionKey().getEncoded(), encryptionKey.getEncoded());
final SecretKey hmacKey = extractJwkSecretKey(wrapCryptoContext, respdata.getHmacKey());
assertArrayEquals(masterToken.getSignatureKey().getEncoded(), hmacKey.getEncoded());
}
@Test(expected = MslInternalException.class)
public void wrongRequestInitialResponse() throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslEntityAuthException, MslException {
final KeyRequestData req = new FakeKeyRequestData();
factory.generateResponse(pskCtx, ENCODER_FORMAT, req, entityAuthData);
}
@Test
public void generateWrapSubsequentResponse() throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslMasterTokenException, MslEntityAuthException, MslException, MslException, MslEncoderException {
final KeyRequestData req = new RequestData(Mechanism.WRAP, WRAPDATA);
final KeyExchangeData keyxData = factory.generateResponse(pskCtx, ENCODER_FORMAT, req, PSK_MASTER_TOKEN);
assertNotNull(keyxData);
assertNotNull(keyxData.cryptoContext);
assertNotNull(keyxData.keyResponseData);
final KeyResponseData resp = keyxData.keyResponseData;
assertEquals(KeyExchangeScheme.JWK_LADDER, resp.getKeyExchangeScheme());
final MasterToken masterToken = resp.getMasterToken();
assertNotNull(masterToken);
assertEquals(PSK_MASTER_TOKEN.getIdentity(), masterToken.getIdentity());
assertEquals(PSK_MASTER_TOKEN.getSerialNumber(), masterToken.getSerialNumber());
assertEquals(PSK_MASTER_TOKEN.getSequenceNumber() + 1, masterToken.getSequenceNumber());
// Unwrap the new wrapping key and create a crypto context from it.
assertTrue(resp instanceof ResponseData);
final ResponseData respdata = (ResponseData)resp;
final SecretKey wrappingKey = extractJwkSecretKey(WRAP_CRYPTO_CONTEXT, respdata.getWrapKey());
final JwkCryptoContext wrapCryptoContext = new AesKwJwkCryptoContext(wrappingKey);
// Unwrap the session keys.
final SecretKey encryptionKey = extractJwkSecretKey(wrapCryptoContext, respdata.getEncryptionKey());
assertArrayEquals(masterToken.getEncryptionKey().getEncoded(), encryptionKey.getEncoded());
final SecretKey hmacKey = extractJwkSecretKey(wrapCryptoContext, respdata.getHmacKey());
assertArrayEquals(masterToken.getSignatureKey().getEncoded(), hmacKey.getEncoded());
}
@Test
public void generatePskSubsequentResponse() throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslMasterTokenException, MslEntityAuthException, MslException, MslException, MslEncoderException {
final KeyRequestData req = new RequestData(Mechanism.PSK, null);
final KeyExchangeData keyxData = factory.generateResponse(pskCtx, ENCODER_FORMAT, req, PSK_MASTER_TOKEN);
assertNotNull(keyxData);
assertNotNull(keyxData.cryptoContext);
assertNotNull(keyxData.keyResponseData);
final KeyResponseData resp = keyxData.keyResponseData;
assertEquals(KeyExchangeScheme.JWK_LADDER, resp.getKeyExchangeScheme());
final MasterToken masterToken = resp.getMasterToken();
assertNotNull(masterToken);
assertEquals(PSK_MASTER_TOKEN.getIdentity(), masterToken.getIdentity());
assertEquals(PSK_MASTER_TOKEN.getSerialNumber(), masterToken.getSerialNumber());
assertEquals(PSK_MASTER_TOKEN.getSequenceNumber() + 1, masterToken.getSequenceNumber());
// Unwrap the new wrapping key and create a crypto context from it.
assertTrue(resp instanceof ResponseData);
final ResponseData respdata = (ResponseData)resp;
final SecretKey wrappingKey = extractJwkSecretKey(PSK_CRYPTO_CONTEXT, respdata.getWrapKey());
final JwkCryptoContext wrapCryptoContext = new AesKwJwkCryptoContext(wrappingKey);
// Unwrap the session keys.
final SecretKey encryptionKey = extractJwkSecretKey(wrapCryptoContext, respdata.getEncryptionKey());
assertArrayEquals(masterToken.getEncryptionKey().getEncoded(), encryptionKey.getEncoded());
final SecretKey hmacKey = extractJwkSecretKey(wrapCryptoContext, respdata.getHmacKey());
assertArrayEquals(masterToken.getSignatureKey().getEncoded(), hmacKey.getEncoded());
}
@Test(expected = MslInternalException.class)
public void wrongRequestSubsequentResponse() throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslMasterTokenException, MslEntityAuthException, MslException {
final KeyRequestData req = new FakeKeyRequestData();
factory.generateResponse(pskCtx, ENCODER_FORMAT, req, PSK_MASTER_TOKEN);
}
@Test(expected = MslMasterTokenException.class)
public void untrustedMasterTokenSubsequentResponse() throws MslEncodingException, MslCryptoException, MslException, MslException, MslEncoderException {
final KeyRequestData req = new RequestData(Mechanism.PSK, null);
final MasterToken masterToken = MslTestUtils.getUntrustedMasterToken(pskCtx);
factory.generateResponse(pskCtx, ENCODER_FORMAT, req, masterToken);
}
@Test
public void getWrapCryptoContext() throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslEntityAuthException, MslException {
final KeyRequestData req = new RequestData(Mechanism.WRAP, WRAPDATA);
final KeyExchangeData keyxData = factory.generateResponse(pskCtx, ENCODER_FORMAT, req, entityAuthData);
final ICryptoContext reqCryptoContext = keyxData.cryptoContext;
final KeyResponseData resp = keyxData.keyResponseData;
// We must put the wrapping key into the repository to create the
// response crypto context.
repository.addCryptoContext(WRAPDATA, WRAP_CRYPTO_CONTEXT);
assertNotNull(repository.getCryptoContext(WRAPDATA));
final ICryptoContext respCryptoContext = factory.getCryptoContext(pskCtx, req, resp, null);
final byte[] wrapdata = repository.getWrapdata();
assertNotNull(wrapdata);
assertArrayEquals(((ResponseData)resp).getWrapdata(), wrapdata);
assertNull(repository.getCryptoContext(WRAPDATA));
final byte[] data = new byte[32];
random.nextBytes(data);
// Ciphertext won't always be equal depending on how it was
// enveloped. So we cannot check for equality or inequality.
final byte[] requestCiphertext = reqCryptoContext.encrypt(data, encoder, ENCODER_FORMAT);
final byte[] responseCiphertext = respCryptoContext.encrypt(data, encoder, ENCODER_FORMAT);
assertFalse(Arrays.equals(data, requestCiphertext));
assertFalse(Arrays.equals(data, responseCiphertext));
// Signatures should always be equal.
final byte[] requestSignature = reqCryptoContext.sign(data, encoder, ENCODER_FORMAT);
final byte[] responseSignature = respCryptoContext.sign(data, encoder, ENCODER_FORMAT);
assertFalse(Arrays.equals(data, requestSignature));
assertFalse(Arrays.equals(data, responseSignature));
assertArrayEquals(requestSignature, responseSignature);
// Plaintext should always be equal to the original message.
final byte[] requestPlaintext = reqCryptoContext.decrypt(responseCiphertext, encoder);
final byte[] responsePlaintext = respCryptoContext.decrypt(requestCiphertext, encoder);
assertNotNull(requestPlaintext);
assertArrayEquals(data, requestPlaintext);
assertArrayEquals(requestPlaintext, responsePlaintext);
// Verification should always succeed.
assertTrue(reqCryptoContext.verify(data, responseSignature, encoder));
assertTrue(respCryptoContext.verify(data, requestSignature, encoder));
}
@Test
public void getPskCryptoContext() throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslEntityAuthException, MslException {
final KeyRequestData req = new RequestData(Mechanism.PSK, null);
final KeyExchangeData keyxData = factory.generateResponse(pskCtx, ENCODER_FORMAT, req, entityAuthData);
final ICryptoContext reqCryptoContext = keyxData.cryptoContext;
final KeyResponseData resp = keyxData.keyResponseData;
assertNull(repository.getWrapdata());
final ICryptoContext respCryptoContext = factory.getCryptoContext(pskCtx, req, resp, null);
final byte[] wrapdata = repository.getWrapdata();
assertNotNull(wrapdata);
assertArrayEquals(((ResponseData)resp).getWrapdata(), wrapdata);
final byte[] data = new byte[32];
random.nextBytes(data);
// Ciphertext won't always be equal depending on how it was
// enveloped. So we cannot check for equality or inequality.
final byte[] requestCiphertext = reqCryptoContext.encrypt(data, encoder, ENCODER_FORMAT);
final byte[] responseCiphertext = respCryptoContext.encrypt(data, encoder, ENCODER_FORMAT);
assertFalse(Arrays.equals(data, requestCiphertext));
assertFalse(Arrays.equals(data, responseCiphertext));
// Signatures should always be equal.
final byte[] requestSignature = reqCryptoContext.sign(data, encoder, ENCODER_FORMAT);
final byte[] responseSignature = respCryptoContext.sign(data, encoder, ENCODER_FORMAT);
assertFalse(Arrays.equals(data, requestSignature));
assertFalse(Arrays.equals(data, responseSignature));
assertArrayEquals(requestSignature, responseSignature);
// Plaintext should always be equal to the original message.
final byte[] requestPlaintext = reqCryptoContext.decrypt(responseCiphertext, encoder);
final byte[] responsePlaintext = respCryptoContext.decrypt(requestCiphertext, encoder);
assertNotNull(requestPlaintext);
assertArrayEquals(data, requestPlaintext);
assertArrayEquals(requestPlaintext, responsePlaintext);
// Verification should always succeed.
assertTrue(reqCryptoContext.verify(data, responseSignature, encoder));
assertTrue(respCryptoContext.verify(data, requestSignature, encoder));
}
@Test(expected = MslInternalException.class)
public void wrongRequestCryptoContext() throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslEntityAuthException, MslException {
final KeyRequestData req = new RequestData(Mechanism.PSK, null);
final KeyExchangeData keyxData = factory.generateResponse(pskCtx, ENCODER_FORMAT, req, entityAuthData);
final KeyResponseData resp = keyxData.keyResponseData;
final KeyRequestData fakeReq = new FakeKeyRequestData();
factory.getCryptoContext(pskCtx, fakeReq, resp, null);
}
@Test(expected = MslInternalException.class)
public void wrongResponseCryptoContext() throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslMasterTokenException, MslEntityAuthException {
final KeyRequestData req = new RequestData(Mechanism.PSK, null);
final KeyResponseData fakeResp = new FakeKeyResponseData();
factory.getCryptoContext(pskCtx, req, fakeResp, null);
}
@Test
public void pskUnsupportedCryptoContext() throws MslKeyExchangeException, MslEntityAuthException, MslException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.UNSUPPORTED_KEYX_MECHANISM);
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
final KeyRequestData req = new RequestData(Mechanism.PSK, null);
final KeyExchangeData keyxData = factory.generateResponse(ctx, ENCODER_FORMAT, req, entityAuthData);
final KeyResponseData resp = keyxData.keyResponseData;
ctx.removeEntityAuthenticationFactory(EntityAuthenticationScheme.PSK);
factory.getCryptoContext(ctx, req, resp, null);
}
@Test
public void wrapKeyMissingCryptoContext() throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslEntityAuthException, MslException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.KEYX_WRAPPING_KEY_MISSING);
final KeyRequestData req = new RequestData(Mechanism.WRAP, WRAPDATA);
final KeyExchangeData keyxData = factory.generateResponse(pskCtx, ENCODER_FORMAT, req, entityAuthData);
final KeyResponseData resp = keyxData.keyResponseData;
factory.getCryptoContext(pskCtx, req, resp, null);
}
@Test
public void invalidWrapJwkCryptoContext() throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslEntityAuthException, MslException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.INVALID_JWK);
final byte[] data = new byte[16];
random.nextBytes(data);
final byte[] wrapJwk = WRAP_CRYPTO_CONTEXT.wrap(data, encoder, ENCODER_FORMAT);
final KeyRequestData req = new RequestData(Mechanism.WRAP, WRAPDATA);
final KeyResponseData invalidResp = new ResponseData(PSK_MASTER_TOKEN, wrapJwk, WRAPDATA, PSK_ENCRYPTION_JWK, PSK_HMAC_JWK);
repository.addCryptoContext(WRAPDATA, WRAP_CRYPTO_CONTEXT);
factory.getCryptoContext(pskCtx, req, invalidResp, null);
}
@Test
public void invalidEncryptionJwkCryptoContext() throws MslException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.INVALID_JWK);
final KeyRequestData req = new RequestData(Mechanism.WRAP, WRAPDATA);
final KeyExchangeData keyxData = factory.generateResponse(pskCtx, ENCODER_FORMAT, req, entityAuthData);
final ResponseData resp = (ResponseData)keyxData.keyResponseData;
// First get the new crypto context. This installs the returned
// wrapping key in the repository.
repository.addCryptoContext(WRAPDATA, WRAP_CRYPTO_CONTEXT);
assertArrayEquals(WRAPDATA, repository.getWrapdata());
factory.getCryptoContext(pskCtx, req, resp, null);
assertFalse(Arrays.equals(WRAPDATA, repository.getWrapdata()));
// Now make the invalid response.
final byte[] data = new byte[16];
random.nextBytes(data);
final ICryptoContext wrapCryptoContext = repository.getCryptoContext(repository.getWrapdata());
final byte[] encryptionJwk = wrapCryptoContext.wrap(data, encoder, ENCODER_FORMAT);
// Extract values from the response.
final MasterToken masterToken = resp.getMasterToken();
final byte[] wrapJwk = resp.getWrapKey();
final byte[] wrapdata = resp.getWrapdata();
final byte[] hmacJwk = resp.getHmacKey();
final KeyResponseData invalidResp = new ResponseData(masterToken, wrapJwk, wrapdata, encryptionJwk, hmacJwk);
// Reinstall the previous wrap crypto context.
repository.addCryptoContext(WRAPDATA, WRAP_CRYPTO_CONTEXT);
assertArrayEquals(WRAPDATA, repository.getWrapdata());
factory.getCryptoContext(pskCtx, req, invalidResp, null);
}
@Test
public void invalidHmacJwkCryptoContext() throws MslException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.INVALID_JWK);
final KeyRequestData req = new RequestData(Mechanism.WRAP, WRAPDATA);
final KeyExchangeData keyxData = factory.generateResponse(pskCtx, ENCODER_FORMAT, req, entityAuthData);
final ResponseData resp = (ResponseData)keyxData.keyResponseData;
// First get the new crypto context. This installs the returned
// wrapping key in the repository.
repository.addCryptoContext(WRAPDATA, WRAP_CRYPTO_CONTEXT);
assertArrayEquals(WRAPDATA, repository.getWrapdata());
factory.getCryptoContext(pskCtx, req, resp, null);
assertFalse(Arrays.equals(WRAPDATA, repository.getWrapdata()));
// Now make the invalid response.
final byte[] data = new byte[16];
random.nextBytes(data);
final ICryptoContext wrapCryptoContext = repository.getCryptoContext(repository.getWrapdata());
final byte[] hmacJwk = wrapCryptoContext.wrap(data, encoder, ENCODER_FORMAT);
// Extract values from the response.
final MasterToken masterToken = resp.getMasterToken();
final byte[] wrapJwk = resp.getWrapKey();
final byte[] wrapdata = resp.getWrapdata();
final byte[] encryptionJwk = resp.getEncryptionKey();
final KeyResponseData invalidResp = new ResponseData(masterToken, wrapJwk, wrapdata, encryptionJwk, hmacJwk);
// Reinstall the previous wrap crypto context.
repository.addCryptoContext(WRAPDATA, WRAP_CRYPTO_CONTEXT);
assertArrayEquals(WRAPDATA, repository.getWrapdata());
factory.getCryptoContext(pskCtx, req, invalidResp, null);
}
}
}
| 9,959 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/keyx/DiffieHellmanExchangeSuite.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.keyx;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.math.BigInteger;
import java.security.InvalidAlgorithmParameterException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Random;
import javax.crypto.interfaces.DHPrivateKey;
import javax.crypto.interfaces.DHPublicKey;
import javax.crypto.spec.DHParameterSpec;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.MslKeyExchangeException;
import com.netflix.msl.MslMasterTokenException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.entityauth.EntityAuthenticationData;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.entityauth.MockPresharedAuthenticationFactory;
import com.netflix.msl.entityauth.PresharedAuthenticationData;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.keyx.DiffieHellmanExchange.RequestData;
import com.netflix.msl.keyx.DiffieHellmanExchange.ResponseData;
import com.netflix.msl.keyx.KeyExchangeFactory.KeyExchangeData;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.tokens.MasterToken;
import com.netflix.msl.util.MockAuthenticationUtils;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* Diffie-Hellman key exchange unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
@RunWith(Suite.class)
@SuiteClasses({DiffieHellmanExchangeSuite.KeyExchangeFactoryTest.class,
DiffieHellmanExchangeSuite.RequestDataTest.class,
DiffieHellmanExchangeSuite.ResponseDataTest.class})
public class DiffieHellmanExchangeSuite {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key key exchange scheme. */
private static final String KEY_SCHEME = "scheme";
/** Key key request data. */
private static final String KEY_KEYDATA = "keydata";
/** Key Diffie-Hellman parameters ID. */
private static final String KEY_PARAMETERS_ID = "parametersid";
/** Key Diffie-Hellman public key. */
private static final String KEY_PUBLIC_KEY = "publickey";
/**
* If the provided byte array begins with a null byte this function simply
* returns the original array. Otherwise a new array is created that is a
* copy of the original array with a null byte prepended, and this new array
* is returned.
*
* @param b the original array.
* @return the resulting byte array.
*/
private static byte[] prependNullByte(final byte[] b) {
if (b[0] == 0x00)
return b;
final byte[] result = new byte[b.length + 1];
result[0] = 0x00;
System.arraycopy(b, 0, result, 1, b.length);
return result;
}
private static MasterToken MASTER_TOKEN;
private static final String PARAMETERS_ID = MockDiffieHellmanParameters.DEFAULT_ID;
private static BigInteger REQUEST_PUBLIC_KEY;
private static DHPrivateKey REQUEST_PRIVATE_KEY;
private static BigInteger RESPONSE_PUBLIC_KEY;
private static DHPrivateKey RESPONSE_PRIVATE_KEY;
/** Random. */
private static Random random;
/** MSL context. */
private static MslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
@BeforeClass
public static synchronized void setup() throws NoSuchAlgorithmException, InvalidAlgorithmParameterException, MslEncodingException, MslCryptoException, MslKeyExchangeException {
if (ctx == null) {
random = new Random();
ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = ctx.getMslEncoderFactory();
MASTER_TOKEN = MslTestUtils.getMasterToken(ctx, 1, 1);
final DiffieHellmanParameters params = MockDiffieHellmanParameters.getDefaultParameters();
final DHParameterSpec paramSpec = params.getParameterSpec(PARAMETERS_ID);
final KeyPairGenerator generator = KeyPairGenerator.getInstance("DH");
generator.initialize(paramSpec);
final KeyPair requestKeyPair = generator.generateKeyPair();
REQUEST_PUBLIC_KEY = ((DHPublicKey)requestKeyPair.getPublic()).getY();
REQUEST_PRIVATE_KEY = (DHPrivateKey)requestKeyPair.getPrivate();
generator.initialize(paramSpec);
final KeyPair responseKeyPair = generator.generateKeyPair();
RESPONSE_PUBLIC_KEY = ((DHPublicKey)responseKeyPair.getPublic()).getY();
RESPONSE_PRIVATE_KEY = (DHPrivateKey)responseKeyPair.getPrivate();
}
}
@AfterClass
public static synchronized void teardown() {
// Teardown causes problems because the data is shared by the inner
// classes, so don't do any cleanup.
}
/** Request data unit tests. */
public static class RequestDataTest {
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@Test
public void ctors() throws MslException, MslEncodingException, MslKeyExchangeException, MslEncoderException {
final RequestData req = new RequestData(PARAMETERS_ID, REQUEST_PUBLIC_KEY, REQUEST_PRIVATE_KEY);
assertEquals(KeyExchangeScheme.DIFFIE_HELLMAN, req.getKeyExchangeScheme());
assertEquals(PARAMETERS_ID, req.getParametersId());
assertArrayEquals(REQUEST_PRIVATE_KEY.getEncoded(), req.getPrivateKey().getEncoded());
assertEquals(REQUEST_PUBLIC_KEY, req.getPublicKey());
final MslObject keydata = req.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata);
final RequestData moReq = new RequestData(keydata);
assertEquals(req.getKeyExchangeScheme(), moReq.getKeyExchangeScheme());
assertEquals(req.getParametersId(), moReq.getParametersId());
assertNull(moReq.getPrivateKey());
assertEquals(req.getPublicKey(), moReq.getPublicKey());
final MslObject moKeydata = moReq.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(moKeydata);
assertTrue(MslEncoderUtils.equalObjects(keydata, moKeydata));
}
@Test
public void mslObject() throws MslException, MslEncoderException {
final RequestData req = new RequestData(PARAMETERS_ID, REQUEST_PUBLIC_KEY, REQUEST_PRIVATE_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, req);
assertEquals(KeyExchangeScheme.DIFFIE_HELLMAN.toString(), mo.getString(KEY_SCHEME));
final MslObject keydata = mo.getMslObject(KEY_KEYDATA, encoder);
assertEquals(PARAMETERS_ID, keydata.getString(KEY_PARAMETERS_ID));
assertArrayEquals(prependNullByte(REQUEST_PUBLIC_KEY.toByteArray()), keydata.getBytes(KEY_PUBLIC_KEY));
}
@Test
public void create() throws MslException, MslEncodingException, MslEntityAuthException, MslCryptoException, MslKeyExchangeException, MslEncoderException {
final RequestData data = new RequestData(PARAMETERS_ID, REQUEST_PUBLIC_KEY, REQUEST_PRIVATE_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, data);
final KeyRequestData keyRequestData = KeyRequestData.create(ctx, mo);
assertNotNull(keyRequestData);
assertTrue(keyRequestData instanceof RequestData);
final RequestData moData = (RequestData)keyRequestData;
assertEquals(data.getKeyExchangeScheme(), moData.getKeyExchangeScheme());
assertEquals(data.getParametersId(), moData.getParametersId());
assertNull(moData.getPrivateKey());
assertEquals(data.getPublicKey(), moData.getPublicKey());
}
@Test
public void missingParametersId() throws MslException, MslEncodingException, MslKeyExchangeException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final RequestData req = new RequestData(PARAMETERS_ID, REQUEST_PUBLIC_KEY, REQUEST_PRIVATE_KEY);
final MslObject keydata = req.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata.remove(KEY_PARAMETERS_ID));
new RequestData(keydata);
}
@Test
public void missingPublicKey() throws MslException, MslEncodingException, MslKeyExchangeException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final RequestData req = new RequestData(PARAMETERS_ID, REQUEST_PUBLIC_KEY, REQUEST_PRIVATE_KEY);
final MslObject keydata = req.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata.remove(KEY_PUBLIC_KEY));
new RequestData(keydata);
}
@Test
public void invalidPublicKey() throws MslException, MslEncodingException, MslKeyExchangeException, MslEncoderException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.KEYX_INVALID_PUBLIC_KEY);
final RequestData req = new RequestData(PARAMETERS_ID, REQUEST_PUBLIC_KEY, REQUEST_PRIVATE_KEY);
final MslObject keydata = req.getKeydata(encoder, ENCODER_FORMAT);
keydata.put(KEY_PUBLIC_KEY, new byte[0]);
new RequestData(keydata);
}
@Test
public void equalsParametersId() throws MslEncodingException, MslKeyExchangeException, MslException, MslEncoderException {
final RequestData dataA = new RequestData(PARAMETERS_ID + "A", REQUEST_PUBLIC_KEY, REQUEST_PRIVATE_KEY);
final RequestData dataB = new RequestData(PARAMETERS_ID + "B", REQUEST_PUBLIC_KEY, REQUEST_PRIVATE_KEY);
final RequestData dataA2 = new RequestData(dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
// The private keys don't transfer via the JSON constructor.
assertFalse(dataA.equals(dataA2));
assertFalse(dataA2.equals(dataA));
assertTrue(dataA.hashCode() != dataA2.hashCode());
}
@Test
public void equalsPublicKey() throws MslEncodingException, MslKeyExchangeException, MslException, MslEncoderException {
final RequestData dataA = new RequestData(PARAMETERS_ID, REQUEST_PUBLIC_KEY, REQUEST_PRIVATE_KEY);
final RequestData dataB = new RequestData(PARAMETERS_ID, RESPONSE_PUBLIC_KEY, REQUEST_PRIVATE_KEY);
final RequestData dataA2 = new RequestData(dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
// The private keys don't transfer via the JSON constructor.
assertFalse(dataA.equals(dataA2));
assertFalse(dataA2.equals(dataA));
assertTrue(dataA.hashCode() != dataA2.hashCode());
}
@Test
public void equalsPrivateKey() throws MslEncodingException, MslKeyExchangeException, MslException, MslEncoderException {
final RequestData dataA = new RequestData(PARAMETERS_ID, REQUEST_PUBLIC_KEY, REQUEST_PRIVATE_KEY);
final RequestData dataB = new RequestData(PARAMETERS_ID, REQUEST_PUBLIC_KEY, RESPONSE_PRIVATE_KEY);
final RequestData dataA2 = new RequestData(dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
// The private keys don't transfer via the JSON constructor.
assertFalse(dataA.equals(dataA2));
assertFalse(dataA2.equals(dataA));
assertTrue(dataA.hashCode() != dataA2.hashCode());
}
@Test
public void equalsObject() {
final RequestData data = new RequestData(PARAMETERS_ID, REQUEST_PUBLIC_KEY, REQUEST_PRIVATE_KEY);
assertFalse(data.equals(null));
assertFalse(data.equals(PARAMETERS_ID));
assertTrue(data.hashCode() != PARAMETERS_ID.hashCode());
}
}
/** Response data unit tests. */
public static class ResponseDataTest {
/** Key master token. */
private static final String KEY_MASTER_TOKEN = "mastertoken";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@Test
public void ctors() throws MslException, MslEncodingException, MslKeyExchangeException, MslEncoderException {
final ResponseData resp = new ResponseData(MASTER_TOKEN, PARAMETERS_ID, RESPONSE_PUBLIC_KEY);
assertEquals(KeyExchangeScheme.DIFFIE_HELLMAN, resp.getKeyExchangeScheme());
assertEquals(PARAMETERS_ID, resp.getParametersId());
assertEquals(RESPONSE_PUBLIC_KEY, resp.getPublicKey());
final MslObject keydata = resp.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata);
final ResponseData moResp = new ResponseData(MASTER_TOKEN, keydata);
assertEquals(resp.getKeyExchangeScheme(), moResp.getKeyExchangeScheme());
assertEquals(resp.getMasterToken(), moResp.getMasterToken());
assertEquals(resp.getParametersId(), moResp.getParametersId());
assertEquals(resp.getPublicKey(), moResp.getPublicKey());
final MslObject moKeydata = moResp.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(moKeydata);
assertTrue(MslEncoderUtils.equalObjects(keydata, moKeydata));
}
@Test
public void mslObject() throws MslException, MslEncodingException, MslCryptoException, MslException, MslEncoderException {
final ResponseData resp = new ResponseData(MASTER_TOKEN, PARAMETERS_ID, RESPONSE_PUBLIC_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, resp);
assertEquals(KeyExchangeScheme.DIFFIE_HELLMAN.toString(), mo.getString(KEY_SCHEME));
final MasterToken masterToken = new MasterToken(ctx, mo.getMslObject(KEY_MASTER_TOKEN, encoder));
assertEquals(MASTER_TOKEN, masterToken);
final MslObject keydata = mo.getMslObject(KEY_KEYDATA, encoder);
assertEquals(PARAMETERS_ID, keydata.getString(KEY_PARAMETERS_ID));
assertArrayEquals(prependNullByte(RESPONSE_PUBLIC_KEY.toByteArray()), keydata.getBytes(KEY_PUBLIC_KEY));
}
@Test
public void create() throws MslException, MslException, MslEncoderException {
final ResponseData data = new ResponseData(MASTER_TOKEN, PARAMETERS_ID, RESPONSE_PUBLIC_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, data);
final KeyResponseData keyResponseData = KeyResponseData.create(ctx, mo);
assertNotNull(keyResponseData);
assertTrue(keyResponseData instanceof ResponseData);
final ResponseData moData = (ResponseData)keyResponseData;
assertEquals(data.getKeyExchangeScheme(), moData.getKeyExchangeScheme());
assertEquals(data.getMasterToken(), moData.getMasterToken());
assertEquals(data.getParametersId(), moData.getParametersId());
assertEquals(data.getPublicKey(), moData.getPublicKey());
}
@Test
public void missingParametersId() throws MslException, MslEncodingException, MslKeyExchangeException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ResponseData resp = new ResponseData(MASTER_TOKEN, PARAMETERS_ID, RESPONSE_PUBLIC_KEY);
final MslObject keydata = resp.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata.remove(KEY_PARAMETERS_ID));
new ResponseData(MASTER_TOKEN, keydata);
}
@Test
public void missingPublicKey() throws MslException, MslEncodingException, MslKeyExchangeException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ResponseData resp = new ResponseData(MASTER_TOKEN, PARAMETERS_ID, RESPONSE_PUBLIC_KEY);
final MslObject keydata = resp.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata.remove(KEY_PUBLIC_KEY));
new ResponseData(MASTER_TOKEN, keydata);
}
@Test
public void invalidPublicKey() throws MslException, MslEncodingException, MslKeyExchangeException, MslEncoderException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.KEYX_INVALID_PUBLIC_KEY);
final ResponseData resp = new ResponseData(MASTER_TOKEN, PARAMETERS_ID, RESPONSE_PUBLIC_KEY);
final MslObject keydata = resp.getKeydata(encoder, ENCODER_FORMAT);
keydata.put(KEY_PUBLIC_KEY, new byte[0]);
new ResponseData(MASTER_TOKEN, keydata);
}
@Test
public void equalsMasterToken() throws MslEncodingException, MslKeyExchangeException, MslException, MslCryptoException, MslEncoderException {
final MasterToken masterTokenA = MslTestUtils.getMasterToken(ctx, 1, 1);
final MasterToken masterTokenB = MslTestUtils.getMasterToken(ctx, 1, 2);
final ResponseData dataA = new ResponseData(masterTokenA, PARAMETERS_ID, RESPONSE_PUBLIC_KEY);
final ResponseData dataB = new ResponseData(masterTokenB, PARAMETERS_ID, RESPONSE_PUBLIC_KEY);
final ResponseData dataA2 = new ResponseData(masterTokenA, dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsParametersId() throws MslEncodingException, MslKeyExchangeException, MslException, MslEncoderException {
final ResponseData dataA = new ResponseData(MASTER_TOKEN, PARAMETERS_ID + "A", RESPONSE_PUBLIC_KEY);
final ResponseData dataB = new ResponseData(MASTER_TOKEN, PARAMETERS_ID + "B", RESPONSE_PUBLIC_KEY);
final ResponseData dataA2 = new ResponseData(MASTER_TOKEN, dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsPublicKey() throws MslEncodingException, MslKeyExchangeException, MslException, MslEncoderException {
final ResponseData dataA = new ResponseData(MASTER_TOKEN, PARAMETERS_ID, RESPONSE_PUBLIC_KEY);
final ResponseData dataB = new ResponseData(MASTER_TOKEN, PARAMETERS_ID, REQUEST_PUBLIC_KEY);
final ResponseData dataA2 = new ResponseData(MASTER_TOKEN, dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsObject() {
final ResponseData data = new ResponseData(MASTER_TOKEN, PARAMETERS_ID, RESPONSE_PUBLIC_KEY);
assertFalse(data.equals(null));
assertFalse(data.equals(PARAMETERS_ID));
assertTrue(data.hashCode() != PARAMETERS_ID.hashCode());
}
}
/** Key exchange factory unit tests. */
public static class KeyExchangeFactoryTest {
/**
* Fake key request data for the Diffie-Hellman key exchange scheme.
*/
private static class FakeKeyRequestData extends KeyRequestData {
/** Create a new fake key request data. */
protected FakeKeyRequestData() {
super(KeyExchangeScheme.DIFFIE_HELLMAN);
}
/* (non-Javadoc)
* @see com.netflix.msl.keyx.KeyRequestData#getKeydata(com.netflix.msl.io.MslEncoderFactory, com.netflix.msl.io.MslEncoderFormat)
*/
@Override
protected MslObject getKeydata(final MslEncoderFactory encoder, final MslEncoderFormat format) throws MslEncoderException {
return null;
}
}
/**
* Fake key response data for the Diffie-Hellman key exchange scheme.
*/
private static class FakeKeyResponseData extends KeyResponseData {
/** Create a new fake key response data. */
protected FakeKeyResponseData() {
super(MASTER_TOKEN, KeyExchangeScheme.DIFFIE_HELLMAN);
}
/* (non-Javadoc)
* @see com.netflix.msl.keyx.KeyResponseData#getKeydata(com.netflix.msl.io.MslEncoderFactory, com.netflix.msl.io.MslEncoderFormat)
*/
@Override
protected MslObject getKeydata(final MslEncoderFactory encoder, final MslEncoderFormat format) throws MslEncoderException {
return null;
}
}
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@BeforeClass
public static void setup() {
authutils = new MockAuthenticationUtils();
final DiffieHellmanParameters params = MockDiffieHellmanParameters.getDefaultParameters();
factory = new DiffieHellmanExchange(params, authutils);
entityAuthData = new PresharedAuthenticationData(MockPresharedAuthenticationFactory.PSK_ESN);
}
@AfterClass
public static void teardown() {
entityAuthData = null;
factory = null;
authutils = null;
}
@Before
public void reset() {
authutils.reset();
ctx.getMslStore().clearCryptoContexts();
ctx.getMslStore().clearServiceTokens();
}
@Test
public void factory() {
assertEquals(KeyExchangeScheme.DIFFIE_HELLMAN, factory.getScheme());
}
@Test
public void generateInitialResponse() throws MslException {
final KeyRequestData keyRequestData = new RequestData(PARAMETERS_ID, REQUEST_PUBLIC_KEY, REQUEST_PRIVATE_KEY);
final KeyExchangeData keyxData = factory.generateResponse(ctx, ENCODER_FORMAT, keyRequestData, entityAuthData);
assertNotNull(keyxData);
assertNotNull(keyxData.cryptoContext);
assertNotNull(keyxData.keyResponseData);
final KeyResponseData keyResponseData = keyxData.keyResponseData;
assertEquals(KeyExchangeScheme.DIFFIE_HELLMAN, keyResponseData.getKeyExchangeScheme());
final MasterToken masterToken = keyResponseData.getMasterToken();
assertNotNull(masterToken);
assertEquals(MockPresharedAuthenticationFactory.PSK_ESN, masterToken.getIdentity());
}
@Test(expected = MslInternalException.class)
public void wrongRequestInitialResponse() throws MslException {
final KeyRequestData keyRequestData = new FakeKeyRequestData();
factory.generateResponse(ctx, ENCODER_FORMAT, keyRequestData, entityAuthData);
}
@Test
public void invalidParametersIdInitialResponse() throws MslException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.UNKNOWN_KEYX_PARAMETERS_ID);
final KeyRequestData keyRequestData = new RequestData("x", REQUEST_PUBLIC_KEY, REQUEST_PRIVATE_KEY);
factory.generateResponse(ctx, ENCODER_FORMAT, keyRequestData, entityAuthData);
}
@Test
public void unknownParametersIdInitialResponse() throws MslException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.UNKNOWN_KEYX_PARAMETERS_ID);
final KeyRequestData keyRequestData = new RequestData(Integer.toString(98765), REQUEST_PUBLIC_KEY, REQUEST_PRIVATE_KEY);
factory.generateResponse(ctx, ENCODER_FORMAT, keyRequestData, entityAuthData);
}
@Test
public void generateSubsequentResponse() throws MslException {
final KeyRequestData keyRequestData = new RequestData(PARAMETERS_ID, REQUEST_PUBLIC_KEY, REQUEST_PRIVATE_KEY);
final KeyExchangeData keyxData = factory.generateResponse(ctx, ENCODER_FORMAT, keyRequestData, MASTER_TOKEN);
assertNotNull(keyxData);
assertNotNull(keyxData.cryptoContext);
assertNotNull(keyxData.keyResponseData);
final KeyResponseData keyResponseData = keyxData.keyResponseData;
assertEquals(KeyExchangeScheme.DIFFIE_HELLMAN, keyResponseData.getKeyExchangeScheme());
final MasterToken masterToken = keyResponseData.getMasterToken();
assertNotNull(masterToken);
assertEquals(MASTER_TOKEN.getIdentity(), masterToken.getIdentity());
assertEquals(MASTER_TOKEN.getSerialNumber(), masterToken.getSerialNumber());
assertEquals(MASTER_TOKEN.getSequenceNumber() + 1, masterToken.getSequenceNumber());
}
@Test
public void untrustedMasterTokenSubsequentResponse() throws MslEncodingException, MslCryptoException, MslException, MslException, MslEncoderException {
thrown.expect(MslMasterTokenException.class);
thrown.expectMslError(MslError.MASTERTOKEN_UNTRUSTED);
final KeyRequestData keyRequestData = new RequestData(PARAMETERS_ID, REQUEST_PUBLIC_KEY, REQUEST_PRIVATE_KEY);
final MasterToken masterToken = MslTestUtils.getUntrustedMasterToken(ctx);
factory.generateResponse(ctx, ENCODER_FORMAT, keyRequestData, masterToken);
}
@Test(expected = MslInternalException.class)
public void wrongRequestSubsequentResponse() throws MslException {
final KeyRequestData keyRequestData = new FakeKeyRequestData();
factory.generateResponse(ctx, ENCODER_FORMAT, keyRequestData, MASTER_TOKEN);
}
@Test
public void invalidParametersIdSubsequentResponse() throws MslException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.UNKNOWN_KEYX_PARAMETERS_ID);
final KeyRequestData keyRequestData = new RequestData("x", REQUEST_PUBLIC_KEY, REQUEST_PRIVATE_KEY);
factory.generateResponse(ctx, ENCODER_FORMAT, keyRequestData, MASTER_TOKEN);
}
@Test
public void unknownParametersIdSubsequentResponse() throws MslException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.UNKNOWN_KEYX_PARAMETERS_ID);
final KeyRequestData keyRequestData = new RequestData(Integer.toString(98765), REQUEST_PUBLIC_KEY, REQUEST_PRIVATE_KEY);
factory.generateResponse(ctx, ENCODER_FORMAT, keyRequestData, MASTER_TOKEN);
}
@Test
public void getCryptoContext() throws MslException {
final KeyRequestData keyRequestData = new RequestData(PARAMETERS_ID, REQUEST_PUBLIC_KEY, REQUEST_PRIVATE_KEY);
final KeyExchangeData keyxData = factory.generateResponse(ctx, ENCODER_FORMAT, keyRequestData, entityAuthData);
final ICryptoContext requestCryptoContext = keyxData.cryptoContext;
final KeyResponseData keyResponseData = keyxData.keyResponseData;
final ICryptoContext responseCryptoContext = factory.getCryptoContext(ctx, keyRequestData, keyResponseData, null);
assertNotNull(responseCryptoContext);
final byte[] data = new byte[32];
random.nextBytes(data);
// Ciphertext won't always be equal depending on how it was
// enveloped. So we cannot check for equality or inequality.
final byte[] requestCiphertext = requestCryptoContext.encrypt(data, encoder, ENCODER_FORMAT);
final byte[] responseCiphertext = responseCryptoContext.encrypt(data, encoder, ENCODER_FORMAT);
assertFalse(Arrays.equals(data, requestCiphertext));
assertFalse(Arrays.equals(data, responseCiphertext));
// Signatures should always be equal.
final byte[] requestSignature = requestCryptoContext.sign(data, encoder, ENCODER_FORMAT);
final byte[] responseSignature = responseCryptoContext.sign(data, encoder, ENCODER_FORMAT);
assertFalse(Arrays.equals(data, requestSignature));
assertFalse(Arrays.equals(data, responseSignature));
assertArrayEquals(requestSignature, responseSignature);
// Plaintext should always be equal to the original message.
final byte[] requestPlaintext = requestCryptoContext.decrypt(responseCiphertext, encoder);
final byte[] responsePlaintext = responseCryptoContext.decrypt(requestCiphertext, encoder);
assertNotNull(requestPlaintext);
assertArrayEquals(data, requestPlaintext);
assertArrayEquals(requestPlaintext, responsePlaintext);
// Verification should always succeed.
assertTrue(requestCryptoContext.verify(data, responseSignature, encoder));
assertTrue(responseCryptoContext.verify(data, requestSignature, encoder));
}
@Test(expected = MslInternalException.class)
public void wrongRequestCryptoContext() throws MslException {
final KeyRequestData keyRequestData = new RequestData(PARAMETERS_ID, REQUEST_PUBLIC_KEY, REQUEST_PRIVATE_KEY);
final KeyExchangeData keyxData = factory.generateResponse(ctx, ENCODER_FORMAT, keyRequestData, entityAuthData);
final KeyResponseData keyResponseData = keyxData.keyResponseData;
final KeyRequestData fakeKeyRequestData = new FakeKeyRequestData();
factory.getCryptoContext(ctx, fakeKeyRequestData, keyResponseData, null);
}
@Test(expected = MslInternalException.class)
public void wrongResponseCryptoContext() throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslMasterTokenException, MslEntityAuthException {
final KeyRequestData keyRequestData = new RequestData(PARAMETERS_ID, REQUEST_PUBLIC_KEY, REQUEST_PRIVATE_KEY);
final KeyResponseData fakeKeyResponseData = new FakeKeyResponseData();
factory.getCryptoContext(ctx, keyRequestData, fakeKeyResponseData, null);
}
@Test
public void parametersIdMismatchCryptoContext() throws MslException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.KEYX_RESPONSE_REQUEST_MISMATCH);
final KeyRequestData keyRequestData = new RequestData(PARAMETERS_ID, REQUEST_PUBLIC_KEY, REQUEST_PRIVATE_KEY);
final KeyExchangeData keyxData = factory.generateResponse(ctx, ENCODER_FORMAT, keyRequestData, entityAuthData);
final KeyResponseData keyResponseData = keyxData.keyResponseData;
final MasterToken masterToken = keyResponseData.getMasterToken();
final KeyResponseData mismatchedKeyResponseData = new ResponseData(masterToken, PARAMETERS_ID + "x", RESPONSE_PUBLIC_KEY);
factory.getCryptoContext(ctx, keyRequestData, mismatchedKeyResponseData, null);
}
@Test
public void privateKeyMissingCryptoContext() throws MslException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.KEYX_PRIVATE_KEY_MISSING);
final KeyRequestData keyRequestData = new RequestData(PARAMETERS_ID, REQUEST_PUBLIC_KEY, null);
final KeyExchangeData keyxData = factory.generateResponse(ctx, ENCODER_FORMAT, keyRequestData, entityAuthData);
final KeyResponseData keyResponseData = keyxData.keyResponseData;
factory.getCryptoContext(ctx, keyRequestData, keyResponseData, null);
}
/** Authentication utilities. */
private static MockAuthenticationUtils authutils;
/** Key exchange factory. */
private static KeyExchangeFactory factory;
/** Entity authentication data. */
private static EntityAuthenticationData entityAuthData;
}
}
| 9,960 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/keyx/JsonWebEncryptionLadderExchangeSuite.java | /**
* Copyright (c) 2013-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.keyx;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.security.NoSuchAlgorithmException;
import java.security.Security;
import java.util.Arrays;
import java.util.Random;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.MslKeyExchangeException;
import com.netflix.msl.MslMasterTokenException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.crypto.JcaAlgorithm;
import com.netflix.msl.crypto.JsonWebEncryptionCryptoContext;
import com.netflix.msl.crypto.JsonWebEncryptionCryptoContext.AesKwCryptoContext;
import com.netflix.msl.crypto.JsonWebEncryptionCryptoContext.CekCryptoContext;
import com.netflix.msl.crypto.JsonWebEncryptionCryptoContext.Encryption;
import com.netflix.msl.crypto.JsonWebEncryptionCryptoContext.Format;
import com.netflix.msl.crypto.JsonWebKey;
import com.netflix.msl.crypto.JsonWebKey.Algorithm;
import com.netflix.msl.crypto.JsonWebKey.Usage;
import com.netflix.msl.entityauth.EntityAuthenticationData;
import com.netflix.msl.entityauth.EntityAuthenticationFactory;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.entityauth.MockPresharedAuthenticationFactory;
import com.netflix.msl.entityauth.PresharedAuthenticationData;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.keyx.JsonWebEncryptionLadderExchange.Mechanism;
import com.netflix.msl.keyx.JsonWebEncryptionLadderExchange.RequestData;
import com.netflix.msl.keyx.JsonWebEncryptionLadderExchange.ResponseData;
import com.netflix.msl.keyx.KeyExchangeFactory.KeyExchangeData;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.tokens.MasterToken;
import com.netflix.msl.util.AuthenticationUtils;
import com.netflix.msl.util.MockAuthenticationUtils;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* JSON Web Encryption ladder exchange unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
@RunWith(Suite.class)
@SuiteClasses({JsonWebEncryptionLadderExchangeSuite.KeyExchangeFactoryTest.class,
JsonWebEncryptionLadderExchangeSuite.RequestDataTest.class,
JsonWebEncryptionLadderExchangeSuite.ResponseDataTest.class})
public class JsonWebEncryptionLadderExchangeSuite {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key key exchange scheme. */
private static final String KEY_SCHEME = "scheme";
/** Key key request data. */
private static final String KEY_KEYDATA = "keydata";
private static ICryptoContext PSK_CRYPTO_CONTEXT, WRAP_CRYPTO_CONTEXT;
private static byte[] WRAP_JWK;
private static byte[] WRAPDATA;
private static final String PSK_IDENTITY = MockPresharedAuthenticationFactory.PSK_ESN;
private static MasterToken PSK_MASTER_TOKEN;
private static byte[] PSK_ENCRYPTION_JWK;
private static byte[] PSK_HMAC_JWK;
@BeforeClass
public static synchronized void setup() throws MslEncodingException, MslCryptoException, NoSuchAlgorithmException, MslEntityAuthException {
if (pskCtx == null) {
Security.addProvider(new BouncyCastleProvider());
pskCtx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = pskCtx.getMslEncoderFactory();
// Create PSK wrapping crypto context.
{
final EntityAuthenticationData entityAuthData = pskCtx.getEntityAuthenticationData(null);
final EntityAuthenticationFactory entityAuthFactory = pskCtx.getEntityAuthenticationFactory(entityAuthData.getScheme());
final ICryptoContext pskCryptoContext = entityAuthFactory.getCryptoContext(pskCtx, entityAuthData);
final CekCryptoContext wrapCekCryptoContext = new AesKwCryptoContext(pskCryptoContext);
PSK_CRYPTO_CONTEXT = new JsonWebEncryptionCryptoContext(pskCtx, wrapCekCryptoContext, Encryption.A128GCM, Format.JWE_JS);
}
// The wrap key is the new wrapping key wrapped by the specified
// wrapping key (e.g. PSK or RSA) inside a JWK. Technically we
// shouldn't know this but that's the only way to verify things.
//
// Create the new wrapping key and wrap crypto context.
final byte[] wrappingKey = new byte[16];
pskCtx.getRandom().nextBytes(wrappingKey);
final SecretKey wrapKey = new SecretKeySpec(wrappingKey, JcaAlgorithm.AESKW);
final CekCryptoContext cekCryptoContext = new AesKwCryptoContext(wrapKey);
WRAP_CRYPTO_CONTEXT = new JsonWebEncryptionCryptoContext(pskCtx, cekCryptoContext, Encryption.A128GCM, Format.JWE_JS);
//
// Wrap the new wrapping key using a PSK wrap crypto context.
final JsonWebKey wrapJwk = new JsonWebKey(Usage.wrap, Algorithm.A128KW, false, null, wrapKey);
WRAP_JWK = PSK_CRYPTO_CONTEXT.wrap(wrapJwk.toMslEncoding(encoder, ENCODER_FORMAT), encoder, ENCODER_FORMAT);
// The wrap data is an AES-128 key wrapped by the primary MSL
// context. Technically we shouldn't know this but that's the only
// way to verify things.
WRAPDATA = pskCtx.getMslCryptoContext().wrap(wrappingKey, encoder, ENCODER_FORMAT);
final WrapCryptoContextRepository repository = new MockCryptoContextRepository();
final AuthenticationUtils authutils = new MockAuthenticationUtils();
final KeyExchangeFactory keyxFactory = new JsonWebEncryptionLadderExchange(repository, authutils);
pskCtx.addKeyExchangeFactory(keyxFactory);
PSK_MASTER_TOKEN = MslTestUtils.getMasterToken(pskCtx, 1, 1);
final SecretKey pskEncryptionKey = PSK_MASTER_TOKEN.getEncryptionKey();
final JsonWebKey pskEncryptionJwk = new JsonWebKey(Usage.enc, Algorithm.A128CBC, false, null, pskEncryptionKey);
PSK_ENCRYPTION_JWK = WRAP_CRYPTO_CONTEXT.wrap(pskEncryptionJwk.toMslEncoding(encoder, ENCODER_FORMAT), encoder, ENCODER_FORMAT);
final SecretKey pskHmacKey = PSK_MASTER_TOKEN.getSignatureKey();
final JsonWebKey pskHmacJwk = new JsonWebKey(Usage.sig, Algorithm.HS256, false, null, pskHmacKey);
PSK_HMAC_JWK = WRAP_CRYPTO_CONTEXT.wrap(pskHmacJwk.toMslEncoding(encoder, ENCODER_FORMAT), encoder, ENCODER_FORMAT);
}
}
@AfterClass
public static synchronized void teardown() {
// Teardown causes problems because the data is shared by the inner
// classes, so don't do any cleanup.
}
/** PSK MSL context. */
private static MockMslContext pskCtx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
/** Request data unit tests. */
public static class RequestDataTest {
/** Key wrap key wrapping mechanism. */
private static final String KEY_MECHANISM = "mechanism";
/** Key public key. */
private static final String KEY_PUBLIC_KEY = "publickey";
/** Key wrap data. */
private static final String KEY_WRAPDATA = "wrapdata";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@Test
public void ctorsWrap() throws MslCryptoException, MslKeyExchangeException, MslEncodingException, MslException, MslEncoderException {
final RequestData req = new RequestData(Mechanism.WRAP, WRAPDATA);
assertEquals(KeyExchangeScheme.JWE_LADDER, req.getKeyExchangeScheme());
assertEquals(Mechanism.WRAP, req.getMechanism());
assertArrayEquals(WRAPDATA, req.getWrapdata());
final MslObject keydata = req.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata);
final RequestData moReq = new RequestData(keydata);
assertEquals(req.getKeyExchangeScheme(), moReq.getKeyExchangeScheme());
assertEquals(req.getMechanism(), moReq.getMechanism());
assertArrayEquals(req.getWrapdata(), moReq.getWrapdata());
final MslObject moKeydata = req.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(moKeydata);
assertTrue(MslEncoderUtils.equalObjects(keydata, moKeydata));
}
@Test
public void jsonWrap() throws MslException, MslEncoderException {
final RequestData req = new RequestData(Mechanism.WRAP, WRAPDATA);
final MslObject mo = MslTestUtils.toMslObject(encoder, req);
assertEquals(KeyExchangeScheme.JWE_LADDER.name(), mo.getString(KEY_SCHEME));
final MslObject keydata = mo.getMslObject(KEY_KEYDATA, encoder);
assertEquals(Mechanism.WRAP.name(), keydata.getString(KEY_MECHANISM));
assertFalse(keydata.has(KEY_PUBLIC_KEY));
assertArrayEquals(WRAPDATA, keydata.getBytes(KEY_WRAPDATA));
}
@Test
public void createWrap() throws MslException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslCryptoException, MslEncoderException {
final RequestData req = new RequestData(Mechanism.WRAP, WRAPDATA);
final MslObject mo = MslTestUtils.toMslObject(encoder, req);
final KeyRequestData keyRequestData = KeyRequestData.create(pskCtx, mo);
assertNotNull(keyRequestData);
assertTrue(keyRequestData instanceof RequestData);
final RequestData moReq = (RequestData)keyRequestData;
assertEquals(req.getKeyExchangeScheme(), moReq.getKeyExchangeScheme());
assertEquals(req.getMechanism(), moReq.getMechanism());
assertArrayEquals(req.getWrapdata(), moReq.getWrapdata());
}
@Test(expected = MslInternalException.class)
public void ctorWrapNullWrapdata() {
new RequestData(Mechanism.WRAP, null);
}
@Test
public void ctorsPsk() throws MslCryptoException, MslKeyExchangeException, MslEncodingException, MslException, MslEncoderException {
final RequestData req = new RequestData(Mechanism.PSK, null);
assertEquals(KeyExchangeScheme.JWE_LADDER, req.getKeyExchangeScheme());
assertEquals(Mechanism.PSK, req.getMechanism());
assertNull(req.getWrapdata());
final MslObject keydata = req.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata);
final RequestData moReq = new RequestData(keydata);
assertEquals(req.getKeyExchangeScheme(), moReq.getKeyExchangeScheme());
assertEquals(req.getMechanism(), moReq.getMechanism());
assertNull(moReq.getWrapdata());
final MslObject moKeydata = req.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(moKeydata);
assertTrue(MslEncoderUtils.equalObjects(keydata, moKeydata));
}
@Test
public void jsonPsk() throws MslException, MslEncoderException {
final RequestData req = new RequestData(Mechanism.PSK, null);
final MslObject mo = MslTestUtils.toMslObject(encoder, req);
assertEquals(KeyExchangeScheme.JWE_LADDER.name(), mo.getString(KEY_SCHEME));
final MslObject keydata = mo.getMslObject(KEY_KEYDATA, encoder);
assertEquals(Mechanism.PSK.name(), keydata.getString(KEY_MECHANISM));
assertFalse(keydata.has(KEY_PUBLIC_KEY));
assertFalse(keydata.has(KEY_WRAPDATA));
}
@Test
public void createPsk() throws MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslException, MslCryptoException, MslEncoderException {
final RequestData req = new RequestData(Mechanism.PSK, null);
final MslObject mo = MslTestUtils.toMslObject(encoder, req);
final KeyRequestData keyRequestData = KeyRequestData.create(pskCtx, mo);
assertNotNull(keyRequestData);
assertTrue(keyRequestData instanceof RequestData);
final RequestData moReq = (RequestData)keyRequestData;
assertEquals(req.getKeyExchangeScheme(), moReq.getKeyExchangeScheme());
assertEquals(req.getMechanism(), moReq.getMechanism());
assertNull(moReq.getWrapdata());
}
@Test
public void missingMechanism() throws MslException, MslCryptoException, MslKeyExchangeException, MslEncodingException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final RequestData req = new RequestData(Mechanism.PSK, null);
final MslObject keydata = req.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata.remove(KEY_MECHANISM));
new RequestData(keydata);
}
@Test
public void invalidMechanism() throws MslCryptoException, MslKeyExchangeException, MslEncodingException, MslException, MslEncoderException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.UNIDENTIFIED_KEYX_MECHANISM);
final RequestData req = new RequestData(Mechanism.PSK, null);
final MslObject keydata = req.getKeydata(encoder, ENCODER_FORMAT);
keydata.put(KEY_MECHANISM, "x");
new RequestData(keydata);
}
@Test
public void wrapMissingWrapdata() throws MslCryptoException, MslKeyExchangeException, MslEncodingException, MslException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final RequestData req = new RequestData(Mechanism.WRAP, WRAPDATA);
final MslObject keydata = req.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata.remove(KEY_WRAPDATA));
new RequestData(keydata);
}
@Test
public void wrapInvalidWrapdata() throws MslCryptoException, MslKeyExchangeException, MslEncodingException, MslException, MslEncoderException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.KEYX_WRAPPING_KEY_MISSING);
final RequestData req = new RequestData(Mechanism.WRAP, WRAPDATA);
final MslObject keydata = req.getKeydata(encoder, ENCODER_FORMAT);
keydata.put(KEY_WRAPDATA, new byte[0]);
new RequestData(keydata);
}
@Test
public void equalsMechanism() throws MslCryptoException, MslKeyExchangeException, MslEncodingException, MslException, MslEncoderException {
final RequestData dataA = new RequestData(Mechanism.WRAP, WRAPDATA);
final RequestData dataB = new RequestData(Mechanism.PSK, null);
final RequestData dataA2 = new RequestData(dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsWrapdata() throws MslCryptoException, MslKeyExchangeException, MslEncodingException, MslException, MslEncoderException {
final byte[] wrapdataB = Arrays.copyOf(WRAPDATA, WRAPDATA.length);
++wrapdataB[0];
final RequestData dataA = new RequestData(Mechanism.WRAP, WRAPDATA);
final RequestData dataB = new RequestData(Mechanism.WRAP, wrapdataB);
final RequestData dataA2 = new RequestData(dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
}
/** Response data unit tests. */
public static class ResponseDataTest {
/** Key master token. */
private static final String KEY_MASTER_TOKEN = "mastertoken";
/** Key wrapping key. */
private static final String KEY_WRAP_KEY = "wrapkey";
/** Key wrapping key data. */
private static final String KEY_WRAPDATA = "wrapdata";
/** Key encrypted encryption key. */
private static final String KEY_ENCRYPTION_KEY = "encryptionkey";
/** Key encrypted HMAC key. */
private static final String KEY_HMAC_KEY = "hmackey";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@Test
public void ctors() throws MslException, MslKeyExchangeException, MslEncodingException, MslEncoderException {
final ResponseData resp = new ResponseData(PSK_MASTER_TOKEN, WRAP_JWK, WRAPDATA, PSK_ENCRYPTION_JWK, PSK_HMAC_JWK);
assertArrayEquals(PSK_ENCRYPTION_JWK, resp.getEncryptionKey());
assertArrayEquals(PSK_HMAC_JWK, resp.getHmacKey());
assertEquals(KeyExchangeScheme.JWE_LADDER, resp.getKeyExchangeScheme());
assertEquals(PSK_MASTER_TOKEN, resp.getMasterToken());
assertArrayEquals(WRAPDATA, resp.getWrapdata());
assertArrayEquals(WRAP_JWK, resp.getWrapKey());
final MslObject keydata = resp.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata);
final ResponseData moResp = new ResponseData(PSK_MASTER_TOKEN, keydata);
assertArrayEquals(resp.getEncryptionKey(), moResp.getEncryptionKey());
assertArrayEquals(resp.getHmacKey(), moResp.getHmacKey());
assertEquals(resp.getKeyExchangeScheme(), moResp.getKeyExchangeScheme());
assertEquals(resp.getMasterToken(), moResp.getMasterToken());
assertArrayEquals(resp.getWrapdata(), moResp.getWrapdata());
assertArrayEquals(resp.getWrapKey(), moResp.getWrapKey());
final MslObject moKeydata = moResp.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(moKeydata);
assertTrue(MslEncoderUtils.equalObjects(keydata, moKeydata));
}
@Test
public void json() throws MslEncodingException, MslCryptoException, MslException, MslException, MslEncoderException {
final ResponseData resp = new ResponseData(PSK_MASTER_TOKEN, WRAP_JWK, WRAPDATA, PSK_ENCRYPTION_JWK, PSK_HMAC_JWK);
final MslObject mo = MslTestUtils.toMslObject(encoder, resp);
assertEquals(KeyExchangeScheme.JWE_LADDER.name(), mo.getString(KEY_SCHEME));
final MasterToken masterToken = new MasterToken(pskCtx, mo.getMslObject(KEY_MASTER_TOKEN, encoder));
assertEquals(PSK_MASTER_TOKEN, masterToken);
final MslObject keydata = mo.getMslObject(KEY_KEYDATA, encoder);
assertArrayEquals(PSK_ENCRYPTION_JWK, keydata.getBytes(KEY_ENCRYPTION_KEY));
assertArrayEquals(PSK_HMAC_JWK, keydata.getBytes(KEY_HMAC_KEY));
assertArrayEquals(WRAPDATA, keydata.getBytes(KEY_WRAPDATA));
assertArrayEquals(WRAP_JWK, keydata.getBytes(KEY_WRAP_KEY));
}
@Test
public void create() throws MslException, MslEncodingException, MslCryptoException, MslKeyExchangeException, MslException, MslEncoderException {
final ResponseData resp = new ResponseData(PSK_MASTER_TOKEN, WRAP_JWK, WRAPDATA, PSK_ENCRYPTION_JWK, PSK_HMAC_JWK);
final MslObject mo = MslTestUtils.toMslObject(encoder, resp);
final KeyResponseData keyResponseData = KeyResponseData.create(pskCtx, mo);
assertNotNull(keyResponseData);
assertTrue(keyResponseData instanceof ResponseData);
final ResponseData moResp = (ResponseData)keyResponseData;
assertArrayEquals(resp.getEncryptionKey(), moResp.getEncryptionKey());
assertArrayEquals(resp.getHmacKey(), moResp.getHmacKey());
assertEquals(resp.getKeyExchangeScheme(), moResp.getKeyExchangeScheme());
assertEquals(resp.getMasterToken(), moResp.getMasterToken());
assertArrayEquals(resp.getWrapdata(), moResp.getWrapdata());
assertArrayEquals(resp.getWrapKey(), moResp.getWrapKey());
}
@Test
public void missingWrapKey() throws MslException, MslKeyExchangeException, MslEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ResponseData resp = new ResponseData(PSK_MASTER_TOKEN, WRAP_JWK, WRAPDATA, PSK_ENCRYPTION_JWK, PSK_HMAC_JWK);
final MslObject keydata = resp.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata.remove(KEY_WRAP_KEY));
new ResponseData(PSK_MASTER_TOKEN, keydata);
}
@Test
public void missingWrapdata() throws MslException, MslKeyExchangeException, MslEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ResponseData resp = new ResponseData(PSK_MASTER_TOKEN, WRAP_JWK, WRAPDATA, PSK_ENCRYPTION_JWK, PSK_HMAC_JWK);
final MslObject keydata = resp.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata.remove(KEY_WRAPDATA));
new ResponseData(PSK_MASTER_TOKEN, keydata);
}
@Test
public void missingEncryptionKey() throws MslKeyExchangeException, MslEncodingException, MslException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ResponseData resp = new ResponseData(PSK_MASTER_TOKEN, WRAP_JWK, WRAPDATA, PSK_ENCRYPTION_JWK, PSK_HMAC_JWK);
final MslObject keydata = resp.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata.remove(KEY_ENCRYPTION_KEY));
new ResponseData(PSK_MASTER_TOKEN, keydata);
}
@Test
public void missingHmacKey() throws MslException, MslKeyExchangeException, MslEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ResponseData resp = new ResponseData(PSK_MASTER_TOKEN, WRAP_JWK, WRAPDATA, PSK_ENCRYPTION_JWK, PSK_HMAC_JWK);
final MslObject keydata = resp.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata.remove(KEY_HMAC_KEY));
new ResponseData(PSK_MASTER_TOKEN, keydata);
}
@Test
public void equalsWrapKey() throws MslKeyExchangeException, MslEncodingException, MslException {
final byte[] wrapKeyB = Arrays.copyOf(WRAP_JWK, WRAP_JWK.length);
++wrapKeyB[0];
final ResponseData dataA = new ResponseData(PSK_MASTER_TOKEN, WRAP_JWK, WRAPDATA, PSK_ENCRYPTION_JWK, PSK_HMAC_JWK);
final ResponseData dataB = new ResponseData(PSK_MASTER_TOKEN, wrapKeyB, WRAPDATA, PSK_ENCRYPTION_JWK, PSK_HMAC_JWK);
final ResponseData dataA2 = new ResponseData(PSK_MASTER_TOKEN, dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsWrapdata() throws MslKeyExchangeException, MslEncodingException, MslException {
final byte[] wrapdataB = Arrays.copyOf(WRAPDATA, WRAPDATA.length);
++wrapdataB[0];
final ResponseData dataA = new ResponseData(PSK_MASTER_TOKEN, WRAP_JWK, WRAPDATA, PSK_ENCRYPTION_JWK, PSK_HMAC_JWK);
final ResponseData dataB = new ResponseData(PSK_MASTER_TOKEN, WRAP_JWK, wrapdataB, PSK_ENCRYPTION_JWK, PSK_HMAC_JWK);
final ResponseData dataA2 = new ResponseData(PSK_MASTER_TOKEN, dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsEncryptionKey() throws MslKeyExchangeException, MslEncodingException, MslException {
final byte[] encryptionKeyB = Arrays.copyOf(PSK_ENCRYPTION_JWK, PSK_ENCRYPTION_JWK.length);
++encryptionKeyB[0];
final ResponseData dataA = new ResponseData(PSK_MASTER_TOKEN, WRAP_JWK, WRAPDATA, PSK_ENCRYPTION_JWK, PSK_HMAC_JWK);
final ResponseData dataB = new ResponseData(PSK_MASTER_TOKEN, WRAP_JWK, WRAPDATA, encryptionKeyB, PSK_HMAC_JWK);
final ResponseData dataA2 = new ResponseData(PSK_MASTER_TOKEN, dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsHmacKey() throws MslKeyExchangeException, MslEncodingException, MslException {
final byte[] hmacKeyB = Arrays.copyOf(PSK_HMAC_JWK, PSK_HMAC_JWK.length);
++hmacKeyB[0];
final ResponseData dataA = new ResponseData(PSK_MASTER_TOKEN, WRAP_JWK, WRAPDATA, PSK_ENCRYPTION_JWK, PSK_HMAC_JWK);
final ResponseData dataB = new ResponseData(PSK_MASTER_TOKEN, WRAP_JWK, WRAPDATA, PSK_ENCRYPTION_JWK, hmacKeyB);
final ResponseData dataA2 = new ResponseData(PSK_MASTER_TOKEN, dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
}
/** Key exchange factory unit tests. */
public static class KeyExchangeFactoryTest {
/**
* Fake key request data for the JSON Web Key key ladder key exchange
* scheme.
*/
private static class FakeKeyRequestData extends KeyRequestData {
/** Create a new fake key request data. */
protected FakeKeyRequestData() {
super(KeyExchangeScheme.JWE_LADDER);
}
/* (non-Javadoc)
* @see com.netflix.msl.keyx.KeyRequestData#getKeydata(com.netflix.msl.io.MslEncoderFactory, com.netflix.msl.io.MslEncoderFormat)
*/
@Override
protected MslObject getKeydata(final MslEncoderFactory encoder, final MslEncoderFormat format) throws MslEncoderException {
return null;
}
}
/**
* Fake key response data for the JSON Web Key key ladder key exchange
* scheme.
*/
private static class FakeKeyResponseData extends KeyResponseData {
/** Create a new fake key response data. */
protected FakeKeyResponseData() {
super(PSK_MASTER_TOKEN, KeyExchangeScheme.JWE_LADDER);
}
/* (non-Javadoc)
* @see com.netflix.msl.keyx.KeyResponseData#getKeydata(com.netflix.msl.io.MslEncoderFactory, com.netflix.msl.io.MslEncoderFormat)
*/
@Override
protected MslObject getKeydata(final MslEncoderFactory encoder, final MslEncoderFormat format) throws MslEncoderException {
return null;
}
}
/**
* Unwrap a JSON Web Key and return the secret key it contains.
*
* @param wrapCryptoContext crypto context for unwrapping the JSON Web Key.
* @param wrappedJwk the wrapped JSON Web Key.
* @return the secret key.
* @throws MslCryptoException if there is an error unwrapping the JSON
* Web Key.
* @throws MslException if there is an error reconstructing the JSON
* Web Key MSL object.
* @throws MslEncoderException if there is an error parsing the data.
*/
private static SecretKey extractJwkSecretKey(final ICryptoContext wrapCryptoContext, final byte[] wrappedJwk) throws MslCryptoException, MslException, MslEncoderException {
final byte[] unwrappedJwk = wrapCryptoContext.unwrap(wrappedJwk, encoder);
final MslObject jwkJo = encoder.parseObject(unwrappedJwk);
final JsonWebKey jwk = new JsonWebKey(jwkJo);
return jwk.getSecretKey();
}
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@BeforeClass
public static void setup() {
random = new Random();
repository = new MockCryptoContextRepository();
authutils = new MockAuthenticationUtils();
factory = new JsonWebEncryptionLadderExchange(repository, authutils);
entityAuthData = new PresharedAuthenticationData(PSK_IDENTITY);
// Not sure why I have to do this again since it's already done by
// the parent class.
Security.addProvider(new BouncyCastleProvider());
}
@AfterClass
public static void teardown() {
entityAuthData = null;
factory = null;
authutils = null;
repository = null;
random = null;
}
@Before
public void reset() {
authutils.reset();
pskCtx.getMslStore().clearCryptoContexts();
pskCtx.getMslStore().clearServiceTokens();
repository.clear();
}
/** Random. */
private static Random random;
/** JWE key ladder crypto context repository. */
private static MockCryptoContextRepository repository;
/** Authentication utilities. */
private static MockAuthenticationUtils authutils;
/** Key exchange factory. */
private static KeyExchangeFactory factory;
/** Entity authentication data. */
private static EntityAuthenticationData entityAuthData;
@Test
public void factory() {
assertEquals(KeyExchangeScheme.JWE_LADDER, factory.getScheme());
}
@Test
public void generateWrapInitialResponse() throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslEntityAuthException, MslException, MslException, MslEncoderException {
final KeyRequestData req = new RequestData(Mechanism.WRAP, WRAPDATA);
final KeyExchangeData keyxData = factory.generateResponse(pskCtx, ENCODER_FORMAT, req, entityAuthData);
assertNotNull(keyxData);
assertNotNull(keyxData.cryptoContext);
assertNotNull(keyxData.keyResponseData);
final KeyResponseData resp = keyxData.keyResponseData;
assertEquals(KeyExchangeScheme.JWE_LADDER, resp.getKeyExchangeScheme());
final MasterToken masterToken = resp.getMasterToken();
assertNotNull(masterToken);
assertEquals(PSK_IDENTITY, masterToken.getIdentity());
// Unwrap the new wrapping key and create a crypto context from it.
assertTrue(resp instanceof ResponseData);
final ResponseData respdata = (ResponseData)resp;
final SecretKey wrappingKey = extractJwkSecretKey(WRAP_CRYPTO_CONTEXT, respdata.getWrapKey());
final CekCryptoContext cekCryptoContext = new AesKwCryptoContext(wrappingKey);
final ICryptoContext wrapCryptoContext = new JsonWebEncryptionCryptoContext(pskCtx, cekCryptoContext, Encryption.A128GCM, Format.JWE_JS);
// Unwrap the session keys.
final SecretKey encryptionKey = extractJwkSecretKey(wrapCryptoContext, respdata.getEncryptionKey());
assertArrayEquals(masterToken.getEncryptionKey().getEncoded(), encryptionKey.getEncoded());
final SecretKey hmacKey = extractJwkSecretKey(wrapCryptoContext, respdata.getHmacKey());
assertArrayEquals(masterToken.getSignatureKey().getEncoded(), hmacKey.getEncoded());
}
@Test
public void generatePskInitialResponse() throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslEntityAuthException, MslException, MslException, MslEncoderException {
final KeyRequestData req = new RequestData(Mechanism.PSK, null);
final KeyExchangeData keyxData = factory.generateResponse(pskCtx, ENCODER_FORMAT, req, entityAuthData);
assertNotNull(keyxData);
assertNotNull(keyxData.cryptoContext);
assertNotNull(keyxData.keyResponseData);
final KeyResponseData resp = keyxData.keyResponseData;
assertEquals(KeyExchangeScheme.JWE_LADDER, resp.getKeyExchangeScheme());
final MasterToken masterToken = resp.getMasterToken();
assertNotNull(masterToken);
assertEquals(PSK_IDENTITY, masterToken.getIdentity());
// Unwrap the new wrapping key and create a crypto context from it.
assertTrue(resp instanceof ResponseData);
final ResponseData respdata = (ResponseData)resp;
final SecretKey wrappingKey = extractJwkSecretKey(PSK_CRYPTO_CONTEXT, respdata.getWrapKey());
final CekCryptoContext cekCryptoContext = new AesKwCryptoContext(wrappingKey);
final ICryptoContext wrapCryptoContext = new JsonWebEncryptionCryptoContext(pskCtx, cekCryptoContext, Encryption.A128GCM, Format.JWE_JS);
// Unwrap the session keys.
final SecretKey encryptionKey = extractJwkSecretKey(wrapCryptoContext, respdata.getEncryptionKey());
assertArrayEquals(masterToken.getEncryptionKey().getEncoded(), encryptionKey.getEncoded());
final SecretKey hmacKey = extractJwkSecretKey(wrapCryptoContext, respdata.getHmacKey());
assertArrayEquals(masterToken.getSignatureKey().getEncoded(), hmacKey.getEncoded());
}
@Test(expected = MslInternalException.class)
public void wrongRequestInitialResponse() throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslEntityAuthException, MslException {
final KeyRequestData req = new FakeKeyRequestData();
factory.generateResponse(pskCtx, ENCODER_FORMAT, req, entityAuthData);
}
@Test
public void generateWrapSubsequentResponse() throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslMasterTokenException, MslEntityAuthException, MslException, MslException, MslEncoderException {
final KeyRequestData req = new RequestData(Mechanism.WRAP, WRAPDATA);
final KeyExchangeData keyxData = factory.generateResponse(pskCtx, ENCODER_FORMAT, req, PSK_MASTER_TOKEN);
assertNotNull(keyxData);
assertNotNull(keyxData.cryptoContext);
assertNotNull(keyxData.keyResponseData);
final KeyResponseData resp = keyxData.keyResponseData;
assertEquals(KeyExchangeScheme.JWE_LADDER, resp.getKeyExchangeScheme());
final MasterToken masterToken = resp.getMasterToken();
assertNotNull(masterToken);
assertEquals(PSK_MASTER_TOKEN.getIdentity(), masterToken.getIdentity());
assertEquals(PSK_MASTER_TOKEN.getSerialNumber(), masterToken.getSerialNumber());
assertEquals(PSK_MASTER_TOKEN.getSequenceNumber() + 1, masterToken.getSequenceNumber());
// Unwrap the new wrapping key and create a crypto context from it.
assertTrue(resp instanceof ResponseData);
final ResponseData respdata = (ResponseData)resp;
final SecretKey wrappingKey = extractJwkSecretKey(WRAP_CRYPTO_CONTEXT, respdata.getWrapKey());
final CekCryptoContext cekCryptoContext = new AesKwCryptoContext(wrappingKey);
final ICryptoContext wrapCryptoContext = new JsonWebEncryptionCryptoContext(pskCtx, cekCryptoContext, Encryption.A128GCM, Format.JWE_JS);
// Unwrap the session keys.
final SecretKey encryptionKey = extractJwkSecretKey(wrapCryptoContext, respdata.getEncryptionKey());
assertArrayEquals(masterToken.getEncryptionKey().getEncoded(), encryptionKey.getEncoded());
final SecretKey hmacKey = extractJwkSecretKey(wrapCryptoContext, respdata.getHmacKey());
assertArrayEquals(masterToken.getSignatureKey().getEncoded(), hmacKey.getEncoded());
}
@Test
public void generatePskSubsequentResponse() throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslMasterTokenException, MslEntityAuthException, MslException, MslException, MslEncoderException {
final KeyRequestData req = new RequestData(Mechanism.PSK, null);
final KeyExchangeData keyxData = factory.generateResponse(pskCtx, ENCODER_FORMAT, req, PSK_MASTER_TOKEN);
assertNotNull(keyxData);
assertNotNull(keyxData.cryptoContext);
assertNotNull(keyxData.keyResponseData);
final KeyResponseData resp = keyxData.keyResponseData;
assertEquals(KeyExchangeScheme.JWE_LADDER, resp.getKeyExchangeScheme());
final MasterToken masterToken = resp.getMasterToken();
assertNotNull(masterToken);
assertEquals(PSK_MASTER_TOKEN.getIdentity(), masterToken.getIdentity());
assertEquals(PSK_MASTER_TOKEN.getSerialNumber(), masterToken.getSerialNumber());
assertEquals(PSK_MASTER_TOKEN.getSequenceNumber() + 1, masterToken.getSequenceNumber());
// Unwrap the new wrapping key and create a crypto context from it.
assertTrue(resp instanceof ResponseData);
final ResponseData respdata = (ResponseData)resp;
final SecretKey wrappingKey = extractJwkSecretKey(PSK_CRYPTO_CONTEXT, respdata.getWrapKey());
final CekCryptoContext cekCryptoContext = new AesKwCryptoContext(wrappingKey);
final ICryptoContext wrapCryptoContext = new JsonWebEncryptionCryptoContext(pskCtx, cekCryptoContext, Encryption.A128GCM, Format.JWE_JS);
// Unwrap the session keys.
final SecretKey encryptionKey = extractJwkSecretKey(wrapCryptoContext, respdata.getEncryptionKey());
assertArrayEquals(masterToken.getEncryptionKey().getEncoded(), encryptionKey.getEncoded());
final SecretKey hmacKey = extractJwkSecretKey(wrapCryptoContext, respdata.getHmacKey());
assertArrayEquals(masterToken.getSignatureKey().getEncoded(), hmacKey.getEncoded());
}
@Test(expected = MslInternalException.class)
public void wrongRequestSubsequentResponse() throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslMasterTokenException, MslEntityAuthException, MslException {
final KeyRequestData req = new FakeKeyRequestData();
factory.generateResponse(pskCtx, ENCODER_FORMAT, req, PSK_MASTER_TOKEN);
}
@Test(expected = MslMasterTokenException.class)
public void untrustedMasterTokenSubsequentResponse() throws MslEncodingException, MslCryptoException, MslException, MslException, MslEncoderException {
final KeyRequestData req = new RequestData(Mechanism.PSK, null);
final MasterToken masterToken = MslTestUtils.getUntrustedMasterToken(pskCtx);
factory.generateResponse(pskCtx, ENCODER_FORMAT, req, masterToken);
}
@Test
public void getWrapCryptoContext() throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslEntityAuthException, MslException {
final KeyRequestData req = new RequestData(Mechanism.WRAP, WRAPDATA);
final KeyExchangeData keyxData = factory.generateResponse(pskCtx, ENCODER_FORMAT, req, entityAuthData);
final ICryptoContext reqCryptoContext = keyxData.cryptoContext;
final KeyResponseData resp = keyxData.keyResponseData;
// We must put the wrapping key into the repository to create the
// response crypto context.
repository.addCryptoContext(WRAPDATA, WRAP_CRYPTO_CONTEXT);
assertNotNull(repository.getCryptoContext(WRAPDATA));
final ICryptoContext respCryptoContext = factory.getCryptoContext(pskCtx, req, resp, null);
final byte[] wrapdata = repository.getWrapdata();
assertNotNull(wrapdata);
assertArrayEquals(((ResponseData)resp).getWrapdata(), wrapdata);
assertNull(repository.getCryptoContext(WRAPDATA));
final byte[] data = new byte[32];
random.nextBytes(data);
// Ciphertext won't always be equal depending on how it was
// enveloped. So we cannot check for equality or inequality.
final byte[] requestCiphertext = reqCryptoContext.encrypt(data, encoder, ENCODER_FORMAT);
final byte[] responseCiphertext = respCryptoContext.encrypt(data, encoder, ENCODER_FORMAT);
assertFalse(Arrays.equals(data, requestCiphertext));
assertFalse(Arrays.equals(data, responseCiphertext));
// Signatures should always be equal.
final byte[] requestSignature = reqCryptoContext.sign(data, encoder, ENCODER_FORMAT);
final byte[] responseSignature = respCryptoContext.sign(data, encoder, ENCODER_FORMAT);
assertFalse(Arrays.equals(data, requestSignature));
assertFalse(Arrays.equals(data, responseSignature));
assertArrayEquals(requestSignature, responseSignature);
// Plaintext should always be equal to the original message.
final byte[] requestPlaintext = reqCryptoContext.decrypt(responseCiphertext, encoder);
final byte[] responsePlaintext = respCryptoContext.decrypt(requestCiphertext, encoder);
assertNotNull(requestPlaintext);
assertArrayEquals(data, requestPlaintext);
assertArrayEquals(requestPlaintext, responsePlaintext);
// Verification should always succeed.
assertTrue(reqCryptoContext.verify(data, responseSignature, encoder));
assertTrue(respCryptoContext.verify(data, requestSignature, encoder));
}
@Test
public void getPskCryptoContext() throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslEntityAuthException, MslException {
final KeyRequestData req = new RequestData(Mechanism.PSK, null);
final KeyExchangeData keyxData = factory.generateResponse(pskCtx, ENCODER_FORMAT, req, entityAuthData);
final ICryptoContext reqCryptoContext = keyxData.cryptoContext;
final KeyResponseData resp = keyxData.keyResponseData;
assertNull(repository.getWrapdata());
final ICryptoContext respCryptoContext = factory.getCryptoContext(pskCtx, req, resp, null);
final byte[] wrapdata = repository.getWrapdata();
assertNotNull(wrapdata);
assertArrayEquals(((ResponseData)resp).getWrapdata(), wrapdata);
final byte[] data = new byte[32];
random.nextBytes(data);
// Ciphertext won't always be equal depending on how it was
// enveloped. So we cannot check for equality or inequality.
final byte[] requestCiphertext = reqCryptoContext.encrypt(data, encoder, ENCODER_FORMAT);
final byte[] responseCiphertext = respCryptoContext.encrypt(data, encoder, ENCODER_FORMAT);
assertFalse(Arrays.equals(data, requestCiphertext));
assertFalse(Arrays.equals(data, responseCiphertext));
// Signatures should always be equal.
final byte[] requestSignature = reqCryptoContext.sign(data, encoder, ENCODER_FORMAT);
final byte[] responseSignature = respCryptoContext.sign(data, encoder, ENCODER_FORMAT);
assertFalse(Arrays.equals(data, requestSignature));
assertFalse(Arrays.equals(data, responseSignature));
assertArrayEquals(requestSignature, responseSignature);
// Plaintext should always be equal to the original message.
final byte[] requestPlaintext = reqCryptoContext.decrypt(responseCiphertext, encoder);
final byte[] responsePlaintext = respCryptoContext.decrypt(requestCiphertext, encoder);
assertNotNull(requestPlaintext);
assertArrayEquals(data, requestPlaintext);
assertArrayEquals(requestPlaintext, responsePlaintext);
// Verification should always succeed.
assertTrue(reqCryptoContext.verify(data, responseSignature, encoder));
assertTrue(respCryptoContext.verify(data, requestSignature, encoder));
}
@Test(expected = MslInternalException.class)
public void wrongRequestCryptoContext() throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslEntityAuthException, MslException {
final KeyRequestData req = new RequestData(Mechanism.PSK, null);
final KeyExchangeData keyxData = factory.generateResponse(pskCtx, ENCODER_FORMAT, req, entityAuthData);
final KeyResponseData resp = keyxData.keyResponseData;
final KeyRequestData fakeReq = new FakeKeyRequestData();
factory.getCryptoContext(pskCtx, fakeReq, resp, null);
}
@Test(expected = MslInternalException.class)
public void wrongResponseCryptoContext() throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslMasterTokenException, MslEntityAuthException {
final KeyRequestData req = new RequestData(Mechanism.PSK, null);
final KeyResponseData fakeResp = new FakeKeyResponseData();
factory.getCryptoContext(pskCtx, req, fakeResp, null);
}
@Test
public void pskUnsupportedCryptoContext() throws MslKeyExchangeException, MslEntityAuthException, MslException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.UNSUPPORTED_KEYX_MECHANISM);
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
final KeyRequestData req = new RequestData(Mechanism.PSK, null);
final KeyExchangeData keyxData = factory.generateResponse(ctx, ENCODER_FORMAT, req, entityAuthData);
final KeyResponseData resp = keyxData.keyResponseData;
ctx.removeEntityAuthenticationFactory(EntityAuthenticationScheme.PSK);
factory.getCryptoContext(ctx, req, resp, null);
}
@Test
public void wrapKeyMissingCryptoContext() throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslEntityAuthException, MslException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.KEYX_WRAPPING_KEY_MISSING);
final KeyRequestData req = new RequestData(Mechanism.WRAP, WRAPDATA);
final KeyExchangeData keyxData = factory.generateResponse(pskCtx, ENCODER_FORMAT, req, entityAuthData);
final KeyResponseData resp = keyxData.keyResponseData;
factory.getCryptoContext(pskCtx, req, resp, null);
}
@Test
public void invalidWrapJwkCryptoContext() throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslEntityAuthException, MslException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.INVALID_JWK);
final byte[] data = new byte[16];
random.nextBytes(data);
final byte[] wrapJwk = WRAP_CRYPTO_CONTEXT.wrap(data, encoder, ENCODER_FORMAT);
final KeyRequestData req = new RequestData(Mechanism.WRAP, WRAPDATA);
final KeyResponseData invalidResp = new ResponseData(PSK_MASTER_TOKEN, wrapJwk, WRAPDATA, PSK_ENCRYPTION_JWK, PSK_HMAC_JWK);
repository.addCryptoContext(WRAPDATA, WRAP_CRYPTO_CONTEXT);
factory.getCryptoContext(pskCtx, req, invalidResp, null);
}
@Test
public void invalidEncryptionJwkCryptoContext() throws MslException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.INVALID_JWK);
final KeyRequestData req = new RequestData(Mechanism.WRAP, WRAPDATA);
final KeyExchangeData keyxData = factory.generateResponse(pskCtx, ENCODER_FORMAT, req, entityAuthData);
final ResponseData resp = (ResponseData)keyxData.keyResponseData;
// First get the new crypto context. This installs the returned
// wrapping key in the repository.
repository.addCryptoContext(WRAPDATA, WRAP_CRYPTO_CONTEXT);
assertArrayEquals(WRAPDATA, repository.getWrapdata());
factory.getCryptoContext(pskCtx, req, resp, null);
assertFalse(Arrays.equals(WRAPDATA, repository.getWrapdata()));
// Now make the invalid response.
final byte[] data = new byte[16];
random.nextBytes(data);
final ICryptoContext wrapCryptoContext = repository.getCryptoContext(repository.getWrapdata());
final byte[] encryptionJwk = wrapCryptoContext.wrap(data, encoder, ENCODER_FORMAT);
// Extract values from the response.
final MasterToken masterToken = resp.getMasterToken();
final byte[] wrapJwk = resp.getWrapKey();
final byte[] wrapdata = resp.getWrapdata();
final byte[] hmacJwk = resp.getHmacKey();
final KeyResponseData invalidResp = new ResponseData(masterToken, wrapJwk, wrapdata, encryptionJwk, hmacJwk);
// Reinstall the previous wrap crypto context.
repository.addCryptoContext(WRAPDATA, WRAP_CRYPTO_CONTEXT);
assertArrayEquals(WRAPDATA, repository.getWrapdata());
factory.getCryptoContext(pskCtx, req, invalidResp, null);
}
@Test
public void invalidHmacJwkCryptoContext() throws MslException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.INVALID_JWK);
final KeyRequestData req = new RequestData(Mechanism.WRAP, WRAPDATA);
final KeyExchangeData keyxData = factory.generateResponse(pskCtx, ENCODER_FORMAT, req, entityAuthData);
final ResponseData resp = (ResponseData)keyxData.keyResponseData;
// First get the new crypto context. This installs the returned
// wrapping key in the repository.
repository.addCryptoContext(WRAPDATA, WRAP_CRYPTO_CONTEXT);
assertArrayEquals(WRAPDATA, repository.getWrapdata());
factory.getCryptoContext(pskCtx, req, resp, null);
assertFalse(Arrays.equals(WRAPDATA, repository.getWrapdata()));
// Now make the invalid response.
final byte[] data = new byte[16];
random.nextBytes(data);
final ICryptoContext wrapCryptoContext = repository.getCryptoContext(repository.getWrapdata());
final byte[] hmacJwk = wrapCryptoContext.wrap(data, encoder, ENCODER_FORMAT);
// Extract values from the response.
final MasterToken masterToken = resp.getMasterToken();
final byte[] wrapJwk = resp.getWrapKey();
final byte[] wrapdata = resp.getWrapdata();
final byte[] encryptionJwk = resp.getEncryptionKey();
final KeyResponseData invalidResp = new ResponseData(masterToken, wrapJwk, wrapdata, encryptionJwk, hmacJwk);
// Reinstall the previous wrap crypto context.
repository.addCryptoContext(WRAPDATA, WRAP_CRYPTO_CONTEXT);
assertArrayEquals(WRAPDATA, repository.getWrapdata());
factory.getCryptoContext(pskCtx, req, invalidResp, null);
}
}
}
| 9,961 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/keyx/AsymmetricWrappedExchangeSuite.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.keyx;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.math.BigInteger;
import java.security.InvalidAlgorithmParameterException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Security;
import java.security.spec.AlgorithmParameterSpec;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.Random;
import javax.crypto.SecretKey;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.jce.spec.ECParameterSpec;
import org.bouncycastle.math.ec.ECCurve;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.MslKeyExchangeException;
import com.netflix.msl.MslMasterTokenException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.entityauth.EntityAuthenticationData;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.entityauth.MockPresharedAuthenticationFactory;
import com.netflix.msl.entityauth.PresharedAuthenticationData;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.keyx.AsymmetricWrappedExchange.RequestData;
import com.netflix.msl.keyx.AsymmetricWrappedExchange.RequestData.Mechanism;
import com.netflix.msl.keyx.AsymmetricWrappedExchange.ResponseData;
import com.netflix.msl.keyx.KeyExchangeFactory.KeyExchangeData;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.tokens.MasterToken;
import com.netflix.msl.util.MockAuthenticationUtils;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* Asymmetric wrapped key exchange unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
@RunWith(Suite.class)
@SuiteClasses({AsymmetricWrappedExchangeSuite.RequestDataTest.class,
AsymmetricWrappedExchangeSuite.RequestDataTest.Params.class,
AsymmetricWrappedExchangeSuite.ResponseDataTest.class,
AsymmetricWrappedExchangeSuite.KeyExchangeFactoryTest.class,
AsymmetricWrappedExchangeSuite.KeyExchangeFactoryTest.Params.class})
public class AsymmetricWrappedExchangeSuite {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** EC curve q. */
private static final BigInteger EC_Q = new BigInteger("883423532389192164791648750360308885314476597252960362792450860609699839");
/** EC coefficient a. */
private static final BigInteger EC_A = new BigInteger("7fffffffffffffffffffffff7fffffffffff8000000000007ffffffffffc", 16);
/** EC coefficient b. */
private static final BigInteger EC_B = new BigInteger("6b016c3bdcf18941d0d654921475ca71a9db2fb27d1d37796185c2942c0a", 16);
/** EC base point g. */
private static final BigInteger EC_G = new BigInteger("020ffa963cdca8816ccc33b8642bedf905c3d358573d3f27fbbd3b3cb9aaaf", 16);
/** EC generator order n. */
private static final BigInteger EC_N = new BigInteger("883423532389192164791648750360308884807550341691627752275345424702807307");
/** Key key exchange scheme. */
private static final String KEY_SCHEME = "scheme";
/** Key key request data. */
private static final String KEY_KEYDATA = "keydata";
/** Key key pair ID. */
private static final String KEY_KEY_PAIR_ID = "keypairid";
/** Key encrypted encryption key. */
private static final String KEY_ENCRYPTION_KEY = "encryptionkey";
/** Key encrypted HMAC key. */
private static final String KEY_HMAC_KEY = "hmackey";
private static final String KEYPAIR_ID = "keypairId";
private static PublicKey ECC_PUBLIC_KEY;
private static PrivateKey ECC_PRIVATE_KEY;
private static PublicKey RSA_PUBLIC_KEY;
private static PrivateKey RSA_PRIVATE_KEY;
private static final String IDENTITY = MockPresharedAuthenticationFactory.PSK_ESN;
private static MasterToken MASTER_TOKEN;
private static byte[] ENCRYPTION_KEY;
private static byte[] HMAC_KEY;
@BeforeClass
public static synchronized void setup() throws NoSuchAlgorithmException, InvalidAlgorithmParameterException, MslEncodingException, MslCryptoException {
if (ctx == null) {
Security.addProvider(new BouncyCastleProvider());
final ECCurve curve = new ECCurve.Fp(EC_Q, EC_A, EC_B);
final AlgorithmParameterSpec paramSpec = new ECParameterSpec(curve, curve.decodePoint(EC_G.toByteArray()), EC_N);
final KeyPairGenerator eccGenerator = KeyPairGenerator.getInstance("ECIES");
eccGenerator.initialize(paramSpec);
final KeyPair eccKeyPair = eccGenerator.generateKeyPair();
ECC_PUBLIC_KEY = eccKeyPair.getPublic();
ECC_PRIVATE_KEY = eccKeyPair.getPrivate();
final KeyPairGenerator rsaGenerator = KeyPairGenerator.getInstance("RSA");
rsaGenerator.initialize(2048);
final KeyPair rsaKeyPair = rsaGenerator.generateKeyPair();
RSA_PUBLIC_KEY = rsaKeyPair.getPublic();
RSA_PRIVATE_KEY = rsaKeyPair.getPrivate();
ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = ctx.getMslEncoderFactory();
MASTER_TOKEN = MslTestUtils.getMasterToken(ctx, 1, 1);
ENCRYPTION_KEY = MASTER_TOKEN.getEncryptionKey().getEncoded();
HMAC_KEY = MASTER_TOKEN.getSignatureKey().getEncoded();
}
}
@AfterClass
public static synchronized void teardown() {
// Teardown causes problems because the data is shared by the inner
// classes, so don't do any cleanup.
}
/** MSL context. */
private static MslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
/** Request data unit tests. */
public static class RequestDataTest {
/** Key key pair ID. */
private static final String KEY_KEY_PAIR_ID = "keypairid";
/** Key mechanism. */
private static final String KEY_MECHANISM = "mechanism";
/** Key public key. */
private static final String KEY_PUBLIC_KEY = "publickey";
@RunWith(Parameterized.class)
public static class Params {
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@Parameters
public static Collection<Object[]> data() throws NoSuchAlgorithmException, InvalidAlgorithmParameterException, MslEncodingException, MslCryptoException {
AsymmetricWrappedExchangeSuite.setup();
return Arrays.asList(new Object[][] {
{ Mechanism.RSA, RSA_PUBLIC_KEY, RSA_PRIVATE_KEY },
{ Mechanism.JWE_RSA, RSA_PUBLIC_KEY, RSA_PRIVATE_KEY },
{ Mechanism.JWEJS_RSA, RSA_PUBLIC_KEY, RSA_PRIVATE_KEY },
{ Mechanism.JWK_RSA, RSA_PUBLIC_KEY, RSA_PRIVATE_KEY },
{ Mechanism.JWK_RSAES, RSA_PUBLIC_KEY, RSA_PRIVATE_KEY },
});
}
/** Key exchange mechanism. */
private final Mechanism mechanism;
/** Public key. */
private final PublicKey publicKey;
/** Private key. */
private final PrivateKey privateKey;
/**
* Create a new request data test instance with the specified key
* exchange parameters.
*
* @param mechanism key exchange mechanism.
* @param publicKey public key.
* @param privateKey private key.
*/
public Params(final Mechanism mechanism, final PublicKey publicKey, final PrivateKey privateKey) {
this.mechanism = mechanism;
this.publicKey = publicKey;
this.privateKey = privateKey;
}
@Test
public void ctors() throws MslException, MslEncodingException, MslCryptoException, MslKeyExchangeException, MslEncoderException {
final RequestData req = new RequestData(KEYPAIR_ID, mechanism, publicKey, privateKey);
assertEquals(KeyExchangeScheme.ASYMMETRIC_WRAPPED, req.getKeyExchangeScheme());
assertEquals(KEYPAIR_ID, req.getKeyPairId());
assertEquals(mechanism, req.getMechanism());
assertArrayEquals(privateKey.getEncoded(), req.getPrivateKey().getEncoded());
assertArrayEquals(publicKey.getEncoded(), req.getPublicKey().getEncoded());
final MslObject keydata = req.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata);
final RequestData moReq = new RequestData(keydata);
assertEquals(req.getKeyExchangeScheme(), moReq.getKeyExchangeScheme());
assertEquals(req.getKeyPairId(), moReq.getKeyPairId());
assertEquals(req.getMechanism(), moReq.getMechanism());
assertNull(moReq.getPrivateKey());
assertArrayEquals(req.getPublicKey().getEncoded(), moReq.getPublicKey().getEncoded());
final MslObject moKeydata = moReq.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(moKeydata);
assertTrue(MslEncoderUtils.equalObjects(keydata, moKeydata));
}
@Test
public void mslObject() throws MslException, MslEncoderException {
final RequestData req = new RequestData(KEYPAIR_ID, mechanism, publicKey, privateKey);
final MslObject mo = MslTestUtils.toMslObject(encoder, req);
assertEquals(KeyExchangeScheme.ASYMMETRIC_WRAPPED.toString(), mo.getString(KEY_SCHEME));
final MslObject keydata = mo.getMslObject(KEY_KEYDATA, encoder);
assertEquals(KEYPAIR_ID, keydata.getString(KEY_KEY_PAIR_ID));
assertEquals(mechanism.toString(), keydata.getString(KEY_MECHANISM));
assertArrayEquals(publicKey.getEncoded(), keydata.getBytes(KEY_PUBLIC_KEY));
}
@Test
public void create() throws MslException, MslEncodingException, MslEntityAuthException, MslCryptoException, MslKeyExchangeException, MslEncoderException {
final RequestData data = new RequestData(KEYPAIR_ID, mechanism, publicKey, privateKey);
final MslObject mo = MslTestUtils.toMslObject(encoder, data);
final KeyRequestData keyRequestData = KeyRequestData.create(ctx, mo);
assertNotNull(keyRequestData);
assertTrue(keyRequestData instanceof RequestData);
final RequestData moData = (RequestData)keyRequestData;
assertEquals(data.getKeyExchangeScheme(), moData.getKeyExchangeScheme());
assertEquals(data.getKeyPairId(), moData.getKeyPairId());
assertEquals(data.getMechanism(), moData.getMechanism());
assertNull(moData.getPrivateKey());
assertArrayEquals(data.getPublicKey().getEncoded(), moData.getPublicKey().getEncoded());
}
@Test
public void missingKeypairId() throws MslException, MslEncodingException, MslCryptoException, MslKeyExchangeException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final RequestData req = new RequestData(KEYPAIR_ID, mechanism, publicKey, privateKey);
final MslObject keydata = req.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata.remove(KEY_KEY_PAIR_ID));
new RequestData(keydata);
}
@Test
public void missingMechanism() throws MslException, MslEncodingException, MslCryptoException, MslKeyExchangeException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final RequestData req = new RequestData(KEYPAIR_ID, mechanism, publicKey, privateKey);
final MslObject keydata = req.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata.remove(KEY_MECHANISM));
new RequestData(keydata);
}
@Test
public void invalidMechanism() throws MslException, MslEncodingException, MslCryptoException, MslKeyExchangeException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.UNIDENTIFIED_KEYX_MECHANISM);
final RequestData req = new RequestData(KEYPAIR_ID, mechanism, publicKey, privateKey);
final MslObject keydata = req.getKeydata(encoder, ENCODER_FORMAT);
keydata.put(KEY_MECHANISM, "x");
new RequestData(keydata);
}
@Test
public void missingPublicKey() throws MslException, MslEncodingException, MslCryptoException, MslKeyExchangeException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final RequestData req = new RequestData(KEYPAIR_ID, mechanism, publicKey, privateKey);
final MslObject keydata = req.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata.remove(KEY_PUBLIC_KEY));
new RequestData(keydata);
}
@Test
public void invalidPublicKey() throws MslException, MslEncodingException, MslCryptoException, MslKeyExchangeException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.INVALID_PUBLIC_KEY);
final RequestData req = new RequestData(KEYPAIR_ID, mechanism, publicKey, privateKey);
final MslObject keydata = req.getKeydata(encoder, ENCODER_FORMAT);
final byte[] encodedKey = publicKey.getEncoded();
final byte[] shortKey = Arrays.copyOf(encodedKey, encodedKey.length / 2);
keydata.put(KEY_PUBLIC_KEY, shortKey);
new RequestData(keydata);
}
}
@Test
public void equalsKeyPairId() throws MslEncodingException, MslCryptoException, MslKeyExchangeException, MslException {
final RequestData dataA = new RequestData(KEYPAIR_ID + "A", Mechanism.JWE_RSA, RSA_PUBLIC_KEY, RSA_PRIVATE_KEY);
final RequestData dataB = new RequestData(KEYPAIR_ID + "B", Mechanism.JWE_RSA, RSA_PUBLIC_KEY, RSA_PRIVATE_KEY);
final RequestData dataA2 = new RequestData(dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
// The private keys don't transfer via the parse constructor.
assertFalse(dataA.equals(dataA2));
assertFalse(dataA2.equals(dataA));
assertTrue(dataA.hashCode() != dataA2.hashCode());
}
@Test
public void equalsMechanism() throws MslEncodingException, MslCryptoException, MslKeyExchangeException, MslException {
final RequestData dataA = new RequestData(KEYPAIR_ID, Mechanism.JWE_RSA, RSA_PUBLIC_KEY, RSA_PRIVATE_KEY);
final RequestData dataB = new RequestData(KEYPAIR_ID, Mechanism.ECC, RSA_PUBLIC_KEY, RSA_PRIVATE_KEY);
final RequestData dataA2 = new RequestData(dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
// The private keys don't transfer via the parse constructor.
assertFalse(dataA.equals(dataA2));
assertFalse(dataA2.equals(dataA));
assertTrue(dataA.hashCode() != dataA2.hashCode());
}
@Test
public void equalsPublicKey() throws MslEncodingException, MslCryptoException, MslKeyExchangeException, MslException {
final RequestData dataA = new RequestData(KEYPAIR_ID, Mechanism.JWE_RSA, RSA_PUBLIC_KEY, RSA_PRIVATE_KEY);
final RequestData dataB = new RequestData(KEYPAIR_ID, Mechanism.JWE_RSA, ECC_PUBLIC_KEY, RSA_PRIVATE_KEY);
final RequestData dataA2 = new RequestData(dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
// The private keys don't transfer via the parse constructor.
assertFalse(dataA.equals(dataA2));
assertFalse(dataA2.equals(dataA));
assertTrue(dataA.hashCode() != dataA2.hashCode());
}
@Test
public void equalsPrivateKey() throws MslEncodingException, MslCryptoException, MslKeyExchangeException, MslException {
final RequestData dataA = new RequestData(KEYPAIR_ID, Mechanism.JWE_RSA, RSA_PUBLIC_KEY, RSA_PRIVATE_KEY);
final RequestData dataB = new RequestData(KEYPAIR_ID, Mechanism.JWE_RSA, RSA_PUBLIC_KEY, ECC_PRIVATE_KEY);
final RequestData dataA2 = new RequestData(dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
// The private keys don't transfer via the parse constructor.
assertFalse(dataA.equals(dataA2));
assertFalse(dataA2.equals(dataA));
assertTrue(dataA.hashCode() != dataA2.hashCode());
}
@Test
public void equalsObject() {
final RequestData data = new RequestData(KEYPAIR_ID, Mechanism.JWE_RSA, RSA_PUBLIC_KEY, RSA_PRIVATE_KEY);
assertFalse(data.equals(null));
assertFalse(data.equals(IDENTITY));
assertTrue(data.hashCode() != IDENTITY.hashCode());
}
}
/** Response data unit tests. */
public static class ResponseDataTest {
/** Key master token. */
private static final String KEY_MASTER_TOKEN = "mastertoken";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@Test
public void ctors() throws MslEncodingException, MslException, MslKeyExchangeException, MslEncoderException {
final ResponseData resp = new ResponseData(MASTER_TOKEN, KEYPAIR_ID, ENCRYPTION_KEY, HMAC_KEY);
assertArrayEquals(ENCRYPTION_KEY, resp.getEncryptionKey());
assertArrayEquals(HMAC_KEY, resp.getHmacKey());
assertEquals(KeyExchangeScheme.ASYMMETRIC_WRAPPED, resp.getKeyExchangeScheme());
assertEquals(KEYPAIR_ID, resp.getKeyPairId());
assertEquals(MASTER_TOKEN, resp.getMasterToken());
final MslObject keydata = resp.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata);
final ResponseData moResp = new ResponseData(MASTER_TOKEN, keydata);
assertArrayEquals(resp.getEncryptionKey(), moResp.getEncryptionKey());
assertArrayEquals(resp.getHmacKey(), moResp.getHmacKey());
assertEquals(resp.getKeyExchangeScheme(), moResp.getKeyExchangeScheme());
assertEquals(resp.getKeyPairId(), moResp.getKeyPairId());
assertEquals(resp.getMasterToken(), moResp.getMasterToken());
final MslObject moKeydata = moResp.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(moKeydata);
assertTrue(MslEncoderUtils.equalObjects(keydata, moKeydata));
}
@Test
public void mslObject() throws MslException, MslEncodingException, MslCryptoException, MslException, MslEncoderException {
final ResponseData resp = new ResponseData(MASTER_TOKEN, KEYPAIR_ID, ENCRYPTION_KEY, HMAC_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, resp);
assertEquals(KeyExchangeScheme.ASYMMETRIC_WRAPPED.toString(), mo.getString(KEY_SCHEME));
final MasterToken masterToken = new MasterToken(ctx, mo.getMslObject(KEY_MASTER_TOKEN, encoder));
assertEquals(MASTER_TOKEN, masterToken);
final MslObject keydata = mo.getMslObject(KEY_KEYDATA, encoder);
assertEquals(KEYPAIR_ID, keydata.getString(KEY_KEY_PAIR_ID));
assertArrayEquals(ENCRYPTION_KEY, keydata.getBytes(KEY_ENCRYPTION_KEY));
assertArrayEquals(HMAC_KEY, keydata.getBytes(KEY_HMAC_KEY));
}
@Test
public void create() throws MslException, MslException, MslEncoderException {
final ResponseData data = new ResponseData(MASTER_TOKEN, KEYPAIR_ID, ENCRYPTION_KEY, HMAC_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, data);
final KeyResponseData keyResponseData = KeyResponseData.create(ctx, mo);
assertNotNull(keyResponseData);
assertTrue(keyResponseData instanceof ResponseData);
final ResponseData moData = (ResponseData)keyResponseData;
assertArrayEquals(data.getEncryptionKey(), moData.getEncryptionKey());
assertArrayEquals(data.getHmacKey(), moData.getHmacKey());
assertEquals(data.getKeyExchangeScheme(), moData.getKeyExchangeScheme());
assertEquals(data.getKeyPairId(), moData.getKeyPairId());
assertEquals(data.getMasterToken(), moData.getMasterToken());
}
@Test
public void missingKeyPairId() throws MslEncodingException, MslException, MslKeyExchangeException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ResponseData resp = new ResponseData(MASTER_TOKEN, KEYPAIR_ID, ENCRYPTION_KEY, HMAC_KEY);
final MslObject keydata = resp.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata.remove(KEY_KEY_PAIR_ID));
new ResponseData(MASTER_TOKEN, keydata);
}
@Test
public void missingEncryptionKey() throws MslException, MslEncodingException, MslKeyExchangeException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ResponseData resp = new ResponseData(MASTER_TOKEN, KEYPAIR_ID, ENCRYPTION_KEY, HMAC_KEY);
final MslObject keydata = resp.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata.remove(KEY_ENCRYPTION_KEY));
new ResponseData(MASTER_TOKEN, keydata);
}
@Test
public void missingHmacKey() throws MslException, MslEncodingException, MslKeyExchangeException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ResponseData resp = new ResponseData(MASTER_TOKEN, KEYPAIR_ID, ENCRYPTION_KEY, HMAC_KEY);
final MslObject keydata = resp.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata.remove(KEY_HMAC_KEY));
new ResponseData(MASTER_TOKEN, keydata);
}
@Test
public void equalsMasterToken() throws MslEncodingException, MslException, MslCryptoException, MslKeyExchangeException, MslEncoderException {
final MasterToken masterTokenA = MslTestUtils.getMasterToken(ctx, 1, 1);
final MasterToken masterTokenB = MslTestUtils.getMasterToken(ctx, 1, 2);
final ResponseData dataA = new ResponseData(masterTokenA, KEYPAIR_ID, ENCRYPTION_KEY, HMAC_KEY);
final ResponseData dataB = new ResponseData(masterTokenB, KEYPAIR_ID, ENCRYPTION_KEY, HMAC_KEY);
final ResponseData dataA2 = new ResponseData(masterTokenA, dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsKeyPairId() throws MslEncodingException, MslException, MslKeyExchangeException, MslEncoderException {
final ResponseData dataA = new ResponseData(MASTER_TOKEN, KEYPAIR_ID + "A", ENCRYPTION_KEY, HMAC_KEY);
final ResponseData dataB = new ResponseData(MASTER_TOKEN, KEYPAIR_ID + "B", ENCRYPTION_KEY, HMAC_KEY);
final ResponseData dataA2 = new ResponseData(MASTER_TOKEN, dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsEncryptionKey() throws MslEncodingException, MslException, MslKeyExchangeException, MslEncoderException {
final byte[] encryptionKeyA = Arrays.copyOf(ENCRYPTION_KEY, ENCRYPTION_KEY.length);
final byte[] encryptionKeyB = Arrays.copyOf(ENCRYPTION_KEY, ENCRYPTION_KEY.length);
++encryptionKeyB[0];
final ResponseData dataA = new ResponseData(MASTER_TOKEN, KEYPAIR_ID, encryptionKeyA, HMAC_KEY);
final ResponseData dataB = new ResponseData(MASTER_TOKEN, KEYPAIR_ID, encryptionKeyB, HMAC_KEY);
final ResponseData dataA2 = new ResponseData(MASTER_TOKEN, dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsHmacKey() throws MslEncodingException, MslException, MslKeyExchangeException, MslEncoderException {
final byte[] hmacKeyA = Arrays.copyOf(HMAC_KEY, HMAC_KEY.length);
final byte[] hmacKeyB = Arrays.copyOf(HMAC_KEY, HMAC_KEY.length);
++hmacKeyB[0];
final ResponseData dataA = new ResponseData(MASTER_TOKEN, KEYPAIR_ID, ENCRYPTION_KEY, hmacKeyA);
final ResponseData dataB = new ResponseData(MASTER_TOKEN, KEYPAIR_ID, ENCRYPTION_KEY, hmacKeyB);
final ResponseData dataA2 = new ResponseData(MASTER_TOKEN, dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsObject() {
final ResponseData data = new ResponseData(MASTER_TOKEN, KEYPAIR_ID, ENCRYPTION_KEY, HMAC_KEY);
assertFalse(data.equals(null));
assertFalse(data.equals(IDENTITY));
assertTrue(data.hashCode() != IDENTITY.hashCode());
}
}
/** Key exchange factory unit tests. */
public static class KeyExchangeFactoryTest {
/**
* Fake key request data for the asymmetric wrapped key exchange
* scheme.
*/
private static class FakeKeyRequestData extends KeyRequestData {
/** Create a new fake key request data. */
protected FakeKeyRequestData() {
super(KeyExchangeScheme.ASYMMETRIC_WRAPPED);
}
/* (non-Javadoc)
* @see com.netflix.msl.keyx.KeyRequestData#getKeydata(com.netflix.msl.io.MslEncoderFactory, com.netflix.msl.io.MslEncoderFormat)
*/
@Override
protected MslObject getKeydata(final MslEncoderFactory encoder, final MslEncoderFormat format) throws MslEncoderException {
return null;
}
}
/**
* Fake key response data for the asymmetric wrapped key exchange
* scheme.
*/
private static class FakeKeyResponseData extends KeyResponseData {
/** Create a new fake key response data. */
protected FakeKeyResponseData() {
super(MASTER_TOKEN, KeyExchangeScheme.ASYMMETRIC_WRAPPED);
}
/* (non-Javadoc)
* @see com.netflix.msl.keyx.KeyResponseData#getKeydata(com.netflix.msl.io.MslEncoderFactory, com.netflix.msl.io.MslEncoderFormat)
*/
@Override
protected MslObject getKeydata(final MslEncoderFactory encoder, final MslEncoderFormat format) throws MslEncoderException {
return null;
}
}
/**
* @param ctx MSL context.
* @param encryptionKey master token encryption key.
* @param hmacKey master token HMAC key.
* @return a new master token.
* @throws MslEncodingException if there is an error encoding the data.
* @throws MslCryptoException if there is an error encrypting or signing
* the token data.
* @throws MslException if the master token is constructed incorrectly.
* @throws MslException if there is an error editing the data.
* @throws MslEncoderException if there is an error modifying the data.
*/
private static MasterToken getUntrustedMasterToken(final MslContext ctx, final SecretKey encryptionKey, final SecretKey hmacKey) throws MslEncodingException, MslCryptoException, MslException, MslException, MslEncoderException {
final Date renewalWindow = new Date(System.currentTimeMillis() + 1000);
final Date expiration = new Date(System.currentTimeMillis() + 2000);
final String identity = MockPresharedAuthenticationFactory.PSK_ESN;
final MasterToken masterToken = new MasterToken(ctx, renewalWindow, expiration, 1L, 1L, null, identity, encryptionKey, hmacKey);
final MslObject mo = MslTestUtils.toMslObject(encoder, masterToken);
final byte[] signature = mo.getBytes("signature");
++signature[1];
mo.put("signature", signature);
final MasterToken untrustedMasterToken = new MasterToken(ctx, mo);
return untrustedMasterToken;
}
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@BeforeClass
public static synchronized void setup() {
Security.addProvider(new BouncyCastleProvider());
random = new Random();
authutils = new MockAuthenticationUtils();
factory = new AsymmetricWrappedExchange(authutils);
entityAuthData = new PresharedAuthenticationData(IDENTITY);
}
@AfterClass
public static void teardown() {
// Do not cleanup so the static instances are available to
// subclasses.
}
@Before
public void reset() {
authutils.reset();
ctx.getMslStore().clearCryptoContexts();
ctx.getMslStore().clearServiceTokens();
}
@RunWith(Parameterized.class)
public static class Params {
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@Parameters
public static Collection<Object[]> data() throws NoSuchAlgorithmException, InvalidAlgorithmParameterException, MslEncodingException, MslCryptoException {
AsymmetricWrappedExchangeSuite.setup();
return Arrays.asList(new Object[][] {
{ Mechanism.RSA, RSA_PUBLIC_KEY, RSA_PRIVATE_KEY },
{ Mechanism.JWE_RSA, RSA_PUBLIC_KEY, RSA_PRIVATE_KEY },
{ Mechanism.JWEJS_RSA, RSA_PUBLIC_KEY, RSA_PRIVATE_KEY },
{ Mechanism.JWK_RSA, RSA_PUBLIC_KEY, RSA_PRIVATE_KEY },
{ Mechanism.JWK_RSAES, RSA_PUBLIC_KEY, RSA_PRIVATE_KEY },
});
}
/** Key exchange mechanism. */
private final Mechanism mechanism;
/** Public key. */
private final PublicKey publicKey;
/** Private key. */
private final PrivateKey privateKey;
/**
* Create a new request data test instance with the specified key
* exchange parameters.
*
* @param mechanism key exchange mechanism.
* @param publicKey public key.
* @param privateKey private key.
*/
public Params(final Mechanism mechanism, final PublicKey publicKey, final PrivateKey privateKey) {
this.mechanism = mechanism;
this.publicKey = publicKey;
this.privateKey = privateKey;
}
@Test
public void generateInitialResponse() throws MslException, MslException {
final KeyRequestData keyRequestData = new RequestData(KEYPAIR_ID, mechanism, publicKey, privateKey);
final KeyExchangeData keyxData = factory.generateResponse(ctx, ENCODER_FORMAT, keyRequestData, entityAuthData);
assertNotNull(keyxData);
assertNotNull(keyxData.cryptoContext);
assertNotNull(keyxData.keyResponseData);
final KeyResponseData keyResponseData = keyxData.keyResponseData;
assertEquals(KeyExchangeScheme.ASYMMETRIC_WRAPPED, keyResponseData.getKeyExchangeScheme());
final MasterToken masterToken = keyResponseData.getMasterToken();
assertNotNull(masterToken);
assertEquals(IDENTITY, masterToken.getIdentity());
}
@Test
public void generateSubsequentResponse() throws MslException {
final KeyRequestData keyRequestData = new RequestData(KEYPAIR_ID, mechanism, publicKey, privateKey);
final KeyExchangeData keyxData = factory.generateResponse(ctx, ENCODER_FORMAT, keyRequestData, MASTER_TOKEN);
assertNotNull(keyxData);
assertNotNull(keyxData.cryptoContext);
assertNotNull(keyxData.keyResponseData);
final KeyResponseData keyResponseData = keyxData.keyResponseData;
assertEquals(KeyExchangeScheme.ASYMMETRIC_WRAPPED, keyResponseData.getKeyExchangeScheme());
final MasterToken masterToken = keyResponseData.getMasterToken();
assertNotNull(masterToken);
assertEquals(MASTER_TOKEN.getIdentity(), masterToken.getIdentity());
assertEquals(MASTER_TOKEN.getSerialNumber(), masterToken.getSerialNumber());
assertEquals(MASTER_TOKEN.getSequenceNumber() + 1, masterToken.getSequenceNumber());
}
@Test
public void untrustedMasterTokenSubsequentResponse() throws MslEncodingException, MslCryptoException, MslException, MslException, MslEncoderException {
thrown.expect(MslMasterTokenException.class);
final KeyRequestData keyRequestData = new RequestData(KEYPAIR_ID, mechanism, publicKey, privateKey);
final SecretKey encryptionKey = MockPresharedAuthenticationFactory.KPE;
final SecretKey hmacKey = MockPresharedAuthenticationFactory.KPH;
final MasterToken masterToken = getUntrustedMasterToken(ctx, encryptionKey, hmacKey);
factory.generateResponse(ctx, ENCODER_FORMAT, keyRequestData, masterToken);
}
@Test
public void getCryptoContext() throws MslException {
final KeyRequestData keyRequestData = new RequestData(KEYPAIR_ID, mechanism, publicKey, privateKey);
final KeyExchangeData keyxData = factory.generateResponse(ctx, ENCODER_FORMAT, keyRequestData, entityAuthData);
final ICryptoContext requestCryptoContext = keyxData.cryptoContext;
final KeyResponseData keyResponseData = keyxData.keyResponseData;
final ICryptoContext responseCryptoContext = factory.getCryptoContext(ctx, keyRequestData, keyResponseData, null);
assertNotNull(responseCryptoContext);
final byte[] data = new byte[32];
random.nextBytes(data);
// Ciphertext won't always be equal depending on how it was
// enveloped. So we cannot check for equality or inequality.
final byte[] requestCiphertext = requestCryptoContext.encrypt(data, encoder, ENCODER_FORMAT);
final byte[] responseCiphertext = responseCryptoContext.encrypt(data, encoder, ENCODER_FORMAT);
assertFalse(Arrays.equals(data, requestCiphertext));
assertFalse(Arrays.equals(data, responseCiphertext));
// Signatures should always be equal.
final byte[] requestSignature = requestCryptoContext.sign(data, encoder, ENCODER_FORMAT);
final byte[] responseSignature = responseCryptoContext.sign(data, encoder, ENCODER_FORMAT);
assertFalse(Arrays.equals(data, requestSignature));
assertFalse(Arrays.equals(data, responseSignature));
assertArrayEquals(requestSignature, responseSignature);
// Plaintext should always be equal to the original message.
final byte[] requestPlaintext = requestCryptoContext.decrypt(responseCiphertext, encoder);
final byte[] responsePlaintext = responseCryptoContext.decrypt(requestCiphertext, encoder);
assertNotNull(requestPlaintext);
assertArrayEquals(data, requestPlaintext);
assertArrayEquals(requestPlaintext, responsePlaintext);
// Verification should always succeed.
assertTrue(requestCryptoContext.verify(data, responseSignature, encoder));
assertTrue(responseCryptoContext.verify(data, requestSignature, encoder));
}
@Test
public void invalidWrappedEncryptionKeyCryptoContext() throws MslException, MslException, MslEncoderException {
thrown.expect(MslCryptoException.class);
final KeyRequestData keyRequestData = new RequestData(KEYPAIR_ID, mechanism, publicKey, privateKey);
final KeyExchangeData keyxData = factory.generateResponse(ctx, ENCODER_FORMAT, keyRequestData, entityAuthData);
final KeyResponseData keyResponseData = keyxData.keyResponseData;
final MasterToken masterToken = keyResponseData.getMasterToken();
final MslObject keydata = keyResponseData.getKeydata(encoder, ENCODER_FORMAT);
final byte[] wrappedEncryptionKey = keydata.getBytes(KEY_ENCRYPTION_KEY);
// I think I have to change length - 2 because of padding.
++wrappedEncryptionKey[wrappedEncryptionKey.length-2];
keydata.put(KEY_ENCRYPTION_KEY, wrappedEncryptionKey);
final byte[] wrappedHmacKey = keydata.getBytes(KEY_HMAC_KEY);
final KeyResponseData invalidKeyResponseData = new ResponseData(masterToken, KEYPAIR_ID, wrappedEncryptionKey, wrappedHmacKey);
factory.getCryptoContext(ctx, keyRequestData, invalidKeyResponseData, null);
}
@Test
public void invalidWrappedHmacKeyCryptoContext() throws MslException, MslException, MslEncoderException {
thrown.expect(MslCryptoException.class);
final KeyRequestData keyRequestData = new RequestData(KEYPAIR_ID, mechanism, publicKey, privateKey);
final KeyExchangeData keyxData = factory.generateResponse(ctx, ENCODER_FORMAT, keyRequestData, entityAuthData);
final KeyResponseData keyResponseData = keyxData.keyResponseData;
final MasterToken masterToken = keyResponseData.getMasterToken();
final MslObject keydata = keyResponseData.getKeydata(encoder, ENCODER_FORMAT);
final byte[] wrappedHmacKey = keydata.getBytes(KEY_HMAC_KEY);
// I think I have to change length - 2 because of padding.
++wrappedHmacKey[wrappedHmacKey.length-2];
keydata.put(KEY_HMAC_KEY, wrappedHmacKey);
final byte[] wrappedEncryptionKey = keydata.getBytes(KEY_ENCRYPTION_KEY);
final KeyResponseData invalidKeyResponseData = new ResponseData(masterToken, KEYPAIR_ID, wrappedEncryptionKey, wrappedHmacKey);
factory.getCryptoContext(ctx, keyRequestData, invalidKeyResponseData, null);
}
}
@Test
public void factory() {
assertEquals(KeyExchangeScheme.ASYMMETRIC_WRAPPED, factory.getScheme());
}
@Test(expected = MslInternalException.class)
public void wrongRequestInitialResponse() throws MslInternalException, MslException {
final KeyRequestData keyRequestData = new FakeKeyRequestData();
factory.generateResponse(ctx, ENCODER_FORMAT, keyRequestData, entityAuthData);
}
@Test(expected = MslInternalException.class)
public void wrongRequestSubsequentResponse() throws MslInternalException, MslException {
final KeyRequestData keyRequestData = new FakeKeyRequestData();
factory.generateResponse(ctx, ENCODER_FORMAT, keyRequestData, MASTER_TOKEN);
}
@Test(expected = MslInternalException.class)
public void wrongRequestCryptoContext() throws MslException {
final KeyRequestData keyRequestData = new RequestData(KEYPAIR_ID, Mechanism.JWE_RSA, RSA_PUBLIC_KEY, RSA_PRIVATE_KEY);
final KeyExchangeData keyxData = factory.generateResponse(ctx, ENCODER_FORMAT, keyRequestData, entityAuthData);
final KeyResponseData keyResponseData = keyxData.keyResponseData;
final KeyRequestData fakeKeyRequestData = new FakeKeyRequestData();
factory.getCryptoContext(ctx, fakeKeyRequestData, keyResponseData, null);
}
@Test(expected = MslInternalException.class)
public void wrongResponseCryptoContext() throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslMasterTokenException, MslEntityAuthException {
final KeyRequestData keyRequestData = new RequestData(KEYPAIR_ID, Mechanism.JWE_RSA, RSA_PUBLIC_KEY, RSA_PRIVATE_KEY);
final KeyResponseData fakeKeyResponseData = new FakeKeyResponseData();
factory.getCryptoContext(ctx, keyRequestData, fakeKeyResponseData, null);
}
@Test
public void keyIdMismatchCryptoContext() throws MslException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.KEYX_RESPONSE_REQUEST_MISMATCH);
final KeyRequestData keyRequestData = new RequestData(KEYPAIR_ID + "A", Mechanism.JWE_RSA, RSA_PUBLIC_KEY, RSA_PRIVATE_KEY);
final KeyExchangeData keyxData = factory.generateResponse(ctx, ENCODER_FORMAT, keyRequestData, entityAuthData);
final KeyResponseData keyResponseData = keyxData.keyResponseData;
final MasterToken masterToken = keyResponseData.getMasterToken();
final KeyResponseData mismatchedKeyResponseData = new ResponseData(masterToken, KEYPAIR_ID + "B", ENCRYPTION_KEY, HMAC_KEY);
factory.getCryptoContext(ctx, keyRequestData, mismatchedKeyResponseData, null);
}
@Test
public void missingPrivateKeyCryptoContext() throws MslException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.KEYX_PRIVATE_KEY_MISSING);
final KeyRequestData keyRequestData = new RequestData(KEYPAIR_ID + "B", Mechanism.JWE_RSA, RSA_PUBLIC_KEY, null);
final KeyExchangeData keyxData = factory.generateResponse(ctx, ENCODER_FORMAT, keyRequestData, entityAuthData);
final KeyResponseData keyResponseData = keyxData.keyResponseData;
factory.getCryptoContext(ctx, keyRequestData, keyResponseData, null);
}
/** Random. */
private static Random random;
/** Authentication utilities. */
private static MockAuthenticationUtils authutils;
/** Key exchange factory. */
private static KeyExchangeFactory factory;
/** Entity authentication data. */
private static EntityAuthenticationData entityAuthData;
}
}
| 9,962 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/keyx/SymmetricWrappedExchangeSuite.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.keyx;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.security.InvalidAlgorithmParameterException;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Date;
import java.util.Random;
import javax.crypto.SecretKey;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.MslKeyExchangeException;
import com.netflix.msl.MslMasterTokenException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.entityauth.EntityAuthenticationData;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.entityauth.MockPresharedAuthenticationFactory;
import com.netflix.msl.entityauth.PresharedAuthenticationData;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.keyx.KeyExchangeFactory.KeyExchangeData;
import com.netflix.msl.keyx.SymmetricWrappedExchange.KeyId;
import com.netflix.msl.keyx.SymmetricWrappedExchange.RequestData;
import com.netflix.msl.keyx.SymmetricWrappedExchange.ResponseData;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.tokens.MasterToken;
import com.netflix.msl.util.MockAuthenticationUtils;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* Symmetric wrapped key exchange unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
@RunWith(Suite.class)
@SuiteClasses({SymmetricWrappedExchangeSuite.KeyExchangeFactoryTest.class,
SymmetricWrappedExchangeSuite.RequestDataTest.class,
SymmetricWrappedExchangeSuite.ResponseDataTest.class})
public class SymmetricWrappedExchangeSuite {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key key exchange scheme. */
private static final String KEY_SCHEME = "scheme";
/** Key key request data. */
private static final String KEY_KEYDATA = "keydata";
/** Key symmetric key ID. */
private static final String KEY_KEY_ID = "keyid";
/** Key wrapped encryption key. */
private static final String KEY_ENCRYPTION_KEY = "encryptionkey";
/** Key wrapped HMAC key. */
private static final String KEY_HMAC_KEY = "hmackey";
private static MasterToken PSK_MASTER_TOKEN;
private static final byte[] ENCRYPTION_KEY = new byte[16];
private static final byte[] HMAC_KEY = new byte[32];
/** Random. */
private static Random random;
/** Preshared keys entity context. */
private static MslContext pskCtx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
/** Unauthenticated (server) entity context. */
private static MslContext unauthCtx;
@BeforeClass
public static synchronized void setup() throws NoSuchAlgorithmException, InvalidAlgorithmParameterException, MslEncodingException, MslCryptoException {
if (random == null) {
random = new Random();
pskCtx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = pskCtx.getMslEncoderFactory();
PSK_MASTER_TOKEN = MslTestUtils.getMasterToken(pskCtx, 1, 1);
unauthCtx = new MockMslContext(EntityAuthenticationScheme.NONE, false);
random.nextBytes(ENCRYPTION_KEY);
random.nextBytes(HMAC_KEY);
}
}
@AfterClass
public static synchronized void teardown() {
// Teardown causes problems because the data is shared by the inner
// classes, so don't do any cleanup.
}
/** Request data unit tests. */
public static class RequestDataTest {
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@Test
public void ctorsPsk() throws MslException, MslEncodingException, MslKeyExchangeException, MslEncoderException {
final RequestData req = new RequestData(KeyId.PSK);
assertEquals(KeyExchangeScheme.SYMMETRIC_WRAPPED, req.getKeyExchangeScheme());
assertEquals(KeyId.PSK, req.getKeyId());
final MslObject keydata = req.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata);
final RequestData moReq = new RequestData(keydata);
assertEquals(req.getKeyExchangeScheme(), moReq.getKeyExchangeScheme());
assertEquals(req.getKeyId(), moReq.getKeyId());
final MslObject moKeydata = moReq.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(moKeydata);
assertTrue(MslEncoderUtils.equalObjects(keydata, moKeydata));
}
@Test
public void ctorsSession() throws MslException, MslEncodingException, MslKeyExchangeException, MslEncoderException {
final RequestData req = new RequestData(KeyId.SESSION);
assertEquals(KeyExchangeScheme.SYMMETRIC_WRAPPED, req.getKeyExchangeScheme());
assertEquals(KeyId.SESSION, req.getKeyId());
final MslObject keydata = req.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata);
final RequestData moReq = new RequestData(keydata);
assertEquals(req.getKeyExchangeScheme(), moReq.getKeyExchangeScheme());
assertEquals(req.getKeyId(), moReq.getKeyId());
final MslObject moKeydata = moReq.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(moKeydata);
assertTrue(MslEncoderUtils.equalObjects(keydata, moKeydata));
}
@Test
public void mslObject() throws MslException, MslEncoderException {
final RequestData req = new RequestData(KeyId.PSK);
final MslObject mo = MslTestUtils.toMslObject(encoder, req);
assertEquals(KeyExchangeScheme.SYMMETRIC_WRAPPED.toString(), mo.getString(KEY_SCHEME));
final MslObject keydata = mo.getMslObject(KEY_KEYDATA, encoder);
assertEquals(KeyId.PSK.toString(), keydata.getString(KEY_KEY_ID));
}
@Test
public void create() throws MslException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslCryptoException, MslEncoderException {
final RequestData data = new RequestData(KeyId.PSK);
final MslObject mo = MslTestUtils.toMslObject(encoder, data);
final KeyRequestData keyRequestData = KeyRequestData.create(pskCtx, mo);
assertNotNull(keyRequestData);
assertTrue(keyRequestData instanceof RequestData);
final RequestData moData = (RequestData)keyRequestData;
assertEquals(data.getKeyExchangeScheme(), moData.getKeyExchangeScheme());
assertEquals(data.getKeyId(), moData.getKeyId());
}
@Test
public void missingKeyId() throws MslException, MslEncodingException, MslKeyExchangeException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final RequestData req = new RequestData(KeyId.PSK);
final MslObject keydata = req.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata.remove(KEY_KEY_ID));
new RequestData(keydata);
}
@Test
public void invalidKeyId() throws MslException, MslEncodingException, MslCryptoException, MslKeyExchangeException, MslEncoderException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.UNIDENTIFIED_KEYX_KEY_ID);
final RequestData req = new RequestData(KeyId.PSK);
final MslObject keydata = req.getKeydata(encoder, ENCODER_FORMAT);
keydata.put(KEY_KEY_ID, "x");
new RequestData(keydata);
}
@Test
public void equalsKeyId() throws MslEncodingException, MslKeyExchangeException, MslException, MslEncoderException {
final RequestData dataA = new RequestData(KeyId.PSK);
final RequestData dataB = new RequestData(KeyId.SESSION);
final RequestData dataA2 = new RequestData(dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsObject() {
final RequestData data = new RequestData(KeyId.PSK);
assertFalse(data.equals(null));
assertFalse(data.equals(KEY_KEY_ID));
assertTrue(data.hashCode() != KEY_KEY_ID.hashCode());
}
}
/** Response data unit tests. */
public static class ResponseDataTest {
/** Key master token. */
private static final String KEY_MASTER_TOKEN = "mastertoken";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@Test
public void ctors() throws MslException, MslEncodingException, MslKeyExchangeException, MslEncoderException {
final ResponseData resp = new ResponseData(PSK_MASTER_TOKEN, KeyId.PSK, ENCRYPTION_KEY, HMAC_KEY);
assertArrayEquals(ENCRYPTION_KEY, resp.getEncryptionKey());
assertArrayEquals(HMAC_KEY, resp.getHmacKey());
assertEquals(KeyExchangeScheme.SYMMETRIC_WRAPPED, resp.getKeyExchangeScheme());
assertEquals(KeyId.PSK, resp.getKeyId());
assertEquals(PSK_MASTER_TOKEN, resp.getMasterToken());
final MslObject keydata = resp.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata);
final ResponseData moResp = new ResponseData(PSK_MASTER_TOKEN, keydata);
assertArrayEquals(resp.getEncryptionKey(), moResp.getEncryptionKey());
assertArrayEquals(resp.getHmacKey(), moResp.getHmacKey());
assertEquals(resp.getKeyExchangeScheme(), moResp.getKeyExchangeScheme());
assertEquals(resp.getKeyId(), moResp.getKeyId());
assertEquals(resp.getMasterToken(), moResp.getMasterToken());
final MslObject moKeydata = resp.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(moKeydata);
assertTrue(MslEncoderUtils.equalObjects(keydata, moKeydata));
}
@Test
public void mslObject() throws MslException, MslEncodingException, MslCryptoException, MslException, MslEncoderException {
final ResponseData resp = new ResponseData(PSK_MASTER_TOKEN, KeyId.PSK, ENCRYPTION_KEY, HMAC_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, resp);
assertEquals(KeyExchangeScheme.SYMMETRIC_WRAPPED.toString(), mo.getString(KEY_SCHEME));
final MasterToken masterToken = new MasterToken(pskCtx, mo.getMslObject(KEY_MASTER_TOKEN, encoder));
assertEquals(PSK_MASTER_TOKEN, masterToken);
final MslObject keydata = mo.getMslObject(KEY_KEYDATA, encoder);
assertEquals(KeyId.PSK.toString(), keydata.getString(KEY_KEY_ID));
assertArrayEquals(ENCRYPTION_KEY, keydata.getBytes(KEY_ENCRYPTION_KEY));
assertArrayEquals(HMAC_KEY, keydata.getBytes(KEY_HMAC_KEY));
}
@Test
public void create() throws MslException, MslException, MslEncoderException {
final ResponseData data = new ResponseData(PSK_MASTER_TOKEN, KeyId.PSK, ENCRYPTION_KEY, HMAC_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, data);
final KeyResponseData keyResponseData = KeyResponseData.create(pskCtx, mo);
assertNotNull(keyResponseData);
assertTrue(keyResponseData instanceof ResponseData);
final ResponseData moData = (ResponseData)keyResponseData;
assertArrayEquals(data.getEncryptionKey(), moData.getEncryptionKey());
assertArrayEquals(data.getHmacKey(), moData.getHmacKey());
assertEquals(data.getKeyExchangeScheme(), moData.getKeyExchangeScheme());
assertEquals(data.getKeyId(), moData.getKeyId());
assertEquals(data.getMasterToken(), moData.getMasterToken());
}
@Test
public void missingKeyId() throws MslEncodingException, MslException, MslKeyExchangeException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ResponseData resp = new ResponseData(PSK_MASTER_TOKEN, KeyId.PSK, ENCRYPTION_KEY, HMAC_KEY);
final MslObject keydata = resp.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata.remove(KEY_KEY_ID));
new ResponseData(PSK_MASTER_TOKEN, keydata);
}
@Test
public void missingEncryptionKey() throws MslException, MslEncodingException, MslKeyExchangeException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ResponseData resp = new ResponseData(PSK_MASTER_TOKEN, KeyId.PSK, ENCRYPTION_KEY, HMAC_KEY);
final MslObject keydata = resp.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata.remove(KEY_ENCRYPTION_KEY));
new ResponseData(PSK_MASTER_TOKEN, keydata);
}
@Test
public void missingHmacKey() throws MslException, MslEncodingException, MslKeyExchangeException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ResponseData resp = new ResponseData(PSK_MASTER_TOKEN, KeyId.PSK, ENCRYPTION_KEY, HMAC_KEY);
final MslObject keydata = resp.getKeydata(encoder, ENCODER_FORMAT);
assertNotNull(keydata.remove(KEY_HMAC_KEY));
new ResponseData(PSK_MASTER_TOKEN, keydata);
}
@Test
public void equalsMasterToken() throws MslEncodingException, MslCryptoException, MslKeyExchangeException, MslException {
final MasterToken masterTokenA = MslTestUtils.getMasterToken(pskCtx, 1, 1);
final MasterToken masterTokenB = MslTestUtils.getMasterToken(pskCtx, 1, 2);
final ResponseData dataA = new ResponseData(masterTokenA, KeyId.PSK, ENCRYPTION_KEY, HMAC_KEY);
final ResponseData dataB = new ResponseData(masterTokenB, KeyId.PSK, ENCRYPTION_KEY, HMAC_KEY);
final ResponseData dataA2 = new ResponseData(masterTokenA, dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsKeyId() throws MslEncodingException, MslKeyExchangeException, MslException {
final ResponseData dataA = new ResponseData(PSK_MASTER_TOKEN, KeyId.PSK, ENCRYPTION_KEY, HMAC_KEY);
final ResponseData dataB = new ResponseData(PSK_MASTER_TOKEN, KeyId.SESSION, ENCRYPTION_KEY, HMAC_KEY);
final ResponseData dataA2 = new ResponseData(PSK_MASTER_TOKEN, dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsEncryptionKey() throws MslEncodingException, MslKeyExchangeException, MslException {
final byte[] encryptionKeyA = Arrays.copyOf(ENCRYPTION_KEY, ENCRYPTION_KEY.length);
final byte[] encryptionKeyB = Arrays.copyOf(ENCRYPTION_KEY, ENCRYPTION_KEY.length);
++encryptionKeyB[0];
final ResponseData dataA = new ResponseData(PSK_MASTER_TOKEN, KeyId.PSK, encryptionKeyA, HMAC_KEY);
final ResponseData dataB = new ResponseData(PSK_MASTER_TOKEN, KeyId.PSK, encryptionKeyB, HMAC_KEY);
final ResponseData dataA2 = new ResponseData(PSK_MASTER_TOKEN, dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsHmacKey() throws MslEncodingException, MslKeyExchangeException, MslException {
final byte[] hmacKeyA = Arrays.copyOf(HMAC_KEY, HMAC_KEY.length);
final byte[] hmacKeyB = Arrays.copyOf(HMAC_KEY, HMAC_KEY.length);
++hmacKeyB[0];
final ResponseData dataA = new ResponseData(PSK_MASTER_TOKEN, KeyId.PSK, ENCRYPTION_KEY, hmacKeyA);
final ResponseData dataB = new ResponseData(PSK_MASTER_TOKEN, KeyId.PSK, ENCRYPTION_KEY, hmacKeyB);
final ResponseData dataA2 = new ResponseData(PSK_MASTER_TOKEN, dataA.getKeydata(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsObject() {
final ResponseData data = new ResponseData(PSK_MASTER_TOKEN, KeyId.PSK, ENCRYPTION_KEY, HMAC_KEY);
assertFalse(data.equals(null));
assertFalse(data.equals(KEY_KEY_ID));
assertTrue(data.hashCode() != KEY_KEY_ID.hashCode());
}
}
/** Key exchange factory unit tests. */
public static class KeyExchangeFactoryTest {
/**
* Fake key request data for the asymmetric wrapped key exchange
* scheme.
*/
private static class FakeKeyRequestData extends KeyRequestData {
/** Create a new fake key request data. */
protected FakeKeyRequestData() {
super(KeyExchangeScheme.SYMMETRIC_WRAPPED);
}
/* (non-Javadoc)
* @see com.netflix.msl.keyx.KeyRequestData#getKeydata(com.netflix.msl.io.MslEncoderFactory, com.netflix.msl.io.MslEncoderFormat)
*/
@Override
protected MslObject getKeydata(final MslEncoderFactory encoder, final MslEncoderFormat format) throws MslEncoderException {
return null;
}
}
/**
* Fake key response data for the asymmetric wrapped key exchange
* scheme.
*/
private static class FakeKeyResponseData extends KeyResponseData {
/** Create a new fake key response data. */
protected FakeKeyResponseData() {
super(PSK_MASTER_TOKEN, KeyExchangeScheme.SYMMETRIC_WRAPPED);
}
/* (non-Javadoc)
* @see com.netflix.msl.keyx.KeyResponseData#getKeydata(com.netflix.msl.io.MslEncoderFactory, com.netflix.msl.io.MslEncoderFormat)
*/
@Override
protected MslObject getKeydata(final MslEncoderFactory encoder, final MslEncoderFormat format) throws MslEncoderException {
return null;
}
}
/**
* @param ctx MSL context.
* @param identity entity identity.
* @param encryptionKey master token encryption key.
* @param hmacKey master token HMAC key.
* @return a new master token.
* @throws MslException if the master token is constructed incorrectly.
* @throws MslEncoderException if there is an error editing the data.
*/
private static MasterToken getUntrustedMasterToken(final MslContext ctx, final String identity, final SecretKey encryptionKey, final SecretKey hmacKey) throws MslEncoderException, MslException {
final Date renewalWindow = new Date(System.currentTimeMillis() + 1000);
final Date expiration = new Date(System.currentTimeMillis() + 2000);
final MasterToken masterToken = new MasterToken(ctx, renewalWindow, expiration, 1L, 1L, null, identity, encryptionKey, hmacKey);
final MslObject mo = MslTestUtils.toMslObject(encoder, masterToken);
final byte[] signature = mo.getBytes("signature");
++signature[1];
mo.put("signature", signature);
final MasterToken untrustedMasterToken = new MasterToken(ctx, mo);
return untrustedMasterToken;
}
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@BeforeClass
public static void setup() throws NoSuchAlgorithmException, InvalidAlgorithmParameterException, MslEncodingException, MslCryptoException {
SymmetricWrappedExchangeSuite.setup();
authutils = new MockAuthenticationUtils();
factory = new SymmetricWrappedExchange(authutils);
entityAuthData = new PresharedAuthenticationData(MockPresharedAuthenticationFactory.PSK_ESN);
}
@AfterClass
public static void teardown() {
entityAuthData = null;
factory = null;
authutils = null;
}
@Before
public void reset() {
authutils.reset();
pskCtx.getMslStore().clearCryptoContexts();
pskCtx.getMslStore().clearServiceTokens();
}
@Test
public void factory() {
assertEquals(KeyExchangeScheme.SYMMETRIC_WRAPPED, factory.getScheme());
}
@Test
public void generatePskInitialResponse() throws MslException {
final KeyRequestData keyRequestData = new RequestData(KeyId.PSK);
final KeyExchangeData keyxData = factory.generateResponse(unauthCtx, ENCODER_FORMAT, keyRequestData, entityAuthData);
assertNotNull(keyxData);
assertNotNull(keyxData.cryptoContext);
assertNotNull(keyxData.keyResponseData);
final KeyResponseData keyResponseData = keyxData.keyResponseData;
assertEquals(KeyExchangeScheme.SYMMETRIC_WRAPPED, keyResponseData.getKeyExchangeScheme());
final MasterToken masterToken = keyResponseData.getMasterToken();
assertNotNull(masterToken);
assertEquals(MockPresharedAuthenticationFactory.PSK_ESN, masterToken.getIdentity());
}
@Ignore
@Test
public void generateSessionInitialResponse() throws MslException {
final KeyRequestData keyRequestData = new RequestData(KeyId.SESSION);
final KeyExchangeData keyxData = factory.generateResponse(unauthCtx, ENCODER_FORMAT, keyRequestData, PSK_MASTER_TOKEN);
assertNotNull(keyxData);
assertNotNull(keyxData.cryptoContext);
assertNotNull(keyxData.keyResponseData);
final KeyResponseData keyResponseData = keyxData.keyResponseData;
assertEquals(KeyExchangeScheme.SYMMETRIC_WRAPPED, keyResponseData.getKeyExchangeScheme());
final MasterToken masterToken = keyResponseData.getMasterToken();
assertNotNull(masterToken);
assertEquals(PSK_MASTER_TOKEN.getIdentity(), masterToken.getIdentity());
}
@Test(expected = MslEntityAuthException.class)
public void invalidPskInitialResponse() throws MslException {
final KeyRequestData keyRequestData = new RequestData(KeyId.PSK);
final EntityAuthenticationData entityAuthData = new PresharedAuthenticationData(MockPresharedAuthenticationFactory.PSK_ESN + "x");
factory.generateResponse(unauthCtx, ENCODER_FORMAT, keyRequestData, entityAuthData);
}
@Test(expected = MslInternalException.class)
public void wrongRequestInitialResponse() throws MslInternalException, MslException {
final KeyRequestData keyRequestData = new FakeKeyRequestData();
factory.generateResponse(unauthCtx, ENCODER_FORMAT, keyRequestData, entityAuthData);
}
@Test
public void generatePskSubsequentResponse() throws MslException {
final KeyRequestData keyRequestData = new RequestData(KeyId.PSK);
final KeyExchangeData keyxData = factory.generateResponse(unauthCtx, ENCODER_FORMAT, keyRequestData, PSK_MASTER_TOKEN);
assertNotNull(keyxData);
assertNotNull(keyxData.cryptoContext);
assertNotNull(keyxData.keyResponseData);
final KeyResponseData keyResponseData = keyxData.keyResponseData;
assertEquals(KeyExchangeScheme.SYMMETRIC_WRAPPED, keyResponseData.getKeyExchangeScheme());
final MasterToken masterToken = keyResponseData.getMasterToken();
assertNotNull(masterToken);
assertEquals(PSK_MASTER_TOKEN.getIdentity(), masterToken.getIdentity());
assertEquals(PSK_MASTER_TOKEN.getSerialNumber(), masterToken.getSerialNumber());
assertEquals(PSK_MASTER_TOKEN.getSequenceNumber() + 1, masterToken.getSequenceNumber());
}
@Ignore
@Test
public void generateSessionSubsequentResponse() throws MslException {
final KeyRequestData keyRequestData = new RequestData(KeyId.SESSION);
final KeyExchangeData keyxData = factory.generateResponse(unauthCtx, ENCODER_FORMAT, keyRequestData, PSK_MASTER_TOKEN);
assertNotNull(keyxData);
assertNotNull(keyxData.cryptoContext);
assertNotNull(keyxData.keyResponseData);
final KeyResponseData keyResponseData = keyxData.keyResponseData;
assertEquals(KeyExchangeScheme.SYMMETRIC_WRAPPED, keyResponseData.getKeyExchangeScheme());
final MasterToken masterToken = keyResponseData.getMasterToken();
assertNotNull(masterToken);
assertEquals(PSK_MASTER_TOKEN.getIdentity(), masterToken.getIdentity());
assertEquals(PSK_MASTER_TOKEN.getSerialNumber(), masterToken.getSerialNumber());
assertEquals(PSK_MASTER_TOKEN.getSequenceNumber() + 1, masterToken.getSequenceNumber());
}
@Test
public void untrustedMasterTokenPskSubsequentResponse() throws MslInternalException, MslException, MslException, MslEncoderException {
thrown.expect(MslMasterTokenException.class);
thrown.expectMslError(MslError.MASTERTOKEN_UNTRUSTED);
final KeyRequestData keyRequestData = new RequestData(KeyId.PSK);
final String identity = MockPresharedAuthenticationFactory.PSK_ESN;
final SecretKey encryptionKey = MockPresharedAuthenticationFactory.KPE;
final SecretKey hmacKey = MockPresharedAuthenticationFactory.KPH;
final MasterToken masterToken = getUntrustedMasterToken(unauthCtx, identity, encryptionKey, hmacKey);
factory.generateResponse(unauthCtx, ENCODER_FORMAT, keyRequestData, masterToken);
}
@Test(expected = MslInternalException.class)
public void wrongRequestSubsequentResponse() throws MslInternalException, MslException {
final KeyRequestData keyRequestData = new FakeKeyRequestData();
factory.generateResponse(unauthCtx, ENCODER_FORMAT, keyRequestData, PSK_MASTER_TOKEN);
}
@Test(expected = MslMasterTokenException.class)
public void untrustedMasterTokenSubsequentResponse() throws MslEncodingException, MslCryptoException, MslException, MslException, MslEncoderException {
final KeyRequestData keyRequestData = new RequestData(KeyId.SESSION);
final String identity = MockPresharedAuthenticationFactory.PSK_ESN;
final SecretKey encryptionKey = MockPresharedAuthenticationFactory.KPE;
final SecretKey hmacKey = MockPresharedAuthenticationFactory.KPH;
final MasterToken masterToken = getUntrustedMasterToken(unauthCtx, identity, encryptionKey, hmacKey);
factory.generateResponse(unauthCtx, ENCODER_FORMAT, keyRequestData, masterToken);
}
@Test
public void getPskCryptoContext() throws MslException {
final KeyRequestData keyRequestData = new RequestData(KeyId.PSK);
final KeyExchangeData keyxData = factory.generateResponse(unauthCtx, ENCODER_FORMAT, keyRequestData, entityAuthData);
final ICryptoContext requestCryptoContext = keyxData.cryptoContext;
final KeyResponseData keyResponseData = keyxData.keyResponseData;
final ICryptoContext responseCryptoContext = factory.getCryptoContext(pskCtx, keyRequestData, keyResponseData, null);
assertNotNull(responseCryptoContext);
final byte[] data = new byte[32];
random.nextBytes(data);
// Ciphertext won't always be equal depending on how it was
// enveloped. So we cannot check for equality or inequality.
final byte[] requestCiphertext = requestCryptoContext.encrypt(data, encoder, ENCODER_FORMAT);
final byte[] responseCiphertext = responseCryptoContext.encrypt(data, encoder, ENCODER_FORMAT);
assertFalse(Arrays.equals(data, requestCiphertext));
assertFalse(Arrays.equals(data, responseCiphertext));
// Signatures should always be equal.
final byte[] requestSignature = requestCryptoContext.sign(data, encoder, ENCODER_FORMAT);
final byte[] responseSignature = responseCryptoContext.sign(data, encoder, ENCODER_FORMAT);
assertFalse(Arrays.equals(data, requestSignature));
assertFalse(Arrays.equals(data, responseSignature));
assertArrayEquals(requestSignature, responseSignature);
// Plaintext should always be equal to the original message.
final byte[] requestPlaintext = requestCryptoContext.decrypt(responseCiphertext, encoder);
final byte[] responsePlaintext = responseCryptoContext.decrypt(requestCiphertext, encoder);
assertNotNull(requestPlaintext);
assertArrayEquals(data, requestPlaintext);
assertArrayEquals(requestPlaintext, responsePlaintext);
// Verification should always succeed.
assertTrue(requestCryptoContext.verify(data, responseSignature, encoder));
assertTrue(responseCryptoContext.verify(data, requestSignature, encoder));
}
@Ignore
@Test
public void getSessionCryptoContext() throws MslException {
final KeyRequestData keyRequestData = new RequestData(KeyId.SESSION);
final KeyExchangeData keyxData = factory.generateResponse(unauthCtx, ENCODER_FORMAT, keyRequestData, PSK_MASTER_TOKEN);
final ICryptoContext requestCryptoContext = keyxData.cryptoContext;
final KeyResponseData keyResponseData = keyxData.keyResponseData;
final ICryptoContext responseCryptoContext = factory.getCryptoContext(pskCtx, keyRequestData, keyResponseData, PSK_MASTER_TOKEN);
assertNotNull(responseCryptoContext);
final byte[] data = new byte[32];
random.nextBytes(data);
final byte[] requestCiphertext = requestCryptoContext.encrypt(data, encoder, ENCODER_FORMAT);
final byte[] responseCiphertext = responseCryptoContext.encrypt(data, encoder, ENCODER_FORMAT);
assertFalse(Arrays.equals(data, requestCiphertext));
assertFalse(Arrays.equals(data, responseCiphertext));
final byte[] requestSignature = requestCryptoContext.sign(data, encoder, ENCODER_FORMAT);
final byte[] responseSignature = responseCryptoContext.sign(data, encoder, ENCODER_FORMAT);
assertFalse(Arrays.equals(data, requestSignature));
assertFalse(Arrays.equals(data, responseSignature));
final byte[] requestPlaintext = requestCryptoContext.decrypt(responseCiphertext, encoder);
final byte[] responsePlaintext = responseCryptoContext.decrypt(requestCiphertext, encoder);
assertNotNull(requestPlaintext);
assertArrayEquals(data, requestPlaintext);
assertArrayEquals(requestPlaintext, responsePlaintext);
assertTrue(requestCryptoContext.verify(data, responseSignature, encoder));
assertTrue(responseCryptoContext.verify(data, requestSignature, encoder));
}
@Ignore
@Test
public void missingMasterTokenCryptoContext() throws MslException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.KEYX_MASTER_TOKEN_MISSING);
final KeyRequestData keyRequestData = new RequestData(KeyId.SESSION);
final KeyExchangeData keyxData = factory.generateResponse(unauthCtx, ENCODER_FORMAT, keyRequestData, PSK_MASTER_TOKEN);
final KeyResponseData keyResponseData = keyxData.keyResponseData;
factory.getCryptoContext(pskCtx, keyRequestData, keyResponseData, null);
}
@Test(expected = MslInternalException.class)
public void wrongRequestCryptoContext() throws MslException {
final KeyRequestData keyRequestData = new RequestData(KeyId.PSK);
final KeyExchangeData keyxData = factory.generateResponse(unauthCtx, ENCODER_FORMAT, keyRequestData, entityAuthData);
final KeyResponseData keyResponseData = keyxData.keyResponseData;
final KeyRequestData fakeKeyRequestData = new FakeKeyRequestData();
factory.getCryptoContext(pskCtx, fakeKeyRequestData, keyResponseData, null);
}
@Test(expected = MslInternalException.class)
public void wrongResponseCryptoContext() throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslMasterTokenException, MslEntityAuthException {
final KeyRequestData keyRequestData = new RequestData(KeyId.PSK);
final KeyResponseData fakeKeyResponseData = new FakeKeyResponseData();
factory.getCryptoContext(pskCtx, keyRequestData, fakeKeyResponseData, null);
}
@Test
public void keyIdMismatchCryptoContext() throws MslException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.KEYX_RESPONSE_REQUEST_MISMATCH);
final KeyRequestData keyRequestData = new RequestData(KeyId.PSK);
final KeyExchangeData keyxData = factory.generateResponse(unauthCtx, ENCODER_FORMAT, keyRequestData, entityAuthData);
final KeyResponseData keyResponseData = keyxData.keyResponseData;
final MasterToken masterToken = keyResponseData.getMasterToken();
final KeyResponseData mismatchedKeyResponseData = new ResponseData(masterToken, KeyId.SESSION, ENCRYPTION_KEY, HMAC_KEY);
factory.getCryptoContext(pskCtx, keyRequestData, mismatchedKeyResponseData, null);
}
@Test(expected = MslCryptoException.class)
public void invalidWrappedEncryptionKeyCryptoContext() throws MslException, MslException, MslEncoderException {
final KeyRequestData keyRequestData = new RequestData(KeyId.PSK);
final KeyExchangeData keyxData = factory.generateResponse(unauthCtx, ENCODER_FORMAT, keyRequestData, entityAuthData);
final KeyResponseData keyResponseData = keyxData.keyResponseData;
final MasterToken masterToken = keyResponseData.getMasterToken();
final MslObject keydata = keyResponseData.getKeydata(encoder, ENCODER_FORMAT);
final byte[] wrappedEncryptionKey = keydata.getBytes(KEY_ENCRYPTION_KEY);
++wrappedEncryptionKey[wrappedEncryptionKey.length-1];
keydata.put(KEY_ENCRYPTION_KEY, wrappedEncryptionKey);
final byte[] wrappedHmacKey = keydata.getBytes(KEY_HMAC_KEY);
final KeyResponseData invalidKeyResponseData = new ResponseData(masterToken, KeyId.PSK, wrappedEncryptionKey, wrappedHmacKey);
factory.getCryptoContext(pskCtx, keyRequestData, invalidKeyResponseData, null);
}
@Test(expected = MslCryptoException.class)
public void invalidWrappedHmacKeyCryptoContext() throws MslException, MslException, MslEncoderException {
final KeyRequestData keyRequestData = new RequestData(KeyId.PSK);
final KeyExchangeData keyxData = factory.generateResponse(unauthCtx, ENCODER_FORMAT, keyRequestData, entityAuthData);
final KeyResponseData keyResponseData = keyxData.keyResponseData;
final MasterToken masterToken = keyResponseData.getMasterToken();
final MslObject keydata = keyResponseData.getKeydata(encoder, ENCODER_FORMAT);
final byte[] wrappedHmacKey = keydata.getBytes(KEY_HMAC_KEY);
++wrappedHmacKey[wrappedHmacKey.length-1];
keydata.put(KEY_HMAC_KEY, wrappedHmacKey);
final byte[] wrappedEncryptionKey = keydata.getBytes(KEY_ENCRYPTION_KEY);
final KeyResponseData invalidKeyResponseData = new ResponseData(masterToken, KeyId.PSK, wrappedEncryptionKey, wrappedHmacKey);
factory.getCryptoContext(pskCtx, keyRequestData, invalidKeyResponseData, null);
}
/** Authentication utilities. */
private static MockAuthenticationUtils authutils;
/** Key exchange factory. */
private static KeyExchangeFactory factory;
/** Entity authentication data. */
private static EntityAuthenticationData entityAuthData;
}
}
| 9,963 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/keyx/KeyRequestDataTest.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.keyx;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
import com.netflix.msl.MslKeyExchangeException;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
/**
* Key request data unit tests.
*
* Successful calls to
* {@link KeyRequestData#create(com.netflix.msl.util.MslContext, org.json.MslObject)}
* covered in the individual key request data unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class KeyRequestDataTest {
/** Key key exchange scheme. */
private static final String KEY_SCHEME = "scheme";
/** Key key request data. */
private static final String KEY_KEYDATA = "keydata";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException {
ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = ctx.getMslEncoderFactory();
}
@AfterClass
public static void teardown() {
encoder = null;
ctx = null;
}
@Test
public void noScheme() throws MslException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslCryptoException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final MslObject mo = encoder.createObject();
mo.put(KEY_SCHEME + "x", KeyExchangeScheme.ASYMMETRIC_WRAPPED.name());
mo.put(KEY_KEYDATA, encoder.createObject());
KeyRequestData.create(ctx, mo);
}
@Test
public void noKeydata() throws MslException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslCryptoException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final MslObject mo = encoder.createObject();
mo.put(KEY_SCHEME, KeyExchangeScheme.ASYMMETRIC_WRAPPED.name());
mo.put(KEY_KEYDATA + "x", encoder.createObject());
KeyRequestData.create(ctx, mo);
}
@Test
public void unidentifiedScheme() throws MslException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslCryptoException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.UNIDENTIFIED_KEYX_SCHEME);
final MslObject mo = encoder.createObject();
mo.put(KEY_SCHEME, "x");
mo.put(KEY_KEYDATA, encoder.createObject());
KeyRequestData.create(ctx, mo);
}
@Test
public void keyxFactoryNotFound() throws MslException, MslEncodingException, MslEntityAuthException, MslKeyExchangeException, MslCryptoException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.KEYX_FACTORY_NOT_FOUND);
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
ctx.removeKeyExchangeFactories(KeyExchangeScheme.ASYMMETRIC_WRAPPED);
final MslObject mo = encoder.createObject();
mo.put(KEY_SCHEME, KeyExchangeScheme.ASYMMETRIC_WRAPPED.name());
mo.put(KEY_KEYDATA, encoder.createObject());
KeyRequestData.create(ctx, mo);
}
/** MSL context. */
private static MslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
}
| 9,964 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/keyx/KeyResponseDataTest.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.keyx;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
import com.netflix.msl.MslKeyExchangeException;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.keyx.SymmetricWrappedExchange.KeyId;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.tokens.MasterToken;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* Key response data unit tests.
*
* Successful calls to
* {@link KeyResponseData#create(com.netflix.msl.util.MslContext, org.json.MslObject)}
* covered in the individual key response data unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class KeyResponseDataTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key master token. */
private static final String KEY_MASTER_TOKEN = "mastertoken";
/** Key key exchange scheme. */
private static final String KEY_SCHEME = "scheme";
/** Key key request data. */
private static final String KEY_KEYDATA = "keydata";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
private static MasterToken MASTER_TOKEN;
private static MslObject MASTER_TOKEN_MO;
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException, MslEncoderException {
ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = ctx.getMslEncoderFactory();
MASTER_TOKEN = MslTestUtils.getMasterToken(ctx, 1, 1);
MASTER_TOKEN_MO = MslTestUtils.toMslObject(encoder, MASTER_TOKEN);
}
@AfterClass
public static void teardown() {
MASTER_TOKEN_MO = null;
MASTER_TOKEN = null;
encoder = null;
ctx = null;
}
@Test
public void noMasterToken() throws MslException, MslEncodingException, MslCryptoException, MslKeyExchangeException, MslException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final MslObject mo = encoder.createObject();
mo.put(KEY_MASTER_TOKEN + "x", MASTER_TOKEN_MO);
mo.put(KEY_SCHEME, KeyExchangeScheme.ASYMMETRIC_WRAPPED.name());
mo.put(KEY_KEYDATA, encoder.createObject());
KeyResponseData.create(ctx, mo);
}
@Test
public void noScheme() throws MslException, MslException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final MslObject mo = encoder.createObject();
mo.put(KEY_MASTER_TOKEN, MASTER_TOKEN_MO);
mo.put(KEY_SCHEME + "x", KeyExchangeScheme.ASYMMETRIC_WRAPPED.name());
mo.put(KEY_KEYDATA, encoder.createObject());
KeyResponseData.create(ctx, mo);
}
@Test
public void noKeydata() throws MslException, MslException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final MslObject mo = encoder.createObject();
mo.put(KEY_MASTER_TOKEN, MASTER_TOKEN_MO);
mo.put(KEY_SCHEME, KeyExchangeScheme.ASYMMETRIC_WRAPPED.name());
mo.put(KEY_KEYDATA + "x", encoder.createObject());
KeyResponseData.create(ctx, mo);
}
@Test
public void invalidMasterToken() throws MslException, MslEncodingException, MslCryptoException, MslKeyExchangeException, MslException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final byte[] encryptionKey = new byte[0];
final byte[] hmacKey = new byte[0];
final KeyResponseData response = new SymmetricWrappedExchange.ResponseData(MASTER_TOKEN, KeyId.PSK, encryptionKey, hmacKey);
final MslObject mo = encoder.createObject();
mo.put(KEY_MASTER_TOKEN + "x", encoder.createObject());
mo.put(KEY_SCHEME, KeyExchangeScheme.ASYMMETRIC_WRAPPED.name());
mo.put(KEY_KEYDATA, response.getKeydata(encoder, ENCODER_FORMAT));
KeyResponseData.create(ctx, mo);
}
@Test
public void unidentifiedScheme() throws MslException, MslException, MslEncoderException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.UNIDENTIFIED_KEYX_SCHEME);
final MslObject mo = encoder.createObject();
mo.put(KEY_MASTER_TOKEN, MASTER_TOKEN_MO);
mo.put(KEY_SCHEME, "x");
mo.put(KEY_KEYDATA, encoder.createObject());
KeyResponseData.create(ctx, mo);
}
@Test
public void keyxFactoryNotFound() throws MslException, MslException, MslEncoderException {
thrown.expect(MslKeyExchangeException.class);
thrown.expectMslError(MslError.KEYX_FACTORY_NOT_FOUND);
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
ctx.removeKeyExchangeFactories(KeyExchangeScheme.ASYMMETRIC_WRAPPED);
final MslObject mo = encoder.createObject();
mo.put(KEY_MASTER_TOKEN, MASTER_TOKEN_MO);
mo.put(KEY_SCHEME, KeyExchangeScheme.ASYMMETRIC_WRAPPED.name());
mo.put(KEY_KEYDATA, encoder.createObject());
KeyResponseData.create(ctx, mo);
}
/** MSL context. */
private static MslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
}
| 9,965 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/io/LZWInputStreamTest.java | /**
* Copyright (c) 2013-2018 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.io;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import org.junit.BeforeClass;
import org.junit.Test;
import com.netflix.msl.util.IOUtils;
/**
* LZW input stream tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class LZWInputStreamTest {
/** RAW data file. */
private static final String DATAFILE = "/pg1112.txt";
/** Compressed data file. */
private static final String LZWFILE = "/pg1112.lzw";
/**
* Create an LZW input stream from the provided codes.
*
* @param codes the LZW codes in order.
* @return an LZW input stream.
*/
private static LZWInputStream createInputStream(final byte[] codes) {
final ByteArrayInputStream lzwbuffer = new ByteArrayInputStream(codes);
return new LZWInputStream(lzwbuffer);
}
/** Raw data. */
private static byte[] rawdata;
/** Compressed data. */
private static byte[] lzwdata;
@BeforeClass
public static void setup() throws IOException {
// Load the raw file.
rawdata = IOUtils.readResource(DATAFILE);
// Load the compressed file.
lzwdata = IOUtils.readResource(LZWFILE);
}
@Test
public void oneByte() throws IOException {
final byte[] codes = { (byte)0xf1 };
final LZWInputStream lzw = createInputStream(codes);
// The decoded data should equal the code value.
final byte data = (byte)lzw.read();
assertEquals(codes[0], data);
// End of stream.
assertEquals(-1, lzw.read());
lzw.close();
}
@Test
public void twoBytes() throws IOException {
final byte[] codes = { (byte)0x66, (byte)0x33, (byte)0x80 };
final byte[] data = { (byte)0x66, (byte)0x67 };
final LZWInputStream lzw = createInputStream(codes);
final byte[] decompressed = new byte[data.length];
final int read = lzw.read(decompressed);
assertEquals(decompressed.length, read);
assertArrayEquals(data, decompressed);
assertEquals(-1, lzw.read());
lzw.close();
}
@Test
public void threeBytes() throws IOException {
final byte[] codes = { (byte)0x61, (byte)0x6b, (byte)0xac, (byte)0x40 };
final byte[] data = { (byte)0x61, (byte)0xd7, (byte)0xb1 };
final LZWInputStream lzw = createInputStream(codes);
final byte[] decompressed = new byte[data.length];
final int read = lzw.read(decompressed);
assertEquals(decompressed.length, read);
assertArrayEquals(data, decompressed);
assertEquals(-1, lzw.read());
lzw.close();
}
@Test
public void verona() throws IOException {
// Decompress the LZW file contents.
final LZWInputStream lzis = createInputStream(lzwdata);
final ByteArrayOutputStream uncompressed = new ByteArrayOutputStream();
final byte[] data = new byte[256 * 1024];
do {
final int read = lzis.read(data);
if (read == -1) break;
uncompressed.write(data, 0, read);
} while (true);
lzis.close();
final byte[] raw = uncompressed.toByteArray();
assertArrayEquals(rawdata, raw);
}
@Test(expected = IOException.class)
public void closed() throws IOException {
final byte[] codes = new byte[0];
final LZWInputStream lzw = createInputStream(codes);
try {
lzw.close();
} catch (final IOException e) {
fail(e.toString());
}
lzw.read();
}
}
| 9,966 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/io/DefaultMslEncoderFactorySuite.java | /**
* Copyright (c) 2017-2018 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.io;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;
import com.netflix.msl.MslConstants;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslException;
import com.netflix.msl.MslKeyExchangeException;
import com.netflix.msl.MslMasterTokenException;
import com.netflix.msl.MslMessageException;
import com.netflix.msl.MslUserAuthException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.entityauth.EntityAuthenticationData;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.msg.Header;
import com.netflix.msl.msg.MessageCapabilities;
import com.netflix.msl.msg.MessageHeader;
import com.netflix.msl.msg.MessageHeader.HeaderData;
import com.netflix.msl.msg.MessageHeader.HeaderPeerData;
import com.netflix.msl.msg.MessageOutputStream;
import com.netflix.msl.msg.PayloadChunk;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
/**
* MSL encoder factory tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
@RunWith(Suite.class)
@SuiteClasses({DefaultMslEncoderFactorySuite.Tokenizer.class,
DefaultMslEncoderFactorySuite.Container.class,
DefaultMslEncoderFactorySuite.Accessor.class,
DefaultMslEncoderFactorySuite.Encoding.class})
public class DefaultMslEncoderFactorySuite {
/** Maximum number of object fields or array elements. */
private static final int MAX_NUM_ELEMENTS = 20;
/** MSL object base key name. */
private static final String MSL_OBJECT_KEY = "KEY";
/** MSL context. */
private static MslContext ctx = null;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
/** Random. */
private static Random random = null;
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException {
if (ctx == null) {
ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = new DefaultMslEncoderFactory();
random = ctx.getRandom();
}
}
@AfterClass
public static void teardown() {
// Teardown causes problems because the data is shared by the inner
// classes, so don't do any cleanup.
}
/**
* @return a random type.
*/
private static Class<?> getRandomType() {
final int i = random.nextInt(8);
switch (i) {
case 0:
return Boolean.class;
case 1:
return byte[].class;
case 2:
return Double.class;
case 3:
return Integer.class;
case 4:
return MslArray.class;
case 5:
return MslObject.class;
case 6:
return Long.class;
default:
return String.class;
}
}
/**
* @param type the type. May be {@code null}.
* @return a randomly generated object of the specified type or
* {@code null} if the type is {@code null}.
*/
private static Object createTypedValue(final Class<?> type) {
if (Boolean.class.equals(type))
return random.nextBoolean();
if (byte[].class.equals(type)) {
final byte[] b = new byte[random.nextInt(10)];
random.nextBytes(b);
return b;
}
if (Double.class.equals(type))
return random.nextDouble();
if (Integer.class.equals(type))
return random.nextInt();
if (MslArray.class.equals(type)) {
final MslArray ma = encoder.createArray();
final Class<?> innerType = getRandomType();
ma.put(-1, createTypedValue(innerType));
return ma;
}
if (MslObject.class.equals(type)) {
final MslObject mo = encoder.createObject();
final Class<?> innerType = getRandomType();
mo.put(MSL_OBJECT_KEY, createTypedValue(innerType));
return mo;
}
if (Long.class.equals(type))
return random.nextLong();
if (String.class.equals(type))
return "STRING";
return null;
}
/**
* @return a randomly generated object of a random type.
*/
private static Object createRandomValue() {
final Class<?> type = getRandomType();
return createTypedValue(type);
}
/**
* Returns the value found in the MSL object for the given key. The
* value will be retrieved using the getter method that explicitly
* matches the expected type. For type {@code null} the untyped getter
* method is used.
*
* @param key MSL object key.
* @param type the expected type. May be {@code null}.
* @param mo the MSL object.
* @return the MSL object's value.
* @throws MslEncoderException if the value type is not equal to the
* expected type.
*/
private static Object getTypedField(final String key, final Class<?> type, final MslObject mo) throws MslEncoderException {
if (Boolean.class.equals(type))
return mo.getBoolean(key);
if (byte[].class.equals(type))
return mo.getBytes(key);
if (Double.class.equals(type))
return mo.getDouble(key);
if (Integer.class.equals(type))
return mo.getInt(key);
if (MslArray.class.equals(type))
return mo.getMslArray(key);
if (MslObject.class.equals(type))
return mo.getMslObject(key, encoder);
if (Long.class.equals(type))
return mo.getLong(key);
if (String.class.equals(type))
return mo.getString(key);
return mo.get(key);
}
/**
* Returns the value found in the MSL object for the given key. The
* value will be retrieved using the optional method that explicitly
* matches the expected type. For type {@code null} the untyped optional
* method is used.
*
* @param key MSL object key.
* @param type the expected type. May be {@code null}.
* @param mo the MSL object.
* @return the MSL object's value.
*/
private static Object optTypedField(final String key, final Class<?> type, final MslObject mo) {
if (Boolean.class.equals(type))
return mo.optBoolean(key);
if (byte[].class.equals(type))
return mo.optBytes(key);
if (Double.class.equals(type))
return mo.optDouble(key);
if (Integer.class.equals(type))
return mo.optInt(key);
if (MslArray.class.equals(type))
return mo.optMslArray(key);
if (MslObject.class.equals(type))
return mo.optMslObject(key, encoder);
if (Long.class.equals(type))
return mo.optLong(key);
if (String.class.equals(type))
return mo.optString(key);
return mo.opt(key);
}
/**
* Returns the value found in the MSL object for the given key. The
* value will be retrieved using the optional method that explicitly
* matches the expected type. For type {@code null} the untyped optional
* method is used.
*
* @param key MSL object key.
* @param type the expected type. May be {@code null}.
* @param mo the MSL object.
* @return the MSL object's value.
*/
private static Object optDefaultTypedField(final String key, final Class<?> type, final MslObject mo) {
if (Boolean.class.equals(type))
return mo.optBoolean(key, false);
if (byte[].class.equals(type))
return mo.optBytes(key, new byte[0]);
if (Double.class.equals(type))
return mo.optDouble(key, Double.NaN);
if (Integer.class.equals(type))
return mo.optInt(key, 0);
if (MslArray.class.equals(type))
return mo.optMslArray(key);
if (MslObject.class.equals(type))
return mo.optMslObject(key, encoder);
if (Long.class.equals(type))
return mo.optLong(key, 0);
if (String.class.equals(type))
return mo.optString(key, "");
return mo.opt(key);
}
/**
* Put a key/value pair into the MSL object. The value will be added using
* the put method that explicitly matches the specified type. For type
* {@code null} the untyped put method is used.
*
* @param key MSL object key.
* @param type the specified type. May be {@code null}.
* @param value the value.
* @param mo the MSL object.
*/
private static void putTypedField(final String key, final Class<?> type, final Object value, final MslObject mo) {
if (Boolean.class.equals(type))
mo.putBoolean(key, (Boolean)value);
if (byte[].class.equals(type))
mo.putBytes(key, (byte[])value);
if (Double.class.equals(type))
mo.putDouble(key, (Double)value);
if (Integer.class.equals(type))
mo.putInt(key, (Integer)value);
if (MslArray.class.equals(type))
mo.putCollection(key, (value != null) ? ((MslArray)value).getCollection() : null);
if (MslObject.class.equals(type))
mo.putMap(key, (value != null) ? ((MslObject)value).getMap() : null);
if (Long.class.equals(type))
mo.putLong(key, (Long)value);
if (String.class.equals(type))
mo.putString(key, (String)value);
mo.put(key, value);
}
/**
* Returns the value found in the MSL array at the given index. The
* value will be retrieved using the getter method that explicitly
* matches the expected type. For type {@code null} the untyped getter
* method is used.
*
* @param index MSL array index.
* @param type the expected type. May be {@code null}.
* @param ma the MSL array.
* @return the MSL array's element.
* @throws MslEncoderException if the value type is not equal to the
* expected type.
*/
private static Object getTypedElement(final int index, final Class<?> type, final MslArray ma) throws MslEncoderException {
if (Boolean.class.equals(type))
return ma.getBoolean(index);
if (byte[].class.equals(type))
return ma.getBytes(index);
if (Double.class.equals(type))
return ma.getDouble(index);
if (Integer.class.equals(type))
return ma.getInt(index);
if (MslArray.class.equals(type))
return ma.getMslArray(index);
if (MslObject.class.equals(type))
return ma.getMslObject(index, encoder);
if (Long.class.equals(type))
return ma.getLong(index);
if (String.class.equals(type))
return ma.getString(index);
return ma.get(index);
}
/**
* Returns the value found in the MSL array at the given index. The
* value will be retrieved using the optional method that explicitly
* matches the expected type. For type {@code null} the untyped optional
* method is used.
*
* @param index MSL array index.
* @param type the expected type. May be {@code null}.
* @param ma the MSL array.
* @return the MSL array's element.
*/
private static Object optTypedElement(final int index, final Class<?> type, final MslArray ma) {
if (Boolean.class.equals(type))
return ma.optBoolean(index);
if (byte[].class.equals(type))
return ma.optBytes(index);
if (Double.class.equals(type))
return ma.optDouble(index);
if (Integer.class.equals(type))
return ma.optInt(index);
if (MslArray.class.equals(type))
return ma.optMslArray(index);
if (MslObject.class.equals(type))
return ma.optMslObject(index, encoder);
if (Long.class.equals(type))
return ma.optLong(index);
if (String.class.equals(type))
return ma.optString(index);
return ma.opt(index);
}
/**
* Returns the value found in the MSL array at the given index. The
* value will be retrieved using the optional method that explicitly
* matches the expected type. For type {@code null} the untyped optional
* method is used.
*
* @param index MSL array index.
* @param type the expected type. May be {@code null}.
* @param ma the MSL array.
* @return the MSL array's element.
*/
private static Object optDefaultTypedElement(final int index, final Class<?> type, final MslArray ma) {
if (Boolean.class.equals(type))
return ma.optBoolean(index, false);
if (byte[].class.equals(type))
return ma.optBytes(index, new byte[0]);
if (Double.class.equals(type))
return ma.optDouble(index, Double.NaN);
if (Integer.class.equals(type))
return ma.optInt(index, 0);
if (MslArray.class.equals(type))
return ma.optMslArray(index);
if (MslObject.class.equals(type))
return ma.optMslObject(index, encoder);
if (Long.class.equals(type))
return ma.optLong(index, 0);
if (String.class.equals(type))
return ma.optString(index, "");
return ma.opt(index);
}
/**
* Put a value into the MSL array at the specified index. The value will be
* added using the put method that explicitly matches the specified type.
* For type {@code null} the untyped put method is used.
*
* @param key MSL object key.
* @param type the specified type. May be {@code null}.
* @param value the value.
* @param mo the MSL object.
*/
private static void putTypedElement(final int index, final Class<?> type, final Object value, final MslArray ma) {
if (Boolean.class.equals(type))
ma.putBoolean(index, (Boolean)value);
if (byte[].class.equals(type))
ma.putBytes(index, (byte[])value);
if (Double.class.equals(type))
ma.putDouble(index, (Double)value);
if (Integer.class.equals(type))
ma.putInt(index, (Integer)value);
if (MslArray.class.equals(type))
ma.putCollection(index, (value != null) ? ((MslArray)value).getCollection() : null);
if (MslObject.class.equals(type))
ma.putMap(index, (value != null) ? ((MslObject)value).getMap() : null);
if (Long.class.equals(type))
ma.putLong(index, (Long)value);
if (String.class.equals(type))
ma.putString(index, (String)value);
ma.put(index, value);
}
/** Tokenizer unit tests. */
@RunWith(Parameterized.class)
public static class Tokenizer {
/** Example payloads. */
private static final byte[][] PAYLOADS = {
"payload1".getBytes(MslConstants.DEFAULT_CHARSET),
"payload2".getBytes(MslConstants.DEFAULT_CHARSET),
};
@Rule
public ExpectedException thrown = ExpectedException.none();
@Parameters
public static Collection<Object[]> data() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException, IOException {
DefaultMslEncoderFactorySuite.setup();
// JSON encoder format.
final Set<MslEncoderFormat> jsonFormat = new HashSet<MslEncoderFormat>();
jsonFormat.add(MslEncoderFormat.JSON);
final MessageCapabilities jsonCaps = new MessageCapabilities(null, null, jsonFormat);
// Create MSL message.
final ByteArrayOutputStream destination = new ByteArrayOutputStream();
final HeaderPeerData peerData = new HeaderPeerData(null, null, null);
final EntityAuthenticationData entityAuthData = ctx.getEntityAuthenticationData(null);
// Create JSON version.
final HeaderData jsonHeaderData = new HeaderData(1, null, false, false, jsonCaps, null, null, null, null, null);
final MessageHeader jsonMessageHeader = new MessageHeader(ctx, entityAuthData, null, jsonHeaderData, peerData);
final ICryptoContext jsonCryptoContext = jsonMessageHeader.getCryptoContext();
final MessageOutputStream jsonMos = new MessageOutputStream(ctx, destination, jsonMessageHeader, jsonCryptoContext);
for (final byte[] payload : PAYLOADS) {
jsonMos.write(payload);
jsonMos.flush();
}
jsonMos.close();
// JSON.
final byte[] jsonMessageData = destination.toByteArray();
// Unsupported.
final byte[] unsupportedMessageData = Arrays.copyOf(jsonMessageData, jsonMessageData.length);
unsupportedMessageData[0] = '1';
// Parameters.
return Arrays.asList(new Object[][] {
{ jsonMessageData, null },
{ unsupportedMessageData, MslEncoderException.class },
});
}
/** Encoded message. */
private final byte[] messageData;
/** Expected exception class. */
private final Class<? extends Exception> exceptionClass;
/**
* Create a new MSL encoder factory test instance with the specified
* encoding format and provided message data.
*
* @param messageData encoded message.
* @param exceptionClass expected exception class.
*/
public Tokenizer(final byte[] messageData, final Class<? extends Exception> exceptionClass) {
this.messageData = messageData;
this.exceptionClass = exceptionClass;
}
@Test
public void detectTokenizer() throws IOException, MslEncoderException, MslEncodingException, MslEntityAuthException, MslCryptoException, MslKeyExchangeException, MslUserAuthException, MslMessageException, MslException {
if (exceptionClass != null)
thrown.expect(exceptionClass);
// Create the tokenizer.
final InputStream source = new ByteArrayInputStream(messageData);
final MslTokenizer tokenizer = encoder.createTokenizer(source);
assertNotNull(tokenizer);
// Pull data off the tokenizer.
final List<MslObject> objects = new ArrayList<MslObject>();
while (tokenizer.more(-1)) {
final MslObject object = tokenizer.nextObject(-1);
assertNotNull(object);
objects.add(object);
}
// +1 for the header, +1 for the EOM payload.
assertEquals(PAYLOADS.length + 2, objects.size());
assertNull(tokenizer.nextObject(-1));
// Pull message header.
final MslObject headerO = objects.get(0);
final Map<String,ICryptoContext> cryptoContexts = Collections.emptyMap();
final Header header = Header.parseHeader(ctx, headerO, cryptoContexts);
assertTrue(header instanceof MessageHeader);
final MessageHeader messageHeader = (MessageHeader)header;
// Verify payloads.
final ICryptoContext payloadCryptoContext = messageHeader.getCryptoContext();
for (int i = 0; i < PAYLOADS.length; ++i) {
final byte[] expectedPayload = PAYLOADS[i];
final MslObject payloadMo = objects.get(i + 1);
final PayloadChunk payload = new PayloadChunk(ctx, payloadMo, payloadCryptoContext);
final byte[] data = payload.getData();
assertArrayEquals(expectedPayload, data);
}
// Close tokenizer.
tokenizer.close();
}
}
/** Container unit tests. */
public static class Container {
/**
* Compare two numbers. The expected value is the original value. The
* candidate value is the value that was the original was converted
* into when retrieving it from the container.
*
* @param expected the expected value.
* @param candidate the value to test.
* @return true if the two numbers are equal.
*/
private static boolean numbersEqual(final Number expected, final Number candidate) {
// Take the expected value and convert it to the candidate value's
// type.
if (candidate instanceof Integer)
return expected.intValue() == candidate.intValue();
if (candidate instanceof Long)
return expected.longValue() == candidate.longValue();
if (candidate instanceof Double)
return expected.doubleValue() == candidate.doubleValue();
return false;
}
@Rule
public ExpectedException thrown = ExpectedException.none();
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException {
DefaultMslEncoderFactorySuite.setup();
}
@Test
public void createObject() throws MslEncoderException {
// Create the object.
final MslObject mo = encoder.createObject();
assertNotNull(mo);
// Populate it with some stuff.
final Map<String,Object> map = new HashMap<String,Object>();
for (int i = 0; i < MAX_NUM_ELEMENTS; ++i) {
final String key = MSL_OBJECT_KEY + ":" + i;
final Object value = createRandomValue();
map.put(key, value);
mo.put(key, value);
}
// Verify object state.
for (final String key : map.keySet()) {
final Object expected = map.get(key);
final Object value = mo.get(key);
assertEquals(expected, value);
final Object typedValue = getTypedField(key, expected.getClass(), mo);
assertEquals(expected, typedValue);
}
// Verify opt functions.
for (final String key : map.keySet()) {
final Object expected = map.get(key);
final Object value = mo.opt(key);
assertEquals(expected, value);
final Object typedValue = optTypedField(key, expected.getClass(), mo);
assertEquals(expected, typedValue);
}
// Verify opt functions with mismatched type.
for (final String key : map.keySet()) {
final Object expected = map.get(key);
final Class<?> randomType = getRandomType();
final Object typedValue = optTypedField(key, randomType, mo);
// opt function returns the value if the type is correct...
if (expected.getClass().equals(randomType)) {
assertEquals(expected, typedValue);
}
// Boolean expects false...
else if (Boolean.class.equals(randomType)) {
assertTrue(typedValue instanceof Boolean);
assertFalse((Boolean)typedValue);
}
// Numbers may be cross-retrieved...
else if (expected instanceof Number &&
(Integer.class.equals(randomType) ||
Long.class.equals(randomType) ||
Double.class.equals(randomType)))
{
assertTrue(numbersEqual((Number)expected, (Number)typedValue));
}
// Double expects NaN...
else if (Double.class.equals(randomType)) {
assertTrue(typedValue instanceof Double);
assertEquals(Double.valueOf(Double.NaN), typedValue);
}
// Numbers expect zero...
else if (Integer.class.equals(randomType) || Long.class.equals(randomType)) {
assertTrue(typedValue instanceof Number);
assertEquals(0, ((Number)typedValue).longValue());
}
// byte[] expects an empty byte array...
else if (byte[].class.equals(randomType)) {
assertTrue(typedValue instanceof byte[]);
assertArrayEquals(new byte[0], (byte[])typedValue);
}
// String expects the empty string...
else if (String.class.equals(randomType)) {
assertTrue(typedValue instanceof String);
assertEquals("", typedValue);
}
// Everything else expects null.
else {
assertNull(typedValue);
}
}
// Verify opt functions with default value.
assertTrue(mo.optBoolean("boolean", true));
final byte[] b = new byte[10];
random.nextBytes(b);
assertArrayEquals(b, mo.optBytes("bytes", b));
final Double d = random.nextDouble();
assertEquals(d, Double.valueOf(mo.optDouble("double", d)));
final Integer i = random.nextInt();
assertEquals(i, Integer.valueOf(mo.optInt("integer", i)));
assertNull(mo.optMslArray("array"));
assertNull(mo.optMslObject("object", encoder));
final Long l = random.nextLong();
assertEquals(l, Long.valueOf(mo.optLong("long", l)));
final String s = new String(b);
assertEquals(s, mo.optString("string", s));
}
@Test
public void createObjectFromMap() throws MslEncoderException {
// Generate some values.
final Map<String,Object> map = new HashMap<String,Object>();
for (int i = 0; i < MAX_NUM_ELEMENTS; ++i) {
final String key = MSL_OBJECT_KEY + ":" + i;
final Object value = createRandomValue();
map.put(key, value);
}
// Create the object.
final MslObject mo = encoder.createObject(map);
assertNotNull(mo);
// Verify object state.
for (final String key : map.keySet()) {
final Object expected = map.get(key);
final Object value = mo.get(key);
assertEquals(expected, value);
final Object typedValue = getTypedField(key, expected.getClass(), mo);
assertEquals(expected, typedValue);
}
}
@Test
public void createArray() throws MslEncoderException {
// Create the array.
final MslArray ma = encoder.createArray();
assertNotNull(ma);
// Populate it with some stuff.
final List<Object> list = new ArrayList<Object>();
for (int i = 0; i < MAX_NUM_ELEMENTS; ++i) {
final Object value = createRandomValue();
list.add(value);
ma.put(-1, value);
}
// Verify array state.
for (int i = 0; i < list.size(); ++i) {
final Object expected = list.get(i);
final Object value = ma.get(i);
assertEquals(expected, value);
final Object typedValue = getTypedElement(i, expected.getClass(), ma);
assertEquals(expected, typedValue);
}
// Verify opt functions.
for (int i = 0; i < list.size(); ++i) {
final Object expected = list.get(i);
final Object value = ma.opt(i);
assertEquals(expected, value);
final Object typedValue = optTypedElement(i, expected.getClass(), ma);
assertEquals(expected, typedValue);
}
// Verify opt functions with mismatched type.
for (int i = 0; i < list.size(); ++i) {
final Object expected = list.get(i);
final Class<?> randomType = getRandomType();
final Object typedValue = optTypedElement(i, randomType, ma);
// opt function returns the value if the type is correct...
if (expected.getClass().equals(randomType)) {
assertEquals(expected, typedValue);
}
// Boolean expects false...
else if (Boolean.class.equals(randomType)) {
assertTrue(typedValue instanceof Boolean);
assertFalse((Boolean)typedValue);
}
// Numbers may be cross-retrieved...
else if (expected instanceof Number &&
(Integer.class.equals(randomType) ||
Long.class.equals(randomType) ||
Double.class.equals(randomType)))
{
assertTrue(numbersEqual((Number)expected, (Number)typedValue));
}
// Double expects NaN...
else if (Double.class.equals(randomType)) {
assertTrue(typedValue instanceof Double);
assertEquals(Double.valueOf(Double.NaN), typedValue);
}
// Numbers expect zero...
else if (Integer.class.equals(randomType) || Long.class.equals(randomType)) {
assertTrue(typedValue instanceof Number);
assertEquals(0L, ((Number)typedValue).longValue());
}
// byte[] expects an empty byte array...
else if (byte[].class.equals(randomType)) {
assertTrue(typedValue instanceof byte[]);
assertArrayEquals(new byte[0], (byte[])typedValue);
}
// String expects the empty string...
else if (String.class.equals(randomType)) {
assertTrue(typedValue instanceof String);
assertEquals("", typedValue);
}
// Everything else expects null.
else {
assertNull(typedValue);
}
}
// Verify opt functions with default value.
ma.put(0, null);
assertTrue(ma.optBoolean(0, true));
final byte[] b = new byte[10];
random.nextBytes(b);
assertArrayEquals(b, ma.optBytes(0, b));
final Double d = random.nextDouble();
assertEquals(d, Double.valueOf(ma.optDouble(0, d)));
final Integer i = random.nextInt();
assertEquals(i, Integer.valueOf(ma.optInt(0, i)));
assertNull(ma.optMslArray(0));
assertNull(ma.optMslObject(0, encoder));
final Long l = random.nextLong();
assertEquals(l, Long.valueOf(ma.optLong(0, l)));
final String s = new String(b);
assertEquals(s, ma.optString(0, s));
}
@Test
public void createArrayFromCollection() throws MslEncoderException {
// Generate some elements.
final List<Object> list = new ArrayList<Object>();
for (int i = 0; i < MAX_NUM_ELEMENTS; ++i) {
final Object value = createRandomValue();
list.add(value);
}
// Create the array.
final MslArray ma = encoder.createArray(list);
assertNotNull(ma);
// Verify array state.
for (int i = 0; i < list.size(); ++i) {
final Object expected = list.get(i);
final Object value = ma.get(i);
assertEquals(expected, value);
final Object typedValue = getTypedElement(i, expected.getClass(), ma);
assertEquals(expected, typedValue);
}
}
}
/** Accessor unit tests. */
@RunWith(Parameterized.class)
public static class Accessor {
@Rule
public ExpectedException thrown = ExpectedException.none();
@Parameters
public static Collection<Object[]> data() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException, IOException {
DefaultMslEncoderFactorySuite.setup();
// Parameters.
return Arrays.asList(new Object[][] {
{ null },
{ Boolean.class },
{ byte[].class },
{ Double.class },
{ Integer.class },
{ MslArray.class },
{ MslObject.class },
{ Long.class },
{ String.class },
});
}
/** Accessor type. May be null. */
private final Class<?> type;
/**
* @param type value or element type.
*/
public Accessor(final Class<?> type) {
this.type = type;
}
@Test
public void objectGetKeyNull() throws MslEncoderException {
thrown.expect(IllegalArgumentException.class);
final MslObject mo = encoder.createObject();
getTypedField(null, type, mo);
}
@Test
public void objectGetValueNull() throws MslEncoderException {
thrown.expect(MslEncoderException.class);
final MslObject mo = encoder.createObject();
getTypedField(MSL_OBJECT_KEY, type, mo);
}
@Test
public void objectOptKeyNull() {
thrown.expect(IllegalArgumentException.class);
final MslObject mo = encoder.createObject();
optTypedField(null, type, mo);
}
@Test
public void objectOptDefaultKeyNull() {
thrown.expect(IllegalArgumentException.class);
final MslObject mo = encoder.createObject();
optDefaultTypedField(null, type, mo);
}
@Test
public void objectPutKeyNull() {
thrown.expect(IllegalArgumentException.class);
final MslObject mo = encoder.createObject();
final Object value = createTypedValue(type);
putTypedField(null, type, value, mo);
}
@Test
public void objectPutValueNull() {
// Null value is incompatible with this test.
if (type != null) {
final MslObject mo = encoder.createObject();
final Object value = createTypedValue(type);
putTypedField(MSL_OBJECT_KEY, type, value, mo);
assertTrue(mo.has(MSL_OBJECT_KEY));
putTypedField(MSL_OBJECT_KEY, type, null, mo);
assertFalse(mo.has(MSL_OBJECT_KEY));
}
}
@Test
public void arrayGetIndexNegative() throws MslEncoderException {
thrown.expect(ArrayIndexOutOfBoundsException.class);
final MslArray ma = encoder.createArray();
getTypedElement(-1, type, ma);
}
@Test
public void arrayGetElementNull() throws MslEncoderException {
thrown.expect(MslEncoderException.class);
final MslArray ma = encoder.createArray();
putTypedElement(0, type, null, ma);
assertEquals(1, ma.size());
getTypedElement(0, type, ma);
}
@Test
public void arrayOptIndexNegative() {
thrown.expect(ArrayIndexOutOfBoundsException.class);
final MslArray ma = encoder.createArray();
optTypedElement(-1, type, ma);
}
@Test
public void arrayOptDefaultIndexNegative() {
thrown.expect(ArrayIndexOutOfBoundsException.class);
final MslArray ma = encoder.createArray();
optDefaultTypedElement(-1, type, ma);
}
@Test
public void arrayGetIndexTooBig() throws MslEncoderException {
thrown.expect(ArrayIndexOutOfBoundsException.class);
final MslArray ma = encoder.createArray();
getTypedElement(ma.size(), type, ma);
}
@Test
public void arrayOptIndexTooBig() {
thrown.expect(ArrayIndexOutOfBoundsException.class);
final MslArray ma = encoder.createArray();
optTypedElement(ma.size(), type, ma);
}
@Test
public void arrayOptDefaultIndexTooBig() {
thrown.expect(ArrayIndexOutOfBoundsException.class);
final MslArray ma = encoder.createArray();
optDefaultTypedElement(ma.size(), type, ma);
}
@Test
public void arrayPutIndexNegative() {
thrown.expect(ArrayIndexOutOfBoundsException.class);
final MslArray ma = encoder.createArray();
final Object value = createTypedValue(type);
putTypedElement(-2, type, value, ma);
}
}
/** Encoding unit tests. */
@RunWith(Parameterized.class)
public static class Encoding {
@Rule
public ExpectedException thrown = ExpectedException.none();
@Parameters
public static Collection<Object[]> data() throws MslEncodingException, MslCryptoException, MslMasterTokenException, MslEntityAuthException, MslMessageException, IOException {
DefaultMslEncoderFactorySuite.setup();
// Parameters.
return Arrays.asList(new Object[][] {
{ MslEncoderFormat.JSON },
});
}
/** MSL encoder format. */
private final MslEncoderFormat format;
/**
* @param format MSL encoder format.
*/
public Encoding(final MslEncoderFormat format) {
this.format = format;
}
@Test
public void encodeAndParseObject() throws MslEncoderException {
// Generate some values.
final Map<String,Object> map = new HashMap<String,Object>();
for (int i = 0; i < MAX_NUM_ELEMENTS; ++i) {
final String key = MSL_OBJECT_KEY + ":" + i;
final Object value = createRandomValue();
map.put(key, value);
}
// Create the object.
final MslObject mo = encoder.createObject(map);
assertNotNull(mo);
// Encode.
final byte[] encode = encoder.encodeObject(mo, format);
assertNotNull(encode);
// Parse.
final MslObject parsedMo = encoder.parseObject(encode);
assertTrue(MslEncoderUtils.equalObjects(mo, parsedMo));
}
@Test
public void parseInvalidObject() throws MslEncoderException {
thrown.expect(MslEncoderException.class);
// Generate some values.
final Map<String,Object> map = new HashMap<String,Object>();
for (int i = 0; i < MAX_NUM_ELEMENTS; ++i) {
final String key = MSL_OBJECT_KEY + ":" + i;
final Object value = createRandomValue();
map.put(key, value);
}
// Create the object.
final MslObject mo = encoder.createObject(map);
assertNotNull(mo);
// Encode.
final byte[] encode = encoder.encodeObject(mo, format);
assertNotNull(encode);
// Corrupt the encode.
encode[0] = 0;
encode[encode.length - 1] = 'x';
// Parse.
encoder.parseObject(encode);
}
}
}
| 9,967 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/io/MslEncoderUtilsTest.java | /**
* Copyright (c) 2012-2019 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.io;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.nio.charset.Charset;
import java.util.Random;
import java.util.Set;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.util.Base64;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
/**
* MSL utilities unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class MslEncoderUtilsTest {
/** Encoding charset. */
private static final Charset UTF_8 = Charset.forName("UTF-8");
/** URL-safe Base64 examples. */
private static final String[][] B64_URL_EXAMPLES = new String[][] {
{ "The long winded author is going for a walk while the light breeze bellows in his ears.",
"VGhlIGxvbmcgd2luZGVkIGF1dGhvciBpcyBnb2luZyBmb3IgYSB3YWxrIHdoaWxlIHRoZSBsaWdodCBicmVlemUgYmVsbG93cyBpbiBoaXMgZWFycy4" },
{ "Sometimes porcupines need beds to sleep on.",
"U29tZXRpbWVzIHBvcmN1cGluZXMgbmVlZCBiZWRzIHRvIHNsZWVwIG9uLg" },
{ "Even the restless dreamer enjoys home-cooked foods.",
"RXZlbiB0aGUgcmVzdGxlc3MgZHJlYW1lciBlbmpveXMgaG9tZS1jb29rZWQgZm9vZHMu" }
};
private static final String KEY_BOOLEAN = "boolean";
private static final String KEY_NUMBER = "number";
private static final String KEY_STRING = "string";
private static final String KEY_OBJECT = "object";
private static final String KEY_ARRAY = "array";
private static final int MAX_ELEMENTS = 12;
private static final int MAX_DEPTH = 3;
private static final int MAX_STRING_CHARS = 25;
/**
* @param random random source.
* @return a random string of random length.
*/
private static final String randomString(final Random random) {
final byte[] raw = new byte[1 + random.nextInt(MAX_STRING_CHARS - 1)];
return Base64.encode(raw);
}
/**
* @param random random source.
* @return a MSL object containing no MSL objects or MSL arrays.
* @throws MslEncoderException if there is an error building the MSL object.
*/
private static MslObject createFlatMslObject(final Random random) throws MslEncoderException {
final MslObject mo = new MslObject();
for (int i = 1 + random.nextInt(MAX_ELEMENTS - 1); i > 0; --i) {
switch (random.nextInt(3)) {
case 0:
mo.put(KEY_BOOLEAN + i, random.nextBoolean());
break;
case 1:
mo.put(KEY_NUMBER + i, random.nextInt());
break;
case 2:
mo.put(KEY_STRING + i, randomString(random));
break;
}
}
return mo;
}
/**
* @param random random source.
* @param depth maximum depth. A depth of 1 indicates no children may have
* more children.
* @return a MSL object that may contain MSL objects or MSL arrays.
* @throws MslEncoderException if there is an error building the MSL object.
*/
private static MslObject createDeepMslObject(final Random random, final int depth) throws MslEncoderException {
final MslObject mo = new MslObject();
for (int i = 1 + random.nextInt(MAX_ELEMENTS - 1); i > 0; --i) {
switch (random.nextInt(5)) {
case 0:
mo.put(KEY_BOOLEAN + i, random.nextBoolean());
break;
case 1:
mo.put(KEY_NUMBER + i, random.nextInt());
break;
case 2:
mo.put(KEY_STRING + i, randomString(random));
break;
case 3:
mo.put(KEY_OBJECT + i, (depth > 1) ? createDeepMslObject(random, depth - 1) : createFlatMslObject(random));
break;
case 4:
mo.put(KEY_ARRAY + i, (depth > 1) ? createDeepMslArray(random, depth - 1) : createFlatMslArray(random));
break;
}
}
return mo;
}
/**
* @param random random source.
* @return a MSL array containing no MSL objects or MSL arrays.
* @throws MslEncoderException if there is an error building the MSL array.
*/
private static MslArray createFlatMslArray(final Random random) throws MslEncoderException {
final MslArray ma = new MslArray();
for (int i = 1 + random.nextInt(MAX_ELEMENTS - 1); i > 0; --i) {
switch (random.nextInt(4)) {
case 0:
ma.put(-1, random.nextBoolean());
break;
case 1:
ma.put(-1, random.nextInt());
break;
case 2:
ma.put(-1, randomString(random));
break;
case 3:
ma.put(-1, null);
break;
}
}
return ma;
}
/**
* @param random random source.
* @param depth maximum depth. A depth of 1 indicates no children may have
* more children.
* @return a MSL array that may contain MSL objects or MSL arrays.
* @throws MslEncoderException if there is an error building the MSL array.
*/
private static MslArray createDeepMslArray(final Random random, final int depth) throws MslEncoderException {
final MslArray ma = new MslArray();
for (int i = 1 + random.nextInt(MAX_ELEMENTS - 1); i > 0; --i) {
switch (random.nextInt(4)) {
case 0:
ma.put(-1, random.nextBoolean());
break;
case 1:
ma.put(-1, random.nextInt());
break;
case 2:
ma.put(-1, randomString(random));
break;
case 3:
ma.put(-1, null);
break;
case 4:
ma.put(-1, (depth > 1) ? createDeepMslObject(random, depth - 1) : createFlatMslObject(random));
break;
case 5:
ma.put(-1, (depth > 1) ? createDeepMslArray(random, depth - 1) : createFlatMslArray(random));
break;
}
}
return ma;
}
/**
* @param o the object to change.
* @return a new object with a changed value.
* @throws MslEncoderException if the object type is unknown or there is an error
* parsing/building the MSL objects or arrays.
*/
private static Object changeValue(final Object o) throws MslEncoderException {
final Random random = new Random();
if (o instanceof String) {
return (String)o + "x";
} else if (o instanceof Number) {
return ((Number)o).doubleValue() + 1;
} else if (o instanceof Boolean) {
return !((Boolean)o).booleanValue();
} else if (o instanceof MslObject) {
final MslObject childMo = encoder.createObject(((MslObject)o).getMap());
final Set<String> childNames = childMo.getKeys();
if (childNames.size() > 0) {
final String childName = childNames.toArray(new String[0])[random.nextInt(childNames.size())];
return changeValue(childMo, childName);
} else {
childMo.put(KEY_NUMBER + "1", 1);
return childMo;
}
} else if (o instanceof MslArray) {
final MslArray childMa = encoder.createArray(((MslArray)o).getCollection());
childMa.put(-1, random.nextInt());
return childMa;
} else if (o == null) {
return true;
}
throw new MslEncoderException("Unknown object type " + o.getClass());
}
/**
* @param mo MSL object to create a changed version of.
* @param name name of value to change.
* @return a new MSL object with the value associated with the given name
* randomly changed.
* @throws MslEncoderException if the name does not exist or there is an error
* parsing/building the MSL objects.
*/
private static MslObject changeValue(final MslObject mo, final String name) throws MslEncoderException {
final MslObject newMo = encoder.createObject(mo.getMap());
final Object o = newMo.opt(name);
newMo.put(name, changeValue(o));
return newMo;
}
private static MslArray changeValue(final MslArray ma, final int index) throws MslEncoderException {
final MslArray newMa = encoder.createArray(ma.getCollection());
final Object o = newMa.opt(index);
newMa.put(index, changeValue(o));
return newMa;
}
@BeforeClass
public static void setup() throws MslEncoderException, MslEncodingException, MslCryptoException {
final MslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = ctx.getMslEncoderFactory();
random = new Random();
flatMo = createFlatMslObject(random);
deepMo = createDeepMslObject(random, MAX_DEPTH);
nullMo = null;
flatMa = createFlatMslArray(random);
deepMa = createDeepMslArray(random, MAX_DEPTH);
nullMa = null;
}
@AfterClass
public static void teardown() {
flatMo = null;
deepMo = null;
flatMa = null;
deepMa = null;
random = null;
encoder = null;
}
@Test
public void b64url() {
for (final String[] example : B64_URL_EXAMPLES) {
final String text = example[0];
final String base64 = example[1];
// Encode the text as bytes and as a string.
{
final String encoded = MslEncoderUtils.b64urlEncode(text.getBytes(UTF_8));
final String encodedString = MslEncoderUtils.b64urlEncode(text);
assertEquals(base64, encoded);
assertEquals(base64, encodedString);
}
// Decode the base64 to bytes and to a string.
{
final byte[] decoded = MslEncoderUtils.b64urlDecode(base64);
assertArrayEquals(text.getBytes(UTF_8), decoded);
}
}
}
@Test
public void mslObjectEqual() throws MslEncoderException {
assertTrue(MslEncoderUtils.equalObjects(flatMo, flatMo));
assertEquals(MslEncoderUtils.hashObject(flatMo), MslEncoderUtils.hashObject(flatMo));
final MslObject mo = encoder.createObject(flatMo.getMap());
assertTrue(MslEncoderUtils.equalObjects(flatMo, mo));
assertEquals(MslEncoderUtils.hashObject(flatMo), MslEncoderUtils.hashObject(mo));
}
@Test
public void mslObjectInequal() throws MslEncoderException {
final Set<String> names = flatMo.getKeys();
for (final String name : names) {
final MslObject mo = changeValue(flatMo, name);
assertFalse(MslEncoderUtils.equalObjects(flatMo, mo));
assertNotEquals(MslEncoderUtils.hashObject(flatMo), MslEncoderUtils.hashObject(mo));
}
}
@Test
public void mslObjectNull() throws MslEncoderException {
assertFalse(MslEncoderUtils.equalObjects(null, new MslObject()));
assertFalse(MslEncoderUtils.equalObjects(new MslObject(), null));
assertTrue(MslEncoderUtils.equalObjects(nullMo, nullMo));
assertEquals(MslEncoderUtils.hashObject(nullMo), MslEncoderUtils.hashObject(nullMo));
}
@Test
public void mslObjectChildrenEqual() throws MslEncoderException {
assertTrue(MslEncoderUtils.equalObjects(deepMo, deepMo));
final MslObject mo = encoder.createObject(deepMo.getMap());
assertTrue(MslEncoderUtils.equalObjects(deepMo, mo));
assertEquals(MslEncoderUtils.hashObject(deepMo), MslEncoderUtils.hashObject(mo));
}
@Test
public void mslObjectChildrenInequal() throws MslEncoderException {
final Set<String> names = deepMo.getKeys();
for (final String name : names) {
final MslObject mo = changeValue(deepMo, name);
assertFalse(MslEncoderUtils.equalObjects(deepMo, mo));
assertNotEquals(MslEncoderUtils.hashObject(deepMo), MslEncoderUtils.hashObject(mo));
}
}
@Test
public void mslArrayEqual() throws MslEncoderException {
assertTrue(MslEncoderUtils.equalArrays(flatMa, flatMa));
assertEquals(MslEncoderUtils.hashArray(flatMa), MslEncoderUtils.hashArray(flatMa));
final MslArray ma = encoder.createArray(flatMa.getCollection());
assertTrue(MslEncoderUtils.equalArrays(flatMa, ma));
assertEquals(MslEncoderUtils.hashArray(flatMa), MslEncoderUtils.hashArray(ma));
}
@Test
public void mslArrayInequal() throws MslEncoderException {
final Random random = new Random();
final MslArray ma1 = encoder.createArray(flatMa.getCollection());
if (ma1.size() > 0) {
ma1.remove(random.nextInt(ma1.size()));
assertFalse(MslEncoderUtils.equalArrays(flatMa, ma1));
assertNotEquals(MslEncoderUtils.hashArray(flatMa), MslEncoderUtils.hashArray(ma1));
}
final MslArray ma2 = encoder.createArray(flatMa.getCollection());
ma2.put(-1, random.nextInt());
assertFalse(MslEncoderUtils.equalArrays(flatMa, ma2));
assertNotEquals(MslEncoderUtils.hashArray(flatMa), MslEncoderUtils.hashArray(ma2));
if (flatMa.size() > 0) {
final MslArray ma3 = changeValue(flatMa, random.nextInt(flatMa.size()));
assertFalse(MslEncoderUtils.equalArrays(flatMa, ma3));
assertNotEquals(MslEncoderUtils.hashArray(flatMa), MslEncoderUtils.hashArray(ma3));
}
}
@Test
public void mslArrayNull() throws MslEncoderException {
assertFalse(MslEncoderUtils.equalArrays(null, new MslArray()));
assertFalse(MslEncoderUtils.equalArrays(new MslArray(), null));
assertTrue(MslEncoderUtils.equalArrays(nullMa, nullMa));
assertEquals(MslEncoderUtils.hashArray(nullMa), MslEncoderUtils.hashArray(nullMa));
}
@Test
public void mslArrayChildrenEqual() throws MslEncoderException {
assertTrue(MslEncoderUtils.equalArrays(deepMa, deepMa));
assertEquals(MslEncoderUtils.hashArray(deepMa), MslEncoderUtils.hashArray(deepMa));
final MslArray ma = encoder.createArray(deepMa.getCollection());
assertTrue(MslEncoderUtils.equalArrays(deepMa, ma));
assertEquals(MslEncoderUtils.hashArray(deepMa), MslEncoderUtils.hashArray(ma));
}
@Test
public void mslArrayChildrenInequal() throws MslEncoderException {
final Random random = new Random();
final MslArray ma1 = encoder.createArray(deepMa.getCollection());
if (ma1.size() > 0) {
ma1.remove(random.nextInt(ma1.size()));
assertFalse(MslEncoderUtils.equalArrays(deepMa, ma1));
assertNotEquals(MslEncoderUtils.hashArray(deepMa), MslEncoderUtils.hashArray(ma1));
}
final MslArray ma2 = encoder.createArray(deepMa.getCollection());
ma2.put(-1, random.nextInt());
assertFalse(MslEncoderUtils.equalArrays(deepMa, ma2));
assertNotEquals(MslEncoderUtils.hashArray(deepMa), MslEncoderUtils.hashArray(ma2));
if (deepMa.size() > 0) {
final MslArray ma3 = changeValue(deepMa, random.nextInt(deepMa.size()));
assertFalse(MslEncoderUtils.equalArrays(deepMa, ma3));
assertNotEquals(MslEncoderUtils.hashArray(deepMa), MslEncoderUtils.hashArray(ma3));
}
}
@Test
public void mergeNulls() throws MslEncoderException {
final MslObject mo1 = null;
final MslObject mo2 = null;
final MslObject merged = MslEncoderUtils.merge(mo1, mo2);
assertNull(merged);
}
@Test
public void mergeFirstNull() throws MslEncoderException {
final MslObject mo1 = null;
final MslObject mo2 = deepMo;
final MslObject merged = MslEncoderUtils.merge(mo1, mo2);
assertTrue(MslEncoderUtils.equalObjects(merged, mo2));
assertEquals(MslEncoderUtils.hashObject(merged), MslEncoderUtils.hashObject(mo2));
}
@Test
public void mergeSecondNull() throws MslEncoderException {
final MslObject mo1 = deepMo;
final MslObject mo2 = null;
final MslObject merged = MslEncoderUtils.merge(mo1, mo2);
assertTrue(MslEncoderUtils.equalObjects(merged, mo1));
assertEquals(MslEncoderUtils.hashObject(merged), MslEncoderUtils.hashObject(mo1));
}
@Test
public void mergeOverwriting() throws MslEncoderException {
final MslObject mo1 = createFlatMslObject(random);
final MslObject mo2 = createFlatMslObject(random);
// Insert some shared keys.
mo1.put("key1", true);
mo2.put("key1", "value1");
mo1.put("key2", 17);
mo2.put("key2", 34);
// Ensure second overwrites first.
final MslObject merged = MslEncoderUtils.merge(mo1, mo2);
for (final String key : merged.getKeys()) {
final Object value = merged.get(key);
if (key.equals("key1") || key.equals("key2")) {
assertEquals(mo2.get(key), value);
} else if (mo2.has(key)) {
assertEquals(mo2.get(key), value);
} else {
assertEquals(mo1.get(key), value);
}
}
}
@Test
public void objectHash() throws MslEncoderException {
final MslObject mo1 = deepMo;
final MslObject mo2 = new MslObject(mo1.getMap());
assertTrue(MslEncoderUtils.equalObjects(mo1, mo2));
assertEquals(MslEncoderUtils.hashObject(mo2), MslEncoderUtils.hashObject(mo1));
final String[] keys = mo1.getKeys().toArray(new String[0]);
final String key = keys[0];
final Object value = mo1.get(key);
mo1.remove(key);
mo1.put(key + "x", value);
assertFalse(MslEncoderUtils.equalObjects(mo1, mo2));
assertNotEquals(MslEncoderUtils.hashObject(mo2), MslEncoderUtils.hashObject(mo1));
mo1.put(key, value);
assertFalse(MslEncoderUtils.equalObjects(mo1, mo2));
assertNotEquals(MslEncoderUtils.hashObject(mo2), MslEncoderUtils.hashObject(mo1));
mo1.remove(key + "x");
assertTrue(MslEncoderUtils.equalObjects(mo1, mo2));
assertEquals(MslEncoderUtils.hashObject(mo2), MslEncoderUtils.hashObject(mo1));
}
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
private static Random random;
private static MslObject flatMo, deepMo, nullMo;
private static MslArray flatMa, deepMa, nullMa;
}
| 9,968 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/io/ThriftyUtf8ReaderTest.java | /**
* Copyright (c) 2018 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.io;
import static org.junit.Assert.assertEquals;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import org.junit.BeforeClass;
import org.junit.Test;
import com.netflix.msl.util.IOUtils;
/**
* <p>Thrifty UTF-8 reader unit tests.</p>
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class ThriftyUtf8ReaderTest {
/** UTF-8 data file. */
private static final String UTF_8_FILE = "/utf-8-test.txt";
/** UTF-8 data file character count. */
private static final int UTF_8_FILE_COUNT = 22472;
/** UTF-8 data. */
private static byte[] utf8data;
@BeforeClass
public static void setup() throws IOException {
// Load the UTF-8 file.
utf8data = IOUtils.readResource(UTF_8_FILE);
}
@Test
public void translate() throws IOException {
// First read one character at a time.
final String oneString;
{
final ByteArrayInputStream input = new ByteArrayInputStream(utf8data);
final ThriftyUtf8Reader reader = new ThriftyUtf8Reader(input);
final StringBuffer sb = new StringBuffer();
do {
final int c = reader.read();
if (c == -1)
break;
sb.append((char)c);
} while (true);
oneString = sb.toString();
reader.close();
}
// Second read multiple characters at a time.
final String bulkString;
{
final ByteArrayInputStream input = new ByteArrayInputStream(utf8data);
final ThriftyUtf8Reader reader = new ThriftyUtf8Reader(input);
final StringBuffer sb = new StringBuffer();
do {
final char[] chars = new char[8192];
final int count = reader.read(chars);
if (count == -1)
break;
sb.append(chars, 0, count);
} while (true);
bulkString = sb.toString();
reader.close();
}
// Third read all the characters at once.
final String allString;
{
final ByteArrayInputStream input = new ByteArrayInputStream(utf8data);
final ThriftyUtf8Reader reader = new ThriftyUtf8Reader(input);
final StringBuffer sb = new StringBuffer();
do {
final char[] chars = new char[32768];
final int count = reader.read(chars);
if (count == -1)
break;
sb.append(chars, 0, count);
} while (true);
allString = sb.toString();
reader.close();
}
assertEquals(UTF_8_FILE_COUNT, oneString.length());
assertEquals(oneString, bulkString);
assertEquals(oneString, allString);
System.out.println(oneString);
}
}
| 9,969 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/io/LZWOutputStreamTest.java | /**
* Copyright (c) 2013-2018 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.io;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import org.junit.After;
import org.junit.BeforeClass;
import org.junit.Test;
import com.netflix.msl.util.IOUtils;
/**
* LZW output stream tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class LZWOutputStreamTest {
/** RAW data file. */
private static final String DATAFILE = "/pg1112.txt";
/** Compressed data file. */
private static final String LZWFILE = "/pg1112.lzw";
/**
* Return the byte value shifted to the right by the number of specified
* bits.
*
* @param b the byte value.
* @param count number of bits to shift.
* @return the shifted byte value.
*/
private static byte shiftright(final byte b, final int count) {
int value = 0 | b;
value >>= count;
return (byte)(value & 0xff);
}
/**
* Return the byte value shifted to the left by the number of specified
* bits.
*
* @param b the byte value.
* @param count number of bits to shift.
* @return the shifted byte value.
*/
private static byte shiftleft(final byte b, final int count) {
int value = 0 | b;
value <<= count;
return (byte)(value & 0xff);
}
/** Destination buffer. */
private final ByteArrayOutputStream lzwbuffer = new ByteArrayOutputStream();
/** LZW output stream. */
private LZWOutputStream lzw = new LZWOutputStream(lzwbuffer);
/** Raw data. */
private static byte[] rawdata;
/** Compressed data. */
private static byte[] lzwdata;
@BeforeClass
public static void setup() throws IOException {
// Load the raw file.
rawdata = IOUtils.readResource(DATAFILE);
// Load the compressed file.
lzwdata = IOUtils.readResource(LZWFILE);
}
@After
public void reset() {
lzwbuffer.reset();
lzw = new LZWOutputStream(lzwbuffer);
}
@Test
public void oneByte() throws IOException {
// Codes are buffered until flushed.
final byte b = 0x1f;
lzw.write(b);
assertEquals(0, lzwbuffer.toByteArray().length);
// Codes are only buffered after another code is received.
lzw.flush();
assertEquals(0, lzwbuffer.toByteArray().length);
// All codes should be written to the backing stream.
lzw.close();
final byte[] compressed = lzwbuffer.toByteArray();
assertEquals(1, compressed.length);
assertEquals(b, compressed[0]);
}
@Test
public void twoBytes() throws IOException {
final byte[] data = { (byte)0x66, (byte)0x67 };
final byte[] codes = { (byte)0x66, (byte)0x33, (byte)0x80 };
// Codes are buffered until flushed.
lzw.write(data);
assertEquals(0, lzwbuffer.toByteArray().length);
// With two codes, the first one will be buffered.
lzw.flush();
final byte[] flushed = lzwbuffer.toByteArray();
assertEquals(1, flushed.length);
assertEquals(codes[0], flushed[0]);
// The second code will have an increased bit length.
lzw.close();
final byte[] compressed = lzwbuffer.toByteArray();
assertEquals(3, compressed.length);
assertEquals(data[0], compressed[0]);
assertEquals(shiftright(data[1], 1), compressed[1]);
assertEquals(shiftleft(data[1], 7), compressed[2]);
assertArrayEquals(codes, compressed);
}
@Test
public void threeBytes() throws IOException {
final byte[] data = { (byte)0x61, (byte)0xd7, (byte)0xb1 };
final byte[] codes = { (byte)0x61, (byte)0x6b, (byte)0xac, (byte)0x40 };
// Codes are buffered until flushed.
lzw.write(data);
assertEquals(0, lzwbuffer.toByteArray().length);
// With two codes, the first one will be buffered.
lzw.flush();
final byte[] flushed = lzwbuffer.toByteArray();
assertEquals(1, flushed.length);
assertEquals(codes[0], flushed[0]);
// Confirm the encoding.
lzw.close();
final byte[] compressed = lzwbuffer.toByteArray();
assertEquals(codes.length, compressed.length);
assertArrayEquals(codes, compressed);
}
@Test
public void finishThreeBytes() throws IOException {
final byte[] data = { (byte)0x61, (byte)0xd7, (byte)0xb1 };
final byte[] codes = { (byte)0x61, (byte)0x6b, (byte)0xac, (byte)0x40 };
// Codes are buffered until flushed.
lzw.write(data);
assertEquals(0, lzwbuffer.toByteArray().length);
// With two codes, the first one will be buffered.
lzw.flush();
final byte[] flushed = lzwbuffer.toByteArray();
assertEquals(1, flushed.length);
assertEquals(codes[0], flushed[0]);
// Finish and confirm the encoding.
lzw.finish();
final byte[] compressed = lzwbuffer.toByteArray();
assertEquals(codes.length, compressed.length);
assertArrayEquals(codes, compressed);
}
@Test
public void verona() throws IOException {
// Compress the raw file contents.
final ByteArrayOutputStream compressed = new ByteArrayOutputStream();
final LZWOutputStream lzos = new LZWOutputStream(compressed);
lzos.write(rawdata);
lzos.close();
final byte[] lzw = compressed.toByteArray();
assertArrayEquals(lzwdata, lzw);
}
@Test(expected = IOException.class)
public void closed() throws IOException {
try {
lzw.close();
} catch (final IOException e) {
fail(e.toString());
}
lzw.write((byte)0);
}
}
| 9,970 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/userauth/UserIdTokenAuthenticationFactoryTest.java | /**
* Copyright (c) 2014-2018 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.userauth;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
import com.netflix.msl.MslUserAuthException;
import com.netflix.msl.MslUserIdTokenException;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.tokens.MasterToken;
import com.netflix.msl.tokens.MockMslUser;
import com.netflix.msl.tokens.MockTokenFactory;
import com.netflix.msl.tokens.MslUser;
import com.netflix.msl.tokens.UserIdToken;
import com.netflix.msl.util.MockAuthenticationUtils;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* User ID token user authentication factory unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class UserIdTokenAuthenticationFactoryTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key master token. */
private static final String KEY_MASTER_TOKEN = "mastertoken";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
/** MSL context. */
private static MockMslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
/** Authentication utilities. */
private static MockAuthenticationUtils authutils;
/** User authentication factory. */
private static UserAuthenticationFactory factory;
/** Token factory. */
private static MockTokenFactory tokenFactory;
/** Master token. */
private static MasterToken MASTER_TOKEN;
/** User ID token. */
private static UserIdToken USER_ID_TOKEN;
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException {
ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = ctx.getMslEncoderFactory();
authutils = new MockAuthenticationUtils();
factory = new UserIdTokenAuthenticationFactory(authutils);
ctx.addUserAuthenticationFactory(factory);
tokenFactory = new MockTokenFactory();
ctx.setTokenFactory(tokenFactory);
MASTER_TOKEN = MslTestUtils.getMasterToken(ctx, 1L, 1L);
final MslUser user = new MockMslUser(1);
USER_ID_TOKEN = MslTestUtils.getUserIdToken(ctx, MASTER_TOKEN, 1L, user);
}
@AfterClass
public static void teardown() {
USER_ID_TOKEN = null;
MASTER_TOKEN = null;
tokenFactory = null;
factory = null;
authutils = null;
encoder = null;
ctx = null;
}
@After
public void reset() {
authutils.reset();
tokenFactory.reset();
}
@Test
public void createData() throws MslEncodingException, MslUserAuthException, MslCryptoException, MslEncoderException {
final UserIdTokenAuthenticationData data = new UserIdTokenAuthenticationData(MASTER_TOKEN, USER_ID_TOKEN);
final MslObject userAuthMo = data.getAuthData(encoder, ENCODER_FORMAT);
final UserAuthenticationData authdata = factory.createData(ctx, null, userAuthMo);
assertNotNull(authdata);
assertTrue(authdata instanceof UserIdTokenAuthenticationData);
assertEquals(data, authdata);
}
@Test
public void encodeException() throws MslEncodingException, MslUserAuthException, MslCryptoException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final UserIdTokenAuthenticationData data = new UserIdTokenAuthenticationData(MASTER_TOKEN, USER_ID_TOKEN);
final MslObject userAuthMo = data.getAuthData(encoder, ENCODER_FORMAT);
userAuthMo.remove(KEY_MASTER_TOKEN);
factory.createData(ctx, null, userAuthMo);
}
@Test
public void authenticate() throws MslUserAuthException, MslUserIdTokenException {
final UserIdTokenAuthenticationData data = new UserIdTokenAuthenticationData(MASTER_TOKEN, USER_ID_TOKEN);
final MslUser user = factory.authenticate(ctx, MASTER_TOKEN.getIdentity(), data, null);
assertNotNull(user);
assertEquals(USER_ID_TOKEN.getUser(), user);
}
@Test
public void authenticateUserIdToken() throws MslEncodingException, MslCryptoException, MslUserAuthException, MslUserIdTokenException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, MASTER_TOKEN.getSequenceNumber() + 1, MASTER_TOKEN.getSerialNumber() + 1);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(ctx, masterToken, USER_ID_TOKEN.getSerialNumber() + 1, USER_ID_TOKEN.getUser());
final UserIdTokenAuthenticationData data = new UserIdTokenAuthenticationData(MASTER_TOKEN, USER_ID_TOKEN);
final MslUser u = factory.authenticate(ctx, MASTER_TOKEN.getIdentity(), data, userIdToken);
assertEquals(USER_ID_TOKEN.getUser(), u);
}
@Test
public void authenticateMismatchedUserIdToken() throws MslEncodingException, MslCryptoException, MslUserAuthException, MslUserIdTokenException {
thrown.expect(MslUserAuthException.class);
thrown.expectMslError(MslError.USERIDTOKEN_USERAUTH_DATA_MISMATCH);
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final MslUser user = new MockMslUser(2);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(ctx, masterToken, 1, user);
final UserIdTokenAuthenticationData data = new UserIdTokenAuthenticationData(MASTER_TOKEN, USER_ID_TOKEN);
factory.authenticate(ctx, MASTER_TOKEN.getIdentity(), data, userIdToken);
}
@Test
public void untrustedMasterToken() throws MslEncodingException, MslCryptoException, MslEncoderException, MslException {
thrown.expect(MslUserAuthException.class);
thrown.expectMslError(MslError.USERAUTH_MASTERTOKEN_NOT_DECRYPTED);
final MasterToken untrustedMasterToken = MslTestUtils.getUntrustedMasterToken(ctx);
final UserIdTokenAuthenticationData data = new UserIdTokenAuthenticationData(untrustedMasterToken, USER_ID_TOKEN);
factory.authenticate(ctx, MASTER_TOKEN.getIdentity(), data, null);
}
@Test
public void mismatchedMasterTokenIdentity() throws MslEncodingException, MslCryptoException, MslUserAuthException, MslUserIdTokenException {
thrown.expect(MslUserAuthException.class);
thrown.expectMslError(MslError.USERAUTH_ENTITY_MISMATCH);
final MslContext mismatchedCtx = new MockMslContext(EntityAuthenticationScheme.X509, false);
final MasterToken mismatchedMasterToken = MslTestUtils.getMasterToken(mismatchedCtx, 1, 1);
final UserIdTokenAuthenticationData data = new UserIdTokenAuthenticationData(mismatchedMasterToken, USER_ID_TOKEN);
factory.authenticate(ctx, MASTER_TOKEN.getIdentity(), data, null);
}
@Test
public void untrustedUserIdToken() throws MslEncodingException, MslCryptoException, MslEncoderException, MslException {
thrown.expect(MslUserAuthException.class);
thrown.expectMslError(MslError.USERAUTH_USERIDTOKEN_NOT_DECRYPTED);
final UserIdToken untrustedUserIdToken = MslTestUtils.getUntrustedUserIdToken(ctx, MASTER_TOKEN, USER_ID_TOKEN.getSerialNumber(), USER_ID_TOKEN.getUser());
final UserIdTokenAuthenticationData data = new UserIdTokenAuthenticationData(MASTER_TOKEN, untrustedUserIdToken);
factory.authenticate(ctx, MASTER_TOKEN.getIdentity(), data, null);
}
@Test
public void userNotPermitted() throws MslUserAuthException, MslUserIdTokenException {
thrown.expect(MslUserAuthException.class);
thrown.expectMslError(MslError.USERAUTH_ENTITYUSER_INCORRECT_DATA);
authutils.disallowScheme(MASTER_TOKEN.getIdentity(), USER_ID_TOKEN.getUser(), UserAuthenticationScheme.USER_ID_TOKEN);
final UserIdTokenAuthenticationData data = new UserIdTokenAuthenticationData(MASTER_TOKEN, USER_ID_TOKEN);
factory.authenticate(ctx, MASTER_TOKEN.getIdentity(), data, null);
}
@Test
public void tokenRevoked() throws MslUserIdTokenException, MslUserAuthException {
thrown.expect(MslUserAuthException.class);
thrown.expectMslError(MslError.USERIDTOKEN_REVOKED);
tokenFactory.setRevokedUserIdToken(USER_ID_TOKEN);
final UserIdTokenAuthenticationData data = new UserIdTokenAuthenticationData(MASTER_TOKEN, USER_ID_TOKEN);
factory.authenticate(ctx, MASTER_TOKEN.getIdentity(), data, null);
}
}
| 9,971 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/userauth/UserAuthenticationDataTest.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.userauth;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslUserAuthException;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
/**
* User authentication data unit tests.
*
* Successful calls to
* {@link UserAuthenticationData#create(com.netflix.msl.util.MslContext, org.json.MslObject)}
* covered in the individual user authentication data unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class UserAuthenticationDataTest {
/** Key user authentication scheme. */
private static final String KEY_SCHEME = "scheme";
/** Key user authentication data. */
private static final String KEY_AUTHDATA = "authdata";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException {
ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = ctx.getMslEncoderFactory();
}
@AfterClass
public static void teardown() {
encoder = null;
ctx = null;
}
@Test
public void noScheme() throws MslEncoderException, MslUserAuthException, MslEncodingException, MslCryptoException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final MslObject mo = encoder.createObject();
mo.put(KEY_SCHEME + "x", UserAuthenticationScheme.EMAIL_PASSWORD.name());
mo.put(KEY_AUTHDATA, encoder.createObject());
UserAuthenticationData.create(ctx, null, mo);
}
@Test
public void noAuthdata() throws MslEncoderException, MslUserAuthException, MslEncodingException, MslCryptoException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final MslObject mo = encoder.createObject();
mo.put(KEY_SCHEME, UserAuthenticationScheme.EMAIL_PASSWORD.name());
mo.put(KEY_AUTHDATA + "x", encoder.createObject());
UserAuthenticationData.create(ctx, null, mo);
}
@Test
public void unidentifiedScheme() throws MslEncoderException, MslUserAuthException, MslEncodingException, MslCryptoException {
thrown.expect(MslUserAuthException.class);
thrown.expectMslError(MslError.UNIDENTIFIED_USERAUTH_SCHEME);
final MslObject mo = encoder.createObject();
mo.put(KEY_SCHEME, "x");
mo.put(KEY_AUTHDATA, encoder.createObject());
UserAuthenticationData.create(ctx, null, mo);
}
@Test
public void authFactoryNotFound() throws MslEncoderException, MslUserAuthException, MslEncodingException, MslCryptoException {
thrown.expect(MslUserAuthException.class);
thrown.expectMslError(MslError.USERAUTH_FACTORY_NOT_FOUND);
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
ctx.removeUserAuthenticationFactory(UserAuthenticationScheme.EMAIL_PASSWORD);
final MslObject mo = encoder.createObject();
mo.put(KEY_SCHEME, UserAuthenticationScheme.EMAIL_PASSWORD.name());
mo.put(KEY_AUTHDATA, encoder.createObject());
UserAuthenticationData.create(ctx, null, mo);
}
/** MSL context. */
private static MslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
}
| 9,972 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/userauth/EmailPasswordAuthenticationDataTest.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.userauth;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.io.IOException;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslUserAuthException;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* Email/password user authentication data unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class EmailPasswordAuthenticationDataTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key user authentication scheme. */
private static final String KEY_SCHEME = "scheme";
/** Key user authentication data. */
private static final String KEY_AUTHDATA = "authdata";
/** Key email. */
private static final String KEY_EMAIL = "email";
/** Key password. */
private static final String KEY_PASSWORD = "password";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@BeforeClass
public static void setup() throws IOException, MslEncodingException, MslCryptoException {
ctx = new MockMslContext(EntityAuthenticationScheme.X509, false);
encoder = ctx.getMslEncoderFactory();
}
@AfterClass
public static void teardown() {
encoder = null;
ctx = null;
}
@Test
public void ctors() throws MslEncodingException, MslEncoderException {
final EmailPasswordAuthenticationData data = new EmailPasswordAuthenticationData(MockEmailPasswordAuthenticationFactory.EMAIL, MockEmailPasswordAuthenticationFactory.PASSWORD);
assertEquals(UserAuthenticationScheme.EMAIL_PASSWORD, data.getScheme());
assertEquals(MockEmailPasswordAuthenticationFactory.EMAIL, data.getEmail());
assertEquals(MockEmailPasswordAuthenticationFactory.PASSWORD, data.getPassword());
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(authdata);
final byte[] encode = data.toMslEncoding(encoder, ENCODER_FORMAT);
final EmailPasswordAuthenticationData moData = new EmailPasswordAuthenticationData(authdata);
assertEquals(data.getScheme(), moData.getScheme());
assertEquals(data.getEmail(), moData.getEmail());
assertEquals(data.getPassword(), moData.getPassword());
final MslObject moAuthdata = moData.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(moAuthdata);
assertTrue(MslEncoderUtils.equalObjects(authdata, moAuthdata));
final byte[] moEncode = moData.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void mslObject() throws MslEncoderException {
final EmailPasswordAuthenticationData data = new EmailPasswordAuthenticationData(MockEmailPasswordAuthenticationFactory.EMAIL, MockEmailPasswordAuthenticationFactory.PASSWORD);
final MslObject mo = MslTestUtils.toMslObject(encoder, data);
assertEquals(UserAuthenticationScheme.EMAIL_PASSWORD.toString(), mo.getString(KEY_SCHEME));
final MslObject authdata = mo.getMslObject(KEY_AUTHDATA, encoder);
assertEquals(MockEmailPasswordAuthenticationFactory.EMAIL, authdata.getString(KEY_EMAIL));
assertEquals(MockEmailPasswordAuthenticationFactory.PASSWORD, authdata.getString(KEY_PASSWORD));
}
@Test
public void create() throws MslUserAuthException, MslEncodingException, MslEncoderException, MslCryptoException {
final EmailPasswordAuthenticationData data = new EmailPasswordAuthenticationData(MockEmailPasswordAuthenticationFactory.EMAIL, MockEmailPasswordAuthenticationFactory.PASSWORD);
final byte[] encode = data.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final UserAuthenticationData userdata = UserAuthenticationData.create(ctx, null, mo);
assertNotNull(userdata);
assertTrue(userdata instanceof EmailPasswordAuthenticationData);
final EmailPasswordAuthenticationData moData = (EmailPasswordAuthenticationData)userdata;
assertEquals(data.getScheme(), moData.getScheme());
assertEquals(data.getEmail(), moData.getEmail());
assertEquals(data.getPassword(), moData.getPassword());
final MslObject moAuthdata = moData.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(moAuthdata);
assertTrue(MslEncoderUtils.equalObjects(data.getAuthData(encoder, ENCODER_FORMAT), moAuthdata));
final byte[] moEncode = moData.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void missingEmail() throws MslEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final EmailPasswordAuthenticationData data = new EmailPasswordAuthenticationData(MockEmailPasswordAuthenticationFactory.EMAIL, MockEmailPasswordAuthenticationFactory.PASSWORD);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
authdata.remove(KEY_EMAIL);
new EmailPasswordAuthenticationData(authdata);
}
@Test
public void missingPassword() throws MslEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final EmailPasswordAuthenticationData data = new EmailPasswordAuthenticationData(MockEmailPasswordAuthenticationFactory.EMAIL, MockEmailPasswordAuthenticationFactory.PASSWORD);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
authdata.remove(KEY_PASSWORD);
new EmailPasswordAuthenticationData(authdata);
}
@Test
public void equalsEmail() throws MslEncodingException {
final EmailPasswordAuthenticationData dataA = new EmailPasswordAuthenticationData(MockEmailPasswordAuthenticationFactory.EMAIL + "A", MockEmailPasswordAuthenticationFactory.PASSWORD);
final EmailPasswordAuthenticationData dataB = new EmailPasswordAuthenticationData(MockEmailPasswordAuthenticationFactory.EMAIL + "B", MockEmailPasswordAuthenticationFactory.PASSWORD);
final EmailPasswordAuthenticationData dataA2 = new EmailPasswordAuthenticationData(dataA.getAuthData(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsPassword() throws MslEncodingException {
final EmailPasswordAuthenticationData dataA = new EmailPasswordAuthenticationData(MockEmailPasswordAuthenticationFactory.EMAIL, MockEmailPasswordAuthenticationFactory.PASSWORD + "A");
final EmailPasswordAuthenticationData dataB = new EmailPasswordAuthenticationData(MockEmailPasswordAuthenticationFactory.EMAIL, MockEmailPasswordAuthenticationFactory.PASSWORD + "B");
final EmailPasswordAuthenticationData dataA2 = new EmailPasswordAuthenticationData(dataA.getAuthData(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsObject() {
final EmailPasswordAuthenticationData data = new EmailPasswordAuthenticationData(MockEmailPasswordAuthenticationFactory.EMAIL, MockEmailPasswordAuthenticationFactory.PASSWORD);
assertFalse(data.equals(null));
assertFalse(data.equals(KEY_EMAIL));
assertTrue(data.hashCode() != KEY_EMAIL.hashCode());
}
/** MSL context. */
private static MslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
}
| 9,973 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/userauth/UserIdTokenAuthenticationDataTest.java | /**
* Copyright (c) 2014-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.userauth;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslUserAuthException;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.tokens.MasterToken;
import com.netflix.msl.tokens.MockMslUser;
import com.netflix.msl.tokens.MslUser;
import com.netflix.msl.tokens.UserIdToken;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* User ID token user authentication data unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class UserIdTokenAuthenticationDataTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key user authentication scheme. */
private static final String KEY_SCHEME = "scheme";
/** Key user authentication data. */
private static final String KEY_AUTHDATA = "authdata";
/** Key master token. */
private static final String KEY_MASTER_TOKEN = "mastertoken";
/** Key user ID token. */
private static final String KEY_USER_ID_TOKEN = "useridtoken";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
/** Master token. */
private static MasterToken MASTER_TOKEN;
/** User ID token. */
private static UserIdToken USER_ID_TOKEN;
/** MSL context. */
private static MslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException {
ctx = new MockMslContext(EntityAuthenticationScheme.X509, false);
encoder = ctx.getMslEncoderFactory();
MASTER_TOKEN = MslTestUtils.getMasterToken(ctx, 1L, 1L);
final MslUser user = new MockMslUser(1);
USER_ID_TOKEN = MslTestUtils.getUserIdToken(ctx, MASTER_TOKEN, 1L, user);
}
@AfterClass
public static void teardown() {
USER_ID_TOKEN = null;
MASTER_TOKEN = null;
encoder = null;
ctx = null;
}
@Test
public void ctors() throws MslEncodingException, MslUserAuthException, MslEncoderException {
final UserIdTokenAuthenticationData data = new UserIdTokenAuthenticationData(MASTER_TOKEN, USER_ID_TOKEN);
assertEquals(UserAuthenticationScheme.USER_ID_TOKEN, data.getScheme());
assertEquals(MASTER_TOKEN, data.getMasterToken());
assertEquals(USER_ID_TOKEN, data.getUserIdToken());
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(authdata);
final byte[] encode = data.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final UserIdTokenAuthenticationData moData = new UserIdTokenAuthenticationData(ctx, authdata);
assertEquals(data.getScheme(), moData.getScheme());
assertEquals(data.getMasterToken(), moData.getMasterToken());
assertEquals(data.getUserIdToken(), moData.getUserIdToken());
final MslObject moAuthdata = moData.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(moAuthdata);
final byte[] moEncode = moData.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(moEncode, encode);
}
@Test
public void mslObject() throws MslEncoderException {
final UserIdTokenAuthenticationData data = new UserIdTokenAuthenticationData(MASTER_TOKEN, USER_ID_TOKEN);
final MslObject mo = MslTestUtils.toMslObject(encoder, data);
assertEquals(UserAuthenticationScheme.USER_ID_TOKEN.name(), mo.getString(KEY_SCHEME));
final MslObject authdata = mo.getMslObject(KEY_AUTHDATA, encoder);
final MslObject masterTokenJo = authdata.getMslObject(KEY_MASTER_TOKEN, encoder);
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, MASTER_TOKEN), masterTokenJo));
final MslObject userIdTokenJo = authdata.getMslObject(KEY_USER_ID_TOKEN, encoder);
assertTrue(MslEncoderUtils.equalObjects(MslTestUtils.toMslObject(encoder, USER_ID_TOKEN), userIdTokenJo));
}
@Test
public void create() throws MslUserAuthException, MslEncodingException, MslCryptoException, MslEncoderException {
final UserIdTokenAuthenticationData data = new UserIdTokenAuthenticationData(MASTER_TOKEN, USER_ID_TOKEN);
final byte[] encode = data.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final UserAuthenticationData userdata = UserAuthenticationData.create(ctx, null, mo);
assertNotNull(userdata);
assertTrue(userdata instanceof UserIdTokenAuthenticationData);
final UserIdTokenAuthenticationData moData = (UserIdTokenAuthenticationData)userdata;
assertEquals(data.getScheme(), moData.getScheme());
assertEquals(data.getMasterToken(), moData.getMasterToken());
assertEquals(data.getUserIdToken(), moData.getUserIdToken());
final MslObject moAuthdata = moData.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(moAuthdata);
final byte[] moEncode = moData.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(moEncode, encode);
}
@Test
public void missingMasterToken() throws MslEncodingException, MslUserAuthException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final UserIdTokenAuthenticationData data = new UserIdTokenAuthenticationData(MASTER_TOKEN, USER_ID_TOKEN);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
authdata.remove(KEY_MASTER_TOKEN);
new UserIdTokenAuthenticationData(ctx, authdata);
}
@Test
public void invalidMasterToken() throws MslEncodingException, MslUserAuthException, MslEncoderException {
thrown.expect(MslUserAuthException.class);
thrown.expectMslError(MslError.USERAUTH_MASTERTOKEN_INVALID);
final UserIdTokenAuthenticationData data = new UserIdTokenAuthenticationData(MASTER_TOKEN, USER_ID_TOKEN);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
authdata.put(KEY_MASTER_TOKEN, new MslObject());
new UserIdTokenAuthenticationData(ctx, authdata);
}
@Test
public void missingUserIdToken() throws MslEncodingException, MslUserAuthException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final UserIdTokenAuthenticationData data = new UserIdTokenAuthenticationData(MASTER_TOKEN, USER_ID_TOKEN);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
authdata.remove(KEY_USER_ID_TOKEN);
new UserIdTokenAuthenticationData(ctx, authdata);
}
@Test
public void invalidUserIdToken() throws MslEncodingException, MslUserAuthException, MslEncoderException {
thrown.expect(MslUserAuthException.class);
thrown.expectMslError(MslError.USERAUTH_USERIDTOKEN_INVALID);
final UserIdTokenAuthenticationData data = new UserIdTokenAuthenticationData(MASTER_TOKEN, USER_ID_TOKEN);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
authdata.put(KEY_USER_ID_TOKEN, new MslObject());
new UserIdTokenAuthenticationData(ctx, authdata);
}
@Test
public void mismatchedTokens() throws MslEncodingException, MslCryptoException, MslUserAuthException, MslEncoderException {
thrown.expect(MslUserAuthException.class);
thrown.expectMslError(MslError.USERAUTH_USERIDTOKEN_INVALID);
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, MASTER_TOKEN.getSequenceNumber(), MASTER_TOKEN.getSerialNumber() + 1);
final UserIdTokenAuthenticationData data = new UserIdTokenAuthenticationData(MASTER_TOKEN, USER_ID_TOKEN);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
authdata.put(KEY_MASTER_TOKEN, MslTestUtils.toMslObject(encoder, masterToken));
new UserIdTokenAuthenticationData(ctx, authdata);
}
@Test
public void equalsMasterToken() throws MslEncodingException, MslCryptoException, MslUserAuthException, MslEncoderException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, MASTER_TOKEN.getSequenceNumber() + 1, MASTER_TOKEN.getSerialNumber());
final UserIdTokenAuthenticationData dataA = new UserIdTokenAuthenticationData(MASTER_TOKEN, USER_ID_TOKEN);
final UserIdTokenAuthenticationData dataB = new UserIdTokenAuthenticationData(masterToken, USER_ID_TOKEN);
final UserIdTokenAuthenticationData dataA2 = new UserIdTokenAuthenticationData(ctx, dataA.getAuthData(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsUserIdToken() throws MslEncodingException, MslCryptoException, MslUserAuthException, MslEncoderException {
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(ctx, MASTER_TOKEN, USER_ID_TOKEN.getSerialNumber() + 1, USER_ID_TOKEN.getUser());
final UserIdTokenAuthenticationData dataA = new UserIdTokenAuthenticationData(MASTER_TOKEN, USER_ID_TOKEN);
final UserIdTokenAuthenticationData dataB = new UserIdTokenAuthenticationData(MASTER_TOKEN, userIdToken);
final UserIdTokenAuthenticationData dataA2 = new UserIdTokenAuthenticationData(ctx, dataA.getAuthData(encoder, ENCODER_FORMAT));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsObject() {
final UserIdTokenAuthenticationData data = new UserIdTokenAuthenticationData(MASTER_TOKEN, USER_ID_TOKEN);
assertFalse(data.equals(null));
assertFalse(data.equals(KEY_MASTER_TOKEN));
assertTrue(data.hashCode() != KEY_MASTER_TOKEN.hashCode());
}
}
| 9,974 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/userauth/EmailPasswordAuthenticationFactoryTest.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.userauth;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslUserAuthException;
import com.netflix.msl.MslUserIdTokenException;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.tokens.MasterToken;
import com.netflix.msl.tokens.MslUser;
import com.netflix.msl.tokens.UserIdToken;
import com.netflix.msl.util.MockAuthenticationUtils;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* Email/password user authentication factory unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class EmailPasswordAuthenticationFactoryTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key email. */
private static final String KEY_EMAIL = "email";
/** Empty string. */
private static final String EMPTY_STRING = "";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException {
ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = ctx.getMslEncoderFactory();
final MockEmailPasswordStore store = new MockEmailPasswordStore();
store.addUser(MockEmailPasswordAuthenticationFactory.EMAIL, MockEmailPasswordAuthenticationFactory.PASSWORD, MockEmailPasswordAuthenticationFactory.USER);
authutils = new MockAuthenticationUtils();
factory = new EmailPasswordAuthenticationFactory(store, authutils);
ctx.addUserAuthenticationFactory(factory);
}
@AfterClass
public static void teardown() {
factory = null;
authutils = null;
encoder = null;
ctx = null;
}
@After
public void reset() {
authutils.reset();
}
@Test
public void createData() throws MslEncodingException, MslUserAuthException, MslEncoderException, MslCryptoException {
final EmailPasswordAuthenticationData data = new EmailPasswordAuthenticationData(MockEmailPasswordAuthenticationFactory.EMAIL, MockEmailPasswordAuthenticationFactory.PASSWORD);
final MslObject userAuthMo = data.getAuthData(encoder, ENCODER_FORMAT);
final UserAuthenticationData authdata = factory.createData(ctx, null, userAuthMo);
assertNotNull(authdata);
assertTrue(authdata instanceof EmailPasswordAuthenticationData);
final MslObject dataMo = MslTestUtils.toMslObject(encoder, data);
final MslObject authdataMo = MslTestUtils.toMslObject(encoder, authdata);
assertTrue(MslEncoderUtils.equalObjects(dataMo, authdataMo));
}
@Test
public void encodeException() throws MslEncodingException, MslUserAuthException, MslCryptoException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final EmailPasswordAuthenticationData data = new EmailPasswordAuthenticationData(MockEmailPasswordAuthenticationFactory.EMAIL, MockEmailPasswordAuthenticationFactory.PASSWORD);
final MslObject userAuthMo = data.getAuthData(encoder, ENCODER_FORMAT);
userAuthMo.remove(KEY_EMAIL);
factory.createData(ctx, null, userAuthMo);
}
@Test
public void authenticate() throws MslUserAuthException, MslUserIdTokenException {
final EmailPasswordAuthenticationData data = new EmailPasswordAuthenticationData(MockEmailPasswordAuthenticationFactory.EMAIL, MockEmailPasswordAuthenticationFactory.PASSWORD);
final MslUser user = factory.authenticate(ctx, null, data, null);
assertNotNull(user);
assertEquals(MockEmailPasswordAuthenticationFactory.USER, user);
}
@Test
public void authenticateUserIdToken() throws MslEncodingException, MslCryptoException, MslUserAuthException, MslUserIdTokenException {
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final MslUser user = MockEmailPasswordAuthenticationFactory.USER;
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(ctx, masterToken, 1, user);
final EmailPasswordAuthenticationData data = new EmailPasswordAuthenticationData(MockEmailPasswordAuthenticationFactory.EMAIL, MockEmailPasswordAuthenticationFactory.PASSWORD);
final MslUser u = factory.authenticate(ctx, null, data, userIdToken);
assertEquals(user, u);
}
@Test
public void authenticateMismatchedUserIdToken() throws MslEncodingException, MslCryptoException, MslUserAuthException, MslUserIdTokenException {
thrown.expect(MslUserAuthException.class);
thrown.expectMslError(MslError.USERIDTOKEN_USERAUTH_DATA_MISMATCH);
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final MslUser user = MockEmailPasswordAuthenticationFactory.USER_2;
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(ctx, masterToken, 1, user);
final EmailPasswordAuthenticationData data = new EmailPasswordAuthenticationData(MockEmailPasswordAuthenticationFactory.EMAIL, MockEmailPasswordAuthenticationFactory.PASSWORD);
factory.authenticate(ctx, null, data, userIdToken);
}
@Test
public void emailBlank() throws MslUserAuthException, MslUserIdTokenException {
thrown.expect(MslUserAuthException.class);
thrown.expectMslError(MslError.EMAILPASSWORD_BLANK);
final EmailPasswordAuthenticationData data = new EmailPasswordAuthenticationData(EMPTY_STRING, MockEmailPasswordAuthenticationFactory.PASSWORD);
factory.authenticate(ctx, null, data, null);
}
@Test
public void passwordBlank() throws MslUserAuthException, MslUserIdTokenException {
thrown.expect(MslUserAuthException.class);
thrown.expectMslError(MslError.EMAILPASSWORD_BLANK);
final EmailPasswordAuthenticationData data = new EmailPasswordAuthenticationData(MockEmailPasswordAuthenticationFactory.EMAIL, EMPTY_STRING);
factory.authenticate(ctx, null, data, null);
}
@Test
public void badLogin() throws MslUserAuthException, MslUserIdTokenException {
thrown.expect(MslUserAuthException.class);
thrown.expectMslError(MslError.EMAILPASSWORD_INCORRECT);
final EmailPasswordAuthenticationData data = new EmailPasswordAuthenticationData(MockEmailPasswordAuthenticationFactory.EMAIL, MockEmailPasswordAuthenticationFactory.PASSWORD + "x");
factory.authenticate(ctx, null, data, null);
}
/** MSL context. */
private static MockMslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
/** Authentication utilities. */
private static MockAuthenticationUtils authutils;
/** User authentication factory. */
private static UserAuthenticationFactory factory;
}
| 9,975 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/tokens/MasterTokenTest.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.tokens;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.io.UnsupportedEncodingException;
import java.util.Date;
import javax.crypto.SecretKey;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslConstants;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.crypto.JcaAlgorithm;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.entityauth.MockPresharedAuthenticationFactory;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* Master token unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class MasterTokenTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Milliseconds per second. */
private static final long MILLISECONDS_PER_SECOND = 1000;
/** Key token data. */
private static final String KEY_TOKENDATA = "tokendata";
/** Key signature. */
private static final String KEY_SIGNATURE = "signature";
// tokendata
/** Key renewal window timestamp. */
private static final String KEY_RENEWAL_WINDOW = "renewalwindow";
/** Key expiration timestamp. */
private static final String KEY_EXPIRATION = "expiration";
/** Key sequence number. */
private static final String KEY_SEQUENCE_NUMBER = "sequencenumber";
/** Key serial number. */
private static final String KEY_SERIAL_NUMBER = "serialnumber";
/** Key session data. */
private static final String KEY_SESSIONDATA = "sessiondata";
// sessiondata
/** Key issuer data. */
private static final String KEY_ISSUER_DATA = "issuerdata";
/** Key identity. */
private static final String KEY_IDENTITY = "identity";
/** Key symmetric encryption key. */
private static final String KEY_ENCRYPTION_KEY = "encryptionkey";
/** Key encryption algorithm. */
private static final String KEY_ENCRYPTION_ALGORITHM = "encryptionalgorithm";
/** Key symmetric HMAC key. */
private static final String KEY_HMAC_KEY = "hmackey";
/** Key signature key. */
private static final String KEY_SIGNATURE_KEY = "signaturekey";
/** Key signature algorithm. */
private static final String KEY_SIGNATURE_ALGORITHM = "signaturealgorithm";
private static final Date RENEWAL_WINDOW = new Date(System.currentTimeMillis() + 60000);
private static final Date EXPIRATION = new Date(System.currentTimeMillis() + 120000);
private static final long SEQUENCE_NUMBER = 1;
private static final long SERIAL_NUMBER = 42;
private static MslObject ISSUER_DATA;
private static final String IDENTITY = MockPresharedAuthenticationFactory.PSK_ESN;
private static final SecretKey ENCRYPTION_KEY = MockPresharedAuthenticationFactory.KPE;
private static final SecretKey SIGNATURE_KEY = MockPresharedAuthenticationFactory.KPH;
private static long incrementSequenceNumber(final long seqNo, final long amount) {
if (seqNo - MslConstants.MAX_LONG_VALUE + amount <= 0)
return seqNo + amount;
return seqNo - MslConstants.MAX_LONG_VALUE - 1 + amount;
}
private static long decrementSequenceNumber(final long seqNo, final long amount) {
if (seqNo - amount >= 0)
return seqNo - amount;
return MslConstants.MAX_LONG_VALUE - amount - 1 + seqNo;
}
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException, MslEncoderException {
ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = ctx.getMslEncoderFactory();
ISSUER_DATA = encoder.parseObject("{ 'issuerid' : 17 }".getBytes());
}
@AfterClass
public static void teardown() {
encoder = null;
ctx = null;
}
@Test
public void ctors() throws MslEncoderException, MslException {
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
assertTrue(masterToken.isDecrypted());
assertTrue(masterToken.isVerified());
assertFalse(masterToken.isRenewable(null));
assertFalse(masterToken.isExpired(null));
assertFalse(masterToken.isNewerThan(masterToken));
assertArrayEquals(ENCRYPTION_KEY.getEncoded(), masterToken.getEncryptionKey().getEncoded());
assertEquals(EXPIRATION.getTime() / MILLISECONDS_PER_SECOND, masterToken.getExpiration().getTime() / MILLISECONDS_PER_SECOND);
assertArrayEquals(SIGNATURE_KEY.getEncoded(), masterToken.getSignatureKey().getEncoded());
assertEquals(IDENTITY, masterToken.getIdentity());
assertTrue(MslEncoderUtils.equalObjects(ISSUER_DATA, masterToken.getIssuerData()));
assertEquals(RENEWAL_WINDOW.getTime() / MILLISECONDS_PER_SECOND, masterToken.getRenewalWindow().getTime() / MILLISECONDS_PER_SECOND);
assertEquals(SEQUENCE_NUMBER, masterToken.getSequenceNumber());
assertEquals(SERIAL_NUMBER, masterToken.getSerialNumber());
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final MslObject mo = encoder.parseObject(encode);
final MasterToken moMasterToken = new MasterToken(ctx, mo);
assertEquals(masterToken.isDecrypted(), moMasterToken.isDecrypted());
assertEquals(masterToken.isVerified(), moMasterToken.isVerified());
assertEquals(masterToken.isRenewable(null), moMasterToken.isRenewable(null));
assertEquals(masterToken.isExpired(null), moMasterToken.isExpired(null));
assertFalse(moMasterToken.isNewerThan(masterToken));
assertFalse(masterToken.isNewerThan(moMasterToken));
assertArrayEquals(masterToken.getEncryptionKey().getEncoded(), moMasterToken.getEncryptionKey().getEncoded());
assertEquals(masterToken.getExpiration().getTime() / MILLISECONDS_PER_SECOND, moMasterToken.getExpiration().getTime() / MILLISECONDS_PER_SECOND);
assertArrayEquals(masterToken.getSignatureKey().getEncoded(), moMasterToken.getSignatureKey().getEncoded());
assertEquals(masterToken.getIdentity(), moMasterToken.getIdentity());
assertTrue(MslEncoderUtils.equalObjects(masterToken.getIssuerData(), moMasterToken.getIssuerData()));
assertEquals(masterToken.getRenewalWindow().getTime() / MILLISECONDS_PER_SECOND, moMasterToken.getRenewalWindow().getTime() / MILLISECONDS_PER_SECOND);
assertEquals(masterToken.getSequenceNumber(), moMasterToken.getSequenceNumber());
assertEquals(masterToken.getSerialNumber(), moMasterToken.getSerialNumber());
final byte[] moEncode = moMasterToken.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test(expected = MslInternalException.class)
public void negativeSequenceNumberCtor() throws MslEncodingException, MslCryptoException {
final long sequenceNumber = -1;
new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, sequenceNumber, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
}
@Test(expected = MslInternalException.class)
public void tooLargeSequenceNumberCtor() throws MslEncodingException, MslCryptoException {
final long sequenceNumber = MslConstants.MAX_LONG_VALUE + 1;
new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, sequenceNumber, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
}
@Test(expected = MslInternalException.class)
public void negativeSerialNumberCtor() throws MslEncodingException, MslCryptoException {
final long serialNumber = -1;
new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, serialNumber, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
}
@Test(expected = MslInternalException.class)
public void tooLargeSerialNumberCtor() throws MslEncodingException, MslCryptoException {
final long serialNumber = MslConstants.MAX_LONG_VALUE + 1;
new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, serialNumber, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
}
@Test(expected = MslInternalException.class)
public void inconsistentExpiration() throws MslException, MslEncoderException {
final Date expiration = new Date(System.currentTimeMillis() - 1);
final Date renewalWindow = new Date();
assertTrue(expiration.before(renewalWindow));
new MasterToken(ctx, renewalWindow, expiration, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
}
@Test
public void inconsistentExpirationParse() throws MslException, MslEncoderException, UnsupportedEncodingException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.MASTERTOKEN_EXPIRES_BEFORE_RENEWAL);
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
tokendataMo.put(KEY_EXPIRATION, System.currentTimeMillis() / MILLISECONDS_PER_SECOND - 1);
tokendataMo.put(KEY_RENEWAL_WINDOW, System.currentTimeMillis() / MILLISECONDS_PER_SECOND);
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new MasterToken(ctx, mo);
}
@Test
public void nullIssuerData() throws MslEncoderException, MslException {
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, null, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
assertNull(masterToken.getIssuerData());
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final MasterToken moMasterToken = new MasterToken(ctx, mo);
assertNull(moMasterToken.getIssuerData());
}
@Test
public void missingTokendata() throws MslEncoderException, MslException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
assertNotNull(mo.remove(KEY_TOKENDATA));
new MasterToken(ctx, mo);
}
@Test(expected = MslEncodingException.class)
public void invalidTokendata() throws MslEncoderException, MslException {
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
++tokendata[0];
mo.put(KEY_TOKENDATA, tokendata);
new MasterToken(ctx, mo);
}
@Test
public void missingSignature() throws MslEncoderException, MslException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
assertNotNull(mo.remove(KEY_SIGNATURE));
new MasterToken(ctx, mo);
}
@Test
public void missingRenewalWindow() throws MslEncoderException, MslException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MASTERTOKEN_TOKENDATA_PARSE_ERROR);
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
assertNotNull(tokendataMo.remove(KEY_RENEWAL_WINDOW));
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new MasterToken(ctx, mo);
}
@Test
public void invalidRenewalWindow() throws MslEncoderException, MslException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MASTERTOKEN_TOKENDATA_PARSE_ERROR);
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
tokendataMo.put(KEY_RENEWAL_WINDOW, "x");
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new MasterToken(ctx, mo);
}
@Test
public void missingExpiration() throws MslEncoderException, MslException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MASTERTOKEN_TOKENDATA_PARSE_ERROR);
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
assertNotNull(tokendataMo.remove(KEY_EXPIRATION));
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new MasterToken(ctx, mo);
}
@Test
public void invalidExpiration() throws MslEncoderException, MslException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MASTERTOKEN_TOKENDATA_PARSE_ERROR);
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
tokendataMo.put(KEY_EXPIRATION, "x");
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new MasterToken(ctx, mo);
}
@Test
public void missingSequenceNumber() throws MslEncoderException, MslException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MASTERTOKEN_TOKENDATA_PARSE_ERROR);
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
assertNotNull(tokendataMo.remove(KEY_SEQUENCE_NUMBER));
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new MasterToken(ctx, mo);
}
@Test
public void invalidSequenceNumber() throws MslEncoderException, MslException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MASTERTOKEN_TOKENDATA_PARSE_ERROR);
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
tokendataMo.put(KEY_SEQUENCE_NUMBER, "x");
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new MasterToken(ctx, mo);
}
@Test
public void negativeSequenceNumber() throws MslEncodingException, MslCryptoException, MslEncoderException, MslException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.MASTERTOKEN_SEQUENCE_NUMBER_OUT_OF_RANGE);
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
tokendataMo.put(KEY_SEQUENCE_NUMBER, -1);
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new MasterToken(ctx, mo);
}
@Test
public void tooLargeSequenceNumber() throws MslEncodingException, MslCryptoException, MslEncoderException, MslException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.MASTERTOKEN_SEQUENCE_NUMBER_OUT_OF_RANGE);
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
tokendataMo.put(KEY_SEQUENCE_NUMBER, MslConstants.MAX_LONG_VALUE + 1);
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new MasterToken(ctx, mo);
}
@Test
public void missingSerialNumber() throws MslEncoderException, MslException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MASTERTOKEN_TOKENDATA_PARSE_ERROR);
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
assertNotNull(tokendataMo.remove(KEY_SERIAL_NUMBER));
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new MasterToken(ctx, mo);
}
@Test
public void invalidSerialNumber() throws MslEncoderException, MslException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MASTERTOKEN_TOKENDATA_PARSE_ERROR);
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
tokendataMo.put(KEY_SERIAL_NUMBER, "x");
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new MasterToken(ctx, mo);
}
@Test
public void negativeSerialNumber() throws MslEncodingException, MslCryptoException, MslEncoderException, MslException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.MASTERTOKEN_SERIAL_NUMBER_OUT_OF_RANGE);
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
tokendataMo.put(KEY_SERIAL_NUMBER, -1);
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new MasterToken(ctx, mo);
}
@Test
public void tooLargeSerialNumber() throws MslEncodingException, MslCryptoException, MslEncoderException, MslException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.MASTERTOKEN_SERIAL_NUMBER_OUT_OF_RANGE);
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
tokendataMo.put(KEY_SERIAL_NUMBER, MslConstants.MAX_LONG_VALUE + 1);
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new MasterToken(ctx, mo);
}
@Test
public void missingSessiondata() throws MslEncoderException, MslException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MASTERTOKEN_TOKENDATA_PARSE_ERROR);
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
assertNotNull(tokendataMo.remove(KEY_SESSIONDATA));
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new MasterToken(ctx, mo);
}
@Test
public void invalidSessiondata() throws UnsupportedEncodingException, MslEncoderException, MslException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MASTERTOKEN_TOKENDATA_PARSE_ERROR);
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
tokendataMo.put(KEY_SESSIONDATA, "x");
final ICryptoContext cryptoContext = ctx.getMslCryptoContext();
final byte[] modifiedTokendata = encoder.encodeObject(tokendataMo, ENCODER_FORMAT);
final byte[] signature = cryptoContext.sign(modifiedTokendata, encoder, ENCODER_FORMAT);
mo.put(KEY_TOKENDATA, modifiedTokendata);
mo.put(KEY_SIGNATURE, signature);
new MasterToken(ctx, mo);
}
@Test
public void emptySessiondata() throws UnsupportedEncodingException, MslEncoderException, MslException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.MASTERTOKEN_SESSIONDATA_MISSING);
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
final ICryptoContext cryptoContext = ctx.getMslCryptoContext();
final byte[] ciphertext = new byte[0];
tokendataMo.put(KEY_SESSIONDATA, ciphertext);
final byte[] modifiedTokendata = encoder.encodeObject(tokendataMo, ENCODER_FORMAT);
final byte[] signature = cryptoContext.sign(modifiedTokendata, encoder, ENCODER_FORMAT);
mo.put(KEY_TOKENDATA, modifiedTokendata);
mo.put(KEY_SIGNATURE, signature);
new MasterToken(ctx, mo);
}
@Test(expected = MslCryptoException.class)
public void corruptSessiondata() throws MslEncoderException, MslException, UnsupportedEncodingException {
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
// This is testing session data that is verified but corrupt.
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
final byte[] sessiondata = tokendataMo.getBytes(KEY_SESSIONDATA);
++sessiondata[sessiondata.length-1];
tokendataMo.put(KEY_SESSIONDATA, sessiondata);
final ICryptoContext cryptoContext = ctx.getMslCryptoContext();
final byte[] modifiedTokendata = encoder.encodeObject(tokendataMo, ENCODER_FORMAT);
final byte[] signature = cryptoContext.sign(modifiedTokendata, encoder, ENCODER_FORMAT);
mo.put(KEY_TOKENDATA, modifiedTokendata);
mo.put(KEY_SIGNATURE, signature);
new MasterToken(ctx, mo);
}
@Test
public void notVerified() throws MslEncoderException, MslException {
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] signature = mo.getBytes(KEY_SIGNATURE);
++signature[0];
mo.put(KEY_SIGNATURE, signature);
final MasterToken moMasterToken = new MasterToken(ctx, mo);
assertFalse(moMasterToken.isDecrypted());
assertFalse(moMasterToken.isVerified());
assertTrue(moMasterToken.isRenewable(null));
assertFalse(moMasterToken.isExpired(null));
assertFalse(moMasterToken.isNewerThan(masterToken));
assertFalse(masterToken.isNewerThan(moMasterToken));
assertNull(moMasterToken.getEncryptionKey());
assertEquals(masterToken.getExpiration().getTime() / MILLISECONDS_PER_SECOND, moMasterToken.getExpiration().getTime() / MILLISECONDS_PER_SECOND);
assertNull(moMasterToken.getSignatureKey());
assertNull(moMasterToken.getIdentity());
assertNull(moMasterToken.getIssuerData());
assertEquals(masterToken.getRenewalWindow().getTime() / MILLISECONDS_PER_SECOND, moMasterToken.getRenewalWindow().getTime() / MILLISECONDS_PER_SECOND);
assertEquals(masterToken.getSequenceNumber(), moMasterToken.getSequenceNumber());
assertEquals(masterToken.getSerialNumber(), moMasterToken.getSerialNumber());
final byte[] moEncode = moMasterToken.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertFalse(encode.equals(moEncode));
}
@Test
public void invalidIssuerData() throws MslEncoderException, MslException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MASTERTOKEN_SESSIONDATA_PARSE_ERROR);
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final ICryptoContext cryptoContext = ctx.getMslCryptoContext();
// Before modifying the session data we need to decrypt it.
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
final byte[] ciphertext = tokendataMo.getBytes(KEY_SESSIONDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject sessiondataMo = encoder.parseObject(plaintext);
// After modifying the session data we need to encrypt it.
sessiondataMo.put(KEY_ISSUER_DATA, "x");
final byte[] sessiondata = cryptoContext.encrypt(encoder.encodeObject(sessiondataMo, ENCODER_FORMAT), encoder, ENCODER_FORMAT);
tokendataMo.put(KEY_SESSIONDATA, sessiondata);
// The tokendata must be signed otherwise the session data will not be
// processed.
final byte[] modifiedTokendata = encoder.encodeObject(tokendataMo, ENCODER_FORMAT);
final byte[] signature = cryptoContext.sign(modifiedTokendata, encoder, ENCODER_FORMAT);
mo.put(KEY_TOKENDATA, modifiedTokendata);
mo.put(KEY_SIGNATURE, signature);
new MasterToken(ctx, mo);
}
@Test
public void missingIdentity() throws MslEncoderException, MslException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MASTERTOKEN_SESSIONDATA_PARSE_ERROR);
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final ICryptoContext cryptoContext = ctx.getMslCryptoContext();
// Before modifying the session data we need to decrypt it.
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
final byte[] ciphertext = tokendataMo.getBytes(KEY_SESSIONDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject sessiondataMo = encoder.parseObject(plaintext);
// After modifying the session data we need to encrypt it.
assertNotNull(sessiondataMo.remove(KEY_IDENTITY));
final byte[] sessiondata = cryptoContext.encrypt(encoder.encodeObject(sessiondataMo, ENCODER_FORMAT), encoder, ENCODER_FORMAT);
tokendataMo.put(KEY_SESSIONDATA, sessiondata);
// The tokendata must be signed otherwise the session data will not be
// processed.
final byte[] modifiedTokendata = encoder.encodeObject(tokendataMo, ENCODER_FORMAT);
final byte[] signature = cryptoContext.sign(modifiedTokendata, encoder, ENCODER_FORMAT);
mo.put(KEY_TOKENDATA, modifiedTokendata);
mo.put(KEY_SIGNATURE, signature);
new MasterToken(ctx, mo);
}
@Test
public void missingEncryptionKey() throws MslEncoderException, MslException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MASTERTOKEN_SESSIONDATA_PARSE_ERROR);
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final ICryptoContext cryptoContext = ctx.getMslCryptoContext();
// Before modifying the session data we need to decrypt it.
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
final byte[] ciphertext = tokendataMo.getBytes(KEY_SESSIONDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject sessiondataMo = encoder.parseObject(plaintext);
// After modifying the session data we need to encrypt it.
assertNotNull(sessiondataMo.remove(KEY_ENCRYPTION_KEY));
final byte[] sessiondata = cryptoContext.encrypt(encoder.encodeObject(sessiondataMo, ENCODER_FORMAT), encoder, ENCODER_FORMAT);
tokendataMo.put(KEY_SESSIONDATA, sessiondata);
// The tokendata must be signed otherwise the session data will not be
// processed.
final byte[] modifiedTokendata = encoder.encodeObject(tokendataMo, ENCODER_FORMAT);
final byte[] signature = cryptoContext.sign(modifiedTokendata, encoder, ENCODER_FORMAT);
mo.put(KEY_TOKENDATA, modifiedTokendata);
mo.put(KEY_SIGNATURE, signature);
new MasterToken(ctx, mo);
}
@Test
public void invalidEncryptionKey() throws MslEncoderException, MslException, UnsupportedEncodingException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.MASTERTOKEN_KEY_CREATION_ERROR);
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final ICryptoContext cryptoContext = ctx.getMslCryptoContext();
// Before modifying the session data we need to decrypt it.
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
final byte[] ciphertext = tokendataMo.getBytes(KEY_SESSIONDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject sessiondataMo = encoder.parseObject(plaintext);
// After modifying the session data we need to encrypt it.
sessiondataMo.put(KEY_ENCRYPTION_KEY, "");
final byte[] sessiondata = cryptoContext.encrypt(encoder.encodeObject(sessiondataMo, ENCODER_FORMAT), encoder, ENCODER_FORMAT);
tokendataMo.put(KEY_SESSIONDATA, sessiondata);
// The tokendata must be signed otherwise the session data will not be
// processed.
final byte[] modifiedTokendata = encoder.encodeObject(tokendataMo, ENCODER_FORMAT);
final byte[] signature = cryptoContext.sign(modifiedTokendata, encoder, ENCODER_FORMAT);
mo.put(KEY_TOKENDATA, modifiedTokendata);
mo.put(KEY_SIGNATURE, signature);
new MasterToken(ctx, mo);
}
@Test
public void missingEncryptionAlgorithm() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final ICryptoContext cryptoContext = ctx.getMslCryptoContext();
// Before modifying the session data we need to decrypt it.
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
final byte[] ciphertext = tokendataMo.getBytes(KEY_SESSIONDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject sessiondataMo = encoder.parseObject(plaintext);
// After modifying the session data we need to encrypt it.
assertNotNull(sessiondataMo.remove(KEY_ENCRYPTION_ALGORITHM));
final byte[] sessiondata = cryptoContext.encrypt(encoder.encodeObject(sessiondataMo, ENCODER_FORMAT), encoder, ENCODER_FORMAT);
tokendataMo.put(KEY_SESSIONDATA, sessiondata);
// The tokendata must be signed otherwise the session data will not be
// processed.
final byte[] modifiedTokendata = encoder.encodeObject(tokendataMo, ENCODER_FORMAT);
final byte[] signature = cryptoContext.sign(modifiedTokendata, encoder, ENCODER_FORMAT);
mo.put(KEY_TOKENDATA, modifiedTokendata);
mo.put(KEY_SIGNATURE, signature);
// Confirm default algorithm.
final MasterToken moMasterToken = new MasterToken(ctx, mo);
final SecretKey moEncryptionKey = moMasterToken.getEncryptionKey();
assertEquals(JcaAlgorithm.AES, moEncryptionKey.getAlgorithm());
}
@Test
public void invalidEncryptionAlgorithm() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNIDENTIFIED_ALGORITHM);
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final ICryptoContext cryptoContext = ctx.getMslCryptoContext();
// Before modifying the session data we need to decrypt it.
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
final byte[] ciphertext = tokendataMo.getBytes(KEY_SESSIONDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject sessiondataMo = encoder.parseObject(plaintext);
// After modifying the session data we need to encrypt it.
sessiondataMo.put(KEY_ENCRYPTION_ALGORITHM, "x");
final byte[] sessiondata = cryptoContext.encrypt(encoder.encodeObject(sessiondataMo, ENCODER_FORMAT), encoder, ENCODER_FORMAT);
tokendataMo.put(KEY_SESSIONDATA, sessiondata);
// The tokendata must be signed otherwise the session data will not be
// processed.
final byte[] modifiedTokendata = encoder.encodeObject(tokendataMo, ENCODER_FORMAT);
final byte[] signature = cryptoContext.sign(modifiedTokendata, encoder, ENCODER_FORMAT);
mo.put(KEY_TOKENDATA, modifiedTokendata);
mo.put(KEY_SIGNATURE, signature);
new MasterToken(ctx, mo);
}
@Test
public void missingHmacKey() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final ICryptoContext cryptoContext = ctx.getMslCryptoContext();
// Before modifying the session data we need to decrypt it.
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
final byte[] ciphertext = tokendataMo.getBytes(KEY_SESSIONDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject sessiondataMo = encoder.parseObject(plaintext);
// After modifying the session data we need to encrypt it.
assertNotNull(sessiondataMo.remove(KEY_HMAC_KEY));
final byte[] sessiondata = cryptoContext.encrypt(encoder.encodeObject(sessiondataMo, ENCODER_FORMAT), encoder, ENCODER_FORMAT);
tokendataMo.put(KEY_SESSIONDATA, sessiondata);
// The tokendata must be signed otherwise the session data will not be
// processed.
final byte[] modifiedTokendata = encoder.encodeObject(tokendataMo, ENCODER_FORMAT);
final byte[] signature = cryptoContext.sign(modifiedTokendata, encoder, ENCODER_FORMAT);
mo.put(KEY_TOKENDATA, modifiedTokendata);
mo.put(KEY_SIGNATURE, signature);
// Confirm signature key.
final MasterToken moMasterToken = new MasterToken(ctx, mo);
final SecretKey moSignatureKey = moMasterToken.getSignatureKey();
assertArrayEquals(masterToken.getSignatureKey().getEncoded(), moSignatureKey.getEncoded());
}
@Test
public void missingSignatureKey() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final ICryptoContext cryptoContext = ctx.getMslCryptoContext();
// Before modifying the session data we need to decrypt it.
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
final byte[] ciphertext = tokendataMo.getBytes(KEY_SESSIONDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject sessiondataMo = encoder.parseObject(plaintext);
// After modifying the session data we need to encrypt it.
assertNotNull(sessiondataMo.remove(KEY_SIGNATURE_KEY));
final byte[] sessiondata = cryptoContext.encrypt(encoder.encodeObject(sessiondataMo, ENCODER_FORMAT), encoder, ENCODER_FORMAT);
tokendataMo.put(KEY_SESSIONDATA, sessiondata);
// The tokendata must be signed otherwise the session data will not be
// processed.
final byte[] modifiedTokendata = encoder.encodeObject(tokendataMo, ENCODER_FORMAT);
final byte[] signature = cryptoContext.sign(modifiedTokendata, encoder, ENCODER_FORMAT);
mo.put(KEY_TOKENDATA, modifiedTokendata);
mo.put(KEY_SIGNATURE, signature);
// Confirm signature key.
final MasterToken moMasterToken = new MasterToken(ctx, mo);
final SecretKey moSignatureKey = moMasterToken.getSignatureKey();
assertArrayEquals(masterToken.getSignatureKey().getEncoded(), moSignatureKey.getEncoded());
}
@Test
public void missingSignatureAlgorithm() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final ICryptoContext cryptoContext = ctx.getMslCryptoContext();
// Before modifying the session data we need to decrypt it.
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
final byte[] ciphertext = tokendataMo.getBytes(KEY_SESSIONDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject sessiondataMo = encoder.parseObject(plaintext);
// After modifying the session data we need to encrypt it.
assertNotNull(sessiondataMo.remove(KEY_SIGNATURE_ALGORITHM));
final byte[] sessiondata = cryptoContext.encrypt(encoder.encodeObject(sessiondataMo, ENCODER_FORMAT), encoder, ENCODER_FORMAT);
tokendataMo.put(KEY_SESSIONDATA, sessiondata);
// The tokendata must be signed otherwise the session data will not be
// processed.
final byte[] modifiedTokendata = encoder.encodeObject(tokendataMo, ENCODER_FORMAT);
final byte[] signature = cryptoContext.sign(modifiedTokendata, encoder, ENCODER_FORMAT);
mo.put(KEY_TOKENDATA, modifiedTokendata);
mo.put(KEY_SIGNATURE, signature);
// Confirm default algorithm.
final MasterToken moMasterToken = new MasterToken(ctx, mo);
final SecretKey moSignatureKey = moMasterToken.getSignatureKey();
assertEquals(JcaAlgorithm.HMAC_SHA256, moSignatureKey.getAlgorithm());
}
@Test
public void invalidSignatureAlgorithm() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.UNIDENTIFIED_ALGORITHM);
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final ICryptoContext cryptoContext = ctx.getMslCryptoContext();
// Before modifying the session data we need to decrypt it.
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
final byte[] ciphertext = tokendataMo.getBytes(KEY_SESSIONDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject sessiondataMo = encoder.parseObject(plaintext);
// After modifying the session data we need to encrypt it.
sessiondataMo.put(KEY_SIGNATURE_ALGORITHM, "x");
final byte[] sessiondata = cryptoContext.encrypt(encoder.encodeObject(sessiondataMo, ENCODER_FORMAT), encoder, ENCODER_FORMAT);
tokendataMo.put(KEY_SESSIONDATA, sessiondata);
// The tokendata must be signed otherwise the session data will not be
// processed.
final byte[] modifiedTokendata = encoder.encodeObject(tokendataMo, ENCODER_FORMAT);
final byte[] signature = cryptoContext.sign(modifiedTokendata, encoder, ENCODER_FORMAT);
mo.put(KEY_TOKENDATA, modifiedTokendata);
mo.put(KEY_SIGNATURE, signature);
new MasterToken(ctx, mo);
}
@Test
public void missingHmacAndSignatureKey() throws MslEncoderException, MslException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MASTERTOKEN_SESSIONDATA_PARSE_ERROR);
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final byte[] encode = masterToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final ICryptoContext cryptoContext = ctx.getMslCryptoContext();
// Before modifying the session data we need to decrypt it.
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
final byte[] ciphertext = tokendataMo.getBytes(KEY_SESSIONDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject sessiondataMo = encoder.parseObject(plaintext);
// After modifying the session data we need to encrypt it.
assertNotNull(sessiondataMo.remove(KEY_HMAC_KEY));
assertNotNull(sessiondataMo.remove(KEY_SIGNATURE_KEY));
final byte[] sessiondata = cryptoContext.encrypt(encoder.encodeObject(sessiondataMo, ENCODER_FORMAT), encoder, ENCODER_FORMAT);
tokendataMo.put(KEY_SESSIONDATA, sessiondata);
// The tokendata must be signed otherwise the session data will not be
// processed.
final byte[] modifiedTokendata = encoder.encodeObject(tokendataMo, ENCODER_FORMAT);
final byte[] signature = cryptoContext.sign(modifiedTokendata, encoder, ENCODER_FORMAT);
mo.put(KEY_TOKENDATA, modifiedTokendata);
mo.put(KEY_SIGNATURE, signature);
new MasterToken(ctx, mo);
}
@Test
public void invalidHmacAndSignatureKey() throws MslEncoderException, MslException, UnsupportedEncodingException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.MASTERTOKEN_KEY_CREATION_ERROR);
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final MslObject mo = MslTestUtils.toMslObject(encoder, masterToken);
final ICryptoContext cryptoContext = ctx.getMslCryptoContext();
// Before modifying the session data we need to decrypt it.
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
final byte[] ciphertext = tokendataMo.getBytes(KEY_SESSIONDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject sessiondataMo = encoder.parseObject(plaintext);
// After modifying the session data we need to encrypt it.
sessiondataMo.put(KEY_HMAC_KEY, "");
sessiondataMo.put(KEY_SIGNATURE_KEY, "");
final byte[] sessiondata = cryptoContext.encrypt(encoder.encodeObject(sessiondataMo, ENCODER_FORMAT), encoder, ENCODER_FORMAT);
tokendataMo.put(KEY_SESSIONDATA, sessiondata);
// The tokendata must be signed otherwise the session data will not be
// processed.
final byte[] modifiedTokendata = encoder.encodeObject(tokendataMo, ENCODER_FORMAT);
final byte[] signature = cryptoContext.sign(modifiedTokendata, encoder, ENCODER_FORMAT);
mo.put(KEY_TOKENDATA, modifiedTokendata);
mo.put(KEY_SIGNATURE, signature);
new MasterToken(ctx, mo);
}
@Test
public void isRenewable() throws MslEncodingException, MslCryptoException {
final Date renewalWindow = new Date();
final Date expiration = new Date(System.currentTimeMillis() + 1000);
final MasterToken masterToken = new MasterToken(ctx, renewalWindow, expiration, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final Date now = new Date();
assertTrue(masterToken.isRenewable(null));
assertTrue(masterToken.isRenewable(now));
assertFalse(masterToken.isExpired(null));
assertFalse(masterToken.isExpired(now));
final Date before = new Date(renewalWindow.getTime() - 1000);
assertFalse(masterToken.isRenewable(before));
assertFalse(masterToken.isExpired(before));
final Date after = new Date(expiration.getTime() + 1000);
assertTrue(masterToken.isRenewable(after));
assertTrue(masterToken.isExpired(after));
}
@Test
public void isExpired() throws MslEncodingException, MslCryptoException {
final Date renewalWindow = new Date(System.currentTimeMillis() - 1000);
final Date expiration = new Date();
final MasterToken masterToken = new MasterToken(ctx, renewalWindow, expiration, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final Date now = new Date();
assertTrue(masterToken.isRenewable(null));
assertTrue(masterToken.isRenewable(now));
assertTrue(masterToken.isExpired(null));
assertTrue(masterToken.isExpired(now));
final Date before = new Date(renewalWindow.getTime() - 1000);
assertFalse(masterToken.isRenewable(before));
assertFalse(masterToken.isExpired(before));
final Date after = new Date(expiration.getTime() + 1000);
assertTrue(masterToken.isRenewable(after));
assertTrue(masterToken.isExpired(after));
}
@Test
public void notRenewableOrExpired() throws MslEncodingException, MslCryptoException {
final Date renewalWindow = new Date(System.currentTimeMillis() + 1000);
final Date expiration = new Date(System.currentTimeMillis() + 2000);
final MasterToken masterToken = new MasterToken(ctx, renewalWindow, expiration, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final Date now = new Date();
assertFalse(masterToken.isRenewable(null));
assertFalse(masterToken.isRenewable(now));
assertFalse(masterToken.isExpired(null));
assertFalse(masterToken.isExpired(now));
final Date before = new Date(renewalWindow.getTime() - 1000);
assertFalse(masterToken.isRenewable(before));
assertFalse(masterToken.isExpired(before));
final Date after = new Date(expiration.getTime() + 1000);
assertTrue(masterToken.isRenewable(after));
assertTrue(masterToken.isExpired(after));
}
@Test
public void isNewerThanSequenceNumbers() throws MslEncodingException, MslCryptoException {
final long sequenceNumberA = 1;
final long sequenceNumberB = 2;
final MasterToken masterTokenA = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, sequenceNumberA, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final MasterToken masterTokenB = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, sequenceNumberB, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
assertTrue(masterTokenB.isNewerThan(masterTokenA));
assertFalse(masterTokenA.isNewerThan(masterTokenB));
assertFalse(masterTokenA.isNewerThan(masterTokenA));
}
@Test
public void isNewerThanSequenceNumbersWrapAround() throws MslEncodingException, MslCryptoException {
// Anything within 128 is newer.
for (long seqNo = MslConstants.MAX_LONG_VALUE - 127; seqNo <= MslConstants.MAX_LONG_VALUE && seqNo != 0; seqNo = incrementSequenceNumber(seqNo, 1)) {
final long minus1 = decrementSequenceNumber(seqNo, 1);
final long plus1 = incrementSequenceNumber(seqNo, 1);
final long plus127 = incrementSequenceNumber(seqNo, 127);
final long plus128 = incrementSequenceNumber(seqNo, 128);
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, seqNo, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final MasterToken minus1MasterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, minus1, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final MasterToken plus1MasterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, plus1, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final MasterToken plus127MasterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, plus127, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final MasterToken plus128MasterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, plus128, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
assertFalse("seqNo = " + seqNo, minus1MasterToken.isNewerThan(masterToken));
assertTrue("seqNo = " + seqNo, masterToken.isNewerThan(minus1MasterToken));
assertTrue("seqNo = " + seqNo, plus1MasterToken.isNewerThan(masterToken));
assertFalse("seqNo = " + seqNo, masterToken.isNewerThan(plus1MasterToken));
assertTrue("seqNo = " + seqNo, plus127MasterToken.isNewerThan(masterToken));
assertFalse("seqNo = " + seqNo, masterToken.isNewerThan(plus127MasterToken));
assertFalse("seqNo = " + seqNo, plus128MasterToken.isNewerThan(masterToken));
assertTrue("seqNo = " + seqNo, masterToken.isNewerThan(plus128MasterToken));
}
}
@Test
public void isNewerThanExpiration() throws MslEncodingException, MslCryptoException {
final Date expirationA = new Date(EXPIRATION.getTime());
final Date expirationB = new Date(EXPIRATION.getTime() + 10000);
final MasterToken masterTokenA = new MasterToken(ctx, RENEWAL_WINDOW, expirationA, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final MasterToken masterTokenB = new MasterToken(ctx, RENEWAL_WINDOW, expirationB, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
assertTrue(masterTokenB.isNewerThan(masterTokenA));
assertFalse(masterTokenA.isNewerThan(masterTokenB));
assertFalse(masterTokenA.isNewerThan(masterTokenA));
}
@Test
public void isNewerSerialNumber() throws MslEncodingException, MslCryptoException {
final long serialNumberA = 1;
final long serialNumberB = 2;
final long sequenceNumberA = 1;
final long sequenceNumberB = 2;
final MasterToken masterTokenA = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, sequenceNumberA, serialNumberA, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final MasterToken masterTokenB = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, sequenceNumberB, serialNumberB, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
assertTrue(masterTokenB.isNewerThan(masterTokenA));
assertFalse(masterTokenA.isNewerThan(masterTokenB));
}
@Test
public void equalsTrustedUntrusted() throws MslException, MslEncoderException {
final Date renewalWindow = new Date(System.currentTimeMillis() + 1000);
final Date expiration = new Date(System.currentTimeMillis() + 2000);
final String identity = MockPresharedAuthenticationFactory.PSK_ESN;
final SecretKey encryptionKey = MockPresharedAuthenticationFactory.KPE;
final SecretKey hmacKey = MockPresharedAuthenticationFactory.KPH;
final MasterToken masterToken = new MasterToken(ctx, renewalWindow, expiration, 1L, 1L, null, identity, encryptionKey, hmacKey);
final MslObject mo = MslTestUtils.toMslObject(encoder, masterToken);
final byte[] signature = mo.getBytes("signature");
++signature[1];
mo.put("signature", signature);
final MasterToken untrustedMasterToken = new MasterToken(ctx, mo);
assertTrue(masterToken.equals(untrustedMasterToken));
assertEquals(masterToken.hashCode(), untrustedMasterToken.hashCode());
}
@Test
public void equalsSerialNumber() throws MslException, MslEncoderException {
final long serialNumberA = 1;
final long serialNumberB = 2;
final MasterToken masterTokenA = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, serialNumberA, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final MasterToken masterTokenB = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, serialNumberB, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final MasterToken masterTokenA2 = new MasterToken(ctx, MslTestUtils.toMslObject(encoder, masterTokenA));
assertTrue(masterTokenA.equals(masterTokenA));
assertEquals(masterTokenA.hashCode(), masterTokenA.hashCode());
assertFalse(masterTokenA.equals(masterTokenB));
assertFalse(masterTokenB.equals(masterTokenA));
assertTrue(masterTokenA.hashCode() != masterTokenB.hashCode());
assertTrue(masterTokenA.equals(masterTokenA2));
assertTrue(masterTokenA2.equals(masterTokenA));
assertEquals(masterTokenA.hashCode(), masterTokenA2.hashCode());
}
@Test
public void equalsSequenceNumber() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
final long sequenceNumberA = 1;
final long sequenceNumberB = 2;
final MasterToken masterTokenA = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, sequenceNumberA, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final MasterToken masterTokenB = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, sequenceNumberB, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final MasterToken masterTokenA2 = new MasterToken(ctx, MslTestUtils.toMslObject(encoder, masterTokenA));
assertTrue(masterTokenA.equals(masterTokenA));
assertEquals(masterTokenA.hashCode(), masterTokenA.hashCode());
assertFalse(masterTokenA.equals(masterTokenB));
assertFalse(masterTokenB.equals(masterTokenA));
assertTrue(masterTokenA.hashCode() != masterTokenB.hashCode());
assertTrue(masterTokenA.equals(masterTokenA2));
assertTrue(masterTokenA2.equals(masterTokenA));
assertEquals(masterTokenA.hashCode(), masterTokenA2.hashCode());
}
@Test
public void equalsExpiration() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
final Date expirationA = new Date(EXPIRATION.getTime());
final Date expirationB = new Date(EXPIRATION.getTime() + 10000);
final MasterToken masterTokenA = new MasterToken(ctx, RENEWAL_WINDOW, expirationA, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final MasterToken masterTokenB = new MasterToken(ctx, RENEWAL_WINDOW, expirationB, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
final MasterToken masterTokenA2 = new MasterToken(ctx, MslTestUtils.toMslObject(encoder, masterTokenA));
assertTrue(masterTokenA.equals(masterTokenA));
assertEquals(masterTokenA.hashCode(), masterTokenA.hashCode());
assertFalse(masterTokenA.equals(masterTokenB));
assertFalse(masterTokenB.equals(masterTokenA));
assertTrue(masterTokenA.hashCode() != masterTokenB.hashCode());
assertTrue(masterTokenA.equals(masterTokenA2));
assertTrue(masterTokenA2.equals(masterTokenA));
assertEquals(masterTokenA.hashCode(), masterTokenA2.hashCode());
}
@Test
public void equalsObject() throws MslEncodingException, MslCryptoException {
final MasterToken masterToken = new MasterToken(ctx, RENEWAL_WINDOW, EXPIRATION, SEQUENCE_NUMBER, SERIAL_NUMBER, ISSUER_DATA, IDENTITY, ENCRYPTION_KEY, SIGNATURE_KEY);
assertFalse(masterToken.equals(null));
assertFalse(masterToken.equals(IDENTITY));
assertTrue(masterToken.hashCode() != IDENTITY.hashCode());
}
/** MSL context. */
private static MslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
}
| 9,976 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/tokens/ServiceTokenTest.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.tokens;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import org.bouncycastle.crypto.CryptoException;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
import com.netflix.msl.MslConstants;
import com.netflix.msl.MslConstants.CompressionAlgorithm;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.crypto.JcaAlgorithm;
import com.netflix.msl.crypto.SymmetricCryptoContext;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.userauth.MockEmailPasswordAuthenticationFactory;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* Service token unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
@RunWith(Parameterized.class)
public class ServiceTokenTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key token data. */
private static final String KEY_TOKENDATA = "tokendata";
/** Key signature. */
private static final String KEY_SIGNATURE = "signature";
// tokendata
/** Key token name. */
private static final String KEY_NAME = "name";
/** Key master token serial number. */
private static final String KEY_MASTER_TOKEN_SERIAL_NUMBER = "mtserialnumber";
/** Key user ID token serial number. */
private static final String KEY_USER_ID_TOKEN_SERIAL_NUMBER = "uitserialnumber";
/** Key encrypted. */
private static final String KEY_ENCRYPTED = "encrypted";
/** Key compression algorithm. */
private static final String KEY_COMPRESSION_ALGORITHM = "compressionalgo";
/** Key service data. */
private static final String KEY_SERVICEDATA = "servicedata";
private static final String NAME = "tokenName";
private static final byte[] DATA = "We have to use some data that is compressible, otherwise service tokens will not always use the compression we request.".getBytes();
private static MasterToken MASTER_TOKEN;
private static UserIdToken USER_ID_TOKEN;
private static final boolean ENCRYPTED = true;
private static ICryptoContext CRYPTO_CONTEXT;
/**
* @param ctx MSL context.
* @return a new crypto context.
* @throws CryptoException if there is an error creating the crypto
* context.
*/
private static ICryptoContext getCryptoContext(final MslContext ctx) {
final String keysetId = "keysetId";
final byte[] encryptionBytes = new byte[16];
random.nextBytes(encryptionBytes);
final SecretKey encryptionKey = new SecretKeySpec(encryptionBytes, JcaAlgorithm.AES);
final byte[] hmacBytes = new byte[32];
random.nextBytes(hmacBytes);
final SecretKey hmacKey = new SecretKeySpec(hmacBytes, JcaAlgorithm.HMAC_SHA256);
final ICryptoContext cryptoContext = new SymmetricCryptoContext(ctx, keysetId, encryptionKey, hmacKey, null);
return cryptoContext;
}
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException {
random = new Random();
ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = ctx.getMslEncoderFactory();
MASTER_TOKEN = MslTestUtils.getMasterToken(ctx, 1, 1);
USER_ID_TOKEN = MslTestUtils.getUserIdToken(ctx, MASTER_TOKEN, 1, MockEmailPasswordAuthenticationFactory.USER);
CRYPTO_CONTEXT = getCryptoContext(ctx);
}
@AfterClass
public static void teardown() {
CRYPTO_CONTEXT = null;
USER_ID_TOKEN = null;
MASTER_TOKEN = null;
encoder = null;
ctx = null;
random = null;
}
@Parameters
public static List<Object[]> data() {
return Arrays.asList(new Object[][] {
{ null },
{ CompressionAlgorithm.LZW },
{ CompressionAlgorithm.GZIP },
});
}
/** Compression algorithm. */
private final CompressionAlgorithm compressionAlgo;
/**
* Create a new master token test instance.
*
* @param compressionAlgo compression algorithm.
*/
public ServiceTokenTest(final CompressionAlgorithm compressionAlgo) {
this.compressionAlgo = compressionAlgo;
}
@Test
public void ctors() throws MslEncoderException, MslException {
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
assertTrue(serviceToken.isDecrypted());
assertFalse(serviceToken.isDeleted());
assertTrue(serviceToken.isVerified());
assertTrue(serviceToken.isBoundTo(MASTER_TOKEN));
assertTrue(serviceToken.isBoundTo(USER_ID_TOKEN));
assertTrue(serviceToken.isMasterTokenBound());
assertTrue(serviceToken.isUserIdTokenBound());
assertFalse(serviceToken.isUnbound());
assertEquals(MASTER_TOKEN.getSerialNumber(), serviceToken.getMasterTokenSerialNumber());
assertEquals(USER_ID_TOKEN.getSerialNumber(), serviceToken.getUserIdTokenSerialNumber());
assertEquals(NAME, serviceToken.getName());
assertEquals(compressionAlgo, serviceToken.getCompressionAlgo());
assertArrayEquals(DATA, serviceToken.getData());
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final MslObject mo = encoder.parseObject(encode);
final ServiceToken moServiceToken = new ServiceToken(ctx, mo, MASTER_TOKEN, USER_ID_TOKEN, CRYPTO_CONTEXT);
assertEquals(serviceToken.isDecrypted(), moServiceToken.isDecrypted());
assertEquals(serviceToken.isDeleted(), moServiceToken.isDeleted());
assertEquals(serviceToken.isVerified(), moServiceToken.isVerified());
assertEquals(serviceToken.isBoundTo(MASTER_TOKEN), moServiceToken.isBoundTo(MASTER_TOKEN));
assertEquals(serviceToken.isBoundTo(USER_ID_TOKEN), moServiceToken.isBoundTo(USER_ID_TOKEN));
assertEquals(serviceToken.isMasterTokenBound(), moServiceToken.isMasterTokenBound());
assertEquals(serviceToken.isUserIdTokenBound(), moServiceToken.isUserIdTokenBound());
assertEquals(serviceToken.isUnbound(), moServiceToken.isUnbound());
assertEquals(serviceToken.getMasterTokenSerialNumber(), moServiceToken.getMasterTokenSerialNumber());
assertEquals(serviceToken.getUserIdTokenSerialNumber(), moServiceToken.getUserIdTokenSerialNumber());
assertEquals(serviceToken.getName(), moServiceToken.getName());
assertEquals(serviceToken.getCompressionAlgo(), moServiceToken.getCompressionAlgo());
assertArrayEquals(serviceToken.getData(), moServiceToken.getData());
final byte[] moEncode = moServiceToken.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void cryptoContextMismatch() throws MslEncoderException, MslException {
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final ICryptoContext moCryptoContext = getCryptoContext(ctx);
final ServiceToken moServiceToken = new ServiceToken(ctx, mo, MASTER_TOKEN, USER_ID_TOKEN, moCryptoContext);
assertFalse(moServiceToken.isDecrypted());
assertFalse(serviceToken.isDeleted());
assertFalse(moServiceToken.isVerified());
assertNull(moServiceToken.getData());
assertEquals(serviceToken.isBoundTo(MASTER_TOKEN), moServiceToken.isBoundTo(MASTER_TOKEN));
assertEquals(serviceToken.isBoundTo(USER_ID_TOKEN), moServiceToken.isBoundTo(USER_ID_TOKEN));
assertEquals(serviceToken.isMasterTokenBound(), moServiceToken.isMasterTokenBound());
assertEquals(serviceToken.isUserIdTokenBound(), moServiceToken.isUserIdTokenBound());
assertEquals(serviceToken.isUnbound(), moServiceToken.isUnbound());
assertEquals(serviceToken.getMasterTokenSerialNumber(), moServiceToken.getMasterTokenSerialNumber());
assertEquals(serviceToken.getUserIdTokenSerialNumber(), moServiceToken.getUserIdTokenSerialNumber());
assertEquals(serviceToken.getName(), moServiceToken.getName());
assertEquals(serviceToken.getCompressionAlgo(), moServiceToken.getCompressionAlgo());
final byte[] moEncode = moServiceToken.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void mappedCryptoContext() throws MslEncoderException, MslException {
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final Map<String,ICryptoContext> cryptoContexts = new HashMap<String,ICryptoContext>();
cryptoContexts.put(NAME, CRYPTO_CONTEXT);
cryptoContexts.put(NAME + "1", getCryptoContext(ctx));
cryptoContexts.put(NAME + "2", getCryptoContext(ctx));
final ServiceToken moServiceToken = new ServiceToken(ctx, mo, MASTER_TOKEN, USER_ID_TOKEN, cryptoContexts);
assertEquals(serviceToken.isDecrypted(), moServiceToken.isDecrypted());
assertEquals(serviceToken.isDeleted(), moServiceToken.isDeleted());
assertEquals(serviceToken.isVerified(), moServiceToken.isVerified());
assertEquals(serviceToken.isBoundTo(MASTER_TOKEN), moServiceToken.isBoundTo(MASTER_TOKEN));
assertEquals(serviceToken.isBoundTo(USER_ID_TOKEN), moServiceToken.isBoundTo(USER_ID_TOKEN));
assertEquals(serviceToken.isMasterTokenBound(), moServiceToken.isMasterTokenBound());
assertEquals(serviceToken.isUserIdTokenBound(), moServiceToken.isUserIdTokenBound());
assertEquals(serviceToken.isUnbound(), moServiceToken.isUnbound());
assertEquals(serviceToken.getMasterTokenSerialNumber(), moServiceToken.getMasterTokenSerialNumber());
assertEquals(serviceToken.getUserIdTokenSerialNumber(), moServiceToken.getUserIdTokenSerialNumber());
assertEquals(serviceToken.getName(), moServiceToken.getName());
assertEquals(serviceToken.getCompressionAlgo(), moServiceToken.getCompressionAlgo());
assertArrayEquals(serviceToken.getData(), moServiceToken.getData());
final byte[] moEncode = moServiceToken.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void unmappedCryptoContext() throws MslEncoderException, MslException {
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final Map<String,ICryptoContext> cryptoContexts = new HashMap<String,ICryptoContext>();
cryptoContexts.put(NAME + "0", CRYPTO_CONTEXT);
cryptoContexts.put(NAME + "1", getCryptoContext(ctx));
cryptoContexts.put(NAME + "2", getCryptoContext(ctx));
final ServiceToken moServiceToken = new ServiceToken(ctx, mo, MASTER_TOKEN, USER_ID_TOKEN, cryptoContexts);
assertFalse(moServiceToken.isDecrypted());
assertFalse(moServiceToken.isDeleted());
assertFalse(moServiceToken.isVerified());
assertNull(moServiceToken.getData());
assertEquals(serviceToken.isBoundTo(MASTER_TOKEN), moServiceToken.isBoundTo(MASTER_TOKEN));
assertEquals(serviceToken.isBoundTo(USER_ID_TOKEN), moServiceToken.isBoundTo(USER_ID_TOKEN));
assertEquals(serviceToken.isMasterTokenBound(), moServiceToken.isMasterTokenBound());
assertEquals(serviceToken.isUserIdTokenBound(), moServiceToken.isUserIdTokenBound());
assertEquals(serviceToken.isUnbound(), moServiceToken.isUnbound());
assertEquals(serviceToken.getMasterTokenSerialNumber(), moServiceToken.getMasterTokenSerialNumber());
assertEquals(serviceToken.getUserIdTokenSerialNumber(), moServiceToken.getUserIdTokenSerialNumber());
assertEquals(serviceToken.getName(), moServiceToken.getName());
assertEquals(serviceToken.getCompressionAlgo(), moServiceToken.getCompressionAlgo());
final byte[] moEncode = moServiceToken.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void masterTokenMismatch() throws MslException, MslEncoderException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.SERVICETOKEN_MASTERTOKEN_MISMATCH);
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, masterToken, null, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final MasterToken moMasterToken = MslTestUtils.getMasterToken(ctx, 1, 2);
new ServiceToken(ctx, mo, moMasterToken, null, CRYPTO_CONTEXT);
}
@Test
public void masterTokenMissing() throws MslEncoderException, MslException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.SERVICETOKEN_MASTERTOKEN_MISMATCH);
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
new ServiceToken(ctx, mo, null, USER_ID_TOKEN, CRYPTO_CONTEXT);
}
@Test
public void userIdTokenMismatch() throws MslException, MslEncoderException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.SERVICETOKEN_USERIDTOKEN_MISMATCH);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(ctx, MASTER_TOKEN, 1, MockEmailPasswordAuthenticationFactory.USER);
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, userIdToken, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final UserIdToken moUserIdToken = MslTestUtils.getUserIdToken(ctx, MASTER_TOKEN, 2, MockEmailPasswordAuthenticationFactory.USER);
new ServiceToken(ctx, mo, MASTER_TOKEN, moUserIdToken, CRYPTO_CONTEXT);
}
@Test
public void userIdTokenMissing() throws MslCryptoException, MslEncodingException, MslException, MslEncoderException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.SERVICETOKEN_USERIDTOKEN_MISMATCH);
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
new ServiceToken(ctx, mo, MASTER_TOKEN, null, CRYPTO_CONTEXT);
}
@Test(expected = MslInternalException.class)
public void tokenMismatch() throws MslInternalException, MslException {
final MasterToken masterTokenA = MslTestUtils.getMasterToken(ctx, 1, 1);
final MasterToken masterTokenB = MslTestUtils.getMasterToken(ctx, 1, 2);
final UserIdToken userIdToken = MslTestUtils.getUserIdToken(ctx, masterTokenB, 1, MockEmailPasswordAuthenticationFactory.USER);
new ServiceToken(ctx, NAME, DATA, masterTokenA, userIdToken, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
}
@Test
public void missingTokendata() throws MslEncoderException, MslException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
assertNotNull(mo.remove(KEY_TOKENDATA));
new ServiceToken(ctx, mo, MASTER_TOKEN, USER_ID_TOKEN, CRYPTO_CONTEXT);
}
@Test
public void invalidTokendata() throws MslException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
++tokendata[0];
mo.put(KEY_TOKENDATA, tokendata);
new ServiceToken(ctx, mo, MASTER_TOKEN, USER_ID_TOKEN, CRYPTO_CONTEXT);
}
@Test
public void missingSignature() throws MslEncoderException, MslCryptoException, MslEncodingException, MslException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
assertNotNull(mo.remove(KEY_SIGNATURE));
new ServiceToken(ctx, mo, MASTER_TOKEN, USER_ID_TOKEN, CRYPTO_CONTEXT);
}
@Test
public void missingName() throws MslCryptoException, MslEncodingException, MslException, MslEncoderException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);;
assertNotNull(tokendataMo.remove(KEY_NAME));
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new ServiceToken(ctx, mo, MASTER_TOKEN, USER_ID_TOKEN, CRYPTO_CONTEXT);
}
@Test
public void missingMasterTokenSerialNumber() throws MslEncoderException, MslException, UnsupportedEncodingException {
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);;
assertNotNull(tokendataMo.remove(KEY_MASTER_TOKEN_SERIAL_NUMBER));
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
final ServiceToken moServiceToken = new ServiceToken(ctx, mo, MASTER_TOKEN, USER_ID_TOKEN, CRYPTO_CONTEXT);
assertEquals(-1, moServiceToken.getMasterTokenSerialNumber());
assertFalse(moServiceToken.isBoundTo(MASTER_TOKEN));
}
@Test
public void invalidMasterTokenSerialNumber() throws MslEncoderException, MslCryptoException, MslEncodingException, MslException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);;
tokendataMo.put(KEY_MASTER_TOKEN_SERIAL_NUMBER, "x");
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new ServiceToken(ctx, mo, MASTER_TOKEN, USER_ID_TOKEN, CRYPTO_CONTEXT);
}
@Test
public void negativeMasterTokenSerialNumber() throws MslEncoderException, MslCryptoException, MslEncodingException, MslException, UnsupportedEncodingException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.SERVICETOKEN_MASTERTOKEN_SERIAL_NUMBER_OUT_OF_RANGE);
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);;
tokendataMo.put(KEY_MASTER_TOKEN_SERIAL_NUMBER, -1);
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new ServiceToken(ctx, mo, MASTER_TOKEN, USER_ID_TOKEN, CRYPTO_CONTEXT);
}
@Test
public void tooLargeMasterTokenSerialNumber() throws MslEncoderException, MslCryptoException, MslEncodingException, MslException, UnsupportedEncodingException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.SERVICETOKEN_MASTERTOKEN_SERIAL_NUMBER_OUT_OF_RANGE);
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);;
tokendataMo.put(KEY_MASTER_TOKEN_SERIAL_NUMBER, MslConstants.MAX_LONG_VALUE + 1);
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new ServiceToken(ctx, mo, MASTER_TOKEN, USER_ID_TOKEN, CRYPTO_CONTEXT);
}
@Test
public void missingUserIdTokenSerialNumber() throws MslEncoderException, MslCryptoException, MslEncodingException, MslException, UnsupportedEncodingException {
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);;
assertNotNull(tokendataMo.remove(KEY_USER_ID_TOKEN_SERIAL_NUMBER));
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
final ServiceToken moServiceToken = new ServiceToken(ctx, mo, MASTER_TOKEN, USER_ID_TOKEN, CRYPTO_CONTEXT);
assertEquals(-1, moServiceToken.getUserIdTokenSerialNumber());
assertFalse(moServiceToken.isBoundTo(USER_ID_TOKEN));
}
@Test
public void invalidUserIdTokenSerialNumber() throws MslEncoderException, MslException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);;
tokendataMo.put(KEY_USER_ID_TOKEN_SERIAL_NUMBER, "x");
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new ServiceToken(ctx, mo, MASTER_TOKEN, USER_ID_TOKEN, CRYPTO_CONTEXT);
}
@Test
public void negativeUserIdTokenSerialNumber() throws MslEncoderException, MslCryptoException, MslEncodingException, MslException, UnsupportedEncodingException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.SERVICETOKEN_USERIDTOKEN_SERIAL_NUMBER_OUT_OF_RANGE);
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);;
tokendataMo.put(KEY_USER_ID_TOKEN_SERIAL_NUMBER, -1);
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new ServiceToken(ctx, mo, MASTER_TOKEN, USER_ID_TOKEN, CRYPTO_CONTEXT);
}
@Test
public void tooLargeUserIdTokenSerialNumber() throws MslEncoderException, MslCryptoException, MslEncodingException, MslException, UnsupportedEncodingException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.SERVICETOKEN_USERIDTOKEN_SERIAL_NUMBER_OUT_OF_RANGE);
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);;
tokendataMo.put(KEY_USER_ID_TOKEN_SERIAL_NUMBER, MslConstants.MAX_LONG_VALUE + 1);
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new ServiceToken(ctx, mo, MASTER_TOKEN, USER_ID_TOKEN, CRYPTO_CONTEXT);
}
@Test
public void missingEncrypted() throws MslEncoderException, MslCryptoException, MslEncodingException, MslException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);;
assertNotNull(tokendataMo.remove(KEY_ENCRYPTED));
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new ServiceToken(ctx, mo, MASTER_TOKEN, USER_ID_TOKEN, CRYPTO_CONTEXT);
}
@Test
public void invalidEncrypted() throws MslEncoderException, MslCryptoException, MslEncodingException, MslException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);;
tokendataMo.put(KEY_ENCRYPTED, "x");
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new ServiceToken(ctx, mo, MASTER_TOKEN, USER_ID_TOKEN, CRYPTO_CONTEXT);
}
@Test
public void invalidCompressionAlgorithm() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.UNIDENTIFIED_COMPRESSION);
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);;
tokendataMo.put(KEY_COMPRESSION_ALGORITHM, "x");
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new ServiceToken(ctx, mo, MASTER_TOKEN, USER_ID_TOKEN, CRYPTO_CONTEXT);
}
@Test
public void missingServicedata() throws MslEncoderException, MslCryptoException, MslEncodingException, MslException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);;
assertNotNull(tokendataMo.remove(KEY_SERVICEDATA));
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new ServiceToken(ctx, mo, MASTER_TOKEN, USER_ID_TOKEN, CRYPTO_CONTEXT);
}
@Test
public void invalidServicedata() throws MslCryptoException, MslEncodingException, MslException, UnsupportedEncodingException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);;
tokendataMo.put(KEY_SERVICEDATA, false);
final byte[] modifiedTokendata = encoder.encodeObject(tokendataMo, ENCODER_FORMAT);
final byte[] signature = CRYPTO_CONTEXT.sign(modifiedTokendata, encoder, ENCODER_FORMAT);
mo.put(KEY_TOKENDATA, modifiedTokendata);
mo.put(KEY_SIGNATURE, signature);
new ServiceToken(ctx, mo, MASTER_TOKEN, USER_ID_TOKEN, CRYPTO_CONTEXT);
}
@Test
public void emptyServicedata() throws MslCryptoException, MslEncodingException, MslException, UnsupportedEncodingException, MslEncoderException {
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, new byte[0], MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
assertTrue(serviceToken.isDeleted());
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final ServiceToken moServiceToken = new ServiceToken(ctx, mo, MASTER_TOKEN, USER_ID_TOKEN, CRYPTO_CONTEXT);
assertTrue(moServiceToken.isDeleted());
assertEquals(0, moServiceToken.getData().length);
}
@Test
public void emptyServicedataNotVerified() throws MslCryptoException, MslEncodingException, MslException, UnsupportedEncodingException, MslEncoderException {
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, new byte[0], MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] signature = mo.getBytes(KEY_SIGNATURE);
++signature[0];
mo.put(KEY_SIGNATURE, signature);
final ServiceToken moServiceToken = new ServiceToken(ctx, mo, MASTER_TOKEN, USER_ID_TOKEN, CRYPTO_CONTEXT);
assertTrue(moServiceToken.isDeleted());
assertEquals(0, moServiceToken.getData().length);
}
@Test(expected = MslCryptoException.class)
public void corruptServicedata() throws MslEncoderException, MslCryptoException, MslEncodingException, MslException, UnsupportedEncodingException {
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
// This is testing service data that is verified but corrupt.
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);;
final byte[] servicedata = tokendataMo.getBytes(KEY_SERVICEDATA);
++servicedata[servicedata.length-1];
tokendataMo.put(KEY_SERVICEDATA, servicedata);
final byte[] modifiedTokendata = encoder.encodeObject(tokendataMo, ENCODER_FORMAT);
final byte[] signature = CRYPTO_CONTEXT.sign(modifiedTokendata, encoder, ENCODER_FORMAT);
mo.put(KEY_TOKENDATA, modifiedTokendata);
mo.put(KEY_SIGNATURE, signature);
new ServiceToken(ctx, mo, MASTER_TOKEN, USER_ID_TOKEN, CRYPTO_CONTEXT);
}
@Test
public void notVerified() throws MslEncoderException, MslException {
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] signature = mo.getBytes(KEY_SIGNATURE);
++signature[0];
mo.put(KEY_SIGNATURE, signature);
final ServiceToken moServiceToken = new ServiceToken(ctx, mo, MASTER_TOKEN, USER_ID_TOKEN, CRYPTO_CONTEXT);
assertFalse(moServiceToken.isDecrypted());
assertFalse(moServiceToken.isDeleted());
assertFalse(moServiceToken.isVerified());
assertNull(moServiceToken.getData());
assertEquals(serviceToken.isBoundTo(MASTER_TOKEN), moServiceToken.isBoundTo(MASTER_TOKEN));
assertEquals(serviceToken.isBoundTo(USER_ID_TOKEN), moServiceToken.isBoundTo(USER_ID_TOKEN));
assertEquals(serviceToken.isMasterTokenBound(), moServiceToken.isMasterTokenBound());
assertEquals(serviceToken.isUserIdTokenBound(), moServiceToken.isUserIdTokenBound());
assertEquals(serviceToken.isUnbound(), moServiceToken.isUnbound());
assertEquals(serviceToken.getMasterTokenSerialNumber(), moServiceToken.getMasterTokenSerialNumber());
assertEquals(serviceToken.getUserIdTokenSerialNumber(), moServiceToken.getUserIdTokenSerialNumber());
assertEquals(serviceToken.getName(), moServiceToken.getName());
final byte[] moEncode = moServiceToken.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertFalse(encode.equals(moEncode));
}
@Test
public void notEncrypted() throws MslEncoderException, MslException {
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, !ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
assertArrayEquals(DATA, serviceToken.getData());
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final ServiceToken moServiceToken = new ServiceToken(ctx, mo, MASTER_TOKEN, USER_ID_TOKEN, CRYPTO_CONTEXT);
assertTrue(moServiceToken.isVerified());
assertFalse(moServiceToken.isDeleted());
assertTrue(moServiceToken.isDecrypted());
assertArrayEquals(serviceToken.getData(), moServiceToken.getData());
assertEquals(serviceToken.isBoundTo(MASTER_TOKEN), moServiceToken.isBoundTo(MASTER_TOKEN));
assertEquals(serviceToken.isBoundTo(USER_ID_TOKEN), moServiceToken.isBoundTo(USER_ID_TOKEN));
assertEquals(serviceToken.isMasterTokenBound(), moServiceToken.isMasterTokenBound());
assertEquals(serviceToken.isUserIdTokenBound(), moServiceToken.isUserIdTokenBound());
assertEquals(serviceToken.isUnbound(), moServiceToken.isUnbound());
assertEquals(serviceToken.getMasterTokenSerialNumber(), moServiceToken.getMasterTokenSerialNumber());
assertEquals(serviceToken.getUserIdTokenSerialNumber(), moServiceToken.getUserIdTokenSerialNumber());
assertEquals(serviceToken.getName(), moServiceToken.getName());
final byte[] moEncode = moServiceToken.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void cryptoContextNull() throws MslException, MslEncoderException {
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final ServiceToken moServiceToken = new ServiceToken(ctx, mo, MASTER_TOKEN, USER_ID_TOKEN, (ICryptoContext)null);
assertFalse(moServiceToken.isDecrypted());
assertFalse(moServiceToken.isDeleted());
assertFalse(moServiceToken.isVerified());
assertNull(moServiceToken.getData());
assertEquals(serviceToken.isBoundTo(MASTER_TOKEN), moServiceToken.isBoundTo(MASTER_TOKEN));
assertEquals(serviceToken.isBoundTo(USER_ID_TOKEN), moServiceToken.isBoundTo(USER_ID_TOKEN));
assertEquals(serviceToken.isMasterTokenBound(), moServiceToken.isMasterTokenBound());
assertEquals(serviceToken.isUserIdTokenBound(), moServiceToken.isUserIdTokenBound());
assertEquals(serviceToken.isUnbound(), moServiceToken.isUnbound());
assertEquals(serviceToken.getMasterTokenSerialNumber(), moServiceToken.getMasterTokenSerialNumber());
assertEquals(serviceToken.getUserIdTokenSerialNumber(), moServiceToken.getUserIdTokenSerialNumber());
assertEquals(serviceToken.getName(), moServiceToken.getName());
final byte[] moEncode = moServiceToken.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void notEncryptedCryptoContextNull() throws MslCryptoException, MslEncodingException, MslException, MslEncoderException, MslEncoderException {
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, !ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final byte[] encode = serviceToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final ServiceToken moServiceToken = new ServiceToken(ctx, mo, MASTER_TOKEN, USER_ID_TOKEN, (ICryptoContext)null);
assertFalse(moServiceToken.isDecrypted());
assertFalse(moServiceToken.isDeleted());
assertFalse(moServiceToken.isVerified());
assertNull(moServiceToken.getData());
assertEquals(serviceToken.isBoundTo(MASTER_TOKEN), moServiceToken.isBoundTo(MASTER_TOKEN));
assertEquals(serviceToken.isBoundTo(USER_ID_TOKEN), moServiceToken.isBoundTo(USER_ID_TOKEN));
assertEquals(serviceToken.isMasterTokenBound(), moServiceToken.isMasterTokenBound());
assertEquals(serviceToken.isUserIdTokenBound(), moServiceToken.isUserIdTokenBound());
assertEquals(serviceToken.isUnbound(), moServiceToken.isUnbound());
assertEquals(serviceToken.getMasterTokenSerialNumber(), moServiceToken.getMasterTokenSerialNumber());
assertEquals(serviceToken.getUserIdTokenSerialNumber(), moServiceToken.getUserIdTokenSerialNumber());
assertEquals(serviceToken.getName(), moServiceToken.getName());
final byte[] moEncode = moServiceToken.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void isBoundToMasterToken() throws MslException {
final MasterToken masterTokenA = MslTestUtils.getMasterToken(ctx, 1, 1);
final MasterToken masterTokenB = MslTestUtils.getMasterToken(ctx, 1, 2);
final ServiceToken serviceTokenA = new ServiceToken(ctx, NAME, DATA, masterTokenA, null, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final ServiceToken serviceTokenB = new ServiceToken(ctx, NAME, DATA, masterTokenB, null, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
assertTrue(serviceTokenA.isBoundTo(masterTokenA));
assertFalse(serviceTokenA.isBoundTo(masterTokenB));
assertFalse(serviceTokenA.isBoundTo((MasterToken)null));
assertTrue(serviceTokenB.isBoundTo(masterTokenB));
assertFalse(serviceTokenB.isBoundTo(masterTokenA));
assertFalse(serviceTokenA.isBoundTo((MasterToken)null));
}
@Test
public void isBoundToUserIdToken() throws MslException {
final UserIdToken userIdTokenA = MslTestUtils.getUserIdToken(ctx, MASTER_TOKEN, 1, MockEmailPasswordAuthenticationFactory.USER);
final UserIdToken userIdTokenB = MslTestUtils.getUserIdToken(ctx, MASTER_TOKEN, 2, MockEmailPasswordAuthenticationFactory.USER);
final ServiceToken serviceTokenA = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, userIdTokenA, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final ServiceToken serviceTokenB = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, userIdTokenB, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
assertTrue(serviceTokenA.isBoundTo(userIdTokenA));
assertFalse(serviceTokenA.isBoundTo(userIdTokenB));
assertFalse(serviceTokenA.isBoundTo((UserIdToken)null));
assertTrue(serviceTokenB.isBoundTo(userIdTokenB));
assertFalse(serviceTokenB.isBoundTo(userIdTokenA));
assertFalse(serviceTokenA.isBoundTo((UserIdToken)null));
}
@Test
public void isUnbound() throws MslException {
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, null, null, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
assertTrue(serviceToken.isUnbound());
assertFalse(serviceToken.isBoundTo(MASTER_TOKEN));
assertFalse(serviceToken.isBoundTo(USER_ID_TOKEN));
assertFalse(serviceToken.isBoundTo((MasterToken)null));
assertFalse(serviceToken.isBoundTo((UserIdToken)null));
}
@Test
public void equalsName() throws MslException, MslEncoderException {
final String nameA = NAME + "A";
final String nameB = NAME + "B";
final ServiceToken serviceTokenA = new ServiceToken(ctx, nameA, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final ServiceToken serviceTokenB = new ServiceToken(ctx, nameB, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final ServiceToken serviceTokenA2 = new ServiceToken(ctx, MslTestUtils.toMslObject(encoder, serviceTokenA), MASTER_TOKEN, USER_ID_TOKEN, CRYPTO_CONTEXT);
assertTrue(serviceTokenA.equals(serviceTokenA));
assertEquals(serviceTokenA.hashCode(), serviceTokenA.hashCode());
assertFalse(serviceTokenA.equals(serviceTokenB));
assertFalse(serviceTokenB.equals(serviceTokenA));
assertTrue(serviceTokenA.hashCode() != serviceTokenB.hashCode());
assertTrue(serviceTokenA.equals(serviceTokenA2));
assertTrue(serviceTokenA2.equals(serviceTokenA));
assertEquals(serviceTokenA.hashCode(), serviceTokenA2.hashCode());
}
@Test
public void equalsMasterTokenSerialNumber() throws MslException, MslEncoderException {
final MasterToken masterTokenA = MslTestUtils.getMasterToken(ctx, 1, 1);
final MasterToken masterTokenB = MslTestUtils.getMasterToken(ctx, 1, 2);
final ServiceToken serviceTokenA = new ServiceToken(ctx, NAME, DATA, masterTokenA, null, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final ServiceToken serviceTokenB = new ServiceToken(ctx, NAME, DATA, masterTokenB, null, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final ServiceToken serviceTokenA2 = new ServiceToken(ctx, MslTestUtils.toMslObject(encoder, serviceTokenA), masterTokenA, null, CRYPTO_CONTEXT);
assertTrue(serviceTokenA.equals(serviceTokenA));
assertEquals(serviceTokenA.hashCode(), serviceTokenA.hashCode());
assertFalse(serviceTokenA.equals(serviceTokenB));
assertFalse(serviceTokenB.equals(serviceTokenA));
assertTrue(serviceTokenA.hashCode() != serviceTokenB.hashCode());
assertTrue(serviceTokenA.equals(serviceTokenA2));
assertTrue(serviceTokenA2.equals(serviceTokenA));
assertEquals(serviceTokenA.hashCode(), serviceTokenA2.hashCode());
}
@Test
public void equalsUserIdTokenSerialNumber() throws MslException, MslEncoderException {
final UserIdToken userIdTokenA = MslTestUtils.getUserIdToken(ctx, MASTER_TOKEN, 1, MockEmailPasswordAuthenticationFactory.USER);
final UserIdToken userIdTokenB = MslTestUtils.getUserIdToken(ctx, MASTER_TOKEN, 2, MockEmailPasswordAuthenticationFactory.USER);
final ServiceToken serviceTokenA = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, userIdTokenA, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final ServiceToken serviceTokenB = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, userIdTokenB, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
final ServiceToken serviceTokenA2 = new ServiceToken(ctx, MslTestUtils.toMslObject(encoder, serviceTokenA), MASTER_TOKEN, userIdTokenA, CRYPTO_CONTEXT);
assertTrue(serviceTokenA.equals(serviceTokenA));
assertEquals(serviceTokenA.hashCode(), serviceTokenA.hashCode());
assertFalse(serviceTokenA.equals(serviceTokenB));
assertFalse(serviceTokenB.equals(serviceTokenA));
assertTrue(serviceTokenA.hashCode() != serviceTokenB.hashCode());
assertTrue(serviceTokenA.equals(serviceTokenA2));
assertTrue(serviceTokenA2.equals(serviceTokenA));
assertEquals(serviceTokenA.hashCode(), serviceTokenA2.hashCode());
}
@Test
public void equalsObject() throws MslException {
final ServiceToken serviceToken = new ServiceToken(ctx, NAME, DATA, MASTER_TOKEN, USER_ID_TOKEN, ENCRYPTED, compressionAlgo, CRYPTO_CONTEXT);
assertFalse(serviceToken.equals(null));
assertFalse(serviceToken.equals(DATA));
assertTrue(serviceToken.hashCode() != Arrays.hashCode(DATA));
}
/** MSL context. */
private static MslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
/** Random. */
private static Random random;
}
| 9,977 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/tokens/UserIdTokenTest.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.tokens;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.io.UnsupportedEncodingException;
import java.util.Date;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslConstants;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.userauth.MockEmailPasswordAuthenticationFactory;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* User ID token unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class UserIdTokenTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Milliseconds per second. */
private static final long MILLISECONDS_PER_SECOND = 1000;
/** Key token data. */
private static final String KEY_TOKENDATA = "tokendata";
/** Key signature. */
private static final String KEY_SIGNATURE = "signature";
// tokendata
/** Key renewal window timestamp. */
private static final String KEY_RENEWAL_WINDOW = "renewalwindow";
/** Key expiration timestamp. */
private static final String KEY_EXPIRATION = "expiration";
/** Key master token serial number. */
private static final String KEY_MASTER_TOKEN_SERIAL_NUMBER = "mtserialnumber";
/** Key user ID token serial number. */
private static final String KEY_SERIAL_NUMBER = "serialnumber";
/** Key token user identification data. */
private static final String KEY_USERDATA = "userdata";
// userdata
/** Key issuer data. */
private static final String KEY_ISSUER_DATA = "issuerdata";
/** Key identity. */
private static final String KEY_IDENTITY = "identity";
private static final Date RENEWAL_WINDOW = new Date(System.currentTimeMillis() + 60000);
private static final Date EXPIRATION = new Date(System.currentTimeMillis() + 120000);
private static MasterToken MASTER_TOKEN;
private static final long SERIAL_NUMBER = 42;
private static MslObject ISSUER_DATA;
private static MslUser USER;
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException, MslEncoderException {
ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = ctx.getMslEncoderFactory();
MASTER_TOKEN = MslTestUtils.getMasterToken(ctx, 1, 1);
ISSUER_DATA = encoder.parseObject("{ 'issuerid' : 17 }".getBytes());
USER = MockEmailPasswordAuthenticationFactory.USER;
}
@AfterClass
public static void teardown() {
USER = null;
MASTER_TOKEN = null;
encoder = null;
ctx = null;
}
@Test
public void ctors() throws MslEncoderException, MslException {
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
assertTrue(userIdToken.isDecrypted());
assertTrue(userIdToken.isVerified());
assertFalse(userIdToken.isRenewable(null));
assertFalse(userIdToken.isExpired(null));
assertTrue(userIdToken.isBoundTo(MASTER_TOKEN));
assertTrue(MslEncoderUtils.equalObjects(ISSUER_DATA, userIdToken.getIssuerData()));
assertEquals(USER, userIdToken.getUser());
assertEquals(EXPIRATION.getTime() / MILLISECONDS_PER_SECOND, userIdToken.getExpiration().getTime() / MILLISECONDS_PER_SECOND);
assertEquals(MASTER_TOKEN.getSerialNumber(), userIdToken.getMasterTokenSerialNumber());
assertEquals(RENEWAL_WINDOW.getTime() / MILLISECONDS_PER_SECOND, userIdToken.getRenewalWindow().getTime() / MILLISECONDS_PER_SECOND);
assertEquals(SERIAL_NUMBER, userIdToken.getSerialNumber());
final byte[] encode = userIdToken.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final MslObject mo = encoder.parseObject(encode);
final UserIdToken moUserIdToken = new UserIdToken(ctx, mo, MASTER_TOKEN);
assertEquals(userIdToken.isDecrypted(), moUserIdToken.isDecrypted());
assertEquals(userIdToken.isVerified(), moUserIdToken.isVerified());
assertEquals(userIdToken.isRenewable(null), moUserIdToken.isRenewable(null));
assertEquals(userIdToken.isExpired(null), moUserIdToken.isExpired(null));
assertTrue(moUserIdToken.isBoundTo(MASTER_TOKEN));
assertTrue(MslEncoderUtils.equalObjects(userIdToken.getIssuerData(), moUserIdToken.getIssuerData()));
assertEquals(userIdToken.getUser(), moUserIdToken.getUser());
assertEquals(userIdToken.getExpiration().getTime() / MILLISECONDS_PER_SECOND, moUserIdToken.getExpiration().getTime() / MILLISECONDS_PER_SECOND);
assertEquals(userIdToken.getMasterTokenSerialNumber(), moUserIdToken.getMasterTokenSerialNumber());
assertEquals(userIdToken.getRenewalWindow().getTime() / MILLISECONDS_PER_SECOND, moUserIdToken.getRenewalWindow().getTime() / MILLISECONDS_PER_SECOND);
assertEquals(userIdToken.getSerialNumber(), moUserIdToken.getSerialNumber());
final byte[] moEncode = moUserIdToken.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test(expected = MslInternalException.class)
public void negativeSerialNumberCtor() throws MslEncodingException, MslCryptoException {
final long serialNumber = -1;
new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, serialNumber, ISSUER_DATA, USER);
}
@Test(expected = MslInternalException.class)
public void tooLargeSerialNumberCtor() throws MslEncodingException, MslCryptoException {
final long serialNumber = MslConstants.MAX_LONG_VALUE + 1;
new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, serialNumber, ISSUER_DATA, USER);
}
@Test(expected = MslInternalException.class)
public void nullMasterToken() throws MslEncodingException, MslCryptoException {
new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, null, SERIAL_NUMBER, ISSUER_DATA, USER);
}
@Test
public void masterTokenMismatch() throws MslException, MslEncoderException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.USERIDTOKEN_MASTERTOKEN_MISMATCH);
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, masterToken, SERIAL_NUMBER, ISSUER_DATA, USER);
final MasterToken moMasterToken = MslTestUtils.getMasterToken(ctx, 1, 2);
new UserIdToken(ctx, MslTestUtils.toMslObject(encoder, userIdToken), moMasterToken);
}
@Test
public void masterTokenNull() throws MslException, MslEncoderException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.USERIDTOKEN_MASTERTOKEN_MISMATCH);
final MasterToken masterToken = MslTestUtils.getMasterToken(ctx, 1, 1);
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, masterToken, SERIAL_NUMBER, ISSUER_DATA, USER);
new UserIdToken(ctx, MslTestUtils.toMslObject(encoder, userIdToken), null);
}
@Test(expected = MslInternalException.class)
public void inconsistentExpiration() throws MslEncodingException, MslCryptoException {
final Date expiration = new Date(System.currentTimeMillis() - 1);
final Date renewalWindow = new Date();
assertTrue(expiration.before(renewalWindow));
new UserIdToken(ctx, renewalWindow, expiration, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
}
@Test
public void inconsistentExpirationJson() throws MslEncoderException, MslException, UnsupportedEncodingException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.USERIDTOKEN_EXPIRES_BEFORE_RENEWAL);
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
final byte[] encode = userIdToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
tokendataMo.put(KEY_EXPIRATION, System.currentTimeMillis() / MILLISECONDS_PER_SECOND - 1);
tokendataMo.put(KEY_RENEWAL_WINDOW, System.currentTimeMillis() / MILLISECONDS_PER_SECOND);
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new UserIdToken(ctx, mo, MASTER_TOKEN);
}
@Test
public void missingTokendata() throws MslException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
final byte[] encode = userIdToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
assertNotNull(mo.remove(KEY_TOKENDATA));
new UserIdToken(ctx, mo, MASTER_TOKEN);
}
@Test(expected = MslEncodingException.class)
public void invalidTokendata() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
final byte[] encode = userIdToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
++tokendata[0];
mo.put(KEY_TOKENDATA, tokendata);
new UserIdToken(ctx, mo, MASTER_TOKEN);
}
@Test
public void missingSignature() throws MslEncodingException, MslCryptoException, MslException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
final byte[] encode = userIdToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
assertNotNull(mo.remove(KEY_SIGNATURE));
new UserIdToken(ctx, mo, MASTER_TOKEN);
}
@Test
public void missingRenewalWindow() throws MslEncoderException, MslException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.USERIDTOKEN_TOKENDATA_PARSE_ERROR);
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
final byte[] encode = userIdToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
assertNotNull(tokendataMo.remove(KEY_RENEWAL_WINDOW));
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new UserIdToken(ctx, mo, MASTER_TOKEN);
}
@Test
public void invalidRenewalWindow() throws MslEncoderException, MslException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.USERIDTOKEN_TOKENDATA_PARSE_ERROR);
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
final byte[] encode = userIdToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
tokendataMo.put(KEY_RENEWAL_WINDOW, "x");
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new UserIdToken(ctx, mo, MASTER_TOKEN);
}
@Test
public void missingExpiration() throws MslEncoderException, MslException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.USERIDTOKEN_TOKENDATA_PARSE_ERROR);
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
final byte[] encode = userIdToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
assertNotNull(tokendataMo.remove(KEY_EXPIRATION));
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new UserIdToken(ctx, mo, MASTER_TOKEN);
}
@Test
public void invalidExpiration() throws MslEncoderException, MslException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.USERIDTOKEN_TOKENDATA_PARSE_ERROR);
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
final byte[] encode = userIdToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
tokendataMo.put(KEY_EXPIRATION, "x");
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new UserIdToken(ctx, mo, MASTER_TOKEN);
}
@Test
public void missingSerialNumber() throws MslEncoderException, MslException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.USERIDTOKEN_TOKENDATA_PARSE_ERROR);
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
final byte[] encode = userIdToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
assertNotNull(tokendataMo.remove(KEY_SERIAL_NUMBER));
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new UserIdToken(ctx, mo, MASTER_TOKEN);
}
@Test
public void invalidSerialNumber() throws MslEncoderException, MslException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.USERIDTOKEN_TOKENDATA_PARSE_ERROR);
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
final byte[] encode = userIdToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
tokendataMo.put(KEY_SERIAL_NUMBER, "x");
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new UserIdToken(ctx, mo, MASTER_TOKEN);
}
@Test
public void negativeSerialNumber() throws MslEncodingException, MslCryptoException, MslEncoderException, MslException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.USERIDTOKEN_SERIAL_NUMBER_OUT_OF_RANGE);
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
final byte[] encode = userIdToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
tokendataMo.put(KEY_SERIAL_NUMBER, -1);
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new UserIdToken(ctx, mo, MASTER_TOKEN);
}
@Test
public void tooLargeSerialNumber() throws MslEncodingException, MslCryptoException, MslEncoderException, MslException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.USERIDTOKEN_SERIAL_NUMBER_OUT_OF_RANGE);
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
final byte[] encode = userIdToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
tokendataMo.put(KEY_SERIAL_NUMBER, MslConstants.MAX_LONG_VALUE + 1);
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new UserIdToken(ctx, mo, MASTER_TOKEN);
}
@Test
public void missingMasterTokenSerialNumber() throws MslEncoderException, MslException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.USERIDTOKEN_TOKENDATA_PARSE_ERROR);
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
final byte[] encode = userIdToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
assertNotNull(tokendataMo.remove(KEY_MASTER_TOKEN_SERIAL_NUMBER));
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new UserIdToken(ctx, mo, MASTER_TOKEN);
}
@Test
public void invalidMasterTokenSerialNumber() throws MslEncoderException, MslException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.USERIDTOKEN_TOKENDATA_PARSE_ERROR);
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
final byte[] encode = userIdToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
tokendataMo.put(KEY_MASTER_TOKEN_SERIAL_NUMBER, "x");
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new UserIdToken(ctx, mo, MASTER_TOKEN);
}
@Test
public void negativeMasterTokenSerialNumber() throws MslEncodingException, MslCryptoException, MslEncoderException, MslException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.USERIDTOKEN_MASTERTOKEN_SERIAL_NUMBER_OUT_OF_RANGE);
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
final byte[] encode = userIdToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
tokendataMo.put(KEY_MASTER_TOKEN_SERIAL_NUMBER, -1);
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new UserIdToken(ctx, mo, MASTER_TOKEN);
}
@Test
public void tooLargeMasterTokenSerialNumber() throws MslEncodingException, MslCryptoException, MslEncoderException, MslException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.USERIDTOKEN_MASTERTOKEN_SERIAL_NUMBER_OUT_OF_RANGE);
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
final byte[] encode = userIdToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
tokendataMo.put(KEY_MASTER_TOKEN_SERIAL_NUMBER, MslConstants.MAX_LONG_VALUE + 1);
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new UserIdToken(ctx, mo, MASTER_TOKEN);
}
@Test
public void missingUserdata() throws MslEncoderException, MslException, UnsupportedEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.USERIDTOKEN_TOKENDATA_PARSE_ERROR);
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
final byte[] encode = userIdToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
assertNotNull(tokendataMo.remove(KEY_USERDATA));
mo.put(KEY_TOKENDATA, encoder.encodeObject(tokendataMo, ENCODER_FORMAT));
new UserIdToken(ctx, mo, MASTER_TOKEN);
}
@Test
public void invalidUserdata() throws MslEncodingException, MslCryptoException, MslException, UnsupportedEncodingException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.USERIDTOKEN_TOKENDATA_PARSE_ERROR);
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
final byte[] encode = userIdToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
tokendataMo.put(KEY_USERDATA, "x");
final ICryptoContext cryptoContext = ctx.getMslCryptoContext();
final byte[] modifiedTokendata = encoder.encodeObject(tokendataMo, ENCODER_FORMAT);
final byte[] signature = cryptoContext.sign(modifiedTokendata, encoder, ENCODER_FORMAT);
mo.put(KEY_TOKENDATA, modifiedTokendata);
mo.put(KEY_SIGNATURE, signature);
new UserIdToken(ctx, mo, MASTER_TOKEN);
}
@Test
public void emptyUserdata() throws MslEncodingException, MslCryptoException, MslException, UnsupportedEncodingException, MslEncoderException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.USERIDTOKEN_USERDATA_MISSING);
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
final byte[] encode = userIdToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
final ICryptoContext cryptoContext = ctx.getMslCryptoContext();
final byte[] ciphertext = new byte[0];
tokendataMo.put(KEY_USERDATA, ciphertext);
final byte[] modifiedTokendata = encoder.encodeObject(tokendataMo, ENCODER_FORMAT);
final byte[] signature = cryptoContext.sign(modifiedTokendata, encoder, ENCODER_FORMAT);
mo.put(KEY_TOKENDATA, modifiedTokendata);
mo.put(KEY_SIGNATURE, signature);
new UserIdToken(ctx, mo, MASTER_TOKEN);
}
@Test(expected = MslCryptoException.class)
public void corruptUserdata() throws MslEncoderException, MslException, UnsupportedEncodingException {
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
final byte[] encode = userIdToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
// This is testing user data that is verified but corrupt.
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
final byte[] userdata = tokendataMo.getBytes(KEY_USERDATA);
++userdata[userdata.length-1];
tokendataMo.put(KEY_USERDATA, userdata);
final ICryptoContext cryptoContext = ctx.getMslCryptoContext();
final byte[] modifiedTokendata = encoder.encodeObject(tokendataMo, ENCODER_FORMAT);
final byte[] signature = cryptoContext.sign(modifiedTokendata, encoder, ENCODER_FORMAT);
mo.put(KEY_TOKENDATA, modifiedTokendata);
mo.put(KEY_SIGNATURE, signature);
new UserIdToken(ctx, mo, MASTER_TOKEN);
}
@Test
public void invalidUser() throws MslEncoderException, MslException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.USERIDTOKEN_IDENTITY_INVALID);
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
final byte[] encode = userIdToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final ICryptoContext cryptoContext = ctx.getMslCryptoContext();
// Before modifying the user data we need to decrypt it.
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
final byte[] ciphertext = tokendataMo.getBytes(KEY_USERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject userdataMo = encoder.parseObject(plaintext);
// After modifying the user data we need to encrypt it.
userdataMo.put(KEY_IDENTITY, "x");
final byte[] userdata = cryptoContext.encrypt(encoder.encodeObject(userdataMo, ENCODER_FORMAT), encoder, ENCODER_FORMAT);
tokendataMo.put(KEY_USERDATA, userdata);
// The tokendata must be signed otherwise the user data will not be
// processed.
final byte[] modifiedTokendata = encoder.encodeObject(tokendataMo, ENCODER_FORMAT);
final byte[] signature = cryptoContext.sign(modifiedTokendata, encoder, ENCODER_FORMAT);
mo.put(KEY_TOKENDATA, modifiedTokendata);
mo.put(KEY_SIGNATURE, signature);
new UserIdToken(ctx, mo, MASTER_TOKEN);
}
@Test
public void emptyUser() throws MslEncoderException, MslException {
thrown.expect(MslException.class);
thrown.expectMslError(MslError.USERIDTOKEN_IDENTITY_INVALID);
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
final byte[] encode = userIdToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final ICryptoContext cryptoContext = ctx.getMslCryptoContext();
// Before modifying the user data we need to decrypt it.
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
final byte[] ciphertext = tokendataMo.getBytes(KEY_USERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject userdataMo = encoder.parseObject(plaintext);
// After modifying the user data we need to encrypt it.
userdataMo.put(KEY_IDENTITY, "");
final byte[] userdata = cryptoContext.encrypt(encoder.encodeObject(userdataMo, ENCODER_FORMAT), encoder, ENCODER_FORMAT);
tokendataMo.put(KEY_USERDATA, userdata);
// The tokendata must be signed otherwise the user data will not be
// processed.
final byte[] modifiedTokendata = encoder.encodeObject(tokendataMo, ENCODER_FORMAT);
final byte[] signature = cryptoContext.sign(modifiedTokendata, encoder, ENCODER_FORMAT);
mo.put(KEY_TOKENDATA, modifiedTokendata);
mo.put(KEY_SIGNATURE, signature);
new UserIdToken(ctx, mo, MASTER_TOKEN);
}
@Test
public void missingUser() throws MslEncoderException, MslException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.USERIDTOKEN_USERDATA_PARSE_ERROR);
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
final byte[] encode = userIdToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final ICryptoContext cryptoContext = ctx.getMslCryptoContext();
// Before modifying the user data we need to decrypt it.
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
final byte[] ciphertext = tokendataMo.getBytes(KEY_USERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject userdataMo = encoder.parseObject(plaintext);
// After modifying the user data we need to encrypt it.
userdataMo.remove(KEY_IDENTITY);
final byte[] userdata = cryptoContext.encrypt(encoder.encodeObject(userdataMo, ENCODER_FORMAT), encoder, ENCODER_FORMAT);
tokendataMo.put(KEY_USERDATA, userdata);
// The tokendata must be signed otherwise the user data will not be
// processed.
final byte[] modifiedTokendata = encoder.encodeObject(tokendataMo, ENCODER_FORMAT);
final byte[] signature = cryptoContext.sign(modifiedTokendata, encoder, ENCODER_FORMAT);
mo.put(KEY_TOKENDATA, modifiedTokendata);
mo.put(KEY_SIGNATURE, signature);
new UserIdToken(ctx, mo, MASTER_TOKEN);
}
@Test
public void invalidIssuerData() throws MslEncodingException, MslCryptoException, MslEncoderException, MslException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.USERIDTOKEN_USERDATA_PARSE_ERROR);
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
final byte[] encode = userIdToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final ICryptoContext cryptoContext = ctx.getMslCryptoContext();
// Before modifying the user data we need to decrypt it.
final byte[] tokendata = mo.getBytes(KEY_TOKENDATA);
final MslObject tokendataMo = encoder.parseObject(tokendata);
final byte[] ciphertext = tokendataMo.getBytes(KEY_USERDATA);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject userdataMo = encoder.parseObject(plaintext);
// After modifying the user data we need to encrypt it.
userdataMo.put(KEY_ISSUER_DATA, "x");
final byte[] userdata = cryptoContext.encrypt(encoder.encodeObject(userdataMo, ENCODER_FORMAT), encoder, ENCODER_FORMAT);
tokendataMo.put(KEY_USERDATA, userdata);
// The tokendata must be signed otherwise the user data will not be
// processed.
final byte[] modifiedTokendata = encoder.encodeObject(tokendataMo, ENCODER_FORMAT);
final byte[] signature = cryptoContext.sign(modifiedTokendata, encoder, ENCODER_FORMAT);
mo.put(KEY_TOKENDATA, modifiedTokendata);
mo.put(KEY_SIGNATURE, signature);
new UserIdToken(ctx, mo, MASTER_TOKEN);
}
@Test
public void notVerified() throws MslEncoderException, MslException {
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
final byte[] encode = userIdToken.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = encoder.parseObject(encode);
final byte[] signature = mo.getBytes(KEY_SIGNATURE);
++signature[0];
mo.put(KEY_SIGNATURE, signature);
final UserIdToken moUserIdToken = new UserIdToken(ctx, mo, MASTER_TOKEN);
assertFalse(moUserIdToken.isDecrypted());
assertFalse(moUserIdToken.isVerified());
assertTrue(moUserIdToken.isRenewable(null));
assertFalse(moUserIdToken.isExpired(null));
assertEquals(userIdToken.isBoundTo(MASTER_TOKEN), moUserIdToken.isBoundTo(MASTER_TOKEN));
assertEquals(null, moUserIdToken.getUser());
assertEquals(userIdToken.getExpiration().getTime() / MILLISECONDS_PER_SECOND, moUserIdToken.getExpiration().getTime() / MILLISECONDS_PER_SECOND);
assertEquals(userIdToken.getMasterTokenSerialNumber(), moUserIdToken.getMasterTokenSerialNumber());
assertEquals(userIdToken.getRenewalWindow().getTime() / MILLISECONDS_PER_SECOND, moUserIdToken.getRenewalWindow().getTime() / MILLISECONDS_PER_SECOND);
assertEquals(userIdToken.getSerialNumber(), moUserIdToken.getSerialNumber());
final byte[] moEncode = moUserIdToken.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertFalse(encode.equals(moEncode));
}
@Test
public void isRenewable() throws MslEncodingException, MslCryptoException {
final Date renewalWindow = new Date();
final Date expiration = new Date(System.currentTimeMillis() + 1000);
final UserIdToken userIdToken = new UserIdToken(ctx, renewalWindow, expiration, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
final Date now = new Date();
assertTrue(userIdToken.isRenewable(null));
assertTrue(userIdToken.isRenewable(now));
assertFalse(userIdToken.isExpired(null));
assertFalse(userIdToken.isExpired(now));
final Date before = new Date(renewalWindow.getTime() - 1000);
assertFalse(userIdToken.isRenewable(before));
assertFalse(userIdToken.isExpired(before));
final Date after = new Date(expiration.getTime() + 1000);
assertTrue(userIdToken.isRenewable(after));
assertTrue(userIdToken.isExpired(after));
}
@Test
public void isExpired() throws MslEncodingException, MslCryptoException {
final Date renewalWindow = new Date(System.currentTimeMillis() - 1000);
final Date expiration = new Date();
final UserIdToken userIdToken = new UserIdToken(ctx, renewalWindow, expiration, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
final Date now = new Date();
assertTrue(userIdToken.isRenewable(null));
assertTrue(userIdToken.isRenewable(now));
assertTrue(userIdToken.isExpired(null));
assertTrue(userIdToken.isExpired(now));
final Date before = new Date(renewalWindow.getTime() - 1000);
assertFalse(userIdToken.isRenewable(before));
assertFalse(userIdToken.isExpired(before));
final Date after = new Date(expiration.getTime() + 1000);
assertTrue(userIdToken.isRenewable(after));
assertTrue(userIdToken.isExpired(after));
}
@Test
public void notRenewableOrExpired() throws MslEncodingException, MslCryptoException {
final Date renewalWindow = new Date(System.currentTimeMillis() + 1000);
final Date expiration = new Date(System.currentTimeMillis() + 2000);
final UserIdToken userIdToken = new UserIdToken(ctx, renewalWindow, expiration, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
final Date now = new Date();
assertFalse(userIdToken.isRenewable(null));
assertFalse(userIdToken.isRenewable(now));
assertFalse(userIdToken.isExpired(null));
assertFalse(userIdToken.isExpired(now));
final Date before = new Date(renewalWindow.getTime() - 1000);
assertFalse(userIdToken.isRenewable(before));
assertFalse(userIdToken.isExpired(before));
final Date after = new Date(expiration.getTime() + 1000);
assertTrue(userIdToken.isRenewable(after));
assertTrue(userIdToken.isExpired(after));
}
@Test
public void isBoundTo() throws MslEncodingException, MslCryptoException {
final MasterToken masterTokenA = MslTestUtils.getMasterToken(ctx, 1, 1);
final UserIdToken userIdTokenA = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, masterTokenA, SERIAL_NUMBER, ISSUER_DATA, USER);
final MasterToken masterTokenB = MslTestUtils.getMasterToken(ctx, 1, 2);
final UserIdToken userIdTokenB = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, masterTokenB, SERIAL_NUMBER, ISSUER_DATA, USER);
assertTrue(userIdTokenA.isBoundTo(masterTokenA));
assertFalse(userIdTokenA.isBoundTo(masterTokenB));
assertFalse(userIdTokenA.isBoundTo(null));
assertTrue(userIdTokenB.isBoundTo(masterTokenB));
assertFalse(userIdTokenB.isBoundTo(masterTokenA));
assertFalse(userIdTokenB.isBoundTo(null));
}
@Test
public void equalsSerialNumber() throws MslException, MslEncoderException {
final long serialNumberA = 1;
final long serialNumberB = 2;
final UserIdToken userIdTokenA = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, serialNumberA, ISSUER_DATA, USER);
final UserIdToken userIdTokenB = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, serialNumberB, ISSUER_DATA, USER);
final UserIdToken userIdTokenA2 = new UserIdToken(ctx, MslTestUtils.toMslObject(encoder, userIdTokenA), MASTER_TOKEN);
assertTrue(userIdTokenA.equals(userIdTokenA));
assertEquals(userIdTokenA.hashCode(), userIdTokenA.hashCode());
assertFalse(userIdTokenA.equals(userIdTokenB));
assertFalse(userIdTokenB.equals(userIdTokenA));
assertTrue(userIdTokenA.hashCode() != userIdTokenB.hashCode());
assertTrue(userIdTokenA.equals(userIdTokenA2));
assertTrue(userIdTokenA2.equals(userIdTokenA));
assertEquals(userIdTokenA.hashCode(), userIdTokenA2.hashCode());
}
@Test
public void equalsMasterTokenSerialNumber() throws MslException, MslEncoderException {
final MasterToken masterTokenA = MslTestUtils.getMasterToken(ctx, 1, 1);
final MasterToken masterTokenB = MslTestUtils.getMasterToken(ctx, 1, 2);
final UserIdToken userIdTokenA = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, masterTokenA, SERIAL_NUMBER, ISSUER_DATA, USER);
final UserIdToken userIdTokenB = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, masterTokenB, SERIAL_NUMBER, ISSUER_DATA, USER);
final UserIdToken userIdTokenA2 = new UserIdToken(ctx, MslTestUtils.toMslObject(encoder, userIdTokenA), masterTokenA);
assertTrue(userIdTokenA.equals(userIdTokenA));
assertEquals(userIdTokenA.hashCode(), userIdTokenA.hashCode());
assertFalse(userIdTokenA.equals(userIdTokenB));
assertFalse(userIdTokenB.equals(userIdTokenA));
assertTrue(userIdTokenA.hashCode() != userIdTokenB.hashCode());
assertTrue(userIdTokenA.equals(userIdTokenA2));
assertTrue(userIdTokenA2.equals(userIdTokenA));
assertEquals(userIdTokenA.hashCode(), userIdTokenA2.hashCode());
}
@Test
public void equalsObject() throws MslEncodingException, MslCryptoException {
final UserIdToken userIdToken = new UserIdToken(ctx, RENEWAL_WINDOW, EXPIRATION, MASTER_TOKEN, SERIAL_NUMBER, ISSUER_DATA, USER);
assertFalse(userIdToken.equals(null));
assertFalse(userIdToken.equals(RENEWAL_WINDOW));
assertTrue(userIdToken.hashCode() != RENEWAL_WINDOW.hashCode());
}
/** MSL context. */
private static MslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
}
| 9,978 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/entityauth/RsaAuthenticationDataTest.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.io.IOException;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* RSA entity authentication data unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class RsaAuthenticationDataTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key entity authentication scheme. */
private static final String KEY_SCHEME = "scheme";
/** Key entity authentication data. */
private static final String KEY_AUTHDATA = "authdata";
/** Key entity identity. */
private static final String KEY_IDENTITY = "identity";
/** Key public key ID. */
private static final String KEY_PUBKEY_ID = "pubkeyid";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@BeforeClass
public static void setup() throws IOException, MslEncodingException, MslCryptoException {
ctx = new MockMslContext(EntityAuthenticationScheme.X509, false);
encoder = ctx.getMslEncoderFactory();
}
@AfterClass
public static void teardown() {
encoder = null;
ctx = null;
}
@Test
public void ctors() throws MslEncodingException, MslEncoderException, MslCryptoException {
final RsaAuthenticationData data = new RsaAuthenticationData(MockRsaAuthenticationFactory.RSA_ESN, MockRsaAuthenticationFactory.RSA_PUBKEY_ID);
assertEquals(MockRsaAuthenticationFactory.RSA_ESN, data.getIdentity());
assertEquals(MockRsaAuthenticationFactory.RSA_PUBKEY_ID, data.getPublicKeyId());
assertEquals(EntityAuthenticationScheme.RSA, data.getScheme());
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(authdata);
final byte[] encode = data.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final RsaAuthenticationData moData = new RsaAuthenticationData(authdata);
assertEquals(data.getIdentity(), moData.getIdentity());
assertEquals(data.getPublicKeyId(), moData.getPublicKeyId());
assertEquals(data.getScheme(), moData.getScheme());
final MslObject moAuthdata = moData.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(moAuthdata);
assertTrue(MslEncoderUtils.equalObjects(authdata, moAuthdata));
final byte[] moEncode = moData.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void encode() throws MslEncoderException, MslCryptoException {
final RsaAuthenticationData data = new RsaAuthenticationData(MockRsaAuthenticationFactory.RSA_ESN, MockRsaAuthenticationFactory.RSA_PUBKEY_ID);
final MslObject mo = MslTestUtils.toMslObject(encoder, data);
assertEquals(EntityAuthenticationScheme.RSA.toString(), mo.getString(KEY_SCHEME));
final MslObject authdata = mo.getMslObject(KEY_AUTHDATA, encoder);
assertEquals(MockRsaAuthenticationFactory.RSA_ESN, authdata.getString(KEY_IDENTITY));
assertEquals(MockRsaAuthenticationFactory.RSA_PUBKEY_ID, authdata.get(KEY_PUBKEY_ID));
}
@Test
public void create() throws MslEncoderException, MslEntityAuthException, MslEncodingException, MslCryptoException {
final RsaAuthenticationData data = new RsaAuthenticationData(MockRsaAuthenticationFactory.RSA_ESN, MockRsaAuthenticationFactory.RSA_PUBKEY_ID);
final byte[] encode = data.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = MslTestUtils.toMslObject(encoder, data);
final EntityAuthenticationData entitydata = EntityAuthenticationData.create(ctx, mo);
assertNotNull(entitydata);
assertTrue(entitydata instanceof RsaAuthenticationData);
final RsaAuthenticationData moData = (RsaAuthenticationData)entitydata;
assertEquals(data.getIdentity(), moData.getIdentity());
assertEquals(data.getPublicKeyId(), moData.getPublicKeyId());
assertEquals(data.getScheme(), moData.getScheme());
final MslObject moAuthdata = moData.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(moAuthdata);
assertTrue(MslEncoderUtils.equalObjects(data.getAuthData(encoder, ENCODER_FORMAT), moAuthdata));
final byte[] moEncode = moData.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void missingIdentity() throws MslEncodingException, MslCryptoException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final RsaAuthenticationData data = new RsaAuthenticationData(MockRsaAuthenticationFactory.RSA_ESN, MockRsaAuthenticationFactory.RSA_PUBKEY_ID);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(authdata.remove(KEY_IDENTITY));
new RsaAuthenticationData(authdata);
}
@Test
public void missingPubkeyId() throws MslEncodingException, MslCryptoException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final RsaAuthenticationData data = new RsaAuthenticationData(MockRsaAuthenticationFactory.RSA_ESN, MockRsaAuthenticationFactory.RSA_PUBKEY_ID);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(authdata.remove(KEY_PUBKEY_ID));
new RsaAuthenticationData(authdata);
}
@Test
public void equalsIdentity() throws MslEncodingException, MslEncoderException, MslEntityAuthException, MslCryptoException {
final String identityA = MockRsaAuthenticationFactory.RSA_ESN + "A";
final String identityB = MockRsaAuthenticationFactory.RSA_ESN + "B";
final RsaAuthenticationData dataA = new RsaAuthenticationData(identityA, MockRsaAuthenticationFactory.RSA_PUBKEY_ID);
final RsaAuthenticationData dataB = new RsaAuthenticationData(identityB, MockRsaAuthenticationFactory.RSA_PUBKEY_ID);
final EntityAuthenticationData dataA2 = EntityAuthenticationData.create(ctx, MslTestUtils.toMslObject(encoder, dataA));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsPubKeyId() throws MslEncodingException, MslEncoderException, MslEntityAuthException, MslCryptoException {
final String pubkeyidA = MockRsaAuthenticationFactory.RSA_PUBKEY_ID + "A";
final String pubkeyidB = MockRsaAuthenticationFactory.RSA_PUBKEY_ID + "B";
final RsaAuthenticationData dataA = new RsaAuthenticationData(MockRsaAuthenticationFactory.RSA_ESN, pubkeyidA);
final RsaAuthenticationData dataB = new RsaAuthenticationData(MockRsaAuthenticationFactory.RSA_ESN, pubkeyidB);
final EntityAuthenticationData dataA2 = EntityAuthenticationData.create(ctx, MslTestUtils.toMslObject(encoder, dataA));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsObject() {
final RsaAuthenticationData data = new RsaAuthenticationData(MockRsaAuthenticationFactory.RSA_ESN, MockRsaAuthenticationFactory.RSA_PUBKEY_ID);
assertFalse(data.equals(null));
assertFalse(data.equals(KEY_IDENTITY));
assertTrue(data.hashCode() != KEY_IDENTITY.hashCode());
}
/** MSL context. */
private static MslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
}
| 9,979 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/entityauth/EntityAuthenticationDataTest.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
/**
* Entity authentication data unit tests.
*
* Successful calls to
* {@link EntityAuthenticationData#create(MslContext, MslObject)} covered in
* the individual entity authentication data unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class EntityAuthenticationDataTest {
/** Key entity authentication scheme. */
private static final String KEY_SCHEME = "scheme";
/** Key entity authentication data. */
private static final String KEY_AUTHDATA = "authdata";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException {
ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = ctx.getMslEncoderFactory();
}
@AfterClass
public static void teardown() {
encoder = null;
ctx = null;
}
@Test
public void noScheme() throws MslEncoderException, MslEntityAuthException, MslEncodingException, MslCryptoException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final MslObject mo = encoder.createObject();
mo.put(KEY_SCHEME + "x", EntityAuthenticationScheme.NONE.name());
mo.put(KEY_AUTHDATA, new MslObject());
EntityAuthenticationData.create(ctx, mo);
}
@Test
public void noAuthdata() throws MslEncoderException, MslEntityAuthException, MslEncodingException, MslCryptoException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final MslObject mo = encoder.createObject();
mo.put(KEY_SCHEME, EntityAuthenticationScheme.NONE.name());
mo.put(KEY_AUTHDATA + "x", new MslObject());
EntityAuthenticationData.create(ctx, mo);
}
@Test
public void unidentifiedScheme() throws MslEncoderException, MslEntityAuthException, MslEncodingException, MslCryptoException {
thrown.expect(MslEntityAuthException.class);
thrown.expectMslError(MslError.UNIDENTIFIED_ENTITYAUTH_SCHEME);
final MslObject mo = encoder.createObject();
mo.put(KEY_SCHEME, "x");
mo.put(KEY_AUTHDATA, new MslObject());
EntityAuthenticationData.create(ctx, mo);
}
@Test
public void authFactoryNotFound() throws MslEncoderException, MslEntityAuthException, MslEncodingException, MslCryptoException {
thrown.expect(MslEntityAuthException.class);
thrown.expectMslError(MslError.ENTITYAUTH_FACTORY_NOT_FOUND);
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
ctx.removeEntityAuthenticationFactory(EntityAuthenticationScheme.NONE);
final MslObject mo = encoder.createObject();
mo.put(KEY_SCHEME, EntityAuthenticationScheme.NONE.name());
mo.put(KEY_AUTHDATA, new MslObject());
EntityAuthenticationData.create(ctx, mo);
}
/** MSL context. */
private static MslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
}
| 9,980 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/entityauth/UnauthenticatedAuthenticationDataTest.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.io.IOException;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* Unauthenticated entity authentication data unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class UnauthenticatedAuthenticationDataTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key entity authentication scheme. */
private static final String KEY_SCHEME = "scheme";
/** Key entity authentication data. */
private static final String KEY_AUTHDATA = "authdata";
/** Key entity identity. */
private static final String KEY_IDENTITY = "identity";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
private static final String IDENTITY = "identity";
@BeforeClass
public static void setup() throws IOException, MslEncodingException, MslCryptoException {
ctx = new MockMslContext(EntityAuthenticationScheme.X509, false);
encoder = ctx.getMslEncoderFactory();
}
@AfterClass
public static void teardown() {
encoder = null;
ctx = null;
}
@Test
public void ctors() throws MslEncodingException, MslEncoderException {
final UnauthenticatedAuthenticationData data = new UnauthenticatedAuthenticationData(IDENTITY);
assertEquals(IDENTITY, data.getIdentity());
assertEquals(EntityAuthenticationScheme.NONE, data.getScheme());
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(authdata);
final byte[] encode = data.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final UnauthenticatedAuthenticationData moData = new UnauthenticatedAuthenticationData(authdata);
assertEquals(data.getIdentity(), moData.getIdentity());
assertEquals(data.getScheme(), moData.getScheme());
final MslObject moAuthdata = moData.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(moAuthdata);
assertTrue(MslEncoderUtils.equalObjects(authdata, moAuthdata));
final byte[] moEncode = moData.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void encode() throws MslEncoderException {
final UnauthenticatedAuthenticationData data = new UnauthenticatedAuthenticationData(IDENTITY);
final MslObject mo = MslTestUtils.toMslObject(encoder, data);
assertEquals(EntityAuthenticationScheme.NONE.toString(), mo.getString(KEY_SCHEME));
final MslObject authdata = mo.getMslObject(KEY_AUTHDATA, encoder);
assertEquals(IDENTITY, authdata.getString(KEY_IDENTITY));
}
@Test
public void create() throws MslEncoderException, MslEntityAuthException, MslEncodingException, MslCryptoException {
final UnauthenticatedAuthenticationData data = new UnauthenticatedAuthenticationData(IDENTITY);
final byte[] encode = data.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = MslTestUtils.toMslObject(encoder, data);
final EntityAuthenticationData entitydata = EntityAuthenticationData.create(ctx, mo);
assertNotNull(entitydata);
assertTrue(entitydata instanceof UnauthenticatedAuthenticationData);
final UnauthenticatedAuthenticationData moData = (UnauthenticatedAuthenticationData)entitydata;
assertEquals(data.getIdentity(), moData.getIdentity());
assertEquals(data.getScheme(), moData.getScheme());
final MslObject moAuthdata = moData.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(moAuthdata);
assertTrue(MslEncoderUtils.equalObjects(data.getAuthData(encoder, ENCODER_FORMAT), moAuthdata));
final byte[] moEncode = moData.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void missingIdentity() throws MslEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final UnauthenticatedAuthenticationData data = new UnauthenticatedAuthenticationData(IDENTITY);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
authdata.remove(KEY_IDENTITY);
new UnauthenticatedAuthenticationData(authdata);
}
@Test
public void equalsIdentity() throws MslEncodingException, MslEncoderException, MslEntityAuthException, MslCryptoException {
final UnauthenticatedAuthenticationData dataA = new UnauthenticatedAuthenticationData(IDENTITY + "A");
final UnauthenticatedAuthenticationData dataB = new UnauthenticatedAuthenticationData(IDENTITY + "B");
final EntityAuthenticationData dataA2 = EntityAuthenticationData.create(ctx, MslTestUtils.toMslObject(encoder, dataA));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsObject() {
final UnauthenticatedAuthenticationData data = new UnauthenticatedAuthenticationData(IDENTITY);
assertFalse(data.equals(null));
assertFalse(data.equals(IDENTITY));
assertTrue(data.hashCode() != IDENTITY.hashCode());
}
/** MSL context. */
private static MslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
}
| 9,981 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/entityauth/PresharedProfileAuthenticationDataTest.java | /**
* Copyright (c) 2014-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.io.IOException;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* Preshared keys profile entity authentication data unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class PresharedProfileAuthenticationDataTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key entity authentication scheme. */
private static final String KEY_SCHEME = "scheme";
/** Key entity authentication data. */
private static final String KEY_AUTHDATA = "authdata";
/** Key entity preshared keys identity. */
private static final String KEY_PSKID = "pskid";
/** Key entity profile. */
private static final String KEY_PROFILE = "profile";
/** Identity concatenation character. */
private static final String CONCAT_CHAR = "-";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@BeforeClass
public static void setup() throws IOException, MslEncodingException, MslCryptoException {
ctx = new MockMslContext(EntityAuthenticationScheme.X509, false);
encoder = ctx.getMslEncoderFactory();
}
@AfterClass
public static void teardown() {
encoder = null;
ctx = null;
}
@Test
public void ctors() throws MslEncodingException, MslEncoderException {
final PresharedProfileAuthenticationData data = new PresharedProfileAuthenticationData(MockPresharedProfileAuthenticationFactory.PSK_ESN, MockPresharedProfileAuthenticationFactory.PROFILE);
assertEquals(MockPresharedProfileAuthenticationFactory.PSK_ESN + CONCAT_CHAR + MockPresharedProfileAuthenticationFactory.PROFILE, data.getIdentity());
assertEquals(MockPresharedProfileAuthenticationFactory.PSK_ESN, data.getPresharedKeysId());
assertEquals(MockPresharedProfileAuthenticationFactory.PROFILE, data.getProfile());
assertEquals(EntityAuthenticationScheme.PSK_PROFILE, data.getScheme());
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(authdata);
final byte[] encode = data.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final PresharedProfileAuthenticationData moData = new PresharedProfileAuthenticationData(authdata);
assertEquals(data.getIdentity(), moData.getIdentity());
assertEquals(data.getPresharedKeysId(), moData.getPresharedKeysId());
assertEquals(data.getProfile(), moData.getProfile());
assertEquals(data.getScheme(), moData.getScheme());
final MslObject moAuthdata = moData.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(moAuthdata);
assertTrue(MslEncoderUtils.equalObjects(authdata, moAuthdata));
final byte[] moEncode = moData.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void encode() throws MslEncoderException {
final PresharedProfileAuthenticationData data = new PresharedProfileAuthenticationData(MockPresharedProfileAuthenticationFactory.PSK_ESN, MockPresharedProfileAuthenticationFactory.PROFILE);
final MslObject mo = MslTestUtils.toMslObject(encoder, data);
assertEquals(EntityAuthenticationScheme.PSK_PROFILE.toString(), mo.getString(KEY_SCHEME));
final MslObject authdata = mo.getMslObject(KEY_AUTHDATA, encoder);
assertEquals(MockPresharedProfileAuthenticationFactory.PSK_ESN, authdata.getString(KEY_PSKID));
assertEquals(MockPresharedProfileAuthenticationFactory.PROFILE, authdata.getString(KEY_PROFILE));
}
@Test
public void create() throws MslEncoderException, MslEntityAuthException, MslEncodingException, MslCryptoException {
final PresharedProfileAuthenticationData data = new PresharedProfileAuthenticationData(MockPresharedProfileAuthenticationFactory.PSK_ESN, MockPresharedProfileAuthenticationFactory.PROFILE);
final byte[] encode = data.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = MslTestUtils.toMslObject(encoder, data);
final EntityAuthenticationData entitydata = EntityAuthenticationData.create(ctx, mo);
assertNotNull(entitydata);
assertTrue(entitydata instanceof PresharedProfileAuthenticationData);
final PresharedProfileAuthenticationData moData = (PresharedProfileAuthenticationData)entitydata;
assertEquals(data.getIdentity(), moData.getIdentity());
assertEquals(data.getPresharedKeysId(), moData.getPresharedKeysId());
assertEquals(data.getProfile(), moData.getProfile());
assertEquals(data.getScheme(), moData.getScheme());
final MslObject moAuthdata = moData.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(moAuthdata);
assertTrue(MslEncoderUtils.equalObjects(data.getAuthData(encoder, ENCODER_FORMAT), moAuthdata));
final byte[] moEncode = moData.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void missingPskId() throws MslEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final PresharedProfileAuthenticationData data = new PresharedProfileAuthenticationData(MockPresharedProfileAuthenticationFactory.PSK_ESN, MockPresharedProfileAuthenticationFactory.PROFILE);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
authdata.remove(KEY_PSKID);
new PresharedProfileAuthenticationData(authdata);
}
@Test
public void missingProfile() throws MslEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final PresharedProfileAuthenticationData data = new PresharedProfileAuthenticationData(MockPresharedProfileAuthenticationFactory.PSK_ESN, MockPresharedProfileAuthenticationFactory.PROFILE);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
authdata.remove(KEY_PROFILE);
new PresharedProfileAuthenticationData(authdata);
}
@Test
public void equalsPskId() throws MslEncodingException, MslEncoderException, MslEntityAuthException, MslCryptoException {
final String pskIdA = MockPresharedProfileAuthenticationFactory.PSK_ESN + "A";
final String pskIdB = MockPresharedProfileAuthenticationFactory.PSK_ESN + "B";
final PresharedProfileAuthenticationData dataA = new PresharedProfileAuthenticationData(pskIdA, MockPresharedProfileAuthenticationFactory.PROFILE);
final PresharedProfileAuthenticationData dataB = new PresharedProfileAuthenticationData(pskIdB, MockPresharedProfileAuthenticationFactory.PROFILE);
final EntityAuthenticationData dataA2 = EntityAuthenticationData.create(ctx, MslTestUtils.toMslObject(encoder, dataA));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsProfile() throws MslEncodingException, MslEncoderException, MslEntityAuthException, MslCryptoException {
final String profileA = MockPresharedProfileAuthenticationFactory.PROFILE + "A";
final String profileB = MockPresharedProfileAuthenticationFactory.PROFILE + "B";
final PresharedProfileAuthenticationData dataA = new PresharedProfileAuthenticationData(MockPresharedProfileAuthenticationFactory.PSK_ESN, profileA);
final PresharedProfileAuthenticationData dataB = new PresharedProfileAuthenticationData(MockPresharedProfileAuthenticationFactory.PSK_ESN, profileB);
final EntityAuthenticationData dataA2 = EntityAuthenticationData.create(ctx, MslTestUtils.toMslObject(encoder, dataA));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsObject() {
final PresharedProfileAuthenticationData data = new PresharedProfileAuthenticationData(MockPresharedProfileAuthenticationFactory.PSK_ESN, MockPresharedProfileAuthenticationFactory.PROFILE);
assertFalse(data.equals(null));
assertFalse(data.equals(KEY_PSKID));
assertTrue(data.hashCode() != KEY_PSKID.hashCode());
}
/** MSL context. */
private static MslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
}
| 9,982 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/entityauth/EccAuthenticationDataTest.java | /**
* Copyright (c) 2016-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.io.IOException;
import org.json.JSONException;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* ECC entity authentication data unit tests.
*/
public class EccAuthenticationDataTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key entity authentication scheme. */
private static final String KEY_SCHEME = "scheme";
/** Key entity authentication data. */
private static final String KEY_AUTHDATA = "authdata";
/** Key entity identity. */
private static final String KEY_IDENTITY = "identity";
/** Key public key ID. */
private static final String KEY_PUBKEY_ID = "pubkeyid";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@BeforeClass
public static void setup() throws IOException, MslEncodingException, MslCryptoException {
ctx = new MockMslContext(EntityAuthenticationScheme.X509, false);
encoder = ctx.getMslEncoderFactory();
}
@AfterClass
public static void teardown() {
encoder = null;
ctx = null;
}
@Test
public void ctors() throws MslEncodingException, MslCryptoException, MslEncoderException {
final EccAuthenticationData data = new EccAuthenticationData(MockEccAuthenticationFactory.ECC_ESN, MockEccAuthenticationFactory.ECC_PUBKEY_ID);
assertEquals(MockEccAuthenticationFactory.ECC_ESN, data.getIdentity());
assertEquals(MockEccAuthenticationFactory.ECC_PUBKEY_ID, data.getPublicKeyId());
assertEquals(EntityAuthenticationScheme.ECC, data.getScheme());
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(authdata);
final byte[] encode = data.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final EccAuthenticationData moData = new EccAuthenticationData(authdata);
assertEquals(data.getIdentity(), moData.getIdentity());
assertEquals(data.getPublicKeyId(), moData.getPublicKeyId());
assertEquals(data.getScheme(), moData.getScheme());
final MslObject moAuthdata = moData.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(moAuthdata);
assertTrue(MslEncoderUtils.equalObjects(authdata, moAuthdata));
final byte[] moEncode = moData.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void mslObject() throws JSONException, MslCryptoException, MslEncoderException {
final EccAuthenticationData data = new EccAuthenticationData(MockEccAuthenticationFactory.ECC_ESN, MockEccAuthenticationFactory.ECC_PUBKEY_ID);
final MslObject mo = MslTestUtils.toMslObject(encoder, data);
assertEquals(EntityAuthenticationScheme.ECC.toString(), mo.getString(KEY_SCHEME));
final MslObject authdata = mo.getMslObject(KEY_AUTHDATA, encoder);
assertEquals(MockEccAuthenticationFactory.ECC_ESN, authdata.getString(KEY_IDENTITY));
assertEquals(MockEccAuthenticationFactory.ECC_PUBKEY_ID, authdata.get(KEY_PUBKEY_ID));
}
@Test
public void create() throws JSONException, MslEntityAuthException, MslEncodingException, MslCryptoException, MslEncoderException {
final EccAuthenticationData data = new EccAuthenticationData(MockEccAuthenticationFactory.ECC_ESN, MockEccAuthenticationFactory.ECC_PUBKEY_ID);
final byte[] encode = data.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = MslTestUtils.toMslObject(encoder, data);
final EntityAuthenticationData entitydata = EntityAuthenticationData.create(ctx, mo);
assertNotNull(entitydata);
assertTrue(entitydata instanceof EccAuthenticationData);
final EccAuthenticationData moData = (EccAuthenticationData)entitydata;
assertEquals(data.getIdentity(), moData.getIdentity());
assertEquals(data.getPublicKeyId(), moData.getPublicKeyId());
assertEquals(data.getScheme(), moData.getScheme());
final MslObject moAuthdata = moData.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(moAuthdata);
assertTrue(MslEncoderUtils.equalObjects(data.getAuthData(encoder, ENCODER_FORMAT), moAuthdata));
final byte[] moEncode = moData.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void missingIdentity() throws MslEncodingException, MslCryptoException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final EccAuthenticationData data = new EccAuthenticationData(MockEccAuthenticationFactory.ECC_ESN, MockEccAuthenticationFactory.ECC_PUBKEY_ID);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
authdata.remove(KEY_IDENTITY);
new EccAuthenticationData(authdata);
}
@Test
public void missingPubkeyId() throws MslEncodingException, MslCryptoException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final EccAuthenticationData data = new EccAuthenticationData(MockEccAuthenticationFactory.ECC_ESN, MockEccAuthenticationFactory.ECC_PUBKEY_ID);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
authdata.remove(KEY_PUBKEY_ID);
new EccAuthenticationData(authdata);
}
@Test
public void equalsIdentity() throws MslEncodingException, JSONException, MslEntityAuthException, MslCryptoException, MslEncoderException {
final String identityA = MockEccAuthenticationFactory.ECC_ESN + "A";
final String identityB = MockEccAuthenticationFactory.ECC_ESN + "B";
final EccAuthenticationData dataA = new EccAuthenticationData(identityA, MockEccAuthenticationFactory.ECC_PUBKEY_ID);
final EccAuthenticationData dataB = new EccAuthenticationData(identityB, MockEccAuthenticationFactory.ECC_PUBKEY_ID);
final EntityAuthenticationData dataA2 = EntityAuthenticationData.create(ctx, MslTestUtils.toMslObject(encoder, dataA));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsPubKeyId() throws MslEncodingException, JSONException, MslEntityAuthException, MslCryptoException, MslEncoderException {
final String pubkeyidA = MockEccAuthenticationFactory.ECC_PUBKEY_ID + "A";
final String pubkeyidB = MockEccAuthenticationFactory.ECC_PUBKEY_ID + "B";
final EccAuthenticationData dataA = new EccAuthenticationData(MockEccAuthenticationFactory.ECC_ESN, pubkeyidA);
final EccAuthenticationData dataB = new EccAuthenticationData(MockEccAuthenticationFactory.ECC_ESN, pubkeyidB);
final EntityAuthenticationData dataA2 = EntityAuthenticationData.create(ctx, MslTestUtils.toMslObject(encoder, dataA));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsObject() {
final EccAuthenticationData data = new EccAuthenticationData(MockEccAuthenticationFactory.ECC_ESN, MockEccAuthenticationFactory.ECC_PUBKEY_ID);
assertFalse(data.equals(null));
assertFalse(data.equals(KEY_IDENTITY));
assertTrue(data.hashCode() != KEY_IDENTITY.hashCode());
}
/** MSL context. */
private static MslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
}
| 9,983 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/entityauth/X509AuthenticationDataTest.java | /**
* Copyright (c) 2012-2018 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.cert.CertificateEncodingException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.util.Base64;
import com.netflix.msl.util.IOUtils;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* X.509 entity authentication data unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class X509AuthenticationDataTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** X.509 expired resource certificate. */
private static final String X509_EXPIRED_CERT = "/entityauth/expired.pem";
/** Key entity authentication scheme. */
private static final String KEY_SCHEME = "scheme";
/** Key entity authentication data. */
private static final String KEY_AUTHDATA = "authdata";
/** Key entity X.509 certificate. */
private static final String KEY_X509_CERT = "x509certificate";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@BeforeClass
public static void setup() throws IOException, MslEncodingException, MslCryptoException, CertificateException {
ctx = new MockMslContext(EntityAuthenticationScheme.X509, false);
encoder = ctx.getMslEncoderFactory();
expiredCert = IOUtils.readX509(X509_EXPIRED_CERT);
}
@AfterClass
public static void teardown() {
expiredCert = null;
encoder = null;
ctx = null;
}
@Test
public void ctors() throws MslCryptoException, MslEncodingException, MslEncoderException {
final X509AuthenticationData data = new X509AuthenticationData(MockX509AuthenticationFactory.X509_CERT);
assertEquals(MockX509AuthenticationFactory.X509_CERT, data.getX509Cert());
assertEquals(EntityAuthenticationScheme.X509, data.getScheme());
assertEquals(MockX509AuthenticationFactory.X509_CERT.getSubjectX500Principal().getName(), data.getIdentity());
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(authdata);
final byte[] encode = data.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final X509AuthenticationData moData = new X509AuthenticationData(authdata);
assertEquals(data.getX509Cert(), moData.getX509Cert());
assertEquals(data.getScheme(), moData.getScheme());
assertEquals(data.getIdentity(), moData.getIdentity());
final MslObject moAuthdata = moData.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(moAuthdata);
assertTrue(MslEncoderUtils.equalObjects(authdata, moAuthdata));
final byte[] moEncode = moData.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void encode() throws MslEncoderException, UnsupportedEncodingException, MslCryptoException, CertificateEncodingException {
final X509AuthenticationData data = new X509AuthenticationData(MockX509AuthenticationFactory.X509_CERT);
final MslObject mo = MslTestUtils.toMslObject(encoder, data);
assertEquals(EntityAuthenticationScheme.X509.name(), mo.getString(KEY_SCHEME));
final MslObject authdata = mo.getMslObject(KEY_AUTHDATA, encoder);
final String x509certificate = authdata.getString(KEY_X509_CERT);
assertArrayEquals(MockX509AuthenticationFactory.X509_CERT.getEncoded(), Base64.decode(x509certificate));
}
@Test
public void create() throws MslEncoderException, MslEntityAuthException, MslEncodingException, MslCryptoException {
final X509AuthenticationData data = new X509AuthenticationData(MockX509AuthenticationFactory.X509_CERT);
final byte[] encode = data.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = MslTestUtils.toMslObject(encoder, data);
final EntityAuthenticationData entitydata = EntityAuthenticationData.create(ctx, mo);
assertNotNull(entitydata);
assertTrue(entitydata instanceof X509AuthenticationData);
final X509AuthenticationData moData = (X509AuthenticationData)entitydata;
assertEquals(data.getX509Cert(), moData.getX509Cert());
assertEquals(data.getScheme(), moData.getScheme());
assertEquals(data.getIdentity(), moData.getIdentity());
final MslObject moAuthdata = moData.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(moAuthdata);
assertTrue(MslEncoderUtils.equalObjects(data.getAuthData(encoder, ENCODER_FORMAT), moAuthdata));
final byte[] moEncode = moData.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void missingX509Cert() throws MslEncodingException, MslCryptoException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final X509AuthenticationData data = new X509AuthenticationData(MockX509AuthenticationFactory.X509_CERT);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
authdata.remove(KEY_X509_CERT);
new X509AuthenticationData(authdata);
}
@Test
public void corruptX509Cert() throws MslEncoderException, MslEncodingException, MslCryptoException {
thrown.expect(MslCryptoException.class);
thrown.expectMslError(MslError.X509CERT_PARSE_ERROR);
final X509AuthenticationData data = new X509AuthenticationData(MockX509AuthenticationFactory.X509_CERT);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
final byte[] x509raw = Base64.decode(authdata.getString(KEY_X509_CERT));
++x509raw[0];
authdata.put(KEY_X509_CERT, Base64.encode(x509raw));
new X509AuthenticationData(authdata);
}
@Test
public void equalsIdentity() throws MslEncodingException, MslEncoderException, MslEntityAuthException, MslCryptoException {
final X509AuthenticationData dataA = new X509AuthenticationData(MockX509AuthenticationFactory.X509_CERT);
final X509AuthenticationData dataB = new X509AuthenticationData(expiredCert);
final EntityAuthenticationData dataA2 = EntityAuthenticationData.create(ctx, MslTestUtils.toMslObject(encoder, dataA));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsObject() throws MslCryptoException {
final X509AuthenticationData data = new X509AuthenticationData(MockX509AuthenticationFactory.X509_CERT);
assertFalse(data.equals(null));
assertFalse(data.equals(KEY_X509_CERT));
assertTrue(data.hashCode() != KEY_X509_CERT.hashCode());
}
/** MSL context. */
private static MslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
/** Expired X.509 certificate. */
private static X509Certificate expiredCert;
}
| 9,984 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/entityauth/MasterTokenProtectedAuthenticationFactoryTest.java | /**
* Copyright (c) 2015-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.tokens.MasterToken;
import com.netflix.msl.util.MockAuthenticationUtils;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* Master token protected authentication factory unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class MasterTokenProtectedAuthenticationFactoryTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key master token. */
protected static final String KEY_MASTER_TOKEN = "mastertoken";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
private static final String IDENTITY = "identity";
/** MSL context. */
private static MockMslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
/** Authentication utilities. */
private static MockAuthenticationUtils authutils;
/** Entity authentication factory. */
private static EntityAuthenticationFactory factory;
/** Master token. */
private static MasterToken masterToken;
/** Encapsulated entity authentication data. */
private static EntityAuthenticationData eAuthdata;
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException {
ctx = new MockMslContext(EntityAuthenticationScheme.NONE, false);
encoder = ctx.getMslEncoderFactory();
authutils = new MockAuthenticationUtils();
factory = new MasterTokenProtectedAuthenticationFactory(authutils);
ctx.addEntityAuthenticationFactory(factory);
masterToken = MslTestUtils.getMasterToken(ctx, 1L, 1L);
eAuthdata = new UnauthenticatedAuthenticationData(IDENTITY);
}
@AfterClass
public static void teardown() {
eAuthdata = null;
masterToken = null;
factory = null;
authutils = null;
encoder = null;
ctx = null;
}
@After
public void reset() {
authutils.reset();
}
@Test
public void createData() throws MslCryptoException, MslEntityAuthException, MslEncodingException, MslEncoderException {
final MasterTokenProtectedAuthenticationData data = new MasterTokenProtectedAuthenticationData(ctx, masterToken, eAuthdata);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
final EntityAuthenticationData moAuthdata = factory.createData(ctx, authdata);
assertNotNull(moAuthdata);
assertTrue(moAuthdata instanceof MasterTokenProtectedAuthenticationData);
final MasterTokenProtectedAuthenticationData moData = (MasterTokenProtectedAuthenticationData)moAuthdata;
assertEquals(data.getIdentity(), moData.getIdentity());
assertEquals(data.getScheme(), moData.getScheme());
assertEquals(data.getEncapsulatedAuthdata(), moData.getEncapsulatedAuthdata());
}
@Test
public void encodeException() throws MslCryptoException, MslEntityAuthException, MslEncodingException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final MasterTokenProtectedAuthenticationData data = new MasterTokenProtectedAuthenticationData(ctx, masterToken, eAuthdata);
final MslObject entityAuthMo = data.getAuthData(encoder, ENCODER_FORMAT);
entityAuthMo.remove(KEY_MASTER_TOKEN);
factory.createData(ctx, entityAuthMo);
}
@Test
public void cryptoContext() throws MslCryptoException, MslEntityAuthException {
final MasterTokenProtectedAuthenticationData data = new MasterTokenProtectedAuthenticationData(ctx, masterToken, eAuthdata);
final ICryptoContext cryptoContext = factory.getCryptoContext(ctx, data);
assertNotNull(cryptoContext);
final EntityAuthenticationFactory eFactory = ctx.getEntityAuthenticationFactory(eAuthdata.getScheme());
final ICryptoContext eCryptoContext = eFactory.getCryptoContext(ctx, eAuthdata);
assertNotNull(eCryptoContext);
final byte[] plaintext = new byte[32];
ctx.getRandom().nextBytes(plaintext);
final byte[] ciphertext = cryptoContext.encrypt(plaintext, encoder, ENCODER_FORMAT);
final byte[] eCiphertext = eCryptoContext.encrypt(plaintext, encoder, ENCODER_FORMAT);
final byte[] decrypted = cryptoContext.decrypt(eCiphertext, encoder);
final byte[] eDecrypted = eCryptoContext.decrypt(ciphertext, encoder);
assertArrayEquals(plaintext, decrypted);
assertArrayEquals(plaintext, eDecrypted);
final byte[] signature = cryptoContext.sign(plaintext, encoder, ENCODER_FORMAT);
final byte[] eSignature = eCryptoContext.sign(plaintext, encoder, ENCODER_FORMAT);
assertTrue(cryptoContext.verify(plaintext, eSignature, encoder));
assertTrue(eCryptoContext.verify(plaintext, signature, encoder));
}
@Test
public void unsupportedEncapsulatedScheme() throws MslEncodingException, MslCryptoException, MslEntityAuthException {
thrown.expect(MslEntityAuthException.class);
thrown.expectMslError(MslError.ENTITYAUTH_FACTORY_NOT_FOUND);
final MockMslContext ctx = new MockMslContext(EntityAuthenticationScheme.NONE, false);
ctx.removeEntityAuthenticationFactory(EntityAuthenticationScheme.NONE);
final MasterTokenProtectedAuthenticationData data = new MasterTokenProtectedAuthenticationData(ctx, masterToken, eAuthdata);
factory.getCryptoContext(ctx, data);
}
@Test
public void revoked() throws MslCryptoException, MslEntityAuthException {
thrown.expect(MslEntityAuthException.class);
thrown.expectMslError(MslError.ENTITY_REVOKED);
authutils.revokeEntity(IDENTITY);
final MasterTokenProtectedAuthenticationData data = new MasterTokenProtectedAuthenticationData(ctx, masterToken, eAuthdata);
factory.getCryptoContext(ctx, data);
}
@Test
public void schemeNotPermitted() throws MslCryptoException, MslEntityAuthException {
thrown.expect(MslEntityAuthException.class);
thrown.expectMslError(MslError.INCORRECT_ENTITYAUTH_DATA);
authutils.disallowScheme(IDENTITY, EntityAuthenticationScheme.MT_PROTECTED);
final MasterTokenProtectedAuthenticationData data = new MasterTokenProtectedAuthenticationData(ctx, masterToken, eAuthdata);
factory.getCryptoContext(ctx, data);
}
}
| 9,985 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/entityauth/PresharedAuthenticationDataTest.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.io.IOException;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* Preshared keys entity authentication data unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class PresharedAuthenticationDataTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key entity authentication scheme. */
private static final String KEY_SCHEME = "scheme";
/** Key entity authentication data. */
private static final String KEY_AUTHDATA = "authdata";
/** Key entity identity. */
private static final String KEY_IDENTITY = "identity";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@BeforeClass
public static void setup() throws IOException, MslEncodingException, MslCryptoException {
ctx = new MockMslContext(EntityAuthenticationScheme.X509, false);
encoder = ctx.getMslEncoderFactory();
}
@AfterClass
public static void teardown() {
encoder = null;
ctx = null;
}
@Test
public void ctors() throws MslEncodingException, MslEncoderException {
final PresharedAuthenticationData data = new PresharedAuthenticationData(MockPresharedAuthenticationFactory.PSK_ESN);
assertEquals(MockPresharedAuthenticationFactory.PSK_ESN, data.getIdentity());
assertEquals(EntityAuthenticationScheme.PSK, data.getScheme());
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(authdata);
final byte[] encode = data.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final PresharedAuthenticationData moData = new PresharedAuthenticationData(authdata);
assertEquals(data.getIdentity(), moData.getIdentity());
assertEquals(data.getScheme(), moData.getScheme());
final MslObject moAuthdata = moData.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(moAuthdata);
assertTrue(MslEncoderUtils.equalObjects(authdata, moAuthdata));
final byte[] moEncode = moData.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void mslObject() throws MslEncoderException {
final PresharedAuthenticationData data = new PresharedAuthenticationData(MockPresharedAuthenticationFactory.PSK_ESN);
final MslObject mo = MslTestUtils.toMslObject(encoder, data);
assertEquals(EntityAuthenticationScheme.PSK.toString(), mo.getString(KEY_SCHEME));
final MslObject authdata = mo.getMslObject(KEY_AUTHDATA, encoder);
assertEquals(MockPresharedAuthenticationFactory.PSK_ESN, authdata.getString(KEY_IDENTITY));
}
@Test
public void create() throws MslEncoderException, MslEntityAuthException, MslEncodingException, MslCryptoException {
final PresharedAuthenticationData data = new PresharedAuthenticationData(MockPresharedAuthenticationFactory.PSK_ESN);
final byte[] encode = data.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = MslTestUtils.toMslObject(encoder, data);
final EntityAuthenticationData entitydata = EntityAuthenticationData.create(ctx, mo);
assertNotNull(entitydata);
assertTrue(entitydata instanceof PresharedAuthenticationData);
final PresharedAuthenticationData moData = (PresharedAuthenticationData)entitydata;
assertEquals(data.getIdentity(), moData.getIdentity());
assertEquals(data.getScheme(), moData.getScheme());
final MslObject moAuthdata = moData.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(moAuthdata);
assertTrue(MslEncoderUtils.equalObjects(data.getAuthData(encoder, ENCODER_FORMAT), moAuthdata));
final byte[] moEncode = moData.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void missingIdentity() throws MslEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final PresharedAuthenticationData data = new PresharedAuthenticationData(MockPresharedAuthenticationFactory.PSK_ESN);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
authdata.remove(KEY_IDENTITY);
new PresharedAuthenticationData(authdata);
}
@Test
public void equalsIdentity() throws MslEncodingException, MslEncoderException, MslEntityAuthException, MslCryptoException {
final String identityA = MockPresharedAuthenticationFactory.PSK_ESN + "A";
final String identityB = MockPresharedAuthenticationFactory.PSK_ESN + "B";
final PresharedAuthenticationData dataA = new PresharedAuthenticationData(identityA);
final PresharedAuthenticationData dataB = new PresharedAuthenticationData(identityB);
final EntityAuthenticationData dataA2 = EntityAuthenticationData.create(ctx, MslTestUtils.toMslObject(encoder, dataA));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsObject() {
final PresharedAuthenticationData data = new PresharedAuthenticationData(MockPresharedAuthenticationFactory.PSK_ESN);
assertFalse(data.equals(null));
assertFalse(data.equals(KEY_IDENTITY));
assertTrue(data.hashCode() != KEY_IDENTITY.hashCode());
}
/** MSL context. */
private static MslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
}
| 9,986 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/entityauth/UnauthenticatedSuffixedAuthenticationDataTest.java | /**
* Copyright (c) 2015-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.io.IOException;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* Unauthenticated suffixed entity authentication data unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class UnauthenticatedSuffixedAuthenticationDataTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key entity authentication scheme. */
private static final String KEY_SCHEME = "scheme";
/** Key entity authentication data. */
private static final String KEY_AUTHDATA = "authdata";
/** Key entity root. */
private static final String KEY_ROOT = "root";
/** Key entity suffix. */
private static final String KEY_SUFFIX = "suffix";
/** Identity concatenation character. */
private static final String CONCAT_CHAR = ".";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
private static final String ROOT = "root";
private static final String SUFFIX = "suffix";
@BeforeClass
public static void setup() throws IOException, MslEncodingException, MslCryptoException {
ctx = new MockMslContext(EntityAuthenticationScheme.NONE_SUFFIXED, false);
encoder = ctx.getMslEncoderFactory();
}
@AfterClass
public static void teardown() {
encoder = null;
ctx = null;
}
@Test
public void ctors() throws MslEncodingException, MslEncoderException {
final UnauthenticatedSuffixedAuthenticationData data = new UnauthenticatedSuffixedAuthenticationData(ROOT, SUFFIX);
assertEquals(ROOT + CONCAT_CHAR + SUFFIX, data.getIdentity());
assertEquals(ROOT, data.getRoot());
assertEquals(SUFFIX, data.getSuffix());
assertEquals(EntityAuthenticationScheme.NONE_SUFFIXED, data.getScheme());
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(authdata);
final byte[] encode = data.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final UnauthenticatedSuffixedAuthenticationData moData = new UnauthenticatedSuffixedAuthenticationData(authdata);
assertEquals(data.getIdentity(), moData.getIdentity());
assertEquals(data.getRoot(), moData.getRoot());
assertEquals(data.getSuffix(), moData.getSuffix());
assertEquals(data.getScheme(), moData.getScheme());
final MslObject moAuthdata = moData.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(moAuthdata);
assertTrue(MslEncoderUtils.equalObjects(authdata, moAuthdata));
final byte[] moEncode = moData.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void encode() throws MslEncoderException {
final UnauthenticatedSuffixedAuthenticationData data = new UnauthenticatedSuffixedAuthenticationData(ROOT, SUFFIX);
final MslObject mo = MslTestUtils.toMslObject(encoder, data);
assertEquals(EntityAuthenticationScheme.NONE_SUFFIXED.toString(), mo.getString(KEY_SCHEME));
final MslObject authdata = mo.getMslObject(KEY_AUTHDATA, encoder);
assertEquals(ROOT, authdata.getString(KEY_ROOT));
assertEquals(SUFFIX, authdata.getString(KEY_SUFFIX));
}
@Test
public void create() throws MslEncoderException, MslEntityAuthException, MslEncodingException, MslCryptoException {
final UnauthenticatedSuffixedAuthenticationData data = new UnauthenticatedSuffixedAuthenticationData(ROOT, SUFFIX);
final byte[] encode = data.toMslEncoding(encoder, ENCODER_FORMAT);
final MslObject mo = MslTestUtils.toMslObject(encoder, data);
final EntityAuthenticationData entitydata = EntityAuthenticationData.create(ctx, mo);
assertNotNull(entitydata);
assertTrue(entitydata instanceof UnauthenticatedSuffixedAuthenticationData);
final UnauthenticatedSuffixedAuthenticationData moData = (UnauthenticatedSuffixedAuthenticationData)entitydata;
assertEquals(data.getIdentity(), moData.getIdentity());
assertEquals(data.getRoot(), moData.getRoot());
assertEquals(data.getSuffix(), moData.getSuffix());
assertEquals(data.getScheme(), moData.getScheme());
final MslObject moAuthdata = moData.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(moAuthdata);
assertTrue(MslEncoderUtils.equalObjects(data.getAuthData(encoder, ENCODER_FORMAT), moAuthdata));
final byte[] moEncode = moData.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
assertArrayEquals(encode, moEncode);
}
@Test
public void missingRoot() throws MslEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final UnauthenticatedSuffixedAuthenticationData data = new UnauthenticatedSuffixedAuthenticationData(ROOT, SUFFIX);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
authdata.remove(KEY_ROOT);
new UnauthenticatedSuffixedAuthenticationData(authdata);
}
@Test
public void missingSuffix() throws MslEncodingException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final UnauthenticatedSuffixedAuthenticationData data = new UnauthenticatedSuffixedAuthenticationData(ROOT, SUFFIX);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
authdata.remove(KEY_SUFFIX);
new UnauthenticatedSuffixedAuthenticationData(authdata);
}
@Test
public void equalsRoot() throws MslEncodingException, MslEncoderException, MslEntityAuthException, MslCryptoException {
final UnauthenticatedSuffixedAuthenticationData dataA = new UnauthenticatedSuffixedAuthenticationData(ROOT + "A", SUFFIX);
final UnauthenticatedSuffixedAuthenticationData dataB = new UnauthenticatedSuffixedAuthenticationData(ROOT + "B", SUFFIX);
final EntityAuthenticationData dataA2 = EntityAuthenticationData.create(ctx, MslTestUtils.toMslObject(encoder, dataA));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsSuffix() throws MslEncodingException, MslEncoderException, MslEntityAuthException, MslCryptoException {
final UnauthenticatedSuffixedAuthenticationData dataA = new UnauthenticatedSuffixedAuthenticationData(ROOT, SUFFIX + "A");
final UnauthenticatedSuffixedAuthenticationData dataB = new UnauthenticatedSuffixedAuthenticationData(ROOT, SUFFIX + "B");
final EntityAuthenticationData dataA2 = EntityAuthenticationData.create(ctx, MslTestUtils.toMslObject(encoder, dataA));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsObject() {
final UnauthenticatedSuffixedAuthenticationData data = new UnauthenticatedSuffixedAuthenticationData(ROOT, SUFFIX);
assertFalse(data.equals(null));
assertFalse(data.equals(ROOT));
assertTrue(data.hashCode() != ROOT.hashCode());
}
/** MSL context. */
private static MslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
}
| 9,987 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/entityauth/EccAuthenticationFactoryTest.java | /**
* Copyright (c) 2016-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import org.json.JSONException;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.util.MockAuthenticationUtils;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* ECC asymmetric keys entity authentication factory unit tests.
*
*/
public class EccAuthenticationFactoryTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key entity identity. */
private static final String KEY_IDENTITY = "identity";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
/** Authentication utilities. */
private static MockAuthenticationUtils authutils;
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException {
ctx = new MockMslContext(EntityAuthenticationScheme.ECC, false);
encoder = ctx.getMslEncoderFactory();
final MockEccStore eccStore = new MockEccStore();
eccStore.addPublicKey(MockEccAuthenticationFactory.ECC_PUBKEY_ID, MockEccAuthenticationFactory.ECC_PUBKEY);
authutils = new MockAuthenticationUtils();
factory = new EccAuthenticationFactory(eccStore, authutils);
ctx.addEntityAuthenticationFactory(factory);
}
@AfterClass
public static void teardown() {
factory = null;
authutils = null;
encoder = null;
ctx = null;
}
@After
public void reset() {
authutils.reset();
}
@Test
public void createData() throws MslEncodingException, MslEntityAuthException, JSONException, MslCryptoException, MslEncoderException {
final EccAuthenticationData data = new EccAuthenticationData(MockEccAuthenticationFactory.ECC_ESN, MockEccAuthenticationFactory.ECC_PUBKEY_ID);
final MslObject entityAuthMo = data.getAuthData(encoder, ENCODER_FORMAT);
final EntityAuthenticationData authdata = factory.createData(ctx, entityAuthMo);
assertNotNull(authdata);
assertTrue(authdata instanceof EccAuthenticationData);
final MslObject dataMo = MslTestUtils.toMslObject(encoder, data);
final MslObject authdataMo = MslTestUtils.toMslObject(encoder, authdata);
assertTrue(MslEncoderUtils.equalObjects(dataMo, authdataMo));
}
@Test
public void encodeException() throws MslEncodingException, MslEntityAuthException, MslCryptoException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final EccAuthenticationData data = new EccAuthenticationData(MockEccAuthenticationFactory.ECC_ESN, MockEccAuthenticationFactory.ECC_PUBKEY_ID);
final MslObject entityAuthMo = data.getAuthData(encoder, ENCODER_FORMAT);
entityAuthMo.remove(KEY_IDENTITY);
factory.createData(ctx, entityAuthMo);
}
@Test
public void cryptoContext() throws MslEntityAuthException, MslCryptoException {
final EccAuthenticationData data = new EccAuthenticationData(MockEccAuthenticationFactory.ECC_ESN, MockEccAuthenticationFactory.ECC_PUBKEY_ID);
final ICryptoContext cryptoContext = factory.getCryptoContext(ctx, data);
assertNotNull(cryptoContext);
}
@Test
public void unknownKeyId() throws MslEntityAuthException, MslCryptoException {
thrown.expect(MslEntityAuthException.class);
thrown.expectMslError(MslError.ECC_PUBLICKEY_NOT_FOUND);
final EccAuthenticationData data = new EccAuthenticationData(MockEccAuthenticationFactory.ECC_ESN, "x");
factory.getCryptoContext(ctx, data);
}
@Test
public void localCryptoContext() throws MslCryptoException, MslEntityAuthException {
final MockEccStore eccStore = new MockEccStore();
eccStore.addPrivateKey(MockEccAuthenticationFactory.ECC_PUBKEY_ID, MockEccAuthenticationFactory.ECC_PRIVKEY);
final EntityAuthenticationFactory factory = new EccAuthenticationFactory(MockEccAuthenticationFactory.ECC_PUBKEY_ID, eccStore, authutils);
final EccAuthenticationData data = new EccAuthenticationData(MockEccAuthenticationFactory.ECC_ESN, MockEccAuthenticationFactory.ECC_PUBKEY_ID);
final ICryptoContext cryptoContext = factory.getCryptoContext(ctx, data);
final byte[] plaintext = new byte[16];
ctx.getRandom().nextBytes(plaintext);
cryptoContext.sign(plaintext, encoder, ENCODER_FORMAT);
}
@Test
public void missingPrivateKey() throws MslCryptoException, MslEntityAuthException {
thrown.expect(MslEntityAuthException.class);
thrown.expectMslError(MslError.ECC_PRIVATEKEY_NOT_FOUND);
final MockEccStore eccStore = new MockEccStore();
eccStore.addPublicKey(MockEccAuthenticationFactory.ECC_PUBKEY_ID, MockEccAuthenticationFactory.ECC_PUBKEY);
final EntityAuthenticationFactory factory = new EccAuthenticationFactory(MockEccAuthenticationFactory.ECC_PUBKEY_ID, eccStore, authutils);
final EccAuthenticationData data = new EccAuthenticationData(MockEccAuthenticationFactory.ECC_ESN, MockEccAuthenticationFactory.ECC_PUBKEY_ID);
factory.getCryptoContext(ctx, data);
}
@Test
public void revoked() throws MslEntityAuthException, MslCryptoException {
thrown.expect(MslEntityAuthException.class);
thrown.expectMslError(MslError.ENTITY_REVOKED);
authutils.revokeEntity(MockEccAuthenticationFactory.ECC_ESN);
final EccAuthenticationData data = new EccAuthenticationData(MockEccAuthenticationFactory.ECC_ESN, "x");
factory.getCryptoContext(ctx, data);
}
/** MSL context. */
private static MockMslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
/** Entity authentication factory. */
private static EntityAuthenticationFactory factory;
}
| 9,988 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/entityauth/PresharedProfileAuthenticationFactoryTest.java | /**
* Copyright (c) 2014-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.util.MockAuthenticationUtils;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* Pre-shared keys profile entity authentication factory unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class PresharedProfileAuthenticationFactoryTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key entity preshared keys identity. */
private static final String KEY_PSKID = "pskid";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException {
ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = ctx.getMslEncoderFactory();
final MockKeySetStore store = new MockKeySetStore();
store.addKeys(MockPresharedProfileAuthenticationFactory.PSK_ESN, MockPresharedProfileAuthenticationFactory.KPE, MockPresharedProfileAuthenticationFactory.KPH, MockPresharedProfileAuthenticationFactory.KPW);
authutils = new MockAuthenticationUtils();
factory = new PresharedProfileAuthenticationFactory(store, authutils);
ctx.addEntityAuthenticationFactory(factory);
}
@AfterClass
public static void teardown() {
factory = null;
authutils = null;
encoder = null;
ctx = null;
}
@After
public void reset() {
authutils.reset();
}
@Test
public void createData() throws MslCryptoException, MslEncodingException, MslEntityAuthException, MslEncoderException {
final PresharedProfileAuthenticationData data = new PresharedProfileAuthenticationData(MockPresharedProfileAuthenticationFactory.PSK_ESN, MockPresharedProfileAuthenticationFactory.PROFILE);
final MslObject entityAuthMo = data.getAuthData(encoder, ENCODER_FORMAT);
final EntityAuthenticationData authdata = factory.createData(ctx, entityAuthMo);
assertNotNull(authdata);
assertTrue(authdata instanceof PresharedProfileAuthenticationData);
final MslObject dataMo = MslTestUtils.toMslObject(encoder, data);
final MslObject authdataMo = MslTestUtils.toMslObject(encoder, authdata);
assertTrue(MslEncoderUtils.equalObjects(dataMo, authdataMo));
}
@Test
public void encodeException() throws MslCryptoException, MslEncodingException, MslEntityAuthException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final PresharedProfileAuthenticationData data = new PresharedProfileAuthenticationData(MockPresharedProfileAuthenticationFactory.PSK_ESN, MockPresharedProfileAuthenticationFactory.PROFILE);
final MslObject entityAuthMo = data.getAuthData(encoder, ENCODER_FORMAT);
entityAuthMo.remove(KEY_PSKID);
factory.createData(ctx, entityAuthMo);
}
@Test
public void cryptoContext() throws MslCryptoException, MslEntityAuthException {
final PresharedProfileAuthenticationData data = new PresharedProfileAuthenticationData(MockPresharedProfileAuthenticationFactory.PSK_ESN, MockPresharedProfileAuthenticationFactory.PROFILE);
final ICryptoContext cryptoContext = factory.getCryptoContext(ctx, data);
assertNotNull(cryptoContext);
}
@Test
public void unknownEsn() throws MslCryptoException, MslEntityAuthException {
thrown.expect(MslEntityAuthException.class);
thrown.expectMslError(MslError.ENTITY_NOT_FOUND);
final PresharedProfileAuthenticationData data = new PresharedProfileAuthenticationData(MockPresharedProfileAuthenticationFactory.PSK_ESN2, MockPresharedProfileAuthenticationFactory.PROFILE);
factory.getCryptoContext(ctx, data);
}
@Test
public void revoked() throws MslCryptoException, MslEntityAuthException {
thrown.expect(MslEntityAuthException.class);
thrown.expectMslError(MslError.ENTITY_REVOKED);
authutils.revokeEntity(MockPresharedProfileAuthenticationFactory.PSK_ESN);
final PresharedProfileAuthenticationData data = new PresharedProfileAuthenticationData(MockPresharedProfileAuthenticationFactory.PSK_ESN, MockPresharedProfileAuthenticationFactory.PROFILE);
factory.getCryptoContext(ctx, data);
}
/** MSL context. */
private static MockMslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
/** Authentication utilities. */
private static MockAuthenticationUtils authutils;
/** Entity authentication factory. */
private static EntityAuthenticationFactory factory;
}
| 9,989 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/entityauth/PresharedAuthenticationFactoryTest.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.util.MockAuthenticationUtils;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* Pre-shared keys entity authentication factory unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class PresharedAuthenticationFactoryTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key entity identity. */
private static final String KEY_IDENTITY = "identity";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
/** Authentication utilities. */
private static MockAuthenticationUtils authutils;
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException {
ctx = new MockMslContext(EntityAuthenticationScheme.PSK, false);
encoder = ctx.getMslEncoderFactory();
final MockKeySetStore store = new MockKeySetStore();
store.addKeys(MockPresharedAuthenticationFactory.PSK_ESN, MockPresharedAuthenticationFactory.KPE, MockPresharedAuthenticationFactory.KPH, MockPresharedAuthenticationFactory.KPW);
authutils = new MockAuthenticationUtils();
factory = new PresharedAuthenticationFactory(store, authutils);
ctx.addEntityAuthenticationFactory(factory);
}
@AfterClass
public static void teardown() {
factory = null;
authutils = null;
encoder = null;
ctx = null;
}
@After
public void reset() {
authutils.reset();
}
@Test
public void createData() throws MslCryptoException, MslEncodingException, MslEntityAuthException, MslEncoderException {
final PresharedAuthenticationData data = new PresharedAuthenticationData(MockPresharedAuthenticationFactory.PSK_ESN);
final MslObject entityAuthMo = data.getAuthData(encoder, ENCODER_FORMAT);
final EntityAuthenticationData authdata = factory.createData(ctx, entityAuthMo);
assertNotNull(authdata);
assertTrue(authdata instanceof PresharedAuthenticationData);
final MslObject dataMo = MslTestUtils.toMslObject(encoder, data);
final MslObject authdataMo = MslTestUtils.toMslObject(encoder, authdata);
assertTrue(MslEncoderUtils.equalObjects(dataMo, authdataMo));
}
@Test
public void encodeException() throws MslCryptoException, MslEncodingException, MslEntityAuthException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final PresharedAuthenticationData data = new PresharedAuthenticationData(MockPresharedAuthenticationFactory.PSK_ESN);
final MslObject entityAuthMo = data.getAuthData(encoder, ENCODER_FORMAT);
entityAuthMo.remove(KEY_IDENTITY);
factory.createData(ctx, entityAuthMo);
}
@Test
public void cryptoContext() throws MslCryptoException, MslEntityAuthException {
final PresharedAuthenticationData data = new PresharedAuthenticationData(MockPresharedAuthenticationFactory.PSK_ESN);
final ICryptoContext cryptoContext = factory.getCryptoContext(ctx, data);
assertNotNull(cryptoContext);
}
@Test
public void unknownEsn() throws MslCryptoException, MslEntityAuthException {
thrown.expect(MslEntityAuthException.class);
thrown.expectMslError(MslError.ENTITY_NOT_FOUND);
final PresharedAuthenticationData data = new PresharedAuthenticationData(MockPresharedAuthenticationFactory.PSK_ESN2);
factory.getCryptoContext(ctx, data);
}
@Test
public void revoked() throws MslCryptoException, MslEntityAuthException {
thrown.expect(MslEntityAuthException.class);
thrown.expectMslError(MslError.ENTITY_REVOKED);
authutils.revokeEntity(MockPresharedAuthenticationFactory.PSK_ESN);
final PresharedAuthenticationData data = new PresharedAuthenticationData(MockPresharedAuthenticationFactory.PSK_ESN);
factory.getCryptoContext(ctx, data);
}
/** MSL context. */
private static MockMslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
/** Entity authentication factory. */
private static EntityAuthenticationFactory factory;
}
| 9,990 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/entityauth/MasterTokenProtectedAuthenticationDataTest.java | /**
* Copyright (c) 2015-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslMasterTokenException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.crypto.SessionCryptoContext;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.tokens.MasterToken;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* Master token protected entity authentication data unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class MasterTokenProtectedAuthenticationDataTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key entity authentication scheme. */
private static final String KEY_SCHEME = "scheme";
/** Key entity authentication data. */
private static final String KEY_AUTHDATA = "authdata";
/** Key master token. */
protected static final String KEY_MASTER_TOKEN = "mastertoken";
/** Key authentication data. */
protected static final String KEY_AUTHENTICATION_DATA = "authdata";
/** Key signature. */
protected static final String KEY_SIGNATURE = "signature";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
private static final String IDENTITY = "identity";
/** MSL context. */
private static MslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
/** Master token. */
private static MasterToken masterToken;
/** Encapsulated entity authentication data. */
private static EntityAuthenticationData eAuthdata;
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException {
ctx = new MockMslContext(EntityAuthenticationScheme.X509, false);
encoder = ctx.getMslEncoderFactory();
masterToken = MslTestUtils.getMasterToken(ctx, 1L, 1L);
eAuthdata = new UnauthenticatedAuthenticationData(IDENTITY);
}
@AfterClass
public static void teardown() {
eAuthdata = null;
masterToken = null;
encoder = null;
ctx = null;
}
@Test
public void ctors() throws MslCryptoException, MslEntityAuthException, MslEncodingException, MslEncoderException {
final MasterTokenProtectedAuthenticationData data = new MasterTokenProtectedAuthenticationData(ctx, masterToken, eAuthdata);
assertEquals(eAuthdata.getIdentity(), data.getIdentity());
assertEquals(EntityAuthenticationScheme.MT_PROTECTED, data.getScheme());
assertEquals(eAuthdata, data.getEncapsulatedAuthdata());
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(authdata);
final byte[] encode = data.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(encode);
final MasterTokenProtectedAuthenticationData moData = new MasterTokenProtectedAuthenticationData(ctx, authdata);
assertEquals(data.getIdentity(), moData.getIdentity());
assertEquals(data.getScheme(), moData.getScheme());
assertEquals(data.getEncapsulatedAuthdata(), moData.getEncapsulatedAuthdata());
assertEquals(data, moData);
final MslObject moAuthdata = moData.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(moAuthdata);
// The authdata will not be equal as it is regenerated.
final byte[] moEncode = moData.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
// The encode will not be equal as it is regenerated.
}
@Test
public void mslObject() throws MslMasterTokenException, MslCryptoException, MslEntityAuthException, MslEncoderException, MslEncodingException {
final MasterTokenProtectedAuthenticationData data = new MasterTokenProtectedAuthenticationData(ctx, masterToken, eAuthdata);
final MslObject mo = MslTestUtils.toMslObject(encoder, data);
assertEquals(EntityAuthenticationScheme.MT_PROTECTED.toString(), mo.getString(KEY_SCHEME));
final MslObject authdata = mo.getMslObject(KEY_AUTHDATA, encoder);
final MslObject masterTokenMo = MslTestUtils.toMslObject(encoder, masterToken);
final MslObject moMasterTokenMo = authdata.getMslObject(KEY_MASTER_TOKEN, encoder);
assertTrue(MslEncoderUtils.equalObjects(masterTokenMo, moMasterTokenMo));
final byte[] ciphertext = authdata.getBytes(KEY_AUTHDATA);
final byte[] signature = authdata.getBytes(KEY_SIGNATURE);
assertNotNull(signature);
// Signature and ciphertext may not be predictable depending on the
// master token encryption and signature algorithms.
final ICryptoContext cryptoContext = new SessionCryptoContext(ctx, masterToken);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject moEAuthdataMo = encoder.parseObject(plaintext);
final EntityAuthenticationData moEAuthdata = EntityAuthenticationData.create(ctx, moEAuthdataMo);
assertEquals(eAuthdata, moEAuthdata);
}
@Test
public void create() throws MslCryptoException, MslEntityAuthException, MslEncodingException, MslEncoderException, MslMasterTokenException {
final MasterTokenProtectedAuthenticationData data = new MasterTokenProtectedAuthenticationData(ctx, masterToken, eAuthdata);
final MslObject mo = MslTestUtils.toMslObject(encoder, data);
final EntityAuthenticationData entitydata = EntityAuthenticationData.create(ctx, mo);
assertNotNull(entitydata);
assertTrue(entitydata instanceof MasterTokenProtectedAuthenticationData);
final MasterTokenProtectedAuthenticationData moData = (MasterTokenProtectedAuthenticationData)entitydata;
assertEquals(data.getIdentity(), moData.getIdentity());
assertEquals(data.getScheme(), moData.getScheme());
assertEquals(data.getEncapsulatedAuthdata(), moData.getEncapsulatedAuthdata());
assertEquals(data, moData);
final MslObject moAuthdata = moData.getAuthData(encoder, ENCODER_FORMAT);
assertNotNull(moAuthdata);
// The authdata will not be equal as it is regenerated.
final MslObject masterTokenMo = MslTestUtils.toMslObject(encoder, masterToken);
final MslObject moMasterTokenMo = moAuthdata.getMslObject(KEY_MASTER_TOKEN, encoder);
assertTrue(MslEncoderUtils.equalObjects(masterTokenMo, moMasterTokenMo));
final byte[] ciphertext = moAuthdata.getBytes(KEY_AUTHDATA);
final byte[] signature = moAuthdata.getBytes(KEY_SIGNATURE);
assertNotNull(signature);
// Signature and ciphertext may not be predictable depending on the
// master token encryption and signature algorithms.
final ICryptoContext cryptoContext = new SessionCryptoContext(ctx, masterToken);
final byte[] plaintext = cryptoContext.decrypt(ciphertext, encoder);
final MslObject moEAuthdataMo = encoder.parseObject(plaintext);
final EntityAuthenticationData moEAuthdata = EntityAuthenticationData.create(ctx, moEAuthdataMo);
assertEquals(eAuthdata, moEAuthdata);
final byte[] moEncode = moData.toMslEncoding(encoder, ENCODER_FORMAT);
assertNotNull(moEncode);
// The encode will not be equal as it is regenerated.
}
@Test
public void missingMasterToken() throws MslEncodingException, MslCryptoException, MslEntityAuthException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final MasterTokenProtectedAuthenticationData data = new MasterTokenProtectedAuthenticationData(ctx, masterToken, eAuthdata);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
authdata.remove(KEY_MASTER_TOKEN);
new MasterTokenProtectedAuthenticationData(ctx, authdata);
}
@Test
public void invalidMasterToken() throws MslEncodingException, MslCryptoException, MslEntityAuthException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final MasterTokenProtectedAuthenticationData data = new MasterTokenProtectedAuthenticationData(ctx, masterToken, eAuthdata);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
authdata.put(KEY_MASTER_TOKEN, "x");
new MasterTokenProtectedAuthenticationData(ctx, authdata);
}
@Test
public void corruptMasterToken() throws MslEncodingException, MslCryptoException, MslEntityAuthException, MslEncoderException {
thrown.expect(MslEntityAuthException.class);
thrown.expectMslError(MslError.ENTITYAUTH_MASTERTOKEN_INVALID);
final MasterTokenProtectedAuthenticationData data = new MasterTokenProtectedAuthenticationData(ctx, masterToken, eAuthdata);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
authdata.put(KEY_MASTER_TOKEN, new MslObject());
new MasterTokenProtectedAuthenticationData(ctx, authdata);
}
@Test
public void missingAuthdata() throws MslEncodingException, MslCryptoException, MslEntityAuthException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final MasterTokenProtectedAuthenticationData data = new MasterTokenProtectedAuthenticationData(ctx, masterToken, eAuthdata);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
authdata.remove(KEY_AUTHENTICATION_DATA);
new MasterTokenProtectedAuthenticationData(ctx, authdata);
}
@Test
public void invalidAuthdata() throws MslEncodingException, MslCryptoException, MslEntityAuthException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final MasterTokenProtectedAuthenticationData data = new MasterTokenProtectedAuthenticationData(ctx, masterToken, eAuthdata);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
authdata.put(KEY_AUTHENTICATION_DATA, true);
new MasterTokenProtectedAuthenticationData(ctx, authdata);
}
@Ignore
@Test
public void corruptAuthdata() throws MslEncodingException, MslCryptoException, MslEntityAuthException, MslEncoderException {
thrown.expect(MslEntityAuthException.class);
thrown.expectMslError(MslError.ENTITYAUTH_CIPHERTEXT_INVALID);
final MasterTokenProtectedAuthenticationData data = new MasterTokenProtectedAuthenticationData(ctx, masterToken, eAuthdata);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
authdata.put(KEY_AUTHENTICATION_DATA, new byte[] { 'x' });
new MasterTokenProtectedAuthenticationData(ctx, authdata);
}
@Test
public void missingSignature() throws MslEncodingException, MslCryptoException, MslEntityAuthException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final MasterTokenProtectedAuthenticationData data = new MasterTokenProtectedAuthenticationData(ctx, masterToken, eAuthdata);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
authdata.remove(KEY_SIGNATURE);
new MasterTokenProtectedAuthenticationData(ctx, authdata);
}
@Test
public void invalidSignature() throws MslEncodingException, MslCryptoException, MslEntityAuthException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final MasterTokenProtectedAuthenticationData data = new MasterTokenProtectedAuthenticationData(ctx, masterToken, eAuthdata);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
authdata.put(KEY_SIGNATURE, true);
new MasterTokenProtectedAuthenticationData(ctx, authdata);
}
@Ignore
@Test
public void corruptSignature() throws MslEncodingException, MslCryptoException, MslEntityAuthException, MslEncoderException {
thrown.expect(MslEntityAuthException.class);
thrown.expectMslError(MslError.ENTITYAUTH_SIGNATURE_INVALID);
final MasterTokenProtectedAuthenticationData data = new MasterTokenProtectedAuthenticationData(ctx, masterToken, eAuthdata);
final MslObject authdata = data.getAuthData(encoder, ENCODER_FORMAT);
authdata.put(KEY_SIGNATURE, new byte[] { 'x' });
new MasterTokenProtectedAuthenticationData(ctx, authdata);
}
@Test
public void equalsMasterToken() throws MslEntityAuthException, MslEncodingException, MslCryptoException, MslEncoderException {
final MasterToken masterTokenB = MslTestUtils.getMasterToken(ctx, 2L, 2L);
final MasterTokenProtectedAuthenticationData dataA = new MasterTokenProtectedAuthenticationData(ctx, masterToken, eAuthdata);
final MasterTokenProtectedAuthenticationData dataB = new MasterTokenProtectedAuthenticationData(ctx, masterTokenB, eAuthdata);
final EntityAuthenticationData dataA2 = EntityAuthenticationData.create(ctx, MslTestUtils.toMslObject(encoder, dataA));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsAuthdata() throws MslEntityAuthException, MslEncodingException, MslCryptoException, MslEncoderException {
final EntityAuthenticationData eAuthdataB = new UnauthenticatedAuthenticationData(IDENTITY + "B");
final MasterTokenProtectedAuthenticationData dataA = new MasterTokenProtectedAuthenticationData(ctx, masterToken, eAuthdata);
final MasterTokenProtectedAuthenticationData dataB = new MasterTokenProtectedAuthenticationData(ctx, masterToken, eAuthdataB);
final EntityAuthenticationData dataA2 = EntityAuthenticationData.create(ctx, MslTestUtils.toMslObject(encoder, dataA));
assertTrue(dataA.equals(dataA));
assertEquals(dataA.hashCode(), dataA.hashCode());
assertFalse(dataA.equals(dataB));
assertFalse(dataB.equals(dataA));
assertTrue(dataA.hashCode() != dataB.hashCode());
assertTrue(dataA.equals(dataA2));
assertTrue(dataA2.equals(dataA));
assertEquals(dataA.hashCode(), dataA2.hashCode());
}
@Test
public void equalsObject() throws MslCryptoException, MslEntityAuthException {
final MasterTokenProtectedAuthenticationData data = new MasterTokenProtectedAuthenticationData(ctx, masterToken, eAuthdata);
assertFalse(data.equals(null));
assertFalse(data.equals(IDENTITY));
assertTrue(data.hashCode() != IDENTITY.hashCode());
}
} | 9,991 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/entityauth/UnauthenticatedSuffixedAuthenticationFactoryTest.java | /**
* Copyright (c) 2015-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.util.MockAuthenticationUtils;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* Unauthenticated suffixed authentication factory unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class UnauthenticatedSuffixedAuthenticationFactoryTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key entity root. */
private static final String KEY_ROOT = "root";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
private static final String UNAUTHENTICATED_ROOT = "MOCKUNAUTH-ROOT";
private static final String UNAUTHENTICATED_SUFFIX = "MOCKUNAUTH-SUFFIX";
/** Authentication utilities. */
private static MockAuthenticationUtils authutils;
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException {
ctx = new MockMslContext(EntityAuthenticationScheme.NONE, false);
encoder = ctx.getMslEncoderFactory();
authutils = new MockAuthenticationUtils();
factory = new UnauthenticatedSuffixedAuthenticationFactory(authutils);
ctx.addEntityAuthenticationFactory(factory);
}
@AfterClass
public static void teardown() {
factory = null;
encoder = null;
ctx = null;
}
@After
public void reset() {
authutils.reset();
}
@Test
public void createData() throws MslCryptoException, MslEncodingException, MslEntityAuthException, MslEncoderException {
final UnauthenticatedSuffixedAuthenticationData data = new UnauthenticatedSuffixedAuthenticationData(UNAUTHENTICATED_ROOT, UNAUTHENTICATED_SUFFIX);
final MslObject entityAuthJO = data.getAuthData(encoder, ENCODER_FORMAT);
final EntityAuthenticationData authdata = factory.createData(ctx, entityAuthJO);
assertNotNull(authdata);
assertTrue(authdata instanceof UnauthenticatedSuffixedAuthenticationData);
final MslObject dataMo = MslTestUtils.toMslObject(encoder, data);
final MslObject authdataMo = MslTestUtils.toMslObject(encoder, authdata);
assertTrue(MslEncoderUtils.equalObjects(dataMo, authdataMo));
}
@Test
public void encodeException() throws MslCryptoException, MslEncodingException, MslEntityAuthException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final UnauthenticatedSuffixedAuthenticationData data = new UnauthenticatedSuffixedAuthenticationData(UNAUTHENTICATED_ROOT, UNAUTHENTICATED_SUFFIX);
final MslObject entityAuthJO = data.getAuthData(encoder, ENCODER_FORMAT);
entityAuthJO.remove(KEY_ROOT);
factory.createData(ctx, entityAuthJO);
}
@Test
public void cryptoContext() throws MslCryptoException, MslEntityAuthException {
final UnauthenticatedSuffixedAuthenticationData data = new UnauthenticatedSuffixedAuthenticationData(UNAUTHENTICATED_ROOT, UNAUTHENTICATED_SUFFIX);
final ICryptoContext cryptoContext = factory.getCryptoContext(ctx, data);
assertNotNull(cryptoContext);
}
@Test
public void revoked() throws MslCryptoException, MslEntityAuthException {
thrown.expect(MslEntityAuthException.class);
thrown.expectMslError(MslError.ENTITY_REVOKED);
authutils.revokeEntity(UNAUTHENTICATED_ROOT);
final UnauthenticatedSuffixedAuthenticationData data = new UnauthenticatedSuffixedAuthenticationData(UNAUTHENTICATED_ROOT, UNAUTHENTICATED_SUFFIX);
factory.getCryptoContext(ctx, data);
}
/** MSL context. */
private static MockMslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
/** Entity authentication factory. */
private static EntityAuthenticationFactory factory;
}
| 9,992 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/entityauth/UnauthenticatedAuthenticationFactoryTest.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.util.MockAuthenticationUtils;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* Unauthenticated authentication factory unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class UnauthenticatedAuthenticationFactoryTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key entity identity. */
private static final String KEY_IDENTITY = "identity";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
private static final String UNAUTHENTICATED_ESN = "MOCKUNAUTH-ESN";
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException {
ctx = new MockMslContext(EntityAuthenticationScheme.NONE, false);
encoder = ctx.getMslEncoderFactory();
authutils = new MockAuthenticationUtils();
factory = new UnauthenticatedAuthenticationFactory(authutils);
ctx.addEntityAuthenticationFactory(factory);
}
@AfterClass
public static void teardown() {
factory = null;
authutils = null;
encoder = null;
ctx = null;
}
@After
public void reset() {
authutils.reset();
}
@Test
public void createData() throws MslCryptoException, MslEncodingException, MslEntityAuthException, MslEncoderException {
final UnauthenticatedAuthenticationData data = new UnauthenticatedAuthenticationData(UNAUTHENTICATED_ESN);
final MslObject entityAuthMo = data.getAuthData(encoder, ENCODER_FORMAT);
final EntityAuthenticationData authdata = factory.createData(ctx, entityAuthMo);
assertNotNull(authdata);
assertTrue(authdata instanceof UnauthenticatedAuthenticationData);
final MslObject dataMo = MslTestUtils.toMslObject(encoder, data);
final MslObject authdataMo = MslTestUtils.toMslObject(encoder, authdata);
assertTrue(MslEncoderUtils.equalObjects(dataMo, authdataMo));
}
@Test
public void encodeException() throws MslCryptoException, MslEncodingException, MslEntityAuthException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final UnauthenticatedAuthenticationData data = new UnauthenticatedAuthenticationData(UNAUTHENTICATED_ESN);
final MslObject entityAuthJO = data.getAuthData(encoder, ENCODER_FORMAT);
entityAuthJO.remove(KEY_IDENTITY);
factory.createData(ctx, entityAuthJO);
}
@Test
public void cryptoContext() throws MslCryptoException, MslEntityAuthException {
final UnauthenticatedAuthenticationData data = new UnauthenticatedAuthenticationData(UNAUTHENTICATED_ESN);
final ICryptoContext cryptoContext = factory.getCryptoContext(ctx, data);
assertNotNull(cryptoContext);
}
@Test
public void notPermitted() throws MslCryptoException, MslEntityAuthException {
thrown.expect(MslEntityAuthException.class);
thrown.expectMslError(MslError.INCORRECT_ENTITYAUTH_DATA);
authutils.disallowScheme(UNAUTHENTICATED_ESN, EntityAuthenticationScheme.NONE);
final UnauthenticatedAuthenticationData data = new UnauthenticatedAuthenticationData(UNAUTHENTICATED_ESN);
factory.getCryptoContext(ctx, data);
}
@Test
public void revoked() throws MslCryptoException, MslEntityAuthException {
thrown.expect(MslEntityAuthException.class);
thrown.expectMslError(MslError.ENTITY_REVOKED);
authutils.revokeEntity(UNAUTHENTICATED_ESN);
final UnauthenticatedAuthenticationData data = new UnauthenticatedAuthenticationData(UNAUTHENTICATED_ESN);
factory.getCryptoContext(ctx, data);
}
/** MSL context. */
private static MockMslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
/** Authentication utilities. */
private static MockAuthenticationUtils authutils;
/** Entity authentication factory. */
private static EntityAuthenticationFactory factory;
}
| 9,993 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/entityauth/RsaAuthenticationFactoryTest.java | /**
* Copyright (c) 2012-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.util.MockAuthenticationUtils;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* RSA asymmetric keys entity authentication factory unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class RsaAuthenticationFactoryTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** Key entity identity. */
private static final String KEY_IDENTITY = "identity";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
@BeforeClass
public static void setup() throws MslEncodingException, MslCryptoException {
ctx = new MockMslContext(EntityAuthenticationScheme.RSA, false);
encoder = ctx.getMslEncoderFactory();
final MockRsaStore rsaStore = new MockRsaStore();
rsaStore.addPublicKey(MockRsaAuthenticationFactory.RSA_PUBKEY_ID, MockRsaAuthenticationFactory.RSA_PUBKEY);
authutils = new MockAuthenticationUtils();
factory = new RsaAuthenticationFactory(rsaStore, authutils);
ctx.addEntityAuthenticationFactory(factory);
}
@AfterClass
public static void teardown() {
factory = null;
authutils = null;
encoder = null;
ctx = null;
}
@After
public void reset() {
authutils.reset();
}
@Test
public void createData() throws MslEncodingException, MslEntityAuthException, MslEncoderException, MslCryptoException {
final RsaAuthenticationData data = new RsaAuthenticationData(MockRsaAuthenticationFactory.RSA_ESN, MockRsaAuthenticationFactory.RSA_PUBKEY_ID);
final MslObject entityAuthMo = data.getAuthData(encoder, ENCODER_FORMAT);
final EntityAuthenticationData authdata = factory.createData(ctx, entityAuthMo);
assertNotNull(authdata);
assertTrue(authdata instanceof RsaAuthenticationData);
final MslObject dataMo = MslTestUtils.toMslObject(encoder, data);
final MslObject authdataMo = MslTestUtils.toMslObject(encoder, authdata);
assertTrue(MslEncoderUtils.equalObjects(dataMo, authdataMo));
}
@Test
public void encodeException() throws MslEncodingException, MslEntityAuthException, MslCryptoException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final RsaAuthenticationData data = new RsaAuthenticationData(MockRsaAuthenticationFactory.RSA_ESN, MockRsaAuthenticationFactory.RSA_PUBKEY_ID);
final MslObject entityAuthMo = data.getAuthData(encoder, ENCODER_FORMAT);
entityAuthMo.remove(KEY_IDENTITY);
factory.createData(ctx, entityAuthMo);
}
@Test
public void cryptoContext() throws MslEntityAuthException, MslCryptoException {
final RsaAuthenticationData data = new RsaAuthenticationData(MockRsaAuthenticationFactory.RSA_ESN, MockRsaAuthenticationFactory.RSA_PUBKEY_ID);
final ICryptoContext cryptoContext = factory.getCryptoContext(ctx, data);
assertNotNull(cryptoContext);
}
@Test
public void unknownKeyId() throws MslEntityAuthException, MslCryptoException {
thrown.expect(MslEntityAuthException.class);
thrown.expectMslError(MslError.RSA_PUBLICKEY_NOT_FOUND);
final RsaAuthenticationData data = new RsaAuthenticationData(MockRsaAuthenticationFactory.RSA_ESN, "x");
factory.getCryptoContext(ctx, data);
}
@Test
public void localCryptoContext() throws MslCryptoException, MslEntityAuthException {
final MockRsaStore rsaStore = new MockRsaStore();
rsaStore.addPrivateKey(MockRsaAuthenticationFactory.RSA_PUBKEY_ID, MockRsaAuthenticationFactory.RSA_PRIVKEY);
final EntityAuthenticationFactory factory = new RsaAuthenticationFactory(MockRsaAuthenticationFactory.RSA_PUBKEY_ID, rsaStore, authutils);
final RsaAuthenticationData data = new RsaAuthenticationData(MockRsaAuthenticationFactory.RSA_ESN, MockRsaAuthenticationFactory.RSA_PUBKEY_ID);
final ICryptoContext cryptoContext = factory.getCryptoContext(ctx, data);
final byte[] plaintext = new byte[16];
ctx.getRandom().nextBytes(plaintext);
cryptoContext.sign(plaintext, encoder, ENCODER_FORMAT);
}
@Test
public void missingPrivateKey() throws MslCryptoException, MslEntityAuthException {
thrown.expect(MslEntityAuthException.class);
thrown.expectMslError(MslError.RSA_PRIVATEKEY_NOT_FOUND);
final MockRsaStore rsaStore = new MockRsaStore();
rsaStore.addPublicKey(MockRsaAuthenticationFactory.RSA_PUBKEY_ID, MockRsaAuthenticationFactory.RSA_PUBKEY);
final EntityAuthenticationFactory factory = new RsaAuthenticationFactory(MockRsaAuthenticationFactory.RSA_PUBKEY_ID, rsaStore, authutils);
final RsaAuthenticationData data = new RsaAuthenticationData(MockRsaAuthenticationFactory.RSA_ESN, MockRsaAuthenticationFactory.RSA_PUBKEY_ID);
factory.getCryptoContext(ctx, data);
}
@Test
public void revoked() throws MslEntityAuthException, MslCryptoException {
thrown.expect(MslEntityAuthException.class);
thrown.expectMslError(MslError.ENTITY_REVOKED);
authutils.revokeEntity(MockRsaAuthenticationFactory.RSA_ESN);
final RsaAuthenticationData data = new RsaAuthenticationData(MockRsaAuthenticationFactory.RSA_ESN, "x");
factory.getCryptoContext(ctx, data);
}
/** MSL context. */
private static MockMslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
/** Authentication utilities. */
private static MockAuthenticationUtils authutils;
/** Entity authentication factory. */
private static EntityAuthenticationFactory factory;
}
| 9,994 |
0 | Create_ds/msl/tests/src/test/java/com/netflix/msl | Create_ds/msl/tests/src/test/java/com/netflix/msl/entityauth/X509AuthenticationFactoryTest.java | /**
* Copyright (c) 2012-2018 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.entityauth;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.SignatureException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslEntityAuthException;
import com.netflix.msl.MslError;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.test.ExpectedMslException;
import com.netflix.msl.util.IOUtils;
import com.netflix.msl.util.MockAuthenticationUtils;
import com.netflix.msl.util.MockMslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* X.509 asymmetric keys entity authentication factory unit tests.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class X509AuthenticationFactoryTest {
/** MSL encoder format. */
private static final MslEncoderFormat ENCODER_FORMAT = MslEncoderFormat.JSON;
/** X.509 expired resource certificate. */
private static final String X509_EXPIRED_CERT = "/entityauth/expired.pem";
/** X.509 untrusted resource certificate. */
private static final String X509_UNTRUSTED_CERT = "/entityauth/untrusted.pem";
/** Key entity X.509 certificate. */
private static final String KEY_X509_CERT = "x509certificate";
@Rule
public ExpectedMslException thrown = ExpectedMslException.none();
/** Authentication utilities. */
private static MockAuthenticationUtils authutils;
@BeforeClass
public static void setup() throws IOException, MslEncodingException, MslCryptoException, CertificateException, InvalidKeyException, SignatureException, NoSuchAlgorithmException, NoSuchProviderException {
ctx = new MockMslContext(EntityAuthenticationScheme.X509, false);
encoder = ctx.getMslEncoderFactory();
expiredCert = IOUtils.readX509(X509_EXPIRED_CERT);
untrustedCert = IOUtils.readX509(X509_UNTRUSTED_CERT);
final X509Store caStore = new X509Store();
caStore.addTrusted(MockX509AuthenticationFactory.X509_CERT);
authutils = new MockAuthenticationUtils();
factory = new X509AuthenticationFactory(caStore, authutils);
ctx.addEntityAuthenticationFactory(factory);
}
@AfterClass
public static void teardown() {
untrustedCert = null;
expiredCert = null;
factory = null;
encoder = null;
ctx = null;
}
@After
public void reset() {
authutils.reset();
}
@Test
public void createData() throws MslEncodingException, MslCryptoException, MslEntityAuthException, MslEncoderException {
final X509AuthenticationData data = new X509AuthenticationData(MockX509AuthenticationFactory.X509_CERT);
final MslObject entityAuthJO = data.getAuthData(encoder, ENCODER_FORMAT);
final EntityAuthenticationData authdata = factory.createData(ctx, entityAuthJO);
assertNotNull(authdata);
assertTrue(authdata instanceof X509AuthenticationData);
final MslObject dataMo = MslTestUtils.toMslObject(encoder, data);
final MslObject authdataMo = MslTestUtils.toMslObject(encoder, authdata);
assertTrue(MslEncoderUtils.equalObjects(dataMo, authdataMo));
}
@Test
public void encodeException() throws MslEncodingException, MslCryptoException, MslEntityAuthException, MslEncoderException {
thrown.expect(MslEncodingException.class);
thrown.expectMslError(MslError.MSL_PARSE_ERROR);
final X509AuthenticationData data = new X509AuthenticationData(MockX509AuthenticationFactory.X509_CERT);
final MslObject entityAuthJO = data.getAuthData(encoder, ENCODER_FORMAT);
entityAuthJO.remove(KEY_X509_CERT);
factory.createData(ctx, entityAuthJO);
}
@Test
public void cryptoContext() throws MslCryptoException, MslEntityAuthException {
final X509AuthenticationData data = new X509AuthenticationData(MockX509AuthenticationFactory.X509_CERT);
final ICryptoContext cryptoContext = factory.getCryptoContext(ctx, data);
assertNotNull(cryptoContext);
}
@Test
public void untrustedCert() throws MslCryptoException, MslEntityAuthException {
thrown.expect(MslEntityAuthException.class);
thrown.expectMslError(MslError.X509CERT_VERIFICATION_FAILED);
final X509AuthenticationData data = new X509AuthenticationData(untrustedCert);
factory.getCryptoContext(ctx, data);
}
@Test
public void expiredCert() throws MslCryptoException, MslEntityAuthException {
thrown.expect(MslEntityAuthException.class);
thrown.expectMslError(MslError.X509CERT_EXPIRED);
final X509AuthenticationData data = new X509AuthenticationData(expiredCert);
factory.getCryptoContext(ctx, data);
}
@Test
public void revoked() throws MslCryptoException, MslEntityAuthException {
thrown.expect(MslEntityAuthException.class);
thrown.expectMslError(MslError.ENTITY_REVOKED);
authutils.revokeEntity(MockX509AuthenticationFactory.X509_ESN);
final X509AuthenticationData data = new X509AuthenticationData(MockX509AuthenticationFactory.X509_CERT);
factory.getCryptoContext(ctx, data);
}
/** MSL context. */
private static MockMslContext ctx;
/** MSL encoder factory. */
private static MslEncoderFactory encoder;
/** Entity authentication factory. */
private static EntityAuthenticationFactory factory;
/** Expired X.509 certificate. */
private static X509Certificate expiredCert;
/** Untrusted X.509 certificate. */
private static X509Certificate untrustedCert;
}
| 9,995 |
0 | Create_ds/msl/tests/src/main/java/com/netflix/msl | Create_ds/msl/tests/src/main/java/com/netflix/msl/test/ExpectedMslException.java | /**
* Copyright (c) 2014-2017 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.test;
import static org.hamcrest.CoreMatchers.both;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import org.hamcrest.Matcher;
import org.hamcrest.StringDescription;
import org.hamcrest.TypeSafeMatcher;
import org.junit.Assert;
import org.junit.rules.TestRule;
import org.junit.runner.Description;
import org.junit.runners.model.Statement;
import com.netflix.msl.MslConstants.ResponseCode;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
/**
* <p>The {@code ExpectedMslException} rule allows in-test specification of
* expected {@link MslException} types and internal error:
*
* <pre>
* // These tests all pass.
* public static class HasExpectedMslException {
* @Rule
* public ExpectedMslException thrown = ExpectedMslException.none();
*
* @Test
* public void throwsNothing() {
* // no exception expected, none thrown: passes.
* }
*
* @Test
* public void throwsMslException() {
* thrown.expect(MslMessageException.class);
* thrown.expectMslError(MslError.JSON_PARSE_ERROR);
* throw new MslMessageException(MslError.JSON_PARSE_ERROR);
* }
*
* @Test
* public void throwsMslExceptionWithResponseCode() {
* thrown.expectResponseCode(ResponseCode.FAIL);
* throw new MslException(MslError.JSON_PARSE_ERROR);
* }
* }
* </pre>
* </p>
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class ExpectedMslException implements TestRule {
/**
* A statement expecting a {@code MslException}.
*/
private class ExpectedMslExceptionStatement extends Statement {
/**
* Create a new statement expecting expecting a {@code MslException} if
* the outer class has a matcher.
*
* @param base the base statement.
*/
public ExpectedMslExceptionStatement(final Statement base) {
fNext = base;
}
/* (non-Javadoc)
* @see org.junit.runners.model.Statement#evaluate()
*/
@Override
public void evaluate() throws Throwable {
try {
fNext.evaluate();
} catch (final Throwable t) {
if (fMatcher == null)
throw t;
Assert.assertThat(t, fMatcher);
return;
}
if (fMatcher != null)
throw new AssertionError("Expected test to throw " + StringDescription.toString(fMatcher));
}
/** The base statement. */
private final Statement fNext;
}
/**
* Create a new {@code MslException} matcher that expects a specific MSL
* error.
*
* @param error the expected MSL error.
* @return the matcher.
*/
private Matcher<MslException> hasMslError(final MslError error) {
return new TypeSafeMatcher<MslException>() {
@Override
public void describeTo(final org.hamcrest.Description description) {
description.appendText("MslException with internal code ");
description.appendDescriptionOf(equalTo(error.getInternalCode()));
}
@Override
protected boolean matchesSafely(final MslException item) {
return is(error).matches(item.getError());
}
};
}
/**
* Create a new {@code MslException} matcher that expects a specific
* response code.
*
* @param code the expected response code.
* @return the matcher.
*/
private Matcher<MslException> hasResponseCode(final ResponseCode code) {
return new TypeSafeMatcher<MslException>() {
@Override
public void describeTo(final org.hamcrest.Description description) {
description.appendText("MslException with response code ");
description.appendDescriptionOf(equalTo(code));
}
@Override
protected boolean matchesSafely(final MslException item) {
return is(code).matches(item.getError().getResponseCode());
}
};
}
/**
* Create a new {@code MslException} matcher that expects a specific
* message ID.
*
* @param id the expected message ID.
* @return the matcher.
*/
private Matcher<MslException> hasMessageId(final long id) {
return new TypeSafeMatcher<MslException>() {
@Override
public void describeTo(final org.hamcrest.Description description) {
description.appendText("MslException with message ID ");
description.appendDescriptionOf(equalTo(id));
}
@Override
protected boolean matchesSafely(final MslException item) {
return is(id).matches(item.getMessageId());
}
};
}
/**
* @return a rule that expects no MslException to be thrown (identical to
* behavior without this rule).
*/
public static ExpectedMslException none() {
return new ExpectedMslException();
}
/**
* Adds {@code matcher} to the list of requirements for any thrown
* exception.
*/
// Should be able to remove this suppression in some brave new hamcrest world.
@SuppressWarnings("unchecked")
public void expect(final Matcher<?> matcher) {
if (fMatcher == null)
fMatcher = (Matcher<Object>)matcher;
else
fMatcher = both(fMatcher).and((Matcher<? super Object>)matcher);
}
/**
* Adds to the list of requirements for any thrown exception that it should
* be an instance of {@code type}.
*
* @param type the specific Exception type.
*/
public void expect(final Class<? extends Exception> type) {
expect(instanceOf(type));
}
/**
* Adds to the list of requirements for any thrown exception that it should
* be a {@code MslException} with the specified {@code MslError}.
*
* @param error the specific MSL error.
*/
public void expectMslError(final MslError error) {
expect(hasMslError(error));
}
/**
* Adds to the list of requirements for any thrown exception that it should
* be a {@code MslException} with the specified {@code ResponseCode}.
*
* @param code the specific response code.
*/
public void expectResponseCode(final ResponseCode code) {
expect(hasResponseCode(code));
}
/**
* Adds to the list of requirements for any thrown exception that it should
* be a {@code MslException} with the specified message ID.
*
* @param id the specific message ID.
*/
public void expectMessageId(final long id) {
expect(hasMessageId(id));
}
/* (non-Javadoc)
* @see org.junit.rules.TestRule#apply(org.junit.runners.model.Statement, org.junit.runner.Description)
*/
@Override
public Statement apply(final Statement base, final Description description) {
return new ExpectedMslExceptionStatement(base);
}
/** Rule requirements. */
private Matcher<Object> fMatcher = null;
}
| 9,996 |
0 | Create_ds/msl/tests/src/main/java/com/netflix/msl | Create_ds/msl/tests/src/main/java/com/netflix/msl/util/IOUtils.java | /**
* Copyright (c) 2018 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.util;
import java.io.ByteArrayOutputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import com.netflix.msl.MslInternalException;
/**
* Utility class to perform simple I/O for testing, not necessarily for
* production use.
*/
public class IOUtils {
/**
* <p>Read an X.509 certificate from the specified resource.</p>
*
* @param resourceName the resource name.
* @return the X.509 certificate read from the resource.
* @throws CertificateException if the resource does not contain a valid
* X.509 certificate.
* @throws IOException if there is an error reading from the resource.
*/
public static X509Certificate readX509(final String resourceName) throws CertificateException, IOException {
final URL expiredUrl = IOUtils.class.getResource(resourceName);
if (expiredUrl == null)
throw new FileNotFoundException("Unable to load resource " + resourceName);
final InputStream expiredInputStream = expiredUrl.openStream();
final CertificateFactory factory;
try {
factory = CertificateFactory.getInstance("X.509");
} catch (final CertificateException e) {
throw new MslInternalException("No X.509 certificate factory provider found.", e);
}
return (X509Certificate)factory.generateCertificate(expiredInputStream);
}
/**
* <p>Read a resource and return its contents.</p>
*
* @param resourceName the resource name.
* @return byte[] contents of file.
*/
public static byte[] readResource(final String resourceName) throws IOException {
// Avoid getClassloader() to make loading more compatible when running
// in tests.
final InputStream resourceAsStream = IOUtils.class.getResourceAsStream(resourceName);
return readAllBytes(resourceAsStream);
}
/**
* <p>Read and return all bytes from the provided InputStream. Closes the
* input stream when done.</p>
*
* @param inputStream input stream to read from.
* @return bytes read in from the input stream.
* @throws IOException if there was an error reading from the input stream.
*/
public static byte[] readAllBytes(final InputStream inputStream) throws IOException {
final ByteArrayOutputStream buffer = new ByteArrayOutputStream();
int nRead;
final byte[] data = new byte[16384];
try {
while ((nRead = inputStream.read(data, 0, data.length)) != -1) {
buffer.write(data, 0, nRead);
}
buffer.flush();
} finally {
inputStream.close();
}
return buffer.toByteArray();
}
}
| 9,997 |
0 | Create_ds/msl/tests/src/main/java/com/netflix/msl | Create_ds/msl/tests/src/main/java/com/netflix/msl/util/MockAuthenticationUtils.java | /**
* Copyright (c) 2013-2014 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.util;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.keyx.KeyExchangeScheme;
import com.netflix.msl.tokens.MslUser;
import com.netflix.msl.userauth.UserAuthenticationScheme;
/**
* Test authentication utilities.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class MockAuthenticationUtils implements AuthenticationUtils {
/**
* Reset the entity revocation state.
*/
public void reset() {
revokedEntityIdentities.clear();
revokedEntityAuthSchemes.clear();
revokedUserAuthSchemes.clear();
revokedEntityUserAuthSchemes.clear();
revokedKeyxSchemes.clear();
}
/**
* @param identity the entity identity to revoke.
*/
public void revokeEntity(final String identity) {
revokedEntityIdentities.add(identity);
}
/**
* @param identity the entity to accept.
*/
public void accept(final String identity) {
revokedEntityIdentities.remove(identity);
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EntityAuthUtils#isRevoked(java.lang.String)
*/
@Override
public boolean isEntityRevoked(final String identity) {
return revokedEntityIdentities.contains(identity);
}
/**
* @param identity the entity identity.
* @param scheme the scheme to permit.
*/
public void permitScheme(final String identity, final EntityAuthenticationScheme scheme) {
final Set<EntityAuthenticationScheme> revokedSchemes = revokedEntityAuthSchemes.get(identity);
if (revokedSchemes == null) return;
revokedSchemes.remove(scheme);
}
/**
* @param identity the entity identity.
* @param scheme the scheme to disallow.
*/
public void disallowScheme(final String identity, final EntityAuthenticationScheme scheme) {
if (!revokedEntityAuthSchemes.containsKey(identity))
revokedEntityAuthSchemes.put(identity, new HashSet<EntityAuthenticationScheme>());
final Set<EntityAuthenticationScheme> revokedSchemes = revokedEntityAuthSchemes.get(identity);
revokedSchemes.add(scheme);
}
/* (non-Javadoc)
* @see com.netflix.msl.util.AuthenticationUtils#isSchemePermitted(java.lang.String, com.netflix.msl.entityauth.EntityAuthenticationScheme)
*/
@Override
public boolean isSchemePermitted(final String identity, final EntityAuthenticationScheme scheme) {
return (!revokedEntityAuthSchemes.containsKey(identity) ||
!revokedEntityAuthSchemes.get(identity).contains(scheme));
}
/**
* @param identity the entity identity.
* @param scheme the scheme to permit.
*/
public void permitScheme(final String identity, final UserAuthenticationScheme scheme) {
final Set<UserAuthenticationScheme> revokedSchemes = revokedUserAuthSchemes.get(identity);
if (revokedSchemes == null) return;
revokedSchemes.remove(scheme);
}
/**
* @param identity the entity identity.
* @param scheme the scheme to disallow.
*/
public void disallowScheme(final String identity, final UserAuthenticationScheme scheme) {
if (!revokedUserAuthSchemes.containsKey(identity))
revokedUserAuthSchemes.put(identity, new HashSet<UserAuthenticationScheme>());
final Set<UserAuthenticationScheme> revokedSchemes = revokedUserAuthSchemes.get(identity);
revokedSchemes.add(scheme);
}
/* (non-Javadoc)
* @see com.netflix.msl.util.AuthenticationUtils#isSchemePermitted(java.lang.String, com.netflix.msl.userauth.UserAuthenticationScheme)
*/
@Override
public boolean isSchemePermitted(final String identity, final UserAuthenticationScheme scheme) {
return (!revokedUserAuthSchemes.containsKey(identity) ||
!revokedUserAuthSchemes.get(identity).contains(scheme));
}
/**
* @param identity the entity identity.
* @param user the MSL user.
* @param scheme the scheme to permit.
*/
public void permitScheme(final String identity, final MslUser user, final UserAuthenticationScheme scheme) {
final Map<MslUser,Set<UserAuthenticationScheme>> entityUsers = revokedEntityUserAuthSchemes.get(identity);
if (entityUsers == null) return;
final Set<UserAuthenticationScheme> revokedSchemes = entityUsers.get(user);
if (revokedSchemes == null) return;
revokedSchemes.remove(scheme);
}
/**
* @param identity the entity identity.
* @param user the MSL user.
* @param scheme the scheme to disallow.
*/
public void disallowScheme(final String identity, final MslUser user, final UserAuthenticationScheme scheme) {
Map<MslUser,Set<UserAuthenticationScheme>> entityUsers = revokedEntityUserAuthSchemes.get(identity);
if (entityUsers == null) {
entityUsers = new HashMap<MslUser,Set<UserAuthenticationScheme>>();
revokedEntityUserAuthSchemes.put(identity, entityUsers);
}
Set<UserAuthenticationScheme> revokedSchemes = entityUsers.get(user);
if (revokedSchemes == null) {
revokedSchemes = new HashSet<UserAuthenticationScheme>();
entityUsers.put(user, revokedSchemes);
}
revokedSchemes.add(scheme);
}
/* (non-Javadoc)
* @see com.netflix.msl.util.AuthenticationUtils#isSchemePermitted(java.lang.String, com.netflix.msl.tokens.MslUser, com.netflix.msl.userauth.UserAuthenticationScheme)
*/
@Override
public boolean isSchemePermitted(final String identity, final MslUser user, final UserAuthenticationScheme scheme) {
final Map<MslUser,Set<UserAuthenticationScheme>> entityUsers = revokedEntityUserAuthSchemes.get(identity);
if (entityUsers == null) return true;
final Set<UserAuthenticationScheme> revokedSchemes = entityUsers.get(user);
if (revokedSchemes == null) return true;
return !revokedSchemes.contains(scheme);
}
/**
* @param identity the entity identity.
* @param scheme the scheme to permit.
*/
public void permitScheme(final String identity, final KeyExchangeScheme scheme) {
final Set<KeyExchangeScheme> revokedSchemes = revokedKeyxSchemes.get(identity);
if (revokedSchemes == null) return;
revokedSchemes.remove(scheme);
}
/**
* @param identity the entity identity.
* @param scheme the scheme to disallow.
*/
public void disallowScheme(final String identity, final KeyExchangeScheme scheme) {
if (!revokedKeyxSchemes.containsKey(identity))
revokedKeyxSchemes.put(identity, new HashSet<KeyExchangeScheme>());
final Set<KeyExchangeScheme> revokedSchemes = revokedKeyxSchemes.get(identity);
revokedSchemes.add(scheme);
}
/* (non-Javadoc)
* @see com.netflix.msl.util.AuthenticationUtils#isSchemePermitted(java.lang.String, com.netflix.msl.keyx.KeyExchangeScheme)
*/
@Override
public boolean isSchemePermitted(final String identity, final KeyExchangeScheme scheme) {
return (!revokedKeyxSchemes.containsKey(identity) ||
!revokedKeyxSchemes.get(identity).contains(scheme));
}
/** Revoked entity identities. */
private final Set<String> revokedEntityIdentities = new HashSet<String>();
/** Revoked entity authentication schemes. */
private final Map<String,Set<EntityAuthenticationScheme>> revokedEntityAuthSchemes = new HashMap<String,Set<EntityAuthenticationScheme>>();
/** Revoked user authentication schemes. */
private final Map<String,Set<UserAuthenticationScheme>> revokedUserAuthSchemes = new HashMap<String,Set<UserAuthenticationScheme>>();
/** Revoked entity-user authentication schemes. */
private final Map<String,Map<MslUser,Set<UserAuthenticationScheme>>> revokedEntityUserAuthSchemes = new HashMap<String,Map<MslUser,Set<UserAuthenticationScheme>>>();
/** Revoked key exchange schemes. */
private final Map<String,Set<KeyExchangeScheme>> revokedKeyxSchemes = new HashMap<String,Set<KeyExchangeScheme>>();
}
| 9,998 |
0 | Create_ds/msl/tests/src/main/java/com/netflix/msl | Create_ds/msl/tests/src/main/java/com/netflix/msl/util/MslTestUtils.java | /**
* Copyright (c) 2012-2020 Netflix, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.msl.util;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Date;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslException;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.crypto.JcaAlgorithm;
import com.netflix.msl.crypto.NullCryptoContext;
import com.netflix.msl.entityauth.EntityAuthenticationData;
import com.netflix.msl.entityauth.MockPresharedAuthenticationFactory;
import com.netflix.msl.io.MslEncodable;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.tokens.MasterToken;
import com.netflix.msl.tokens.MslUser;
import com.netflix.msl.tokens.ServiceToken;
import com.netflix.msl.tokens.UserIdToken;
/**
* Helper functions common to many unit tests and mocks.
*
* @author Wesley Miaw <wmiaw@netflix.com>
*/
public class MslTestUtils {
/** Base service token name. */
private static final String SERVICE_TOKEN_NAME = "serviceTokenName";
/**
* Maximum number of service tokens to randomly generate. This needs to be
* large enough to statistically create the applicable set of service
* tokens for the tests.
*/
private static final int NUM_SERVICE_TOKENS = 12;
/** Wrapping key derivation algorithm salt. */
private static final byte[] SALT = {
(byte)0x02, (byte)0x76, (byte)0x17, (byte)0x98, (byte)0x4f, (byte)0x62, (byte)0x27, (byte)0x53,
(byte)0x9a, (byte)0x63, (byte)0x0b, (byte)0x89, (byte)0x7c, (byte)0x01, (byte)0x7d, (byte)0x69 };
/** Wrapping key derivation algorithm info. */
private static final byte[] INFO = {
(byte)0x80, (byte)0x9f, (byte)0x82, (byte)0xa7, (byte)0xad, (byte)0xdf, (byte)0x54, (byte)0x8d,
(byte)0x3e, (byte)0xa9, (byte)0xdd, (byte)0x06, (byte)0x7f, (byte)0xf9, (byte)0xbb, (byte)0x91, };
/** Wrapping key length in bytes. */
private static final int WRAPPING_KEY_LENGTH = 128 / Byte.SIZE;
/**
* Parse a new {@link MslObject} from the {@link MslEncodable}.
*
* @param encoder the {@link MslEncoderFactory}.
* @param encode a {@link MslEncodable}.
* @return the {@link MslObject}
* @throws MslEncoderException if there is an error encoding and converting
* the object cannot be encoded and converted
*/
public static MslObject toMslObject(final MslEncoderFactory encoder, final MslEncodable encode) throws MslEncoderException {
final byte[] encoding = encode.toMslEncoding(encoder, encoder.getPreferredFormat(null));
return encoder.parseObject(encoding);
}
/**
* Returns a master token with the identity of the MSL context entity
* authentication data that is not renewable or expired.
*
* @param ctx MSL context.
* @param sequenceNumber master token sequence number to use.
* @param serialNumber master token serial number to use.
* @return a new master token.
* @throws MslEncodingException if there is an error encoding the JSON
* data.
* @throws MslCryptoException if there is an error encrypting or signing
* the token data.
*/
public static MasterToken getMasterToken(final MslContext ctx, final long sequenceNumber, final long serialNumber) throws MslEncodingException, MslCryptoException {
final Date renewalWindow = new Date(System.currentTimeMillis() + 10000);
final Date expiration = new Date(System.currentTimeMillis() + 20000);
final EntityAuthenticationData entityAuthData = ctx.getEntityAuthenticationData(null);
final String identity = entityAuthData.getIdentity();
final SecretKey encryptionKey = MockPresharedAuthenticationFactory.KPE;
final SecretKey hmacKey = MockPresharedAuthenticationFactory.KPH;
return new MasterToken(ctx, renewalWindow, expiration, sequenceNumber, serialNumber, null, identity, encryptionKey, hmacKey);
}
/**
* Returns an untrusted master token with the identity of the MSL context
* entity authentication data that is not renewable or expired.
*
* @param ctx MSL context.
* @return a new untrusted master token.
* @throws MslEncodingException if there is an error encoding the data.
* @throws MslCryptoException if there is an error encrypting or signing
* the token data.
* @throws MslException if the master token is constructed incorrectly.
* @throws MslEncoderException if there is an error editing the data.
*/
public static MasterToken getUntrustedMasterToken(final MslContext ctx) throws MslEncodingException, MslCryptoException, MslEncoderException, MslException {
final Date renewalWindow = new Date(System.currentTimeMillis() + 10000);
final Date expiration = new Date(System.currentTimeMillis() + 20000);
final EntityAuthenticationData entityAuthData = ctx.getEntityAuthenticationData(null);
final String identity = entityAuthData.getIdentity();
final SecretKey encryptionKey = MockPresharedAuthenticationFactory.KPE;
final SecretKey hmacKey = MockPresharedAuthenticationFactory.KPH;
final MasterToken masterToken = new MasterToken(ctx, renewalWindow, expiration, 1L, 1L, null, identity, encryptionKey, hmacKey);
final MslEncoderFactory encoder = ctx.getMslEncoderFactory();
final MslObject mo = toMslObject(encoder, masterToken);
final byte[] signature = mo.getBytes("signature");
++signature[1];
mo.put("signature", signature);
return new MasterToken(ctx, mo);
}
/**
* Returns a user ID token with the identity of the provided user that is
* not renewable or expired.
*
* @param ctx MSL context.
* @param masterToken master token to bind against.
* @param serialNumber user ID token serial number to use.
* @param user MSL user to use.
* @return a new user ID token.
* @throws MslEncodingException if there is an error encoding the JSON
* data.
* @throws MslCryptoException if there is an error encrypting or signing
* the token data.
*/
public static UserIdToken getUserIdToken(final MslContext ctx, final MasterToken masterToken, final long serialNumber, final MslUser user) throws MslEncodingException, MslCryptoException {
final Date renewalWindow = new Date(System.currentTimeMillis() + 10000);
final Date expiration = new Date(System.currentTimeMillis() + 20000);
return new UserIdToken(ctx, renewalWindow, expiration, masterToken, serialNumber, null, user);
}
/**
* Returns an untrusted user ID token with the identity of the provided
* user that is not renewable or expired.
*
* @param ctx MSL context.
* @param masterToken master token to bind against.
* @param serialNumber user ID token serial number to use.
* @param user MSL user to use.
* @return a new untrusted user ID token.
* @throws MslEncodingException if there is an error encoding the data.
* @throws MslCryptoException if there is an error encrypting or signing
* the token data.
* @throws MslEncoderException if there is an error editing the data.
* @throws MslException if the user ID token serial number is out of range.
*/
public static UserIdToken getUntrustedUserIdToken(final MslContext ctx, final MasterToken masterToken, final long serialNumber, final MslUser user) throws MslEncodingException, MslCryptoException, MslEncoderException, MslException {
final Date renewalWindow = new Date(System.currentTimeMillis() + 10000);
final Date expiration = new Date(System.currentTimeMillis() + 20000);
final UserIdToken userIdToken = new UserIdToken(ctx, renewalWindow, expiration, masterToken, serialNumber, null, user);
final MslEncoderFactory encoder = ctx.getMslEncoderFactory();
final MslObject mo = toMslObject(encoder, userIdToken);
final byte[] signature = mo.getBytes("signature");
++signature[1];
mo.put("signature", signature);
return new UserIdToken(ctx, mo, masterToken);
}
/**
* @param ctx MSL context.
* @param masterToken master token to bind against. May be null.
* @param userIdToken user ID token to bind against. May be null.
* @return a set of new service tokens with random token bindings.
* @throws MslEncodingException if there is an error encoding the JSON
* data.
* @throws MslCryptoException if there is an error encrypting or signing
* the token data.
* @throws MslException if there is an error compressing the data.
*/
public static Set<ServiceToken> getServiceTokens(final MslContext ctx, final MasterToken masterToken, final UserIdToken userIdToken) throws MslEncodingException, MslCryptoException, MslException {
final Random random = new Random();
final ICryptoContext cryptoContext = new NullCryptoContext();
final Set<ServiceToken> serviceTokens = new HashSet<ServiceToken>();
final int numTokens = Math.max(NUM_SERVICE_TOKENS, 3);
for (int i = 0; i < numTokens; ++i) {
final String name = SERVICE_TOKEN_NAME + random.nextInt();
final byte[] data = new byte[32];
random.nextBytes(data);
// Make sure one of each type of token is included.
// Otherwise pick a random type.
final int type = (i < 3) ? i : random.nextInt(3);
switch (type) {
case 0:
serviceTokens.add(new ServiceToken(ctx, name, data, null, null, false, null, cryptoContext));
break;
case 1:
serviceTokens.add(new ServiceToken(ctx, name, data, masterToken, null, false, null, cryptoContext));
break;
case 2:
serviceTokens.add(new ServiceToken(ctx, name, data, masterToken, userIdToken, false, null, cryptoContext));
break;
}
}
return serviceTokens;
}
/**
* @param ctx MSL context.
* @param masterToken the master token to bind against.
* @return a random set of master token bound service tokens.
* @throws MslEncodingException if there is an error constructing the
* service token.
* @throws MslCryptoException if there is an error constructing the service
* token.
* @throws MslException if there is an error compressing the data.
*/
public static Set<ServiceToken> getMasterBoundServiceTokens(final MslContext ctx, final MasterToken masterToken) throws MslEncodingException, MslCryptoException, MslException {
final Random random = new Random();
final ICryptoContext cryptoContext = new NullCryptoContext();
final Set<ServiceToken> tokens = new HashSet<ServiceToken>();
for (int count = random.nextInt(NUM_SERVICE_TOKENS); count >= 0; --count) {
final String name = SERVICE_TOKEN_NAME + random.nextInt();
final byte[] data = new byte[8];
random.nextBytes(data);
final ServiceToken token = new ServiceToken(ctx, name, data, masterToken, null, false, null, cryptoContext);
tokens.add(token);
}
return tokens;
}
/**
* @param ctx MSL context.
* @param masterToken the master token to bind against.
* @param userIdToken the user ID token to bind against.
* @return a random set of user ID token bound service tokens.
* @throws MslEncodingException if there is an error constructing the
* service token.
* @throws MslCryptoException if there is an error constructing the service
* token.
* @throws MslException if there is an error compressing the data.
*/
public static Set<ServiceToken> getUserBoundServiceTokens(final MslContext ctx, final MasterToken masterToken, final UserIdToken userIdToken) throws MslEncodingException, MslCryptoException, MslException {
final Random random = new Random();
final ICryptoContext cryptoContext = new NullCryptoContext();
final Set<ServiceToken> tokens = new HashSet<ServiceToken>();
for (int count = random.nextInt(NUM_SERVICE_TOKENS); count >= 0; --count) {
final String name = SERVICE_TOKEN_NAME + random.nextInt();
final byte[] data = new byte[8];
random.nextBytes(data);
final ServiceToken token = new ServiceToken(ctx, name, data, masterToken, userIdToken, false, null, cryptoContext);
tokens.add(token);
}
return tokens;
}
/**
* Derives the pre-shared or model group keys AES-128 Key Wrap key from the
* provided AES-128 encryption key and HMAC-SHA256 key.
*
* @param encryptionKey the encryption key.
* @param hmacKey the HMAC key.
* @return the wrapping key.
*/
public static byte[] deriveWrappingKey(final byte[] encryptionKey, final byte[] hmacKey) {
try {
// Concatenate the keys.
final byte[] bits = Arrays.copyOf(encryptionKey, encryptionKey.length + hmacKey.length);
System.arraycopy(hmacKey, 0, bits, encryptionKey.length, hmacKey.length);
// HMAC-SHA256 the keys with the salt as the HMAC key.
final SecretKey saltKey = new SecretKeySpec(SALT, JcaAlgorithm.HMAC_SHA256);
final Mac intermediateMac = Mac.getInstance(saltKey.getAlgorithm());
intermediateMac.init(saltKey);
final byte[] intermediateBits = intermediateMac.doFinal(bits);
// HMAC-SHA256 the info with the intermediate key as the HMAC key.
final SecretKey intermediateKey = new SecretKeySpec(intermediateBits, JcaAlgorithm.HMAC_SHA256);
final Mac finalMac = Mac.getInstance(intermediateKey.getAlgorithm());
finalMac.init(intermediateKey);
final byte[] finalBits = finalMac.doFinal(INFO);
// Grab the first 128 bits.
return Arrays.copyOf(finalBits, WRAPPING_KEY_LENGTH);
} catch (final NoSuchAlgorithmException e) {
throw new MslInternalException(JcaAlgorithm.HMAC_SHA256 + " algorithm not found.", e);
} catch (final InvalidKeyException e) {
throw new MslInternalException("Invalid " + JcaAlgorithm.HMAC_SHA256 + " key.", e);
}
}
}
| 9,999 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.