def test_append(self):
# could possibly split this into different tests
uri = "/localhost/user/folders/files/%00%0F"
name = Name(uri)
name2 = Name("/localhost").append(Name("/user/folders/"))
self.assertEqual(name2.size(), 3, 'Name constructed by appending names has ' + str(name2.size()) + ' components instead of 3')
self.assertTrue(name2.get(2).getValue().equals(Blob(bytearray("folders"))), 'Name constructed with append has wrong suffix')
name2 = name2.append("files")
self.assertEqual(name2.size(), 4, 'Name constructed by appending string has ' + str(name2.size()) + ' components instead of 4')
name2 = name2.appendSegment(15)
self.assertTrue(name2.get(4).getValue().equals(Blob(bytearray([0x00, 0x0F]))), 'Name constructed by appending segment has wrong segment value')
self.assertTrue(name2.equals(name), 'Name constructed with append is not equal to URI constructed name')
self.assertEqual(name2.toUri(), name.toUri(), 'Name constructed with append has wrong URI')
def test_append(self):
# could possibly split this into different tests
uri = "/localhost/user/folders/files/%00%0F"
name = Name(uri)
name2 = Name("/localhost").append(Name("/user/folders/"))
self.assertEqual(name2.size(), 3, 'Name constructed by appending names has ' + str(name2.size()) + ' components instead of 3')
self.assertTrue(name2.get(2).getValue().equals(Blob(bytearray("folders"))), 'Name constructed with append has wrong suffix')
name2 = name2.append("files")
self.assertEqual(name2.size(), 4, 'Name constructed by appending string has ' + str(name2.size()) + ' components instead of 4')
name2 = name2.appendSegment(15)
self.assertTrue(name2.get(4).getValue().equals(Blob(bytearray([0x00, 0x0F]))), 'Name constructed by appending segment has wrong segment value')
self.assertTrue(name2.equals(name), 'Name constructed with append is not equal to URI constructed name')
self.assertEqual(name2.toUri(), name.toUri(), 'Name constructed with append has wrong URI')
def test_subname(self):
name = Name("/edu/cmu/andrew/user/3498478")
subName1 = name.getSubName(0)
self.assertTrue(subName1.equals(name), 'Subname from first component does not match original name')
subName2 = name.getSubName(3)
self.assertEqual(subName2.toUri(), "/user/3498478")
subName3 = name.getSubName(1,3)
self.assertEqual(subName3.toUri(), "/cmu/andrew/user")
subName4 = name.getSubName(0,100)
self.assertTrue(name.equals(subName4), 'Subname with more components than original should stop at end of original name')
subName5 = name.getSubName(7,9)
self.assertTrue(Name().equals(subName5), 'Subname beginning after end of name should be empty')
def test_subname(self):
name = Name("/edu/cmu/andrew/user/3498478")
subName1 = name.getSubName(0)
self.assertTrue(subName1.equals(name), 'Subname from first component does not match original name')
subName2 = name.getSubName(3)
self.assertEqual(subName2.toUri(), "/user/3498478")
subName3 = name.getSubName(1,3)
self.assertEqual(subName3.toUri(), "/cmu/andrew/user")
subName4 = name.getSubName(0,100)
self.assertTrue(name.equals(subName4), 'Subname with more components than original should stop at end of original name')
subName5 = name.getSubName(7,9)
self.assertTrue(Name().equals(subName5), 'Subname beginning after end of name should be empty')
def test_basic(self):
identityName = Name("/my-identity")
keyName = Name("/my-key")
certificateName = Name("/my-cert")
info = SigningInfo()
self.assertEquals(SigningInfo.SignerType.NULL, info.getSignerType())
self.assertTrue(Name().equals(info.getSignerName()))
self.assertEquals(DigestAlgorithm.SHA256, info.getDigestAlgorithm())
info.setSigningIdentity(identityName)
self.assertEquals(SigningInfo.SignerType.ID, info.getSignerType())
self.assertTrue(identityName.equals(info.getSignerName()))
self.assertEquals(DigestAlgorithm.SHA256, info.getDigestAlgorithm())
infoId = SigningInfo(SigningInfo.SignerType.ID, identityName)
self.assertEquals(SigningInfo.SignerType.ID, infoId.getSignerType())
self.assertTrue(identityName.equals(infoId.getSignerName()))
self.assertEquals(DigestAlgorithm.SHA256, infoId.getDigestAlgorithm())
info.setSigningKeyName(keyName)
self.assertEquals(SigningInfo.SignerType.KEY, info.getSignerType())
self.assertTrue(keyName.equals(info.getSignerName()))
self.assertEquals(DigestAlgorithm.SHA256, info.getDigestAlgorithm())
infoKey = SigningInfo(SigningInfo.SignerType.KEY, keyName)
self.assertEquals(SigningInfo.SignerType.KEY, infoKey.getSignerType())
self.assertTrue(keyName.equals(infoKey.getSignerName()))
self.assertEquals(DigestAlgorithm.SHA256, infoKey.getDigestAlgorithm())
info.setSigningCertificateName(certificateName)
self.assertEquals(SigningInfo.SignerType.CERT, info.getSignerType())
self.assertTrue(certificateName.equals(info.getSignerName()))
self.assertEquals(DigestAlgorithm.SHA256, info.getDigestAlgorithm())
infoCert = SigningInfo(SigningInfo.SignerType.CERT, certificateName)
self.assertEquals(SigningInfo.SignerType.CERT,
infoCert.getSignerType())
self.assertTrue(certificateName.equals(infoCert.getSignerName()))
self.assertEquals(DigestAlgorithm.SHA256,
infoCert.getDigestAlgorithm())
info.setSha256Signing()
self.assertEquals(SigningInfo.SignerType.SHA256, info.getSignerType())
self.assertTrue(Name().equals(info.getSignerName()))
self.assertEquals(DigestAlgorithm.SHA256, info.getDigestAlgorithm())
infoSha256 = SigningInfo(SigningInfo.SignerType.SHA256)
self.assertEquals(SigningInfo.SignerType.SHA256,
infoSha256.getSignerType())
self.assertTrue(Name().equals(infoSha256.getSignerName()))
self.assertEquals(DigestAlgorithm.SHA256,
infoSha256.getDigestAlgorithm())
def test_basic(self):
identityName = Name("/my-identity")
keyName = Name("/my-key")
certificateName = Name("/my-cert")
info = SigningInfo()
self.assertEqual(SigningInfo.SignerType.NULL, info.getSignerType())
self.assertTrue(Name().equals(info.getSignerName()))
self.assertEqual(DigestAlgorithm.SHA256, info.getDigestAlgorithm())
info.setSigningIdentity(identityName)
self.assertEqual(SigningInfo.SignerType.ID, info.getSignerType())
self.assertTrue(identityName.equals(info.getSignerName()))
self.assertEqual(DigestAlgorithm.SHA256, info.getDigestAlgorithm())
infoId = SigningInfo(SigningInfo.SignerType.ID, identityName)
self.assertEqual(SigningInfo.SignerType.ID, infoId.getSignerType())
self.assertTrue(identityName.equals(infoId.getSignerName()))
self.assertEqual(DigestAlgorithm.SHA256, infoId.getDigestAlgorithm())
info.setSigningKeyName(keyName)
self.assertEqual(SigningInfo.SignerType.KEY, info.getSignerType())
self.assertTrue(keyName.equals(info.getSignerName()))
self.assertEqual(DigestAlgorithm.SHA256, info.getDigestAlgorithm())
infoKey = SigningInfo(SigningInfo.SignerType.KEY, keyName)
self.assertEqual(SigningInfo.SignerType.KEY, infoKey.getSignerType())
self.assertTrue(keyName.equals(infoKey.getSignerName()))
self.assertEqual(DigestAlgorithm.SHA256, infoKey.getDigestAlgorithm())
info.setSigningCertificateName(certificateName)
self.assertEqual(SigningInfo.SignerType.CERT, info.getSignerType())
self.assertTrue(certificateName.equals(info.getSignerName()))
self.assertEqual(DigestAlgorithm.SHA256, info.getDigestAlgorithm())
infoCert = SigningInfo(SigningInfo.SignerType.CERT, certificateName)
self.assertEqual(SigningInfo.SignerType.CERT, infoCert.getSignerType())
self.assertTrue(certificateName.equals(infoCert.getSignerName()))
self.assertEqual(DigestAlgorithm.SHA256, infoCert.getDigestAlgorithm())
info.setSha256Signing()
self.assertEqual(SigningInfo.SignerType.SHA256, info.getSignerType())
self.assertTrue(Name().equals(info.getSignerName()))
self.assertEqual(DigestAlgorithm.SHA256, info.getDigestAlgorithm())
infoSha256 = SigningInfo(SigningInfo.SignerType.SHA256)
self.assertEqual(SigningInfo.SignerType.SHA256, infoSha256.getSignerType())
self.assertTrue(Name().equals(infoSha256.getSignerName()))
self.assertEqual(DigestAlgorithm.SHA256, infoSha256.getDigestAlgorithm())
def test_content_asymmetric_encrypt_small(self):
for input in encryptorRsaTestInputs:
rawContent = Blob(
bytearray([
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()
rsaParams = RsaKeyParams(1024)
keyName = Name("test")
decryptKey = RsaAlgorithm.generateKey(rsaParams)
encryptKey = RsaAlgorithm.deriveEncryptKey(decryptKey.getKeyBits())
eKey = encryptKey.getKeyBits()
dKey = decryptKey.getKeyBits()
encryptParams = EncryptParams(input.type)
Encryptor.encryptData(data, rawContent, keyName, eKey,
encryptParams)
self.assertTrue(
data.getName().equals(Name("/FOR").append(keyName)),
input.testName)
extractContent = EncryptedContent()
extractContent.wireDecode(data.getContent())
self.assertTrue(
keyName.equals(extractContent.getKeyLocator().getKeyName()),
input.testName)
self.assertEqual(extractContent.getInitialVector().size(), 0,
input.testName)
self.assertEqual(extractContent.getAlgorithmType(), input.type,
input.testName)
recovered = extractContent.getPayload()
decrypted = RsaAlgorithm.decrypt(dKey, recovered, encryptParams)
self.assertTrue(rawContent.equals(decrypted), input.testName)
def testEqual(self):
size = 10
iblt1 = InvertibleBloomLookupTable(size)
iblt2 = InvertibleBloomLookupTable(size)
self.assertTrue(iblt1.equals(iblt2))
prefix = Name("/test/memphis").appendNumber(1).toUri()
newHash = Common.murmurHash3Blob(11, prefix)
iblt1.insert(newHash)
iblt2.insert(newHash)
self.assertTrue(iblt1.equals(iblt2))
ibfName1 = Name("/sync")
ibfName2 = Name("/sync")
ibfName1.append(iblt1.encode())
ibfName2.append(iblt2.encode())
self.assertTrue(ibfName1.equals(ibfName2))
def test_content_asymmetric_encrypt_small(self):
for input in encryptorRsaTestInputs:
rawContent = Blob(bytearray([
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()
rsaParams = RsaKeyParams(1024)
keyName = Name("test")
decryptKey = RsaAlgorithm.generateKey(rsaParams)
encryptKey = RsaAlgorithm.deriveEncryptKey(decryptKey.getKeyBits())
eKey = encryptKey.getKeyBits()
dKey = decryptKey.getKeyBits()
encryptParams = EncryptParams(input.type)
Encryptor.encryptData(data, rawContent, keyName, eKey, encryptParams)
self.assertTrue(data.getName().equals(Name("/FOR").append(keyName)),
input.testName)
extractContent = EncryptedContent()
extractContent.wireDecode(data.getContent())
self.assertTrue(
keyName.equals(extractContent.getKeyLocator().getKeyName()),
input.testName)
self.assertEqual(
extractContent.getInitialVector().size(), 0, input.testName)
self.assertEqual(
extractContent.getAlgorithmType(), input.type, input.testName)
recovered = extractContent.getPayload()
decrypted = RsaAlgorithm.decrypt(dKey, recovered, encryptParams)
self.assertTrue(rawContent.equals(decrypted), input.testName)
def test_content_asymmetric_encrypt_large(self):
for input in encryptorRsaTestInputs:
largeContent = Blob(bytearray([
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()
rsaParams = RsaKeyParams(1024)
keyName = Name("test")
decryptKey = RsaAlgorithm.generateKey(rsaParams)
encryptKey = RsaAlgorithm.deriveEncryptKey(decryptKey.getKeyBits())
eKey = encryptKey.getKeyBits()
dKey = decryptKey.getKeyBits()
encryptParams = EncryptParams(input.type)
Encryptor.encryptData(data, largeContent, keyName, eKey, encryptParams)
self.assertTrue(data.getName().equals(Name("/FOR").append(keyName)),
input.testName)
largeDataContent = data.getContent()
# largeDataContent is a sequence of the two EncryptedContent.
encryptedNonce = EncryptedContent()
encryptedNonce.wireDecode(largeDataContent)
self.assertTrue(keyName.equals(encryptedNonce.getKeyLocator().getKeyName()),
input.testName)
self.assertEqual(encryptedNonce.getInitialVector().size(), 0,
input.testName)
self.assertEqual(encryptedNonce.getAlgorithmType(), input.type,
input.testName)
# Use the size of encryptedNonce to find the start of encryptedPayload.
payloadContent = largeDataContent.buf()[encryptedNonce.wireEncode().size():]
encryptedPayload = EncryptedContent()
encryptedPayload.wireDecode(payloadContent)
nonceKeyName = Name(keyName)
nonceKeyName.append("nonce")
self.assertTrue(nonceKeyName.equals(encryptedPayload.getKeyLocator().getKeyName()),
input.testName)
self.assertEqual(encryptedPayload.getInitialVector().size(), 16,
input.testName)
self.assertEqual(encryptedPayload.getAlgorithmType(), EncryptAlgorithmType.AesCbc,
input.testName)
self.assertEqual(
largeDataContent.size(),
encryptedNonce.wireEncode().size() + encryptedPayload.wireEncode().size(),
input.testName)
blobNonce = encryptedNonce.getPayload()
nonce = RsaAlgorithm.decrypt(dKey, blobNonce, encryptParams)
encryptParams.setAlgorithmType(EncryptAlgorithmType.AesCbc)
encryptParams.setInitialVector(encryptedPayload.getInitialVector())
bufferPayload = encryptedPayload.getPayload()
largePayload = AesAlgorithm.decrypt(nonce, bufferPayload, encryptParams)
self.assertTrue(largeContent.equals(largePayload), input.testName)
def test_copy_constructor(self):
name = Name(self.expectedURI)
name2 = Name(name)
self.assertTrue(name.equals(name2), 'Name from copy constructor does not match original')
def test_copy_constructor(self):
name = Name(self.expectedURI)
name2 = Name(name)
self.assertTrue(name.equals(name2), 'Name from copy constructor does not match original')
