index
int64 0
0
| repo_id
stringlengths 26
205
| file_path
stringlengths 51
246
| content
stringlengths 8
433k
| __index_level_0__
int64 0
10k
|
|---|---|---|---|---|
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 <[email protected]>
*/
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;
}
| 1,800 |
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 <[email protected]>
*/
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());
}
}
| 1,801 |
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 <[email protected]>
*/
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());
}
}
| 1,802 |
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 <[email protected]>
*/
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();
}
}
| 1,803 |
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 <[email protected]>
*/
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());
}
}
| 1,804 |
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 <[email protected]>
*/
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));
}
}
| 1,805 |
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 <[email protected]>
*/
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());
}
}
| 1,806 |
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 <[email protected]>
*/
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);
}
}
| 1,807 |
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 <[email protected]>
*/
@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());
}
}
}
| 1,808 |
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 <[email protected]>
*/
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());
}
}
| 1,809 |
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 <[email protected]>
*/
@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);
}
}
}
| 1,810 |
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 <[email protected]>
*/
@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;
}
}
| 1,811 |
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 <[email protected]>
*/
@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);
}
}
}
| 1,812 |
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 <[email protected]>
*/
@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;
}
}
| 1,813 |
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 <[email protected]>
*/
@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;
}
}
| 1,814 |
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 <[email protected]>
*/
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;
}
| 1,815 |
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 <[email protected]>
*/
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;
}
| 1,816 |
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 <[email protected]>
*/
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();
}
}
| 1,817 |
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 <[email protected]>
*/
@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);
}
}
}
| 1,818 |
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 <[email protected]>
*/
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;
}
| 1,819 |
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 <[email protected]>
*/
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);
}
}
| 1,820 |
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 <[email protected]>
*/
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);
}
}
| 1,821 |
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 <[email protected]>
*/
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);
}
}
| 1,822 |
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 <[email protected]>
*/
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;
}
| 1,823 |
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 <[email protected]>
*/
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;
}
| 1,824 |
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 <[email protected]>
*/
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());
}
}
| 1,825 |
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 <[email protected]>
*/
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;
}
| 1,826 |
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 <[email protected]>
*/
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;
}
| 1,827 |
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 <[email protected]>
*/
@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;
}
| 1,828 |
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 <[email protected]>
*/
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;
}
| 1,829 |
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 <[email protected]>
*/
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;
}
| 1,830 |
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 <[email protected]>
*/
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;
}
| 1,831 |
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 <[email protected]>
*/
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;
}
| 1,832 |
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 <[email protected]>
*/
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;
}
| 1,833 |
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;
}
| 1,834 |
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 <[email protected]>
*/
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;
}
| 1,835 |
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 <[email protected]>
*/
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);
}
}
| 1,836 |
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 <[email protected]>
*/
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;
}
| 1,837 |
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 <[email protected]>
*/
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;
}
| 1,838 |
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;
}
| 1,839 |
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 <[email protected]>
*/
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;
}
| 1,840 |
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 <[email protected]>
*/
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;
}
| 1,841 |
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 <[email protected]>
*/
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());
}
}
| 1,842 |
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 <[email protected]>
*/
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;
}
| 1,843 |
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 <[email protected]>
*/
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;
}
| 1,844 |
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 <[email protected]>
*/
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;
}
| 1,845 |
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 <[email protected]>
*/
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;
}
| 1,846 |
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 <[email protected]>
*/
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;
}
| 1,847 |
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();
}
}
| 1,848 |
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 <[email protected]>
*/
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>>();
}
| 1,849 |
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 <[email protected]>
*/
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);
}
}
}
| 1,850 |
0 |
Create_ds/msl/tests/src/main/java/com/netflix/msl
|
Create_ds/msl/tests/src/main/java/com/netflix/msl/util/MockMslContext.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.util;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import com.netflix.msl.MslConstants.CompressionAlgorithm;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.crypto.JcaAlgorithm;
import com.netflix.msl.crypto.SymmetricCryptoContext;
import com.netflix.msl.entityauth.EntityAuthenticationData;
import com.netflix.msl.entityauth.EntityAuthenticationFactory;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.entityauth.MasterTokenProtectedAuthenticationFactory;
import com.netflix.msl.entityauth.MockIdentityProvisioningService;
import com.netflix.msl.entityauth.MockPresharedAuthenticationFactory;
import com.netflix.msl.entityauth.MockPresharedProfileAuthenticationFactory;
import com.netflix.msl.entityauth.MockRsaAuthenticationFactory;
import com.netflix.msl.entityauth.MockEccAuthenticationFactory;
import com.netflix.msl.entityauth.MockX509AuthenticationFactory;
import com.netflix.msl.entityauth.PresharedAuthenticationData;
import com.netflix.msl.entityauth.PresharedProfileAuthenticationData;
import com.netflix.msl.entityauth.ProvisionedAuthenticationFactory;
import com.netflix.msl.entityauth.RsaAuthenticationData;
import com.netflix.msl.entityauth.EccAuthenticationData;
import com.netflix.msl.entityauth.UnauthenticatedAuthenticationData;
import com.netflix.msl.entityauth.UnauthenticatedAuthenticationFactory;
import com.netflix.msl.entityauth.UnauthenticatedSuffixedAuthenticationData;
import com.netflix.msl.entityauth.UnauthenticatedSuffixedAuthenticationFactory;
import com.netflix.msl.entityauth.X509AuthenticationData;
import com.netflix.msl.io.DefaultMslEncoderFactory;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.keyx.AsymmetricWrappedExchange;
import com.netflix.msl.keyx.DiffieHellmanExchange;
import com.netflix.msl.keyx.KeyExchangeFactory;
import com.netflix.msl.keyx.KeyExchangeScheme;
import com.netflix.msl.keyx.MockDiffieHellmanParameters;
import com.netflix.msl.keyx.SymmetricWrappedExchange;
import com.netflix.msl.msg.MessageCapabilities;
import com.netflix.msl.tokens.MockTokenFactory;
import com.netflix.msl.tokens.TokenFactory;
import com.netflix.msl.userauth.MockEmailPasswordAuthenticationFactory;
import com.netflix.msl.userauth.MockUserIdTokenAuthenticationFactory;
import com.netflix.msl.userauth.UserAuthenticationFactory;
import com.netflix.msl.userauth.UserAuthenticationScheme;
/**
* MSL context for unit tests.
*
* @author Wesley Miaw <[email protected]>
*/
public class MockMslContext extends MslContext {
/** MSL encryption key. */
private static final byte[] MSL_ENCRYPTION_KEY = {
(byte)0x1d, (byte)0x58, (byte)0xf3, (byte)0xb8, (byte)0xf7, (byte)0x47, (byte)0xd1, (byte)0x6a,
(byte)0xb1, (byte)0x93, (byte)0xc4, (byte)0xc0, (byte)0xa6, (byte)0x24, (byte)0xea, (byte)0xcf,
};
/** MSL HMAC key. */
private static final byte[] MSL_HMAC_KEY = {
(byte)0xd7, (byte)0xae, (byte)0xbf, (byte)0xd5, (byte)0x87, (byte)0x9b, (byte)0xb0, (byte)0xe0,
(byte)0xad, (byte)0x01, (byte)0x6a, (byte)0x4c, (byte)0xf3, (byte)0xcb, (byte)0x39, (byte)0x82,
(byte)0xf5, (byte)0xba, (byte)0x26, (byte)0x0d, (byte)0xa5, (byte)0x20, (byte)0x24, (byte)0x5b,
(byte)0xb4, (byte)0x22, (byte)0x75, (byte)0xbd, (byte)0x79, (byte)0x47, (byte)0x37, (byte)0x0c,
};
/** MSL wrapping key. */
private static final byte[] MSL_WRAPPING_KEY = {
(byte)0x83, (byte)0xb6, (byte)0x9a, (byte)0x15, (byte)0x80, (byte)0xd3, (byte)0x23, (byte)0xa2,
(byte)0xe7, (byte)0x9d, (byte)0xd9, (byte)0xb2, (byte)0x26, (byte)0x26, (byte)0xb3, (byte)0xf6,
};
/**
* Key exchange factory comparator.
*/
private static class KeyExchangeFactoryComparator implements Comparator<KeyExchangeFactory> {
/** Scheme priorities. Lower values are higher priority. */
private final Map<KeyExchangeScheme,Integer> schemePriorities = new HashMap<KeyExchangeScheme,Integer>();
/**
* Create a new key exchange factory comparator.
*/
public KeyExchangeFactoryComparator() {
schemePriorities.put(KeyExchangeScheme.JWK_LADDER, 0);
schemePriorities.put(KeyExchangeScheme.JWE_LADDER, 1);
schemePriorities.put(KeyExchangeScheme.DIFFIE_HELLMAN, 2);
schemePriorities.put(KeyExchangeScheme.SYMMETRIC_WRAPPED, 3);
schemePriorities.put(KeyExchangeScheme.ASYMMETRIC_WRAPPED, 4);
}
/* (non-Javadoc)
* @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
*/
@Override
public int compare(final KeyExchangeFactory a, final KeyExchangeFactory b) {
final KeyExchangeScheme schemeA = a.getScheme();
final KeyExchangeScheme schemeB = b.getScheme();
final Integer priorityA = schemePriorities.get(schemeA);
final Integer priorityB = schemePriorities.get(schemeB);
return priorityA.compareTo(priorityB);
}
}
/**
* Create a new test MSL context.
*
* @param scheme entity authentication scheme.
* @param peerToPeer true if the context should operate in peer-to-peer
* mode.
* @throws MslCryptoException if there is an error signing or creating the
* entity authentication data.
* @throws MslEncodingException if there is an error creating the entity
* authentication data.
*/
public MockMslContext(final EntityAuthenticationScheme scheme, final boolean peerToPeer) throws MslEncodingException, MslCryptoException {
this.peerToPeer = peerToPeer;
if (EntityAuthenticationScheme.PSK.equals(scheme))
entityAuthData = new PresharedAuthenticationData(MockPresharedAuthenticationFactory.PSK_ESN);
else if (EntityAuthenticationScheme.PSK_PROFILE.equals(scheme))
entityAuthData = new PresharedProfileAuthenticationData(MockPresharedProfileAuthenticationFactory.PSK_ESN, MockPresharedProfileAuthenticationFactory.PROFILE);
else if (EntityAuthenticationScheme.X509.equals(scheme))
entityAuthData = new X509AuthenticationData(MockX509AuthenticationFactory.X509_CERT);
else if (EntityAuthenticationScheme.RSA.equals(scheme))
entityAuthData = new RsaAuthenticationData(MockRsaAuthenticationFactory.RSA_ESN, MockRsaAuthenticationFactory.RSA_PUBKEY_ID);
else if (EntityAuthenticationScheme.ECC.equals(scheme))
entityAuthData = new EccAuthenticationData(MockEccAuthenticationFactory.ECC_ESN, MockEccAuthenticationFactory.ECC_PUBKEY_ID);
else if (EntityAuthenticationScheme.NONE.equals(scheme))
entityAuthData = new UnauthenticatedAuthenticationData("MOCKUNAUTH-ESN");
else if (EntityAuthenticationScheme.NONE_SUFFIXED.equals(scheme))
entityAuthData = new UnauthenticatedSuffixedAuthenticationData("MOCKUNAUTH-ROOT", "MOCKUNAUTH-SUFFIX");
else
throw new IllegalArgumentException("Unsupported authentication type: " + scheme.name());
final Set<CompressionAlgorithm> algos = new HashSet<CompressionAlgorithm>();
algos.add(CompressionAlgorithm.GZIP);
algos.add(CompressionAlgorithm.LZW);
final List<String> languages = Arrays.asList(new String[] { "en-US" });
final Set<MslEncoderFormat> formats = new HashSet<MslEncoderFormat>();
formats.add(MslEncoderFormat.JSON);
capabilities = new MessageCapabilities(algos, languages, formats);
final SecretKey mslEncryptionKey = new SecretKeySpec(MSL_ENCRYPTION_KEY, JcaAlgorithm.AES);
final SecretKey mslHmacKey = new SecretKeySpec(MSL_HMAC_KEY, JcaAlgorithm.HMAC_SHA256);
final SecretKey mslWrappingKey = new SecretKeySpec(MSL_WRAPPING_KEY, JcaAlgorithm.AESKW);
mslCryptoContext = new SymmetricCryptoContext(this, "TestMslKeys", mslEncryptionKey, mslHmacKey, mslWrappingKey);
tokenFactory = new MockTokenFactory();
store = new SimpleMslStore();
encoderFactory = new DefaultMslEncoderFactory();
final MockDiffieHellmanParameters params = MockDiffieHellmanParameters.getDefaultParameters();
final AuthenticationUtils authutils = new MockAuthenticationUtils();
entityAuthFactories = new HashMap<EntityAuthenticationScheme,EntityAuthenticationFactory>();
entityAuthFactories.put(EntityAuthenticationScheme.PSK, new MockPresharedAuthenticationFactory());
entityAuthFactories.put(EntityAuthenticationScheme.PSK_PROFILE, new MockPresharedProfileAuthenticationFactory());
entityAuthFactories.put(EntityAuthenticationScheme.RSA, new MockRsaAuthenticationFactory());
entityAuthFactories.put(EntityAuthenticationScheme.ECC, new MockEccAuthenticationFactory());
entityAuthFactories.put(EntityAuthenticationScheme.NONE, new UnauthenticatedAuthenticationFactory(authutils));
entityAuthFactories.put(EntityAuthenticationScheme.X509, new MockX509AuthenticationFactory());
entityAuthFactories.put(EntityAuthenticationScheme.NONE_SUFFIXED, new UnauthenticatedSuffixedAuthenticationFactory(authutils));
entityAuthFactories.put(EntityAuthenticationScheme.MT_PROTECTED, new MasterTokenProtectedAuthenticationFactory(authutils));
entityAuthFactories.put(EntityAuthenticationScheme.PROVISIONED, new ProvisionedAuthenticationFactory(new MockIdentityProvisioningService(this)));
userAuthFactories = new HashMap<UserAuthenticationScheme,UserAuthenticationFactory>();
userAuthFactories.put(UserAuthenticationScheme.EMAIL_PASSWORD, new MockEmailPasswordAuthenticationFactory());
userAuthFactories.put(UserAuthenticationScheme.USER_ID_TOKEN, new MockUserIdTokenAuthenticationFactory());
keyxFactories = new TreeSet<KeyExchangeFactory>(new KeyExchangeFactoryComparator());
keyxFactories.add(new AsymmetricWrappedExchange(authutils));
keyxFactories.add(new SymmetricWrappedExchange(authutils));
keyxFactories.add(new DiffieHellmanExchange(params, authutils));
}
@Override
public long getTime() {
return System.currentTimeMillis();
}
@Override
public Random getRandom() {
return new Random();
}
@Override
public boolean isPeerToPeer() {
return peerToPeer;
}
/**
* Set the message capabilities.
*
* @param capabilities the new message capabilities.
*/
public void setMessageCapabilities(final MessageCapabilities capabilities) {
this.capabilities = capabilities;
}
@Override
public MessageCapabilities getMessageCapabilities() {
return capabilities;
}
/**
* Set the entity authentication data.
*
* @param entityAuthData the new entity authentication data.
*/
public void setEntityAuthenticationData(final EntityAuthenticationData entityAuthData) {
this.entityAuthData = entityAuthData;
}
@Override
public EntityAuthenticationData getEntityAuthenticationData(final ReauthCode reauthCode) {
return entityAuthData;
}
/**
* Set the MSL crypto context.
*
* @param cryptoContext the new MSL crypto context.
*/
public void setMslCryptoContext(final ICryptoContext cryptoContext) {
mslCryptoContext = cryptoContext;
}
@Override
public ICryptoContext getMslCryptoContext() throws MslCryptoException {
return mslCryptoContext;
}
@Override
public EntityAuthenticationScheme getEntityAuthenticationScheme(final String name) {
return EntityAuthenticationScheme.getScheme(name);
}
/**
* Adds or replaces the entity authentication factory associated with the
* entity authentication scheme of the provided factory.
*
* @param factory entity authentication factory.
*/
public void addEntityAuthenticationFactory(final EntityAuthenticationFactory factory) {
entityAuthFactories.put(factory.getScheme(), factory);
}
/**
* Removes the entity authentication factory associated with the specified
* entity authentication scheme.
*
* @param scheme entity authentication scheme.
*/
public void removeEntityAuthenticationFactory(final EntityAuthenticationScheme scheme) {
entityAuthFactories.remove(scheme);
}
@Override
public EntityAuthenticationFactory getEntityAuthenticationFactory(final EntityAuthenticationScheme scheme) {
return entityAuthFactories.get(scheme);
}
@Override
public UserAuthenticationScheme getUserAuthenticationScheme(final String name) {
return UserAuthenticationScheme.getScheme(name);
}
/**
* Adds or replaces the user authentication factory associated with the
* user authentication scheme of the provided factory.
*
* @param factory user authentication factory.
*/
public void addUserAuthenticationFactory(final UserAuthenticationFactory factory) {
userAuthFactories.put(factory.getScheme(), factory);
}
/**
* Removes the user authentication factory associated with the specified
* user authentication scheme.
*
* @param scheme user authentication scheme.
*/
public void removeUserAuthenticationFactory(final UserAuthenticationScheme scheme) {
userAuthFactories.remove(scheme);
}
@Override
public UserAuthenticationFactory getUserAuthenticationFactory(final UserAuthenticationScheme scheme) {
return userAuthFactories.get(scheme);
}
/**
* Sets the token factory.
*
* @param factory the token factory.
*/
public void setTokenFactory(final TokenFactory factory) {
this.tokenFactory = factory;
}
@Override
public TokenFactory getTokenFactory() {
return tokenFactory;
}
@Override
public KeyExchangeScheme getKeyExchangeScheme(final String name) {
return KeyExchangeScheme.getScheme(name);
}
/**
* Adds a key exchange factory to the end of the preferred set.
*
* @param factory key exchange factory.
*/
public void addKeyExchangeFactory(final KeyExchangeFactory factory) {
keyxFactories.add(factory);
}
/**
* Removes all key exchange factories associated with the specified key
* exchange scheme.
*
* @param scheme key exchange scheme.
*/
public void removeKeyExchangeFactories(final KeyExchangeScheme scheme) {
final Iterator<KeyExchangeFactory> factories = keyxFactories.iterator();
while (factories.hasNext()) {
final KeyExchangeFactory factory = factories.next();
if (factory.getScheme().equals(scheme))
factories.remove();
}
}
@Override
public KeyExchangeFactory getKeyExchangeFactory(final KeyExchangeScheme scheme) {
for (final KeyExchangeFactory factory : keyxFactories) {
if (factory.getScheme().equals(scheme))
return factory;
}
return null;
}
@Override
public SortedSet<KeyExchangeFactory> getKeyExchangeFactories() {
return Collections.unmodifiableSortedSet(keyxFactories);
}
/**
* Sets the MSL store.
*
* @param store the MSL store.
*/
public void setMslStore(final MslStore store) {
this.store = store;
}
@Override
public MslStore getMslStore() {
return store;
}
/**
* Sets the MSL encoder factory.
*
* @param encoderFactory the MSL encoder factory.
*/
public void setMslEncoderFactory(final MslEncoderFactory encoderFactory) {
this.encoderFactory = encoderFactory;
}
@Override
public MslEncoderFactory getMslEncoderFactory() {
return encoderFactory;
}
/** Peer-to-peer mode. */
private final boolean peerToPeer;
/** Message capabilities. */
private MessageCapabilities capabilities;
/** Entity authentication data. */
private EntityAuthenticationData entityAuthData;
/** MSL crypto context. */
private ICryptoContext mslCryptoContext;
/** Map of supported entity authentication schemes onto factories. */
private final Map<EntityAuthenticationScheme,EntityAuthenticationFactory> entityAuthFactories;
/** Map of supported user authentication schemes onto factories. */
private final Map<UserAuthenticationScheme,UserAuthenticationFactory> userAuthFactories;
/** Token factory. */
private TokenFactory tokenFactory;
/** Supported key exchange factories in preferred order. */
private final SortedSet<KeyExchangeFactory> keyxFactories;
/** MSL store. */
private MslStore store;
/** MSL encoder factory. */
private MslEncoderFactory encoderFactory;
}
| 1,851 |
0 |
Create_ds/msl/tests/src/main/java/com/netflix/msl
|
Create_ds/msl/tests/src/main/java/com/netflix/msl/msg/MockMessageContext.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 java.io.IOException;
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.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
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 com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslKeyExchangeException;
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.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.KeyRequestData;
import com.netflix.msl.keyx.MockDiffieHellmanParameters;
import com.netflix.msl.keyx.SymmetricWrappedExchange;
import com.netflix.msl.keyx.SymmetricWrappedExchange.KeyId;
import com.netflix.msl.tokens.MslUser;
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.MslContext;
/**
* Test message context.
*
* The {@link #updateServiceTokens(MessageServiceTokenBuilder, boolean)} and
* {@link #write(MessageOutputStream)} methods do nothing. Unit tests should
* override those methods for the specific test.
*
* @author Wesley Miaw <[email protected]>
*/
public class MockMessageContext implements MessageContext {
private static final String DH_PARAMETERS_ID = "1";
private static final String RSA_KEYPAIR_ID = "rsaKeypairId";
/** Service token name for crypto context. */
public static final String SERVICE_TOKEN_NAME = "serviceToken";
/** Default service token crypto context name (empty string). */
public static final String DEFAULT_SERVICE_TOKEN_NAME = "";
/**
* @param ctx MSL context.
* @param bitlength key length in bits.
* @return a new key of the specified bit length.
*/
private static SecretKey getSecretKey(final MslContext ctx, final int bitlength, final String algorithm) {
final byte[] keydata = new byte[bitlength / Byte.SIZE];
ctx.getRandom().nextBytes(keydata);
return new SecretKeySpec(keydata, algorithm);
}
/**
* Create a new test message context.
*
* The message will not be encrypted or non-replayable.
*
* @param ctx MSL context.
* @param userId user ID. May be {@code null}.
* @param scheme user authentication scheme. May be {@code null}.
* @throws NoSuchAlgorithmException if a key generation algorithm is not
* found.
* @throws InvalidAlgorithmParameterException if key generation parameters
* are invalid.
* @throws MslKeyExchangeException if there is an error accessing Diffie-
* Hellman parameters.
*/
public MockMessageContext(final MslContext ctx, final String userId, final UserAuthenticationScheme scheme) throws NoSuchAlgorithmException, InvalidAlgorithmParameterException, MslKeyExchangeException {
this.remoteEntityIdentity = null;
this.encrypted = false;
this.integrityProtected = false;
this.nonReplayable = false;
this.requestingTokens = false;
this.userId = userId;
this.user = null;
this.debugContext = null;
if (UserAuthenticationScheme.EMAIL_PASSWORD.equals(scheme)) {
userAuthData = new EmailPasswordAuthenticationData(MockEmailPasswordAuthenticationFactory.EMAIL, MockEmailPasswordAuthenticationFactory.PASSWORD);
} else if (scheme != null) {
throw new IllegalArgumentException("Unsupported authentication type: " + scheme.name());
}
keyRequestData = new HashSet<KeyRequestData>();
{
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();
keyRequestData.add(new DiffieHellmanExchange.RequestData(DH_PARAMETERS_ID, publicKey, privateKey));
}
{
final KeyPairGenerator rsaGenerator = KeyPairGenerator.getInstance("RSA");
final KeyPair rsaKeyPair = rsaGenerator.generateKeyPair();
final PublicKey publicKey = rsaKeyPair.getPublic();
final PrivateKey privateKey = rsaKeyPair.getPrivate();
keyRequestData.add(new AsymmetricWrappedExchange.RequestData(RSA_KEYPAIR_ID, Mechanism.RSA, publicKey, privateKey));
}
{
keyRequestData.add(new SymmetricWrappedExchange.RequestData(KeyId.PSK));
}
cryptoContexts = new HashMap<String,ICryptoContext>();
cryptoContexts.put(SERVICE_TOKEN_NAME, new SymmetricCryptoContext(ctx, SERVICE_TOKEN_NAME, getSecretKey(ctx, 128, JcaAlgorithm.AES), getSecretKey(ctx, 256, JcaAlgorithm.HMAC_SHA256), null));
cryptoContexts.put(DEFAULT_SERVICE_TOKEN_NAME, new SymmetricCryptoContext(ctx, DEFAULT_SERVICE_TOKEN_NAME, getSecretKey(ctx, 128, JcaAlgorithm.AES), getSecretKey(ctx, 256, JcaAlgorithm.HMAC_SHA256), null));
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getCryptoContexts()
*/
@Override
public Map<String,ICryptoContext> getCryptoContexts() {
return Collections.unmodifiableMap(cryptoContexts);
}
/**
* Remove a service token crypto context.
*
* @param name service token name.
*/
public void removeCryptoContext(final String name) {
cryptoContexts.remove(name);
}
/**
* @param remoteEntityIdentity the message remote entity identity or {@code null} if unknown.
*/
public void setRemoteEntityIdentity(final String remoteEntityIdentity) {
this.remoteEntityIdentity = remoteEntityIdentity;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getRemoteEntityIdentity()
*/
@Override
public String getRemoteEntityIdentity() {
return remoteEntityIdentity;
}
/**
* @param encrypted true if the message must be encrypted.
*/
public void setEncrypted(final boolean encrypted) {
this.encrypted = encrypted;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#isEncrypted()
*/
@Override
public boolean isEncrypted() {
return encrypted;
}
/**
* @param integrityProtected true if the message must be integrity
* protected.
*/
public void setIntegrityProtected(final boolean integrityProtected) {
this.integrityProtected = integrityProtected;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#isIntegrityProtected()
*/
@Override
public boolean isIntegrityProtected() {
return integrityProtected;
}
/**
* @param requestingTokens true if the message is requesting tokens.
*/
public void setRequestingTokens(final boolean requestingTokens) {
this.requestingTokens = requestingTokens;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#isRequestingTokens()
*/
@Override
public boolean isRequestingTokens() {
return requestingTokens;
}
/**
* @param nonReplayable true if the message must be non-replayable.
*/
public void setNonReplayable(final boolean nonReplayable) {
this.nonReplayable = nonReplayable;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#isNonReplayable()
*/
@Override
public boolean isNonReplayable() {
return nonReplayable;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getUserId()
*/
@Override
public String getUserId() {
return userId;
}
/**
* @param userAuthData the new user authentication data.
*/
public void setUserAuthData(final UserAuthenticationData userAuthData) {
this.userAuthData = userAuthData;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getUserAuthData(com.netflix.msl.msg.MessageContext.ReauthCode, boolean, boolean)
*/
@Override
public UserAuthenticationData getUserAuthData(final ReauthCode reauth, final boolean renewable, final boolean required) {
// Default implementation just returns the existing user authentication
// data. Override to implement specific behavior.
return userAuthData;
}
/**
* @param user the remote user.
*/
public void setUser(final MslUser user) {
this.user = user;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getUser()
*/
@Override
public MslUser getUser() {
return user;
}
/**
* @param keyRequestData the new key request data.
*/
public void setKeyRequestData(final Set<KeyRequestData> keyRequestData) {
this.keyRequestData.clear();
this.keyRequestData.addAll(keyRequestData);
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getKeyRequestData()
*/
@Override
public Set<KeyRequestData> getKeyRequestData() {
return Collections.unmodifiableSet(keyRequestData);
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#updateServiceTokens(com.netflix.msl.msg.MessageServiceTokenBuilder, boolean)
*/
@Override
public void updateServiceTokens(final MessageServiceTokenBuilder builder, final boolean handshake) throws MslMessageException, MslCryptoException, MslEncodingException {
// Default implementation does nothing. Override to implement specific
// behavior.
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#write(com.netflix.msl.msg.MessageOutputStream)
*/
@Override
public void write(final MessageOutputStream output) throws IOException {
// Default implementation does nothing. Override to implement specific
// behavior.
}
/**
* @param debugContext the new message debug context.
*/
public void setMessageDebugContext(final MessageDebugContext debugContext) {
this.debugContext = debugContext;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getDebugContext()
*/
@Override
public MessageDebugContext getDebugContext() {
return debugContext;
}
/** Message remote entity identity. */
private String remoteEntityIdentity;
/** Message requires encryption. */
private boolean encrypted;
/** Message requires integrity protection. */
private boolean integrityProtected;
/** Message must be non-replayable. */
private boolean nonReplayable;
/** Message is requesting tokens. */
private boolean requestingTokens;
/** Message user ID. */
private final String userId;
/** Message user authentication data. */
private UserAuthenticationData userAuthData;
/** Message remote user. */
private MslUser user;
/** Key request data. */
private final Set<KeyRequestData> keyRequestData;
/** Service token crypto contexts. */
private final Map<String,ICryptoContext> cryptoContexts;
/** Message debug context. */
private MessageDebugContext debugContext;
}
| 1,852 |
0 |
Create_ds/msl/tests/src/main/java/com/netflix/msl
|
Create_ds/msl/tests/src/main/java/com/netflix/msl/keyx/MockCryptoContextRepository.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.keyx;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import com.netflix.msl.crypto.ICryptoContext;
/**
* This crypto context repository provides a simple in-memory store of wrapping
* key crypto contexts.
*
* This class is thread-safe.
*
* @author Wesley Miaw <[email protected]>
*/
public class MockCryptoContextRepository implements WrapCryptoContextRepository {
/* (non-Javadoc)
* @see com.netflix.msl.keyx.JsonWebEncryptionLadderExchange.CryptoContextRepository#addCryptoContext(byte[], com.netflix.msl.crypto.ICryptoContext)
*/
@Override
public synchronized void addCryptoContext(final byte[] wrapdata, final ICryptoContext cryptoContext) {
cryptoContexts.put(wrapdata, cryptoContext);
this.wrapdata = wrapdata;
}
@Override
public synchronized ICryptoContext getCryptoContext(final byte[] wrapdata) {
return cryptoContexts.get(wrapdata);
}
/* (non-Javadoc)
* @see com.netflix.msl.keyx.JsonWebEncryptionLadderExchange.CryptoContextRepository#removeCryptoContext(byte[])
*/
@Override
public synchronized void removeCryptoContext(final byte[] wrapdata) {
cryptoContexts.remove(wrapdata);
if (Arrays.equals(this.wrapdata, wrapdata))
this.wrapdata = null;
}
/**
* @return the newest wrap data or null if there is none.
*/
public synchronized byte[] getWrapdata() {
return wrapdata;
}
/**
* Clear the repository of all state data.
*/
public synchronized void clear() {
cryptoContexts.clear();
wrapdata = null;
}
/** Newest wrap data. */
private byte[] wrapdata;
/** Map of wrap data onto crypto contexts. */
private final Map<byte[],ICryptoContext> cryptoContexts = new HashMap<byte[],ICryptoContext>();
}
| 1,853 |
0 |
Create_ds/msl/tests/src/main/java/com/netflix/msl
|
Create_ds/msl/tests/src/main/java/com/netflix/msl/keyx/MockDiffieHellmanParameters.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.keyx;
import java.math.BigInteger;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import javax.crypto.spec.DHParameterSpec;
/**
* Test Diffie-Hellman parameters.
*
* @author Wesley Miaw <[email protected]>
*/
public class MockDiffieHellmanParameters implements DiffieHellmanParameters {
/** Default parameters. */
private static BigInteger p = new BigInteger("C2048E076B268761DB1427BA3AD98473D32B0ABDEE98C0827923426F294EDA3392BF0032A1D8092055B58BAA07586A7D3E271C39A8C891F5CEEA4DEBDFA6B023", 16);
private static BigInteger g = new BigInteger("02", 16);
/** Default parameter ID. */
public static final String DEFAULT_ID = "default1";
/**
* Returns the default test parameters containing a single set of Diffie-
* Hellman parameters associated with parameter ID {@link #DEFAULT_ID}.
*
* @return the default test parameters.
*/
public static MockDiffieHellmanParameters getDefaultParameters() {
final MockDiffieHellmanParameters params = new MockDiffieHellmanParameters();
final DHParameterSpec paramSpec = new DHParameterSpec(p, g);
params.addParameterSpec(DEFAULT_ID, paramSpec);
return params;
}
/**
* Add Diffie-Hellman parameters.
*
* @param id parameters ID.
* @param spec Diffie-Hellman parameters.
*/
public void addParameterSpec(final String id, final DHParameterSpec spec) {
params.put(id, spec);
}
/**
* Remove all known parameter specs.
*/
public void clear() {
params.clear();
}
/* (non-Javadoc)
* @see com.netflix.msl.keyx.DiffieHellmanParameters#getParameterSpecs()
*/
@Override
public Map<String,DHParameterSpec> getParameterSpecs() {
return Collections.unmodifiableMap(params);
}
/* (non-Javadoc)
* @see com.netflix.msl.keyx.DiffieHellmanParameters#getParameterSpec(java.lang.String)
*/
@Override
public DHParameterSpec getParameterSpec(final String id) {
return params.get(id);
}
/** Diffie-Hellman parameters. */
private final Map<String,DHParameterSpec> params = new HashMap<String,DHParameterSpec>();
}
| 1,854 |
0 |
Create_ds/msl/tests/src/main/java/com/netflix/msl
|
Create_ds/msl/tests/src/main/java/com/netflix/msl/userauth/MockEmailPasswordAuthenticationFactory.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.userauth;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
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.MockMslUser;
import com.netflix.msl.tokens.MslUser;
import com.netflix.msl.tokens.UserIdToken;
import com.netflix.msl.util.MslContext;
/**
* Test email/password authentication factory.
*
* @author Wesley Miaw <[email protected]>
*/
public class MockEmailPasswordAuthenticationFactory extends UserAuthenticationFactory {
/** Email. */
public static final String EMAIL = "[email protected]";
/** Password. */
public static final String PASSWORD = "password";
/** User. */
public static final MslUser USER = new MockMslUser(312204600);
/** Email #2. */
public static final String EMAIL_2 = "[email protected]";
/** Password #2. */
public static final String PASSWORD_2 = "password2";
/** User #2. */
public static final MslUser USER_2 = new MockMslUser(880083944);
/**
* Create a new test email/password authentication factory.
*/
public MockEmailPasswordAuthenticationFactory() {
super(UserAuthenticationScheme.EMAIL_PASSWORD);
}
/* (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 {
return new EmailPasswordAuthenticationData(userAuthMo);
}
/* (non-Javadoc)
* @see com.netflix.msl.userauth.EmailPasswordAuthenticationFactory#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 EmailPasswordAuthenticationData))
throw new MslInternalException("Incorrect authentication data type " + data.getClass().getName() + ".");
final EmailPasswordAuthenticationData epad = (EmailPasswordAuthenticationData)data;
// Extract and check email and password values.
final String epadEmail = epad.getEmail();
final String epadPassword = epad.getPassword();
if (epadEmail == null || epadPassword == null)
throw new MslUserAuthException(MslError.EMAILPASSWORD_BLANK).setUserAuthenticationData(epad);
final String email = epadEmail.trim();
final String password = epadPassword.trim();
if (email.isEmpty() || password.isEmpty())
throw new MslUserAuthException(MslError.EMAILPASSWORD_BLANK).setUserAuthenticationData(epad);
// Identify the user.
final MslUser user;
if (EMAIL.equals(email) && PASSWORD.equals(password))
user = USER;
else if (EMAIL_2.equals(email) && PASSWORD_2.equals(password))
user = USER_2;
else
throw new MslUserAuthException(MslError.EMAILPASSWORD_INCORRECT).setUserAuthenticationData(epad);
// 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);
}
// Return the user.
return user;
}
}
| 1,855 |
0 |
Create_ds/msl/tests/src/main/java/com/netflix/msl
|
Create_ds/msl/tests/src/main/java/com/netflix/msl/userauth/MockEmailPasswordStore.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 java.util.HashMap;
import java.util.Map;
import com.netflix.msl.tokens.MslUser;
/**
* Test email/password store.
*
* @author Wesley Miaw <[email protected]>
*/
public class MockEmailPasswordStore implements EmailPasswordStore {
/**
* A user and password pair.
*/
private static class UserAndPassword {
/**
* Create a new user and password pair.
*
* @param user MSL user.
* @param password user password.
*/
public UserAndPassword(final MslUser user, final String password) {
this.user = user;
this.password = password;
}
/** User. */
private final MslUser user;
/** User password. */
private final String password;
}
/**
* Add a user to the store.
*
* @param email email address.
* @param password password.
* @param user user.
*/
public void addUser(final String email, final String password, final MslUser user) {
if (email.trim().isEmpty())
throw new IllegalArgumentException("Email cannot be blank.");
if (password.trim().isEmpty())
throw new IllegalArgumentException("Password cannot be blank.");
final UserAndPassword iap = new UserAndPassword(user, password);
credentials.put(email, iap);
}
/**
* Clear all known users.
*/
public void clear() {
credentials.clear();
}
/* (non-Javadoc)
* @see com.netflix.msl.userauth.EmailPasswordStore#isUser(java.lang.String, java.lang.String)
*/
@Override
public MslUser isUser(final String email, final String password) {
final UserAndPassword iap = credentials.get(email);
if (iap == null || !iap.password.equals(password))
return null;
return iap.user;
}
/** Map of email addresses onto user ID and password pairs. */
private final Map<String,UserAndPassword> credentials = new HashMap<String,UserAndPassword>();
}
| 1,856 |
0 |
Create_ds/msl/tests/src/main/java/com/netflix/msl
|
Create_ds/msl/tests/src/main/java/com/netflix/msl/userauth/MockUserIdTokenAuthenticationFactory.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.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.MslContext;
/**
* Test user ID token authentication factory.
*
* @author Wesley Miaw <[email protected]>
*/
public class MockUserIdTokenAuthenticationFactory extends UserAuthenticationFactory {
/**
* Create a new test user ID token authentication factory. By default no
* tokens are accepted.
*/
public MockUserIdTokenAuthenticationFactory() {
super(UserAuthenticationScheme.USER_ID_TOKEN);
}
/**
* <p>Set the master token and user ID token pair to accept. The user ID
* token must be bound to the master token.</p>
*
* @param masterToken the master token to accept.
* @param userIdToken the user ID token to accept.
*/
public void setTokens(final MasterToken masterToken, final UserIdToken userIdToken) {
if (!userIdToken.isBoundTo(masterToken))
throw new MslInternalException("The user ID token must be bound to the master token.");
this.masterToken = masterToken;
this.userIdToken = userIdToken;
}
/**
* @return the accepted master token.
*/
public MasterToken getMasterToken() {
return masterToken;
}
/**
* @return the accepted user ID token.
*/
public UserIdToken getUserIdToken() {
return userIdToken;
}
/* (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;
// 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 user.
if (!uitadMasterToken.equals(masterToken) ||
!uitadUserIdToken.equals(userIdToken))
{
throw new MslUserAuthException(MslError.USERAUTH_ENTITYUSER_INCORRECT_DATA, "Authentication scheme " + this.getScheme() + " not permitted for entity " + identity + ".").setUserAuthenticationData(data);
}
// 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;
}
/** Master token. */
private MasterToken masterToken = null;
/** User ID token. */
private UserIdToken userIdToken = null;
}
| 1,857 |
0 |
Create_ds/msl/tests/src/main/java/com/netflix/msl
|
Create_ds/msl/tests/src/main/java/com/netflix/msl/tokens/MockTokenFactory.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 java.sql.Date;
import javax.crypto.SecretKey;
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.MslMasterTokenException;
import com.netflix.msl.MslUserIdTokenException;
import com.netflix.msl.entityauth.EntityAuthenticationData;
import com.netflix.msl.io.MslEncoderException;
import com.netflix.msl.io.MslEncoderUtils;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslUtils;
/**
* Token factory for unit tests.
*
* @author Wesley Miaw <[email protected]>
*/
public class MockTokenFactory implements TokenFactory {
/** Renewal window start offset in milliseconds. */
protected static final int RENEWAL_OFFSET = 60000;
/** Expiration offset in milliseconds. */
protected static final int EXPIRATION_OFFSET = 120000;
/** Non-replayable ID acceptance window. */
private static final long NON_REPLAYABLE_ID_WINDOW = 65536;
/**
* @param sequenceNumber the newest master token sequence number, or -1 to
* accept all master tokens as the newest.
*/
public void setNewestMasterToken(final long sequenceNumber) {
this.sequenceNumber = sequenceNumber;
}
/**
* @param masterToken the master token to consider revoked or {@code null}
* to unset.
*/
public void setRevokedMasterToken(final MasterToken masterToken) {
this.revokedMasterToken = masterToken;
}
/* (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) throws MslMasterTokenException {
if (!masterToken.isDecrypted())
throw new MslMasterTokenException(MslError.MASTERTOKEN_UNTRUSTED, masterToken);
if (this.revokedMasterToken != null && this.revokedMasterToken.getIdentity().equals(masterToken.getIdentity()))
return MslError.MASTERTOKEN_IDENTITY_REVOKED;
return null;
}
/**
* @param nonReplayableId the largest non-replayable ID, or -1 to accept
* all non-replayable IDs.
*/
public void setLargestNonReplayableId(final long nonReplayableId) {
this.largestNonReplayableId = nonReplayableId;
}
/* (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) throws MslMasterTokenException, MslException {
if (!masterToken.isDecrypted())
throw new MslMasterTokenException(MslError.MASTERTOKEN_UNTRUSTED, masterToken);
if (nonReplayableId < 0 || nonReplayableId > MslConstants.MAX_LONG_VALUE)
throw new MslException(MslError.NONREPLAYABLE_ID_OUT_OF_RANGE, "nonReplayableId " + nonReplayableId);
// Reject if the non-replayable ID is equal or just a few messages
// behind. The sender can recover by incrementing.
final long catchupWindow = MslConstants.MAX_MESSAGES / 2;
if (nonReplayableId <= largestNonReplayableId &&
nonReplayableId > largestNonReplayableId - catchupWindow)
{
return MslError.MESSAGE_REPLAYED;
}
// Reject if the non-replayable ID is larger by more than the
// acceptance window. The sender cannot recover quickly.
if (nonReplayableId - NON_REPLAYABLE_ID_WINDOW > largestNonReplayableId)
return MslError.MESSAGE_REPLAYED_UNRECOVERABLE;
// If the non-replayable ID is smaller reject it if it is outside the
// wrap-around window. The sender cannot recover quickly.
if (nonReplayableId < largestNonReplayableId) {
final long cutoff = largestNonReplayableId - MslConstants.MAX_LONG_VALUE + NON_REPLAYABLE_ID_WINDOW;
if (nonReplayableId >= cutoff)
return MslError.MESSAGE_REPLAYED_UNRECOVERABLE;
}
// Accept the non-replayable ID.
largestNonReplayableId = 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) throws MslEncodingException, MslCryptoException {
final Date renewalWindow = new Date(ctx.getTime() + RENEWAL_OFFSET);
final Date expiration = new Date(ctx.getTime() + EXPIRATION_OFFSET);
final long sequenceNumber = 0;
final long serialNumber = MslUtils.getRandomLong(ctx);
final String identity = entityAuthData.getIdentity();
return new MasterToken(ctx, renewalWindow, expiration, sequenceNumber, serialNumber, issuerData, identity, encryptionKey, hmacKey);
}
/* (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) throws MslMasterTokenException {
if (!masterToken.isDecrypted())
throw new MslMasterTokenException(MslError.MASTERTOKEN_UNTRUSTED, masterToken);
// Always succeed.
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) throws MslEncodingException, MslCryptoException, MslMasterTokenException {
if (!masterToken.isDecrypted())
throw new MslMasterTokenException(MslError.MASTERTOKEN_UNTRUSTED, masterToken);
final Date renewalWindow = new Date(ctx.getTime() + RENEWAL_OFFSET);
final Date expiration = new Date(ctx.getTime() + EXPIRATION_OFFSET);
final long oldSequenceNumber = masterToken.getSequenceNumber();
final long sequenceNumber;
if (this.sequenceNumber == -1) {
sequenceNumber = (oldSequenceNumber == MslConstants.MAX_LONG_VALUE) ? 0 : oldSequenceNumber + 1;
} else {
this.sequenceNumber = (this.sequenceNumber == MslConstants.MAX_LONG_VALUE) ? 0 : this.sequenceNumber + 1;
sequenceNumber = this.sequenceNumber;
}
final long serialNumber = masterToken.getSerialNumber();
final MslObject mtIssuerData = masterToken.getIssuerData();
final MslObject mergedIssuerData;
try {
mergedIssuerData = MslEncoderUtils.merge(mtIssuerData, issuerData);
} catch (final MslEncoderException e) {
throw new MslEncodingException(MslError.MASTERTOKEN_ISSUERDATA_ENCODE_ERROR, "mt issuerdata " + mtIssuerData + "; issuerdata " + issuerData, e);
}
final String identity = masterToken.getIdentity();
return new MasterToken(ctx, renewalWindow, expiration, sequenceNumber, serialNumber, mergedIssuerData, identity, encryptionKey, hmacKey);
}
/**
* @param userIdToken the user ID token to consider revoked or {@code null}
* to unset.
*/
public void setRevokedUserIdToken(final UserIdToken userIdToken) {
this.revokedUserIdToken = userIdToken;
}
/* (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) throws MslUserIdTokenException, MslMasterTokenException {
if (!masterToken.isDecrypted())
throw new MslMasterTokenException(MslError.MASTERTOKEN_UNTRUSTED, masterToken);
if (!userIdToken.isDecrypted())
throw new MslUserIdTokenException(MslError.USERIDTOKEN_NOT_DECRYPTED, userIdToken);
if (userIdToken.equals(this.revokedUserIdToken))
return MslError.USERIDTOKEN_REVOKED;
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) throws MslEncodingException, MslCryptoException {
final MslObject issuerData = null;
final Date renewalWindow = new Date(ctx.getTime() + RENEWAL_OFFSET);
final Date expiration = new Date(ctx.getTime() + EXPIRATION_OFFSET);
final long serialNumber = MslUtils.getRandomLong(ctx);
return new UserIdToken(ctx, renewalWindow, expiration, masterToken, serialNumber, issuerData, user);
}
/* (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) throws MslEncodingException, MslCryptoException, MslUserIdTokenException {
if (!userIdToken.isDecrypted())
throw new MslUserIdTokenException(MslError.USERIDTOKEN_NOT_DECRYPTED, userIdToken).setMasterToken(masterToken);
final MslObject issuerData = null;
final Date renewalWindow = new Date(ctx.getTime() + RENEWAL_OFFSET);
final Date expiration = new Date(ctx.getTime() + EXPIRATION_OFFSET);
final long serialNumber = userIdToken.getSerialNumber();
final MslUser user = userIdToken.getUser();
return new UserIdToken(ctx, renewalWindow, expiration, masterToken, serialNumber, issuerData, user);
}
/* (non-Javadoc)
* @see com.netflix.msl.tokens.TokenFactory#createUser(com.netflix.msl.util.MslContext, byte[])
*/
@Override
public MslUser createUser(final MslContext ctx, final String userdata) throws MslException {
try {
return new MockMslUser(userdata);
} catch (final IllegalArgumentException e) {
throw new MslException(MslError.USERIDTOKEN_IDENTITY_INVALID, userdata, e);
}
}
/**
* Reset the token factory state.
*/
public void reset() {
sequenceNumber = -1;
revokedMasterToken = null;
largestNonReplayableId = 0;
revokedUserIdToken = null;
}
/** Newest master token sequence number. (-1 accepts all master tokens.) */
protected long sequenceNumber = -1;
/** Revoked master token. (null accepts all master tokens.) */
private MasterToken revokedMasterToken = null;
/** Current largest non-replayable ID. */
private long largestNonReplayableId = 0;
/** Revoked user ID token. (null accepts all user ID tokens.) */
private UserIdToken revokedUserIdToken = null;
}
| 1,858 |
0 |
Create_ds/msl/tests/src/main/java/com/netflix/msl
|
Create_ds/msl/tests/src/main/java/com/netflix/msl/tokens/MockMslUser.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;
/**
* Test MSL user.
*
* @author Wesley Miaw <[email protected]>
*/
public class MockMslUser implements MslUser {
/**
* Create a new MSL user with the specified user ID.
*
* @param id MSL user ID.
*/
public MockMslUser(final long id) {
this.id = id;
}
/**
* Create a new MSL user from the serialized user data.
*
* @param userdata serialized user data.
* @throws IllegalArgumentException if the user data is invalid.
*/
public MockMslUser(final String userdata) {
try {
this.id = Long.parseLong(userdata);
} catch (final NumberFormatException e) {
throw new IllegalArgumentException("Invalid user data serialization: " + userdata, e);
}
}
/**
* @return the user ID.
*/
public Long getId() {
return id;
}
/* (non-Javadoc)
* @see com.netflix.msl.tokens.MslUser#getEncoded()
*/
@Override
public String getEncoded() {
return Long.toString(id);
}
/* (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 MockMslUser)) return false;
final MockMslUser that = (MockMslUser)obj;
return this.id == that.id;
}
/* (non-Javadoc)
* @see java.lang.Object#hashCode()
*/
@Override
public int hashCode() {
return Long.valueOf(id).hashCode();
}
/* (non-Javadoc)
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
return Long.toString(id);
}
/** User ID. */
private final long id;
}
| 1,859 |
0 |
Create_ds/msl/tests/src/main/java/com/netflix/msl
|
Create_ds/msl/tests/src/main/java/com/netflix/msl/entityauth/MockEccAuthenticationFactory.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.KeyFactory;
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.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
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.Base64;
import com.netflix.msl.util.MslContext;
/**
* Test ECC asymmetric keys authentication factory.
*/
public class MockEccAuthenticationFactory extends EntityAuthenticationFactory {
/** ECC public key. */
private static String ECC_PUBKEY_B64 =
"MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExgY6uU5xZkvDLVlo5PpKjhRJnyqS" +
"j4+LNcQ+x+kdPbZf1GwiJy2sRiJwghsXl9X8ffRpUqiLeNW0oOE/+dG2iw==";
/** ECC private key. */
private static String ECC_PRIVKEY_B64 =
"MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgrNqzpcZOpGRqlVGZ" +
"nelA4i7N/E96nJ8Ntk1ZXhPzKcChRANCAATGBjq5TnFmS8MtWWjk+kqOFEmfKpKP" +
"j4s1xD7H6R09tl/UbCInLaxGInCCGxeX1fx99GlSqIt41bSg4T/50baL";
/** ECC ESN. */
public static final String ECC_ESN = "ECCPREFIX-ESN";
/** ECC public key ID. */
public static final String ECC_PUBKEY_ID = "mockECCKeyId";
/** ECC public key. */
public static final PublicKey ECC_PUBKEY;
/** ECC private key. */
public static final PrivateKey ECC_PRIVKEY;
static {
Security.addProvider(new BouncyCastleProvider());
try {
final byte[] pubKeyEncoded = Base64.decode(ECC_PUBKEY_B64);
final byte[] privKeyEncoded = Base64.decode(ECC_PRIVKEY_B64);
final X509EncodedKeySpec pubKeySpec = new X509EncodedKeySpec(pubKeyEncoded);
final PKCS8EncodedKeySpec privKeySpec = new PKCS8EncodedKeySpec(privKeyEncoded);
final KeyFactory keyFactory = KeyFactory.getInstance("ECDSA");
ECC_PUBKEY = keyFactory.generatePublic(pubKeySpec);
ECC_PRIVKEY = keyFactory.generatePrivate(privKeySpec);
} catch (final InvalidKeySpecException e) {
throw new MslInternalException("ECC key generation failure: InvalidKeySpecException", e);
} catch (final NoSuchAlgorithmException e) {
throw new MslInternalException("ECC key generation failure.", e);
}
}
/**
* Create a new test ECC authentication factory.
*/
public MockEccAuthenticationFactory() {
super(EntityAuthenticationScheme.ECC);
}
/* (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.EccAuthenticationFactory#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 rad = (EccAuthenticationData)authdata;
// Try to return the test crypto context.
final String pubkeyid = rad.getPublicKeyId();
if (ECC_PUBKEY_ID.equals(pubkeyid)) {
final String identity = rad.getIdentity();
return new EccCryptoContext(identity, ECC_PRIVKEY, ECC_PUBKEY, Mode.SIGN_VERIFY);
}
// Entity not found.
throw new MslEntityAuthException(MslError.ECC_PUBLICKEY_NOT_FOUND, pubkeyid).setEntityAuthenticationData(rad);
}
}
| 1,860 |
0 |
Create_ds/msl/tests/src/main/java/com/netflix/msl
|
Create_ds/msl/tests/src/main/java/com/netflix/msl/entityauth/MockIdentityProvisioningService.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.util.Random;
import com.netflix.msl.entityauth.ProvisionedAuthenticationFactory.IdentityProvisioningService;
import com.netflix.msl.util.MslContext;
/**
* <p>Test identity provisioning service.</p>
*
* <p>This class creates entity identities from a prefix set equal to the
* current time in milliseconds since the UNIX epoch and a suffix set equal a
* random long number. The prefix and suffix are separated by a colon.</p>
*
* @author Wesley Miaw <[email protected]>
*/
public class MockIdentityProvisioningService implements IdentityProvisioningService {
/**
* <p>Create a new test identity provisioning service using the random
* number generator from the provided MSL context.<p>
*
* @param ctx MSL context.
*/
public MockIdentityProvisioningService(final MslContext ctx) {
this.ctx = ctx;
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.ProvisionedAuthenticationFactory.IdentityProvisioningService#nextIdentity(com.netflix.msl.util.MslContext)
*/
@Override
public String nextIdentity() {
final long now = ctx.getTime();
final Random r = ctx.getRandom();
final long suffix = r.nextLong();
return Long.toString(now) + ":" + Long.toString(suffix);
}
/** MSL context. */
private final MslContext ctx;
}
| 1,861 |
0 |
Create_ds/msl/tests/src/main/java/com/netflix/msl
|
Create_ds/msl/tests/src/main/java/com/netflix/msl/entityauth/MockRsaStore.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.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
/**
* Test RSA key store.
*
* @author Wesley Miaw <[email protected]>
*/
public class MockRsaStore implements RsaStore {
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.RsaStore#getIdentities()
*/
@Override
public Set<String> getIdentities() {
final Set<String> identities = new HashSet<String>();
identities.addAll(keys.keySet());
identities.addAll(privateKeys.keySet());
return identities;
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.RsaStore#getPublicKey(java.lang.String)
*/
@Override
public PublicKey getPublicKey(final String identity) {
return keys.get(identity);
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.RsaStore#getPrivateKey(java.lang.String)
*/
public PrivateKey getPrivateKey(final String identity) {
return privateKeys.get(identity);
}
/**
* Add an RSA public key to the store.
*
* @param identity RSA key pair identity.
* @param input DER-encoded RSA public key input stream.
* @throws IOException if there is an error reading from the input stream.
* @throws NoSuchAlgorithmException if no RSA provider is found.
* @throws InvalidKeySpecException if the RSA public key is invalid.
*/
public void addPublicKey(final String identity, final InputStream input) throws IOException, NoSuchAlgorithmException, InvalidKeySpecException {
final ByteArrayOutputStream der = new ByteArrayOutputStream();
do {
final byte[] b = new byte[16384];
final int read = input.read(b);
if (read == -1) break;
der.write(b, 0, read);
} while (true);
final X509EncodedKeySpec spec = new X509EncodedKeySpec(der.toByteArray());
final KeyFactory factory = KeyFactory.getInstance("RSA");
final PublicKey pubkey = factory.generatePublic(spec);
addPublicKey(identity, pubkey);
}
/**
* Add an RSA public key to the store.
*
* @param identity RSA key pair identity.
* @param pubkey RSA public key.
* @throws IllegalArgumentException if the public key is not a
* {@link RSAPublicKey}.
*/
public void addPublicKey(final String identity, final PublicKey pubkey) {
if (!(pubkey instanceof RSAPublicKey))
throw new IllegalArgumentException("Public key is not an instance of RSAPublicKey.");
keys.put(identity, pubkey);
}
/**
* Add an RSA private key to the store.
*
* @param identity RSA key pair identity.
* @param privkey RSA private key.
* @throws IllegalArgumentException if the private key is not a
* {@link RSAPrivateKey}.
*/
public void addPrivateKey(final String identity, final PrivateKey privkey) {
if (!(privkey instanceof RSAPrivateKey))
throw new IllegalArgumentException("Private key is not an instance of RSAPrivateKey.");
privateKeys.put(identity, privkey);
}
/**
* <p>Clear the store of all public and private keys.</p>
*/
public void clear() {
keys.clear();
privateKeys.clear();
}
/** Public keys. */
private final Map<String,PublicKey> keys = new HashMap<String,PublicKey>();
/** Private keys. */
private final Map<String,PrivateKey> privateKeys = new HashMap<String,PrivateKey>();
}
| 1,862 |
0 |
Create_ds/msl/tests/src/main/java/com/netflix/msl
|
Create_ds/msl/tests/src/main/java/com/netflix/msl/entityauth/MockX509AuthenticationFactory.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.ByteArrayOutputStream;
import java.io.InputStream;
import java.net.URL;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.security.spec.KeySpec;
import java.security.spec.PKCS8EncodedKeySpec;
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.MslContext;
/**
* Test X.509 asymmetric keys authentication factory.
*
* @author Wesley Miaw <[email protected]>
*/
public class MockX509AuthenticationFactory extends EntityAuthenticationFactory {
/** X.509 private key. */
private static final String X509_PRIVATE_KEY = "/entityauth/msl.key";
/** X.509 self-signed resource certificate. */
private static final String X509_SELF_SIGNED_CERT = "/entityauth/msl.pem";
/** X.509 ESN. */
public static final String X509_ESN;
/** X509Cert. */
public static final X509Certificate X509_CERT;
/** Private key. */
public static final PrivateKey X509_PRIVKEY;
static {
try {
final URL certUrl = MockX509AuthenticationFactory.class.getResource(X509_SELF_SIGNED_CERT);
final InputStream certInputStream = certUrl.openStream();
final CertificateFactory factory = CertificateFactory.getInstance("X.509");
X509_CERT = (X509Certificate)factory.generateCertificate(certInputStream);
X509_ESN = X509_CERT.getSubjectX500Principal().getName();
} catch (final Exception e) {
throw new MslInternalException("Hard-coded X.509 self-signed certificate failure.", e);
}
try {
final URL keyUrl = MockX509AuthenticationFactory.class.getResource(X509_PRIVATE_KEY);
final InputStream keyInputStream = keyUrl.openStream();
final ByteArrayOutputStream key = new ByteArrayOutputStream();
do {
final byte[] data = new byte[4096];
final int bytesRead = keyInputStream.read(data);
if (bytesRead == -1) break;
key.write(data, 0, bytesRead);
} while (true);
keyInputStream.close();
final KeyFactory rsaFactory = KeyFactory.getInstance("RSA");
final KeySpec keySpec = new PKCS8EncodedKeySpec(key.toByteArray());
X509_PRIVKEY = rsaFactory.generatePrivate(keySpec);
} catch (final Exception e) {
throw new MslInternalException("Hard-coded X.509 private key failure.", e);
}
}
/**
* Create a new test X.509 authentication factory.
*/
public MockX509AuthenticationFactory() {
super(EntityAuthenticationScheme.X509);
}
/* (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.X509AuthenticationFactory#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 X509AuthenticationData))
throw new MslInternalException("Incorrect authentication data type " + authdata.getClass().getName() + ".");
final X509AuthenticationData xad = (X509AuthenticationData)authdata;
// Try to return the test crypto context.
final String identity = xad.getIdentity();
if (X509_CERT.getSubjectX500Principal().getName().equals(identity))
return new RsaCryptoContext(ctx, identity, X509_PRIVKEY, X509_CERT.getPublicKey(), Mode.SIGN_VERIFY);
// Certificate verification failed.
throw new MslEntityAuthException(MslError.X509CERT_VERIFICATION_FAILED, xad.getX509Cert().toString()).setEntityAuthenticationData(xad);
}
}
| 1,863 |
0 |
Create_ds/msl/tests/src/main/java/com/netflix/msl
|
Create_ds/msl/tests/src/main/java/com/netflix/msl/entityauth/MockPresharedProfileAuthenticationFactory.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;
import javax.crypto.spec.SecretKeySpec;
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.JcaAlgorithm;
import com.netflix.msl.crypto.SymmetricCryptoContext;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.util.Base64;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* Test pre-shared keys profile authentication factory.
*
* @author Wesley Miaw <[email protected]>
*/
public class MockPresharedProfileAuthenticationFactory extends EntityAuthenticationFactory {
/** PSK ESN. */
public static final String PSK_ESN = "PSK-ESN";
/** PSK Kpe. */
private static final byte[] PSK_KPE = Base64.decode("kzWYEtKSsPI8dOW5YyoILQ==");
/** PSK Kph. */
private static final byte[] PSK_KPH = Base64.decode("VhxNUK7bYIcCV4wLE2YK90do1X3XqhPeMwwllmNh8Jw=");
/** PSK ESN 2. */
public static final String PSK_ESN2 = "PSK-ESN2";
/** PSK Kpe 2. */
private static final byte[] PSK_KPE2 = Base64.decode("lzWYEtKSsPI8dOW5YyoILQ==");
/** PSK Kph 2. */
private static final byte[] PSK_KPH2 = Base64.decode("WhxNUK7bYIcCV4wLE2YK90do1X3XqhPeMwwllmNh8Jw=");
/** Profile. */
public static final String PROFILE = "PROFILE";
/** Kpe/Kph/Kpw #1. */
public static final SecretKey KPE, KPH, KPW;
/** Kpe/Kph/Kpw #2. */
public static final SecretKey KPE2, KPH2, KPW2;
static {
KPE = new SecretKeySpec(PSK_KPE, JcaAlgorithm.AES);
KPH = new SecretKeySpec(PSK_KPH, JcaAlgorithm.HMAC_SHA256);
KPW = new SecretKeySpec(MslTestUtils.deriveWrappingKey(PSK_KPE, PSK_KPH), JcaAlgorithm.AESKW);
KPE2 = new SecretKeySpec(PSK_KPE2, JcaAlgorithm.AES);
KPH2 = new SecretKeySpec(PSK_KPH2, JcaAlgorithm.HMAC_SHA256);
KPW2 = new SecretKeySpec(MslTestUtils.deriveWrappingKey(PSK_KPE2, PSK_KPH2), JcaAlgorithm.AESKW);
}
/**
* Create a new test pre-shared keys profile authentication factory.
*/
public MockPresharedProfileAuthenticationFactory() {
super(EntityAuthenticationScheme.PSK_PROFILE);
}
/* (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.PresharedAuthenticationFactory#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;
// Try to return the test crypto context.
final String pskId = ppad.getPresharedKeysId();
final String identity = ppad.getIdentity();
if (PSK_ESN.equals(pskId))
return new SymmetricCryptoContext(ctx, identity, KPE, KPH, KPW);
if (PSK_ESN2.equals(pskId))
return new SymmetricCryptoContext(ctx, identity, KPE2, KPH2, KPW2);
// Entity not found.
throw new MslEntityAuthException(MslError.ENTITY_NOT_FOUND, "psk profile " + pskId).setEntityAuthenticationData(ppad);
}
}
| 1,864 |
0 |
Create_ds/msl/tests/src/main/java/com/netflix/msl
|
Create_ds/msl/tests/src/main/java/com/netflix/msl/entityauth/MockRsaAuthenticationFactory.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.security.KeyFactory;
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.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
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.Base64;
import com.netflix.msl.util.MslContext;
/**
* Test RSA asymmetric keys authentication factory.
*
* @author Wesley Miaw <[email protected]>
*/
public class MockRsaAuthenticationFactory extends EntityAuthenticationFactory {
/** 1024-bit RSA public key. */
private static String RSA_PUBKEY_B64 =
"MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBALeJpiH5nikd3XeAo2rHjLJVVChM/p6l" +
"VnQHyFh77w0Efbppi1P1pNy8BxJ++iFKt2dV/4ZKkUKqtlIu3KX19kcCAwEAAQ==";
/** 1024-bit RSA private key. */
private static String RSA_PRIVKEY_B64 =
"MIIBVgIBADANBgkqhkiG9w0BAQEFAASCAUAwggE8AgEAAkEAt4mmIfmeKR3dd4Cj" +
"aseMslVUKEz+nqVWdAfIWHvvDQR9ummLU/Wk3LwHEn76IUq3Z1X/hkqRQqq2Ui7c" +
"pfX2RwIDAQABAkEAlB6YXq7uv0wE4V6Fg7VLjNhkNKn+itXwMW/eddp/D8cC4QbH" +
"+0Ejt0e3F+YcY0RBsTUk7hz89VW7BtpjXRrU0QIhAOyjvUsihGzImq+WDiEWvnXX" +
"lVaUaJXaaNElE37V/BE1AiEAxo25k2z2SDbFC904Zk020kISi95KNNv5ceEFcGu0" +
"dQsCIQDUgj7uCHNv1b7ETDcoE+q6nP2poOFDIb7bgzY8wyH4uQIgf+02YO82auam" +
"5HL+8KLVLHkXm/h31UDZoe66Y2lxlmsCIQC+cKulQATpKNnMV1RVtpH07A0+X72s" +
"wpu2pmaRSYgw/w==";
/** RSA ESN. */
public static final String RSA_ESN = "RSAPREFIX-ESN";
/** RSA public key ID. */
public static final String RSA_PUBKEY_ID = "mockRSAKeyId";
/** RSA public key. */
public static final PublicKey RSA_PUBKEY;
/** RSA private key. */
public static final PrivateKey RSA_PRIVKEY;
static {
Security.addProvider(new BouncyCastleProvider());
try {
final byte[] pubKeyEncoded = Base64.decode(RSA_PUBKEY_B64);
final byte[] privKeyEncoded = Base64.decode(RSA_PRIVKEY_B64);
final X509EncodedKeySpec pubKeySpec = new X509EncodedKeySpec(pubKeyEncoded);
final PKCS8EncodedKeySpec privKeySpec = new PKCS8EncodedKeySpec(privKeyEncoded);
final KeyFactory keyFactory = KeyFactory.getInstance("RSA");
RSA_PUBKEY = keyFactory.generatePublic(pubKeySpec);
RSA_PRIVKEY = keyFactory.generatePrivate(privKeySpec);
} catch (final InvalidKeySpecException e) {
throw new MslInternalException("RSA key generation failure: InvalidKeySpecException", e);
} catch (final NoSuchAlgorithmException e) {
throw new MslInternalException("RSA key generation failure.", e);
}
}
/**
* Create a new test RSA authentication factory.
*/
public MockRsaAuthenticationFactory() {
super(EntityAuthenticationScheme.RSA);
}
/* (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.RsaAuthenticationFactory#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;
// Try to return the test crypto context.
final String pubkeyid = rad.getPublicKeyId();
if (RSA_PUBKEY_ID.equals(pubkeyid)) {
final String identity = rad.getIdentity();
return new RsaCryptoContext(ctx, identity, RSA_PRIVKEY, RSA_PUBKEY, Mode.SIGN_VERIFY);
}
// Entity not found.
throw new MslEntityAuthException(MslError.RSA_PUBLICKEY_NOT_FOUND, pubkeyid).setEntityAuthenticationData(rad);
}
}
| 1,865 |
0 |
Create_ds/msl/tests/src/main/java/com/netflix/msl
|
Create_ds/msl/tests/src/main/java/com/netflix/msl/entityauth/MockPresharedAuthenticationFactory.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 javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
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.JcaAlgorithm;
import com.netflix.msl.crypto.SymmetricCryptoContext;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.util.Base64;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslTestUtils;
/**
* Test pre-shared keys authentication factory.
*
* @author Wesley Miaw <[email protected]>
*/
public class MockPresharedAuthenticationFactory extends EntityAuthenticationFactory {
/** PSK ESN. */
public static final String PSK_ESN = "PSK-ESN";
/** PSK Kpe. */
private static final byte[] PSK_KPE = Base64.decode("kzWYEtKSsPI8dOW5YyoILQ==");
/** PSK Kph. */
private static final byte[] PSK_KPH = Base64.decode("VhxNUK7bYIcCV4wLE2YK90do1X3XqhPeMwwllmNh8Jw=");
/** PSK ESN 2. */
public static final String PSK_ESN2 = "PSK-ESN2";
/** PSK Kpe 2. */
private static final byte[] PSK_KPE2 = Base64.decode("lzWYEtKSsPI8dOW5YyoILQ==");
/** PSK Kph 2. */
private static final byte[] PSK_KPH2 = Base64.decode("WhxNUK7bYIcCV4wLE2YK90do1X3XqhPeMwwllmNh8Jw=");
/** Kpe/Kph/Kpw #1. */
public static final SecretKey KPE, KPH, KPW;
/** Kpe/Kph/Kpw #2. */
public static final SecretKey KPE2, KPH2, KPW2;
static {
KPE = new SecretKeySpec(PSK_KPE, JcaAlgorithm.AES);
KPH = new SecretKeySpec(PSK_KPH, JcaAlgorithm.HMAC_SHA256);
KPW = new SecretKeySpec(MslTestUtils.deriveWrappingKey(PSK_KPE, PSK_KPH), JcaAlgorithm.AESKW);
KPE2 = new SecretKeySpec(PSK_KPE2, JcaAlgorithm.AES);
KPH2 = new SecretKeySpec(PSK_KPH2, JcaAlgorithm.HMAC_SHA256);
KPW2 = new SecretKeySpec(MslTestUtils.deriveWrappingKey(PSK_KPE2, PSK_KPH2), JcaAlgorithm.AESKW);
}
/**
* Create a new test pre-shared keys authentication factory.
*/
public MockPresharedAuthenticationFactory() {
super(EntityAuthenticationScheme.PSK);
}
/* (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.PresharedAuthenticationFactory#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 PresharedAuthenticationData))
throw new MslInternalException("Incorrect authentication data type " + authdata.getClass().getName() + ".");
final PresharedAuthenticationData pad = (PresharedAuthenticationData)authdata;
// Try to return the test crypto context.
final String identity = pad.getIdentity();
if (PSK_ESN.equals(identity))
return new SymmetricCryptoContext(ctx, identity, KPE, KPH, KPW);
if (PSK_ESN2.equals(identity))
return new SymmetricCryptoContext(ctx, identity, KPE2, KPH2, KPW2);
// Entity not found.
throw new MslEntityAuthException(MslError.ENTITY_NOT_FOUND, "psk " + identity).setEntityAuthenticationData(pad);
}
}
| 1,866 |
0 |
Create_ds/msl/tests/src/main/java/com/netflix/msl
|
Create_ds/msl/tests/src/main/java/com/netflix/msl/entityauth/MockKeySetStore.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 java.util.HashMap;
import java.util.Map;
import javax.crypto.SecretKey;
/**
* Test preshared keys store.
*
* @author Wesley Miaw <[email protected]>
*/
public class MockKeySetStore implements KeySetStore {
/**
* Add a key set to the store.
*
* @param identity keys set identity.
* @param encryptionKey the encryption key.
* @param hmacKey the HMAC key.
* @param wrappingKey the wrapping key.
*/
public void addKeys(final String identity, final SecretKey encryptionKey, final SecretKey hmacKey, final SecretKey wrappingKey) {
final KeySet keyset = new KeySet(encryptionKey, hmacKey, wrappingKey);
keysets.put(identity, keyset);
}
/**
* Remove all preshared key sets from the store.
*/
public void clear() {
keysets.clear();
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.KeySetStore#getKeys(java.lang.String)
*/
@Override
public KeySet getKeys(final String identity) {
return keysets.get(identity);
}
/** Key sets. */
private final Map<String,KeySet> keysets = new HashMap<String,KeySet>();
}
| 1,867 |
0 |
Create_ds/msl/tests/src/main/java/com/netflix/msl
|
Create_ds/msl/tests/src/main/java/com/netflix/msl/entityauth/MockEccStore.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.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.interfaces.ECPrivateKey;
import java.security.interfaces.ECPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
/**
* Test ECC key store.
*
*/
public class MockEccStore implements EccStore {
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EccStore#getIdentities()
*/
@Override
public Set<String> getIdentities() {
final Set<String> identities = new HashSet<String>();
identities.addAll(keys.keySet());
identities.addAll(privateKeys.keySet());
return identities;
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EccStore#getPublicKey(java.lang.String)
*/
@Override
public PublicKey getPublicKey(final String identity) {
return keys.get(identity);
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.EccStore#getPrivateKey(java.lang.String)
*/
public PrivateKey getPrivateKey(final String identity) {
return privateKeys.get(identity);
}
/**
* Add an ECC public key to the store.
*
* @param identity ECC key pair identity.
* @param input DER-encoded ECC public key input stream.
* @throws IOException if there is an error reading from the input stream.
* @throws NoSuchAlgorithmException if no ECC provider is found.
* @throws InvalidKeySpecException if the ECC public key is invalid.
*/
public void addPublicKey(final String identity, final InputStream input) throws IOException, NoSuchAlgorithmException, InvalidKeySpecException {
final ByteArrayOutputStream der = new ByteArrayOutputStream();
do {
final byte[] b = new byte[16384];
final int read = input.read(b);
if (read == -1) break;
der.write(b, 0, read);
} while (true);
final X509EncodedKeySpec spec = new X509EncodedKeySpec(der.toByteArray());
final KeyFactory factory = KeyFactory.getInstance("ECDSA");
final PublicKey pubkey = factory.generatePublic(spec);
addPublicKey(identity, pubkey);
}
/**
* Add an ECC public key to the store.
*
* @param identity ECC key pair identity.
* @param pubkey ECC public key.
* @throws IllegalArgumentException if the public key is not a
* {@link ECPublicKey}.
*/
public void addPublicKey(final String identity, final PublicKey pubkey) {
if (!(pubkey instanceof ECPublicKey))
throw new IllegalArgumentException("Public key is not an instance of ECPublicKey.");
keys.put(identity, pubkey);
}
/**
* Add an EC private key to the store.
*
* @param identity ECC key pair identity.
* @param privkey EC private key.
* @throws IllegalArgumentException if the private key is not a
* {@link ECPrivateKey}.
*/
public void addPrivateKey(final String identity, final PrivateKey privkey) {
if (!(privkey instanceof ECPrivateKey))
throw new IllegalArgumentException("Private key is not an instance of ECPrivateKey.");
privateKeys.put(identity, privkey);
}
/**
* <p>Clear the store of all public and private keys.</p>
*/
public void clear() {
keys.clear();
privateKeys.clear();
}
/** Public keys. */
private final Map<String,PublicKey> keys = new HashMap<String,PublicKey>();
/** Private keys. */
private final Map<String,PrivateKey> privateKeys = new HashMap<String,PrivateKey>();
}
| 1,868 |
0 |
Create_ds/msl/examples/websocket/src/main/java
|
Create_ds/msl/examples/websocket/src/main/java/server/PushMslMessage.java
|
/**
* Copyright (c) 2017-2018 Netflix, Inc. All rights reserved.
*/
package server;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.msg.MessageContext;
import com.netflix.msl.msg.MessageInputStream;
import com.netflix.msl.msg.MslControl;
import com.netflix.msl.msg.MslControl.MslChannel;
import com.netflix.msl.util.MslContext;
import io.netty.channel.ChannelHandlerContext;
import io.netty.util.Attribute;
import server.msg.PushMessageContext;
/**
* <p>Push a MSL message to a WebSocket client.</p>
*
* @author Wesley Miaw <[email protected]>
*/
public class PushMslMessage {
/**
* <p>Create a new push MSL message with the given
* {@link MslControl} and {@link MslContext}.</p>
*
* @param mslCtrl MSL control. May be shared.
* @param mslCtx MSL context. May be shared.
*/
public PushMslMessage(final MslControl mslCtrl, final MslContext mslCtx) {
this.mslCtrl = mslCtrl;
this.mslCtx = mslCtx;
}
/**
* <p>Sends a new MSL message with a single payload chunk containing the
* provided data out over the given channel.</p>
*
* @param ctx channel context.
* @param data application data to send.
*/
public void send(final ChannelHandlerContext ctx, final byte[] data) {
// Grab the original message input stream.
final Attribute<MessageInputStream> misAttr = ctx.attr(PushConstants.ATTR_KEY_MIS);
final Object o = misAttr.get();
if (o == null || !(o instanceof MessageInputStream))
throw new MslInternalException("Cannot send MSL data without having first initialized MSL communication.");
final MessageInputStream mis = (MessageInputStream)o;
// Push out a MSL message based on the message input stream.
final MessageContext msgCtx = new PushMessageContext(data);
final InputStream in = new ByteArrayInputStream(new byte[0]);
final OutputStream out = new ChannelOutputStream(ctx.channel());
final Future<MslChannel> resp = mslCtrl.push(mslCtx, msgCtx, in, out, mis, PushConstants.TIMEOUT_MS);
final MslChannel channel;
try {
channel = resp.get();
} catch (final ExecutionException | InterruptedException e) {
e.printStackTrace(System.err);
return;
}
// If the channel is null, something went wrong.
if (channel == null)
System.err.println("Push MSL channel was unexpectedly null.");
}
/** MSL control. */
private final MslControl mslCtrl;
/** MSL context. */
private final MslContext mslCtx;
}
| 1,869 |
0 |
Create_ds/msl/examples/websocket/src/main/java
|
Create_ds/msl/examples/websocket/src/main/java/server/PushServer.java
|
/**
* Copyright (c) 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 server;
import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import javax.websocket.server.ServerEndpoint;
import com.netflix.msl.entityauth.RsaStore;
import com.netflix.msl.msg.ConsoleFilterStreamFactory;
import com.netflix.msl.msg.MslControl;
import com.netflix.msl.util.Base64;
import com.netflix.msl.util.MslContext;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.codec.http.websocketx.WebSocketFrameAggregator;
import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler;
import io.netty.handler.codec.http.websocketx.extensions.compression.WebSocketServerCompressionHandler;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import server.entityauth.PushRsaStore;
import server.util.PushMslContext;
/**
* <p>An example WebSocket server that listens for an initial request from a
* a client, sends an initial response, and then will periodically send
* additional responses over the same WebSocket that the client may
* receive.</p>
*
* @author Wesley Miaw <[email protected]>
*/
@ServerEndpoint("/push")
public class PushServer {
/** Server port number. */
private static final int PORT = 8080;
/**
* <p>This channel initializer sets up the channel pipeline for MSL
* communication over WebSocket.</p>
*/
private static class WebSocketServerInitializer extends ChannelInitializer<SocketChannel> {
/** WebSocket URL path. */
private static final String WEBSOCKET_PATH = "/websocket";
/** Maximum content length in bytes. */
private static final int MAX_CONTENT_LENGTH = 10 * 1024 * 1024;
/**
* <p>Create a WebSocket channel initializer that uses the provided MSL
* control and MSL context.</p>
*
* @param ctrl MSL control.
* @param ctx MSL context.
*/
public WebSocketServerInitializer(final MslControl ctrl, final MslContext ctx) {
this.ctrl = ctrl;
this.ctx = ctx;
}
@Override
public void initChannel(final SocketChannel ch) throws Exception {
final ChannelPipeline pipeline = ch.pipeline();
pipeline.addLast(new HttpServerCodec());
pipeline.addLast(new HttpObjectAggregator(MAX_CONTENT_LENGTH));
pipeline.addLast(new WebSocketServerCompressionHandler());
pipeline.addLast(new WebSocketServerProtocolHandler(WEBSOCKET_PATH));
pipeline.addLast(new WebSocketFrameAggregator(MAX_CONTENT_LENGTH));
pipeline.addLast(new PushMslInitHandler(ctrl, ctx));
}
/** MSL control. */
private final MslControl ctrl;
/** MSL context. */
private final MslContext ctx;
}
public static void main(final String[] args) throws Exception {
// Create the RSA key store.
final RsaStore rsaStore;
try {
final byte[] privKeyEncoded = Base64.decode(PushConstants.RSA_PRIVKEY_B64);
final PKCS8EncodedKeySpec privKeySpec = new PKCS8EncodedKeySpec(privKeyEncoded);
final KeyFactory rsaKeyFactory = KeyFactory.getInstance("RSA");
final PrivateKey privKey = rsaKeyFactory.generatePrivate(privKeySpec);
rsaStore = new PushRsaStore(PushConstants.SERVER_ID, null, privKey);
} catch (final NoSuchAlgorithmException e) {
throw new RuntimeException("RSA algorithm not found.", e);
} catch (final InvalidKeySpecException e) {
throw new RuntimeException("Invalid RSA private key.", e);
}
// Set up the MSL context.
final MslContext ctx = new PushMslContext(PushConstants.SERVER_ID, rsaStore);
// Create the MSL control.
//
// Since this is an example process all requests on the calling thread.
final MslControl ctrl = new MslControl(0);
ctrl.setFilterFactory(new ConsoleFilterStreamFactory());
// Start listening for connections.
final EventLoopGroup bossGroup = new NioEventLoopGroup(1);
final EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
final ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.handler(new LoggingHandler(LogLevel.INFO))
.childHandler(new WebSocketServerInitializer(ctrl, ctx));
final Channel ch = b.bind(PORT).sync().channel();
System.out.println("Open your web browser and navigate to http://127.0.0.1:" + PORT + '/');
ch.closeFuture().sync();
} finally {
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
}
| 1,870 |
0 |
Create_ds/msl/examples/websocket/src/main/java
|
Create_ds/msl/examples/websocket/src/main/java/server/ChannelOutputStream.java
|
/**
* Copyright (c) 2017 Netflix, Inc. All rights reserved.
*/
package server;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.handler.codec.http.websocketx.BinaryWebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketFrame;
/**
* <p>Output stream backed by a channel.</p>
*
* <p>All data will be buffered until the output stream is closed, at which
* point a single {@link BinaryWebSocketFrame} will be created to output the
* data over the backing channel.</p>
*
* @author Wesley Miaw <[email protected]>
*/
public class ChannelOutputStream extends OutputStream {
/**
* Create a new output stream backed by the provided channel.
*
* @param channel the channel.
*/
public ChannelOutputStream(final Channel channel) {
this.channel = channel;
}
@Override
public void write(final byte[] b) {
write(b, 0, b.length);
}
@Override
public void write(final byte[] b, final int off, final int len) {
// If we flush after writing, then we rely upon the caller to write
// data in chunks appropriate for each frame. Instead, buffer the data
// and send it as a single frame when flushed or closed.
buffer.write(b, off, len);
}
@Override
public void flush() {
// Do nothing, as MSL will attempt to flush each header and payload
// chunk, but we don't want the recipient to receive partial MSL
// messages.
}
@Override
public void close() throws IOException {
// Close will be called when the MSL message is complete. Write it out
// to the channel.
final ByteBuf data = Unpooled.wrappedBuffer(buffer.toByteArray());
final WebSocketFrame frame = new BinaryWebSocketFrame(data);
final ChannelFuture future = channel.writeAndFlush(frame);
// Wait for the write to complete so we know everything worked.
future.awaitUninterruptibly();
if (future.isCancelled()) {
// Do nothing if we were cancelled.
return;
} else if (!future.isSuccess()) {
final Throwable cause = future.cause();
throw new IOException("Error writing MSL message to the channel.", cause);
}
// Success.
}
@Override
public void write(final int b) {
buffer.write(b);
}
/** Channel. */
private final Channel channel;
/** Write buffer. */
private final ByteArrayOutputStream buffer = new ByteArrayOutputStream();
}
| 1,871 |
0 |
Create_ds/msl/examples/websocket/src/main/java
|
Create_ds/msl/examples/websocket/src/main/java/server/PushMslInitHandler.java
|
/**
* Copyright (c) 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 server;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.nio.charset.Charset;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import com.netflix.msl.msg.MessageContext;
import com.netflix.msl.msg.MessageInputStream;
import com.netflix.msl.msg.MslControl;
import com.netflix.msl.util.MslContext;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.websocketx.WebSocketFrame;
import io.netty.util.Attribute;
import server.msg.PushMessageContext;
/**
* @author Wesley Miaw <[email protected]>
*/
public class PushMslInitHandler extends SimpleChannelInboundHandler<WebSocketFrame> {
/** UTF-8 character set. */
private static final Charset UTF_8 = Charset.forName("UTF-8");
/** Acknowledgement payload. */
private static final byte[] ACK = "ack".getBytes(UTF_8);
/**
* <p>Create a new MSL initialization handler with the given
* {@link MslControl} and {@link MslContext}.</p>
*
* @param mslCtrl MSL control. May be shared.
* @param mslCtx MSL context. May be shared.
*/
public PushMslInitHandler(final MslControl mslCtrl, final MslContext mslCtx) {
this.mslCtrl = mslCtrl;
this.mslCtx = mslCtx;
}
@Override
protected void messageReceived(final ChannelHandlerContext ctx, final WebSocketFrame msg) throws Exception {
// Grab the frame data.
final ByteBuf frame = msg.content();
final byte[] framedata = frame.array();
final InputStream in = new ByteArrayInputStream(framedata);
// Create the output stream.
final ChannelOutputStream out = new ChannelOutputStream(ctx.channel());
// Receive the initial request.
final MessageContext msgCtx = new PushMessageContext(ACK);
final Future<MessageInputStream> recv = mslCtrl.receive(mslCtx, msgCtx, in, out, PushConstants.TIMEOUT_MS);
final MessageInputStream mis;
try {
mis = recv.get();
} catch (final ExecutionException | InterruptedException e) {
e.printStackTrace(System.err);
return;
}
// If the message input stream is null, a response was probably
// automatically sent (i.e. a handshake is being performed). That
// should not occur, since we're not set up to perform authentication
// or token issuance, but regardless we are done.
if (mis == null)
return;
// Save the message input stream for this channel.
final Attribute<MessageInputStream> misAttr = ctx.attr(PushConstants.ATTR_KEY_MIS);
misAttr.set(mis);
}
/** MSL control. */
private final MslControl mslCtrl;
/** MSL context. */
private final MslContext mslCtx;
}
| 1,872 |
0 |
Create_ds/msl/examples/websocket/src/main/java
|
Create_ds/msl/examples/websocket/src/main/java/server/PushConstants.java
|
/**
* Copyright (c) 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 server;
import com.netflix.msl.msg.MessageInputStream;
import io.netty.util.AttributeKey;
/**
* @author Wesley Miaw <[email protected]>
*/
public class PushConstants {
/** Server entity ID. */
public static final String SERVER_ID = "PushMslServer";
/** Server 2048-bit RSA public key. */
public static final String RSA_PUBKEY_B64 =
"MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4feorj/FWQi8AhbvjK3G" +
"L31ct6N+Ad/3FwqNsa4vAsfPmilLRx0DWhkxRycetmQEAa+1THyNCzobIduQE3UY" +
"8NtdOiy1S3BtHDoiSNEITFPAs0l2OAZ2ZUv0KIr9sLWAznlXMclLOBXtLOQMCs2e" +
"Ey4MO1m9uLywwc2SuAfoZe+wjEIauyoQK/M5miA0fbaEn4H+3m5aiP3Lb1X5Ss4b" +
"4tuu0ENsO/ebgMx2ltZ4b9dkzA65DM6XxEC60jK1AW+/wvFb4+iPQqrA7mdiZWsp" +
"zqMRTaAUDHKJo2LFBc6N0/wuTsXczHx6TYz5b2hrI6N+O7EEuxirAaU+xU7XEqv2" +
"dQIDAQAB";
/** Server 2048-bit RSA private key. */
public static final String RSA_PRIVKEY_B64 =
"MIIEowIBAAKCAQEA4feorj/FWQi8AhbvjK3GL31ct6N+Ad/3FwqNsa4vAsfPmilL" +
"Rx0DWhkxRycetmQEAa+1THyNCzobIduQE3UY8NtdOiy1S3BtHDoiSNEITFPAs0l2" +
"OAZ2ZUv0KIr9sLWAznlXMclLOBXtLOQMCs2eEy4MO1m9uLywwc2SuAfoZe+wjEIa" +
"uyoQK/M5miA0fbaEn4H+3m5aiP3Lb1X5Ss4b4tuu0ENsO/ebgMx2ltZ4b9dkzA65" +
"DM6XxEC60jK1AW+/wvFb4+iPQqrA7mdiZWspzqMRTaAUDHKJo2LFBc6N0/wuTsXc" +
"zHx6TYz5b2hrI6N+O7EEuxirAaU+xU7XEqv2dQIDAQABAoIBAQCh/pEv8knBbXCT" +
"Muwi90VYMFAy2oNwRqZ2Hzu7gHr1TFd5VldAMP2BLwRT1SjAau0wZE3d+oCG5u4i" +
"lKwyNsVdjnXESd7iqUOfc9G2UBzZ00UXgve8bG2eaxgrpJEAiO5Bl126NGu3VojE" +
"oOw9JnFHoMBmIAzSDnvNRFoFkq25vQYAG45l9ZeNJv8mJaJG5+DNr6xbAE5PmROc" +
"qyDL7RrfSqLxALhgZzLjVAP99fBGpOw2dCGKbQRzkUY0bojO19G3UUtf3HCI005i" +
"kYHuAPdvu4+AteOvKdnDeMcT1pDxiNZKO+kXumIGYaKul2k6t9UpsRvCSmrthFZx" +
"t8izGEehAoGBAPJ7YiK6W6NrgVyW5PaDtDRTrwZb/1G/K+jvCzHhV8/X5KfmjsaA" +
"kT5m2WS1/rMwJoyc45GmTyyy6reGqLs5zAdUVicRKjZZaQnj00QXHRlmAEiDtx2T" +
"b0cagryVf79Ma5FgyOMmqHjS5Pob7RvI4UyzVhR/pYmOrqxWGZgmRlxNAoGBAO6Q" +
"lfXvbL9JKZ3HXIVbrXS5QToACnQf19QH05LPJG4jni7ycoTZFOiFmJodP5ca+Gug" +
"TLlPaeVu52dlbXM1k32tV+0ui6vn0ErE8ZsXTjbZ/KInx4munWrLP8w3Ju8MHPPl" +
"sEgmeggL0xBtt5BFRKus0SWwImZ9rIzxFXdbanbJAoGAOrP4LCQlr0iFht7ZC30T" +
"EV/5DXcUNrwrazcD5M2DLsQ7jRJaGmBhyVOo6aLNyJ+tlXkd9tLmdBHUlR26l6kE" +
"Zfna6ZZUO9glf8lyChf2aYGyK9wHZtecpwAaCoG+7ZcYq5dcyvE+9BFKcep02rcl" +
"JCZ+fnPwpX6vdvVZOOZ7PjkCgYAGMv2imWkjA1ywe+i8kmhMey/luPCMmfM60EVA" +
"MF/K+OP4ZlZxe06eyDHx90aav5mq+kxkGFsxGhOrTSht8Pt3LZT2VdpNSkXQW5PH" +
"qvBeXoXBFPWLb10p1ERBI0HAvnjWIabWCSHsqZn/eEpn1lT1fRUmPJB4R1W/h9g9" +
"9MMseQKBgBVp+6dU2Rdf1jzwzDH3IRDIVgWeqLlQucbVr/Fipjooioq6nxH2oHUB" +
"2Qmq7FjYLKfKdaIRRoJhgeUhjVOVdjyIKVhLlBYpztr48jrMD5e4ykvKdAV2tlNv" +
"B/b+6sSJkqh7Qm6CMO29m+dE2PJBZCzviTkBMOzyme71phGsh//C";
/** Timeout in milliseconds. */
public static final int TIMEOUT_MS = 60000;
/** Channel message input stream attribute key. */
public static final AttributeKey<MessageInputStream> ATTR_KEY_MIS = AttributeKey.valueOf("mis");
}
| 1,873 |
0 |
Create_ds/msl/examples/websocket/src/main/java/server
|
Create_ds/msl/examples/websocket/src/main/java/server/util/PushMslContext.java
|
/**
* Copyright (c) 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 server.util;
import java.security.SecureRandom;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import com.netflix.msl.MslConstants.CompressionAlgorithm;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.crypto.SymmetricCryptoContext;
import com.netflix.msl.entityauth.EntityAuthenticationData;
import com.netflix.msl.entityauth.EntityAuthenticationFactory;
import com.netflix.msl.entityauth.EntityAuthenticationScheme;
import com.netflix.msl.entityauth.RsaAuthenticationData;
import com.netflix.msl.entityauth.RsaAuthenticationFactory;
import com.netflix.msl.entityauth.RsaStore;
import com.netflix.msl.io.DefaultMslEncoderFactory;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.keyx.KeyExchangeFactory;
import com.netflix.msl.keyx.KeyExchangeScheme;
import com.netflix.msl.msg.MessageCapabilities;
import com.netflix.msl.tokens.TokenFactory;
import com.netflix.msl.userauth.UserAuthenticationFactory;
import com.netflix.msl.userauth.UserAuthenticationScheme;
import com.netflix.msl.util.AuthenticationUtils;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslStore;
import com.netflix.msl.util.NullAuthenticationUtils;
import com.netflix.msl.util.NullMslStore;
import server.userauth.PushTokenFactory;
/**
* <p>The example server MSL context.</p>
*
* @author Wesley Miaw <[email protected]>
*/
public class PushMslContext extends MslContext {
/** MSL encryption key. */
private static final byte[] MSL_ENCRYPTION_KEY = {
(byte)0x1d, (byte)0x58, (byte)0xf3, (byte)0xb8, (byte)0xf7, (byte)0x47, (byte)0xd1, (byte)0x6a,
(byte)0xb1, (byte)0x93, (byte)0xc4, (byte)0xc0, (byte)0xa6, (byte)0x24, (byte)0xea, (byte)0xcf,
};
/** MSL HMAC key. */
private static final byte[] MSL_HMAC_KEY = {
(byte)0xd7, (byte)0xae, (byte)0xbf, (byte)0xd5, (byte)0x87, (byte)0x9b, (byte)0xb0, (byte)0xe0,
(byte)0xad, (byte)0x01, (byte)0x6a, (byte)0x4c, (byte)0xf3, (byte)0xcb, (byte)0x39, (byte)0x82,
(byte)0xf5, (byte)0xba, (byte)0x26, (byte)0x0d, (byte)0xa5, (byte)0x20, (byte)0x24, (byte)0x5b,
(byte)0xb4, (byte)0x22, (byte)0x75, (byte)0xbd, (byte)0x79, (byte)0x47, (byte)0x37, (byte)0x0c,
};
/** MSL wrapping key. */
private static final byte[] MSL_WRAPPING_KEY = {
(byte)0x83, (byte)0xb6, (byte)0x9a, (byte)0x15, (byte)0x80, (byte)0xd3, (byte)0x23, (byte)0xa2,
(byte)0xe7, (byte)0x9d, (byte)0xd9, (byte)0xb2, (byte)0x26, (byte)0x26, (byte)0xb3, (byte)0xf6,
};
/**
* <p>Create a new simple MSL context.</p>
*
* @param serverId local server entity identity.
* @param rsaStore local server entity RSA store.
*/
public PushMslContext(final String serverId, final RsaStore rsaStore) {
// Message capabilities.
final Set<CompressionAlgorithm> compressionAlgos = new HashSet<CompressionAlgorithm>(Arrays.asList(CompressionAlgorithm.GZIP, CompressionAlgorithm.LZW));
final List<String> languages = Arrays.asList("en-US");
final Set<MslEncoderFormat> encoderFormats = new HashSet<MslEncoderFormat>(Arrays.asList(MslEncoderFormat.JSON));
this.messageCaps = new MessageCapabilities(compressionAlgos, languages, encoderFormats);
// MSL crypto context.
final SecretKey encryptionKey = new SecretKeySpec(MSL_ENCRYPTION_KEY, "AES");
final SecretKey hmacKey = new SecretKeySpec(MSL_HMAC_KEY, "HmacSHA256");
final SecretKey wrappingKey = new SecretKeySpec(MSL_WRAPPING_KEY, "AES");
this.mslCryptoContext = new SymmetricCryptoContext(this, serverId, encryptionKey, hmacKey, wrappingKey);
// Create authentication utils.
final AuthenticationUtils authutils = new NullAuthenticationUtils();
// Entity authentication.
//
// Use the local entity identity for the key pair ID.
this.entityAuthData = new RsaAuthenticationData(serverId, serverId);
// Entity authentication factories.
this.entityAuthFactories = new HashSet<EntityAuthenticationFactory>();
this.entityAuthFactories.add(new RsaAuthenticationFactory(serverId, rsaStore, authutils));
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getTime()
*/
@Override
public long getTime() {
return System.currentTimeMillis();
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getRandom()
*/
@Override
public Random getRandom() {
return new SecureRandom();
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#isPeerToPeer()
*/
@Override
public boolean isPeerToPeer() {
return false;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getMessageCapabilities()
*/
@Override
public MessageCapabilities getMessageCapabilities() {
return messageCaps;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getEntityAuthenticationData(com.netflix.msl.util.MslContext.ReauthCode)
*/
@Override
public EntityAuthenticationData getEntityAuthenticationData(final ReauthCode reauthCode) {
return entityAuthData;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getMslCryptoContext()
*/
@Override
public ICryptoContext getMslCryptoContext() throws MslCryptoException {
return mslCryptoContext;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getEntityAuthenticationScheme(java.lang.String)
*/
@Override
public EntityAuthenticationScheme getEntityAuthenticationScheme(final String name) {
return EntityAuthenticationScheme.getScheme(name);
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getEntityAuthenticationFactory(com.netflix.msl.entityauth.EntityAuthenticationScheme)
*/
@Override
public EntityAuthenticationFactory getEntityAuthenticationFactory(final EntityAuthenticationScheme scheme) {
for (final EntityAuthenticationFactory factory : entityAuthFactories) {
if (factory.getScheme().equals(scheme))
return factory;
}
return null;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getUserAuthenticationScheme(java.lang.String)
*/
@Override
public UserAuthenticationScheme getUserAuthenticationScheme(final String name) {
return UserAuthenticationScheme.getScheme(name);
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getUserAuthenticationFactory(com.netflix.msl.userauth.UserAuthenticationScheme)
*/
@Override
public UserAuthenticationFactory getUserAuthenticationFactory(final UserAuthenticationScheme scheme) {
return null;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getTokenFactory()
*/
@Override
public TokenFactory getTokenFactory() {
return tokenFactory;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getKeyExchangeScheme(java.lang.String)
*/
@Override
public KeyExchangeScheme getKeyExchangeScheme(final String name) {
return KeyExchangeScheme.getScheme(name);
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getKeyExchangeFactory(com.netflix.msl.keyx.KeyExchangeScheme)
*/
@Override
public KeyExchangeFactory getKeyExchangeFactory(final KeyExchangeScheme scheme) {
return null;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getKeyExchangeFactories()
*/
@Override
public SortedSet<KeyExchangeFactory> getKeyExchangeFactories() {
return keyxFactories;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getMslStore()
*/
@Override
public MslStore getMslStore() {
return store;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getMslEncoderFactory()
*/
@Override
public MslEncoderFactory getMslEncoderFactory() {
return encoderFactory;
}
private final MessageCapabilities messageCaps;
private final EntityAuthenticationData entityAuthData;
private final ICryptoContext mslCryptoContext;
private final Set<EntityAuthenticationFactory> entityAuthFactories;
private final SortedSet<KeyExchangeFactory> keyxFactories = new TreeSet<KeyExchangeFactory>();
private final TokenFactory tokenFactory = new PushTokenFactory();
private final MslStore store = new NullMslStore();
private final MslEncoderFactory encoderFactory = new DefaultMslEncoderFactory();
}
| 1,874 |
0 |
Create_ds/msl/examples/websocket/src/main/java/server
|
Create_ds/msl/examples/websocket/src/main/java/server/msg/PushMessageContext.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 server.msg;
import java.io.IOException;
import java.util.Collections;
import java.util.Map;
import java.util.Set;
import com.netflix.msl.MslKeyExchangeException;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.keyx.KeyRequestData;
import com.netflix.msl.msg.MessageContext;
import com.netflix.msl.msg.MessageDebugContext;
import com.netflix.msl.msg.MessageOutputStream;
import com.netflix.msl.msg.MessageServiceTokenBuilder;
import com.netflix.msl.tokens.MslUser;
import com.netflix.msl.userauth.UserAuthenticationData;
/**
* <p>Example server message context for receiving messages.</p>
*
* @author Wesley Miaw <[email protected]>
*/
public class PushMessageContext implements MessageContext {
/**
* <p>Create a new receive message context.</p>
*
* @param data application data.
*/
public PushMessageContext(final byte[] data) {
this.data = data;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getCryptoContexts()
*/
@Override
public Map<String, ICryptoContext> getCryptoContexts() {
return Collections.emptyMap();
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getRemoteEntityIdentity()
*/
@Override
public String getRemoteEntityIdentity() {
return null;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#isEncrypted()
*/
@Override
public boolean isEncrypted() {
return true;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#isIntegrityProtected()
*/
@Override
public boolean isIntegrityProtected() {
return true;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#isNonReplayable()
*/
@Override
public boolean isNonReplayable() {
return false;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#isRequestingTokens()
*/
@Override
public boolean isRequestingTokens() {
return false;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getUserId()
*/
@Override
public String getUserId() {
return null;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getUserAuthData(com.netflix.msl.msg.MessageContext.ReauthCode, boolean, boolean)
*/
@Override
public UserAuthenticationData getUserAuthData(final ReauthCode reauthCode, final boolean renewable, final boolean required) {
return null;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getUser()
*/
@Override
public MslUser getUser() {
return null;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getKeyRequestData()
*/
@Override
public Set<KeyRequestData> getKeyRequestData() throws MslKeyExchangeException {
return null;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#updateServiceTokens(com.netflix.msl.msg.MessageServiceTokenBuilder, boolean)
*/
@Override
public void updateServiceTokens(final MessageServiceTokenBuilder builder, final boolean handshake) {
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#write(com.netflix.msl.msg.MessageOutputStream)
*/
@Override
public void write(final MessageOutputStream output) throws IOException {
output.write(data);
output.close();
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getDebugContext()
*/
@Override
public MessageDebugContext getDebugContext() {
return null;
}
/** Application data. */
private final byte[] data;
}
| 1,875 |
0 |
Create_ds/msl/examples/websocket/src/main/java/server
|
Create_ds/msl/examples/websocket/src/main/java/server/userauth/PushUser.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 server.userauth;
import com.netflix.msl.tokens.MslUser;
/**
* <p>A MSL user that is just the user ID.</p>
*
* @author Wesley Miaw <[email protected]>
*/
public class PushUser implements MslUser {
/**
* <p>Create a new MSL user with the given user ID.</p>
*
* @param userId the user ID.
*/
public PushUser(final String userId) {
this.userId = userId;
}
/**
* @return the user ID.
*/
public String getUserId() {
return userId;
}
/* (non-Javadoc)
* @see com.netflix.msl.tokens.MslUser#getEncoded()
*/
@Override
public String getEncoded() {
return userId;
}
/* (non-Javadoc)
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
return userId;
}
/** User string representation. */
private final String userId;
}
| 1,876 |
0 |
Create_ds/msl/examples/websocket/src/main/java/server
|
Create_ds/msl/examples/websocket/src/main/java/server/userauth/PushTokenFactory.java
|
/**
* Copyright (c) 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 server.userauth;
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.tokens.MasterToken;
import com.netflix.msl.tokens.MslUser;
import com.netflix.msl.tokens.TokenFactory;
import com.netflix.msl.tokens.UserIdToken;
import com.netflix.msl.util.MslContext;
/**
* <p>A token factory that does not create or renew tokens.</p>
*
* @author Wesley Miaw <[email protected]>
*/
public class PushTokenFactory 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) {
// No support for revoked master tokens.
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) {
// No support for non-replayable IDs.
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) {
// No support for master token creation. We do not expect this method
// to be called.
throw new MslInternalException("Cannot create master tokens.");
}
/* (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) {
// No support for master token renewable checks.
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) {
// No support for master token renewal. If attempted, simply return the
// existing master token.
return masterToken;
}
/* (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) {
// No support for revoked user ID tokens.
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) {
// No support for user ID token creation. We do not expect this method
// to be called.
throw new MslInternalException("Cannot create user ID tokens.");
}
/* (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) {
// No support for user ID token renewal. If attempted, simply return
// the existing user ID token.
return userIdToken;
}
/* (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) {
return new PushUser(userdata);
}
}
| 1,877 |
0 |
Create_ds/msl/examples/websocket/src/main/java/server
|
Create_ds/msl/examples/websocket/src/main/java/server/entityauth/PushRsaStore.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 server.entityauth;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import com.netflix.msl.entityauth.RsaStore;
/**
* <p>An example RSA key store.</p>
*
* @author Wesley Miaw <[email protected]>
*/
public class PushRsaStore implements RsaStore {
/**
* <p>Create a new RSA store that will return the provided public and/or
* private keys for the specified server entity identity. A public key must
* be provided to authenticate remote entities. A private key must be
* provided to authenticate local entities.</p>
*
* @param serverId server entity identity.
* @param publicKey server RSA public key. May be null.
* @param privateKey server RSA private key. May be null.
*/
public PushRsaStore(final String serverId, final PublicKey publicKey, final PrivateKey privateKey) {
this.serverId = serverId;
this.publicKey = publicKey;
this.privateKey = privateKey;
}
@Override
public Set<String> getIdentities() {
return new HashSet<String>(Arrays.asList(serverId));
}
@Override
public PublicKey getPublicKey(final String identity) {
if (serverId.equals(identity))
return publicKey;
return null;
}
@Override
public PrivateKey getPrivateKey(final String identity) {
if (serverId.equals(identity))
return privateKey;
return null;
}
/** Server entity identity. */
private final String serverId;
/** Server RSA public key. */
private final PublicKey publicKey;
/** Server RSA private key. */
private final PrivateKey privateKey;
};
| 1,878 |
0 |
Create_ds/msl/examples/oneshot/src/main/java
|
Create_ds/msl/examples/oneshot/src/main/java/oneshot/OneshotMslContext.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 oneshot;
import java.security.SecureRandom;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import java.util.SortedSet;
import java.util.TreeSet;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.crypto.ClientMslCryptoContext;
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.entityauth.RsaAuthenticationFactory;
import com.netflix.msl.entityauth.RsaStore;
import com.netflix.msl.entityauth.UnauthenticatedAuthenticationData;
import com.netflix.msl.entityauth.UnauthenticatedAuthenticationFactory;
import com.netflix.msl.io.DefaultMslEncoderFactory;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.keyx.AsymmetricWrappedExchange;
import com.netflix.msl.keyx.KeyExchangeFactory;
import com.netflix.msl.keyx.KeyExchangeScheme;
import com.netflix.msl.msg.MessageCapabilities;
import com.netflix.msl.tokens.ClientTokenFactory;
import com.netflix.msl.tokens.TokenFactory;
import com.netflix.msl.userauth.UserAuthenticationFactory;
import com.netflix.msl.userauth.UserAuthenticationScheme;
import com.netflix.msl.util.AuthenticationUtils;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.MslStore;
import com.netflix.msl.util.NullAuthenticationUtils;
import com.netflix.msl.util.SimpleMslStore;
/**
* <p>Simple MSL context for the oneshot example.</p>
*
* <p>This configuration uses the unauthenticated entity authentication scheme
* and the asymmetric wrapped key exchange scheme. It does not support secure
* MSL token issuance or remote user authentication.</p>
*
* @author Wesley Miaw <[email protected]>
*/
public class OneshotMslContext extends MslContext {
/** Random. */
private static final Random random = new SecureRandom();
/** MSL crypto context. */
private static final ICryptoContext mslCryptoContext = new ClientMslCryptoContext();
/** Token factory. */
private static final TokenFactory tokenFactory = new ClientTokenFactory();
/** Encoder factory. */
private static final MslEncoderFactory encoderFactory = new DefaultMslEncoderFactory();
/**
* <p>Create a new oneshot MSL context.</p>
*
* @param identity local entity identity.
* @param rsaStore RSA key store for remote entity authentication.
*/
public OneshotMslContext(final String identity, final RsaStore rsaStore) {
// Create local entity authentication data.
this.entityAuthData = new UnauthenticatedAuthenticationData(identity);
// Populate entity authentication factories, including remote entity
// authentication.
final AuthenticationUtils authutils = new NullAuthenticationUtils();
this.entityAuthFactories = new HashMap<EntityAuthenticationScheme,EntityAuthenticationFactory>();
this.entityAuthFactories.put(EntityAuthenticationScheme.NONE, new UnauthenticatedAuthenticationFactory(authutils));
this.entityAuthFactories.put(EntityAuthenticationScheme.RSA, new RsaAuthenticationFactory(rsaStore, authutils));
// Populate key exchange factories.
this.keyxFactories = new HashMap<KeyExchangeScheme,KeyExchangeFactory>();
this.keyxFactories.put(KeyExchangeScheme.ASYMMETRIC_WRAPPED, new AsymmetricWrappedExchange(authutils));
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getTime()
*/
@Override
public long getTime() {
return System.currentTimeMillis();
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getRandom()
*/
@Override
public Random getRandom() {
return random;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#isPeerToPeer()
*/
@Override
public boolean isPeerToPeer() {
return false;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getMessageCapabilities()
*/
@Override
public MessageCapabilities getMessageCapabilities() {
return null;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getEntityAuthenticationData(com.netflix.msl.util.MslContext.ReauthCode)
*/
@Override
public EntityAuthenticationData getEntityAuthenticationData(final ReauthCode reauthCode) {
return entityAuthData;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getMslCryptoContext()
*/
@Override
public ICryptoContext getMslCryptoContext() throws MslCryptoException {
return mslCryptoContext;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getEntityAuthenticationScheme(java.lang.String)
*/
@Override
public EntityAuthenticationScheme getEntityAuthenticationScheme(final String name) {
return EntityAuthenticationScheme.getScheme(name);
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getEntityAuthenticationFactory(com.netflix.msl.entityauth.EntityAuthenticationScheme)
*/
@Override
public EntityAuthenticationFactory getEntityAuthenticationFactory(final EntityAuthenticationScheme scheme) {
return entityAuthFactories.get(scheme);
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getUserAuthenticationScheme(java.lang.String)
*/
@Override
public UserAuthenticationScheme getUserAuthenticationScheme(final String name) {
return UserAuthenticationScheme.getScheme(name);
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getUserAuthenticationFactory(com.netflix.msl.userauth.UserAuthenticationScheme)
*/
@Override
public UserAuthenticationFactory getUserAuthenticationFactory(final UserAuthenticationScheme scheme) {
return null;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getTokenFactory()
*/
@Override
public TokenFactory getTokenFactory() {
return tokenFactory;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getKeyExchangeScheme(java.lang.String)
*/
@Override
public KeyExchangeScheme getKeyExchangeScheme(final String name) {
return KeyExchangeScheme.getScheme(name);
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getKeyExchangeFactory(com.netflix.msl.keyx.KeyExchangeScheme)
*/
@Override
public KeyExchangeFactory getKeyExchangeFactory(final KeyExchangeScheme scheme) {
return keyxFactories.get(scheme);
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getKeyExchangeFactories()
*/
@Override
public SortedSet<KeyExchangeFactory> getKeyExchangeFactories() {
return new TreeSet<KeyExchangeFactory>(keyxFactories.values());
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getMslStore()
*/
@Override
public MslStore getMslStore() {
return store;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getMslEncoderFactory()
*/
@Override
public MslEncoderFactory getMslEncoderFactory() {
return encoderFactory;
}
/** Entity authentication data. */
private final EntityAuthenticationData entityAuthData;
/** Entity authentication factories. */
private final Map<EntityAuthenticationScheme,EntityAuthenticationFactory> entityAuthFactories;
/** Key exchange factories. */
private final Map<KeyExchangeScheme,KeyExchangeFactory> keyxFactories;
/** MSL store. */
private final MslStore store = new SimpleMslStore();
}
| 1,879 |
0 |
Create_ds/msl/examples/oneshot/src/main/java
|
Create_ds/msl/examples/oneshot/src/main/java/oneshot/OneshotMessageContext.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 oneshot;
import java.io.IOException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
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.ICryptoContext;
import com.netflix.msl.keyx.AsymmetricWrappedExchange;
import com.netflix.msl.keyx.KeyRequestData;
import com.netflix.msl.msg.MessageDebugContext;
import com.netflix.msl.msg.MessageOutputStream;
import com.netflix.msl.msg.MessageServiceTokenBuilder;
import com.netflix.msl.msg.SecretMessageContext;
import com.netflix.msl.tokens.MslUser;
import com.netflix.msl.userauth.EmailPasswordAuthenticationData;
import com.netflix.msl.userauth.UserAuthenticationData;
/**
* <p>A simple message context for the oneshot example.</p>
*
* <p>All data must be encrypted and integrity protected. Email/password user
* authentication is supported.</p>
*
* @author Wesley Miaw <[email protected]>
*/
public class OneshotMessageContext extends SecretMessageContext {
/** MSL local user ID. */
private static final String USER_ID = "local-userid";
/** Key exchange key pair ID. */
private static final String KEY_PAIR_ID = "keyx-keypairid";
/**
* <p>Crate a new message context with the provided application data. If
* both email and password are provided then user authentication data will
* be provided as needed.</p>
*
* @param data application data.
* @param email user email address. May be {@code null}.
* @param password user password. May be {@code null}.
*/
public OneshotMessageContext(final byte[] data, final String email, final String password) {
this.data = data;
if (email != null && password != null)
this.userAuthData = new EmailPasswordAuthenticationData(email, password);
else
this.userAuthData = null;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getCryptoContexts()
*/
@Override
public Map<String, ICryptoContext> getCryptoContexts() {
return null;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getRemoteEntityIdentity()
*/
@Override
public String getRemoteEntityIdentity() {
return null;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#isRequestingTokens()
*/
@Override
public boolean isRequestingTokens() {
return true;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getUserId()
*/
@Override
public String getUserId() {
return USER_ID;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getUserAuthData(com.netflix.msl.msg.MessageContext.ReauthCode, boolean, boolean)
*/
@Override
public UserAuthenticationData getUserAuthData(final ReauthCode reauthCode, final boolean renewable, final boolean required) {
return userAuthData;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getUser()
*/
@Override
public MslUser getUser() {
return null;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getKeyRequestData()
*/
@Override
public Set<KeyRequestData> getKeyRequestData() throws MslKeyExchangeException {
// Create key request data on demand; we do not want to reuse RSA keys.
final KeyPairGenerator generator;
try {
generator = KeyPairGenerator.getInstance("RSA");
} catch (final NoSuchAlgorithmException e) {
throw new MslInternalException("RSA algorithm not found.", e);
}
generator.initialize(2048);
final KeyPair keypair = generator.generateKeyPair();
final PrivateKey privateKey = keypair.getPrivate();
final PublicKey publicKey = keypair.getPublic();
// Return key request data.
final KeyRequestData keyxRequest = new AsymmetricWrappedExchange.RequestData(KEY_PAIR_ID, AsymmetricWrappedExchange.RequestData.Mechanism.JWK_RSA, publicKey, privateKey);
return new HashSet<KeyRequestData>(Arrays.asList(keyxRequest));
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#updateServiceTokens(com.netflix.msl.msg.MessageServiceTokenBuilder, boolean)
*/
@Override
public void updateServiceTokens(final MessageServiceTokenBuilder builder, final boolean handshake) throws MslMessageException, MslCryptoException, MslEncodingException, MslException {
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#write(com.netflix.msl.msg.MessageOutputStream)
*/
@Override
public void write(final MessageOutputStream output) throws IOException {
output.write(data);
output.close();
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getDebugContext()
*/
@Override
public MessageDebugContext getDebugContext() {
return null;
}
/** Application data. */
private final byte[] data;
/** User authentication data. */
private final UserAuthenticationData userAuthData;
}
| 1,880 |
0 |
Create_ds/msl/examples/oneshot/src/main/java
|
Create_ds/msl/examples/oneshot/src/main/java/oneshot/Oneshot.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 oneshot;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.PublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.X509EncodedKeySpec;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import com.netflix.msl.MslConstants.ResponseCode;
import com.netflix.msl.MslException;
import com.netflix.msl.io.JavaUrl;
import com.netflix.msl.io.Url;
import com.netflix.msl.msg.ErrorHeader;
import com.netflix.msl.msg.MessageContext;
import com.netflix.msl.msg.MessageInputStream;
import com.netflix.msl.msg.MslControl;
import com.netflix.msl.msg.MslControl.MslChannel;
import com.netflix.msl.util.Base64;
import com.netflix.msl.util.MslContext;
/**
* @author Wesley Miaw <[email protected]>
*/
public class Oneshot {
/** Local entity identity. */
private static final String LOCAL_IDENTITY = "local-identity";
/** Remote entity identity. */
private static final String REMOTE_IDENTITY = "remote-identity";
/** Remote entity RSA public key. */
private static final String REMOTE_RSA_PUBKEY_B64 =
"MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBALeJpiH5nikd3XeAo2rHjLJVVChM/p6l" +
"VnQHyFh77w0Efbppi1P1pNy8BxJ++iFKt2dV/4ZKkUKqtlIu3KX19kcCAwEAAQ==";
/** User email address; {@code null} for no user. */
private static final String EMAIL = "[email protected]";
/** User password; {@code null} for no user. */
private static final String PASSWORD = "password";
/** MSL timeout in milliseconds. */
private static final int TIMEOUT = 30 * 1000;
/**
* @param localIdentity local entity identity.
* @param remoteIdentity remote entity identity.
* @param remoteRsaPubkeyB64 base64-encoded remote entity public key in
* X.509 format.
* @param email user email address. May be {@code null}.
* @param password user password. May be {@code null}.
* @throws NoSuchAlgorithmException if the RSA algorithm is not supported.
* @throws InvalidKeySpecException if the public key is invalid.
*/
public Oneshot(final String localIdentity, final String remoteIdentity, final String remoteRsaPubkeyB64, final String email, final String password) throws NoSuchAlgorithmException, InvalidKeySpecException {
// Create MSL control.
this.ctrl = new MslControl(0);
// Setup remote entity public key.
final byte[] pubkeyBytes = Base64.decode(remoteRsaPubkeyB64);
final X509EncodedKeySpec pubkeySpec = new X509EncodedKeySpec(pubkeyBytes);
final KeyFactory factory = KeyFactory.getInstance("RSA");
final PublicKey pubkey = factory.generatePublic(pubkeySpec);
final OneshotRsaStore rsaStore = new OneshotRsaStore(remoteIdentity, pubkey);
// Create MSL context.
this.ctx = new OneshotMslContext(localIdentity, rsaStore);
// Save user account information.
this.email = email;
this.password = password;
}
/**
* @param remoteEntity remote entity URL.
* @param data application data.
* @return the application response data or {@code null} if interrupted or
* cancelled.
* @throws MslException if there is an MSL error.
* @throws ExecutionException if there is a problem making the request.
* @throws InterruptedException if the request was interrupted.
* @throws OneshotErrorResponse if the remote entity returned a MSL error.
* @throws IOException if there is an error reading the response.
*/
public byte[] request(final Url remoteEntity, final byte[] data) throws MslException, ExecutionException, InterruptedException, OneshotErrorResponse, IOException {
// Setup message context.
final MessageContext msgCtx = new OneshotMessageContext(data, email, password);
// Make the request.
MessageInputStream mis = null;
try {
final Future<MslChannel> future = ctrl.request(ctx, msgCtx, remoteEntity, TIMEOUT);
final MslChannel channel = future.get();
// Check if cancelled or interrupted. Not expected.
if (channel == null)
return null;
// Grab the message input stream.
mis = channel.input;
} catch (final ExecutionException | InterruptedException e) {
final Throwable cause = e.getCause();
if (cause instanceof MslException)
throw (MslException)cause;
throw e;
}
// Check for an error response.
final ErrorHeader errorHeader = mis.getErrorHeader();
if (errorHeader != null)
throw new OneshotErrorResponse(errorHeader);
// Read all the response data.
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
final byte[] buffer = new byte[16384];
do {
final int count = mis.read(buffer);
if (count == -1)
return baos.toByteArray();
baos.write(buffer, 0, count);
} while (true);
}
/** MSL control. */
private final MslControl ctrl;
/** MSL context. */
private final MslContext ctx;
/** User email address. */
private final String email;
/** User password. */
private final String password;
/**
* <p>Issue a oneshot request/response to a MSL endpoint.</p>
*
* <p>The first argument is a URL pointing at the remote entity. The second
* argument identifes the application request data source: either a
* filename or the '-' character to read from stdin.</p>
*
* <p>The response data is printed to stdout. Any errors or exceptions are
* printed to stderr.</p>
*/
public static void main(final String[] args) {
try {
if (args.length != 2) {
System.err.println("Usage: oneshot url file");
System.err.println(" use '-' for file to read from STDIN");
System.exit(1);
}
// Grab remote URL and data file.
final Url url = new JavaUrl(new URL(args[0]));
final String file = args[1];
// Read request data.
final byte[] request;
final InputStream is = (file.equals("-"))
? System.in
: new FileInputStream(file);
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
final byte[] buffer = new byte[16384];
do {
final int count = is.read(buffer);
if (count == -1) {
request = baos.toByteArray();
break;
}
baos.write(buffer, 0, count);
} while (true);
// Send request and print application response data.
final Oneshot oneshot = new Oneshot(LOCAL_IDENTITY, REMOTE_IDENTITY, REMOTE_RSA_PUBKEY_B64, EMAIL, PASSWORD);
final byte[] response = oneshot.request(url, request);
System.out.write(response);
} catch (final Throwable t) {
// Print the exception message and stack trace for normal errors.
if (!(t instanceof OneshotErrorResponse)) {
t.printStackTrace(System.err);
return;
}
// Print the MSL error details for MSL error responses.
final OneshotErrorResponse oer = (OneshotErrorResponse)t;
final ErrorHeader errorHeader = oer.getErrorHeader();
final ResponseCode errorCode = errorHeader.getErrorCode();
final int internalCode = errorHeader.getInternalCode();
final String errorMessage = errorHeader.getErrorMessage();
final String userMessage = errorHeader.getUserMessage();
System.err.println("MSL Error: " + errorCode + " (" + internalCode + ")");
System.err.println("\t" + errorMessage);
if (userMessage != null)
System.err.println("\t" + userMessage);
}
}
}
| 1,881 |
0 |
Create_ds/msl/examples/oneshot/src/main/java
|
Create_ds/msl/examples/oneshot/src/main/java/oneshot/OneshotErrorResponse.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 oneshot;
import com.netflix.msl.msg.ErrorHeader;
/**
* <p>A oneshot error response is thrown if communication with the remote
* application failed due to a MSL error.</p>
*
* @author Wesley Miaw <[email protected]>
*/
public class OneshotErrorResponse extends Exception {
private static final long serialVersionUID = -1145472407581465209L;
/**
* @param errorHeader the error header.
*/
public OneshotErrorResponse(final ErrorHeader errorHeader) {
this.errorHeader = errorHeader;
}
/**
* @return the error header.
*/
public ErrorHeader getErrorHeader() {
return errorHeader;
}
/** MSL error header. */
private final ErrorHeader errorHeader;
}
| 1,882 |
0 |
Create_ds/msl/examples/oneshot/src/main/java
|
Create_ds/msl/examples/oneshot/src/main/java/oneshot/OneshotRsaStore.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 oneshot;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import com.netflix.msl.entityauth.RsaStore;
/**
* <p>Simple RSA store for the oneshot example.</p>
*/
public class OneshotRsaStore implements RsaStore {
/**
* <p>Create a new RSA store for the specified entity identity and matching
* public key.</p>
*
* @param identity entity identity.
* @param pubkey entity public key.
*/
public OneshotRsaStore(final String identity, final PublicKey pubkey) {
this.identity = identity;
this.pubkey = pubkey;
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.RsaStore#getIdentities()
*/
@Override
public Set<String> getIdentities() {
return new HashSet<String>(Arrays.asList(identity));
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.RsaStore#getPublicKey(java.lang.String)
*/
@Override
public PublicKey getPublicKey(final String identity) {
if (this.identity.equals(identity))
return pubkey;
return null;
}
/* (non-Javadoc)
* @see com.netflix.msl.entityauth.RsaStore#getPrivateKey(java.lang.String)
*/
@Override
public PrivateKey getPrivateKey(final String identity) {
return null;
}
/** Entity identity. */
private final String identity;
/** Public key. */
private final PublicKey pubkey;
}
| 1,883 |
0 |
Create_ds/msl/examples/proxy/src/main/java/com/netflix
|
Create_ds/msl/examples/proxy/src/main/java/com/netflix/msl/ProxyTransientException.java
|
/**
* Copyright (c) 2015 Netflix, Inc. All rights reserved.
*/
package com.netflix.msl;
/**
* <p>Thrown when there is a transient failure indicating the operation may
* succeed at a later time.</p>
*
* @author Wesley Miaw <[email protected]>
*/
public class ProxyTransientException extends ProxyException {
private static final long serialVersionUID = -99248671046579868L;
/**
* <p>Creates a new {@code ProxyTransientException} with the specified detail
* message and cause.</p>
*
* @param message the detail message.
* @param cause the cause. May be {@code null}.
*/
public ProxyTransientException(final String message, final Throwable cause) {
super(message, cause);
}
}
| 1,884 |
0 |
Create_ds/msl/examples/proxy/src/main/java/com/netflix
|
Create_ds/msl/examples/proxy/src/main/java/com/netflix/msl/ProxyMslError.java
|
/**
* Copyright (c) 2015 Netflix, Inc. All rights reserved.
*/
package com.netflix.msl;
import com.netflix.msl.MslConstants.ResponseCode;
/**
* <p>Proxy MSL error codes and descriptions.</p>
*
* @author Wesley Miaw <[email protected]>
*/
public class ProxyMslError extends MslError {
/** Zuul proxy internal error code offset value. */
private static final int OFFSET = 200000;
// 1 Master Token
public static final MslError MASTERTOKEN_CREATION_REQUIRED = new ProxyMslError(1000, ResponseCode.FAIL, "Master token creation required.", true);
public static final MslError MASTERTOKEN_RENEWAL_REQUIRED = new ProxyMslError(1001, ResponseCode.FAIL, "Master token renewal required.", true);
// 2 User ID Token
public static final MslError USERIDTOKEN_CREATION_REQUIRED = new ProxyMslError(2000, ResponseCode.FAIL, "User ID token creation required.", true);
public static final MslError USERIDTOKEN_RENEWAL_REQUIRED = new ProxyMslError(2001, ResponseCode.FAIL, "User ID token renewal required.", true);
// 3 Service Token
// 4 Entity Authentication
public static final MslError ENTITYAUTH_REQUIRED = new ProxyMslError(4000, ResponseCode.FAIL, "Entity authentication required.", true);
public static final MslError ENTITYAUTH_CANNOT_FAILOVER = new ProxyMslError(4001, ResponseCode.TRANSIENT_FAILURE, "Entity authentication cannot be handled during failover.", false);
// 5 User Authentication
public static final MslError USERAUTH_REQUIRED = new ProxyMslError(5000, ResponseCode.FAIL, "User authentication required.", true);
public static final MslError USERAUTH_CANNOT_FAILOVER = new ProxyMslError(5001, ResponseCode.TRANSIENT_FAILURE, "User authentication cannot be handled during failover.", false);
// 6 Message
public static final MslError NONREPLAYABLE_ID_CHECK_REQUIRED = new ProxyMslError(6000, ResponseCode.FAIL, "Non-replayable message check required.", true);
public static final MslError SERVICETOKEN_REQUIRES_MASTERTOKEN = new ProxyMslError(6001, ResponseCode.FAIL, "Cannot attach entity service token to a message with no master token.", false);
public static final MslError SERVICETOKEN_REQUIRES_USERIDTOKEN = new ProxyMslError(6002, ResponseCode.FAIL, "Cannot attach user service token to a message with no user ID token.", false);
// 7 Key Exchange
public static final MslError KEYX_REQUIRED = new ProxyMslError(7000, ResponseCode.FAIL, "Key exchange required.", true);
// 9 Internal Errors
//public static final MslError PROXY_ACTION_REQUIRED = new ProxyMslError(9000, ResponseCode.FAIL, "External processing by the proxied MSL service is required.", true);
/**
* Construct a Proxy MSL error with the specified internal and response
* error codes and message.
*
* @param internalCode internal error code.
* @param responseCode response error code.
* @param msg developer-consumable error message.
* @param requiresExternalProcessing true if this error indicates the
* message requires processing by the external MSL service.
*/
protected ProxyMslError(final int internalCode, final ResponseCode responseCode, final String msg, final boolean requiresExternalProcessing) {
super(OFFSET + internalCode, responseCode, msg);
this.requiresExternalProcessing = requiresExternalProcessing;
}
/**
* Check if the given MSL error indicates a message required processing by
* the external MSL service being proxied.
*
* @param e the MSL error to check.
* @return true if the MSL error indicates the message requires processing
* by the external MSL service.
*/
public static boolean isExternalProcessingRequired(final MslError e) {
// FIXME this function may be unnecessary.
return (e instanceof ProxyMslError && ((ProxyMslError)e).requiresExternalProcessing);
}
/** External processing required. */
private final boolean requiresExternalProcessing;
}
| 1,885 |
0 |
Create_ds/msl/examples/proxy/src/main/java/com/netflix
|
Create_ds/msl/examples/proxy/src/main/java/com/netflix/msl/ProxyMslException.java
|
/**
* Copyright (c) 2015 Netflix, Inc. All rights reserved.
*/
package com.netflix.msl;
/**
* <p>Thrown by the proxy when a MSL exception has occurred.</p>
*
* @author Wesley Miaw <[email protected]>
*/
public class ProxyMslException extends ProxyException {
private static final long serialVersionUID = 2621303915896379638L;
/**
* <p>Creates a new {@code ProxyMslException} with the specified detail
* message and cause.</p>
*
* @param message the detail message.
* @param cause the cause. May be {@code null}.
*/
public ProxyMslException(final String message, final MslException cause) {
super(message, cause);
}
}
| 1,886 |
0 |
Create_ds/msl/examples/proxy/src/main/java/com/netflix
|
Create_ds/msl/examples/proxy/src/main/java/com/netflix/msl/ProxyException.java
|
/**
* Copyright (c) 2015 Netflix, Inc. All rights reserved.
*/
package com.netflix.msl;
/**
* <p>Thrown by the proxy when an exception has occurred. This class is the
* general class of exceptions produced by failed proxy operations.</p>
*
* @author Wesley Miaw <[email protected]>
*/
public class ProxyException extends Exception {
private static final long serialVersionUID = -2504349809538822945L;
/**
* <p>Creates a new {@code ProxyException} with the specified detail
* message and cause.</p>
*
* @param message the detail message.
* @param cause the cause. May be {@code null}.
*/
public ProxyException(final String message, final Throwable cause) {
super(message, cause);
}
}
| 1,887 |
0 |
Create_ds/msl/examples/proxy/src/main/java/com/netflix
|
Create_ds/msl/examples/proxy/src/main/java/com/netflix/msl/Proxy.java
|
/**
* Copyright (c) 2015-2018 Netflix, Inc. All rights reserved.
*/
package com.netflix.msl;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.BufferOverflowException;
import java.nio.ByteBuffer;
import java.nio.ReadOnlyBufferException;
import java.util.Collections;
import java.util.Map;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import com.netflix.msl.msg.MessageFactory;
import rx.Observable;
import rx.Observable.OnSubscribe;
import rx.Subscriber;
import rx.functions.Action1;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.entityauth.EntityAuthenticationData;
import com.netflix.msl.entityauth.EntityAuthenticationFactory;
import com.netflix.msl.msg.ErrorMessageRegistry;
import com.netflix.msl.msg.MessageContext;
import com.netflix.msl.msg.MessageDebugContext;
import com.netflix.msl.msg.MessageInputStream;
import com.netflix.msl.msg.MslControl;
import com.netflix.msl.msg.MslControl.MslChannel;
import com.netflix.msl.msg.ReceiveMessageContext;
import com.netflix.msl.msg.RespondMessageContext;
import com.netflix.msl.tokens.MslUser;
import com.netflix.msl.util.FailoverMslContext;
import com.netflix.msl.util.MslContext;
import com.netflix.msl.util.ProxyMslContext;
/**
* <p>A MSL proxy that first attempts to process messages locally, then
* forwards them for external processing if unable to do so, and finally
* attempts to accept and respond if unable to communicate with the external
* processor.</p>
*
* <p>The {@link #receive(ICryptoContext, ByteBuffer, ByteBuffer, int, MessageDebugContext)}
* method is used to process an incoming MSL message. If the message is
* processed successfully, the resulting {@link MessageInputStream} will be
* returned. If unsuccessful, any data written into the output stream must be
* delivered to the remote entity.</p>
*
* <p>The {@link #respond(ICryptoContext, Response, ByteBuffer, MessageInputStream, int, MessageDebugContext)}
* method is used to create a response to a previous MSL message. If the
* response is generated successfully and the application data will be sent,
* {@link Boolean#TRUE} is returned. If the application data will not be sent
* due to an inability to satisfy the application's security and message
* requirements, {@link Boolean#FALSE} is returned. In all cases any data
* written into the output stream must be delivered to the remote entity.</p>
*
* <p>The methods {@link #receiveExternally(ByteBuffer, ByteBuffer)}
* {@link #respondExternally(MessageInputStream, Response, ByteBuffer)}
* be implemented to perform any external message processing. These methods
* will be called when the proxy is unable to process a message locally.</p>
*
* @author Wesley Miaw <[email protected]>
*/
public abstract class Proxy {
/**
* An {@link InputStream} wrapper around a {@link ByteBuffer}.
*/
private static class ByteBufferInputStream extends InputStream {
/**
* <p>Create a new byte buffer input stream with the provided backing
* byte buffer.</p>
*
* @param buffer backing byte buffer.
*/
public ByteBufferInputStream(final ByteBuffer buffer) {
this.buffer = buffer;
}
/* (non-Javadoc)
* @see java.io.InputStream#read()
*/
@Override
public int read() throws IOException {
if (available() == 0) return -1;
return buffer.get();
}
/* (non-Javadoc)
* @see java.io.InputStream#read(byte[], int, int)
*/
@Override
public int read(byte[] b, int off, int len) throws IOException {
final int available = available();
if (available == 0)
return -1;
final int count = Math.min(len - off, available);
buffer.get(b, 0, count);
return count;
}
/* (non-Javadoc)
* @see java.io.InputStream#skip(long)
*/
@Override
public long skip(final long n) throws IOException {
if (n < 0) return 0;
final int count = Math.min((int)n, available());
buffer.position(buffer.position() + count);
return count;
}
/* (non-Javadoc)
* @see java.io.InputStream#available()
*/
@Override
public int available() throws IOException {
return buffer.remaining();
}
/* (non-Javadoc)
* @see java.io.InputStream#mark(int)
*/
@Override
public synchronized void mark(final int readlimit) {
buffer.mark();
}
/* (non-Javadoc)
* @see java.io.InputStream#reset()
*/
@Override
public synchronized void reset() throws IOException {
buffer.reset();
}
/* (non-Javadoc)
* @see java.io.InputStream#markSupported()
*/
@Override
public boolean markSupported() {
return true;
}
/** Backing byte buffer. */
private final ByteBuffer buffer;
}
/**
* An {@link OutputStream} wrapper around a {@link ByteBuffer}.
*/
private static class ByteBufferOutputStream extends OutputStream {
/**
* <p>Create a new byte buffer output stream with the provided backing
* byte buffer.</p>
*
* @param buffer backing byte buffer.
*/
public ByteBufferOutputStream(final ByteBuffer buffer) {
this.buffer = buffer;
}
/* (non-Javadoc)
* @see java.io.OutputStream#write(int)
*/
@Override
public void write(final int b) throws IOException {
try {
buffer.put((byte)(b & 0xff));
} catch (final BufferOverflowException | ReadOnlyBufferException e) {
throw new IOException(e);
}
}
/* (non-Javadoc)
* @see java.io.OutputStream#write(byte[], int, int)
*/
@Override
public void write(final byte[] b, final int off, final int len) throws IOException {
if (off < 0 || len < 0 || off + len > b.length)
throw new IndexOutOfBoundsException();
try {
buffer.put(b, off, len);
} catch (final BufferOverflowException | ReadOnlyBufferException e) {
throw new IOException(e);
}
}
/** Backing byte buffer. */
private final ByteBuffer buffer;
}
/**
* <p>A response data container.</p>
*/
public static class Response {
/**
* <p>Construct a new response data container with the provided
* data.</p>
*
* @param appdata the application data to include in the response. May
* be empty.
* @param entityServiceTokens entity-associated service token
* name/value pairs. May be empty.
* @param userServiceTokens user-associated service token name/value
* pairs. May be empty.
* @param user a user to attach to the response. May be {@code null}.
*/
public Response(final byte[] appdata, final Map<String,byte[]> entityServiceTokens, final Map<String,byte[]> userServiceTokens, final MslUser user) {
this.appdata = appdata;
this.entityServiceTokens = Collections.unmodifiableMap(entityServiceTokens);
this.userServiceTokens = Collections.unmodifiableMap(userServiceTokens);
this.user = user;
}
/** Application data. */
public byte[] appdata;
/** Entity service tokens. */
public Map<String,byte[]> entityServiceTokens;
/** User service tokens. */
public Map<String,byte[]> userServiceTokens;
/** MSL user. May be {@code null}. */
public MslUser user;
}
/**
* <p>Create a new proxy.</p>
*
* <p>The local entity authentication data and factory will be used to
* authenticate the local identity when generating responses.</p>
*
* <p>The MSL token crypto context will be used to verify and decrypt the
* MSL tokens of received messages.</p>
*
* @param messageFactory message factory.
* @param registry MSL error message registry.
* @param entityAuthData local entity authentication data.
* @param entityAuthFactory local entity authentication factory.
* @param mslCryptoContext MSL token crypto context.
*/
public Proxy(final MessageFactory messageFactory, final ErrorMessageRegistry registry, final EntityAuthenticationData entityAuthData, final EntityAuthenticationFactory entityAuthFactory, final ICryptoContext mslCryptoContext) {
mslCtrl = new MslControl(0, messageFactory, registry);
proxyMslCtx = new ProxyMslContext(entityAuthData, entityAuthFactory, mslCryptoContext);
failoverMslCtx = new FailoverMslContext(entityAuthData, entityAuthFactory, mslCryptoContext);
}
/**
* <p>This observable receives a request from the remote entity and attempts
* to process it in the following order:
* <ol>
* <li>Locally if the message does not require authentication, key exchange,
* or other external dependencies.</li>
* <li>Through the external service being proxied.</li>
* <li>With failover behaviors if the external service cannot be accessed
* and the message does not require authentication to occur.</li>
* </ol>
*/
private class ReceiveObservable implements OnSubscribe<MessageInputStream> {
/**
* <p>Create a new receive observable.</p>
*
* <p> The input stream must contain the entire request data, which
* will be read before any attempt is made to process it.</p>
*
* @param tokenCryptoContext service token crypto context.
* @param in remote entity input stream.
* @param out remote entity output stream.
* @param timeout renewal lock acquisition timeout.
* @param dbgCtx message debug context.
*/
public ReceiveObservable(final ICryptoContext tokenCryptoContext, final ByteBuffer in, final ByteBuffer out, final int timeout, final MessageDebugContext dbgCtx) {
this.tokenCryptoContext = tokenCryptoContext;
this.in = in;
this.out = out;
this.timeout = timeout;
this.dbgCtx = dbgCtx;
}
/**
* <p>Receive a request over the provided byte buffer.</p>
*
* <p>If {@link MessageInputStream} is returned then the MSL message
* was successfully processed and the MSL header and application data
* can be accessed directly.</p>
*
* <p>If {@code null} is returned then the MSL message does not contain
* any application data. Any MSL error and handshake responses will
* have been written into the provided output stream and must be
* delivered to the remote entity.</p>
*
* <p>If an exception is thrown any MSL error and handshake responses
* will have been written into the provided output stream and must be
* delivered to the remote entity.</p>
*
* <p>The following checked exceptions may be thrown:
* <ul>
* <li>{@link IOException} if there is an error reading from the input
* or writing to the output stream.</li>
* <li>{@link InterruptedException} if the thread was interrupted while
* processing the message.</li>
* <li>{@link ProxyMslException} if the message cannot be processed due
* to a MSL exception.</li>
* <li>{@link ProxyException} if the message cannot be processed due to
* a non-MSL reason.</li>
* </ul></p>
*
* @param observer the event observer.
*/
@Override
public void call(final Subscriber<? super MessageInputStream> observer) {
try {
// Mark the byte buffers so their positions can be reset.
in.mark();
out.mark();
// First attempt to proxy the request.
final Observable<MessageInputStream> local = receiveLocally(tokenCryptoContext, in, out, timeout, dbgCtx);
local.subscribe(new Action1<MessageInputStream>() {
@Override
public void call(final MessageInputStream mis) {
observer.onNext(mis);
observer.onCompleted();
return;
}
}, new Action1<Throwable>() {
@Override
public void call(final Throwable t) {
// A MslException indicates external processing is
// required.
if (t instanceof MslException) {
callExternal(observer);
return;
}
observer.onError(t);
return;
}
});
} catch (final Throwable t) {
observer.onError(t);
return;
}
}
/**
* This method has the same behavior as {@link #call(Subscriber)}.
*/
private void callExternal(final Subscriber<? super MessageInputStream> observer) {
try {
// Reset the byte buffers.
in.reset();
out.reset();
// Second attempt to process externally.
final Observable<MessageInputStream> ext = receiveExternally(in, out);
ext.subscribe(new Action1<MessageInputStream>() {
@Override
public void call(final MessageInputStream mis) {
observer.onNext(mis);
observer.onCompleted();
return;
}
}, new Action1<Throwable>() {
@Override
public void call(final Throwable t) {
// If there was a problem communicating with or a
// transient failure at the external service, failover
// processing is required.
if (t instanceof ProxyIoException || t instanceof ProxyTransientException) {
callFailover(observer);
return;
}
observer.onError(t);
return;
}
});
} catch (final Throwable t) {
observer.onError(t);
return;
}
}
/**
* This method has the same behavior as {@link #call(Subscriber)}.
*/
private void callFailover(final Subscriber<? super MessageInputStream> observer) {
try {
// Reset the byte buffers.
in.reset();
out.reset();
// Third attempt to process in failover mode.
final Observable<MessageInputStream> failover = receiveFailover(tokenCryptoContext, in, out, timeout, dbgCtx);
failover.subscribe(observer);
} catch (final Throwable t) {
observer.onError(t);
return;
}
}
/** Service token crypto context. */
final ICryptoContext tokenCryptoContext;
/** Remote entity input stream. */
final ByteBuffer in;
/** Remote entity output stream. */
final ByteBuffer out;
/** Renewal lock acquisition timeout in milliseconds. */
final int timeout;
/** Message debug context. */
final MessageDebugContext dbgCtx;
}
/**
* <p>This observable receives a request from the remote entity and attempts
* to process it locally.</p>
*/
private class ReceiveLocallyObservable implements OnSubscribe<MessageInputStream> {
/**
* <p>Create a new receive locally observable.</p>
*
* <p> The input stream must contain the entire request data, which
* will be read before any attempt is made to process it.</p>
*
* @param tokenCryptoContext service token crypto context.
* @param in remote entity input stream.
* @param out remote entity output stream.
* @param timeout renewal lock acquisition timeout.
* @param dbgCtx message debug context.
*/
public ReceiveLocallyObservable(final ICryptoContext tokenCryptoContext, final ByteBuffer in, final ByteBuffer out, final int timeout, final MessageDebugContext dbgCtx) {
this.tokenCryptoContext = tokenCryptoContext;
this.in = in;
this.out = out;
this.timeout = timeout;
this.dbgCtx = dbgCtx;
}
/**
* <p>Receive and locally process a request over the provided byte
* buffer.</p>
*
* <p>If {@link MessageInputStream} is returned then the MSL message
* was successfully processed and the MSL header and application data
* can be accessed directly.</p>
*
* <p>If {@code null} is returned then the MSL message does not contain
* any application data. Any MSL error and handshake responses will
* have been written into the provided output stream and must be
* delivered to the remote entity.</p>
*
* <p>If an exception is thrown any MSL error and handshake responses will
* have been written into the provided output byte buffer. If external
* processing is not indicated then any such data must be delivered to the
* remote entity.</p>
*
* <p>The following checked exceptions may be thrown:
* <ul>
* <li>{@link IOException} if there is an error reading from the input
* or writing to the output stream.</li>
* <li>{@link CancellationException} if the operation was cancelled.
* <li>{@link InterruptedException} if the thread was interrupted while
* processing the message.</li>
* <li>{@link ProxyMslException} if the message cannot be processed due
* to a MSL exception.</li>
* <li>{@link ProxyException} if the message cannot be processed due to
* a non-MSL reason.</li>
* <li>{@link MslException} if the message must be processed
* externally.<li>
* </ul></p>
*
* @param observer the event observer.
*/
@Override
public void call(Subscriber<? super MessageInputStream> observer) {
// Attempt to proxy the request.
try {
final MessageContext msgCtx = new ReceiveMessageContext(tokenCryptoContext, dbgCtx);
final ByteBufferInputStream bbis = new ByteBufferInputStream(in);
final ByteBufferOutputStream bbos = new ByteBufferOutputStream(out);
final Future<MessageInputStream> proxyFuture = mslCtrl.receive(proxyMslCtx, msgCtx, bbis, bbos, timeout);
final MessageInputStream mis = proxyFuture.get();
observer.onNext(mis);
observer.onCompleted();
return;
} catch (final InterruptedException e) {
observer.onError(e);
return;
} catch (final ExecutionException e) {
// Throw the exception if it is not a MSL exception indicating
// external processing.
final Throwable cause = e.getCause();
if (!(cause instanceof MslException)) {
observer.onError(new ProxyException("Unexpected exception thrown by proxied MslControl.receive().", cause));
return;
}
final MslException mslCause = (MslException)cause;
if (!ProxyMslError.isExternalProcessingRequired(mslCause.getError())) {
observer.onError(new ProxyMslException("MSL exception thrown by proxied MslControl.receive().", mslCause));
return;
}
// External processing is required. Throw the original cause.
observer.onError(mslCause);
return;
} catch (Throwable t) {
observer.onError(t);
return;
}
}
/** Service token crypto context. */
final ICryptoContext tokenCryptoContext;
/** Remote entity input stream. */
final ByteBuffer in;
/** Remote entity output stream. */
final ByteBuffer out;
/** Renewal lock acquisition timeout in milliseconds. */
final int timeout;
/** Message debug context. */
final MessageDebugContext dbgCtx;
}
/**
* <p>This observable receives a request from the remote entity and attempts
* to process it in failover mode.</p>
*/
private class ReceiveFailoverObservable implements OnSubscribe<MessageInputStream> {
/**
* <p>Create a new receive failover observable.</p>
*
* <p> The input stream must contain the entire request data, which
* will be read before any attempt is made to process it.</p>
*
* @param tokenCryptoContext service token crypto context.
* @param in remote entity input stream.
* @param out remote entity output stream.
* @param timeout renewal lock acquisition timeout.
* @param dbgCtx message debug context.
*/
public ReceiveFailoverObservable(final ICryptoContext tokenCryptoContext, final ByteBuffer in, final ByteBuffer out, final int timeout, final MessageDebugContext dbgCtx) {
this.tokenCryptoContext = tokenCryptoContext;
this.in = in;
this.out = out;
this.timeout = timeout;
this.dbgCtx = dbgCtx;
}
/**
* <p>Receive and locally process in failover mode a request over the
* provided byte buffer.</p>
*
* <p>If {@link MessageInputStream} is returned then the MSL message
* was successfully processed and the MSL header and application data
* can be accessed directly.</p>
*
* <p>If {@code null} is returned then the MSL message does not contain
* any application data. Any MSL error and handshake responses will
* have been written into the provided output stream and must be
* delivered to the remote entity.</p>
*
* <p>If an exception is thrown any MSL error and handshake responses
* will have been written into the provided output stream and must be
* delivered to the remote entity.</p>
*
* <p>The following checked exceptions may be thrown:
* <ul>
* <li>{@link IOException} if there is an error reading from the input
* or writing to the output stream.</li>
* <li>{@link InterruptedException} if the thread was interrupted while
* processing the message.</li>
* <li>{@link ProxyMslException} if the message cannot be processed due
* to a MSL exception.</li>
* <li>{@link ProxyException} if the message cannot be processed due to
* a non-MSL reason.</li>
* </ul></p>
*
* @param observer the event observer.
*/
@Override
public void call(Subscriber<? super MessageInputStream> observer) {
// Attempt to process the request in failover mode.
try {
final MessageContext msgCtx = new ReceiveMessageContext(tokenCryptoContext, dbgCtx);
final ByteBufferInputStream bbis = new ByteBufferInputStream(in);
final ByteBufferOutputStream bbos = new ByteBufferOutputStream(out);
final Future<MessageInputStream> failoverFuture = mslCtrl.receive(failoverMslCtx, msgCtx, bbis, bbos, timeout);
final MessageInputStream mis = failoverFuture.get();
observer.onNext(mis);
observer.onCompleted();
return;
} catch (final InterruptedException e) {
observer.onError(e);
return;
} catch (final ExecutionException e) {
// Throw the exception.
final Throwable cause = e.getCause();
if (!(cause instanceof MslException)) {
observer.onError(new ProxyException("Unexpected exception thrown by failover MslControl.receive().", cause));
return;
}
final MslException mslCause = (MslException)cause;
observer.onError(new ProxyMslException("MSL exception thrown by failover MslControl.recieve().", mslCause));
return;
} catch (Throwable t) {
observer.onError(t);
return;
}
}
/** Service token crypto context. */
final ICryptoContext tokenCryptoContext;
/** Remote entity input stream. */
final ByteBuffer in;
/** Remote entity output stream. */
final ByteBuffer out;
/** Renewal lock acquisition timeout in milliseconds. */
final int timeout;
/** Message debug context. */
final MessageDebugContext dbgCtx;
}
/**
* <p>Process a request over the provided input byte buffer. The byte
* buffer must contain the entire request data, which will be read before
* any attempt is made to process it.</p>
*
* <p>The returned {@link Observable} will return the received
* {@link MessageInputStream} if the MSL message was successfully
* processed. The MSL header and application data can then be accessed
* directly.</p>
*
* <p>If the {@link Observable} returns {@code null} then the received MSL
* message does not have any application data. Any MSL error and handshake
* responses will have been written into the provided output stream and
* must be delivered to the remote entity.</p>
*
* <p>If an exception is thrown any MSL error and handshake responses will
* have been written into the provided output stream and must be delivered
* to the remote entity.</p>
*
* <p>The {@link Observable} may throw any of the following exceptions:
* <ul>
* <li>{@link IOException} if there is an error reading from the input or
* writing to the output stream.</li>
* <li>{@link CancellationException} if the operation was cancelled.
* <li>{@link InterruptedException} if the thread was interrupted while
* processing the message.</li>
* <li>{@link ProxyMslException} if the message cannot be processed due to
* a MSL exception.</li>
* <li>{@link ProxyException} if the message cannot be processed due to a
* non-MSL reason.</li>
* </ul></p>
*
* @param tokenCryptoContext service token crypto context.
* @param in remote entity input byte buffer.
* @param out remote entity output byte buffer.
* @param timeout MSL renewal lock acquisition timeout in milliseconds.
* @param dbgCtx message debug context.
* @return an {@link Observable} for the message.
*/
public Observable<MessageInputStream> receive(final ICryptoContext tokenCryptoContext, final ByteBuffer in, final ByteBuffer out, final int timeout, final MessageDebugContext dbgCtx) {
return Observable.create(new ReceiveObservable(tokenCryptoContext, in, out, timeout,dbgCtx));
}
/**
* <p>Locally process the request contained in the provided input byte
* buffer.</p>
*
* <p>The returned {@link Observable} will return the received
* {@link MessageInputStream} if the MSL message was successfully
* processed. The MSL header and application data can then be accessed
* directly.</p>
*
* <p>If the {@link Observable} returns {@code null} then the received MSL
* message does not have any application data. Any MSL error and handshake
* responses will have been written into the provided output stream and
* must be delivered to the remote entity.</p>
*
* <p>If an exception is thrown any MSL error and handshake responses will
* have been written into the provided output byte buffer. If external
* processing is not indicated then any such data must be delivered to the
* remote entity.</p>
*
* <p>The {@link Observable} may throw any of the following exceptions:
* <ul>
* <li>{@link IOException} if there is an error reading from the input or
* writing to the output stream.</li>
* <li>{@link CancellationException} if the operation was cancelled.
* <li>{@link InterruptedException} if the thread was interrupted while
* processing the message.</li>
* <li>{@link ProxyMslException} if the message cannot be processed due to
* a MSL exception.</li>
* <li>{@link ProxyException} if the message cannot be processed due to a
* non-MSL reason.</li>
* <li>{@link MslException} if the message must be processed externally.<li>
* </ul></p>
*
* @param tokenCryptoContext service token crypto context.
* @param in remote entity input byte buffer.
* @param out remote entity output byte buffer.
* @param timeout MSL renewal lock acquisition timeout in milliseconds.
* @param dbgCtx message debug context.
* @return an {@link Observable} for the message.
*/
protected Observable<MessageInputStream> receiveLocally(final ICryptoContext tokenCryptoContext, final ByteBuffer in, final ByteBuffer out, final int timeout, final MessageDebugContext dbgCtx) {
return Observable.create(new ReceiveLocallyObservable(tokenCryptoContext, in, out, timeout, dbgCtx));
}
/**
* <p>Externally process the request contained in the provided input byte
* buffer. The byte buffer must contain the entire request data, which will
* be read before any attempt is made to process it.</p>
*
* <p>If {@link MessageInputStream} is returned then the MSL message was
* successfully processed and the MSL header and application data can be
* accessed directly.</p>
*
* <p>If {@code null} was returned then a reply was automatically sent or
* the operation was cancelled or interrupted. Any MSL response (success or
* error) will have been written into the provided output stream and must
* be delivered to the remote entity. Reasons for a {@code null} return
* value include:</p>
* <ul>
* <li>Automatic response to a handshake request.</li>
* <li>An error response must be sent.</li>
* </ul></p>
*
* <p>If an exception is thrown any MSL error and handshake responses will
* have been written into the provided output byte buffer. If failover
* processing is not indicated then any such data must be delivered to the
* remote entity.</p>
*
* <p>The {@link Observable} may throw any of the following exceptions:
* <ul>
* <li>{@link ProxyIoException} if there is an error communicating with the
* external service. This indicates the message should be processed
* in failover mode.</li>
* <li>{@link ProxyTransientException} if there is a transient problem with
* the external service. This indicates the message should be processed
* in failover mode.</li>
* <li>{@link ProxyMslException} if the external service throws a MSL
* exception.</li>
* <li>{@link ProxyException} if the message cannot be processed by the
* external service for a non-MSL reason.</li>
* </ul></p>
*
* <p>This function must not call {@link ByteBuffer#mark()} on either the
* input or output byte buffers.</p>
*
* @param in remote entity input byte buffer.
* @param out remote entity output byte buffer.
* @return an {@link Observable} for the message.
*/
protected abstract Observable<MessageInputStream> receiveExternally(final ByteBuffer in, final ByteBuffer out);
/**
* <p>Locally process the request contained in the provided input byte
* buffer in failover mode.</p>
*
* <p>The returned {@link Observable} will return the received
* {@link MessageInputStream} if the MSL message was successfully
* processed. The MSL header and application data can then be accessed
* directly.</p>
*
* <p>If the {@link Observable} returns {@code null} then the received MSL
* message does not have any application data. Any MSL error and handshake
* responses will have been written into the provided output stream and
* must be delivered to the remote entity.</p>
*
* <p>If an exception is thrown any MSL error and handshake responses will
* have been written into the provided output stream and must be delivered
* to the remote entity.</p>
*
* <p>The {@link Observable} may throw any of the following exceptions:
* <ul>
* <li>{@link IOException} if there is an error reading from the input or
* writing to the output stream.</li>
* <li>{@link CancellationException} if the operation was cancelled.
* <li>{@link InterruptedException} if the thread was interrupted while
* processing the message.</li>
* <li>{@link ProxyMslException} if the message cannot be processed due to
* a MSL exception.</li>
* <li>{@link ProxyException} if the message cannot be processed due to a
* non-MSL reason.</li>
* </ul></p>
*
* @param tokenCryptoContext service token crypto context.
* @param in remote entity input byte buffer.
* @param out remote entity output byte buffer.
* @param timeout MSL renewal lock acquisition timeout in milliseconds.
* @param dbgCtx message debug context.
* @return an {@link Observable} for the message.
*/
protected Observable<MessageInputStream> receiveFailover(final ICryptoContext tokenCryptoContext, final ByteBuffer in, final ByteBuffer out, final int timeout, final MessageDebugContext dbgCtx) {
return Observable.create(new ReceiveFailoverObservable(tokenCryptoContext, in, out, timeout, dbgCtx));
}
/**
* <p>This observable sends a response to the remote entity and attempts to
* generate the response in the following order:
* <ol>
* <li>Locally if the message does not require token renewal, key exchange,
* or other external dependencies.</li>
* <li>Through the external service being proxied.</li>
* <li>With failover behaviors if the external service cannot be
* accessed.</li>
* </ol>
*/
private class RespondObservable implements OnSubscribe<Boolean> {
/**
* <p>Create a new respond observable.</p>
*
* <p>The provided response data will be used to generate the
* response.</p>
*
* @param request original request to respond to.
* @param responseData application response data.
* @param tokenCryptoContext service token crypto context.
* @param out remote entity output stream.
* @param timeout renewal lock acquisition timeout.
* @param dbgCtx message debug context.
*/
public RespondObservable(final MessageInputStream request, final Response responseData, final ICryptoContext tokenCryptoContext, final ByteBuffer out, final int timeout, final MessageDebugContext dbgCtx) {
this.request = request;
this.responseData = responseData;
this.tokenCryptoContext = tokenCryptoContext;
this.out = out;
this.timeout = timeout;
this.dbgCtx = dbgCtx;
}
/**
* <p>Send a response over the provided byte buffer.</p>
*
* <p>If {@link Boolean#TRUE} was returned then the response was
* successfully created and written into the provided output stream and
* must be delivered to the remote entity.</p>
*
* <p>If {@link Boolean#FALSE} was returned then the provided response
* data could not be sent and a MSL error response will have been
* written into the provided output stream and must be delivered to the
* remote entity. Reasons for an error response include:
* <ul>
* <li>The response could not be sent with encryption or integrity
* protection when it is required.</li>
* <li>A user cannot be attached to the response due to the lack of a
* master token.</li>
* </ul></p>
*
* <p>If an exception is thrown any MSL error response will have been
* written into the provided output stream and must be delivered to the
* remote entity.</p>
*
* <p>The following checked exceptions may be thrown:
* <ul>
* <li>{@link InterruptedException} if the thread was interrupted while processing the message.</li>
* <li>{@link IOException} if there is an error writing to the output stream.</li>
* <li>{@link ProxyMslException} if the message cannot be processed due to a MSL exception.</li>
* <li>{@link ProxyException} if the message cannot be processed due to a non-MSL reason.</li>
* </ul></p>
*
* @param observer the event observer.
*/
@Override
public void call(final Subscriber<? super Boolean> observer) {
try {
// Mark the byte buffer so its position can be reset.
out.mark();
// First attempt to proxy the operation.
final Observable<Boolean> local = respondLocally(tokenCryptoContext, responseData, out, request, timeout, dbgCtx);
local.subscribe(new Action1<Boolean>() {
@Override
public void call(final Boolean b) {
observer.onNext(b);
observer.onCompleted();
return;
}
}, new Action1<Throwable>() {
@Override
public void call(final Throwable t) {
// A MslException indicates external processing is
// required.
if (t instanceof MslException) {
callExternal(observer);
return;
}
observer.onError(t);
return;
}
});
} catch (final Throwable t) {
observer.onError(t);
return;
}
}
/**
* This method has the same behavior as {@link #call(Subscriber)}.
*/
private void callExternal(final Subscriber<? super Boolean> observer) {
try {
// Reset the byte buffer.
out.reset();
// Second attempt to process externally.
final Observable<Boolean> ext = respondExternally(request, responseData, out);
ext.subscribe(new Action1<Boolean>() {
@Override
public void call(final Boolean b) {
observer.onNext(b);
observer.onCompleted();
return;
}
}, new Action1<Throwable>() {
@Override
public void call(final Throwable t) {
// If there was a problem communicating with or a
// transient failure at the external service, failover
// processing is required.
if (t instanceof ProxyIoException || t instanceof ProxyTransientException) {
callFailover(observer);
return;
}
observer.onError(t);
return;
}
});
} catch (final Throwable t) {
observer.onError(t);
return;
}
}
/**
* This method has the same behavior as {@link #call(Subscriber)}.
*/
private void callFailover(final Subscriber<? super Boolean> observer) {
try {
// Reset the byte buffer.
out.reset();
// Third attempt to process in failover mode.
final Observable<Boolean> failover = respondFailover(tokenCryptoContext, responseData, out, request, timeout, dbgCtx);
failover.subscribe(observer);
} catch (final Throwable t) {
observer.onError(t);
return;
}
}
/** Original request. */
private final MessageInputStream request;
/** Response data. */
final Response responseData;
/** Service token crypto context. */
final ICryptoContext tokenCryptoContext;
/** Remote entity output stream. */
final ByteBuffer out;
/** Renewal lock acquisition timeout in milliseconds. */
final int timeout;
/** Message debug context. */
final MessageDebugContext dbgCtx;
}
/**
* <p>This observable sends a response to the remote entity and attempts to
* generate the response locally.</p>
*/
private class RespondLocallyObservable implements OnSubscribe<Boolean> {
/**
* <p>Create a new respond locally observable.</p>
*
* <p>The provided response data will be used to generate the
* response.</p>
*
* @param request original request to respond to.
* @param responseData application response data.
* @param tokenCryptoContext service token crypto context.
* @param out remote entity output stream.
* @param timeout renewal lock acquisition timeout.
* @param dbgCtx message debug context.
*/
public RespondLocallyObservable(final MessageInputStream request, final Response responseData, final ICryptoContext tokenCryptoContext, final ByteBuffer out, final int timeout, final MessageDebugContext dbgCtx) {
this.request = request;
this.responseData = responseData;
this.tokenCryptoContext = tokenCryptoContext;
this.out = out;
this.timeout = timeout;
this.dbgCtx = dbgCtx;
}
/**
* <p>Locally send a response over the provided output stream. The
* provided response data will be used to generate the response.</p>
*
* <p>If {@link Boolean#TRUE} is returned the response was successfully
* created and written into the provided output stream. The data in the
* output stream must be delivered to the remote entity.</p>
*
* <p>If {@link Boolean#FALSE} is returned then the provided response
* data could not be sent and a MSL error response will have been
* written into the provided output stream and must be delivered to the
* remote entity. Reasons for an error response include:
* <ul>
* <li>The response could not be sent with encryption or integrity
* protection when it is required.</li>
* <li>A user cannot be attached to the response due to the lack of a
* master token.</li>
* </ul></p>
*
* <p>If an exception is thrown any MSL error and handshake responses
* will have been written into the provided output byte buffer. If
* external processing is not indicated then any such data must be
* delivered to the remote entity.</p>
*
* <p>The following checked exceptions may be thrown:
* <ul>
* <li>{@link IOException} if there is an error reading from the input or
* writing to the output stream.</li>
* <li>{@link CancellationException} if the operation was cancelled.
* <li>{@link InterruptedException} if the thread was interrupted while
* processing the message.</li>
* <li>{@link ProxyMslException} if the message cannot be processed due to
* a MSL exception.</li>
* <li>{@link ProxyException} if the message cannot be processed due to a
* non-MSL reason.</li>
* <li>{@link MslException} if the message must be processed externally.<li>
* </ul></p>
*
* @param observer the event observer.
*/
@Override
public void call(Subscriber<? super Boolean> observer) {
// Attempt to proxy the operation.
try {
final MessageContext msgCtx = new RespondMessageContext(responseData.appdata, responseData.entityServiceTokens, responseData.userServiceTokens, tokenCryptoContext, responseData.user, dbgCtx);
final ByteArrayInputStream nullInput = new ByteArrayInputStream(new byte[0]);
final ByteBufferOutputStream bbos = new ByteBufferOutputStream(out);
final Future<MslChannel> proxyFuture = mslCtrl.respond(proxyMslCtx, msgCtx, nullInput, bbos, request, timeout);
final MslChannel channel = proxyFuture.get();
observer.onNext(channel != null && channel.output != null);
observer.onCompleted();
return;
} catch (final InterruptedException e) {
observer.onError(e);
return;
} catch (final ExecutionException e) {
// Throw the exception if it is not a MSL exception indicating
// external processing.
final Throwable cause = e.getCause();
if (!(cause instanceof MslException)) {
observer.onError(new ProxyException("Unexpected exception thrown by proxied MslControl.respond().", cause));
return;
}
final MslException mslCause = (MslException)cause;
if (!ProxyMslError.isExternalProcessingRequired(mslCause.getError())) {
observer.onError(new ProxyMslException("MSL exception thrown by proxied MslControl.respond().", mslCause));
return;
}
// External processing is required. Throw the original cause.
observer.onError(mslCause);
return;
} catch (final Throwable t) {
observer.onError(t);
return;
}
}
/** Original request. */
private final MessageInputStream request;
/** Response data. */
final Response responseData;
/** Service token crypto context. */
final ICryptoContext tokenCryptoContext;
/** Remote entity output stream. */
final ByteBuffer out;
/** Renewal lock acquisition timeout in milliseconds. */
final int timeout;
/** Message debug context. */
final MessageDebugContext dbgCtx;
}
/**
* <p>This observable sends a response to the remote entity and attempts to
* generate the response in failover mode.</p>
*/
private class RespondFailoverObservable implements OnSubscribe<Boolean> {
/**
* <p>Create a new respond failover observable.</p>
*
* <p>The provided response data will be used to generate the
* response.</p>
*
* @param request original request to respond to.
* @param responseData application response data.
* @param tokenCryptoContext service token crypto context.
* @param out remote entity output stream.
* @param timeout renewal lock acquisition timeout.
* @param dbgCtx message debug context.
*/
public RespondFailoverObservable(final MessageInputStream request, final Response responseData, final ICryptoContext tokenCryptoContext, final ByteBuffer out, final int timeout, final MessageDebugContext dbgCtx) {
this.request = request;
this.responseData = responseData;
this.tokenCryptoContext = tokenCryptoContext;
this.out = out;
this.timeout = timeout;
this.dbgCtx = dbgCtx;
}
/**
* <p>Locally send a response over the provided input stream in
* failover mode. The provided response data will be used to generate
* the response.</p>
*
* <p>If {@link Boolean#TRUE} is returned the response was successfully
* created and written into the provided output stream. The data in the
* output stream must be delivered to the remote entity.</p>
*
* <p>If {@link Boolean#FALSE} is returned then the provided response
* data could not be sent and a MSL error response will have been
* written into the provided output stream and must be delivered to the
* remote entity. Reasons for an error response include:
* <ul>
* <li>The response could not be sent with encryption or integrity
* protection when it is required.</li>
* <li>A user cannot be attached to the response due to the lack of a
* master token.</li>
* </ul></p>
*
* <p>If an exception is thrown any MSL error and handshake responses will
* have been written into the provided output stream and must be delivered
* to the remote entity.</p>
*
* <p>The following checked exceptions may be thrown:
* <ul>
* <li>{@link IOException} if there is an error reading from the input or
* writing to the output stream.</li>
* <li>{@link CancellationException} if the operation was cancelled.
* <li>{@link InterruptedException} if the thread was interrupted while
* processing the message.</li>
* <li>{@link ProxyMslException} if the message cannot be processed due to
* a MSL exception.</li>
* <li>{@link ProxyException} if the message cannot be processed due to a
* non-MSL reason.</li>
* </ul></p>
*
* @param observer the event observer.
*/
@Override
public void call(Subscriber<? super Boolean> observer) {
// Attempt to process the operation in failover mode.
try {
final MessageContext msgCtx = new RespondMessageContext(responseData.appdata, responseData.entityServiceTokens, responseData.userServiceTokens, tokenCryptoContext, responseData.user, dbgCtx);
final ByteArrayInputStream nullInput = new ByteArrayInputStream(new byte[0]);
final ByteBufferOutputStream bbos = new ByteBufferOutputStream(out);
final Future<MslChannel> failoverFuture = mslCtrl.respond(failoverMslCtx, msgCtx, nullInput, bbos, request, timeout);
final MslChannel channel = failoverFuture.get();
observer.onNext(channel != null && channel.output != null);
return;
} catch (final InterruptedException e) {
observer.onError(e);
return;
} catch (final ExecutionException e) {
// Throw the exception.
final Throwable cause = e.getCause();
if (!(cause instanceof MslException)) {
observer.onError(new ProxyException("Unexpected exception thrown by failover MslControl.respond().", cause));
return;
}
final MslException mslCause = (MslException)cause;
observer.onError(new ProxyMslException("MSL exception thrown by failover MslControl.respond().", mslCause));
return;
} catch (final Throwable t) {
observer.onError(t);
return;
}
}
/** Original request. */
private final MessageInputStream request;
/** Response data. */
final Response responseData;
/** Service token crypto context. */
final ICryptoContext tokenCryptoContext;
/** Remote entity output stream. */
final ByteBuffer out;
/** Renewal lock acquisition timeout in milliseconds. */
final int timeout;
/** Message debug context. */
final MessageDebugContext dbgCtx;
}
/**
* <p>Send a response over the provided output stream. The provided
* response data will be used to generate the response.</p>
*
* <p>The returned {@link Observable} will return {@link Boolean#TRUE} the
* response was successfully created and written into the provided output
* stream. The data in the output stream must be delivered to the remote
* entity.</p>
*
* <p>If the {@link Observable} returns {@link Boolean#FALSE} then the
* provided response data could not be sent and a MSL error response will
* have been written into the provided output stream and must be delivered
* to the remote entity. Reasons for an error response include:
* <ul>
* <li>The response could not be sent with encryption or integrity
* protection when it is required.</li>
* <li>A user cannot be attached to the response due to the lack of a
* master token.</li>
* </ul></p>
*
* <p>If an exception is thrown any MSL error response will have been
* written into the provided output stream and must be delivered to the
* remote entity.</p>
*
* <p>The {@link Observable} may throw any of the following exceptions:
* <ul>
* <li>{@link IOException} if there is an error reading from the input or
* writing to the output stream.</li>
* <li>{@link CancellationException} if the operation was cancelled.
* <li>{@link InterruptedException} if the thread was interrupted while
* processing the message.</li>
* <li>{@link ProxyMslException} if the message cannot be processed due to
* a MSL exception.</li>
* <li>{@link ProxyException} if the message cannot be processed due to a
* non-MSL reason.</li>
* </ul></p>
*
* @param tokenCryptoContext service token crypto context.
* @param responseData application response data.
* @param out remote entity output stream.
* @param request original request to respond to.
* @param timeout MSL renewal lock acquisition timeout in milliseconds.
* @param dbgCtx message debug context.
* @return an {@link Observable} for the response operation.
*/
public Observable<Boolean> respond(final ICryptoContext tokenCryptoContext, final Response responseData, final ByteBuffer out, final MessageInputStream request, final int timeout, final MessageDebugContext dbgCtx) {
return Observable.create(new RespondObservable(request, responseData, tokenCryptoContext, out, timeout, dbgCtx));
}
/**
* <p>Locally send a response over the provided output stream. The provided
* response data will be used to generate the response.</p>
*
* <p>The returned {@link Observable} will return {@link Boolean#TRUE} the
* response was successfully created and written into the provided output
* stream. The data in the output stream must be delivered to the remote
* entity.</p>
*
* <p>If the {@link Observable} returns {@link Boolean#FALSE} then the
* provided response data could not be sent and a MSL error response will
* have been written into the provided output stream and must be delivered
* to the remote entity. Reasons for an error response include:
* <ul>
* <li>The response could not be sent with encryption or integrity
* protection when it is required.</li>
* <li>A user cannot be attached to the response due to the lack of a
* master token.</li>
* </ul></p>
*
* <p>If an exception is thrown any MSL error and handshake responses will
* have been written into the provided output byte buffer. If external
* processing is not indicated then any such data must be delivered to the
* remote entity.</p>
*
* <p>The {@link Observable} may throw any of the following exceptions:
* <ul>
* <li>{@link IOException} if there is an error reading from the input or
* writing to the output stream.</li>
* <li>{@link CancellationException} if the operation was cancelled.
* <li>{@link InterruptedException} if the thread was interrupted while
* processing the message.</li>
* <li>{@link ProxyMslException} if the message cannot be processed due to
* a MSL exception.</li>
* <li>{@link ProxyException} if the message cannot be processed due to a
* non-MSL reason.</li>
* <li>{@link MslException} if the message must be processed externally.<li>
* </ul></p>
*
* @param tokenCryptoContext service token crypto context.
* @param responseData application response data.
* @param out remote entity output stream.
* @param request original request to respond to.
* @param timeout MSL renewal lock acquisition timeout in milliseconds.
* @param dbgCtx message debug context.
* @return an {@link Observable} for the response operation.
*/
protected Observable<Boolean> respondLocally(final ICryptoContext tokenCryptoContext, final Response responseData, final ByteBuffer out, final MessageInputStream request, final int timeout, final MessageDebugContext dbgCtx) {
return Observable.create(new RespondLocallyObservable(request, responseData, tokenCryptoContext, out, timeout, dbgCtx));
}
/**
* <p>Externally send a response over the provided input stream. The
* provided response data will be used to generate the response.</p>
*
* <p>The returned {@link Observable} will return {@link Boolean#TRUE} the
* response was successfully created and written into the provided output
* stream. The data in the output stream must be delivered to the remote
* entity.</p>
*
* <p>If the {@link Observable} returns {@link Boolean#FALSE} then the
* provided response data could not be sent and a MSL error response will
* have been written into the provided output stream and must be delivered
* to the remote entity. Reasons for an error response include:
* <ul>
* <li>The response could not be sent with encryption or integrity
* protection when it is required.</li>
* <li>A user cannot be attached to the response due to the lack of a
* master token.</li>
* </ul></p>
*
* <p>If an exception is thrown any MSL error and handshake responses will
* have been written into the provided output byte buffer. If failover
* processing is not indicated then any such data must be delivered to the
* remote entity.</p>
*
* <p>The {@link Observable} may throw any of the following exceptions:
* <ul>
* <li>{@link ProxyIoException} if there is an error communicating with the
* external service. This indicates the message should be processed
* in failover mode.</li>
* <li>{@link ProxyTransientException} if there is a transient problem with
* the external service. This indicates the message should be processed
* in failover mode.</li>
* <li>{@link ProxyMslException} if the external service throws a MSL
* exception.</li>
* <li>{@link ProxyException} if the message cannot be processed by the
* external service for a non-MSL reason.</li>
* </ul></p>
*
* <p>This function must not call {@link ByteBuffer#mark()} on either the
* input or output byte buffers.</p>
*
* @param request original request to respond to.
* @param responseData application response data.
* @param out remote entity output byte buffer.
* @return an {@link Observable} for the response operation.
*/
protected abstract Observable<Boolean> respondExternally(final MessageInputStream request, final Response responseData, final ByteBuffer out);
/**
* <p>Locally send a response over the provided input stream in failover
* mode. The provided response data will be used to generate the
* response.</p>
*
* <p>The returned {@link Observable} will return {@link Boolean#TRUE} the
* response was successfully created and written into the provided output
* stream. The data in the output stream must be delivered to the remote
* entity.</p>
*
* <p>If the {@link Observable} returns {@link Boolean#FALSE} then the
* provided response data could not be sent and a MSL error response will
* have been written into the provided output stream and must be delivered
* to the remote entity. Reasons for an error response include:
* <ul>
* <li>The response could not be sent with encryption or integrity
* protection when it is required.</li>
* <li>A user cannot be attached to the response due to the lack of a
* master token.</li>
* </ul></p>
*
* <p>If an exception is thrown any MSL error and handshake responses will
* have been written into the provided output stream and must be delivered
* to the remote entity.</p>
*
* <p>The {@link Observable} may throw any of the following exceptions:
* <ul>
* <li>{@link IOException} if there is an error reading from the input or
* writing to the output stream.</li>
* <li>{@link CancellationException} if the operation was cancelled.
* <li>{@link InterruptedException} if the thread was interrupted while
* processing the message.</li>
* <li>{@link ProxyMslException} if the message cannot be processed due to
* a MSL exception.</li>
* <li>{@link ProxyException} if the message cannot be processed due to a
* non-MSL reason.</li>
* </ul></p>
*
* @param tokenCryptoContext service token crypto context.
* @param responseData application response data.
* @param out remote entity output stream.
* @param request original request to respond to.
* @param timeout MSL renewal lock acquisition timeout in milliseconds.
* @param dbgCtx message debug context.
* @return an {@link Observable} for the response operation.
*/
protected Observable<Boolean> respondFailover(final ICryptoContext tokenCryptoContext, final Response responseData, final ByteBuffer out, final MessageInputStream request, final int timeout, final MessageDebugContext dbgCtx) {
return Observable.create(new RespondFailoverObservable(request, responseData, tokenCryptoContext, out, timeout, dbgCtx));
}
/** MSL control. */
private final MslControl mslCtrl;
/** Proxy MSL context. */
private final MslContext proxyMslCtx;
/** Failover MSL context. */
private final MslContext failoverMslCtx;
}
| 1,888 |
0 |
Create_ds/msl/examples/proxy/src/main/java/com/netflix
|
Create_ds/msl/examples/proxy/src/main/java/com/netflix/msl/ProxyIoException.java
|
/**
* Copyright (c) 2015 Netflix, Inc. All rights reserved.
*/
package com.netflix.msl;
/**
* <p>Thrown when there is a communication failure with the external MSL
* service being proxed.</p>
*
* @author Wesley Miaw <[email protected]>
*/
public class ProxyIoException extends ProxyException {
private static final long serialVersionUID = 999987202864141531L;
/**
* <p>Creates a new {@code ProxyIOException} with the specified detail
* message and cause.</p>
*
* @param message the detail message.
* @param cause the cause. May be {@code null}.
*/
public ProxyIoException(final String message, final Throwable cause) {
super(message, cause);
}
}
| 1,889 |
0 |
Create_ds/msl/examples/proxy/src/main/java/com/netflix/msl
|
Create_ds/msl/examples/proxy/src/main/java/com/netflix/msl/util/FailoverMslContext.java
|
/**
* Copyright (c) 2015 Netflix, Inc. All rights reserved.
*/
package com.netflix.msl.util;
import java.util.Arrays;
import java.util.SortedSet;
import java.util.TreeSet;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.ProxyMslError;
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.entityauth.FailingEntityAuthenticationFactory;
import com.netflix.msl.entityauth.ProxyEntityAuthenticationFactory;
import com.netflix.msl.entityauth.ProxyEntityAuthenticationScheme;
import com.netflix.msl.keyx.FailingKeyExchange;
import com.netflix.msl.keyx.KeyExchangeFactory;
import com.netflix.msl.keyx.KeyExchangeScheme;
import com.netflix.msl.keyx.ProxyKeyExchangeScheme;
import com.netflix.msl.tokens.FailoverTokenFactory;
import com.netflix.msl.tokens.TokenFactory;
import com.netflix.msl.userauth.FailingUserAuthenticationFactory;
import com.netflix.msl.userauth.ProxyUserAuthenticationScheme;
import com.netflix.msl.userauth.UserAuthenticationFactory;
import com.netflix.msl.userauth.UserAuthenticationScheme;
/**
* <p>A trusted services network MSL context that supports MSL messages that
* are protected using session keys. FIXME</p>
*
* @author Wesley Miaw <[email protected]>
*/
public class FailoverMslContext extends ProxyMslContext {
/**
* <p>Failover entity authentication factory.</p>
*
* <p>When used, this factory throws an exception indicating inability to
* process the MSL message.</p>
*/
private static EntityAuthenticationFactory failoverEntityAuthFactory = new FailingEntityAuthenticationFactory(ProxyEntityAuthenticationScheme.PROXY, ProxyMslError.ENTITYAUTH_CANNOT_FAILOVER);
/**
* <p>Failover user authentication factory.</p>
*
* <p>When used, this factory throws an exception indiating inability to
* process the MSL message.</p>
*/
private static UserAuthenticationFactory failoverUserAuthFactory = new FailingUserAuthenticationFactory(ProxyUserAuthenticationScheme.PROXY, ProxyMslError.USERAUTH_CANNOT_FAILOVER);
/**
* <p>Failover key exchange factory.</p>
*
* <p>When used to generate a response, this factory simply returns
* {@code null} indicating it does not wish to perform key exchange.</p>
*/
private static KeyExchangeFactory failoverKeyxFactory = new FailingKeyExchange(ProxyKeyExchangeScheme.PROXY, null);
/**
* <p>Create a new proxy MSL context.</p>
*
* @param entityAuthData local entity authentication data.
* @param entityAuthFactory local entity authentication factory.
* @param cryptoContext MSL token crypto context.
*/
public FailoverMslContext(final EntityAuthenticationData entityAuthData, final EntityAuthenticationFactory entityAuthFactory, final ICryptoContext cryptoContext) {
super(entityAuthData, entityAuthFactory, cryptoContext);
// Entity authentication.
this.entityAuthData = entityAuthData;
final String identity;
try {
identity = entityAuthData.getIdentity();
} catch (final MslCryptoException e) {
throw new MslInternalException("Unable to extract identity from proxy entity authentication data.", e);
}
this.entityAuthFactory = new ProxyEntityAuthenticationFactory(identity, entityAuthFactory, ProxyMslError.ENTITYAUTH_CANNOT_FAILOVER);
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getEntityAuthenticationFactory(com.netflix.msl.entityauth.EntityAuthenticationScheme)
*/
@Override
public EntityAuthenticationFactory getEntityAuthenticationFactory(final EntityAuthenticationScheme scheme) {
// We must explicitly support authentication of the local entity.
if (entityAuthData.getScheme().equals(scheme))
return entityAuthFactory;
// Otherwise return the failover entity authentication factory that
// will always fail.
return failoverEntityAuthFactory;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getUserAuthenticationFactory(com.netflix.msl.userauth.UserAuthenticationScheme)
*/
@Override
public UserAuthenticationFactory getUserAuthenticationFactory(final UserAuthenticationScheme scheme) {
// Return the failover user authentication factory that will always
// fail.
return failoverUserAuthFactory;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getTokenFactory()
*/
@Override
public TokenFactory getTokenFactory() {
return tokenFactory;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getKeyExchangeFactory(com.netflix.msl.keyx.KeyExchangeScheme)
*/
@Override
public KeyExchangeFactory getKeyExchangeFactory(final KeyExchangeScheme scheme) {
// Return the failover key exchange factory that will simply not
// perform key exchange.
return failoverKeyxFactory;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getKeyExchangeFactories()
*/
@Override
public SortedSet<KeyExchangeFactory> getKeyExchangeFactories() {
return keyxFactories;
}
/** Entity authentication data. */
private final EntityAuthenticationData entityAuthData;
/** Entity authentiation factory. */
private final EntityAuthenticationFactory entityAuthFactory;
/** Token factory. */
private final TokenFactory tokenFactory = new FailoverTokenFactory();
/** Key exchange factories. */
private final SortedSet<KeyExchangeFactory> keyxFactories = new TreeSet<KeyExchangeFactory>(Arrays.asList(failoverKeyxFactory));
}
| 1,890 |
0 |
Create_ds/msl/examples/proxy/src/main/java/com/netflix/msl
|
Create_ds/msl/examples/proxy/src/main/java/com/netflix/msl/util/ProxyMslContext.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.util;
import java.security.SecureRandom;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import com.netflix.msl.MslConstants.CompressionAlgorithm;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslInternalException;
import com.netflix.msl.ProxyMslError;
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.entityauth.FailingEntityAuthenticationFactory;
import com.netflix.msl.entityauth.ProxyEntityAuthenticationFactory;
import com.netflix.msl.entityauth.ProxyEntityAuthenticationScheme;
import com.netflix.msl.io.DefaultMslEncoderFactory;
import com.netflix.msl.io.MslEncoderFactory;
import com.netflix.msl.io.MslEncoderFormat;
import com.netflix.msl.keyx.FailingKeyExchange;
import com.netflix.msl.keyx.KeyExchangeFactory;
import com.netflix.msl.keyx.KeyExchangeScheme;
import com.netflix.msl.keyx.ProxyKeyExchangeScheme;
import com.netflix.msl.msg.MessageCapabilities;
import com.netflix.msl.tokens.ProxyTokenFactory;
import com.netflix.msl.tokens.TokenFactory;
import com.netflix.msl.userauth.FailingUserAuthenticationFactory;
import com.netflix.msl.userauth.ProxyUserAuthenticationScheme;
import com.netflix.msl.userauth.UserAuthenticationFactory;
import com.netflix.msl.userauth.UserAuthenticationScheme;
/**
* <p>A trusted services network MSL context that supports MSL messages that
* are protected using session keys. Authentication and key exchange are not
* supported and any attempt to perform those operations will throw an
* exception.</p>
*
* @author Wesley Miaw <[email protected]>
*/
public class ProxyMslContext extends MslContext {
/**
* <p>Proxy entity authentication factory.</p>
*
* <p>When used, this factory throws an exception to trigger external
* processing of the MSL message.</p>
*/
private static EntityAuthenticationFactory proxyEntityAuthFactory = new FailingEntityAuthenticationFactory(ProxyEntityAuthenticationScheme.PROXY, ProxyMslError.ENTITYAUTH_REQUIRED);
/**
* <p>Proxy user authentication factory.</p>
*
* <p>When used, this factory throws an exception to trigger external
* processing of the MSL message.</p>
*/
private static UserAuthenticationFactory proxyUserAuthFactory = new FailingUserAuthenticationFactory(ProxyUserAuthenticationScheme.PROXY, ProxyMslError.USERAUTH_REQUIRED);
/**
* <p>Proxy key exchange factory.</p>
*
* <p>When used to generate a response, this factory throws an exception to
* trigger external processing of the message.</p>
*/
private static KeyExchangeFactory proxyKeyxFactory = new FailingKeyExchange(ProxyKeyExchangeScheme.PROXY, ProxyMslError.KEYX_REQUIRED);
/**
* <p>Create a new proxy MSL context.</p>
*
* @param entityAuthData local entity authentication data.
* @param entityAuthFactory local entity authentication factory.
* @param cryptoContext MSL token crypto context.
*/
public ProxyMslContext(final EntityAuthenticationData entityAuthData, final EntityAuthenticationFactory entityAuthFactory, final ICryptoContext cryptoContext) {
// Message capabilities.
final Set<CompressionAlgorithm> compressionAlgos = new HashSet<CompressionAlgorithm>(Arrays.asList(CompressionAlgorithm.values()));
final Set<MslEncoderFormat> encoderFormats = new HashSet<MslEncoderFormat>(MslEncoderFormat.values());
this.messageCapabilities = new MessageCapabilities(compressionAlgos, null, encoderFormats);
// Entity authentication.
this.entityAuthData = entityAuthData;
final String identity;
try {
identity = entityAuthData.getIdentity();
} catch (final MslCryptoException e) {
throw new MslInternalException("Unable to extract identity from proxy entity authentication data.", e);
}
this.entityAuthFactory = new ProxyEntityAuthenticationFactory(identity, entityAuthFactory, ProxyMslError.ENTITYAUTH_REQUIRED);
// MSL token crypto context.
this.cryptoContext = cryptoContext;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getTime()
*/
@Override
public long getTime() {
return System.currentTimeMillis();
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getRandom()
*/
@Override
public Random getRandom() {
return new SecureRandom();
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#isPeerToPeer()
*/
@Override
public boolean isPeerToPeer() {
return false;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getMessageCapabilities()
*/
@Override
public MessageCapabilities getMessageCapabilities() {
return messageCapabilities;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getEntityAuthenticationData(com.netflix.msl.util.MslContext.ReauthCode)
*/
@Override
public EntityAuthenticationData getEntityAuthenticationData(final ReauthCode reauthCode) {
return entityAuthData;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getMslCryptoContext()
*/
@Override
public ICryptoContext getMslCryptoContext() throws MslCryptoException {
return cryptoContext;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getEntityAuthenticationScheme(java.lang.String)
*/
@Override
public EntityAuthenticationScheme getEntityAuthenticationScheme(final String name) {
// We must explicitly support the local entity's entity authentication
// scheme.
if (entityAuthData.getScheme().name().equals(name))
return entityAuthData.getScheme();
// Otherwise return the proxy scheme that will trigger external
// processing of the message.
return ProxyEntityAuthenticationScheme.PROXY;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getEntityAuthenticationFactory(com.netflix.msl.entityauth.EntityAuthenticationScheme)
*/
@Override
public EntityAuthenticationFactory getEntityAuthenticationFactory(final EntityAuthenticationScheme scheme) {
// We must explicitly support authentication of the local entity.
if (entityAuthData.getScheme().equals(scheme))
return entityAuthFactory;
// Otherwise return the proxy entity authentication factory that will
// trigger external processing of the message.
return proxyEntityAuthFactory;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getUserAuthenticationScheme(java.lang.String)
*/
@Override
public UserAuthenticationScheme getUserAuthenticationScheme(final String name) {
return ProxyUserAuthenticationScheme.PROXY;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getUserAuthenticationFactory(com.netflix.msl.userauth.UserAuthenticationScheme)
*/
@Override
public UserAuthenticationFactory getUserAuthenticationFactory(final UserAuthenticationScheme scheme) {
// Return the proxy user authentication factory that will trigger
// external processing of the message.
return proxyUserAuthFactory;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getTokenFactory()
*/
@Override
public TokenFactory getTokenFactory() {
return tokenFactory;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getKeyExchangeScheme(java.lang.String)
*/
@Override
public KeyExchangeScheme getKeyExchangeScheme(final String name) {
return ProxyKeyExchangeScheme.PROXY;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getKeyExchangeFactory(com.netflix.msl.keyx.KeyExchangeScheme)
*/
@Override
public KeyExchangeFactory getKeyExchangeFactory(final KeyExchangeScheme scheme) {
// Return the proxy key exchange factory that will trigger external
// processing of the message.
return proxyKeyxFactory;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getKeyExchangeFactories()
*/
@Override
public SortedSet<KeyExchangeFactory> getKeyExchangeFactories() {
return keyxFactories;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getMslStore()
*/
@Override
public MslStore getMslStore() {
return store;
}
/* (non-Javadoc)
* @see com.netflix.msl.util.MslContext#getMslEncoderFactory()
*/
@Override
public MslEncoderFactory getMslEncoderFactory() {
return encoderFactory;
}
/** Message capabilities. */
private final MessageCapabilities messageCapabilities;
/** Entity authentication data. */
private final EntityAuthenticationData entityAuthData;
/** Entity authentiation factory. */
private final EntityAuthenticationFactory entityAuthFactory;
/** MSL crypto context. */
private final ICryptoContext cryptoContext;
/** Token factory. */
private final TokenFactory tokenFactory = new ProxyTokenFactory();
/** Key exchange factories. */
private final SortedSet<KeyExchangeFactory> keyxFactories = new TreeSet<KeyExchangeFactory>(Arrays.asList(proxyKeyxFactory));
/** MSL store. */
private final MslStore store = new NullMslStore();
/** MSL encoder factory. */
private final MslEncoderFactory encoderFactory = new DefaultMslEncoderFactory();
}
| 1,891 |
0 |
Create_ds/msl/examples/proxy/src/main/java/com/netflix/msl
|
Create_ds/msl/examples/proxy/src/main/java/com/netflix/msl/msg/RespondMessageContext.java
|
/**
* Copyright (c) 2015 Netflix, Inc. All rights reserved.
*/
package com.netflix.msl.msg;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslException;
import com.netflix.msl.MslKeyExchangeException;
import com.netflix.msl.MslMessageException;
import com.netflix.msl.ProxyMslError;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.keyx.KeyRequestData;
import com.netflix.msl.tokens.MslUser;
import com.netflix.msl.userauth.UserAuthenticationData;
/**
* <p>A trusted services network message context used to generate server
* messages.</p>
*
* @author Wesley Miaw <[email protected]>
*/
public class RespondMessageContext implements MessageContext {
/**
* <p>Create a new receive message context.</p>
*
* @param appdata the application data to include in the response.
* @param entityServiceTokens entity-associated service token name/value
* pairs.
* @param userServiceTokens user-associated service token name/value pairs.
* @param cryptoContext default service token crypto context.
* @param user optional user to attach to the response. May be {@code null}.
* @param dbgCtx optional message debug context. May be {@code null}.
*/
public RespondMessageContext(final byte[] appdata, final Map<String,byte[]> entityServiceTokens, final Map<String,byte[]> userServiceTokens, final ICryptoContext cryptoContext, final MslUser user, final MessageDebugContext dbgCtx) {
this.appdata = appdata;
this.entityServiceTokens = entityServiceTokens;
this.userServiceTokens = userServiceTokens;
final Map<String,ICryptoContext> cryptoContexts = new HashMap<String,ICryptoContext>();
cryptoContexts.put("", cryptoContext);
this.cryptoContexts = Collections.unmodifiableMap(cryptoContexts);
this.user = user;
this.dbgCtx = dbgCtx;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getCryptoContexts()
*/
@Override
public Map<String, ICryptoContext> getCryptoContexts() {
return cryptoContexts;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getRemoteEntityIdentity()
*/
@Override
public String getRemoteEntityIdentity() {
return null;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#isEncrypted()
*/
@Override
public boolean isEncrypted() {
return true;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#isIntegrityProtected()
*/
@Override
public boolean isIntegrityProtected() {
return true;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#isNonReplayable()
*/
@Override
public boolean isNonReplayable() {
return false;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#isRequestingTokens()
*/
@Override
public boolean isRequestingTokens() {
return false;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getUserId()
*/
@Override
public String getUserId() {
return null;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getUserAuthData(com.netflix.msl.msg.MessageContext.ReauthCode, boolean, boolean)
*/
@Override
public UserAuthenticationData getUserAuthData(final ReauthCode reauthCode, final boolean renewable, final boolean required) {
return null;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getUser()
*/
@Override
public MslUser getUser() {
return user;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getKeyRequestData()
*/
@Override
public Set<KeyRequestData> getKeyRequestData() throws MslKeyExchangeException {
return null;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#updateServiceTokens(com.netflix.msl.msg.MessageServiceTokenBuilder, boolean)
*/
@Override
public void updateServiceTokens(final MessageServiceTokenBuilder builder, final boolean handshake) throws MslEncodingException, MslCryptoException, MslException {
// Attach tokens. Throw an exception if a desired token cannot be
// attached.
for (final Map.Entry<String,byte[]> entry : entityServiceTokens.entrySet()) {
final String name = entry.getKey();
final byte[] value = entry.getValue();
final boolean added = builder.addMasterBoundPrimaryServiceToken(name, value, true, null);
if (!added)
throw new MslMessageException(ProxyMslError.SERVICETOKEN_REQUIRES_MASTERTOKEN, name);
}
for (final Map.Entry<String,byte[]> entry : userServiceTokens.entrySet()) {
final String name = entry.getKey();
final byte[] value = entry.getValue();
final boolean added = builder.addUserBoundPrimaryServiceToken(name, value, true, null);
if (!added)
throw new MslMessageException(ProxyMslError.SERVICETOKEN_REQUIRES_USERIDTOKEN, name);
}
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#write(com.netflix.msl.msg.MessageOutputStream)
*/
@Override
public void write(final MessageOutputStream output) throws IOException {
output.write(appdata);
output.close();
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getDebugContext()
*/
@Override
public MessageDebugContext getDebugContext() {
return dbgCtx;
}
/** Application data. */
private final byte[] appdata;
/** Entity service tokens. */
private final Map<String,byte[]> entityServiceTokens;
/** User service tokens. */
private final Map<String,byte[]> userServiceTokens;
/** Service token crypto context. */
private final Map<String,ICryptoContext> cryptoContexts;
/** MSL user. */
private final MslUser user;
/** Message debug context. */
private final MessageDebugContext dbgCtx;
}
| 1,892 |
0 |
Create_ds/msl/examples/proxy/src/main/java/com/netflix/msl
|
Create_ds/msl/examples/proxy/src/main/java/com/netflix/msl/msg/ReceiveMessageContext.java
|
/**
* Copyright (c) 2015 Netflix, Inc. All rights reserved.
*/
package com.netflix.msl.msg;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import com.netflix.msl.crypto.ICryptoContext;
import com.netflix.msl.keyx.KeyRequestData;
import com.netflix.msl.tokens.MslUser;
import com.netflix.msl.userauth.UserAuthenticationData;
/**
* <p>A trusted services network message context used to receive client
* messages.</p>
*
* @author Wesley Miaw <[email protected]>
*/
public class ReceiveMessageContext implements MessageContext {
/**
* <p>Create a new receive message context.</p>
*
* @param cryptoContext default service token crypto context.
* @param dbgCtx optional message debug context. May be {@code null}.
*/
public ReceiveMessageContext(final ICryptoContext cryptoContext, final MessageDebugContext dbgCtx) {
final Map<String,ICryptoContext> cryptoContexts = new HashMap<String,ICryptoContext>();
cryptoContexts.put("", cryptoContext);
this.cryptoContexts = Collections.unmodifiableMap(cryptoContexts);
this.dbgCtx = dbgCtx;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getCryptoContexts()
*/
@Override
public Map<String, ICryptoContext> getCryptoContexts() {
return cryptoContexts;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getRemoteEntityIdentity()
*/
@Override
public String getRemoteEntityIdentity() {
return null;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#isEncrypted()
*/
@Override
public boolean isEncrypted() {
return false;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#isIntegrityProtected()
*/
@Override
public boolean isIntegrityProtected() {
return false;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#isNonReplayable()
*/
@Override
public boolean isNonReplayable() {
return false;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#isRequestingTokens()
*/
@Override
public boolean isRequestingTokens() {
return false;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getUserId()
*/
@Override
public String getUserId() {
return null;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getUserAuthData(com.netflix.msl.msg.MessageContext.ReauthCode, boolean, boolean)
*/
@Override
public UserAuthenticationData getUserAuthData(final ReauthCode reauthCode, final boolean renewable, final boolean required) {
return null;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getUser()
*/
@Override
public MslUser getUser() {
return null;
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getKeyRequestData()
*/
@Override
public Set<KeyRequestData> getKeyRequestData() {
return Collections.emptySet();
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#updateServiceTokens(com.netflix.msl.msg.MessageServiceTokenBuilder, boolean)
*/
@Override
public void updateServiceTokens(final MessageServiceTokenBuilder builder, final boolean handshake) {
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#write(com.netflix.msl.msg.MessageOutputStream)
*/
@Override
public void write(final MessageOutputStream output) throws IOException {
}
/* (non-Javadoc)
* @see com.netflix.msl.msg.MessageContext#getDebugContext()
*/
@Override
public MessageDebugContext getDebugContext() {
return dbgCtx;
}
/** Service token crypto context. */
private final Map<String,ICryptoContext> cryptoContexts;
/** Message debug context. */
private final MessageDebugContext dbgCtx;
}
| 1,893 |
0 |
Create_ds/msl/examples/proxy/src/main/java/com/netflix/msl
|
Create_ds/msl/examples/proxy/src/main/java/com/netflix/msl/keyx/FailingKeyExchange.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.keyx;
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.crypto.ICryptoContext;
import com.netflix.msl.entityauth.EntityAuthenticationData;
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>Failing user authentication factory.</p>
*
* <p>When used, this factory either refuses to perform key exchange or throws
* a {@link MslKeyExchangeException} containing the MSL error specified when
* attempting to generate a key response.</p>
*
* @author Wesley Miaw <[email protected]>
*/
public class FailingKeyExchange extends KeyExchangeFactory {
/**
* <p>A simple key request object that holds the raw key request data.</p>
*/
private static class KeyRequest extends KeyRequestData {
/**
* <p>Create a new key request data that contains the provided
* key request data.</p>
*
* @param keydata the unprocessed key request data.
*/
public KeyRequest(final MslObject keydata) {
super(ProxyKeyExchangeScheme.PROXY);
this.keydata = keydata;
}
@Override
protected MslObject getKeydata(final MslEncoderFactory encoder, final MslEncoderFormat format) {
return keydata;
}
/** The original key data. */
private final MslObject keydata;
}
/**
* Create a new failing key exchange factory for the specified scheme.
*
* @param scheme the key exchange scheme.
* @param error the error to throw or {@code null} if key exchange should
* simply no be performed.
*/
public FailingKeyExchange(final KeyExchangeScheme scheme, final MslError error) {
super(scheme);
this.error = error;
}
/* (non-Javadoc)
* @see com.netflix.msl.keyx.KeyExchangeFactory#createRequestData(com.netflix.msl.util.MslContext, com.netflix.msl.io.MslObject)
*/
@Override
protected KeyRequestData createRequestData(final MslContext ctx, final MslObject keyRequestMo) {
// This method will be called if key request data exists. We do not
// want to trigger external processing if we are not going to do
// key exchange, so simply return a dummy key request data object.
return new KeyRequest(keyRequestMo);
}
/* (non-Javadoc)
* @see com.netflix.msl.keyx.KeyExchangeFactory#createResponseData(com.netflix.msl.util.MslContext, com.netflix.msl.tokens.MasterToken, com.netflix.msl.io.MslObject)
*/
@Override
protected KeyResponseData createResponseData(final MslContext ctx, final MasterToken masterToken, final MslObject keyDataMo) {
// This method should never be called; we should never receive key
// response data.
throw new MslInternalException("Unexpected call to create key response data.");
}
/* (non-Javadoc)
* @see com.netflix.msl.keyx.KeyExchangeFactory#generateResponse(com.netflix.msl.util.MslContext, com.netflix.msl.io.MslEncoderFormat, com.netflix.msl.keyx.KeyRequestData, com.netflix.msl.tokens.MasterToken)
*/
@Override
public KeyExchangeData generateResponse(final MslContext ctx, final MslEncoderFormat format, final KeyRequestData keyRequestData, final MasterToken masterToken) throws MslKeyExchangeException {
// This method is called if key exchange needs to be performed.
// Throw an exception if an error was specified.
if (error != null)
throw new MslKeyExchangeException(error);
// Otherwise refuse to perform the key exchange.
return null;
}
/* (non-Javadoc)
* @see com.netflix.msl.keyx.KeyExchangeFactory#generateResponse(com.netflix.msl.util.MslContext, com.netflix.msl.io.MslEncoderFormat, com.netflix.msl.keyx.KeyRequestData, com.netflix.msl.entityauth.EntityAuthenticationData)
*/
@Override
public KeyExchangeData generateResponse(final MslContext ctx, final MslEncoderFormat format, final KeyRequestData keyRequestData, final EntityAuthenticationData entityAuthData) throws MslKeyExchangeException, MslCryptoException, MslEncodingException, MslEntityAuthException, MslException {
// This method is called if key exchange needs to be performed.
// Throw an exception if an error was specified.
if (error != null)
throw new MslKeyExchangeException(error);
// Otherwise refuse to perform the key exchange.
return null;
}
/* (non-Javadoc)
* @see com.netflix.msl.keyx.KeyExchangeFactory#getCryptoContext(com.netflix.msl.util.MslContext, com.netflix.msl.keyx.KeyRequestData, com.netflix.msl.keyx.KeyResponseData, com.netflix.msl.tokens.MasterToken)
*/
@Override
public ICryptoContext getCryptoContext(final MslContext ctx, final KeyRequestData keyRequestData, final KeyResponseData keyResponseData, final MasterToken masterToken) throws MslKeyExchangeException {
// This method should never be called; we should never be the
// entity requesting a key exchange.
throw new MslInternalException("Unexpected call to generate a crypto context from key response data.");
}
/** MSL error. May be {@code null}. */
private final MslError error;
}
| 1,894 |
0 |
Create_ds/msl/examples/proxy/src/main/java/com/netflix/msl
|
Create_ds/msl/examples/proxy/src/main/java/com/netflix/msl/keyx/ProxyKeyExchangeScheme.java
|
/**
* Copyright (c) 2015 Netflix, Inc. All rights reserved.
*/
package com.netflix.msl.keyx;
import com.netflix.msl.keyx.KeyExchangeScheme;
/**
* <p>Proxy key exchange schemes.</p>
*
* <p>All key exchange schemes are automatically re-mapped onto the proxy
* key exchange scheme.</p>
*
* @author Wesley Miaw <[email protected]>
*/
public class ProxyKeyExchangeScheme extends KeyExchangeScheme {
/** Proxy key exchange scheme. */
public static final KeyExchangeScheme PROXY = new ProxyKeyExchangeScheme("PROXY");
/**
* Define a key exchange scheme with the specified name.
*
* @param name the key exchange scheme name.
*/
public ProxyKeyExchangeScheme(final String name) {
super(name);
}
}
| 1,895 |
0 |
Create_ds/msl/examples/proxy/src/main/java/com/netflix/msl
|
Create_ds/msl/examples/proxy/src/main/java/com/netflix/msl/userauth/FailingUserAuthenticationFactory.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.userauth;
import com.netflix.msl.MslError;
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.MslContext;
/**
* <p>Failing user authentication factory.</p>
*
* <p>When used, this factory throws a {@link MslUserAuthException}
* containing the MSL error specified when constructed.</p>
*
* @author Wesley Miaw <[email protected]>
*/
public class FailingUserAuthenticationFactory extends UserAuthenticationFactory {
/**
* Create a new failing user authentication factory for the specified
* scheme.
*
* @param scheme the user authentication scheme.
* @param error the error to throw.
*/
public FailingUserAuthenticationFactory(final UserAuthenticationScheme scheme, final MslError error) {
super(scheme);
this.error = error;
}
/* (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 MslUserAuthException {
throw new MslUserAuthException(error);
}
/* (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 {
throw new MslUserAuthException(error);
}
/** MSL error. */
private final MslError error;
}
| 1,896 |
0 |
Create_ds/msl/examples/proxy/src/main/java/com/netflix/msl
|
Create_ds/msl/examples/proxy/src/main/java/com/netflix/msl/userauth/ProxyUserAuthenticationScheme.java
|
/**
* Copyright (c) 2015 Netflix, Inc. All rights reserved.
*/
package com.netflix.msl.userauth;
import com.netflix.msl.userauth.UserAuthenticationScheme;
/**
* <p>Proxy user authentication schemes.</p>
*
* <p>All user authentication schemes are automatically re-mapped onto the
* proxy key exchange scheme.</p>
*
* @author Wesley Miaw <[email protected]>
*/
public class ProxyUserAuthenticationScheme extends UserAuthenticationScheme {
/** Proxy key exchange scheme. */
public static final UserAuthenticationScheme PROXY = new ProxyUserAuthenticationScheme("PROXY");
/**
* Define a user authentication scheme with the specified name.
*
* @param name the user authentication scheme name.
*/
public ProxyUserAuthenticationScheme(final String name) {
super(name);
}
}
| 1,897 |
0 |
Create_ds/msl/examples/proxy/src/main/java/com/netflix/msl
|
Create_ds/msl/examples/proxy/src/main/java/com/netflix/msl/userauth/ProxyMslUser.java
|
package com.netflix.msl.userauth;
import com.netflix.msl.tokens.MslUser;
/**
* <p>A MSL user that is just the user ID.</p>
*/
public class ProxyMslUser implements MslUser {
/**
* <p>Create a new MSL user with the given user ID.</p>
*
* @param userId the user ID.
*/
public ProxyMslUser(final String userId) {
this.userId = userId;
}
/**
* @return the user ID.
*/
public String getUserId() {
return userId;
}
/* (non-Javadoc)
* @see com.netflix.msl.tokens.MslUser#getEncoded()
*/
@Override
public String getEncoded() {
return userId;
}
/* (non-Javadoc)
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
return userId;
}
/** User string representation. */
private final String userId;
}
| 1,898 |
0 |
Create_ds/msl/examples/proxy/src/main/java/com/netflix/msl
|
Create_ds/msl/examples/proxy/src/main/java/com/netflix/msl/tokens/ProxyTokenFactory.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.tokens;
import javax.crypto.SecretKey;
import com.netflix.msl.MslCryptoException;
import com.netflix.msl.MslEncodingException;
import com.netflix.msl.MslError;
import com.netflix.msl.MslException;
import com.netflix.msl.ProxyMslError;
import com.netflix.msl.entityauth.EntityAuthenticationData;
import com.netflix.msl.io.MslObject;
import com.netflix.msl.userauth.ProxyMslUser;
import com.netflix.msl.util.MslContext;
/**
* <p>This token factory accepts all tokens and throws an exception if a token
* must be created or renewed.</p>
*
* @author Wesley Miaw <[email protected]>
*/
public class ProxyTokenFactory 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) {
// TODO This check should be implemented to immediately check if a
// master token has been revoked. For now return null indicating the
// master token is acceptable.
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) throws MslException {
// TODO This check should be implemented somehow. For now throw an
// exception to trigger processing by the proxied MSL service.
throw new MslException(ProxyMslError.NONREPLAYABLE_ID_CHECK_REQUIRED);
}
/* (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) throws MslEncodingException, MslCryptoException, MslException {
// This method should not get called. If it does then throw an
// exception to trigger processing by the proxied MSL service.
throw new MslException(ProxyMslError.MASTERTOKEN_CREATION_REQUIRED);
}
/* (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) {
// Assume the master token will be renewed if it needs to be. The
// downside of not checking right now is that we may reject the message
// after doing application-level work.
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) throws MslException {
throw new MslException(ProxyMslError.MASTERTOKEN_RENEWAL_REQUIRED);
}
/* (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) {
// TODO This check should be implemented to immediately check if a
// user ID token has been revoked. For now return null indicating the
// user ID token is acceptable.
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) throws MslException {
throw new MslException(ProxyMslError.USERIDTOKEN_CREATION_REQUIRED);
}
/* (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) throws MslException {
throw new MslException(ProxyMslError.USERIDTOKEN_RENEWAL_REQUIRED);
}
/* (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) {
return new ProxyMslUser(userdata);
}
}
| 1,899 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.