Exemple #1
0
    def setUp(self):
        self.plaintext = "attack at dawn"
        self.ciphertext = "U2FsdGVkX1/XnDGaEACaoTEhm7YsBicuJNgLrFSMKe0="
        self.passphrase = "9ACJQzDPFiVJXC"
        self.salt = '\xd7\x9c1\x9a\x10\x00\x9a\xa1'

        self.k = Kopy()
        self.s = "Salted__"
Exemple #2
0
    def setUp(self):
        self.plaintext = "attack at dawn"
        self.ciphertext = "U2FsdGVkX1/XnDGaEACaoTEhm7YsBicuJNgLrFSMKe0="
        self.passphrase = "9ACJQzDPFiVJXC"
        self.salt = '\xd7\x9c1\x9a\x10\x00\x9a\xa1' 

        self.k = Kopy()
        self.s = "Salted__"
Exemple #3
0
class KopyTest(TestCase):

    # TODO theres no checks for inputs of the wrong type.

    def setUp(self):
        self.plaintext = "attack at dawn"
        self.ciphertext = "U2FsdGVkX1/XnDGaEACaoTEhm7YsBicuJNgLrFSMKe0="
        self.passphrase = "9ACJQzDPFiVJXC"
        self.salt = '\xd7\x9c1\x9a\x10\x00\x9a\xa1'

        self.k = Kopy()
        self.s = "Salted__"

    def testPadding(self):

        self.assertEqual(self.k._pad("A" * 16), "A" * 16 + "\x10" * 16)
        self.assertEqual(self.k._pad("A" * 15), "A" * 15 + "\x01")
        self.assertEqual(self.k._pad("A" * 31), "A" * 31 + "\x01")
        self.assertEqual(self.k._pad("A" * 8), "A" * 8 + "\x08" * 8)
        self.assertEqual(self.k._pad("A" * 24), "A" * 24 + "\x08" * 8)
        self.assertEqual(self.k._pad(""), "\x10" * 16)

    def testUnpadding(self):

        self.assertEqual(self.k._unpad("A" * 15 + "\x01"), "A" * 15)
        self.assertEqual(self.k._unpad("A" * 24 + "\x08" * 8), "A" * 24)
        self.assertEqual(self.k._unpad("\x10" * 16), "")
        self.assertEqual(self.k._unpad("A" * 16 + "\x10" * 16), "A" * 16)

        self.assertRaises(Exception, self.k._unpad, "A" * 14 + "\x01\x02")
        self.assertRaises(Exception, self.k._unpad, "A" * 15)
        self.assertRaises(Exception, self.k._unpad, "A" * 15 + "\x02")
        self.assertRaises(Exception, self.k._unpad, "A" * 256 + "\xff" * 256)

    # TODO more testing for crypto.
    # - Tests for incorrectly sized inputs

    def testEncryption(self):

        self.assertEqual(
            self.k.encrypt(self.plaintext, self.passphrase, salt=self.salt),
            self.ciphertext)

    def testDecryption(self):

        self.assertEqual(self.k.decrypt(self.ciphertext, self.passphrase),
                         self.plaintext)

    # It would be nice if these tests weren't just lumps of binary
    # Doesn't seem to be a good alternative though

    def testKeyDerivation(self):

        self.assertEqual(self.k.opensslKeyDerivation("AAAAAAAAAA",
                         "AAAAAAAA", 32, 16),
                         ('\x9f\xe1%\xb6h\x0bC\xa6)S\xd4\xccoN\x08\xbfK\xa5' + \
                         '\xf8k\xeeH\xd2b\x0bZ\xb6\xc6\x80\xa0^K',
                         '\xb1\x9frVm)\x0b\xa7\x04"@\xcc\x87\x7f\x91\x10'))

    def testAESArgs(self):

        self.assertEqual(self.k._getAESArgs("password", "A"*8),
                        ('\xd5\x90\x8c\xbb\xcbvB\xd6\xe3;\xc2\xffeP!\xa5\x8a' + \
                        '\xb6aT\xe3\x19\x1a\xe3|\xe1|\x00=\xc8]7',
                        '\xda\xc2B\xd0T\xf3\xcb\xd6\x97X\xa6\\v#\xf4\xd5'))

        self.assertRaises(Exception, self.k._getAESArgs, "A" * 10, "B" * 7)
        self.assertRaises(Exception, self.k._getAESArgs, "A" * 10, "B" * 9)

    def testCryptoFormat(self):

        self.assertEqual(self.k._formatCiphertext("A" * 8, "B" * 16),
                         b64encode(self.s + "A" * 8 + "B" * 16))
        self.assertEqual(self.k._formatCiphertext("A" * 8, "B" * 32),
                         b64encode(self.s + "A" * 8 + "B" * 32))

        self.assertRaises(Exception, self.k._formatCiphertext, "A" * 7,
                          "B" * 16)
        self.assertRaises(Exception, self.k._formatCiphertext, "A" * 8,
                          "B" * 15)

    def testCryptoParse(self):

        self.assertEqual(
            self.k._parseCiphertext(b64encode(self.s + "A" * 8 + "B" * 16)),
            ("A" * 8, "B" * 16))
        self.assertEqual(
            self.k._parseCiphertext(b64encode(self.s + "A" * 8 + "B" * 32)),
            ("A" * 8, "B" * 32))

        self.assertRaises(Exception, self.k._parseCiphertext,
                          b64encode("A" * 8 + "B" * 16))
        self.assertRaises(Exception, self.k._parseCiphertext,
                          "Salted_" + "A" * 8 + "B" * 16)
        # Bad salt padding ("Salted__")

        self.assertRaises(Exception, self.k._parseCiphertext,
                          b64encode(self.s + "A" * 7 + "B" * 16))
        # Bad salt

        self.assertRaises(Exception, self.k._parseCiphertext,
                          b64encode(self.s + "A" * 8 + "B" * 15))
        self.assertRaises(Exception, self.k._parseCiphertext,
                          b64encode(self.s + "A" * 8 + "B" * 33))
        # Bad padding

    def testRandom(self):

        self.assertEqual(len(self.k._randomBytes(100)), 100)

        self.assertRaises(Exception, self.k._randomBytes, 0)
        self.assertRaises(Exception, self.k._randomBytes, -1)

    def testGenerateRandomBytes(self):

        self.assertEqual(len(self.k.generateRandomBytes(100)), 100)

        # FIXME no way to differentiate this raising an exception and
        # _randomBytes, atm
        self.assertRaises(Exception, self.k.generateRandomBytes, 0)
        self.assertRaises(Exception, self.k.generateRandomBytes, -1)

    def testSalt(self):

        self.assertEqual(len(self.k._generateSalt()), 8)
