private void Decryptnew_Click(object sender, EventArgs e)
{
DecrypText.Clear();
DecryptKey.Clear();
Decryptresoultbox.Clear();
DecrypText.ReadOnly = false;
}
public Identity Decrypt(DecryptKey decryptKey)
{
Check(decryptKey);
var point = Points[1].Subtract(Points[0].Multiply(decryptKey.PrivateKey)).Normalize();
return(new Identity(point));
}
private void Decryptnew_Click_1(object sender, EventArgs e)
{
DecrypText.Clear();
DecryptKey.Clear();
Decryptresoultbox.Clear();
DecrypText.ReadOnly = false;
decryptedWord = " ! Word not found ! ";
decryptkey = 0;
}
//Open encrypt page button
private void button1_Click(object sender, EventArgs e)
{
HideDecrypt();
Showencrypt();
DecrypText.Clear();
DecryptKey.Clear();
Decryptresoultbox.Clear();
DecrypText.ReadOnly = false;
}
public Identity Decrypt(DecryptKey decryptKey)
{
Guard.AssertNotNull(decryptKey, nameof(decryptKey));
Check(decryptKey);
var point = Points[1].Subtract(Points[0].Multiply(decryptKey.KeyPair.PrivateKey)).Normalize();
return(new Identity(point));
}
// Show Decrypt function
private void ShowDecrypt()
{
DecryptLable.Show();
DecrypText.Show();
DecryptLablekey.Show();
DecryptKey.Show();
DecryptButton.Show();
Decrypttextbox.Show();
Decryptresoultbox.Show();
Decryptnew.Show();
}
//Hyde Decrypt function
private void HideDecrypt()
{
DecryptLable.Hide();
DecrypText.Hide();
DecryptLablekey.Hide();
DecryptKey.Hide();
DecryptButton.Hide();
Decrypttextbox.Hide();
Decryptresoultbox.Hide();
Decryptnew.Hide();
}
/// <summary>
/// Generate a new random decrypt key for AES based on the given params.
/// </summary>
///
/// <param name="params">The key params with the key size (in bits).</param>
/// <returns>The new decrypt key.</returns>
public static DecryptKey generateKey(AesKeyParams paras)
{
// Convert the key bit size to bytes.
ByteBuffer key = ILOG.J2CsMapping.NIO.ByteBuffer.allocate(paras.getKeySize() / 8);
net.named_data.jndn.util.Common.getRandom().nextBytes(key.array());
DecryptKey decryptKey = new DecryptKey(new Blob(key, false));
return(decryptKey);
}
static internal void generateRsaKeys(Blob[] encryptionKeyBlob,
Blob[] decryptionKeyBlob)
{
RsaKeyParams paras = new RsaKeyParams();
DecryptKey decryptKey = net.named_data.jndn.encrypt.algo.RsaAlgorithm.generateKey(paras);
decryptionKeyBlob[0] = decryptKey.getKeyBits();
EncryptKey encryptKey = net.named_data.jndn.encrypt.algo.RsaAlgorithm
.deriveEncryptKey(decryptionKeyBlob[0]);
encryptionKeyBlob[0] = encryptKey.getKeyBits();
}
static internal void generateAesKeys(Blob[] encryptionKeyBlob,
Blob[] decryptionKeyBlob)
{
AesKeyParams paras = new AesKeyParams();
DecryptKey memberDecryptKey = net.named_data.jndn.encrypt.algo.AesAlgorithm.generateKey(paras);
decryptionKeyBlob[0] = memberDecryptKey.getKeyBits();
EncryptKey memberEncryptKey = net.named_data.jndn.encrypt.algo.AesAlgorithm
.deriveEncryptKey(decryptionKeyBlob[0]);
encryptionKeyBlob[0] = memberEncryptKey.getKeyBits();
}
public Pseudonym Decrypt(DecryptKey decryptKey, DecryptKey closingKey)
{
Check(decryptKey);
Check(closingKey);
var point = Points[1].Subtract(
Points[0].Multiply(decryptKey.PrivateKey)
)
.Multiply(closingKey.PrivateKey)
.Normalize();
return(new Pseudonym(closingKey.RecipientKeySetVersion, point));
}
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 Pseudonym Decrypt(DecryptKey decryptKey, DecryptKey closingKey)
{
Guard.AssertNotNull(decryptKey, nameof(decryptKey));
Check(decryptKey);
Guard.AssertNotNull(closingKey, nameof(closingKey));
Check(closingKey);
var point = Points[1].Subtract(
Points[0].Multiply(decryptKey.KeyPair.PrivateKey)
)
.Multiply(closingKey.KeyPair.PrivateKey)
.Normalize();
return(new Pseudonym(closingKey.RecipientKeySetVersion, point));
}
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));
}
internal PseudonymClosingKey GetPseudonymClosingKey()
{
return(DecryptKey.FromPem <PseudonymClosingKey>(PseudoClosingKeyPem));
}
internal IdentityDecryptKey GetIdentityDecryptKey()
{
return(DecryptKey.FromPem <IdentityDecryptKey>(IdentityPem));
}
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 setUp()
{
// Don't show INFO log messages.
ILOG.J2CsMapping.Util.Logging.Logger.getLogger("").setLevel(ILOG.J2CsMapping.Util.Logging.Level.WARNING);
FileInfo policyConfigDirectory = net.named_data.jndn.tests.integration_tests.IntegrationTestsCommon
.getPolicyConfigDirectory();
dKeyDatabaseFilePath = new FileInfo(System.IO.Path.Combine(policyConfigDirectory.FullName, "manager-d-key-test.db"));
dKeyDatabaseFilePath.delete();
eKeyDatabaseFilePath = new FileInfo(System.IO.Path.Combine(policyConfigDirectory.FullName, "manager-e-key-test.db"));
eKeyDatabaseFilePath.delete();
intervalDatabaseFilePath = new FileInfo(System.IO.Path.Combine(policyConfigDirectory.FullName, "manager-interval-test.db"));
intervalDatabaseFilePath.delete();
groupKeyDatabaseFilePath = new FileInfo(System.IO.Path.Combine(policyConfigDirectory.FullName, "manager-group-key-test.db"));
groupKeyDatabaseFilePath.delete();
RsaKeyParams paras = new RsaKeyParams();
DecryptKey memberDecryptKey = net.named_data.jndn.encrypt.algo.RsaAlgorithm.generateKey(paras);
decryptKeyBlob = memberDecryptKey.getKeyBits();
EncryptKey memberEncryptKey = net.named_data.jndn.encrypt.algo.RsaAlgorithm
.deriveEncryptKey(decryptKeyBlob);
encryptKeyBlob = memberEncryptKey.getKeyBits();
// Generate the certificate.
certificate.setName(new Name("/ndn/memberA/KEY/ksk-123/ID-CERT/123"));
PublicKey contentPublicKey = new PublicKey(encryptKeyBlob);
certificate.setPublicKeyInfo(contentPublicKey);
certificate.setNotBefore(0);
certificate.setNotAfter(0);
certificate.encode();
Blob signatureInfoBlob = new Blob(SIG_INFO, false);
Blob signatureValueBlob = new Blob(SIG_VALUE, false);
Signature signature = net.named_data.jndn.encoding.TlvWireFormat.get().decodeSignatureInfoAndValue(
signatureInfoBlob.buf(), signatureValueBlob.buf());
certificate.setSignature(signature);
certificate.wireEncode();
// Set up the keyChain.
MemoryIdentityStorage identityStorage = new MemoryIdentityStorage();
MemoryPrivateKeyStorage privateKeyStorage = new MemoryPrivateKeyStorage();
keyChain = new KeyChain(new IdentityManager(identityStorage,
privateKeyStorage), new NoVerifyPolicyManager());
Name identityName = new Name("TestGroupManager");
keyChain.createIdentityAndCertificate(identityName);
keyChain.getIdentityManager().setDefaultIdentity(identityName);
net.named_data.jndn.encrypt.GroupManager.setFriendAccess(this);
}
internal DecryptKey GetPseudonymDecryptKey()
{
return(DecryptKey.FromPem(PseudoKeyPem));
}
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));
}
}
