/// <summary>
/// Create a D-KEY Data packet with an EncryptedContent for the given private
/// key, encrypted with the certificate key.
/// </summary>
///
/// <param name="startTimeStamp">The start time stamp string to put in the name.</param>
/// <param name="endTimeStamp">The end time stamp string to put in the name.</param>
/// <param name="keyName"></param>
/// <param name="privateKeyBlob">A Blob of the encoded private key.</param>
/// <param name="certificateKey"></param>
/// <returns>The Data packet.</returns>
/// <exception cref="System.Security.SecurityException">for an error using the security KeyChain.</exception>
private Data createDKeyData(String startTimeStamp, String endTimeStamp,
Name keyName, Blob privateKeyBlob, Blob certificateKey)
{
Name name = new Name(namespace_);
name.append(net.named_data.jndn.encrypt.algo.Encryptor.NAME_COMPONENT_D_KEY);
name.append(startTimeStamp).append(endTimeStamp);
Data data = new Data(name);
data.getMetaInfo().setFreshnessPeriod(
freshnessHours_ * MILLISECONDS_IN_HOUR);
EncryptParams encryptParams = new EncryptParams(
net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.RsaOaep);
try {
net.named_data.jndn.encrypt.algo.Encryptor.encryptData(data, privateKeyBlob, keyName,
certificateKey, encryptParams);
} catch (Exception ex) {
// Consolidate errors such as InvalidKeyException.
throw new SecurityException(
"createDKeyData: Error in encryptData: " + ex.Message);
}
keyChain_.sign(data);
return(data);
}
public void testCreateDKeyData()
{
// Create the group manager.
GroupManager manager = new GroupManager(new Name("Alice"), new Name(
"data_type"), new Sqlite3GroupManagerDb(
dKeyDatabaseFilePath.FullName), 2048, 1, keyChain);
Blob newCertificateBlob = certificate.wireEncode();
IdentityCertificate newCertificate = new IdentityCertificate();
newCertificate.wireDecode(newCertificateBlob);
// Encrypt the D-KEY.
Data data = friendAccess.createDKeyData(manager, "20150825T000000",
"20150827T000000", new Name("/ndn/memberA/KEY"),
decryptKeyBlob, newCertificate.getPublicKeyInfo().getKeyDer());
// Verify the encrypted D-KEY.
Blob dataContent = data.getContent();
// Get the nonce key.
// dataContent is a sequence of the two EncryptedContent.
EncryptedContent encryptedNonce = new EncryptedContent();
encryptedNonce.wireDecode(dataContent);
Assert.AssertEquals(0, encryptedNonce.getInitialVector().size());
Assert.AssertEquals(net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.RsaOaep,
encryptedNonce.getAlgorithmType());
Blob blobNonce = encryptedNonce.getPayload();
EncryptParams decryptParams = new EncryptParams(
net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.RsaOaep);
Blob nonce = net.named_data.jndn.encrypt.algo.RsaAlgorithm.decrypt(decryptKeyBlob, blobNonce,
decryptParams);
// Get the D-KEY.
// Use the size of encryptedNonce to find the start of encryptedPayload.
ByteBuffer payloadContent = dataContent.buf().duplicate();
payloadContent.position(encryptedNonce.wireEncode().size());
EncryptedContent encryptedPayload = new EncryptedContent();
encryptedPayload.wireDecode(payloadContent);
Assert.AssertEquals(16, encryptedPayload.getInitialVector().size());
Assert.AssertEquals(net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.AesCbc,
encryptedPayload.getAlgorithmType());
decryptParams.setAlgorithmType(net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.AesCbc);
decryptParams.setInitialVector(encryptedPayload.getInitialVector());
Blob blobPayload = encryptedPayload.getPayload();
Blob largePayload = net.named_data.jndn.encrypt.algo.AesAlgorithm.decrypt(nonce, blobPayload,
decryptParams);
Assert.AssertTrue(largePayload.equals(decryptKeyBlob));
}
internal Data createEncryptedDKey()
{
Data dKeyData = new Data(dKeyName);
EncryptParams encryptParams = new EncryptParams(
net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.RsaOaep);
net.named_data.jndn.encrypt.algo.Encryptor.encryptData(dKeyData, fixtureDKeyBlob, uKeyName,
fixtureUEKeyBlob, encryptParams);
keyChain.sign(dKeyData, certificateName);
return(dKeyData);
}
internal Data createEncryptedContent()
{
Data contentData = new Data(contentName);
EncryptParams encryptParams = new EncryptParams(
net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.AesCbc);
encryptParams.setInitialVector(new Blob(INITIAL_VECTOR, false));
net.named_data.jndn.encrypt.algo.Encryptor.encryptData(contentData, new Blob(DATA_CONTENT, false),
cKeyName, fixtureCKeyBlob, encryptParams);
keyChain.sign(contentData, certificateName);
return(contentData);
}
public void checkEncryptionKeys(IList result, double testTime,
Name.Component roundedTime,
int expectedExpressInterestCallCount)
{
Assert.AssertEquals(expectedExpressInterestCallCount,
expressInterestCallCount_[0]);
try {
Assert.AssertEquals(true, testDb_.hasContentKey(testTime));
contentKey_[0] = testDb_.getContentKey(testTime);
} catch (ProducerDb.Error ex) {
Assert.Fail("Error in ProducerDb: " + ex);
}
EncryptParams paras = new EncryptParams(
net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.RsaOaep);
for (int i = 0; i < result.Count; ++i)
{
Data key = (Data)result[i];
Name keyName = key.getName();
Assert.AssertEquals(cKeyName_, keyName.getSubName(0, 6));
Assert.AssertEquals(keyName.get(6), roundedTime);
Assert.AssertEquals(keyName.get(7), net.named_data.jndn.encrypt.algo.Encryptor.NAME_COMPONENT_FOR);
Assert.AssertEquals(true,
outer_TestProducer.decryptionKeys.Contains(keyName.getSubName(8)));
Blob decryptionKey = (Blob)ILOG.J2CsMapping.Collections.Collections.Get(outer_TestProducer.decryptionKeys, keyName
.getSubName(8));
Assert.AssertEquals(true, decryptionKey.size() != 0);
Blob encryptedKeyEncoding = key.getContent();
EncryptedContent content = new EncryptedContent();
try {
content.wireDecode(encryptedKeyEncoding);
} catch (EncodingException ex_0) {
Assert.Fail("Error decoding EncryptedContent" + ex_0);
}
Blob encryptedKey = content.getPayload();
Blob retrievedKey = null;
try {
retrievedKey = net.named_data.jndn.encrypt.algo.RsaAlgorithm.decrypt(decryptionKey,
encryptedKey, paras);
} catch (Exception ex_1) {
Assert.Fail("Error in RsaAlgorithm.decrypt: " + ex_1);
}
Assert.AssertTrue(contentKey_[0].equals(retrievedKey));
}
Assert.AssertEquals(3, result.Count);
}
public void testEncryptionDecryption()
{
EncryptParams encryptParams = new EncryptParams(
net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.AesEcb, 16);
Blob key = new Blob(KEY, false);
DecryptKey decryptKey = new DecryptKey(key);
EncryptKey encryptKey = net.named_data.jndn.encrypt.algo.AesAlgorithm.deriveEncryptKey(decryptKey
.getKeyBits());
// Check key loading and key derivation.
Assert.AssertTrue(encryptKey.getKeyBits().equals(key));
Assert.AssertTrue(decryptKey.getKeyBits().equals(key));
Blob plainBlob = new Blob(PLAINTEXT, false);
// Encrypt data in AES_ECB.
Blob cipherBlob = net.named_data.jndn.encrypt.algo.AesAlgorithm.encrypt(encryptKey.getKeyBits(),
plainBlob, encryptParams);
Assert.AssertTrue(cipherBlob.equals(new Blob(CIPHERTEXT_ECB, false)));
// Decrypt data in AES_ECB.
Blob receivedBlob = net.named_data.jndn.encrypt.algo.AesAlgorithm.decrypt(decryptKey.getKeyBits(),
cipherBlob, encryptParams);
Assert.AssertTrue(receivedBlob.equals(plainBlob));
// Encrypt/decrypt data in AES_CBC with auto-generated IV.
encryptParams.setAlgorithmType(net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.AesCbc);
cipherBlob = net.named_data.jndn.encrypt.algo.AesAlgorithm.encrypt(encryptKey.getKeyBits(), plainBlob,
encryptParams);
receivedBlob = net.named_data.jndn.encrypt.algo.AesAlgorithm.decrypt(decryptKey.getKeyBits(),
cipherBlob, encryptParams);
Assert.AssertTrue(receivedBlob.equals(plainBlob));
// Encrypt data in AES_CBC with specified IV.
Blob initialVector = new Blob(INITIAL_VECTOR, false);
encryptParams.setInitialVector(initialVector);
cipherBlob = net.named_data.jndn.encrypt.algo.AesAlgorithm.encrypt(encryptKey.getKeyBits(), plainBlob,
encryptParams);
Assert.AssertTrue(cipherBlob.equals(new Blob(CIPHERTEXT_CBC_IV, false)));
// Decrypt data in AES_CBC with specified IV.
receivedBlob = net.named_data.jndn.encrypt.algo.AesAlgorithm.decrypt(decryptKey.getKeyBits(),
cipherBlob, encryptParams);
Assert.AssertTrue(receivedBlob.equals(plainBlob));
}
public void testEncryptionDecryption()
{
EncryptParams encryptParams = new EncryptParams(
net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.RsaOaep, 0);
Blob privateKeyBlob = new Blob(net.named_data.jndn.util.Common.base64Decode(PRIVATE_KEY), false);
Blob publicKeyBlob = new Blob(net.named_data.jndn.util.Common.base64Decode(PUBLIC_KEY), false);
DecryptKey decryptKey = new DecryptKey(privateKeyBlob);
EncryptKey encryptKey = net.named_data.jndn.encrypt.algo.RsaAlgorithm.deriveEncryptKey(decryptKey
.getKeyBits());
Blob encodedPublic = publicKeyBlob;
Blob derivedPublicKey = encryptKey.getKeyBits();
Assert.AssertTrue(encodedPublic.equals(derivedPublicKey));
Blob plainBlob = new Blob(PLAINTEXT, false);
Blob encryptBlob = net.named_data.jndn.encrypt.algo.RsaAlgorithm.encrypt(encryptKey.getKeyBits(),
plainBlob, encryptParams);
Blob receivedBlob = net.named_data.jndn.encrypt.algo.RsaAlgorithm.decrypt(decryptKey.getKeyBits(),
encryptBlob, encryptParams);
Assert.AssertTrue(plainBlob.equals(receivedBlob));
Blob cipherBlob = new Blob(CIPHERTEXT_OAEP, false);
Blob decryptedBlob = net.named_data.jndn.encrypt.algo.RsaAlgorithm.decrypt(decryptKey.getKeyBits(),
cipherBlob, encryptParams);
Assert.AssertTrue(plainBlob.equals(decryptedBlob));
// Now test RsaPkcs.
encryptParams = new EncryptParams(net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.RsaPkcs, 0);
encryptBlob = net.named_data.jndn.encrypt.algo.RsaAlgorithm.encrypt(encryptKey.getKeyBits(), plainBlob,
encryptParams);
receivedBlob = net.named_data.jndn.encrypt.algo.RsaAlgorithm.decrypt(decryptKey.getKeyBits(),
encryptBlob, encryptParams);
Assert.AssertTrue(plainBlob.equals(receivedBlob));
cipherBlob = new Blob(CIPHERTEXT_PKCS, false);
decryptedBlob = net.named_data.jndn.encrypt.algo.RsaAlgorithm.decrypt(decryptKey.getKeyBits(),
cipherBlob, encryptParams);
Assert.AssertTrue(plainBlob.equals(decryptedBlob));
}
public void testContentAsymmetricEncryptSmall()
{
/* foreach */
foreach (TestEncryptor.AsymmetricEncryptInput input in encryptorRsaTestInputs)
{
Blob rawContent = new Blob(toBuffer(new int[] { 0x01, 0x23, 0x45,
0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76,
0x54, 0x32, 0x10, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74,
0x73 }), false);
Data data = new Data();
RsaKeyParams rsaParams = new RsaKeyParams(1024);
Name keyName = new Name("test");
DecryptKey decryptKey = net.named_data.jndn.encrypt.algo.RsaAlgorithm.generateKey(rsaParams);
EncryptKey encryptKey = net.named_data.jndn.encrypt.algo.RsaAlgorithm.deriveEncryptKey(decryptKey
.getKeyBits());
Blob eKey = encryptKey.getKeyBits();
Blob dKey = decryptKey.getKeyBits();
EncryptParams encryptParams = new EncryptParams(input.type());
net.named_data.jndn.encrypt.algo.Encryptor.encryptData(data, rawContent, keyName, eKey,
encryptParams);
Assert.AssertEquals(input.testName(), new Name("/FOR").append(keyName),
data.getName());
EncryptedContent extractContent = new EncryptedContent();
extractContent.wireDecode(data.getContent());
Assert.AssertEquals(input.testName(), keyName, extractContent
.getKeyLocator().getKeyName());
Assert.AssertEquals(input.testName(), 0, extractContent.getInitialVector()
.size());
Assert.AssertEquals(input.testName(), input.type(),
extractContent.getAlgorithmType());
Blob recovered = extractContent.getPayload();
Blob decrypted = net.named_data.jndn.encrypt.algo.RsaAlgorithm.decrypt(dKey, recovered,
encryptParams);
Assert.AssertTrue(input.testName(), rawContent.equals(decrypted));
}
}
public void testKeyGeneration()
{
AesKeyParams keyParams = new AesKeyParams(128);
DecryptKey decryptKey = net.named_data.jndn.encrypt.algo.AesAlgorithm.generateKey(keyParams);
EncryptKey encryptKey = net.named_data.jndn.encrypt.algo.AesAlgorithm.deriveEncryptKey(decryptKey
.getKeyBits());
Blob plainBlob = new Blob(PLAINTEXT, false);
// Encrypt/decrypt data in AES_CBC with auto-generated IV.
EncryptParams encryptParams = new EncryptParams(
net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.AesEcb, 16);
Blob cipherBlob = net.named_data.jndn.encrypt.algo.AesAlgorithm.encrypt(encryptKey.getKeyBits(),
plainBlob, encryptParams);
Blob receivedBlob = net.named_data.jndn.encrypt.algo.AesAlgorithm.decrypt(decryptKey.getKeyBits(),
cipherBlob, encryptParams);
Assert.AssertTrue(receivedBlob.equals(plainBlob));
}
/// <summary>
/// Encrypt the given content with the content key that covers timeSlot, and
/// update the data packet with the encrypted content and an appropriate data
/// name.
/// </summary>
///
/// <param name="data">An empty Data object which is updated.</param>
/// <param name="timeSlot_0">The time slot as milliseconds since Jan 1, 1970 UTC.</param>
/// <param name="content">The content to encrypt.</param>
/// <param name="onError_1">better error handling the callback should catch and properly handle any exceptions.</param>
public void produce(Data data, double timeSlot_0, Blob content,
net.named_data.jndn.encrypt.EncryptError.OnError onError_1)
{
// Get a content key.
Name contentKeyName = createContentKey(timeSlot_0, null, onError_1);
Blob contentKey = database_.getContentKey(timeSlot_0);
// Produce data.
Name dataName = new Name(namespace_);
dataName.append(net.named_data.jndn.encrypt.Schedule.toIsoString(timeSlot_0));
data.setName(dataName);
EncryptParams paras = new EncryptParams(net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.AesCbc,
16);
net.named_data.jndn.encrypt.algo.Encryptor
.encryptData(data, content, contentKeyName, contentKey, paras);
keyChain_.sign(data);
}
/// <summary>
/// Get the content key from the database_ and encrypt it for the timeSlot
/// using encryptionKey.
/// </summary>
///
/// <param name="encryptionKey">The encryption key value.</param>
/// <param name="eKeyName">The key name for the EncryptedContent.</param>
/// <param name="timeSlot_0">The time slot as milliseconds since Jan 1, 1970 UTC.</param>
/// <param name="onEncryptedKeys_1">encrypted content key Data packets. If onEncryptedKeys is null, this does not use it.</param>
/// <returns>True if encryption succeeds, otherwise false.</returns>
private bool encryptContentKey(Blob encryptionKey, Name eKeyName,
double timeSlot_0, Producer.OnEncryptedKeys onEncryptedKeys_1, net.named_data.jndn.encrypt.EncryptError.OnError onError_2)
{
double timeCount = Math.Round(timeSlot_0, MidpointRounding.AwayFromZero);
Producer.KeyRequest keyRequest = (Producer.KeyRequest)ILOG.J2CsMapping.Collections.Collections.Get(keyRequests_, timeCount);
Name keyName = new Name(namespace_);
keyName.append(net.named_data.jndn.encrypt.algo.Encryptor.NAME_COMPONENT_C_KEY);
keyName.append(net.named_data.jndn.encrypt.Schedule.toIsoString(getRoundedTimeSlot(timeSlot_0)));
Blob contentKey = database_.getContentKey(timeSlot_0);
Data cKeyData = new Data();
cKeyData.setName(keyName);
EncryptParams paras = new EncryptParams(net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.RsaOaep);
try {
net.named_data.jndn.encrypt.algo.Encryptor.encryptData(cKeyData, contentKey, eKeyName,
encryptionKey, paras);
} catch (Exception ex) {
try {
onError_2.onError(net.named_data.jndn.encrypt.EncryptError.ErrorCode.EncryptionFailure, ex.Message);
} catch (Exception exception) {
logger_.log(ILOG.J2CsMapping.Util.Logging.Level.SEVERE, "Error in onError", exception);
}
return(false);
}
keyChain_.sign(cKeyData);
ILOG.J2CsMapping.Collections.Collections.Add(keyRequest.encryptedKeys, cKeyData);
updateKeyRequest(keyRequest, timeCount, onEncryptedKeys_1);
return(true);
}
public void testContentKeyRequest()
{
Name prefix = new Name("/prefix");
Name suffix = new Name("/a/b/c");
Name expectedInterest = new Name(prefix);
expectedInterest.append(net.named_data.jndn.encrypt.algo.Encryptor.NAME_COMPONENT_READ);
expectedInterest.append(suffix);
expectedInterest.append(net.named_data.jndn.encrypt.algo.Encryptor.NAME_COMPONENT_E_KEY);
Name cKeyName = new Name(prefix);
cKeyName.append(net.named_data.jndn.encrypt.algo.Encryptor.NAME_COMPONENT_SAMPLE);
cKeyName.append(suffix);
cKeyName.append(net.named_data.jndn.encrypt.algo.Encryptor.NAME_COMPONENT_C_KEY);
Name timeMarker = new Name("20150101T100000/20150101T120000");
double testTime1 = net.named_data.jndn.encrypt.Schedule.fromIsoString("20150101T100001");
double testTime2 = net.named_data.jndn.encrypt.Schedule.fromIsoString("20150101T110001");
Name.Component testTimeRounded1 = new Name.Component(
"20150101T100000");
Name.Component testTimeRounded2 = new Name.Component(
"20150101T110000");
Name.Component testTimeComponent2 = new Name.Component(
"20150101T110001");
// Create content keys required for this test case:
for (int i = 0; i < suffix.size(); ++i)
{
createEncryptionKey(expectedInterest, timeMarker);
expectedInterest = expectedInterest.getPrefix(-2).append(
net.named_data.jndn.encrypt.algo.Encryptor.NAME_COMPONENT_E_KEY);
}
int[] expressInterestCallCount = new int[] { 0 };
// Prepare a LocalTestFace to instantly answer calls to expressInterest.
TestProducer.LocalTestFace face = new TestProducer.LocalTestFace(this, timeMarker,
expressInterestCallCount);
// Verify that the content key is correctly encrypted for each domain, and
// the produce method encrypts the provided data with the same content key.
ProducerDb testDb = new Sqlite3ProducerDb(
databaseFilePath.FullName);
Producer producer = new Producer(prefix, suffix, face, keyChain, testDb);
Blob[] contentKey = new Blob[] { null };
TestProducer.CheckEncryptionKeys checkEncryptionKeys = new TestProducer.CheckEncryptionKeys(
this, expressInterestCallCount, contentKey, cKeyName, testDb);
// An initial test to confirm that keys are created for this time slot.
Name contentKeyName1 = producer.createContentKey(testTime1,
new TestProducer.Anonymous_C4(checkEncryptionKeys, testTimeRounded1,
testTime1));
// Verify that we do not repeat the search for e-keys. The total
// expressInterestCallCount should be the same.
Name contentKeyName2 = producer.createContentKey(testTime2,
new TestProducer.Anonymous_C3(checkEncryptionKeys, testTime2,
testTimeRounded2));
// Confirm content key names are correct
Assert.AssertEquals(cKeyName, contentKeyName1.getPrefix(-1));
Assert.AssertEquals(testTimeRounded1, contentKeyName1.get(6));
Assert.AssertEquals(cKeyName, contentKeyName2.getPrefix(-1));
Assert.AssertEquals(testTimeRounded2, contentKeyName2.get(6));
// Confirm that produce encrypts with the correct key and has the right name.
Data testData = new Data();
producer.produce(testData, testTime2, new Blob(DATA_CONTENT, false));
Name producedName = testData.getName();
Assert.AssertEquals(cKeyName.getPrefix(-1), producedName.getSubName(0, 5));
Assert.AssertEquals(testTimeComponent2, producedName.get(5));
Assert.AssertEquals(net.named_data.jndn.encrypt.algo.Encryptor.NAME_COMPONENT_FOR, producedName.get(6));
Assert.AssertEquals(cKeyName, producedName.getSubName(7, 6));
Assert.AssertEquals(testTimeRounded2, producedName.get(13));
Blob dataBlob = testData.getContent();
EncryptedContent dataContent = new EncryptedContent();
dataContent.wireDecode(dataBlob);
Blob encryptedData = dataContent.getPayload();
Blob initialVector = dataContent.getInitialVector();
EncryptParams paras = new EncryptParams(net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.AesCbc,
16);
paras.setInitialVector(initialVector);
Blob decryptTest = net.named_data.jndn.encrypt.algo.AesAlgorithm.decrypt(contentKey[0], encryptedData,
paras);
Assert.AssertTrue(decryptTest.equals(new Blob(DATA_CONTENT, false)));
}
/// <summary>
/// Decrypt encryptedContent using keyBits.
/// </summary>
///
/// <param name="encryptedContent">The EncryptedContent to decrypt.</param>
/// <param name="keyBits">The key value.</param>
/// <param name="onPlainText_0"></param>
/// <param name="onError_1">This calls onError.onError(errorCode, message) for an error.</param>
static internal void decrypt(EncryptedContent encryptedContent,
Blob keyBits, Consumer.OnPlainText onPlainText_0, net.named_data.jndn.encrypt.EncryptError.OnError onError_1)
{
Blob payload = encryptedContent.getPayload();
if (encryptedContent.getAlgorithmType() == net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.AesCbc)
{
// Prepare the parameters.
EncryptParams decryptParams = new EncryptParams(
net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.AesCbc);
decryptParams.setInitialVector(encryptedContent.getInitialVector());
// Decrypt the content.
Blob content;
try {
content = net.named_data.jndn.encrypt.algo.AesAlgorithm.decrypt(keyBits, payload, decryptParams);
} catch (Exception ex) {
try {
onError_1.onError(net.named_data.jndn.encrypt.EncryptError.ErrorCode.InvalidEncryptedFormat,
ex.Message);
} catch (Exception exception) {
logger_.log(ILOG.J2CsMapping.Util.Logging.Level.SEVERE, "Error in onError", exception);
}
return;
}
try {
onPlainText_0.onPlainText(content);
} catch (Exception ex_2) {
logger_.log(ILOG.J2CsMapping.Util.Logging.Level.SEVERE, "Error in onPlainText", ex_2);
}
}
else if (encryptedContent.getAlgorithmType() == net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.RsaOaep)
{
// Prepare the parameters.
EncryptParams decryptParams_3 = new EncryptParams(
net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.RsaOaep);
// Decrypt the content.
Blob content_4;
try {
content_4 = net.named_data.jndn.encrypt.algo.RsaAlgorithm.decrypt(keyBits, payload, decryptParams_3);
} catch (Exception ex_5) {
try {
onError_1.onError(net.named_data.jndn.encrypt.EncryptError.ErrorCode.InvalidEncryptedFormat,
ex_5.Message);
} catch (Exception exception_6) {
logger_.log(ILOG.J2CsMapping.Util.Logging.Level.SEVERE, "Error in onError", exception_6);
}
return;
}
try {
onPlainText_0.onPlainText(content_4);
} catch (Exception ex_7) {
logger_.log(ILOG.J2CsMapping.Util.Logging.Level.SEVERE, "Error in onPlainText", ex_7);
}
}
else
{
try {
onError_1.onError(net.named_data.jndn.encrypt.EncryptError.ErrorCode.UnsupportedEncryptionScheme, ""
+ encryptedContent.getAlgorithmType());
} catch (Exception ex_8) {
logger_.log(ILOG.J2CsMapping.Util.Logging.Level.SEVERE, "Error in onError", ex_8);
}
}
}
public void testContentAsymmetricEncryptLarge()
{
/* foreach */
foreach (TestEncryptor.AsymmetricEncryptInput input in encryptorRsaTestInputs)
{
Blob largeContent = new Blob(toBuffer(new int[] { 0x73, 0x5a, 0xbd,
0x47, 0x0c, 0xfe, 0xf8, 0x7d, 0x2e, 0x17, 0xaa, 0x11, 0x6f,
0x23, 0xc5, 0x10, 0x23, 0x36, 0x88, 0xc4, 0x2a, 0x0f, 0x9a,
0x72, 0x54, 0x31, 0xa8, 0xb3, 0x51, 0x18, 0x9f, 0x0e, 0x1b,
0x93, 0x62, 0xd9, 0xc4, 0xf5, 0xf4, 0x3d, 0x61, 0x9a, 0xca,
0x05, 0x65, 0x6b, 0xc6, 0x41, 0xf9, 0xd5, 0x1c, 0x67, 0xc1,
0xd0, 0xd5, 0x6f, 0x7b, 0x70, 0xb8, 0x8f, 0xdb, 0x19, 0x68,
0x7c, 0xe0, 0x2d, 0x04, 0x49, 0xa9, 0xa2, 0x77, 0x4e, 0xfc,
0x60, 0x0d, 0x7c, 0x1b, 0x93, 0x6c, 0xd2, 0x61, 0xc4, 0x6b,
0x01, 0xe9, 0x12, 0x28, 0x6d, 0xf5, 0x78, 0xe9, 0x99, 0x0b,
0x9c, 0x4f, 0x90, 0x34, 0x3e, 0x06, 0x92, 0x57, 0xe3, 0x7a,
0x8f, 0x13, 0xc7, 0xf3, 0xfe, 0xf0, 0xe2, 0x59, 0x48, 0x15,
0xb9, 0xdb, 0x77, 0x07, 0x1d, 0x6d, 0xb5, 0x65, 0x17, 0xdf,
0x76, 0x6f, 0xb5, 0x43, 0xde, 0x71, 0xac, 0xf1, 0x22, 0xbf,
0xb2, 0xe5, 0xd9, 0x22, 0xf1, 0x67, 0x76, 0x71, 0x0c, 0xff,
0x99, 0x7b, 0x94, 0x9b, 0x24, 0x20, 0x80, 0xe3, 0xcc, 0x06,
0x4a, 0xed, 0xdf, 0xec, 0x50, 0xd5, 0x87, 0x3d, 0xa0, 0x7d,
0x9c, 0xe5, 0x13, 0x10, 0x98, 0x14, 0xc3, 0x90, 0x10, 0xd9,
0x25, 0x9a, 0x59, 0xe9, 0x37, 0x26, 0xfd, 0x87, 0xd7, 0xf4,
0xf9, 0x11, 0x91, 0xad, 0x5c, 0x00, 0x95, 0xf5, 0x2b, 0x37,
0xf7, 0x4e, 0xb4, 0x4b, 0x42, 0x7c, 0xb3, 0xad, 0xd6, 0x33,
0x5f, 0x0b, 0x84, 0x57, 0x7f, 0xa7, 0x07, 0x73, 0x37, 0x4b,
0xab, 0x2e, 0xfb, 0xfe, 0x1e, 0xcb, 0xb6, 0x4a, 0xc1, 0x21,
0x5f, 0xec, 0x92, 0xb7, 0xac, 0x97, 0x75, 0x20, 0xc9, 0xd8,
0x9e, 0x93, 0xd5, 0x12, 0x7a, 0x64, 0xb9, 0x4c, 0xed, 0x49,
0x87, 0x44, 0x5b, 0x4f, 0x90, 0x34, 0x3e, 0x06, 0x92, 0x57,
0xe3, 0x7a, 0x8f, 0x13, 0xc7, 0xf3, 0xfe, 0xf0, 0xe2, 0x59,
0x48, 0x15, 0xb9, 0xdb, 0x77, 0x07, 0x1d, 0x6d, 0xb5, 0x65,
0x17, 0xdf, 0x76, 0x6f, 0xb5, 0x43, 0xde, 0x71, 0xac, 0xf1,
0x22, 0xbf, 0xb2, 0xe5, 0xd9 }), false);
Data data = new Data();
RsaKeyParams rsaParams = new RsaKeyParams(1024);
Name keyName = new Name("test");
DecryptKey decryptKey = net.named_data.jndn.encrypt.algo.RsaAlgorithm.generateKey(rsaParams);
EncryptKey encryptKey = net.named_data.jndn.encrypt.algo.RsaAlgorithm.deriveEncryptKey(decryptKey
.getKeyBits());
Blob eKey = encryptKey.getKeyBits();
Blob dKey = decryptKey.getKeyBits();
EncryptParams encryptParams = new EncryptParams(input.type());
net.named_data.jndn.encrypt.algo.Encryptor.encryptData(data, largeContent, keyName, eKey,
encryptParams);
Assert.AssertEquals(input.testName(), new Name("/FOR").append(keyName),
data.getName());
Blob largeDataContent = data.getContent();
// largeDataContent is a sequence of the two EncryptedContent.
EncryptedContent encryptedNonce = new EncryptedContent();
encryptedNonce.wireDecode(largeDataContent);
Assert.AssertEquals(input.testName(), keyName, encryptedNonce
.getKeyLocator().getKeyName());
Assert.AssertEquals(input.testName(), 0, encryptedNonce.getInitialVector()
.size());
Assert.AssertEquals(input.testName(), input.type(),
encryptedNonce.getAlgorithmType());
// Use the size of encryptedNonce to find the start of encryptedPayload.
ByteBuffer payloadContent = largeDataContent.buf().duplicate();
payloadContent.position(encryptedNonce.wireEncode().size());
EncryptedContent encryptedPayload = new EncryptedContent();
encryptedPayload.wireDecode(payloadContent);
Name nonceKeyName = new Name(keyName);
nonceKeyName.append("nonce");
Assert.AssertEquals(input.testName(), nonceKeyName, encryptedPayload
.getKeyLocator().getKeyName());
Assert.AssertEquals(input.testName(), 16, encryptedPayload
.getInitialVector().size());
Assert.AssertEquals(input.testName(), net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.AesCbc,
encryptedPayload.getAlgorithmType());
Assert.AssertTrue(input.testName(), encryptedNonce.wireEncode().size()
+ encryptedPayload.wireEncode().size() == largeDataContent
.size());
Blob blobNonce = encryptedNonce.getPayload();
Blob nonce = net.named_data.jndn.encrypt.algo.RsaAlgorithm.decrypt(dKey, blobNonce, encryptParams);
encryptParams.setAlgorithmType(net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.AesCbc);
encryptParams.setInitialVector(encryptedPayload.getInitialVector());
Blob bufferPayload = encryptedPayload.getPayload();
Blob largePayload = net.named_data.jndn.encrypt.algo.AesAlgorithm.decrypt(nonce, bufferPayload,
encryptParams);
Assert.AssertTrue(input.testName(), largeContent.equals(largePayload));
}
}
public void testGetGroupKey()
{
// Create the group manager.
GroupManager manager = new GroupManager(new Name("Alice"), new Name(
"data_type"), new Sqlite3GroupManagerDb(
groupKeyDatabaseFilePath.FullName), 1024, 1, keyChain);
setManager(manager);
// Get the data list from the group manager.
double timePoint1 = net.named_data.jndn.encrypt.Schedule.fromIsoString("20150825T093000");
IList result = manager.getGroupKey(timePoint1);
Assert.AssertEquals(4, result.Count);
// The first data packet contains the group's encryption key (public key).
Data data = (Data)result[0];
Assert.AssertEquals(
"/Alice/READ/data_type/E-KEY/20150825T090000/20150825T100000",
data.getName().toUri());
EncryptKey groupEKey = new EncryptKey(data.getContent());
// Get the second data packet and decrypt.
data = (Data)result[1];
Assert.AssertEquals(
"/Alice/READ/data_type/D-KEY/20150825T090000/20150825T100000/FOR/ndn/memberA/ksk-123",
data.getName().toUri());
/////////////////////////////////////////////////////// Start decryption.
Blob dataContent = data.getContent();
// Get the nonce key.
// dataContent is a sequence of the two EncryptedContent.
EncryptedContent encryptedNonce = new EncryptedContent();
encryptedNonce.wireDecode(dataContent);
Assert.AssertEquals(0, encryptedNonce.getInitialVector().size());
Assert.AssertEquals(net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.RsaOaep,
encryptedNonce.getAlgorithmType());
EncryptParams decryptParams = new EncryptParams(
net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.RsaOaep);
Blob blobNonce = encryptedNonce.getPayload();
Blob nonce = net.named_data.jndn.encrypt.algo.RsaAlgorithm.decrypt(decryptKeyBlob, blobNonce,
decryptParams);
// Get the payload.
// Use the size of encryptedNonce to find the start of encryptedPayload.
ByteBuffer payloadContent = dataContent.buf().duplicate();
payloadContent.position(encryptedNonce.wireEncode().size());
EncryptedContent encryptedPayload = new EncryptedContent();
encryptedPayload.wireDecode(payloadContent);
Assert.AssertEquals(16, encryptedPayload.getInitialVector().size());
Assert.AssertEquals(net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.AesCbc,
encryptedPayload.getAlgorithmType());
decryptParams.setAlgorithmType(net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.AesCbc);
decryptParams.setInitialVector(encryptedPayload.getInitialVector());
Blob blobPayload = encryptedPayload.getPayload();
Blob largePayload = net.named_data.jndn.encrypt.algo.AesAlgorithm.decrypt(nonce, blobPayload,
decryptParams);
// Get the group D-KEY.
DecryptKey groupDKey = new DecryptKey(largePayload);
/////////////////////////////////////////////////////// End decryption.
// Check the D-KEY.
EncryptKey derivedGroupEKey = net.named_data.jndn.encrypt.algo.RsaAlgorithm.deriveEncryptKey(groupDKey
.getKeyBits());
Assert.AssertTrue(groupEKey.getKeyBits().equals(derivedGroupEKey.getKeyBits()));
// Check the third data packet.
data = (Data)result[2];
Assert.AssertEquals(
"/Alice/READ/data_type/D-KEY/20150825T090000/20150825T100000/FOR/ndn/memberB/ksk-123",
data.getName().toUri());
// Check the fourth data packet.
data = (Data)result[3];
Assert.AssertEquals(
"/Alice/READ/data_type/D-KEY/20150825T090000/20150825T100000/FOR/ndn/memberC/ksk-123",
data.getName().toUri());
// Check invalid time stamps for getting the group key.
double timePoint2 = net.named_data.jndn.encrypt.Schedule.fromIsoString("20150826T083000");
Assert.AssertEquals(0, manager.getGroupKey(timePoint2).Count);
double timePoint3 = net.named_data.jndn.encrypt.Schedule.fromIsoString("20150827T023000");
Assert.AssertEquals(0, manager.getGroupKey(timePoint3).Count);
}
public void checkEncryptionKeys(List result, double testTime,
Name.Component roundedTime,
int expectedExpressInterestCallCount) {
AssertEquals(expectedExpressInterestCallCount,
expressInterestCallCount[0]);
try {
AssertEquals(true, testDb.HasContentKey(testTime));
contentKey[0] = testDb.GetContentKey(testTime);
} catch (ProducerDb.Error ex) {
Fail("Error in ProducerDb: " + ex);
}
EncryptParams paras = new EncryptParams(
net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.RsaOaep);
for (int i = 0; i < result.Count; ++i) {
Data key = (Data) result[i];
Name keyName = key.getName();
AssertEquals(cKeyName, keyName.getSubName(0, 6));
AssertEquals(keyName.get(6), roundedTime);
AssertEquals(keyName.get(7), net.named_data.jndn.encrypt.algo.Encryptor.NAME_COMPONENT_FOR);
AssertEquals(true,
outer_TestProducer.decryptionKeys.Contains(keyName.getSubName(8)));
Blob decryptionKey = (Blob) ILOG.J2CsMapping.Collections.Collections.Get(outer_TestProducer.decryptionKeys,keyName
.getSubName(8));
AssertEquals(true, decryptionKey.size() != 0);
Blob encryptedKeyEncoding = key.getContent();
EncryptedContent content = new EncryptedContent();
try {
content.wireDecode(encryptedKeyEncoding);
} catch (EncodingException ex_0) {
Fail("Error decoding EncryptedContent" + ex_0);
}
Blob encryptedKey = content.getPayload();
Blob retrievedKey = null;
try {
retrievedKey = net.named_data.jndn.encrypt.algo.RsaAlgorithm.decrypt(decryptionKey,
encryptedKey, paras);
} catch (Exception ex_1) {
Fail("Error in RsaAlgorithm.decrypt: " + ex_1);
}
AssertTrue(contentKey[0].Equals(retrievedKey));
}
AssertEquals(3, result.Count);
}