Exemple #4
0
class KopyTest(TestCase):

    # TODO theres no checks for inputs of the wrong type.

    def setUp(self):
        self.plaintext = "attack at dawn"
        self.ciphertext = "U2FsdGVkX1/XnDGaEACaoTEhm7YsBicuJNgLrFSMKe0="
        self.passphrase = "9ACJQzDPFiVJXC"
        self.salt = '\xd7\x9c1\x9a\x10\x00\x9a\xa1' 

        self.k = Kopy()
        self.s = "Salted__"

    def testPadding(self):

        self.assertEqual(self.k._pad("A"*16), "A"*16+"\x10"*16)
        self.assertEqual(self.k._pad("A"*15), "A"*15+"\x01")
        self.assertEqual(self.k._pad("A"*31), "A"*31+"\x01")
        self.assertEqual(self.k._pad("A"*8), "A"*8+"\x08"*8)
        self.assertEqual(self.k._pad("A"*24), "A"*24+"\x08"*8)
        self.assertEqual(self.k._pad(""), "\x10"*16)

    def testUnpadding(self):

        self.assertEqual(self.k._unpad("A"*15+"\x01"), "A"*15)
        self.assertEqual(self.k._unpad("A"*24+"\x08"*8), "A"*24)
        self.assertEqual(self.k._unpad("\x10"*16), "")
        self.assertEqual(self.k._unpad("A"*16+"\x10"*16), "A"*16)

        self.assertRaises(Exception, self.k._unpad, "A"*14+"\x01\x02")
        self.assertRaises(Exception, self.k._unpad, "A"*15)
        self.assertRaises(Exception, self.k._unpad, "A"*15+"\x02")
        self.assertRaises(Exception, self.k._unpad, "A"*256+"\xff"*256)

    # TODO more testing for crypto.
    # - Tests for incorrectly sized inputs

    def testEncryption(self):

        self.assertEqual(self.k.encrypt(self.plaintext, self.passphrase, salt=self.salt),
                        self.ciphertext)

    def testDecryption(self):

        self.assertEqual(self.k.decrypt(self.ciphertext, self.passphrase),
                        self.plaintext)

    # It would be nice if these tests weren't just lumps of binary
    # Doesn't seem to be a good alternative though

    def testKeyDerivation(self):

        self.assertEqual(self.k.opensslKeyDerivation("AAAAAAAAAA",
                         "AAAAAAAA", 32, 16),
                         ('\x9f\xe1%\xb6h\x0bC\xa6)S\xd4\xccoN\x08\xbfK\xa5' + \
                         '\xf8k\xeeH\xd2b\x0bZ\xb6\xc6\x80\xa0^K',
                         '\xb1\x9frVm)\x0b\xa7\x04"@\xcc\x87\x7f\x91\x10'))
    def testAESArgs(self):

        self.assertEqual(self.k._getAESArgs("password", "A"*8),
                        ('\xd5\x90\x8c\xbb\xcbvB\xd6\xe3;\xc2\xffeP!\xa5\x8a' + \
                        '\xb6aT\xe3\x19\x1a\xe3|\xe1|\x00=\xc8]7',
                        '\xda\xc2B\xd0T\xf3\xcb\xd6\x97X\xa6\\v#\xf4\xd5'))

        self.assertRaises(Exception, self.k._getAESArgs, "A"*10, "B"*7)
        self.assertRaises(Exception, self.k._getAESArgs, "A"*10, "B"*9)

    def testCryptoFormat(self):

        self.assertEqual(self.k._formatCiphertext("A"*8, "B"*16),
                        b64encode(self.s + "A"*8 + "B"*16))
        self.assertEqual(self.k._formatCiphertext("A"*8, "B"*32),
                        b64encode(self.s + "A"*8 + "B"*32))

        self.assertRaises(Exception, self.k._formatCiphertext, "A"*7, "B"*16)
        self.assertRaises(Exception, self.k._formatCiphertext, "A"*8, "B"*15)

    def testCryptoParse(self):

        self.assertEqual(self.k._parseCiphertext(
                        b64encode(self.s + "A"*8 + "B"*16)),
                        ("A"*8, "B"*16))
        self.assertEqual(self.k._parseCiphertext(
                        b64encode(self.s + "A"*8 + "B"*32)),
                        ("A"*8, "B"*32))
        
        self.assertRaises(Exception, self.k._parseCiphertext,
                          b64encode("A"*8 + "B"*16))
        self.assertRaises(Exception, self.k._parseCiphertext,
                          "Salted_" + "A"*8 + "B"*16)
        # Bad salt padding ("Salted__")

        self.assertRaises(Exception, self.k._parseCiphertext, 
                         b64encode(self.s + "A"*7 + "B"*16))
        # Bad salt

        self.assertRaises(Exception, self.k._parseCiphertext,
            b64encode(self.s + "A"*8 + "B"*15))
        self.assertRaises(Exception, self.k._parseCiphertext,
            b64encode(self.s + "A"*8 + "B"*33))
        # Bad padding

    def testRandom(self):

        self.assertEqual(len(self.k._randomBytes(100)), 100)

        self.assertRaises(Exception, self.k._randomBytes, 0)
        self.assertRaises(Exception, self.k._randomBytes, -1)

    def testGenerateRandomBytes(self):

        self.assertEqual(len(self.k.generateRandomBytes(100)), 100)

        # FIXME no way to differentiate this raising an exception and 
        # _randomBytes, atm
        self.assertRaises(Exception, self.k.generateRandomBytes, 0)
        self.assertRaises(Exception, self.k.generateRandomBytes, -1)

    def testSalt(self):

        self.assertEqual(len(self.k._generateSalt()), 8)